oxlint-plugin-react-doctor 0.7.7-dev.287dff7 → 0.7.7-dev.30b7eeb

package/dist/index.js

@@ -10558,7 +10558,7 @@ const getAssignedName = (node) => {
 	}
 	return null;
 };
-const isModuleExportsAssignment$1 = (node) => {
+const isModuleExportsAssignment = (node) => {
 	const parent = node.parent;
 	if (!parent || !isNodeOfType(parent, "AssignmentExpression")) return false;
 	const left = parent.left;
@@ -10717,7 +10717,7 @@ const displayName = defineRule({
 				}
 				const assignedName = getAssignedName(node);
 				if (assignedName && isReactComponentName(assignedName) && ignoreNamed) return;
-				if (isModuleExportsAssignment$1(node) && !node.id) {
+				if (isModuleExportsAssignment(node) && !node.id) {
 					reportAt(node);
 					return;
 				}
@@ -10739,7 +10739,7 @@ const displayName = defineRule({
 						reportAt(node);
 						return;
 					}
-					if (isModuleExportsAssignment$1(node)) {
+					if (isModuleExportsAssignment(node)) {
 						reportAt(node);
 						return;
 					}
@@ -14368,22 +14368,6 @@ const isReactHocCallbackArgument = (functionNode) => {
 	return calleeName !== null && REACT_HOC_NAMES.has(calleeName);
 };
 //#endregion
-//#region src/plugin/utils/is-outside-all-functions.ts
-const FUNCTION_SCOPE_KINDS = new Set([
-	"function",
-	"arrow-function",
-	"method"
-]);
-const isOutsideAllFunctions = (symbol) => {
-	let scope = symbol.scope;
-	while (scope) {
-		if (FUNCTION_SCOPE_KINDS.has(scope.kind)) return false;
-		if (scope.kind === "module") return true;
-		scope = scope.parent;
-	}
-	return true;
-};
-//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-low-level.ts
 /**
 * Lowest-level helpers consumed by both the main `exhaustive-deps`
@@ -14436,6 +14420,25 @@ const getHookName = (callee, scopes) => {
 	if (isNodeOfType(strippedCallee, "MemberExpression") && !strippedCallee.computed && isNodeOfType(strippedCallee.property, "Identifier")) return strippedCallee.property.name;
 	return null;
 };
+const FUNCTION_SCOPE_KINDS = new Set([
+	"function",
+	"arrow-function",
+	"method"
+]);
+/**
+* True for symbols declared at module scope (outside any function
+* scope). Module-scope bindings don't change between renders so they
+* don't need to live in dependency arrays.
+*/
+const isOutsideAllFunctions = (symbol) => {
+	let scope = symbol.scope;
+	while (scope) {
+		if (FUNCTION_SCOPE_KINDS.has(scope.kind)) return false;
+		if (scope.kind === "module") return true;
+		scope = scope.parent ?? null;
+	}
+	return true;
+};
 //#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-messages.ts
 const buildMissingDepMessage = (hookName, depName) => `\`${hookName}\` can run with a stale \`${depName}\` & show your users old data.`;
@@ -29493,7 +29496,7 @@ const isNumericForLoopCounter = (attributeNode, indexName) => {
 	if (forStatement.test && forLoopTestReadsDataLength(forStatement.test)) return false;
 	return true;
 };
-const EMPTY_NAME_SET$1 = /* @__PURE__ */ new Set();
+const EMPTY_NAME_SET = /* @__PURE__ */ new Set();
 const findIteratorItemNamesOfBinding = (binding) => {
 	const names = /* @__PURE__ */ new Set();
 	if (!binding.bindingFunction || !isFunctionLike$1(binding.bindingFunction)) return names;
@@ -29607,9 +29610,9 @@ const noArrayIndexAsKey = defineRule({
 					const jsxElement = openingElement.parent;
 					if (jsxElement && isNodeOfType(jsxElement, "JSXElement")) {
 						const isInlineTextRun = INLINE_TEXT_LEAF_TAGS.has(elementName.name);
-						const primitiveItemNames = keyTemplate ? findBareItemNamesReferencedByTemplate(keyTemplate, itemNames) : EMPTY_NAME_SET$1;
+						const primitiveItemNames = keyTemplate ? findBareItemNamesReferencedByTemplate(keyTemplate, itemNames) : EMPTY_NAME_SET;
 						if (!containsStatefulDescendant(jsxElement, {
-							memberRootNames: isInlineTextRun ? itemNames : EMPTY_NAME_SET$1,
+							memberRootNames: isInlineTextRun ? itemNames : EMPTY_NAME_SET,
 							bareIdentifierNames: primitiveItemNames.size > 0 ? new Set([...derivedNames, ...primitiveItemNames]) : derivedNames
 						})) return;
 					}
@@ -30110,9 +30113,6 @@ const findNearestPackageDirectory = (filename) => {
 const readNearestPackageManifest = (filename) => {
 	const packageDirectory = findNearestPackageDirectory(filename);
 	if (!packageDirectory) return null;
-	return readPackageManifest(packageDirectory);
-};
-const readPackageManifest = (packageDirectory) => {
 	const packageJsonPath = path.join(packageDirectory, "package.json");
 	recordContentProbe(packageJsonPath);
 	const cached = cachedManifestByPackageDirectory.get(packageDirectory);
@@ -30491,16 +30491,7 @@ const isRenderPreservingCallArgumentFunction = (node, scopes) => {
 	return parent.arguments.some((argumentNode) => argumentNode === node) && isProvenArrayMapCall(parent, scopes);
 };
 const isNestedRenderEvidenceBoundary = (node, scopes) => NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES.has(node.type) && !isRenderPreservingCallArgumentFunction(node, scopes);
-const isRenderOutputExpression = (node, scopes) => node.type === "JSXElement" || node.type === "JSXFragment" || isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS) || isReactDomCreatePortalCall(node, scopes);
-const isReactDomCreatePortalCall = (node, scopes) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = stripParenExpression(node.callee);
-	if (isNodeOfType(callee, "Identifier")) return scopes.symbolFor(callee)?.kind === "import" && getImportedNameFromModule(callee, callee.name, "react-dom") === "createPortal";
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== "createPortal") return false;
-	const symbol = scopes.symbolFor(callee.object);
-	if (!symbol || symbol.kind !== "import") return false;
-	return isDefaultImportFromModule(callee.object, callee.object.name, "react-dom") || isNamespaceImportFromModule(callee.object, callee.object.name, "react-dom");
-};
+const isRenderOutputExpression = (node, scopes) => node.type === "JSXElement" || node.type === "JSXFragment" || isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS);
 const containsRenderOutput$1 = (rootNode, scopes) => {
 	let hasRenderOutput = false;
 	walkAst(rootNode, (node) => {
@@ -41892,107 +41883,18 @@ const getNodeText$1 = (node) => {
 		return value;
 	});
 };
-const normalizeAsBoolean = (identity) => ({
-	...identity,
-	booleanNormalization: identity.booleanNormalization === "identity" ? "normalized" : identity.booleanNormalization
-});
-const negateBoolean = (identity) => ({
-	...identity,
-	booleanNormalization: identity.booleanNormalization === "negated" ? "normalized" : "negated"
-});
-const getLivePropExpressionIdentity = (analysis, context, node, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(node);
-	if (isNodeOfType(expression, "Identifier")) {
-		const reference = getRef(analysis, expression);
-		const symbol = context.scopes.symbolFor(expression);
-		if (!reference || !symbol) return null;
-		if (isProp(analysis, reference)) return {
-			propSymbolId: symbol.id,
-			memberPath: [],
-			booleanNormalization: "identity"
-		};
-		if (visitedSymbolIds.has(symbol.id) || symbol.kind !== "const") return null;
-		visitedSymbolIds.add(symbol.id);
-		const initializer = getDirectConstInitializer(symbol);
-		if (initializer) return getLivePropExpressionIdentity(analysis, context, initializer, visitedSymbolIds);
-		return getUpstreamRefs(analysis, reference).some((upstreamReference) => isProp(analysis, upstreamReference)) ? {
-			propSymbolId: symbol.id,
-			memberPath: [],
-			booleanNormalization: "identity"
-		} : null;
-	}
-	if (isNodeOfType(expression, "MemberExpression")) {
-		const propertyName = getStaticMemberPropertyName(expression);
-		if (!propertyName) return null;
-		const objectIdentity = getLivePropExpressionIdentity(analysis, context, expression.object, visitedSymbolIds);
-		if (!objectIdentity) return null;
-		return {
-			...objectIdentity,
-			memberPath: [...objectIdentity.memberPath, propertyName]
-		};
-	}
-	if (isNodeOfType(expression, "CallExpression") && isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "Boolean" && context.scopes.isGlobalReference(expression.callee) && expression.arguments?.length === 1) {
-		const argument = expression.arguments[0];
-		const argumentIdentity = getLivePropExpressionIdentity(analysis, context, argument, visitedSymbolIds);
-		return argumentIdentity ? normalizeAsBoolean(argumentIdentity) : null;
-	}
-	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "!") {
-		const argumentIdentity = getLivePropExpressionIdentity(analysis, context, expression.argument, visitedSymbolIds);
-		return argumentIdentity ? negateBoolean(argumentIdentity) : null;
-	}
-	return null;
-};
-const isMountSnapshotInitializer = (context, node) => {
-	if (!isReactApiCall(node, "useMemo", context.scopes, { resolveNamedAliases: true }) || !isNodeOfType(node, "CallExpression")) return false;
-	const dependencies = node.arguments?.[1];
-	return isNodeOfType(dependencies, "ArrayExpression") && dependencies.elements.length === 0;
-};
-const isMountSnapshotBinding = (context, identifier, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const symbol = context.scopes.symbolFor(identifier);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	visitedSymbolIds.add(symbol.id);
-	const initializer = getDirectConstInitializer(symbol);
-	if (!initializer) return false;
-	if (isMountSnapshotInitializer(context, initializer)) return true;
-	const expression = stripParenExpression(initializer);
-	return isNodeOfType(expression, "Identifier") && isMountSnapshotBinding(context, expression, visitedSymbolIds);
-};
-const isConstantBooleanExpression = (context, node, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(node);
-	if (isNodeOfType(expression, "Literal")) return true;
-	if (isNodeOfType(expression, "Identifier")) {
-		const symbol = context.scopes.symbolFor(expression);
-		if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-		visitedSymbolIds.add(symbol.id);
-		const initializer = getDirectConstInitializer(symbol);
-		return Boolean(initializer && isConstantBooleanExpression(context, initializer, visitedSymbolIds));
-	}
-	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "!") return isConstantBooleanExpression(context, expression.argument, visitedSymbolIds);
-	if (isNodeOfType(expression, "CallExpression") && isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "Boolean" && context.scopes.isGlobalReference(expression.callee) && expression.arguments?.length === 1) return isConstantBooleanExpression(context, expression.arguments[0], visitedSymbolIds);
-	return false;
+const isLiteralConstantIdentifier = (analysis, identifier) => {
+	const definitions = getRef(analysis, identifier)?.resolved?.defs;
+	if (!definitions || definitions.length !== 1) return false;
+	const definition = definitions[0];
+	if (definition.type !== "Variable") return false;
+	const declarator = definition.node;
+	if (!isNodeOfType(declarator, "VariableDeclarator")) return false;
+	const declaration = declarator.parent;
+	if (!isNodeOfType(declaration, "VariableDeclaration") || declaration.kind !== "const") return false;
+	return isNodeOfType(declarator.init, "Literal");
 };
-const isProvenLiveBinding = (analysis, context, identifier) => {
-	const reference = getRef(analysis, identifier);
-	const symbol = context.scopes.symbolFor(identifier);
-	if (!reference || !symbol || symbol.kind !== "const" || isOutsideAllFunctions(symbol)) return false;
-	const initializer = symbol.initializer;
-	if (!initializer || isMountSnapshotBinding(context, identifier)) return false;
-	if (getDownstreamRefs(analysis, initializer).some((initializerReference) => isRefCurrent(initializerReference))) return false;
-	return !isConstantBooleanExpression(context, initializer);
-};
-const areSameProvenLiveBinding = (analysis, context, left, right) => {
-	const leftExpression = stripParenExpression(left);
-	const rightExpression = stripParenExpression(right);
-	if (!isNodeOfType(leftExpression, "Identifier") || !isNodeOfType(rightExpression, "Identifier")) return false;
-	const leftSymbol = context.scopes.symbolFor(leftExpression);
-	const rightSymbol = context.scopes.symbolFor(rightExpression);
-	return Boolean(leftSymbol && leftSymbol === rightSymbol && isProvenLiveBinding(analysis, context, leftExpression));
-};
-const haveSameLivePropExpressionIdentity = (left, right) => {
-	if (left.propSymbolId !== right.propSymbolId || left.booleanNormalization !== right.booleanNormalization || left.memberPath.length !== right.memberPath.length) return false;
-	return left.memberPath.every((propertyName, index) => propertyName === right.memberPath[index]);
-};
-const isSetStateToInitialValue = (analysis, context, setterRef) => {
+const isSetStateToInitialValue = (analysis, setterRef) => {
 	const callExpr = getCallExpr(setterRef);
 	if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) return false;
 	const setStateToValue = callExpr.arguments?.[0];
@@ -42003,12 +41905,7 @@ const isSetStateToInitialValue = (analysis, context, setterRef) => {
 	if (isUndefinedNode(setStateToValue) && isUndefinedNode(stateInitialValue)) return true;
 	if (setStateToValue == null && stateInitialValue == null) return true;
 	if (setStateToValue && !stateInitialValue || !setStateToValue && stateInitialValue) return false;
-	if (stateInitialValue && setStateToValue) {
-		const initialLivePropIdentity = getLivePropExpressionIdentity(analysis, context, stateInitialValue);
-		const nextLivePropIdentity = getLivePropExpressionIdentity(analysis, context, setStateToValue);
-		if (initialLivePropIdentity && nextLivePropIdentity && haveSameLivePropExpressionIdentity(initialLivePropIdentity, nextLivePropIdentity)) return false;
-		if (areSameProvenLiveBinding(analysis, context, stateInitialValue, setStateToValue)) return false;
-	}
+	if (stateInitialValue && isNodeOfType(stateInitialValue, "Identifier") && stateInitialValue.name !== "undefined" && !isLiteralConstantIdentifier(analysis, stateInitialValue)) return false;
 	return getNodeText$1(setStateToValue) === getNodeText$1(stateInitialValue);
 };
 const countUseStates = (analysis, componentNode) => {
@@ -42017,10 +41914,10 @@ const countUseStates = (analysis, componentNode) => {
 	for (const ref of getDownstreamRefs(analysis, componentNode)) if (isState(analysis, ref)) stateVariables.add(ref.resolved);
 	return stateVariables.size;
 };
-const findPropUsedToResetAllState = (analysis, context, effectFnRefs, depsRefs, useEffectNode, effectFn) => {
+const findPropUsedToResetAllState = (analysis, effectFnRefs, depsRefs, useEffectNode, effectFn) => {
 	const stateSetterRefs = effectFnRefs.filter((ref) => isSyncStateSetterCall(analysis, ref, effectFn));
 	if (stateSetterRefs.length === 0) return null;
-	if (!stateSetterRefs.every((ref) => isSetStateToInitialValue(analysis, context, ref))) return null;
+	if (!stateSetterRefs.every((ref) => isSetStateToInitialValue(analysis, ref))) return null;
 	if (stateSetterRefs.every((setterRef) => effectFnRefs.some((otherRef) => otherRef !== setterRef && otherRef.resolved === setterRef.resolved && Boolean(getCallExpr(otherRef)) && !isSyncStateSetterCall(analysis, otherRef, effectFn)))) return null;
 	const containing = findContainingNode(analysis, useEffectNode);
 	if (new Set(stateSetterRefs.map((setterRef) => setterRef.resolved)).size !== countUseStates(analysis, containing)) return null;
@@ -42044,7 +41941,7 @@ const noResetAllStateOnPropChange = defineRule({
 		if (containing && isCustomHook(containing)) return;
 		const effectFn = getEffectFn(analysis, node);
 		if (!effectFn) return;
-		if (!findPropUsedToResetAllState(analysis, context, effectFnRefs, depsRefs, node, effectFn)) return;
+		if (!findPropUsedToResetAllState(analysis, effectFnRefs, depsRefs, node, effectFn)) return;
 		context.report({
 			node,
 			message: `Your users briefly see stale state when a prop changes because this useEffect clears all state.`
@@ -45847,726 +45744,19 @@ const nosqlInjectionRisk = defineRule({
 	})
 });
 //#endregion
-//#region src/plugin/utils/export-all-adds-runtime-values.ts
-const getExportedName = (node) => {
-	if (!node) return null;
-	if (isNodeOfType(node, "Identifier")) return node.name;
-	if (isNodeOfType(node, "Literal") && typeof node.value === "string") return node.value;
-	return null;
-};
-const programHasRuntimeNamedExports = (filePath, program, visitedFilePaths) => {
-	if (!isNodeOfType(program, "Program")) return true;
-	for (const statement of program.body) {
-		if (isNodeOfType(statement, "ExportDefaultDeclaration")) continue;
-		if (isNodeOfType(statement, "ExportAllDeclaration")) {
-			if (statement.exportKind === "type") continue;
-			if (statement.exported) return true;
-			if (typeof statement.source.value !== "string") return true;
-			if (exportAllAddsRuntimeValues(filePath, statement.source.value, visitedFilePaths)) return true;
-			continue;
-		}
-		if (!isNodeOfType(statement, "ExportNamedDeclaration")) continue;
-		if (statement.exportKind === "type") continue;
-		if (statement.declaration) {
-			if (statement.declaration.type !== "TSInterfaceDeclaration" && statement.declaration.type !== "TSTypeAliasDeclaration" && statement.declaration.type !== "TSDeclareFunction") return true;
-			continue;
-		}
-		if (isEverySpecifierInlineType(statement.specifiers, "ExportSpecifier", "exportKind")) continue;
-		for (const specifier of statement.specifiers) {
-			if (!isNodeOfType(specifier, "ExportSpecifier") || specifier.exportKind === "type") continue;
-			if (getExportedName(specifier.exported) !== "default") return true;
-		}
-	}
-	return false;
-};
-const exportAllAddsRuntimeValues = (importerFilePath, source, visitedFilePaths = /* @__PURE__ */ new Set()) => {
-	const resolvedFilePath = resolveRelativeImportPath(importerFilePath, source);
-	if (!resolvedFilePath) return true;
-	if (path.extname(resolvedFilePath) === ".cjs" || resolvedFilePath.endsWith(".cts")) return true;
-	if (visitedFilePaths.has(resolvedFilePath)) return true;
-	visitedFilePaths.add(resolvedFilePath);
-	const program = parseSourceFile(resolvedFilePath);
-	if (!program) return true;
-	return programHasRuntimeNamedExports(resolvedFilePath, program, visitedFilePaths);
-};
-//#endregion
 //#region src/plugin/utils/is-framework-route-or-special-filename.ts
-const NEXT_APP_ROUTE_FILE_PATTERN = new RegExp(`^(page|layout|loading|error|not-found|template|default|global-error|route)\\.${NEXTJS_SOURCE_FILE_EXTENSION_GROUP}$`);
-const NEXT_PAGES_ROUTE_FILE_PATTERN = new RegExp(`^(_app|_document|_error|_meta)\\.${NEXTJS_SOURCE_FILE_EXTENSION_GROUP}$`);
-const EXPO_ROUTE_FILE_PATTERN = new RegExp(`^(_layout|\\+html|\\+not-found|\\+native-intent)\\.${NEXTJS_SOURCE_FILE_EXTENSION_GROUP}$`);
-const TANSTACK_ROUTE_FILE_PATTERN = new RegExp(`(?:^__root|\\.lazy)\\.${NEXTJS_SOURCE_FILE_EXTENSION_GROUP}$`);
-const REACT_ROUTER_FILE_PATTERN = new RegExp(`^(root|entry\\.client|entry\\.server)\\.${NEXTJS_SOURCE_FILE_EXTENSION_GROUP}$`);
-const isInNextDirectory = (context, directoryPath) => {
-	if (isInProjectDirectory(context, directoryPath)) return true;
-	const filename = normalizeFilename(context.filename ?? "");
-	if (path.isAbsolute(filename)) return false;
-	return filename.startsWith(`${directoryPath}/`) || filename.includes(`/${directoryPath}/`);
-};
-const isInExpoRouteDirectory = (context) => {
-	const filename = normalizeFilename(context.filename ?? "");
-	const configuredRootDirectory = getReactDoctorStringSetting(context.settings, "rootDirectory");
-	const packageDirectory = path.isAbsolute(filename) ? findNearestPackageDirectory(filename) : null;
-	const projectRelativeFilename = getProjectRelativeFilename(filename, configuredRootDirectory ?? packageDirectory ?? void 0);
-	const relativeFilename = projectRelativeFilename === filename && path.isAbsolute(filename) ? filename.split("/").slice(2).join("/") : projectRelativeFilename;
-	return relativeFilename.startsWith("app/") || relativeFilename.startsWith("src/app/");
-};
-const isFrameworkRouteOrSpecialFilename = (context, runtime) => {
-	const rawFilename = context.filename;
+const sourceFileExtensionGroup = NEXTJS_SOURCE_FILE_EXTENSION_GROUP;
+const FRAMEWORK_ROUTE_FILE_PATTERNS = [
+	new RegExp(`^(page|layout|loading|error|not-found|template|default|global-error|route|_app|_document|_error)\\.${sourceFileExtensionGroup}$`),
+	new RegExp(`^(_layout|\\+html|\\+not-found|\\+native-intent)\\.${sourceFileExtensionGroup}$`),
+	new RegExp(`(?:^__root|\\.lazy)\\.${sourceFileExtensionGroup}$`),
+	new RegExp(`^(root|entry\\.client|entry\\.server)\\.${sourceFileExtensionGroup}$`)
+];
+const isFrameworkRouteOrSpecialFilename = (rawFilename) => {
 	if (!rawFilename) return false;
+	if (isNextjsMetadataImageRouteFilename(rawFilename)) return true;
 	const basename = path.basename(rawFilename);
-	if (runtime === "next") return isInNextDirectory(context, "app") && (isNextjsMetadataImageRouteFilename(rawFilename) || NEXT_APP_ROUTE_FILE_PATTERN.test(basename)) || isInNextDirectory(context, "pages") && NEXT_PAGES_ROUTE_FILE_PATTERN.test(basename);
-	if (runtime === "expo") return isInExpoRouteDirectory(context) && EXPO_ROUTE_FILE_PATTERN.test(basename);
-	if (runtime === "tanstack") return TANSTACK_ROUTE_FILE_PATTERN.test(basename);
-	if (runtime === "react-router" || runtime === "remix") return REACT_ROUTER_FILE_PATTERN.test(basename);
-	return false;
-};
-//#endregion
-//#region src/plugin/utils/function-has-react-element-return-type.ts
-const isReactNamespaceBinding = (node) => {
-	if (!isNodeOfType(node, "Identifier")) return false;
-	const binding = getImportBindingForName(node, node.name);
-	return Boolean(binding && binding.source === "react" && (binding.isNamespace || binding.exportedName === "default"));
-};
-const hasLocalJsxNamespace = (node) => {
-	const program = findProgramRoot(node);
-	if (!program || !isNodeOfType(program, "Program")) return false;
-	return program.body.some((statement) => isNodeOfType(statement, "TSModuleDeclaration") && isNodeOfType(statement.id, "Identifier") && statement.id.name === "JSX");
-};
-const isReactElementTypeReference = (node) => {
-	if (!isNodeOfType(node, "TSTypeReference")) return false;
-	const typeName = node.typeName;
-	if (isNodeOfType(typeName, "Identifier")) return getImportedNameFromModule(typeName, typeName.name, "react") === "ReactElement";
-	if (!isNodeOfType(typeName, "TSQualifiedName")) return false;
-	if (!isNodeOfType(typeName.right, "Identifier")) return false;
-	if (typeName.right.name === "ReactElement" && isReactNamespaceBinding(typeName.left)) return true;
-	if (typeName.right.name !== "Element") return false;
-	if (isNodeOfType(typeName.left, "Identifier")) {
-		if (typeName.left.name !== "JSX") return false;
-		const binding = getImportBindingForName(typeName.left, typeName.left.name);
-		if (!binding) return !hasLocalJsxNamespace(typeName.left);
-		return binding.source === "react" && binding.exportedName === "JSX";
-	}
-	return isNodeOfType(typeName.left, "TSQualifiedName") && isNodeOfType(typeName.left.right, "Identifier") && typeName.left.right.name === "JSX" && isReactNamespaceBinding(typeName.left.left);
-};
-const containsReactElementType = (node) => {
-	if (isNodeOfType(node, "TSUnionType")) return node.types.some((member) => containsReactElementType(member));
-	return isReactElementTypeReference(node);
-};
-const functionHasReactElementReturnType = (functionNode) => {
-	const returnType = Reflect.get(functionNode, "returnType");
-	if (!isNodeOfType(returnType, "TSTypeAnnotation")) return false;
-	return containsReactElementType(returnType.typeAnnotation);
-};
-//#endregion
-//#region src/plugin/constants/fast-refresh.ts
-const FAST_REFRESH_CONFIG_FILENAMES = [
-	"vite.config.ts",
-	"vite.config.mts",
-	"vite.config.cts",
-	"vite.config.js",
-	"vite.config.mjs",
-	"vite.config.cjs",
-	"webpack.config.ts",
-	"webpack.config.js",
-	"webpack.config.mjs",
-	"webpack.config.cjs",
-	"rsbuild.config.ts",
-	"rsbuild.config.js",
-	"rspack.config.ts",
-	"rspack.config.js"
-];
-const MINIMUM_FAST_REFRESH_VERSIONS = {
-	dumi: {
-		major: 2,
-		minor: 0
-	},
-	expo: {
-		major: 36,
-		minor: 0
-	},
-	gatsby: {
-		major: 2,
-		minor: 31
-	},
-	next: {
-		major: 9,
-		minor: 4
-	},
-	parcel: {
-		major: 2,
-		minor: 0
-	},
-	reactForGatsbyTwo: {
-		major: 17,
-		minor: 0
-	},
-	reactNative: {
-		major: 0,
-		minor: 61
-	},
-	reactScripts: {
-		major: 4,
-		minor: 0
-	},
-	storybookReact: {
-		major: 6,
-		minor: 1
-	}
-};
-//#endregion
-//#region src/plugin/utils/get-fast-refresh-file-status.ts
-const INTEGRATION_IMPORTS = new Map([
-	["@vitejs/plugin-react", {
-		importedNames: null,
-		requiresViteDevelopmentServer: true,
-		runtime: "generic"
-	}],
-	["@vitejs/plugin-react-swc", {
-		importedNames: null,
-		requiresViteDevelopmentServer: true,
-		runtime: "generic"
-	}],
-	["@pmmmwh/react-refresh-webpack-plugin", {
-		importedNames: null,
-		runtime: "generic"
-	}],
-	["@react-router/dev/vite", {
-		importedNames: new Set(["reactRouter"]),
-		requiresViteDevelopmentServer: true,
-		runtime: "react-router"
-	}],
-	["@remix-run/dev", {
-		importedNames: new Set(["vitePlugin"]),
-		requiresViteDevelopmentServer: true,
-		runtime: "remix"
-	}],
-	["@rsbuild/plugin-react", {
-		importedNames: new Set(["pluginReact"]),
-		runtime: "generic"
-	}],
-	["@rspack/plugin-react-refresh", {
-		importedNames: null,
-		runtime: "generic"
-	}],
-	["@rozenite/vite-plugin", {
-		importedNames: new Set(["rozenitePlugin"]),
-		requiresViteDevelopmentServer: true,
-		runtime: "generic"
-	}],
-	["@tanstack/react-start/plugin/vite", {
-		importedNames: new Set(["tanstackStart"]),
-		requiresViteDevelopmentServer: true,
-		runtime: "tanstack"
-	}]
-]);
-const REGISTERED_INTEGRATION_RUNTIME_PRECEDENCE = [
-	"tanstack",
-	"remix",
-	"react-router",
-	"generic"
-];
-const cachedLocalStatusByManifest = /* @__PURE__ */ new WeakMap();
-const cachedWorkspaceIndexByManifest = /* @__PURE__ */ new WeakMap();
-const INACTIVE_STATUS = {
-	isActive: false,
-	runtime: "generic"
-};
-const WORKSPACE_IGNORED_DIRECTORY_NAMES = new Set([
-	".git",
-	".next",
-	"build",
-	"coverage",
-	"dist",
-	"node_modules",
-	"out"
-]);
-const parseVersion = (version) => {
-	if (typeof version !== "string") return null;
-	const match = version.match(/(?:^|[^\d])(\d+)(?:\.(\d+))?/);
-	if (!match) return null;
-	return {
-		major: Number(match[1]),
-		minor: Number(match[2] ?? 0)
-	};
-};
-const isVersionAtLeast = (version, minimum) => {
-	const parsed = parseVersion(version);
-	if (!parsed) return false;
-	return parsed.major > minimum.major || parsed.major === minimum.major && parsed.minor >= minimum.minor;
-};
-const getDependencyVersion = (manifest, dependencyName) => manifest.dependencies?.[dependencyName] ?? manifest.devDependencies?.[dependencyName] ?? manifest.peerDependencies?.[dependencyName] ?? manifest.optionalDependencies?.[dependencyName];
-const getRuntimeDependencyVersion = (manifest, dependencyName) => manifest.dependencies?.[dependencyName] ?? manifest.optionalDependencies?.[dependencyName];
-const getOwnedDependencyVersion = (manifest, dependencyName, developmentCommandPattern) => {
-	const runtimeVersion = getRuntimeDependencyVersion(manifest, dependencyName);
-	if (runtimeVersion !== void 0) return runtimeVersion;
-	return Object.values(manifest.scripts ?? {}).some((script) => typeof script === "string" && developmentCommandPattern.test(script)) ? manifest.devDependencies?.[dependencyName] : void 0;
-};
-const hasParcelBrowserEntry = (manifest) => {
-	if (typeof manifest.source === "string" && manifest.source.endsWith(".html")) return true;
-	return Object.values(manifest.scripts ?? {}).some((script) => typeof script === "string" && /(?:^|\s)parcel(?:\s+serve)?\s+[^\n]*\.html(?:\s|$)/.test(script));
-};
-const hasParcelDevelopmentCommand = (manifest) => Object.values(manifest.scripts ?? {}).some((script) => typeof script === "string" && /(?:^|[\s;&|'\\"])parcel(?=\s|$)(?!\s+(?:build|help|watch|--help|--version|-h|-V)(?:\s|$))/.test(script) && !/(?:^|\s)--no-hmr(?:\s|$)/.test(script));
-const hasOwnedDevelopmentCommand = (manifest, commandPattern) => Object.values(manifest.scripts ?? {}).some((script) => typeof script === "string" && commandPattern.test(script));
-const hasViteDevelopmentCommand = (manifest) => Object.values(manifest.scripts ?? {}).some((script) => {
-	if (typeof script !== "string") return false;
-	return [...script.matchAll(/(?:^|[\s;&|'\\"])vite(?:\s+(build|preview|test)\b)?/g)].some((match) => match[1] === void 0);
-});
-const hasViteBrowserEntry = (manifest, packageDirectory) => {
-	if (typeof manifest.source === "string" && manifest.source.endsWith(".html")) return true;
-	const browserEntryPath = path.join(packageDirectory, "index.html");
-	recordExistenceProbe(browserEntryPath);
-	return fs.existsSync(browserEntryPath);
-};
-const getBuiltInStatus = (manifest) => {
-	if (isVersionAtLeast(getOwnedDependencyVersion(manifest, "next", /(?:^|\s)next\s+dev(?:\s|$)/), MINIMUM_FAST_REFRESH_VERSIONS.next)) return {
-		isActive: true,
-		runtime: "next"
-	};
-	const gatsbyDependency = getOwnedDependencyVersion(manifest, "gatsby", /(?:^|\s)gatsby\s+develop(?:\s|$)/);
-	const gatsbyVersion = parseVersion(gatsbyDependency);
-	const hasGatsbyFastRefresh = gatsbyVersion !== null && (gatsbyVersion.major >= 3 || isVersionAtLeast(gatsbyDependency, MINIMUM_FAST_REFRESH_VERSIONS.gatsby) && isVersionAtLeast(getDependencyVersion(manifest, "react"), MINIMUM_FAST_REFRESH_VERSIONS.reactForGatsbyTwo));
-	if (isVersionAtLeast(getOwnedDependencyVersion(manifest, "react-scripts", /(?:^|\s)react-scripts\s+start(?:\s|$)/), MINIMUM_FAST_REFRESH_VERSIONS.reactScripts) || hasGatsbyFastRefresh || isVersionAtLeast(getDependencyVersion(manifest, "parcel"), MINIMUM_FAST_REFRESH_VERSIONS.parcel) && declaresDependency(manifest, "react") && hasParcelDevelopmentCommand(manifest) && hasParcelBrowserEntry(manifest)) return {
-		isActive: true,
-		runtime: "generic"
-	};
-	if (isVersionAtLeast(getOwnedDependencyVersion(manifest, "expo", /(?:^|\s)expo\s+start(?:\s|$)/), MINIMUM_FAST_REFRESH_VERSIONS.expo) || isVersionAtLeast(getOwnedDependencyVersion(manifest, "react-native", /(?:^|\s)react-native\s+start(?:\s|$)/), MINIMUM_FAST_REFRESH_VERSIONS.reactNative)) return {
-		isActive: true,
-		runtime: "expo"
-	};
-	if (isVersionAtLeast(getOwnedDependencyVersion(manifest, "dumi", /(?:^|\s)dumi\s+dev(?:\s|$)/), MINIMUM_FAST_REFRESH_VERSIONS.dumi)) return {
-		isActive: true,
-		runtime: "generic"
-	};
-	return null;
-};
-const getIntegrationLocalNames = (program, scopes) => {
-	const localBindings = /* @__PURE__ */ new Map();
-	const registerLocalName = (source, importedName, localIdentifier) => {
-		const integration = INTEGRATION_IMPORTS.get(source);
-		if (!integration) return;
-		if (integration.importedNames === null ? importedName === null || importedName === "default" : importedName !== null && integration.importedNames.has(importedName)) {
-			const symbol = scopes.symbolFor(localIdentifier);
-			if (symbol) localBindings.set(symbol, integration);
-		}
-	};
-	walkAst(program, (node) => {
-		if (isNodeOfType(node, "ImportDeclaration")) {
-			const source = node.source.value;
-			if (typeof source !== "string") return;
-			for (const specifier of node.specifiers) {
-				if (isNodeOfType(specifier, "ImportDefaultSpecifier") || isNodeOfType(specifier, "ImportNamespaceSpecifier")) {
-					registerLocalName(source, null, specifier.local);
-					continue;
-				}
-				registerLocalName(source, getImportedName(specifier) ?? null, specifier.local);
-			}
-			return;
-		}
-		if (!isNodeOfType(node, "VariableDeclarator") || !node.init) return;
-		const initializer = node.init;
-		if (!isNodeOfType(initializer, "CallExpression") || !isNodeOfType(initializer.callee, "Identifier") || initializer.callee.name !== "require") return;
-		const sourceArgument = initializer.arguments[0];
-		if (!sourceArgument || !isNodeOfType(sourceArgument, "Literal")) return;
-		const source = sourceArgument.value;
-		if (typeof source !== "string") return;
-		if (isNodeOfType(node.id, "Identifier")) {
-			registerLocalName(source, null, node.id);
-			return;
-		}
-		if (!isNodeOfType(node.id, "ObjectPattern")) return;
-		for (const property of node.id.properties) {
-			if (!isNodeOfType(property, "Property") || !isNodeOfType(property.value, "Identifier")) continue;
-			registerLocalName(source, isNodeOfType(property.key, "Identifier") ? property.key.name : isNodeOfType(property.key, "Literal") && typeof property.key.value === "string" ? property.key.value : null, property.value);
-		}
-	});
-	return localBindings;
-};
-const isModuleExportsAssignment = (node) => isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && isNodeOfType(node.left.object, "Identifier") && node.left.object.name === "module" && isNodeOfType(node.left.property, "Identifier") && node.left.property.name === "exports";
-const getExportedBindings = (program, scopes) => {
-	const exportedBindings = /* @__PURE__ */ new Set();
-	walkAst(program, (node) => {
-		let exportRoot = null;
-		if (isNodeOfType(node, "ExportDefaultDeclaration")) exportRoot = node.declaration;
-		else if (isNodeOfType(node, "AssignmentExpression") && isModuleExportsAssignment(node)) exportRoot = node.right;
-		if (!exportRoot) return;
-		if (isFunctionLike$1(exportRoot) || isNodeOfType(exportRoot, "ObjectExpression")) return;
-		walkAst(exportRoot, (exportNode) => {
-			if (isFunctionLike$1(exportNode) || isNodeOfType(exportNode, "ObjectExpression")) return false;
-			if (!isNodeOfType(exportNode, "Identifier")) return;
-			const symbol = scopes.symbolFor(exportNode);
-			if (symbol) exportedBindings.add(symbol);
-		});
-	});
-	return exportedBindings;
-};
-const isExportedConfigProperty = (property, exportedBindings, scopes) => {
-	let ancestor = property.parent;
-	let didFindContainingObject = false;
-	let didCrossNestedProperty = false;
-	let didCrossFunctionBoundary = false;
-	let containingFunction = null;
-	let containingReturn = null;
-	while (ancestor) {
-		if (isNodeOfType(ancestor, "ObjectExpression") && !didFindContainingObject) didFindContainingObject = true;
-		else if (didFindContainingObject && isNodeOfType(ancestor, "Property")) didCrossNestedProperty = true;
-		if (!containingReturn && isNodeOfType(ancestor, "ReturnStatement")) containingReturn = ancestor;
-		if (isFunctionLike$1(ancestor)) if (containingFunction) didCrossFunctionBoundary = true;
-		else containingFunction = ancestor;
-		if (isNodeOfType(ancestor, "ExportDefaultDeclaration") || isModuleExportsAssignment(ancestor)) return !didCrossNestedProperty && !didCrossFunctionBoundary && (!containingFunction || Boolean(containingReturn) || !isNodeOfType(containingFunction.body, "BlockStatement"));
-		if (isNodeOfType(ancestor, "VariableDeclarator") && isNodeOfType(ancestor.id, "Identifier")) {
-			const binding = scopes.symbolFor(ancestor.id);
-			if (binding && exportedBindings.has(binding)) return !didCrossNestedProperty && !containingFunction;
-		}
-		ancestor = ancestor.parent;
-	}
-	return false;
-};
-const getExplicitConfigPaths = (packageDirectory, manifest) => {
-	const configPaths = new Set(FAST_REFRESH_CONFIG_FILENAMES.map((configFilename) => path.join(packageDirectory, configFilename)));
-	for (const script of Object.values(manifest.scripts ?? {})) {
-		if (typeof script !== "string") continue;
-		for (const match of script.matchAll(/(?:^|\s)--config(?:=|\s+)(?:"([^"]+)"|'([^']+)'|([^\s;&|]+))/g)) {
-			const relativeConfigPath = match[1] ?? match[2] ?? match[3];
-			if (!relativeConfigPath) continue;
-			const configPath = path.resolve(packageDirectory, relativeConfigPath);
-			const relativePath = path.relative(packageDirectory, configPath);
-			if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) continue;
-			configPaths.add(configPath);
-		}
-	}
-	return [...configPaths];
-};
-const getRegisteredIntegration = (packageDirectory, manifest) => {
-	for (const configPath of getExplicitConfigPaths(packageDirectory, manifest)) {
-		const program = parseSourceFile(configPath);
-		if (!program) continue;
-		const scopes = analyzeScopes(program);
-		const integrationLocalBindings = getIntegrationLocalNames(program, scopes);
-		if (integrationLocalBindings.size === 0) continue;
-		const exportedBindings = getExportedBindings(program, scopes);
-		const registeredIntegrations = [];
-		walkAst(program, (node) => {
-			if (!isNodeOfType(node, "Property")) return;
-			if (!(isNodeOfType(node.key, "Identifier") && node.key.name === "plugins" || isNodeOfType(node.key, "Literal") && node.key.value === "plugins")) return;
-			if (!isExportedConfigProperty(node, exportedBindings, scopes)) return;
-			const inspectedBindings = /* @__PURE__ */ new Set();
-			const inspectValue = (value) => {
-				walkAst(value, (valueNode) => {
-					if (isNodeOfType(valueNode, "Identifier")) {
-						const symbol = scopes.symbolFor(valueNode);
-						const initializer = symbol ? getDirectUnreassignedInitializer(symbol) : null;
-						if (symbol && initializer && !inspectedBindings.has(symbol.id)) {
-							inspectedBindings.add(symbol.id);
-							inspectValue(initializer);
-						}
-					}
-					if (!isNodeOfType(valueNode, "CallExpression") && !isNodeOfType(valueNode, "NewExpression")) return;
-					if (!isNodeOfType(valueNode.callee, "Identifier")) return;
-					const symbol = scopes.symbolFor(valueNode.callee);
-					const integration = symbol ? integrationLocalBindings.get(symbol) : null;
-					if (integration) registeredIntegrations.push(integration);
-				});
-			};
-			inspectValue(node.value);
-			return false;
-		});
-		const hasViteDevelopmentRuntime = hasViteDevelopmentCommand(manifest) || hasViteBrowserEntry(manifest, packageDirectory);
-		const registeredIntegration = REGISTERED_INTEGRATION_RUNTIME_PRECEDENCE.flatMap((runtime) => registeredIntegrations.filter((integration) => integration.runtime === runtime && (!integration.requiresViteDevelopmentServer || hasViteDevelopmentRuntime)))[0];
-		if (registeredIntegration) return {
-			isActive: true,
-			runtime: registeredIntegration.runtime
-		};
-	}
-	return null;
-};
-const hasStorybookReactViteConfig = (packageDirectory) => {
-	for (const configFilename of [
-		"main.ts",
-		"main.js",
-		"main.mjs",
-		"main.cjs"
-	]) {
-		const program = parseSourceFile(path.join(packageDirectory, ".storybook", configFilename));
-		if (!program) continue;
-		const scopes = analyzeScopes(program);
-		const exportedBindings = getExportedBindings(program, scopes);
-		let hasReactViteFramework = false;
-		walkAst(program, (node) => {
-			if (!isNodeOfType(node, "Property")) return;
-			if (!(isNodeOfType(node.key, "Identifier") && node.key.name === "framework" || isNodeOfType(node.key, "Literal") && node.key.value === "framework")) return;
-			if (!isExportedConfigProperty(node, exportedBindings, scopes)) return;
-			walkAst(node.value, (valueNode) => {
-				if (isNodeOfType(valueNode, "Literal") && valueNode.value === "@storybook/react-vite") {
-					hasReactViteFramework = true;
-					return false;
-				}
-			});
-			if (hasReactViteFramework) return false;
-		});
-		if (hasReactViteFramework) return true;
-	}
-	return false;
-};
-const resolveDirectUnreassignedValue = (value, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const unwrappedValue = stripParenExpression(value);
-	if (!isNodeOfType(unwrappedValue, "Identifier")) return unwrappedValue;
-	const symbol = scopes.symbolFor(unwrappedValue);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return unwrappedValue;
-	const initializer = getDirectUnreassignedInitializer(symbol);
-	if (!initializer) return unwrappedValue;
-	visitedSymbolIds.add(symbol.id);
-	return resolveDirectUnreassignedValue(initializer, scopes, visitedSymbolIds);
-};
-const isStaticPropertyNamed = (node, propertyName) => isNodeOfType(node, "Property") && (!node.computed && isNodeOfType(node.key, "Identifier") && node.key.name === propertyName || isNodeOfType(node.key, "Literal") && node.key.value === propertyName);
-const readLastStaticBooleanProperty = (value, propertyName, scopes) => {
-	const resolvedValue = resolveDirectUnreassignedValue(value, scopes);
-	if (!isNodeOfType(resolvedValue, "ObjectExpression")) return null;
-	let propertyValue = null;
-	for (const property of resolvedValue.properties) {
-		if (isNodeOfType(property, "SpreadElement")) {
-			propertyValue = null;
-			continue;
-		}
-		if (!isStaticPropertyNamed(property, propertyName) || !isNodeOfType(property, "Property")) continue;
-		propertyValue = readStaticBoolean(resolveDirectUnreassignedValue(property.value, scopes));
-	}
-	return propertyValue;
-};
-const isLastStaticPropertyInObject = (property, propertyName) => {
-	if (!isNodeOfType(property.parent, "ObjectExpression")) return false;
-	const propertyIndex = property.parent.properties.findIndex((objectProperty) => objectProperty === property);
-	return property.parent.properties.slice(propertyIndex + 1).every((laterProperty) => {
-		if (isNodeOfType(laterProperty, "SpreadElement")) return false;
-		return !isStaticPropertyNamed(laterProperty, propertyName);
-	});
-};
-const hasStorybookReactWebpackFastRefreshConfig = (packageDirectory) => {
-	for (const configFilename of [
-		"main.ts",
-		"main.js",
-		"main.mjs",
-		"main.cjs"
-	]) {
-		const program = parseSourceFile(path.join(packageDirectory, ".storybook", configFilename));
-		if (!program) continue;
-		const scopes = analyzeScopes(program);
-		const exportedBindings = getExportedBindings(program, scopes);
-		let hasFastRefresh = false;
-		walkAst(program, (node) => {
-			if (!isStaticPropertyNamed(node, "reactOptions") || !isNodeOfType(node, "Property")) return;
-			if (!isExportedConfigProperty(node, exportedBindings, scopes)) return;
-			if (!isLastStaticPropertyInObject(node, "reactOptions")) return;
-			if (readLastStaticBooleanProperty(node.value, "fastRefresh", scopes) === true) {
-				hasFastRefresh = true;
-				return false;
-			}
-		});
-		if (hasFastRefresh) return true;
-	}
-	return false;
-};
-const hasStorybookReactViteIntegration = (packageDirectory, manifest) => hasOwnedDevelopmentCommand(manifest, /(?:^|\s)(?:storybook\s+dev|start-storybook)(?:\s|$)/) && hasStorybookReactViteConfig(packageDirectory);
-const hasStorybookReactWebpackFastRefreshIntegration = (packageDirectory, manifest) => {
-	const developmentCommandPattern = /(?:^|\s)(?:storybook\s+dev|start-storybook)(?:\s|$)/;
-	if (!hasOwnedDevelopmentCommand(manifest, developmentCommandPattern)) return false;
-	return isVersionAtLeast(getOwnedDependencyVersion(manifest, "@storybook/react", developmentCommandPattern) ?? getOwnedDependencyVersion(manifest, "@storybook/react-webpack5", developmentCommandPattern), MINIMUM_FAST_REFRESH_VERSIONS.storybookReact) && hasStorybookReactWebpackFastRefreshConfig(packageDirectory);
-};
-const hasNxStorybookReactViteIntegration = (packageDirectory) => {
-	if (!hasStorybookReactViteConfig(packageDirectory)) return false;
-	try {
-		const project = JSON.parse(fs.readFileSync(path.join(packageDirectory, "project.json"), "utf8"));
-		if (typeof project !== "object" || project === null) return false;
-		const targets = Reflect.get(project, "targets");
-		if (typeof targets !== "object" || targets === null) return false;
-		return Object.keys(targets).some((targetName) => targetName === "storybook:serve:dev");
-	} catch {
-		return false;
-	}
-};
-const getLocalFastRefreshStatus = (packageDirectory, manifest) => {
-	const cachedStatus = cachedLocalStatusByManifest.get(manifest);
-	if (cachedStatus) return cachedStatus;
-	const status = getBuiltInStatus(manifest) ?? (hasStorybookReactViteIntegration(packageDirectory, manifest) || hasNxStorybookReactViteIntegration(packageDirectory) || hasStorybookReactWebpackFastRefreshIntegration(packageDirectory, manifest) ? {
-		isActive: true,
-		runtime: "generic"
-	} : null) ?? getRegisteredIntegration(packageDirectory, manifest) ?? INACTIVE_STATUS;
-	cachedLocalStatusByManifest.set(manifest, status);
-	return status;
-};
-const isWorkspaceRoot = (directory, manifest) => {
-	if (manifest?.workspaces !== void 0) return true;
-	return [
-		"pnpm-workspace.yaml",
-		"pnpm-workspace.yml",
-		"nx.json"
-	].some((filename) => fs.existsSync(path.join(directory, filename)));
-};
-const findWorkspaceRoot = (packageDirectory) => {
-	let currentDirectory = packageDirectory;
-	let workspaceRoot = null;
-	while (true) {
-		const manifest = readPackageManifest(currentDirectory);
-		if (isWorkspaceRoot(currentDirectory, manifest)) workspaceRoot = currentDirectory;
-		const parentDirectory = path.dirname(currentDirectory);
-		if (parentDirectory === currentDirectory) return workspaceRoot;
-		currentDirectory = parentDirectory;
-	}
-};
-const collectWorkspacePackages = (workspaceRoot) => {
-	const packages = [];
-	const pendingDirectories = [workspaceRoot];
-	while (pendingDirectories.length > 0) {
-		const directory = pendingDirectories.pop();
-		if (!directory) continue;
-		const manifest = readPackageManifest(directory);
-		if (manifest) packages.push({
-			directory,
-			manifest,
-			status: getLocalFastRefreshStatus(directory, manifest)
-		});
-		let entries;
-		try {
-			entries = fs.readdirSync(directory, { withFileTypes: true });
-		} catch {
-			continue;
-		}
-		for (const entry of entries) {
-			if (!entry.isDirectory()) continue;
-			if (entry.name.startsWith(".") || WORKSPACE_IGNORED_DIRECTORY_NAMES.has(entry.name)) continue;
-			pendingDirectories.push(path.join(directory, entry.name));
-		}
-	}
-	return packages;
-};
-const isPropertyNamed = (node, name) => isNodeOfType(node, "Property") && (isNodeOfType(node.key, "Identifier") && node.key.name === name || isNodeOfType(node.key, "Literal") && node.key.value === name);
-const normalizeAliasRoot = (configDirectory, aliasPath) => {
-	if (!aliasPath.startsWith(".") && !path.isAbsolute(aliasPath)) return null;
-	const withoutPlaceholder = aliasPath.replace(/(?:\/)?(?:\*|\$\d+).*$/, "");
-	return path.resolve(configDirectory, withoutPlaceholder);
-};
-const collectAliasRootsFromValue = (value, configDirectory, aliasRoots) => {
-	walkAst(value, (node) => {
-		if (!isPropertyNamed(node, "alias")) return;
-		if (!isNodeOfType(node, "Property")) return;
-		walkAst(node.value, (aliasNode) => {
-			if (!isNodeOfType(aliasNode, "Literal") || typeof aliasNode.value !== "string") return;
-			const aliasRoot = normalizeAliasRoot(configDirectory, aliasNode.value);
-			if (aliasRoot) aliasRoots.add(aliasRoot);
-		});
-		return false;
-	});
-};
-const getActivePackageAliasRoots = (packageDirectory, manifest) => {
-	const aliasRoots = /* @__PURE__ */ new Set();
-	const configPaths = [...getExplicitConfigPaths(packageDirectory, manifest), ...[
-		"main.ts",
-		"main.js",
-		"main.mjs",
-		"main.cjs"
-	].map((filename) => path.join(packageDirectory, ".storybook", filename))];
-	for (const configPath of configPaths) {
-		const program = parseSourceFile(configPath);
-		if (!program) continue;
-		const scopes = analyzeScopes(program);
-		const exportedBindings = getExportedBindings(program, scopes);
-		walkAst(program, (node) => {
-			if (!isPropertyNamed(node, "resolve") && !isPropertyNamed(node, "viteFinal")) return;
-			if (!isNodeOfType(node, "Property")) return;
-			if (!isExportedConfigProperty(node, exportedBindings, scopes)) return;
-			collectAliasRootsFromValue(node.value, path.dirname(configPath), aliasRoots);
-			return false;
-		});
-	}
-	return aliasRoots;
-};
-const collectStringValues = (value, values) => {
-	if (typeof value === "string") {
-		values.push(value);
-		return;
-	}
-	if (Array.isArray(value)) {
-		for (const entry of value) collectStringValues(entry, values);
-		return;
-	}
-	if (typeof value !== "object" || value === null) return;
-	for (const entry of Object.values(value)) collectStringValues(entry, values);
-};
-const hasSourceRuntimeEntry = (manifest) => {
-	const entryValues = [];
-	collectStringValues(manifest.exports, entryValues);
-	collectStringValues(manifest.main, entryValues);
-	collectStringValues(manifest.module, entryValues);
-	return entryValues.some((entry) => /^\.\/?src(?:\/|\.|$)/.test(entry));
-};
-const getWorkspaceDependencyVersion = (manifest, dependencyName) => manifest.dependencies?.[dependencyName] ?? manifest.optionalDependencies?.[dependencyName];
-const buildWorkspaceFastRefreshIndex = (workspaceRoot, rootManifest) => {
-	const cached = cachedWorkspaceIndexByManifest.get(rootManifest);
-	if (cached) return cached;
-	const workspacePackages = collectWorkspacePackages(workspaceRoot);
-	const activePackages = workspacePackages.filter((workspacePackage) => workspacePackage.status.isActive);
-	const aliasOwners = [];
-	for (const activePackage of activePackages) for (const rootDirectory of getActivePackageAliasRoots(activePackage.directory, activePackage.manifest)) aliasOwners.push({
-		rootDirectory,
-		status: activePackage.status
-	});
-	const sourceEntryOwners = /* @__PURE__ */ new Map();
-	for (const producerPackage of workspacePackages) {
-		const packageName = producerPackage.manifest.name;
-		if (typeof packageName !== "string" || !hasSourceRuntimeEntry(producerPackage.manifest)) continue;
-		const owner = activePackages.find((activePackage) => {
-			const dependencyVersion = getWorkspaceDependencyVersion(activePackage.manifest, packageName);
-			return typeof dependencyVersion === "string" && dependencyVersion.startsWith("workspace:");
-		});
-		if (owner) sourceEntryOwners.set(producerPackage.directory, owner.status);
-	}
-	const index = {
-		aliasOwners,
-		sourceEntryOwners
-	};
-	cachedWorkspaceIndexByManifest.set(rootManifest, index);
-	return index;
-};
-const isPathInside = (filePath, directory) => {
-	const relativePath = path.relative(directory, filePath);
-	return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
-};
-const getWorkspaceOwnedStatus = (filename, packageDirectory) => {
-	const workspaceRoot = findWorkspaceRoot(packageDirectory);
-	if (!workspaceRoot) return null;
-	const rootManifest = readPackageManifest(workspaceRoot);
-	if (!rootManifest) return null;
-	const index = buildWorkspaceFastRefreshIndex(workspaceRoot, rootManifest);
-	const aliasOwner = index.aliasOwners.find((owner) => isPathInside(filename, owner.rootDirectory));
-	if (aliasOwner) return aliasOwner.status;
-	for (const [producerDirectory, status] of index.sourceEntryOwners) if (isPathInside(filename, producerDirectory)) return status;
-	return null;
-};
-const resolveFastRefreshFileStatus = (filename) => {
-	const manifest = readNearestPackageManifest(filename);
-	if (!manifest) return INACTIVE_STATUS;
-	const packageDirectory = findNearestPackageDirectory(filename);
-	if (!packageDirectory) return INACTIVE_STATUS;
-	const localStatus = getLocalFastRefreshStatus(packageDirectory, manifest);
-	if (localStatus.isActive) return localStatus;
-	return getWorkspaceOwnedStatus(filename, packageDirectory) ?? INACTIVE_STATUS;
-};
-const getConfiguredFallbackStatus = (context) => {
-	const framework = getReactDoctorStringSetting(context.settings, "framework");
-	return {
-		isActive: true,
-		runtime: framework === "nextjs" ? "next" : framework === "expo" || framework === "react-native" ? "expo" : framework === "remix" ? "remix" : framework === "tanstack-start" ? "tanstack" : "generic"
-	};
-};
-const getFastRefreshFileStatus = (context) => {
-	let filename = context.filename;
-	if (!filename) return getConfiguredFallbackStatus(context);
-	if (!path.isAbsolute(filename)) {
-		const absoluteFilename = path.resolve(filename);
-		if (!fs.existsSync(absoluteFilename)) return getConfiguredFallbackStatus(context);
-		filename = absoluteFilename;
-	}
-	if (!readNearestPackageManifest(filename)) return INACTIVE_STATUS;
-	return resolveFastRefreshFileStatus(filename);
+	return FRAMEWORK_ROUTE_FILE_PATTERNS.some((pattern) => pattern.test(basename));
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/only-export-components-tables.ts
@@ -46578,7 +45768,6 @@ const NOT_REACT_COMPONENT_EXPRESSION_TYPES = new Set([
 	"ConditionalExpression",
 	"Literal",
 	"LogicalExpression",
-	"NewExpression",
 	"ObjectExpression",
 	"TemplateLiteral",
 	"ThisExpression",
@@ -46597,25 +45786,124 @@ const NON_FAST_REFRESH_PATH_SEGMENTS = [
 	"/cypress/",
 	"/.storybook/",
 	"/stories/",
-	"/__stories__/"
+	"/__stories__/",
+	"/playground/",
+	"/playgrounds/",
+	"/examples/",
+	"/example/",
+	"/demo/",
+	"/demos/",
+	"/sandbox/",
+	"/sandboxes/"
 ];
-const TANSTACK_ROUTE_FACTORY_CALLEE_NAMES = new Set([
+const ENTRY_POINT_BASENAMES = new Set([
+	"main.tsx",
+	"main.jsx",
+	"main.js",
+	"index.tsx",
+	"index.jsx",
+	"entry.tsx",
+	"entry.jsx",
+	"bootstrap.tsx",
+	"bootstrap.jsx",
+	"client.tsx",
+	"client.jsx",
+	"server.tsx",
+	"server.jsx",
+	"app.tsx",
+	"app.jsx",
+	"App.tsx",
+	"App.jsx"
+]);
+const UTILITY_FILE_BASENAMES = new Set([
+	"utils.tsx",
+	"utils.jsx",
+	"util.tsx",
+	"util.jsx",
+	"helpers.tsx",
+	"helpers.jsx",
+	"helper.tsx",
+	"helper.jsx",
+	"shared.tsx",
+	"shared.jsx",
+	"common.tsx",
+	"common.jsx",
+	"lib.tsx",
+	"lib.jsx",
+	"nodeTypes.tsx",
+	"nodeTypes.jsx",
+	"node-types.tsx",
+	"node-types.jsx",
+	"edgeTypes.tsx",
+	"edgeTypes.jsx",
+	"edge-types.tsx",
+	"edge-types.jsx",
+	"cellTypes.tsx",
+	"cellTypes.jsx",
+	"columnTypes.tsx",
+	"columnTypes.jsx",
+	"columnDefs.tsx",
+	"columnDefs.jsx",
+	"columnRenderers.tsx",
+	"columnRenderers.jsx",
+	"columns.tsx",
+	"columns.jsx",
+	"mappings.tsx",
+	"mappings.jsx",
+	"mapping.tsx",
+	"mapping.jsx",
+	"lookups.tsx",
+	"lookups.jsx",
+	"lookup.tsx",
+	"lookup.jsx",
+	"registry.tsx",
+	"registry.jsx",
+	"toast.tsx",
+	"toast.jsx",
+	"toaster.tsx",
+	"toaster.jsx",
+	"theme.tsx",
+	"theme.jsx",
+	"tokens.tsx",
+	"tokens.jsx",
+	"palette.tsx",
+	"palette.jsx",
+	"colors.tsx",
+	"colors.jsx",
+	"colours.tsx",
+	"colours.jsx",
+	"constants.tsx",
+	"constants.jsx",
+	"enums.tsx",
+	"enums.jsx",
+	"types.tsx",
+	"types.jsx",
+	"schemas.tsx",
+	"schemas.jsx",
+	"schema.tsx",
+	"schema.jsx",
+	"definitions.tsx",
+	"definitions.jsx",
+	"config.tsx",
+	"config.jsx",
+	"defaults.tsx",
+	"defaults.jsx"
+]);
+const ROUTE_FACTORY_CALLEE_NAMES = new Set([
 	...TANSTACK_ROUTE_CREATION_FUNCTIONS,
 	"createLazyFileRoute",
 	"createLazyRoute",
 	"createAPIFileRoute",
 	"createServerFileRoute",
 	"createServerRootRoute",
-	"createServerRoute"
-]);
-const REACT_ROUTER_FACTORY_CALLEE_NAMES = new Set([
+	"createServerRoute",
 	"createBrowserRouter",
 	"createHashRouter",
 	"createMemoryRouter",
 	"createStaticRouter",
 	"createRouter"
 ]);
-const REACT_ROUTER_ALLOWED_EXPORT_NAMES = new Set([
+const ROUTE_MODULE_ALLOWED_EXPORT_NAMES = new Set([
 	"loader",
 	"clientLoader",
 	"action",
@@ -46626,9 +45914,7 @@ const REACT_ROUTER_ALLOWED_EXPORT_NAMES = new Set([
 	"handle",
 	"shouldRevalidate",
 	"middleware",
-	"unstable_middleware"
-]);
-const NEXT_ALLOWED_EXPORT_NAMES = new Set([
+	"unstable_middleware",
 	"getServerSideProps",
 	"getStaticProps",
 	"getStaticPaths",
@@ -46648,9 +45934,9 @@ const NEXT_ALLOWED_EXPORT_NAMES = new Set([
 	"runtime",
 	"preferredRegion",
 	"maxDuration",
-	"experimental_ppr"
+	"experimental_ppr",
+	"unstable_settings"
 ]);
-const EXPO_ALLOWED_EXPORT_NAMES = new Set(["unstable_settings"]);
 //#endregion
 //#region src/plugin/rules/react-builtins/only-export-components.ts
 const NAMED_EXPORT_MESSAGE = "This file exports non-components, so Fast Refresh can't safely preserve component state.";
@@ -46663,8 +45949,6 @@ const DEFAULT_REACT_HOCS = [
 	"forwardRef",
 	"lazy"
 ];
-const EMPTY_NAME_SET = /* @__PURE__ */ new Set();
-const TEST_SUPPORT_FILE_PATTERN = /(?:^|\/)(?:test|spec)(?:[-_.]?(?:utils?|helpers?|setup|fixtures?))?\.(?:jsx?|tsx?)$/i;
 const resolveSettings$6 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.onlyExportComponents ?? {} : {};
@@ -46688,12 +45972,13 @@ const isReactCreateContext = (initializer) => {
 	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "createContext") return true;
 	return false;
 };
-const isRouteFactoryCall = (expression, bindings) => {
+const isRouteFactoryName = (name) => ROUTE_FACTORY_CALLEE_NAMES.has(name);
+const isRouteFactoryCall = (expression) => {
 	let currentCall = expression;
 	while (isNodeOfType(currentCall, "CallExpression")) {
 		const callee = currentCall.callee;
-		if (isNodeOfType(callee, "Identifier") && bindings.localNames.has(callee.name)) return true;
-		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && bindings.namespaceNames.has(callee.object.name) && isNodeOfType(callee.property, "Identifier") && bindings.memberNames.has(callee.property.name)) return true;
+		if (isNodeOfType(callee, "Identifier") && isRouteFactoryName(callee.name)) return true;
+		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && isRouteFactoryName(callee.property.name)) return true;
 		if (!isNodeOfType(callee, "CallExpression")) return false;
 		currentCall = callee;
 	}
@@ -46721,11 +46006,10 @@ const isHocCallee = (callee, state) => {
 const canBeReactFunctionComponent = (initializer, state) => {
 	if (!initializer) return false;
 	const expression = skipTsExpression(initializer);
-	if (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression")) return functionHasReactRenderSemantics(expression, state);
+	if (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression")) return true;
 	if (isNodeOfType(expression, "CallExpression")) return isHocCallee(expression.callee, state);
 	return false;
 };
-const functionHasReactRenderSemantics = (functionNode, state) => functionContainsReactRenderOutput(functionNode, state.scopes, state.controlFlow) || functionHasReactElementReturnType(functionNode) || functionReturnsOnlyNull(functionNode);
 const isReactComponentInitializer = (expression, state) => {
 	const stripped = skipTsExpression(expression);
 	if (isNodeOfType(stripped, "ArrowFunctionExpression")) return true;
@@ -46734,60 +46018,6 @@ const isReactComponentInitializer = (expression, state) => {
 	if (isNodeOfType(stripped, "CallExpression") && isHocCallee(stripped.callee, state) && stripped.arguments.length > 0) return true;
 	return false;
 };
-const isNextDynamicCall = (expression, nextDynamicImportSymbolIds, scopes) => {
-	const stripped = skipTsExpression(expression);
-	if (!isNodeOfType(stripped, "CallExpression")) return false;
-	const callee = skipTsExpression(stripped.callee);
-	if (!isNodeOfType(callee, "Identifier")) return false;
-	const symbol = scopes.symbolFor(callee);
-	return symbol !== null && nextDynamicImportSymbolIds.has(symbol.id);
-};
-const functionReturnsNextDynamicComponent = (expression, nextDynamicImportSymbolIds, scopes) => {
-	const stripped = skipTsExpression(expression);
-	if (!isNodeOfType(stripped, "ArrowFunctionExpression") && !isNodeOfType(stripped, "FunctionExpression") && !isNodeOfType(stripped, "FunctionDeclaration")) return false;
-	const body = stripped.body;
-	if (!isNodeOfType(body, "BlockStatement")) return isNextDynamicCall(body, nextDynamicImportSymbolIds, scopes);
-	if (body.body.length !== 1) return false;
-	const statement = body.body[0];
-	return Boolean(statement) && isNodeOfType(statement, "ReturnStatement") && Boolean(statement.argument) && isNextDynamicCall(statement.argument, nextDynamicImportSymbolIds, scopes);
-};
-const isComponentFactoryCall = (expression, state) => {
-	const stripped = skipTsExpression(expression);
-	if (!isNodeOfType(stripped, "CallExpression")) return false;
-	const callee = skipTsExpression(stripped.callee);
-	if (!isNodeOfType(callee, "Identifier")) return false;
-	const symbol = state.scopes.symbolFor(callee);
-	return symbol !== null && state.componentFactorySymbolIds.has(symbol.id);
-};
-const isProvenComponentValue = (expression, state, inspectedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const stripped = skipTsExpression(expression);
-	if (isNodeOfType(stripped, "Identifier")) {
-		const symbol = state.scopes.symbolFor(stripped);
-		if (!symbol) return false;
-		if (state.localComponentNames.has(stripped.name)) return symbol.references.every((reference) => reference.flag === "read");
-		if (isReactComponentName(stripped.name) && symbol.kind === "import") return true;
-		if (inspectedSymbolIds.has(symbol.id)) return false;
-		const initializer = getDirectUnreassignedInitializer(symbol);
-		if (!initializer) return false;
-		const strippedInitializer = skipTsExpression(initializer);
-		if (isNodeOfType(strippedInitializer, "ArrowFunctionExpression") || isNodeOfType(strippedInitializer, "FunctionExpression")) return false;
-		return isProvenComponentValue(initializer, state, new Set([...inspectedSymbolIds, symbol.id]));
-	}
-	if (isNodeOfType(stripped, "MemberExpression") && !stripped.computed && isNodeOfType(stripped.object, "Identifier") && isNodeOfType(stripped.property, "Identifier") && isReactComponentName(stripped.property.name)) {
-		const objectSymbol = state.scopes.symbolFor(stripped.object);
-		return objectSymbol !== null && state.importSymbolIds.has(objectSymbol.id);
-	}
-	if (isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "FunctionExpression")) return functionHasReactRenderSemantics(stripped, state);
-	if (!isNodeOfType(stripped, "CallExpression")) return false;
-	if (!isHocCallee(stripped.callee, state)) return false;
-	return stripped.arguments.some((argument) => isProvenComponentValue(argument, state));
-};
-const isDirectRefreshWrapperCall = (call, state) => {
-	const callee = skipTsExpression(call.callee);
-	if (isHocCallee(callee, state)) return call.arguments.length > 0;
-	if (!isNodeOfType(callee, "Identifier") && !isNodeOfType(callee, "MemberExpression")) return false;
-	return call.arguments.some((argument) => isProvenComponentValue(argument, state));
-};
 const objectExpressionBundlesComponents = (objectExpression, state) => {
 	for (const property of objectExpression.properties ?? []) {
 		if (!isNodeOfType(property, "Property")) continue;
@@ -46797,22 +46027,20 @@ const objectExpressionBundlesComponents = (objectExpression, state) => {
 			continue;
 		}
 		if (!(!property.computed && isNodeOfType(property.key, "Identifier") && isReactComponentName(property.key.name))) continue;
-		if ((isNodeOfType(value, "ArrowFunctionExpression") || isNodeOfType(value, "FunctionExpression")) && functionHasReactRenderSemantics(value, state)) return true;
+		if ((isNodeOfType(value, "ArrowFunctionExpression") || isNodeOfType(value, "FunctionExpression")) && functionContainsReactRenderOutput(value, state.scopes, state.controlFlow)) return true;
 		if (isNodeOfType(value, "CallExpression") && isHocCallee(value.callee, state) && value.arguments.length > 0) return true;
 	}
 	return false;
 };
 const classifyExport = (name, reportNode, isFunction, initializer, state) => {
-	if (isNodeOfType(reportNode, "Identifier") && isProvenComponentValue(reportNode, state)) return { kind: "react-component" };
 	if (initializer) {
 		const expression = skipTsExpression(initializer);
-		if (isNodeOfType(expression, "CallExpression") && isReactComponentName(name) && isComponentFactoryCall(expression, state)) return { kind: "react-component" };
-		if (isRouteFactoryCall(expression, state.routeFactoryBindings)) return { kind: "react-component" };
+		if (isRouteFactoryCall(expression)) return { kind: "react-component" };
 		if (isNodeOfType(expression, "CallExpression") && isHocCallee(expression.callee, state) && expression.arguments.length > 0 && isReactComponentName(name)) return { kind: "react-component" };
 		if (isNodeOfType(expression, "ConditionalExpression") && isReactComponentName(name) && isReactComponentInitializer(expression.consequent, state) && isReactComponentInitializer(expression.alternate, state)) return { kind: "react-component" };
 	}
 	if (state.allowExportNames.has(name)) return { kind: "allowed" };
-	if (state.allowedRouteExportNames.has(name)) return { kind: "allowed" };
+	if (ROUTE_MODULE_ALLOWED_EXPORT_NAMES.has(name)) return { kind: "allowed" };
 	if (/^use[A-Z]/.test(name)) return { kind: "allowed" };
 	if (state.allowConstantExport && initializer) {
 		const expression = skipTsExpression(initializer);
@@ -46838,33 +46066,42 @@ const classifyExport = (name, reportNode, isFunction, initializer, state) => {
 			kind: "namespace-object",
 			reportNode
 		};
-		if (isNodeOfType(stripped, "MemberExpression")) return isProvenComponentValue(stripped, state) ? { kind: "react-component" } : {
-			kind: "non-component",
-			reportNode
-		};
-		if (isNodeOfType(stripped, "Identifier")) return isProvenComponentValue(stripped, state) ? { kind: "react-component" } : {
-			kind: "non-component",
-			reportNode
-		};
 		if (NOT_REACT_COMPONENT_EXPRESSION_TYPES.has(stripped.type)) return {
 			kind: "non-component",
 			reportNode
 		};
-		if (isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "FunctionExpression")) return {
-			kind: "non-component",
-			reportNode
-		};
 	}
 	return isReactComponentName(name) ? { kind: "react-component" } : {
 		kind: "non-component",
 		reportNode
 	};
 };
+const isEntryPointFile = (filename) => {
+	const lastSlash = Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\"));
+	const basename = lastSlash === -1 ? filename : filename.slice(lastSlash + 1);
+	return ENTRY_POINT_BASENAMES.has(basename);
+};
+const ASSET_FILE_BASENAME_PATTERN = /^([A-Za-z][\w-]*[-._])?(icons?|svgs?|svg[-_]?sprites?|sprites?|emojis?|flags?|logos?|lockups?|illustrations?|glyphs?|stickers?|emotes?|avatars?|backgrounds?|patterns?|assets?|gradients?|countryVectors?|paymentVectors?|brandVectors?|brandLogos?)\.(t|j)sx?$/;
+const UTILITY_BASENAME_SUFFIX_PATTERN = /^[A-Za-z][\w-]*(Utils|Util|Helpers|Helper|Shared|Constants|Constant|Types|Type|Mappings|Mapping|Lookups|Lookup|Registry|Renderers|Renderer|NodeTypes|EdgeTypes|CellTypes|ColumnDefs|ColumnTypes|ColumnRenderers|Schemas|Schema|Definitions|Definition|Config|Configuration|Defaults|Default|Tokens|Palette|Context|Provider|Providers|Logic|Scene|Page|Layout)\.(t|j)sx?$/;
+const HOOK_FILE_BASENAME_PATTERN = /^use[A-Z][\w-]*\.(t|j)sx?$/;
+const NODE_DEFINITION_BASENAME_PATTERN = /^[A-Z][\w-]*(NodeUtil|ShapeUtil|EdgeUtil|BindingUtil|InlineNode|BlockNode|NotebookNode)\.(t|j)sx?$/;
+const isAssetOrUtilityFile = (filename) => {
+	const lastSlash = Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\"));
+	const basename = lastSlash === -1 ? filename : filename.slice(lastSlash + 1);
+	if (ASSET_FILE_BASENAME_PATTERN.test(basename)) return true;
+	if (UTILITY_FILE_BASENAMES.has(basename)) return true;
+	if (UTILITY_BASENAME_SUFFIX_PATTERN.test(basename)) return true;
+	if (HOOK_FILE_BASENAME_PATTERN.test(basename)) return true;
+	if (NODE_DEFINITION_BASENAME_PATTERN.test(basename)) return true;
+	return false;
+};
 const isFileNameAllowed = (filename, checkJS) => {
 	if (!filename) return true;
-	if (TEST_SUPPORT_FILE_PATTERN.test(filename)) return false;
 	if (filename.includes(".test.") || filename.includes(".spec.") || filename.includes(".cy.") || filename.includes(".stories.")) return false;
 	for (const segment of NON_FAST_REFRESH_PATH_SEGMENTS) if (filename.includes(segment)) return false;
+	if (isEntryPointFile(filename)) return false;
+	if (isFrameworkRouteOrSpecialFilename(filename)) return false;
+	if (isAssetOrUtilityFile(filename)) return false;
 	if (filename.endsWith(".tsx") || filename.endsWith(".jsx")) return true;
 	if (checkJS && filename.endsWith(".js")) return true;
 	return false;
@@ -46877,100 +46114,16 @@ const onlyExportComponents = defineRule({
 	category: "Architecture",
 	create: (context) => {
 		const settings = resolveSettings$6(context.settings);
-		const filename = normalizeFilename(context.filename ?? "");
-		const fastRefreshStatus = getFastRefreshFileStatus(context);
-		if (!fastRefreshStatus.isActive) return {};
-		if (isFrameworkRouteOrSpecialFilename(context, fastRefreshStatus.runtime)) return {};
-		if (!isFileNameAllowed(filename, settings.checkJS)) return {};
-		const allowedRouteExportNames = fastRefreshStatus.runtime === "next" ? NEXT_ALLOWED_EXPORT_NAMES : fastRefreshStatus.runtime === "expo" ? EXPO_ALLOWED_EXPORT_NAMES : fastRefreshStatus.runtime === "react-router" || fastRefreshStatus.runtime === "remix" ? REACT_ROUTER_ALLOWED_EXPORT_NAMES : EMPTY_NAME_SET;
-		const routeFactoryMemberNames = fastRefreshStatus.runtime === "tanstack" ? TANSTACK_ROUTE_FACTORY_CALLEE_NAMES : fastRefreshStatus.runtime === "react-router" || fastRefreshStatus.runtime === "remix" ? REACT_ROUTER_FACTORY_CALLEE_NAMES : EMPTY_NAME_SET;
-		const routeFactoryLocalNames = /* @__PURE__ */ new Set();
-		const routeFactoryNamespaceNames = /* @__PURE__ */ new Set();
-		const nextDynamicImportSymbolIds = /* @__PURE__ */ new Set();
-		const importSymbolIds = /* @__PURE__ */ new Set();
-		const routeFactoryBindings = {
-			localNames: routeFactoryLocalNames,
-			memberNames: routeFactoryMemberNames,
-			namespaceNames: routeFactoryNamespaceNames
-		};
+		if (!isFileNameAllowed(normalizeFilename(context.filename ?? ""), settings.checkJS)) return {};
 		const exportNodes = [];
 		const componentCandidates = [];
-		const createRootNames = /* @__PURE__ */ new Set();
-		const hydrateRootNames = /* @__PURE__ */ new Set();
-		const legacyRenderNames = /* @__PURE__ */ new Set();
-		const reactDomNamespaceNames = /* @__PURE__ */ new Set();
-		const rootNames = /* @__PURE__ */ new Set();
-		let hasRootMount = false;
-		const isCreateRootCall = (node) => {
-			if (!isNodeOfType(node, "CallExpression")) return false;
-			if (isNodeOfType(node.callee, "Identifier")) return createRootNames.has(node.callee.name);
-			return isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.object, "Identifier") && reactDomNamespaceNames.has(node.callee.object.name) && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "createRoot";
-		};
-		const visitImportDeclaration = (node) => {
-			if (!isNodeOfType(node, "ImportDeclaration")) return;
-			const source = node.source.value;
-			for (const specifier of node.specifiers) {
-				const symbol = context.scopes.symbolFor(specifier.local);
-				if (symbol) importSymbolIds.add(symbol.id);
-			}
-			if (typeof source === "string" && (fastRefreshStatus.runtime === "tanstack" && (source.startsWith("@tanstack/react-router") || source.startsWith("@tanstack/react-start")) || (fastRefreshStatus.runtime === "react-router" || fastRefreshStatus.runtime === "remix") && (source === "react-router" || source === "react-router-dom" || source === "@remix-run/react"))) for (const specifier of node.specifiers) {
-				if (isNodeOfType(specifier, "ImportNamespaceSpecifier")) {
-					routeFactoryNamespaceNames.add(specifier.local.name);
-					continue;
-				}
-				const importedName = getImportedName(specifier);
-				if (importedName && routeFactoryMemberNames.has(importedName)) routeFactoryLocalNames.add(specifier.local.name);
-			}
-			if (source === "next/dynamic") for (const specifier of node.specifiers) {
-				if (!isNodeOfType(specifier, "ImportDefaultSpecifier")) continue;
-				const symbol = context.scopes.symbolFor(specifier.local);
-				if (symbol) nextDynamicImportSymbolIds.add(symbol.id);
-			}
-			if (source !== "react-dom" && source !== "react-dom/client") return;
-			for (const specifier of node.specifiers) {
-				if (isNodeOfType(specifier, "ImportDefaultSpecifier") || isNodeOfType(specifier, "ImportNamespaceSpecifier")) {
-					reactDomNamespaceNames.add(specifier.local.name);
-					continue;
-				}
-				const importedName = getImportedName(specifier);
-				if (importedName === "createRoot") createRootNames.add(specifier.local.name);
-				if (importedName === "hydrateRoot") hydrateRootNames.add(specifier.local.name);
-				if (source === "react-dom" && (importedName === "render" || importedName === "hydrate")) legacyRenderNames.add(specifier.local.name);
-			}
-		};
-		const visitCallExpression = (node) => {
-			if (!isNodeOfType(node, "CallExpression")) return;
-			if (isInsideFunctionScope(node)) return;
-			if (isNodeOfType(node.callee, "Identifier")) {
-				if (hydrateRootNames.has(node.callee.name) || legacyRenderNames.has(node.callee.name)) hasRootMount = true;
-				return;
-			}
-			if (!isNodeOfType(node.callee, "MemberExpression") || !isNodeOfType(node.callee.property, "Identifier")) return;
-			const methodName = node.callee.property.name;
-			if (isNodeOfType(node.callee.object, "Identifier") && reactDomNamespaceNames.has(node.callee.object.name) && (methodName === "render" || methodName === "hydrate" || methodName === "hydrateRoot")) {
-				hasRootMount = true;
-				return;
-			}
-			if (methodName !== "render") return;
-			if (isCreateRootCall(node.callee.object)) {
-				hasRootMount = true;
-				return;
-			}
-			if (isNodeOfType(node.callee.object, "Identifier") && rootNames.has(node.callee.object.name)) hasRootMount = true;
-		};
 		const pushExportNode = (node) => {
 			exportNodes.push(node);
 		};
 		const pushComponentCandidate = (node) => {
 			componentCandidates.push(node);
-			if (isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && node.init && isCreateRootCall(node.init) && !isInsideFunctionScope(node)) rootNames.add(node.id.name);
 		};
 		return {
-			ImportDeclaration: visitImportDeclaration,
-			CallExpression: visitCallExpression,
-			AssignmentExpression(node) {
-				if (isNodeOfType(node.left, "Identifier") && rootNames.has(node.left.name)) rootNames.delete(node.left.name);
-			},
 			ExportAllDeclaration: pushExportNode,
 			ExportDefaultDeclaration: pushExportNode,
 			ExportNamedDeclaration: pushExportNode,
@@ -46978,53 +46131,31 @@ const onlyExportComponents = defineRule({
 			VariableDeclarator: pushComponentCandidate,
 			ClassDeclaration: pushComponentCandidate,
 			"Program:exit"() {
-				if (hasRootMount) return;
 				const localComponentNames = /* @__PURE__ */ new Set();
-				const componentFactorySymbolIds = /* @__PURE__ */ new Set();
-				for (const child of componentCandidates) {
-					if (isInsideFunctionScope(child)) continue;
-					if (isNodeOfType(child, "FunctionDeclaration") && child.id) {
-						if (functionReturnsNextDynamicComponent(child, nextDynamicImportSymbolIds, context.scopes)) {
-							const symbol = context.scopes.symbolFor(child.id);
-							if (symbol?.references.every((reference) => reference.flag === "read")) componentFactorySymbolIds.add(symbol.id);
-						}
-						continue;
-					}
-					if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier") && child.init && functionReturnsNextDynamicComponent(child.init, nextDynamicImportSymbolIds, context.scopes)) {
-						const symbol = context.scopes.symbolFor(child.id);
-						if (symbol?.references.every((reference) => reference.flag === "read")) componentFactorySymbolIds.add(symbol.id);
-					}
-				}
 				const state = {
 					customHocs: new Set([...DEFAULT_REACT_HOCS, ...settings.customHOCs]),
 					allowExportNames: new Set(settings.allowExportNames),
 					allowConstantExport: settings.allowConstantExport,
-					allowedRouteExportNames,
-					routeFactoryBindings,
-					componentFactorySymbolIds,
-					importSymbolIds,
 					localComponentNames,
 					scopes: context.scopes,
 					controlFlow: context.cfg
 				};
 				for (const child of componentCandidates) {
 					if (isNodeOfType(child, "FunctionDeclaration") && child.id) {
-						if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child) && functionHasReactRenderSemantics(child, state)) localComponentNames.add(child.id.name);
+						if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child) && functionContainsReactRenderOutput(child, context.scopes, context.cfg)) localComponentNames.add(child.id.name);
 					}
 					if (isNodeOfType(child, "ClassDeclaration") && child.id) {
 						if (isReactComponentName(child.id.name) && isEs6Component(child) && !isInsideFunctionScope(child)) localComponentNames.add(child.id.name);
 					}
 					if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
 						const initializer = child.init;
-						const expression = initializer ? skipTsExpression(initializer) : null;
-						const isDirectFunction = expression !== null && (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression"));
-						if (isReactComponentName(child.id.name) && (canBeReactFunctionComponent(initializer, state) || (expression ? isEs6Component(expression) : false)) && !isInsideFunctionScope(child)) {
-							if (!isDirectFunction || functionHasReactRenderSemantics(expression, state)) localComponentNames.add(child.id.name);
+						if (isReactComponentName(child.id.name) && (canBeReactFunctionComponent(initializer, state) || (initializer ? isEs6Component(skipTsExpression(initializer)) : false)) && !isInsideFunctionScope(child)) {
+							const expression = initializer ? skipTsExpression(initializer) : null;
+							if (!(expression !== null && (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression"))) || functionContainsReactRenderOutput(expression, context.scopes, context.cfg)) localComponentNames.add(child.id.name);
 						}
 					}
 				}
 				const exports = [];
-				const exportAllNodes = [];
 				let hasReactExport = false;
 				let hasAnyExports = false;
 				const isExportedNodeIds = /* @__PURE__ */ new WeakSet();
@@ -47032,8 +46163,10 @@ const onlyExportComponents = defineRule({
 					if (isNodeOfType(child, "ExportAllDeclaration")) {
 						if (child.exportKind === "type") continue;
 						hasAnyExports = true;
-						const source = child.source.value;
-						if (typeof source !== "string" || exportAllAddsRuntimeValues(filename, source)) exportAllNodes.push(child);
+						context.report({
+							node: child,
+							message: EXPORT_ALL_MESSAGE
+						});
 						continue;
 					}
 					if (isNodeOfType(child, "ExportDefaultDeclaration")) {
@@ -47041,24 +46174,17 @@ const onlyExportComponents = defineRule({
 						const declaration = child.declaration;
 						const stripped = skipTsExpression(declaration);
 						if (isNodeOfType(stripped, "FunctionDeclaration") || isNodeOfType(stripped, "FunctionExpression")) {
-							const hasRenderOutput = functionHasReactRenderSemantics(stripped, state);
 							if (stripped.id) {
 								const idNode = stripped.id;
 								isExportedNodeIds.add(stripped);
-								exports.push(hasRenderOutput ? classifyExport(idNode.name, idNode, true, null, state) : {
-									kind: "non-component",
-									reportNode: idNode
-								});
-							} else if (hasRenderOutput) {
+								exports.push(classifyExport(idNode.name, idNode, true, null, state));
+							} else {
 								context.report({
 									node: stripped,
 									message: ANONYMOUS_MESSAGE
 								});
 								hasReactExport = true;
-							} else exports.push({
-								kind: "non-component",
-								reportNode: stripped
-							});
+							}
 							continue;
 						}
 						if (isNodeOfType(stripped, "ClassDeclaration") || isNodeOfType(stripped, "ClassExpression")) {
@@ -47077,34 +46203,26 @@ const onlyExportComponents = defineRule({
 							continue;
 						}
 						if (isNodeOfType(stripped, "Identifier")) {
-							exports.push(isProvenComponentValue(stripped, state) ? { kind: "react-component" } : {
-								kind: "non-component",
-								reportNode: stripped
-							});
-							continue;
-						}
-						if (isNodeOfType(stripped, "MemberExpression")) {
-							if (isProvenComponentValue(stripped, state)) hasReactExport = true;
-							else exports.push({
-								kind: "non-component",
-								reportNode: stripped
-							});
+							exports.push(classifyExport(stripped.name, stripped, false, null, state));
 							continue;
 						}
 						if (isNodeOfType(stripped, "CallExpression")) {
-							if (isRouteFactoryCall(stripped, state.routeFactoryBindings)) {
+							if (isRouteFactoryCall(stripped)) {
 								hasReactExport = true;
 								continue;
 							}
-							if (isReactCreateContext(stripped)) {
-								exports.push({
-									kind: "react-context",
-									reportNode: stripped
-								});
-								continue;
-							}
-							if (isDirectRefreshWrapperCall(stripped, state)) hasReactExport = true;
-							else if (isConfigOnlyFactoryCall(stripped)) exports.push({
+							const isHoc = isHocCallee(stripped.callee, state);
+							const firstArg = stripped.arguments[0];
+							const firstArgIsValid = Boolean(firstArg) && (() => {
+								if (!firstArg) return false;
+								const expression = skipTsExpression(firstArg);
+								if (isNodeOfType(expression, "Identifier")) return true;
+								if (isNodeOfType(expression, "FunctionExpression") && expression.id) return true;
+								if (isNodeOfType(expression, "CallExpression") && isHocCallee(expression.callee, state)) return true;
+								return false;
+							})();
+							if (isHoc && firstArgIsValid) hasReactExport = true;
+							else if (!isHoc && isConfigOnlyFactoryCall(stripped)) exports.push({
 								kind: "non-component",
 								reportNode: stripped
 							});
@@ -47115,32 +46233,16 @@ const onlyExportComponents = defineRule({
 							continue;
 						}
 						if (isNodeOfType(stripped, "ObjectExpression")) {
-							exports.push(objectExpressionBundlesComponents(stripped, state) ? {
-								kind: "namespace-object",
-								reportNode: stripped
-							} : {
-								kind: "non-component",
-								reportNode: stripped
-							});
-							continue;
-						}
-						if (isNodeOfType(stripped, "ArrowFunctionExpression")) {
-							if (functionHasReactRenderSemantics(stripped, state)) {
-								context.report({
-									node: stripped,
-									message: ANONYMOUS_MESSAGE
-								});
-								hasReactExport = true;
-							} else exports.push({
-								kind: "non-component",
-								reportNode: stripped
+							context.report({
+								node: stripped,
+								message: objectExpressionBundlesComponents(stripped, state) ? NAMESPACE_OBJECT_MESSAGE : ANONYMOUS_MESSAGE
 							});
 							continue;
 						}
-						if (isNodeOfType(stripped, "Literal") || isNodeOfType(stripped, "NewExpression")) {
-							exports.push({
-								kind: "non-component",
-								reportNode: stripped
+						if (isNodeOfType(stripped, "ArrowFunctionExpression") || isNodeOfType(stripped, "Literal")) {
+							context.report({
+								node: stripped,
+								message: ANONYMOUS_MESSAGE
 							});
 							continue;
 						}
@@ -47157,10 +46259,7 @@ const onlyExportComponents = defineRule({
 							const declaration = child.declaration;
 							if (isNodeOfType(declaration, "FunctionDeclaration") && declaration.id) {
 								isExportedNodeIds.add(declaration);
-								exports.push(functionHasReactRenderSemantics(declaration, state) || localComponentNames.has(declaration.id.name) ? classifyExport(declaration.id.name, declaration.id, true, null, state) : {
-									kind: "non-component",
-									reportNode: declaration.id
-								});
+								exports.push(classifyExport(declaration.id.name, declaration.id, true, null, state));
 							} else if (isNodeOfType(declaration, "ClassDeclaration") && declaration.id) {
 								isExportedNodeIds.add(declaration);
 								if (isReactComponentName(declaration.id.name) && isEs6Component(declaration)) exports.push({ kind: "react-component" });
@@ -47184,7 +46283,6 @@ const onlyExportComponents = defineRule({
 						const isReExportFromSource = Boolean(child.source);
 						for (const specifier of child.specifiers ?? []) {
 							if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
-							if (specifier.exportKind === "type") continue;
 							const exported = specifier.exported;
 							const local = specifier.local;
 							let exportedName = null;
@@ -47192,13 +46290,8 @@ const onlyExportComponents = defineRule({
 							const localName = local && isNodeOfType(local, "Identifier") ? local.name : null;
 							const reportNode = specifier;
 							let entry;
-							if (localName && localComponentNames.has(localName)) entry = { kind: "react-component" };
-							else if (!isReExportFromSource && localName === exportedName && localName !== null && isReactComponentName(localName)) entry = { kind: "react-component" };
-							else if (exportedName === "default" && localName && local) entry = isProvenComponentValue(local, state) ? { kind: "react-component" } : {
-								kind: "non-component",
-								reportNode
-							};
-							else if (exportedName) entry = classifyExport(exportedName, reportNode, false, isReExportFromSource ? null : local, state);
+							if (exportedName === "default" && localName) entry = classifyExport(localName, reportNode, false, null, state);
+							else if (exportedName) entry = classifyExport(exportedName, reportNode, false, null, state);
 							else {
 								entry = {
 									kind: "non-component",
@@ -47216,21 +46309,15 @@ const onlyExportComponents = defineRule({
 					node: entry.reportNode,
 					message: NAMESPACE_OBJECT_MESSAGE
 				});
-				if (hasAnyExports && hasReactExport) {
-					for (const exportAllNode of exportAllNodes) context.report({
-						node: exportAllNode,
-						message: EXPORT_ALL_MESSAGE
+				if (hasAnyExports && hasReactExport) for (const entry of exports) {
+					if (entry.kind === "non-component") context.report({
+						node: entry.reportNode,
+						message: NAMED_EXPORT_MESSAGE
+					});
+					if (entry.kind === "react-context") context.report({
+						node: entry.reportNode,
+						message: REACT_CONTEXT_MESSAGE
 					});
-					for (const entry of exports) {
-						if (entry.kind === "non-component") context.report({
-							node: entry.reportNode,
-							message: NAMED_EXPORT_MESSAGE
-						});
-						if (entry.kind === "react-context") context.report({
-							node: entry.reportNode,
-							message: REACT_CONTEXT_MESSAGE
-						});
-					}
 				}
 			}
 		};
@@ -67327,7 +66414,6 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"no-effect-with-fresh-deps",
 	"no-initialize-state",
 	"no-mutating-reducer-state",
-	"only-export-components",
 	"no-unguarded-browser-global-in-render-or-hook-init",
 	"prefer-dynamic-import",
 	"rendering-hydration-mismatch-time",
@@ -67535,7 +66621,7 @@ const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 * `CROSS_FILE_DEPENDENCY_COLLECTORS` (the core guard test enforces the
 * partition), forcing a conscious classification.
 */
-const UNBOUNDED_CROSS_FILE_RULE_IDS = new Set(["only-export-components"]);
+const UNBOUNDED_CROSS_FILE_RULE_IDS = /* @__PURE__ */ new Set();
 /**
 * Runs the collectors for `ruleIds` over one file and returns every
 * filesystem probe they made — the file's cross-file dependency set.