oxlint-plugin-react-doctor 0.7.4-dev.118f806 → 0.7.4-dev.4a5d9bb

package/dist/index.js

@@ -9191,6 +9191,24 @@ const fileContainsReleaseForUsage = (usage, context) => {
 	});
 	return didFindRelease;
 };
+const isUseSyncExternalStoreSubscribeFunction = (functionNode, context) => {
+	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
+	if (!bindingIdentifier) return false;
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	const isSubscribeBinding = (candidateBinding) => {
+		const symbol = context.scopes.symbolFor(candidateBinding);
+		if (!symbol || visitedSymbolIds.has(symbol.id) || symbol.references.length === 0) return false;
+		visitedSymbolIds.add(symbol.id);
+		return symbol.references.every((reference) => {
+			const referenceRoot = findTransparentExpressionRoot(reference.identifier);
+			const referenceParent = referenceRoot.parent;
+			if (isNodeOfType(referenceParent, "CallExpression") && referenceParent.arguments?.[0] === referenceRoot) return isReactApiCall(referenceParent, "useSyncExternalStore", context.scopes);
+			const aliasDeclaration = referenceParent?.parent;
+			return Boolean(isNodeOfType(referenceParent, "VariableDeclarator") && referenceParent.init === referenceRoot && isNodeOfType(referenceParent.id, "Identifier") && isNodeOfType(aliasDeclaration, "VariableDeclaration") && aliasDeclaration.kind === "const" && isSubscribeBinding(referenceParent.id));
+		});
+	};
+	return isSubscribeBinding(bindingIdentifier);
+};
 const doesResourceResultEscape = (resourceNode, allowConciseReturnEscape) => {
 	let currentNode = resourceNode;
 	let parentNode = currentNode.parent;
@@ -9212,6 +9230,8 @@ const findRetainedFunctionLeak = (retainedFunction, context) => {
 	if (!body) return null;
 	let leak = null;
 	const allowConciseReturnEscape = !isInlineRetainedHandlerFunction(retainedFunction, context);
+	const isExternalStoreSubscribeFunction = isUseSyncExternalStoreSubscribeFunction(retainedFunction, context);
+	const hasReleaseForUsage = (usage) => isExternalStoreSubscribeFunction ? effectHasCleanupForUsage(retainedFunction, usage, context) : fileContainsReleaseForUsage(usage, context);
 	walkAst(body, (child) => {
 		if (leak !== null) return false;
 		if (isFunctionLike$1(child)) return false;
@@ -9226,7 +9246,7 @@ const findRetainedFunctionLeak = (retainedFunction, context) => {
 				eventKey: null,
 				handlerKey: null
 			};
-			if (!fileContainsReleaseForUsage(socketUsage, context)) {
+			if (!hasReleaseForUsage(socketUsage)) {
 				leak = socketUsage;
 				return false;
 			}
@@ -9243,7 +9263,7 @@ const findRetainedFunctionLeak = (retainedFunction, context) => {
 				eventKey: null,
 				handlerKey: null
 			};
-			if (!fileContainsReleaseForUsage(timerUsage, context)) {
+			if (!hasReleaseForUsage(timerUsage)) {
 				leak = timerUsage;
 				return false;
 			}
@@ -9257,7 +9277,7 @@ const findRetainedFunctionLeak = (retainedFunction, context) => {
 				handleKey: findAssignedResourceKey(child, context),
 				...registrationDetails
 			};
-			if (!hasSelfReleasingListenerOptions(child, context) && !fileContainsReleaseForUsage(subscriptionUsage, context)) leak = subscriptionUsage;
+			if (!hasSelfReleasingListenerOptions(child, context) && !hasReleaseForUsage(subscriptionUsage)) leak = subscriptionUsage;
 			return false;
 		}
 	});
@@ -20988,6 +21008,7 @@ 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);
@@ -21002,6 +21023,7 @@ 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;
@@ -21050,25 +21072,37 @@ const resolveImportedExportName = (importSpecifier) => {
 	if (isNodeOfType(importSpecifier, "ImportDefaultSpecifier")) return "default";
 	return null;
 };
-const findReExportSourcesForName = (programRoot, exportedName) => {
+const findReExportTargetsForName = (programRoot, exportedName) => {
 	if (!isNodeOfType(programRoot, "Program")) return [];
-	const exportAllSources = [];
+	const exportAllTargets = [];
 	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) return [sourceValue];
+				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(statement, "ExportAllDeclaration") && statement.source) {
+			if (statement.exportKind === "type" || statement.exported) continue;
 			const sourceValue = statement.source.value;
-			if (typeof sourceValue === "string") exportAllSources.push(sourceValue);
+			if (typeof sourceValue === "string") exportAllTargets.push({
+				importedName: exportedName,
+				source: sourceValue
+			});
 		}
 	}
-	return exportAllSources;
+	return exportAllTargets;
 };
 //#endregion
 //#region src/plugin/utils/attach-parent-references.ts
