react-doctor 0.0.34 → 0.0.35

package/dist/react-doctor-plugin.js

@@ -169,6 +169,56 @@ const SECRET_FALSE_POSITIVE_SUFFIXES = new Set([
 	"schema",
 	"constant"
 ]);
+const TANSTACK_ROUTE_FILE_PATTERN = /\/routes\//;
+const TANSTACK_ROOT_ROUTE_FILE_PATTERN = /__root\.(tsx?|jsx?)$/;
+const TANSTACK_ROUTE_PROPERTY_ORDER = [
+	"params",
+	"validateSearch",
+	"loaderDeps",
+	"search.middlewares",
+	"ssr",
+	"context",
+	"beforeLoad",
+	"loader",
+	"onEnter",
+	"onStay",
+	"onLeave",
+	"head",
+	"scripts",
+	"headers",
+	"remountDeps"
+];
+const TANSTACK_ROUTE_CREATION_FUNCTIONS = new Set([
+	"createFileRoute",
+	"createRoute",
+	"createRootRoute",
+	"createRootRouteWithContext"
+]);
+const TANSTACK_SERVER_FN_NAMES = new Set(["createServerFn"]);
+const TANSTACK_MIDDLEWARE_METHOD_ORDER = [
+	"middleware",
+	"inputValidator",
+	"client",
+	"server",
+	"handler"
+];
+const TANSTACK_REDIRECT_FUNCTIONS = new Set(["redirect", "notFound"]);
+const TANSTACK_SERVER_FN_FILE_PATTERN = /\.functions(\.[jt]sx?)?$/;
+const SEQUENTIAL_AWAIT_THRESHOLD_FOR_LOADER = 2;
+const TANSTACK_QUERY_HOOKS = new Set([
+	"useQuery",
+	"useInfiniteQuery",
+	"useSuspenseQuery",
+	"useSuspenseInfiniteQuery"
+]);
+const TANSTACK_MUTATION_HOOKS = new Set(["useMutation"]);
+const TANSTACK_QUERY_CLIENT_CLASS = "QueryClient";
+const STABLE_HOOK_WRAPPERS = new Set([
+	"useState",
+	"useMemo",
+	"useRef"
+]);
+const SCRIPT_LOADING_ATTRIBUTES = new Set(["defer", "async"]);
 const TRIVIAL_INITIALIZER_NAMES = new Set([
 	"Boolean",
 	"String",
@@ -355,7 +405,7 @@ const isSimpleExpression = (node) => {
 		case "TemplateLiteral": return true;
 		case "BinaryExpression": return isSimpleExpression(node.left) && isSimpleExpression(node.right);
 		case "UnaryExpression": return isSimpleExpression(node.argument);
-		case "MemberExpression": return !node.computed;
+		case "MemberExpression": return !node.computed && isSimpleExpression(node.object);
 		case "ConditionalExpression": return isSimpleExpression(node.test) && isSimpleExpression(node.consequent) && isSimpleExpression(node.alternate);
 		default: return false;
 	}
@@ -673,6 +723,10 @@ const jsCombineIterations = { create: (context) => ({ CallExpression(node) {
 	if (innerCall?.type !== "CallExpression" || innerCall.callee?.type !== "MemberExpression" || innerCall.callee.property?.type !== "Identifier") return;
 	const innerMethod = innerCall.callee.property.name;
 	if (!CHAINABLE_ITERATION_METHODS.has(innerMethod)) return;
+	if (innerMethod === "map" && outerMethod === "filter") {
+		const filterArgument = node.arguments?.[0];
+		if (filterArgument?.type === "Identifier" && filterArgument.name === "Boolean" || filterArgument?.type === "ArrowFunctionExpression" && filterArgument.params?.length === 1 && filterArgument.body?.type === "Identifier" && filterArgument.params[0]?.type === "Identifier" && filterArgument.body.name === filterArgument.params[0].name) return;
+	}
 	context.report({
 		node,
 		message: `.${innerMethod}().${outerMethod}() iterates the array twice — combine into a single loop with .reduce() or for...of`
@@ -798,6 +852,21 @@ const reportIfIndependent = (statements, context) => {
 		message: `${statements.length} sequential await statements that appear independent — use Promise.all() for parallel execution`
 	});
 };
+const jsFlatmapFilter = { create: (context) => ({ CallExpression(node) {
+	if (node.callee?.type !== "MemberExpression" || node.callee.property?.type !== "Identifier") return;
+	if (node.callee.property.name !== "filter") return;
+	const filterArgument = node.arguments?.[0];
+	if (!filterArgument) return;
+	const isIdentityArrow = filterArgument.type === "ArrowFunctionExpression" && filterArgument.params?.length === 1 && filterArgument.body?.type === "Identifier" && filterArgument.params[0]?.type === "Identifier" && filterArgument.body.name === filterArgument.params[0].name;
+	if (!(filterArgument.type === "Identifier" && filterArgument.name === "Boolean" || isIdentityArrow)) return;
+	const innerCall = node.callee.object;
+	if (innerCall?.type !== "CallExpression" || innerCall.callee?.type !== "MemberExpression" || innerCall.callee.property?.type !== "Identifier") return;
+	if (innerCall.callee.property.name !== "map") return;
+	context.report({
+		node,
+		message: ".map().filter(Boolean) iterates twice — use .flatMap() to transform and filter in a single pass"
+	});
+} }) };
 
 //#endregion
 //#region src/plugin/rules/nextjs.ts
@@ -888,32 +957,37 @@ const nextjsMissingMetadata = { create: (context) => ({ Program(programNode) {
 		message: "Page without metadata or generateMetadata export — hurts SEO"
 	});
 } }) };
-const describeClientSideNavigation = (node) => {
+const describeClientSideNavigation = (node, isPagesRouterFile) => {
+	const redirectGuidance = isPagesRouterFile ? "handle navigation in an event handler, getServerSideProps redirect, or middleware" : "use redirect() from next/navigation or handle navigation in an event handler";
 	if (node.type === "CallExpression" && node.callee?.type === "MemberExpression") {
 		const objectName = node.callee.object?.type === "Identifier" ? node.callee.object.name : null;
 		const methodName = node.callee.property?.type === "Identifier" ? node.callee.property.name : null;
-		if (objectName === "router" && (methodName === "push" || methodName === "replace")) return `router.${methodName}() in useEffect — use redirect() from next/navigation or handle navigation in an event handler`;
+		if (objectName === "router" && (methodName === "push" || methodName === "replace")) return `router.${methodName}() in useEffect — ${redirectGuidance}`;
 	}
 	if (node.type === "AssignmentExpression" && node.left?.type === "MemberExpression") {
 		const objectName = node.left.object?.type === "Identifier" ? node.left.object.name : null;
 		const propertyName = node.left.property?.type === "Identifier" ? node.left.property.name : null;
-		if (objectName === "window" && propertyName === "location") return "window.location assignment in useEffect — use redirect() from next/navigation or handle in middleware instead";
-		if (objectName === "location" && propertyName === "href") return "location.href assignment in useEffect — use redirect() from next/navigation or handle in middleware instead";
+		if (objectName === "window" && propertyName === "location") return `window.location assignment in useEffect — ${redirectGuidance}`;
+		if (objectName === "location" && propertyName === "href") return `location.href assignment in useEffect — ${redirectGuidance}`;
 	}
 	return null;
 };
-const nextjsNoClientSideRedirect = { create: (context) => ({ CallExpression(node) {
-	if (!isHookCall(node, EFFECT_HOOK_NAMES)) return;
-	const callback = getEffectCallback(node);
-	if (!callback) return;
-	walkAst(callback, (child) => {
-		const navigationDescription = describeClientSideNavigation(child);
-		if (navigationDescription) context.report({
-			node: child,
-			message: navigationDescription
+const nextjsNoClientSideRedirect = { create: (context) => {
+	const filename = context.getFilename?.() ?? "";
+	const isPagesRouterFile = PAGES_DIRECTORY_PATTERN.test(filename);
+	return { CallExpression(node) {
+		if (!isHookCall(node, EFFECT_HOOK_NAMES)) return;
+		const callback = getEffectCallback(node);
+		if (!callback) return;
+		walkAst(callback, (child) => {
+			const navigationDescription = describeClientSideNavigation(child, isPagesRouterFile);
+			if (navigationDescription) context.report({
+				node: child,
+				message: navigationDescription
+			});
 		});
-	});
-} }) };
+	} };
+} };
 const nextjsNoRedirectInTryCatch = { create: (context) => {
 	let tryCatchDepth = 0;
 	return {
@@ -1260,6 +1334,19 @@ const renderingHydrationNoFlicker = { create: (context) => ({ CallExpression(nod
 		message: "useEffect(setState, []) on mount causes a flash — consider useSyncExternalStore or suppressHydrationWarning"
 	});
 } }) };
+const renderingScriptDeferAsync = { create: (context) => ({ JSXOpeningElement(node) {
+	if (node.name?.type !== "JSXIdentifier" || node.name.name !== "script") return;
+	const attributes = node.attributes ?? [];
+	if (!attributes.some((attr) => attr.type === "JSXAttribute" && attr.name?.type === "JSXIdentifier" && attr.name.name === "src")) return;
+	const typeAttribute = attributes.find((attr) => attr.type === "JSXAttribute" && attr.name?.type === "JSXIdentifier" && attr.name.name === "type");
+	const typeValue = typeAttribute?.value?.type === "Literal" ? typeAttribute.value.value : null;
+	if (typeof typeValue === "string" && !EXECUTABLE_SCRIPT_TYPES.has(typeValue)) return;
+	if (typeValue === "module") return;
+	if (!attributes.some((attr) => attr.type === "JSXAttribute" && attr.name?.type === "JSXIdentifier" && SCRIPT_LOADING_ATTRIBUTES.has(attr.name.name))) context.report({
+		node,
+		message: "<script src> without defer or async — blocks HTML parsing and delays First Contentful Paint. Add defer for DOM-dependent scripts or async for independent ones"
+	});
+} }) };
 
 //#endregion
 //#region src/plugin/rules/react-native.ts
@@ -1424,6 +1511,119 @@ const rnNoSingleElementStyleArray = { create: (context) => ({ JSXAttribute(node)
 	});
 } }) };
 
+//#endregion
+//#region src/plugin/rules/tanstack-query.ts
+const queryStableQueryClient = { create: (context) => {
+	let componentDepth = 0;
+	let stableHookDepth = 0;
+	return {
+		FunctionDeclaration(node) {
+			if (node.id?.name && UPPERCASE_PATTERN.test(node.id.name)) componentDepth++;
+		},
+		"FunctionDeclaration:exit"(node) {
+			if (node.id?.name && UPPERCASE_PATTERN.test(node.id.name)) componentDepth--;
+		},
+		VariableDeclarator(node) {
+			if (node.id?.type === "Identifier" && UPPERCASE_PATTERN.test(node.id.name) && (node.init?.type === "ArrowFunctionExpression" || node.init?.type === "FunctionExpression")) componentDepth++;
+		},
+		"VariableDeclarator:exit"(node) {
+			if (node.id?.type === "Identifier" && UPPERCASE_PATTERN.test(node.id.name) && (node.init?.type === "ArrowFunctionExpression" || node.init?.type === "FunctionExpression")) componentDepth--;
+		},
+		CallExpression(node) {
+			if (node.callee?.type === "Identifier" && STABLE_HOOK_WRAPPERS.has(node.callee.name)) stableHookDepth++;
+		},
+		"CallExpression:exit"(node) {
+			if (node.callee?.type === "Identifier" && STABLE_HOOK_WRAPPERS.has(node.callee.name)) stableHookDepth--;
+		},
+		NewExpression(node) {
+			if (componentDepth <= 0) return;
+			if (stableHookDepth > 0) return;
+			if (node.callee?.type !== "Identifier" || node.callee.name !== TANSTACK_QUERY_CLIENT_CLASS) return;
+			context.report({
+				node,
+				message: "new QueryClient() inside a component — creates a new cache on every render. Move to module scope or wrap in useState(() => new QueryClient())"
+			});
+		}
+	};
+} };
+const queryNoRestDestructuring = { create: (context) => ({ VariableDeclarator(node) {
+	if (node.id?.type !== "ObjectPattern") return;
+	if (!node.init || node.init.type !== "CallExpression") return;
+	const calleeName = node.init.callee?.type === "Identifier" ? node.init.callee.name : null;
+	if (!calleeName || !TANSTACK_QUERY_HOOKS.has(calleeName)) return;
+	if (node.id.properties?.some((property) => property.type === "RestElement")) context.report({
+		node: node.id,
+		message: `Rest destructuring on ${calleeName}() result — subscribes to all fields and causes unnecessary re-renders. Destructure only the fields you need`
+	});
+} }) };
+const queryNoVoidQueryFn = { create: (context) => ({ CallExpression(node) {
+	const calleeName = node.callee?.type === "Identifier" ? node.callee.name : null;
+	if (!calleeName || !TANSTACK_QUERY_HOOKS.has(calleeName)) return;
+	const optionsArgument = node.arguments?.[0];
+	if (!optionsArgument || optionsArgument.type !== "ObjectExpression") return;
+	const queryFnProperty = optionsArgument.properties?.find((property) => property.type === "Property" && property.key?.type === "Identifier" && property.key.name === "queryFn");
+	if (!queryFnProperty?.value) return;
+	const queryFnValue = queryFnProperty.value;
+	if (queryFnValue.type === "ArrowFunctionExpression" && queryFnValue.body?.type !== "BlockStatement") return;
+	if (queryFnValue.type === "ArrowFunctionExpression" || queryFnValue.type === "FunctionExpression") {
+		const body = queryFnValue.body;
+		if (body?.type !== "BlockStatement") return;
+		if ((body.body ?? []).length === 0) context.report({
+			node: queryFnProperty,
+			message: "Empty queryFn — query functions must return a value. Use the enabled option to conditionally disable the query instead"
+		});
+	}
+} }) };
+const queryNoQueryInEffect = { create: (context) => ({ CallExpression(node) {
+	if (!isHookCall(node, EFFECT_HOOK_NAMES)) return;
+	const callback = getEffectCallback(node);
+	if (!callback) return;
+	walkAst(callback, (child) => {
+		if (child.type !== "CallExpression") return;
+		if ((child.callee?.type === "Identifier" ? child.callee.name : null) === "refetch") context.report({
+			node: child,
+			message: "refetch() inside useEffect — React Query manages refetching automatically. Use queryKey dependencies or the enabled option instead"
+		});
+	});
+} }) };
+const queryMutationMissingInvalidation = { create: (context) => ({ CallExpression(node) {
+	const calleeName = node.callee?.type === "Identifier" ? node.callee.name : null;
+	if (!calleeName || !TANSTACK_MUTATION_HOOKS.has(calleeName)) return;
+	const optionsArgument = node.arguments?.[0];
+	if (!optionsArgument || optionsArgument.type !== "ObjectExpression") return;
+	if (!optionsArgument.properties?.some((property) => property.type === "Property" && property.key?.type === "Identifier" && property.key.name === "mutationFn")) return;
+	let hasInvalidation = false;
+	walkAst(optionsArgument, (child) => {
+		if (hasInvalidation) return;
+		if (child.type === "CallExpression" && child.callee?.type === "MemberExpression" && child.callee.property?.type === "Identifier" && child.callee.property.name === "invalidateQueries") hasInvalidation = true;
+	});
+	if (!hasInvalidation) context.report({
+		node,
+		message: "useMutation without invalidateQueries — stale data may remain cached after the mutation. Add onSuccess with queryClient.invalidateQueries()"
+	});
+} }) };
+const queryNoUseQueryForMutation = { create: (context) => ({ CallExpression(node) {
+	const calleeName = node.callee?.type === "Identifier" ? node.callee.name : null;
+	if (!calleeName || !TANSTACK_QUERY_HOOKS.has(calleeName)) return;
+	const optionsArgument = node.arguments?.[0];
+	if (!optionsArgument || optionsArgument.type !== "ObjectExpression") return;
+	const queryFnProperty = optionsArgument.properties?.find((property) => property.type === "Property" && property.key?.type === "Identifier" && property.key.name === "queryFn");
+	if (!queryFnProperty?.value) return;
+	let hasMutatingFetch = false;
+	walkAst(queryFnProperty.value, (child) => {
+		if (hasMutatingFetch) return;
+		if (child.type !== "CallExpression") return;
+		if (child.callee?.type !== "Identifier" || child.callee.name !== "fetch") return;
+		const optionsArg = child.arguments?.[1];
+		if (!optionsArg || optionsArg.type !== "ObjectExpression") return;
+		if (optionsArg.properties?.find((property) => property.type === "Property" && property.key?.type === "Identifier" && property.key.name === "method" && property.value?.type === "Literal" && typeof property.value.value === "string" && MUTATING_HTTP_METHODS.has(property.value.value.toUpperCase()))) hasMutatingFetch = true;
+	});
+	if (hasMutatingFetch) context.report({
+		node,
+		message: `${calleeName}() with a mutating fetch (POST/PUT/DELETE) — use useMutation() instead, which provides onSuccess/onError callbacks and doesn't auto-refetch`
+	});
+} }) };
+
 //#endregion
 //#region src/plugin/rules/security.ts
 const noEval = { create: (context) => ({
@@ -1522,6 +1722,335 @@ const serverAfterNonblocking = { create: (context) => {
 	};
 } };
 
+//#endregion
+//#region src/plugin/rules/tanstack-start.ts
+const getRouteOptionsObject = (node) => {
+	if (node.type !== "CallExpression") return null;
+	const callee = node.callee;
+	if (callee?.type === "CallExpression" && callee.callee?.type === "Identifier") {
+		if (!TANSTACK_ROUTE_CREATION_FUNCTIONS.has(callee.callee.name)) return null;
+		const optionsArgument = node.arguments?.[0];
+		if (optionsArgument?.type === "ObjectExpression") return optionsArgument;
+		return null;
+	}
+	if (callee?.type === "Identifier") {
+		if (!TANSTACK_ROUTE_CREATION_FUNCTIONS.has(callee.name)) return null;
+		const optionsArgument = node.arguments?.[0];
+		if (optionsArgument?.type === "ObjectExpression") return optionsArgument;
+		return null;
+	}
+	return null;
+};
+const getPropertyKeyName = (property) => {
+	if (property.type !== "Property" && property.type !== "MethodDefinition") return null;
+	if (property.key?.type === "Identifier") return property.key.name;
+	if (property.key?.type === "Literal") return String(property.key.value);
+	return null;
+};
+const walkServerFnChain = (outerNode) => {
+	const result = {
+		isServerFnChain: false,
+		specifiedMethod: null,
+		hasInputValidator: false
+	};
+	let currentNode = outerNode.callee?.object;
+	while (currentNode?.type === "CallExpression") {
+		const calleeName = getCalleeName(currentNode);
+		if (calleeName && TANSTACK_SERVER_FN_NAMES.has(calleeName)) {
+			result.isServerFnChain = true;
+			const optionsArgument = currentNode.arguments?.[0];
+			if (optionsArgument?.type === "ObjectExpression") {
+				for (const property of optionsArgument.properties ?? []) if (property.key?.type === "Identifier" && property.key.name === "method" && property.value?.type === "Literal" && typeof property.value.value === "string") result.specifiedMethod = property.value.value;
+			}
+		}
+		if (calleeName === "inputValidator") result.hasInputValidator = true;
+		if (currentNode.callee?.type === "MemberExpression") currentNode = currentNode.callee.object;
+		else break;
+	}
+	return result;
+};
+const tanstackStartRoutePropertyOrder = { create: (context) => ({ CallExpression(node) {
+	const optionsObject = getRouteOptionsObject(node);
+	if (!optionsObject) return;
+	const properties = optionsObject.properties ?? [];
+	const orderedPropertyNames = [];
+	for (const property of properties) {
+		const propertyName = getPropertyKeyName(property);
+		if (propertyName !== null) orderedPropertyNames.push(propertyName);
+	}
+	const sensitiveProperties = orderedPropertyNames.filter((propertyName) => TANSTACK_ROUTE_PROPERTY_ORDER.includes(propertyName));
+	let lastIndex = -1;
+	for (const propertyName of sensitiveProperties) {
+		const currentIndex = TANSTACK_ROUTE_PROPERTY_ORDER.indexOf(propertyName);
+		if (currentIndex < lastIndex) {
+			const expectedBefore = TANSTACK_ROUTE_PROPERTY_ORDER[lastIndex];
+			context.report({
+				node: optionsObject,
+				message: `Route property "${propertyName}" must come before "${expectedBefore}" — wrong order breaks TypeScript type inference`
+			});
+			return;
+		}
+		lastIndex = currentIndex;
+	}
+} }) };
+const tanstackStartNoDirectFetchInLoader = { create: (context) => ({ CallExpression(node) {
+	const optionsObject = getRouteOptionsObject(node);
+	if (!optionsObject) return;
+	const properties = optionsObject.properties ?? [];
+	for (const property of properties) {
+		if (getPropertyKeyName(property) !== "loader") continue;
+		walkAst(property.value ?? property, (child) => {
+			if (child.type !== "CallExpression") return;
+			if (child.callee?.type === "Identifier" && child.callee.name === "fetch") context.report({
+				node: child,
+				message: "Direct fetch() in route loader — use createServerFn() for type-safe server logic with automatic RPC"
+			});
+		});
+	}
+} }) };
+const tanstackStartServerFnValidateInput = { create: (context) => ({ CallExpression(node) {
+	if (node.callee?.type !== "MemberExpression") return;
+	if (node.callee.property?.type !== "Identifier") return;
+	if (node.callee.property.name !== "handler") return;
+	const chainInfo = walkServerFnChain(node);
+	if (!chainInfo.isServerFnChain) return;
+	const handlerFunction = node.arguments?.[0];
+	if (!handlerFunction) return;
+	let accessesData = false;
+	walkAst(handlerFunction, (child) => {
+		if (child.type === "MemberExpression" && child.property?.type === "Identifier" && child.property.name === "data") accessesData = true;
+		if (child.type === "ObjectPattern" && child.properties?.some((property) => property.key?.type === "Identifier" && property.key.name === "data")) accessesData = true;
+	});
+	if (accessesData && !chainInfo.hasInputValidator) context.report({
+		node,
+		message: "Server function handler accesses data without inputValidator() — validate inputs crossing the network boundary"
+	});
+} }) };
+const tanstackStartNoUseEffectFetch = { create: (context) => ({ CallExpression(node) {
+	const filename = context.getFilename?.() ?? "";
+	if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
+	if (node.callee?.type !== "Identifier") return;
+	if (node.callee.name !== "useEffect" && node.callee.name !== "useLayoutEffect") return;
+	const callback = node.arguments?.[0];
+	if (!callback) return;
+	let hasFetchCall = false;
+	walkAst(callback, (child) => {
+		if (hasFetchCall) return;
+		if (child.type === "CallExpression" && child.callee?.type === "Identifier" && child.callee.name === "fetch") hasFetchCall = true;
+	});
+	if (hasFetchCall) context.report({
+		node,
+		message: "fetch() inside useEffect in a route file — use the route loader or createServerFn() instead"
+	});
+} }) };
+const tanstackStartMissingHeadContent = { create: (context) => {
+	let hasHeadContentElement = false;
+	return {
+		JSXOpeningElement(node) {
+			const filename = context.getFilename?.() ?? "";
+			if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename)) return;
+			if (node.name?.type === "JSXIdentifier" && node.name.name === "HeadContent") hasHeadContentElement = true;
+		},
+		"Program:exit"(programNode) {
+			const filename = context.getFilename?.() ?? "";
+			if (!TANSTACK_ROOT_ROUTE_FILE_PATTERN.test(filename)) return;
+			if (!hasHeadContentElement) context.report({
+				node: programNode,
+				message: "Root route (__root) without <HeadContent /> — route head() meta tags won't render"
+			});
+		}
+	};
+} };
+const tanstackStartNoAnchorElement = { create: (context) => ({ JSXOpeningElement(node) {
+	const filename = context.getFilename?.() ?? "";
+	if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
+	if (node.name?.type !== "JSXIdentifier" || node.name.name !== "a") return;
+	const hrefAttribute = (node.attributes ?? []).find((attribute) => attribute.type === "JSXAttribute" && attribute.name?.type === "JSXIdentifier" && attribute.name.name === "href");
+	if (!hrefAttribute?.value) return;
+	let hrefValue = null;
+	if (hrefAttribute.value.type === "Literal") hrefValue = hrefAttribute.value.value;
+	else if (hrefAttribute.value.type === "JSXExpressionContainer" && hrefAttribute.value.expression?.type === "Literal") hrefValue = hrefAttribute.value.expression.value;
+	if (typeof hrefValue === "string" && hrefValue.startsWith("/")) context.report({
+		node,
+		message: "Use <Link> from @tanstack/react-router instead of <a> for internal navigation — enables type-safe routing and preloading"
+	});
+} }) };
+const tanstackStartServerFnMethodOrder = { create: (context) => ({ CallExpression(node) {
+	if (node.callee?.type !== "MemberExpression") return;
+	const methodNames = [];
+	let currentNode = node;
+	while (currentNode?.type === "CallExpression" && currentNode.callee?.type === "MemberExpression") {
+		const methodName = currentNode.callee.property?.type === "Identifier" ? currentNode.callee.property.name : null;
+		if (methodName) methodNames.unshift(methodName);
+		currentNode = currentNode.callee.object;
+	}
+	if (currentNode?.type === "CallExpression" && currentNode.callee?.type === "Identifier") {
+		if (!TANSTACK_SERVER_FN_NAMES.has(currentNode.callee.name)) return;
+	} else return;
+	const ownMethodName = node.callee.property?.type === "Identifier" ? node.callee.property.name : null;
+	if (methodNames[methodNames.length - 1] !== ownMethodName) return;
+	const orderSensitiveMethods = methodNames.filter((name) => TANSTACK_MIDDLEWARE_METHOD_ORDER.includes(name));
+	let lastIndex = -1;
+	for (const methodName of orderSensitiveMethods) {
+		const currentIndex = TANSTACK_MIDDLEWARE_METHOD_ORDER.indexOf(methodName);
+		if (currentIndex < lastIndex) {
+			const expectedBefore = TANSTACK_MIDDLEWARE_METHOD_ORDER[lastIndex];
+			context.report({
+				node,
+				message: `Server function method .${methodName}() must come before .${expectedBefore}() — wrong order breaks type inference`
+			});
+			return;
+		}
+		lastIndex = currentIndex;
+	}
+} }) };
+const tanstackStartNoNavigateInRender = { create: (context) => {
+	let effectDepth = 0;
+	let eventHandlerDepth = 0;
+	return {
+		CallExpression(node) {
+			const filename = context.getFilename?.() ?? "";
+			if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
+			if (node.callee?.type === "Identifier" && (node.callee.name === "useEffect" || node.callee.name === "useLayoutEffect")) effectDepth++;
+			if (effectDepth > 0 || eventHandlerDepth > 0) return;
+			if (node.callee?.type === "Identifier" && node.callee.name === "navigate" && node.arguments?.length > 0) context.report({
+				node,
+				message: "navigate() called during render — use redirect() in beforeLoad/loader for route-level redirects"
+			});
+		},
+		"CallExpression:exit"(node) {
+			const filename = context.getFilename?.() ?? "";
+			if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
+			if (node.callee?.type === "Identifier" && (node.callee.name === "useEffect" || node.callee.name === "useLayoutEffect")) effectDepth--;
+		},
+		JSXAttribute(node) {
+			const filename = context.getFilename?.() ?? "";
+			if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
+			if (node.name?.type === "JSXIdentifier" && node.name.name.startsWith("on") && UPPERCASE_PATTERN.test(node.name.name.charAt(2))) eventHandlerDepth++;
+		},
+		"JSXAttribute:exit"(node) {
+			const filename = context.getFilename?.() ?? "";
+			if (!TANSTACK_ROUTE_FILE_PATTERN.test(filename)) return;
+			if (node.name?.type === "JSXIdentifier" && node.name.name.startsWith("on") && UPPERCASE_PATTERN.test(node.name.name.charAt(2))) eventHandlerDepth--;
+		}
+	};
+} };
+const tanstackStartNoDynamicServerFnImport = { create: (context) => ({ ImportExpression(node) {
+	const source = node.source;
+	if (!source) return;
+	let importPath = null;
+	if (source.type === "Literal" && typeof source.value === "string") importPath = source.value;
+	else if (source.type === "TemplateLiteral" && source.quasis?.length === 1) importPath = source.quasis[0].value?.raw ?? null;
+	if (importPath && TANSTACK_SERVER_FN_FILE_PATTERN.test(importPath)) context.report({
+		node,
+		message: "Dynamic import of server functions file — use static imports so the bundler can replace server code with RPC stubs"
+	});
+} }) };
+const tanstackStartNoUseServerInHandler = { create: (context) => ({ CallExpression(node) {
+	if (node.callee?.type !== "MemberExpression") return;
+	if (node.callee.property?.type !== "Identifier" || node.callee.property.name !== "handler") return;
+	const handlerFunction = node.arguments?.[0];
+	if (!handlerFunction || handlerFunction.type !== "ArrowFunctionExpression" && handlerFunction.type !== "FunctionExpression") return;
+	const body = handlerFunction.body;
+	if (body?.type !== "BlockStatement") return;
+	if (body.body?.some((statement) => statement.type === "ExpressionStatement" && (statement.directive === "use server" || statement.expression?.type === "Literal" && statement.expression.value === "use server"))) context.report({
+		node: handlerFunction,
+		message: "\"use server\" inside createServerFn handler — TanStack Start handles this automatically, remove the directive"
+	});
+} }) };
+const tanstackStartNoSecretsInLoader = { create: (context) => ({ CallExpression(node) {
+	const optionsObject = getRouteOptionsObject(node);
+	if (!optionsObject) return;
+	const properties = optionsObject.properties ?? [];
+	for (const property of properties) {
+		const keyName = getPropertyKeyName(property);
+		if (keyName !== "loader" && keyName !== "beforeLoad") continue;
+		walkAst(property.value ?? property, (child) => {
+			if (child.type !== "MemberExpression") return;
+			if (child.object?.type === "MemberExpression" && child.object.object?.type === "Identifier" && child.object.object.name === "process" && child.object.property?.type === "Identifier" && child.object.property.name === "env") {
+				const envVarName = child.property?.type === "Identifier" ? child.property.name : null;
+				if (envVarName && !envVarName.startsWith("VITE_")) context.report({
+					node: child,
+					message: `process.env.${envVarName} in ${keyName} — loaders are isomorphic and may leak secrets to the client. Move to a createServerFn()`
+				});
+			}
+		});
+	}
+} }) };
+const tanstackStartGetMutation = { create: (context) => ({ CallExpression(node) {
+	if (node.callee?.type !== "MemberExpression") return;
+	if (node.callee.property?.type !== "Identifier" || node.callee.property.name !== "handler") return;
+	const chainInfo = walkServerFnChain(node);
+	if (!chainInfo.isServerFnChain) return;
+	if (chainInfo.specifiedMethod && MUTATING_HTTP_METHODS.has(chainInfo.specifiedMethod.toUpperCase())) return;
+	const handlerFunction = node.arguments?.[0];
+	if (!handlerFunction) return;
+	const sideEffect = findSideEffect(handlerFunction);
+	if (sideEffect) context.report({
+		node,
+		message: `GET server function has side effects (${sideEffect}) — use createServerFn({ method: 'POST' }) for mutations`
+	});
+} }) };
+const tanstackStartRedirectInTryCatch = { create: (context) => {
+	let tryBlockDepth = 0;
+	let catchClauseDepth = 0;
+	return {
+		TryStatement() {
+			tryBlockDepth++;
+		},
+		"TryStatement:exit"() {
+			tryBlockDepth--;
+		},
+		CatchClause() {
+			catchClauseDepth++;
+		},
+		"CatchClause:exit"() {
+			catchClauseDepth--;
+		},
+		ThrowStatement(node) {
+			if (tryBlockDepth === 0) return;
+			if (catchClauseDepth > 0) return;
+			const argument = node.argument;
+			if (argument?.type !== "CallExpression") return;
+			if (argument.callee?.type !== "Identifier") return;
+			if (!TANSTACK_REDIRECT_FUNCTIONS.has(argument.callee.name)) return;
+			context.report({
+				node,
+				message: `throw ${argument.callee.name}() inside try block — the router catches this internally. Move it outside the try block or re-throw in the catch`
+			});
+		}
+	};
+} };
+const hasTopLevelAwait = (statement) => {
+	if (statement.type === "VariableDeclaration") return statement.declarations?.some((declarator) => declarator.init?.type === "AwaitExpression");
+	if (statement.type === "ExpressionStatement") return statement.expression?.type === "AwaitExpression" || statement.expression?.type === "AssignmentExpression" && statement.expression.right?.type === "AwaitExpression";
+	if (statement.type === "ReturnStatement") return statement.argument?.type === "AwaitExpression";
+	return false;
+};
+const tanstackStartLoaderParallelFetch = { create: (context) => ({ CallExpression(node) {
+	const optionsObject = getRouteOptionsObject(node);
+	if (!optionsObject) return;
+	const properties = optionsObject.properties ?? [];
+	for (const property of properties) {
+		if (getPropertyKeyName(property) !== "loader") continue;
+		const loaderValue = property.value;
+		if (!loaderValue || loaderValue.type !== "ArrowFunctionExpression" && loaderValue.type !== "FunctionExpression") continue;
+		const functionBody = loaderValue.body;
+		if (!functionBody || functionBody.type !== "BlockStatement") continue;
+		let sequentialAwaitCount = 0;
+		for (const statement of functionBody.body ?? []) {
+			if (hasTopLevelAwait(statement)) sequentialAwaitCount++;
+			if (sequentialAwaitCount >= SEQUENTIAL_AWAIT_THRESHOLD_FOR_LOADER) {
+				context.report({
+					node: property,
+					message: "Multiple sequential awaits in loader — use Promise.all() to fetch data in parallel and avoid waterfalls"
+				});
+				break;
+			}
+		}
+	}
+} }) };
+
 //#endregion
 //#region src/plugin/rules/state-and-effects.ts
 const noDerivedStateEffect = { create: (context) => ({ CallExpression(node) {
@@ -1700,6 +2229,7 @@ const plugin = {
 		"rendering-animate-svg-wrapper": renderingAnimateSvgWrapper,
 		"no-inline-prop-on-memo-component": noInlinePropOnMemoComponent,
 		"rendering-hydration-no-flicker": renderingHydrationNoFlicker,
+		"rendering-script-defer-async": renderingScriptDeferAsync,
 		"no-transition-all": noTransitionAll,
 		"no-global-css-variable-animation": noGlobalCssVariableAnimation,
 		"no-large-animated-blur": noLargeAnimatedBlur,
@@ -1744,6 +2274,7 @@ const plugin = {
 		"js-index-maps": jsIndexMaps,
 		"js-cache-storage": jsCacheStorage,
 		"js-early-exit": jsEarlyExit,
+		"js-flatmap-filter": jsFlatmapFilter,
 		"async-parallel": asyncParallel,
 		"rn-no-raw-text": rnNoRawText,
 		"rn-no-deprecated-modules": rnNoDeprecatedModules,
@@ -1752,7 +2283,27 @@ const plugin = {
 		"rn-no-inline-flatlist-renderitem": rnNoInlineFlatlistRenderitem,
 		"rn-no-legacy-shadow-styles": rnNoLegacyShadowStyles,
 		"rn-prefer-reanimated": rnPreferReanimated,
-		"rn-no-single-element-style-array": rnNoSingleElementStyleArray
+		"rn-no-single-element-style-array": rnNoSingleElementStyleArray,
+		"tanstack-start-route-property-order": tanstackStartRoutePropertyOrder,
+		"tanstack-start-no-direct-fetch-in-loader": tanstackStartNoDirectFetchInLoader,
+		"tanstack-start-server-fn-validate-input": tanstackStartServerFnValidateInput,
+		"tanstack-start-no-useeffect-fetch": tanstackStartNoUseEffectFetch,
+		"tanstack-start-missing-head-content": tanstackStartMissingHeadContent,
+		"tanstack-start-no-anchor-element": tanstackStartNoAnchorElement,
+		"tanstack-start-server-fn-method-order": tanstackStartServerFnMethodOrder,
+		"tanstack-start-no-navigate-in-render": tanstackStartNoNavigateInRender,
+		"tanstack-start-no-dynamic-server-fn-import": tanstackStartNoDynamicServerFnImport,
+		"tanstack-start-no-use-server-in-handler": tanstackStartNoUseServerInHandler,
+		"tanstack-start-no-secrets-in-loader": tanstackStartNoSecretsInLoader,
+		"tanstack-start-get-mutation": tanstackStartGetMutation,
+		"tanstack-start-redirect-in-try-catch": tanstackStartRedirectInTryCatch,
+		"tanstack-start-loader-parallel-fetch": tanstackStartLoaderParallelFetch,
+		"query-stable-query-client": queryStableQueryClient,
+		"query-no-rest-destructuring": queryNoRestDestructuring,
+		"query-no-void-query-fn": queryNoVoidQueryFn,
+		"query-no-query-in-effect": queryNoQueryInEffect,
+		"query-mutation-missing-invalidation": queryMutationMissingInvalidation,
+		"query-no-usequery-for-mutation": queryNoUseQueryForMutation
 	}
 };