oxlint-plugin-react-doctor 0.7.9-dev.b30fb80 → 0.7.9-dev.c7f61cd

package/dist/index.js

@@ -579,6 +579,22 @@ const EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS = new Set([
 	"ResizeObserver",
 	"PerformanceObserver"
 ]);
+const EXTERNAL_SYNC_DOM_MEMBER_METHOD_NAMES = new Set([
+	"blur",
+	"focus",
+	"getBoundingClientRect",
+	"getClientRects",
+	"measure",
+	"measureInWindow",
+	"measureLayout",
+	"scroll",
+	"scrollBy",
+	"scrollIntoView",
+	"scrollTo",
+	"select",
+	"setRangeText",
+	"setSelectionRange"
+]);
 const STORAGE_OBJECTS = new Set(["localStorage", "sessionStorage"]);
 //#endregion
 //#region src/plugin/constants/react.ts
@@ -1819,8 +1835,70 @@ const flattenJsxName$1 = (node) => {
 	return null;
 };
 //#endregion
-//#region src/plugin/utils/is-member-property.ts
-const isMemberProperty = (node, propertyName) => Boolean(node && isNodeOfType(node, "MemberExpression") && isNodeOfType(node.property, "Identifier") && node.property.name === propertyName);
+//#region src/plugin/utils/get-static-property-name.ts
+const getStaticPropertyName = (memberExpression) => {
+	const property = memberExpression.property;
+	if (!memberExpression.computed && isNodeOfType(property, "Identifier")) return property.name;
+	if (memberExpression.computed && isNodeOfType(property, "Literal")) return typeof property.value === "string" ? property.value : null;
+	if (memberExpression.computed && isNodeOfType(property, "TemplateLiteral") && property.expressions.length === 0) return property.quasis[0]?.value.cooked ?? property.quasis[0]?.value.raw ?? null;
+	return null;
+};
+//#endregion
+//#region src/plugin/utils/is-generated-image-renderer-call.ts
+const GENERATED_IMAGE_RENDERER_MODULES = [
+	"next/og",
+	"@vercel/og",
+	"satori"
+];
+const IMAGE_RESPONSE_MODULES = new Set(["next/og", "@vercel/og"]);
+const getImportDeclaration$1 = (node) => {
+	let current = node.parent;
+	while (current) {
+		if (isNodeOfType(current, "ImportDeclaration")) return current;
+		if (isNodeOfType(current, "Program")) return null;
+		current = current.parent;
+	}
+	return null;
+};
+const getImportSource = (declaration) => typeof declaration.source.value === "string" ? declaration.source.value : null;
+const isNamedImport = (symbol, importedName, moduleSources) => {
+	if (symbol.kind !== "import") return false;
+	const declaration = symbol.declarationNode;
+	if (!isNodeOfType(declaration, "ImportSpecifier")) return false;
+	const importDeclaration = getImportDeclaration$1(declaration);
+	const source = importDeclaration ? getImportSource(importDeclaration) : null;
+	if (!source || !moduleSources.has(source)) return false;
+	const imported = declaration.imported;
+	return isNodeOfType(imported, "Identifier") && imported.name === importedName || isNodeOfType(imported, "Literal") && imported.value === importedName;
+};
+const isSatoriImport = (symbol) => {
+	if (symbol.kind !== "import") return false;
+	const declaration = symbol.declarationNode;
+	const importDeclaration = getImportDeclaration$1(declaration);
+	if (!importDeclaration || getImportSource(importDeclaration) !== "satori") return false;
+	if (isNodeOfType(declaration, "ImportDefaultSpecifier")) return true;
+	if (!isNodeOfType(declaration, "ImportSpecifier")) return false;
+	const imported = declaration.imported;
+	return isNodeOfType(imported, "Identifier") && imported.name === "satori" || isNodeOfType(imported, "Literal") && imported.value === "satori";
+};
+const isGeneratedImageRendererCall = (node, scopes) => {
+	if (!isNodeOfType(node, "CallExpression") && !isNodeOfType(node, "NewExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (isNodeOfType(callee, "Identifier")) {
+		const symbol = scopes.referenceFor(callee)?.resolvedSymbol ?? null;
+		return Boolean(symbol && (isNamedImport(symbol, "ImageResponse", IMAGE_RESPONSE_MODULES) || isSatoriImport(symbol)));
+	}
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	if (getStaticPropertyName(callee) !== "ImageResponse") return false;
+	if (!isNodeOfType(callee.object, "Identifier")) return false;
+	const symbol = scopes.referenceFor(callee.object)?.resolvedSymbol ?? null;
+	if (!symbol || symbol.kind !== "import") return false;
+	const declaration = symbol.declarationNode;
+	if (!isNodeOfType(declaration, "ImportNamespaceSpecifier")) return false;
+	const importDeclaration = getImportDeclaration$1(declaration);
+	const source = importDeclaration ? getImportSource(importDeclaration) : null;
+	return Boolean(source && IMAGE_RESPONSE_MODULES.has(source));
+};
 //#endregion
 //#region src/plugin/constants/nextjs.ts
 const NEXTJS_SOURCE_FILE_EXTENSION_GROUP = "(?:tsx?|jsx?|mts|mjs)";
@@ -1892,42 +1970,22 @@ const isNextjsMetadataImageRouteFilename = (rawFilename) => {
 const normalizeFilename = (filename) => filename.includes("\\") ? filename.replaceAll("\\", "/") : filename;
 //#endregion
 //#region src/plugin/utils/is-generated-image-render-context.ts
-const IMAGE_RESPONSE_MODULES = ["next/og", "@vercel/og"];
-const SATORI_MODULE = "satori";
-const GENERATED_IMAGE_MODULES = [...IMAGE_RESPONSE_MODULES, SATORI_MODULE];
 const generatedImageJsxCache = /* @__PURE__ */ new WeakMap();
 const isGeneratedImageRenderFilename = (rawFilename) => {
 	if (!rawFilename) return false;
 	return isNextjsMetadataImageRouteFilename(normalizeFilename(rawFilename));
 };
-const isImageResponseCallee = (contextNode, callee) => {
-	if (isNodeOfType(callee, "Identifier")) return IMAGE_RESPONSE_MODULES.some((moduleSource) => getImportedNameFromModule(contextNode, callee.name, moduleSource) === "ImageResponse");
-	if (!isMemberProperty(callee, "ImageResponse")) return false;
-	if (!isNodeOfType(callee.object, "Identifier")) return false;
-	const namespaceIdentifierName = callee.object.name;
-	return IMAGE_RESPONSE_MODULES.some((moduleSource) => isNamespaceImportFromModule(contextNode, namespaceIdentifierName, moduleSource));
-};
-const isSatoriCallee = (contextNode, callee) => {
-	if (!isNodeOfType(callee, "Identifier")) return false;
-	if (getImportedNameFromModule(contextNode, callee.name, SATORI_MODULE) === "satori") return true;
-	return isDefaultImportFromModule(contextNode, callee.name, SATORI_MODULE);
-};
-const isGeneratedImageRendererCall = (node) => {
-	if (!isNodeOfType(node, "CallExpression") && !isNodeOfType(node, "NewExpression")) return false;
-	if (!isNodeOfType(node.callee, "Identifier") && !isNodeOfType(node.callee, "MemberExpression")) return false;
-	return isImageResponseCallee(node, node.callee) || isSatoriCallee(node, node.callee);
-};
 const isComponentIdentifierName = (name) => {
 	const firstCharacter = name[0];
 	return Boolean(firstCharacter && firstCharacter === firstCharacter.toUpperCase());
 };
 const isFunctionLike = (node) => Boolean(node && (isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression")));
-const markFunctionReturnJsx = (functionNode, programRoot, generatedImageJsxNodes, visitedComponentNames) => {
+const markFunctionReturnJsx = (functionNode, programRoot, scopes, generatedImageJsxNodes, visitedComponentNames) => {
 	if (!isFunctionLike(functionNode)) return;
 	if (isNodeOfType(functionNode, "ArrowFunctionExpression")) {
 		const body = stripParenExpression(functionNode.body);
 		if (!isNodeOfType(body, "BlockStatement")) {
-			markGeneratedImageExpression(body, programRoot, generatedImageJsxNodes, visitedComponentNames);
+			markGeneratedImageExpression(body, programRoot, scopes, generatedImageJsxNodes, visitedComponentNames);
 			return;
 		}
 	}
@@ -1937,7 +1995,7 @@ const markFunctionReturnJsx = (functionNode, programRoot, generatedImageJsxNodes
 		if (descendantNode !== body && isFunctionLike(descendantNode)) return false;
 		if (!isNodeOfType(descendantNode, "ReturnStatement")) return;
 		if (!descendantNode.argument) return;
-		markGeneratedImageExpression(stripParenExpression(descendantNode.argument), programRoot, generatedImageJsxNodes, visitedComponentNames);
+		markGeneratedImageExpression(stripParenExpression(descendantNode.argument), programRoot, scopes, generatedImageJsxNodes, visitedComponentNames);
 	});
 };
 const hasNormalJsxUsage = (programRoot, componentName, generatedImageJsxNodes) => {
@@ -1952,7 +2010,7 @@ const hasNormalJsxUsage = (programRoot, componentName, generatedImageJsxNodes) =
 	});
 	return hasNormalUsage;
 };
-const markComponentRenderJsx = (programRoot, openingElement, generatedImageJsxNodes, visitedComponentNames) => {
+const markComponentRenderJsx = (programRoot, scopes, openingElement, generatedImageJsxNodes, visitedComponentNames) => {
 	const tagName = flattenJsxName$1(openingElement.name);
 	if (!tagName || tagName.includes(".") || !isComponentIdentifierName(tagName)) return;
 	if (visitedComponentNames.has(tagName)) return;
@@ -1960,70 +2018,70 @@ const markComponentRenderJsx = (programRoot, openingElement, generatedImageJsxNo
 	const binding = findVariableInitializer(openingElement, tagName);
 	if (!binding?.initializer) return;
 	visitedComponentNames.add(tagName);
-	markGeneratedImageExpression(stripParenExpression(binding.initializer), programRoot, generatedImageJsxNodes, visitedComponentNames);
+	markGeneratedImageExpression(stripParenExpression(binding.initializer), programRoot, scopes, generatedImageJsxNodes, visitedComponentNames);
 };
-const isInsideGeneratedImageRendererArgument = (node) => {
+const isInsideGeneratedImageRendererArgument$1 = (node, scopes) => {
 	let cursor = node.parent;
 	while (cursor) {
-		if (isGeneratedImageRendererCall(cursor)) return true;
+		if (isGeneratedImageRendererCall(cursor, scopes)) return true;
 		cursor = cursor.parent ?? null;
 	}
 	return false;
 };
-const hasNormalFunctionCallUsage = (programRoot, functionName) => {
+const hasNormalFunctionCallUsage = (programRoot, functionName, scopes) => {
 	let hasNormalUsage = false;
 	walkAst(programRoot, (descendantNode) => {
 		if (hasNormalUsage) return false;
 		if (!isNodeOfType(descendantNode, "CallExpression")) return;
 		if (!isNodeOfType(descendantNode.callee, "Identifier")) return;
 		if (descendantNode.callee.name !== functionName) return;
-		if (isInsideGeneratedImageRendererArgument(descendantNode)) return;
+		if (isInsideGeneratedImageRendererArgument$1(descendantNode, scopes)) return;
 		hasNormalUsage = true;
 		return false;
 	});
 	return hasNormalUsage;
 };
-const markJsxSubtree = (node, programRoot, generatedImageJsxNodes, visitedComponentNames) => {
+const markJsxSubtree = (node, programRoot, scopes, generatedImageJsxNodes, visitedComponentNames) => {
 	walkAst(node, (descendantNode) => {
 		if (!isNodeOfType(descendantNode, "JSXOpeningElement")) return;
 		generatedImageJsxNodes.add(descendantNode);
-		markComponentRenderJsx(programRoot, descendantNode, generatedImageJsxNodes, visitedComponentNames);
+		markComponentRenderJsx(programRoot, scopes, descendantNode, generatedImageJsxNodes, visitedComponentNames);
 	});
 };
-const markGeneratedImageExpression = (expression, programRoot, generatedImageJsxNodes, visitedComponentNames) => {
+const markGeneratedImageExpression = (expression, programRoot, scopes, generatedImageJsxNodes, visitedComponentNames) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	if (isNodeOfType(unwrappedExpression, "JSXElement") || isNodeOfType(unwrappedExpression, "JSXFragment")) {
-		markJsxSubtree(unwrappedExpression, programRoot, generatedImageJsxNodes, visitedComponentNames);
+		markJsxSubtree(unwrappedExpression, programRoot, scopes, generatedImageJsxNodes, visitedComponentNames);
 		return;
 	}
 	if (isFunctionLike(unwrappedExpression)) {
-		markFunctionReturnJsx(unwrappedExpression, programRoot, generatedImageJsxNodes, visitedComponentNames);
+		markFunctionReturnJsx(unwrappedExpression, programRoot, scopes, generatedImageJsxNodes, visitedComponentNames);
 		return;
 	}
 	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) {
-		markGeneratedImageExpression(unwrappedExpression.consequent, programRoot, generatedImageJsxNodes, visitedComponentNames);
-		markGeneratedImageExpression(unwrappedExpression.alternate, programRoot, generatedImageJsxNodes, visitedComponentNames);
+		markGeneratedImageExpression(unwrappedExpression.consequent, programRoot, scopes, generatedImageJsxNodes, visitedComponentNames);
+		markGeneratedImageExpression(unwrappedExpression.alternate, programRoot, scopes, generatedImageJsxNodes, visitedComponentNames);
 		return;
 	}
 	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
-		markGeneratedImageExpression(unwrappedExpression.left, programRoot, generatedImageJsxNodes, visitedComponentNames);
-		markGeneratedImageExpression(unwrappedExpression.right, programRoot, generatedImageJsxNodes, visitedComponentNames);
+		markGeneratedImageExpression(unwrappedExpression.left, programRoot, scopes, generatedImageJsxNodes, visitedComponentNames);
+		markGeneratedImageExpression(unwrappedExpression.right, programRoot, scopes, generatedImageJsxNodes, visitedComponentNames);
 		return;
 	}
 	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
 		const callee = unwrappedExpression.callee;
 		if (isFunctionLike(callee)) {
-			markFunctionReturnJsx(callee, programRoot, generatedImageJsxNodes, visitedComponentNames);
+			markFunctionReturnJsx(callee, programRoot, scopes, generatedImageJsxNodes, visitedComponentNames);
 			return;
 		}
 		if (!isNodeOfType(callee, "Identifier")) return;
 		if (visitedComponentNames.has(callee.name)) return;
 		if (hasNormalJsxUsage(programRoot, callee.name, generatedImageJsxNodes)) return;
-		if (hasNormalFunctionCallUsage(programRoot, callee.name)) return;
+		if (hasNormalFunctionCallUsage(programRoot, callee.name, scopes)) return;
 		const binding = findVariableInitializer(callee, callee.name);
 		if (!binding?.initializer || !isFunctionLike(stripParenExpression(binding.initializer))) return;
 		visitedComponentNames.add(callee.name);
-		markFunctionReturnJsx(stripParenExpression(binding.initializer), programRoot, generatedImageJsxNodes, visitedComponentNames);
+		markFunctionReturnJsx(stripParenExpression(binding.initializer), programRoot, scopes, generatedImageJsxNodes, visitedComponentNames);
 		return;
 	}
 	if (isNodeOfType(unwrappedExpression, "Identifier")) {
@@ -2031,16 +2089,17 @@ const markGeneratedImageExpression = (expression, programRoot, generatedImageJsx
 		visitedComponentNames.add(unwrappedExpression.name);
 		const binding = findVariableInitializer(unwrappedExpression, unwrappedExpression.name);
 		if (!binding?.initializer) return;
-		markGeneratedImageExpression(stripParenExpression(binding.initializer), programRoot, generatedImageJsxNodes, visitedComponentNames);
+		markGeneratedImageExpression(stripParenExpression(binding.initializer), programRoot, scopes, generatedImageJsxNodes, visitedComponentNames);
 	}
 };
-const collectGeneratedImageJsxNodes = (programRoot) => {
+const collectGeneratedImageJsxNodes = (programRoot, scopes) => {
 	const cached = generatedImageJsxCache.get(programRoot);
 	if (cached) return cached;
 	const generatedImageJsxNodes = /* @__PURE__ */ new WeakSet();
-	if (hasImportFromModules(programRoot, GENERATED_IMAGE_MODULES)) walkAst(programRoot, (descendantNode) => {
-		if (!isGeneratedImageRendererCall(descendantNode)) return;
-		for (const argument of descendantNode.arguments) markGeneratedImageExpression(argument, programRoot, generatedImageJsxNodes, /* @__PURE__ */ new Set());
+	if (hasImportFromModules(programRoot, GENERATED_IMAGE_RENDERER_MODULES)) walkAst(programRoot, (descendantNode) => {
+		if (!isNodeOfType(descendantNode, "CallExpression") && !isNodeOfType(descendantNode, "NewExpression")) return;
+		if (!isGeneratedImageRendererCall(descendantNode, scopes)) return;
+		for (const argument of descendantNode.arguments) markGeneratedImageExpression(argument, programRoot, scopes, generatedImageJsxNodes, /* @__PURE__ */ new Set());
 	});
 	generatedImageJsxCache.set(programRoot, generatedImageJsxNodes);
 	return generatedImageJsxNodes;
@@ -2050,7 +2109,7 @@ const isGeneratedImageRenderContext = (context, node) => {
 	if (!node) return false;
 	const programRoot = findProgramRoot(node);
 	if (!programRoot) return false;
-	const generatedImageJsxNodes = collectGeneratedImageJsxNodes(programRoot);
+	const generatedImageJsxNodes = collectGeneratedImageJsxNodes(programRoot, context.scopes);
 	if (generatedImageJsxNodes.has(node)) return true;
 	if (isNodeOfType(node, "JSXElement")) return generatedImageJsxNodes.has(node.openingElement);
 	return false;
@@ -4496,15 +4555,6 @@ const getDestructuredBindingPropertyName = (bindingIdentifier) => {
 	return getStaticPropertyKeyName(property, { allowComputedString: true });
 };
 //#endregion
-//#region src/plugin/utils/get-static-property-name.ts
-const getStaticPropertyName = (memberExpression) => {
-	const property = memberExpression.property;
-	if (!memberExpression.computed && isNodeOfType(property, "Identifier")) return property.name;
-	if (memberExpression.computed && isNodeOfType(property, "Literal")) return typeof property.value === "string" ? property.value : null;
-	if (memberExpression.computed && isNodeOfType(property, "TemplateLiteral") && property.expressions.length === 0) return property.quasis[0]?.value.cooked ?? property.quasis[0]?.value.raw ?? null;
-	return null;
-};
-//#endregion
 //#region src/plugin/utils/has-static-property-write-before.ts
 const equivalentSymbolsByAnalysis = /* @__PURE__ */ new WeakMap();
 const potentiallyAliasedSymbolsByAnalysis = /* @__PURE__ */ new WeakMap();
@@ -8200,6 +8250,9 @@ const createMethodMutationAnalysis = (context) => {
 	};
 };
 //#endregion
+//#region src/plugin/utils/is-member-property.ts
+const isMemberProperty = (node, propertyName) => Boolean(node && isNodeOfType(node, "MemberExpression") && isNodeOfType(node.property, "Identifier") && node.property.name === propertyName);
+//#endregion
 //#region src/plugin/utils/collect-function-return-statements.ts
 const collectFunctionReturnStatements = (functionNode) => {
 	if (!isFunctionLike$1(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return [];
@@ -14364,14 +14417,14 @@ const DEPENDENCY_HOOK_NAMES = new Set([
 	"useImperativeHandle",
 	"useInsertionEffect"
 ]);
-const crossFileScopes = /* @__PURE__ */ new WeakMap();
+const crossFileScopes$1 = /* @__PURE__ */ new WeakMap();
 const crossFileControlFlow = /* @__PURE__ */ new WeakMap();
 const forwardedFreshDependencyCache = /* @__PURE__ */ new WeakMap();
-const getCrossFileScopes = (resolved) => {
-	const cached = crossFileScopes.get(resolved.programNode);
+const getCrossFileScopes$1 = (resolved) => {
+	const cached = crossFileScopes$1.get(resolved.programNode);
 	if (cached) return cached;
 	const scopes = analyzeScopes(resolved.programNode);
-	crossFileScopes.set(resolved.programNode, scopes);
+	crossFileScopes$1.set(resolved.programNode, scopes);
 	return scopes;
 };
 const getCrossFileControlFlow = (resolved) => {
@@ -14406,7 +14459,7 @@ const isCustomHookFunction = (functionNode, fallbackName) => {
 	const displayName = componentOrHookDisplayNameForFunction(functionNode) ?? fallbackName ?? "";
 	return /^use[A-Z0-9]/.test(displayName);
 };
-const getImportedHookBinding = (callee, scopes) => {
+const getImportedHookBinding$1 = (callee, scopes) => {
 	if (!isNodeOfType(callee, "Identifier")) return null;
 	const importedSymbol = resolveConstIdentifierAlias(callee, scopes);
 	if (importedSymbol?.kind !== "import" || !importedSymbol.initializer) return null;
@@ -14422,7 +14475,7 @@ const getImportedHookBinding = (callee, scopes) => {
 };
 const resolveImportedHookFunction = (callee, scopes, currentFilename) => {
 	if (!currentFilename) return null;
-	const importedBinding = getImportedHookBinding(callee, scopes);
+	const importedBinding = getImportedHookBinding$1(callee, scopes);
 	if (!importedBinding) return null;
 	const resolved = resolveCrossFileFunctionExportWithFilePath(currentFilename, importedBinding.source, importedBinding.exportedName);
 	if (!resolved || !isCustomHookFunction(resolved.functionNode, importedBinding.exportedName)) return null;
@@ -14431,7 +14484,7 @@ const resolveImportedHookFunction = (callee, scopes, currentFilename) => {
 		filePath: resolved.filePath,
 		functionNode: resolved.functionNode,
 		programNode: resolved.programNode,
-		scopes: getCrossFileScopes(resolved)
+		scopes: getCrossFileScopes$1(resolved)
 	};
 };
 const dependencyIndexForReactHookReference = (expression, scopes, dependencyHookNames, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
@@ -14462,11 +14515,11 @@ const dependencyIndexForReactHookReference = (expression, scopes, dependencyHook
 };
 const getImportedReactDependencyIndex = (callExpression, scopes, currentFilename, dependencyHookNames) => {
 	if (!currentFilename) return null;
-	const importedBinding = getImportedHookBinding(stripParenExpression(callExpression.callee), scopes);
+	const importedBinding = getImportedHookBinding$1(stripParenExpression(callExpression.callee), scopes);
 	if (!importedBinding) return null;
 	const resolved = resolveCrossFileValueExportWithFilePath(currentFilename, importedBinding.source, importedBinding.exportedName);
 	if (!resolved) return null;
-	return dependencyIndexForReactHookReference(resolved.exportedNode, getCrossFileScopes(resolved), dependencyHookNames);
+	return dependencyIndexForReactHookReference(resolved.exportedNode, getCrossFileScopes$1(resolved), dependencyHookNames);
 };
 const resolveHookFunction = (callExpression, scopes, cfg, currentFilename) => {
 	const callee = stripParenExpression(callExpression.callee);
@@ -19181,10 +19234,10 @@ const isUncacheableOptionsMergeUtility = (node) => {
 		return (argument.properties ?? []).some((property) => isNodeOfType(property, "SpreadElement") && isNodeOfType(property.argument, "Identifier") && parameterNames.has(property.argument.name));
 	});
 };
-const isIntlNewExpression = (node) => {
+const isIntlNewExpression = (node, context) => {
 	if (!isNodeOfType(node, "NewExpression")) return false;
 	const callee = node.callee;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "Intl" && isNodeOfType(callee.property, "Identifier") && INTL_CLASSES.has(callee.property.name)) return true;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "Intl" && context.scopes.isGlobalReference(callee.object) && isNodeOfType(callee.property, "Identifier") && INTL_CLASSES.has(callee.property.name)) return true;
 	return false;
 };
 const jsHoistIntl = defineRule({
@@ -19194,7 +19247,7 @@ const jsHoistIntl = defineRule({
 	severity: "warn",
 	recommendation: "Move `new Intl.NumberFormat(...)` to the top of the file or wrap it in `useMemo`. Building one is slow, so don't redo it on every call",
 	create: (context) => ({ NewExpression(node) {
-		if (!isIntlNewExpression(node)) return;
+		if (!isIntlNewExpression(node, context)) return;
 		let cursor = node.parent ?? null;
 		let inFunctionBody = false;
 		while (cursor) {
@@ -19959,6 +20012,28 @@ const jsLengthCheckFirst = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/is-proven-global-namespace-reference.ts
+const isProvenGlobalObjectReference = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(strippedExpression, "Identifier")) return false;
+	if ((strippedExpression.name === "globalThis" || strippedExpression.name === "window" || strippedExpression.name === "self" || strippedExpression.name === "global") && scopes.isGlobalReference(strippedExpression)) return true;
+	const symbol = scopes.symbolFor(strippedExpression);
+	if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isProvenGlobalObjectReference(symbol.initializer, scopes, visitedSymbolIds);
+};
+const isProvenGlobalNamespaceReference = (expression, namespaceName, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Identifier")) {
+		if (strippedExpression.name === namespaceName && scopes.isGlobalReference(strippedExpression)) return true;
+		const symbol = scopes.symbolFor(strippedExpression);
+		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
+		visitedSymbolIds.add(symbol.id);
+		return isProvenGlobalNamespaceReference(symbol.initializer, namespaceName, scopes, visitedSymbolIds);
+	}
+	return isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isProvenGlobalObjectReference(strippedExpression.object, scopes);
+};
+//#endregion
 //#region src/plugin/rules/js-performance/js-min-max-loop.ts
 const builtinMutationByProgram = /* @__PURE__ */ new WeakMap();
 const RUNTIMELESS_SYMBOL_KINDS = new Set(["ts-interface", "ts-type-alias"]);
@@ -20015,26 +20090,6 @@ const isSafeFreshNumericArray = (arrayExpression) => {
 	}
 	return !(didFindPositiveZero && didFindNegativeZero);
 };
-const isGlobalObjectReference = (expression, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
-	const strippedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(strippedExpression, "Identifier")) return false;
-	if ((strippedExpression.name === "globalThis" || strippedExpression.name === "window" || strippedExpression.name === "self" || strippedExpression.name === "global") && scopes.isGlobalReference(strippedExpression)) return true;
-	const symbol = scopes.symbolFor(strippedExpression);
-	if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbols.has(symbol.id)) return false;
-	visitedSymbols.add(symbol.id);
-	return isGlobalObjectReference(symbol.initializer, scopes, visitedSymbols);
-};
-const resolvesToGlobalNamespace = (expression, namespaceName, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
-	const strippedExpression = stripParenExpression(expression);
-	if (isNodeOfType(strippedExpression, "Identifier")) {
-		if (strippedExpression.name === namespaceName && scopes.isGlobalReference(strippedExpression)) return true;
-		const symbol = scopes.symbolFor(strippedExpression);
-		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbols.has(symbol.id)) return false;
-		visitedSymbols.add(symbol.id);
-		return resolvesToGlobalNamespace(symbol.initializer, namespaceName, scopes, visitedSymbols);
-	}
-	return isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isGlobalObjectReference(strippedExpression.object, scopes);
-};
 const resolvesToGlobalMethod = (expression, namespaceName, methodNames, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
 	const strippedExpression = stripParenExpression(expression);
 	if (isNodeOfType(strippedExpression, "Identifier")) {
@@ -20043,7 +20098,7 @@ const resolvesToGlobalMethod = (expression, namespaceName, methodNames, scopes,
 		visitedSymbols.add(symbol.id);
 		return resolvesToGlobalMethod(symbol.initializer, namespaceName, methodNames, scopes, visitedSymbols);
 	}
-	return isNodeOfType(strippedExpression, "MemberExpression") && methodNames.has(getStaticPropertyName(strippedExpression) ?? "") && resolvesToGlobalNamespace(strippedExpression.object, namespaceName, scopes);
+	return isNodeOfType(strippedExpression, "MemberExpression") && methodNames.has(getStaticPropertyName(strippedExpression) ?? "") && isProvenGlobalNamespaceReference(strippedExpression.object, namespaceName, scopes);
 };
 const resolvesToNativeArrayPrototype = (expression, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
 	const strippedExpression = stripParenExpression(expression);
@@ -20055,7 +20110,7 @@ const resolvesToNativeArrayPrototype = (expression, scopes, visitedSymbols = /*
 	}
 	if (isNodeOfType(strippedExpression, "MemberExpression")) {
 		const propertyName = getStaticPropertyName(strippedExpression);
-		if (propertyName === "prototype") return resolvesToGlobalNamespace(strippedExpression.object, "Array", scopes);
+		if (propertyName === "prototype") return isProvenGlobalNamespaceReference(strippedExpression.object, "Array", scopes);
 		return propertyName === "__proto__" && isNodeOfType(stripParenExpression(strippedExpression.object), "ArrayExpression");
 	}
 	if (!isNodeOfType(strippedExpression, "CallExpression")) return false;
@@ -20066,23 +20121,23 @@ const resolvesToNativeArrayPrototype = (expression, scopes, visitedSymbols = /*
 const isGlobalNamespaceReplacementTarget = (target, namespaceName, scopes) => {
 	const strippedTarget = stripParenExpression(target);
 	if (isNodeOfType(strippedTarget, "Identifier")) return strippedTarget.name === namespaceName && scopes.isGlobalReference(strippedTarget);
-	return isNodeOfType(strippedTarget, "MemberExpression") && getStaticPropertyName(strippedTarget) === namespaceName && isGlobalObjectReference(strippedTarget.object, scopes);
+	return isNodeOfType(strippedTarget, "MemberExpression") && getStaticPropertyName(strippedTarget) === namespaceName && isProvenGlobalObjectReference(strippedTarget.object, scopes);
 };
 const isUnsafeBuiltinMemberTarget = (target, targetFunction, scopes) => {
 	const strippedTarget = stripParenExpression(target);
 	if (!isNodeOfType(strippedTarget, "MemberExpression")) return false;
 	const propertyName = getStaticPropertyName(strippedTarget);
 	if (resolvesToNativeArrayPrototype(strippedTarget.object, scopes)) return propertyName === null || propertyName === "sort";
-	if (resolvesToGlobalNamespace(strippedTarget.object, "Math", scopes)) return propertyName === null || propertyName === targetFunction;
-	return isGlobalObjectReference(strippedTarget.object, scopes) && (propertyName === null || propertyName === "Math");
+	if (isProvenGlobalNamespaceReference(strippedTarget.object, "Math", scopes)) return propertyName === null || propertyName === targetFunction;
+	return isProvenGlobalObjectReference(strippedTarget.object, scopes) && (propertyName === null || propertyName === "Math");
 };
 const isUnsafeBuiltinMutationApiCall = (callExpression, targetFunction, scopes) => {
 	const target = callExpression.arguments[0];
 	if (!target) return false;
 	let propertyName = null;
 	if (resolvesToNativeArrayPrototype(target, scopes)) propertyName = "sort";
-	else if (resolvesToGlobalNamespace(target, "Math", scopes)) propertyName = targetFunction;
-	else if (isGlobalObjectReference(target, scopes)) propertyName = "Math";
+	else if (isProvenGlobalNamespaceReference(target, "Math", scopes)) propertyName = targetFunction;
+	else if (isProvenGlobalObjectReference(target, scopes)) propertyName = "Math";
 	if (!propertyName) return false;
 	const canObjectExpressionSetProperty = (properties) => {
 		if (!isNodeOfType(properties, "ObjectExpression")) return true;
@@ -20133,7 +20188,7 @@ const hasUnsafeMathBinding = (node, scopes) => {
 	let scope = scopes.scopeFor(node);
 	while (scope) {
 		const symbol = scope.symbolsByName.get("Math");
-		if (symbol && !RUNTIMELESS_SYMBOL_KINDS.has(symbol.kind)) return !(symbol.kind === "const" && symbol.initializer && resolvesToGlobalNamespace(symbol.initializer, "Math", scopes));
+		if (symbol && !RUNTIMELESS_SYMBOL_KINDS.has(symbol.kind)) return !(symbol.kind === "const" && symbol.initializer && isProvenGlobalNamespaceReference(symbol.initializer, "Math", scopes));
 		scope = scope.parent;
 	}
 	return false;
@@ -26486,6 +26541,489 @@ const hasEmailTemplateImport = (programRoot) => {
 	return found;
 };
 //#endregion
+//#region src/plugin/utils/build-generated-image-project-index.ts
+const GENERATED_IMAGE_SOURCE_FILE_PATTERN = /\.[cm]?[jt]sx?$/i;
+const GENERATED_IMAGE_DECLARATION_FILE_PATTERN = /\.d\.[cm]?[jt]s$/i;
+const GENERATED_IMAGE_MDX_FILE_PATTERN = /\.mdx$/i;
+const GENERATED_IMAGE_IGNORED_DIRECTORY_NAMES = new Set([
+	".angular",
+	".astro",
+	".cache",
+	".contentlayer",
+	".docusaurus",
+	".expo",
+	".git",
+	".next",
+	".nuxt",
+	".output",
+	".svelte-kit",
+	".turbo",
+	".vercel",
+	"build",
+	"coverage",
+	"dist",
+	"node_modules",
+	"out",
+	"storybook-static"
+]);
+const generatedImageScopeCache = /* @__PURE__ */ new WeakMap();
+const getGeneratedImageModuleScopes = (programNode) => {
+	const cachedScopes = generatedImageScopeCache.get(programNode);
+	if (cachedScopes) return cachedScopes;
+	const scopes = analyzeScopes(programNode);
+	generatedImageScopeCache.set(programNode, scopes);
+	return scopes;
+};
+const listProductionSourceFiles = (rootDirectory) => {
+	const sourceFilePaths = [];
+	const pendingDirectories = [rootDirectory];
+	let hasOpaqueMdxConsumerSurface = false;
+	while (pendingDirectories.length > 0) {
+		const currentDirectory = pendingDirectories.pop();
+		if (!currentDirectory) continue;
+		let entries;
+		try {
+			entries = fs.readdirSync(currentDirectory, { withFileTypes: true });
+		} catch {
+			return null;
+		}
+		for (const entry of entries) {
+			const absolutePath = path.join(currentDirectory, entry.name);
+			const isIgnoredDirectoryName = GENERATED_IMAGE_IGNORED_DIRECTORY_NAMES.has(entry.name) || entry.name.startsWith(".") && entry.name !== ".dumi" && entry.name !== ".storybook";
+			if (entry.isSymbolicLink() && isIgnoredDirectoryName) continue;
+			if (entry.isSymbolicLink()) return null;
+			if (entry.isDirectory()) {
+				if (isIgnoredDirectoryName) continue;
+				pendingDirectories.push(absolutePath);
+				continue;
+			}
+			if (!entry.isFile() || isTestlikeFilename(absolutePath)) continue;
+			if (GENERATED_IMAGE_MDX_FILE_PATTERN.test(entry.name)) {
+				hasOpaqueMdxConsumerSurface = true;
+				continue;
+			}
+			if (!GENERATED_IMAGE_SOURCE_FILE_PATTERN.test(entry.name)) continue;
+			if (GENERATED_IMAGE_DECLARATION_FILE_PATTERN.test(entry.name)) continue;
+			sourceFilePaths.push(normalizeFilename(absolutePath));
+		}
+	}
+	return {
+		sourceFilePaths,
+		hasOpaqueMdxConsumerSurface
+	};
+};
+const getRuntimeModuleSource = (node) => {
+	if (isNodeOfType(node, "ImportDeclaration")) {
+		if (isTypeOnlyImport(node)) return null;
+		return typeof node.source.value === "string" ? node.source.value : null;
+	}
+	if (isNodeOfType(node, "ExportNamedDeclaration")) {
+		if (node.exportKind === "type" || isEverySpecifierInlineType(node.specifiers, "ExportSpecifier", "exportKind")) return null;
+		return node.source && typeof node.source.value === "string" ? node.source.value : null;
+	}
+	if (isNodeOfType(node, "ExportAllDeclaration")) {
+		if (node.exportKind === "type") return null;
+		return typeof node.source.value === "string" ? node.source.value : null;
+	}
+	if (isNodeOfType(node, "ImportExpression")) return isNodeOfType(node.source, "Literal") && typeof node.source.value === "string" ? node.source.value : null;
+	if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "require" && node.arguments.length === 1) {
+		const source = node.arguments[0];
+		return source && isNodeOfType(source, "Literal") && typeof source.value === "string" ? source.value : null;
+	}
+	return null;
+};
+const indexModuleSources = (module, consumerModulesByFilePath, resolvedSourcePathByNode, unresolvedRuntimeSources) => {
+	walkAst(module.programNode, (node) => {
+		const source = getRuntimeModuleSource(node);
+		if (!source) return;
+		const resolvedSourcePath = resolveModulePath(module.filePath, source);
+		if (!resolvedSourcePath) {
+			unresolvedRuntimeSources.add(source);
+			return;
+		}
+		const normalizedSourcePath = normalizeFilename(resolvedSourcePath);
+		resolvedSourcePathByNode.set(node, normalizedSourcePath);
+		const consumerModules = consumerModulesByFilePath.get(normalizedSourcePath) ?? /* @__PURE__ */ new Set();
+		consumerModules.add(module);
+		consumerModulesByFilePath.set(normalizedSourcePath, consumerModules);
+	});
+};
+const buildGeneratedImageProjectIndex = (rootDirectory, currentFilePath, currentProgramNode, currentScopes) => {
+	const productionSourceFiles = listProductionSourceFiles(rootDirectory);
+	if (!productionSourceFiles) return null;
+	const modulesByFilePath = /* @__PURE__ */ new Map();
+	for (const filePath of productionSourceFiles.sourceFilePaths) {
+		if (filePath === currentFilePath) {
+			modulesByFilePath.set(filePath, {
+				filePath,
+				programNode: currentProgramNode,
+				scopes: currentScopes
+			});
+			continue;
+		}
+		const parsedProgram = parseSourceFile(filePath);
+		if (!parsedProgram || !isNodeOfType(parsedProgram, "Program")) return null;
+		modulesByFilePath.set(filePath, {
+			filePath,
+			programNode: parsedProgram,
+			scopes: getGeneratedImageModuleScopes(parsedProgram)
+		});
+	}
+	const consumerModulesByFilePath = /* @__PURE__ */ new Map();
+	const resolvedSourcePathByNode = /* @__PURE__ */ new WeakMap();
+	const unresolvedRuntimeSources = /* @__PURE__ */ new Set();
+	for (const module of modulesByFilePath.values()) indexModuleSources(module, consumerModulesByFilePath, resolvedSourcePathByNode, unresolvedRuntimeSources);
+	return {
+		modulesByFilePath,
+		consumerModulesByFilePath,
+		resolvedSourcePathByNode,
+		unresolvedRuntimeSources,
+		hasOpaqueMdxConsumerSurface: productionSourceFiles.hasOpaqueMdxConsumerSurface
+	};
+};
+//#endregion
+//#region src/plugin/utils/read-nearest-package-manifest.ts
+const cachedPackageDirectoryByFilename = /* @__PURE__ */ new Map();
+const cachedManifestByPackageDirectory = /* @__PURE__ */ new Map();
+const resetManifestCaches = () => {
+	cachedPackageDirectoryByFilename.clear();
+	cachedManifestByPackageDirectory.clear();
+};
+const findNearestPackageDirectory = (filename) => {
+	if (!filename) return null;
+	const fromCache = cachedPackageDirectoryByFilename.get(filename);
+	if (fromCache !== void 0) {
+		if (isProbeRecorderActive()) {
+			let probedDirectory = path.dirname(filename);
+			while (true) {
+				recordExistenceProbe(path.join(probedDirectory, "package.json"));
+				if (probedDirectory === fromCache) break;
+				const parentDirectory = path.dirname(probedDirectory);
+				if (parentDirectory === probedDirectory) break;
+				probedDirectory = parentDirectory;
+			}
+		}
+		return fromCache;
+	}
+	let currentDirectory = path.dirname(filename);
+	while (true) {
+		const candidatePackageJsonPath = path.join(currentDirectory, "package.json");
+		recordExistenceProbe(candidatePackageJsonPath);
+		let hasPackageJson = false;
+		try {
+			hasPackageJson = fs.statSync(candidatePackageJsonPath).isFile();
+		} catch {
+			hasPackageJson = false;
+		}
+		if (hasPackageJson) {
+			cachedPackageDirectoryByFilename.set(filename, currentDirectory);
+			return currentDirectory;
+		}
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) {
+			cachedPackageDirectoryByFilename.set(filename, null);
+			return null;
+		}
+		currentDirectory = parentDirectory;
+	}
+};
+const readNearestPackageManifest = (filename) => {
+	const packageDirectory = findNearestPackageDirectory(filename);
+	if (!packageDirectory) return null;
+	return readPackageManifest(packageDirectory);
+};
+const readPackageManifest = (packageDirectory) => {
+	const packageJsonPath = path.join(packageDirectory, "package.json");
+	recordContentProbe(packageJsonPath);
+	const cached = cachedManifestByPackageDirectory.get(packageDirectory);
+	if (cached !== void 0) return cached;
+	let manifest = null;
+	try {
+		const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+		if (typeof parsed === "object" && parsed !== null) manifest = parsed;
+	} catch {
+		manifest = null;
+	}
+	cachedManifestByPackageDirectory.set(packageDirectory, manifest);
+	return manifest;
+};
+//#endregion
+//#region src/plugin/utils/is-exported-jsx-owned-by-generated-image-renderers.ts
+const getExportedSpecifierName = (specifier) => {
+	const exported = specifier.exported;
+	if (isNodeOfType(exported, "Identifier")) return exported.name;
+	return isNodeOfType(exported, "Literal") && typeof exported.value === "string" ? exported.value : null;
+};
+const getImportedSpecifierName = (specifier) => {
+	const local = specifier.local;
+	if (isNodeOfType(local, "Identifier")) return local.name;
+	return isNodeOfType(local, "Literal") && typeof local.value === "string" ? local.value : null;
+};
+const getImportSpecifierName = (specifier) => {
+	if (isNodeOfType(specifier, "ImportDefaultSpecifier")) return "default";
+	if (!isNodeOfType(specifier, "ImportSpecifier")) return null;
+	const imported = specifier.imported;
+	if (isNodeOfType(imported, "Identifier")) return imported.name;
+	return isNodeOfType(imported, "Literal") && typeof imported.value === "string" ? imported.value : null;
+};
+const getDirectFunctionBindingIdentifier = (functionNode) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration") && isNodeOfType(functionNode.id, "Identifier")) return functionNode.id;
+	const functionValueRoot = findTransparentExpressionRoot(functionNode);
+	const parent = functionValueRoot.parent;
+	return isNodeOfType(parent, "VariableDeclarator") && parent.init === functionValueRoot && isNodeOfType(parent.id, "Identifier") ? parent.id : null;
+};
+const getExportNamesForFunction = (programNode, functionNode) => {
+	const functionValueRoot = findTransparentExpressionRoot(functionNode);
+	const bindingName = getDirectFunctionBindingIdentifier(functionNode)?.name ?? null;
+	const exportedNames = /* @__PURE__ */ new Set();
+	for (const statement of programNode.body) {
+		if (isNodeOfType(statement, "ExportDefaultDeclaration")) {
+			if (statement.declaration === functionValueRoot || bindingName && isNodeOfType(statement.declaration, "Identifier") && statement.declaration.name === bindingName) exportedNames.add("default");
+			continue;
+		}
+		if (!isNodeOfType(statement, "ExportNamedDeclaration")) continue;
+		const declaration = statement.declaration;
+		if (declaration === functionValueRoot && bindingName) exportedNames.add(bindingName);
+		if (declaration && isNodeOfType(declaration, "VariableDeclaration")) {
+			for (const declarator of declaration.declarations) if (declarator.init === functionValueRoot && isNodeOfType(declarator.id, "Identifier")) exportedNames.add(declarator.id.name);
+		}
+		if (!bindingName || statement.source) continue;
+		for (const specifier of statement.specifiers) {
+			if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
+			if (getImportedSpecifierName(specifier) !== bindingName) continue;
+			const exportedName = getExportedSpecifierName(specifier);
+			if (exportedName) exportedNames.add(exportedName);
+		}
+	}
+	return [...exportedNames];
+};
+const isTransparentGeneratedImageValueFlow = (expression, target) => {
+	let current = findTransparentExpressionRoot(expression);
+	while (current !== target) {
+		const parent = current.parent;
+		if (!parent) return false;
+		if (!((isNodeOfType(parent, "JSXExpressionContainer") || isNodeOfType(parent, "JSXSpreadChild")) && parent.expression === current || (isNodeOfType(parent, "JSXElement") || isNodeOfType(parent, "JSXFragment")) && parent.children.some((child) => child === current) || isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === current || parent.alternate === current) || isNodeOfType(parent, "LogicalExpression") && (parent.left === current || parent.right === current) || isNodeOfType(parent, "ArrayExpression") && parent.elements.some((element) => element === current) || isNodeOfType(parent, "SequenceExpression") && parent.expressions.at(-1) === current || isNodeOfType(parent, "AwaitExpression") && parent.argument === current)) return false;
+		current = findTransparentExpressionRoot(parent);
+	}
+	return true;
+};
+const isInsideGeneratedImageRendererArgument = (expression, scopes) => {
+	let cursor = expression;
+	while (cursor?.parent) {
+		const parent = cursor.parent;
+		if (isFunctionLike$1(parent)) return false;
+		if (isNodeOfType(parent, "CallExpression") || isNodeOfType(parent, "NewExpression")) {
+			if (parent.arguments[0] && isTransparentGeneratedImageValueFlow(expression, parent.arguments[0]) && isGeneratedImageRendererCall(parent, scopes)) return true;
+		}
+		cursor = parent;
+	}
+	return false;
+};
+const getInvokedExpression = (identifier) => {
+	const referenceExpression = findTransparentExpressionRoot(identifier);
+	const parent = referenceExpression.parent;
+	if (isNodeOfType(parent, "CallExpression") && parent.callee === referenceExpression) return parent;
+	if (isNodeOfType(parent, "TaggedTemplateExpression") && parent.tag === referenceExpression) return parent;
+	if ((isNodeOfType(parent, "JSXOpeningElement") || isNodeOfType(parent, "JSXClosingElement")) && parent.name === identifier) {
+		const element = parent.parent;
+		return isNodeOfType(element, "JSXElement") ? element : null;
+	}
+	return null;
+};
+const getForwardingFunction = (expression) => {
+	const enclosingFunction = findEnclosingFunction$1(expression);
+	if (!enclosingFunction) return null;
+	if (isNodeOfType(enclosingFunction, "ArrowFunctionExpression") && !isNodeOfType(enclosingFunction.body, "BlockStatement") && isTransparentGeneratedImageValueFlow(expression, enclosingFunction.body)) return enclosingFunction;
+	let cursor = expression.parent;
+	while (cursor && cursor !== enclosingFunction) {
+		if (isFunctionLike$1(cursor)) return null;
+		if (isNodeOfType(cursor, "ReturnStatement") && cursor.argument && isTransparentGeneratedImageValueFlow(expression, cursor.argument)) return enclosingFunction;
+		cursor = cursor.parent;
+	}
+	return null;
+};
+const enqueueExport = (state, filePath, exportedName) => {
+	state.pendingExports.push({
+		filePath: normalizeFilename(filePath),
+		exportedName
+	});
+};
+const classifyInvokedExpression = (module, expression, state) => {
+	if (isInsideGeneratedImageRendererArgument(expression, module.scopes)) {
+		state.didReachRenderer = true;
+		return true;
+	}
+	const forwardingFunction = getForwardingFunction(expression);
+	if (!forwardingFunction) return false;
+	const exportedNames = getExportNamesForFunction(module.programNode, forwardingFunction);
+	if (exportedNames.length === 0) return false;
+	for (const exportedName of exportedNames) enqueueExport(state, module.filePath, exportedName);
+	return true;
+};
+const classifySymbolReferences = (module, symbol, state, visitedSymbolIds) => {
+	if (visitedSymbolIds.has(symbol.id)) return true;
+	visitedSymbolIds.add(symbol.id);
+	for (const reference of symbol.references) {
+		if (reference.flag !== "read") return false;
+		state.currentExportWasUsed = true;
+		const identifier = reference.identifier;
+		const invokedExpression = getInvokedExpression(identifier);
+		if (invokedExpression) {
+			if (!classifyInvokedExpression(module, invokedExpression, state)) return false;
+			continue;
+		}
+		const parent = identifier.parent;
+		if (isNodeOfType(parent, "ExportSpecifier") && parent.local === identifier) {
+			const exportedName = getExportedSpecifierName(parent);
+			if (!exportedName) return false;
+			enqueueExport(state, module.filePath, exportedName);
+			continue;
+		}
+		if (isNodeOfType(parent, "ExportDefaultDeclaration")) {
+			enqueueExport(state, module.filePath, "default");
+			continue;
+		}
+		if (isNodeOfType(parent, "VariableDeclarator") && parent.init === identifier && isNodeOfType(parent.id, "Identifier") && isNodeOfType(parent.parent, "VariableDeclaration") && parent.parent.kind === "const") {
+			const aliasSymbol = module.scopes.symbolFor(parent.id);
+			if (!aliasSymbol || !classifySymbolReferences(module, aliasSymbol, state, visitedSymbolIds)) return false;
+			continue;
+		}
+		return false;
+	}
+	return true;
+};
+const classifyNamespaceImportReferences = (module, symbol, exportedName, state) => {
+	for (const reference of symbol.references) {
+		if (reference.flag !== "read") return false;
+		const identifier = reference.identifier;
+		const parent = identifier.parent;
+		if (!isNodeOfType(parent, "MemberExpression") || parent.object !== identifier) return false;
+		const propertyName = getStaticPropertyName(parent);
+		if (propertyName === null) return false;
+		if (propertyName !== exportedName) continue;
+		state.currentExportWasUsed = true;
+		const invokedExpression = getInvokedExpression(parent);
+		if (!invokedExpression || !classifyInvokedExpression(module, invokedExpression, state)) return false;
+	}
+	return true;
+};
+const classifyImportsFromExport = (module, exportIdentity, state) => {
+	for (const statement of module.programNode.body) {
+		if (isNodeOfType(statement, "ImportDeclaration")) {
+			if (state.projectIndex.resolvedSourcePathByNode.get(statement) !== exportIdentity.filePath) continue;
+			if (statement.importKind === "type") continue;
+			for (const specifier of statement.specifiers) {
+				if (isNodeOfType(specifier, "ImportSpecifier") && specifier.importKind === "type") continue;
+				if (isNodeOfType(specifier, "ImportNamespaceSpecifier")) {
+					const namespaceSymbol = module.scopes.symbolFor(specifier.local);
+					if (!namespaceSymbol || !classifyNamespaceImportReferences(module, namespaceSymbol, exportIdentity.exportedName, state)) return false;
+					continue;
+				}
+				if (getImportSpecifierName(specifier) !== exportIdentity.exportedName) continue;
+				const symbol = module.scopes.symbolFor(specifier.local);
+				if (!symbol || !classifySymbolReferences(module, symbol, state, /* @__PURE__ */ new Set())) return false;
+			}
+			continue;
+		}
+		if ((isNodeOfType(statement, "ExportNamedDeclaration") || isNodeOfType(statement, "ExportAllDeclaration")) && statement.source && state.projectIndex.resolvedSourcePathByNode.get(statement) === exportIdentity.filePath) {
+			if (isNodeOfType(statement, "ExportAllDeclaration")) {
+				if (statement.exported) return false;
+				state.currentExportWasUsed = true;
+				enqueueExport(state, module.filePath, exportIdentity.exportedName);
+				continue;
+			}
+			for (const specifier of statement.specifiers) {
+				if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
+				if (getImportedSpecifierName(specifier) !== exportIdentity.exportedName) continue;
+				const exportedName = getExportedSpecifierName(specifier);
+				if (!exportedName) return false;
+				state.currentExportWasUsed = true;
+				enqueueExport(state, module.filePath, exportedName);
+			}
+		}
+	}
+	return true;
+};
+const hasOpaqueDynamicImportOfExport = (module, exportIdentity, projectIndex) => {
+	let isOpaque = false;
+	walkAst(module.programNode, (node) => {
+		if (isOpaque) return false;
+		if (isNodeOfType(node, "ImportExpression")) {
+			if (projectIndex.resolvedSourcePathByNode.get(node) === exportIdentity.filePath) {
+				isOpaque = true;
+				return false;
+			}
+		}
+		if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "require" && node.arguments.length === 1) {
+			if (projectIndex.resolvedSourcePathByNode.get(node) === exportIdentity.filePath) {
+				isOpaque = true;
+				return false;
+			}
+		}
+	});
+	return isOpaque;
+};
+const classifyLocalExportReferences = (module, exportIdentity, state) => {
+	const exportedValue = findExportedValue(module.programNode, exportIdentity.exportedName);
+	if (!exportedValue || !isFunctionLike$1(exportedValue)) return true;
+	const bindingIdentifier = getDirectFunctionBindingIdentifier(exportedValue);
+	if (!bindingIdentifier) return true;
+	const symbol = module.scopes.symbolFor(bindingIdentifier);
+	return symbol ? classifySymbolReferences(module, symbol, state, /* @__PURE__ */ new Set()) : false;
+};
+const hasOpaqueWorkspacePackageConsumer = (projectIndex, exportIdentity) => {
+	const packageName = readNearestPackageManifest(exportIdentity.filePath)?.name;
+	if (typeof packageName !== "string" || packageName.length === 0) return false;
+	for (const unresolvedSource of projectIndex.unresolvedRuntimeSources) if (unresolvedSource === packageName || unresolvedSource.startsWith(`${packageName}/`)) return true;
+	return false;
+};
+const createExportedJsxGeneratedImageOwnershipAnalyzer = (context) => {
+	const filename = context.filename ? normalizeFilename(context.filename) : "";
+	const rootDirectorySetting = getReactDoctorStringSetting(context.settings, "rootDirectory");
+	const rootDirectory = rootDirectorySetting ? normalizeFilename(rootDirectorySetting).replace(/\/$/, "") : "";
+	const isFileInsideRoot = Boolean(filename && rootDirectory) && (filename === rootDirectory || filename.startsWith(`${rootDirectory}/`));
+	let projectIndex;
+	return (jsxNode) => {
+		if (!isFileInsideRoot) return false;
+		const programNode = findProgramRoot(jsxNode);
+		const enclosingFunction = findEnclosingFunction$1(jsxNode);
+		if (!programNode || !enclosingFunction) return false;
+		const initialExportNames = getExportNamesForFunction(programNode, enclosingFunction);
+		if (initialExportNames.length === 0) return false;
+		if (projectIndex === void 0) projectIndex = buildGeneratedImageProjectIndex(rootDirectory, filename, programNode, context.scopes);
+		if (!projectIndex || projectIndex.hasOpaqueMdxConsumerSurface) return false;
+		const state = {
+			projectIndex,
+			pendingExports: initialExportNames.map((exportedName) => ({
+				filePath: filename,
+				exportedName
+			})),
+			visitedExportKeys: /* @__PURE__ */ new Set(),
+			currentExportWasUsed: false,
+			didReachRenderer: false
+		};
+		while (state.pendingExports.length > 0) {
+			const exportIdentity = state.pendingExports.pop();
+			if (!exportIdentity) continue;
+			const exportKey = `${exportIdentity.filePath}\0${exportIdentity.exportedName}`;
+			if (state.visitedExportKeys.has(exportKey)) continue;
+			state.visitedExportKeys.add(exportKey);
+			state.currentExportWasUsed = false;
+			if (hasOpaqueWorkspacePackageConsumer(projectIndex, exportIdentity)) return false;
+			const ownerModule = projectIndex.modulesByFilePath.get(exportIdentity.filePath);
+			if (!ownerModule || !classifyLocalExportReferences(ownerModule, exportIdentity, state)) return false;
+			const consumerModules = projectIndex.consumerModulesByFilePath.get(exportIdentity.filePath) ?? [];
+			for (const module of consumerModules) {
+				if (module.filePath === exportIdentity.filePath) continue;
+				if (hasOpaqueDynamicImportOfExport(module, exportIdentity, projectIndex)) return false;
+				if (!classifyImportsFromExport(module, exportIdentity, state)) return false;
+			}
+			if (!state.currentExportWasUsed) return false;
+		}
+		return state.didReachRenderer;
+	};
+};
+//#endregion
 //#region src/plugin/rules/nextjs/nextjs-no-img-element.ts
 const NON_OPTIMIZABLE_SRC_PREFIX_PATTERN = /^\s*(data:|blob:)/i;
 const GENERATED_URL_NAME_PATTERN = /(data|object|blob)_?url/i;
@@ -26588,9 +27126,20 @@ const nextjsNoImgElement = defineRule({
 	recommendation: "Use `next/image` so users get optimized formats, responsive srcsets, and lazy loading instead of oversized image downloads.",
 	create: (context) => {
 		if (isGeneratedImageRenderContext(context)) return {};
+		const generatedImageOwnershipByFunction = /* @__PURE__ */ new WeakMap();
+		const isExportedJsxGeneratedImageOwned = createExportedJsxGeneratedImageOwnershipAnalyzer(context);
 		return { JSXOpeningElement(node) {
 			if (resolveJsxElementType(node) !== "img") return;
 			if (isGeneratedImageRenderContext(context, node)) return;
+			const enclosingFunction = findEnclosingFunction$1(node);
+			if (enclosingFunction) {
+				let isGeneratedImageOwned = generatedImageOwnershipByFunction.get(enclosingFunction);
+				if (isGeneratedImageOwned === void 0) {
+					isGeneratedImageOwned = isExportedJsxGeneratedImageOwned(node);
+					generatedImageOwnershipByFunction.set(enclosingFunction, isGeneratedImageOwned);
+				}
+				if (isGeneratedImageOwned) return;
+			}
 			const programRoot = findProgramRoot(node);
 			if (programRoot && hasEmailTemplateImport(programRoot)) return;
 			const srcAttribute = findJsxAttribute(node.attributes, "src");
@@ -27936,7 +28485,11 @@ const isProvenNativeReadMethod = (ref, methodName) => Boolean(ref.resolved?.defs
 }));
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/react.ts
-const KNOWN_PURE_HOC_NAMES = new Set(["memo", "forwardRef"]);
+const KNOWN_COMPONENT_WRAPPER_NAMES = new Set([
+	"memo",
+	"forwardRef",
+	"observer"
+]);
 const startsWithUppercase = (name) => Boolean(name && name.length > 0 && name[0] >= "A" && name[0] <= "Z");
 const isReactFunctionalComponent = (node) => {
 	if (!node) return false;
@@ -27958,7 +28511,7 @@ const isReactFunctionalHOC = (analysis, node) => {
 	const isWrappedInline = () => {
 		if (!isNodeOfType(init, "CallExpression")) return false;
 		if (!isNodeOfType(init.callee, "Identifier")) return false;
-		if (KNOWN_PURE_HOC_NAMES.has(init.callee.name)) return false;
+		if (KNOWN_COMPONENT_WRAPPER_NAMES.has(init.callee.name)) return false;
 		const firstArg = init.arguments?.[0];
 		if (!firstArg) return false;
 		return isNodeOfType(firstArg, "ArrowFunctionExpression") || isNodeOfType(firstArg, "FunctionExpression");
@@ -27978,7 +28531,7 @@ const isReactFunctionalHOC = (analysis, node) => {
 			if (!args.includes(refId)) continue;
 			const callee = parent.callee;
 			const calleeName = isNodeOfType(callee, "Identifier") ? callee.name : isNodeOfType(callee, "CallExpression") && isNodeOfType(callee.callee, "Identifier") ? callee.callee.name : null;
-			if (calleeName != null && !KNOWN_PURE_HOC_NAMES.has(calleeName)) return true;
+			if (calleeName != null && !KNOWN_COMPONENT_WRAPPER_NAMES.has(calleeName)) return true;
 		}
 		return false;
 	};
@@ -31030,72 +31583,6 @@ const isReactNativeDependencyName = (dependencyName) => {
 	return false;
 };
 //#endregion
-//#region src/plugin/utils/read-nearest-package-manifest.ts
-const cachedPackageDirectoryByFilename = /* @__PURE__ */ new Map();
-const cachedManifestByPackageDirectory = /* @__PURE__ */ new Map();
-const resetManifestCaches = () => {
-	cachedPackageDirectoryByFilename.clear();
-	cachedManifestByPackageDirectory.clear();
-};
-const findNearestPackageDirectory = (filename) => {
-	if (!filename) return null;
-	const fromCache = cachedPackageDirectoryByFilename.get(filename);
-	if (fromCache !== void 0) {
-		if (isProbeRecorderActive()) {
-			let probedDirectory = path.dirname(filename);
-			while (true) {
-				recordExistenceProbe(path.join(probedDirectory, "package.json"));
-				if (probedDirectory === fromCache) break;
-				const parentDirectory = path.dirname(probedDirectory);
-				if (parentDirectory === probedDirectory) break;
-				probedDirectory = parentDirectory;
-			}
-		}
-		return fromCache;
-	}
-	let currentDirectory = path.dirname(filename);
-	while (true) {
-		const candidatePackageJsonPath = path.join(currentDirectory, "package.json");
-		recordExistenceProbe(candidatePackageJsonPath);
-		let hasPackageJson = false;
-		try {
-			hasPackageJson = fs.statSync(candidatePackageJsonPath).isFile();
-		} catch {
-			hasPackageJson = false;
-		}
-		if (hasPackageJson) {
-			cachedPackageDirectoryByFilename.set(filename, currentDirectory);
-			return currentDirectory;
-		}
-		const parentDirectory = path.dirname(currentDirectory);
-		if (parentDirectory === currentDirectory) {
-			cachedPackageDirectoryByFilename.set(filename, null);
-			return null;
-		}
-		currentDirectory = parentDirectory;
-	}
-};
-const readNearestPackageManifest = (filename) => {
-	const packageDirectory = findNearestPackageDirectory(filename);
-	if (!packageDirectory) return null;
-	return readPackageManifest(packageDirectory);
-};
-const readPackageManifest = (packageDirectory) => {
-	const packageJsonPath = path.join(packageDirectory, "package.json");
-	recordContentProbe(packageJsonPath);
-	const cached = cachedManifestByPackageDirectory.get(packageDirectory);
-	if (cached !== void 0) return cached;
-	let manifest = null;
-	try {
-		const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-		if (typeof parsed === "object" && parsed !== null) manifest = parsed;
-	} catch {
-		manifest = null;
-	}
-	cachedManifestByPackageDirectory.set(packageDirectory, manifest);
-	return manifest;
-};
-//#endregion
 //#region src/plugin/utils/classify-package-platform.ts
 const WEB_FRAMEWORK_DEPENDENCY_NAMES = new Set([
 	"next",
@@ -32148,6 +32635,24 @@ const isBuiltinNamespaceCallee = (callee) => {
 	}
 	return false;
 };
+const getReactUseCallbackSource = (reference, context) => {
+	const identifier = reference.identifier;
+	const symbol = resolveConstIdentifierAlias(identifier, context.scopes);
+	if (!symbol || symbol.kind !== "const" || !symbol.initializer) return null;
+	const initializer = stripParenExpression(symbol.initializer);
+	if (isNodeOfType(initializer, "CallExpression") && isReactApiCall(initializer, "useCallback", context.scopes, {
+		allowGlobalReactNamespace: true,
+		resolveNamedAliases: true
+	})) return initializer;
+	return null;
+};
+const getDependencyStateRefs = (analysis, context, dependencyReference) => {
+	const useCallbackCall = getReactUseCallbackSource(dependencyReference, context);
+	if (!useCallbackCall) return getUpstreamRefs(analysis, dependencyReference).filter((reference) => isState(analysis, reference));
+	const dependencyList = useCallbackCall.arguments?.[1];
+	if (!dependencyList || !isNodeOfType(dependencyList, "ArrayExpression")) return getUpstreamRefs(analysis, dependencyReference).filter((reference) => isState(analysis, reference));
+	return getDownstreamRefs(analysis, dependencyList).flatMap((reference) => getUpstreamRefs(analysis, reference)).filter((reference) => isState(analysis, reference));
+};
 const isSimpleExpression$1 = (analysis, expression, effectFn, visitedDeclarators) => {
 	let isSimple = true;
 	walkAst(expression, (child) => {
@@ -32195,7 +32700,7 @@ const noChainStateUpdates = defineRule({
 		if (!effectFnRefs || !depsRefs) return;
 		const effectFn = getEffectFn(analysis, node);
 		if (!effectFn) return;
-		const stateDeps = depsRefs.flatMap((ref) => getUpstreamRefs(analysis, ref)).filter((ref) => isState(analysis, ref));
+		const stateDeps = depsRefs.flatMap((reference) => getDependencyStateRefs(analysis, context, reference));
 		if (stateDeps.length === 0) return;
 		if (stateDeps.every((ref) => isExternallyDrivenState(analysis, ref))) return;
 		const stateDepDeclarators = new Set(stateDeps.map((ref) => getUseStateDeclarator(ref)).filter((declarator) => declarator !== null));
@@ -32454,16 +32959,7 @@ const isProvenIntrinsicJsxElement = (openingElement, scopes) => {
 	return isIntrinsicValue(openingElement.name);
 };
 //#endregion
-//#region src/plugin/rules/react-builtins/is-safe-create-ref-callback-current-write.ts
-const pathStartsWith$1 = (propertyPath, prefix) => prefix.every((propertyName, index) => propertyPath[index] === propertyName);
-const collectMemberExpression = (identifier) => {
-	let expression = findTransparentExpressionRoot(identifier);
-	while (expression.parent && isNodeOfType(expression.parent, "MemberExpression") && expression.parent.object === expression) {
-		if (!getStaticPropertyName(expression.parent)) return null;
-		expression = findTransparentExpressionRoot(expression.parent);
-	}
-	return expression;
-};
+//#region src/plugin/utils/is-inline-intrinsic-ref-callback.ts
 const isInlineIntrinsicRefCallback = (functionNode, scopes) => {
 	const functionExpression = findTransparentExpressionRoot(functionNode);
 	if (!isFunctionLike$1(functionExpression) || functionExpression.async || functionExpression.generator) return false;
@@ -32474,6 +32970,17 @@ const isInlineIntrinsicRefCallback = (functionNode, scopes) => {
 	const openingElement = attribute.parent;
 	return Boolean(openingElement && isNodeOfType(openingElement, "JSXOpeningElement") && isProvenIntrinsicJsxElement(openingElement, scopes));
 };
+//#endregion
+//#region src/plugin/rules/react-builtins/is-safe-create-ref-callback-current-write.ts
+const pathStartsWith$1 = (propertyPath, prefix) => prefix.every((propertyName, index) => propertyPath[index] === propertyName);
+const collectMemberExpression = (identifier) => {
+	let expression = findTransparentExpressionRoot(identifier);
+	while (expression.parent && isNodeOfType(expression.parent, "MemberExpression") && expression.parent.object === expression) {
+		if (!getStaticPropertyName(expression.parent)) return null;
+		expression = findTransparentExpressionRoot(expression.parent);
+	}
+	return expression;
+};
 const isSafeCreateRefCallbackCurrentWrite = (referenceNode, accessedPropertyPath, targetPropertyPath, scopes) => {
 	if (accessedPropertyPath.length !== targetPropertyPath.length + 1 || !pathStartsWith$1(accessedPropertyPath, targetPropertyPath) || accessedPropertyPath[targetPropertyPath.length] !== "current") return false;
 	const memberExpression = collectMemberExpression(referenceNode);
@@ -35417,17 +35924,178 @@ const visitSynchronousFunctionBodies = (analysisFunctions, visitor) => {
 		walkInsideStatementBlocks(analysisFunction.body, visitor);
 	}
 };
-const collectWrittenStateNamesInEffect = (analysisFunctions, setterToStateName) => {
-	const writtenStateNames = /* @__PURE__ */ new Set();
+const readStaticEffectValue = (expression, scopes, stateSymbolId, stateValue, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "Literal")) {
+		const literalValue = unwrappedExpression.value;
+		if (literalValue === null || typeof literalValue === "boolean" || typeof literalValue === "number" || typeof literalValue === "string") return { value: literalValue };
+		return null;
+	}
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		if (scopes.symbolFor(unwrappedExpression)?.id === stateSymbolId) return stateValue;
+		if (unwrappedExpression.name === "undefined" && scopes.isGlobalReference(unwrappedExpression)) return { value: void 0 };
+		const immutableSymbol = scopes.symbolFor(unwrappedExpression);
+		if (immutableSymbol?.kind !== "const" || !immutableSymbol.initializer || !isNodeOfType(immutableSymbol.declarationNode, "VariableDeclarator") || immutableSymbol.declarationNode.id !== immutableSymbol.bindingIdentifier || immutableSymbol.declarationNode.init !== immutableSymbol.initializer || immutableSymbol.references.some((reference) => reference.flag !== "read") || visitedSymbolIds.has(immutableSymbol.id)) return null;
+		return readStaticEffectValue(immutableSymbol.initializer, scopes, stateSymbolId, stateValue, new Set(visitedSymbolIds).add(immutableSymbol.id));
+	}
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression")) {
+		if (unwrappedExpression.operator === "void") return { value: void 0 };
+		if (unwrappedExpression.operator !== "!") return null;
+		const argumentValue = readStaticEffectValue(unwrappedExpression.argument, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		return argumentValue ? { value: !argumentValue.value } : null;
+	}
+	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
+		if (isNodeOfType(unwrappedExpression.callee, "Identifier") && unwrappedExpression.callee.name === "Boolean" && scopes.isGlobalReference(unwrappedExpression.callee) && unwrappedExpression.arguments.length === 1 && unwrappedExpression.arguments[0] && !isNodeOfType(unwrappedExpression.arguments[0], "SpreadElement")) {
+			const argumentValue = readStaticEffectValue(unwrappedExpression.arguments[0], scopes, stateSymbolId, stateValue, visitedSymbolIds);
+			return argumentValue ? { value: Boolean(argumentValue.value) } : null;
+		}
+		return null;
+	}
+	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
+		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		if (!leftValue) return null;
+		if (unwrappedExpression.operator === "&&" && !leftValue.value) return leftValue;
+		if (unwrappedExpression.operator === "||" && leftValue.value) return leftValue;
+		if (unwrappedExpression.operator === "??" && leftValue.value !== null && leftValue.value !== void 0) return leftValue;
+		return readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+	}
+	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) {
+		const testValue = readStaticEffectValue(unwrappedExpression.test, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		if (!testValue) return null;
+		return readStaticEffectValue(testValue.value ? unwrappedExpression.consequent : unwrappedExpression.alternate, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+	}
+	if (isNodeOfType(unwrappedExpression, "MemberExpression") && unwrappedExpression.optional) {
+		const objectValue = readStaticEffectValue(unwrappedExpression.object, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		if (objectValue?.value === null || objectValue?.value === void 0) return { value: void 0 };
+		return null;
+	}
+	if (isNodeOfType(unwrappedExpression, "BinaryExpression")) {
+		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		const rightValue = readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds);
+		if (!leftValue || !rightValue) return null;
+		if (unwrappedExpression.operator === "===" || unwrappedExpression.operator === "!==") {
+			const areEqual = leftValue.value === rightValue.value;
+			return { value: unwrappedExpression.operator === "===" ? areEqual : !areEqual };
+		}
+		if (unwrappedExpression.operator === "==" || unwrappedExpression.operator === "!=") {
+			const isLeftNullish = leftValue.value === null || leftValue.value === void 0;
+			const isRightNullish = rightValue.value === null || rightValue.value === void 0;
+			if (!isLeftNullish && !isRightNullish && typeof leftValue.value !== typeof rightValue.value) return null;
+			const areEqual = isLeftNullish || isRightNullish ? isLeftNullish && isRightNullish : leftValue.value === rightValue.value;
+			return { value: unwrappedExpression.operator === "==" ? areEqual : !areEqual };
+		}
+	}
+	return null;
+};
+const readStaticUpdaterReturnValue = (updater, scopes) => {
+	if (!isFunctionLike$1(updater) || updater.async || updater.generator) return null;
+	if (!isNodeOfType(updater.body, "BlockStatement")) return readStaticEffectValue(updater.body, scopes, null, null);
+	if (updater.body.body.length === 0) return { value: void 0 };
+	if (updater.body.body.length !== 1) return null;
+	const returnStatement = updater.body.body[0];
+	if (!isNodeOfType(returnStatement, "ReturnStatement")) return null;
+	if (!returnStatement.argument) return { value: void 0 };
+	return readStaticEffectValue(returnStatement.argument, scopes, null, null);
+};
+const readStaticSetterValue = (setterCall, scopes) => {
+	const argument = setterCall.arguments[0];
+	if (!argument) return { value: void 0 };
+	if (isNodeOfType(argument, "SpreadElement")) return null;
+	const updater = resolveExactLocalFunction(argument, scopes);
+	if (updater) return readStaticUpdaterReturnValue(updater, scopes);
+	return readStaticEffectValue(argument, scopes, null, null);
+};
+const collectStateWritesInEffect = (analysisFunctions, setterToStateName, scopes) => {
+	const stateWrites = /* @__PURE__ */ new Map();
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (!isNodeOfType(child.callee, "Identifier")) return;
 		const stateName = setterToStateName.get(child.callee.name);
-		if (stateName) writtenStateNames.add(stateName);
+		if (!stateName) return;
+		const writeInfo = stateWrites.get(stateName) ?? {
+			values: /* @__PURE__ */ new Set(),
+			hasUnknownValue: false
+		};
+		const staticValue = readStaticSetterValue(child, scopes);
+		if (staticValue) writeInfo.values.add(staticValue.value);
+		else writeInfo.hasUnknownValue = true;
+		stateWrites.set(stateName, writeInfo);
 	});
-	return writtenStateNames;
+	return stateWrites;
+};
+const isGlobalBooleanCall = (node, scopes) => {
+	return isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Boolean" && scopes.isGlobalReference(node.callee);
+};
+const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, scopes) => {
+	let currentNode = workNode;
+	while (currentNode.parent) {
+		const parentNode = currentNode.parent;
+		if (isFunctionLike$1(parentNode)) break;
+		if (isNodeOfType(parentNode, "IfStatement")) {
+			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue);
+			if (testValue) {
+				if (currentNode === parentNode.consequent && !testValue.value) return false;
+				if (currentNode === parentNode.alternate && testValue.value) return false;
+			}
+		}
+		if (isNodeOfType(parentNode, "ConditionalExpression")) {
+			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue);
+			if (testValue) {
+				if (currentNode === parentNode.consequent && !testValue.value) return false;
+				if (currentNode === parentNode.alternate && testValue.value) return false;
+			}
+		}
+		if (isNodeOfType(parentNode, "LogicalExpression") && currentNode === parentNode.right) {
+			const leftValue = readStaticEffectValue(parentNode.left, scopes, stateSymbolId, stateValue);
+			if (leftValue) {
+				if (parentNode.operator === "&&" && !leftValue.value) return false;
+				if (parentNode.operator === "||" && leftValue.value) return false;
+				if (parentNode.operator === "??" && leftValue.value !== null && leftValue.value !== void 0) return false;
+			}
+		}
+		if (isNodeOfType(parentNode, "BlockStatement")) {
+			const statementIndex = parentNode.body.findIndex((statement) => statement === currentNode);
+			if (statementIndex >= 0) for (let index = 0; index < statementIndex; index += 1) {
+				const earlierStatement = parentNode.body[index];
+				if (!isNodeOfType(earlierStatement, "IfStatement") || earlierStatement.alternate || !statementAlwaysExits(earlierStatement.consequent)) continue;
+				if (readStaticEffectValue(earlierStatement.test, scopes, stateSymbolId, stateValue)?.value) return false;
+			}
+		}
+		currentNode = parentNode;
+	}
+	return true;
+};
+const isReaderWorkNode = (node, analysisFunctions, scopes) => {
+	if (isNodeOfType(node, "CallExpression")) {
+		if (isGlobalBooleanCall(node, scopes)) return false;
+		const invokedFunction = resolveExactLocalFunction(node.callee, scopes);
+		return !invokedFunction || !analysisFunctions.has(invokedFunction);
+	}
+	return isNodeOfType(node, "AssignmentExpression") || isNodeOfType(node, "UpdateExpression") || isNodeOfType(node, "NewExpression") || isNodeOfType(node, "TaggedTemplateExpression") || isNodeOfType(node, "ThrowStatement") || isNodeOfType(node, "UnaryExpression") && node.operator === "delete";
+};
+const canStateWriteReachReaderWork = (writeInfo, readerEffect, stateSymbolId, scopes) => {
+	if (writeInfo.hasUnknownValue || stateSymbolId === null) return true;
+	for (const writtenValue of writeInfo.values) {
+		const stateValue = { value: writtenValue };
+		let didFindReachableWork = false;
+		visitSynchronousFunctionBodies(readerEffect.analysisFunctions, (child) => {
+			if (didFindReachableWork || !isReaderWorkNode(child, readerEffect.analysisFunctions, scopes)) return;
+			if (isWorkNodeReachableForStateValue(child, stateSymbolId, stateValue, scopes)) didFindReachableWork = true;
+		});
+		if (didFindReachableWork) return true;
+	}
+	return false;
 };
 const EMPTY_CLEANUP_NAME_SET = /* @__PURE__ */ new Set();
+const NON_CONTAMINATING_MAP_METHOD_NAMES = new Set([
+	"clear",
+	"delete",
+	"entries",
+	"get",
+	"has",
+	"keys",
+	"values"
+]);
 const isFunctionShapedReturn = (returnedValue, setterToStateName, isExplicitReturnStatement) => {
 	if (isNodeOfType(returnedValue, "ArrowFunctionExpression") || isNodeOfType(returnedValue, "FunctionExpression")) return true;
 	if (isNodeOfType(returnedValue, "CallExpression")) {
@@ -35478,27 +36146,135 @@ const callsOpaqueExternalSetter = (analysisFunctions, setterToStateName) => {
 	});
 	return didFindOpaqueSetterCall;
 };
+const isReactRefCall = (expression, scopes) => isNodeOfType(expression, "CallExpression") && (isReactApiCall(expression, "useRef", scopes, {
+	allowGlobalReactNamespace: true,
+	allowUnboundBareCalls: true,
+	resolveNamedAliases: true
+}) || isReactApiCall(expression, "createRef", scopes, {
+	allowGlobalReactNamespace: true,
+	allowUnboundBareCalls: true,
+	resolveNamedAliases: true
+}));
+const getDirectReactRefSymbol = (rawExpression, scopes) => {
+	const expression = stripParenExpression(rawExpression);
+	if (!isNodeOfType(expression, "Identifier")) return null;
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol) return null;
+	const initializer = getDirectUnreassignedInitializer(symbol);
+	return initializer && isReactRefCall(stripParenExpression(initializer), scopes) ? symbol : null;
+};
+const isReactNativeJsxElement = (openingElement, scopes) => {
+	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return false;
+	const symbol = scopes.symbolFor(openingElement.name);
+	const importDeclaration = symbol?.declarationNode.parent;
+	return Boolean(symbol?.kind === "import" && importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "react-native");
+};
+const isDirectHostJsxRef = (symbol, scopes) => {
+	let hostRefCount = 0;
+	for (const reference of symbol.references) {
+		const expression = findTransparentExpressionRoot(reference.identifier);
+		const container = expression.parent;
+		if (isNodeOfType(container, "MemberExpression") && container.object === expression && getStaticPropertyName(container) === "current") continue;
+		if (!container || !isNodeOfType(container, "JSXExpressionContainer") || container.expression !== expression) return false;
+		const attribute = container.parent;
+		if (!attribute || !isNodeOfType(attribute, "JSXAttribute") || getJsxAttributeName(attribute.name) !== "ref") return false;
+		const openingElement = attribute.parent;
+		if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement") || !isProvenIntrinsicJsxElement(openingElement, scopes) && !isReactNativeJsxElement(openingElement, scopes)) return false;
+		hostRefCount += 1;
+	}
+	return hostRefCount > 0;
+};
+const isIntrinsicRefCallbackParameter = (expression, scopes) => {
+	const identifier = stripParenExpression(expression);
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const callback = findEnclosingFunction$1(identifier);
+	if (!callback || !isFunctionLike$1(callback) || !isInlineIntrinsicRefCallback(callback, scopes)) return false;
+	const rawFirstParameter = callback.params?.[0];
+	const firstParameter = isNodeOfType(rawFirstParameter, "AssignmentPattern") ? rawFirstParameter.left : rawFirstParameter;
+	const symbol = scopes.symbolFor(identifier);
+	return Boolean(firstParameter && symbol?.bindingIdentifier === firstParameter);
+};
+const getDirectReactRefCall = (symbol, scopes) => {
+	const initializer = getDirectUnreassignedInitializer(symbol);
+	if (!initializer) return null;
+	const expression = stripParenExpression(initializer);
+	return isNodeOfType(expression, "CallExpression") && isReactRefCall(expression, scopes) ? expression : null;
+};
+const storesOnlyIntrinsicRefCallbackValues = (symbol, scopes) => {
+	const initialValue = getDirectReactRefCall(symbol, scopes)?.arguments?.[0];
+	if (!initialValue || !isNodeOfType(initialValue, "NewExpression") || !isNodeOfType(initialValue.callee, "Identifier") || initialValue.callee.name !== "Map" || !scopes.isGlobalReference(initialValue.callee) || initialValue.arguments.length !== 0) return false;
+	let intrinsicValueWriteCount = 0;
+	for (const reference of symbol.references) {
+		const identifier = findTransparentExpressionRoot(reference.identifier);
+		const currentMember = identifier.parent;
+		if (!isNodeOfType(currentMember, "MemberExpression") || currentMember.object !== identifier || getStaticPropertyName(currentMember) !== "current") return false;
+		const currentExpression = findTransparentExpressionRoot(currentMember);
+		const methodMember = currentExpression.parent;
+		if (!isNodeOfType(methodMember, "MemberExpression") || methodMember.object !== currentExpression) return false;
+		const methodName = getStaticPropertyName(methodMember);
+		if (methodName === "size") continue;
+		const call = methodMember.parent;
+		if (!isNodeOfType(call, "CallExpression") || call.callee !== methodMember) return false;
+		if (methodName && NON_CONTAMINATING_MAP_METHOD_NAMES.has(methodName)) continue;
+		if (methodName !== "set") return false;
+		const storedValue = call.arguments[1];
+		if (!storedValue || isNodeOfType(storedValue, "SpreadElement") || !isIntrinsicRefCallbackParameter(storedValue, scopes)) return false;
+		intrinsicValueWriteCount += 1;
+	}
+	return intrinsicValueWriteCount > 0;
+};
+const isDerivedFromProvenDomRefCurrent = (rawExpression, scopes, didReadCollectionValue = false, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(rawExpression);
+	if (isNodeOfType(expression, "Identifier")) {
+		const symbol = scopes.symbolFor(expression);
+		if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+		const initializer = getDirectUnreassignedInitializer(symbol);
+		if (!initializer) return false;
+		visitedSymbolIds.add(symbol.id);
+		return isDerivedFromProvenDomRefCurrent(initializer, scopes, didReadCollectionValue, visitedSymbolIds);
+	}
+	if (isNodeOfType(expression, "MemberExpression")) {
+		if (getStaticPropertyName(expression) === "current") {
+			const symbol = getDirectReactRefSymbol(expression.object, scopes);
+			return Boolean(symbol && (isDirectHostJsxRef(symbol, scopes) || didReadCollectionValue && storesOnlyIntrinsicRefCallbackValues(symbol, scopes)));
+		}
+		return isDerivedFromProvenDomRefCurrent(expression.object, scopes, didReadCollectionValue, visitedSymbolIds);
+	}
+	if (!isNodeOfType(expression, "CallExpression")) return false;
+	const callee = stripParenExpression(expression.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	return isDerivedFromProvenDomRefCurrent(callee.object, scopes, didReadCollectionValue || getStaticPropertyName(callee) === "get", visitedSymbolIds);
+};
+const isCommittedDomSyncNode = (node, scopes) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const propertyName = getStaticPropertyName(callee);
+	if (propertyName === null || !EXTERNAL_SYNC_DOM_MEMBER_METHOD_NAMES.has(propertyName)) return false;
+	return isDerivedFromProvenDomRefCurrent(callee.object, scopes) || isProvenBrowserApiReceiver(callee.object, "dom-event-target", scopes);
+};
 const isExternalSyncNode = (node) => {
 	if (isNodeOfType(node, "NewExpression")) return isNodeOfType(node.callee, "Identifier") && EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS.has(node.callee.name);
 	if (isNodeOfType(node, "AssignmentExpression")) return isNodeOfType(node.left, "MemberExpression") && isNodeOfType(node.left.property, "Identifier") && node.left.property.name === "current";
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	if (isNodeOfType(node.callee, "Identifier")) return EXTERNAL_SYNC_DIRECT_CALLEE_NAMES.has(node.callee.name);
-	if (!isNodeOfType(node.callee, "MemberExpression") || !isNodeOfType(node.callee.property, "Identifier")) return false;
-	const propertyName = node.callee.property.name;
+	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
+	const propertyName = getStaticPropertyName(node.callee);
+	if (propertyName === null) return false;
 	if (EXTERNAL_SYNC_MEMBER_METHOD_NAMES.has(propertyName)) return true;
 	if (isBrowserStorageReceiver(node.callee.object)) return true;
 	if (!EXTERNAL_SYNC_AMBIGUOUS_HTTP_METHOD_NAMES.has(propertyName)) return false;
 	const receiverRootName = getRootIdentifierName(node.callee.object);
 	return receiverRootName !== null && EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS.has(receiverRootName);
 };
-const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateName) => {
+const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateName, scopes, allowCommittedDomSync) => {
 	if (!isFunctionLike$1(effectCallback)) return false;
 	if (!isNodeOfType(effectCallback.body, "BlockStatement")) {
 		if (isFunctionShapedReturn(effectCallback.body, setterToStateName, false)) return true;
 	} else for (const statement of effectCallback.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument && isFunctionShapedReturn(statement.argument, setterToStateName, true)) return true;
 	let didFindExternalCall = false;
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
-		if (isExternalSyncNode(child)) didFindExternalCall = true;
+		if (isExternalSyncNode(child) || allowCommittedDomSync && isCommittedDomSyncNode(child, scopes)) didFindExternalCall = true;
 	});
 	return didFindExternalCall;
 };
@@ -35514,32 +36290,45 @@ const noEffectChain = defineRule({
 			const useStateBindings = collectUseStateBindings(componentBody);
 			if (useStateBindings.length === 0) return;
 			const setterToStateName = /* @__PURE__ */ new Map();
-			for (const binding of useStateBindings) setterToStateName.set(binding.setterName, binding.valueName);
+			const stateSymbolIds = /* @__PURE__ */ new Map();
+			for (const binding of useStateBindings) {
+				setterToStateName.set(binding.setterName, binding.valueName);
+				if (!isNodeOfType(binding.declarator.id, "ArrayPattern")) continue;
+				const stateIdentifier = binding.declarator.id.elements[0];
+				if (isNodeOfType(stateIdentifier, "Identifier")) {
+					const stateSymbol = context.scopes.symbolFor(stateIdentifier);
+					if (stateSymbol) stateSymbolIds.set(binding.valueName, stateSymbol.id);
+				}
+			}
 			const storageSetterNames = collectStorageHookSetterNames(componentBody);
 			const effectInfos = [];
 			for (const effectCall of findTopLevelEffectCalls(componentBody)) {
 				const callback = getEffectCallback(effectCall, context.scopes);
 				if (!callback || !isFunctionLike$1(callback) || callback.async) continue;
 				const analysisFunctions = collectSynchronouslyInvokedFunctions(callback, context.scopes);
-				const writtenStateNames = collectWrittenStateNamesInEffect(analysisFunctions, setterToStateName);
+				const stateWrites = collectStateWritesInEffect(analysisFunctions, setterToStateName, context.scopes);
+				const writtenStateNames = new Set(stateWrites.keys());
 				effectInfos.push({
 					node: effectCall,
 					depNames: collectDepIdentifierNames(effectCall),
-					writtenStateNames,
-					isExternalSync: isExternalSyncEffect(callback, analysisFunctions, setterToStateName) || callsStorageHookSetter(analysisFunctions, storageSetterNames) || writtenStateNames.size === 0 && callsOpaqueExternalSetter(analysisFunctions, setterToStateName)
+					stateWrites,
+					analysisFunctions,
+					isExternalSync: isExternalSyncEffect(callback, analysisFunctions, setterToStateName, context.scopes, writtenStateNames.size === 0) || callsStorageHookSetter(analysisFunctions, storageSetterNames) || writtenStateNames.size === 0 && callsOpaqueExternalSetter(analysisFunctions, setterToStateName)
 				});
 			}
 			if (effectInfos.length < 2) return;
 			const reportedNodes = /* @__PURE__ */ new Set();
 			for (const writerEffect of effectInfos) {
 				if (writerEffect.isExternalSync) continue;
-				if (writerEffect.writtenStateNames.size === 0) continue;
+				if (writerEffect.stateWrites.size === 0) continue;
 				for (const readerEffect of effectInfos) {
 					if (readerEffect === writerEffect) continue;
 					if (readerEffect.isExternalSync) continue;
 					if (readerEffect.depNames.size === 0) continue;
 					let chainedStateName = null;
-					for (const writtenName of writerEffect.writtenStateNames) if (readerEffect.depNames.has(writtenName)) {
+					for (const [writtenName, writeInfo] of writerEffect.stateWrites) {
+						if (!readerEffect.depNames.has(writtenName)) continue;
+						if (!canStateWriteReachReaderWork(writeInfo, readerEffect, stateSymbolIds.get(writtenName) ?? null, context.scopes)) continue;
 						chainedStateName = writtenName;
 						break;
 					}
@@ -39206,6 +39995,18 @@ const functionContainsProvenReactHookCall = (functionNode, scopes) => {
 	return containsReactHookCall;
 };
 //#endregion
+//#region src/plugin/utils/function-returns-only-null.ts
+const isNullExpression = (expression) => {
+	const candidate = stripParenExpression(expression);
+	return isNodeOfType(candidate, "Literal") && candidate.value === null;
+};
+const functionReturnsOnlyNull = (functionNode) => {
+	if (!isFunctionLike$1(functionNode)) return false;
+	if (!isNodeOfType(functionNode.body, "BlockStatement")) return isNullExpression(functionNode.body);
+	const returnStatements = collectFunctionReturnStatements(functionNode);
+	return returnStatements.length > 0 && returnStatements.every((returnStatement) => Boolean(returnStatement.argument && isNullExpression(returnStatement.argument)));
+};
+//#endregion
 //#region src/plugin/utils/function-returns-props-children.ts
 const functionReturnsPropsChildren = (functionNode, scopes, controlFlow) => {
 	if (!isFunctionLike$1(functionNode) || functionNode.params.length === 0) return false;
@@ -39238,17 +40039,8 @@ const functionReturnsPropsChildren = (functionNode, scopes, controlFlow) => {
 	}, controlFlow);
 };
 //#endregion
-//#region src/plugin/utils/function-returns-only-null.ts
-const isNullExpression = (expression) => {
-	const candidate = stripParenExpression(expression);
-	return isNodeOfType(candidate, "Literal") && candidate.value === null;
-};
-const functionReturnsOnlyNull = (functionNode) => {
-	if (!isFunctionLike$1(functionNode)) return false;
-	if (!isNodeOfType(functionNode.body, "BlockStatement")) return isNullExpression(functionNode.body);
-	const returnStatements = collectFunctionReturnStatements(functionNode);
-	return returnStatements.length > 0 && returnStatements.every((returnStatement) => Boolean(returnStatement.argument && isNullExpression(returnStatement.argument)));
-};
+//#region src/plugin/utils/function-has-react-component-evidence.ts
+const functionHasReactComponentEvidence = (functionNode, scopes, controlFlow) => functionContainsReactRenderOutput(functionNode, scopes, controlFlow) || functionReturnsPropsChildren(functionNode, scopes, controlFlow) || functionContainsProvenReactHookCall(functionNode, scopes) && functionReturnsOnlyNull(functionNode);
 //#endregion
 //#region src/plugin/utils/is-proven-styled-component-expression.ts
 const findFactoryRoot = (node) => {
@@ -39281,17 +40073,16 @@ const isProvenStyledComponentExpression = (expression, scopes) => {
 //#region src/plugin/utils/is-proven-react-component-symbol.ts
 const REACT_COMPONENT_HOC_NAMES = new Set(["memo", "forwardRef"]);
 const LEGACY_REACT_COMPONENT_FACTORY_NAMES = new Set(["createClass", "createReactClass"]);
-const functionHasComponentEvidence = (functionNode, scopes, controlFlow) => functionContainsReactRenderOutput(functionNode, scopes, controlFlow) || functionReturnsPropsChildren(functionNode, scopes, controlFlow) || functionContainsProvenReactHookCall(functionNode, scopes) && functionReturnsOnlyNull(functionNode);
 const isProvenReactComponentExpression = (expression, scopes, controlFlow, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
 	const candidate = stripParenExpression(expression);
-	if (isInlineFunctionExpression(candidate)) return functionHasComponentEvidence(candidate, scopes, controlFlow);
+	if (isInlineFunctionExpression(candidate)) return functionHasReactComponentEvidence(candidate, scopes, controlFlow);
 	if (isNodeOfType(candidate, "ClassExpression")) return isProvenReactClassComponent(candidate, scopes);
 	if (isProvenStyledComponentExpression(candidate, scopes)) return true;
 	if (isNodeOfType(candidate, "Identifier")) {
 		const symbol = scopes.symbolFor(candidate);
 		if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, candidate, scopes)) return false;
 		visitedSymbolIds.add(symbol.id);
-		if (isNodeOfType(symbol.declarationNode, "FunctionDeclaration")) return functionHasComponentEvidence(symbol.declarationNode, scopes, controlFlow);
+		if (isNodeOfType(symbol.declarationNode, "FunctionDeclaration")) return functionHasReactComponentEvidence(symbol.declarationNode, scopes, controlFlow);
 		if (isNodeOfType(symbol.declarationNode, "ClassDeclaration") || isNodeOfType(symbol.declarationNode, "ClassExpression")) return isProvenReactClassComponent(symbol.declarationNode, scopes);
 		return Boolean(symbol.initializer && isProvenReactComponentExpression(symbol.initializer, scopes, controlFlow, visitedSymbolIds));
 	}
@@ -39318,7 +40109,7 @@ const isProvenReactComponentSymbol = (symbol, scopes, controlFlow, componentRefe
 	for (const candidateSymbol of candidateSymbols) {
 		if (hasSymbolWriteBefore(candidateSymbol, componentReference, scopes)) continue;
 		if (isComponentDeclaration(candidateSymbol.declarationNode)) {
-			if (functionHasComponentEvidence(candidateSymbol.declarationNode, scopes, controlFlow)) return true;
+			if (functionHasReactComponentEvidence(candidateSymbol.declarationNode, scopes, controlFlow)) return true;
 			continue;
 		}
 		const initializer = candidateSymbol.initializer ? stripParenExpression(candidateSymbol.initializer) : null;
@@ -43104,6 +43895,53 @@ const noPropCallbackInEffect = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-prop-callback-in-render.ts
+const functionBindingSymbols = (functionNode, scopes) => {
+	let bindingIdentifier = null;
+	if (isNodeOfType(functionNode, "FunctionDeclaration") && functionNode.id) bindingIdentifier = functionNode.id;
+	else {
+		let bindingExpression = findTransparentExpressionRoot(functionNode);
+		let parent = bindingExpression.parent;
+		while (isNodeOfType(parent, "CallExpression") && parent.arguments[0] === bindingExpression) {
+			const callee = parent.callee;
+			const wrapperName = isNodeOfType(callee, "Identifier") ? callee.name : isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") ? callee.property.name : null;
+			if (!isReactApiCall(parent, REACT_HOC_NAMES, scopes, {
+				allowGlobalReactNamespace: true,
+				resolveNamedAliases: true
+			}) && (!wrapperName || REACT_HOC_NAMES.has(wrapperName) || !COMPONENT_HOC_WRAPPER_NAMES.has(wrapperName))) break;
+			bindingExpression = findTransparentExpressionRoot(parent);
+			parent = bindingExpression.parent;
+		}
+		if (isNodeOfType(parent, "VariableDeclarator") && parent.init === bindingExpression && isNodeOfType(parent.id, "Identifier")) bindingIdentifier = parent.id;
+	}
+	if (!bindingIdentifier) return [];
+	let scope = scopes.scopeFor(functionNode);
+	while (scope) {
+		const symbols = scope.symbols.filter((symbol) => symbol.bindingIdentifier === bindingIdentifier);
+		if (symbols.length > 0) return symbols;
+		scope = scope.parent;
+	}
+	return [];
+};
+const symbolHasReactComponentUse = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	for (const reference of symbol.references) {
+		const identifier = reference.identifier;
+		if (hasSymbolWriteBefore(symbol, identifier, scopes)) continue;
+		const parent = identifier.parent;
+		if (isNodeOfType(parent, "JSXOpeningElement") && isNodeOfType(parent.name, "JSXIdentifier") && parent.name === identifier) return true;
+		const expression = findTransparentExpressionRoot(identifier);
+		const expressionParent = expression.parent;
+		if (isNodeOfType(expressionParent, "CallExpression") && expressionParent.arguments[0] === expression && isReactApiCall(expressionParent, "createElement", scopes, { resolveNamedAliases: true })) return true;
+		if (!isNodeOfType(expressionParent, "VariableDeclarator") || expressionParent.init !== expression || !isNodeOfType(expressionParent.id, "Identifier") || !isNodeOfType(expressionParent.parent, "VariableDeclaration") || expressionParent.parent.kind !== "const") continue;
+		const aliasSymbol = scopes.symbolFor(expressionParent.id);
+		if (aliasSymbol && symbolHasReactComponentUse(aliasSymbol, scopes, visitedSymbolIds)) return true;
+	}
+	return false;
+};
+const functionHasReactComponentUse = (functionNode, scopes) => {
+	return functionBindingSymbols(functionNode, scopes).some((symbol) => symbolHasReactComponentUse(symbol, scopes));
+};
 const isPreservedThroughConciseArrow = (callExpression, scopes) => {
 	let node = callExpression;
 	let parent = node.parent;
@@ -43150,7 +43988,10 @@ const noPropCallbackInRender = defineRule({
 	create: (context) => ({ CallExpression(node) {
 		if (!isResultDiscardedCall(node)) return;
 		if (isPreservedThroughConciseArrow(node, context.scopes)) return;
-		if (!findRenderPhaseComponentOrHook(node, context.scopes)) return;
+		const renderPhaseOwner = findRenderPhaseComponentOrHook(node, context.scopes);
+		if (!renderPhaseOwner) return;
+		const renderPhaseOwnerName = componentOrHookDisplayNameForFunction(renderPhaseOwner);
+		if (!renderPhaseOwnerName || !isReactHookName(renderPhaseOwnerName) && !functionHasReactComponentEvidence(renderPhaseOwner, context.scopes, context.cfg) && !functionHasReactComponentUse(renderPhaseOwner, context.scopes)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
 		const callee = stripParenExpression(node.callee);
@@ -43886,11 +44727,110 @@ const isSameRefCurrentMember = (node, refSymbol, scopes) => {
 	return isNodeOfType(receiver, "Identifier") && resolveConstIdentifierAlias(receiver, scopes)?.id === refSymbol.id;
 };
 const isSameRefCurrentAlias = (node, refSymbol, scopes) => {
-	if (isSameRefCurrentMember(node, refSymbol, scopes)) return true;
-	if (!isNodeOfType(node, "Identifier")) return false;
-	const aliasSymbol = scopes.symbolFor(node);
+	const expression = stripParenExpression(node);
+	if (isSameRefCurrentMember(expression, refSymbol, scopes)) return true;
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	const aliasSymbol = scopes.symbolFor(expression);
 	return aliasSymbol?.kind === "const" && aliasSymbol.initializer !== null && isSameRefCurrentMember(stripParenExpression(aliasSymbol.initializer), refSymbol, scopes);
 };
+const resolveImmutableInitializationValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(node);
+	if (!isNodeOfType(expression, "Identifier")) return expression;
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol || symbol.kind !== "const" || !symbol.initializer || symbol.references.some((reference) => reference.flag !== "read") || visitedSymbolIds.has(symbol.id)) return null;
+	visitedSymbolIds.add(symbol.id);
+	return resolveImmutableInitializationValue(symbol.initializer, scopes, visitedSymbolIds);
+};
+const isProvablyTruthyInitializationValue = (node, scopes) => {
+	const expression = resolveImmutableInitializationValue(node, scopes);
+	return Boolean(expression && (isNodeOfType(expression, "NewExpression") || isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "ArrayExpression") || isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression") || isNodeOfType(expression, "ClassExpression")));
+};
+const getInitializationConstructorName = (node, scopes) => {
+	const expression = resolveImmutableInitializationValue(node, scopes);
+	if (!expression) return null;
+	if (isNodeOfType(expression, "NewExpression")) {
+		const callee = stripParenExpression(expression.callee);
+		return isNodeOfType(callee, "Identifier") ? callee.name : null;
+	}
+	return null;
+};
+const isClosedTruthyTypeDomain = (typeNode, initializationValue, scopes) => {
+	const initializationExpression = stripParenExpression(initializationValue);
+	if (isNodeOfType(typeNode, "TSTypeLiteral")) return isNodeOfType(initializationExpression, "ObjectExpression");
+	if (isNodeOfType(typeNode, "TSArrayType") || isNodeOfType(typeNode, "TSTupleType")) return isNodeOfType(initializationExpression, "ArrayExpression");
+	if (isNodeOfType(typeNode, "TSFunctionType") || isNodeOfType(typeNode, "TSConstructorType")) return isNodeOfType(initializationExpression, "ArrowFunctionExpression") || isNodeOfType(initializationExpression, "FunctionExpression") || isNodeOfType(initializationExpression, "ClassExpression");
+	if (isNodeOfType(typeNode, "TSObjectKeyword")) return true;
+	if (!isNodeOfType(typeNode, "TSTypeReference")) return false;
+	const typeName = typeNode.typeName;
+	return isNodeOfType(typeName, "Identifier") && typeName.name === getInitializationConstructorName(initializationExpression, scopes);
+};
+const refHasClosedFalsySentinelDomain = (refSymbol, initializationValue, scopes) => {
+	const initializer = refSymbol.initializer ? stripParenExpression(refSymbol.initializer) : null;
+	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
+	const [initialValue] = initializer.arguments ?? [];
+	if (!initialValue || isNodeOfType(initialValue, "SpreadElement") || !isEmptySentinel(initialValue, scopes)) return false;
+	const [declaredType] = initializer.typeArguments?.params ?? [];
+	if (!declaredType || !isNodeOfType(declaredType, "TSUnionType")) return false;
+	let hasEmptySentinel = false;
+	let hasTruthyDomain = false;
+	for (const memberType of declaredType.types ?? []) {
+		if (isNodeOfType(memberType, "TSNullKeyword") || isNodeOfType(memberType, "TSUndefinedKeyword")) {
+			hasEmptySentinel = true;
+			continue;
+		}
+		if (!isClosedTruthyTypeDomain(memberType, initializationValue, scopes)) return false;
+		hasTruthyDomain = true;
+	}
+	return hasEmptySentinel && hasTruthyDomain;
+};
+const isSafeRefIdentifierUse = (identifier) => {
+	const expressionRoot = findTransparentExpressionRoot(identifier);
+	const parent = expressionRoot.parent;
+	if (parent && isNodeOfType(parent, "VariableDeclarator") && parent.id === expressionRoot && parent.parent !== null && isNodeOfType(parent.parent, "VariableDeclaration") && parent.parent.kind === "const") return true;
+	if (parent && isNodeOfType(parent, "MemberExpression") && parent.object === expressionRoot && getStaticPropertyName(parent) === "current") return true;
+	if (!parent || !isNodeOfType(parent, "VariableDeclarator") || parent.init !== expressionRoot) return false;
+	return isNodeOfType(parent.id, "Identifier") && parent.parent !== null && isNodeOfType(parent.parent, "VariableDeclaration") && parent.parent.kind === "const";
+};
+const refDoesNotEscape = (branchRoot, refSymbol, scopes) => {
+	let didEscape = false;
+	walkAst(branchRoot, (child) => {
+		if (didEscape) return false;
+		if (!isNodeOfType(child, "Identifier")) return;
+		if (resolveConstIdentifierAlias(child, scopes)?.id !== refSymbol.id) return;
+		if (child === refSymbol.bindingIdentifier || isSafeRefIdentifierUse(child)) return;
+		didEscape = true;
+		return false;
+	});
+	return !didEscape;
+};
+const expressionContainsRefCurrent = (expression, refSymbol, scopes) => {
+	let didFindRefCurrent = false;
+	walkAst(expression, (child) => {
+		if (didFindRefCurrent) return false;
+		if (resolveReactRefSymbol(child, scopes)?.id !== refSymbol.id) return;
+		didFindRefCurrent = true;
+		return false;
+	});
+	return didFindRefCurrent;
+};
+const hasNoCompetingRefCurrentWrite = (branchRoot, assignmentExpression, refSymbol, scopes) => {
+	let writeCount = 0;
+	walkAst(branchRoot, (child) => {
+		if (writeCount > 1) return false;
+		if (isNodeOfType(child, "AssignmentExpression")) {
+			if (expressionContainsRefCurrent(child.left, refSymbol, scopes)) writeCount++;
+			return;
+		}
+		if (isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") {
+			if (expressionContainsRefCurrent(child.argument, refSymbol, scopes)) writeCount++;
+			return;
+		}
+		if (isNodeOfType(child, "ForInStatement") || isNodeOfType(child, "ForOfStatement")) {
+			if (expressionContainsRefCurrent(child.left, refSymbol, scopes)) writeCount++;
+		}
+	});
+	return writeCount === 1 && expressionContainsRefCurrent(assignmentExpression.left, refSymbol, scopes);
+};
 const isEmptySentinel = (node, scopes) => isNodeOfType(node, "Literal") && node.value === null || isNodeOfType(node, "Identifier") && node.name === "undefined" && scopes.isGlobalReference(node);
 const hasRepeatedExecutionAncestor = (node, stop) => {
 	let ancestor = node.parent;
@@ -43939,18 +44879,22 @@ const hasNoPriorCoExecutableWrite = (assignmentExpression, branchRoot, refSymbol
 const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes) => {
 	if (assignmentExpression.operator === "??=" || assignmentExpression.operator === "||=") return true;
 	if (assignmentExpression.operator !== "=") return false;
+	const renderOwner = findRenderPhaseComponentOrHook(assignmentExpression, scopes);
+	if (!renderOwner) return false;
 	let descendant = assignmentExpression;
 	let ancestor = descendant.parent;
 	while (ancestor) {
-		if (isNodeOfType(ancestor, "IfStatement") && isNodeOfType(ancestor.test, "BinaryExpression") && [
+		const test = isNodeOfType(ancestor, "IfStatement") ? stripParenExpression(ancestor.test) : null;
+		if (isNodeOfType(ancestor, "IfStatement") && test && isNodeOfType(test, "UnaryExpression") && test.operator === "!" && isSameRefCurrentAlias(test.argument, refSymbol, scopes) && ancestor.consequent === descendant && isProvablyTruthyInitializationValue(assignmentExpression.right, scopes) && refHasClosedFalsySentinelDomain(refSymbol, assignmentExpression.right, scopes) && !hasRepeatedExecutionAncestor(assignmentExpression, ancestor.consequent) && !hasRepeatedExecutionAncestor(ancestor, renderOwner) && hasNoPriorCoExecutableWrite(assignmentExpression, ancestor.consequent, refSymbol, scopes) && hasNoCompetingRefCurrentWrite(renderOwner, assignmentExpression, refSymbol, scopes) && refDoesNotEscape(renderOwner, refSymbol, scopes)) return true;
+		if (isNodeOfType(ancestor, "IfStatement") && isNodeOfType(test, "BinaryExpression") && [
 			"===",
 			"==",
 			"!==",
 			"!="
-		].includes(ancestor.test.operator)) {
-			const { left, right } = ancestor.test;
+		].includes(test.operator)) {
+			const { left, right } = test;
 			const comparesEmptySentinel = isSameRefCurrentAlias(left, refSymbol, scopes) && isEmptySentinel(right, scopes) || isSameRefCurrentAlias(right, refSymbol, scopes) && isEmptySentinel(left, scopes);
-			const guardedBranch = ancestor.test.operator === "===" || ancestor.test.operator === "==" ? ancestor.consequent : ancestor.alternate;
+			const guardedBranch = test.operator === "===" || test.operator === "==" ? ancestor.consequent : ancestor.alternate;
 			if (comparesEmptySentinel && guardedBranch === descendant && guardedBranch && !hasRepeatedExecutionAncestor(assignmentExpression, guardedBranch) && hasNoPriorCoExecutableWrite(assignmentExpression, guardedBranch, refSymbol, scopes)) return true;
 		}
 		descendant = ancestor;
@@ -46585,6 +47529,185 @@ const noUnescapedEntities = defineRule({
 	} })
 });
 //#endregion
+//#region src/plugin/utils/read-server-snapshot-boolean.ts
+const crossFileScopes = /* @__PURE__ */ new WeakMap();
+const getCrossFileScopes = (programNode) => {
+	const cachedScopes = crossFileScopes.get(programNode);
+	if (cachedScopes) return cachedScopes;
+	const scopes = analyzeScopes(programNode);
+	crossFileScopes.set(programNode, scopes);
+	return scopes;
+};
+const symbolIsImmutable = (symbol) => (symbol.kind === "const" || symbol.kind === "function") && symbol.references.every((reference) => reference.flag === "read");
+const identifierAliasChainIsImmutable = (identifier, scopes, allowImportTerminal = false) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	let symbol = scopes.symbolFor(identifier);
+	while (symbol) {
+		if (symbol.kind === "import") return allowImportTerminal;
+		if (visitedSymbolIds.has(symbol.id) || !symbolIsImmutable(symbol)) return false;
+		visitedSymbolIds.add(symbol.id);
+		if (symbol.kind !== "const" || !symbol.initializer) return symbol.kind === "function";
+		const initializer = stripParenExpression(symbol.initializer);
+		if (!isNodeOfType(initializer, "Identifier")) return true;
+		symbol = scopes.symbolFor(initializer);
+	}
+	return false;
+};
+const getImportedHookBinding = (callee, scopes) => {
+	if (!isNodeOfType(callee, "Identifier") || !identifierAliasChainIsImmutable(callee, scopes, true)) return null;
+	const importedSymbol = resolveConstIdentifierAlias(callee, scopes);
+	if (importedSymbol?.kind !== "import") return null;
+	const importDeclaration = importedSymbol.declarationNode.parent;
+	if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration")) return null;
+	const source = importDeclaration.source.value;
+	if (typeof source !== "string") return null;
+	const exportedName = resolveImportedExportName(importedSymbol.declarationNode);
+	return exportedName ? {
+		exportedName,
+		source
+	} : null;
+};
+const functionBindingIsImmutable = (functionNode, scopes) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration") && functionNode.id) {
+		const symbol = scopes.symbolFor(functionNode.id);
+		return Boolean(symbol && symbolIsImmutable(symbol));
+	}
+	const expressionRoot = findTransparentExpressionRoot(functionNode);
+	const parentNode = expressionRoot.parent;
+	if (isNodeOfType(parentNode, "ExportDefaultDeclaration")) return true;
+	if (!isNodeOfType(parentNode, "VariableDeclarator") || parentNode.init !== expressionRoot || !isNodeOfType(parentNode.id, "Identifier")) return false;
+	const symbol = scopes.symbolFor(parentNode.id);
+	return Boolean(symbol && symbolIsImmutable(symbol));
+};
+const getExactFunctionResultExpression = (functionNode) => {
+	if (!isFunctionLike$1(functionNode) || functionNode.async) return null;
+	if (isNodeOfType(functionNode, "FunctionDeclaration") && functionNode.generator) return null;
+	if (isNodeOfType(functionNode, "FunctionExpression") && functionNode.generator) return null;
+	if (!isNodeOfType(functionNode.body, "BlockStatement")) return functionNode.body;
+	const [returnStatement, additionalReturnStatement] = collectFunctionReturnStatements(functionNode);
+	if (!returnStatement || additionalReturnStatement || !returnStatement.argument) return null;
+	if ([...functionNode.body.body].pop() !== returnStatement) return null;
+	return returnStatement.argument;
+};
+const functionHasNoParameters = (functionNode) => isFunctionLike$1(functionNode) && (functionNode.params?.length ?? 0) === 0;
+const readImmutableBooleanLiteral = (expression, scopes, visitedSymbolIds) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "Literal") && typeof unwrappedExpression.value === "boolean") return unwrappedExpression.value;
+	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
+	const symbol = scopes.symbolFor(unwrappedExpression);
+	if (!symbol || symbol.kind !== "const" || !symbol.initializer || !symbolIsImmutable(symbol) || visitedSymbolIds.has(symbol.id)) return null;
+	visitedSymbolIds.add(symbol.id);
+	return readImmutableBooleanLiteral(symbol.initializer, scopes, visitedSymbolIds);
+};
+const readFunctionLiteralBoolean = (expression, scopes) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "Identifier") && !identifierAliasChainIsImmutable(unwrappedExpression, scopes)) return null;
+	const functionNode = resolveExactLocalFunction(unwrappedExpression, scopes);
+	if (!functionNode) return null;
+	const resultExpression = getExactFunctionResultExpression(functionNode);
+	return resultExpression ? readImmutableBooleanLiteral(resultExpression, scopes, /* @__PURE__ */ new Set()) : null;
+};
+const readServerSnapshotBooleanInternal = (expression, scopes, visitedSymbolIds, visitedFunctionNodes, currentFilename) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "Literal") && typeof unwrappedExpression.value === "boolean") return {
+		hasUseSyncExternalStoreOrigin: false,
+		value: unwrappedExpression.value
+	};
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		const symbol = scopes.symbolFor(unwrappedExpression);
+		if (!symbol || symbol.kind !== "const" || !symbol.initializer || !symbolIsImmutable(symbol) || visitedSymbolIds.has(symbol.id)) return null;
+		visitedSymbolIds.add(symbol.id);
+		return readServerSnapshotBooleanInternal(symbol.initializer, scopes, visitedSymbolIds, visitedFunctionNodes, currentFilename);
+	}
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
+		const argumentResult = readServerSnapshotBooleanInternal(unwrappedExpression.argument, scopes, visitedSymbolIds, visitedFunctionNodes, currentFilename);
+		return argumentResult ? {
+			hasUseSyncExternalStoreOrigin: argumentResult.hasUseSyncExternalStoreOrigin,
+			value: !argumentResult.value
+		} : null;
+	}
+	if (isNodeOfType(unwrappedExpression, "LogicalExpression") && (unwrappedExpression.operator === "&&" || unwrappedExpression.operator === "||")) {
+		const leftResult = readServerSnapshotBooleanInternal(unwrappedExpression.left, scopes, new Set(visitedSymbolIds), new Set(visitedFunctionNodes), currentFilename);
+		if (leftResult && (unwrappedExpression.operator === "&&" && !leftResult.value || unwrappedExpression.operator === "||" && leftResult.value)) return leftResult;
+		const rightResult = readServerSnapshotBooleanInternal(unwrappedExpression.right, scopes, new Set(visitedSymbolIds), new Set(visitedFunctionNodes), currentFilename);
+		if (rightResult && (unwrappedExpression.operator === "&&" && !rightResult.value || unwrappedExpression.operator === "||" && rightResult.value)) return rightResult;
+		return leftResult && rightResult ? {
+			hasUseSyncExternalStoreOrigin: leftResult.hasUseSyncExternalStoreOrigin || rightResult.hasUseSyncExternalStoreOrigin,
+			value: rightResult.value
+		} : null;
+	}
+	if (!isNodeOfType(unwrappedExpression, "CallExpression")) return null;
+	if (isReactApiCall(unwrappedExpression, "useSyncExternalStore", scopes, { resolveNamedAliases: true })) {
+		const [, , serverSnapshotArgument] = unwrappedExpression.arguments ?? [];
+		if (!serverSnapshotArgument || isNodeOfType(serverSnapshotArgument, "SpreadElement")) return null;
+		const serverSnapshotValue = readFunctionLiteralBoolean(serverSnapshotArgument, scopes);
+		return serverSnapshotValue === null ? null : {
+			hasUseSyncExternalStoreOrigin: true,
+			value: serverSnapshotValue
+		};
+	}
+	if ((unwrappedExpression.arguments?.length ?? 0) !== 0) return null;
+	const callee = stripParenExpression(unwrappedExpression.callee);
+	const importedHookBinding = getImportedHookBinding(callee, scopes);
+	if (importedHookBinding && currentFilename) {
+		const resolvedHook = resolveCrossFileFunctionExportWithFilePath(path.resolve(currentFilename), importedHookBinding.source, importedHookBinding.exportedName);
+		if (resolvedHook && !resolvedHook.filePath.split(path.sep).includes("node_modules")) {
+			const resolvedScopes = getCrossFileScopes(resolvedHook.programNode);
+			if (isReactHookName(componentOrHookDisplayNameForFunction(resolvedHook.functionNode) ?? (importedHookBinding.exportedName === "default" && isNodeOfType(callee, "Identifier") ? callee.name : importedHookBinding.exportedName)) && functionHasNoParameters(resolvedHook.functionNode) && functionBindingIsImmutable(resolvedHook.functionNode, resolvedScopes) && !visitedFunctionNodes.has(resolvedHook.functionNode)) {
+				visitedFunctionNodes.add(resolvedHook.functionNode);
+				const resultExpression = getExactFunctionResultExpression(resolvedHook.functionNode);
+				if (resultExpression) return readServerSnapshotBooleanInternal(resultExpression, resolvedScopes, /* @__PURE__ */ new Set(), visitedFunctionNodes, resolvedHook.filePath);
+			}
+		}
+		return null;
+	}
+	if (!isNodeOfType(callee, "Identifier") || !isReactHookName(callee.name) || !identifierAliasChainIsImmutable(callee, scopes)) return null;
+	const hookFunction = resolveExactLocalFunction(callee, scopes);
+	if (!hookFunction || !functionHasNoParameters(hookFunction) || visitedFunctionNodes.has(hookFunction)) return null;
+	visitedFunctionNodes.add(hookFunction);
+	const resultExpression = getExactFunctionResultExpression(hookFunction);
+	return resultExpression ? readServerSnapshotBooleanInternal(resultExpression, scopes, visitedSymbolIds, visitedFunctionNodes, currentFilename) : null;
+};
+const readServerSnapshotBoolean = (expression, scopes, currentFilename) => {
+	const result = readServerSnapshotBooleanInternal(expression, scopes, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), currentFilename);
+	return result?.hasUseSyncExternalStoreOrigin ? result.value : null;
+};
+//#endregion
+//#region src/plugin/utils/is-after-falsy-server-snapshot-early-return.ts
+const isAfterFalsyServerSnapshotEarlyReturn = (node, componentOrHookNode, scopes, filename) => {
+	const enclosingFunction = findEnclosingFunction$1(node);
+	if (!enclosingFunction || enclosingFunction !== componentOrHookNode && !executesDuringRender(enclosingFunction, 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;
+			const serverResult = readServerSnapshotBoolean(statement.test, scopes, filename);
+			if (serverResult === true && statementAlwaysExits(statement.consequent)) return true;
+			if (serverResult === false && statement.alternate && statementAlwaysExits(statement.alternate)) return true;
+		}
+		currentNode = parentNode;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/is-gated-by-falsy-server-snapshot.ts
+const isGatedByFalsyServerSnapshot = (node, scopes, filename) => {
+	let currentNode = node;
+	let parentNode = node.parent;
+	while (parentNode) {
+		if (isNodeOfType(parentNode, "LogicalExpression") && parentNode.right === currentNode && (parentNode.operator === "&&" && readServerSnapshotBoolean(parentNode.left, scopes, filename) === false || parentNode.operator === "||" && readServerSnapshotBoolean(parentNode.left, scopes, filename) === true)) return true;
+		if (isNodeOfType(parentNode, "ConditionalExpression") && (parentNode.consequent === currentNode && readServerSnapshotBoolean(parentNode.test, scopes, filename) === false || parentNode.alternate === currentNode && readServerSnapshotBoolean(parentNode.test, scopes, filename) === true)) return true;
+		if (isNodeOfType(parentNode, "IfStatement") && (parentNode.consequent === currentNode && readServerSnapshotBoolean(parentNode.test, scopes, filename) === false || parentNode.alternate === currentNode && readServerSnapshotBoolean(parentNode.test, scopes, filename) === true)) return true;
+		currentNode = parentNode;
+		parentNode = parentNode.parent ?? null;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/performance/no-unguarded-browser-global-in-render-or-hook-init.ts
 const BROWSER_GLOBAL_NAMES = new Set([
 	"window",
@@ -46691,7 +47814,9 @@ const noUnguardedBrowserGlobalInRenderOrHookInit = defineRule({
 			if (fileIsEmailTemplate) return;
 			if (isGeneratedImageRenderContext(context, findEnclosingJsxOpeningElement(node) ?? node)) return;
 			if (isGatedByFalsyInitialState(node, context.scopes)) return;
+			if (isGatedByFalsyServerSnapshot(node, context.scopes, context.filename)) return;
 			if (isAfterClientOnlyEarlyReturn(node, componentOrHookNode, context.scopes)) return;
+			if (isAfterFalsyServerSnapshotEarlyReturn(node, componentOrHookNode, context.scopes, context.filename)) return;
 			if (isInsideAvailabilityGuard(node, browserGlobalName, context)) return;
 			if (isAfterAvailabilityEarlyExit(node, componentOrHookNode, browserGlobalName, context)) return;
 			reportedNodes.add(node);
@@ -50894,6 +52019,31 @@ const preferModuleScopePureFunction = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/get-require-call-source.ts
+const getRequireCallSource = (expression) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "MemberExpression")) return getRequireCallSource(unwrappedExpression.object);
+	if (!isNodeOfType(unwrappedExpression, "CallExpression")) return null;
+	if (!isNodeOfType(unwrappedExpression.callee, "Identifier") || unwrappedExpression.callee.name !== "require") return null;
+	const [firstArgument] = unwrappedExpression.arguments ?? [];
+	if (!firstArgument || !isNodeOfType(firstArgument, "Literal")) return null;
+	return typeof firstArgument.value === "string" ? firstArgument.value : null;
+};
+//#endregion
+//#region src/plugin/utils/is-proven-node-crypto-namespace-reference.ts
+const NODE_CRYPTO_MODULE_SOURCES = new Set(["crypto", "node:crypto"]);
+const isProvenNodeCryptoNamespaceReference = (expression, scopes) => {
+	const identifier = stripParenExpression(expression);
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const symbol = resolveConstIdentifierAlias(identifier, scopes);
+	if (!symbol) return false;
+	if (symbol.kind === "import") {
+		const importBinding = getImportBindingForName(identifier, symbol.name);
+		return Boolean(importBinding && NODE_CRYPTO_MODULE_SOURCES.has(importBinding.source));
+	}
+	return Boolean(symbol.kind === "const" && symbol.initializer && NODE_CRYPTO_MODULE_SOURCES.has(getRequireCallSource(symbol.initializer) ?? ""));
+};
+//#endregion
 //#region src/plugin/rules/architecture/prefer-module-scope-static-value.ts
 const MUTATING_RECEIVER_METHOD_NAMES = new Set([...MUTATING_ARRAY_METHODS, ...MUTATING_COLLECTION_METHODS]);
 const isMutationContext = (referenceIdentifier) => {
@@ -51007,9 +52157,9 @@ const isImpureCall = (node, scopes) => {
 	const callee = node.callee;
 	if (isNodeOfType(callee, "Identifier")) return isImpureBareCallee(callee, scopes);
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return false;
-	if (!isNodeOfType(callee.object, "Identifier")) return false;
 	if (!isNodeOfType(callee.property, "Identifier")) return false;
-	return Boolean(IMPURE_MEMBER_RECEIVERS.get(callee.object.name)?.has(callee.property.name));
+	for (const [receiverName, receiverMethodNames] of IMPURE_MEMBER_RECEIVERS) if (receiverMethodNames.has(callee.property.name) && (isProvenGlobalNamespaceReference(callee.object, receiverName, scopes) || receiverName === "crypto" && isProvenNodeCryptoNamespaceReference(callee.object, scopes))) return true;
+	return false;
 };
 const containsImpureExpression = (expression, scopes) => {
 	let foundImpure = false;
@@ -55778,16 +56928,6 @@ const rnListCallbackPerRow = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/get-require-call-source.ts
-const getRequireCallSource = (expression) => {
-	if (isNodeOfType(expression, "MemberExpression")) return getRequireCallSource(expression.object);
-	if (!isNodeOfType(expression, "CallExpression")) return null;
-	if (!isNodeOfType(expression.callee, "Identifier") || expression.callee.name !== "require") return null;
-	const [firstArgument] = expression.arguments ?? [];
-	if (!firstArgument || !isNodeOfType(firstArgument, "Literal")) return null;
-	return typeof firstArgument.value === "string" ? firstArgument.value : null;
-};
-//#endregion
 //#region src/plugin/utils/get-initializer-module-source.ts
 const getInitializerModuleSource = (contextNode, initializer) => {
 	const requireSource = getRequireCallSource(initializer);
@@ -62566,9 +63706,35 @@ const serverDedupProps = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/server/server-fetch-without-revalidate.ts
-const isFetchCall = (node) => {
+const isGlobalThisFetchMember = (node, context) => {
+	const memberExpression = stripParenExpression(node);
+	if (!isNodeOfType(memberExpression, "MemberExpression")) return false;
+	const receiver = stripParenExpression(memberExpression.object);
+	return getStaticPropertyName(memberExpression) === "fetch" && isNodeOfType(receiver, "Identifier") && receiver.name === "globalThis" && context.scopes.isGlobalReference(receiver);
+};
+const isGlobalThisIdentifier = (node, context) => {
+	const expression = stripParenExpression(node);
+	return isNodeOfType(expression, "Identifier") && expression.name === "globalThis" && context.scopes.isGlobalReference(expression);
+};
+const isGlobalFetchDestructuringBinding = (symbolBinding, declaration, context) => isNodeOfType(declaration.id, "ObjectPattern") && Boolean(declaration.id.properties.some((property) => isNodeOfType(property, "Property") && property.value === symbolBinding && getStaticPropertyKeyName(property, { allowComputedString: true }) === "fetch") && declaration.init && isGlobalThisIdentifier(declaration.init, context));
+const isExactGlobalFetchValue = (node, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(node);
+	if (isGlobalThisFetchMember(expression, context)) return true;
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	if (expression.name === "fetch" && context.scopes.isGlobalReference(expression)) return true;
+	const symbol = context.scopes.symbolFor(expression);
+	if (!symbol || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id)) return false;
+	if (!isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return false;
+	if (isGlobalFetchDestructuringBinding(symbol.bindingIdentifier, symbol.declarationNode, context)) return true;
+	if (symbol.declarationNode.id !== symbol.bindingIdentifier || !symbol.initializer) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isExactGlobalFetchValue(symbol.initializer, context, visitedSymbolIds);
+};
+const isFetchCall = (node, context) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
-	return isNodeOfType(node.callee, "Identifier") && node.callee.name === "fetch";
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "Identifier") || callee.name !== "fetch") return false;
+	return isExactGlobalFetchValue(callee, context);
 };
 const getPropertyKeyName$1 = (property) => {
 	if (!isNodeOfType(property, "Property")) return null;
@@ -62614,7 +63780,7 @@ const serverFetchWithoutRevalidate = defineRule({
 			},
 			CallExpression(node) {
 				if (!isServerSideFile) return;
-				if (!isFetchCall(node)) return;
+				if (!isFetchCall(node, context)) return;
 				if (isMutatingFetchCall(node)) return;
 				const optionsArg = node.arguments?.[1];
 				if (optionsArg) {
@@ -70096,6 +71262,7 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"exhaustive-deps",
 	"no-barrel-import",
 	"nextjs-missing-metadata",
+	"nextjs-no-img-element",
 	"nextjs-no-use-search-params-without-suspense",
 	"no-dynamic-import-path",
 	"no-full-lodash-import",
@@ -70327,12 +71494,12 @@ const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 ]);
 /**
 * Cross-file rules whose dependency set CANNOT be soundly bounded — they are
-* excluded from fingerprinting and re-lint every file on every scan. Empty
-* today; a new cross-file rule must be added either here or to
+* excluded from fingerprinting and re-lint every file on every scan. A new
+* cross-file rule must be added either here or to
 * `CROSS_FILE_DEPENDENCY_COLLECTORS` (the core guard test enforces the
 * partition), forcing a conscious classification.
 */
-const UNBOUNDED_CROSS_FILE_RULE_IDS = new Set(["only-export-components"]);
+const UNBOUNDED_CROSS_FILE_RULE_IDS = new Set(["nextjs-no-img-element", "only-export-components"]);
 /**
 * Runs the collectors for `ruleIds` over one file and returns every
 * filesystem probe they made — the file's cross-file dependency set.