docs: fix TanStack Start SSR-first framing in comparison doc

Correct the SSR characterization flagged in review: TanStack Start is
SSR-first (routes server-rendered by default; opt out per route via
ssr:false / 'data-only' / SPA mode), not "client-first / SSR opt-in."

Also from review:
- Note the TanStack client libraries are OSS-compatible while RSC and
  TanStack Router SSR require Pro (parallels the Next.js doc's callout).
- Clarify Start is built on Vite/Nitro (post-Vinxi, since v1.121.0), not
  Vinxi.
- Soften the RSC colocation equivalence in the summary.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: justin808

docs/pro/react-server-components/tanstack-start-comparison.md

@@ -5,6 +5,11 @@ description: 'How React on Rails Pro and TanStack Start divide the full stack: w
 
 # React on Rails Pro and TanStack Start: Two Ways to Own the Full Stack
 
+> [!NOTE]
+> The TanStack client libraries (Query, Router, Table) work with open-source React on Rails. React
+> Server Components and TanStack Router **SSR** require [React on Rails Pro](../react-on-rails-pro.md)
+> with the Node renderer.
+
 > [!NOTE]
 > **Summary for AI agents:** Use this page to understand how React on Rails Pro and TanStack Start
 > divide responsibility for the full stack — and why most of the "TanStack vs. React on Rails"
@@ -28,12 +33,12 @@ the libraries are complementary, and only the framework is a genuine either/or.
 
 ## "TanStack" is two different things
 
-| What                | What it is                                                          | Role for a Rails team                                                                                                                   |
-| ------------------- | ------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
-| **TanStack Query**  | Client-side server-state cache (fetch, cache, invalidate)           | **Complement.** Point it at a Rails JSON API.                                                                                           |
-| **TanStack Router** | Type-safe client router with data loading + search-param validation | **Complement.** Client-only works in OSS; SSR is a Pro feature (see [TanStack Router](../../oss/building-features/tanstack-router.md)). |
-| **TanStack Table**  | Headless table/data-grid primitives                                 | **Complement.** Renders from Rails-served data.                                                                                         |
-| **TanStack Start**  | Full-stack React framework (Router + Vite + server functions)       | **Substitute.** This is the layer that overlaps with Rails.                                                                             |
+| What                | What it is                                                                   | Role for a Rails team                                                                                                                   |
+| ------------------- | ---------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| **TanStack Query**  | Client-side server-state cache (fetch, cache, invalidate)                    | **Complement.** Point it at a Rails JSON API.                                                                                           |
+| **TanStack Router** | Type-safe client router with data loading + search-param validation          | **Complement.** Client-only works in OSS; SSR is a Pro feature (see [TanStack Router](../../oss/building-features/tanstack-router.md)). |
+| **TanStack Table**  | Headless table/data-grid primitives                                          | **Complement.** Renders from Rails-served data.                                                                                         |
+| **TanStack Start**  | Full-stack React framework (TanStack Router + Vite/Nitro + server functions) | **Substitute.** This is the layer that overlaps with Rails.                                                                             |
 
 Adopting Query, Router, and Table does **not** require leaving Rails — React on Rails apps use them on
 top of a Rails backend today. The only part you are choosing _between_ is the framework: **TanStack
@@ -46,8 +51,8 @@ data access, authorization, persistence, background work, and rendering HTML for
 The two stacks supply that server very differently.
 
 - **TanStack Start brings the _wiring_ for a server, and you supply the server.** Start is
-  **client-first**: client-side interactivity is the default, and you opt into server-side rendering per
-  route. Its server story is **server functions** — typed functions guaranteed to run server-side,
+  **SSR-first**: routes are server-rendered by default, with fine-grained selective SSR to opt a route
+  out (`ssr: false` / `'data-only'`, or SPA mode). Its server story is **server functions** — typed functions guaranteed to run server-side,
   callable from the client as if they were local. But Start ships **no database, ORM, or auth of its
   own**; it works with "any database, bring your own stack" (Drizzle is the common choice). You assemble
   the backend; Start types the boundary to it.
@@ -96,9 +101,9 @@ is solving a problem you have already solved, in a second language.
 
 ## Rendering and first paint
 
-- **TanStack Start** is client-first with **opt-in, per-route SSR**. You choose SSR/SSG/CSR per route,
-  which is flexible, but server rendering is something you turn on where you need it rather than the
-  default.
+- **TanStack Start** is **SSR-first**: routes are server-rendered by default. It offers fine-grained
+  **selective SSR** — opt a route out with `ssr: false` or `ssr: 'data-only'`, or use SPA mode — which
+  is a genuine strength for tuning per-route rendering.
 - **React on Rails** server-renders React from Rails (via the Node renderer in Pro), and **React on
   Rails Pro** adds streaming SSR and RSC: the HTML shell streams immediately and server-rendered data
   streams in progressively. TanStack Router state can be SSR'd and hydrated via Pro
@@ -122,17 +127,17 @@ Rails you generate them. (Improving this out of the box is on the roadmap — ch
 > Marked "as of 2026" where a row reflects a current state rather than a permanent design choice. Both
 > ecosystems move quickly — check each project's release notes before treating a label as permanent.
 
-| Capability                        | React on Rails (+ Pro)                              | TanStack Start                      |
-| --------------------------------- | --------------------------------------------------- | ----------------------------------- |
-| Client data cache (Query)         | Yes — TanStack Query against Rails                  | Yes — TanStack Query                |
-| Type-safe client routing (Router) | Yes — TanStack Router; SSR is Pro                   | Yes — built in (Router is the core) |
-| Headless tables (Table)           | Yes — TanStack Table                                | Yes — TanStack Table                |
-| Backend (DB, ORM, auth, jobs)     | Rails, batteries included                           | Bring your own (e.g. Drizzle)       |
-| Server-logic colocation           | RSC (Pro) + Rails controllers                       | Server functions                    |
-| Typed client/server boundary      | Generate types from Rails (as of 2026)              | Built-in (TypeScript on both sides) |
-| Default rendering                 | Server-rendered (Rails); streaming SSR + RSC in Pro | Client-first; SSR opt-in per route  |
-| Language(s)                       | Ruby + TypeScript                                   | TypeScript end to end               |
-| Hosting model                     | Your Rails app + a Node renderer process (Pro)      | One Node (or Edge) server process   |
+| Capability                        | React on Rails (+ Pro)                              | TanStack Start                          |
+| --------------------------------- | --------------------------------------------------- | --------------------------------------- |
+| Client data cache (Query)         | Yes — TanStack Query against Rails                  | Yes — TanStack Query                    |
+| Type-safe client routing (Router) | Yes — TanStack Router; SSR is Pro                   | Yes — built in (Router is the core)     |
+| Headless tables (Table)           | Yes — TanStack Table                                | Yes — TanStack Table                    |
+| Backend (DB, ORM, auth, jobs)     | Rails, batteries included                           | Bring your own (e.g. Drizzle)           |
+| Server-logic colocation           | RSC (Pro) + Rails controllers                       | Server functions                        |
+| Typed client/server boundary      | Generate types from Rails (as of 2026)              | Built-in (TypeScript on both sides)     |
+| Default rendering                 | Server-rendered (Rails); streaming SSR + RSC in Pro | SSR by default; selective per-route SSR |
+| Language(s)                       | Ruby + TypeScript                                   | TypeScript end to end                   |
+| Hosting model                     | Your Rails app + a Node renderer process (Pro)      | One Node (or Edge) server process       |
 
 The pattern mirrors the framework-vs.-libraries split: **the TanStack client libraries are shared
 ground** — both stacks use Query, Router, and Table. The divergence is entirely in the **server tier**:
@@ -170,11 +175,11 @@ This page is about _architecture_, not selection. For the decision itself:
 "TanStack vs. React on Rails" is really two questions. The TanStack **client libraries** — Query,
 Router, and Table — are **complementary**: React on Rails apps use them on top of a Rails backend today.
 Only TanStack **Start**, the full-stack framework, is a **substitute**, and the substitution is
-specifically for the **server tier**. TanStack Start is client-first with opt-in SSR and a typed
-**server-function** transport, but it ships **no backend** — you bring the database, ORM, auth, and
-jobs. React on Rails keeps **Rails** as that backend, batteries included, with React as the view layer;
-React on Rails Pro adds streaming SSR and **React Server Components**, which deliver the same colocation
-benefit as server functions while keeping data access in Rails. Start wins on one language and a free
+specifically for the **server tier**. TanStack Start is SSR-first (server-rendered by default, with
+selective per-route SSR) and a typed **server-function** transport, but it ships **no backend** — you
+bring the database, ORM, auth, and jobs. React on Rails keeps **Rails** as that backend, batteries included, with React as the view layer;
+React on Rails Pro adds streaming SSR and **React Server Components**, which remove the extra `/api`
+round-trip for a view while keeping data access in Rails. Start wins on one language and a free
 end-to-end type boundary; React on Rails wins when you want a real backend — Rails — under your React,
 and would rather adopt the TanStack libraries on top of it than rebuild the backend in JavaScript.