oxlint-plugin-react-doctor 0.7.4-dev.b47d053 → 0.7.4-dev.b686594

package/dist/index.js

@@ -1915,10 +1915,7 @@ const isGeneratedImageRenderContext = (context, node) => {
 	if (!node) return false;
 	const programRoot = findProgramRoot(node);
 	if (!programRoot) return false;
-	const generatedImageJsxNodes = collectGeneratedImageJsxNodes(programRoot);
-	if (generatedImageJsxNodes.has(node)) return true;
-	if (isNodeOfType(node, "JSXElement")) return generatedImageJsxNodes.has(node.openingElement);
-	return false;
+	return collectGeneratedImageJsxNodes(programRoot).has(node);
 };
 //#endregion
 //#region src/plugin/utils/object-has-accessible-child.ts
@@ -7675,21 +7672,6 @@ const readStaticBoolean = (node) => {
 	return unwrappedNode.value;
 };
 //#endregion
-//#region src/plugin/utils/resolve-const-identifier-alias.ts
-const resolveConstIdentifierAlias = (identifier, scopes) => {
-	if (!isNodeOfType(identifier, "Identifier")) return null;
-	const visitedSymbolIds = /* @__PURE__ */ new Set();
-	let symbol = scopes.symbolFor(identifier);
-	while (symbol?.kind === "const") {
-		if (visitedSymbolIds.has(symbol.id) || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
-		visitedSymbolIds.add(symbol.id);
-		const initializer = stripParenExpression(symbol.initializer);
-		if (!isNodeOfType(initializer, "Identifier")) return symbol;
-		symbol = scopes.symbolFor(initializer);
-	}
-	return symbol;
-};
-//#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) => {
@@ -7705,7 +7687,8 @@ const isNamedReactApiImport = (identifier, apiNames, scopes) => {
 	return Boolean(importedName && includesApiName(apiNames, importedName));
 };
 const isReactNamespaceImport = (identifier, scopes) => {
-	const symbol = resolveConstIdentifierAlias(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");
 };
@@ -7716,11 +7699,9 @@ const isReactApiCall = (node, apiNames, scopes, options = {}) => {
 		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.property, "Identifier") || !includesApiName(apiNames, callee.property.name)) return false;
-	const receiver = stripParenExpression(callee.object);
-	if (!isNodeOfType(receiver, "Identifier")) return false;
-	if (isReactNamespaceImport(receiver, scopes)) return true;
-	return Boolean(options.allowGlobalReactNamespace && receiver.name === "React" && scopes.isGlobalReference(receiver));
+	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
@@ -9875,14 +9856,35 @@ 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;
-	return isReactApiCall(initializer, "useEffectEvent", scopes, {
-		allowGlobalReactNamespace: true,
-		allowUnboundBareCalls: true
-	});
+	if (getUseEffectEventCalleeName(initializer.callee) !== "useEffectEvent") return false;
+	return !isNonReactEffectEventCallee(initializer.callee, initializer, scopes);
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps.ts
@@ -15929,190 +15931,6 @@ const memoStatusForJsxOpeningName = (registry, openingName) => {
 	return registry.get(openingName.name) ?? "unknown";
 };
 //#endregion
-//#region src/plugin/utils/unwrap-react-hoc-function.ts
-/**
-* Resolves a `VariableDeclarator.init` (or any expression) to the inline
-* function expression it binds, seeing through chains of `memo` /
-* `forwardRef` / `React.memo` / `React.forwardRef` wrappers:
-*
-*   `() => {}`                          → the arrow
-*   `memo(function Foo() {})`           → the named function expression
-*   `React.memo(forwardRef(() => {}))`  → the inner arrow
-*   `memo(SomeIdentifier)`              → the identifier's same-file function when scopes are provided
-*
-* Component-shaped rules that previously gated on a direct function init
-* (via `isComponentAssignment`) use this so memo-wrapped components are
-* not silently skipped.
-*/
-const resolveReactHocFunction = (node, scopes, visitedSymbolIds) => {
-	if (!node) return null;
-	const current = stripParenExpression(node);
-	if (isInlineFunctionExpression(current)) return current;
-	if (isNodeOfType(current, "Identifier") && scopes) {
-		const symbol = scopes.symbolFor(current);
-		if (!symbol || visitedSymbolIds.has(symbol.id) || !symbol.initializer || symbol.kind !== "const" && symbol.kind !== "function") return null;
-		if (symbol.kind === "const" && (!isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier)) return null;
-		visitedSymbolIds.add(symbol.id);
-		return resolveReactHocFunction(symbol.initializer, scopes, visitedSymbolIds);
-	}
-	if (isNodeOfType(current, "CallExpression")) {
-		const calleeName = flattenCalleeName(current.callee);
-		if (!calleeName || !REACT_HOC_NAMES.has(calleeName)) return null;
-		const firstArgument = current.arguments[0];
-		if (!firstArgument || isNodeOfType(firstArgument, "SpreadElement")) return null;
-		return resolveReactHocFunction(firstArgument, scopes, visitedSymbolIds);
-	}
-	return null;
-};
-const unwrapReactHocFunction = (node, scopes) => resolveReactHocFunction(node, scopes, /* @__PURE__ */ new Set());
-//#endregion
-//#region src/plugin/utils/build-same-file-jsx-slot-prop-registry.ts
-const REACT_SLOT_TYPE_NAMES = new Set(["ReactNode", "ReactElement"]);
-const unwrapTopLevelDeclaration = (statement) => {
-	if (isNodeOfType(statement, "ExportNamedDeclaration")) return statement.declaration;
-	if (isNodeOfType(statement, "ExportDefaultDeclaration")) return statement.declaration;
-	return statement;
-};
-const buildReactSlotTypeEnvironment = (program) => {
-	const reactSlotTypeBindings = /* @__PURE__ */ new Set();
-	const reactNamespaceBindings = /* @__PURE__ */ new Set();
-	const reactJsxNamespaceBindings = /* @__PURE__ */ new Set();
-	const nonReactJsxNamespaceBindings = /* @__PURE__ */ new Set();
-	const sameFileTypeDeclarations = /* @__PURE__ */ new Map();
-	let hasLocalJsxNamespace = false;
-	if (!isNodeOfType(program, "Program")) return {
-		reactSlotTypeBindings,
-		reactNamespaceBindings,
-		reactJsxNamespaceBindings,
-		nonReactJsxNamespaceBindings,
-		sameFileTypeDeclarations,
-		hasLocalJsxNamespace
-	};
-	for (const statement of program.body) {
-		if (isNodeOfType(statement, "ImportDeclaration")) {
-			const isReactImport = statement.source.value === "react";
-			for (const specifier of statement.specifiers) {
-				if (isReactImport && (isNodeOfType(specifier, "ImportDefaultSpecifier") || isNodeOfType(specifier, "ImportNamespaceSpecifier"))) {
-					reactNamespaceBindings.add(specifier.local.name);
-					continue;
-				}
-				if (!isNodeOfType(specifier, "ImportSpecifier")) continue;
-				const importedName = getImportedName(specifier);
-				if (!importedName) continue;
-				if (isReactImport && REACT_SLOT_TYPE_NAMES.has(importedName)) reactSlotTypeBindings.add(specifier.local.name);
-				if (importedName === "JSX") if (isReactImport) reactJsxNamespaceBindings.add(specifier.local.name);
-				else nonReactJsxNamespaceBindings.add(specifier.local.name);
-			}
-			continue;
-		}
-		const declaration = unwrapTopLevelDeclaration(statement);
-		if (!declaration) continue;
-		if ((isNodeOfType(declaration, "TSInterfaceDeclaration") || isNodeOfType(declaration, "TSTypeAliasDeclaration")) && isNodeOfType(declaration.id, "Identifier")) sameFileTypeDeclarations.set(declaration.id.name, declaration);
-		if (isNodeOfType(declaration, "TSModuleDeclaration") && isNodeOfType(declaration.id, "Identifier") && declaration.id.name === "JSX") hasLocalJsxNamespace = true;
-	}
-	return {
-		reactSlotTypeBindings,
-		reactNamespaceBindings,
-		reactJsxNamespaceBindings,
-		nonReactJsxNamespaceBindings,
-		sameFileTypeDeclarations,
-		hasLocalJsxNamespace
-	};
-};
-const isJsxElementTypeName = (typeName, environment) => {
-	if (!isNodeOfType(typeName, "TSQualifiedName")) return false;
-	if (!isNodeOfType(typeName.right, "Identifier") || typeName.right.name !== "Element") return false;
-	if (isNodeOfType(typeName.left, "Identifier")) {
-		const namespaceName = typeName.left.name;
-		if (environment.reactNamespaceBindings.has(namespaceName)) return true;
-		if (environment.reactJsxNamespaceBindings.has(namespaceName)) return true;
-		if (environment.nonReactJsxNamespaceBindings.has(namespaceName)) return false;
-		return namespaceName === "JSX" && !environment.hasLocalJsxNamespace;
-	}
-	return isNodeOfType(typeName.left, "TSQualifiedName") && isNodeOfType(typeName.left.left, "Identifier") && environment.reactNamespaceBindings.has(typeName.left.left.name) && isNodeOfType(typeName.left.right, "Identifier") && typeName.left.right.name === "JSX";
-};
-const isReactSlotType = (typeNode, environment, activeDeclarations) => {
-	if (isNodeOfType(typeNode, "TSUnionType")) return typeNode.types.some((unionMember) => isReactSlotType(unionMember, environment, activeDeclarations));
-	if (!isNodeOfType(typeNode, "TSTypeReference")) return false;
-	if (isJsxElementTypeName(typeNode.typeName, environment)) return true;
-	if (isNodeOfType(typeNode.typeName, "TSQualifiedName") && isNodeOfType(typeNode.typeName.left, "Identifier") && environment.reactNamespaceBindings.has(typeNode.typeName.left.name) && isNodeOfType(typeNode.typeName.right, "Identifier") && REACT_SLOT_TYPE_NAMES.has(typeNode.typeName.right.name)) return true;
-	if (!isNodeOfType(typeNode.typeName, "Identifier")) return false;
-	const typeName = typeNode.typeName.name;
-	const sameFileDeclaration = environment.sameFileTypeDeclarations.get(typeName);
-	if (sameFileDeclaration) {
-		if (!isNodeOfType(sameFileDeclaration, "TSTypeAliasDeclaration") || activeDeclarations.has(sameFileDeclaration)) return false;
-		activeDeclarations.add(sameFileDeclaration);
-		const isSlot = isReactSlotType(sameFileDeclaration.typeAnnotation, environment, activeDeclarations);
-		activeDeclarations.delete(sameFileDeclaration);
-		return isSlot;
-	}
-	return environment.reactSlotTypeBindings.has(typeName);
-};
-const getPropertyName = (property) => {
-	if (!isNodeOfType(property, "TSPropertySignature") || property.computed) return null;
-	if (isNodeOfType(property.key, "Identifier")) return property.key.name;
-	if (isNodeOfType(property.key, "Literal") && typeof property.key.value === "string") return property.key.value;
-	return null;
-};
-const collectSlotPropertyNames = (propsType, environment, slotPropertyNames, activeDeclarations) => {
-	let members = null;
-	if (isNodeOfType(propsType, "TSTypeLiteral")) members = propsType.members;
-	if (isNodeOfType(propsType, "TSInterfaceDeclaration")) members = propsType.body.body;
-	if (members) {
-		for (const member of members) {
-			const propertyName = getPropertyName(member);
-			if (!propertyName || !isNodeOfType(member, "TSPropertySignature")) continue;
-			const annotation = member.typeAnnotation;
-			if (annotation && isNodeOfType(annotation, "TSTypeAnnotation") && isReactSlotType(annotation.typeAnnotation, environment, /* @__PURE__ */ new Set())) slotPropertyNames.add(propertyName);
-		}
-		return;
-	}
-	if (isNodeOfType(propsType, "TSIntersectionType")) {
-		for (const intersectionMember of propsType.types) collectSlotPropertyNames(intersectionMember, environment, slotPropertyNames, activeDeclarations);
-		return;
-	}
-	if (isNodeOfType(propsType, "TSTypeAliasDeclaration")) {
-		collectSlotPropertyNames(propsType.typeAnnotation, environment, slotPropertyNames, activeDeclarations);
-		return;
-	}
-	if (!isNodeOfType(propsType, "TSTypeReference") || !isNodeOfType(propsType.typeName, "Identifier")) return;
-	const declaration = environment.sameFileTypeDeclarations.get(propsType.typeName.name);
-	if (!declaration || activeDeclarations.has(declaration)) return;
-	activeDeclarations.add(declaration);
-	collectSlotPropertyNames(declaration, environment, slotPropertyNames, activeDeclarations);
-	activeDeclarations.delete(declaration);
-};
-const getMemoizedComponentPropsType = (initializer, scopes) => {
-	const componentFunction = unwrapReactHocFunction(initializer, scopes);
-	if (componentFunction) {
-		const firstParameter = componentFunction.params[0];
-		const annotation = firstParameter && "typeAnnotation" in firstParameter ? firstParameter.typeAnnotation : null;
-		if (annotation && isNodeOfType(annotation, "TSTypeAnnotation")) return annotation.typeAnnotation;
-	}
-	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	return initializer.typeArguments?.params[0] ?? null;
-};
-const buildSameFileJsxSlotPropRegistry = (program, memoRegistry, scopes) => {
-	const registry = /* @__PURE__ */ new Map();
-	if (!isNodeOfType(program, "Program")) return registry;
-	const environment = buildReactSlotTypeEnvironment(program);
-	for (const statement of program.body) {
-		const declaration = unwrapTopLevelDeclaration(statement);
-		if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) continue;
-		for (const declarator of declaration.declarations) {
-			if (!isNodeOfType(declarator.id, "Identifier") || memoRegistry.get(declarator.id.name) !== "memoised" || !declarator.init) continue;
-			const componentSymbol = scopes.symbolFor(declarator.id);
-			if (!componentSymbol) continue;
-			const propsType = getMemoizedComponentPropsType(declarator.init, scopes);
-			if (!propsType) continue;
-			const slotPropertyNames = /* @__PURE__ */ new Set();
-			collectSlotPropertyNames(propsType, environment, slotPropertyNames, /* @__PURE__ */ new Set());
-			if (slotPropertyNames.size > 0) registry.set(componentSymbol.id, slotPropertyNames);
-		}
-	}
-	return registry;
-};
-//#endregion
 //#region src/plugin/utils/is-on-intrinsic-html-element.ts
 const isJsxAttributeOnIntrinsicHtmlElement = (attribute) => {
 	const openingElement = attribute.parent;
@@ -16386,11 +16204,9 @@ const jsxNoJsxAsProp = defineRule({
 	create: (context) => {
 		const isTestlikeFile = isTestlikeFilename(context.filename);
 		let memoRegistry = null;
-		let jsxSlotPropRegistry = null;
 		return {
 			Program(node) {
 				memoRegistry = buildSameFileMemoRegistry(node);
-				jsxSlotPropRegistry = buildSameFileJsxSlotPropRegistry(node, memoRegistry, context.scopes);
 			},
 			JSXAttribute(node) {
 				if (isTestlikeFile) return;
@@ -16398,8 +16214,6 @@ const jsxNoJsxAsProp = defineRule({
 				const parentJsxOpening = node.parent;
 				const openingName = parentJsxOpening && isNodeOfType(parentJsxOpening, "JSXOpeningElement") ? parentJsxOpening.name : null;
 				if (memoStatusForJsxOpeningName(memoRegistry, openingName) !== "memoised") return;
-				const openingSymbol = openingName && isNodeOfType(openingName, "JSXIdentifier") ? context.scopes.symbolFor(openingName) : null;
-				if (openingSymbol && isNodeOfType(node.name, "JSXIdentifier") && jsxSlotPropRegistry?.get(openingSymbol.id)?.has(node.name.name)) return;
 				if (isNodeOfType(node.name, "JSXIdentifier") && isSlotPropName(node.name.name)) return;
 				if (!isInsideFunctionScope(node)) return;
 				const value = node.value;
@@ -27600,24 +27414,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/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/rules/state-and-effects/no-effect-event-in-deps.ts
 const createComponentBindingStackTracker = (callbacks) => {
 	const componentBindingStack = [];
@@ -28699,61 +28495,13 @@ const noEventTriggerState = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/resolve-expression-key.ts
-const resolveExpressionKey = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (!expression) return null;
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		const symbol = context.scopes.symbolFor(unwrappedExpression);
-		if (!symbol) return context.scopes.isGlobalReference(unwrappedExpression) ? `global:${unwrappedExpression.name}` : null;
-		if (visitedSymbolIds.has(symbol.id)) return `symbol:${symbol.id}`;
-		visitedSymbolIds.add(symbol.id);
-		const bindingProperty = symbol.bindingIdentifier.parent;
-		const bindingPattern = bindingProperty?.parent;
-		const variableDeclarator = bindingPattern?.parent;
-		const bindingPropertyName = isNodeOfType(bindingProperty, "Property") ? getStaticPropertyKeyName(bindingProperty) : null;
-		if (bindingPropertyName && isNodeOfType(bindingPattern, "ObjectPattern") && isNodeOfType(variableDeclarator, "VariableDeclarator") && variableDeclarator.id === bindingPattern) {
-			const objectKey = resolveExpressionKey(variableDeclarator.init, context, visitedSymbolIds);
-			return objectKey ? `${objectKey}.${bindingPropertyName}` : `symbol:${symbol.id}`;
-		}
-		const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
-		if (symbol.kind === "const" && initializer && (isNodeOfType(initializer, "Identifier") || isNodeOfType(initializer, "MemberExpression"))) return resolveExpressionKey(initializer, context, visitedSymbolIds) ?? `symbol:${symbol.id}`;
-		return `symbol:${symbol.id}`;
-	}
-	if (isNodeOfType(unwrappedExpression, "MemberExpression") && !unwrappedExpression.computed) {
-		if (!isNodeOfType(unwrappedExpression.property, "Identifier")) return null;
-		const objectKey = resolveExpressionKey(unwrappedExpression.object, context, visitedSymbolIds);
-		return objectKey ? `${objectKey}.${unwrappedExpression.property.name}` : null;
-	}
-	if (isNodeOfType(unwrappedExpression, "ThisExpression")) return "this";
-	if (isNodeOfType(unwrappedExpression, "Literal") && (typeof unwrappedExpression.value === "string" || typeof unwrappedExpression.value === "number")) return `literal:${String(unwrappedExpression.value)}`;
-	if (isFunctionLike$1(unwrappedExpression)) {
-		const rangeStart = getRangeStart(unwrappedExpression);
-		return rangeStart === null ? null : `function:${rangeStart}`;
-	}
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/statement-always-exits.ts
-const statementAlwaysExits = (statement) => {
-	if (isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement")) return true;
-	if (isNodeOfType(statement, "IfStatement")) return Boolean(statement.alternate && statementAlwaysExits(statement.consequent) && statementAlwaysExits(statement.alternate));
-	if (!isNodeOfType(statement, "BlockStatement")) return false;
-	return statement.body.some((childStatement) => statementAlwaysExits(childStatement));
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-fetch-in-effect.ts
 const IMPORT_INITIALIZER_TYPES = new Set([
 	"ImportSpecifier",
 	"ImportDefaultSpecifier",
 	"ImportNamespaceSpecifier"
 ]);
-const CANCELLATION_FLAG_NAME_PATTERN = /cancel|ignore/i;
-const PROMISE_CONTINUATION_METHOD_NAMES = new Set([
-	"then",
-	"catch",
-	"finally"
-]);
+const CANCELLATION_FLAG_NAME_PATTERN = /cancel/i;
 const isShadowedByLocalBinding = (identifier) => {
 	if (!isNodeOfType(identifier, "Identifier")) return false;
 	const binding = findVariableInitializer(identifier, identifier.name);
@@ -28769,54 +28517,49 @@ const isRealFetchCall = (node) => {
 };
 const isXmlHttpRequestConstruction = (node) => isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "XMLHttpRequest";
 const isNetworkRequest = (node) => isRealFetchCall(node) || isXmlHttpRequestConstruction(node);
-const resolveLocalFunction = (expression, context) => {
-	if (!expression) return null;
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isFunctionLike$1(unwrappedExpression)) return unwrappedExpression;
-	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
-	const initializer = context.scopes.symbolFor(unwrappedExpression)?.initializer;
-	if (!initializer) return null;
-	const unwrappedInitializer = stripParenExpression(initializer);
-	return isFunctionLike$1(unwrappedInitializer) ? unwrappedInitializer : null;
+const containsNetworkRequest = (root) => {
+	let found = false;
+	walkAst(root, (child) => {
+		if (found) return false;
+		if (isNetworkRequest(child)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
 };
-const collectEffectAnalysisFunctions = (effectCallback, context) => {
-	const analysisFunctions = /* @__PURE__ */ new Set();
-	const pendingFunctions = [];
-	const enqueueFunction = (functionNode) => {
-		for (const invokedFunction of collectEffectInvokedFunctions(functionNode)) {
-			if (analysisFunctions.has(invokedFunction)) continue;
-			analysisFunctions.add(invokedFunction);
-			pendingFunctions.push(invokedFunction);
+const collectComponentScopeFunctionBindings = (componentScope, effectCallback) => {
+	const bindings = /* @__PURE__ */ new Map();
+	walkAst(componentScope, (child) => {
+		if (child === effectCallback) return false;
+		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
+			const initializer = child.init ? stripParenExpression(child.init) : null;
+			if (isFunctionLike$1(initializer)) bindings.set(child.id.name, initializer);
+			return;
 		}
-	};
-	enqueueFunction(effectCallback);
-	while (pendingFunctions.length > 0) {
-		const currentFunction = pendingFunctions.pop();
-		if (!currentFunction) break;
-		walkAst(currentFunction, (child) => {
-			if (child !== currentFunction && isFunctionLike$1(child)) return false;
-			if (!isNodeOfType(child, "CallExpression")) return;
-			const calledFunction = resolveLocalFunction(child.callee, context);
-			if (calledFunction) enqueueFunction(calledFunction);
-			for (const callArgument of child.arguments ?? []) {
-				const callbackFunction = resolveLocalFunction(callArgument, context);
-				if (callbackFunction) enqueueFunction(callbackFunction);
-			}
-		});
-	}
-	return analysisFunctions;
+		if (isNodeOfType(child, "FunctionDeclaration") && isNodeOfType(child.id, "Identifier")) bindings.set(child.id.name, child);
+	});
+	return bindings;
 };
-const collectNodesFromAnalysisFunctions = (analysisFunctions, predicate) => {
-	const nodes = [];
-	const seenNodes = /* @__PURE__ */ new Set();
-	for (const analysisFunction of analysisFunctions) walkAst(analysisFunction, (child) => {
-		if (child !== analysisFunction && isFunctionLike$1(child)) return false;
-		if (!seenNodes.has(child) && predicate(child)) {
-			seenNodes.add(child);
-			nodes.push(child);
+const containsNetworkRequestInEffect = (effectCallback) => {
+	const invokedFunctions = collectEffectInvokedFunctions(effectCallback);
+	for (const invokedFunction of invokedFunctions) if (containsNetworkRequest(invokedFunction)) return true;
+	const enclosingComponent = findEnclosingFunction(effectCallback);
+	if (!enclosingComponent) return false;
+	const scopeFunctions = collectComponentScopeFunctionBindings(enclosingComponent, effectCallback);
+	let found = false;
+	walkAst(effectCallback, (child) => {
+		if (found) return false;
+		if (child !== effectCallback && isFunctionLike$1(child) && invokedFunctions.has(child)) return false;
+		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier")) {
+			const scopeFunction = scopeFunctions.get(child.callee.name);
+			if (scopeFunction && containsNetworkRequest(scopeFunction)) {
+				found = true;
+				return false;
+			}
 		}
 	});
-	return nodes;
+	return found;
 };
 const findEffectCleanupFunction = (callback) => {
 	if (!isFunctionLike$1(callback)) return null;
@@ -28829,177 +28572,36 @@ const findEffectCleanupFunction = (callback) => {
 	});
 	return cleanup;
 };
-const collectEffectCancellationFlagKeys = (effectCallback, context) => {
-	const flagKeys = /* @__PURE__ */ new Set();
-	if (!isFunctionLike$1(effectCallback)) return flagKeys;
+const collectEffectCancellationFlagNames = (effectCallback) => {
+	const flagNames = /* @__PURE__ */ new Set();
+	if (!isFunctionLike$1(effectCallback)) return flagNames;
 	const body = effectCallback.body;
-	if (!isNodeOfType(body, "BlockStatement")) return flagKeys;
+	if (!isNodeOfType(body, "BlockStatement")) return flagNames;
 	for (const statement of body.body ?? []) {
 		if (!isNodeOfType(statement, "VariableDeclaration") || statement.kind !== "let") continue;
 		for (const declarator of statement.declarations ?? []) {
 			if (!isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.id, "Identifier")) continue;
 			const initializer = declarator.init;
-			if (isNodeOfType(initializer, "Literal") && initializer.value === false && CANCELLATION_FLAG_NAME_PATTERN.test(declarator.id.name)) {
-				const flagKey = resolveExpressionKey(declarator.id, context);
-				if (flagKey) flagKeys.add(flagKey);
-			}
+			if (isNodeOfType(initializer, "Literal") && initializer.value === false && CANCELLATION_FLAG_NAME_PATTERN.test(declarator.id.name)) flagNames.add(declarator.id.name);
 		}
 	}
-	return flagKeys;
+	return flagNames;
 };
-const resolveConstValue = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (!expression) return null;
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "Identifier")) return unwrappedExpression;
-	const symbol = context.scopes.symbolFor(unwrappedExpression);
-	if (!symbol || symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return unwrappedExpression;
-	visitedSymbolIds.add(symbol.id);
-	return resolveConstValue(symbol.initializer, context, visitedSymbolIds);
-};
-const resolveRequestAbortControllerKey = (request, context) => {
-	if (isNodeOfType(request, "NewExpression")) {
-		const declarator = request.parent;
-		return isNodeOfType(declarator, "VariableDeclarator") && declarator.init === request ? resolveExpressionKey(declarator.id, context) : null;
-	}
-	if (!isNodeOfType(request, "CallExpression")) return null;
-	for (const requestArgument of request.arguments ?? []) {
-		const options = resolveConstValue(requestArgument, context);
-		if (!isNodeOfType(options, "ObjectExpression")) continue;
-		for (const property of options.properties ?? []) {
-			if (!isNodeOfType(property, "Property") || getStaticPropertyKeyName(property, { allowComputedString: true }) !== "signal") continue;
-			const signalKey = resolveExpressionKey(property.value, context);
-			return signalKey?.endsWith(".signal") ? signalKey.slice(0, -7) : null;
-		}
-	}
-	return null;
-};
-const collectCleanupAbortedControllerKeys = (cleanup, context) => {
-	const controllerKeys = /* @__PURE__ */ new Set();
-	walkAst(cleanup, (child) => {
-		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "MemberExpression") && !child.callee.computed && isNodeOfType(child.callee.property, "Identifier") && child.callee.property.name === "abort") {
-			const controllerKey = resolveExpressionKey(child.callee.object, context);
-			if (controllerKey) controllerKeys.add(controllerKey);
-		}
-	});
-	return controllerKeys;
-};
-const collectCleanupAssignedCancellationFlagKeys = (cleanup, cancellationFlagKeys, context) => {
-	const assignedFlagKeys = /* @__PURE__ */ new Set();
+const isCancellationCleanup = (cleanup, effectCallback) => {
+	const cancellationFlagNames = collectEffectCancellationFlagNames(effectCallback);
+	let found = false;
 	walkAst(cleanup, (child) => {
-		if (isNodeOfType(child, "AssignmentExpression") && isNodeOfType(child.right, "Literal") && child.right.value === true) {
-			const assignedKey = resolveExpressionKey(child.left, context);
-			if (assignedKey && cancellationFlagKeys.has(assignedKey)) assignedFlagKeys.add(assignedKey);
-		}
-	});
-	return assignedFlagKeys;
-};
-const readCancellationCondition = (expression, cancellationFlagKey, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (resolveExpressionKey(unwrappedExpression, context) === cancellationFlagKey) return true;
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		const argumentResult = readCancellationCondition(unwrappedExpression.argument, cancellationFlagKey, context);
-		return argumentResult === null ? null : !argumentResult;
-	}
-	if (!isNodeOfType(unwrappedExpression, "BinaryExpression")) return null;
-	const leftResult = readCancellationCondition(unwrappedExpression.left, cancellationFlagKey, context);
-	const rightResult = readCancellationCondition(unwrappedExpression.right, cancellationFlagKey, context);
-	const leftBoolean = isNodeOfType(unwrappedExpression.left, "Literal") && typeof unwrappedExpression.left.value === "boolean" ? unwrappedExpression.left.value : null;
-	const rightBoolean = isNodeOfType(unwrappedExpression.right, "Literal") && typeof unwrappedExpression.right.value === "boolean" ? unwrappedExpression.right.value : null;
-	const comparedCancellationValue = leftResult !== null && rightBoolean !== null ? rightBoolean : rightResult !== null && leftBoolean !== null ? leftBoolean : null;
-	if (comparedCancellationValue === null) return null;
-	if (unwrappedExpression.operator === "===" || unwrappedExpression.operator === "==") return comparedCancellationValue;
-	if (unwrappedExpression.operator === "!==" || unwrappedExpression.operator === "!=") return !comparedCancellationValue;
-	return null;
-};
-const isCompletionSinkInsideCancellationGuard = (completionSink, cancellationFlagKey, context) => {
-	let currentNode = completionSink;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isFunctionLike$1(parentNode)) return false;
-		if (isNodeOfType(parentNode, "IfStatement")) {
-			const cancellationResult = readCancellationCondition(parentNode.test, cancellationFlagKey, context);
-			if (currentNode === parentNode.consequent && cancellationResult === false) return true;
-			if (currentNode === parentNode.alternate && cancellationResult === true) return true;
-		}
-		if (isNodeOfType(parentNode, "ConditionalExpression")) {
-			const cancellationResult = readCancellationCondition(parentNode.test, cancellationFlagKey, context);
-			if (currentNode === parentNode.consequent && cancellationResult === false) return true;
-			if (currentNode === parentNode.alternate && cancellationResult === true) return true;
-		}
-		if (isNodeOfType(parentNode, "LogicalExpression") && currentNode === parentNode.right) {
-			const cancellationResult = readCancellationCondition(parentNode.left, cancellationFlagKey, context);
-			if (parentNode.operator === "&&" && cancellationResult === false) return true;
-			if (parentNode.operator === "||" && cancellationResult === true) return true;
+		if (found) return false;
+		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") && child.callee.property.name === "abort") {
+			found = true;
+			return false;
 		}
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return false;
-};
-const isCompletionSinkAfterCancellationEarlyExit = (completionSink, cancellationFlagKey, context) => {
-	let currentNode = completionSink;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isFunctionLike$1(parentNode)) return false;
-		if (isNodeOfType(parentNode, "BlockStatement")) {
-			const statementIndex = parentNode.body.findIndex((statement) => statement === currentNode);
-			if (statementIndex >= 0) for (const statement of parentNode.body.slice(0, statementIndex)) {
-				if (!isNodeOfType(statement, "IfStatement")) continue;
-				const cancellationResult = readCancellationCondition(statement.test, cancellationFlagKey, context);
-				if (cancellationResult === true && statementAlwaysExits(statement.consequent) || cancellationResult === false && statement.alternate && statementAlwaysExits(statement.alternate)) return true;
-			}
+		if (isNodeOfType(child, "AssignmentExpression") && isNodeOfType(child.left, "Identifier") && cancellationFlagNames.has(child.left.name) && isNodeOfType(child.right, "Literal") && child.right.value === true) {
+			found = true;
+			return false;
 		}
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return false;
-};
-const isCompletionSinkGuardedByCancellationFlag = (completionSink, cancellationFlagKey, context) => isCompletionSinkInsideCancellationGuard(completionSink, cancellationFlagKey, context) || isCompletionSinkAfterCancellationEarlyExit(completionSink, cancellationFlagKey, context);
-const isDescendantOf = (node, ancestor) => {
-	let currentNode = node;
-	while (currentNode) {
-		if (currentNode === ancestor) return true;
-		currentNode = currentNode.parent ?? null;
-	}
-	return false;
-};
-const isPromiseContinuationForRequest = (functionNode, request) => {
-	const callNode = functionNode.parent;
-	if (!isNodeOfType(callNode, "CallExpression") || !callNode.arguments?.some((callArgument) => callArgument === functionNode) || !isNodeOfType(callNode.callee, "MemberExpression") || callNode.callee.computed || !isNodeOfType(callNode.callee.property, "Identifier") || !PROMISE_CONTINUATION_METHOD_NAMES.has(callNode.callee.property.name)) return false;
-	return isDescendantOf(request, callNode.callee.object);
-};
-const isAwaitedInFunction = (request, functionNode) => {
-	let currentNode = request.parent;
-	while (currentNode && currentNode !== functionNode) {
-		if (isNodeOfType(currentNode, "AwaitExpression")) return true;
-		currentNode = currentNode.parent ?? null;
-	}
-	return false;
-};
-const isCompletionSinkForRequest = (completionSink, request) => {
-	const requestFunction = findEnclosingFunction(request);
-	const completionSinkFunction = findEnclosingFunction(completionSink);
-	if (!requestFunction || !completionSinkFunction) return false;
-	if (requestFunction === completionSinkFunction) {
-		if (!isAwaitedInFunction(request, requestFunction)) return false;
-		const requestStart = getRangeStart(request);
-		const completionSinkStart = getRangeStart(completionSink);
-		return requestStart === null || completionSinkStart === null || completionSinkStart > requestStart;
-	}
-	return isPromiseContinuationForRequest(completionSinkFunction, request);
-};
-const requestHasGuardedCompletionSinks = (request, completionSinks, assignedCancellationFlagKeys, context) => {
-	const followingCompletionSinks = completionSinks.filter((completionSink) => isCompletionSinkForRequest(completionSink, request));
-	return followingCompletionSinks.length > 0 && followingCompletionSinks.every((completionSink) => [...assignedCancellationFlagKeys].some((cancellationFlagKey) => isCompletionSinkGuardedByCancellationFlag(completionSink, cancellationFlagKey, context)));
-};
-const allRequestsHaveCorrelatedCancellation = (requests, completionSinks, cleanup, effectCallback, context) => {
-	const abortedControllerKeys = collectCleanupAbortedControllerKeys(cleanup, context);
-	const assignedCancellationFlagKeys = collectCleanupAssignedCancellationFlagKeys(cleanup, collectEffectCancellationFlagKeys(effectCallback, context), context);
-	return requests.every((request) => {
-		const requestControllerKey = resolveRequestAbortControllerKey(request, context);
-		if (requestControllerKey && abortedControllerKeys.has(requestControllerKey)) return true;
-		return requestHasGuardedCompletionSinks(request, completionSinks, assignedCancellationFlagKeys, context);
 	});
+	return found;
 };
 const noFetchInEffect = defineRule({
 	id: "no-fetch-in-effect",
@@ -29010,13 +28612,9 @@ const noFetchInEffect = defineRule({
 		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
 		const callback = getEffectCallback(node);
 		if (!callback) return;
-		const analysisFunctions = collectEffectAnalysisFunctions(callback, context);
-		const requests = collectNodesFromAnalysisFunctions(analysisFunctions, isNetworkRequest);
-		if (requests.length === 0) return;
+		if (!containsNetworkRequestInEffect(callback)) return;
 		const cleanup = findEffectCleanupFunction(callback);
-		if (cleanup) {
-			if (allRequestsHaveCorrelatedCancellation(requests, collectNodesFromAnalysisFunctions(analysisFunctions, isSetterCall), cleanup, callback, context)) return;
-		}
+		if (cleanup && isCancellationCleanup(cleanup, callback)) return;
 		context.report({
 			node,
 			message: "fetch() inside useEffect can race, double-fire, or leak. Use a data-fetching layer or Server Component instead."
@@ -29316,6 +28914,34 @@ const noGenericHandlerNames = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/unwrap-react-hoc-function.ts
+/**
+* Resolves a `VariableDeclarator.init` (or any expression) to the inline
+* function expression it binds, seeing through chains of `memo` /
+* `forwardRef` / `React.memo` / `React.forwardRef` wrappers:
+*
+*   `() => {}`                          → the arrow
+*   `memo(function Foo() {})`           → the named function expression
+*   `React.memo(forwardRef(() => {}))`  → the inner arrow
+*   `memo(SomeIdentifier)`              → `null` (no inline function)
+*
+* Component-shaped rules that previously gated on a direct function init
+* (via `isComponentAssignment`) use this so memo-wrapped components are
+* not silently skipped.
+*/
+const unwrapReactHocFunction = (node) => {
+	if (!node) return null;
+	let current = stripParenExpression(node);
+	while (isNodeOfType(current, "CallExpression")) {
+		const calleeName = flattenCalleeName(current.callee);
+		if (!calleeName || !REACT_HOC_NAMES.has(calleeName)) return null;
+		const firstArgument = current.arguments[0];
+		if (!firstArgument) return null;
+		current = stripParenExpression(firstArgument);
+	}
+	return isInlineFunctionExpression(current) ? current : null;
+};
+//#endregion
 //#region src/plugin/rules/architecture/no-giant-component.ts
 const noGiantComponent = defineRule({
 	id: "no-giant-component",
@@ -29568,470 +29194,6 @@ const noGrayOnColoredBackground = 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/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 REACT_RENDER_PHASE_HOOK_NAMES = new Set(["useMemo", "useState"]);
-const isGlobalArrayFromMember = (node, scopes) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "MemberExpression") || unwrappedNode.computed || !isNodeOfType(unwrappedNode.object, "Identifier") || unwrappedNode.object.name !== "Array" || !scopes.isGlobalReference(unwrappedNode.object) || !isNodeOfType(unwrappedNode.property, "Identifier")) return false;
-	return unwrappedNode.property.name === "from";
-};
-const isConstAliasOfGlobalArrayFrom = (node, scopes) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "Identifier")) return false;
-	const binding = findVariableInitializer(unwrappedNode, unwrappedNode.name);
-	if (!binding?.initializer) return false;
-	const declarator = findDeclaratorForBinding(binding.bindingIdentifier);
-	return Boolean(declarator && scopes.symbolFor(unwrappedNode)?.declarationNode === declarator && declarator.init && declarator.parent && isNodeOfType(declarator.parent, "VariableDeclaration") && declarator.parent.kind === "const" && isGlobalArrayFromMember(declarator.init, scopes));
-};
-const executesDuringRender = (functionNode, scopes) => {
-	const parent = functionNode.parent;
-	if (!isNodeOfType(parent, "CallExpression")) return false;
-	if (parent.callee === functionNode) return true;
-	if ((scopes ? isReactApiCall(parent, REACT_RENDER_PHASE_HOOK_NAMES, scopes, { allowGlobalReactNamespace: true }) : isHookCall$2(parent, REACT_RENDER_PHASE_HOOK_NAMES)) && parent.arguments?.[0] === functionNode) return true;
-	if (scopes && parent.arguments?.[1] === functionNode && (isGlobalArrayFromMember(parent.callee, scopes) || isConstAliasOfGlobalArrayFrom(parent.callee, scopes))) 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/find-enclosing-jsx-opening-element.ts
-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;
-};
-//#endregion
-//#region src/plugin/utils/find-render-phase-component-or-hook.ts
-const findRenderPhaseComponentOrHook = (node, scopes) => {
-	let functionNode = findEnclosingFunction(node);
-	while (functionNode) {
-		if (componentOrHookDisplayNameForFunction(functionNode)) return functionNode;
-		if (!executesDuringRender(functionNode, scopes)) return null;
-		functionNode = findEnclosingFunction(functionNode);
-	}
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/has-client-render-evidence.ts
-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;
-};
-//#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/read-initial-state-boolean.ts
-const readLogicalResult = (operator, leftResult, rightResult) => {
-	if (operator === "&&") {
-		if (leftResult === false || rightResult === false) return false;
-		if (leftResult === true && rightResult === true) return true;
-		return null;
-	}
-	if (leftResult === true || rightResult === true) return true;
-	if (leftResult === false && rightResult === false) return false;
-	return null;
-};
-const readIdentifierInitialStateBoolean = (identifier, scopes, visitedBindings, allowLazyInitializer) => {
-	if (!isNodeOfType(identifier, "Identifier")) return null;
-	if (identifier.name === "undefined" && scopes.isGlobalReference(identifier)) return false;
-	const binding = findVariableInitializer(identifier, identifier.name);
-	if (!binding || visitedBindings.has(binding.bindingIdentifier)) return null;
-	visitedBindings.add(binding.bindingIdentifier);
-	const declarator = findDeclaratorForBinding(binding.bindingIdentifier);
-	if (!declarator?.init || scopes.symbolFor(identifier)?.declarationNode !== declarator) return null;
-	const initializer = stripParenExpression(declarator.init);
-	if (isNodeOfType(declarator.id, "ArrayPattern") && declarator.id.elements?.[0] === binding.bindingIdentifier && isReactApiCall(initializer, "useState", scopes, { allowGlobalReactNamespace: true }) && isNodeOfType(initializer, "CallExpression")) {
-		const initialState = initializer.arguments?.[0];
-		if (!initialState) return false;
-		if (initialState.type === "SpreadElement") return null;
-		return readInitialStateBooleanInternal(initialState, scopes, visitedBindings, true);
-	}
-	const declaration = declarator.parent;
-	if (!isNodeOfType(declarator.id, "Identifier") || declarator.id !== binding.bindingIdentifier || !isNodeOfType(declaration, "VariableDeclaration") || declaration.kind !== "const") return null;
-	return readInitialStateBooleanInternal(initializer, scopes, visitedBindings, allowLazyInitializer);
-};
-const readInitialStateBooleanInternal = (expression, scopes, visitedBindings, allowLazyInitializer) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "Literal")) return Boolean(unwrappedExpression.value);
-	if (isNodeOfType(unwrappedExpression, "Identifier")) return readIdentifierInitialStateBoolean(unwrappedExpression, scopes, visitedBindings, allowLazyInitializer);
-	if (allowLazyInitializer && (isNodeOfType(unwrappedExpression, "ArrowFunctionExpression") || isNodeOfType(unwrappedExpression, "FunctionExpression"))) {
-		if (unwrappedExpression.async || isNodeOfType(unwrappedExpression, "FunctionExpression") && unwrappedExpression.generator) return null;
-		if (!isNodeOfType(unwrappedExpression.body, "BlockStatement")) return readInitialStateBooleanInternal(unwrappedExpression.body, scopes, visitedBindings, false);
-		if (unwrappedExpression.body.body.length !== 1) return null;
-		const returnStatement = unwrappedExpression.body.body[0];
-		if (!isNodeOfType(returnStatement, "ReturnStatement") || !returnStatement.argument) return null;
-		return readInitialStateBooleanInternal(returnStatement.argument, scopes, visitedBindings, false);
-	}
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		const argumentResult = readInitialStateBooleanInternal(unwrappedExpression.argument, scopes, visitedBindings, false);
-		return argumentResult === null ? null : !argumentResult;
-	}
-	if (isNodeOfType(unwrappedExpression, "LogicalExpression") && (unwrappedExpression.operator === "&&" || unwrappedExpression.operator === "||")) return readLogicalResult(unwrappedExpression.operator, readInitialStateBooleanInternal(unwrappedExpression.left, scopes, new Set(visitedBindings), false), readInitialStateBooleanInternal(unwrappedExpression.right, scopes, new Set(visitedBindings), false));
-	return null;
-};
-const readInitialStateBoolean = (expression, scopes) => readInitialStateBooleanInternal(expression, scopes, /* @__PURE__ */ new Set(), false);
-//#endregion
-//#region src/plugin/utils/is-after-client-only-early-return.ts
-const isAfterClientOnlyEarlyReturn = (node, componentOrHookNode, scopes) => {
-	const body = isFunctionLike$1(componentOrHookNode) ? componentOrHookNode.body : null;
-	if (!isNodeOfType(body, "BlockStatement")) return false;
-	const ancestors = /* @__PURE__ */ new Set();
-	let currentNode = node;
-	while (currentNode) {
-		ancestors.add(currentNode);
-		currentNode = currentNode.parent ?? null;
-	}
-	for (const statement of body.body ?? []) {
-		if (ancestors.has(statement)) return false;
-		if (!isNodeOfType(statement, "IfStatement")) continue;
-		const initialConditionResult = readInitialStateBoolean(statement.test, scopes);
-		if (initialConditionResult === true && statementAlwaysExits(statement.consequent)) return true;
-		if (initialConditionResult === false && statement.alternate && statementAlwaysExits(statement.alternate)) return true;
-	}
-	return false;
-};
-//#endregion
-//#region src/plugin/utils/is-gated-by-falsy-initial-state.ts
-const isGatedByFalsyInitialState = (node, scopes) => {
-	let cursor = node;
-	let parent = node.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "LogicalExpression") && parent.right === cursor && (parent.operator === "&&" && readInitialStateBoolean(parent.left, scopes) === false || parent.operator === "||" && readInitialStateBoolean(parent.left, scopes) === true)) return true;
-		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === cursor && readInitialStateBoolean(parent.test, scopes) === false || parent.alternate === cursor && readInitialStateBoolean(parent.test, scopes) === true)) return true;
-		if (isNodeOfType(parent, "IfStatement") && (parent.consequent === cursor && readInitialStateBoolean(parent.test, scopes) === false || parent.alternate === cursor && readInitialStateBoolean(parent.test, scopes) === true)) return true;
-		cursor = parent;
-		parent = parent.parent ?? null;
-	}
-	return false;
-};
-//#endregion
-//#region src/plugin/utils/is-event-handler-attribute.ts
-const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && /^on[A-Z]/.test(node.name.name);
-//#endregion
-//#region src/plugin/rules/performance/no-hydration-branch-on-browser-global.ts
-const evaluateEquality = (operator, left, right) => {
-	if (operator === "===" || operator === "==") return left === right;
-	if (operator === "!==" || operator === "!=") return left !== right;
-	return null;
-};
-const readTypeofBrowserGlobal = (expression, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "UnaryExpression") || unwrappedExpression.operator !== "typeof") return null;
-	const argument = stripParenExpression(unwrappedExpression.argument);
-	if (isNodeOfType(argument, "Identifier")) return (argument.name === "window" || argument.name === "document") && context.scopes.isGlobalReference(argument) ? argument.name : null;
-	if (!isNodeOfType(argument, "MemberExpression") || argument.computed || !isNodeOfType(argument.object, "Identifier") || argument.object.name !== "globalThis" || !context.scopes.isGlobalReference(argument.object) || !isNodeOfType(argument.property, "Identifier") || argument.property.name !== "window" && argument.property.name !== "document") return null;
-	return argument.property.name;
-};
-const matchBrowserPredicate = (expression, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		const innerMatch = matchBrowserPredicate(unwrappedExpression.argument, context);
-		return innerMatch ? {
-			browserGlobalName: innerMatch.browserGlobalName,
-			clientResult: !innerMatch.clientResult,
-			serverResult: !innerMatch.serverResult
-		} : null;
-	}
-	if (!isNodeOfType(unwrappedExpression, "BinaryExpression")) return null;
-	const leftGlobalName = readTypeofBrowserGlobal(unwrappedExpression.left, context);
-	const rightGlobalName = readTypeofBrowserGlobal(unwrappedExpression.right, context);
-	const leftString = isNodeOfType(unwrappedExpression.left, "Literal") ? unwrappedExpression.left.value : null;
-	const rightString = isNodeOfType(unwrappedExpression.right, "Literal") ? unwrappedExpression.right.value : null;
-	const browserGlobalName = leftGlobalName && typeof rightString === "string" ? leftGlobalName : rightGlobalName && typeof leftString === "string" ? rightGlobalName : null;
-	const comparedType = leftGlobalName && typeof rightString === "string" ? rightString : rightGlobalName && typeof leftString === "string" ? leftString : null;
-	if (!browserGlobalName || !comparedType) return null;
-	const clientResult = evaluateEquality(unwrappedExpression.operator, "object", comparedType);
-	const serverResult = evaluateEquality(unwrappedExpression.operator, "undefined", comparedType);
-	if (clientResult === null || serverResult === null || clientResult === serverResult) return null;
-	return {
-		browserGlobalName,
-		clientResult,
-		serverResult
-	};
-};
-const readLogicalConditionResult = (operator, leftResult, rightResult) => {
-	if (operator === "&&") {
-		if (leftResult === false || rightResult === false) return false;
-		if (leftResult === true && rightResult === true) return true;
-		return null;
-	}
-	if (leftResult === true || rightResult === true) return true;
-	if (leftResult === false && rightResult === false) return false;
-	return null;
-};
-const readHydrationConditionResult = (expression, context, runtime) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
-	if (predicateMatch) return predicateMatch[`${runtime}Result`];
-	const staticResult = readInitialStateBoolean(unwrappedExpression, context.scopes);
-	if (staticResult !== null) return staticResult;
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		const argumentResult = readHydrationConditionResult(unwrappedExpression.argument, context, runtime);
-		return argumentResult === null ? null : !argumentResult;
-	}
-	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
-	return readLogicalConditionResult(unwrappedExpression.operator, readHydrationConditionResult(unwrappedExpression.left, context, runtime), readHydrationConditionResult(unwrappedExpression.right, context, runtime));
-};
-const matchHydrationCondition = (expression, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
-	if (predicateMatch) return {
-		predicateMatch,
-		predicateNode: unwrappedExpression
-	};
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return matchHydrationCondition(unwrappedExpression.argument, context);
-	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
-	const leftMatch = matchHydrationCondition(unwrappedExpression.left, context);
-	const rightMatch = matchHydrationCondition(unwrappedExpression.right, context);
-	if (leftMatch && rightMatch) {
-		const clientResult = readHydrationConditionResult(unwrappedExpression, context, "client");
-		const serverResult = readHydrationConditionResult(unwrappedExpression, context, "server");
-		return clientResult !== null && serverResult !== null && clientResult !== serverResult ? leftMatch : null;
-	}
-	const nestedMatch = leftMatch ?? rightMatch;
-	if (!nestedMatch) return null;
-	const otherResult = readInitialStateBoolean(leftMatch ? unwrappedExpression.right : unwrappedExpression.left, context.scopes);
-	if (unwrappedExpression.operator === "&&" && otherResult === false || unwrappedExpression.operator === "||" && otherResult === true) return null;
-	return nestedMatch;
-};
-const areNodeArraysEquivalent = (leftNodes, rightNodes) => leftNodes.length === rightNodes.length && leftNodes.every((leftNode, index) => areRenderedBranchesEquivalent(leftNode, rightNodes[index]));
-const areRenderedBranchesEquivalent = (leftNode, rightNode) => {
-	if (!leftNode || !rightNode) return leftNode === rightNode;
-	const left = stripParenExpression(leftNode);
-	const right = stripParenExpression(rightNode);
-	if (areExpressionsStructurallyEqual(left, right)) return true;
-	if (left.type !== right.type) return false;
-	if (isNodeOfType(left, "JSXText") && isNodeOfType(right, "JSXText")) return left.value === right.value;
-	if (isNodeOfType(left, "JSXExpressionContainer") && isNodeOfType(right, "JSXExpressionContainer")) {
-		if (!isAstNode(left.expression) || !isAstNode(right.expression)) return left.expression.type === right.expression.type;
-		return areRenderedBranchesEquivalent(left.expression, right.expression);
-	}
-	if (isNodeOfType(left, "JSXElement") && isNodeOfType(right, "JSXElement")) {
-		if (flattenJsxName$1(left.openingElement.name) !== flattenJsxName$1(right.openingElement.name)) return false;
-		if (!areNodeArraysEquivalent(left.openingElement.attributes, right.openingElement.attributes)) return false;
-		return areNodeArraysEquivalent(left.children, right.children);
-	}
-	if (isNodeOfType(left, "JSXFragment") && isNodeOfType(right, "JSXFragment")) return areNodeArraysEquivalent(left.children, right.children);
-	if (isNodeOfType(left, "JSXAttribute") && isNodeOfType(right, "JSXAttribute")) {
-		if (flattenJsxName$1(left.name) !== flattenJsxName$1(right.name)) return false;
-		return areRenderedBranchesEquivalent(left.value, right.value);
-	}
-	if (isNodeOfType(left, "JSXSpreadAttribute") && isNodeOfType(right, "JSXSpreadAttribute")) return areRenderedBranchesEquivalent(left.argument, right.argument);
-	if (isNodeOfType(left, "TemplateLiteral") && isNodeOfType(right, "TemplateLiteral")) {
-		if (left.quasis.length !== right.quasis.length) return false;
-		if (!left.quasis.every((quasi, index) => quasi.value.cooked === right.quasis[index]?.value.cooked && quasi.value.raw === right.quasis[index]?.value.raw)) return false;
-		return areNodeArraysEquivalent(left.expressions, right.expressions);
-	}
-	return false;
-};
-const isRenderedValue = (node) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (isNodeOfType(unwrappedNode, "Literal")) return unwrappedNode.value !== null && unwrappedNode.value !== true && unwrappedNode.value !== false && unwrappedNode.value !== "";
-	if (isNodeOfType(unwrappedNode, "TemplateLiteral")) return unwrappedNode.expressions.length > 0 || unwrappedNode.quasis[0]?.value.cooked !== "";
-	return isNodeOfType(unwrappedNode, "JSXElement") || isNodeOfType(unwrappedNode, "JSXFragment");
-};
-const findRenderedValueInAndBranch = (node) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (isRenderedValue(unwrappedNode)) return unwrappedNode;
-	if (!isNodeOfType(unwrappedNode, "LogicalExpression") || unwrappedNode.operator !== "&&") return null;
-	return findRenderedValueInAndBranch(unwrappedNode.right);
-};
-const findEnclosingJsxAttribute = (node) => {
-	let currentNode = node.parent;
-	while (currentNode) {
-		if (isNodeOfType(currentNode, "JSXAttribute")) return currentNode;
-		if (isNodeOfType(currentNode, "JSXElement") || isNodeOfType(currentNode, "JSXFragment") || isFunctionLike$1(currentNode)) return null;
-		currentNode = currentNode.parent;
-	}
-	return null;
-};
-const isInRenderedOutput = (node, componentOrHookNode, scopes) => {
-	let currentNode = node;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isNodeOfType(parentNode, "JSXExpressionContainer")) {
-			const attribute = findEnclosingJsxAttribute(parentNode);
-			return attribute ? !isEventHandlerAttribute(attribute) : true;
-		}
-		if (isNodeOfType(parentNode, "ReturnStatement")) {
-			if (findEnclosingFunction(parentNode) === componentOrHookNode) return true;
-		}
-		if (parentNode === componentOrHookNode) return isFunctionLike$1(componentOrHookNode) && !isNodeOfType(componentOrHookNode.body, "BlockStatement") && componentOrHookNode.body === currentNode;
-		if (isFunctionLike$1(parentNode) && !executesDuringRender(parentNode, scopes)) return false;
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return false;
-};
-const getReturnedValues = (statement) => {
-	if (!statement) return [];
-	if (isNodeOfType(statement, "ReturnStatement")) return statement.argument ? [statement.argument] : [];
-	if (isNodeOfType(statement, "IfStatement")) return [...getReturnedValues(statement.consequent), ...getReturnedValues(statement.alternate)];
-	if (!isNodeOfType(statement, "BlockStatement")) return [];
-	const returnedValues = [];
-	for (const childStatement of statement.body) {
-		returnedValues.push(...getReturnedValues(childStatement));
-		if (statementAlwaysExits(childStatement)) break;
-	}
-	return returnedValues;
-};
-const findFollowingReturnedValues = (ifStatement) => {
-	const parentNode = ifStatement.parent;
-	if (!isNodeOfType(parentNode, "BlockStatement")) return [];
-	const statementIndex = parentNode.body.findIndex((statement) => statement === ifStatement);
-	if (statementIndex < 0) return [];
-	const returnedValues = [];
-	for (const statement of parentNode.body.slice(statementIndex + 1)) {
-		returnedValues.push(...getReturnedValues(statement));
-		if (statementAlwaysExits(statement)) break;
-	}
-	return returnedValues;
-};
-const areConditionExpressionsEquivalent = (leftExpression, rightExpression) => {
-	const left = stripParenExpression(leftExpression);
-	const right = stripParenExpression(rightExpression);
-	if (areExpressionsStructurallyEqual(left, right)) return true;
-	if (left.type !== right.type) return false;
-	if (isNodeOfType(left, "UnaryExpression") && isNodeOfType(right, "UnaryExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.argument, right.argument);
-	if (isNodeOfType(left, "LogicalExpression") && isNodeOfType(right, "LogicalExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.left, right.left) && areConditionExpressionsEquivalent(left.right, right.right);
-	if (isNodeOfType(left, "BinaryExpression") && isNodeOfType(right, "BinaryExpression")) return left.operator === right.operator && areConditionExpressionsEquivalent(left.left, right.left) && areConditionExpressionsEquivalent(left.right, right.right);
-	return false;
-};
-const areReturnTreesEquivalent = (leftStatement, rightStatement) => {
-	if (!leftStatement || !rightStatement) return leftStatement === rightStatement;
-	if (isNodeOfType(leftStatement, "ReturnStatement") && isNodeOfType(rightStatement, "ReturnStatement")) return areRenderedBranchesEquivalent(leftStatement.argument, rightStatement.argument);
-	if (isNodeOfType(leftStatement, "IfStatement") && isNodeOfType(rightStatement, "IfStatement")) return areConditionExpressionsEquivalent(leftStatement.test, rightStatement.test) && areReturnTreesEquivalent(leftStatement.consequent, rightStatement.consequent) && areReturnTreesEquivalent(leftStatement.alternate, rightStatement.alternate);
-	if (!isNodeOfType(leftStatement, "BlockStatement") || !isNodeOfType(rightStatement, "BlockStatement")) return false;
-	const leftReturningStatements = leftStatement.body.filter((statement) => getReturnedValues(statement).length > 0);
-	const rightReturningStatements = rightStatement.body.filter((statement) => getReturnedValues(statement).length > 0);
-	return leftReturningStatements.length === rightReturningStatements.length && leftReturningStatements.every((statement, index) => areReturnTreesEquivalent(statement, rightReturningStatements[index]));
-};
-const isStructuralRenderedValue = (node) => {
-	if (!node) return false;
-	const unwrappedNode = stripParenExpression(node);
-	return isNodeOfType(unwrappedNode, "JSXElement") || isNodeOfType(unwrappedNode, "JSXFragment");
-};
-const branchRootsSuppressSameElement = (leftBranch, rightBranch) => {
-	if (!rightBranch) return false;
-	const left = stripParenExpression(leftBranch);
-	const right = stripParenExpression(rightBranch);
-	return isNodeOfType(left, "JSXElement") && isNodeOfType(right, "JSXElement") && flattenJsxName$1(left.openingElement.name) === flattenJsxName$1(right.openingElement.name) && hasSuppressHydrationWarningAttribute(left.openingElement) && hasSuppressHydrationWarningAttribute(right.openingElement);
-};
-const noHydrationBranchOnBrowserGlobal = defineRule({
-	id: "no-hydration-branch-on-browser-global",
-	title: "Server and client render different branches",
-	severity: "error",
-	category: "Correctness",
-	requires: ["ssr"],
-	recommendation: "Render the same initial output on the server and client, then switch after mount or use useSyncExternalStore with a stable server snapshot.",
-	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 reportHydrationBranch = (conditionNode, leftBranch, rightBranch, requiresRenderedContext) => {
-			const conditionMatch = matchHydrationCondition(conditionNode, context);
-			if (!conditionMatch) return;
-			const { predicateMatch, predicateNode } = conditionMatch;
-			if (reportedNodes.has(predicateNode)) return;
-			if (rightBranch && areRenderedBranchesEquivalent(leftBranch, rightBranch)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(predicateNode, context.scopes);
-			if (!componentOrHookNode) return;
-			if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-			if (requiresRenderedContext && !isInRenderedOutput(predicateNode, componentOrHookNode, context.scopes)) return;
-			if (!isRenderedValue(leftBranch) && (!rightBranch || !isRenderedValue(rightBranch))) {
-				const attribute = findEnclosingJsxAttribute(predicateNode);
-				if (!attribute || isEventHandlerAttribute(attribute)) return;
-			}
-			if (fileIsEmailTemplate || isGatedByFalsyInitialState(predicateNode, context.scopes)) return;
-			if (isAfterClientOnlyEarlyReturn(predicateNode, componentOrHookNode, context.scopes)) return;
-			const openingElement = findEnclosingJsxOpeningElement(predicateNode);
-			if (hasSuppressHydrationWarningAttribute(openingElement) && !isStructuralRenderedValue(leftBranch) && !isStructuralRenderedValue(rightBranch)) return;
-			if (branchRootsSuppressSameElement(leftBranch, rightBranch)) return;
-			if (isGeneratedImageRenderContext(context, openingElement ?? leftBranch)) return;
-			reportedNodes.add(predicateNode);
-			context.report({
-				node: predicateNode,
-				message: `\`typeof ${predicateMatch.browserGlobalName}\` selects different rendered output on the server and during hydration. Render the same initial output, then switch after mount.`
-			});
-		};
-		return {
-			Program(node) {
-				fileHasUseClientDirective = hasDirective(node, "use client");
-				fileIsEmailTemplate = hasEmailTemplateImport(node);
-			},
-			ConditionalExpression(node) {
-				reportHydrationBranch(node.test, node.consequent, node.alternate, true);
-			},
-			LogicalExpression(node) {
-				if (node.operator !== "&&" && node.operator !== "||") return;
-				const renderedValue = node.operator === "&&" ? findRenderedValueInAndBranch(node.right) : isRenderedValue(node.right) ? node.right : null;
-				if (!renderedValue) return;
-				reportHydrationBranch(node, renderedValue, null, true);
-			},
-			IfStatement(node) {
-				if (node.alternate && areReturnTreesEquivalent(node.consequent, node.alternate)) return;
-				const consequentValues = getReturnedValues(node.consequent);
-				const alternateValues = node.alternate ? getReturnedValues(node.alternate) : findFollowingReturnedValues(node);
-				if (consequentValues.length === 0 || alternateValues.length === 0) return;
-				const componentOrHookNode = findRenderPhaseComponentOrHook(node.test, context.scopes);
-				if (!componentOrHookNode) return;
-				const enclosingFunction = findEnclosingFunction(node);
-				if (enclosingFunction !== componentOrHookNode && (!enclosingFunction || !isInRenderedOutput(enclosingFunction, componentOrHookNode, context.scopes))) return;
-				for (const consequentValue of consequentValues) for (const alternateValue of alternateValues) {
-					if (!isRenderedValue(consequentValue) && !isRenderedValue(alternateValue)) continue;
-					reportHydrationBranch(node.test, consequentValue, alternateValue, false);
-				}
-			}
-		};
-	}
-});
-//#endregion
 //#region src/plugin/rules/performance/no-img-lazy-with-high-fetchpriority.ts
 const MESSAGE$22 = "`<img loading=\"lazy\">` defers the request while `fetchPriority=\"high\"` asks the browser to rush it, so the two directives contradict each other. Drop one: keep `fetchPriority=\"high\"` (and eager loading) for an LCP image, or `loading=\"lazy\"` for a below-the-fold one.";
 const noImgLazyWithHighFetchpriority = defineRule({
@@ -30877,6 +30039,111 @@ 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",
@@ -31006,12 +30273,75 @@ const matchDateDefaultStringification = (node) => {
 	}
 	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",
-	requires: ["ssr"],
+	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 {};
@@ -31021,12 +30351,13 @@ const noLocaleFormatInRender = defineRule({
 		const reportedNodes = /* @__PURE__ */ new Set();
 		const reportIfRenderPhase = (match) => {
 			if (reportedNodes.has(match.node)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(match.node, context.scopes);
+			const componentOrHookNode = findRenderPhaseComponentOrHook(match.node);
 			if (!componentOrHookNode) return;
 			if (fileIsEmailTemplate) return;
 			if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-			if (isGatedByFalsyInitialState(match.node, context.scopes)) return;
-			if (isAfterClientOnlyEarlyReturn(match.node, componentOrHookNode, context.scopes)) 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);
@@ -31053,7 +30384,7 @@ const noLocaleFormatInRender = defineRule({
 				if (!isNodeOfType(expression, "CallExpression")) return;
 				if (!isNodeOfType(expression.callee, "Identifier")) return;
 				const helperName = expression.callee.name;
-				const componentOrHookNode = findRenderPhaseComponentOrHook(node, context.scopes);
+				const componentOrHookNode = findRenderPhaseComponentOrHook(node);
 				if (!componentOrHookNode) return;
 				const helperNode = findVariableInitializer(expression.callee, helperName)?.initializer;
 				if (!helperNode || !isFunctionLike$1(helperNode)) return;
@@ -31065,8 +30396,9 @@ const noLocaleFormatInRender = defineRule({
 					if (!match || reportedNodes.has(match.node)) return;
 					if (fileIsEmailTemplate) return;
 					if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-					if (isGatedByFalsyInitialState(node, context.scopes)) return;
-					if (isAfterClientOnlyEarlyReturn(node, componentOrHookNode, context.scopes)) 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({
@@ -31168,6 +30500,9 @@ const noLongTransitionDuration = defineRule({
 const BOOLEAN_PROP_PREFIX_PATTERN = /^(?:is|has|should|can|show|hide|enable|disable|with)[A-Z]/;
 const isBooleanPrefixedPropName = (propName) => BOOLEAN_PROP_PREFIX_PATTERN.test(propName);
 //#endregion
+//#region src/plugin/utils/is-event-handler-attribute.ts
+const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && /^on[A-Z]/.test(node.name.name);
+//#endregion
 //#region src/plugin/rules/architecture/no-many-boolean-props.ts
 const IMPERATIVE_CALLBACK_PREFIX_PATTERN = /^(?:show|hide|enable|disable)[A-Z]/;
 const collectCallbackUsedNames = (componentBody, propsParam, scopes) => {
@@ -31299,7 +30634,7 @@ const noMatchMediaInStateInitializer = defineRule({
 	title: "matchMedia in state initializer",
 	severity: "warn",
 	category: "Correctness",
-	requires: ["ssr"],
+	disabledWhen: ["vite", "cra"],
 	recommendation: "Prefer CSS media queries for layout, or subscribe with `useSyncExternalStore` and provide a stable server snapshot.",
 	create: (context) => {
 		if (isTestlikeFilename(context.filename)) return {};
@@ -34103,11 +33438,7 @@ const noReactChildren = defineRule({
 //#endregion
 //#region src/plugin/rules/architecture/utils/create-deprecated-react-import-rule.ts
 const createDeprecatedReactImportRule = ({ source, messages, handleExtraSource }) => ({ create: (context) => {
-	const namespaceImportSpecifiers = /* @__PURE__ */ new Set();
-	const resolvesToNamespaceImport = (identifier) => {
-		const symbol = resolveConstIdentifierAlias(identifier, context.scopes);
-		return Boolean(symbol && namespaceImportSpecifiers.has(symbol.declarationNode));
-	};
+	const namespaceBindings = /* @__PURE__ */ new Set();
 	return {
 		ImportDeclaration(node) {
 			const sourceValue = node.source?.value;
@@ -34127,15 +33458,18 @@ const createDeprecatedReactImportRule = ({ source, messages, handleExtraSource }
 					});
 					continue;
 				}
-				if (isNodeOfType(specifier, "ImportDefaultSpecifier") || isNodeOfType(specifier, "ImportNamespaceSpecifier")) namespaceImportSpecifiers.add(specifier);
+				if (isNodeOfType(specifier, "ImportDefaultSpecifier") || isNodeOfType(specifier, "ImportNamespaceSpecifier")) {
+					const localName = specifier.local?.name;
+					if (localName) namespaceBindings.add(localName);
+				}
 			}
 		},
 		MemberExpression(node) {
-			if (namespaceImportSpecifiers.size === 0) return;
+			if (namespaceBindings.size === 0) return;
 			if (node.computed) return;
 			const receiver = stripParenExpression(node.object);
 			if (!isNodeOfType(receiver, "Identifier")) return;
-			if (!resolvesToNamespaceImport(receiver)) return;
+			if (!namespaceBindings.has(receiver.name)) return;
 			if (!isNodeOfType(node.property, "Identifier")) return;
 			const message = messages.get(node.property.name);
 			if (message) context.report({
@@ -34200,9 +33534,15 @@ 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 isVendoredShadcnUiFilename = (rawFilename) => {
+	if (!rawFilename) return false;
+	const filename = rawFilename.replaceAll("\\", "/");
+	return (filename.startsWith("/") ? filename : `/${filename}`).includes("/components/ui/");
+};
 const deprecatedReactImportRule = createDeprecatedReactImportRule({
 	source: "react",
-	messages: new Map([["createFactory", "React 19 removed createFactory. Use JSX or createElement instead."]])
+	messages: REACT_19_DEPRECATED_MESSAGES
 });
 const buildOncePerApiContext = (context) => {
 	const reportedMessages = /* @__PURE__ */ new Set();
@@ -34232,8 +33572,11 @@ const noReact19DeprecatedApis = defineRule({
 	requires: ["react:19"],
 	tags: ["test-noise", "migration-hint"],
 	severity: "warn",
-	recommendation: "Replace removed React APIs with their supported React 19 alternatives. Only runs on React 19+ projects.",
-	create: (context) => deprecatedReactImportRule.create(buildOncePerApiContext(context))
+	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));
+	}
 });
 //#endregion
 //#region src/plugin/constants/aria-element-roles.ts
@@ -36566,140 +35909,6 @@ const noUnescapedEntities = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/rules/performance/no-unguarded-browser-global-in-render-or-hook-init.ts
-const BROWSER_GLOBAL_NAMES = new Set([
-	"window",
-	"document",
-	"localStorage",
-	"sessionStorage",
-	"navigator",
-	"matchMedia"
-]);
-const getTypeofBrowserGlobalName = (expression, context) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "UnaryExpression") || unwrappedExpression.operator !== "typeof") return null;
-	const argument = stripParenExpression(unwrappedExpression.argument);
-	if (isNodeOfType(argument, "Identifier")) return BROWSER_GLOBAL_NAMES.has(argument.name) && context.scopes.isGlobalReference(argument) ? argument.name : null;
-	if (!isNodeOfType(argument, "MemberExpression") || argument.computed || !isNodeOfType(argument.object, "Identifier") || argument.object.name !== "globalThis" || !context.scopes.isGlobalReference(argument.object) || !isNodeOfType(argument.property, "Identifier") || !BROWSER_GLOBAL_NAMES.has(argument.property.name)) return null;
-	return argument.property.name;
-};
-const browserGuardCoversGlobal = (guardName, browserGlobalName) => guardName === browserGlobalName || guardName === "window" || guardName === "document";
-const mergeAvailability = (leftAvailability, rightAvailability) => {
-	if (leftAvailability === null) return rightAvailability;
-	if (rightAvailability === null) return leftAvailability;
-	return leftAvailability === rightAvailability ? leftAvailability : null;
-};
-const readAvailabilityWhenPredicate = (expression, browserGlobalName, context, predicateResult) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return readAvailabilityWhenPredicate(unwrappedExpression.argument, browserGlobalName, context, !predicateResult);
-	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
-		if (unwrappedExpression.operator === "&&" && predicateResult) return mergeAvailability(readAvailabilityWhenPredicate(unwrappedExpression.left, browserGlobalName, context, true), readAvailabilityWhenPredicate(unwrappedExpression.right, browserGlobalName, context, true));
-		if (unwrappedExpression.operator === "||" && !predicateResult) return mergeAvailability(readAvailabilityWhenPredicate(unwrappedExpression.left, browserGlobalName, context, false), readAvailabilityWhenPredicate(unwrappedExpression.right, browserGlobalName, context, false));
-		return null;
-	}
-	if (!isNodeOfType(unwrappedExpression, "BinaryExpression")) return null;
-	const leftTypeofName = getTypeofBrowserGlobalName(unwrappedExpression.left, context);
-	const rightTypeofName = getTypeofBrowserGlobalName(unwrappedExpression.right, context);
-	const leftComparedType = isNodeOfType(unwrappedExpression.left, "Literal") && typeof unwrappedExpression.left.value === "string" ? unwrappedExpression.left.value : null;
-	const rightComparedType = isNodeOfType(unwrappedExpression.right, "Literal") && typeof unwrappedExpression.right.value === "string" ? unwrappedExpression.right.value : null;
-	const guardName = leftTypeofName && rightComparedType ? leftTypeofName : rightTypeofName && leftComparedType ? rightTypeofName : null;
-	const comparedType = leftTypeofName && rightComparedType ? rightComparedType : rightTypeofName && leftComparedType ? leftComparedType : null;
-	if (!guardName || !browserGuardCoversGlobal(guardName, browserGlobalName)) return null;
-	if (!comparedType) return null;
-	const isEquality = unwrappedExpression.operator === "===" || unwrappedExpression.operator === "==";
-	const isInequality = unwrappedExpression.operator === "!==" || unwrappedExpression.operator === "!=";
-	if (!isEquality && !isInequality) return null;
-	const browserType = guardName === "matchMedia" ? "function" : "object";
-	const browserResult = isEquality ? browserType === comparedType : browserType !== comparedType;
-	if (browserResult === (isEquality ? comparedType === "undefined" : comparedType !== "undefined")) return null;
-	return predicateResult === browserResult;
-};
-const isInsideAvailabilityGuard = (node, browserGlobalName, context) => {
-	let currentNode = node;
-	let parentNode = currentNode.parent;
-	while (parentNode) {
-		if (isFunctionLike$1(parentNode) && !executesDuringRender(parentNode, context.scopes)) break;
-		if (isNodeOfType(parentNode, "LogicalExpression") && (parentNode.operator === "&&" || parentNode.operator === "||") && parentNode.right === currentNode && readAvailabilityWhenPredicate(parentNode.left, browserGlobalName, context, parentNode.operator === "&&") === true) return true;
-		if (isNodeOfType(parentNode, "ConditionalExpression")) {
-			if (parentNode.consequent === currentNode && readAvailabilityWhenPredicate(parentNode.test, browserGlobalName, context, true) === true || parentNode.alternate === currentNode && readAvailabilityWhenPredicate(parentNode.test, browserGlobalName, context, false) === true) return true;
-		}
-		if (isNodeOfType(parentNode, "IfStatement")) {
-			if (parentNode.consequent === currentNode && readAvailabilityWhenPredicate(parentNode.test, browserGlobalName, context, true) === true || parentNode.alternate === currentNode && readAvailabilityWhenPredicate(parentNode.test, browserGlobalName, context, false) === true) return true;
-		}
-		currentNode = parentNode;
-		parentNode = currentNode.parent;
-	}
-	return false;
-};
-const isAfterAvailabilityEarlyExit = (node, componentOrHookNode, browserGlobalName, context) => {
-	const enclosingFunction = findEnclosingFunction(node);
-	if (!enclosingFunction || enclosingFunction !== componentOrHookNode && !executesDuringRender(enclosingFunction, context.scopes) || !isFunctionLike$1(enclosingFunction) || !isNodeOfType(enclosingFunction.body, "BlockStatement")) return false;
-	let currentNode = node;
-	while (currentNode !== enclosingFunction) {
-		const parentNode = currentNode.parent;
-		if (!parentNode) return false;
-		if (isNodeOfType(parentNode, "BlockStatement")) for (const statement of parentNode.body) {
-			if (statement === currentNode) break;
-			if (!isNodeOfType(statement, "IfStatement")) continue;
-			if (readAvailabilityWhenPredicate(statement.test, browserGlobalName, context, false) === true && statementAlwaysExits(statement.consequent)) return true;
-			if (readAvailabilityWhenPredicate(statement.test, browserGlobalName, context, true) === true && statement.alternate && statementAlwaysExits(statement.alternate)) return true;
-		}
-		currentNode = parentNode;
-	}
-	return false;
-};
-const isTypeofProbe = (node) => {
-	const expressionRoot = findTransparentExpressionRoot(node);
-	const parentNode = expressionRoot.parent;
-	return isNodeOfType(parentNode, "UnaryExpression") && parentNode.operator === "typeof" && parentNode.argument === expressionRoot;
-};
-const noUnguardedBrowserGlobalInRenderOrHookInit = defineRule({
-	id: "no-unguarded-browser-global-in-render-or-hook-init",
-	title: "Browser global read during server render",
-	severity: "error",
-	category: "Correctness",
-	requires: ["ssr"],
-	recommendation: "Move browser-only reads into an effect or event, guard them behind a client-only render path, or use useSyncExternalStore with a stable server snapshot.",
-	create: (context) => {
-		if (isTestlikeFilename(context.filename)) return {};
-		if (classifyReactNativeFileTarget(context) === "react-native") return {};
-		let fileIsEmailTemplate = false;
-		const reportedNodes = /* @__PURE__ */ new Set();
-		const reportBrowserRead = (node, browserGlobalName) => {
-			if (reportedNodes.has(node) || isTypeofProbe(node)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(node, context.scopes);
-			if (!componentOrHookNode) return;
-			if (fileIsEmailTemplate) return;
-			if (isGeneratedImageRenderContext(context, findEnclosingJsxOpeningElement(node) ?? node)) return;
-			if (isGatedByFalsyInitialState(node, context.scopes)) return;
-			if (isAfterClientOnlyEarlyReturn(node, componentOrHookNode, context.scopes)) return;
-			if (isInsideAvailabilityGuard(node, browserGlobalName, context)) return;
-			if (isAfterAvailabilityEarlyExit(node, componentOrHookNode, browserGlobalName, context)) return;
-			reportedNodes.add(node);
-			context.report({
-				node,
-				message: `\`${browserGlobalName}\` is read while React is rendering on the server, where browser globals are unavailable. Move the read into an effect or event, or provide a stable server snapshot.`
-			});
-		};
-		return {
-			Program(node) {
-				fileIsEmailTemplate = hasEmailTemplateImport(node);
-			},
-			Identifier(node) {
-				if (!BROWSER_GLOBAL_NAMES.has(node.name)) return;
-				if (!context.scopes.isGlobalReference(node)) return;
-				reportBrowserRead(node, node.name);
-			},
-			MemberExpression(node) {
-				if (node.computed) return;
-				const objectNode = stripParenExpression(node.object);
-				if (!isNodeOfType(objectNode, "Identifier") || objectNode.name !== "globalThis" || !context.scopes.isGlobalReference(objectNode) || !isNodeOfType(node.property, "Identifier") || !BROWSER_GLOBAL_NAMES.has(node.property.name)) return;
-				reportBrowserRead(node, node.property.name);
-			}
-		};
-	}
-});
-//#endregion
 //#region src/plugin/constants/dom-aria-properties.ts
 const ARIA_PROPERTY_NAMES = new Set([
 	"activedescendant",
@@ -42010,7 +41219,7 @@ const renderingHydrationMismatchTime = defineRule({
 	title: "Time or random value in JSX",
 	severity: "warn",
 	category: "Correctness",
-	requires: ["ssr"],
+	disabledWhen: ["vite", "cra"],
 	recommendation: "Move time or random values into useEffect+useState so they only run in the browser, or add suppressHydrationWarning to the parent if it's intentional",
 	create: (context) => {
 		const isTestlikeFile = isTestlikeFilename(context.filename);
@@ -42024,7 +41233,8 @@ const renderingHydrationMismatchTime = defineRule({
 			const matched = NONDETERMINISTIC_RENDER_PATTERNS.find((pattern) => pattern.matches(node.expression));
 			if (matched) {
 				if (hasSuppressHydrationWarningAttribute(findOpeningElementOfChild(node))) return;
-				if (isGatedByFalsyInitialState(node, context.scopes)) return;
+				if (isInsideClientOnlyGuard(node)) return;
+				if (isGatedByFalsyInitialState(node)) return;
 				if (isInsideMotionTransitionAttribute(node)) return;
 				context.report({
 					node,
@@ -42033,10 +41243,11 @@ const renderingHydrationMismatchTime = defineRule({
 				return;
 			}
 			walkAst(node.expression, (child) => {
-				if (isFunctionLike$1(child) && !executesDuringRender(child, context.scopes)) return false;
+				if (isFunctionLike$1(child) && !executesDuringRender(child)) return false;
 				for (const pattern of NONDETERMINISTIC_RENDER_PATTERNS) if (pattern.matches(child)) {
 					if (hasSuppressHydrationWarningAttribute(findOpeningElementOfChild(node))) return;
-					if (isGatedByFalsyInitialState(child, context.scopes)) return;
+					if (isInsideClientOnlyGuard(child)) return;
+					if (isGatedByFalsyInitialState(child)) return;
 					if (isInsideMotionTransitionAttribute(child)) return;
 					if (pattern.display === "new Date()" && isYearOnlyDateRead(child)) return;
 					context.report({
@@ -55373,18 +54584,6 @@ const reactDoctorRules = [
 			category: "Accessibility"
 		}
 	},
-	{
-		key: "react-doctor/no-hydration-branch-on-browser-global",
-		id: "no-hydration-branch-on-browser-global",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noHydrationBranchOnBrowserGlobal,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noHydrationBranchOnBrowserGlobal.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-img-lazy-with-high-fetchpriority",
 		id: "no-img-lazy-with-high-fetchpriority",
@@ -56148,18 +55347,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noUnescapedEntities.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/no-unguarded-browser-global-in-render-or-hook-init",
-		id: "no-unguarded-browser-global-in-render-or-hook-init",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noUnguardedBrowserGlobalInRenderOrHookInit,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noUnguardedBrowserGlobalInRenderOrHookInit.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-unknown-property",
 		id: "no-unknown-property",
@@ -58492,12 +57679,10 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"nextjs-no-use-search-params-without-suspense",
 	"no-dynamic-import-path",
 	"no-full-lodash-import",
-	"no-hydration-branch-on-browser-global",
 	"no-indeterminate-attribute",
 	"no-locale-format-in-render",
 	"no-match-media-in-state-initializer",
 	"no-mutating-reducer-state",
-	"no-unguarded-browser-global-in-render-or-hook-init",
 	"prefer-dynamic-import",
 	"rendering-hydration-mismatch-time",
 	"rn-no-legacy-shadow-styles",
@@ -58631,12 +57816,10 @@ 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-hydration-branch-on-browser-global", collectNearestManifestDependencies],
 	["no-indeterminate-attribute", collectNearestManifestDependencies],
 	["no-locale-format-in-render", collectNearestManifestDependencies],
 	["no-match-media-in-state-initializer", collectNearestManifestDependencies],
 	["no-mutating-reducer-state", collectMutatingReducerDependencies],
-	["no-unguarded-browser-global-in-render-or-hook-init", collectNearestManifestDependencies],
 	["prefer-dynamic-import", collectNearestManifestDependencies],
 	["rendering-hydration-mismatch-time", collectNearestManifestDependencies],
 	["rn-no-legacy-shadow-styles", collectLegacyArchDependencies],