oxlint-plugin-react-doctor 0.7.2-dev.fb8ffb0 → 0.7.3-dev.6b70b32

package/dist/index.js

@@ -532,6 +532,12 @@ const TIMER_AND_SCHEDULER_DIRECT_CALLEE_NAMES = new Set([
 ]);
 const TIMER_CALLEE_NAMES_REQUIRING_CLEANUP = new Set(["setInterval", "setTimeout"]);
 const TIMER_CLEANUP_CALLEE_NAMES = new Set(["clearInterval", "clearTimeout"]);
+const SOCKET_CONSTRUCTOR_NAMES_REQUIRING_CLEANUP = new Set([
+	"WebSocket",
+	"EventSource",
+	"BroadcastChannel",
+	"RTCPeerConnection"
+]);
 const MUTABLE_GLOBAL_ROOTS = new Set([
 	"location",
 	"window",
@@ -687,7 +693,10 @@ const GLOBAL_RELEASE_METHOD_NAMES = new Set([
 	"unwatch",
 	"unlisten",
 	"unsub",
-	"abort"
+	"abort",
+	"disconnect",
+	"unobserve",
+	"close"
 ]);
 const BOUND_RESOURCE_RELEASE_METHOD_NAMES = new Set([
 	"remove",
@@ -782,7 +791,7 @@ const findProgramRoot = (node) => {
 };
 //#endregion
 //#region src/plugin/utils/get-imported-name.ts
-const getImportedName$1 = (importSpecifier) => {
+const getImportedName = (importSpecifier) => {
 	if (!isNodeOfType(importSpecifier, "ImportSpecifier")) return void 0;
 	const imported = importSpecifier.imported;
 	if (isNodeOfType(imported, "Identifier")) return imported.name;
@@ -904,7 +913,7 @@ const activityWrapsEffectHeavySubtree = defineRule({
 						continue;
 					}
 					if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
-					const importedName = getImportedName$1(specifier);
+					const importedName = getImportedName(specifier);
 					if (!importedName || !ACTIVITY_IMPORTED_NAMES.has(importedName)) continue;
 					if (isNodeOfType(specifier.local, "Identifier")) localActivityNames.add(specifier.local.name);
 				}
@@ -2248,6 +2257,39 @@ const anchorHasContent = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/get-jsx-prop-static-string-values.ts
+const MAX_CONST_RESOLUTION_HOPS = 4;
+const resolveStaticStringValues = (rawExpression, scopes, remainingHops) => {
+	const expression = stripParenExpression(rawExpression);
+	if (isNodeOfType(expression, "Literal")) return typeof expression.value === "string" ? [expression.value] : null;
+	if (isNodeOfType(expression, "TemplateLiteral")) {
+		const staticValue = getStaticTemplateLiteralValue(expression);
+		return staticValue === null ? null : [staticValue];
+	}
+	if (isNodeOfType(expression, "ConditionalExpression")) {
+		const consequentValues = resolveStaticStringValues(expression.consequent, scopes, remainingHops);
+		if (consequentValues === null) return null;
+		const alternateValues = resolveStaticStringValues(expression.alternate, scopes, remainingHops);
+		if (alternateValues === null) return null;
+		return [...consequentValues, ...alternateValues];
+	}
+	if (isNodeOfType(expression, "Identifier")) {
+		if (remainingHops === 0) return null;
+		const symbol = scopes.referenceFor(expression)?.resolvedSymbol;
+		if (!symbol || symbol.kind !== "const" || !symbol.initializer) return null;
+		if (!isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
+		return resolveStaticStringValues(symbol.initializer, scopes, remainingHops - 1);
+	}
+	return null;
+};
+const getJsxPropStaticStringValues = (attribute, scopes) => {
+	const value = attribute.value;
+	if (!value) return null;
+	if (isNodeOfType(value, "Literal")) return typeof value.value === "string" ? [value.value] : null;
+	if (isNodeOfType(value, "JSXExpressionContainer")) return resolveStaticStringValues(value.expression, scopes, MAX_CONST_RESOLUTION_HOPS);
+	return null;
+};
+//#endregion
 //#region src/plugin/rules/a11y/anchor-is-valid.ts
 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.";
@@ -2275,30 +2317,14 @@ const isDirectChildOfLinkComponent = (openingElement) => {
 const isKeyboardOperableWidgetAnchor = (openingElement) => Boolean(hasJsxPropIgnoreCase(openingElement.attributes, "role")) && Boolean(hasJsxPropIgnoreCase(openingElement.attributes, "tabindex")) && (Boolean(hasJsxPropIgnoreCase(openingElement.attributes, "onkeydown")) || Boolean(hasJsxPropIgnoreCase(openingElement.attributes, "onkeyup")));
 const isInvalidHref = (value, validHrefs) => {
 	if (validHrefs.has(value)) return false;
-	return value === "" || value === "#" || value === "javascript:void(0)";
+	const withoutLeadingNonWord = value.replace(/^[^a-zA-Z0-9_]+/, "");
+	return value === "" || value === "#" || withoutLeadingNonWord.startsWith("javascript:");
 };
-const getStaticHrefValue = (value) => {
-	if (isNodeOfType(value, "Literal")) return typeof value.value === "string" ? value.value : null;
-	if (isNodeOfType(value, "JSXExpressionContainer")) {
-		const expression = value.expression;
-		if (isNodeOfType(expression, "Literal") && typeof expression.value === "string") return expression.value;
-		if (isNodeOfType(expression, "TemplateLiteral")) return getStaticTemplateLiteralValue(expression);
-	}
-	return null;
-};
-const checkValueIsEmptyOrInvalid = (value, validHrefs) => {
-	if (isNodeOfType(value, "Literal")) return typeof value.value === "string" ? isInvalidHref(value.value, validHrefs) : false;
+const isNullishOrFragmentHref = (value) => {
 	if (isNodeOfType(value, "JSXExpressionContainer")) {
 		const expression = value.expression;
 		if (isNodeOfType(expression, "Identifier") && expression.name === "undefined") return true;
-		if (isNodeOfType(expression, "Literal")) {
-			if (expression.value === null) return true;
-			if (typeof expression.value === "string") return isInvalidHref(expression.value, validHrefs);
-		}
-		if (isNodeOfType(expression, "TemplateLiteral")) {
-			const staticValue = getStaticTemplateLiteralValue(expression);
-			return staticValue === null ? false : isInvalidHref(staticValue, validHrefs);
-		}
+		if (isNodeOfType(expression, "Literal") && expression.value === null) return true;
 	}
 	if (isNodeOfType(value, "JSXFragment")) return true;
 	return false;
@@ -2331,9 +2357,10 @@ const anchorIsValid = defineRule({
 					});
 					return;
 				}
-				if (checkValueIsEmptyOrInvalid(hrefAttribute.value, settings.validHrefs)) {
+				const hrefCandidates = getJsxPropStaticStringValues(hrefAttribute, context.scopes);
+				if (hrefCandidates !== null ? hrefCandidates.length > 0 && hrefCandidates.every((candidate) => isInvalidHref(candidate, settings.validHrefs)) : isNullishOrFragmentHref(hrefAttribute.value)) {
 					const hasOnClick = Boolean(hasJsxPropIgnoreCase(node.attributes, "onClick"));
-					if (!hasOnClick && getStaticHrefValue(hrefAttribute.value) === "#") return;
+					if (!hasOnClick && hrefCandidates?.every((candidate) => candidate === "#")) return;
 					context.report({
 						node: node.name,
 						message: hasOnClick ? MESSAGE_CANT_BE_ANCHOR : MESSAGE_INCORRECT_HREF
@@ -3389,6 +3416,25 @@ const ariaRole = defineRule({
 			if (!roleAttribute) return;
 			const elementType = getElementType(node, context.settings);
 			if (settings.ignoreNonDOM && !HTML_TAGS.has(elementType)) return;
+			const reportFirstInvalidCandidate = (candidates) => {
+				for (const candidate of candidates) {
+					if (candidate.trim().length === 0) {
+						context.report({
+							node: roleAttribute,
+							message: buildBaseMessage("")
+						});
+						return;
+					}
+					const tokens = candidate.split(/\s+/).filter((token) => token.length > 0);
+					for (const token of tokens) if (!VALID_ARIA_ROLES.has(token) && !settings.allowedInvalidRoles.includes(token)) {
+						context.report({
+							node: roleAttribute,
+							message: buildBaseMessage(` \`${token}\` is not one.`)
+						});
+						return;
+					}
+				}
+			};
 			const value = roleAttribute.value;
 			if (!value) {
 				context.report({
@@ -3405,22 +3451,7 @@ const ariaRole = defineRule({
 					});
 					return;
 				}
-				const stringValue = value.value;
-				if (stringValue.trim().length === 0) {
-					context.report({
-						node: roleAttribute,
-						message: buildBaseMessage("")
-					});
-					return;
-				}
-				const tokens = stringValue.split(/\s+/).filter((token) => token.length > 0);
-				for (const token of tokens) if (!VALID_ARIA_ROLES.has(token) && !settings.allowedInvalidRoles.includes(token)) {
-					context.report({
-						node: roleAttribute,
-						message: buildBaseMessage(` \`${token}\` is not one.`)
-					});
-					return;
-				}
+				reportFirstInvalidCandidate([value.value]);
 				return;
 			}
 			if (isNodeOfType(value, "JSXExpressionContainer")) {
@@ -3441,6 +3472,11 @@ const ariaRole = defineRule({
 					});
 					return;
 				}
+				const resolvedCandidates = getJsxPropStaticStringValues(roleAttribute, context.scopes);
+				if (resolvedCandidates !== null) {
+					reportFirstInvalidCandidate(resolvedCandidates);
+					return;
+				}
 				return;
 			}
 			context.report({
@@ -5157,7 +5193,7 @@ const authTokenInWebStorage = defineRule({
 			const callee = node.callee;
 			if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return;
 			if (!isNodeOfType(callee.property, "Identifier") || callee.property.name !== "setItem") return;
-			if (!isWebStorageObject(callee.object)) return;
+			if (!isWebStorageObject(stripParenExpression(callee.object))) return;
 			const keyArgument = node.arguments?.[0];
 			if (!keyArgument) return;
 			const keyString = resolveStaticKeyString(keyArgument);
@@ -6097,19 +6133,21 @@ const clickjackingRedirectRisk = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/utils/is-global-method-call.ts
+const isGlobalMethodCall = (node, objectName, methodName) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return false;
+	const receiver = stripParenExpression(callee.object);
+	return isNodeOfType(receiver, "Identifier") && receiver.name === objectName && isNodeOfType(callee.property, "Identifier") && callee.property.name === methodName;
+};
+//#endregion
 //#region src/plugin/rules/client/client-localstorage-no-version.ts
 const VERSIONED_KEY_PATTERN = /(?:[._:-]v\d+|@\d+|\bv\d+\b)/i;
 const CAMEL_CASE_VERSIONED_KEY_PATTERN = /[a-z]V\d+/;
 const STORAGE_OBJECTS = new Set(["localStorage", "sessionStorage"]);
 const isVersionedKey = (key) => VERSIONED_KEY_PATTERN.test(key) || CAMEL_CASE_VERSIONED_KEY_PATTERN.test(key);
-const isJsonStringifyCall = (node) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
-	if (!isNodeOfType(node.callee.object, "Identifier")) return false;
-	if (node.callee.object.name !== "JSON") return false;
-	if (!isNodeOfType(node.callee.property, "Identifier")) return false;
-	return node.callee.property.name === "stringify";
-};
+const isJsonStringifyCall = (node) => isGlobalMethodCall(node, "JSON", "stringify");
 const resolveStringKey = (keyArg, context) => {
 	if (isNodeOfType(keyArg, "Literal")) return typeof keyArg.value === "string" ? keyArg.value : null;
 	if (!isNodeOfType(keyArg, "Identifier")) return null;
@@ -6128,8 +6166,9 @@ const clientLocalstorageNoVersion = defineRule({
 	recommendation: "Put a version in the storage key (e.g. \"myKey:v1\"). If you change the data shape later, old saved data can be ignored instead of crashing the app.",
 	create: (context) => ({ CallExpression(node) {
 		if (!isNodeOfType(node.callee, "MemberExpression")) return;
-		if (!isNodeOfType(node.callee.object, "Identifier")) return;
-		if (!STORAGE_OBJECTS.has(node.callee.object.name)) return;
+		const receiver = stripParenExpression(node.callee.object);
+		if (!isNodeOfType(receiver, "Identifier")) return;
+		if (!STORAGE_OBJECTS.has(receiver.name)) return;
 		if (!isNodeOfType(node.callee.property, "Identifier")) return;
 		if (node.callee.property.name !== "setItem") return;
 		const keyArg = node.arguments?.[0];
@@ -6142,7 +6181,7 @@ const clientLocalstorageNoVersion = defineRule({
 		if (!isJsonStringifyCall(valueArg)) return;
 		context.report({
 			node: keyArg,
-			message: `${node.callee.object.name}.setItem("${keyValue}", JSON.stringify(...)) has no version, so changing the data shape later crashes your users' saved sessions. Add one to the key (e.g. "${keyValue}:v1").`
+			message: `${receiver.name}.setItem("${keyValue}", JSON.stringify(...)) has no version, so changing the data shape later crashes your users' saved sessions. Add one to the key (e.g. "${keyValue}:v1").`
 		});
 	} })
 });
@@ -7623,6 +7662,840 @@ const displayName = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/get-static-property-key-name.ts
+const getStaticPropertyKeyName = (node, options = {}) => {
+	if (!isNodeOfType(node, "Property")) return null;
+	if (node.computed) {
+		if (options.allowComputedString && isNodeOfType(node.key, "Literal") && typeof node.key.value === "string") return node.key.value;
+		return null;
+	}
+	if (isNodeOfType(node.key, "Identifier")) return node.key.name;
+	if (isNodeOfType(node.key, "Literal")) {
+		if (typeof node.key.value === "string") return node.key.value;
+		if (options.stringifyNonStringLiterals) return String(node.key.value);
+	}
+	return null;
+};
+//#endregion
+//#region src/plugin/utils/read-static-boolean.ts
+const readStaticBoolean = (node) => {
+	if (!node) return null;
+	const unwrappedNode = stripParenExpression(node);
+	if (!isNodeOfType(unwrappedNode, "Literal") || typeof unwrappedNode.value !== "boolean") return null;
+	return unwrappedNode.value;
+};
+//#endregion
+//#region src/plugin/utils/is-react-api-call.ts
+const includesApiName = (apiNames, apiName) => typeof apiNames === "string" ? apiNames === apiName : apiNames.has(apiName);
+const isImportedFromReact = (symbol) => {
+	if (symbol.kind !== "import") return false;
+	const importDeclaration = symbol.declarationNode.parent;
+	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "react");
+};
+const isNamedReactApiImport = (identifier, apiNames, scopes) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const symbol = scopes.symbolFor(identifier);
+	if (!symbol || !isImportedFromReact(symbol)) return false;
+	const importedName = getImportedName(symbol.declarationNode);
+	return Boolean(importedName && includesApiName(apiNames, importedName));
+};
+const isReactNamespaceImport = (identifier, scopes) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const symbol = scopes.symbolFor(identifier);
+	if (!symbol || !isImportedFromReact(symbol)) return false;
+	return isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier");
+};
+const isReactApiCall = (node, apiNames, scopes, options = {}) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (isNodeOfType(callee, "Identifier")) {
+		if (isNamedReactApiImport(callee, apiNames, scopes)) return true;
+		return Boolean(options.allowUnboundBareCalls && includesApiName(apiNames, callee.name) && scopes.isGlobalReference(callee));
+	}
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || !isNodeOfType(callee.property, "Identifier") || !includesApiName(apiNames, callee.property.name)) return false;
+	if (isReactNamespaceImport(callee.object, scopes)) return true;
+	return Boolean(options.allowGlobalReactNamespace && callee.object.name === "React" && scopes.isGlobalReference(callee.object));
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/build-listener-cleanup-mismatch-message.ts
+const buildListenerCleanupMismatchMessage = (eventName, registrationCapture, removalCapture, callbackComparison) => {
+	const hasCallbackMismatch = callbackComparison === "different";
+	if (hasCallbackMismatch && registrationCapture !== removalCapture) return `The cleanup removes \`${eventName}\` with a different callback binding and capture ${String(removalCapture)}, but it was registered with capture ${String(registrationCapture)}. Pass the same callback binding and capture flag to both EventTarget calls.`;
+	if (hasCallbackMismatch) return `The cleanup removes \`${eventName}\` with a different callback binding than the one registered, so \`removeEventListener\` cannot detach that listener. Pass the same callback binding to both calls.`;
+	return `The cleanup removes \`${eventName}\` with capture ${String(removalCapture)}, but it was registered with capture ${String(registrationCapture)}. \`removeEventListener\` must use the same capture flag as \`addEventListener\`.`;
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/callback-may-register-event-listener.ts
+const callbackMayRegisterEventListener = (callbackNode) => {
+	let foundCall = false;
+	walkAst(callbackNode, (child) => {
+		if (isNodeOfType(child, "CallExpression")) {
+			foundCall = true;
+			return false;
+		}
+	});
+	return foundCall;
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/compare-listener-callback-identities.ts
+const compareListenerCallbackIdentities = (registrationIdentity, removalIdentity) => {
+	if (registrationIdentity.node === removalIdentity.node) return "same";
+	if (registrationIdentity.isConcreteFunction && removalIdentity.isConcreteFunction) return "different";
+	return "unknown";
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/does-listener-analysis-abort-controller.ts
+const doesListenerAnalysisAbortController = (analysis, controllerSymbolId) => analysis.abortedControllerSymbolIds.has(controllerSymbolId) || analysis.exhaustiveBranches.some(({ alternate, consequent }) => doesListenerAnalysisAbortController(alternate, controllerSymbolId) && doesListenerAnalysisAbortController(consequent, controllerSymbolId));
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/compare-listener-target-keys.ts
+const compareListenerTargetKeys = (firstTargetKey, secondTargetKey) => {
+	if (firstTargetKey === secondTargetKey) return "same";
+	if (firstTargetKey.startsWith("global:") && secondTargetKey.startsWith("global:")) return "different";
+	if (firstTargetKey.startsWith("fresh:") || secondTargetKey.startsWith("fresh:")) return "different";
+	return "unknown";
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/does-listener-analysis-cancel-registration.ts
+const cancellationResult = (analysis, registration) => {
+	if (registration.abortControllerSymbolId !== null && doesListenerAnalysisAbortController(analysis, registration.abortControllerSymbolId)) return "cancelled";
+	let result = analysis.hasUnknownRemovalCall || registration.abortControllerSymbolId !== null && analysis.hasUnknownAbortCall ? "unknown" : "not-cancelled";
+	for (const removal of analysis.removals) {
+		if (removal.eventName !== registration.eventName || removal.capture !== registration.capture || removal.callbackIdentity === null || compareListenerCallbackIdentities(registration.callbackIdentity, removal.callbackIdentity) !== "same") continue;
+		const targetComparison = compareListenerTargetKeys(registration.targetKey, removal.targetKey);
+		if (targetComparison === "same") return "cancelled";
+		if (targetComparison === "unknown") result = "unknown";
+	}
+	for (const { alternate, consequent } of analysis.exhaustiveBranches) {
+		const alternateResult = cancellationResult(alternate, registration);
+		const consequentResult = cancellationResult(consequent, registration);
+		if (alternateResult === "cancelled" && consequentResult === "cancelled") return "cancelled";
+		if (alternateResult !== "not-cancelled" && consequentResult !== "not-cancelled") result = "unknown";
+	}
+	return result;
+};
+const doesListenerAnalysisCancelRegistration = (analysis, registration) => cancellationResult(analysis, registration) !== "not-cancelled";
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/static-member-property-name.ts
+const getStaticMemberPropertyName = (node) => {
+	if (!node) return null;
+	const unwrappedNode = stripParenExpression(node);
+	if (!isNodeOfType(unwrappedNode, "MemberExpression")) return null;
+	if (!unwrappedNode.computed && isNodeOfType(unwrappedNode.property, "Identifier")) return unwrappedNode.property.name;
+	if (unwrappedNode.computed && isNodeOfType(unwrappedNode.property, "Literal") && typeof unwrappedNode.property.value === "string") return unwrappedNode.property.value;
+	return null;
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/is-listener-path-ambiguous.ts
+const PATH_AMBIGUOUS_ANCESTOR_TYPES = new Set([
+	"CatchClause",
+	"ConditionalExpression",
+	"DoWhileStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"IfStatement",
+	"LogicalExpression",
+	"SwitchCase",
+	"SwitchStatement",
+	"TryStatement",
+	"WhileStatement"
+]);
+const isGuaranteedChild = (parentNode, childNode) => {
+	if (isNodeOfType(parentNode, "IfStatement")) {
+		if (parentNode.test === childNode) return true;
+		const staticTestValue = readStaticBoolean(parentNode.test);
+		return parentNode.consequent === childNode && staticTestValue === true || parentNode.alternate === childNode && staticTestValue === false;
+	}
+	if (isNodeOfType(parentNode, "ConditionalExpression")) {
+		if (parentNode.test === childNode) return true;
+		const staticTestValue = readStaticBoolean(parentNode.test);
+		return parentNode.consequent === childNode && staticTestValue === true || parentNode.alternate === childNode && staticTestValue === false;
+	}
+	if (isNodeOfType(parentNode, "LogicalExpression")) {
+		if (parentNode.left === childNode) return true;
+		if (parentNode.right !== childNode) return false;
+		const staticLeftValue = readStaticBoolean(parentNode.left);
+		return parentNode.operator === "&&" && staticLeftValue === true || parentNode.operator === "||" && staticLeftValue === false;
+	}
+	if (isNodeOfType(parentNode, "TryStatement")) return parentNode.finalizer === childNode;
+	if (isNodeOfType(parentNode, "SwitchStatement")) return parentNode.discriminant === childNode;
+	if (isNodeOfType(parentNode, "ForStatement")) return parentNode.init === childNode || parentNode.test === childNode;
+	if (isNodeOfType(parentNode, "ForInStatement") || isNodeOfType(parentNode, "ForOfStatement")) return parentNode.right === childNode;
+	if (isNodeOfType(parentNode, "WhileStatement")) return parentNode.test === childNode;
+	return false;
+};
+const isListenerPathAmbiguous = (node, bodyNode, allowAmbiguousChild) => {
+	let currentNode = node;
+	while (currentNode && currentNode !== bodyNode) {
+		const parentNode = currentNode.parent;
+		if (!parentNode) return true;
+		if (PATH_AMBIGUOUS_ANCESTOR_TYPES.has(parentNode.type) && !isGuaranteedChild(parentNode, currentNode) && !allowAmbiguousChild?.(parentNode, currentNode)) return true;
+		currentNode = parentNode;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/resolve-event-listener-capture.ts
+const resolveEventListenerCapture = (optionsNode) => {
+	if (!optionsNode) return false;
+	const unwrappedOptions = stripParenExpression(optionsNode);
+	if (isNodeOfType(unwrappedOptions, "Literal")) return typeof unwrappedOptions.value === "boolean" ? unwrappedOptions.value : null;
+	if (!isNodeOfType(unwrappedOptions, "ObjectExpression")) return null;
+	let capture = false;
+	for (const property of unwrappedOptions.properties) {
+		if (!isNodeOfType(property, "Property")) return null;
+		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+		if (propertyName === null) return null;
+		if (!property.computed && propertyName === "__proto__") return null;
+		if (propertyName !== "capture") continue;
+		const propertyValue = stripParenExpression(property.value);
+		if (!isNodeOfType(propertyValue, "Literal") || typeof propertyValue.value !== "boolean") return null;
+		capture = propertyValue.value;
+	}
+	return capture;
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/resolve-static-once-option.ts
+const resolveStaticOnceOption = (optionsNode) => {
+	if (!optionsNode) return false;
+	const unwrappedOptions = stripParenExpression(optionsNode);
+	if (isNodeOfType(unwrappedOptions, "Literal")) return typeof unwrappedOptions.value === "boolean" ? false : null;
+	if (!isNodeOfType(unwrappedOptions, "ObjectExpression")) return null;
+	let once = false;
+	for (const property of unwrappedOptions.properties) {
+		if (!isNodeOfType(property, "Property")) return null;
+		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+		if (propertyName === null || !property.computed && propertyName === "__proto__") return null;
+		if (propertyName !== "once") continue;
+		const propertyValue = stripParenExpression(property.value);
+		if (!isNodeOfType(propertyValue, "Literal") || typeof propertyValue.value !== "boolean") return null;
+		once = propertyValue.value;
+	}
+	return once;
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/effect-listener-cleanup-mismatch.ts
+const LISTENER_EFFECT_HOOK_NAMES = new Set([...EFFECT_HOOK_NAMES$1, "useInsertionEffect"]);
+const hasOnlyReadReferences = (symbol) => symbol.references.every((reference) => reference.flag === "read");
+const isStableSymbol = (symbol) => symbol.kind === "const" || symbol.kind === "import" || (symbol.kind === "function" || symbol.kind === "parameter") && hasOnlyReadReferences(symbol);
+const isPlainConstSymbol = (symbol) => symbol.kind === "const" && isNodeOfType(symbol.declarationNode, "VariableDeclarator") && isNodeOfType(symbol.declarationNode.id, "Identifier") && symbol.declarationNode.id === symbol.bindingIdentifier;
+const resolveAliasedSymbol = (identifier, context, visitedSymbolIds) => {
+	if (!isNodeOfType(identifier, "Identifier")) return null;
+	const symbol = context.scopes.symbolFor(identifier);
+	if (!symbol || !isStableSymbol(symbol) || visitedSymbolIds.has(symbol.id)) return null;
+	if (symbol.kind === "const" && !isPlainConstSymbol(symbol)) return null;
+	visitedSymbolIds.add(symbol.id);
+	const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
+	if (symbol.kind === "const" && isNodeOfType(initializer, "Identifier")) {
+		const resolvedAlias = resolveAliasedSymbol(initializer, context, visitedSymbolIds);
+		if (resolvedAlias) return resolvedAlias;
+	}
+	return symbol;
+};
+const resolveCallbackIdentity = (callbackNode, context) => {
+	if (!callbackNode) return null;
+	const unwrappedCallback = stripParenExpression(callbackNode);
+	if (isFunctionLike$1(unwrappedCallback)) return {
+		node: unwrappedCallback,
+		isConcreteFunction: true
+	};
+	if (!isNodeOfType(unwrappedCallback, "Identifier")) return null;
+	const symbol = resolveAliasedSymbol(unwrappedCallback, context, /* @__PURE__ */ new Set());
+	if (!symbol) return null;
+	const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
+	if (initializer && isFunctionLike$1(initializer)) return {
+		node: initializer,
+		isConcreteFunction: true
+	};
+	return {
+		node: symbol.bindingIdentifier,
+		isConcreteFunction: false
+	};
+};
+const resolveTargetKey = (targetNode, context) => {
+	const unwrappedTarget = stripParenExpression(targetNode);
+	if (isNodeOfType(unwrappedTarget, "Identifier")) {
+		const symbol = resolveAliasedSymbol(unwrappedTarget, context, /* @__PURE__ */ new Set());
+		if (symbol) {
+			if (symbol.kind === "import" || symbol.kind === "parameter" || symbol.kind === "function") return null;
+			const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
+			if (isNodeOfType(initializer, "NewExpression") && isNodeOfType(initializer.callee, "Identifier") && !context.scopes.isGlobalReference(initializer.callee)) return null;
+			if (isNodeOfType(initializer, "NewExpression")) return `fresh:${symbol.id}`;
+			return `symbol:${symbol.id}`;
+		}
+		if (context.scopes.isGlobalReference(unwrappedTarget)) return `global:${unwrappedTarget.name}`;
+		return null;
+	}
+	if (isNodeOfType(unwrappedTarget, "MemberExpression") && !unwrappedTarget.computed && isNodeOfType(unwrappedTarget.property, "Identifier")) {
+		const objectKey = resolveTargetKey(unwrappedTarget.object, context);
+		if (unwrappedTarget.property.name === "document" && (objectKey === "global:window" || objectKey === "global:globalThis")) return "global:document";
+		if (unwrappedTarget.property.name === "window" && (objectKey === "global:window" || objectKey === "global:globalThis")) return "global:window";
+		return objectKey === null ? null : `${objectKey}.${unwrappedTarget.property.name}`;
+	}
+	return null;
+};
+const resolveStaticEventName = (eventNode, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!eventNode) return null;
+	const unwrappedEvent = stripParenExpression(eventNode);
+	if (isNodeOfType(unwrappedEvent, "Literal") && typeof unwrappedEvent.value === "string") return unwrappedEvent.value;
+	if (isNodeOfType(unwrappedEvent, "TemplateLiteral") && unwrappedEvent.expressions.length === 0) return unwrappedEvent.quasis[0]?.value.cooked ?? "";
+	if (!isNodeOfType(unwrappedEvent, "Identifier")) return null;
+	const symbol = context.scopes.symbolFor(unwrappedEvent);
+	if (!symbol || !isPlainConstSymbol(symbol) || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return null;
+	visitedSymbolIds.add(symbol.id);
+	return resolveStaticEventName(symbol.initializer, context, visitedSymbolIds);
+};
+const readStaticEventDispatch = (node, context) => {
+	const targetNode = readDirectMemberReceiver(node.callee, "dispatchEvent", context);
+	const eventArgument = node.arguments?.[0];
+	if (!eventArgument) return null;
+	const eventNode = stripParenExpression(eventArgument);
+	if (!targetNode || !isNodeOfType(eventNode, "NewExpression") || !isNodeOfType(eventNode.callee, "Identifier") || eventNode.callee.name !== "Event" || !context.scopes.isGlobalReference(eventNode.callee)) return null;
+	const target = stripParenExpression(targetNode);
+	if (!isNodeOfType(target, "Identifier")) return null;
+	const targetSymbol = resolveAliasedSymbol(target, context, /* @__PURE__ */ new Set());
+	const targetInitializer = targetSymbol?.initializer ? stripParenExpression(targetSymbol.initializer) : null;
+	if (!isNodeOfType(targetInitializer, "NewExpression") || !isNodeOfType(targetInitializer.callee, "Identifier") || targetInitializer.callee.name !== "EventTarget" || !context.scopes.isGlobalReference(targetInitializer.callee)) return null;
+	const targetKey = resolveTargetKey(targetNode, context);
+	const eventName = resolveStaticEventName(eventNode.arguments?.[0], context);
+	return targetKey !== null && eventName !== null ? {
+		eventName,
+		targetKey
+	} : null;
+};
+const resolveLocalAbortControllerSymbolId = (controllerNode, context) => {
+	const unwrappedController = stripParenExpression(controllerNode);
+	if (!isNodeOfType(unwrappedController, "Identifier")) return null;
+	const controllerSymbol = resolveAliasedSymbol(unwrappedController, context, /* @__PURE__ */ new Set());
+	if (!controllerSymbol || controllerSymbol.kind !== "const" || !controllerSymbol.initializer) return null;
+	const initializer = stripParenExpression(controllerSymbol.initializer);
+	if (!isNodeOfType(initializer, "NewExpression") || !isNodeOfType(initializer.callee, "Identifier") || initializer.callee.name !== "AbortController" || !context.scopes.isGlobalReference(initializer.callee)) return null;
+	return controllerSymbol.id;
+};
+const readDirectMemberReceiver = (memberNode, memberName, context) => {
+	if (!memberNode) return null;
+	const unwrappedMember = stripParenExpression(memberNode);
+	if (!isNodeOfType(unwrappedMember, "MemberExpression")) return null;
+	if ((getStaticMemberPropertyName(unwrappedMember) ?? (context && unwrappedMember.computed ? resolveStaticEventName(unwrappedMember.property, context) : null)) !== memberName) return null;
+	return unwrappedMember.object;
+};
+const isSignalObjectPatternBinding = (patternNode, bindingIdentifier) => {
+	if (!isNodeOfType(patternNode, "ObjectPattern")) return false;
+	return patternNode.properties.some((property) => {
+		if (!isNodeOfType(property, "Property")) return false;
+		if (getStaticPropertyKeyName(property, { allowComputedString: true }) !== "signal") return false;
+		return (isNodeOfType(property.value, "AssignmentPattern") ? property.value.left : property.value) === bindingIdentifier;
+	});
+};
+const resolveSignalAbortControllerSymbolId = (signalNode, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const unwrappedSignal = stripParenExpression(signalNode);
+	const directControllerNode = readDirectMemberReceiver(unwrappedSignal, "signal");
+	if (directControllerNode) return resolveLocalAbortControllerSymbolId(directControllerNode, context);
+	if (!isNodeOfType(unwrappedSignal, "Identifier")) return null;
+	const signalSymbol = context.scopes.symbolFor(unwrappedSignal);
+	if (!signalSymbol || signalSymbol.kind !== "const" || !signalSymbol.initializer || visitedSymbolIds.has(signalSymbol.id) || !hasOnlyReadReferences(signalSymbol)) return null;
+	visitedSymbolIds.add(signalSymbol.id);
+	const declarationNode = signalSymbol.declarationNode;
+	if (!isNodeOfType(declarationNode, "VariableDeclarator")) return null;
+	if (isNodeOfType(declarationNode.id, "Identifier") && declarationNode.id === signalSymbol.bindingIdentifier) {
+		const initializer = stripParenExpression(signalSymbol.initializer);
+		if (isNodeOfType(initializer, "Identifier")) return resolveSignalAbortControllerSymbolId(initializer, context, visitedSymbolIds);
+		const controllerNode = readDirectMemberReceiver(initializer, "signal");
+		return controllerNode ? resolveLocalAbortControllerSymbolId(controllerNode, context) : null;
+	}
+	if (!isSignalObjectPatternBinding(declarationNode.id, signalSymbol.bindingIdentifier)) return null;
+	return resolveLocalAbortControllerSymbolId(signalSymbol.initializer, context);
+};
+const readControllerAbortedCondition = (conditionNode, controllerSymbolId, context) => {
+	const unwrappedCondition = stripParenExpression(conditionNode);
+	if (isNodeOfType(unwrappedCondition, "UnaryExpression") && unwrappedCondition.operator === "!") {
+		const operandCondition = readControllerAbortedCondition(unwrappedCondition.argument, controllerSymbolId, context);
+		if (operandCondition === "aborted") return "not-aborted";
+		if (operandCondition === "not-aborted") return "aborted";
+		return null;
+	}
+	if (isNodeOfType(unwrappedCondition, "BinaryExpression")) {
+		const leftBoolean = readStaticBoolean(unwrappedCondition.left);
+		const rightBoolean = readStaticBoolean(unwrappedCondition.right);
+		const memberNode = leftBoolean === null ? unwrappedCondition.left : rightBoolean === null ? unwrappedCondition.right : null;
+		const comparedBoolean = leftBoolean ?? rightBoolean;
+		if (memberNode && comparedBoolean !== null) {
+			const memberCondition = readControllerAbortedCondition(memberNode, controllerSymbolId, context);
+			if (memberCondition) {
+				const isEquality = unwrappedCondition.operator === "==" || unwrappedCondition.operator === "===";
+				const isInequality = unwrappedCondition.operator === "!=" || unwrappedCondition.operator === "!==";
+				const shouldInvert = isEquality && !comparedBoolean || isInequality && comparedBoolean;
+				if (isEquality || isInequality) {
+					if (!shouldInvert) return memberCondition;
+					return memberCondition === "aborted" ? "not-aborted" : "aborted";
+				}
+			}
+		}
+		return null;
+	}
+	const signalNode = readDirectMemberReceiver(unwrappedCondition, "aborted");
+	if (!signalNode) return null;
+	return resolveSignalAbortControllerSymbolId(signalNode, context) === controllerSymbolId ? "aborted" : null;
+};
+const isAbortGuardForChild = (parentNode, childNode, controllerSymbolId, context) => {
+	if (isNodeOfType(parentNode, "IfStatement") || isNodeOfType(parentNode, "ConditionalExpression")) {
+		const condition = readControllerAbortedCondition(parentNode.test, controllerSymbolId, context);
+		return parentNode.consequent === childNode && condition === "not-aborted" || parentNode.alternate === childNode && condition === "aborted";
+	}
+	if (!isNodeOfType(parentNode, "LogicalExpression") || parentNode.right !== childNode) return false;
+	const condition = readControllerAbortedCondition(parentNode.left, controllerSymbolId, context);
+	return parentNode.operator === "&&" && condition === "not-aborted" || parentNode.operator === "||" && condition === "aborted";
+};
+const isAbortGuaranteedByPath = (node, bodyNode, controllerSymbolId, context) => !isListenerPathAmbiguous(node, bodyNode, (parentNode, childNode) => isAbortGuardForChild(parentNode, childNode, controllerSymbolId, context));
+const resolveBoundAbortControllerSymbolId = (callNode, context) => {
+	const callee = stripParenExpression(callNode.callee);
+	if (!isNodeOfType(callee, "Identifier")) return null;
+	const boundAbortSymbol = resolveAliasedSymbol(callee, context, /* @__PURE__ */ new Set());
+	if (!boundAbortSymbol?.initializer) return null;
+	const initializer = stripParenExpression(boundAbortSymbol.initializer);
+	if (!isNodeOfType(initializer, "CallExpression")) return null;
+	const abortMethodNode = readDirectMemberReceiver(initializer.callee, "bind");
+	if (!abortMethodNode) return null;
+	const controllerNode = readDirectMemberReceiver(abortMethodNode, "abort");
+	const boundThisNode = initializer.arguments?.[0];
+	if (!controllerNode || !boundThisNode) return null;
+	const controllerSymbolId = resolveLocalAbortControllerSymbolId(controllerNode, context);
+	const boundThisSymbolId = resolveLocalAbortControllerSymbolId(boundThisNode, context);
+	return controllerSymbolId !== null && controllerSymbolId === boundThisSymbolId ? controllerSymbolId : null;
+};
+const resolveRegistrationCancellation = (optionsNode, context) => {
+	const noCancellation = {
+		abortControllerSymbolId: null,
+		hasUnknownCancellation: false
+	};
+	if (!optionsNode) return noCancellation;
+	const unwrappedOptions = stripParenExpression(optionsNode);
+	if (!isNodeOfType(unwrappedOptions, "ObjectExpression")) return noCancellation;
+	let resolvedCancellation = null;
+	for (const property of unwrappedOptions.properties) {
+		if (!isNodeOfType(property, "Property")) return noCancellation;
+		if (getStaticPropertyKeyName(property, { allowComputedString: true }) !== "signal") continue;
+		if (resolvedCancellation) return {
+			abortControllerSymbolId: null,
+			hasUnknownCancellation: true
+		};
+		const abortControllerSymbolId = resolveSignalAbortControllerSymbolId(property.value, context);
+		resolvedCancellation = {
+			abortControllerSymbolId,
+			hasUnknownCancellation: abortControllerSymbolId === null
+		};
+	}
+	return resolvedCancellation ?? noCancellation;
+};
+const readListenerCandidate = (node, methodName, context) => {
+	const targetNode = readDirectMemberReceiver(node.callee, methodName, context);
+	if (!targetNode) return null;
+	const targetKey = resolveTargetKey(targetNode, context);
+	const eventName = resolveStaticEventName(node.arguments?.[0], context);
+	const callbackIdentity = resolveCallbackIdentity(node.arguments?.[1], context);
+	const capture = resolveEventListenerCapture(node.arguments?.[2]);
+	if (targetKey === null || eventName === null) return null;
+	return {
+		node,
+		targetKey,
+		eventName,
+		callbackIdentity,
+		capture
+	};
+};
+const readDestructuredRemovalCandidate = (node, context) => {
+	const methodNode = readDirectMemberReceiver(node.callee, "call");
+	if (!methodNode || !isNodeOfType(methodNode, "Identifier")) return null;
+	const methodSymbol = context.scopes.symbolFor(methodNode);
+	if (!methodSymbol || methodSymbol.kind !== "const" || !hasOnlyReadReferences(methodSymbol) || !isNodeOfType(methodSymbol.declarationNode, "VariableDeclarator")) return null;
+	const declaration = methodSymbol.declarationNode;
+	if (!isNodeOfType(declaration.id, "ObjectPattern") || !declaration.init) return null;
+	if (!declaration.id.properties.some((property) => {
+		if (!isNodeOfType(property, "Property")) return false;
+		const bindingNode = isNodeOfType(property.value, "AssignmentPattern") ? property.value.left : property.value;
+		return getStaticPropertyKeyName(property, { allowComputedString: true }) === "removeEventListener" && bindingNode === methodSymbol.bindingIdentifier;
+	})) return null;
+	const targetNode = node.arguments?.[0];
+	if (!targetNode) return null;
+	const declarationTargetKey = resolveTargetKey(declaration.init, context);
+	const targetKey = resolveTargetKey(targetNode, context);
+	if (declarationTargetKey === null || targetKey === null || declarationTargetKey !== targetKey) return null;
+	const eventName = resolveStaticEventName(node.arguments?.[1], context);
+	if (eventName === null) return null;
+	return {
+		node,
+		targetKey,
+		eventName,
+		callbackIdentity: resolveCallbackIdentity(node.arguments?.[2], context),
+		capture: resolveEventListenerCapture(node.arguments?.[3])
+	};
+};
+const resolveReturnedCleanupBody = (returnedValue, context) => {
+	if (!returnedValue) return null;
+	const unwrappedValue = stripParenExpression(returnedValue);
+	if (isFunctionLike$1(unwrappedValue)) return unwrappedValue.body;
+	if (!isNodeOfType(unwrappedValue, "Identifier")) return null;
+	const symbol = resolveAliasedSymbol(unwrappedValue, context, /* @__PURE__ */ new Set());
+	if (!symbol || !symbol.initializer) return null;
+	const initializer = stripParenExpression(symbol.initializer);
+	return isFunctionLike$1(initializer) ? initializer.body : null;
+};
+const collectEffectListenerInputs = (effectBody, context) => {
+	const registrations = [];
+	const cleanupBodies = [];
+	const listenerRegistrationCountsByTarget = /* @__PURE__ */ new Map();
+	let returnStatementCount = 0;
+	if (!isNodeOfType(effectBody, "BlockStatement")) return {
+		registrations,
+		cleanupBodies,
+		hasCanonicalCleanupReturn: false,
+		returnStatementCount
+	};
+	const finalEffectStatement = effectBody.body[effectBody.body.length - 1];
+	const hasCanonicalCleanupReturn = isNodeOfType(finalEffectStatement, "ReturnStatement");
+	walkAst(effectBody, (child) => {
+		if (child !== effectBody && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "ClassDeclaration") || isNodeOfType(child, "ClassExpression")) return false;
+		if (isNodeOfType(child, "CallExpression")) {
+			if (isListenerPathAmbiguous(child, effectBody)) return;
+			const registrationTarget = readDirectMemberReceiver(child.callee, "addEventListener", context);
+			const registrationTargetKey = registrationTarget ? resolveTargetKey(registrationTarget, context) : null;
+			if (registrationTargetKey !== null) listenerRegistrationCountsByTarget.set(registrationTargetKey, (listenerRegistrationCountsByTarget.get(registrationTargetKey) ?? 0) + 1);
+			const candidate = readListenerCandidate(child, "addEventListener", context);
+			if (candidate?.callbackIdentity && candidate.capture !== null) {
+				const registrationCancellation = resolveRegistrationCancellation(candidate.node.arguments?.[2], context);
+				registrations.push({
+					node: candidate.node,
+					targetKey: candidate.targetKey,
+					eventName: candidate.eventName,
+					callbackIdentity: candidate.callbackIdentity,
+					capture: candidate.capture,
+					once: resolveStaticOnceOption(candidate.node.arguments?.[2]) === true,
+					abortControllerSymbolId: registrationCancellation.abortControllerSymbolId,
+					hasUnknownCancellation: registrationCancellation.hasUnknownCancellation
+				});
+			}
+			const eventDispatch = readStaticEventDispatch(child, context);
+			if (eventDispatch) {
+				const dispatchedRegistrations = registrations.filter((registration) => registration.targetKey === eventDispatch.targetKey && registration.eventName === eventDispatch.eventName);
+				const dispatchedRegistration = dispatchedRegistrations[0];
+				if (dispatchedRegistrations.length === 1 && dispatchedRegistration?.once && listenerRegistrationCountsByTarget.get(eventDispatch.targetKey) === 1 && dispatchedRegistration.callbackIdentity.isConcreteFunction && !callbackMayRegisterEventListener(dispatchedRegistration.callbackIdentity.node)) registrations.splice(registrations.indexOf(dispatchedRegistration), 1);
+			}
+			return;
+		}
+		if (isNodeOfType(child, "ReturnStatement")) {
+			returnStatementCount += 1;
+			const cleanupBody = resolveReturnedCleanupBody(child.argument, context);
+			if (cleanupBody) cleanupBodies.push(cleanupBody);
+		}
+	});
+	return {
+		registrations,
+		cleanupBodies,
+		hasCanonicalCleanupReturn,
+		returnStatementCount
+	};
+};
+const resolveCalledCleanup = (callNode, context) => {
+	const callee = stripParenExpression(callNode.callee);
+	if (!isNodeOfType(callee, "Identifier")) return null;
+	const cleanupSymbol = resolveAliasedSymbol(callee, context, /* @__PURE__ */ new Set());
+	if (!cleanupSymbol?.initializer || cleanupSymbol.kind !== "const" && cleanupSymbol.kind !== "function") return null;
+	const initializer = stripParenExpression(cleanupSymbol.initializer);
+	if (!isFunctionLike$1(initializer) || initializer.async || initializer.generator) return null;
+	return {
+		body: initializer.body,
+		symbolId: cleanupSymbol.id
+	};
+};
+const analyzeCleanupBody = (cleanupBody, context, visitedCleanupSymbolIds = /* @__PURE__ */ new Set(), isLoopBody = false) => {
+	const removals = [];
+	const abortedControllerSymbolIds = /* @__PURE__ */ new Set();
+	const exhaustiveBranches = [];
+	let hasAmbiguousReachability = false;
+	let hasUnknownAbortCall = false;
+	let hasUnknownRemovalCall = false;
+	const finalCleanupStatement = isNodeOfType(cleanupBody, "BlockStatement") ? cleanupBody.body[cleanupBody.body.length - 1] : null;
+	const addCleanupAnalysis = (analysis) => {
+		removals.push(...analysis.removals);
+		hasUnknownAbortCall ||= analysis.hasUnknownAbortCall;
+		hasUnknownRemovalCall ||= analysis.hasUnknownRemovalCall;
+		for (const controllerSymbolId of analysis.abortedControllerSymbolIds) abortedControllerSymbolIds.add(controllerSymbolId);
+		exhaustiveBranches.push(...analysis.exhaustiveBranches);
+	};
+	const addGuaranteedLoopPrefix = (loopBody) => {
+		const loopStatements = isNodeOfType(loopBody, "BlockStatement") ? loopBody.body : [loopBody];
+		for (const loopStatement of loopStatements) {
+			if (isNodeOfType(loopStatement, "BreakStatement") || isNodeOfType(loopStatement, "ContinueStatement")) return true;
+			if (isNodeOfType(loopStatement, "BlockStatement")) {
+				if (addGuaranteedLoopPrefix(loopStatement)) return true;
+				continue;
+			}
+			if (isNodeOfType(loopStatement, "IfStatement")) {
+				const staticTestValue = readStaticBoolean(loopStatement.test);
+				if (staticTestValue !== null) {
+					const testAnalysis = analyzeCleanupBody(loopStatement.test, context, new Set(visitedCleanupSymbolIds), true);
+					if (!testAnalysis) return true;
+					addCleanupAnalysis(testAnalysis);
+					const guaranteedBranch = staticTestValue ? loopStatement.consequent : loopStatement.alternate;
+					if (guaranteedBranch && addGuaranteedLoopPrefix(guaranteedBranch)) return true;
+					continue;
+				}
+			}
+			const loopStatementAnalysis = analyzeCleanupBody(loopStatement, context, new Set(visitedCleanupSymbolIds), true);
+			if (!loopStatementAnalysis) return true;
+			addCleanupAnalysis(loopStatementAnalysis);
+		}
+		return false;
+	};
+	walkAst(cleanupBody, (child) => {
+		if (child !== cleanupBody && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "ClassDeclaration") || isNodeOfType(child, "ClassExpression")) return false;
+		if (isNodeOfType(child, "ReturnStatement") && child === finalCleanupStatement) return;
+		if (isNodeOfType(child, "ReturnStatement") || isNodeOfType(child, "ThrowStatement") || isLoopBody && (isNodeOfType(child, "BreakStatement") || isNodeOfType(child, "ContinueStatement"))) {
+			hasAmbiguousReachability = true;
+			return false;
+		}
+		if (isNodeOfType(child, "ForOfStatement")) {
+			const iterable = stripParenExpression(child.right);
+			if (isNodeOfType(iterable, "ArrayExpression") && iterable.elements.some((element) => element && !isNodeOfType(element, "SpreadElement")) && !isListenerPathAmbiguous(child, cleanupBody)) addGuaranteedLoopPrefix(child.body);
+			return false;
+		}
+		if ((isNodeOfType(child, "IfStatement") || isNodeOfType(child, "ConditionalExpression")) && child.alternate && readStaticBoolean(child.test) === null && !isListenerPathAmbiguous(child, cleanupBody)) {
+			const consequentAnalysis = analyzeCleanupBody(child.consequent, context, new Set(visitedCleanupSymbolIds));
+			const alternateAnalysis = analyzeCleanupBody(child.alternate, context, new Set(visitedCleanupSymbolIds));
+			if (consequentAnalysis && alternateAnalysis) {
+				exhaustiveBranches.push({
+					alternate: alternateAnalysis,
+					consequent: consequentAnalysis
+				});
+				hasUnknownAbortCall ||= consequentAnalysis.hasUnknownAbortCall && alternateAnalysis.hasUnknownAbortCall;
+				hasUnknownRemovalCall ||= consequentAnalysis.hasUnknownRemovalCall && alternateAnalysis.hasUnknownRemovalCall;
+			}
+			const testAnalysis = analyzeCleanupBody(child.test, context, new Set(visitedCleanupSymbolIds));
+			if (testAnalysis) addCleanupAnalysis(testAnalysis);
+			return false;
+		}
+		if (!isNodeOfType(child, "CallExpression")) return;
+		const hasAmbiguousPath = isListenerPathAmbiguous(child, cleanupBody);
+		const removalTarget = readDirectMemberReceiver(child.callee, "removeEventListener", context);
+		if (removalTarget && !hasAmbiguousPath) {
+			const removal = readListenerCandidate(child, "removeEventListener", context);
+			if (removal) {
+				removals.push(removal);
+				hasUnknownRemovalCall ||= removal.callbackIdentity === null || removal.capture === null;
+			} else hasUnknownRemovalCall = true;
+		}
+		if (!removalTarget && !hasAmbiguousPath) {
+			const destructuredRemoval = readDestructuredRemovalCandidate(child, context);
+			if (destructuredRemoval) removals.push(destructuredRemoval);
+		}
+		const controllerNode = readDirectMemberReceiver(child.callee, "abort");
+		if (controllerNode) {
+			const controllerSymbolId = resolveLocalAbortControllerSymbolId(controllerNode, context);
+			if (controllerSymbolId === null) {
+				if (!hasAmbiguousPath) hasUnknownAbortCall = true;
+			} else if (!hasAmbiguousPath || isAbortGuaranteedByPath(child, cleanupBody, controllerSymbolId, context)) abortedControllerSymbolIds.add(controllerSymbolId);
+			return;
+		}
+		if (hasAmbiguousPath) return;
+		const boundAbortControllerSymbolId = resolveBoundAbortControllerSymbolId(child, context);
+		if (boundAbortControllerSymbolId !== null) {
+			abortedControllerSymbolIds.add(boundAbortControllerSymbolId);
+			return;
+		}
+		const calledCleanup = resolveCalledCleanup(child, context);
+		if (!calledCleanup || visitedCleanupSymbolIds.has(calledCleanup.symbolId)) return;
+		visitedCleanupSymbolIds.add(calledCleanup.symbolId);
+		const calledCleanupAnalysis = analyzeCleanupBody(calledCleanup.body, context, visitedCleanupSymbolIds);
+		if (!calledCleanupAnalysis) return;
+		addCleanupAnalysis(calledCleanupAnalysis);
+	});
+	if (hasAmbiguousReachability) return null;
+	return {
+		removals,
+		abortedControllerSymbolIds,
+		exhaustiveBranches,
+		hasUnknownAbortCall,
+		hasUnknownRemovalCall
+	};
+};
+const analyzeEffectListeners = (effectBody, context) => {
+	const effectInputs = collectEffectListenerInputs(effectBody, context);
+	if (!effectInputs.hasCanonicalCleanupReturn || effectInputs.returnStatementCount !== 1 || effectInputs.cleanupBodies.length !== 1) return null;
+	const removals = [];
+	const abortedControllerSymbolIds = /* @__PURE__ */ new Set();
+	const exhaustiveBranches = [];
+	let hasUnknownAbortCall = false;
+	let hasUnknownRemovalCall = false;
+	const addAnalysis = (analysis) => {
+		removals.push(...analysis.removals);
+		exhaustiveBranches.push(...analysis.exhaustiveBranches);
+		hasUnknownAbortCall ||= analysis.hasUnknownAbortCall;
+		hasUnknownRemovalCall ||= analysis.hasUnknownRemovalCall;
+		for (const controllerSymbolId of analysis.abortedControllerSymbolIds) abortedControllerSymbolIds.add(controllerSymbolId);
+	};
+	const setupAbortAnalysis = analyzeCleanupBody(effectBody, context);
+	for (const cleanupBody of effectInputs.cleanupBodies) {
+		const cleanupAnalysis = analyzeCleanupBody(cleanupBody, context);
+		if (!cleanupAnalysis) return null;
+		addAnalysis(cleanupAnalysis);
+	}
+	return {
+		registrations: effectInputs.registrations,
+		removals,
+		abortedControllerSymbolIds,
+		exhaustiveBranches,
+		hasUnknownAbortCall,
+		hasUnknownRemovalCall,
+		setupAbortAnalysis
+	};
+};
+const effectListenerCleanupMismatch = defineRule({
+	id: "effect-listener-cleanup-mismatch",
+	title: "Effect cleanup does not match its event listener",
+	severity: "error",
+	recommendation: "Pass the same callback binding and capture flag to `addEventListener` and `removeEventListener`, or abort the registration's local AbortController during cleanup.",
+	create: (context) => ({ CallExpression(node) {
+		if (!isReactApiCall(node, LISTENER_EFFECT_HOOK_NAMES, context.scopes)) return;
+		const effectCallback = getEffectCallback(node);
+		if (!isFunctionLike$1(effectCallback)) return;
+		const listenerAnalysis = analyzeEffectListeners(effectCallback.body, context);
+		if (!listenerAnalysis) return;
+		for (const registration of listenerAnalysis.registrations) {
+			if (registration.hasUnknownCancellation || listenerAnalysis.hasUnknownRemovalCall) continue;
+			if (listenerAnalysis.registrations.filter((candidateRegistration) => candidateRegistration.targetKey === registration.targetKey && candidateRegistration.eventName === registration.eventName).length > 1) continue;
+			if (registration.abortControllerSymbolId !== null && listenerAnalysis.hasUnknownAbortCall) continue;
+			if (registration.abortControllerSymbolId !== null && listenerAnalysis.setupAbortAnalysis && doesListenerAnalysisAbortController(listenerAnalysis.setupAbortAnalysis, registration.abortControllerSymbolId)) continue;
+			if (doesListenerAnalysisCancelRegistration(listenerAnalysis, registration)) continue;
+			const candidateRemovals = listenerAnalysis.removals.filter((removal) => removal.targetKey === registration.targetKey && removal.eventName === registration.eventName);
+			let firstProvableMismatch;
+			let didFindNonMismatchCandidate = false;
+			for (const removal of candidateRemovals) {
+				if (!removal.callbackIdentity || removal.capture === null) {
+					didFindNonMismatchCandidate = true;
+					break;
+				}
+				const callbackComparison = compareListenerCallbackIdentities(registration.callbackIdentity, removal.callbackIdentity);
+				if (callbackComparison === "unknown") {
+					didFindNonMismatchCandidate = true;
+					break;
+				}
+				if (callbackComparison === "same" && registration.capture === removal.capture) {
+					didFindNonMismatchCandidate = true;
+					break;
+				}
+				firstProvableMismatch ??= {
+					removalNode: removal.node,
+					removalCapture: removal.capture,
+					callbackComparison
+				};
+			}
+			if (candidateRemovals.length === 0 || didFindNonMismatchCandidate || !firstProvableMismatch) continue;
+			context.report({
+				node: firstProvableMismatch.removalNode,
+				message: buildListenerCleanupMismatchMessage(registration.eventName, registration.capture, firstProvableMismatch.removalCapture, firstProvableMismatch.callbackComparison)
+			});
+		}
+	} })
+});
+//#endregion
+//#region src/plugin/utils/is-react-hook-name.ts
+const isReactHookName = (name) => {
+	if (!name.startsWith("use")) return false;
+	if (name.length === 3) return true;
+	const fourthCharacter = name.charCodeAt(3);
+	return fourthCharacter >= 65 && fourthCharacter <= 90 || fourthCharacter >= 48 && fourthCharacter <= 57;
+};
+//#endregion
+//#region src/plugin/utils/is-react-component-or-hook-name.ts
+const isReactComponentOrHookName = (name) => isReactComponentName(name) || isReactHookName(name);
+//#endregion
+//#region src/plugin/utils/component-or-hook-display-name.ts
+const hocWrapperCalleeName = (callee) => {
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+	return null;
+};
+const displayNameFromFunctionBinding = (functionNode) => {
+	let current = functionNode;
+	for (;;) {
+		const parent = current.parent;
+		if (parent && isNodeOfType(parent, "CallExpression") && parent.arguments?.[0] === current) {
+			const calleeName = hocWrapperCalleeName(parent.callee);
+			if (calleeName && COMPONENT_HOC_WRAPPER_NAMES.has(calleeName)) {
+				current = parent;
+				continue;
+			}
+		}
+		break;
+	}
+	const binding = current.parent;
+	if (binding && isNodeOfType(binding, "VariableDeclarator") && isNodeOfType(binding.id, "Identifier") && binding.init === current) return isReactComponentOrHookName(binding.id.name) ? binding.id.name : null;
+	return null;
+};
+const componentOrHookDisplayNameForFunction = (functionNode) => {
+	if ((isNodeOfType(functionNode, "FunctionDeclaration") || isNodeOfType(functionNode, "FunctionExpression")) && functionNode.id) return isReactComponentOrHookName(functionNode.id.name) ? functionNode.id.name : null;
+	return displayNameFromFunctionBinding(functionNode);
+};
+//#endregion
+//#region src/plugin/utils/find-enclosing-function.ts
+const findEnclosingFunction = (node) => {
+	let cursor = node.parent;
+	while (cursor) {
+		if (isFunctionLike$1(cursor)) return cursor;
+		cursor = cursor.parent ?? null;
+	}
+	return null;
+};
+//#endregion
+//#region src/plugin/utils/enclosing-component-or-hook-name.ts
+const enclosingComponentOrHookName = (node) => {
+	const functionNode = findEnclosingFunction(node);
+	return functionNode ? componentOrHookDisplayNameForFunction(functionNode) : null;
+};
+//#endregion
+//#region src/plugin/utils/get-range-start.ts
+const getRangeStart = (node) => {
+	const rangeStart = node.range?.[0];
+	return typeof rangeStart === "number" ? rangeStart : null;
+};
+//#endregion
+//#region src/plugin/utils/is-result-discarded-call.ts
+const isResultDiscardedCall = (callExpression) => {
+	let node = callExpression;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "ExpressionStatement")) return true;
+		if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "void") return true;
+		if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === node) return true;
+		if (isNodeOfType(parent, "ChainExpression")) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "SequenceExpression")) {
+			const expressions = parent.expressions ?? [];
+			if (expressions[expressions.length - 1] !== node) return true;
+			node = parent;
+			parent = node.parent;
+			continue;
+		}
+		return false;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/utils/walk-inside-statement-blocks.ts
 const walkInsideStatementBlocks = (node, visitor) => {
 	if (!node || typeof node !== "object") return;
@@ -7774,6 +8647,17 @@ const isCleanupReturn = (returnedValue, knownCleanupFunctionNames, knownBoundSub
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/effect-needs-cleanup.ts
+const OBSERVER_REGISTRATION_METHOD_NAME = "observe";
+const RESOURCE_NOUN_BY_KIND = {
+	subscribe: "subscription",
+	timer: "timer",
+	socket: "connection"
+};
+const isSocketConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && SOCKET_CONSTRUCTOR_NAMES_REQUIRING_CLEANUP.has(node.callee.name);
+const isSubscribeOrObserveCall = (node) => {
+	if (isSubscribeLikeCallExpression(node)) return true;
+	return isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME;
+};
 const findSubscribeLikeUsages = (callback) => {
 	const usages = [];
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
@@ -7785,6 +8669,14 @@ const findSubscribeLikeUsages = (callback) => {
 	}
 	walkAst(callback, (child) => {
 		if (child === cleanupArgument && !isSubscribeLikeCallExpression(child)) return false;
+		if (isSocketConstruction(child)) {
+			usages.push({
+				kind: "socket",
+				node: child,
+				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket"
+			});
+			return;
+		}
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (isNodeOfType(child.callee, "Identifier") && TIMER_CALLEE_NAMES_REQUIRING_CLEANUP.has(child.callee.name)) {
 			usages.push({
@@ -7794,7 +8686,7 @@ const findSubscribeLikeUsages = (callback) => {
 			});
 			return;
 		}
-		if (isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name)) usages.push({
+		if (isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && (SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name) || child.callee.property.name === OBSERVER_REGISTRATION_METHOD_NAME)) usages.push({
 			kind: "subscribe",
 			node: child,
 			resourceName: child.callee.property.name
@@ -7810,6 +8702,13 @@ const collectCleanupBindings = (effectCallback) => {
 	};
 	if (!isNodeOfType(effectCallback, "ArrowFunctionExpression") && !isNodeOfType(effectCallback, "FunctionExpression")) return bindings;
 	if (!isNodeOfType(effectCallback.body, "BlockStatement")) return bindings;
+	walkAst(effectCallback.body, (child) => {
+		if (!isSubscribeOrObserveCall(child)) return;
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (!isNodeOfType(child.callee, "MemberExpression")) return;
+		if (!isNodeOfType(child.callee.object, "Identifier")) return;
+		bindings.subscriptionNames.add(child.callee.object.name);
+	});
 	walkInsideStatementBlocks(effectCallback.body, (child) => {
 		if (!isNodeOfType(child, "VariableDeclaration")) return;
 		for (const declarator of child.declarations ?? []) {
@@ -7817,7 +8716,12 @@ const collectCleanupBindings = (effectCallback) => {
 			const bindingName = declarator.id.name;
 			bindings.effectScopeVariableNames.add(bindingName);
 			const init = declarator.init;
-			if (!init || !isNodeOfType(init, "CallExpression")) continue;
+			if (!init) continue;
+			if (isSocketConstruction(init)) {
+				bindings.subscriptionNames.add(bindingName);
+				continue;
+			}
+			if (!isNodeOfType(init, "CallExpression")) continue;
 			if (isSubscribeLikeCallExpression(init)) {
 				bindings.subscriptionNames.add(bindingName);
 				if (isCleanupReturningSubscribeLikeCallExpression(init)) bindings.cleanupFunctionNames.add(bindingName);
@@ -7843,9 +8747,21 @@ const collectCleanupBindings = (effectCallback) => {
 	});
 	return bindings;
 };
-const getRangeStart = (node) => {
-	const rangeStart = node.range?.[0];
-	return typeof rangeStart === "number" ? rangeStart : null;
+const removeSynchronouslyReleasedUsages = (callback, usages) => {
+	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return usages;
+	if (!isNodeOfType(callback.body, "BlockStatement")) return usages;
+	const releaseStarts = [];
+	walkInsideStatementBlocks(callback.body, (child) => {
+		if (!isReleaseLikeCall(child, EMPTY_NAME_SET$1, EMPTY_NAME_SET$1)) return;
+		const releaseStart = getRangeStart(child);
+		if (releaseStart !== null) releaseStarts.push(releaseStart);
+	});
+	if (releaseStarts.length === 0) return usages;
+	return usages.filter((usage) => {
+		const usageStart = getRangeStart(usage.node);
+		if (usageStart === null) return true;
+		return !releaseStarts.some((releaseStart) => releaseStart > usageStart);
+	});
 };
 const cleanupReturnRunsAfterUsage = (returnStatement, usages) => {
 	if (returnStatement.argument && isCleanupReturningSubscribeLikeCallExpression(returnStatement.argument)) return true;
@@ -7869,26 +8785,177 @@ const effectHasCleanupReturn = (callback, usages) => {
 	});
 	return didFindCleanupReturn;
 };
+const EMPTY_NAME_SET$1 = /* @__PURE__ */ new Set();
+const isSelfReleasingListenerOptionProperty = (property) => {
+	if (!isNodeOfType(property, "Property")) return false;
+	const keyName = isNodeOfType(property.key, "Identifier") ? property.key.name : isNodeOfType(property.key, "Literal") ? property.key.value : null;
+	if (keyName === "signal") return true;
+	if (keyName !== "once") return false;
+	return isNodeOfType(property.value, "Literal") && property.value.value === true;
+};
+const hasSelfReleasingListenerOptions = (node) => isNodeOfType(node, "CallExpression") && (node.arguments ?? []).some((argument) => isNodeOfType(argument, "ObjectExpression") && (argument.properties ?? []).some(isSelfReleasingListenerOptionProperty));
+const PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB = new Map([
+	["addEventListener", new Set(["removeEventListener", "abort"])],
+	["addListener", new Set([
+		"removeListener",
+		"off",
+		"abort"
+	])],
+	["on", new Set([
+		"off",
+		"removeListener",
+		"on"
+	])],
+	["subscribe", new Set(["unsubscribe", "unsub"])],
+	["sub", new Set(["unsub", "unsubscribe"])],
+	["watch", new Set(["unwatch", "close"])],
+	["listen", new Set(["unlisten", "close"])],
+	[OBSERVER_REGISTRATION_METHOD_NAME, new Set(["disconnect", "unobserve"])]
+]);
+const UNIVERSAL_RELEASE_VERB_NAMES = new Set([
+	"cleanup",
+	"dispose",
+	"destroy",
+	"teardown"
+]);
+const SOCKET_RELEASE_VERB_NAMES = new Set(["close"]);
+const INTERVAL_RELEASE_VERB_NAMES = new Set(["clearInterval"]);
+const getReleaseVerbName = (node) => {
+	if (!isReleaseLikeCall(node, EMPTY_NAME_SET$1, EMPTY_NAME_SET$1)) return null;
+	const callNode = isNodeOfType(node, "ChainExpression") ? node.expression : node;
+	if (!isNodeOfType(callNode, "CallExpression")) return null;
+	const callee = isNodeOfType(callNode.callee, "ChainExpression") ? callNode.callee.expression : callNode.callee;
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+	return null;
+};
+const matchesPairedReleaseVerb = (releaseVerbName, pairedVerbNames) => pairedVerbNames.has(releaseVerbName) || UNIVERSAL_RELEASE_VERB_NAMES.has(releaseVerbName);
+const bodyContainsPairedReleaseCall = (body, pairedVerbNames) => {
+	let didFindPairedRelease = false;
+	walkAst(body, (child) => {
+		if (didFindPairedRelease) return false;
+		if (child !== body && isFunctionLike$1(child)) return false;
+		const releaseVerbName = getReleaseVerbName(child);
+		if (releaseVerbName !== null && matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) {
+			didFindPairedRelease = true;
+			return false;
+		}
+	});
+	return didFindPairedRelease;
+};
+const fileReleaseVerbNamesCache = /* @__PURE__ */ new WeakMap();
+const collectFileReleaseVerbNames = (anyNode) => {
+	let programNode = anyNode;
+	while (programNode.parent) programNode = programNode.parent;
+	const cached = fileReleaseVerbNamesCache.get(programNode);
+	if (cached) return cached;
+	const releaseVerbNames = /* @__PURE__ */ new Set();
+	walkAst(programNode, (child) => {
+		const releaseVerbName = getReleaseVerbName(child);
+		if (releaseVerbName !== null) releaseVerbNames.add(releaseVerbName);
+	});
+	fileReleaseVerbNamesCache.set(programNode, releaseVerbNames);
+	return releaseVerbNames;
+};
+const fileContainsPairedReleaseCall = (registrationCall, registrationVerbName) => {
+	const fileReleaseVerbNames = collectFileReleaseVerbNames(registrationCall);
+	const pairedVerbNames = PAIRED_RELEASE_VERB_NAMES_BY_REGISTRATION_VERB.get(registrationVerbName);
+	if (!pairedVerbNames) return fileReleaseVerbNames.size > 0;
+	for (const releaseVerbName of fileReleaseVerbNames) if (matchesPairedReleaseVerb(releaseVerbName, pairedVerbNames)) return true;
+	return false;
+};
+const findRetainedFunctionLeak = (retainedFunction) => {
+	if (!isFunctionLike$1(retainedFunction)) return null;
+	const body = retainedFunction.body;
+	if (!body) return null;
+	const conciseReturnValue = isNodeOfType(body, "BlockStatement") ? null : body;
+	let leak = null;
+	walkAst(body, (child) => {
+		if (leak !== null) return false;
+		if (isFunctionLike$1(child)) return false;
+		if (child === conciseReturnValue && isNodeOfType(child, "CallExpression")) return;
+		if (isSocketConstruction(child) && isResultDiscardedCall(child) && !bodyContainsPairedReleaseCall(body, SOCKET_RELEASE_VERB_NAMES)) {
+			leak = {
+				kind: "socket",
+				node: child,
+				resourceName: isNodeOfType(child.callee, "Identifier") ? child.callee.name : "WebSocket"
+			};
+			return false;
+		}
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (isNodeOfType(child.callee, "Identifier") && child.callee.name === "setInterval" && isResultDiscardedCall(child) && !bodyContainsPairedReleaseCall(body, INTERVAL_RELEASE_VERB_NAMES)) {
+			leak = {
+				kind: "timer",
+				node: child,
+				resourceName: "setInterval"
+			};
+			return false;
+		}
+		if (isSubscribeOrObserveCall(child) && isResultDiscardedCall(child)) {
+			const registrationVerbName = isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") ? child.callee.property.name : "subscribe";
+			if (!hasSelfReleasingListenerOptions(child) && !fileContainsPairedReleaseCall(child, registrationVerbName)) leak = {
+				kind: "subscribe",
+				node: child,
+				resourceName: registrationVerbName
+			};
+			return false;
+		}
+	});
+	return leak;
+};
+const isRetainedComponentScopeFunction = (functionNode) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration")) return enclosingComponentOrHookName(functionNode) !== null;
+	if (!isNodeOfType(functionNode, "ArrowFunctionExpression") && !isNodeOfType(functionNode, "FunctionExpression")) return false;
+	if (!isNodeOfType(functionNode.parent, "VariableDeclarator")) return false;
+	return enclosingComponentOrHookName(functionNode) !== null;
+};
 const effectNeedsCleanup = defineRule({
 	id: "effect-needs-cleanup",
 	title: "Effect subscription or timer never cleaned up",
 	severity: "error",
 	tags: ["test-noise"],
-	recommendation: "Return a cleanup function that stops the subscription or timer: `return () => target.removeEventListener(name, handler)` for listeners, `return () => clearInterval(id)` or `clearTimeout(id)` for timers, or `return unsubscribe` if the subscribe call already gave you one.",
-	create: (context) => ({ CallExpression(node) {
-		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
-		const callback = getEffectCallback(node);
-		if (!callback) return;
-		const usages = findSubscribeLikeUsages(callback);
-		if (usages.length === 0) return;
-		if (effectHasCleanupReturn(callback, usages)) return;
-		const firstUsage = usages[0];
-		const resourceKind = firstUsage.kind === "timer" ? "timer" : "subscription";
-		context.report({
-			node,
-			message: `\`${firstUsage.resourceName}\` creates a ${resourceKind} in useEffect without returning cleanup. Return a cleanup function so it does not leak after unmount.`
-		});
-	} })
+	recommendation: "Return a cleanup function that stops the subscription or timer: `return () => target.removeEventListener(name, handler)` for listeners, `return () => clearInterval(id)` or `clearTimeout(id)` for timers, `return () => observer.disconnect()` for observers, `return () => socket.close()` for connections, or `return unsubscribe` if the subscribe call already gave you one.",
+	create: (context) => {
+		const reportRetainedLeak = (retainedFunction) => {
+			const leak = findRetainedFunctionLeak(retainedFunction);
+			if (!leak) return;
+			const resourceNoun = RESOURCE_NOUN_BY_KIND[leak.kind];
+			context.report({
+				node: leak.node,
+				message: `\`${leak.resourceName}\` creates a ${resourceNoun} in a function that outlives the render, with no cleanup path. Store the handle and release it, or move this into a useEffect that returns cleanup, so it does not leak after unmount.`
+			});
+		};
+		return {
+			CallExpression(node) {
+				if (isHookCall$2(node, "useCallback")) {
+					const retainedCallback = getEffectCallback(node);
+					if (retainedCallback) reportRetainedLeak(retainedCallback);
+					return;
+				}
+				if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
+				const callback = getEffectCallback(node);
+				if (!callback) return;
+				const usages = removeSynchronouslyReleasedUsages(callback, findSubscribeLikeUsages(callback));
+				if (usages.length === 0) return;
+				if (effectHasCleanupReturn(callback, usages)) return;
+				const firstUsage = usages[0];
+				const resourceNoun = RESOURCE_NOUN_BY_KIND[firstUsage.kind];
+				context.report({
+					node,
+					message: `\`${firstUsage.resourceName}\` creates a ${resourceNoun} in useEffect without returning cleanup. Return a cleanup function so it does not leak after unmount.`
+				});
+			},
+			FunctionDeclaration(node) {
+				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
+			},
+			ArrowFunctionExpression(node) {
+				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
+			},
+			FunctionExpression(node) {
+				if (isRetainedComponentScopeFunction(node)) reportRetainedLeak(node);
+			}
+		};
+	}
 });
 //#endregion
 //#region src/plugin/semantic/scope-analysis.ts
@@ -8447,17 +9514,6 @@ const closureCaptures = (functionNode, scopes) => {
 	return computedCaptures;
 };
 //#endregion
-//#region src/plugin/utils/is-react-hook-name.ts
-const isReactHookName = (name) => {
-	if (!name.startsWith("use")) return false;
-	if (name.length === 3) return true;
-	const fourthCharacter = name.charCodeAt(3);
-	return fourthCharacter >= 65 && fourthCharacter <= 90 || fourthCharacter >= 48 && fourthCharacter <= 57;
-};
-//#endregion
-//#region src/plugin/utils/is-react-component-or-hook-name.ts
-const isReactComponentOrHookName = (name) => isReactComponentName(name) || isReactHookName(name);
-//#endregion
 //#region src/plugin/utils/is-react-hoc-callback-argument.ts
 const reactHocCalleeName = (callee) => {
 	if (isNodeOfType(callee, "Identifier")) return callee.name;
@@ -8671,8 +9727,8 @@ const isAstDescendant = (inner, outer) => {
 * One cohesive concept: "given a captured symbol, is its value
 * structurally stable across re-renders (and therefore unnecessary
 * in a deps array)?". The rule reads `symbolHasStableValue` /
-* `symbolHasStableHookOrigin` / `symbolHasUseEffectEventOrigin` /
-* `isRecursiveInitializerCapture` at multiple sites — extracting
+* `symbolHasStableHookOrigin` / `isRecursiveInitializerCapture` at
+* multiple sites — extracting
 * them lets the rule body stay focused on the diff-the-captured-vs-
 * declared logic.
 *
@@ -8728,11 +9784,6 @@ const symbolHasStableHookOrigin = (symbol) => {
 	}
 	return false;
 };
-const symbolHasUseEffectEventOrigin = (symbol) => {
-	const initializer = symbol.initializer ? unwrapExpression$3(symbol.initializer) : null;
-	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	return getHookName(initializer.callee) === "useEffectEvent";
-};
 const getFunctionValueNode = (symbol) => {
 	if (symbol.kind === "function" && isNodeOfType(symbol.declarationNode, "FunctionDeclaration")) return symbol.declarationNode;
 	const initializer = symbol.initializer ? unwrapExpression$3(symbol.initializer) : null;
@@ -8818,6 +9869,37 @@ const symbolHasStableFunctionOrigin = (symbol, scopes, visitedSymbolIds) => {
 };
 const symbolHasStableValue = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => symbolHasStableHookOrigin(symbol) || symbolHasStableFunctionOrigin(symbol, scopes, visitedSymbolIds) || symbolHasStableMemoizedOrigin(symbol, scopes, visitedSymbolIds);
 //#endregion
+//#region src/plugin/utils/is-imported-from-non-react-module.ts
+const isImportedFromNonReactModule = (contextNode, localIdentifierName) => {
+	const importSource = getImportSourceForName(contextNode, localIdentifierName);
+	if (importSource === null) return false;
+	return !REACT_RUNTIME_MODULE_SOURCES.has(importSource);
+};
+//#endregion
+//#region src/plugin/utils/is-non-react-effect-event-callee.ts
+const resolvesToLocalNonImportBinding = (identifier, scopes) => {
+	const symbol = scopes.referenceFor(identifier)?.resolvedSymbol;
+	return Boolean(symbol && symbol.kind !== "import");
+};
+const isNonReactEffectEventCallee = (callee, contextNode, scopes) => {
+	if (isNodeOfType(callee, "Identifier")) return isImportedFromNonReactModule(contextNode, callee.name) || resolvesToLocalNonImportBinding(callee, scopes);
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier")) return isImportedFromNonReactModule(contextNode, callee.object.name);
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/symbol-has-react-use-effect-event-origin.ts
+const getUseEffectEventCalleeName = (callee) => {
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+	return null;
+};
+const symbolHasReactUseEffectEventOrigin = (symbol, scopes) => {
+	const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
+	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
+	if (getUseEffectEventCalleeName(initializer.callee) !== "useEffectEvent") return false;
+	return !isNonReactEffectEventCallee(initializer.callee, initializer, scopes);
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps.ts
 const HOOKS_REQUIRING_DEPS_MATCH = new Set([
 	"useEffect",
@@ -9468,7 +10550,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (isLiteralOrEmptyTemplate(stripped)) continue;
 				if (isNodeOfType(stripped, "Identifier")) {
 					const depSymbol = context.scopes.symbolFor(stripped);
-					if (depSymbol && symbolHasUseEffectEventOrigin(depSymbol)) {
+					if (depSymbol && symbolHasReactUseEffectEventOrigin(depSymbol, context.scopes)) {
 						context.report({
 							node: elementNode,
 							message: buildEffectEventDepMessage()
@@ -9894,7 +10976,10 @@ const PRAGMA = "React";
 const isReactFunctionCall = (node, expectedCall) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	if (getCalleeName$2(node) !== expectedCall) return false;
-	if (isNodeOfType(node.callee, "MemberExpression")) return isNodeOfType(node.callee.object, "Identifier") && node.callee.object.name === PRAGMA;
+	if (isNodeOfType(node.callee, "MemberExpression")) {
+		const receiver = stripParenExpression(node.callee.object);
+		return isNodeOfType(receiver, "Identifier") && receiver.name === PRAGMA;
+	}
 	return true;
 };
 //#endregion
@@ -11059,8 +12144,8 @@ const interactiveSupportsFocus = defineRule({
 			if (node.attributes.length === 0) return;
 			if (hasJsxSpreadAttribute$1(node.attributes)) return;
 			const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
-			const role = roleAttribute ? getJsxPropStringValue(roleAttribute) : null;
-			if (!role) return;
+			const roleCandidates = roleAttribute ? getJsxPropStaticStringValues(roleAttribute, context.scopes) : null;
+			if (roleCandidates === null || roleCandidates.length === 0) return;
 			let hasInteractiveHandler = false;
 			for (const attribute of node.attributes) {
 				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
@@ -11074,11 +12159,16 @@ const interactiveSupportsFocus = defineRule({
 			const elementType = getElementType(node, context.settings);
 			if (!HTML_TAGS.has(elementType)) return;
 			if (isDisabledElement(node) || isHiddenFromScreenReader(node, context.settings) || isPresentationRole(node)) return;
-			if (COMPOSITE_CONTAINER_ROLES.has(role)) return;
-			if (COMPOSITE_ITEM_ROLES.has(role) && Boolean(hasJsxPropIgnoreCase(node.attributes, "id"))) return;
 			const hasTabIndex = Boolean(hasJsxPropIgnoreCase(node.attributes, "tabIndex"));
-			if (!isInteractiveRole(role) || isInteractiveElement(elementType, node) || isNonInteractiveRole(role) || isNonInteractiveElement(elementType, node) || hasTabIndex) return;
-			const message = tabbableSet.has(role) ? buildTabbableMessage(role) : buildFocusableMessage(role);
+			const hasId = Boolean(hasJsxPropIgnoreCase(node.attributes, "id"));
+			for (const role of roleCandidates) {
+				if (COMPOSITE_CONTAINER_ROLES.has(role)) return;
+				if (COMPOSITE_ITEM_ROLES.has(role) && hasId) return;
+				if (!isInteractiveRole(role) || isInteractiveElement(elementType, node) || isNonInteractiveRole(role) || isNonInteractiveElement(elementType, node) || hasTabIndex) return;
+			}
+			const isEveryCandidateTabbable = roleCandidates.every((role) => tabbableSet.has(role));
+			const roleDisplay = roleCandidates.join("' / '");
+			const message = isEveryCandidateTabbable ? buildTabbableMessage(roleDisplay) : buildFocusableMessage(roleDisplay);
 			context.report({
 				node,
 				message
@@ -11267,16 +12357,6 @@ const collectHandlerReferencedNames = (root) => {
 	return names;
 };
 //#endregion
-//#region src/plugin/utils/find-enclosing-function.ts
-const findEnclosingFunction = (node) => {
-	let cursor = node.parent;
-	while (cursor) {
-		if (isFunctionLike$1(cursor)) return cursor;
-		cursor = cursor.parent ?? null;
-	}
-	return null;
-};
-//#endregion
 //#region src/plugin/utils/get-function-binding-name.ts
 const getFunctionBindingIdentifier = (functionNode) => {
 	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
@@ -11480,7 +12560,7 @@ const jotaiTqUseRawQueryAtom = defineRule({
 					if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
 					if (!isNodeOfType(specifier.local, "Identifier")) continue;
 					if (source === "jotai-tanstack-query") {
-						const importedName = getImportedName$1(specifier);
+						const importedName = getImportedName(specifier);
 						if (importedName && QUERY_ATOM_FACTORY_IMPORTED_NAMES.has(importedName)) queryAtomFactoryLocalNames.add(specifier.local.name);
 						continue;
 					}
@@ -11976,14 +13056,15 @@ const jsCacheStorage = defineRule({
 			"ArrowFunctionExpression:exit": exitFunctionScope,
 			CallExpression(node) {
 				if (!isMemberProperty(node.callee, "getItem")) return;
-				if (!isNodeOfType(node.callee.object, "Identifier") || !STORAGE_OBJECTS$1.has(node.callee.object.name)) return;
+				const receiver = stripParenExpression(node.callee.object);
+				if (!isNodeOfType(receiver, "Identifier") || !STORAGE_OBJECTS$1.has(receiver.name)) return;
 				if (!isNodeOfType(node.arguments?.[0], "Literal")) return;
 				const storageReadCounts = storageReadCountStack[storageReadCountStack.length - 1];
 				const storageKey = String(node.arguments[0].value);
 				const readCount = (storageReadCounts.get(storageKey) ?? 0) + 1;
 				storageReadCounts.set(storageKey, readCount);
 				if (readCount === 2) {
-					const storageName = node.callee.object.name;
+					const storageName = receiver.name;
 					context.report({
 						node,
 						message: `This is slow because ${storageName}.getItem("${storageKey}") runs several times & re-parses the data each call, so read it once & reuse the value`
@@ -11997,13 +13078,16 @@ const jsCacheStorage = defineRule({
 //#region src/plugin/rules/js-performance/js-combine-iterations.ts
 const isIteratorProducingCall = (callExpression, generatorNamesInFile) => {
 	const callee = callExpression.callee;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "Iterator" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "from") return true;
-	if (isNodeOfType(callee, "Identifier") && generatorNamesInFile.has(callee.name)) return true;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && ITERATOR_PRODUCING_METHOD_NAMES.has(callee.property.name)) {
-		const receiver = callee.object;
-		if (isNodeOfType(receiver, "Identifier") && receiver.name === "Object") return false;
-		return true;
+	if (isNodeOfType(callee, "MemberExpression")) {
+		const receiver = stripParenExpression(callee.object);
+		if (isNodeOfType(receiver, "Identifier") && receiver.name === "Iterator" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "from") return true;
+		if (isNodeOfType(callee.property, "Identifier") && ITERATOR_PRODUCING_METHOD_NAMES.has(callee.property.name)) {
+			if (isNodeOfType(receiver, "Identifier") && receiver.name === "Object") return false;
+			return true;
+		}
+		return false;
 	}
+	if (isNodeOfType(callee, "Identifier") && generatorNamesInFile.has(callee.name)) return true;
 	return false;
 };
 const isChainPassThroughCall = (callExpression) => {
@@ -12015,10 +13099,7 @@ const isChainPassThroughCall = (callExpression) => {
 const isReceiverChainIteratorRooted = (receiverNode, generatorNamesInFile) => {
 	let cursor = receiverNode;
 	while (cursor) {
-		if (isNodeOfType(cursor, "ChainExpression")) {
-			cursor = cursor.expression;
-			continue;
-		}
+		cursor = stripParenExpression(cursor);
 		if (!isNodeOfType(cursor, "CallExpression")) return false;
 		if (isIteratorProducingCall(cursor, generatorNamesInFile)) return true;
 		if (!isChainPassThroughCall(cursor)) return false;
@@ -12094,10 +13175,7 @@ const isStringSplitRootedChain = (receiverNode) => {
 	let hops = 0;
 	while (cursor && hops < 12) {
 		hops += 1;
-		if (isNodeOfType(cursor, "ChainExpression")) {
-			cursor = cursor.expression;
-			continue;
-		}
+		cursor = stripParenExpression(cursor);
 		if (!isNodeOfType(cursor, "CallExpression")) return false;
 		const callee = cursor.callee;
 		if (!isNodeOfType(callee, "MemberExpression")) return false;
@@ -12121,10 +13199,7 @@ const isSmallLiteralArray = (node) => {
 const isSmallLiteralArrayRootedChain = (receiverNode, smallConstArrayNames) => {
 	let cursor = receiverNode;
 	while (cursor) {
-		if (isNodeOfType(cursor, "ChainExpression")) {
-			cursor = cursor.expression;
-			continue;
-		}
+		cursor = stripParenExpression(cursor);
 		if (isNodeOfType(cursor, "ArrayExpression")) return isSmallLiteralArray(cursor);
 		if (isNodeOfType(cursor, "Identifier")) return smallConstArrayNames.has(cursor.name);
 		if (!isNodeOfType(cursor, "CallExpression")) return false;
@@ -12189,7 +13264,7 @@ const jsCombineIterations = defineRule({
 				if (!isNodeOfType(node.callee, "MemberExpression") || !isNodeOfType(node.callee.property, "Identifier")) return;
 				const outerMethod = node.callee.property.name;
 				if (!CHAINABLE_ITERATION_METHODS.has(outerMethod)) return;
-				const innerCall = node.callee.object;
+				const innerCall = stripParenExpression(node.callee.object);
 				if (!isNodeOfType(innerCall, "CallExpression") || !isNodeOfType(innerCall.callee, "MemberExpression") || !isNodeOfType(innerCall.callee.property, "Identifier")) return;
 				const innerMethod = innerCall.callee.property.name;
 				if (!CHAINABLE_ITERATION_METHODS.has(innerMethod)) return;
@@ -12262,10 +13337,10 @@ const jsFlatmapFilter = defineRule({
 		if (!filterArgument) return;
 		const isIdentityArrow = isNodeOfType(filterArgument, "ArrowFunctionExpression") && filterArgument.params?.length === 1 && isNodeOfType(filterArgument.body, "Identifier") && isNodeOfType(filterArgument.params[0], "Identifier") && filterArgument.body.name === filterArgument.params[0].name;
 		if (!(isNodeOfType(filterArgument, "Identifier") && filterArgument.name === "Boolean" || isIdentityArrow)) return;
-		const innerCall = node.callee.object;
+		const innerCall = stripParenExpression(node.callee.object);
 		if (!isNodeOfType(innerCall, "CallExpression") || !isNodeOfType(innerCall.callee, "MemberExpression") || !isNodeOfType(innerCall.callee.property, "Identifier")) return;
 		if (innerCall.callee.property.name !== "map") return;
-		const receiver = innerCall.callee.object;
+		const receiver = stripParenExpression(innerCall.callee.object);
 		if (receiver && isNodeOfType(receiver, "ArrayExpression")) {
 			const elements = receiver.elements ?? [];
 			if (elements.length > 0 && elements.length <= 8 && elements.every((element) => element == null || !isNodeOfType(element, "SpreadElement"))) return;
@@ -13525,7 +14600,7 @@ const jsTosortedImmutable = defineRule({
 	recommendation: "Use `array.toSorted()` (ES2023) instead of `[...array].sort()` so you sort without copying the array first",
 	create: (context) => ({ CallExpression(node) {
 		if (!isMemberProperty(node.callee, "sort")) return;
-		const receiver = node.callee.object;
+		const receiver = stripParenExpression(node.callee.object);
 		if (isNodeOfType(receiver, "ArrayExpression") && receiver.elements?.length === 1 && isNodeOfType(receiver.elements[0], "SpreadElement")) {
 			const spreadArgument = receiver.elements[0].argument;
 			if (isFreshOrIteratorAllocation(spreadArgument)) return;
@@ -18562,7 +19637,8 @@ const isInsidePollingLoop = (navigationNode, effectCallback, timerScheduledNames
 };
 const describeClientSideNavigation = (node) => {
 	if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression")) {
-		const objectName = isNodeOfType(node.callee.object, "Identifier") ? node.callee.object.name : null;
+		const receiver = stripParenExpression(node.callee.object);
+		const objectName = isNodeOfType(receiver, "Identifier") ? receiver.name : null;
 		const methodName = isNodeOfType(node.callee.property, "Identifier") ? node.callee.property.name : null;
 		if (objectName === "router" && (methodName === "push" || methodName === "replace")) return `router.${methodName}() in useEffect flashes the wrong page before redirecting.`;
 	}
@@ -19182,7 +20258,7 @@ const getCookieMutationMethodName = (node, locallyScopedCookieBindings) => {
 	if (!isNodeOfType(node.callee, "MemberExpression")) return null;
 	if (!isNodeOfType(node.callee.property, "Identifier")) return null;
 	if (!COOKIE_MUTATION_METHOD_NAMES.has(node.callee.property.name)) return null;
-	if (!isCookieReceiver(node.callee.object, locallyScopedCookieBindings)) return null;
+	if (!isCookieReceiver(stripParenExpression(node.callee.object), locallyScopedCookieBindings)) return null;
 	return node.callee.property.name;
 };
 const isMutatingFetchCall = (node) => {
@@ -19196,7 +20272,7 @@ const isMutatingDbCall = (node, locallyScopedSafeBindings) => {
 	if (!isNodeOfType(node, "CallExpression") || !isNodeOfType(node.callee, "MemberExpression")) return false;
 	const { property, object } = node.callee;
 	if (!isNodeOfType(property, "Identifier") || !MUTATION_METHOD_NAMES.has(property.name)) return false;
-	if (isSafeReceiverChain(object, locallyScopedSafeBindings)) return false;
+	if (isSafeReceiverChain(stripParenExpression(object), locallyScopedSafeBindings)) return false;
 	return true;
 };
 const getDbCallDescription = (node) => {
@@ -19204,7 +20280,8 @@ const getDbCallDescription = (node) => {
 	if (!isNodeOfType(node.callee, "MemberExpression")) return ".unknown()";
 	if (!isNodeOfType(node.callee.property, "Identifier")) return ".unknown()";
 	const methodName = node.callee.property.name;
-	const rootObjectName = isNodeOfType(node.callee.object, "Identifier") ? node.callee.object.name : null;
+	const receiver = stripParenExpression(node.callee.object);
+	const rootObjectName = isNodeOfType(receiver, "Identifier") ? receiver.name : null;
 	return rootObjectName ? `${rootObjectName}.${methodName}()` : `.${methodName}()`;
 };
 const findSideEffect = (node, options = {}) => {
@@ -20089,7 +21166,7 @@ const astMentionsSuspense = (programNode) => {
 			return false;
 		}
 		if (isNodeOfType(child, "ImportDeclaration") && child.source?.value === "react") {
-			if ((child.specifiers ?? []).some((specifier) => isNodeOfType(specifier, "ImportSpecifier") && getImportedName$1(specifier) === "Suspense")) {
+			if ((child.specifiers ?? []).some((specifier) => isNodeOfType(specifier, "ImportSpecifier") && getImportedName(specifier) === "Suspense")) {
 				didDetect = true;
 				return false;
 			}
@@ -20133,7 +21210,7 @@ const collectSuspenseLocalNames = (programNode) => {
 	for (const statement of programNode.body ?? []) {
 		if (!isNodeOfType(statement, "ImportDeclaration")) continue;
 		if (statement.source?.value !== "react") continue;
-		for (const specifier of statement.specifiers ?? []) if (isNodeOfType(specifier, "ImportSpecifier") && getImportedName$1(specifier) === "Suspense" && specifier.local?.name) names.add(specifier.local.name);
+		for (const specifier of statement.specifiers ?? []) if (isNodeOfType(specifier, "ImportSpecifier") && getImportedName(specifier) === "Suspense" && specifier.local?.name) names.add(specifier.local.name);
 	}
 	return names;
 };
@@ -20604,13 +21681,13 @@ const getCallExpr = (ref, current = ref.identifier.parent) => {
 	if (isNodeOfType(current, "CallExpression")) {
 		let node = ref.identifier;
 		let parent = node.parent;
-		while (parent && isNodeOfType(parent, "MemberExpression")) {
+		while (parent && (isNodeOfType(parent, "MemberExpression") || TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type))) {
 			node = parent;
 			parent = node.parent;
 		}
 		if (current.callee === node) return current;
 	}
-	if (isNodeOfType(current, "MemberExpression")) return getCallExpr(ref, current.parent);
+	if (isNodeOfType(current, "MemberExpression") || TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(current.type)) return getCallExpr(ref, current.parent);
 	return null;
 };
 const getArgsUpstreamRefs = (analysis, ref) => {
@@ -20745,7 +21822,7 @@ const isReactNamedImportReference = (ref, importedName) => Boolean(ref?.resolved
 	const importDeclaration = declarationNode.parent;
 	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && isNodeOfType(importDeclaration.source, "Literal") && importDeclaration.source.value === "react");
 }));
-const isHookCallee = (analysis, node, hookName) => {
+const isHookCallee$1 = (analysis, node, hookName) => {
 	if (!node) return false;
 	if (isNodeOfType(node, "Identifier")) {
 		if (node.name === hookName) return true;
@@ -20754,15 +21831,19 @@ const isHookCallee = (analysis, node, hookName) => {
 		if (parent && isNodeOfType(parent, "MemberExpression") && isNodeOfType(parent.object, "Identifier") && parent.object.name === "React" && isNodeOfType(parent.property, "Identifier") && parent.property.name === hookName) return true;
 		return false;
 	}
-	if (isNodeOfType(node, "MemberExpression")) return isNodeOfType(node.object, "Identifier") && node.object.name === "React" && isNodeOfType(node.property, "Identifier") && node.property.name === hookName;
+	if (isNodeOfType(node, "MemberExpression")) {
+		const receiver = stripParenExpression(node.object);
+		return isNodeOfType(receiver, "Identifier") && receiver.name === "React" && isNodeOfType(node.property, "Identifier") && node.property.name === hookName;
+	}
 	return false;
 };
 const isUseEffect = (node) => {
 	if (!node || !isNodeOfType(node, "CallExpression")) return false;
 	const callee = node.callee;
 	if (isNodeOfType(callee, "Identifier") && callee.name === "useEffect") return true;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "React" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "useEffect") return true;
-	return false;
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const receiver = stripParenExpression(callee.object);
+	return isNodeOfType(receiver, "Identifier") && receiver.name === "React" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "useEffect";
 };
 const getEffectFn = (analysis, node) => {
 	if (!isNodeOfType(node, "CallExpression")) return null;
@@ -20790,7 +21871,7 @@ const isState = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator")) return false;
 	if (!isNodeOfType(node.init, "CallExpression")) return false;
-	if (!isHookCallee(analysis, node.init.callee, "useState")) return false;
+	if (!isHookCallee$1(analysis, node.init.callee, "useState")) return false;
 	if (!isNodeOfType(node.id, "ArrayPattern")) return false;
 	const elements = node.id.elements ?? [];
 	if (elements.length !== 1 && elements.length !== 2) return false;
@@ -20801,7 +21882,7 @@ const isStateSetter = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) =
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator")) return false;
 	if (!isNodeOfType(node.init, "CallExpression")) return false;
-	if (!isHookCallee(analysis, node.init.callee, "useState")) return false;
+	if (!isHookCallee$1(analysis, node.init.callee, "useState")) return false;
 	if (!isNodeOfType(node.id, "ArrayPattern")) return false;
 	const elements = node.id.elements ?? [];
 	if (elements.length !== 2) return false;
@@ -20848,7 +21929,7 @@ const isRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator")) return false;
 	if (!isNodeOfType(node.init, "CallExpression")) return false;
-	return isHookCallee(analysis, node.init.callee, "useRef");
+	return isHookCallee$1(analysis, node.init.callee, "useRef");
 }));
 const isRefCurrent = (ref) => {
 	const parent = ref.identifier.parent;
@@ -20861,11 +21942,15 @@ const isSyncStateSetterCall = (analysis, ref, effectFn) => isStateSetterCall(ana
 const HANDLER_NAMED_METHOD_PATTERN = /^(on|handle)[A-Z]/;
 const isPropCallbackInvocationRef = (analysis, ref) => {
 	if (!isPropAlias(analysis, ref)) return false;
-	const identifier = ref.identifier;
-	const parent = identifier.parent;
+	let effectiveNode = ref.identifier;
+	let parent = effectiveNode.parent;
+	while (parent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type) && "expression" in parent && parent.expression === effectiveNode) {
+		effectiveNode = parent;
+		parent = effectiveNode.parent;
+	}
 	if (!parent) return false;
-	if (isNodeOfType(parent, "CallExpression") && parent.callee === identifier) return true;
-	if (isNodeOfType(parent, "MemberExpression") && parent.object === identifier) {
+	if (isNodeOfType(parent, "CallExpression") && parent.callee === effectiveNode) return true;
+	if (isNodeOfType(parent, "MemberExpression") && parent.object === effectiveNode) {
 		const memberParent = parent.parent;
 		if (isNodeOfType(memberParent, "CallExpression") && memberParent.callee === parent) {
 			if (!parent.computed && isNodeOfType(parent.property, "Identifier") && HANDLER_NAMED_METHOD_PATTERN.test(parent.property.name)) return true;
@@ -20876,7 +21961,7 @@ const isPropCallbackInvocationRef = (analysis, ref) => {
 };
 const isRefCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => isRefCurrent(innerRef) || isRef(analysis, innerRef));
 const getUseStateDecl = (analysis, ref) => {
-	let node = getUpstreamRefs(analysis, ref).find((upRef) => isHookCallee(analysis, upRef.identifier, "useState"))?.identifier;
+	let node = getUpstreamRefs(analysis, ref).find((upRef) => isHookCallee$1(analysis, upRef.identifier, "useState"))?.identifier;
 	while (node && !isNodeOfType(node, "VariableDeclarator")) node = node.parent;
 	return node ?? null;
 };
@@ -21081,7 +22166,7 @@ const isObjectUrlLifecycleEffect = (effectFn) => {
 const noAdjustStateOnPropChange = defineRule({
 	id: "no-adjust-state-on-prop-change",
 	title: "State synced to a prop inside an effect",
-	severity: "error",
+	severity: "warn",
 	tags: ["test-noise"],
 	recommendation: "Adjust the state inline during render with a `prev`-prop comparison (`if (prop !== prevProp) { setPrevProp(prop); setX(...); }`), or refactor to remove the duplicated state. Routing the adjustment through a useEffect forces an extra render with a stale UI between the two commits. See https://react.dev/learn/you-might-not-need-an-effect#adjusting-some-state-when-a-prop-changes",
 	create: (context) => ({ CallExpression(node) {
@@ -21122,7 +22207,23 @@ const ALWAYS_FOCUSABLE_TAGS = new Set([
 	"summary",
 	"textarea"
 ]);
+const isStaticallyFalseBooleanAttribute = (attribute) => {
+	const value = attribute.value;
+	if (!value || !isNodeOfType(value, "JSXExpressionContainer")) return false;
+	const expression = value.expression;
+	return isNodeOfType(expression, "Literal") && expression.value === false;
+};
+const DISABLEABLE_TAGS = new Set([
+	"button",
+	"input",
+	"select",
+	"textarea"
+]);
 const isNativelyFocusable = (tagName, openingElement) => {
+	if (DISABLEABLE_TAGS.has(tagName)) {
+		const disabledAttribute = hasJsxPropIgnoreCase(openingElement.attributes, "disabled");
+		if (disabledAttribute && !isStaticallyFalseBooleanAttribute(disabledAttribute)) return false;
+	}
 	if (ALWAYS_FOCUSABLE_TAGS.has(tagName)) return true;
 	switch (tagName) {
 		case "input": {
@@ -21136,7 +22237,10 @@ const isNativelyFocusable = (tagName, openingElement) => {
 		case "a":
 		case "area": return hasJsxPropIgnoreCase(openingElement.attributes, "href") !== void 0;
 		case "audio":
-		case "video": return hasJsxPropIgnoreCase(openingElement.attributes, "controls") !== void 0;
+		case "video": {
+			const controlsAttribute = hasJsxPropIgnoreCase(openingElement.attributes, "controls");
+			return controlsAttribute !== void 0 && !isStaticallyFalseBooleanAttribute(controlsAttribute);
+		}
 		default: return false;
 	}
 };
@@ -22100,7 +23204,8 @@ const SECOND_INDEX_METHODS = new Set([
 	"some"
 ]);
 const THIRD_INDEX_METHODS = new Set(["reduce", "reduceRight"]);
-const isPositionallyStableIterationReceiver = (receiver) => {
+const isPositionallyStableIterationReceiver = (receiverNode) => {
+	const receiver = stripParenExpression(receiverNode);
 	if (isAllLiteralArrayExpression(receiver)) return true;
 	if (isNodeOfType(receiver, "ArrayExpression") && receiver.elements?.length === 1) {
 		const only = receiver.elements[0];
@@ -22111,17 +23216,13 @@ const isPositionallyStableIterationReceiver = (receiver) => {
 	}
 	if (!isNodeOfType(receiver, "CallExpression")) return false;
 	const callee = receiver.callee;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "from" && receiver.arguments.length >= 1 && isNodeOfType(receiver.arguments[0], "ObjectExpression")) return true;
+	if (isGlobalMethodCall(receiver, "Array", "from") && receiver.arguments.length >= 1 && isNodeOfType(receiver.arguments[0], "ObjectExpression")) return true;
 	if (isNodeOfType(callee, "Identifier") && callee.name === "Array") return true;
 	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "split") return true;
 	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && (callee.property.name === "fill" || callee.property.name === "flat")) return isPositionallyStableIterationReceiver(callee.object);
 	return false;
 };
-const isArrayFromMapperCallback = (parentCall, callback) => {
-	if (parentCall.arguments[1] !== callback) return false;
-	const callee = parentCall.callee;
-	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "from";
-};
+const isArrayFromMapperCallback = (parentCall, callback) => parentCall.arguments[1] === callback && isGlobalMethodCall(parentCall, "Array", "from");
 const isArrayFromSourcePositionallyStable = (source) => {
 	if (isNodeOfType(source, "ObjectExpression")) {
 		for (const property of source.properties ?? []) {
@@ -22180,18 +23281,12 @@ const expressionUsesIndex = (expression, paramName) => {
 		return false;
 	}
 	if (isNodeOfType(expression, "CallExpression")) {
-		if (isNodeOfType(expression.callee, "MemberExpression") && isNodeOfType(expression.callee.property, "Identifier") && expression.callee.property.name === "toString" && isIndexReference(expression.callee.object, paramName)) return true;
+		if (isNodeOfType(expression.callee, "MemberExpression") && isNodeOfType(expression.callee.property, "Identifier") && expression.callee.property.name === "toString" && isIndexReference(stripParenExpression(expression.callee.object), paramName)) return true;
 		if (isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "String" && expression.arguments.length > 0 && isIndexReference(expression.arguments[0], paramName)) return true;
 	}
 	return false;
 };
-const isReactCloneElement = (callExpression) => {
-	const callee = callExpression.callee;
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	if (!isNodeOfType(callee.property, "Identifier")) return false;
-	if (callee.property.name !== "cloneElement") return false;
-	return isNodeOfType(callee.object, "Identifier") && callee.object.name === "React";
-};
+const isReactCloneElement = (callExpression) => isGlobalMethodCall(callExpression, "React", "cloneElement");
 const noArrayIndexKey = defineRule({
 	id: "no-array-index-key",
 	title: "Array index used as a key",
@@ -22700,6 +23795,10 @@ const NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES = new Set([
 	"ClassDeclaration",
 	"ClassExpression"
 ]);
+const REACT_CREATE_ELEMENT_OPTIONS = {
+	allowGlobalReactNamespace: false,
+	allowUnboundBareCalls: false
+};
 const isCallArgumentFunctionExpression = (node) => {
 	if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionExpression") return false;
 	const parent = node.parent;
@@ -22707,44 +23806,10 @@ const isCallArgumentFunctionExpression = (node) => {
 	return parent.arguments.some((argumentNode) => argumentNode === node);
 };
 const isNestedRenderEvidenceBoundary = (node) => NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES.has(node.type) && !isCallArgumentFunctionExpression(node);
-const isReactImport$1 = (symbol) => {
-	let importDeclaration = symbol.declarationNode?.parent;
-	while (importDeclaration && !isNodeOfType(importDeclaration, "ImportDeclaration")) importDeclaration = importDeclaration.parent ?? null;
-	if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration")) return false;
-	return importDeclaration.source.value === "react";
-};
-const getImportedName = (symbol) => {
-	if (symbol.kind !== "import") return null;
-	if (!isReactImport$1(symbol)) return null;
-	return getImportedName$1(symbol.declarationNode) ?? null;
-};
-const isReactNamespaceImport = (symbol) => {
-	if (symbol.kind !== "import") return false;
-	if (!isReactImport$1(symbol)) return false;
-	return isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier");
-};
-const isReactCreateElementIdentifierCall = (callee, scopes) => {
-	if (!isNodeOfType(callee, "Identifier")) return false;
-	const symbol = scopes.symbolFor(callee);
-	return Boolean(symbol && getImportedName(symbol) === "createElement");
-};
-const isReactCreateElementMemberCall = (callee, scopes) => {
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	if (callee.computed) return false;
-	if (!isNodeOfType(callee.object, "Identifier")) return false;
-	if (!isNodeOfType(callee.property, "Identifier")) return false;
-	if (callee.property.name !== "createElement") return false;
-	const symbol = scopes.symbolFor(callee.object);
-	return Boolean(symbol && isReactNamespaceImport(symbol));
-};
-const isReactCreateElementCall = (node, scopes) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	return isReactCreateElementIdentifierCall(node.callee, scopes) || isReactCreateElementMemberCall(node.callee, scopes);
-};
 const containsRenderOutput$1 = (node, rootNode, scopes) => {
 	if (node !== rootNode && isNestedRenderEvidenceBoundary(node)) return false;
 	if (node.type === "JSXElement" || node.type === "JSXFragment") return true;
-	if (isReactCreateElementCall(node, scopes)) return true;
+	if (isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS)) return true;
 	const nodeRecord = node;
 	for (const key of Object.keys(nodeRecord)) {
 		if (key === "parent") continue;
@@ -22915,7 +23980,7 @@ const isAsyncFunctionLike = (node) => {
 	if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) return Boolean(node.async);
 	return false;
 };
-const SYNCHRONOUS_ITERATION_METHOD_NAMES = new Set([
+const SYNCHRONOUS_ITERATION_METHOD_NAMES$1 = new Set([
 	"forEach",
 	"map",
 	"filter",
@@ -22936,30 +24001,51 @@ const runsOnEffectDispatch = (functionNode) => {
 	if (parent.callee === functionNode) return true;
 	if (!(parent.arguments ?? []).some((argument) => argument === functionNode)) return false;
 	const callee = parent.callee;
-	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES.has(callee.property.name);
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES$1.has(callee.property.name);
 };
 const isTerminatingStatement = (statement) => isNodeOfType(statement, "BreakStatement") || isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement") || isNodeOfType(statement, "ContinueStatement");
-const isGuardWithTerminatingBranch = (statement) => {
-	if (!isNodeOfType(statement, "IfStatement")) return null;
-	if (statement.alternate) return null;
-	const consequent = statement.consequent;
-	if (isTerminatingStatement(consequent)) return consequent;
-	if (isNodeOfType(consequent, "BlockStatement") && (consequent.body ?? []).some((inner) => isTerminatingStatement(inner))) return consequent;
-	return null;
-};
-const countStatementSequenceSetStateCalls = (statements, context) => {
+const analyzeBranchStatements = (branch, context) => analyzeStatementSequence(isNodeOfType(branch, "BlockStatement") ? branch.body ?? [] : [branch], context);
+const analyzeStatementSequence = (statements, context) => {
 	let fallThroughCount = 0;
-	let maxTerminatingPathCount = 0;
+	let maxTerminatedCount = 0;
 	for (const statement of statements) {
-		const guardBranch = isGuardWithTerminatingBranch(statement);
-		if (guardBranch) {
-			maxTerminatingPathCount = Math.max(maxTerminatingPathCount, fallThroughCount + countMaxPathSetStateCalls(guardBranch, context));
+		if (isNodeOfType(statement, "IfStatement")) {
+			fallThroughCount += countMaxPathSetStateCalls(statement.test, context);
+			const thenSummary = analyzeBranchStatements(statement.consequent, context);
+			const elseSummary = statement.alternate ? analyzeBranchStatements(statement.alternate, context) : {
+				fallThroughCount: 0,
+				maxTerminatedCount: 0,
+				doAllPathsTerminate: false
+			};
+			maxTerminatedCount = Math.max(maxTerminatedCount, fallThroughCount + thenSummary.maxTerminatedCount, fallThroughCount + elseSummary.maxTerminatedCount);
+			if (thenSummary.doAllPathsTerminate && elseSummary.doAllPathsTerminate) return {
+				fallThroughCount: 0,
+				maxTerminatedCount,
+				doAllPathsTerminate: true
+			};
+			const fallThroughBranchCounts = [...thenSummary.doAllPathsTerminate ? [] : [thenSummary.fallThroughCount], ...elseSummary.doAllPathsTerminate ? [] : [elseSummary.fallThroughCount]];
+			fallThroughCount += Math.max(...fallThroughBranchCounts);
 			continue;
 		}
-		if (isTerminatingStatement(statement)) break;
+		if (isTerminatingStatement(statement)) {
+			const terminatedPathCount = fallThroughCount + countMaxPathSetStateCalls(statement, context);
+			return {
+				fallThroughCount: 0,
+				maxTerminatedCount: Math.max(maxTerminatedCount, terminatedPathCount),
+				doAllPathsTerminate: true
+			};
+		}
 		fallThroughCount += countMaxPathSetStateCalls(statement, context);
 	}
-	return Math.max(maxTerminatingPathCount, fallThroughCount);
+	return {
+		fallThroughCount,
+		maxTerminatedCount,
+		doAllPathsTerminate: false
+	};
+};
+const countStatementSequenceSetStateCalls = (statements, context) => {
+	const summary = analyzeStatementSequence(statements, context);
+	return Math.max(summary.fallThroughCount, summary.maxTerminatedCount);
 };
 const collectLocalHelperFunctions = (root) => {
 	const helpersByName = /* @__PURE__ */ new Map();
@@ -23090,7 +24176,9 @@ const isDevOnlyGuardedEffect = (callback) => {
 	if (!body || !isNodeOfType(body, "BlockStatement")) return false;
 	const firstStatement = (body.body ?? [])[0];
 	if (!firstStatement) return false;
-	if (!isGuardWithTerminatingBranch(firstStatement)) return false;
+	if (!isNodeOfType(firstStatement, "IfStatement") || firstStatement.alternate) return false;
+	const consequent = firstStatement.consequent;
+	if (!(isTerminatingStatement(consequent) || isNodeOfType(consequent, "BlockStatement") && (consequent.body ?? []).some((inner) => isTerminatingStatement(inner)))) return false;
 	return mentionsDevEnvFlag(firstStatement.test);
 };
 const noCascadingSetState = defineRule({
@@ -23449,40 +24537,6 @@ const noCloneElement = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/component-or-hook-display-name.ts
-const hocWrapperCalleeName = (callee) => {
-	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
-	return null;
-};
-const displayNameFromFunctionBinding = (functionNode) => {
-	let current = functionNode;
-	for (;;) {
-		const parent = current.parent;
-		if (parent && isNodeOfType(parent, "CallExpression") && parent.arguments?.[0] === current) {
-			const calleeName = hocWrapperCalleeName(parent.callee);
-			if (calleeName && COMPONENT_HOC_WRAPPER_NAMES.has(calleeName)) {
-				current = parent;
-				continue;
-			}
-		}
-		break;
-	}
-	const binding = current.parent;
-	if (binding && isNodeOfType(binding, "VariableDeclarator") && isNodeOfType(binding.id, "Identifier") && binding.init === current) return isReactComponentOrHookName(binding.id.name) ? binding.id.name : null;
-	return null;
-};
-const componentOrHookDisplayNameForFunction = (functionNode) => {
-	if ((isNodeOfType(functionNode, "FunctionDeclaration") || isNodeOfType(functionNode, "FunctionExpression")) && functionNode.id) return isReactComponentOrHookName(functionNode.id.name) ? functionNode.id.name : null;
-	return displayNameFromFunctionBinding(functionNode);
-};
-//#endregion
-//#region src/plugin/utils/enclosing-component-or-hook-name.ts
-const enclosingComponentOrHookName = (node) => {
-	const functionNode = findEnclosingFunction(node);
-	return functionNode ? componentOrHookDisplayNameForFunction(functionNode) : null;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-create-context-in-render.ts
 const MESSAGE$30 = "createContext() builds a new context every render, so every consumer gets cut off & resets.";
 const CONTEXT_MODULES = [
@@ -24071,16 +25125,6 @@ const isInitialOnlyPropName = (propName) => {
 	return /^initial[A-Z]/.test(propName) || /^default[A-Z]/.test(propName) || /^seed[A-Z]/.test(propName) || /^starting[A-Z]/.test(propName) || /^baseline[A-Z]/.test(propName) || /^preset[A-Z]/.test(propName);
 };
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/static-member-property-name.ts
-const getStaticMemberPropertyName = (node) => {
-	if (!node) return null;
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "MemberExpression")) return null;
-	if (!unwrappedNode.computed && isNodeOfType(unwrappedNode.property, "Identifier")) return unwrappedNode.property.name;
-	if (unwrappedNode.computed && isNodeOfType(unwrappedNode.property, "Literal") && typeof unwrappedNode.property.value === "string") return unwrappedNode.property.value;
-	return null;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/event-handler-reference.ts
 const isEventHandlerName = (name) => /^on[A-Z]/.test(name);
 const getStaticMemberReferenceName = (node, resolveName = (name) => name) => {
@@ -24089,13 +25133,6 @@ const getStaticMemberReferenceName = (node, resolveName = (name) => name) => {
 	const propertyName = getStaticMemberPropertyName(node);
 	return propertyName ? `${resolveName(node.object.name)}.${propertyName}` : null;
 };
-const getStaticPropertyKeyName = (node) => {
-	if (!isNodeOfType(node, "Property")) return null;
-	if (node.computed) return null;
-	if (isNodeOfType(node.key, "Identifier")) return node.key.name;
-	if (isNodeOfType(node.key, "Literal")) return String(node.key.value);
-	return null;
-};
 const isEventHandlerValue = (node, eventHandlerReferenceNames, resolveName = (name) => name) => {
 	if (isInlineFunctionExpression(node)) return true;
 	if (isNodeOfType(node, "Identifier")) return eventHandlerReferenceNames.has(resolveName(node.name));
@@ -24453,11 +25490,21 @@ const isInitialOnlySetterCall = (callExpr) => {
 	return isInitialOnlyPropName(arg.name);
 };
 //#endregion
+//#region src/plugin/utils/is-no-op-statement.ts
+const isNoOpStatement = (statement) => {
+	if (isNodeOfType(statement, "EmptyStatement")) return true;
+	if (!isNodeOfType(statement, "ExpressionStatement")) return false;
+	const expression = stripParenExpression(statement.expression);
+	if (isNodeOfType(expression, "Literal")) return true;
+	if (isNodeOfType(expression, "Identifier")) return expression.name === "undefined";
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return isNodeOfType(stripParenExpression(expression.argument), "Literal");
+	return false;
+};
+//#endregion
 //#region src/plugin/utils/get-callback-statements.ts
 const getCallbackStatements = (callback) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression") && !isNodeOfType(callback, "FunctionDeclaration")) return [];
-	if (isNodeOfType(callback.body, "BlockStatement")) return callback.body.body ?? [];
-	return callback.body ? [callback.body] : [];
+	return (isNodeOfType(callback.body, "BlockStatement") ? callback.body.body ?? [] : callback.body ? [callback.body] : []).filter((statement) => !isNoOpStatement(statement));
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-derived-state-effect.ts
@@ -24496,6 +25543,27 @@ const collectValueIdentifierNames = (node, into, localBindingNames = /* @__PURE_
 		} else if (child && typeof child === "object" && "type" in child) collectValueIdentifierNames(child, into, localBindingNames);
 	}
 };
+const flattenGuardedStatements = (statements) => {
+	const flattened = [];
+	for (const statement of statements) {
+		if (isNoOpStatement(statement)) continue;
+		if (isNodeOfType(statement, "ExpressionStatement")) {
+			flattened.push(statement);
+			continue;
+		}
+		if (isNodeOfType(statement, "IfStatement")) {
+			for (const branch of [statement.consequent, statement.alternate]) {
+				if (!branch) continue;
+				const flattenedBranch = flattenGuardedStatements(isNodeOfType(branch, "BlockStatement") ? branch.body ?? [] : [branch]);
+				if (flattenedBranch === null) return null;
+				flattened.push(...flattenedBranch);
+			}
+			continue;
+		}
+		return null;
+	}
+	return flattened;
+};
 const noDerivedStateEffect = defineRule({
 	id: "no-derived-state-effect",
 	title: "Derived state stored in an effect",
@@ -24527,8 +25595,8 @@ const noDerivedStateEffect = defineRule({
 			}
 		}
 		if (sawAnyDep && allDepsAreInitialOnly) return;
-		const statements = getCallbackStatements(callback);
-		if (statements.length === 0) return;
+		const statements = flattenGuardedStatements(getCallbackStatements(callback));
+		if (statements === null || statements.length === 0) return;
 		if (!statements.every((statement) => {
 			if (!isNodeOfType(statement, "ExpressionStatement")) return false;
 			const expression = statement.expression;
@@ -25163,7 +26231,7 @@ const noDidMountSetState = defineRule({
 		const { mode } = resolveSettings$20(context.settings);
 		return { CallExpression(node) {
 			if (!isNodeOfType(node.callee, "MemberExpression")) return;
-			if (!isNodeOfType(node.callee.object, "ThisExpression")) return;
+			if (!isNodeOfType(stripParenExpression(node.callee.object), "ThisExpression")) return;
 			if (!isNodeOfType(node.callee.property, "Identifier") || node.callee.property.name !== "setState") return;
 			if (!isSetStateCallInLifecycle(node, LIFECYCLE_NAMES$2, { disallowInNestedFunctions: mode === "disallow-in-func" })) return;
 			if (isMountFlagArgument(node.arguments?.[0])) return;
@@ -25288,7 +26356,7 @@ const noDidUpdateSetState = defineRule({
 		const { mode } = resolveSettings$19(context.settings);
 		return { CallExpression(node) {
 			if (!isNodeOfType(node.callee, "MemberExpression")) return;
-			if (!isNodeOfType(node.callee.object, "ThisExpression")) return;
+			if (!isNodeOfType(stripParenExpression(node.callee.object), "ThisExpression")) return;
 			if (!isNodeOfType(node.callee.property, "Identifier") || node.callee.property.name !== "setState") return;
 			if (!isSetStateCallInLifecycle(node, LIFECYCLE_NAMES$1, { disallowInNestedFunctions: mode === "disallow-in-func" })) return;
 			if (isInsideDiffGuard(node)) return;
@@ -25385,18 +26453,45 @@ const collectUseStateBindings = (componentBody) => {
 //#region src/plugin/rules/state-and-effects/no-direct-state-mutation.ts
 const PLAIN_DATA_PRODUCER_GLOBAL_NAMES = new Set(["Array", "structuredClone"]);
 const PLAIN_DATA_ARRAY_STATIC_METHODS = new Set(["from", "of"]);
+const PLAIN_DATA_JSON_STATIC_METHODS = new Set(["parse"]);
+const PLAIN_DATA_OBJECT_STATIC_METHODS = new Set([
+	"assign",
+	"entries",
+	"fromEntries",
+	"keys",
+	"values"
+]);
+const ARRAY_COPY_METHOD_NAMES = new Set([
+	"map",
+	"filter",
+	"slice",
+	"concat",
+	"flat",
+	"flatMap",
+	"toSorted",
+	"toReversed",
+	"toSpliced",
+	"with"
+]);
 const isNullOrUndefinedExpression = (expression) => isNodeOfType(expression, "Literal") && expression.value === null || isNodeOfType(expression, "Identifier") && expression.name === "undefined";
 const isPlainDataProducerCall = (expression) => {
 	if (!isNodeOfType(expression, "CallExpression")) return false;
 	const callee = expression.callee;
 	if (isNodeOfType(callee, "Identifier")) return PLAIN_DATA_PRODUCER_GLOBAL_NAMES.has(callee.name);
 	if (!isNodeOfType(callee, "MemberExpression") || !isNodeOfType(callee.property, "Identifier")) return false;
-	if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array") return PLAIN_DATA_ARRAY_STATIC_METHODS.has(callee.property.name);
+	if (isNodeOfType(callee.object, "Identifier")) {
+		if (callee.object.name === "Array") return PLAIN_DATA_ARRAY_STATIC_METHODS.has(callee.property.name);
+		if (callee.object.name === "JSON") return PLAIN_DATA_JSON_STATIC_METHODS.has(callee.property.name);
+		if (callee.object.name === "Object") return PLAIN_DATA_OBJECT_STATIC_METHODS.has(callee.property.name);
+	}
 	return producesPlainStateValue(callee.object);
 };
+const PLAIN_DATA_CONSTRUCTOR_NAMES = new Set(["Array", "Object"]);
+const isPlainDataNewExpression = (expression) => isNodeOfType(expression, "NewExpression") && isNodeOfType(expression.callee, "Identifier") && PLAIN_DATA_CONSTRUCTOR_NAMES.has(expression.callee.name);
 const producesPlainStateValue = (expression) => {
 	const unwrapped = stripParenExpression(expression);
 	if (isNodeOfType(unwrapped, "ObjectExpression") || isNodeOfType(unwrapped, "ArrayExpression")) return true;
+	if (isPlainDataNewExpression(unwrapped)) return true;
 	if (isNullOrUndefinedExpression(unwrapped)) return true;
 	if (isNodeOfType(unwrapped, "MemberExpression") && getRootIdentifierName(unwrapped) === "props") return true;
 	return isPlainDataProducerCall(unwrapped);
@@ -25411,6 +26506,38 @@ const initializerMarksPlainState = (initializerArgument) => {
 	}
 	return producesPlainStateValue(unwrapped);
 };
+const producesOpaqueInstanceValue = (expression) => {
+	if (isNodeOfType(expression, "NewExpression")) return !isPlainDataNewExpression(expression);
+	if (!isNodeOfType(expression, "CallExpression")) return false;
+	const callee = expression.callee;
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	if (isPlainDataProducerCall(expression)) return false;
+	if (!callee.computed && isNodeOfType(callee.property, "Identifier") && ARRAY_COPY_METHOD_NAMES.has(callee.property.name)) return false;
+	return true;
+};
+const collectSetterValueObservations = (componentBody, setterNames) => {
+	const plainFedSetterNames = /* @__PURE__ */ new Set();
+	const opaqueFedSetterNames = /* @__PURE__ */ new Set();
+	walkComponentRespectingShadows(componentBody, /* @__PURE__ */ new Set(), (node, currentlyShadowed) => {
+		if (!isNodeOfType(node, "CallExpression")) return;
+		if (!isNodeOfType(node.callee, "Identifier")) return;
+		const setterName = node.callee.name;
+		if (!setterNames.has(setterName) || currentlyShadowed.has(setterName)) return;
+		const argument = node.arguments?.[0];
+		if (!argument) return;
+		const unwrapped = stripParenExpression(argument);
+		if (isNullOrUndefinedExpression(unwrapped)) return;
+		if (producesPlainStateValue(unwrapped)) {
+			plainFedSetterNames.add(setterName);
+			return;
+		}
+		if (producesOpaqueInstanceValue(unwrapped)) opaqueFedSetterNames.add(setterName);
+	}, true);
+	return {
+		plainFedSetterNames,
+		opaqueFedSetterNames
+	};
+};
 const collectCallbackRefSetterNames = (componentBody) => {
 	const callbackRefSetterNames = /* @__PURE__ */ new Set();
 	walkAst(componentBody, (node) => {
@@ -25480,11 +26607,15 @@ const noDirectStateMutation = defineRule({
 			if (bindings.length === 0) return;
 			const stateValueToSetter = new Map(bindings.map((binding) => [binding.valueName, binding.setterName]));
 			const callbackRefSetterNames = collectCallbackRefSetterNames(componentBody);
+			const setterValueObservations = collectSetterValueObservations(componentBody, new Set(bindings.map((binding) => binding.setterName)));
 			const plainObjectStateValueNames = /* @__PURE__ */ new Set();
 			for (const binding of bindings) {
 				if (callbackRefSetterNames.has(binding.setterName)) continue;
 				if (!isNodeOfType(binding.declarator.init, "CallExpression")) continue;
-				if (initializerMarksPlainState(binding.declarator.init.arguments?.[0])) plainObjectStateValueNames.add(binding.valueName);
+				const initializerArgument = binding.declarator.init.arguments?.[0];
+				if (!initializerMarksPlainState(initializerArgument)) continue;
+				if ((!initializerArgument || isNullOrUndefinedExpression(stripParenExpression(initializerArgument))) && setterValueObservations.opaqueFedSetterNames.has(binding.setterName) && !setterValueObservations.plainFedSetterNames.has(binding.setterName)) continue;
+				plainObjectStateValueNames.add(binding.valueName);
 			}
 			const visitMutationCandidate = (child, currentlyShadowed) => {
 				if (isNodeOfType(child, "AssignmentExpression")) {
@@ -25609,9 +26740,10 @@ const noDocumentStartViewTransition = defineRule({
 	create: (context) => ({ CallExpression(node) {
 		const callee = node.callee;
 		if (!isNodeOfType(callee, "MemberExpression")) return;
-		if (!isNodeOfType(callee.object, "Identifier") || callee.object.name !== "document") return;
+		const receiver = stripParenExpression(callee.object);
+		if (!isNodeOfType(receiver, "Identifier") || receiver.name !== "document") return;
 		if (!isNodeOfType(callee.property, "Identifier") || callee.property.name !== "startViewTransition") return;
-		if (context.scopes.symbolFor(callee.object) !== null) return;
+		if (context.scopes.symbolFor(receiver) !== null) return;
 		if (!importsReactViewTransition(node)) return;
 		context.report({
 			node,
@@ -25631,7 +26763,8 @@ const noDocumentWrite = defineRule({
 	create: (context) => ({ CallExpression(node) {
 		const callee = node.callee;
 		if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return;
-		if (!isNodeOfType(callee.object, "Identifier") || callee.object.name !== "document") return;
+		const receiver = stripParenExpression(callee.object);
+		if (!isNodeOfType(receiver, "Identifier") || receiver.name !== "document") return;
 		if (!isNodeOfType(callee.property, "Identifier") || !WRITE_METHODS.has(callee.property.name)) return;
 		context.report({
 			node,
@@ -26263,13 +27396,6 @@ const noEffectEventHandler = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-imported-from-non-react-module.ts
-const isImportedFromNonReactModule = (contextNode, localIdentifierName) => {
-	const importSource = getImportSourceForName(contextNode, localIdentifierName);
-	if (importSource === null) return false;
-	return !REACT_RUNTIME_MODULE_SOURCES.has(importSource);
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-effect-event-in-deps.ts
 const createComponentBindingStackTracker = (callbacks) => {
 	const componentBindingStack = [];
@@ -26323,11 +27449,7 @@ const noEffectEventInDeps = defineRule({
 			const initializer = declaratorNode.init;
 			if (!initializer || !isNodeOfType(initializer, "CallExpression")) return;
 			if (!isHookCall$2(initializer, "useEffectEvent")) return;
-			if (isNodeOfType(initializer.callee, "Identifier")) {
-				if (isImportedFromNonReactModule(declaratorNode, initializer.callee.name)) return;
-				const calleeSymbol = context.scopes.referenceFor(initializer.callee)?.resolvedSymbol;
-				if (calleeSymbol && calleeSymbol.kind !== "import") return;
-			}
+			if (isNonReactEffectEventCallee(initializer.callee, declaratorNode, context.scopes)) return;
 			componentBindings.addBindingToCurrentFrame(declaratorNode.id.name);
 		} });
 		return {
@@ -27044,7 +28166,7 @@ const collectVariableDeclarationReferenceNames = (node, scope, eventHandlerRefer
 };
 const collectPropertyReferenceNames = (node, scope, eventHandlerReferenceNames) => {
 	if (!isNodeOfType(node, "Property")) return /* @__PURE__ */ new Set();
-	const propertyName = getStaticPropertyKeyName(node);
+	const propertyName = getStaticPropertyKeyName(node, { stringifyNonStringLiterals: true });
 	if (propertyName && isEventHandlerName(propertyName) && isEventHandlerValue(node.value, eventHandlerReferenceNames, (name) => resolveBindingName(scope, name))) return /* @__PURE__ */ new Set();
 	const names = /* @__PURE__ */ new Set();
 	if (node.computed) addNames$1(names, collectScopedReferenceNames(node.key, scope, eventHandlerReferenceNames));
@@ -27422,7 +28544,7 @@ const addObjectPropertyFunctionNames = (objectBindingName, node, functionLikeLoc
 	if (!isNodeOfType(node, "ObjectExpression")) return;
 	for (const property of node.properties ?? []) {
 		if (!isNodeOfType(property, "Property")) continue;
-		const propertyName = getStaticPropertyKeyName(property);
+		const propertyName = getStaticPropertyKeyName(property, { stringifyNonStringLiterals: true });
 		if (!propertyName) continue;
 		if (!isFunctionLikeReference(property.value, functionLikeLocalNames, scope)) continue;
 		functionLikeLocalNames.add(`${objectBindingName}.${propertyName}`);
@@ -27933,7 +29055,7 @@ const noFlushSync = defineRule({
 		if (node.source?.value !== "react-dom") return;
 		for (const specifier of node.specifiers ?? []) {
 			if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
-			if (getImportedName$1(specifier) !== "flushSync") continue;
+			if (getImportedName(specifier) !== "flushSync") continue;
 			const program = findProgram(node);
 			if (program) {
 				if (importsImperativeDomLibrary(program)) return;
@@ -28907,7 +30029,7 @@ const noIsMounted = defineRule({
 	recommendation: "`isMounted` doesn't work in modern React. Track mount state with a ref, or cancel the async work instead.",
 	create: (context) => ({ CallExpression(node) {
 		if (!isNodeOfType(node.callee, "MemberExpression")) return;
-		if (!isNodeOfType(node.callee.object, "ThisExpression")) return;
+		if (!isNodeOfType(stripParenExpression(node.callee.object), "ThisExpression")) return;
 		if (!isNodeOfType(node.callee.property, "Identifier") || node.callee.property.name !== "isMounted") return;
 		if (!getParentComponent(node)) return;
 		context.report({
@@ -28922,7 +30044,9 @@ const MESSAGE$20 = "`JSON.parse(JSON.stringify(x))` deep-clones by re-serializin
 const isJsonMethodCall = (node, method) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	const callee = node.callee;
-	return isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier") && callee.object.name === "JSON" && isNodeOfType(callee.property, "Identifier") && callee.property.name === method;
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return false;
+	const receiver = stripParenExpression(callee.object);
+	return isNodeOfType(receiver, "Identifier") && receiver.name === "JSON" && isNodeOfType(callee.property, "Identifier") && callee.property.name === method;
 };
 const SNAPSHOT_FUNCTION_NAME_PATTERN = /snapshot|serializ|tojson/i;
 const NORMALIZATION_BINDING_NAME_PATTERN = /normali[sz]/i;
@@ -29007,7 +30131,7 @@ const extractReturnTypeAnnotation = (returnType) => {
 const noJsxElementType = defineRule({
 	id: "no-jsx-element-type",
 	title: "No JSX.Element",
-	severity: "error",
+	severity: "warn",
 	recommendation: "Replace `JSX.Element` with `React.ReactNode`. `JSX.Element` is too narrow: it excludes `null`, strings, numbers, and fragments that components commonly return.",
 	create: (context) => {
 		let isJsxImported = false;
@@ -29333,6 +30457,378 @@ const noLegacyContextApi = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/executes-during-render.ts
+const SYNCHRONOUS_ITERATION_METHOD_NAMES = new Set([
+	"map",
+	"filter",
+	"forEach",
+	"flatMap",
+	"reduce",
+	"reduceRight",
+	"some",
+	"every",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"sort",
+	"toSorted"
+]);
+const executesDuringRender = (functionNode) => {
+	const parent = functionNode.parent;
+	if (!isNodeOfType(parent, "CallExpression")) return false;
+	if (parent.callee === functionNode) return true;
+	if (isHookCall$2(parent, "useMemo") && parent.arguments?.[0] === functionNode) return true;
+	return isNodeOfType(parent.callee, "MemberExpression") && !parent.callee.computed && isNodeOfType(parent.callee.property, "Identifier") && SYNCHRONOUS_ITERATION_METHOD_NAMES.has(parent.callee.property.name) && parent.arguments?.[0] === functionNode;
+};
+//#endregion
+//#region src/plugin/utils/has-suppress-hydration-warning-attribute.ts
+const hasSuppressHydrationWarningAttribute = (openingElement) => {
+	if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement")) return false;
+	for (const attr of openingElement.attributes ?? []) if (isNodeOfType(attr, "JSXAttribute") && isNodeOfType(attr.name, "JSXIdentifier") && attr.name.name === "suppressHydrationWarning") return true;
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/find-declarator-for-binding.ts
+const findDeclaratorForBinding = (bindingIdentifier) => {
+	let ancestor = bindingIdentifier.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "VariableDeclarator")) return ancestor;
+		if (isNodeOfType(ancestor, "FunctionDeclaration") || isNodeOfType(ancestor, "FunctionExpression") || isNodeOfType(ancestor, "ArrowFunctionExpression") || isNodeOfType(ancestor, "Program")) return null;
+		ancestor = ancestor.parent ?? null;
+	}
+	return null;
+};
+//#endregion
+//#region src/plugin/utils/references-falsy-initial-state.ts
+const isFalsyLiteral = (node) => {
+	if (!node) return true;
+	if (isNodeOfType(node, "Literal")) return !node.value;
+	return isNodeOfType(node, "Identifier") && node.name === "undefined";
+};
+const isFalsyInitialStateBinding = (identifier) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const binding = findVariableInitializer(identifier, identifier.name);
+	if (!binding) return false;
+	const declarator = findDeclaratorForBinding(binding.bindingIdentifier);
+	if (!declarator?.init) return false;
+	const init = stripParenExpression(declarator.init);
+	if (!isHookCall$2(init, "useState") || !isNodeOfType(init, "CallExpression")) return false;
+	if (!isNodeOfType(declarator.id, "ArrayPattern")) return false;
+	if (declarator.id.elements?.[0] !== binding.bindingIdentifier) return false;
+	return isFalsyLiteral(init.arguments?.[0]);
+};
+const referencesFalsyInitialState = (expression) => flattenLogicalAndChain(stripParenExpression(expression)).some((operand) => isFalsyInitialStateBinding(stripParenExpression(operand)));
+//#endregion
+//#region src/plugin/utils/is-gated-by-falsy-initial-state.ts
+const isGatedByFalsyInitialState = (node) => {
+	let cursor = node;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "LogicalExpression") && parent.operator === "&&" && parent.right === cursor && referencesFalsyInitialState(parent.left)) return true;
+		if (isNodeOfType(parent, "ConditionalExpression") && parent.consequent === cursor && referencesFalsyInitialState(parent.test)) return true;
+		if (isNodeOfType(parent, "IfStatement") && parent.consequent === cursor && referencesFalsyInitialState(parent.test)) return true;
+		cursor = parent;
+		parent = parent.parent ?? null;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/references-client-only-flag.ts
+const CLIENT_ONLY_FLAG_NAME_PATTERN = /^(?:is|has|did)?_?(?:client|mounted|hydrated|browser)(?:_?(?:side|ready|only))?$/i;
+const referencesClientOnlyFlag = (expression) => {
+	const unwrapped = stripParenExpression(expression);
+	if (isNodeOfType(unwrapped, "Identifier")) return CLIENT_ONLY_FLAG_NAME_PATTERN.test(unwrapped.name);
+	if (isNodeOfType(unwrapped, "MemberExpression")) {
+		const property = unwrapped.property;
+		return isNodeOfType(property, "Identifier") && CLIENT_ONLY_FLAG_NAME_PATTERN.test(property.name);
+	}
+	if (isNodeOfType(unwrapped, "UnaryExpression") && unwrapped.operator === "!") return referencesClientOnlyFlag(unwrapped.argument);
+	if (isNodeOfType(unwrapped, "LogicalExpression")) return referencesClientOnlyFlag(unwrapped.left) || referencesClientOnlyFlag(unwrapped.right);
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/is-inside-client-only-guard.ts
+const isInsideClientOnlyGuard = (node) => {
+	let cursor = node;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "LogicalExpression") && parent.operator === "&&" && parent.right === cursor && referencesClientOnlyFlag(parent.left)) return true;
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === cursor || parent.alternate === cursor) && referencesClientOnlyFlag(parent.test)) return true;
+		if (isNodeOfType(parent, "IfStatement") && parent.consequent === cursor && referencesClientOnlyFlag(parent.test)) return true;
+		cursor = parent;
+		parent = parent.parent ?? null;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/rules/performance/no-locale-format-in-render.ts
+const LOCALE_FORMAT_METHOD_NAMES = new Set([
+	"toLocaleString",
+	"toLocaleDateString",
+	"toLocaleTimeString"
+]);
+const DATE_ONLY_LOCALE_METHOD_NAMES = new Set(["toLocaleDateString", "toLocaleTimeString"]);
+const INTL_FORMATTER_NAMES = new Set(["DateTimeFormat", "RelativeTimeFormat"]);
+const INTL_FORMAT_METHOD_NAMES = new Set([
+	"format",
+	"formatToParts",
+	"formatRange"
+]);
+const isProvableDateExpression = (expression) => {
+	if (!expression) return false;
+	const unwrapped = stripParenExpression(expression);
+	return isNodeOfType(unwrapped, "NewExpression") && isNodeOfType(unwrapped.callee, "Identifier") && unwrapped.callee.name === "Date";
+};
+const DATE_FLAVORED_NAME_PATTERN = /(date|time|timestamp|deadline|created|updated|scheduled|expire|moment|when|birthday|dob)|(at)$/i;
+const receiverNameLooksDateFlavored = (expression) => {
+	if (!expression) return false;
+	const unwrapped = stripParenExpression(expression);
+	if (isNodeOfType(unwrapped, "Identifier")) return DATE_FLAVORED_NAME_PATTERN.test(unwrapped.name);
+	if (isNodeOfType(unwrapped, "MemberExpression") && !unwrapped.computed) return isNodeOfType(unwrapped.property, "Identifier") && DATE_FLAVORED_NAME_PATTERN.test(unwrapped.property.name);
+	if (isNodeOfType(unwrapped, "CallExpression")) return receiverNameLooksDateFlavored(unwrapped.callee);
+	return false;
+};
+const objectLiteralHasProperty = (objectExpression, propertyName) => {
+	if (!objectExpression) return false;
+	const unwrapped = stripParenExpression(objectExpression);
+	if (!isNodeOfType(unwrapped, "ObjectExpression")) return false;
+	for (const property of unwrapped.properties ?? []) {
+		if (!isNodeOfType(property, "Property")) continue;
+		if (property.computed) continue;
+		if (isNodeOfType(property.key, "Identifier") && property.key.name === propertyName) return true;
+		if (isNodeOfType(property.key, "Literal") && property.key.value === propertyName) return true;
+	}
+	return false;
+};
+const hasExplicitLocaleArgument = (argument) => {
+	if (!argument) return false;
+	const unwrapped = stripParenExpression(argument);
+	if (isNodeOfType(unwrapped, "Identifier") && unwrapped.name === "undefined") return false;
+	return true;
+};
+const isDeterministicLocaleMethodCall = (call, methodName, receiverIsProvablyDate) => {
+	const localeArgument = call.arguments?.[0];
+	if (!hasExplicitLocaleArgument(localeArgument)) return false;
+	const optionsArgument = call.arguments?.[1];
+	if (objectLiteralHasProperty(optionsArgument, "timeZone")) return true;
+	return !DATE_ONLY_LOCALE_METHOD_NAMES.has(methodName) && !receiverIsProvablyDate;
+};
+const matchLocaleMethodCall = (call) => {
+	const callee = call.callee;
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return null;
+	if (!isNodeOfType(callee.property, "Identifier")) return null;
+	const methodName = callee.property.name;
+	if (!LOCALE_FORMAT_METHOD_NAMES.has(methodName)) return null;
+	const receiverIsProvablyDate = isProvableDateExpression(callee.object);
+	if (methodName === "toLocaleString" && !receiverIsProvablyDate && !receiverNameLooksDateFlavored(callee.object)) return null;
+	if (isDeterministicLocaleMethodCall(call, methodName, receiverIsProvablyDate)) return null;
+	return {
+		node: call,
+		display: `${methodName}()`
+	};
+};
+const getIntlFormatterName = (expression) => {
+	if (!expression) return null;
+	const unwrapped = stripParenExpression(expression);
+	if (!isNodeOfType(unwrapped, "CallExpression") && !isNodeOfType(unwrapped, "NewExpression")) return null;
+	const callee = unwrapped.callee;
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return null;
+	if (!isNodeOfType(callee.object, "Identifier") || callee.object.name !== "Intl") return null;
+	if (!isNodeOfType(callee.property, "Identifier")) return null;
+	return INTL_FORMATTER_NAMES.has(callee.property.name) ? callee.property.name : null;
+};
+const isDeterministicIntlConstruction = (construction, formatterName) => {
+	if (!isNodeOfType(construction, "CallExpression") && !isNodeOfType(construction, "NewExpression")) return false;
+	if (!hasExplicitLocaleArgument(construction.arguments?.[0])) return false;
+	if (formatterName !== "DateTimeFormat") return true;
+	return objectLiteralHasProperty(construction.arguments?.[1], "timeZone");
+};
+const matchIntlFormatCall = (call) => {
+	const callee = call.callee;
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return null;
+	if (!isNodeOfType(callee.property, "Identifier")) return null;
+	if (!INTL_FORMAT_METHOD_NAMES.has(callee.property.name)) return null;
+	let construction = stripParenExpression(callee.object);
+	if (isNodeOfType(construction, "Identifier")) {
+		const binding = findVariableInitializer(construction, construction.name);
+		construction = binding?.initializer ? stripParenExpression(binding.initializer) : null;
+	}
+	if (!construction) return null;
+	const formatterName = getIntlFormatterName(construction);
+	if (!formatterName) return null;
+	if (isDeterministicIntlConstruction(construction, formatterName)) return null;
+	return {
+		node: call,
+		display: `Intl.${formatterName}().${callee.property.name}()`
+	};
+};
+const isDeterministicInputDateConstruction = (expression) => {
+	if (!expression) return false;
+	const unwrapped = stripParenExpression(expression);
+	if (!isNodeOfType(unwrapped, "NewExpression")) return false;
+	if (!isNodeOfType(unwrapped.callee, "Identifier") || unwrapped.callee.name !== "Date") return false;
+	return (unwrapped.arguments?.length ?? 0) > 0;
+};
+const matchDateDefaultStringification = (node) => {
+	if (isNodeOfType(node, "CallExpression")) {
+		const callee = node.callee;
+		if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && callee.property.name === "toString" && isDeterministicInputDateConstruction(callee.object)) return {
+			node,
+			display: "Date.prototype.toString()"
+		};
+		if (isNodeOfType(callee, "Identifier") && callee.name === "String" && isDeterministicInputDateConstruction(node.arguments?.[0])) return {
+			node,
+			display: "String(new Date(…))"
+		};
+		return null;
+	}
+	if (isNodeOfType(node, "TemplateLiteral")) {
+		for (const expression of node.expressions ?? []) if (isDeterministicInputDateConstruction(expression)) return {
+			node: expression,
+			display: "`${new Date(…)}`"
+		};
+	}
+	return null;
+};
+const findRenderPhaseComponentOrHook = (node) => {
+	let functionNode = findEnclosingFunction(node);
+	while (functionNode) {
+		if (componentOrHookDisplayNameForFunction(functionNode)) return functionNode;
+		if (!executesDuringRender(functionNode)) return null;
+		functionNode = findEnclosingFunction(functionNode);
+	}
+	return null;
+};
+const hasClientRenderEvidence = (componentOrHookNode, fileHasUseClientDirective) => {
+	if (fileHasUseClientDirective) return true;
+	const displayName = componentOrHookDisplayNameForFunction(componentOrHookNode);
+	if (displayName && isReactHookName(displayName)) return true;
+	let callsHook = false;
+	walkAst((isFunctionLike$1(componentOrHookNode) ? componentOrHookNode.body : null) ?? componentOrHookNode, (child) => {
+		if (callsHook) return false;
+		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && isReactHookName(child.callee.name)) {
+			callsHook = true;
+			return false;
+		}
+	});
+	return callsHook;
+};
+const isAfterClientOnlyEarlyReturn = (node, componentOrHookNode) => {
+	const body = isFunctionLike$1(componentOrHookNode) ? componentOrHookNode.body : null;
+	if (!isNodeOfType(body, "BlockStatement")) return false;
+	const ancestors = /* @__PURE__ */ new Set();
+	let cursor = node;
+	while (cursor) {
+		ancestors.add(cursor);
+		cursor = cursor.parent ?? null;
+	}
+	for (const statement of body.body ?? []) {
+		if (ancestors.has(statement)) return false;
+		if (!isNodeOfType(statement, "IfStatement")) continue;
+		if (!referencesClientOnlyFlag(statement.test) && !referencesFalsyInitialState(statement.test)) continue;
+		let returnsEarly = false;
+		walkAst(statement.consequent, (child) => {
+			if (isFunctionLike$1(child)) return false;
+			if (isNodeOfType(child, "ReturnStatement")) {
+				returnsEarly = true;
+				return false;
+			}
+		});
+		if (returnsEarly) return true;
+	}
+	return false;
+};
+const findEnclosingJsxOpeningElement = (node) => {
+	let cursor = node.parent;
+	while (cursor) {
+		if (isNodeOfType(cursor, "JSXElement")) return cursor.openingElement;
+		if (isNodeOfType(cursor, "JSXFragment")) return null;
+		cursor = cursor.parent ?? null;
+	}
+	return null;
+};
+const noLocaleFormatInRender = defineRule({
+	id: "no-locale-format-in-render",
+	title: "Locale/timezone formatting during render",
+	severity: "warn",
+	category: "Correctness",
+	disabledWhen: [
+		"vite",
+		"cra",
+		"expo",
+		"react-native",
+		"unknown"
+	],
+	recommendation: "Format locale/timezone-dependent values in a post-mount useEffect + state, or pass an explicit locale and timeZone so the server and the browser render the same text. Only runs on SSR-capable projects.",
+	create: (context) => {
+		if (isTestlikeFilename(context.filename)) return {};
+		if (classifyReactNativeFileTarget(context) === "react-native") return {};
+		let fileHasUseClientDirective = false;
+		let fileIsEmailTemplate = false;
+		const reportedNodes = /* @__PURE__ */ new Set();
+		const reportIfRenderPhase = (match) => {
+			if (reportedNodes.has(match.node)) return;
+			const componentOrHookNode = findRenderPhaseComponentOrHook(match.node);
+			if (!componentOrHookNode) return;
+			if (fileIsEmailTemplate) return;
+			if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
+			if (isInsideClientOnlyGuard(match.node)) return;
+			if (isGatedByFalsyInitialState(match.node)) return;
+			if (isAfterClientOnlyEarlyReturn(match.node, componentOrHookNode)) return;
+			if (hasSuppressHydrationWarningAttribute(findEnclosingJsxOpeningElement(match.node))) return;
+			if (isGeneratedImageRenderContext(context, findEnclosingJsxOpeningElement(match.node)?.parent ?? match.node)) return;
+			reportedNodes.add(match.node);
+			context.report({
+				node: match.node,
+				message: `This can cause a hydration mismatch because ${match.display} formats with the server's locale and timezone during server rendering but the user's in the browser. Format it in a post-mount useEffect, or pass an explicit locale and timeZone.`
+			});
+		};
+		return {
+			Program(node) {
+				fileHasUseClientDirective = hasDirective(node, "use client");
+				fileIsEmailTemplate = hasEmailTemplateImport(node);
+			},
+			CallExpression(node) {
+				const match = matchLocaleMethodCall(node) ?? matchIntlFormatCall(node) ?? matchDateDefaultStringification(node);
+				if (match) reportIfRenderPhase(match);
+			},
+			TemplateLiteral(node) {
+				const match = matchDateDefaultStringification(node);
+				if (match) reportIfRenderPhase(match);
+			},
+			JSXExpressionContainer(node) {
+				const expression = stripParenExpression(node.expression);
+				if (!isNodeOfType(expression, "CallExpression")) return;
+				if (!isNodeOfType(expression.callee, "Identifier")) return;
+				const helperName = expression.callee.name;
+				const componentOrHookNode = findRenderPhaseComponentOrHook(node);
+				if (!componentOrHookNode) return;
+				const helperNode = findVariableInitializer(expression.callee, helperName)?.initializer;
+				if (!helperNode || !isFunctionLike$1(helperNode)) return;
+				if (componentOrHookDisplayNameForFunction(helperNode)) return;
+				walkAst(helperNode.body ?? helperNode, (child) => {
+					if (isFunctionLike$1(child)) return false;
+					if (!isNodeOfType(child, "CallExpression")) return;
+					const match = matchLocaleMethodCall(child) ?? matchIntlFormatCall(child);
+					if (!match || reportedNodes.has(match.node)) return;
+					if (fileIsEmailTemplate) return;
+					if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
+					if (isInsideClientOnlyGuard(node)) return;
+					if (isGatedByFalsyInitialState(node)) return;
+					if (isAfterClientOnlyEarlyReturn(node, componentOrHookNode)) return;
+					if (hasSuppressHydrationWarningAttribute(findEnclosingJsxOpeningElement(node))) return;
+					reportedNodes.add(match.node);
+					context.report({
+						node: match.node,
+						message: `This can cause a hydration mismatch because ${match.display} (reached from JSX through "${helperName}") formats with the server's locale and timezone during server rendering but the user's in the browser. Format it in a post-mount useEffect, or pass an explicit locale and timeZone.`
+					});
+				});
+			}
+		};
+	}
+});
+//#endregion
 //#region src/plugin/rules/design/no-long-transition-duration.ts
 const hasInfiniteIterationCount = (properties) => properties.some((property) => {
 	if (getStylePropertyKey(property) !== "animationIterationCount") return false;
@@ -30146,7 +31642,6 @@ const SAME_REFERENCE_ARRAY_RETURN_METHODS = new Set([
 	"reverse",
 	"sort"
 ]);
-const SAME_REFERENCE_COLLECTION_RETURN_METHODS = new Set(["add", "set"]);
 const OBJECT_MUTATION_METHODS = new Set([
 	"assign",
 	"defineProperties",
@@ -30220,7 +31715,6 @@ const canExpressionReturnOriginalReducerStateReference = (node, state) => {
 			const methodName = getStaticMemberPropertyName(unwrappedNode.callee);
 			if (methodName === "assign" && isNodeOfType(unwrappedNode.callee.object, "Identifier") && unwrappedNode.callee.object.name === "Object") return isExpressionOriginalReducerStateReference(unwrappedNode.arguments?.[0], state);
 			if (methodName && SAME_REFERENCE_ARRAY_RETURN_METHODS.has(methodName) && isExpressionOriginalReducerStateReference(unwrappedNode.callee.object, state)) return true;
-			if (methodName && SAME_REFERENCE_COLLECTION_RETURN_METHODS.has(methodName) && isExpressionOriginalReducerStateReference(unwrappedNode.callee.object, state)) return true;
 		}
 	}
 	if (isNodeOfType(unwrappedNode, "ConditionalExpression")) return canExpressionReturnOriginalReducerStateReference(unwrappedNode.consequent, state) || canExpressionReturnOriginalReducerStateReference(unwrappedNode.alternate, state);
@@ -30259,6 +31753,7 @@ const collectReducerStateMutationsInExpressionOrStatement = (node, state) => {
 		if (!isNodeOfType(unwrappedChild.callee, "MemberExpression")) return;
 		const methodName = getStaticMemberPropertyName(unwrappedChild.callee);
 		if (!methodName || !MUTATING_ARRAY_METHODS.has(methodName) && !MUTATING_COLLECTION_METHODS.has(methodName)) return;
+		if (MUTATING_COLLECTION_METHODS.has(methodName) && !MUTATING_ARRAY_METHODS.has(methodName) && !isResultDiscardedCall(unwrappedChild)) return;
 		if (isExpressionRootedInMutableReducerStateSource(unwrappedChild.callee.object, state)) mutations.push({ node: unwrappedChild });
 	});
 	return mutations;
@@ -30491,7 +31986,7 @@ const noNestedComponentDefinition = defineRule({
 	id: "no-nested-component-definition",
 	title: "Component defined inside another component",
 	tags: ["test-noise", "react-jsx-only"],
-	severity: "error",
+	severity: "warn",
 	category: "Correctness",
 	recommendation: "Move it to module scope or a separate file so React does not recreate the component and erase its state on every parent render.",
 	create: (context) => {
@@ -31446,12 +32941,12 @@ const noPassDataToParent = defineRule({
 			if (calleeNode === identifier) {
 				if (!isDirectParentCallbackRef(analysis, ref)) continue;
 				if (isNodeOfType(identifier, "Identifier") && COMMAND_PROP_NAME_PATTERN.test(identifier.name)) continue;
-			} else if (isNodeOfType(calleeNode, "MemberExpression") && unwrapChainExpression(calleeNode.object) === identifier) {
+			} else if (isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === identifier) {
 				if (!isWholePropsObjectReference(analysis, ref)) continue;
 				if (isCustomHookParameter(ref)) continue;
 			} else continue;
 			const methodName = getCallMethodName(calleeNode);
-			const isPropCallbackNamedLikeStringRead = Boolean(methodName && STRING_READ_METHOD_NAMES.has(methodName) && isNodeOfType(calleeNode, "MemberExpression") && calleeNode.object === ref.identifier && isWholePropsObjectReference(analysis, ref));
+			const isPropCallbackNamedLikeStringRead = Boolean(methodName && STRING_READ_METHOD_NAMES.has(methodName) && isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === ref.identifier && isWholePropsObjectReference(analysis, ref));
 			if (methodName && DATA_SINK_METHOD_NAMES.has(methodName) && !isPropCallbackNamedLikeStringRead) continue;
 			if (methodName && COMMAND_PROP_NAME_PATTERN.test(methodName)) continue;
 			if (isNamespacedApiCallee(calleeNode)) continue;
@@ -31642,7 +33137,7 @@ const noPassLiveStateToParent = defineRule({
 			if (isCallResultConsumedAsArgument(callExpr)) continue;
 			const calleeNode = callExpr.callee;
 			const methodName = calleeNode ? getCallMethodName(calleeNode) : null;
-			const isPropCallbackNamedLikeStringRead = Boolean(methodName && STRING_READ_METHOD_NAMES.has(methodName) && calleeNode && isNodeOfType(calleeNode, "MemberExpression") && calleeNode.object === ref.identifier && isWholePropsObjectReference(analysis, ref));
+			const isPropCallbackNamedLikeStringRead = Boolean(methodName && STRING_READ_METHOD_NAMES.has(methodName) && calleeNode && isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === ref.identifier && isWholePropsObjectReference(analysis, ref));
 			if (methodName && DATA_SINK_METHOD_NAMES.has(methodName) && !isPropCallbackNamedLikeStringRead) continue;
 			if (calleeNode && isNamespacedApiCallee(calleeNode)) continue;
 			const stateArgRefs = collectPropCallbackBoundStateRefs(analysis, ref, (innerRef) => isParentNotificationCallbackRef(analysis, innerRef));
@@ -31970,40 +33465,6 @@ const noPreventDefault = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/is-result-discarded-call.ts
-const isResultDiscardedCall = (callExpression) => {
-	let node = callExpression;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "ExpressionStatement")) return true;
-		if (isNodeOfType(parent, "ArrowFunctionExpression") && parent.body === node) return true;
-		if (isNodeOfType(parent, "ChainExpression")) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "LogicalExpression") && parent.right === node) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === node || parent.alternate === node)) {
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		if (isNodeOfType(parent, "SequenceExpression")) {
-			const expressions = parent.expressions ?? [];
-			if (expressions[expressions.length - 1] !== node) return true;
-			node = parent;
-			parent = node.parent;
-			continue;
-		}
-		return false;
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-prop-callback-in-effect.ts
 const isRefLatchGuardedEffect = (callbackBody) => {
 	const refNamesReadInGuards = /* @__PURE__ */ new Set();
@@ -32210,7 +33671,7 @@ const isAlwaysFreshExpression = (expression) => {
 		return `${callee.name}()`;
 	}
 	if (isNodeOfType(callee, "MemberExpression") && !callee.computed) {
-		const receiver = callee.object;
+		const receiver = stripParenExpression(callee.object);
 		const property = callee.property;
 		if (!isNodeOfType(property, "Identifier")) return null;
 		if (isNodeOfType(receiver, "Identifier")) {
@@ -32331,9 +33792,11 @@ const createDeprecatedReactImportRule = ({ source, messages, handleExtraSource }
 			if (typeof sourceValue !== "string") return;
 			if (handleExtraSource?.(node, context)) return;
 			if (sourceValue !== source) return;
+			if (isTypeOnlyImport(node)) return;
 			for (const specifier of node.specifiers ?? []) {
 				if (isNodeOfType(specifier, "ImportSpecifier")) {
-					const importedName = getImportedName$1(specifier);
+					if (specifier.importKind === "type") continue;
+					const importedName = getImportedName(specifier);
 					if (!importedName) continue;
 					const message = messages.get(importedName);
 					if (message) context.report({
@@ -32351,8 +33814,9 @@ const createDeprecatedReactImportRule = ({ source, messages, handleExtraSource }
 		MemberExpression(node) {
 			if (namespaceBindings.size === 0) return;
 			if (node.computed) return;
-			if (!isNodeOfType(node.object, "Identifier")) return;
-			if (!namespaceBindings.has(node.object.name)) return;
+			const receiver = stripParenExpression(node.object);
+			if (!isNodeOfType(receiver, "Identifier")) return;
+			if (!namespaceBindings.has(receiver.name)) return;
 			if (!isNodeOfType(node.property, "Identifier")) return;
 			const message = messages.get(node.property.name);
 			if (message) context.report({
@@ -32385,7 +33849,7 @@ const buildTestUtilsMessage = (importedName) => {
 const reportTestUtilsImports = (node, context) => {
 	for (const specifier of node.specifiers ?? []) {
 		if (isNodeOfType(specifier, "ImportSpecifier")) {
-			const importedName = getImportedName$1(specifier) ?? "default";
+			const importedName = getImportedName(specifier) ?? "default";
 			context.report({
 				node: specifier,
 				message: buildTestUtilsMessage(importedName)
@@ -32417,7 +33881,7 @@ const noReactDomDeprecatedApis = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/architecture/no-react19-deprecated-apis.ts
-const REACT_19_DEPRECATED_MESSAGES = new Map([["forwardRef", "forwardRef is dead weight in React 19, since ref is a normal prop now, so drop it & pass ref straight through."], ["useContext", "useContext is replaced by `use()` in React 19, which reads context inside ifs & loops too, so switch to `import { use } from 'react'`."]]);
+const REACT_19_DEPRECATED_MESSAGES = new Map([["forwardRef", "forwardRef is dead weight in React 19, since ref is a normal prop now, so drop it & pass ref straight through."]]);
 const isVendoredShadcnUiFilename = (rawFilename) => {
 	if (!rawFilename) return false;
 	const filename = rawFilename.replaceAll("\\", "/");
@@ -32455,7 +33919,7 @@ const noReact19DeprecatedApis = defineRule({
 	requires: ["react:19"],
 	tags: ["test-noise", "migration-hint"],
 	severity: "warn",
-	recommendation: "Pass `ref` as a normal prop on function components, since `forwardRef` isn't needed in React 19. Replace `useContext(X)` with `use(X)`. Only runs on React 19+ projects.",
+	recommendation: "Pass `ref` as a normal prop on function components, since `forwardRef` isn't needed in React 19. Only runs on React 19+ projects.",
 	create: (context) => {
 		if (isVendoredShadcnUiFilename(context.filename)) return {};
 		return deprecatedReactImportRule.create(buildOncePerApiContext(context));
@@ -32779,34 +34243,11 @@ const noRedundantShouldComponentUpdate = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/architecture/no-render-in-render.ts
-const tracesToPropOrParameter = (symbol, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
-	if (!symbol || visitedSymbols.has(symbol)) return false;
-	visitedSymbols.add(symbol);
-	if (isComponentParameterSymbol(symbol)) return true;
-	if (!isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return false;
-	const source = symbol.initializer;
-	if (!source) return false;
-	return initializerRootsInProps(source, scopes, visitedSymbols);
-};
-const initializerRootsInProps = (node, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
-	if (isNodeOfType(node, "LogicalExpression")) return initializerRootsInProps(node.left, scopes, visitedSymbols) || initializerRootsInProps(node.right, scopes, visitedSymbols);
-	if (isNodeOfType(node, "ConditionalExpression")) return initializerRootsInProps(node.consequent, scopes, visitedSymbols) || initializerRootsInProps(node.alternate, scopes, visitedSymbols);
-	return rootsInProps(node, scopes, visitedSymbols);
-};
-const rootsInProps = (node, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
-	let current = node;
-	while (isNodeOfType(current, "MemberExpression")) {
-		if (isNodeOfType(current.object, "ThisExpression") && isNodeOfType(current.property, "Identifier") && current.property.name === "props") return true;
-		current = current.object;
-	}
-	if (isNodeOfType(current, "Identifier")) return tracesToPropOrParameter(scopes.symbolFor(current), scopes, visitedSymbols);
-	return false;
-};
 const isInsideComponentContext = (node) => {
 	let cursor = node.parent;
 	while (cursor) {
-		if (isNodeOfType(cursor, "ClassDeclaration") || isNodeOfType(cursor, "ClassExpression")) return true;
 		if (isFunctionLike$1(cursor) && isComponentFunction$1(cursor)) return true;
+		if (isEs5Component(cursor) || isEs6Component(cursor)) return true;
 		cursor = cursor.parent ?? null;
 	}
 	return false;
@@ -32816,24 +34257,28 @@ const functionBodyOf = (node) => {
 	if (isNodeOfType(node, "VariableDeclarator") && node.init && isFunctionLike$1(node.init)) return node.init.body ?? null;
 	return null;
 };
+const isHookCallee = (callee) => {
+	if (isNodeOfType(callee, "Identifier")) return isReactHookName(callee.name);
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier") && isUppercaseName(callee.object.name) && isNodeOfType(callee.property, "Identifier")) return isReactHookName(callee.property.name);
+	return false;
+};
 const containsHookCall = (body) => {
 	let found = false;
 	walkAst(body, (child) => {
-		if (found) return;
+		if (found) return false;
+		if (child !== body && isFunctionLike$1(child) && isComponentFunction$1(child)) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
-		const name = getCalleeName$2(child);
-		if (name && isReactHookName(name)) found = true;
+		if (isHookCallee(child.callee)) found = true;
 	});
 	return found;
 };
-const isModuleScopeHookFreeHelper = (symbol) => {
+const isHookCallingRenderHelper = (symbol) => {
 	if (!symbol) return false;
 	const declaration = symbol.declarationNode;
 	if (!isNodeOfType(declaration, "FunctionDeclaration") && !isNodeOfType(declaration, "VariableDeclarator")) return false;
 	const body = functionBodyOf(declaration);
 	if (!body) return false;
-	if (findEnclosingFunction(declaration) !== null) return false;
-	return !containsHookCall(body);
+	return containsHookCall(body);
 };
 const noRenderInRender = defineRule({
 	id: "no-render-in-render",
@@ -32842,20 +34287,13 @@ const noRenderInRender = defineRule({
 	tags: ["test-noise"],
 	recommendation: "Make it a named component rendered as JSX so React can track it and preserve its state.",
 	create: (context) => ({ JSXExpressionContainer(node) {
-		const expression = node.expression;
+		const expression = isNodeOfType(node.expression, "ChainExpression") ? node.expression.expression : node.expression;
 		if (!isNodeOfType(expression, "CallExpression")) return;
-		let calleeName = null;
-		if (isNodeOfType(expression.callee, "Identifier")) calleeName = expression.callee.name;
-		else if (isNodeOfType(expression.callee, "MemberExpression") && isNodeOfType(expression.callee.property, "Identifier")) calleeName = expression.callee.property.name;
-		if (!calleeName || !RENDER_FUNCTION_PATTERN.test(calleeName)) return;
+		if (!isNodeOfType(expression.callee, "Identifier")) return;
+		const calleeName = expression.callee.name;
+		if (!RENDER_FUNCTION_PATTERN.test(calleeName)) return;
 		if (!isInsideComponentContext(node)) return;
-		if (isNodeOfType(expression.callee, "Identifier")) {
-			const calleeSymbol = context.scopes.symbolFor(expression.callee);
-			if (tracesToPropOrParameter(calleeSymbol, context.scopes)) return;
-			if (isModuleScopeHookFreeHelper(calleeSymbol)) return;
-		} else if (isNodeOfType(expression.callee, "MemberExpression")) {
-			if (rootsInProps(expression.callee.object, context.scopes)) return;
-		}
+		if (!isHookCallingRenderHelper(context.scopes.symbolFor(expression.callee))) return;
 		context.report({
 			node: expression,
 			message: `"${calleeName}()" hides a component behind an inline call, so pull it into its own component and render it as JSX so React can track it.`
@@ -32916,13 +34354,7 @@ const noRenderPropChildren = defineRule({
 //#endregion
 //#region src/plugin/rules/react-builtins/no-render-return-value.ts
 const MESSAGE$14 = "Your app breaks in React 19 because `ReactDOM.render` returns nothing there.";
-const isReactDomRenderCall = (node) => {
-	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
-	if (!isNodeOfType(node.callee.object, "Identifier")) return false;
-	if (node.callee.object.name !== "ReactDOM") return false;
-	if (!isNodeOfType(node.callee.property, "Identifier")) return false;
-	return node.callee.property.name === "render";
-};
+const isReactDomRenderCall = (node) => isGlobalMethodCall(node, "ReactDOM", "render");
 const isUsedAsReturnValue = (parent) => {
 	if (!parent) return false;
 	if (isNodeOfType(parent, "VariableDeclarator") || isNodeOfType(parent, "Property") || isNodeOfType(parent, "ReturnStatement") || isNodeOfType(parent, "AssignmentExpression")) return true;
@@ -33758,7 +35190,7 @@ const noSetState = defineRule({
 	category: "Architecture",
 	create: (context) => ({ CallExpression(node) {
 		if (!isNodeOfType(node.callee, "MemberExpression")) return;
-		if (!isNodeOfType(node.callee.object, "ThisExpression")) return;
+		if (!isNodeOfType(stripParenExpression(node.callee.object), "ThisExpression")) return;
 		if (!isNodeOfType(node.callee.property, "Identifier") || node.callee.property.name !== "setState") return;
 		if (!getParentComponent(node)) return;
 		context.report({
@@ -33924,6 +35356,204 @@ const noSideTabBorder = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/rules/state-and-effects/no-stale-timer-ref.ts
+const GLOBAL_TIMER_RECEIVER_NAMES = new Set([
+	"window",
+	"globalThis",
+	"self"
+]);
+const NULLISH_COMPARISON_OPERATORS = new Set([
+	"==",
+	"===",
+	"!=",
+	"!=="
+]);
+const getGlobalTimerCalleeName = (node) => {
+	if (!isNodeOfType(node, "CallExpression")) return null;
+	const callee = stripParenExpression(node.callee);
+	if (isNodeOfType(callee, "Identifier")) return callee.name;
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) {
+		const receiver = stripParenExpression(callee.object);
+		if (isNodeOfType(receiver, "Identifier") && GLOBAL_TIMER_RECEIVER_NAMES.has(receiver.name)) return callee.property.name;
+	}
+	return null;
+};
+const getRefCurrentReceiverName = (node) => {
+	if (!isNodeOfType(node, "MemberExpression") || node.computed) return null;
+	if (!isNodeOfType(node.property, "Identifier") || node.property.name !== "current") return null;
+	const receiver = stripParenExpression(node.object);
+	return isNodeOfType(receiver, "Identifier") ? receiver.name : null;
+};
+const isRefCurrentMemberOf = (node, refName) => getRefCurrentReceiverName(node) === refName;
+const parseClearCallOnTimerRef = (node) => {
+	const clearCalleeName = getGlobalTimerCalleeName(node);
+	if (clearCalleeName === null || !TIMER_CLEANUP_CALLEE_NAMES.has(clearCalleeName)) return null;
+	if (!isNodeOfType(node, "CallExpression")) return null;
+	const clearedArgument = node.arguments?.[0];
+	if (!clearedArgument) return null;
+	const refName = getRefCurrentReceiverName(stripParenExpression(clearedArgument));
+	return refName === null ? null : {
+		clearCalleeName,
+		refName
+	};
+};
+const isClearCallOnRef = (node, refName) => parseClearCallOnTimerRef(node)?.refName === refName;
+const isNullishResetExpression = (node) => isNullishExpression(stripParenExpression(node));
+const isAssignmentToRefCurrent = (node, refName) => isNodeOfType(node, "AssignmentExpression") && node.operator === "=" && isRefCurrentMemberOf(node.left, refName);
+const isClearGuardIfIdiom = (ifStatement, refName) => {
+	if (ifStatement.alternate) return false;
+	const consequent = ifStatement.consequent;
+	return (isNodeOfType(consequent, "BlockStatement") ? consequent.body ?? [] : [consequent]).every((statement) => {
+		if (!isNodeOfType(statement, "ExpressionStatement")) return false;
+		const expression = stripParenExpression(statement.expression);
+		if (isClearCallOnRef(expression, refName)) return true;
+		return isAssignmentToRefCurrent(expression, refName) && isNullishResetExpression(expression.right);
+	});
+};
+const climbBooleanProjection = (refCurrentMember) => {
+	let cursor = refCurrentMember;
+	const logicalAncestors = [];
+	let didPassBooleanProjection = false;
+	while (cursor.parent) {
+		const parent = cursor.parent;
+		if (TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type)) {
+			cursor = parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "!") {
+			didPassBooleanProjection = true;
+			cursor = parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "BinaryExpression") && NULLISH_COMPARISON_OPERATORS.has(parent.operator) && isNullishResetExpression(parent.left === cursor ? parent.right : parent.left)) {
+			didPassBooleanProjection = true;
+			cursor = parent;
+			continue;
+		}
+		if (isNodeOfType(parent, "LogicalExpression")) {
+			logicalAncestors.push(parent);
+			cursor = parent;
+			continue;
+		}
+		break;
+	}
+	return {
+		conditionRoot: cursor,
+		logicalAncestors,
+		didPassBooleanProjection
+	};
+};
+const isLogicalClearGuardIdiom = (logicalAncestors, refName) => logicalAncestors.some((logical) => logical.operator === "&&" && isClearCallOnRef(stripParenExpression(logical.right), refName));
+const isPendingSignalRead = (refCurrentMember, refName) => {
+	const { conditionRoot, logicalAncestors, didPassBooleanProjection } = climbBooleanProjection(refCurrentMember);
+	const conditionParent = conditionRoot.parent;
+	if (isNodeOfType(conditionParent, "IfStatement") && conditionParent.test === conditionRoot) return !isClearGuardIfIdiom(conditionParent, refName);
+	if ((isNodeOfType(conditionParent, "ConditionalExpression") || isNodeOfType(conditionParent, "WhileStatement") || isNodeOfType(conditionParent, "DoWhileStatement") || isNodeOfType(conditionParent, "ForStatement")) && conditionParent.test === conditionRoot) return true;
+	if (logicalAncestors.length > 0) return !isLogicalClearGuardIdiom(logicalAncestors, refName);
+	return didPassBooleanProjection;
+};
+const collectTimerRefUsageFacts = (ownerScope, refName) => {
+	const facts = {
+		holdsScheduledTimerId: false,
+		hasPendingSignalRead: false
+	};
+	walkAst(ownerScope, (child) => {
+		if (isAssignmentToRefCurrent(child, refName)) {
+			const assignedCalleeName = getGlobalTimerCalleeName(stripParenExpression(child.right));
+			if (assignedCalleeName !== null && TIMER_CALLEE_NAMES_REQUIRING_CLEANUP.has(assignedCalleeName)) facts.holdsScheduledTimerId = true;
+			return;
+		}
+		if (isRefCurrentMemberOf(child, refName) && isPendingSignalRead(child, refName)) facts.hasPendingSignalRead = true;
+	});
+	return facts;
+};
+const isEffectCallbackFunction = (functionNode) => {
+	const parent = functionNode.parent;
+	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
+	return isHookCall$2(parent, EFFECT_HOOK_NAMES$1) && getEffectCallback(parent) === functionNode;
+};
+const doesEffectCallbackReturnName = (effectCallback, name) => {
+	if (!isFunctionLike$1(effectCallback)) return false;
+	let isReturnedByName = false;
+	walkInsideStatementBlocks(effectCallback.body, (child) => {
+		if (isReturnedByName || !isNodeOfType(child, "ReturnStatement") || !child.argument) return;
+		const returned = stripParenExpression(child.argument);
+		if (isNodeOfType(returned, "Identifier") && returned.name === name) isReturnedByName = true;
+	});
+	return isReturnedByName;
+};
+const isFunctionReturnedFromEffectCallback = (functionNode, effectCallback) => {
+	if (!isFunctionLike$1(effectCallback)) return false;
+	if (isNodeOfType(functionNode.parent, "ReturnStatement")) return true;
+	if (effectCallback.body === functionNode) return true;
+	const cleanupBindingName = getFunctionBindingName$1(functionNode);
+	return cleanupBindingName !== null && doesEffectCallbackReturnName(effectCallback, cleanupBindingName);
+};
+const isReturnedFromAnyEffectInScope = (functionNode, ownerScope) => {
+	const cleanupBindingName = getFunctionBindingName$1(functionNode);
+	if (cleanupBindingName === null) return false;
+	let isReturnedFromEffect = false;
+	walkAst(ownerScope, (child) => {
+		if (isReturnedFromEffect) return false;
+		if (!isNodeOfType(child, "CallExpression") || !isHookCall$2(child, EFFECT_HOOK_NAMES$1)) return;
+		const effectCallback = getEffectCallback(child);
+		if (effectCallback && doesEffectCallbackReturnName(effectCallback, cleanupBindingName)) isReturnedFromEffect = true;
+	});
+	return isReturnedFromEffect;
+};
+const isInsideEffectCleanupReturn = (node, ownerScope) => {
+	let functionNode = findEnclosingFunction(node);
+	while (functionNode) {
+		const outerFunction = findEnclosingFunction(functionNode);
+		if (outerFunction && isEffectCallbackFunction(outerFunction) && isFunctionReturnedFromEffectCallback(functionNode, outerFunction)) return true;
+		if (isReturnedFromAnyEffectInScope(functionNode, ownerScope)) return true;
+		functionNode = outerFunction;
+	}
+	return false;
+};
+const hasRefCurrentReassignmentAfterClear = (clearCall, refName) => {
+	const enclosingFunction = findEnclosingFunction(clearCall);
+	if (!isFunctionLike$1(enclosingFunction)) return false;
+	if (!isNodeOfType(enclosingFunction.body, "BlockStatement")) return false;
+	const clearStart = getRangeStart(clearCall);
+	if (clearStart === null) return false;
+	let didFindLaterReassignment = false;
+	walkInsideStatementBlocks(enclosingFunction.body, (child) => {
+		if (didFindLaterReassignment) return;
+		if (!isAssignmentToRefCurrent(child, refName)) return;
+		const assignmentStart = getRangeStart(child);
+		if (assignmentStart !== null && assignmentStart > clearStart) didFindLaterReassignment = true;
+	});
+	return didFindLaterReassignment;
+};
+const isShadowedTimerGlobal = (clearCall) => {
+	const callee = stripParenExpression(clearCall.callee);
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	return findVariableInitializer(callee, callee.name) !== null;
+};
+const noStaleTimerRef = defineRule({
+	id: "no-stale-timer-ref",
+	title: "Cleared timer ref keeps the stale id",
+	severity: "warn",
+	recommendation: "Reset the ref right after clearing (`clearTimeout(ref.current); ref.current = null`) so truthiness checks on the ref keep meaning “timer still pending”.",
+	create: (context) => ({ CallExpression(node) {
+		const clearCall = parseClearCallOnTimerRef(node);
+		if (!clearCall) return;
+		if (isShadowedTimerGlobal(node)) return;
+		const { clearCalleeName, refName } = clearCall;
+		const refBinding = findVariableInitializer(node, refName);
+		if (!refBinding?.initializer || !isHookCall$2(refBinding.initializer, "useRef")) return;
+		const usageFacts = collectTimerRefUsageFacts(refBinding.scopeOwner, refName);
+		if (!usageFacts.holdsScheduledTimerId || !usageFacts.hasPendingSignalRead) return;
+		if (isInsideEffectCleanupReturn(node, refBinding.scopeOwner)) return;
+		if (hasRefCurrentReassignmentAfterClear(node, refName)) return;
+		context.report({
+			node,
+			message: `\`${clearCalleeName}(${refName}.current)\` cancels the timer but leaves the old id in \`${refName}.current\`, and this component reads \`${refName}.current\` as a \u201Ctimer pending\u201D signal — assign \`${refName}.current = null\` right after clearing so a cancelled timer does not look pending.`
+		});
+	} })
+});
+//#endregion
 //#region src/plugin/utils/is-abstract-role.ts
 const isAbstractRole = (openingElement, settings) => {
 	const elementType = getElementType(openingElement, settings);
@@ -36204,6 +37834,36 @@ const isTriviallyCheapExpression = (node) => {
 	if (isNodeOfType(innerExpression, "MemberExpression")) return false;
 	return true;
 };
+const isTrivialContainerLiteral = (node) => {
+	if (!node) return false;
+	const innerExpression = stripParenExpression(node);
+	if (isNodeOfType(innerExpression, "ArrayExpression")) return (innerExpression.elements ?? []).every((element) => element !== null && isSimpleExpression(element));
+	if (isNodeOfType(innerExpression, "ObjectExpression")) return (innerExpression.properties ?? []).every((property) => isNodeOfType(property, "Property") && !property.computed && isSimpleExpression(property.value));
+	return false;
+};
+const isNonEscapingRead = (identifier) => {
+	const readRoot = findTransparentExpressionRoot(identifier);
+	const memberNode = readRoot.parent;
+	if (!isNodeOfType(memberNode, "MemberExpression") || memberNode.object !== readRoot) return false;
+	const memberUse = findTransparentExpressionRoot(memberNode);
+	const memberUseParent = memberUse.parent;
+	if (isNodeOfType(memberUseParent, "AssignmentExpression") && memberUseParent.left === memberUse) return false;
+	if (isNodeOfType(memberUseParent, "UpdateExpression")) return false;
+	if (isNodeOfType(memberUseParent, "UnaryExpression") && memberUseParent.operator === "delete") return false;
+	return !(isNodeOfType(memberUseParent, "CallExpression") && memberUseParent.callee === memberUse && !memberNode.computed && isNodeOfType(memberNode.property, "Identifier") && MUTATING_ARRAY_METHODS.has(memberNode.property.name));
+};
+const isMemoIdentityUnused = (memoCallNode, scopes) => {
+	const memoUsageRoot = findTransparentExpressionRoot(memoCallNode);
+	const parentNode = memoUsageRoot.parent;
+	if (isNodeOfType(parentNode, "ExpressionStatement")) return true;
+	if (!isNodeOfType(parentNode, "VariableDeclarator") || parentNode.init !== memoUsageRoot) return false;
+	const bindingTarget = parentNode.id;
+	if (isNodeOfType(bindingTarget, "ArrayPattern") || isNodeOfType(bindingTarget, "ObjectPattern")) return true;
+	if (!isNodeOfType(bindingTarget, "Identifier")) return false;
+	const symbol = scopes.symbolFor(bindingTarget);
+	if (!symbol) return false;
+	return symbol.references.every((reference) => reference.flag === "read" && isNonEscapingRead(reference.identifier));
+};
 const noUsememoSimpleExpression = defineRule({
 	id: "no-usememo-simple-expression",
 	title: "useMemo on a cheap value",
@@ -36225,9 +37885,17 @@ const noUsememoSimpleExpression = defineRule({
 		let returnExpression = null;
 		if (!isNodeOfType(callback.body, "BlockStatement")) returnExpression = callback.body;
 		else if (callback.body.body?.length === 1 && isNodeOfType(callback.body.body[0], "ReturnStatement")) returnExpression = callback.body.body[0].argument;
-		if (returnExpression && isTriviallyCheapExpression(returnExpression)) context.report({
+		if (!returnExpression) return;
+		if (isTriviallyCheapExpression(returnExpression)) {
+			context.report({
+				node,
+				message: "This costs more than it saves because useMemo is wrapping a value that's already cheap, so remove the useMemo"
+			});
+			return;
+		}
+		if (isTrivialContainerLiteral(returnExpression) && isMemoIdentityUnused(node, context.scopes)) context.report({
 			node,
-			message: "This costs more than it saves because useMemo is wrapping a value that's already cheap, so remove the useMemo"
+			message: "This useMemo rebuilds a tiny literal whose reference is never relied on, so remove the useMemo and build the value inline"
 		});
 	} })
 });
@@ -36333,7 +38001,7 @@ const noWillUpdateSetState = defineRule({
 		const activeLifecycleNames = isReactBelow16_3(context.settings) ? new Set(["componentWillUpdate"]) : LIFECYCLE_NAMES;
 		return { CallExpression(node) {
 			if (!isNodeOfType(node.callee, "MemberExpression")) return;
-			if (!isNodeOfType(node.callee.object, "ThisExpression")) return;
+			if (!isNodeOfType(stripParenExpression(node.callee.object), "ThisExpression")) return;
 			if (!isNodeOfType(node.callee.property, "Identifier") || node.callee.property.name !== "setState") return;
 			if (!isSetStateCallInLifecycle(node, activeLifecycleNames, { disallowInNestedFunctions: mode === "disallow-in-func" })) return;
 			context.report({
@@ -36650,6 +38318,10 @@ const isRouteFactoryCall = (expression) => {
 	}
 	return false;
 };
+const isConfigOnlyFactoryCall = (call) => call.arguments.length > 0 && call.arguments.every((argument) => {
+	const expression = skipTsExpression(argument);
+	return isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "Literal") || isNodeOfType(expression, "TemplateLiteral");
+});
 const isReactHocName = (name, state) => state.customHocs.has(name);
 const isHocCallee = (callee, state) => {
 	if (isNodeOfType(callee, "Identifier")) return isReactHocName(callee.name, state);
@@ -36689,7 +38361,7 @@ const objectExpressionBundlesComponents = (objectExpression, state) => {
 			continue;
 		}
 		if (!(!property.computed && isNodeOfType(property.key, "Identifier") && isReactComponentName(property.key.name))) continue;
-		if (isNodeOfType(value, "ArrowFunctionExpression") || isNodeOfType(value, "FunctionExpression")) return true;
+		if ((isNodeOfType(value, "ArrowFunctionExpression") || isNodeOfType(value, "FunctionExpression")) && functionContainsReactRenderOutput(value, state.scopes)) return true;
 		if (isNodeOfType(value, "CallExpression") && isHocCallee(value.callee, state) && value.arguments.length > 0) return true;
 	}
 	return false;
@@ -36797,18 +38469,22 @@ const onlyExportComponents = defineRule({
 				customHocs: new Set([...DEFAULT_REACT_HOCS, ...settings.customHOCs]),
 				allowExportNames: new Set(settings.allowExportNames),
 				allowConstantExport: settings.allowConstantExport,
-				localComponentNames
+				localComponentNames,
+				scopes: context.scopes
 			};
 			for (const child of componentCandidates) {
 				if (isNodeOfType(child, "FunctionDeclaration") && child.id) {
-					if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child)) localComponentNames.add(child.id.name);
+					if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child) && functionContainsReactRenderOutput(child, context.scopes)) localComponentNames.add(child.id.name);
 				}
 				if (isNodeOfType(child, "ClassDeclaration") && child.id) {
 					if (isReactComponentName(child.id.name) && isEs6Component(child) && !isInsideFunctionScope(child)) localComponentNames.add(child.id.name);
 				}
 				if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
 					const initializer = child.init;
-					if (isReactComponentName(child.id.name) && (canBeReactFunctionComponent(initializer, state) || (initializer ? isEs6Component(skipTsExpression(initializer)) : false)) && !isInsideFunctionScope(child)) localComponentNames.add(child.id.name);
+					if (isReactComponentName(child.id.name) && (canBeReactFunctionComponent(initializer, state) || (initializer ? isEs6Component(skipTsExpression(initializer)) : false)) && !isInsideFunctionScope(child)) {
+						const expression = initializer ? skipTsExpression(initializer) : null;
+						if (!(expression !== null && (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression"))) || functionContainsReactRenderOutput(expression, context.scopes)) localComponentNames.add(child.id.name);
+					}
 				}
 			}
 			const exports = [];
@@ -36878,6 +38554,10 @@ const onlyExportComponents = defineRule({
 							return false;
 						})();
 						if (isHoc && firstArgIsValid) hasReactExport = true;
+						else if (!isHoc && isConfigOnlyFactoryCall(stripped)) exports.push({
+							kind: "non-component",
+							reportNode: stripped
+						});
 						else context.report({
 							node: stripped,
 							message: ANONYMOUS_MESSAGE
@@ -37768,8 +39448,8 @@ const preferHtmlDialog = defineRule({
 				if (!HTML_TAGS.has(tagName)) return;
 				const roleAttribute = findJsxAttribute(node.attributes, "role");
 				if (roleAttribute) {
-					const roleValue = getJsxPropStringValue(roleAttribute);
-					if (roleValue !== null && ROLE_DIALOG_VALUES.has(roleValue)) {
+					const roleCandidates = getJsxPropStaticStringValues(roleAttribute, context.scopes);
+					if (roleCandidates !== null && roleCandidates.length > 0 && roleCandidates.every((candidate) => ROLE_DIALOG_VALUES.has(candidate))) {
 						if (focusTrapSignals && isElementFocusTrapped(node, focusTrapSignals)) return;
 						const ariaModalAttribute = findJsxAttribute(node.attributes, "aria-modal");
 						const isModal = ariaModalAttribute ? isAriaModalTrue(ariaModalAttribute) : false;
@@ -38473,11 +40153,22 @@ const getSubscriptionHandlerArgument = (subscribeCall, effectBodyStatements) =>
 	}
 	return null;
 };
+const isTrivialLiteralExpression = (expression) => {
+	if (isNodeOfType(expression, "Literal")) return true;
+	if (isNodeOfType(expression, "Identifier")) return expression.name === "undefined";
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "-") return isNodeOfType(expression.argument, "Literal");
+	if (isNodeOfType(expression, "TemplateLiteral")) return (expression.expressions?.length ?? 0) === 0;
+	return false;
+};
 const getSingleSetterCallFromHandler = (handler) => {
 	const handlerStatements = getCallbackStatements(handler);
 	if (handlerStatements.length !== 1) return null;
 	const onlyStatement = handlerStatements[0];
-	const expression = isNodeOfType(onlyStatement, "ExpressionStatement") ? onlyStatement.expression : onlyStatement;
+	let expression = onlyStatement;
+	if (isNodeOfType(onlyStatement, "ExpressionStatement")) expression = onlyStatement.expression;
+	if (isNodeOfType(onlyStatement, "ReturnStatement")) expression = onlyStatement.argument;
+	if (!expression) return null;
+	expression = stripParenExpression(expression);
 	if (!isNodeOfType(expression, "CallExpression")) return null;
 	if (!isNodeOfType(expression.callee, "Identifier")) return null;
 	if (!isSetterIdentifier(expression.callee.name)) return null;
@@ -38487,6 +40178,106 @@ const getSingleSetterCallFromHandler = (handler) => {
 		setterArgument: expression.arguments[0]
 	};
 };
+const isListenerCollectionInitializer = (init) => {
+	if (!init) return false;
+	if (isNodeOfType(init, "ArrayExpression")) return true;
+	return isNodeOfType(init, "NewExpression") && isNodeOfType(init.callee, "Identifier") && init.callee.name === "Set";
+};
+const functionRegistersParameterIntoCollection = (functionNode, listenerCollectionNames) => {
+	if (!isFunctionLike$1(functionNode)) return false;
+	const firstParam = functionNode.params?.[0];
+	if (!isNodeOfType(firstParam, "Identifier")) return false;
+	const listenerParamName = firstParam.name;
+	let registersListener = false;
+	walkAst(functionNode.body, (child) => {
+		if (registersListener) return false;
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (!isNodeOfType(child.callee, "MemberExpression")) return;
+		if (!isNodeOfType(child.callee.object, "Identifier")) return;
+		if (!listenerCollectionNames.has(child.callee.object.name)) return;
+		if (!isNodeOfType(child.callee.property, "Identifier")) return;
+		if (child.callee.property.name !== "add" && child.callee.property.name !== "push") return;
+		const registeredArgument = child.arguments?.[0];
+		if (isNodeOfType(registeredArgument, "Identifier") && registeredArgument.name === listenerParamName) registersListener = true;
+	});
+	return registersListener;
+};
+const buildModuleScopeStoreIndex = (programRoot) => {
+	const mutableBindingNames = /* @__PURE__ */ new Set();
+	const listenerCollectionNames = /* @__PURE__ */ new Set();
+	const moduleFunctionsByName = /* @__PURE__ */ new Map();
+	if (!isNodeOfType(programRoot, "Program")) return {
+		mutableBindingNames,
+		subscribeFunctionNames: /* @__PURE__ */ new Set()
+	};
+	for (const statement of programRoot.body ?? []) {
+		const unwrapped = isNodeOfType(statement, "ExportNamedDeclaration") && statement.declaration ? statement.declaration : statement;
+		if (isNodeOfType(unwrapped, "FunctionDeclaration") && unwrapped.id) {
+			moduleFunctionsByName.set(unwrapped.id.name, unwrapped);
+			continue;
+		}
+		if (!isNodeOfType(unwrapped, "VariableDeclaration")) continue;
+		for (const declarator of unwrapped.declarations ?? []) {
+			if (!isNodeOfType(declarator.id, "Identifier")) continue;
+			const init = declarator.init ?? null;
+			if ((unwrapped.kind === "let" || unwrapped.kind === "var") && init && !isFunctionLike$1(init)) {
+				mutableBindingNames.add(declarator.id.name);
+				continue;
+			}
+			if (isListenerCollectionInitializer(init)) {
+				listenerCollectionNames.add(declarator.id.name);
+				continue;
+			}
+			if (init && isFunctionLike$1(init)) moduleFunctionsByName.set(declarator.id.name, init);
+		}
+	}
+	const subscribeFunctionNames = /* @__PURE__ */ new Set();
+	for (const [functionName, functionNode] of moduleFunctionsByName) if (functionRegistersParameterIntoCollection(functionNode, listenerCollectionNames)) subscribeFunctionNames.add(functionName);
+	return {
+		mutableBindingNames,
+		subscribeFunctionNames
+	};
+};
+const getModuleStoreSnapshotName = (useStateCall, storeIndex) => {
+	if (!isNodeOfType(useStateCall, "CallExpression")) return null;
+	let initialArgument = stripParenExpression(useStateCall.arguments?.[0]);
+	if (initialArgument && isFunctionLike$1(initialArgument) && !isNodeOfType(initialArgument.body, "BlockStatement")) initialArgument = stripParenExpression(initialArgument.body);
+	if (!isNodeOfType(initialArgument, "Identifier")) return null;
+	if (!storeIndex.mutableBindingNames.has(initialArgument.name)) return null;
+	const binding = findVariableInitializer(initialArgument, initialArgument.name);
+	if (!binding || !isNodeOfType(binding.scopeOwner, "Program")) return null;
+	return initialArgument.name;
+};
+const argumentForwardsSetter = (argument, setterName) => {
+	if (!argument) return false;
+	const unwrapped = stripParenExpression(argument);
+	if (isNodeOfType(unwrapped, "Identifier")) return unwrapped.name === setterName;
+	if (!isFunctionLike$1(unwrapped)) return false;
+	let callsSetter = false;
+	walkAst(unwrapped.body, (child) => {
+		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === setterName) {
+			callsSetter = true;
+			return false;
+		}
+	});
+	return callsSetter;
+};
+const findModuleSubscribeCallForwardingSetter = (effectCallback, setterName, storeIndex) => {
+	let matchedCall = null;
+	walkAst((isFunctionLike$1(effectCallback) ? effectCallback.body : null) ?? effectCallback, (child) => {
+		if (matchedCall) return false;
+		if (!isNodeOfType(child, "CallExpression")) return;
+		if (!isNodeOfType(child.callee, "Identifier")) return;
+		if (!storeIndex.subscribeFunctionNames.has(child.callee.name)) return;
+		const binding = findVariableInitializer(child.callee, child.callee.name);
+		if (!binding || !isNodeOfType(binding.scopeOwner, "Program")) return;
+		for (const argument of child.arguments ?? []) if (argumentForwardsSetter(argument, setterName)) {
+			matchedCall = child;
+			return false;
+		}
+	});
+	return matchedCall;
+};
 const cleanupReleasesSubscription = (effectBodyStatements, boundReleaseName, boundSubscriptionName) => {
 	const lastStatement = effectBodyStatements[effectBodyStatements.length - 1];
 	if (!isNodeOfType(lastStatement, "ReturnStatement")) return false;
@@ -38503,6 +40294,16 @@ const preferUseSyncExternalStore = defineRule({
 	severity: "warn",
 	recommendation: "Replace the `useState(getSnapshot())` + `useEffect(() => store.subscribe(() => setSnapshot(getSnapshot())))` pair with `useSyncExternalStore(store.subscribe, getSnapshot)`. The hook gets this right during concurrent rendering and on the server; the hand-rolled version doesn't.",
 	create: (context) => {
+		let cachedStoreIndex = null;
+		const storeIndexFor = (node) => {
+			if (cachedStoreIndex) return cachedStoreIndex;
+			const programRoot = findProgramRoot(node);
+			cachedStoreIndex = programRoot ? buildModuleScopeStoreIndex(programRoot) : {
+				mutableBindingNames: /* @__PURE__ */ new Set(),
+				subscribeFunctionNames: /* @__PURE__ */ new Set()
+			};
+			return cachedStoreIndex;
+		};
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
 			const useStateBindings = collectUseStateBindings(componentBody);
@@ -38540,6 +40341,7 @@ const preferUseSyncExternalStore = defineRule({
 				const useStateInitializer = useStateInitializerByValueName.get(valueName);
 				if (!useStateInitializer) continue;
 				if (!areExpressionsStructurallyEqual(useStateInitializer, setterPayload.setterArgument)) continue;
+				if (isTrivialLiteralExpression(setterPayload.setterArgument)) continue;
 				if (!cleanupReleasesSubscription(effectBodyStatements, subscription.boundReleaseName, subscription.boundSubscriptionName)) continue;
 				const matchingBinding = useStateBindings.find((binding) => binding.valueName === valueName);
 				context.report({
@@ -38547,14 +40349,47 @@ const preferUseSyncExternalStore = defineRule({
 					message: `Your users can see stale or torn values because useState "${valueName}" syncs an outside store through a useEffect.`
 				});
 			}
+			checkModuleStoreShape(componentBody, useStateBindings);
+		};
+		const checkModuleStoreShape = (componentBody, useStateBindings) => {
+			const storeIndex = storeIndexFor(componentBody);
+			if (storeIndex.mutableBindingNames.size === 0) return;
+			if (storeIndex.subscribeFunctionNames.size === 0) return;
+			const snapshotBindings = useStateBindings.map((binding) => ({
+				binding,
+				storeName: isNodeOfType(binding.declarator.init, "CallExpression") ? getModuleStoreSnapshotName(binding.declarator.init, storeIndex) : null
+			})).filter((candidate) => candidate.storeName !== null);
+			if (snapshotBindings.length === 0) return;
+			const reportedDeclarators = /* @__PURE__ */ new Set();
+			for (const effectCall of findUseEffectsInComponent(componentBody)) {
+				if (!isNodeOfType(effectCall, "CallExpression")) continue;
+				if ((effectCall.arguments?.length ?? 0) < 2) continue;
+				const depsNode = effectCall.arguments[1];
+				if (!isNodeOfType(depsNode, "ArrayExpression")) continue;
+				if ((depsNode.elements?.length ?? 0) !== 0) continue;
+				const callback = getEffectCallback(effectCall);
+				if (!callback || !isFunctionLike$1(callback)) continue;
+				for (const { binding, storeName } of snapshotBindings) {
+					if (reportedDeclarators.has(binding.declarator)) continue;
+					if (!findModuleSubscribeCallForwardingSetter(callback, binding.setterName, storeIndex)) continue;
+					reportedDeclarators.add(binding.declarator);
+					context.report({
+						node: binding.declarator,
+						message: `Your users can miss updates or see torn values because useState "${binding.valueName}" snapshots module store "${storeName}" at render but only subscribes later in a useEffect.`
+					});
+				}
+			}
 		};
 		return {
 			FunctionDeclaration(node) {
-				if (!node.id?.name || !isUppercaseName(node.id.name)) return;
+				const functionName = node.id?.name;
+				if (!functionName) return;
+				if (!isUppercaseName(functionName) && !isReactHookName(functionName)) return;
 				checkComponent(node.body);
 			},
 			VariableDeclarator(node) {
-				if (!isComponentAssignment(node)) return;
+				const isHookAssignment = isNodeOfType(node.id, "Identifier") && isReactHookName(node.id.name);
+				if (!isComponentAssignment(node) && !isHookAssignment) return;
 				if (!isNodeOfType(node.init, "ArrowFunctionExpression") && !isNodeOfType(node.init, "FunctionExpression")) return;
 				checkComponent(node.init.body);
 			}
@@ -39164,7 +40999,7 @@ const queryNoVoidQueryFn = defineRule({
 		if (isNodeOfType(queryFnValue, "ArrowFunctionExpression") || isNodeOfType(queryFnValue, "FunctionExpression")) {
 			const body = queryFnValue.body;
 			if (!isNodeOfType(body, "BlockStatement")) return;
-			if ((body.body ?? []).length === 0) context.report({
+			if ((body.body ?? []).filter((statement) => !isNoOpStatement(statement)).length === 0) context.report({
 				node: queryFnProperty,
 				message: "This empty queryFn caches undefined, so the component never gets data."
 			});
@@ -39671,17 +41506,6 @@ const renderingHoistJsx = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/find-declarator-for-binding.ts
-const findDeclaratorForBinding = (bindingIdentifier) => {
-	let ancestor = bindingIdentifier.parent;
-	while (ancestor) {
-		if (isNodeOfType(ancestor, "VariableDeclarator")) return ancestor;
-		if (isNodeOfType(ancestor, "FunctionDeclaration") || isNodeOfType(ancestor, "FunctionExpression") || isNodeOfType(ancestor, "ArrowFunctionExpression") || isNodeOfType(ancestor, "Program")) return null;
-		ancestor = ancestor.parent ?? null;
-	}
-	return null;
-};
-//#endregion
 //#region src/plugin/rules/performance/rendering-hydration-mismatch-time.ts
 const NONDETERMINISTIC_RENDER_PATTERNS = [
 	{
@@ -39690,19 +41514,19 @@ const NONDETERMINISTIC_RENDER_PATTERNS = [
 	},
 	{
 		display: "Date.now()",
-		matches: (node) => isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.object, "Identifier") && node.callee.object.name === "Date" && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "now"
+		matches: (node) => isGlobalMethodCall(node, "Date", "now")
 	},
 	{
 		display: "Math.random()",
-		matches: (node) => isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.object, "Identifier") && node.callee.object.name === "Math" && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "random"
+		matches: (node) => isGlobalMethodCall(node, "Math", "random")
 	},
 	{
 		display: "performance.now()",
-		matches: (node) => isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.object, "Identifier") && node.callee.object.name === "performance" && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "now"
+		matches: (node) => isGlobalMethodCall(node, "performance", "now")
 	},
 	{
 		display: "crypto.randomUUID()",
-		matches: (node) => isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.object, "Identifier") && node.callee.object.name === "crypto" && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "randomUUID"
+		matches: (node) => isGlobalMethodCall(node, "crypto", "randomUUID")
 	}
 ];
 const findOpeningElementOfChild = (jsxNode) => {
@@ -39714,54 +41538,6 @@ const findOpeningElementOfChild = (jsxNode) => {
 	}
 	return null;
 };
-const executesDuringRender = (functionNode) => {
-	const parent = functionNode.parent;
-	if (!isNodeOfType(parent, "CallExpression")) return false;
-	if (parent.callee === functionNode) return true;
-	return isHookCall$2(parent, "useMemo") && parent.arguments?.[0] === functionNode;
-};
-const CLIENT_ONLY_FLAG_NAME_PATTERN = /^(?:is|has|did)?_?(?:client|mounted|hydrated|browser)(?:_?(?:side|ready|only))?$/i;
-const referencesClientOnlyFlag = (expression) => {
-	const unwrapped = stripParenExpression(expression);
-	if (isNodeOfType(unwrapped, "Identifier")) return CLIENT_ONLY_FLAG_NAME_PATTERN.test(unwrapped.name);
-	if (isNodeOfType(unwrapped, "MemberExpression")) {
-		const property = unwrapped.property;
-		return isNodeOfType(property, "Identifier") && CLIENT_ONLY_FLAG_NAME_PATTERN.test(property.name);
-	}
-	if (isNodeOfType(unwrapped, "UnaryExpression") && unwrapped.operator === "!") return referencesClientOnlyFlag(unwrapped.argument);
-	if (isNodeOfType(unwrapped, "LogicalExpression")) return referencesClientOnlyFlag(unwrapped.left) || referencesClientOnlyFlag(unwrapped.right);
-	return false;
-};
-const isFalsyLiteral = (node) => {
-	if (!node) return true;
-	if (isNodeOfType(node, "Literal")) return !node.value;
-	return isNodeOfType(node, "Identifier") && node.name === "undefined";
-};
-const isFalsyInitialStateBinding = (identifier) => {
-	if (!isNodeOfType(identifier, "Identifier")) return false;
-	const binding = findVariableInitializer(identifier, identifier.name);
-	if (!binding) return false;
-	const declarator = findDeclaratorForBinding(binding.bindingIdentifier);
-	if (!declarator?.init) return false;
-	const init = stripParenExpression(declarator.init);
-	if (!isHookCall$2(init, "useState") || !isNodeOfType(init, "CallExpression")) return false;
-	if (!isNodeOfType(declarator.id, "ArrayPattern")) return false;
-	if (declarator.id.elements?.[0] !== binding.bindingIdentifier) return false;
-	return isFalsyLiteral(init.arguments?.[0]);
-};
-const referencesFalsyInitialState = (expression) => flattenLogicalAndChain(stripParenExpression(expression)).some((operand) => isFalsyInitialStateBinding(stripParenExpression(operand)));
-const isGatedByFalsyInitialState = (node) => {
-	let cursor = node;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "LogicalExpression") && parent.operator === "&&" && parent.right === cursor && referencesFalsyInitialState(parent.left)) return true;
-		if (isNodeOfType(parent, "ConditionalExpression") && parent.consequent === cursor && referencesFalsyInitialState(parent.test)) return true;
-		if (isNodeOfType(parent, "IfStatement") && parent.consequent === cursor && referencesFalsyInitialState(parent.test)) return true;
-		cursor = parent;
-		parent = parent.parent ?? null;
-	}
-	return false;
-};
 const isYearOnlyDateRead = (dateNode) => {
 	const member = dateNode.parent;
 	if (!isNodeOfType(member, "MemberExpression") || member.object !== dateNode) return false;
@@ -39785,23 +41561,6 @@ const isInsideMotionTransitionAttribute = (node) => {
 	}
 	return false;
 };
-const isInsideClientOnlyGuard = (node) => {
-	let cursor = node;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "LogicalExpression") && parent.operator === "&&" && parent.right === cursor && referencesClientOnlyFlag(parent.left)) return true;
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === cursor || parent.alternate === cursor) && referencesClientOnlyFlag(parent.test)) return true;
-		if (isNodeOfType(parent, "IfStatement") && parent.consequent === cursor && referencesClientOnlyFlag(parent.test)) return true;
-		cursor = parent;
-		parent = parent.parent ?? null;
-	}
-	return false;
-};
-const hasSuppressHydrationWarningAttribute = (openingElement) => {
-	if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement")) return false;
-	for (const attr of openingElement.attributes ?? []) if (isNodeOfType(attr, "JSXAttribute") && isNodeOfType(attr.name, "JSXIdentifier") && attr.name.name === "suppressHydrationWarning") return true;
-	return false;
-};
 const renderingHydrationMismatchTime = defineRule({
 	id: "rendering-hydration-mismatch-time",
 	title: "Time or random value in JSX",
@@ -39849,6 +41608,35 @@ const renderingHydrationMismatchTime = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/contains-locale-environment-read.ts
+const LOCALE_ENVIRONMENT_METHOD_NAMES = new Set([
+	"toLocaleString",
+	"toLocaleDateString",
+	"toLocaleTimeString",
+	"getTimezoneOffset"
+]);
+const containsLocaleEnvironmentRead = (expression) => {
+	let readsLocaleEnvironment = false;
+	walkAst(expression, (child) => {
+		if (readsLocaleEnvironment) return false;
+		if (isNodeOfType(child, "MemberExpression") && isNodeOfType(child.object, "Identifier")) {
+			if (child.object.name === "Intl") {
+				readsLocaleEnvironment = true;
+				return false;
+			}
+			if (child.object.name === "navigator" && isNodeOfType(child.property, "Identifier") && (child.property.name === "language" || child.property.name === "languages")) {
+				readsLocaleEnvironment = true;
+				return false;
+			}
+		}
+		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "MemberExpression") && !child.callee.computed && isNodeOfType(child.callee.property, "Identifier") && LOCALE_ENVIRONMENT_METHOD_NAMES.has(child.callee.property.name)) {
+			readsLocaleEnvironment = true;
+			return false;
+		}
+	});
+	return readsLocaleEnvironment;
+};
+//#endregion
 //#region src/plugin/rules/performance/rendering-hydration-no-flicker.ts
 const USE_EFFECT_ONLY = new Set(["useEffect"]);
 const argumentsReadRefCurrent = (callArguments) => callArguments.some((argument) => {
@@ -39914,14 +41702,15 @@ const renderingHydrationNoFlicker = defineRule({
 		if (!isNodeOfType(depsNode, "ArrayExpression") || depsNode.elements?.length !== 0) return;
 		const callback = getEffectCallback(node);
 		if (!callback || !isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return;
-		const bodyStatements = isNodeOfType(callback.body, "BlockStatement") ? callback.body.body : [callback.body];
-		if (!bodyStatements || bodyStatements.length !== 1) return;
+		const bodyStatements = (isNodeOfType(callback.body, "BlockStatement") ? callback.body.body ?? [] : [callback.body]).filter((statement) => !isNoOpStatement(statement));
+		if (bodyStatements.length !== 1) return;
 		const soleStatement = bodyStatements[0];
 		if (!isNodeOfType(soleStatement, "ExpressionStatement")) return;
 		const expression = soleStatement.expression;
 		if (isSetterCall(expression) && isNodeOfType(expression, "CallExpression") && isNodeOfType(expression.callee, "Identifier") && isUseStateSetterInScope(expression, expression.callee.name)) {
 			if (argumentsReadRefCurrent(expression.arguments ?? [])) return;
 			if (isStateUsedOnlyInIdOrAriaAttributes(expression, expression.callee.name)) return;
+			if ((expression.arguments ?? []).some(containsLocaleEnvironmentRead)) return;
 			context.report({
 				node,
 				message: "This flashes for your users because useEffect(setState, []) runs after the first paint, so use useSyncExternalStore, or add suppressHydrationWarning"
@@ -40740,6 +42529,9 @@ const rerenderFunctionalSetstate = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/is-trivial-built-in-construction.ts
+const isTrivialBuiltInConstruction = (expression) => isNodeOfType(expression, "NewExpression") && isNodeOfType(expression.callee, "Identifier") && TRIVIAL_CONSTRUCTOR_NAMES.has(expression.callee.name) && (expression.arguments ?? []).length === 0;
+//#endregion
 //#region src/plugin/rules/state-and-effects/rerender-lazy-ref-init.ts
 const rerenderLazyRefInit = defineRule({
 	id: "rerender-lazy-ref-init",
@@ -40750,7 +42542,7 @@ const rerenderLazyRefInit = defineRule({
 	recommendation: "Initialize the ref lazily so expensive values are not rebuilt and discarded on every render.",
 	create: (context) => ({ CallExpression(node) {
 		if (!isHookCall$2(node, "useRef") || !node.arguments?.length) return;
-		const initializer = node.arguments[0];
+		const initializer = stripParenExpression(node.arguments[0]);
 		const isPlainCall = isNodeOfType(initializer, "CallExpression");
 		const isNewCall = isNodeOfType(initializer, "NewExpression");
 		if (!isPlainCall && !isNewCall) return;
@@ -40758,7 +42550,7 @@ const rerenderLazyRefInit = defineRule({
 		const memberPropertyName = isNodeOfType(callee, "MemberExpression") && (isNodeOfType(callee.property, "Identifier") || isNodeOfType(callee.property, "PrivateIdentifier")) ? callee.property.name : null;
 		const calleeName = isNodeOfType(callee, "Identifier") ? callee.name : memberPropertyName ?? "fn";
 		if (TRIVIAL_INITIALIZER_NAMES.has(calleeName)) return;
-		if (isNewCall && TRIVIAL_CONSTRUCTOR_NAMES.has(calleeName)) return;
+		if (isTrivialBuiltInConstruction(initializer)) return;
 		if (isPlainCall && isReactHookName(calleeName)) return;
 		const callShape = isNewCall ? `new ${calleeName}()` : `${calleeName}()`;
 		context.report({
@@ -40794,11 +42586,11 @@ const TRIVIAL_DATE_GETTER_NAMES = new Set([
 const EAGER_CALL_RESOLUTION_DEPTH_LIMIT = 4;
 const findEagerInitializerCall = (expression, depth = 0) => {
 	if (depth > EAGER_CALL_RESOLUTION_DEPTH_LIMIT) return null;
-	if (isNodeOfType(expression, "CallExpression") || isNodeOfType(expression, "NewExpression")) return expression;
-	if (isNodeOfType(expression, "ChainExpression")) return findEagerInitializerCall(expression.expression, depth + 1);
-	if (isNodeOfType(expression, "LogicalExpression")) return findEagerInitializerCall(expression.left, depth + 1);
-	if (isNodeOfType(expression, "MemberExpression")) return findEagerInitializerCall(expression.object, depth + 1);
-	if (isNodeOfType(expression, "ArrayExpression")) for (const element of expression.elements ?? []) {
+	const innerExpression = stripParenExpression(expression);
+	if (isNodeOfType(innerExpression, "CallExpression") || isNodeOfType(innerExpression, "NewExpression")) return innerExpression;
+	if (isNodeOfType(innerExpression, "LogicalExpression")) return findEagerInitializerCall(innerExpression.left, depth + 1);
+	if (isNodeOfType(innerExpression, "MemberExpression")) return findEagerInitializerCall(innerExpression.object, depth + 1);
+	if (isNodeOfType(innerExpression, "ArrayExpression")) for (const element of innerExpression.elements ?? []) {
 		if (!element || !isNodeOfType(element, "SpreadElement")) continue;
 		const spreadCall = findEagerInitializerCall(element.argument, depth + 1);
 		if (spreadCall) return spreadCall;
@@ -40821,7 +42613,7 @@ const rerenderLazyStateInit = defineRule({
 		const memberPropertyName = isNodeOfType(callee, "MemberExpression") && (isNodeOfType(callee.property, "Identifier") || isNodeOfType(callee.property, "PrivateIdentifier")) ? callee.property.name : null;
 		const calleeName = isNodeOfType(callee, "Identifier") ? callee.name : memberPropertyName ?? "fn";
 		if (TRIVIAL_INITIALIZER_NAMES.has(calleeName)) return;
-		if (isConstructor && TRIVIAL_CONSTRUCTOR_NAMES.has(calleeName)) return;
+		if (isTrivialBuiltInConstruction(initializer)) return;
 		if (memberPropertyName && (initializer.arguments ?? []).length === 0 && TRIVIAL_DATE_GETTER_NAMES.has(memberPropertyName)) return;
 		if (isReactHookName(calleeName)) return;
 		const callDescription = isConstructor ? `new ${calleeName}()` : `${calleeName}()`;
@@ -41488,7 +43280,7 @@ const rnAnimationReactionAsDerived = defineRule({
 		const body = reactionFn.body;
 		let singleAssignment = null;
 		if (isNodeOfType(body, "BlockStatement")) {
-			const statements = body.body ?? [];
+			const statements = (body.body ?? []).filter((statement) => !isNoOpStatement(statement));
 			if (statements.length !== 1) return;
 			const onlyStatement = statements[0];
 			if (!isNodeOfType(onlyStatement, "ExpressionStatement")) return;
@@ -41562,7 +43354,8 @@ const PROMISE_SETTLE_METHODS = new Set([
 	"catch",
 	"finally"
 ]);
-const findChainRoot = (node) => {
+const findChainRoot = (wrappedNode) => {
+	const node = stripParenExpression(wrappedNode);
 	if (isNodeOfType(node, "CallExpression")) {
 		if (isNodeOfType(node.callee, "Identifier")) return {
 			calleeName: node.callee.name,
@@ -42116,7 +43909,7 @@ const rnNoDeprecatedModules = defineRule({
 		for (const specifier of node.specifiers ?? []) {
 			if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
 			if (specifier.importKind === "type") continue;
-			const importedName = getImportedName$1(specifier);
+			const importedName = getImportedName(specifier);
 			if (!importedName) continue;
 			if (!DEPRECATED_RN_MODULE_REPLACEMENTS.get(importedName)) continue;
 			context.report({
@@ -42150,20 +43943,21 @@ const isBindingReactNativeDimensions = (node, binding, localName) => {
 };
 const isReactNativeDimensionsCallee = (node, callee) => {
 	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	if (isNodeOfType(callee.object, "Identifier")) {
-		const localName = callee.object.name;
+	const receiver = stripParenExpression(callee.object);
+	if (isNodeOfType(receiver, "Identifier")) {
+		const localName = receiver.name;
 		const binding = findVariableInitializer(node, localName);
 		if (binding !== null) return isBindingReactNativeDimensions(node, binding, localName);
 		return localName === "Dimensions";
 	}
-	if (isNodeOfType(callee.object, "MemberExpression") && !callee.object.computed && isNodeOfType(callee.object.property, "Identifier") && callee.object.property.name === "Dimensions") {
-		if (getInitializerModuleSource(node, callee.object.object) === REACT_NATIVE_MODULE) return true;
-		const rootName = getRootIdentifierName(callee.object.object);
+	if (isNodeOfType(receiver, "MemberExpression") && !receiver.computed && isNodeOfType(receiver.property, "Identifier") && receiver.property.name === "Dimensions") {
+		if (getInitializerModuleSource(node, receiver.object) === REACT_NATIVE_MODULE) return true;
+		const rootName = getRootIdentifierName(receiver.object);
 		if (rootName === null) return false;
 		const importBinding = getImportBindingForName(node, rootName);
 		return importBinding !== null && importBinding.isNamespace && importBinding.source === REACT_NATIVE_MODULE;
 	}
-	if (getRequireCallSource(callee.object) === REACT_NATIVE_MODULE) return isNodeOfType(callee.object, "MemberExpression") && !callee.object.computed && isNodeOfType(callee.object.property, "Identifier") && callee.object.property.name === "Dimensions";
+	if (getRequireCallSource(receiver) === REACT_NATIVE_MODULE) return isNodeOfType(receiver, "MemberExpression") && !receiver.computed && isNodeOfType(receiver.property, "Identifier") && receiver.property.name === "Dimensions";
 	return false;
 };
 const STYLE_FACTORY_CALLEE_PATTERN$1 = /(?:^|\.)(?:make|create)(?:Use)?Styles$/;
@@ -42607,7 +44401,8 @@ const rnNoLegacyShadowStyles = defineRule({
 			},
 			CallExpression(node) {
 				if (!isNodeOfType(node.callee, "MemberExpression")) return;
-				if (!isNodeOfType(node.callee.object, "Identifier") || node.callee.object.name !== "StyleSheet") return;
+				const receiver = stripParenExpression(node.callee.object);
+				if (!isNodeOfType(receiver, "Identifier") || receiver.name !== "StyleSheet") return;
 				if (!isMemberProperty(node.callee, "create")) return;
 				const stylesArgument = node.arguments?.[0];
 				if (!isNodeOfType(stylesArgument, "ObjectExpression")) return;
@@ -42666,7 +44461,7 @@ const rnNoPanresponder = defineRule({
 		for (const specifier of node.specifiers ?? []) {
 			if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
 			if (specifier.importKind === "type") continue;
-			if (getImportedName$1(specifier) !== "PanResponder") continue;
+			if (getImportedName(specifier) !== "PanResponder") continue;
 			context.report({
 				node: specifier,
 				message: "PanResponder runs gesture handling on the JS thread, which stutters under load. Use react-native-gesture-handler (`Gesture.Pan()`) so gestures run on the native UI thread."
@@ -43457,7 +45252,7 @@ const rnNoSetNativeProps = defineRule({
 		const callee = node.callee;
 		if (!isStaticMemberNamed(callee, "setNativeProps")) return;
 		if (!isNodeOfType(callee, "MemberExpression")) return;
-		if (!isStaticMemberNamed(callee.object, "current")) return;
+		if (!isStaticMemberNamed(stripParenExpression(callee.object), "current")) return;
 		context.report({
 			node,
 			message: "`setNativeProps` is a silent no-op under the New Architecture (Fabric), so this imperative update won't change the view. Drive the prop via state, an Animated.Value, or a Reanimated shared value."
@@ -43596,7 +45391,7 @@ const rnPreferExpoImage = defineRule({
 				for (const specifier of node.specifiers ?? []) {
 					if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
 					if (specifier.importKind === "type") continue;
-					const importedName = getImportedName$1(specifier);
+					const importedName = getImportedName(specifier);
 					if (importedName !== "Image" && importedName !== "ImageBackground") continue;
 					flaggedImports.push({
 						localName: specifier.local.name,
@@ -43658,7 +45453,7 @@ const rnPreferPressable = defineRule({
 		for (const specifier of node.specifiers ?? []) {
 			if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
 			if (specifier.importKind === "type") continue;
-			const importedName = getImportedName$1(specifier);
+			const importedName = getImportedName(specifier);
 			if (!importedName || !TOUCHABLE_COMPONENTS.has(importedName)) continue;
 			context.report({
 				node: specifier,
@@ -43685,14 +45480,15 @@ const analyzeGestureChain = (expression) => {
 		if (!isNodeOfType(callee, "MemberExpression")) return null;
 		if (!isNodeOfType(callee.property, "Identifier")) return null;
 		const methodName = callee.property.name;
-		if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Gesture") return {
+		const receiver = stripParenExpression(callee.object);
+		if (isNodeOfType(receiver, "Identifier") && receiver.name === "Gesture") return {
 			factoryName: methodName,
 			chainMethodNames,
 			numberOfTapsArgument
 		};
 		if (methodName === "numberOfTaps" && numberOfTapsArgument === null && callExpression.arguments?.length === 1) numberOfTapsArgument = callExpression.arguments[0] ?? null;
 		chainMethodNames.push(methodName);
-		cursor = callee.object;
+		cursor = receiver;
 	}
 	return null;
 };
@@ -43759,7 +45555,7 @@ const rnPreferReanimated = defineRule({
 		for (const specifier of node.specifiers ?? []) {
 			if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
 			if (specifier.importKind === "type") continue;
-			const importedName = getImportedName$1(specifier);
+			const importedName = getImportedName(specifier);
 			if (!importedName || !JS_THREAD_ANIMATION_IMPORTS.has(importedName)) continue;
 			const suggestion = importedName === "LayoutAnimation" ? "Your users see stutter when LayoutAnimation runs on the JS thread." : "Your users see stutter when Animated from react-native runs on the JS thread.";
 			context.report({
@@ -44217,9 +46013,9 @@ const roleHasRequiredAriaProps = defineRule({
 		if (!HTML_TAGS.has(elementType)) return;
 		const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
 		if (!roleAttribute) return;
-		const roleValue = getJsxPropStringValue(roleAttribute);
-		if (roleValue === null) return;
-		const roles = roleValue.split(/\s+/).filter((token) => token.length > 0);
+		const roleCandidates = getJsxPropStaticStringValues(roleAttribute, context.scopes);
+		if (roleCandidates === null) return;
+		const roles = new Set(roleCandidates.flatMap((candidate) => candidate.split(/\s+/).filter((token) => token.length > 0)));
 		for (const role of roles) {
 			const required = ROLE_REQUIRED_PROPS.get(role);
 			if (!required) continue;
@@ -47336,7 +49132,9 @@ const ROLE_SUPPORTS_ARIA_PROPS = {
 };
 //#endregion
 //#region src/plugin/rules/a11y/role-supports-aria-props.ts
-const buildMessageDefault = (role, propName) => `Screen reader users get no help from \`${propName}\` because role \`${role}\` ignores it, so remove it or change the role.`;
+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.`;
+};
 const buildMessageImplicit = (role, propName, elementType) => `Screen reader users get no help from \`${propName}\` because \`${elementType}\` has role \`${role}\`, which ignores it, so remove \`${propName}\` or change the element.`;
 const roleSupportsAriaProps = defineRule({
 	id: "role-supports-aria-props",
@@ -47356,6 +49154,8 @@ const roleSupportsAriaProps = defineRule({
 			const propName = propRawName.toLowerCase();
 			if (!propName.startsWith("aria-")) continue;
 			if (!ARIA_PROPERTIES.has(propName)) continue;
+			const attributeValue = attributeNode.value;
+			if (attributeValue && isNodeOfType(attributeValue, "JSXExpressionContainer") && isNullishExpression(attributeValue.expression)) continue;
 			(ariaAttributes ??= []).push({
 				attribute,
 				propName
@@ -47364,17 +49164,21 @@ const roleSupportsAriaProps = defineRule({
 		if (!ariaAttributes) return;
 		const elementType = getElementType(node, context.settings);
 		const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
-		const role = roleAttribute ? getJsxPropStringValue(roleAttribute) : getImplicitRole(node, elementType);
-		if (!role) return;
-		if (!VALID_ARIA_ROLES.has(role)) return;
+		const roleCandidates = roleAttribute ? getJsxPropStaticStringValues(roleAttribute, context.scopes) : [getImplicitRole(node, elementType)].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);
+		}
 		const isImplicit = !roleAttribute;
-		const supported = ROLE_SUPPORTS_ARIA_PROPS[role];
-		if (!supported) return;
 		for (const { attribute, propName } of ariaAttributes) {
-			if (supported.has(propName)) continue;
+			if (supportedSets.some((supported) => supported.has(propName))) continue;
 			context.report({
 				node: attribute,
-				message: isImplicit ? buildMessageImplicit(role, propName, elementType) : buildMessageDefault(role, propName)
+				message: isImplicit ? buildMessageImplicit(roleCandidates[0], propName, elementType) : buildMessageDefault(roleCandidates, propName)
 			});
 		}
 	} })
@@ -47721,21 +49525,6 @@ const isInsideLoop = (descendant, ancestor) => {
 	}
 	return false;
 };
-const isUseEffectEventSymbol = (symbol) => {
-	const initializer = symbol.initializer;
-	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	return getHookNameFromCallee(initializer.callee) === "useEffectEvent";
-};
-const resolvesToLocalNonImportBinding = (identifier, scopes) => {
-	const symbol = scopes.referenceFor(identifier)?.resolvedSymbol;
-	return Boolean(symbol && symbol.kind !== "import");
-};
-const isNonReactEffectEventCallee = (callee, contextNode, scopes) => isNodeOfType(callee, "Identifier") && (isImportedFromNonReactModule(contextNode, callee.name) || resolvesToLocalNonImportBinding(callee, scopes));
-const isNonReactEffectEventSymbol = (symbol, contextNode, scopes) => {
-	const initializer = symbol.initializer;
-	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	return isNonReactEffectEventCallee(initializer.callee, contextNode, scopes);
-};
 const findEnclosingComponentOrHookFunction = (node) => {
 	let current = node.parent;
 	while (current) {
@@ -47925,8 +49714,7 @@ const rulesOfHooks = defineRule({
 			},
 			Identifier(node) {
 				const symbol = context.scopes.referenceFor(node)?.resolvedSymbol;
-				if (!symbol || !isUseEffectEventSymbol(symbol)) return;
-				if (isNonReactEffectEventSymbol(symbol, node, context.scopes)) return;
+				if (!symbol || !symbolHasReactUseEffectEventOrigin(symbol, context.scopes)) return;
 				if (!isSameComponentOrHookScope(symbol, node)) return;
 				if (isInsideAllowedEffectEventCallback(node, additionalEffectHooksRegex)) return;
 				context.report({
@@ -48074,7 +49862,8 @@ const serverAfterNonblocking = defineRule({
 				if (!fileHasUseServerDirective && serverFunctionDepth === 0) return;
 				if (!isNodeOfType(node.callee, "MemberExpression")) return;
 				if (!isNodeOfType(node.callee.property, "Identifier")) return;
-				const objectName = isNodeOfType(node.callee.object, "Identifier") ? node.callee.object.name : null;
+				const receiver = stripParenExpression(node.callee.object);
+				const objectName = isNodeOfType(receiver, "Identifier") ? receiver.name : null;
 				if (!objectName) return;
 				const methodName = node.callee.property.name;
 				if (!isDeferrableSideEffectCall(objectName, methodName)) return;
@@ -48750,7 +50539,17 @@ const getMemberPropertyName$1 = (memberExpression) => {
 };
 const ascendMemberChain = (referenceIdentifier) => {
 	let chainTip = referenceIdentifier;
-	while (chainTip.parent && isNodeOfType(chainTip.parent, "MemberExpression") && chainTip.parent.object === chainTip) chainTip = chainTip.parent;
+	while (chainTip.parent) {
+		if (TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(chainTip.parent.type) && "expression" in chainTip.parent && chainTip.parent.expression === chainTip) {
+			chainTip = chainTip.parent;
+			continue;
+		}
+		if (isNodeOfType(chainTip.parent, "MemberExpression") && chainTip.parent.object === chainTip) {
+			chainTip = chainTip.parent;
+			continue;
+		}
+		break;
+	}
 	return chainTip;
 };
 const isDirectContentsMutation = (referenceIdentifier) => {
@@ -48775,7 +50574,8 @@ const isMutatedThroughCallArgument = (referenceIdentifier, scopes, mayFollowCall
 	const callee = callExpression.callee;
 	if (isNodeOfType(callee, "MemberExpression")) {
 		const methodName = getMemberPropertyName$1(callee);
-		return Boolean(isNodeOfType(callee.object, "Identifier") && callee.object.name === "Object" && methodName !== null && OBJECT_MUTATING_METHODS.has(methodName) && referenceArgumentIndex === 0);
+		const calleeReceiver = stripParenExpression(callee.object);
+		return Boolean(isNodeOfType(calleeReceiver, "Identifier") && calleeReceiver.name === "Object" && methodName !== null && OBJECT_MUTATING_METHODS.has(methodName) && referenceArgumentIndex === 0);
 	}
 	if (!mayFollowCalleeHop || !isNodeOfType(callee, "Identifier")) return false;
 	const calleeSymbol = scopes.symbolFor(callee);
@@ -49505,7 +51305,7 @@ const walkServerFnChain = (outerNode) => {
 	};
 	if (!isNodeOfType(outerNode, "CallExpression")) return result;
 	if (!isNodeOfType(outerNode.callee, "MemberExpression")) return result;
-	let currentNode = outerNode.callee.object;
+	let currentNode = stripParenExpression(outerNode.callee.object);
 	while (isNodeOfType(currentNode, "CallExpression")) {
 		const calleeName = getCalleeName$2(currentNode);
 		if (calleeName && TANSTACK_SERVER_FN_NAMES.has(calleeName)) {
@@ -49516,7 +51316,7 @@ const walkServerFnChain = (outerNode) => {
 			}
 		}
 		if (calleeName && TANSTACK_INPUT_VALIDATOR_METHOD_NAMES.has(calleeName)) result.hasInputValidation = true;
-		if (isNodeOfType(currentNode.callee, "MemberExpression")) currentNode = currentNode.callee.object;
+		if (isNodeOfType(currentNode.callee, "MemberExpression")) currentNode = stripParenExpression(currentNode.callee.object);
 		else break;
 	}
 	return result;
@@ -50169,7 +51969,7 @@ const tanstackStartServerFnMethodOrder = defineRule({
 		while (isNodeOfType(currentNode, "CallExpression") && isNodeOfType(currentNode.callee, "MemberExpression")) {
 			const methodName = isNodeOfType(currentNode.callee.property, "Identifier") ? currentNode.callee.property.name : null;
 			if (methodName) methodNames.unshift(methodName);
-			currentNode = currentNode.callee.object;
+			currentNode = stripParenExpression(currentNode.callee.object);
 		}
 		if (isNodeOfType(currentNode, "CallExpression") && isNodeOfType(currentNode.callee, "Identifier")) {
 			if (!TANSTACK_SERVER_FN_NAMES.has(currentNode.callee.name)) return;
@@ -50389,7 +52189,7 @@ const useLazyMotion = defineRule({
 		if (node.specifiers?.some((specifier) => {
 			if (!isNodeOfType(specifier, "ImportSpecifier")) return false;
 			if (specifier.importKind === "type") return false;
-			return getImportedName$1(specifier) === "motion";
+			return getImportedName(specifier) === "motion";
 		})) context.report({
 			node,
 			message: "Importing \"motion\" ships about 30 kb of extra code and slows page load. Use \"m\" with LazyMotion instead."
@@ -51416,6 +53216,18 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...displayName.requires ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/effect-listener-cleanup-mismatch",
+		id: "effect-listener-cleanup-mismatch",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...effectListenerCleanupMismatch,
+			framework: "global",
+			category: "Bugs",
+			requires: [...new Set(["react", ...effectListenerCleanupMismatch.requires ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/effect-needs-cleanup",
 		id: "effect-needs-cleanup",
@@ -53251,6 +55063,18 @@ const reactDoctorRules = [
 			category: "Bugs"
 		}
 	},
+	{
+		key: "react-doctor/no-locale-format-in-render",
+		id: "no-locale-format-in-render",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noLocaleFormatInRender,
+			framework: "global",
+			category: "Bugs",
+			requires: [...new Set(["react", ...noLocaleFormatInRender.requires ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/no-long-transition-duration",
 		id: "no-long-transition-duration",
@@ -53679,6 +55503,18 @@ const reactDoctorRules = [
 			category: "Maintainability"
 		}
 	},
+	{
+		key: "react-doctor/no-stale-timer-ref",
+		id: "no-stale-timer-ref",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...noStaleTimerRef,
+			framework: "global",
+			category: "Bugs",
+			requires: [...new Set(["react", ...noStaleTimerRef.requires ?? []])]
+		}
+	},
 	{
 		key: "react-doctor/no-static-element-interactions",
 		id: "no-static-element-interactions",
@@ -56127,6 +57963,7 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"nextjs-no-use-search-params-without-suspense",
 	"no-dynamic-import-path",
 	"no-full-lodash-import",
+	"no-locale-format-in-render",
 	"no-mutating-reducer-state",
 	"prefer-dynamic-import",
 	"rendering-hydration-mismatch-time",
@@ -56261,6 +58098,7 @@ const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 	["nextjs-no-use-search-params-without-suspense", collectNextjsSearchParamsDependencies],
 	["no-dynamic-import-path", collectNearestManifestDependencies],
 	["no-full-lodash-import", collectNearestManifestDependencies],
+	["no-locale-format-in-render", collectNearestManifestDependencies],
 	["no-mutating-reducer-state", collectMutatingReducerDependencies],
 	["prefer-dynamic-import", collectNearestManifestDependencies],
 	["rendering-hydration-mismatch-time", collectNearestManifestDependencies],