oxlint-plugin-react-doctor 0.7.2-dev.08b768b → 0.7.2-dev.0eb5293

package/dist/index.js

@@ -532,12 +532,6 @@ 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",
@@ -601,19 +595,6 @@ const TRIVIAL_INITIALIZER_NAMES = new Set([
 	"parseInt",
 	"parseFloat"
 ]);
-const TRIVIAL_CONSTRUCTOR_NAMES = new Set([
-	"Date",
-	"Map",
-	"Set",
-	"WeakMap",
-	"WeakSet",
-	"WeakRef",
-	"RegExp",
-	"Error",
-	"URL",
-	"URLSearchParams",
-	"AbortController"
-]);
 const TRIVIAL_DERIVATION_CALLEE_NAMES = new Set([
 	"Boolean",
 	"String",
@@ -693,10 +674,7 @@ const GLOBAL_RELEASE_METHOD_NAMES = new Set([
 	"unwatch",
 	"unlisten",
 	"unsub",
-	"abort",
-	"disconnect",
-	"unobserve",
-	"close"
+	"abort"
 ]);
 const BOUND_RESOURCE_RELEASE_METHOD_NAMES = new Set([
 	"remove",
@@ -2257,38 +2235,6 @@ 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;
-		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.";
@@ -2318,11 +2264,28 @@ const isInvalidHref = (value, validHrefs) => {
 	if (validHrefs.has(value)) return false;
 	return value === "" || value === "#" || value === "javascript:void(0)";
 };
-const isNullishOrFragmentHref = (value) => {
+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;
 	if (isNodeOfType(value, "JSXExpressionContainer")) {
 		const expression = value.expression;
 		if (isNodeOfType(expression, "Identifier") && expression.name === "undefined") return true;
-		if (isNodeOfType(expression, "Literal") && expression.value === null) 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(value, "JSXFragment")) return true;
 	return false;
@@ -2355,10 +2318,9 @@ const anchorIsValid = defineRule({
 					});
 					return;
 				}
-				const hrefCandidates = getJsxPropStaticStringValues(hrefAttribute, context.scopes);
-				if (hrefCandidates !== null ? hrefCandidates.length > 0 && hrefCandidates.every((candidate) => isInvalidHref(candidate, settings.validHrefs)) : isNullishOrFragmentHref(hrefAttribute.value)) {
+				if (checkValueIsEmptyOrInvalid(hrefAttribute.value, settings.validHrefs)) {
 					const hasOnClick = Boolean(hasJsxPropIgnoreCase(node.attributes, "onClick"));
-					if (!hasOnClick && hrefCandidates?.every((candidate) => candidate === "#")) return;
+					if (!hasOnClick && getStaticHrefValue(hrefAttribute.value) === "#") return;
 					context.report({
 						node: node.name,
 						message: hasOnClick ? MESSAGE_CANT_BE_ANCHOR : MESSAGE_INCORRECT_HREF
@@ -3414,25 +3376,6 @@ 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({
@@ -3449,7 +3392,22 @@ const ariaRole = defineRule({
 					});
 					return;
 				}
-				reportFirstInvalidCandidate([value.value]);
+				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;
+				}
 				return;
 			}
 			if (isNodeOfType(value, "JSXExpressionContainer")) {
@@ -3470,11 +3428,6 @@ const ariaRole = defineRule({
 					});
 					return;
 				}
-				const resolvedCandidates = getJsxPropStaticStringValues(roleAttribute, context.scopes);
-				if (resolvedCandidates !== null) {
-					reportFirstInvalidCandidate(resolvedCandidates);
-					return;
-				}
 				return;
 			}
 			context.report({
@@ -7657,95 +7610,6 @@ const displayName = defineRule({
 	}
 });
 //#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/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/utils/walk-inside-statement-blocks.ts
 const walkInsideStatementBlocks = (node, visitor) => {
 	if (!node || typeof node !== "object") return;
@@ -7897,17 +7761,6 @@ 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;
@@ -7919,14 +7772,6 @@ 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({
@@ -7936,7 +7781,7 @@ const findSubscribeLikeUsages = (callback) => {
 			});
 			return;
 		}
-		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({
+		if (isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && SUBSCRIPTION_METHOD_NAMES.has(child.callee.property.name)) usages.push({
 			kind: "subscribe",
 			node: child,
 			resourceName: child.callee.property.name
@@ -7959,12 +7804,7 @@ const collectCleanupBindings = (effectCallback) => {
 			const bindingName = declarator.id.name;
 			bindings.effectScopeVariableNames.add(bindingName);
 			const init = declarator.init;
-			if (!init) continue;
-			if (isSocketConstruction(init)) {
-				bindings.subscriptionNames.add(bindingName);
-				continue;
-			}
-			if (!isNodeOfType(init, "CallExpression")) continue;
+			if (!init || !isNodeOfType(init, "CallExpression")) continue;
 			if (isSubscribeLikeCallExpression(init)) {
 				bindings.subscriptionNames.add(bindingName);
 				if (isCleanupReturningSubscribeLikeCallExpression(init)) bindings.cleanupFunctionNames.add(bindingName);
@@ -8016,168 +7856,26 @@ const effectHasCleanupReturn = (callback, usages) => {
 	});
 	return didFindCleanupReturn;
 };
-const EMPTY_NAME_SET$1 = /* @__PURE__ */ new Set();
-const hasSelfReleasingListenerOptions = (node) => isNodeOfType(node, "CallExpression") && (node.arguments ?? []).some((argument) => isNodeOfType(argument, "ObjectExpression") && (argument.properties ?? []).some((property) => isNodeOfType(property, "Property") && isNodeOfType(property.key, "Identifier") && (property.key.name === "signal" || property.key.name === "once" && isNodeOfType(property.value, "Literal") && property.value.value === true)));
-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;
-	let leak = null;
-	walkAst(body, (child) => {
-		if (leak !== null) return false;
-		if (isFunctionLike$1(child)) return false;
-		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, `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 = 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);
-			}
-		};
-	}
+	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.`
+		});
+	} })
 });
 //#endregion
 //#region src/plugin/semantic/scope-analysis.ts
@@ -8736,6 +8434,17 @@ 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;
@@ -9907,7 +9616,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 });
 //#endregion
 //#region src/plugin/rules/react-native/expo-no-non-inlined-env.ts
-const EMPTY_VISITORS$6 = {};
+const EMPTY_VISITORS$5 = {};
 const NODE_OR_BUILD_FILE = /(\.config\.[cm]?[jt]sx?$)|((^|\/)(scripts|tools|tooling|cli|bin)\/)|(\+(api|html)\.[cm]?[jt]sx?$)|(\.server\.[cm]?[jt]sx?$)|(\.(test|spec)\.[cm]?[jt]sx?$)|((^|\/)__tests__\/)|(\.e2e\.[cm]?[jt]sx?$)/;
 const isNonExpoPublicLiteralKey = (key) => isNodeOfType(key, "Literal") && typeof key.value === "string" && !key.value.startsWith("EXPO_PUBLIC_");
 const isProcessEnv = (node) => isNodeOfType(node, "MemberExpression") && !node.computed && isNodeOfType(node.object, "Identifier") && node.object.name === "process" && isNodeOfType(node.property, "Identifier") && node.property.name === "env";
@@ -9919,7 +9628,7 @@ const expoNoNonInlinedEnv = defineRule({
 	recommendation: "Read env vars with static dotted access (`process.env.EXPO_PUBLIC_NAME`). Computed access and destructuring aren't inlined by babel-preset-expo and resolve to `undefined` at runtime.",
 	create: (context) => {
 		const filename = normalizeFilename(context.filename ?? "");
-		if (filename && NODE_OR_BUILD_FILE.test(filename)) return EMPTY_VISITORS$6;
+		if (filename && NODE_OR_BUILD_FILE.test(filename)) return EMPTY_VISITORS$5;
 		return {
 			MemberExpression(node) {
 				if (!node.computed) return;
@@ -11337,8 +11046,8 @@ const interactiveSupportsFocus = defineRule({
 			if (node.attributes.length === 0) return;
 			if (hasJsxSpreadAttribute$1(node.attributes)) return;
 			const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
-			const roleCandidates = roleAttribute ? getJsxPropStaticStringValues(roleAttribute, context.scopes) : null;
-			if (roleCandidates === null || roleCandidates.length === 0) return;
+			const role = roleAttribute ? getJsxPropStringValue(roleAttribute) : null;
+			if (!role) return;
 			let hasInteractiveHandler = false;
 			for (const attribute of node.attributes) {
 				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
@@ -11352,16 +11061,11 @@ 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"));
-			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);
+			if (!isInteractiveRole(role) || isInteractiveElement(elementType, node) || isNonInteractiveRole(role) || isNonInteractiveElement(elementType, node) || hasTabIndex) return;
+			const message = tabbableSet.has(role) ? buildTabbableMessage(role) : buildFocusableMessage(role);
 			context.report({
 				node,
 				message
@@ -11550,6 +11254,16 @@ 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;
@@ -21354,7 +21068,7 @@ const isObjectUrlLifecycleEffect = (effectFn) => {
 const noAdjustStateOnPropChange = defineRule({
 	id: "no-adjust-state-on-prop-change",
 	title: "State synced to a prop inside an effect",
-	severity: "warn",
+	severity: "error",
 	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) {
@@ -22763,10 +22477,6 @@ const declaresAnyDependency = (manifest) => DEPENDENCY_SECTION_NAMES.some((secti
 	const section = manifest[sectionName];
 	return typeof section === "object" && section !== null && Object.keys(section).length > 0;
 });
-const declaresDependency = (manifest, dependencyName) => {
-	for (const declaredName of iterateDependencyNames(manifest)) if (declaredName === dependencyName) return true;
-	return false;
-};
 const cachedPlatformByManifest = /* @__PURE__ */ new WeakMap();
 const classifyPackagePlatform = (filename) => {
 	const manifest = readNearestPackageManifest(filename);
@@ -22783,7 +22493,9 @@ const classifyPackagePlatform = (filename) => {
 	return result;
 };
 //#endregion
-//#region src/plugin/utils/is-package-nested-below-project-root.ts
+//#region src/plugin/utils/is-react-native-file.ts
+const WEB_FILE_EXTENSION_PATTERN = /\.web\.[cm]?[jt]sx?$/;
+const NATIVE_FILE_EXTENSION_PATTERN = /\.(?:ios|android|native)\.[cm]?[jt]sx?$/;
 const cachedRealDirectoryByDirectory = /* @__PURE__ */ new Map();
 const resolveRealDirectory = (directory) => {
 	const cached = cachedRealDirectoryByDirectory.get(directory);
@@ -22804,10 +22516,6 @@ const isPackageNestedBelowProjectRoot = (packageDirectory, rootDirectory) => {
 	const rootPrefix = normalizedRootDirectory.endsWith("/") ? normalizedRootDirectory : `${normalizedRootDirectory}/`;
 	return realPackageDirectory.startsWith(rootPrefix);
 };
-//#endregion
-//#region src/plugin/utils/is-react-native-file.ts
-const WEB_FILE_EXTENSION_PATTERN = /\.web\.[cm]?[jt]sx?$/;
-const NATIVE_FILE_EXTENSION_PATTERN = /\.(?:ios|android|native)\.[cm]?[jt]sx?$/;
 const classifyReactNativeFileTarget = (context) => {
 	const rawFilename = context.filename;
 	if (!rawFilename) return "unknown";
@@ -23224,6 +22932,7 @@ const countStatementSequenceSetStateCalls = (statements, context) => {
 	let fallThroughCount = 0;
 	let maxTerminatingPathCount = 0;
 	for (const statement of statements) {
+		if (isFunctionLike$1(statement)) continue;
 		const guardBranch = isGuardWithTerminatingBranch(statement);
 		if (guardBranch) {
 			maxTerminatingPathCount = Math.max(maxTerminatingPathCount, fallThroughCount + countMaxPathSetStateCalls(guardBranch, context));
@@ -23259,23 +22968,14 @@ const isWholesaleDelegationCall = (callNode, effectCallback) => {
 	if (!isNodeOfType(parent, "ExpressionStatement")) return false;
 	return parent.parent === effectCallback.body;
 };
-const countFunctionBodySetStateCalls = (functionNode, context) => {
-	if (isAsyncFunctionLike(functionNode)) return 0;
-	const body = functionNode.body;
-	if (!body) return 0;
-	return countMaxPathSetStateCalls(body, context);
-};
 const countMaxPathSetStateCalls = (node, context) => {
 	if (!node || typeof node !== "object") return 0;
-	if (isFunctionLike$1(node)) return 0;
+	if (isAsyncFunctionLike(node)) return 0;
 	if (isNodeOfType(node, "BlockStatement") || isNodeOfType(node, "Program")) return countStatementSequenceSetStateCalls(node.body ?? [], context);
 	if (isNodeOfType(node, "IfStatement") || isNodeOfType(node, "ConditionalExpression")) {
 		const consequent = node.consequent;
 		const alternate = node.alternate;
-		const testCount = countMaxPathSetStateCalls(node.test, context);
-		const thenCount = countMaxPathSetStateCalls(consequent, context);
-		const elseCount = alternate ? countMaxPathSetStateCalls(alternate, context) : 0;
-		return testCount + Math.max(thenCount, elseCount);
+		return countMaxPathSetStateCalls(consequent, context) + (alternate ? countMaxPathSetStateCalls(alternate, context) : 0);
 	}
 	if (isNodeOfType(node, "SwitchStatement")) {
 		let maxRunSetters = 0;
@@ -23305,31 +23005,28 @@ const countMaxPathSetStateCalls = (node, context) => {
 	}
 	if (isNodeOfType(node, "CallExpression") && isSetterCall(node) && isNodeOfType(node.callee, "Identifier") && isUseStateSetterInScope(node, node.callee.name)) {
 		let nestedSettersInArgs = 0;
-		for (const argument of node.arguments ?? []) nestedSettersInArgs += isFunctionLike$1(argument) ? countFunctionBodySetStateCalls(argument, context) : countMaxPathSetStateCalls(argument, context);
+		for (const argument of node.arguments ?? []) nestedSettersInArgs += countMaxPathSetStateCalls(argument, context);
 		return 1 + nestedSettersInArgs;
 	}
 	if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier")) {
 		const helperFunction = context.helpersByName.get(node.callee.name);
 		if (helperFunction && !context.activeHelpers.has(helperFunction) && isWholesaleDelegationCall(node, context.effectCallback)) {
 			context.activeHelpers.add(helperFunction);
-			let helperCount = countFunctionBodySetStateCalls(helperFunction, context);
+			let helperCount = countMaxPathSetStateCalls(helperFunction, context);
 			context.activeHelpers.delete(helperFunction);
 			for (const argument of node.arguments ?? []) helperCount += countMaxPathSetStateCalls(argument, context);
 			return helperCount;
 		}
 	}
-	const countChild = (child) => {
-		if (isFunctionLike$1(child)) return runsOnEffectDispatch(child) ? countFunctionBodySetStateCalls(child, context) : 0;
-		return countMaxPathSetStateCalls(child, context);
-	};
+	const shouldWalkChild = (child) => !isFunctionLike$1(child) || runsOnEffectDispatch(child);
 	let total = 0;
 	const nodeRecord = node;
 	for (const key of Object.keys(nodeRecord)) {
 		if (key === "parent") continue;
 		const child = nodeRecord[key];
 		if (Array.isArray(child)) {
-			for (const item of child) if (item && typeof item === "object" && "type" in item) total += countChild(item);
-		} else if (child && typeof child === "object" && "type" in child) total += countChild(child);
+			for (const item of child) if (item && typeof item === "object" && "type" in item && shouldWalkChild(item)) total += countMaxPathSetStateCalls(item, context);
+		} else if (child && typeof child === "object" && "type" in child && shouldWalkChild(child)) total += countMaxPathSetStateCalls(child, context);
 	}
 	return total;
 };
@@ -23378,7 +23075,7 @@ const noCascadingSetState = defineRule({
 		const callback = getEffectCallback(node);
 		if (!callback) return;
 		if (isDevOnlyGuardedEffect(callback)) return;
-		const setStateCallCount = countFunctionBodySetStateCalls(callback, {
+		const setStateCallCount = countMaxPathSetStateCalls(callback, {
 			helpersByName: collectLocalHelperFunctions(findProgramRoot(node) ?? callback),
 			activeHelpers: /* @__PURE__ */ new Set(),
 			effectCallback: callback
@@ -23722,6 +23419,40 @@ 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 = [
@@ -24735,26 +24466,6 @@ 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 (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",
@@ -24786,8 +24497,8 @@ const noDerivedStateEffect = defineRule({
 			}
 		}
 		if (sawAnyDep && allDepsAreInitialOnly) return;
-		const statements = flattenGuardedStatements(getCallbackStatements(callback));
-		if (statements === null || statements.length === 0) return;
+		const statements = getCallbackStatements(callback);
+		if (statements.length === 0) return;
 		if (!statements.every((statement) => {
 			if (!isNodeOfType(statement, "ExpressionStatement")) return false;
 			const expression = statement.expression;
@@ -26582,11 +26293,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 (isNodeOfType(initializer.callee, "Identifier") && isImportedFromNonReactModule(declaratorNode, initializer.callee.name)) return;
 			componentBindings.addBindingToCurrentFrame(declaratorNode.id.name);
 		} });
 		return {
@@ -29266,7 +28973,7 @@ const extractReturnTypeAnnotation = (returnType) => {
 const noJsxElementType = defineRule({
 	id: "no-jsx-element-type",
 	title: "No JSX.Element",
-	severity: "warn",
+	severity: "error",
 	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;
@@ -30405,6 +30112,7 @@ 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",
@@ -30478,6 +30186,7 @@ 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);
@@ -30516,7 +30225,6 @@ 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;
@@ -30749,7 +30457,7 @@ const noNestedComponentDefinition = defineRule({
 	id: "no-nested-component-definition",
 	title: "Component defined inside another component",
 	tags: ["test-noise", "react-jsx-only"],
-	severity: "warn",
+	severity: "error",
 	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) => {
@@ -32228,6 +31936,40 @@ 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();
@@ -32641,7 +32383,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."]]);
+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 isVendoredShadcnUiFilename = (rawFilename) => {
 	if (!rawFilename) return false;
 	const filename = rawFilename.replaceAll("\\", "/");
@@ -32679,7 +32421,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. Only runs on React 19+ projects.",
+	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.",
 	create: (context) => {
 		if (isVendoredShadcnUiFilename(context.filename)) return {};
 		return deprecatedReactImportRule.create(buildOncePerApiContext(context));
@@ -33003,11 +32745,34 @@ 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;
@@ -33020,21 +32785,21 @@ const functionBodyOf = (node) => {
 const containsHookCall = (body) => {
 	let found = false;
 	walkAst(body, (child) => {
-		if (found) return false;
-		if (child !== body && isFunctionLike$1(child) && isComponentFunction$1(child)) return false;
+		if (found) return;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		const name = getCalleeName$2(child);
 		if (name && isReactHookName(name)) found = true;
 	});
 	return found;
 };
-const isHookCallingRenderHelper = (symbol) => {
+const isModuleScopeHookFreeHelper = (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;
-	return containsHookCall(body);
+	if (findEnclosingFunction(declaration) !== null) return false;
+	return !containsHookCall(body);
 };
 const noRenderInRender = defineRule({
 	id: "no-render-in-render",
@@ -33045,11 +32810,18 @@ const noRenderInRender = defineRule({
 	create: (context) => ({ JSXExpressionContainer(node) {
 		const expression = node.expression;
 		if (!isNodeOfType(expression, "CallExpression")) return;
-		if (!isNodeOfType(expression.callee, "Identifier")) return;
-		const calleeName = expression.callee.name;
-		if (!RENDER_FUNCTION_PATTERN.test(calleeName)) 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 (!isInsideComponentContext(node)) return;
-		if (!isHookCallingRenderHelper(context.scopes.symbolFor(expression.callee))) 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;
+		}
 		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.`
@@ -36398,28 +36170,6 @@ 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 parentNode = identifier.parent;
-	return isNodeOfType(parentNode, "MemberExpression") && parentNode.object === identifier;
-};
-const isMemoIdentityUnused = (memoCallNode, scopes) => {
-	const parentNode = memoCallNode.parent;
-	if (isNodeOfType(parentNode, "ExpressionStatement")) return true;
-	if (!isNodeOfType(parentNode, "VariableDeclarator") || parentNode.init !== memoCallNode) 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",
@@ -36441,17 +36191,9 @@ 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) 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({
+		if (returnExpression && isTriviallyCheapExpression(returnExpression)) context.report({
 			node,
-			message: "This useMemo rebuilds a tiny literal whose reference is never relied on, so remove the useMemo and build the value inline"
+			message: "This costs more than it saves because useMemo is wrapping a value that's already cheap, so remove the useMemo"
 		});
 	} })
 });
@@ -36833,7 +36575,8 @@ const NAMED_EXPORT_MESSAGE = "This file exports non-components, so Fast Refresh
 const ANONYMOUS_MESSAGE = "This component is unnamed, so Fast Refresh can't track it and falls back to a full reload.";
 const EXPORT_ALL_MESSAGE = "`export *` hides what's exported, so Fast Refresh can't safely preserve component state.";
 const REACT_CONTEXT_MESSAGE = "This file exports a context with components, so Fast Refresh can't safely preserve component state.";
-const NAMESPACE_OBJECT_MESSAGE = "This export bundles components inside an object, so Fast Refresh can't track them and falls back to a full reload.";
+const LOCAL_COMPONENT_MESSAGE = "This component is not exported, so Fast Refresh skips it and local edits can full-reload.";
+const NO_EXPORT_MESSAGE = "This file exports nothing, so Fast Refresh can't track the component and local edits can full-reload.";
 const DEFAULT_REACT_HOCS = [
 	"memo",
 	"forwardRef",
@@ -36904,20 +36647,6 @@ const isReactComponentInitializer = (expression, state) => {
 	if (isNodeOfType(stripped, "CallExpression") && isHocCallee(stripped.callee, state) && stripped.arguments.length > 0) return true;
 	return false;
 };
-const objectExpressionBundlesComponents = (objectExpression, state) => {
-	for (const property of objectExpression.properties ?? []) {
-		if (!isNodeOfType(property, "Property")) continue;
-		const value = skipTsExpression(property.value);
-		if (isNodeOfType(value, "Identifier")) {
-			if (state.localComponentNames.has(value.name)) return true;
-			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, "CallExpression") && isHocCallee(value.callee, state) && value.arguments.length > 0) return true;
-	}
-	return false;
-};
 const classifyExport = (name, reportNode, isFunction, initializer, state) => {
 	if (initializer) {
 		const expression = skipTsExpression(initializer);
@@ -36948,10 +36677,6 @@ const classifyExport = (name, reportNode, isFunction, initializer, state) => {
 				reportNode
 			};
 		}
-		if (isNodeOfType(stripped, "ObjectExpression") && objectExpressionBundlesComponents(stripped, state)) return {
-			kind: "namespace-object",
-			reportNode
-		};
 		if (NOT_REACT_COMPONENT_EXPRESSION_TYPES.has(stripped.type)) return {
 			kind: "non-component",
 			reportNode
@@ -36968,7 +36693,7 @@ const collectRelevantNodes = (programRoot) => {
 	walkAst(programRoot, (child) => {
 		const childType = child.type;
 		if (childType === "ExportAllDeclaration" || childType === "ExportDefaultDeclaration" || childType === "ExportNamedDeclaration") exportNodes.push(child);
-		else if (childType === "FunctionDeclaration" || childType === "VariableDeclarator" || childType === "ClassDeclaration") componentCandidates.push(child);
+		else if (childType === "FunctionDeclaration" || childType === "VariableDeclarator") componentCandidates.push(child);
 	});
 	return {
 		exportNodes,
@@ -37013,31 +36738,18 @@ const onlyExportComponents = defineRule({
 	category: "Architecture",
 	create: (context) => {
 		const settings = resolveSettings$6(context.settings);
+		const state = {
+			customHocs: new Set([...DEFAULT_REACT_HOCS, ...settings.customHOCs]),
+			allowExportNames: new Set(settings.allowExportNames),
+			allowConstantExport: settings.allowConstantExport
+		};
 		return { Program(node) {
 			if (!isFileNameAllowed(normalizeFilename(context.filename ?? ""), settings.checkJS)) return;
 			const { exportNodes, componentCandidates } = collectRelevantNodes(node);
-			const localComponentNames = /* @__PURE__ */ new Set();
-			const state = {
-				customHocs: new Set([...DEFAULT_REACT_HOCS, ...settings.customHOCs]),
-				allowExportNames: new Set(settings.allowExportNames),
-				allowConstantExport: settings.allowConstantExport,
-				localComponentNames
-			};
-			for (const child of componentCandidates) {
-				if (isNodeOfType(child, "FunctionDeclaration") && child.id) {
-					if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child)) 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);
-				}
-			}
 			const exports = [];
 			let hasReactExport = false;
 			let hasAnyExports = false;
+			const localComponents = [];
 			const isExportedNodeIds = /* @__PURE__ */ new WeakSet();
 			for (const child of exportNodes) {
 				if (isNodeOfType(child, "ExportAllDeclaration")) {
@@ -37108,14 +36820,7 @@ const onlyExportComponents = defineRule({
 						});
 						continue;
 					}
-					if (isNodeOfType(stripped, "ObjectExpression")) {
-						context.report({
-							node: stripped,
-							message: objectExpressionBundlesComponents(stripped, state) ? NAMESPACE_OBJECT_MESSAGE : ANONYMOUS_MESSAGE
-						});
-						continue;
-					}
-					if (isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "Literal")) {
+					if (isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "ObjectExpression") || isNodeOfType(stripped, "Literal")) {
 						context.report({
 							node: stripped,
 							message: ANONYMOUS_MESSAGE
@@ -37168,23 +36873,32 @@ const onlyExportComponents = defineRule({
 						let entry;
 						if (exportedName === "default" && localName) entry = classifyExport(localName, reportNode, false, null, state);
 						else if (exportedName) entry = classifyExport(exportedName, reportNode, false, null, state);
-						else {
-							entry = {
-								kind: "non-component",
-								reportNode
-							};
-							if (localName && isReactComponentName(localName)) exports.push({ kind: "react-component" });
-						}
+						else entry = {
+							kind: "non-component",
+							reportNode
+						};
 						if (isReExportFromSource && entry.kind !== "react-component") continue;
 						exports.push(entry);
 					}
 				}
 			}
 			for (const entry of exports) if (entry.kind === "react-component") hasReactExport = true;
-			for (const entry of exports) if (entry.kind === "namespace-object") context.report({
-				node: entry.reportNode,
-				message: NAMESPACE_OBJECT_MESSAGE
-			});
+			const isInsideExport = (node) => {
+				let walker = node.parent;
+				while (walker) {
+					if (isNodeOfType(walker, "ExportNamedDeclaration") || isNodeOfType(walker, "ExportDefaultDeclaration") || isNodeOfType(walker, "ExportAllDeclaration")) return true;
+					walker = walker.parent ?? null;
+				}
+				return false;
+			};
+			for (const child of componentCandidates) {
+				if (isNodeOfType(child, "FunctionDeclaration") && child.id) {
+					if (isReactComponentName(child.id.name) && !isInsideExport(child) && !isInsideFunctionScope(child)) localComponents.push(child.id);
+				}
+				if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
+					if (isReactComponentName(child.id.name) && canBeReactFunctionComponent(child.init, state) && !isInsideExport(child) && !isInsideFunctionScope(child)) localComponents.push(child.id);
+				}
+			}
 			if (hasAnyExports && hasReactExport) for (const entry of exports) {
 				if (entry.kind === "non-component") context.report({
 					node: entry.reportNode,
@@ -37195,6 +36909,14 @@ const onlyExportComponents = defineRule({
 					message: REACT_CONTEXT_MESSAGE
 				});
 			}
+			else if (hasAnyExports && !hasReactExport && localComponents.length > 0) for (const local of localComponents) context.report({
+				node: local,
+				message: LOCAL_COMPONENT_MESSAGE
+			});
+			else if (!hasAnyExports && localComponents.length > 0) for (const local of localComponents) context.report({
+				node: local,
+				message: NO_EXPORT_MESSAGE
+			});
 		} };
 	}
 });
@@ -37992,8 +37714,8 @@ const preferHtmlDialog = defineRule({
 				if (!HTML_TAGS.has(tagName)) return;
 				const roleAttribute = findJsxAttribute(node.attributes, "role");
 				if (roleAttribute) {
-					const roleCandidates = getJsxPropStaticStringValues(roleAttribute, context.scopes);
-					if (roleCandidates !== null && roleCandidates.length > 0 && roleCandidates.every((candidate) => ROLE_DIALOG_VALUES.has(candidate))) {
+					const roleValue = getJsxPropStringValue(roleAttribute);
+					if (roleValue !== null && ROLE_DIALOG_VALUES.has(roleValue)) {
 						if (focusTrapSignals && isElementFocusTrapped(node, focusTrapSignals)) return;
 						const ariaModalAttribute = findJsxAttribute(node.attributes, "aria-modal");
 						const isModal = ariaModalAttribute ? isAriaModalTrue(ariaModalAttribute) : false;
@@ -40982,7 +40704,6 @@ 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 (isPlainCall && isReactHookName(calleeName)) return;
 		const callShape = isNewCall ? `new ${calleeName}()` : `${calleeName}()`;
 		context.report({
@@ -41015,6 +40736,18 @@ const TRIVIAL_DATE_GETTER_NAMES = new Set([
 	"getUTCMilliseconds",
 	"valueOf"
 ]);
+const TRIVIAL_CONSTRUCTOR_NAMES = new Set([
+	"Date",
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"RegExp",
+	"Error",
+	"URL",
+	"URLSearchParams",
+	"AbortController"
+]);
 const EAGER_CALL_RESOLUTION_DEPTH_LIMIT = 4;
 const findEagerInitializerCall = (expression, depth = 0) => {
 	if (depth > EAGER_CALL_RESOLUTION_DEPTH_LIMIT) return null;
@@ -41758,7 +41491,7 @@ const rnBottomSheetPreferNative = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-detox-missing-await.ts
-const EMPTY_VISITORS$5 = {};
+const EMPTY_VISITORS$4 = {};
 const DETOX_TEST_FILE = /(\.e2e\.[cm]?[jt]sx?$)|((^|\/)e2e\/)/;
 const DETOX_ELEMENT_ACTIONS = new Set([
 	"tap",
@@ -41818,7 +41551,7 @@ const rnDetoxMissingAwait = defineRule({
 	recommendation: "Prepend `await` to Detox actions, `waitFor(...)` chains, and `expect(element(...))` assertions. They return promises tied to Detox's synchronization, so a missing await runs steps out of order.",
 	create: (context) => {
 		const filename = normalizeFilename(context.filename ?? "");
-		if (!filename || !DETOX_TEST_FILE.test(filename)) return EMPTY_VISITORS$5;
+		if (!filename || !DETOX_TEST_FILE.test(filename)) return EMPTY_VISITORS$4;
 		return { ExpressionStatement(node) {
 			const expression = node.expression;
 			if (!isNodeOfType(expression, "CallExpression")) return;
@@ -42793,7 +42526,7 @@ const isLegacyArchReactNativeFile = (filename) => {
 };
 //#endregion
 //#region src/plugin/rules/react-native/rn-no-legacy-shadow-styles.ts
-const EMPTY_VISITORS$4 = {};
+const EMPTY_VISITORS$3 = {};
 const reportLegacyShadowProperties = (objectExpression, context) => {
 	const legacyShadowPropertyNames = [];
 	for (const property of objectExpression.properties ?? []) {
@@ -42816,7 +42549,7 @@ const rnNoLegacyShadowStyles = defineRule({
 	severity: "warn",
 	recommendation: "Use `boxShadow` for shadows that work on both platforms on the new architecture, instead of platform-specific shadow properties.",
 	create: (context) => {
-		if (context.filename && isLegacyArchReactNativeFile(normalizeFilename(context.filename))) return EMPTY_VISITORS$4;
+		if (context.filename && isLegacyArchReactNativeFile(normalizeFilename(context.filename))) return EMPTY_VISITORS$3;
 		return {
 			JSXAttribute(node) {
 				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
@@ -43737,7 +43470,7 @@ const isExpoManagedFileActive = (context) => {
 };
 //#endregion
 //#region src/plugin/rules/react-native/rn-prefer-expo-image.ts
-const EMPTY_VISITORS$3 = {};
+const EMPTY_VISITORS$2 = {};
 const BUNDLED_ASSET_SOURCE_PATTERN = /\.(?:png|jpe?g|gif|webp|bmp)$/i;
 const MEMBER_PATH_FAN_OUT_LIMIT = 32;
 const isRequireOfBundledAsset = (node) => isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "require" && node.arguments?.length === 1 && isNodeOfType(node.arguments[0], "Literal") && typeof node.arguments[0].value === "string" && BUNDLED_ASSET_SOURCE_PATTERN.test(node.arguments[0].value);
@@ -43771,7 +43504,7 @@ const rnPreferExpoImage = defineRule({
 	severity: "warn",
 	recommendation: "Use `<Image>` from `expo-image` instead of `react-native`. Same props, plus caching, placeholders, and crossfades for faster image loading.",
 	create: (context) => {
-		if (!isExpoManagedFileActive(context)) return EMPTY_VISITORS$3;
+		if (!isExpoManagedFileActive(context)) return EMPTY_VISITORS$2;
 		const flaggedImports = [];
 		const assetBindingNames = /* @__PURE__ */ new Set();
 		const moduleObjectLiterals = /* @__PURE__ */ new Map();
@@ -44258,7 +43991,7 @@ const rnScrollviewFlexInContentContainer = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-native/rn-style-prefer-box-shadow.ts
-const EMPTY_VISITORS$2 = {};
+const EMPTY_VISITORS$1 = {};
 const IOS_SHADOW_KEYS = new Set([
 	"shadowColor",
 	"shadowOffset",
@@ -44344,7 +44077,7 @@ const rnStylePreferBoxShadow = defineRule({
 	severity: "warn",
 	recommendation: "These shadow keys only work on one platform. On RN v7+, use the CSS `boxShadow` string instead, like `boxShadow: \"0 2px 8px rgba(0,0,0,0.1)\"`, which works on both.",
 	create: (context) => {
-		if (context.filename && isLegacyArchReactNativeFile(normalizeFilename(context.filename))) return EMPTY_VISITORS$2;
+		if (context.filename && isLegacyArchReactNativeFile(normalizeFilename(context.filename))) return EMPTY_VISITORS$1;
 		return {
 			JSXAttribute(node) {
 				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
@@ -44441,9 +44174,9 @@ const roleHasRequiredAriaProps = defineRule({
 		if (!HTML_TAGS.has(elementType)) return;
 		const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
 		if (!roleAttribute) return;
-		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)));
+		const roleValue = getJsxPropStringValue(roleAttribute);
+		if (roleValue === null) return;
+		const roles = roleValue.split(/\s+/).filter((token) => token.length > 0);
 		for (const role of roles) {
 			const required = ROLE_REQUIRED_PROPS.get(role);
 			if (!required) continue;
@@ -47560,9 +47293,7 @@ const ROLE_SUPPORTS_ARIA_PROPS = {
 };
 //#endregion
 //#region src/plugin/rules/a11y/role-supports-aria-props.ts
-const buildMessageDefault = (roles, propName) => {
-	return `Screen reader users get no help from \`${propName}\` because role ${roles.map((role) => `\`${role}\``).join(" / ")} ignores it, so remove it or change the role.`;
-};
+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 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",
@@ -47590,21 +47321,17 @@ const roleSupportsAriaProps = defineRule({
 		if (!ariaAttributes) return;
 		const elementType = getElementType(node, context.settings);
 		const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
-		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 role = roleAttribute ? getJsxPropStringValue(roleAttribute) : getImplicitRole(node, elementType);
+		if (!role) return;
+		if (!VALID_ARIA_ROLES.has(role)) return;
 		const isImplicit = !roleAttribute;
+		const supported = ROLE_SUPPORTS_ARIA_PROPS[role];
+		if (!supported) return;
 		for (const { attribute, propName } of ariaAttributes) {
-			if (supportedSets.some((supported) => supported.has(propName))) continue;
+			if (supported.has(propName)) continue;
 			context.report({
 				node: attribute,
-				message: isImplicit ? buildMessageImplicit(roleCandidates[0], propName, elementType) : buildMessageDefault(roleCandidates, propName)
+				message: isImplicit ? buildMessageImplicit(role, propName, elementType) : buildMessageDefault(role, propName)
 			});
 		}
 	} })
@@ -47956,15 +47683,11 @@ const isUseEffectEventSymbol = (symbol) => {
 	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 isNonReactEffectEventCallee = (callee, contextNode) => isNodeOfType(callee, "Identifier") && isImportedFromNonReactModule(contextNode, callee.name);
+const isNonReactEffectEventSymbol = (symbol, contextNode) => {
 	const initializer = symbol.initializer;
 	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	return isNonReactEffectEventCallee(initializer.callee, contextNode, scopes);
+	return isNonReactEffectEventCallee(initializer.callee, contextNode);
 };
 const findEnclosingComponentOrHookFunction = (node) => {
 	let current = node.parent;
@@ -48043,7 +47766,7 @@ const rulesOfHooks = defineRule({
 				const hookContext = isHookCall$1(node, context.scopes, settings);
 				if (!hookContext) return;
 				const { hookName } = hookContext;
-				if (hookName === "useEffectEvent" && !isUseEffectEventInitializer(node) && !isNonReactEffectEventCallee(node.callee, node, context.scopes)) {
+				if (hookName === "useEffectEvent" && !isUseEffectEventInitializer(node) && !isNonReactEffectEventCallee(node.callee, node)) {
 					context.report({
 						node: node.callee,
 						message: buildEffectEventPassedDownMessage()
@@ -48156,7 +47879,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 (isNonReactEffectEventSymbol(symbol, node)) return;
 				if (!isSameComponentOrHookScope(symbol, node)) return;
 				if (isInsideAllowedEffectEventCallback(node, additionalEffectHooksRegex)) return;
 				context.report({
@@ -55728,34 +55451,6 @@ const reactDoctorRules = [
 ];
 const ruleRegistry = Object.fromEntries(reactDoctorRules.map((rule) => [rule.id, rule.rule]));
 //#endregion
-//#region src/plugin/utils/is-next-file.ts
-const isNextFileActive = (context) => {
-	const rawFilename = context.filename;
-	if (!rawFilename) return true;
-	const filename = normalizeFilename(rawFilename);
-	const manifest = readNearestPackageManifest(filename);
-	if (!manifest) return true;
-	if (declaresDependency(manifest, "next")) return true;
-	if (!declaresAnyDependency(manifest)) return true;
-	const packageDirectory = findNearestPackageDirectory(filename);
-	const rootDirectory = getReactDoctorStringSetting(context.settings, "rootDirectory");
-	if (packageDirectory !== null && isPackageNestedBelowProjectRoot(packageDirectory, rootDirectory)) return false;
-	return true;
-};
-//#endregion
-//#region src/plugin/utils/wrap-nextjs-rule.ts
-const EMPTY_VISITORS$1 = {};
-const wrapNextjsRule = (rule) => {
-	const innerCreate = rule.create.bind(rule);
-	return {
-		...rule,
-		create: (context) => {
-			if (!isNextFileActive(context)) return EMPTY_VISITORS$1;
-			return innerCreate(context);
-		}
-	};
-};
-//#endregion
 //#region src/plugin/utils/wrap-react-native-rule.ts
 const EMPTY_VISITORS = {};
 const wrapReactNativeRule = (rule) => {
@@ -56225,14 +55920,9 @@ const wrapWithSemanticContext = (rule) => ({
 });
 //#endregion
 //#region src/plugin/react-doctor-plugin.ts
-const applyFrameworkGate = (rule) => {
-	if (rule.framework === "react-native") return wrapReactNativeRule(rule);
-	if (rule.framework === "nextjs") return wrapNextjsRule(rule);
-	return rule;
-};
 const applyFrameworkRuleWrappers = (registry) => {
 	const wrapped = {};
-	for (const [ruleId, rule] of Object.entries(registry)) wrapped[ruleId] = wrapWithSemanticContext(applyFrameworkGate(rule));
+	for (const [ruleId, rule] of Object.entries(registry)) wrapped[ruleId] = wrapWithSemanticContext(rule.framework === "react-native" ? wrapReactNativeRule(rule) : rule);
 	return wrapped;
 };
 const plugin = {