TanStack Start & Router SSR: Type-Safe Search Params, Loaders, and Streaming Invariants

--- description: TanStack Start & Router SSR: Type-Safe Search Params, Loaders, and Streaming Invariants - Enforces strict type safety for search params via validation schemas, prohibits blocking SSR waterfalls by mandating deferred promise streaming for non-critical assets, and eliminates hydration mismatches in TanStack Start full-stack routes. Guarantees zero runtime search parameter divergence and deterministic server-side rendering execution. globs: app/**/*.{ts,tsx}, src/routes/**/*.{ts,tsx}, src/router/**/*.{ts,tsx} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tanstack-start-router-ssr-invariants" --- # TanStack Start & Router SSR: Type-Safe Search Params, Loaders, and Streaming Invariants > **Severity**: CRITICAL | **Category**: frontend > **Anti-Pattern Warning**: Unvalidated search params, blocking data waterfalls in SSR loaders, and raw client-side state reads during initial hydration. ## System Constraints You are a Principal Software Architect enforcing production invariants for TanStack Start and TanStack Router full-stack SSR applications. You must enforce runtime schema validation using Zod/Valibot for all route search params via `validateSearch`, ensure critical above-the-fold data is awaited while secondary data is deferred via `defer()` to preserve fast TTFB, mandate `createServerFn` usage for server-only RPC logic, and guarantee hydration safety across all route loaders and components. ## Strict Guidelines - Routes with search parameters MUST ALWAYS define `validateSearch` using a strict validator (e.g., Zod, Valibot) and return clean, fallback-safe types. - Route `loader` functions MUST NOT await secondary or non-critical data; they MUST use `defer()` to stream promises and render Suspense boundaries on the client. - Route loaders MUST ONLY interact with backend services via `createServerFn` to guarantee server/client code isolation and tree-shaking of private keys. - Components consuming deferred data MUST wrap consumers in `Await` and React `Suspense` with explicit fallback states. - Components MUST NEVER access browser-only globals (like `window.location`, `localStorage`, or `document`) during loader execution or initial component evaluation prior to `useEffect`. - Route definitions MUST use the `createFileRoute` API for file-based routing or `createRoute` for code-based routing, retaining the strictly typed context throughout child routes. ## Bad vs Good Implementations ### Type-Safe Search Parameters and Deferred Streaming Loader #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Untyped search parameters bypass runtime parsing and introduce security/type vulnerabilities. Awaiting `fetchSlowAnalytics` blocks SSR time-to-first-byte (TTFB), degrading performance and preventing progressive streaming. ```typescript import { createFileRoute } from '@tanstack/react-router'; // ANTI-PATTERN: Raw search params, blocking all rendering until slow metrics resolve export const Route = createFileRoute('/dashboard')({ loader: async ({ search }: { search: any }) => { const page = search.page || 1; // Blocking the entire SSR response for slow analytics const user = await fetchUser(); const analytics = await fetchSlowAnalytics(page); return { user, analytics, page }; }, component: DashboardComponent, }); function DashboardComponent() { const { user, analytics } = Route.useLoaderData(); return ( <div> <h1>Welcome, {user.name}</h1> <div>{analytics.totalViews} views</div> </div> ); } ``` #### Production Standard (Correct) > **Standard**: Validates search params via Zod with fallbacks, uses `createServerFn` for secure server execution, resolves critical user data before SSR streaming, and defers slow analytics wrapped in `defer` and `<Await>` to achieve optimal TTFB. ```typescript import { createFileRoute, defer, Await } from '@tanstack/react-router'; import { createServerFn } from '@tanstack/start'; import { Suspense } from 'react'; import { z } from 'zod'; const dashboardSearchSchema = z.object({ page: z.number().catch(1), filter: z.string().optional(), }); const fetchUserServerFn = createServerFn({ method: 'GET' }).handler(async () => { return fetchUser(); }); const fetchAnalyticsServerFn = createServerFn({ method: 'GET' }) .validator((d: number) => d) .handler(async ({ data: page }) => { return fetchSlowAnalytics(page); }); export const Route = createFileRoute('/dashboard')({ validateSearch: (search) => dashboardSearchSchema.parse(search), loaderDeps: ({ search: { page } }) => ({ page }), loader: async ({ deps: { page } }) => { // Critical above-the-fold data awaited for immediate SSR const user = await fetchUserServerFn(); // Slow non-critical data deferred for HTTP streaming const analyticsPromise = fetchAnalyticsServerFn({ data: page }); return { user, deferredAnalytics: defer(analyticsPromise), }; }, component: DashboardComponent, }); function DashboardComponent() { const { user, deferredAnalytics } = Route.useLoaderData(); return ( <main> <h1>Welcome, {user.name}</h1> <Suspense fallback={<div>Loading analytics...</div>}> <Await promise={deferredAnalytics}> {(analytics) => <div>{analytics.totalViews} views</div>} </Await> </Suspense> </main> ); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: TanStack Start & Router SSR: Type-Safe Search Params, Loaders, and Streaming Invariants

TanStack Start & Router SSR: Type-Safe Search Params, Loaders, and Streaming Invariants defines an industrial-grade behavioral standard for frontend engineering. Enforces strict type safety for search params via validation schemas, prohibits blocking SSR waterfalls by mandating deferred promise streaming for non-critical assets, and eliminates hydration mismatches in TanStack Start full-stack routes. Guarantees zero runtime search parameter divergence and deterministic server-side rendering execution. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: Unvalidated search params, blocking data waterfalls in SSR loaders, and raw client-side state reads during initial hydration. Without an explicit system instruction file, developers spend hours debugging silent failures.

Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure Mode	AI Symptom (The Anti-Pattern)	Severity	Production Impact & Remedy
AI Hallucination & Deprecation Drift	Unvalidated search params, blocking data waterfalls in SSR loaders, and raw client-side state reads during initial hydration.	Critical	Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production. Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture Inconsistency	AI assistants produce mixed paradigms across files, creating fragmented codebase conventions.	Medium	Increases cognitive load during code reviews and leads to maintenance debt across engineering teams. Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.

Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

Routes with search parameters MUST ALWAYS define `validateSearch` using a strict validator (e.g., Zod, Valibot) and return clean, fallback-safe types.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.