@@ -21157,139 +21191,6 @@ 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",
@@ -21406,35 +21307,6 @@ 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;
@@ -21613,25 +21485,29 @@ const resolveTsconfigAliasPath = (fromFilename, source) => {
 };
 //#endregion
 //#region src/plugin/utils/resolve-module-path.ts
-const resolveModulePath = (fromFilename, source) => resolveRelativeImportPath(fromFilename, source) ?? resolveTsconfigAliasPath(fromFilename, source);
+const resolveModulePath = (fromFilename, source) => {
+	if (path.isAbsolute(source)) return null;
+	return source.startsWith(".") ? 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 actualFilePath = resolveBarrelExportFilePath(filePath, exportedName) ?? filePath;
-	const programRoot = parseSourceFile(actualFilePath);
+	const programRoot = parseSourceFile(filePath);
 	if (!programRoot) return null;
 	const exported = findExportedFunctionBody(programRoot, exportedName);
 	if (exported) return exported;
-	for (const reExportSource of findReExportSourcesForName(programRoot, exportedName)) {
-		const nextFilePath = resolveModulePath(actualFilePath, reExportSource);
+	const resolvedCandidates = /* @__PURE__ */ new Set();
+	for (const target of findReExportTargetsForName(programRoot, exportedName)) {
+		const nextFilePath = resolveModulePath(filePath, target.source);
 		if (!nextFilePath) continue;
-		const resolved = resolveFunctionExportInFile(nextFilePath, exportedName, visitedFilePaths);
-		if (resolved) return resolved;
+		const resolved = resolveFunctionExportInFile(nextFilePath, target.importedName, new Set(visitedFilePaths));
+		if (resolved) resolvedCandidates.add(resolved);
 	}
-	return null;
+	if (resolvedCandidates.size !== 1) return null;
+	return resolvedCandidates.values().next().value ?? null;
 };
 const resolveCrossFileFunctionExport = (fromFilename, source, exportedName) => {
 	const resolvedFilePath = resolveModulePath(fromFilename, source);
@@ -22814,6 +22690,46 @@ 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",
@@ -22860,6 +22776,42 @@ 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);
@@ -22990,7 +22942,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) => {
+const collectBoundedEffectExecutionFrames = (analysis, effectNode, currentFilename) => {
 	const effectFunction = getEffectFn(analysis, effectNode);
 	if (!effectFunction || !isFunctionLike$1(effectFunction) || effectFunction.async === true) return [];
 	const invokedFunctionEvidence = collectEffectInvokedFunctions(effectFunction);
@@ -22999,7 +22951,8 @@ const collectBoundedEffectExecutionFrames = (analysis, effectNode) => {
 		invocation: null,
 		isDeferred: false,
 		introducedBindings: /* @__PURE__ */ new Set(),
-		substitutions: /* @__PURE__ */ new Map()
+		substitutions: /* @__PURE__ */ new Map(),
+		currentFilename
 	};
 	const frames = [rootFrame];
 	walkAst(effectFunction, (child) => {
@@ -23020,7 +22973,8 @@ const collectBoundedEffectExecutionFrames = (analysis, effectNode) => {
 				invocation: child,
 				isDeferred,
 				introducedBindings,
-				substitutions: buildSubstitutions(analysis, callable, argumentsForCallable, rootFrame)
+				substitutions: buildSubstitutions(analysis, callable, argumentsForCallable, rootFrame),
+				currentFilename
 			});
 		};
 		if (isFunctionLike$1(callee)) {
@@ -23073,6 +23027,174 @@ 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"));
@@ -23158,38 +23280,55 @@ 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 (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;
+		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)));
+			}
 			return evidence;
 		}
 		if (remainingCallFrames <= 0) {
 			evidence.hasUnknownSource = true;
 			return evidence;
 		}
