oxlint-plugin-react-doctor 0.7.4-dev.98005f2 → 0.7.4-dev.a31f5e8

package/dist/index.js

@@ -21008,7 +21008,6 @@ const findExportedFunctionBody = (programRoot, exportedName) => {
 			continue;
 		}
 		if (isNodeOfType(statement, "ExportNamedDeclaration")) {
-			if (statement.exportKind === "type") continue;
 			const declaration = statement.declaration;
 			if (declaration && isNodeOfType(declaration, "VariableDeclaration")) {
 				recordVariableDeclaration(declaration);
@@ -21023,7 +21022,6 @@ const findExportedFunctionBody = (programRoot, exportedName) => {
 			}
 			for (const specifier of statement.specifiers ?? []) {
 				if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
-				if (specifier.exportKind === "type") continue;
 				const local = specifier.local;
 				const exported = specifier.exported;
 				if (!isNodeOfType(local, "Identifier")) continue;
@@ -21072,37 +21070,25 @@ const resolveImportedExportName = (importSpecifier) => {
 	if (isNodeOfType(importSpecifier, "ImportDefaultSpecifier")) return "default";
 	return null;
 };
-const findReExportTargetsForName = (programRoot, exportedName) => {
+const findReExportSourcesForName = (programRoot, exportedName) => {
 	if (!isNodeOfType(programRoot, "Program")) return [];
-	const exportAllTargets = [];
+	const exportAllSources = [];
 	for (const statement of programRoot.body ?? []) {
 		if (isNodeOfType(statement, "ExportNamedDeclaration") && statement.source) {
-			if (statement.exportKind === "type") continue;
 			const sourceValue = statement.source.value;
 			if (typeof sourceValue !== "string") continue;
 			for (const specifier of statement.specifiers ?? []) {
 				if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
-				if (specifier.exportKind === "type") continue;
 				const exported = specifier.exported;
-				if ((isNodeOfType(exported, "Identifier") ? exported.name : isNodeOfType(exported, "Literal") && typeof exported.value === "string" ? exported.value : null) !== exportedName) continue;
-				const local = specifier.local;
-				const importedName = isNodeOfType(local, "Identifier") ? local.name : isNodeOfType(local, "Literal") && typeof local.value === "string" ? local.value : null;
-				if (importedName) return [{
-					importedName,
-					source: sourceValue
-				}];
+				if ((isNodeOfType(exported, "Identifier") ? exported.name : isNodeOfType(exported, "Literal") && typeof exported.value === "string" ? exported.value : null) === exportedName) return [sourceValue];
 			}
 		}
 		if (isNodeOfType(statement, "ExportAllDeclaration") && statement.source) {
-			if (statement.exportKind === "type" || statement.exported) continue;
 			const sourceValue = statement.source.value;
-			if (typeof sourceValue === "string") exportAllTargets.push({
-				importedName: exportedName,
-				source: sourceValue
-			});
+			if (typeof sourceValue === "string") exportAllSources.push(sourceValue);
 		}
 	}
-	return exportAllTargets;
+	return exportAllSources;
 };
 //#endregion
 //#region src/plugin/utils/attach-parent-references.ts
@@ -21191,6 +21177,139 @@ const parseSourceFile = (absoluteFilePath) => {
 	return parsedProgram;
 };
 //#endregion
+//#region src/plugin/utils/is-barrel-index-module.ts
+const INDEX_MODULE_FILE_PATTERN = /^index\.(?:[cm]?[jt]sx?|mjs)$/;
+const BINDING_IMPORT_DECLARATION_PATTERN = /^\s*import\s+(type\s+)?(?!["'])([^;]*?)\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const BARREL_REEXPORT_DECLARATION_PATTERN = /^\s*export\s+(type\s+)?(?:\*(?:\s+as\s+([\w$]+))?|\{([\s\S]*?)\})\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN = /^\s*export\s+(type\s+)?\{([\s\S]*?)\}\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const barrelIndexModuleInfoCache = /* @__PURE__ */ new Map();
+const isIndexModuleFilePath = (filePath) => INDEX_MODULE_FILE_PATTERN.test(path.basename(filePath));
+const createNonBarrelInfo = () => ({
+	isBarrel: false,
+	exportsByName: /* @__PURE__ */ new Map(),
+	starExportSources: []
+});
+const addImportedBinding = (importedBindings, binding) => {
+	importedBindings.set(binding.localName, {
+		...binding,
+		didExport: false
+	});
+};
+const collectNamedImportBindings = (namedSpecifiersText, source, declarationIsTypeOnly, importedBindings) => {
+	for (const specifier of parseExportSpecifiers(namedSpecifiersText, declarationIsTypeOnly)) addImportedBinding(importedBindings, {
+		localName: specifier.exportedName,
+		importedName: specifier.localName,
+		source,
+		isTypeOnly: specifier.isTypeOnly
+	});
+};
+const collectImportBindings = (importClause, source, declarationIsTypeOnly, importedBindings) => {
+	const trimmedImportClause = importClause.trim();
+	const namespaceMatch = trimmedImportClause.match(/(?:^|,\s*)\*\s+as\s+([\w$]+)/);
+	if (namespaceMatch?.[1]) addImportedBinding(importedBindings, {
+		localName: namespaceMatch[1],
+		importedName: "*",
+		source,
+		isTypeOnly: declarationIsTypeOnly
+	});
+	const namedImportMatch = trimmedImportClause.match(/\{([\s\S]*?)\}/);
+	if (namedImportMatch?.[1]) collectNamedImportBindings(namedImportMatch[1], source, declarationIsTypeOnly, importedBindings);
+	const defaultImportName = trimmedImportClause.split(",")[0]?.trim();
+	if (defaultImportName && !defaultImportName.startsWith("{") && !defaultImportName.startsWith("*")) addImportedBinding(importedBindings, {
+		localName: defaultImportName,
+		importedName: "default",
+		source,
+		isTypeOnly: declarationIsTypeOnly
+	});
+};
+const replaceKnownDeclarations = (sourceText, importedBindings, exportsByName, starExportSources) => {
+	let withoutKnownDeclarations = sourceText.replace(BINDING_IMPORT_DECLARATION_PATTERN, (_match, typeKeyword, importClause, source) => {
+		collectImportBindings(importClause, source, Boolean(typeKeyword), importedBindings);
+		return "";
+	});
+	withoutKnownDeclarations = withoutKnownDeclarations.replace(BARREL_REEXPORT_DECLARATION_PATTERN, (_match, typeKeyword, namespaceExportName, specifiersText, source) => {
+		const isTypeOnly = Boolean(typeKeyword);
+		if (namespaceExportName) {
+			exportsByName.set(namespaceExportName, {
+				exportedName: namespaceExportName,
+				importedName: "*",
+				source,
+				isTypeOnly
+			});
+			return "";
+		}
+		if (specifiersText) {
+			for (const specifier of parseExportSpecifiers(specifiersText, isTypeOnly)) exportsByName.set(specifier.exportedName, {
+				exportedName: specifier.exportedName,
+				importedName: specifier.localName,
+				source,
+				isTypeOnly: specifier.isTypeOnly
+			});
+			return "";
+		}
+		starExportSources.push(source);
+		return "";
+	});
+	withoutKnownDeclarations = withoutKnownDeclarations.replace(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN, (_match, typeKeyword, specifiersText) => {
+		for (const specifier of parseExportSpecifiers(specifiersText, Boolean(typeKeyword))) {
+			const importedBinding = importedBindings.get(specifier.localName);
+			if (!importedBinding) return _match;
+			importedBinding.didExport = true;
+			exportsByName.set(specifier.exportedName, {
+				exportedName: specifier.exportedName,
+				importedName: importedBinding.importedName,
+				source: importedBinding.source,
+				isTypeOnly: specifier.isTypeOnly || importedBinding.isTypeOnly
+			});
+		}
+		return "";
+	});
+	return withoutKnownDeclarations;
+};
+const hasUnexportedRuntimeImport = (importedBindings) => {
+	for (const binding of importedBindings.values()) if (!binding.isTypeOnly && !binding.didExport) return true;
+	return false;
+};
+const classifyBarrelModule = (sourceText) => {
+	const strippedSource = stripJsComments(sourceText).trim();
+	if (!strippedSource) return createNonBarrelInfo();
+	const importedBindings = /* @__PURE__ */ new Map();
+	const exportsByName = /* @__PURE__ */ new Map();
+	const starExportSources = [];
+	if (replaceKnownDeclarations(strippedSource, importedBindings, exportsByName, starExportSources).trim() || hasUnexportedRuntimeImport(importedBindings)) return createNonBarrelInfo();
+	return {
+		isBarrel: exportsByName.size > 0 || starExportSources.length > 0,
+		exportsByName,
+		starExportSources
+	};
+};
+const getBarrelIndexModuleInfo = (filePath) => {
+	if (!isIndexModuleFilePath(filePath)) return createNonBarrelInfo();
+	recordContentProbe(filePath);
+	let fileStat;
+	try {
+		fileStat = fs.statSync(filePath);
+	} catch {
+		fileStat = null;
+	}
+	const cachedResult = barrelIndexModuleInfoCache.get(filePath);
+	if (cachedResult !== void 0 && fileStat !== null && cachedResult.mtimeMs === fileStat.mtimeMs && cachedResult.size === fileStat.size) return cachedResult.moduleInfo;
+	if (fileStat === null) return createNonBarrelInfo();
+	let moduleInfo = createNonBarrelInfo();
+	try {
+		moduleInfo = classifyBarrelModule(fs.readFileSync(filePath, "utf8"));
+	} catch {
+		moduleInfo = createNonBarrelInfo();
+	}
+	barrelIndexModuleInfoCache.set(filePath, {
+		mtimeMs: fileStat.mtimeMs,
+		size: fileStat.size,
+		moduleInfo
+	});
+	return moduleInfo;
+};
+const isBarrelIndexModule = (filePath) => getBarrelIndexModuleInfo(filePath).isBarrel;
+//#endregion
 //#region src/plugin/utils/resolve-relative-import-path.ts
 const MODULE_FILE_EXTENSIONS = [
 	".ts",
@@ -21307,6 +21426,35 @@ const resolveModuleFileFromAbsolutePath = (importPath) => {
 };
 const resolveRelativeImportPath = (filename, source) => resolveModuleFileFromAbsolutePath(path.resolve(path.dirname(filename), source));
 //#endregion
+//#region src/plugin/utils/resolve-barrel-export-file-path.ts
+const getUniqueFilePath = (filePaths) => {
+	const uniqueFilePaths = new Set(filePaths);
+	if (uniqueFilePaths.size !== 1) return null;
+	const [filePath] = uniqueFilePaths;
+	return filePath ?? null;
+};
+const resolveStarExportFilePath = (barrelFilePath, exportedName, source, visitedFilePaths) => {
+	const resolvedTargetPath = resolveRelativeImportPath(barrelFilePath, source);
+	if (!resolvedTargetPath) return null;
+	const nestedTargetPath = resolveBarrelExportFilePath(resolvedTargetPath, exportedName, new Set(visitedFilePaths));
+	if (nestedTargetPath) return nestedTargetPath;
+	return doesModuleExportName(resolvedTargetPath, exportedName) ? resolvedTargetPath : null;
+};
+const resolveBarrelExportFilePath = (barrelFilePath, exportedName, visitedFilePaths = /* @__PURE__ */ new Set()) => {
+	if (visitedFilePaths.has(barrelFilePath)) return null;
+	visitedFilePaths.add(barrelFilePath);
+	const moduleInfo = getBarrelIndexModuleInfo(barrelFilePath);
+	if (!moduleInfo.isBarrel) return null;
+	const target = moduleInfo.exportsByName.get(exportedName);
+	if (target) {
+		const resolvedTargetPath = resolveRelativeImportPath(barrelFilePath, target.source);
+		if (!resolvedTargetPath) return null;
+		return resolveBarrelExportFilePath(resolvedTargetPath, target.importedName, visitedFilePaths) ?? resolvedTargetPath;
+	}
+	if (exportedName === "default") return null;
+	return getUniqueFilePath(moduleInfo.starExportSources.map((source) => resolveStarExportFilePath(barrelFilePath, exportedName, source, visitedFilePaths)).filter((filePath) => Boolean(filePath)));
+};
+//#endregion
 //#region src/plugin/utils/resolve-tsconfig-alias.ts
 const TSCONFIG_FILE_NAMES = ["tsconfig.json", "jsconfig.json"];
 const isObjectRecord = (value) => typeof value === "object" && value !== null;
@@ -21485,29 +21633,25 @@ const resolveTsconfigAliasPath = (fromFilename, source) => {
 };
 //#endregion
 //#region src/plugin/utils/resolve-module-path.ts
-const resolveModulePath = (fromFilename, source) => {
-	if (path.isAbsolute(source)) return null;
-	return source.startsWith(".") ? resolveRelativeImportPath(fromFilename, source) : resolveTsconfigAliasPath(fromFilename, source);
-};
+const resolveModulePath = (fromFilename, source) => resolveRelativeImportPath(fromFilename, source) ?? resolveTsconfigAliasPath(fromFilename, source);
 //#endregion
 //#region src/plugin/utils/resolve-cross-file-function-export.ts
 const resolveFunctionExportInFile = (filePath, exportedName, visitedFilePaths) => {
 	if (visitedFilePaths.size >= 4) return null;
 	if (visitedFilePaths.has(filePath)) return null;
 	visitedFilePaths.add(filePath);
-	const programRoot = parseSourceFile(filePath);
+	const actualFilePath = resolveBarrelExportFilePath(filePath, exportedName) ?? filePath;
+	const programRoot = parseSourceFile(actualFilePath);
 	if (!programRoot) return null;
 	const exported = findExportedFunctionBody(programRoot, exportedName);
 	if (exported) return exported;
-	const resolvedCandidates = /* @__PURE__ */ new Set();
-	for (const target of findReExportTargetsForName(programRoot, exportedName)) {
-		const nextFilePath = resolveModulePath(filePath, target.source);
+	for (const reExportSource of findReExportSourcesForName(programRoot, exportedName)) {
+		const nextFilePath = resolveModulePath(actualFilePath, reExportSource);
 		if (!nextFilePath) continue;
-		const resolved = resolveFunctionExportInFile(nextFilePath, target.importedName, new Set(visitedFilePaths));
-		if (resolved) resolvedCandidates.add(resolved);
+		const resolved = resolveFunctionExportInFile(nextFilePath, exportedName, visitedFilePaths);
+		if (resolved) return resolved;
 	}
-	if (resolvedCandidates.size !== 1) return null;
-	return resolvedCandidates.values().next().value ?? null;
+	return null;
 };
 const resolveCrossFileFunctionExport = (fromFilename, source, exportedName) => {
 	const resolvedFilePath = resolveModulePath(fromFilename, source);
@@ -22690,46 +22834,6 @@ const PURE_GLOBAL_CALLEE_NAMES = new Set([
 	"parseInt"
 ]);
 const PURE_GLOBAL_NAMESPACE_NAMES = new Set(["JSON", "Math"]);
-const PURE_HELPER_NAMESPACE_MEMBER_NAMES = new Map([["JSON", new Set([
-	"isRawJSON",
-	"parse",
-	"rawJSON",
-	"stringify"
-])], ["Math", new Set([
-	"abs",
-	"acos",
-	"acosh",
-	"asin",
-	"asinh",
-	"atan",
-	"atan2",
-	"atanh",
-	"cbrt",
-	"ceil",
-	"clz32",
-	"cos",
-	"cosh",
-	"exp",
-	"floor",
-	"fround",
-	"hypot",
-	"imul",
-	"log",
-	"log10",
-	"log1p",
-	"log2",
-	"max",
-	"min",
-	"pow",
-	"round",
-	"sign",
-	"sin",
-	"sinh",
-	"sqrt",
-	"tan",
-	"tanh",
-	"trunc"
-])]]);
 const PURE_MEMBER_TRANSFORM_NAMES = new Set([
 	"concat",
 	"filter",
@@ -22776,42 +22880,6 @@ const getParameterBindingIdentity = (analysis, functionNode, parameter) => {
 	}
 	return parameter;
 };
-const isAsyncOrGeneratorFunction = (functionNode) => Boolean(functionNode.async === true || functionNode.generator === true);
-const isModuleFunction = (functionNode) => {
-	let ancestor = functionNode.parent;
-	while (ancestor) {
-		if (isFunctionLike$1(ancestor)) return false;
-		if (isNodeOfType(ancestor, "Program")) return true;
-		ancestor = ancestor.parent;
-	}
-	return false;
-};
-const getFunctionBindingNames = (functionNode) => {
-	const names = /* @__PURE__ */ new Set();
-	if ((isNodeOfType(functionNode, "FunctionDeclaration") || isNodeOfType(functionNode, "FunctionExpression")) && functionNode.id) names.add(functionNode.id.name);
-	const parent = functionNode.parent;
-	if (parent && isNodeOfType(parent, "VariableDeclarator") && isNodeOfType(parent.id, "Identifier")) names.add(parent.id.name);
-	return names;
-};
-const collectModuleBindingNames = (functionNode) => {
-	let program = functionNode.parent;
-	while (program && !isNodeOfType(program, "Program")) program = program.parent;
-	const bindingNames = /* @__PURE__ */ new Set();
-	if (!program || !isNodeOfType(program, "Program")) return bindingNames;
-	for (const statement of program.body ?? []) {
-		if (isNodeOfType(statement, "ImportDeclaration")) {
-			for (const specifier of statement.specifiers ?? []) if (isNodeOfType(specifier.local, "Identifier")) bindingNames.add(specifier.local.name);
-			continue;
-		}
-		const declaration = isNodeOfType(statement, "ExportNamedDeclaration") || isNodeOfType(statement, "ExportDefaultDeclaration") ? statement.declaration : statement;
-		if (isNodeOfType(declaration, "VariableDeclaration")) {
-			for (const declarator of declaration.declarations ?? []) collectPatternNames(declarator.id, bindingNames);
-			continue;
-		}
-		if ((isNodeOfType(declaration, "FunctionDeclaration") || isNodeOfType(declaration, "ClassDeclaration")) && isNodeOfType(declaration.id, "Identifier")) bindingNames.add(declaration.id.name);
-	}
-	return bindingNames;
-};
 const buildSubstitutions = (analysis, functionNode, argumentExpressions, parentFrame) => {
 	const substitutions = /* @__PURE__ */ new Map();
 	const parameters = getFunctionParameters(functionNode);
@@ -22942,7 +23010,7 @@ const collectIntroducedBindings = (analysis, functionNode) => {
 	for (const parameter of getFunctionParameters(functionNode)) if (isNodeOfType(parameter, "Identifier")) introducedBindings.add(getParameterBindingIdentity(analysis, functionNode, parameter));
 	return introducedBindings;
 };
-const collectBoundedEffectExecutionFrames = (analysis, effectNode, currentFilename) => {
+const collectBoundedEffectExecutionFrames = (analysis, effectNode) => {
 	const effectFunction = getEffectFn(analysis, effectNode);
 	if (!effectFunction || !isFunctionLike$1(effectFunction) || effectFunction.async === true) return [];
 	const invokedFunctionEvidence = collectEffectInvokedFunctions(effectFunction);
@@ -22951,8 +23019,7 @@ const collectBoundedEffectExecutionFrames = (analysis, effectNode, currentFilena
 		invocation: null,
 		isDeferred: false,
 		introducedBindings: /* @__PURE__ */ new Set(),
-		substitutions: /* @__PURE__ */ new Map(),
-		currentFilename
+		substitutions: /* @__PURE__ */ new Map()
 	};
 	const frames = [rootFrame];
 	walkAst(effectFunction, (child) => {
@@ -22973,8 +23040,7 @@ const collectBoundedEffectExecutionFrames = (analysis, effectNode, currentFilena
 				invocation: child,
 				isDeferred,
 				introducedBindings,
-				substitutions: buildSubstitutions(analysis, callable, argumentsForCallable, rootFrame),
-				currentFilename
+				substitutions: buildSubstitutions(analysis, callable, argumentsForCallable, rootFrame)
 			});
 		};
 		if (isFunctionLike$1(callee)) {
@@ -23027,174 +23093,6 @@ const isOpaqueHookCall = (callExpression) => {
 	const calleeName = getCallCalleeName$1(callExpression);
 	return Boolean(calleeName && /^use[A-Z0-9]/.test(calleeName) && calleeName !== "useMemo" && calleeName !== "useCallback" && calleeName !== "useEffectEvent");
 };
-const analyzeHelperStatements = (statements, environment, usedParameterIndices, analyzeExpression) => {
-	let canContinue = true;
-	for (const statement of statements) {
-		if (!canContinue) {
-			if (!isNodeOfType(statement, "EmptyStatement")) return {
-				canContinue: false,
-				isValid: false
-			};
-			continue;
-		}
-		if (isNodeOfType(statement, "EmptyStatement")) continue;
-		if (isNodeOfType(statement, "ReturnStatement")) {
-			if (!statement.argument || !analyzeExpression(statement.argument, environment, usedParameterIndices)) return {
-				canContinue: false,
-				isValid: false
-			};
-			canContinue = false;
-			continue;
-		}
-		if (isNodeOfType(statement, "BlockStatement")) {
-			const blockSummary = analyzeHelperStatements(statement.body ?? [], environment, usedParameterIndices, analyzeExpression);
-			if (!blockSummary.isValid) return blockSummary;
-			canContinue = blockSummary.canContinue;
-			continue;
-		}
-		if (isNodeOfType(statement, "IfStatement")) {
-			if (!analyzeExpression(statement.test, environment, usedParameterIndices)) return {
-				canContinue: false,
-				isValid: false
-			};
-			const consequentSummary = analyzeHelperStatements([statement.consequent], environment, usedParameterIndices, analyzeExpression);
-			if (!consequentSummary.isValid) return consequentSummary;
-			const alternateSummary = statement.alternate ? analyzeHelperStatements([statement.alternate], environment, usedParameterIndices, analyzeExpression) : {
-				canContinue: true,
-				isValid: true
-			};
-			if (!alternateSummary.isValid) return alternateSummary;
-			canContinue = consequentSummary.canContinue || alternateSummary.canContinue;
-			continue;
-		}
-		return {
-			canContinue: false,
-			isValid: false
-		};
-	}
-	return {
-		canContinue,
-		isValid: true
-	};
-};
-const analyzeHelperExpression = (expression, environment, usedParameterIndices) => {
-	const node = stripParenExpression(expression);
-	if (isNodeOfType(node, "Literal") || isNodeOfType(node, "TemplateElement")) return true;
-	if (isNodeOfType(node, "Identifier")) {
-		const parameterIndex = environment.parameterIndices.get(node.name);
-		if (parameterIndex !== void 0) {
-			if (parameterIndex !== null) usedParameterIndices.add(parameterIndex);
-			return true;
-		}
-		return node.name === "undefined" || node.name === "NaN" || node.name === "Infinity";
-	}
-	if (isNodeOfType(node, "ArrayExpression")) return (node.elements ?? []).every((element) => !element || analyzeHelperExpression(element, environment, usedParameterIndices));
-	if (isNodeOfType(node, "ObjectExpression")) return (node.properties ?? []).every((property) => {
-		if (isNodeOfType(property, "SpreadElement")) return analyzeHelperExpression(property.argument, environment, usedParameterIndices);
-		if (!isNodeOfType(property, "Property") || property.kind !== "init" || property.method === true) return false;
-		if (property.computed && !analyzeHelperExpression(property.key, environment, usedParameterIndices)) return false;
-		return analyzeHelperExpression(property.value, environment, usedParameterIndices);
-	});
-	if (isNodeOfType(node, "TemplateLiteral")) return (node.expressions ?? []).every((templateExpression) => analyzeHelperExpression(templateExpression, environment, usedParameterIndices));
-	if (isNodeOfType(node, "UnaryExpression")) return node.operator !== "delete" && analyzeHelperExpression(node.argument, environment, usedParameterIndices);
-	if (isNodeOfType(node, "BinaryExpression") || isNodeOfType(node, "LogicalExpression")) return analyzeHelperExpression(node.left, environment, usedParameterIndices) && analyzeHelperExpression(node.right, environment, usedParameterIndices);
-	if (isNodeOfType(node, "ConditionalExpression")) return analyzeHelperExpression(node.test, environment, usedParameterIndices) && analyzeHelperExpression(node.consequent, environment, usedParameterIndices) && analyzeHelperExpression(node.alternate, environment, usedParameterIndices);
-	if (isNodeOfType(node, "MemberExpression")) {
-		if (!analyzeHelperExpression(node.object, environment, usedParameterIndices)) return false;
-		return !node.computed || analyzeHelperExpression(node.property, environment, usedParameterIndices);
-	}
-	if (isFunctionLike$1(node)) {
-		if (isAsyncOrGeneratorFunction(node)) return false;
-		const callbackParameterIndices = new Map(environment.parameterIndices);
-		for (const parameter of getFunctionParameters(node)) {
-			if (!isNodeOfType(parameter, "Identifier")) return false;
-			callbackParameterIndices.set(parameter.name, null);
-		}
-		const callbackEnvironment = {
-			parameterIndices: callbackParameterIndices,
-			recursiveNames: environment.recursiveNames,
-			shadowedGlobalNames: environment.shadowedGlobalNames
-		};
-		if (!isNodeOfType(node.body, "BlockStatement")) return analyzeHelperExpression(node.body, callbackEnvironment, usedParameterIndices);
-		const callbackSummary = analyzeHelperStatements(node.body.body ?? [], callbackEnvironment, usedParameterIndices, analyzeHelperExpression);
-		return callbackSummary.isValid && !callbackSummary.canContinue;
-	}
-	if (isNodeOfType(node, "CallExpression")) {
-		const callee = stripParenExpression(node.callee);
-		const calleeRoot = getMemberRoot(callee);
-		const isPureGlobalCall = isNodeOfType(callee, "Identifier") && PURE_GLOBAL_CALLEE_NAMES.has(callee.name) && !environment.parameterIndices.has(callee.name) && !environment.recursiveNames.has(callee.name) && !environment.shadowedGlobalNames.has(callee.name);
-		const namespaceName = isNodeOfType(calleeRoot, "Identifier") && !environment.parameterIndices.has(calleeRoot.name) && !environment.recursiveNames.has(calleeRoot.name) && !environment.shadowedGlobalNames.has(calleeRoot.name) ? calleeRoot.name : null;
-		const namespaceMemberName = getStaticMemberName(callee);
-		const isPureNamespaceCall = isNodeOfType(callee, "MemberExpression") && namespaceName !== null && namespaceMemberName !== null && PURE_HELPER_NAMESPACE_MEMBER_NAMES.get(namespaceName)?.has(namespaceMemberName) === true;
-		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName(callee) ?? "");
-		if (!isPureGlobalCall && !isPureNamespaceCall && !isPureMemberTransform) return false;
-		if (isPureMemberTransform && isNodeOfType(callee, "MemberExpression") && !analyzeHelperExpression(callee.object, environment, usedParameterIndices)) return false;
-		return (node.arguments ?? []).every((argument) => analyzeHelperExpression(argument, environment, usedParameterIndices));
-	}
-	if (isNodeOfType(node, "SpreadElement")) return analyzeHelperExpression(node.argument, environment, usedParameterIndices);
-	return false;
-};
-const helperSummaryCache = /* @__PURE__ */ new WeakMap();
-const summarizeHelperReturn = (functionNode) => {
-	if (!isFunctionLike$1(functionNode) || !isModuleFunction(functionNode)) return null;
-	if (helperSummaryCache.has(functionNode)) return helperSummaryCache.get(functionNode) ?? null;
-	if (isAsyncOrGeneratorFunction(functionNode)) {
-		helperSummaryCache.set(functionNode, null);
-		return null;
-	}
-	const parameterIndices = /* @__PURE__ */ new Map();
-	const parameters = getFunctionParameters(functionNode);
-	for (let parameterIndex = 0; parameterIndex < parameters.length; parameterIndex += 1) {
-		const parameter = parameters[parameterIndex];
-		if (!parameter || !isNodeOfType(parameter, "Identifier") || parameterIndices.has(parameter.name)) {
-			helperSummaryCache.set(functionNode, null);
-			return null;
-		}
-		parameterIndices.set(parameter.name, parameterIndex);
-	}
-	const environment = {
-		parameterIndices,
-		recursiveNames: getFunctionBindingNames(functionNode),
-		shadowedGlobalNames: collectModuleBindingNames(functionNode)
-	};
-	const usedParameterIndices = /* @__PURE__ */ new Set();
-	if (!isNodeOfType(functionNode.body, "BlockStatement")) {
-		if (!analyzeHelperExpression(functionNode.body, environment, usedParameterIndices)) {
-			helperSummaryCache.set(functionNode, null);
-			return null;
-		}
-	} else {
-		const controlFlowSummary = analyzeHelperStatements(functionNode.body.body ?? [], environment, usedParameterIndices, analyzeHelperExpression);
-		if (!controlFlowSummary.isValid || controlFlowSummary.canContinue) {
-			helperSummaryCache.set(functionNode, null);
-			return null;
-		}
-	}
-	const summary = { usedParameterIndices };
-	helperSummaryCache.set(functionNode, summary);
-	return summary;
-};
-const resolveValueHelperFunction = (analysis, callee, currentFilename) => {
-	if (!isNodeOfType(callee, "Identifier")) return null;
-	const reference = getRef(analysis, callee);
-	if (!reference?.resolved) return null;
-	const importDefinition = reference.resolved.defs.find((definition) => definition.type === "ImportBinding");
-	if (importDefinition) {
-		if (!currentFilename) return null;
-		const specifier = importDefinition.node;
-		if (!isNodeOfType(specifier, "ImportSpecifier") && !isNodeOfType(specifier, "ImportDefaultSpecifier")) return null;
-		const importDeclaration = specifier.parent;
-		if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration")) return null;
-		if (importDeclaration.importKind === "type" || isNodeOfType(specifier, "ImportSpecifier") && specifier.importKind === "type") return null;
-		const source = importDeclaration.source?.value;
-		if (typeof source !== "string") return null;
-		const exportedName = resolveImportedExportName(specifier);
-		if (!exportedName) return null;
-		return resolveCrossFileFunctionExport(currentFilename, source, exportedName);
-	}
-	const callable = resolveWrappedCallable(analysis, callee);
-	return callable && isModuleFunction(callable) ? callable : null;
-};
 const isLocallyConstructedObjectMember = (reference, memberExpression) => isNodeOfType(memberExpression, "MemberExpression") && reference.resolved?.defs.some((definition) => {
 	const definitionNode = definition.node;
 	return isNodeOfType(definitionNode, "VariableDeclarator") && Boolean(definitionNode.init) && (isNodeOfType(definitionNode.init, "ObjectExpression") || isNodeOfType(definitionNode.init, "ArrayExpression"));
@@ -23280,55 +23178,38 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 		const calleeRoot = getMemberRoot(callee);
 		const isPureGlobalCall = isNodeOfType(callee, "Identifier") && PURE_GLOBAL_CALLEE_NAMES.has(callee.name) && getIdentifierBindingIdentity(analysis, callee) === null || isNodeOfType(calleeRoot, "Identifier") && PURE_GLOBAL_NAMESPACE_NAMES.has(calleeRoot.name) && getIdentifierBindingIdentity(analysis, calleeRoot) === null;
 		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName(callee) ?? "");
-		if (isPureGlobalCall || isPureMemberTransform) {
-			if (isPureMemberTransform && isNodeOfType(callee, "MemberExpression")) mergeEvidence(evidence, collectValueEvidence(analysis, callee.object, frame, remainingCallFrames, new Set(visitedBindings)));
-			for (const argument of node.arguments ?? []) {
-				if (isFunctionLike$1(argument)) continue;
-				mergeEvidence(evidence, collectValueEvidence(analysis, argument, frame, remainingCallFrames, new Set(visitedBindings)));
-			}
+		if (isPureMemberTransform) mergeEvidence(evidence, collectValueEvidence(analysis, callee.object, frame, remainingCallFrames, new Set(visitedBindings)));
+		for (const argument of node.arguments ?? []) {
+			if (isFunctionLike$1(argument)) continue;
+			mergeEvidence(evidence, collectValueEvidence(analysis, argument, frame, remainingCallFrames, new Set(visitedBindings)));
+		}
+		if (isPureGlobalCall || isPureMemberTransform) return evidence;
+		if (isNodeOfType(callee, "MemberExpression")) {
+			evidence.hasUnknownSource = true;
 			return evidence;
 		}
 		if (remainingCallFrames <= 0) {
 			evidence.hasUnknownSource = true;
 			return evidence;
 		}
-		const localHelperFunction = resolveWrappedCallable(analysis, callee);
-		if (localHelperFunction && !isModuleFunction(localHelperFunction)) {
-			if (isAsyncOrGeneratorFunction(localHelperFunction) || functionInvokesItself(analysis, localHelperFunction)) {
-				evidence.hasUnknownSource = true;
-				return evidence;
-			}
-			const localHelperFrame = {
-				functionNode: localHelperFunction,
-				invocation: node,
-				isDeferred: false,
-				introducedBindings: /* @__PURE__ */ new Set(),
-				substitutions: buildSubstitutions(analysis, localHelperFunction, node.arguments ?? [], frame),
-				currentFilename: frame.currentFilename
-			};
-			const returnedExpressions = getReturnedExpressions(localHelperFunction);
-			if (returnedExpressions.length === 0) {
-				evidence.hasUnknownSource = true;
-				return evidence;
-			}
-			for (const returnedExpression of returnedExpressions) mergeEvidence(evidence, collectValueEvidence(analysis, returnedExpression, localHelperFrame, remainingCallFrames - 1, new Set(visitedBindings)));
+		const callable = resolveWrappedCallable(analysis, callee);
+		if (!callable || callable.async === true || functionInvokesItself(analysis, callable)) {
+			evidence.hasUnknownSource = true;
 			return evidence;
 		}
-		const helperFunction = resolveValueHelperFunction(analysis, callee, frame.currentFilename);
-		const helperSummary = helperFunction ? summarizeHelperReturn(helperFunction) : null;
-		if (!helperSummary) {
+		const valueFrame = {
+			functionNode: callable,
+			invocation: node,
+			isDeferred: false,
+			introducedBindings: /* @__PURE__ */ new Set(),
+			substitutions: buildSubstitutions(analysis, callable, node.arguments ?? [], frame)
+		};
+		const returnedExpressions = getReturnedExpressions(callable);
+		if (returnedExpressions.length === 0) {
 			evidence.hasUnknownSource = true;
 			return evidence;
 		}
-		const argumentsForHelper = node.arguments ?? [];
-		for (const parameterIndex of helperSummary.usedParameterIndices) {
-			const argument = argumentsForHelper[parameterIndex];
-			if (!argument) {
-				evidence.hasUnknownSource = true;
-				return evidence;
-			}
-			mergeEvidence(evidence, collectValueEvidence(analysis, argument, frame, remainingCallFrames - 1, new Set(visitedBindings)));
-		}
+		for (const returnedExpression of returnedExpressions) mergeEvidence(evidence, collectValueEvidence(analysis, returnedExpression, valueFrame, remainingCallFrames - 1, new Set(visitedBindings)));
 		return evidence;
 	}
 	if (isFunctionLike$1(node) || isNodeOfType(node, "AwaitExpression")) {
@@ -23408,8 +23289,8 @@ const areInMutuallyExclusiveBranches = (leftNode, rightNode) => {
 	}
 	return false;
 };
-const collectEffectStateWriteFacts = (analysis, effectNode, currentFilename) => {
-	const frames = collectBoundedEffectExecutionFrames(analysis, effectNode, currentFilename);
+const collectEffectStateWriteFacts = (analysis, effectNode) => {
+	const frames = collectBoundedEffectExecutionFrames(analysis, effectNode);
 	if (frames.length === 0) return [];
 	const effectHasCleanup = hasCleanup(analysis, effectNode);
 	const cleanupManagedStateDeclarators = /* @__PURE__ */ new Set();
@@ -23429,8 +23310,7 @@ const collectEffectStateWriteFacts = (analysis, effectNode, currentFilename) =>
 				invocation: callExpression,
 				isDeferred: frame.isDeferred,
 				introducedBindings: collectIntroducedBindings(analysis, writtenValue),
-				substitutions: /* @__PURE__ */ new Map(),
-				currentFilename
+				substitutions: /* @__PURE__ */ new Map()
 			};
 			valueEvidence = emptyEvidence();
 			const returnedExpressions = getReturnedExpressions(writtenValue);
@@ -23479,7 +23359,7 @@ const noAdjustStateOnPropChange = defineRule({
 		const dependencyReferences = getEffectDepsRefs(analysis, node);
 		if (!dependencyReferences) return;
 		if (!dependencyReferences.flatMap((reference) => isState(analysis, reference) ? [] : getUpstreamRefs(analysis, reference)).some((reference) => isProp(analysis, reference))) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node)) {
 			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
 			context.report({
 				node: fact.callExpression,
@@ -24740,139 +24620,6 @@ const createRelativeImportSource = (filename, targetFilePath) => {
 	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
 };
 //#endregion
-//#region src/plugin/utils/is-barrel-index-module.ts
-const INDEX_MODULE_FILE_PATTERN = /^index\.(?:[cm]?[jt]sx?|mjs)$/;
-const BINDING_IMPORT_DECLARATION_PATTERN = /^\s*import\s+(type\s+)?(?!["'])([^;]*?)\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
-const BARREL_REEXPORT_DECLARATION_PATTERN = /^\s*export\s+(type\s+)?(?:\*(?:\s+as\s+([\w$]+))?|\{([\s\S]*?)\})\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
-const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN = /^\s*export\s+(type\s+)?\{([\s\S]*?)\}\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
-const barrelIndexModuleInfoCache = /* @__PURE__ */ new Map();
-const isIndexModuleFilePath = (filePath) => INDEX_MODULE_FILE_PATTERN.test(path.basename(filePath));
-const createNonBarrelInfo = () => ({
-	isBarrel: false,
-	exportsByName: /* @__PURE__ */ new Map(),
-	starExportSources: []
-});
-const addImportedBinding = (importedBindings, binding) => {
-	importedBindings.set(binding.localName, {
-		...binding,
-		didExport: false
-	});
-};
-const collectNamedImportBindings = (namedSpecifiersText, source, declarationIsTypeOnly, importedBindings) => {
-	for (const specifier of parseExportSpecifiers(namedSpecifiersText, declarationIsTypeOnly)) addImportedBinding(importedBindings, {
-		localName: specifier.exportedName,
-		importedName: specifier.localName,
-		source,
-		isTypeOnly: specifier.isTypeOnly
-	});
-};
-const collectImportBindings = (importClause, source, declarationIsTypeOnly, importedBindings) => {
-	const trimmedImportClause = importClause.trim();
-	const namespaceMatch = trimmedImportClause.match(/(?:^|,\s*)\*\s+as\s+([\w$]+)/);
-	if (namespaceMatch?.[1]) addImportedBinding(importedBindings, {
-		localName: namespaceMatch[1],
-		importedName: "*",
-		source,
-		isTypeOnly: declarationIsTypeOnly
-	});
-	const namedImportMatch = trimmedImportClause.match(/\{([\s\S]*?)\}/);
-	if (namedImportMatch?.[1]) collectNamedImportBindings(namedImportMatch[1], source, declarationIsTypeOnly, importedBindings);
-	const defaultImportName = trimmedImportClause.split(",")[0]?.trim();
-	if (defaultImportName && !defaultImportName.startsWith("{") && !defaultImportName.startsWith("*")) addImportedBinding(importedBindings, {
-		localName: defaultImportName,
-		importedName: "default",
-		source,
-		isTypeOnly: declarationIsTypeOnly
-	});
-};
-const replaceKnownDeclarations = (sourceText, importedBindings, exportsByName, starExportSources) => {
-	let withoutKnownDeclarations = sourceText.replace(BINDING_IMPORT_DECLARATION_PATTERN, (_match, typeKeyword, importClause, source) => {
-		collectImportBindings(importClause, source, Boolean(typeKeyword), importedBindings);
-		return "";
-	});
-	withoutKnownDeclarations = withoutKnownDeclarations.replace(BARREL_REEXPORT_DECLARATION_PATTERN, (_match, typeKeyword, namespaceExportName, specifiersText, source) => {
-		const isTypeOnly = Boolean(typeKeyword);
-		if (namespaceExportName) {
-			exportsByName.set(namespaceExportName, {
-				exportedName: namespaceExportName,
-				importedName: "*",
-				source,
-				isTypeOnly
-			});
-			return "";
-		}
-		if (specifiersText) {
-			for (const specifier of parseExportSpecifiers(specifiersText, isTypeOnly)) exportsByName.set(specifier.exportedName, {
-				exportedName: specifier.exportedName,
-				importedName: specifier.localName,
-				source,
-				isTypeOnly: specifier.isTypeOnly
-			});
-			return "";
-		}
-		starExportSources.push(source);
-		return "";
-	});
-	withoutKnownDeclarations = withoutKnownDeclarations.replace(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN, (_match, typeKeyword, specifiersText) => {
-		for (const specifier of parseExportSpecifiers(specifiersText, Boolean(typeKeyword))) {
-			const importedBinding = importedBindings.get(specifier.localName);
-			if (!importedBinding) return _match;
-			importedBinding.didExport = true;
-			exportsByName.set(specifier.exportedName, {
-				exportedName: specifier.exportedName,
-				importedName: importedBinding.importedName,
-				source: importedBinding.source,
-				isTypeOnly: specifier.isTypeOnly || importedBinding.isTypeOnly
-			});
-		}
-		return "";
-	});
-	return withoutKnownDeclarations;
-};
-const hasUnexportedRuntimeImport = (importedBindings) => {
-	for (const binding of importedBindings.values()) if (!binding.isTypeOnly && !binding.didExport) return true;
-	return false;
-};
-const classifyBarrelModule = (sourceText) => {
-	const strippedSource = stripJsComments(sourceText).trim();
-	if (!strippedSource) return createNonBarrelInfo();
-	const importedBindings = /* @__PURE__ */ new Map();
-	const exportsByName = /* @__PURE__ */ new Map();
-	const starExportSources = [];
-	if (replaceKnownDeclarations(strippedSource, importedBindings, exportsByName, starExportSources).trim() || hasUnexportedRuntimeImport(importedBindings)) return createNonBarrelInfo();
-	return {
-		isBarrel: exportsByName.size > 0 || starExportSources.length > 0,
-		exportsByName,
-		starExportSources
-	};
-};
-const getBarrelIndexModuleInfo = (filePath) => {
-	if (!isIndexModuleFilePath(filePath)) return createNonBarrelInfo();
-	recordContentProbe(filePath);
-	let fileStat;
-	try {
-		fileStat = fs.statSync(filePath);
-	} catch {
-		fileStat = null;
-	}
-	const cachedResult = barrelIndexModuleInfoCache.get(filePath);
-	if (cachedResult !== void 0 && fileStat !== null && cachedResult.mtimeMs === fileStat.mtimeMs && cachedResult.size === fileStat.size) return cachedResult.moduleInfo;
-	if (fileStat === null) return createNonBarrelInfo();
-	let moduleInfo = createNonBarrelInfo();
-	try {
-		moduleInfo = classifyBarrelModule(fs.readFileSync(filePath, "utf8"));
-	} catch {
-		moduleInfo = createNonBarrelInfo();
-	}
-	barrelIndexModuleInfoCache.set(filePath, {
-		mtimeMs: fileStat.mtimeMs,
-		size: fileStat.size,
-		moduleInfo
-	});
-	return moduleInfo;
-};
-const isBarrelIndexModule = (filePath) => getBarrelIndexModuleInfo(filePath).isBarrel;
-//#endregion
 //#region src/react-native-dependency-names.ts
 const EXPO_MANAGED_DEPENDENCY_NAMES = new Set([
 	"expo",
@@ -25075,35 +24822,6 @@ const classifyReactNativeFileTarget = (context) => {
 };
 const isReactNativeFileActive = (context) => classifyReactNativeFileTarget(context) !== "web";
 //#endregion
-//#region src/plugin/utils/resolve-barrel-export-file-path.ts
-const getUniqueFilePath = (filePaths) => {
-	const uniqueFilePaths = new Set(filePaths);
-	if (uniqueFilePaths.size !== 1) return null;
-	const [filePath] = uniqueFilePaths;
-	return filePath ?? null;
-};
-const resolveStarExportFilePath = (barrelFilePath, exportedName, source, visitedFilePaths) => {
-	const resolvedTargetPath = resolveRelativeImportPath(barrelFilePath, source);
-	if (!resolvedTargetPath) return null;
-	const nestedTargetPath = resolveBarrelExportFilePath(resolvedTargetPath, exportedName, new Set(visitedFilePaths));
-	if (nestedTargetPath) return nestedTargetPath;
-	return doesModuleExportName(resolvedTargetPath, exportedName) ? resolvedTargetPath : null;
-};
-const resolveBarrelExportFilePath = (barrelFilePath, exportedName, visitedFilePaths = /* @__PURE__ */ new Set()) => {
-	if (visitedFilePaths.has(barrelFilePath)) return null;
-	visitedFilePaths.add(barrelFilePath);
-	const moduleInfo = getBarrelIndexModuleInfo(barrelFilePath);
-	if (!moduleInfo.isBarrel) return null;
-	const target = moduleInfo.exportsByName.get(exportedName);
-	if (target) {
-		const resolvedTargetPath = resolveRelativeImportPath(barrelFilePath, target.source);
-		if (!resolvedTargetPath) return null;
-		return resolveBarrelExportFilePath(resolvedTargetPath, target.importedName, visitedFilePaths) ?? resolvedTargetPath;
-	}
-	if (exportedName === "default") return null;
-	return getUniqueFilePath(moduleInfo.starExportSources.map((source) => resolveStarExportFilePath(barrelFilePath, exportedName, source, visitedFilePaths)).filter((filePath) => Boolean(filePath)));
-};
-//#endregion
 //#region src/plugin/rules/bundle-size/no-barrel-import.ts
 const TYPE_DECLARATION_FILE_PATTERN = /\.d\.[cm]?ts$/;
 const SERVER_ONLY_FILE_PATTERN = /\.server\.[cm]?[jt]sx?$/;
@@ -26419,7 +26137,7 @@ const noDerivedState = defineRule({
 		if (!isUseEffect(node)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node)) {
 			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
 			const stateName = getStateName$1(fact.stateDeclarator);
 			context.report({
@@ -26441,7 +26159,7 @@ const noDerivedStateEffect = defineRule({
 		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		if (!collectEffectStateWriteFacts(analysis, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
+		if (!collectEffectStateWriteFacts(analysis, node).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
 		context.report({
 			node,
 			message: "You pay an extra render for state you can derive from other values."
@@ -30603,131 +30321,6 @@ const noImgLazyWithHighFetchpriority = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/rules/state-and-effects/no-impure-state-updater.ts
-const TIMER_FUNCTION_NAMES = new Set([
-	"cancelAnimationFrame",
-	"clearInterval",
-	"clearTimeout",
-	"queueMicrotask",
-	"requestAnimationFrame",
-	"setInterval",
-	"setTimeout"
-]);
-const STORAGE_MUTATION_METHOD_NAMES = new Set([
-	"clear",
-	"removeItem",
-	"setItem"
-]);
-const STORAGE_RECEIVER_NAMES = new Set(["localStorage", "sessionStorage"]);
-const EXTERNAL_READ_METHOD_NAMES = new Set(["getBoundingClientRect", "getClientRects"]);
-const NOTIFICATION_RECEIVER_NAMES = new Set([
-	"message",
-	"notification",
-	"toast"
-]);
-const NOTIFICATION_METHOD_NAMES = new Set([
-	"error",
-	"info",
-	"loading",
-	"open",
-	"show",
-	"success",
-	"warning"
-]);
-const getMemberCall = (node) => {
-	if (!isNodeOfType(node, "CallExpression")) return null;
-	if (!isNodeOfType(node.callee, "MemberExpression") || node.callee.computed) return null;
-	if (!isNodeOfType(node.callee.property, "Identifier")) return null;
-	return {
-		methodName: node.callee.property.name,
-		receiver: stripParenExpression(node.callee.object)
-	};
-};
-const isNotificationReceiver = (receiver, scopes) => {
-	if (!isNodeOfType(receiver, "Identifier")) return false;
-	if (!NOTIFICATION_RECEIVER_NAMES.has(receiver.name)) return false;
-	const symbol = scopes.symbolFor(receiver);
-	if (symbol?.kind === "import") return true;
-	if (!isNodeOfType(symbol?.initializer, "CallExpression")) return false;
-	const callee = symbol.initializer.callee;
-	return isNodeOfType(callee, "Identifier") && /^use(?:Message|Notification|Toast)$/.test(callee.name);
-};
-const getKnownImpureCall = (callExpression, scopes) => {
-	if (isNodeOfType(callExpression.callee, "Identifier") && TIMER_FUNCTION_NAMES.has(callExpression.callee.name) && scopes.isGlobalReference(callExpression.callee)) return `${callExpression.callee.name}()`;
-	const memberCall = getMemberCall(callExpression);
-	if (!memberCall) return null;
-	const { methodName, receiver } = memberCall;
-	if (STORAGE_MUTATION_METHOD_NAMES.has(methodName) && isNodeOfType(receiver, "Identifier") && STORAGE_RECEIVER_NAMES.has(receiver.name) && scopes.isGlobalReference(receiver)) return `${receiver.name}.${methodName}()`;
-	if (EXTERNAL_READ_METHOD_NAMES.has(methodName)) return `.${methodName}()`;
-	if (NOTIFICATION_METHOD_NAMES.has(methodName) && isNodeOfType(receiver, "Identifier") && isNotificationReceiver(receiver, scopes)) return `${receiver.name}.${methodName}()`;
-	return null;
-};
-const getExternalAssignmentDescription = (assignmentTarget, updater, scopes) => {
-	let rootIdentifier = null;
-	if (isNodeOfType(assignmentTarget, "Identifier")) rootIdentifier = assignmentTarget;
-	else if (isNodeOfType(assignmentTarget, "MemberExpression") && isNodeOfType(assignmentTarget.object, "Identifier")) rootIdentifier = assignmentTarget.object;
-	if (!rootIdentifier) return null;
-	const updaterScope = scopes.ownScopeFor(updater);
-	if (!updaterScope) return null;
-	const symbol = scopes.symbolFor(rootIdentifier);
-	if (!symbol) return `the external value "${rootIdentifier.name}"`;
-	if (symbol.kind === "parameter" && symbol.scope === updaterScope) return `the updater argument "${rootIdentifier.name}"`;
-	return isDescendantScope(symbol.scope, updaterScope) ? null : `the captured value "${rootIdentifier.name}"`;
-};
-const findImpureUpdaterOperation = (updater, scopes) => {
-	const analysis = getProgramAnalysis(updater);
-	let operation = null;
-	walkAst(updater, (child) => {
-		if (operation) return false;
-		if (child !== updater && isFunctionLike$1(child) && !executesDuringRender(child, scopes)) return false;
-		if (isNodeOfType(child, "CallExpression")) {
-			if (isNodeOfType(child.callee, "Identifier") && analysis) {
-				const calleeReference = getRef(analysis, child.callee);
-				if (calleeReference && isStateSetterCall(analysis, calleeReference)) {
-					operation = `the nested state update "${child.callee.name}()"`;
-					return false;
-				}
-			}
-			const impureCall = getKnownImpureCall(child, scopes);
-			if (impureCall) {
-				operation = impureCall;
-				return false;
-			}
-		}
-		if (isNodeOfType(child, "AssignmentExpression")) {
-			operation = getExternalAssignmentDescription(child.left, updater, scopes);
-			if (operation) return false;
-		}
-		if (isNodeOfType(child, "UpdateExpression")) {
-			operation = getExternalAssignmentDescription(child.argument, updater, scopes);
-			if (operation) return false;
-		}
-	});
-	return operation;
-};
-const noImpureStateUpdater = defineRule({
-	id: "no-impure-state-updater",
-	title: "State updater has side effects",
-	severity: "error",
-	recommendation: "Keep state updater callbacks pure and return only the next state. Move notifications, storage, timers, ref writes, and other external work into the event or effect that queues the update.",
-	create: (context) => ({ CallExpression(node) {
-		const updater = node.arguments?.[0];
-		if (!updater || !isFunctionLike$1(updater)) return;
-		const analysis = getProgramAnalysis(node);
-		if (!analysis || !isNodeOfType(node.callee, "Identifier")) return;
-		const calleeReference = getRef(analysis, node.callee);
-		if (!calleeReference || !isStateSetterCall(analysis, calleeReference)) return;
-		const stateDeclarator = getUseStateDecl(analysis, calleeReference);
-		if (!isNodeOfType(stateDeclarator, "VariableDeclarator") || !isNodeOfType(stateDeclarator.init, "CallExpression") || !isReactApiCall(stateDeclarator.init, "useState", context.scopes, { allowGlobalReactNamespace: true })) return;
-		const operation = findImpureUpdaterOperation(updater, context.scopes);
-		if (!operation) return;
-		context.report({
-			node: updater,
-			message: `This state updater performs ${operation}. React may run updater functions more than once, so side effects here can repeat or observe inconsistent external state.`
-		});
-	} })
-});
-//#endregion
 //#region src/plugin/rules/correctness/no-indeterminate-attribute.ts
 const MESSAGE$21 = "The `indeterminate` HTML attribute does not set a checkbox's visual state. Assign the `HTMLInputElement.indeterminate` DOM property instead.";
 const REACT_USE_REF_OPTIONS = {
@@ -30894,7 +30487,7 @@ const noInitializeState = defineRule({
 		if (!dependencies || !isNodeOfType(dependencies, "ArrayExpression") || (dependencies.elements ?? []).length !== 0) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node)) {
 			if (!fact.isRenderKnownCopy || fact.matchesStateInitializer || fact.resetsSourceState) continue;
 			const stateName = getStateName(fact.stateDeclarator);
 			context.report({
@@ -33896,166 +33489,6 @@ const isDirectParentCallbackRef = (analysis, ref) => {
 		return getDownstreamRefs(analysis, initializer).some((initializerRef) => getUpstreamRefs(analysis, initializerRef).some((upstreamRef) => isProp(analysis, upstreamRef)));
 	}));
 };
-const getDeclarationKind = (declarator) => {
-	const declaration = declarator.parent;
-	return declaration && isNodeOfType(declaration, "VariableDeclaration") ? declaration.kind : null;
-};
-const hasMutableBindingWrite = (reference) => Boolean(reference.resolved?.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init));
-const getDestructuredPropertyName = (bindingIdentifier) => {
-	const property = bindingIdentifier.parent;
-	if (!property || !isNodeOfType(property, "Property")) return null;
-	if (property.computed) return isNodeOfType(property.key, "Literal") && typeof property.key.value === "string" ? String(property.key.value) : null;
-	return isNodeOfType(property.key, "Identifier") ? property.key.name : null;
-};
-const getParentCallbackPropName = (analysis, expression, visitedVariables = /* @__PURE__ */ new Set()) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		const callbackReference = getRef(analysis, unwrappedExpression);
-		const callbackVariable = callbackReference?.resolved;
-		if (!callbackReference || !callbackVariable || visitedVariables.has(callbackVariable)) return null;
-		if (isProp(analysis, callbackReference)) {
-			if (isWholePropsObjectReference(analysis, callbackReference)) return null;
-			const bindingIdentifier = callbackVariable.defs.find((definition) => definition.type === "Parameter")?.name;
-			return (bindingIdentifier && getDestructuredPropertyName(bindingIdentifier)) ?? unwrappedExpression.name;
-		}
-		if (hasMutableBindingWrite(callbackReference)) return null;
-		const definitions = callbackVariable.defs.map((definition) => definition.node).filter((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
-		if (definitions.length !== 1) return null;
-		const declarator = definitions[0];
-		if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || getDeclarationKind(declarator) !== "const" || !declarator.init) return null;
-		visitedVariables.add(callbackVariable);
-		if (isNodeOfType(declarator.id, "ObjectPattern")) {
-			const bindingIdentifier = callbackVariable.defs[0]?.name;
-			const propertyName = bindingIdentifier ? getDestructuredPropertyName(bindingIdentifier) : null;
-			const propsReference = getDownstreamRefs(analysis, declarator.init).find((candidateReference) => isWholePropsObjectReference(analysis, candidateReference));
-			return propertyName && propsReference ? propertyName : null;
-		}
-		if (!isNodeOfType(declarator.id, "Identifier")) return null;
-		return getParentCallbackPropName(analysis, declarator.init, visitedVariables);
-	}
-	if (!isNodeOfType(unwrappedExpression, "MemberExpression")) return null;
-	const callbackName = getStaticMemberPropertyName(unwrappedExpression);
-	if (!callbackName) return null;
-	const receiver = stripParenExpression(unwrappedExpression.object);
-	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const receiverReference = getRef(analysis, receiver);
-	if (!receiverReference || !isWholePropsObjectReference(analysis, receiverReference)) return null;
-	return callbackName;
-};
-const isNullishRefInitializer = (initializer) => {
-	if (!initializer) return true;
-	const unwrappedInitializer = stripParenExpression(initializer);
-	if (isNodeOfType(unwrappedInitializer, "Literal")) return unwrappedInitializer.value === null;
-	if (!isNodeOfType(unwrappedInitializer, "Identifier")) return false;
-	return unwrappedInitializer.name === "undefined";
-};
-const getDirectComponentBodyStatement = (node, componentBody) => {
-	let current = node;
-	while (current?.parent && current.parent !== componentBody) current = current.parent;
-	return current?.parent === componentBody ? current : null;
-};
-const getVariableForDeclarator = (analysis, declarator) => {
-	for (const scope of analysis.scopeManager.scopes) {
-		const variable = scope.variables.find((candidateVariable) => candidateVariable.defs.some((definition) => definition.node === declarator));
-		if (variable) return variable;
-	}
-	return null;
-};
-const getRefMember = (identifier) => {
-	const receiver = findTransparentExpressionRoot(identifier);
-	const member = receiver.parent;
-	if (!member || !isNodeOfType(member, "MemberExpression") || member.object !== receiver) return null;
-	return member;
-};
-const getRefMemberAssignment = (identifier) => {
-	const member = getRefMember(identifier);
-	if (!member) return null;
-	const memberRoot = findTransparentExpressionRoot(member);
-	const assignment = memberRoot.parent;
-	if (!assignment || !isNodeOfType(assignment, "AssignmentExpression") || assignment.left !== memberRoot) return null;
-	return assignment;
-};
-const getRefAliasDeclarator = (identifier) => {
-	const initializer = findTransparentExpressionRoot(identifier);
-	const declarator = initializer.parent;
-	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || declarator.init !== initializer || !isNodeOfType(declarator.id, "Identifier") || getDeclarationKind(declarator) !== "const") return null;
-	return declarator;
-};
-const getRefBindingProvenance = (analysis, receiver, isReactUseRefCall) => {
-	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const receiverReference = getRef(analysis, receiver);
-	if (!receiverReference?.resolved || hasMutableBindingWrite(receiverReference)) return null;
-	const variables = /* @__PURE__ */ new Set();
-	let currentVariable = receiverReference.resolved;
-	let refCall = null;
-	while (currentVariable && !variables.has(currentVariable)) {
-		variables.add(currentVariable);
-		const definitions = currentVariable.defs.map((definition) => definition.node).filter((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
-		if (definitions.length !== 1) return null;
-		const declarator = definitions[0];
-		if (!declarator || !isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.id, "Identifier") || !declarator.init) return null;
-		if (isNodeOfType(declarator.init, "CallExpression") && isReactUseRefCall(declarator.init)) {
-			refCall = declarator.init;
-			break;
-		}
-		if (getDeclarationKind(declarator) !== "const" || !isNodeOfType(stripParenExpression(declarator.init), "Identifier")) return null;
-		const upstreamReference = getRef(analysis, stripParenExpression(declarator.init));
-		if (!upstreamReference?.resolved || hasMutableBindingWrite(upstreamReference)) return null;
-		currentVariable = upstreamReference.resolved;
-	}
-	if (!refCall) return null;
-	const pendingVariables = [...variables];
-	while (pendingVariables.length > 0) {
-		const variable = pendingVariables.pop();
-		if (!variable) continue;
-		for (const candidateReference of variable.references) {
-			const aliasDeclarator = getRefAliasDeclarator(candidateReference.identifier);
-			if (!aliasDeclarator) continue;
-			const aliasVariable = getVariableForDeclarator(analysis, aliasDeclarator);
-			if (!aliasVariable || variables.has(aliasVariable)) continue;
-			if (aliasVariable.references.some((aliasReference) => aliasReference.isWrite() && !aliasReference.init)) return null;
-			variables.add(aliasVariable);
-			pendingVariables.push(aliasVariable);
-		}
-	}
-	return {
-		refCall,
-		variables
-	};
-};
-const getCallbackRefProvenance = (analysis, effectCall, callExpression, isReactUseRefCall) => {
-	const callee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(callee, "MemberExpression") || getStaticMemberPropertyName(callee) !== "current") return null;
-	const bindingProvenance = getRefBindingProvenance(analysis, stripParenExpression(callee.object), isReactUseRefCall);
-	if (!bindingProvenance) return null;
-	const { refCall, variables } = bindingProvenance;
-	const componentFunction = findEnclosingFunction(effectCall);
-	if (!componentFunction || !isFunctionLike$1(componentFunction) || !isComponentFunction$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return null;
-	if (!getDirectComponentBodyStatement(effectCall, componentFunction.body)) return null;
-	const callbackPropNames = /* @__PURE__ */ new Set();
-	const initializer = refCall.arguments?.[0];
-	const initializerCallbackName = initializer ? getParentCallbackPropName(analysis, initializer) : null;
-	if (initializerCallbackName) callbackPropNames.add(initializerCallbackName);
-	else if (!isNullishRefInitializer(initializer)) return null;
-	for (const variable of variables) for (const candidateReference of variable.references) {
-		if (candidateReference.init) continue;
-		if (candidateReference.isWrite()) return null;
-		const identifier = candidateReference.identifier;
-		if (getRefAliasDeclarator(identifier)) continue;
-		const member = getRefMember(identifier);
-		if (!member || getStaticMemberPropertyName(member) !== "current") return null;
-		const memberParent = findTransparentExpressionRoot(member).parent;
-		if (memberParent && (isNodeOfType(memberParent, "UpdateExpression") || isNodeOfType(memberParent, "UnaryExpression") && memberParent.operator === "delete")) return null;
-		const assignment = getRefMemberAssignment(identifier);
-		if (!assignment) continue;
-		const assignmentStatement = findTransparentExpressionRoot(assignment).parent;
-		if (assignment.operator !== "=" || !assignmentStatement || !isNodeOfType(assignmentStatement, "ExpressionStatement") || assignmentStatement.parent !== componentFunction.body) return null;
-		const assignedCallbackName = getParentCallbackPropName(analysis, assignment.right);
-		if (!assignedCallbackName) return null;
-		callbackPropNames.add(assignedCallbackName);
-	}
-	return callbackPropNames.size > 0 ? { callbackPropNames } : null;
-};
 const isWrapperHookCallbackRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	const node = def.node;
 	if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return false;
@@ -34111,79 +33544,71 @@ const noPassDataToParent = defineRule({
 	severity: "warn",
 	tags: ["test-noise"],
 	recommendation: "Fetch the data in the parent and pass it down as a prop (or return it from the hook), instead of handing it back up through a prop callback in a useEffect. See https://react.dev/learn/you-might-not-need-an-effect#passing-data-to-the-parent",
-	create: (context) => {
-		const isReactUseRefCall = (node) => isReactApiCall(node, "useRef", context.scopes, {
-			allowGlobalReactNamespace: true,
-			allowUnboundBareCalls: true
-		});
-		return { CallExpression(node) {
-			if (!isUseEffect(node)) return;
-			const analysis = getProgramAnalysis(node);
-			if (!analysis) return;
-			if (hasCleanup(analysis, node)) return;
-			const effectFnRefs = getEffectFnRefs(analysis, node);
-			if (!effectFnRefs) return;
-			const effectFn = getEffectFn(analysis, node);
-			if (!effectFn) return;
-			for (const ref of effectFnRefs) {
-				const callExpr = getCallExpr(ref);
-				if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
-				const callbackRefProvenance = getCallbackRefProvenance(analysis, node, callExpr, isReactUseRefCall);
-				if (isRefCall(analysis, ref) && !callbackRefProvenance) continue;
-				if (!isSynchronous(ref.identifier, effectFn)) continue;
-				const calleeNode = unwrapChainExpression$1(callExpr.callee);
-				const identifier = ref.identifier;
-				if (callbackRefProvenance) {
-					if ([...callbackRefProvenance.callbackPropNames].some((callbackPropName) => COMMAND_PROP_NAME_PATTERN.test(callbackPropName))) continue;
-				} else if (calleeNode === identifier) {
-					if (!isDirectParentCallbackRef(analysis, ref)) continue;
-					if (isNodeOfType(identifier, "Identifier") && COMMAND_PROP_NAME_PATTERN.test(identifier.name)) continue;
-				} else if (isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === identifier) {
-					if (!isWholePropsObjectReference(analysis, ref)) continue;
-					if (isCustomHookParameter(ref)) continue;
-				} else continue;
-				const methodName = getCallMethodName(calleeNode);
-				const isPropCallbackNamedLikeStringRead = Boolean(methodName && STRING_READ_METHOD_NAMES.has(methodName) && isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === ref.identifier && isWholePropsObjectReference(analysis, ref));
-				if (methodName && DATA_SINK_METHOD_NAMES.has(methodName) && !isPropCallbackNamedLikeStringRead) continue;
-				if (methodName && COMMAND_PROP_NAME_PATTERN.test(methodName)) continue;
-				if (!callbackRefProvenance && isNamespacedApiCallee(calleeNode)) continue;
-				const isSetterNamedCallee = callbackRefProvenance ? [...callbackRefProvenance.callbackPropNames].every((callbackPropName) => SETTER_NAMED_PROP_PATTERN.test(callbackPropName)) : Boolean((isNodeOfType(identifier, "Identifier") ? identifier.name : methodName) && SETTER_NAMED_PROP_PATTERN.test((isNodeOfType(identifier, "Identifier") ? identifier.name : methodName) ?? ""));
-				const isLeafRef = (argRef) => getUpstreamRefs(analysis, argRef).length === 1;
-				const argsUpstreamRefs = (callExpr.arguments ?? []).flatMap((argument) => {
-					if (isFunctionLike$1(argument)) {
-						if (!isSetterNamedCallee) return [];
-						return getFunctionalUpdaterDataRefs(analysis, argument);
-					}
-					if (isHandlerBagArgument(analysis, argument)) return [];
-					if (isParentWiredHookResultArgument(analysis, argument)) return [];
-					if (isNodeOfType(argument, "Identifier")) {
-						const argumentRef = getRef(analysis, argument);
-						if (argumentRef && resolveToFunction(argumentRef)) return [];
-					}
-					return getDownstreamRefs(analysis, argument);
-				}).flatMap((argumentRef) => getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
-				if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
-				if (!argsUpstreamRefs.some((argRef) => {
-					if (isUseStateIdentifier(argRef.identifier)) return false;
-					if (isProp(analysis, argRef)) return false;
-					if (isUseRefIdentifier(argRef.identifier)) return false;
-					if (isRefCurrent(argRef)) return false;
-					if (isConstant(argRef)) return false;
-					if (isParentWiredHookResultRef(analysis, argRef)) return false;
-					if (isParentWiredHookCalleeRef(analysis, argRef)) return false;
-					if (resolvesToFunctionBinding(argRef)) return false;
-					const argIdentifier = argRef.identifier;
-					if (isImportBindingRef(argRef) && !isCalleePosition(argIdentifier)) return false;
-					if (isNodeOfType(argIdentifier, "Identifier") && argIdentifier.name === "undefined") return false;
-					return true;
-				})) continue;
-				context.report({
-					node: callExpr,
-					message: "Handing data back to a parent from a useEffect costs your users an extra render."
-				});
-			}
-		} };
-	}
+	create: (context) => ({ CallExpression(node) {
+		if (!isUseEffect(node)) return;
+		const analysis = getProgramAnalysis(node);
+		if (!analysis) return;
+		if (hasCleanup(analysis, node)) return;
+		const effectFnRefs = getEffectFnRefs(analysis, node);
+		if (!effectFnRefs) return;
+		const effectFn = getEffectFn(analysis, node);
+		if (!effectFn) return;
+		for (const ref of effectFnRefs) {
+			const callExpr = getCallExpr(ref);
+			if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
+			if (isRefCall(analysis, ref)) continue;
+			if (!isSynchronous(ref.identifier, effectFn)) continue;
+			const calleeNode = unwrapChainExpression$1(callExpr.callee);
+			const identifier = ref.identifier;
+			if (calleeNode === identifier) {
+				if (!isDirectParentCallbackRef(analysis, ref)) continue;
+				if (isNodeOfType(identifier, "Identifier") && COMMAND_PROP_NAME_PATTERN.test(identifier.name)) continue;
+			} else if (isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === identifier) {
+				if (!isWholePropsObjectReference(analysis, ref)) continue;
+				if (isCustomHookParameter(ref)) continue;
+			} else continue;
+			const methodName = getCallMethodName(calleeNode);
+			const isPropCallbackNamedLikeStringRead = Boolean(methodName && STRING_READ_METHOD_NAMES.has(methodName) && isNodeOfType(calleeNode, "MemberExpression") && stripParenExpression(calleeNode.object) === ref.identifier && isWholePropsObjectReference(analysis, ref));
+			if (methodName && DATA_SINK_METHOD_NAMES.has(methodName) && !isPropCallbackNamedLikeStringRead) continue;
+			if (methodName && COMMAND_PROP_NAME_PATTERN.test(methodName)) continue;
+			if (isNamespacedApiCallee(calleeNode)) continue;
+			const calleeName = isNodeOfType(identifier, "Identifier") ? identifier.name : methodName;
+			const isSetterNamedCallee = Boolean(calleeName && SETTER_NAMED_PROP_PATTERN.test(calleeName));
+			const isLeafRef = (argRef) => getUpstreamRefs(analysis, argRef).length === 1;
+			const argsUpstreamRefs = (callExpr.arguments ?? []).flatMap((argument) => {
+				if (isFunctionLike$1(argument)) {
+					if (!isSetterNamedCallee) return [];
+					return getFunctionalUpdaterDataRefs(analysis, argument);
+				}
+				if (isHandlerBagArgument(analysis, argument)) return [];
+				if (isParentWiredHookResultArgument(analysis, argument)) return [];
+				if (isNodeOfType(argument, "Identifier")) {
+					const argumentRef = getRef(analysis, argument);
+					if (argumentRef && resolveToFunction(argumentRef)) return [];
+				}
+				return getDownstreamRefs(analysis, argument);
+			}).flatMap((argumentRef) => getUpstreamRefs(analysis, argumentRef)).filter(isLeafRef);
+			if (calleeNode === identifier && isWrapperHookCallbackRef(analysis, ref)) argsUpstreamRefs.push(...getArgsUpstreamRefs(analysis, ref).filter(isLeafRef));
+			if (!argsUpstreamRefs.some((argRef) => {
+				if (isUseStateIdentifier(argRef.identifier)) return false;
+				if (isProp(analysis, argRef)) return false;
+				if (isUseRefIdentifier(argRef.identifier)) return false;
+				if (isRefCurrent(argRef)) return false;
+				if (isConstant(argRef)) return false;
+				if (isParentWiredHookResultRef(analysis, argRef)) return false;
+				if (isParentWiredHookCalleeRef(analysis, argRef)) return false;
+				if (resolvesToFunctionBinding(argRef)) return false;
+				const argIdentifier = argRef.identifier;
+				if (isImportBindingRef(argRef) && !isCalleePosition(argIdentifier)) return false;
+				if (isNodeOfType(argIdentifier, "Identifier") && argIdentifier.name === "undefined") return false;
+				return true;
+			})) continue;
+			context.report({
+				node: callExpr,
+				message: "Handing data back to a parent from a useEffect costs your users an extra render."
+			});
+		}
+	} })
 });
 //#endregion
 //#region src/plugin/utils/is-call-result-consumed-as-argument.ts
@@ -56393,18 +55818,6 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...noImgLazyWithHighFetchpriority.requires ?? []])]
 		}
 	},
-	{
-		key: "react-doctor/no-impure-state-updater",
-		id: "no-impure-state-updater",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...noImpureStateUpdater,
-			framework: "global",
-			category: "Bugs",
-			requires: [...new Set(["react", ...noImpureStateUpdater.requires ?? []])]
-		}
-	},
 	{
 		key: "react-doctor/no-indeterminate-attribute",
 		id: "no-indeterminate-attribute",
@@ -59504,11 +58917,6 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"no-indeterminate-attribute",
 	"no-locale-format-in-render",
 	"no-match-media-in-state-initializer",
-	"no-adjust-state-on-prop-change",
-	"no-derived-state",
-	"no-derived-state-effect",
-	"no-event-handler",
-	"no-initialize-state",
 	"no-mutating-reducer-state",
 	"no-unguarded-browser-global-in-render-or-hook-init",
 	"prefer-dynamic-import",
@@ -59562,9 +58970,6 @@ const collectNextjsSearchParamsDependencies = ({ absoluteFilePath, staticImports
 	if (hasAncestorSuspenseLayout(absoluteFilePath)) return;
 	for (const entry of flattenImportEntries(staticImports)) resolveCrossFileFunctionExport(absoluteFilePath, entry.source, entry.exportedName);
 };
-const collectEffectValueHelperDependencies = ({ absoluteFilePath, staticImports }) => {
-	for (const entry of flattenImportEntries(staticImports)) resolveCrossFileFunctionExport(absoluteFilePath, entry.source, entry.exportedName);
-};
 const collectMutatingReducerDependencies = ({ absoluteFilePath, sourceText, staticImports, program }) => {
 	const namedUseReducerLocals = /* @__PURE__ */ new Set();
 	const reactObjectLocals = /* @__PURE__ */ new Set();
@@ -59651,11 +59056,6 @@ const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 	["no-indeterminate-attribute", collectNearestManifestDependencies],
 	["no-locale-format-in-render", collectNearestManifestDependencies],
 	["no-match-media-in-state-initializer", collectNearestManifestDependencies],
-	["no-adjust-state-on-prop-change", collectEffectValueHelperDependencies],
-	["no-derived-state", collectEffectValueHelperDependencies],
-	["no-derived-state-effect", collectEffectValueHelperDependencies],
-	["no-event-handler", collectEffectValueHelperDependencies],
-	["no-initialize-state", collectEffectValueHelperDependencies],
 	["no-mutating-reducer-state", collectMutatingReducerDependencies],
 	["no-unguarded-browser-global-in-render-or-hook-init", collectNearestManifestDependencies],
 	["prefer-dynamic-import", collectNearestManifestDependencies],