-		const callable = resolveWrappedCallable(analysis, callee);
-		if (!callable || callable.async === true || functionInvokesItself(analysis, callable)) {
-			evidence.hasUnknownSource = true;
+		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)));
 			return evidence;
 		}
-		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) {
+		const helperFunction = resolveValueHelperFunction(analysis, callee, frame.currentFilename);
+		const helperSummary = helperFunction ? summarizeHelperReturn(helperFunction) : null;
+		if (!helperSummary) {
 			evidence.hasUnknownSource = true;
 			return evidence;
 		}
-		for (const returnedExpression of returnedExpressions) mergeEvidence(evidence, collectValueEvidence(analysis, returnedExpression, valueFrame, remainingCallFrames - 1, new Set(visitedBindings)));
+		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)));
+		}
 		return evidence;
 	}
 	if (isFunctionLike$1(node) || isNodeOfType(node, "AwaitExpression")) {
@@ -23269,8 +23408,8 @@ const areInMutuallyExclusiveBranches = (leftNode, rightNode) => {
 	}
 	return false;
 };
-const collectEffectStateWriteFacts = (analysis, effectNode) => {
-	const frames = collectBoundedEffectExecutionFrames(analysis, effectNode);
+const collectEffectStateWriteFacts = (analysis, effectNode, currentFilename) => {
+	const frames = collectBoundedEffectExecutionFrames(analysis, effectNode, currentFilename);
 	if (frames.length === 0) return [];
 	const effectHasCleanup = hasCleanup(analysis, effectNode);
 	const cleanupManagedStateDeclarators = /* @__PURE__ */ new Set();
@@ -23290,7 +23429,8 @@ const collectEffectStateWriteFacts = (analysis, effectNode) => {
 				invocation: callExpression,
 				isDeferred: frame.isDeferred,
 				introducedBindings: collectIntroducedBindings(analysis, writtenValue),
-				substitutions: /* @__PURE__ */ new Map()
+				substitutions: /* @__PURE__ */ new Map(),
+				currentFilename
 			};
 			valueEvidence = emptyEvidence();
 			const returnedExpressions = getReturnedExpressions(writtenValue);
@@ -23339,7 +23479,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)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
 			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
 			context.report({
 				node: fact.callExpression,
@@ -24600,6 +24740,139 @@ 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",
@@ -24802,6 +25075,35 @@ 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?$/;
@@ -26117,7 +26419,7 @@ const noDerivedState = defineRule({
 		if (!isUseEffect(node)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, node)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
 			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
 			const stateName = getStateName$1(fact.stateDeclarator);
 			context.report({
@@ -26139,7 +26441,7 @@ const noDerivedStateEffect = defineRule({
 		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		if (!collectEffectStateWriteFacts(analysis, node).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
+		if (!collectEffectStateWriteFacts(analysis, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
 		context.report({
 			node,
 			message: "You pay an extra render for state you can derive from other values."
@@ -30467,7 +30769,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)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
 			if (!fact.isRenderKnownCopy || fact.matchesStateInitializer || fact.resetsSourceState) continue;
 			const stateName = getStateName(fact.stateDeclarator);
 			context.report({
@@ -58897,6 +59199,11 @@ 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",
@@ -58950,6 +59257,9 @@ 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();
@@ -59036,6 +59346,11 @@ 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],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.4-dev.118f806",
+  "version": "0.7.4-dev.4a5d9bb",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",