diff --git a/.changeset/quiet-ssr-hotspots.md b/.changeset/quiet-ssr-hotspots.md
new file mode 100644
index 0000000000..aa2278fb19
--- /dev/null
+++ b/.changeset/quiet-ssr-hotspots.md
@@ -0,0 +1,6 @@
+---
+'@tanstack/router-core': patch
+'@tanstack/start-plugin-core': patch
+---
+
+Reduce per-request SSR overhead: abort settled route matches with one shared `AbortError`-shaped reason instead of building a stack-capturing `DOMException` per match, skip `JSON.parse` for search values that cannot start JSON, wait on request signals with one listener per wait, and keep resolved server-function modules in production builds instead of re-importing them on every call.
diff --git a/.changeset/steady-streams-flow.md b/.changeset/steady-streams-flow.md
new file mode 100644
index 0000000000..de779b8c95
--- /dev/null
+++ b/.changeset/steady-streams-flow.md
@@ -0,0 +1,35 @@
+---
+'@tanstack/router-core': patch
+'@tanstack/router-ssr-query-core': patch
+'@tanstack/react-router': patch
+'@tanstack/react-router-ssr-query': patch
+'@tanstack/solid-router': patch
+'@tanstack/solid-router-ssr-query': patch
+'@tanstack/solid-start-server': patch
+'@tanstack/start-client-core': patch
+'@tanstack/start-server-core': patch
+'@tanstack/start-static-server-functions': patch
+'@tanstack/vue-router': patch
+'@tanstack/vue-router-ssr-query': patch
+'@tanstack/vue-start-server': patch
+---
+
+Stream large deferred SSR hydration payloads through a backpressure-aware router transport, fail known setup errors before response creation, and close cancelled or expired transforms safely.
+
+Start now cancels discarded middleware and HEAD response bodies, including plain streams and derived branches.
+
+Server-function raw streams share one ordered response. Arbitrary or sequential consumption can require potentially unbounded buffering of unread data on the client. Cancelling one raw stream discards it locally, while aborting the whole call cancels the response and server work. Consume streams concurrently, cancel unused streams promptly, or use separate calls when independent backpressure is required. A raw stream that exceeds its unread-byte limit now fails alone; sibling streams and the JSON result keep flowing.
+
+The JSON wire shape of a `RawStream` server-function argument changed. Clients and servers must run matching versions for requests that pass a `RawStream`.
+
+The frame-protocol constants (`FRAME_TYPE_*`, `MAX_FRAME_PAYLOAD_SIZE`, `MAX_FRAMED_STREAMS`) moved from the `@tanstack/start-client-core` root to the `@tanstack/start-client-core/client-rpc` subpath.
+
+Router requests whose `Accept` header allows neither `text/html` nor `*/*` now receive `406 Not Acceptable` instead of `500`.
+
+Framework adapters share the body `` composition (`getSsrBodyScriptParts`, `composeSsrBodyScripts`) and the eager HTML response wrapper (`renderSsrHtmlResponse`) from `@tanstack/router-core`.
+
+Solid SSR now emits one document type and renders late lazy errors through route boundaries. A Solid `` without a `fallback` no longer holds the streamed shell; it renders inside the nearest `` boundary like React and Vue, and now renders falsy resolved values.
+
+Static server functions decode cached `RawStream` values with the client deserializer plugins.
+
+SSR Query integrations now keep request cleanup and stream ownership aligned with the router lifecycle.
diff --git a/benchmarks/ssr/scenarios/control-flow/vue/src/routeTree.gen.ts b/benchmarks/ssr/scenarios/control-flow/vue/src/routeTree.gen.ts
index f5063d1c09..6dcf0d095e 100644
--- a/benchmarks/ssr/scenarios/control-flow/vue/src/routeTree.gen.ts
+++ b/benchmarks/ssr/scenarios/control-flow/vue/src/routeTree.gen.ts
@@ -10,30 +10,20 @@
import { Route as rootRouteImport } from './routes/__root'
import { Route as IndexRouteImport } from './routes/index'
-import { Route as TargetIdRouteImport } from './routes/target.$id'
-import { Route as MissingIdRouteImport } from './routes/missing.$id'
-import { Route as HeadersIdRouteImport } from './routes/headers.$id'
-import { Route as FromIdRouteImport } from './routes/from.$id'
import { Route as BoomIdRouteImport } from './routes/boom.$id'
+import { Route as FromIdRouteImport } from './routes/from.$id'
+import { Route as HeadersIdRouteImport } from './routes/headers.$id'
+import { Route as MissingIdRouteImport } from './routes/missing.$id'
+import { Route as TargetIdRouteImport } from './routes/target.$id'
const IndexRoute = IndexRouteImport.update({
id: '/',
path: '/',
getParentRoute: () => rootRouteImport,
} as any)
-const TargetIdRoute = TargetIdRouteImport.update({
- id: '/target/$id',
- path: '/target/$id',
- getParentRoute: () => rootRouteImport,
-} as any)
-const MissingIdRoute = MissingIdRouteImport.update({
- id: '/missing/$id',
- path: '/missing/$id',
- getParentRoute: () => rootRouteImport,
-} as any)
-const HeadersIdRoute = HeadersIdRouteImport.update({
- id: '/headers/$id',
- path: '/headers/$id',
+const BoomIdRoute = BoomIdRouteImport.update({
+ id: '/boom/$id',
+ path: '/boom/$id',
getParentRoute: () => rootRouteImport,
} as any)
const FromIdRoute = FromIdRouteImport.update({
@@ -41,9 +31,19 @@ const FromIdRoute = FromIdRouteImport.update({
path: '/from/$id',
getParentRoute: () => rootRouteImport,
} as any)
-const BoomIdRoute = BoomIdRouteImport.update({
- id: '/boom/$id',
- path: '/boom/$id',
+const HeadersIdRoute = HeadersIdRouteImport.update({
+ id: '/headers/$id',
+ path: '/headers/$id',
+ getParentRoute: () => rootRouteImport,
+} as any)
+const MissingIdRoute = MissingIdRouteImport.update({
+ id: '/missing/$id',
+ path: '/missing/$id',
+ getParentRoute: () => rootRouteImport,
+} as any)
+const TargetIdRoute = TargetIdRouteImport.update({
+ id: '/target/$id',
+ path: '/target/$id',
getParentRoute: () => rootRouteImport,
} as any)
@@ -117,25 +117,11 @@ declare module '@tanstack/vue-router' {
preLoaderRoute: typeof IndexRouteImport
parentRoute: typeof rootRouteImport
}
- '/target/$id': {
- id: '/target/$id'
- path: '/target/$id'
- fullPath: '/target/$id'
- preLoaderRoute: typeof TargetIdRouteImport
- parentRoute: typeof rootRouteImport
- }
- '/missing/$id': {
- id: '/missing/$id'
- path: '/missing/$id'
- fullPath: '/missing/$id'
- preLoaderRoute: typeof MissingIdRouteImport
- parentRoute: typeof rootRouteImport
- }
- '/headers/$id': {
- id: '/headers/$id'
- path: '/headers/$id'
- fullPath: '/headers/$id'
- preLoaderRoute: typeof HeadersIdRouteImport
+ '/boom/$id': {
+ id: '/boom/$id'
+ path: '/boom/$id'
+ fullPath: '/boom/$id'
+ preLoaderRoute: typeof BoomIdRouteImport
parentRoute: typeof rootRouteImport
}
'/from/$id': {
@@ -145,11 +131,25 @@ declare module '@tanstack/vue-router' {
preLoaderRoute: typeof FromIdRouteImport
parentRoute: typeof rootRouteImport
}
- '/boom/$id': {
- id: '/boom/$id'
- path: '/boom/$id'
- fullPath: '/boom/$id'
- preLoaderRoute: typeof BoomIdRouteImport
+ '/headers/$id': {
+ id: '/headers/$id'
+ path: '/headers/$id'
+ fullPath: '/headers/$id'
+ preLoaderRoute: typeof HeadersIdRouteImport
+ parentRoute: typeof rootRouteImport
+ }
+ '/missing/$id': {
+ id: '/missing/$id'
+ path: '/missing/$id'
+ fullPath: '/missing/$id'
+ preLoaderRoute: typeof MissingIdRouteImport
+ parentRoute: typeof rootRouteImport
+ }
+ '/target/$id': {
+ id: '/target/$id'
+ path: '/target/$id'
+ fullPath: '/target/$id'
+ preLoaderRoute: typeof TargetIdRouteImport
parentRoute: typeof rootRouteImport
}
}
diff --git a/benchmarks/ssr/scenarios/global-middleware/bench.ts b/benchmarks/ssr/scenarios/global-middleware/bench.ts
index a89d03cabb..d2784aed38 100644
--- a/benchmarks/ssr/scenarios/global-middleware/bench.ts
+++ b/benchmarks/ssr/scenarios/global-middleware/bench.ts
@@ -7,10 +7,13 @@ import {
import {
expectedFunctionTotal,
expectedRequestTotal,
+ getExpectedRequestContext,
makeDocumentMarker,
makeServerFnMarker,
makeServerRouteMarker,
+ setRequestMiddlewareCount,
} from './shared'
+import type { RequestMiddlewareCount } from './shared'
import type { StartRequestHandler } from '../../bench-utils'
export type { StartRequestHandler }
@@ -140,6 +143,7 @@ function buildPostRequest(urls: FnUrls, bodies: Array, index: number) {
export async function setupGlobalMiddlewareBench(
handler: StartRequestHandler,
): Promise {
+ setRequestMiddlewareCount(3)
const urls = await discoverUrls(handler)
const payloads = createPayloads()
const bodies = await createBodies(payloads)
@@ -154,6 +158,7 @@ export async function setupGlobalMiddlewareBench(
}
async function assertDocumentResponse(handler: StartRequestHandler) {
+ setRequestMiddlewareCount(3)
const id = 'page-sanity'
const response = await handler.fetch(
new Request(`${origin}/page/${id}`, documentRequestInit),
@@ -175,7 +180,11 @@ async function assertDocumentResponse(handler: StartRequestHandler) {
}
}
-async function assertServerRouteResponse(handler: StartRequestHandler) {
+async function assertServerRouteResponseForCount(
+ handler: StartRequestHandler,
+ count: RequestMiddlewareCount,
+) {
+ setRequestMiddlewareCount(count)
const id = 'route-sanity'
const response = await handler.fetch(
new Request(`${origin}/api/ping/${id}`, apiRequestInit),
@@ -199,10 +208,8 @@ async function assertServerRouteResponse(handler: StartRequestHandler) {
marker?: string
requestTotal?: number
}
- const expectedMarker = makeServerRouteMarker(id, {
- requestTrace: 'req.r1.r2.r3',
- requestTotal: expectedRequestTotal,
- })
+ const expectedContext = getExpectedRequestContext(count)
+ const expectedMarker = makeServerRouteMarker(id, expectedContext)
if (body.marker !== expectedMarker) {
throw new Error(
@@ -210,9 +217,9 @@ async function assertServerRouteResponse(handler: StartRequestHandler) {
)
}
- if (body.requestTotal !== expectedRequestTotal) {
+ if (body.requestTotal !== expectedContext.requestTotal) {
throw new Error(
- `Expected server route requestTotal ${expectedRequestTotal}, received ${body.requestTotal}`,
+ `Expected server route requestTotal ${expectedContext.requestTotal}, received ${body.requestTotal}`,
)
}
}
@@ -221,6 +228,7 @@ async function assertServerFnResponse(
handler: StartRequestHandler,
context: GlobalMiddlewareBenchContext,
) {
+ setRequestMiddlewareCount(3)
const response = await handler.fetch(
buildPostRequest(context.urls, context.bodies, 0),
)
@@ -257,10 +265,14 @@ export async function assertGlobalMiddlewareScenario(
) {
await assertDocumentResponse(handler)
await assertServerFnResponse(handler, context)
- await assertServerRouteResponse(handler)
+ for (const count of [0, 1, 2, 3] as const) {
+ await assertServerRouteResponseForCount(handler, count)
+ }
+ setRequestMiddlewareCount(3)
}
export function runGlobalMiddlewareDocumentLoop(handler: StartRequestHandler) {
+ setRequestMiddlewareCount(3)
return runRequestLoop(handler, {
seed: benchmarkSeed,
concurrency: 16,
@@ -273,6 +285,7 @@ export function runGlobalMiddlewareServerFnLoop(
handler: StartRequestHandler,
context: GlobalMiddlewareBenchContext,
) {
+ setRequestMiddlewareCount(3)
return runRequestLoop(handler, {
seed: benchmarkSeed,
concurrency: 16,
@@ -284,7 +297,9 @@ export function runGlobalMiddlewareServerFnLoop(
export function runGlobalMiddlewareServerRouteLoop(
handler: StartRequestHandler,
+ count: RequestMiddlewareCount = 3,
) {
+ setRequestMiddlewareCount(count)
return runRequestLoop(handler, {
seed: benchmarkSeed,
concurrency: 16,
diff --git a/benchmarks/ssr/scenarios/global-middleware/react/speed.global-mw-server-route-0-middleware.bench.ts b/benchmarks/ssr/scenarios/global-middleware/react/speed.global-mw-server-route-0-middleware.bench.ts
new file mode 100644
index 0000000000..2a784ec987
--- /dev/null
+++ b/benchmarks/ssr/scenarios/global-middleware/react/speed.global-mw-server-route-0-middleware.bench.ts
@@ -0,0 +1,27 @@
+import { bench, describe } from 'vitest'
+import {
+ assertGlobalMiddlewareScenario,
+ globalMiddlewareBenchOptions,
+ runGlobalMiddlewareServerRouteLoop,
+ setupGlobalMiddlewareBench,
+} from '../bench'
+import type { StartRequestHandler } from '../bench'
+
+const appModuleUrl = new URL('./dist/server/server.js', import.meta.url).href
+
+const { default: handler } = (await import(
+ /* @vite-ignore */ appModuleUrl
+)) as {
+ default: StartRequestHandler
+}
+const context = await setupGlobalMiddlewareBench(handler)
+
+await assertGlobalMiddlewareScenario(handler, context)
+
+describe('ssr', () => {
+ bench(
+ 'ssr global-mw server-route 0 middleware (react)',
+ () => runGlobalMiddlewareServerRouteLoop(handler, 0),
+ globalMiddlewareBenchOptions,
+ )
+})
diff --git a/benchmarks/ssr/scenarios/global-middleware/react/speed.global-mw-server-route-1-middleware.bench.ts b/benchmarks/ssr/scenarios/global-middleware/react/speed.global-mw-server-route-1-middleware.bench.ts
new file mode 100644
index 0000000000..64e18cfe61
--- /dev/null
+++ b/benchmarks/ssr/scenarios/global-middleware/react/speed.global-mw-server-route-1-middleware.bench.ts
@@ -0,0 +1,27 @@
+import { bench, describe } from 'vitest'
+import {
+ assertGlobalMiddlewareScenario,
+ globalMiddlewareBenchOptions,
+ runGlobalMiddlewareServerRouteLoop,
+ setupGlobalMiddlewareBench,
+} from '../bench'
+import type { StartRequestHandler } from '../bench'
+
+const appModuleUrl = new URL('./dist/server/server.js', import.meta.url).href
+
+const { default: handler } = (await import(
+ /* @vite-ignore */ appModuleUrl
+)) as {
+ default: StartRequestHandler
+}
+const context = await setupGlobalMiddlewareBench(handler)
+
+await assertGlobalMiddlewareScenario(handler, context)
+
+describe('ssr', () => {
+ bench(
+ 'ssr global-mw server-route 1 middleware (react)',
+ () => runGlobalMiddlewareServerRouteLoop(handler, 1),
+ globalMiddlewareBenchOptions,
+ )
+})
diff --git a/benchmarks/ssr/scenarios/global-middleware/react/speed.global-mw-server-route-2-middleware.bench.ts b/benchmarks/ssr/scenarios/global-middleware/react/speed.global-mw-server-route-2-middleware.bench.ts
new file mode 100644
index 0000000000..4418f0867e
--- /dev/null
+++ b/benchmarks/ssr/scenarios/global-middleware/react/speed.global-mw-server-route-2-middleware.bench.ts
@@ -0,0 +1,27 @@
+import { bench, describe } from 'vitest'
+import {
+ assertGlobalMiddlewareScenario,
+ globalMiddlewareBenchOptions,
+ runGlobalMiddlewareServerRouteLoop,
+ setupGlobalMiddlewareBench,
+} from '../bench'
+import type { StartRequestHandler } from '../bench'
+
+const appModuleUrl = new URL('./dist/server/server.js', import.meta.url).href
+
+const { default: handler } = (await import(
+ /* @vite-ignore */ appModuleUrl
+)) as {
+ default: StartRequestHandler
+}
+const context = await setupGlobalMiddlewareBench(handler)
+
+await assertGlobalMiddlewareScenario(handler, context)
+
+describe('ssr', () => {
+ bench(
+ 'ssr global-mw server-route 2 middlewares (react)',
+ () => runGlobalMiddlewareServerRouteLoop(handler, 2),
+ globalMiddlewareBenchOptions,
+ )
+})
diff --git a/benchmarks/ssr/scenarios/global-middleware/react/speed.global-mw-server-route.bench.ts b/benchmarks/ssr/scenarios/global-middleware/react/speed.global-mw-server-route.bench.ts
index 9dc19cf943..189f3b7ef6 100644
--- a/benchmarks/ssr/scenarios/global-middleware/react/speed.global-mw-server-route.bench.ts
+++ b/benchmarks/ssr/scenarios/global-middleware/react/speed.global-mw-server-route.bench.ts
@@ -20,8 +20,8 @@ await assertGlobalMiddlewareScenario(handler, context)
describe('ssr', () => {
bench(
- 'ssr global-mw server-route (react)',
- () => runGlobalMiddlewareServerRouteLoop(handler),
+ 'ssr global-mw server-route 3 middlewares (react)',
+ () => runGlobalMiddlewareServerRouteLoop(handler, 3),
globalMiddlewareBenchOptions,
)
})
diff --git a/benchmarks/ssr/scenarios/global-middleware/react/src/start.ts b/benchmarks/ssr/scenarios/global-middleware/react/src/start.ts
index 6b59e8035b..8dfb2dd3c4 100644
--- a/benchmarks/ssr/scenarios/global-middleware/react/src/start.ts
+++ b/benchmarks/ssr/scenarios/global-middleware/react/src/start.ts
@@ -1,4 +1,5 @@
import { createMiddleware, createStart } from '@tanstack/react-start'
+import { getRequestMiddlewareCount } from '../../shared'
import type { GlobalMiddlewareContext } from '../../shared'
function appendTrace(
@@ -48,6 +49,13 @@ const requestMiddlewareC = createMiddleware({ type: 'request' }).server(
},
)
+const requestMiddlewareSets: Array> = [
+ [],
+ [requestMiddlewareA],
+ [requestMiddlewareA, requestMiddlewareB],
+ [requestMiddlewareA, requestMiddlewareB, requestMiddlewareC],
+]
+
const functionMiddlewareA = createMiddleware({ type: 'function' }).server(
({ next, context }) => {
const ctx = (context ?? {}) as GlobalMiddlewareContext
@@ -75,10 +83,6 @@ const functionMiddlewareB = createMiddleware({ type: 'function' }).server(
)
export const startInstance = createStart(() => ({
- requestMiddleware: [
- requestMiddlewareA,
- requestMiddlewareB,
- requestMiddlewareC,
- ],
+ requestMiddleware: requestMiddlewareSets[getRequestMiddlewareCount()],
functionMiddleware: [functionMiddlewareA, functionMiddlewareB],
}))
diff --git a/benchmarks/ssr/scenarios/global-middleware/shared.ts b/benchmarks/ssr/scenarios/global-middleware/shared.ts
index f90fa9b233..8fbe788911 100644
--- a/benchmarks/ssr/scenarios/global-middleware/shared.ts
+++ b/benchmarks/ssr/scenarios/global-middleware/shared.ts
@@ -10,11 +10,41 @@ export interface GlobalMiddlewareRouteContext extends GlobalMiddlewareContext {
globalMiddlewareContext?: GlobalMiddlewareContext
}
+export type RequestMiddlewareCount = 0 | 1 | 2 | 3
+
+const requestMiddlewareCountKey = '__TSR_SSR_BENCH_REQUEST_MIDDLEWARE_COUNT__'
+
+type BenchmarkGlobal = typeof globalThis & {
+ [requestMiddlewareCountKey]?: RequestMiddlewareCount
+}
+
+const expectedRequestContexts: ReadonlyArray = [
+ {},
+ { requestTrace: 'req.r1', requestTotal: 1 },
+ { requestTrace: 'req.r1.r2', requestTotal: 3 },
+ { requestTrace: 'req.r1.r2.r3', requestTotal: 6 },
+]
+
export const expectedRequestTrace = 'req.r1.r2.r3'
export const expectedRequestTotal = 6
export const expectedFunctionTrace = 'fn.f1.f2'
export const expectedFunctionTotal = 30
+export function setRequestMiddlewareCount(count: RequestMiddlewareCount) {
+ const benchmarkGlobal = globalThis as BenchmarkGlobal
+ benchmarkGlobal[requestMiddlewareCountKey] = count
+}
+
+export function getRequestMiddlewareCount(): RequestMiddlewareCount {
+ return (globalThis as BenchmarkGlobal)[requestMiddlewareCountKey] ?? 3
+}
+
+export function getExpectedRequestContext(
+ count: RequestMiddlewareCount,
+): GlobalMiddlewareContext {
+ return expectedRequestContexts[count]!
+}
+
export function makeDocumentMarker(
id: string,
context: GlobalMiddlewareContext,
diff --git a/benchmarks/ssr/scenarios/global-middleware/solid/speed.global-mw-server-route-0-middleware.bench.ts b/benchmarks/ssr/scenarios/global-middleware/solid/speed.global-mw-server-route-0-middleware.bench.ts
new file mode 100644
index 0000000000..c7485b4ef4
--- /dev/null
+++ b/benchmarks/ssr/scenarios/global-middleware/solid/speed.global-mw-server-route-0-middleware.bench.ts
@@ -0,0 +1,27 @@
+import { bench, describe } from 'vitest'
+import {
+ assertGlobalMiddlewareScenario,
+ globalMiddlewareBenchOptions,
+ runGlobalMiddlewareServerRouteLoop,
+ setupGlobalMiddlewareBench,
+} from '../bench'
+import type { StartRequestHandler } from '../bench'
+
+const appModuleUrl = new URL('./dist/server/server.js', import.meta.url).href
+
+const { default: handler } = (await import(
+ /* @vite-ignore */ appModuleUrl
+)) as {
+ default: StartRequestHandler
+}
+const context = await setupGlobalMiddlewareBench(handler)
+
+await assertGlobalMiddlewareScenario(handler, context)
+
+describe('ssr', () => {
+ bench(
+ 'ssr global-mw server-route 0 middleware (solid)',
+ () => runGlobalMiddlewareServerRouteLoop(handler, 0),
+ globalMiddlewareBenchOptions,
+ )
+})
diff --git a/benchmarks/ssr/scenarios/global-middleware/solid/speed.global-mw-server-route-1-middleware.bench.ts b/benchmarks/ssr/scenarios/global-middleware/solid/speed.global-mw-server-route-1-middleware.bench.ts
new file mode 100644
index 0000000000..ac18e0ca79
--- /dev/null
+++ b/benchmarks/ssr/scenarios/global-middleware/solid/speed.global-mw-server-route-1-middleware.bench.ts
@@ -0,0 +1,27 @@
+import { bench, describe } from 'vitest'
+import {
+ assertGlobalMiddlewareScenario,
+ globalMiddlewareBenchOptions,
+ runGlobalMiddlewareServerRouteLoop,
+ setupGlobalMiddlewareBench,
+} from '../bench'
+import type { StartRequestHandler } from '../bench'
+
+const appModuleUrl = new URL('./dist/server/server.js', import.meta.url).href
+
+const { default: handler } = (await import(
+ /* @vite-ignore */ appModuleUrl
+)) as {
+ default: StartRequestHandler
+}
+const context = await setupGlobalMiddlewareBench(handler)
+
+await assertGlobalMiddlewareScenario(handler, context)
+
+describe('ssr', () => {
+ bench(
+ 'ssr global-mw server-route 1 middleware (solid)',
+ () => runGlobalMiddlewareServerRouteLoop(handler, 1),
+ globalMiddlewareBenchOptions,
+ )
+})
diff --git a/benchmarks/ssr/scenarios/global-middleware/solid/speed.global-mw-server-route-2-middleware.bench.ts b/benchmarks/ssr/scenarios/global-middleware/solid/speed.global-mw-server-route-2-middleware.bench.ts
new file mode 100644
index 0000000000..7c2be97b01
--- /dev/null
+++ b/benchmarks/ssr/scenarios/global-middleware/solid/speed.global-mw-server-route-2-middleware.bench.ts
@@ -0,0 +1,27 @@
+import { bench, describe } from 'vitest'
+import {
+ assertGlobalMiddlewareScenario,
+ globalMiddlewareBenchOptions,
+ runGlobalMiddlewareServerRouteLoop,
+ setupGlobalMiddlewareBench,
+} from '../bench'
+import type { StartRequestHandler } from '../bench'
+
+const appModuleUrl = new URL('./dist/server/server.js', import.meta.url).href
+
+const { default: handler } = (await import(
+ /* @vite-ignore */ appModuleUrl
+)) as {
+ default: StartRequestHandler
+}
+const context = await setupGlobalMiddlewareBench(handler)
+
+await assertGlobalMiddlewareScenario(handler, context)
+
+describe('ssr', () => {
+ bench(
+ 'ssr global-mw server-route 2 middlewares (solid)',
+ () => runGlobalMiddlewareServerRouteLoop(handler, 2),
+ globalMiddlewareBenchOptions,
+ )
+})
diff --git a/benchmarks/ssr/scenarios/global-middleware/solid/speed.global-mw-server-route.bench.ts b/benchmarks/ssr/scenarios/global-middleware/solid/speed.global-mw-server-route.bench.ts
index 495c57112a..7d21d72067 100644
--- a/benchmarks/ssr/scenarios/global-middleware/solid/speed.global-mw-server-route.bench.ts
+++ b/benchmarks/ssr/scenarios/global-middleware/solid/speed.global-mw-server-route.bench.ts
@@ -20,8 +20,8 @@ await assertGlobalMiddlewareScenario(handler, context)
describe('ssr', () => {
bench(
- 'ssr global-mw server-route (solid)',
- () => runGlobalMiddlewareServerRouteLoop(handler),
+ 'ssr global-mw server-route 3 middlewares (solid)',
+ () => runGlobalMiddlewareServerRouteLoop(handler, 3),
globalMiddlewareBenchOptions,
)
})
diff --git a/benchmarks/ssr/scenarios/global-middleware/solid/src/start.ts b/benchmarks/ssr/scenarios/global-middleware/solid/src/start.ts
index 8c4168d574..a6f6214b82 100644
--- a/benchmarks/ssr/scenarios/global-middleware/solid/src/start.ts
+++ b/benchmarks/ssr/scenarios/global-middleware/solid/src/start.ts
@@ -1,4 +1,5 @@
import { createMiddleware, createStart } from '@tanstack/solid-start'
+import { getRequestMiddlewareCount } from '../../shared'
import type { GlobalMiddlewareContext } from '../../shared'
function appendTrace(
@@ -48,6 +49,13 @@ const requestMiddlewareC = createMiddleware({ type: 'request' }).server(
},
)
+const requestMiddlewareSets: Array> = [
+ [],
+ [requestMiddlewareA],
+ [requestMiddlewareA, requestMiddlewareB],
+ [requestMiddlewareA, requestMiddlewareB, requestMiddlewareC],
+]
+
const functionMiddlewareA = createMiddleware({ type: 'function' }).server(
({ next, context }) => {
const ctx = (context ?? {}) as GlobalMiddlewareContext
@@ -75,10 +83,6 @@ const functionMiddlewareB = createMiddleware({ type: 'function' }).server(
)
export const startInstance = createStart(() => ({
- requestMiddleware: [
- requestMiddlewareA,
- requestMiddlewareB,
- requestMiddlewareC,
- ],
+ requestMiddleware: requestMiddlewareSets[getRequestMiddlewareCount()],
functionMiddleware: [functionMiddlewareA, functionMiddlewareB],
}))
diff --git a/benchmarks/ssr/scenarios/global-middleware/vue/speed.global-mw-server-route-0-middleware.bench.ts b/benchmarks/ssr/scenarios/global-middleware/vue/speed.global-mw-server-route-0-middleware.bench.ts
new file mode 100644
index 0000000000..c334af8b65
--- /dev/null
+++ b/benchmarks/ssr/scenarios/global-middleware/vue/speed.global-mw-server-route-0-middleware.bench.ts
@@ -0,0 +1,27 @@
+import { bench, describe } from 'vitest'
+import {
+ assertGlobalMiddlewareScenario,
+ globalMiddlewareBenchOptions,
+ runGlobalMiddlewareServerRouteLoop,
+ setupGlobalMiddlewareBench,
+} from '../bench'
+import type { StartRequestHandler } from '../bench'
+
+const appModuleUrl = new URL('./dist/server/server.js', import.meta.url).href
+
+const { default: handler } = (await import(
+ /* @vite-ignore */ appModuleUrl
+)) as {
+ default: StartRequestHandler
+}
+const context = await setupGlobalMiddlewareBench(handler)
+
+await assertGlobalMiddlewareScenario(handler, context)
+
+describe('ssr', () => {
+ bench(
+ 'ssr global-mw server-route 0 middleware (vue)',
+ () => runGlobalMiddlewareServerRouteLoop(handler, 0),
+ globalMiddlewareBenchOptions,
+ )
+})
diff --git a/benchmarks/ssr/scenarios/global-middleware/vue/speed.global-mw-server-route-1-middleware.bench.ts b/benchmarks/ssr/scenarios/global-middleware/vue/speed.global-mw-server-route-1-middleware.bench.ts
new file mode 100644
index 0000000000..7c1b91a0ea
--- /dev/null
+++ b/benchmarks/ssr/scenarios/global-middleware/vue/speed.global-mw-server-route-1-middleware.bench.ts
@@ -0,0 +1,27 @@
+import { bench, describe } from 'vitest'
+import {
+ assertGlobalMiddlewareScenario,
+ globalMiddlewareBenchOptions,
+ runGlobalMiddlewareServerRouteLoop,
+ setupGlobalMiddlewareBench,
+} from '../bench'
+import type { StartRequestHandler } from '../bench'
+
+const appModuleUrl = new URL('./dist/server/server.js', import.meta.url).href
+
+const { default: handler } = (await import(
+ /* @vite-ignore */ appModuleUrl
+)) as {
+ default: StartRequestHandler
+}
+const context = await setupGlobalMiddlewareBench(handler)
+
+await assertGlobalMiddlewareScenario(handler, context)
+
+describe('ssr', () => {
+ bench(
+ 'ssr global-mw server-route 1 middleware (vue)',
+ () => runGlobalMiddlewareServerRouteLoop(handler, 1),
+ globalMiddlewareBenchOptions,
+ )
+})
diff --git a/benchmarks/ssr/scenarios/global-middleware/vue/speed.global-mw-server-route-2-middleware.bench.ts b/benchmarks/ssr/scenarios/global-middleware/vue/speed.global-mw-server-route-2-middleware.bench.ts
new file mode 100644
index 0000000000..5b00bd3ca9
--- /dev/null
+++ b/benchmarks/ssr/scenarios/global-middleware/vue/speed.global-mw-server-route-2-middleware.bench.ts
@@ -0,0 +1,27 @@
+import { bench, describe } from 'vitest'
+import {
+ assertGlobalMiddlewareScenario,
+ globalMiddlewareBenchOptions,
+ runGlobalMiddlewareServerRouteLoop,
+ setupGlobalMiddlewareBench,
+} from '../bench'
+import type { StartRequestHandler } from '../bench'
+
+const appModuleUrl = new URL('./dist/server/server.js', import.meta.url).href
+
+const { default: handler } = (await import(
+ /* @vite-ignore */ appModuleUrl
+)) as {
+ default: StartRequestHandler
+}
+const context = await setupGlobalMiddlewareBench(handler)
+
+await assertGlobalMiddlewareScenario(handler, context)
+
+describe('ssr', () => {
+ bench(
+ 'ssr global-mw server-route 2 middlewares (vue)',
+ () => runGlobalMiddlewareServerRouteLoop(handler, 2),
+ globalMiddlewareBenchOptions,
+ )
+})
diff --git a/benchmarks/ssr/scenarios/global-middleware/vue/speed.global-mw-server-route.bench.ts b/benchmarks/ssr/scenarios/global-middleware/vue/speed.global-mw-server-route.bench.ts
index e7fd4cd205..6cdc34241e 100644
--- a/benchmarks/ssr/scenarios/global-middleware/vue/speed.global-mw-server-route.bench.ts
+++ b/benchmarks/ssr/scenarios/global-middleware/vue/speed.global-mw-server-route.bench.ts
@@ -20,8 +20,8 @@ await assertGlobalMiddlewareScenario(handler, context)
describe('ssr', () => {
bench(
- 'ssr global-mw server-route (vue)',
- () => runGlobalMiddlewareServerRouteLoop(handler),
+ 'ssr global-mw server-route 3 middlewares (vue)',
+ () => runGlobalMiddlewareServerRouteLoop(handler, 3),
globalMiddlewareBenchOptions,
)
})
diff --git a/benchmarks/ssr/scenarios/global-middleware/vue/src/routeTree.gen.ts b/benchmarks/ssr/scenarios/global-middleware/vue/src/routeTree.gen.ts
index aae3329420..3118848e4d 100644
--- a/benchmarks/ssr/scenarios/global-middleware/vue/src/routeTree.gen.ts
+++ b/benchmarks/ssr/scenarios/global-middleware/vue/src/routeTree.gen.ts
@@ -10,8 +10,8 @@
import { Route as rootRouteImport } from './routes/__root'
import { Route as IndexRouteImport } from './routes/index'
-import { Route as PageIdRouteImport } from './routes/page.$id'
import { Route as ApiFnUrlsRouteImport } from './routes/api.fn-urls'
+import { Route as PageIdRouteImport } from './routes/page.$id'
import { Route as ApiPingIdRouteImport } from './routes/api.ping.$id'
const IndexRoute = IndexRouteImport.update({
@@ -19,16 +19,16 @@ const IndexRoute = IndexRouteImport.update({
path: '/',
getParentRoute: () => rootRouteImport,
} as any)
-const PageIdRoute = PageIdRouteImport.update({
- id: '/page/$id',
- path: '/page/$id',
- getParentRoute: () => rootRouteImport,
-} as any)
const ApiFnUrlsRoute = ApiFnUrlsRouteImport.update({
id: '/api/fn-urls',
path: '/api/fn-urls',
getParentRoute: () => rootRouteImport,
} as any)
+const PageIdRoute = PageIdRouteImport.update({
+ id: '/page/$id',
+ path: '/page/$id',
+ getParentRoute: () => rootRouteImport,
+} as any)
const ApiPingIdRoute = ApiPingIdRouteImport.update({
id: '/api/ping/$id',
path: '/api/ping/$id',
@@ -78,13 +78,6 @@ declare module '@tanstack/vue-router' {
preLoaderRoute: typeof IndexRouteImport
parentRoute: typeof rootRouteImport
}
- '/page/$id': {
- id: '/page/$id'
- path: '/page/$id'
- fullPath: '/page/$id'
- preLoaderRoute: typeof PageIdRouteImport
- parentRoute: typeof rootRouteImport
- }
'/api/fn-urls': {
id: '/api/fn-urls'
path: '/api/fn-urls'
@@ -92,6 +85,13 @@ declare module '@tanstack/vue-router' {
preLoaderRoute: typeof ApiFnUrlsRouteImport
parentRoute: typeof rootRouteImport
}
+ '/page/$id': {
+ id: '/page/$id'
+ path: '/page/$id'
+ fullPath: '/page/$id'
+ preLoaderRoute: typeof PageIdRouteImport
+ parentRoute: typeof rootRouteImport
+ }
'/api/ping/$id': {
id: '/api/ping/$id'
path: '/api/ping/$id'
diff --git a/benchmarks/ssr/scenarios/global-middleware/vue/src/start.ts b/benchmarks/ssr/scenarios/global-middleware/vue/src/start.ts
index dc3f142e27..6e4eb2c5ef 100644
--- a/benchmarks/ssr/scenarios/global-middleware/vue/src/start.ts
+++ b/benchmarks/ssr/scenarios/global-middleware/vue/src/start.ts
@@ -1,4 +1,5 @@
import { createMiddleware, createStart } from '@tanstack/vue-start'
+import { getRequestMiddlewareCount } from '../../shared'
import type { GlobalMiddlewareContext } from '../../shared'
function appendTrace(
@@ -48,6 +49,13 @@ const requestMiddlewareC = createMiddleware({ type: 'request' }).server(
},
)
+const requestMiddlewareSets: Array> = [
+ [],
+ [requestMiddlewareA],
+ [requestMiddlewareA, requestMiddlewareB],
+ [requestMiddlewareA, requestMiddlewareB, requestMiddlewareC],
+]
+
const functionMiddlewareA = createMiddleware({ type: 'function' }).server(
({ next, context }) => {
const ctx = (context ?? {}) as GlobalMiddlewareContext
@@ -75,10 +83,6 @@ const functionMiddlewareB = createMiddleware({ type: 'function' }).server(
)
export const startInstance = createStart(() => ({
- requestMiddleware: [
- requestMiddlewareA,
- requestMiddlewareB,
- requestMiddlewareC,
- ],
+ requestMiddleware: requestMiddlewareSets[getRequestMiddlewareCount()],
functionMiddleware: [functionMiddlewareA, functionMiddlewareB],
}))
diff --git a/benchmarks/ssr/scenarios/serialization/vue/src/routeTree.gen.ts b/benchmarks/ssr/scenarios/serialization/vue/src/routeTree.gen.ts
index 02268c2c3c..cd7b0b449b 100644
--- a/benchmarks/ssr/scenarios/serialization/vue/src/routeTree.gen.ts
+++ b/benchmarks/ssr/scenarios/serialization/vue/src/routeTree.gen.ts
@@ -9,19 +9,19 @@
// Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.
import { Route as rootRouteImport } from './routes/__root'
-import { Route as RichIdRouteImport } from './routes/rich.$id'
import { Route as PlainIdRouteImport } from './routes/plain.$id'
+import { Route as RichIdRouteImport } from './routes/rich.$id'
-const RichIdRoute = RichIdRouteImport.update({
- id: '/rich/$id',
- path: '/rich/$id',
- getParentRoute: () => rootRouteImport,
-} as any)
const PlainIdRoute = PlainIdRouteImport.update({
id: '/plain/$id',
path: '/plain/$id',
getParentRoute: () => rootRouteImport,
} as any)
+const RichIdRoute = RichIdRouteImport.update({
+ id: '/rich/$id',
+ path: '/rich/$id',
+ getParentRoute: () => rootRouteImport,
+} as any)
export interface FileRoutesByFullPath {
'/plain/$id': typeof PlainIdRoute
@@ -51,13 +51,6 @@ export interface RootRouteChildren {
declare module '@tanstack/vue-router' {
interface FileRoutesByPath {
- '/rich/$id': {
- id: '/rich/$id'
- path: '/rich/$id'
- fullPath: '/rich/$id'
- preLoaderRoute: typeof RichIdRouteImport
- parentRoute: typeof rootRouteImport
- }
'/plain/$id': {
id: '/plain/$id'
path: '/plain/$id'
@@ -65,6 +58,13 @@ declare module '@tanstack/vue-router' {
preLoaderRoute: typeof PlainIdRouteImport
parentRoute: typeof rootRouteImport
}
+ '/rich/$id': {
+ id: '/rich/$id'
+ path: '/rich/$id'
+ fullPath: '/rich/$id'
+ preLoaderRoute: typeof RichIdRouteImport
+ parentRoute: typeof rootRouteImport
+ }
}
}
diff --git a/benchmarks/ssr/scenarios/server-fns/vue/src/routeTree.gen.ts b/benchmarks/ssr/scenarios/server-fns/vue/src/routeTree.gen.ts
index fa27fb1a5d..0e24cd9c15 100644
--- a/benchmarks/ssr/scenarios/server-fns/vue/src/routeTree.gen.ts
+++ b/benchmarks/ssr/scenarios/server-fns/vue/src/routeTree.gen.ts
@@ -10,24 +10,24 @@
import { Route as rootRouteImport } from './routes/__root'
import { Route as IndexRouteImport } from './routes/index'
-import { Route as SsrCallIdRouteImport } from './routes/ssr-call.$id'
import { Route as ApiFnUrlsRouteImport } from './routes/api.fn-urls'
+import { Route as SsrCallIdRouteImport } from './routes/ssr-call.$id'
const IndexRoute = IndexRouteImport.update({
id: '/',
path: '/',
getParentRoute: () => rootRouteImport,
} as any)
-const SsrCallIdRoute = SsrCallIdRouteImport.update({
- id: '/ssr-call/$id',
- path: '/ssr-call/$id',
- getParentRoute: () => rootRouteImport,
-} as any)
const ApiFnUrlsRoute = ApiFnUrlsRouteImport.update({
id: '/api/fn-urls',
path: '/api/fn-urls',
getParentRoute: () => rootRouteImport,
} as any)
+const SsrCallIdRoute = SsrCallIdRouteImport.update({
+ id: '/ssr-call/$id',
+ path: '/ssr-call/$id',
+ getParentRoute: () => rootRouteImport,
+} as any)
export interface FileRoutesByFullPath {
'/': typeof IndexRoute
@@ -68,13 +68,6 @@ declare module '@tanstack/vue-router' {
preLoaderRoute: typeof IndexRouteImport
parentRoute: typeof rootRouteImport
}
- '/ssr-call/$id': {
- id: '/ssr-call/$id'
- path: '/ssr-call/$id'
- fullPath: '/ssr-call/$id'
- preLoaderRoute: typeof SsrCallIdRouteImport
- parentRoute: typeof rootRouteImport
- }
'/api/fn-urls': {
id: '/api/fn-urls'
path: '/api/fn-urls'
@@ -82,6 +75,13 @@ declare module '@tanstack/vue-router' {
preLoaderRoute: typeof ApiFnUrlsRouteImport
parentRoute: typeof rootRouteImport
}
+ '/ssr-call/$id': {
+ id: '/ssr-call/$id'
+ path: '/ssr-call/$id'
+ fullPath: '/ssr-call/$id'
+ preLoaderRoute: typeof SsrCallIdRouteImport
+ parentRoute: typeof rootRouteImport
+ }
}
}
diff --git a/docs/router/api/router/RouterEventsType.md b/docs/router/api/router/RouterEventsType.md
index c79bb47f81..c27887fba1 100644
--- a/docs/router/api/router/RouterEventsType.md
+++ b/docs/router/api/router/RouterEventsType.md
@@ -47,9 +47,6 @@ type RouterEvents = {
hrefChanged: boolean
hashChanged: boolean
}
- onInjectedHtml: {
- type: 'onInjectedHtml'
- }
onRendered: {
type: 'onRendered'
fromLocation?: ParsedLocation
@@ -67,7 +64,7 @@ Once an event is emitted, the following properties will be present on the event
### `type` property
-- Type: `onBeforeNavigate | onBeforeLoad | onLoad | onBeforeRouteMount | onResolved | onRendered | onInjectedHtml`
+- Type: `onBeforeNavigate | onBeforeLoad | onLoad | onBeforeRouteMount | onResolved | onRendered`
- The type of the event
- This is useful for discriminating between events in a listener function.
diff --git a/docs/router/guide/ssr.md b/docs/router/guide/ssr.md
index ae3cdbef7c..46a0941e7c 100644
--- a/docs/router/guide/ssr.md
+++ b/docs/router/guide/ssr.md
@@ -158,6 +158,8 @@ export async function render({ request }: { request: Request }) {
using `renderRouterToString`
+React and Solid use their native synchronous string renderers. Suspended components render their Suspense fallback without waiting for the component to resolve. The router still finishes serializing hydration data before returning the response. Use `renderRouterToStream` when you need the server to render suspended content after it resolves.
+
# React
@@ -260,6 +262,9 @@ This pattern can be useful for pages that have slow or high-latency data fetchin
> [!NOTE]
> This streaming pattern is all automatic as long as you are using either `defaultStreamHandler` or `renderRouterToStream`.
+> [!IMPORTANT]
+> Render [``](./document-head-management.md#scripts) inside `` of your root route. It emits the route scripts and marks where the router inserts streamed hydration data. Without it the response still completes, but the page cannot hydrate.
+
using `defaultStreamHandler`
diff --git a/e2e/react-start/static-server-functions/src/routeTree.gen.ts b/e2e/react-start/static-server-functions/src/routeTree.gen.ts
index ea6a6a3806..558b1ab4d9 100644
--- a/e2e/react-start/static-server-functions/src/routeTree.gen.ts
+++ b/e2e/react-start/static-server-functions/src/routeTree.gen.ts
@@ -11,6 +11,7 @@
import { Route as rootRouteImport } from './routes/__root'
import { Route as IndexRouteImport } from './routes/index'
import { Route as PostsRouteImport } from './routes/posts'
+import { Route as RawStreamRouteImport } from './routes/raw-stream'
import { Route as PostsIndexRouteImport } from './routes/posts.index'
const IndexRoute = IndexRouteImport.update({
@@ -23,6 +24,11 @@ const PostsRoute = PostsRouteImport.update({
path: '/posts',
getParentRoute: () => rootRouteImport,
} as any)
+const RawStreamRoute = RawStreamRouteImport.update({
+ id: '/raw-stream',
+ path: '/raw-stream',
+ getParentRoute: () => rootRouteImport,
+} as any)
const PostsIndexRoute = PostsIndexRouteImport.update({
id: '/',
path: '/',
@@ -32,29 +38,33 @@ const PostsIndexRoute = PostsIndexRouteImport.update({
export interface FileRoutesByFullPath {
'/': typeof IndexRoute
'/posts': typeof PostsRouteWithChildren
+ '/raw-stream': typeof RawStreamRoute
'/posts/': typeof PostsIndexRoute
}
export interface FileRoutesByTo {
'/': typeof IndexRoute
+ '/raw-stream': typeof RawStreamRoute
'/posts': typeof PostsIndexRoute
}
export interface FileRoutesById {
__root__: typeof rootRouteImport
'/': typeof IndexRoute
'/posts': typeof PostsRouteWithChildren
+ '/raw-stream': typeof RawStreamRoute
'/posts/': typeof PostsIndexRoute
}
export interface FileRouteTypes {
fileRoutesByFullPath: FileRoutesByFullPath
- fullPaths: '/' | '/posts' | '/posts/'
+ fullPaths: '/' | '/posts' | '/raw-stream' | '/posts/'
fileRoutesByTo: FileRoutesByTo
- to: '/' | '/posts'
- id: '__root__' | '/' | '/posts' | '/posts/'
+ to: '/' | '/raw-stream' | '/posts'
+ id: '__root__' | '/' | '/posts' | '/raw-stream' | '/posts/'
fileRoutesById: FileRoutesById
}
export interface RootRouteChildren {
IndexRoute: typeof IndexRoute
PostsRoute: typeof PostsRouteWithChildren
+ RawStreamRoute: typeof RawStreamRoute
}
declare module '@tanstack/react-router' {
@@ -73,6 +83,13 @@ declare module '@tanstack/react-router' {
preLoaderRoute: typeof PostsRouteImport
parentRoute: typeof rootRouteImport
}
+ '/raw-stream': {
+ id: '/raw-stream'
+ path: '/raw-stream'
+ fullPath: '/raw-stream'
+ preLoaderRoute: typeof RawStreamRouteImport
+ parentRoute: typeof rootRouteImport
+ }
'/posts/': {
id: '/posts/'
path: '/'
@@ -96,6 +113,7 @@ const PostsRouteWithChildren = PostsRoute._addFileChildren(PostsRouteChildren)
const rootRouteChildren: RootRouteChildren = {
IndexRoute: IndexRoute,
PostsRoute: PostsRouteWithChildren,
+ RawStreamRoute: RawStreamRoute,
}
export const routeTree = rootRouteImport
._addFileChildren(rootRouteChildren)
diff --git a/e2e/react-start/static-server-functions/src/routes/__root.tsx b/e2e/react-start/static-server-functions/src/routes/__root.tsx
index b768e8b9a1..a300613fa8 100644
--- a/e2e/react-start/static-server-functions/src/routes/__root.tsx
+++ b/e2e/react-start/static-server-functions/src/routes/__root.tsx
@@ -30,6 +30,9 @@ function RootComponent() {
Posts
+
+ Raw Stream
+
diff --git a/e2e/react-start/static-server-functions/src/routes/raw-stream.tsx b/e2e/react-start/static-server-functions/src/routes/raw-stream.tsx
new file mode 100644
index 0000000000..df898d2907
--- /dev/null
+++ b/e2e/react-start/static-server-functions/src/routes/raw-stream.tsx
@@ -0,0 +1,29 @@
+import { createFileRoute } from '@tanstack/react-router'
+import { RawStream, createServerFn } from '@tanstack/react-start'
+import { staticFunctionMiddleware } from '@tanstack/start-static-server-functions'
+
+const fetchRawStream = createServerFn({ method: 'GET' })
+ .middleware([staticFunctionMiddleware])
+ .handler(async () => {
+ return new RawStream(new Response('Static cache stream').body!, {
+ hint: 'text',
+ })
+ })
+
+export const Route = createFileRoute('/raw-stream')({
+ loader: async () => {
+ const result = await fetchRawStream()
+ if (typeof document === 'undefined') {
+ return ''
+ }
+ const stream = result as RawStream | ReadableStream
+ return new Response(
+ stream instanceof RawStream ? stream.stream : stream,
+ ).text()
+ },
+ component: RawStreamComponent,
+})
+
+function RawStreamComponent() {
+ return {Route.useLoaderData()}
+}
diff --git a/e2e/react-start/static-server-functions/tests/app.spec.ts b/e2e/react-start/static-server-functions/tests/app.spec.ts
index 895566aa35..d86fd61a75 100644
--- a/e2e/react-start/static-server-functions/tests/app.spec.ts
+++ b/e2e/react-start/static-server-functions/tests/app.spec.ts
@@ -59,5 +59,32 @@ test.describe('Static Server Functions with Nitro', () => {
await expect(page.getByTestId('post-2')).toHaveText('Second Post')
await expect(page.getByTestId('post-3')).toHaveText('Third Post')
})
+
+ test('should decode a cached RawStream during client navigation', async ({
+ page,
+ }) => {
+ await page.goto('/')
+ // Nitro snapshots public assets before Start prerenders (see #6787).
+ // Serve the generated file as a static host would to isolate decoding.
+ await page.route('**/__tsr/staticServerFnCache/*.json', (route) =>
+ route.fulfill({
+ path: join(
+ process.cwd(),
+ '.output',
+ 'public',
+ new URL(route.request().url()).pathname,
+ ),
+ }),
+ )
+ const cacheResponse = page.waitForResponse((response) =>
+ response.url().includes('/__tsr/staticServerFnCache/'),
+ )
+ await page.getByTestId('link-raw-stream').click()
+ const response = await cacheResponse
+ expect(response.status(), response.url()).toBe(200)
+ await expect(page.getByTestId('raw-stream')).toHaveText(
+ 'Static cache stream',
+ )
+ })
})
})
diff --git a/e2e/react-start/streaming-ssr/package.json b/e2e/react-start/streaming-ssr/package.json
index 3e85f5e78c..d0e3757175 100644
--- a/e2e/react-start/streaming-ssr/package.json
+++ b/e2e/react-start/streaming-ssr/package.json
@@ -10,7 +10,8 @@
"start": "pnpx srvx --prod -s ../client dist/server/server.js",
"preview": "vite preview",
"test:e2e": "playwright test --project=chromium",
- "test:e2e:preview": "MODE=preview playwright test preview-streaming.spec.ts --project=chromium"
+ "test:e2e:preview": "MODE=preview playwright test preview-streaming.spec.ts --project=chromium",
+ "test:e2e:buffer-repro": "RUN_SSR_ROUTER_HTML_BUFFER_REPRO=true playwright test router-html-buffer.spec.ts --project=chromium"
},
"dependencies": {
"@tanstack/react-query": "^5.80.7",
@@ -26,9 +27,45 @@
"@types/node": "^22.10.2",
"@types/react": "^19.0.8",
"@types/react-dom": "^19.0.3",
+ "@vitejs/plugin-react": "^6.0.1",
"srvx": "^0.11.9",
"@typescript/native": "npm:typescript@^7.0.2",
"typescript": "npm:@typescript/typescript6@^6.0.2",
"vite": "^8.0.14"
+ },
+ "nx": {
+ "targets": {
+ "build": {
+ "inputs": [
+ "buildProduction",
+ "^buildProduction",
+ "dependentTaskOutputs",
+ "streamingSsrTests"
+ ]
+ },
+ "test:e2e": {
+ "inputs": [
+ "default",
+ "^production",
+ "dependentTaskOutputs",
+ "streamingSsrTests"
+ ]
+ },
+ "test:e2e:preview": {
+ "inputs": [
+ "default",
+ "^production",
+ "streamingSsrTests"
+ ]
+ },
+ "test:e2e:buffer-repro": {
+ "inputs": [
+ "default",
+ "^production",
+ "dependentTaskOutputs",
+ "streamingSsrTests"
+ ]
+ }
+ }
}
}
diff --git a/e2e/react-start/streaming-ssr/src/routeTree.gen.ts b/e2e/react-start/streaming-ssr/src/routeTree.gen.ts
index c1a51b62f8..169121003d 100644
--- a/e2e/react-start/streaming-ssr/src/routeTree.gen.ts
+++ b/e2e/react-start/streaming-ssr/src/routeTree.gen.ts
@@ -17,6 +17,7 @@ import { Route as FastSerialRouteImport } from './routes/fast-serial'
import { Route as ManyPromisesRouteImport } from './routes/many-promises'
import { Route as NestedDeferredRouteImport } from './routes/nested-deferred'
import { Route as QueryHeavyRouteImport } from './routes/query-heavy'
+import { Route as RouterHtmlBufferRouteImport } from './routes/router-html-buffer'
import { Route as SlowRenderRouteImport } from './routes/slow-render'
import { Route as StreamRouteImport } from './routes/stream'
import { Route as SyncOnlyRouteImport } from './routes/sync-only'
@@ -61,6 +62,11 @@ const QueryHeavyRoute = QueryHeavyRouteImport.update({
path: '/query-heavy',
getParentRoute: () => rootRouteImport,
} as any)
+const RouterHtmlBufferRoute = RouterHtmlBufferRouteImport.update({
+ id: '/router-html-buffer',
+ path: '/router-html-buffer',
+ getParentRoute: () => rootRouteImport,
+} as any)
const SlowRenderRoute = SlowRenderRouteImport.update({
id: '/slow-render',
path: '/slow-render',
@@ -86,6 +92,7 @@ export interface FileRoutesByFullPath {
'/many-promises': typeof ManyPromisesRoute
'/nested-deferred': typeof NestedDeferredRoute
'/query-heavy': typeof QueryHeavyRoute
+ '/router-html-buffer': typeof RouterHtmlBufferRoute
'/slow-render': typeof SlowRenderRoute
'/stream': typeof StreamRoute
'/sync-only': typeof SyncOnlyRoute
@@ -99,6 +106,7 @@ export interface FileRoutesByTo {
'/many-promises': typeof ManyPromisesRoute
'/nested-deferred': typeof NestedDeferredRoute
'/query-heavy': typeof QueryHeavyRoute
+ '/router-html-buffer': typeof RouterHtmlBufferRoute
'/slow-render': typeof SlowRenderRoute
'/stream': typeof StreamRoute
'/sync-only': typeof SyncOnlyRoute
@@ -113,6 +121,7 @@ export interface FileRoutesById {
'/many-promises': typeof ManyPromisesRoute
'/nested-deferred': typeof NestedDeferredRoute
'/query-heavy': typeof QueryHeavyRoute
+ '/router-html-buffer': typeof RouterHtmlBufferRoute
'/slow-render': typeof SlowRenderRoute
'/stream': typeof StreamRoute
'/sync-only': typeof SyncOnlyRoute
@@ -128,6 +137,7 @@ export interface FileRouteTypes {
| '/many-promises'
| '/nested-deferred'
| '/query-heavy'
+ | '/router-html-buffer'
| '/slow-render'
| '/stream'
| '/sync-only'
@@ -141,6 +151,7 @@ export interface FileRouteTypes {
| '/many-promises'
| '/nested-deferred'
| '/query-heavy'
+ | '/router-html-buffer'
| '/slow-render'
| '/stream'
| '/sync-only'
@@ -154,6 +165,7 @@ export interface FileRouteTypes {
| '/many-promises'
| '/nested-deferred'
| '/query-heavy'
+ | '/router-html-buffer'
| '/slow-render'
| '/stream'
| '/sync-only'
@@ -168,6 +180,7 @@ export interface RootRouteChildren {
ManyPromisesRoute: typeof ManyPromisesRoute
NestedDeferredRoute: typeof NestedDeferredRoute
QueryHeavyRoute: typeof QueryHeavyRoute
+ RouterHtmlBufferRoute: typeof RouterHtmlBufferRoute
SlowRenderRoute: typeof SlowRenderRoute
StreamRoute: typeof StreamRoute
SyncOnlyRoute: typeof SyncOnlyRoute
@@ -231,6 +244,13 @@ declare module '@tanstack/react-router' {
preLoaderRoute: typeof QueryHeavyRouteImport
parentRoute: typeof rootRouteImport
}
+ '/router-html-buffer': {
+ id: '/router-html-buffer'
+ path: '/router-html-buffer'
+ fullPath: '/router-html-buffer'
+ preLoaderRoute: typeof RouterHtmlBufferRouteImport
+ parentRoute: typeof rootRouteImport
+ }
'/slow-render': {
id: '/slow-render'
path: '/slow-render'
@@ -264,6 +284,7 @@ const rootRouteChildren: RootRouteChildren = {
ManyPromisesRoute: ManyPromisesRoute,
NestedDeferredRoute: NestedDeferredRoute,
QueryHeavyRoute: QueryHeavyRoute,
+ RouterHtmlBufferRoute: RouterHtmlBufferRoute,
SlowRenderRoute: SlowRenderRoute,
StreamRoute: StreamRoute,
SyncOnlyRoute: SyncOnlyRoute,
diff --git a/e2e/react-start/streaming-ssr/src/routes/concurrent.tsx b/e2e/react-start/streaming-ssr/src/routes/concurrent.tsx
index a1bed0fe07..c04155aa59 100644
--- a/e2e/react-start/streaming-ssr/src/routes/concurrent.tsx
+++ b/e2e/react-start/streaming-ssr/src/routes/concurrent.tsx
@@ -1,54 +1,9 @@
import { Await, createFileRoute } from '@tanstack/react-router'
import { Suspense } from 'react'
-
-/**
- * Tests concurrent promise resolution - multiple promises resolving at the exact same time.
- * This can stress the serialization system and reveal race conditions.
- */
-
-// Shared delay function that resolves multiple promises at the same instant
-function createConcurrentPromises(
- count: number,
- delayMs: number,
-): Array> {
- const sharedPromise = new Promise((resolve) =>
- setTimeout(resolve, delayMs),
- )
- return Array.from({ length: count }, (_, i) =>
- sharedPromise.then(() => `concurrent-${i + 1}`),
- )
-}
+import { createConcurrentLoaderData } from '../../../../streaming-ssr-fixtures'
export const Route = createFileRoute('/concurrent')({
- loader: async () => {
- // Create fresh batches of concurrent promises for each request
- const batch1 = createConcurrentPromises(5, 100) // 5 promises resolving at 100ms
- const batch2 = createConcurrentPromises(5, 200) // 5 promises resolving at 200ms
- const batch3 = createConcurrentPromises(5, 300) // 5 promises resolving at 300ms
-
- return {
- // Batch 1: 5 promises resolving at exactly the same time (100ms)
- concurrent1_1: batch1[0],
- concurrent1_2: batch1[1],
- concurrent1_3: batch1[2],
- concurrent1_4: batch1[3],
- concurrent1_5: batch1[4],
-
- // Batch 2: 5 promises resolving at exactly the same time (200ms)
- concurrent2_1: batch2[0],
- concurrent2_2: batch2[1],
- concurrent2_3: batch2[2],
- concurrent2_4: batch2[3],
- concurrent2_5: batch2[4],
-
- // Batch 3: 5 promises resolving at exactly the same time (300ms)
- concurrent3_1: batch3[0],
- concurrent3_2: batch3[1],
- concurrent3_3: batch3[2],
- concurrent3_4: batch3[3],
- concurrent3_5: batch3[4],
- }
- },
+ loader: async () => createConcurrentLoaderData(),
component: Concurrent,
})
@@ -86,7 +41,6 @@ function Concurrent() {
gap: '20px',
}}
>
- {/* Batch 1: 100ms */}
Batch 1 (100ms)
@@ -96,7 +50,6 @@ function Concurrent() {
- {/* Batch 2: 200ms */}
Batch 2 (200ms)
@@ -106,7 +59,6 @@ function Concurrent() {
- {/* Batch 3: 300ms */}
Batch 3 (300ms)
diff --git a/e2e/react-start/streaming-ssr/src/routes/deferred-rejection.tsx b/e2e/react-start/streaming-ssr/src/routes/deferred-rejection.tsx
index d9b5305480..3ac1e7fc2d 100644
--- a/e2e/react-start/streaming-ssr/src/routes/deferred-rejection.tsx
+++ b/e2e/react-start/streaming-ssr/src/routes/deferred-rejection.tsx
@@ -1,7 +1,9 @@
import { Await, createFileRoute } from '@tanstack/react-router'
import { Suspense } from 'react'
-
-const deferredErrorMessage = 'Error in deferred object'
+import {
+ deferredDataDelay,
+ deferredErrorMessage,
+} from '../../../../streaming-ssr-fixtures'
export const Route = createFileRoute('/deferred-rejection')({
loader: async () => {
@@ -9,7 +11,7 @@ export const Route = createFileRoute('/deferred-rejection')({
deferredData: new Promise
((_resolve, reject) => {
setTimeout(() => {
reject(new Error(deferredErrorMessage))
- }, 1000)
+ }, deferredDataDelay)
}),
}
},
diff --git a/e2e/react-start/streaming-ssr/src/routes/deferred.tsx b/e2e/react-start/streaming-ssr/src/routes/deferred.tsx
index 506efbd345..9f91c0f2d4 100644
--- a/e2e/react-start/streaming-ssr/src/routes/deferred.tsx
+++ b/e2e/react-start/streaming-ssr/src/routes/deferred.tsx
@@ -1,55 +1,40 @@
import { Await, createFileRoute } from '@tanstack/react-router'
import { createServerFn } from '@tanstack/react-start'
import { Suspense } from 'react'
+import {
+ deferredDataDelay,
+ deferredDataMessage,
+ deferredImmediateName,
+ deferredServerDelay,
+ deferredSlowName,
+ delay,
+ makeDeferredMessage,
+ makeServerData,
+ sourceMarker,
+} from '../../../../streaming-ssr-fixtures'
-// Server function that returns immediately
const getImmediateData = createServerFn({ method: 'GET' })
.validator((data: { name: string }) => data)
- .handler(({ data }) => {
- return {
- name: data.name,
- timestamp: Date.now(),
- // Track where this data came from - should always be 'server' if SSR works
- source: 'server' as const,
- }
- })
+ .handler(({ data }) => makeServerData(data.name))
-// Server function that takes time to complete
const getSlowData = createServerFn({ method: 'GET' })
.validator((data: { name: string; delay: number }) => data)
.handler(async ({ data }) => {
- await new Promise((r) => setTimeout(r, data.delay))
- return {
- name: data.name,
- timestamp: Date.now(),
- // Track where this data came from - should always be 'server' if SSR works
- source: 'server' as const,
- }
+ await delay(data.delay)
+ return makeServerData(data.name)
})
export const Route = createFileRoute('/deferred')({
loader: async () => {
return {
- // Deferred promise that resolves after 1 second
- deferredData: new Promise<{ message: string; source: string }>((r) =>
- setTimeout(
- () =>
- r({
- message: 'Deferred data loaded!',
- // Track where this data came from - should always be 'server' if SSR works
- source: typeof window === 'undefined' ? 'server' : 'client',
- }),
- 1000,
- ),
- ),
- // Deferred server function call
+ deferredData: makeDeferredMessage(deferredDataMessage, deferredDataDelay),
deferredServerData: getSlowData({
- data: { name: 'Slow User', delay: 800 },
+ data: { name: deferredSlowName, delay: deferredServerDelay },
}),
- // Immediate data (awaited)
- immediateData: await getImmediateData({ data: { name: 'Fast User' } }),
- // Track where loader ran - should always be 'server' if SSR works
- loaderSource: typeof window === 'undefined' ? 'server' : 'client',
+ immediateData: await getImmediateData({
+ data: { name: deferredImmediateName },
+ }),
+ loaderSource: sourceMarker(),
}
},
component: Deferred,
@@ -63,7 +48,6 @@ function Deferred() {
Deferred Data Test
- {/* Immediate data should be available right away */}
Immediate: {immediateData.name} @ {immediateData.timestamp}
@@ -74,7 +58,6 @@ function Deferred() {
Loader source: {loaderSource}
- {/* Deferred promise */}
Loading deferred... }
>
@@ -88,7 +71,6 @@ function Deferred() {
/>
- {/* Deferred server function */}
Loading server data...
diff --git a/e2e/react-start/streaming-ssr/src/routes/fast-serial.tsx b/e2e/react-start/streaming-ssr/src/routes/fast-serial.tsx
index 61a47469f4..cc3f0c2b5c 100644
--- a/e2e/react-start/streaming-ssr/src/routes/fast-serial.tsx
+++ b/e2e/react-start/streaming-ssr/src/routes/fast-serial.tsx
@@ -1,26 +1,23 @@
import { createFileRoute } from '@tanstack/react-router'
import { createServerFn } from '@tanstack/react-start'
+import {
+ fastSerialStaticData,
+ makeFastSerialSmallData,
+ sourceMarker,
+} from '../../../../streaming-ssr-fixtures'
-// Server function that returns immediately with minimal data
-const getSmallData = createServerFn({ method: 'GET' }).handler(() => {
- return {
- value: 'small-data',
- timestamp: Date.now(),
- // Track where this data came from - should always be 'server' if SSR works
- source: 'server' as const,
- }
-})
+const getSmallData = createServerFn({ method: 'GET' }).handler(() =>
+ makeFastSerialSmallData(),
+)
export const Route = createFileRoute('/fast-serial')({
loader: async () => {
- // All data is awaited immediately - serialization should complete quickly
const data = await getSmallData()
return {
serverData: data,
- staticData: 'This is static data',
+ staticData: fastSerialStaticData,
timestamp: Date.now(),
- // Track where loader ran - should always be 'server' if SSR works
- loaderSource: typeof window === 'undefined' ? 'server' : 'client',
+ loaderSource: sourceMarker(),
}
},
component: FastSerial,
diff --git a/e2e/react-start/streaming-ssr/src/routes/many-promises.tsx b/e2e/react-start/streaming-ssr/src/routes/many-promises.tsx
index a6d0374972..25cb6511c7 100644
--- a/e2e/react-start/streaming-ssr/src/routes/many-promises.tsx
+++ b/e2e/react-start/streaming-ssr/src/routes/many-promises.tsx
@@ -1,47 +1,9 @@
import { Await, createFileRoute } from '@tanstack/react-router'
import { Suspense } from 'react'
-
-/**
- * Tests streaming with many (15+) deferred promises resolving in various orders.
- * This stresses the serialization system with concurrent promise resolutions.
- */
-
-// Helper to create a promise with a specific delay and value
-function createDelayedPromise(value: T, delayMs: number): Promise {
- return new Promise((resolve) => setTimeout(() => resolve(value), delayMs))
-}
+import { createManyPromises } from '../../../../streaming-ssr-fixtures'
export const Route = createFileRoute('/many-promises')({
- loader: async () => {
- // Create 15 promises with varying delays to test ordering
- // Some resolve quickly, some slowly, some at similar times
- return {
- // Immediate/very fast (0-50ms)
- immediate1: createDelayedPromise('immediate-1', 0),
- immediate2: createDelayedPromise('immediate-2', 10),
- immediate3: createDelayedPromise('immediate-3', 20),
-
- // Fast (50-150ms)
- fast1: createDelayedPromise('fast-1', 50),
- fast2: createDelayedPromise('fast-2', 75),
- fast3: createDelayedPromise('fast-3', 100),
- fast4: createDelayedPromise('fast-4', 125),
-
- // Medium (150-300ms)
- medium1: createDelayedPromise('medium-1', 150),
- medium2: createDelayedPromise('medium-2', 200),
- medium3: createDelayedPromise('medium-3', 250),
-
- // Slow (300-600ms)
- slow1: createDelayedPromise('slow-1', 300),
- slow2: createDelayedPromise('slow-2', 400),
- slow3: createDelayedPromise('slow-3', 500),
-
- // Very slow (600ms+)
- verySlow1: createDelayedPromise('very-slow-1', 600),
- verySlow2: createDelayedPromise('very-slow-2', 800),
- }
- },
+ loader: async () => createManyPromises(),
component: ManyPromises,
})
@@ -85,7 +47,6 @@ function ManyPromises() {
gap: '10px',
}}
>
- {/* Immediate group */}
- {/* Fast group */}
Fast (50-125ms)
@@ -114,7 +74,6 @@ function ManyPromises() {
- {/* Medium group */}
- {/* Slow group */}
Slow (300-500ms)
@@ -142,7 +100,6 @@ function ManyPromises() {
- {/* Very slow group */}
Very Slow (600-800ms)
{
- await new Promise((r) => setTimeout(r, 200))
- return { level: 1, timestamp: Date.now() }
+ await delay(nestedLevelDelays[0])
+ return makeLevelData(1)
})
const getLevel2Data = createServerFn({ method: 'GET' }).handler(async () => {
- await new Promise((r) => setTimeout(r, 400))
- return { level: 2, timestamp: Date.now() }
+ await delay(nestedLevelDelays[1])
+ return makeLevelData(2)
})
const getLevel3Data = createServerFn({ method: 'GET' }).handler(async () => {
- await new Promise((r) => setTimeout(r, 600))
- return { level: 3, timestamp: Date.now() }
+ await delay(nestedLevelDelays[2])
+ return makeLevelData(3)
})
export const Route = createFileRoute('/nested-deferred')({
loader: async () => {
return {
- // Multiple deferred promises that resolve at different times
level1: getLevel1Data(),
level2: getLevel2Data(),
level3: getLevel3Data(),
- // Also a plain deferred promise
- plainDeferred: new Promise((r) =>
- setTimeout(() => r('Plain deferred resolved!'), 300),
- ),
+ plainDeferred: makeDeferred(nestedPlainMessage, nestedPlainDelay),
}
},
component: NestedDeferred,
})
-// Nested component that renders more Await components
function Level1Content({
level2,
level3,
@@ -106,7 +108,6 @@ function NestedDeferred() {
Tests multiple nested deferred promises resolving at different times.
- {/* Plain deferred */}
Loading plain... }
>
@@ -116,7 +117,6 @@ function NestedDeferred() {
/>
- {/* Nested structure */}
Loading level 1...
}
diff --git a/e2e/react-start/streaming-ssr/src/routes/query-heavy.tsx b/e2e/react-start/streaming-ssr/src/routes/query-heavy.tsx
index b20921323c..115ae9f10f 100644
--- a/e2e/react-start/streaming-ssr/src/routes/query-heavy.tsx
+++ b/e2e/react-start/streaming-ssr/src/routes/query-heavy.tsx
@@ -1,167 +1,48 @@
import { queryOptions, useSuspenseQuery } from '@tanstack/react-query'
import { createFileRoute } from '@tanstack/react-router'
import { Suspense } from 'react'
+import {
+ delay,
+ makeQueryData,
+ queryHeavyItems,
+} from '../../../../streaming-ssr-fixtures'
+import type { QueryData } from '../../../../streaming-ssr-fixtures'
-/**
- * Tests multiple useSuspenseQuery calls on a single route.
- * Some queries have synchronous queryFn (return immediately),
- * some have async queryFn with various delays.
- *
- * This stresses the SSR query streaming integration.
- */
+function makeQueryOptions(item: (typeof queryHeavyItems)[number]) {
+ return queryOptions({
+ queryKey: ['streaming-ssr-query-heavy', item.type, item.id],
+ queryFn: (): QueryData | Promise => {
+ if (item.delayMs > 0) {
+ return delay(item.delayMs).then(() => makeQueryData(item))
+ }
-// Synchronous query - returns immediately (no await)
-const syncQuery1 = queryOptions({
- queryKey: ['sync', 1],
- queryFn: () => {
- // Synchronous return - no Promise delay
- return {
- type: 'sync',
- id: 1,
- value: 'sync-value-1',
- source: typeof window === 'undefined' ? 'server' : 'client',
- }
- },
- staleTime: Infinity,
-})
+ return makeQueryData(item)
+ },
+ staleTime: Infinity,
+ })
+}
-const syncQuery2 = queryOptions({
- queryKey: ['sync', 2],
- queryFn: () => {
- return {
- type: 'sync',
- id: 2,
- value: 'sync-value-2',
- source: typeof window === 'undefined' ? 'server' : 'client',
- }
- },
- staleTime: Infinity,
-})
+const syncQuery1 = makeQueryOptions(queryHeavyItems[0])
+const syncQuery2 = makeQueryOptions(queryHeavyItems[1])
+const syncQuery3 = makeQueryOptions(queryHeavyItems[2])
+const fastAsyncQuery1 = makeQueryOptions(queryHeavyItems[3])
+const fastAsyncQuery2 = makeQueryOptions(queryHeavyItems[4])
+const fastAsyncQuery3 = makeQueryOptions(queryHeavyItems[5])
+const slowAsyncQuery1 = makeQueryOptions(queryHeavyItems[6])
+const slowAsyncQuery2 = makeQueryOptions(queryHeavyItems[7])
+const slowAsyncQuery3 = makeQueryOptions(queryHeavyItems[8])
-const syncQuery3 = queryOptions({
- queryKey: ['sync', 3],
- queryFn: () => {
- return {
- type: 'sync',
- id: 3,
- value: 'sync-value-3',
- source: typeof window === 'undefined' ? 'server' : 'client',
- }
- },
- staleTime: Infinity,
-})
-
-// Fast async queries (50-100ms)
-const fastAsyncQuery1 = queryOptions({
- queryKey: ['fast-async', 1],
- queryFn: async () => {
- await new Promise((r) => setTimeout(r, 50))
- return {
- type: 'fast-async',
- id: 1,
- value: 'fast-async-1',
- source: typeof window === 'undefined' ? 'server' : 'client',
- }
- },
- staleTime: Infinity,
-})
-
-const fastAsyncQuery2 = queryOptions({
- queryKey: ['fast-async', 2],
- queryFn: async () => {
- await new Promise((r) => setTimeout(r, 75))
- return {
- type: 'fast-async',
- id: 2,
- value: 'fast-async-2',
- source: typeof window === 'undefined' ? 'server' : 'client',
- }
- },
- staleTime: Infinity,
-})
-
-const fastAsyncQuery3 = queryOptions({
- queryKey: ['fast-async', 3],
- queryFn: async () => {
- await new Promise((r) => setTimeout(r, 100))
- return {
- type: 'fast-async',
- id: 3,
- value: 'fast-async-3',
- source: typeof window === 'undefined' ? 'server' : 'client',
- }
- },
- staleTime: Infinity,
-})
-
-// Slow async queries (200-400ms)
-const slowAsyncQuery1 = queryOptions({
- queryKey: ['slow-async', 1],
- queryFn: async () => {
- await new Promise((r) => setTimeout(r, 200))
- return {
- type: 'slow-async',
- id: 1,
- value: 'slow-async-1',
- source: typeof window === 'undefined' ? 'server' : 'client',
- }
- },
- staleTime: Infinity,
-})
-
-const slowAsyncQuery2 = queryOptions({
- queryKey: ['slow-async', 2],
- queryFn: async () => {
- await new Promise((r) => setTimeout(r, 300))
- return {
- type: 'slow-async',
- id: 2,
- value: 'slow-async-2',
- source: typeof window === 'undefined' ? 'server' : 'client',
- }
- },
- staleTime: Infinity,
-})
-
-const slowAsyncQuery3 = queryOptions({
- queryKey: ['slow-async', 3],
- queryFn: async () => {
- await new Promise((r) => setTimeout(r, 400))
- return {
- type: 'slow-async',
- id: 3,
- value: 'slow-async-3',
- source: typeof window === 'undefined' ? 'server' : 'client',
- }
- },
- staleTime: Infinity,
-})
+type QueryOptions = ReturnType
export const Route = createFileRoute('/query-heavy')({
component: QueryHeavy,
})
-// Individual query components to test Suspense boundaries
-function SyncQueryDisplay({
+function QueryDisplay({
queryOpts,
testId,
}: {
- queryOpts: typeof syncQuery1
- testId: string
-}) {
- const { data } = useSuspenseQuery(queryOpts)
- return (
-
- {data.value} (source: {data.source})
-
- )
-}
-
-function AsyncQueryDisplay({
- queryOpts,
- testId,
-}: {
- queryOpts: typeof fastAsyncQuery1
+ queryOpts: QueryOptions
testId: string
}) {
const { data } = useSuspenseQuery(queryOpts)
@@ -190,27 +71,25 @@ function QueryHeavy() {
marginTop: '20px',
}}
>
- {/* Sync queries - should resolve immediately */}
Sync Queries (immediate)
Loading sync 1...
}
>
-
+
Loading sync 2...}
>
-
+
Loading sync 3...}
>
-
+
- {/* Fast async queries */}
Fast Async Queries (50-100ms)
Loading fast 1...
}
>
-
@@ -228,7 +107,7 @@ function QueryHeavy() {
Loading fast 2...
}
>
-
@@ -238,14 +117,13 @@ function QueryHeavy() {
Loading fast 3...
}
>
-
- {/* Slow async queries */}
Slow Async Queries (200-400ms)
Loading slow 1...
}
>
-
@@ -263,7 +141,7 @@ function QueryHeavy() {
Loading slow 2...
}
>
-
@@ -273,7 +151,7 @@ function QueryHeavy() {
Loading slow 3...
}
>
-
diff --git a/e2e/react-start/streaming-ssr/src/routes/router-html-buffer.tsx b/e2e/react-start/streaming-ssr/src/routes/router-html-buffer.tsx
new file mode 100644
index 0000000000..6fb7bde27b
--- /dev/null
+++ b/e2e/react-start/streaming-ssr/src/routes/router-html-buffer.tsx
@@ -0,0 +1,58 @@
+import { Suspense, useState } from 'react'
+import { Await, createFileRoute } from '@tanstack/react-router'
+import { createRouterHtmlPayload } from '../../../../streaming-ssr-fixtures'
+
+export const Route = createFileRoute('/router-html-buffer')({
+ loader: () => {
+ return {
+ payload: createRouterHtmlPayload(),
+ }
+ },
+ component: RouterHtmlBufferRoute,
+})
+
+function RouterHtmlBufferRoute() {
+ const { payload } = Route.useLoaderData()
+
+ return (
+
+ Router HTML Buffer Reproduction
+ Waiting for the deferred payload...}>
+ (
+
+ )}
+ />
+
+
+ )
+}
+
+function HydratedPayload({
+ payload,
+ source,
+}: {
+ payload: string
+ source: 'server' | 'client'
+}) {
+ const [hydrationResult, setHydrationResult] = useState('not checked')
+
+ return (
+ <>
+ {payload.length}
+
+ {hydrationResult}
+ >
+ )
+}
diff --git a/e2e/react-start/streaming-ssr/src/routes/slow-render.tsx b/e2e/react-start/streaming-ssr/src/routes/slow-render.tsx
index 5dd9772604..a897c519c1 100644
--- a/e2e/react-start/streaming-ssr/src/routes/slow-render.tsx
+++ b/e2e/react-start/streaming-ssr/src/routes/slow-render.tsx
@@ -1,47 +1,36 @@
import { Await, createFileRoute } from '@tanstack/react-router'
import { createServerFn } from '@tanstack/react-start'
import { Suspense } from 'react'
+import {
+ makeDeferredMessage,
+ makeServerData,
+ slowRenderComponents,
+ slowRenderDeferredDelay,
+ slowRenderDeferredMessage,
+ slowRenderQuickName,
+ sourceMarker,
+} from '../../../../streaming-ssr-fixtures'
-// Server function that completes quickly
-const getQuickData = createServerFn({ method: 'GET' }).handler(() => {
- return {
- name: 'Quick data',
- timestamp: Date.now(),
- // Track where this data came from - should always be 'server' if SSR works
- source: 'server' as const,
- }
-})
+const getQuickData = createServerFn({ method: 'GET' }).handler(() =>
+ makeServerData(slowRenderQuickName),
+)
-// Simulate a slow component render by doing work during render
function SlowComponent({ data, index }: { data: string; index: number }) {
- // This simulates a component that takes time to render
const startTime = Date.now()
- while (Date.now() - startTime < 100) {
- // Blocking loop to simulate slow render
- }
+ while (Date.now() - startTime < 100) {}
return {data}
}
export const Route = createFileRoute('/slow-render')({
loader: async () => {
- // All data loads quickly
const quickData = await getQuickData()
return {
quickData,
- // Deferred data that resolves before render might complete
- deferredData: new Promise<{ message: string; source: string }>((r) =>
- setTimeout(
- () =>
- r({
- message: 'Deferred resolved!',
- // Track where this data came from - should always be 'server' if SSR works
- source: typeof window === 'undefined' ? 'server' : 'client',
- }),
- 50,
- ),
+ deferredData: makeDeferredMessage(
+ slowRenderDeferredMessage,
+ slowRenderDeferredDelay,
),
- // Track where loader ran - should always be 'server' if SSR works
- loaderSource: typeof window === 'undefined' ? 'server' : 'client',
+ loaderSource: sourceMarker(),
}
},
component: SlowRender,
@@ -76,10 +65,9 @@ function SlowRender() {
/>
- {/* Multiple slow components to extend render time */}
-
-
-
+ {slowRenderComponents.map((data, index) => (
+
+ ))}
)
}
diff --git a/e2e/react-start/streaming-ssr/src/routes/stream.tsx b/e2e/react-start/streaming-ssr/src/routes/stream.tsx
index c1629204c7..458be61366 100644
--- a/e2e/react-start/streaming-ssr/src/routes/stream.tsx
+++ b/e2e/react-start/streaming-ssr/src/routes/stream.tsx
@@ -1,24 +1,16 @@
import { Await, createFileRoute } from '@tanstack/react-router'
import { Suspense, useEffect, useRef, useState } from 'react'
+import {
+ createChunkStream,
+ createStreamPromise,
+} from '../../../../streaming-ssr-fixtures'
export const Route = createFileRoute('/stream')({
component: StreamRoute,
loader() {
return {
- // A promise that resolves after a short delay
- promise: new Promise((resolve) =>
- setTimeout(() => resolve('promise-resolved'), 150),
- ),
- // A ReadableStream that emits chunks over time
- stream: new ReadableStream({
- async start(controller) {
- for (let i = 0; i < 5; i++) {
- await new Promise((resolve) => setTimeout(resolve, 200))
- controller.enqueue(`chunk-${i}`)
- }
- controller.close()
- },
- }),
+ promise: createStreamPromise(),
+ stream: createChunkStream(),
}
},
})
@@ -33,19 +25,16 @@ function StreamRoute() {
const streamRef = useRef(null)
useEffect(() => {
- // If we're already reading this exact stream, don't start again
if (streamRef.current === stream && readerRef.current) {
return
}
- // Reset state for a new stream
if (streamRef.current !== stream) {
setStreamData([])
setStreamComplete(false)
streamRef.current = stream
}
- // Check if stream is already locked (from a previous render)
if (stream.locked) {
return
}
@@ -65,7 +54,6 @@ function StreamRoute() {
}
setStreamComplete(true)
} catch (e) {
- // Stream was cancelled or errored, ignore
if (!(e instanceof TypeError && String(e).includes('cancelled'))) {
console.error('Stream error:', e)
}
@@ -75,7 +63,6 @@ function StreamRoute() {
fetchStream()
return () => {
- // Cancel the reader on cleanup
if (readerRef.current) {
readerRef.current.cancel().catch(() => {})
readerRef.current = null
@@ -87,7 +74,6 @@ function StreamRoute() {
ReadableStream Test
- {/* Promise data */}
Loading promise...}
>
@@ -97,7 +83,6 @@ function StreamRoute() {
/>
- {/* Stream data */}
Stream chunks:
diff --git a/e2e/react-start/streaming-ssr/src/routes/sync-only.tsx b/e2e/react-start/streaming-ssr/src/routes/sync-only.tsx
index c95a1d467f..67a77a3e9f 100644
--- a/e2e/react-start/streaming-ssr/src/routes/sync-only.tsx
+++ b/e2e/react-start/streaming-ssr/src/routes/sync-only.tsx
@@ -1,22 +1,8 @@
import { createFileRoute } from '@tanstack/react-router'
+import { makeSyncOnlyData } from '../../../../streaming-ssr-fixtures'
-/**
- * This route tests synchronous serialization - no deferred data, no streaming.
- * The loader returns data synchronously (awaited), so crossSerializeStream
- * completes immediately and all bootstrap scripts should be in the initial HTML.
- */
export const Route = createFileRoute('/sync-only')({
- loader: async () => {
- // Simulate a fast synchronous data fetch
- // This data is awaited, not deferred, so serialization completes synchronously
- return {
- message: 'Hello from sync loader!',
- timestamp: Date.now(),
- items: ['item-1', 'item-2', 'item-3'],
- // Track where this data came from - should always be 'server' if SSR works
- source: typeof window === 'undefined' ? 'server' : 'client',
- }
- },
+ loader: async () => makeSyncOnlyData(),
component: SyncOnly,
})
diff --git a/e2e/react-start/streaming-ssr/tests/client-navigation.spec.ts b/e2e/react-start/streaming-ssr/tests/client-navigation.spec.ts
index 91138987ad..8b9b3a8dcc 100644
--- a/e2e/react-start/streaming-ssr/tests/client-navigation.spec.ts
+++ b/e2e/react-start/streaming-ssr/tests/client-navigation.spec.ts
@@ -1,372 +1 @@
-import { expect, test, testWithHydration } from './fixtures'
-
-test.describe('Client-side navigation between all routes', () => {
- test.beforeEach(async ({ page }) => {
- // Start from home page
- await page.goto('/')
- await page.waitForLoadState('networkidle')
- })
-
- test('home -> sync-only -> home works', async ({ page }) => {
- // Navigate to sync-only
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Sync Only' })
- .click()
- await expect(page).toHaveURL('/sync-only')
- await expect(page.getByTestId('sync-message')).toBeVisible()
-
- // Navigate back to home
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Home' })
- .click()
- await expect(page).toHaveURL('/')
- await expect(page.getByTestId('index-title')).toBeVisible()
- })
-
- test('home -> deferred -> home works', async ({ page }) => {
- // Navigate to deferred (use exact: true to avoid matching "Nested Deferred")
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Deferred', exact: true })
- .click()
- await expect(page).toHaveURL('/deferred')
- await expect(page.getByTestId('immediate-data')).toBeVisible()
-
- // Wait for deferred data
- await expect(page.getByTestId('deferred-data')).toBeVisible({
- timeout: 5000,
- })
-
- // Navigate back to home
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Home' })
- .click()
- await expect(page).toHaveURL('/')
- })
-
- test('home -> stream -> home works (no stream locking error)', async ({
- page,
- }) => {
- // This test specifically validates the ReadableStream locking fix
- // Console errors are monitored by the fixture automatically
-
- // Navigate to stream
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Stream' })
- .click()
- await expect(page).toHaveURL('/stream')
-
- // Wait for stream to start (at least one chunk or promise resolved)
- await expect(page.getByTestId('promise-data')).toBeVisible({
- timeout: 5000,
- })
-
- // Navigate back to home before stream completes
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Home' })
- .click()
- await expect(page).toHaveURL('/')
- })
-
- test('home -> stream -> wait for completion -> home works', async ({
- page,
- }) => {
- // Navigate to stream
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Stream' })
- .click()
- await expect(page).toHaveURL('/stream')
-
- // Wait for stream to complete
- await expect(page.getByTestId('stream-complete')).toBeVisible({
- timeout: 10000,
- })
-
- // Navigate back to home
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Home' })
- .click()
- await expect(page).toHaveURL('/')
- await expect(page.getByTestId('index-title')).toBeVisible()
- })
-
- test('home -> stream -> home -> stream again works (fresh stream each time)', async ({
- page,
- }) => {
- // Console errors are monitored by the fixture automatically
-
- // First navigation to stream
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Stream' })
- .click()
- await expect(page).toHaveURL('/stream')
- await expect(page.getByTestId('promise-data')).toBeVisible({
- timeout: 5000,
- })
-
- // Navigate back to home
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Home' })
- .click()
- await expect(page).toHaveURL('/')
-
- // Second navigation to stream - should get fresh stream without errors
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Stream' })
- .click()
- await expect(page).toHaveURL('/stream')
-
- // Wait for stream to complete
- await expect(page.getByTestId('stream-complete')).toBeVisible({
- timeout: 10000,
- })
-
- // Verify all chunks are present
- await expect(page.getByTestId('stream-chunk-0')).toBeVisible()
- await expect(page.getByTestId('stream-chunk-4')).toBeVisible()
- })
-
- test('home -> fast-serial -> home works', async ({ page }) => {
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Fast Serial' })
- .click()
- await expect(page).toHaveURL('/fast-serial')
- await expect(page.getByTestId('server-data')).toBeVisible()
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Home' })
- .click()
- await expect(page).toHaveURL('/')
- })
-
- test('home -> slow-render -> home works', async ({ page }) => {
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Slow Render' })
- .click()
- await expect(page).toHaveURL('/slow-render')
- await expect(page.getByTestId('quick-data')).toBeVisible()
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Home' })
- .click()
- await expect(page).toHaveURL('/')
- })
-
- test('home -> nested-deferred -> home works', async ({ page }) => {
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Nested Deferred' })
- .click()
- await expect(page).toHaveURL('/nested-deferred')
-
- // Wait for all levels to load
- await expect(page.getByTestId('level3-data')).toBeVisible({ timeout: 5000 })
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Home' })
- .click()
- await expect(page).toHaveURL('/')
- })
-
- test('rapid navigation between routes works', async ({ page }) => {
- // Console errors are monitored by the fixture automatically
-
- // Rapid navigation sequence
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Sync Only' })
- .click()
- await expect(page).toHaveURL('/sync-only')
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Deferred', exact: true })
- .click()
- await expect(page).toHaveURL('/deferred')
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Stream' })
- .click()
- await expect(page).toHaveURL('/stream')
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Fast Serial' })
- .click()
- await expect(page).toHaveURL('/fast-serial')
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Slow Render' })
- .click()
- await expect(page).toHaveURL('/slow-render')
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Nested Deferred' })
- .click()
- await expect(page).toHaveURL('/nested-deferred')
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Home' })
- .click()
- await expect(page).toHaveURL('/')
- })
-})
-
-test.describe('Direct navigation followed by client navigation', () => {
- test('direct to stream -> client nav to deferred works', async ({ page }) => {
- // Direct navigation to stream
- await page.goto('/stream')
- await expect(page.getByTestId('promise-data')).toBeVisible({
- timeout: 5000,
- })
-
- // Client navigation to deferred (use exact: true)
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Deferred', exact: true })
- .click()
- await expect(page).toHaveURL('/deferred')
- await expect(page.getByTestId('immediate-data')).toBeVisible()
- })
-
- test('direct to deferred -> client nav to stream works', async ({ page }) => {
- // Console errors are monitored by the fixture automatically
-
- // Direct navigation to deferred
- await page.goto('/deferred')
- await expect(page.getByTestId('immediate-data')).toBeVisible()
-
- // Client navigation to stream
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Stream' })
- .click()
- await expect(page).toHaveURL('/stream')
- await expect(page.getByTestId('stream-complete')).toBeVisible({
- timeout: 10000,
- })
- })
-
- test('direct to sync-only -> client nav to all routes works', async ({
- page,
- }) => {
- await page.goto('/sync-only')
- await expect(page.getByTestId('sync-message')).toBeVisible()
-
- // Navigate through all routes
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Deferred', exact: true })
- .click()
- await expect(page).toHaveURL('/deferred')
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Stream' })
- .click()
- await expect(page).toHaveURL('/stream')
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Fast Serial' })
- .click()
- await expect(page).toHaveURL('/fast-serial')
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Home' })
- .click()
- await expect(page).toHaveURL('/')
- })
-})
-
-testWithHydration.describe('Hydration after client navigation', () => {
- testWithHydration(
- 'interactive elements work after navigating to deferred',
- async ({ page }) => {
- await page.goto('/')
- await page.waitForLoadState('networkidle')
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Deferred', exact: true })
- .click()
- await expect(page).toHaveURL('/deferred')
-
- // Wait for the page to be fully loaded
- await expect(page.getByTestId('immediate-data')).toBeVisible()
- },
- )
-
- testWithHydration(
- 'interactive elements work after navigating to fast-serial',
- async ({ page }) => {
- await page.goto('/')
- await page.waitForLoadState('networkidle')
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Fast Serial' })
- .click()
- await expect(page).toHaveURL('/fast-serial')
-
- // Wait for page to load
- await expect(page.getByTestId('server-data')).toBeVisible()
- },
- )
-
- testWithHydration(
- 'interactive elements work after navigating to nested-deferred',
- async ({ page }) => {
- await page.goto('/')
- await page.waitForLoadState('networkidle')
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Nested Deferred' })
- .click()
- await expect(page).toHaveURL('/nested-deferred')
-
- // Wait for page to load
- await expect(page.getByTestId('plain-deferred')).toBeVisible({
- timeout: 5000,
- })
- },
- )
-
- testWithHydration(
- 'interactive elements work after navigating to slow-render',
- async ({ page }) => {
- await page.goto('/')
- await page.waitForLoadState('networkidle')
-
- await page
- .getByRole('navigation')
- .getByRole('link', { name: 'Slow Render' })
- .click()
- await expect(page).toHaveURL('/slow-render')
-
- // Wait for page to load (slow-render has blocking loops)
- await expect(page.getByTestId('quick-data')).toBeVisible()
- },
- )
-})
+import '../../../streaming-ssr-specs/client-navigation'
diff --git a/e2e/react-start/streaming-ssr/tests/concurrent.spec.ts b/e2e/react-start/streaming-ssr/tests/concurrent.spec.ts
index 10e32c6809..8625473a58 100644
--- a/e2e/react-start/streaming-ssr/tests/concurrent.spec.ts
+++ b/e2e/react-start/streaming-ssr/tests/concurrent.spec.ts
@@ -1,100 +1 @@
-import { expect, test, testWithHydration } from './fixtures'
-
-test.describe('Concurrent promise resolution (15 promises in 3 batches)', () => {
- test('all concurrent promises resolve correctly', async ({ page }) => {
- await page.goto('/concurrent')
-
- // Batch 1 (5 promises at 100ms)
- await expect(page.getByTestId('concurrent-1-1')).toContainText(
- 'concurrent-1',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('concurrent-1-2')).toContainText(
- 'concurrent-2',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('concurrent-1-3')).toContainText(
- 'concurrent-3',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('concurrent-1-4')).toContainText(
- 'concurrent-4',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('concurrent-1-5')).toContainText(
- 'concurrent-5',
- { timeout: 5000 },
- )
-
- // Batch 2 (5 promises at 200ms)
- await expect(page.getByTestId('concurrent-2-1')).toContainText(
- 'concurrent-1',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('concurrent-2-2')).toContainText(
- 'concurrent-2',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('concurrent-2-3')).toContainText(
- 'concurrent-3',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('concurrent-2-4')).toContainText(
- 'concurrent-4',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('concurrent-2-5')).toContainText(
- 'concurrent-5',
- { timeout: 5000 },
- )
-
- // Batch 3 (5 promises at 300ms)
- await expect(page.getByTestId('concurrent-3-1')).toContainText(
- 'concurrent-1',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('concurrent-3-2')).toContainText(
- 'concurrent-2',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('concurrent-3-3')).toContainText(
- 'concurrent-3',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('concurrent-3-4')).toContainText(
- 'concurrent-4',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('concurrent-3-5')).toContainText(
- 'concurrent-5',
- { timeout: 5000 },
- )
- })
-
- test('batch 1 resolves before batch 3', async ({ page }) => {
- await page.goto('/concurrent', { waitUntil: 'commit' })
-
- // Batch 1 should be visible before batch 3
- await expect(page.getByTestId('concurrent-1-1')).toBeVisible({
- timeout: 3000,
- })
-
- // Eventually batch 3 should also be visible
- await expect(page.getByTestId('concurrent-3-5')).toBeVisible({
- timeout: 5000,
- })
- })
-
- testWithHydration(
- 'hydration works with concurrent resolutions',
- async ({ page }) => {
- await page.goto('/concurrent')
- await page.waitForLoadState('networkidle')
-
- // Wait for all batches
- await expect(page.getByTestId('concurrent-3-5')).toBeVisible({
- timeout: 5000,
- })
- },
- )
-})
+import '../../../streaming-ssr-specs/concurrent'
diff --git a/e2e/react-start/streaming-ssr/tests/deferred-rejection.spec.ts b/e2e/react-start/streaming-ssr/tests/deferred-rejection.spec.ts
index 3b8144072c..355b5019bc 100644
--- a/e2e/react-start/streaming-ssr/tests/deferred-rejection.spec.ts
+++ b/e2e/react-start/streaming-ssr/tests/deferred-rejection.spec.ts
@@ -1,21 +1 @@
-import { expect, test } from './fixtures'
-
-test.use({
- whitelistErrors: ['Error in deferred object'],
-})
-
-test('rejected deferred Await renders the route error boundary without killing SSR', async ({
- page,
-}) => {
- await page.goto('/deferred-rejection')
-
- await expect(page.getByTestId('deferred-error-boundary')).toContainText(
- 'Error in deferred object',
- { timeout: 5000 },
- )
-
- await page.goto('/sync-only')
- await expect(page.getByTestId('sync-message')).toContainText(
- 'Hello from sync loader!',
- )
-})
+import '../../../streaming-ssr-specs/deferred-rejection'
diff --git a/e2e/react-start/streaming-ssr/tests/deferred.spec.ts b/e2e/react-start/streaming-ssr/tests/deferred.spec.ts
index 90ee16edc0..3145897d7b 100644
--- a/e2e/react-start/streaming-ssr/tests/deferred.spec.ts
+++ b/e2e/react-start/streaming-ssr/tests/deferred.spec.ts
@@ -1,120 +1 @@
-import { expect, test, testWithHydration } from './fixtures'
-
-test.describe('Deferred data streaming', () => {
- test('shows immediate data right away and deferred data after loading', async ({
- page,
- }) => {
- await page.goto('/deferred')
-
- // Immediate data should be available right away
- await expect(page.getByTestId('immediate-data')).toBeVisible()
- await expect(page.getByTestId('immediate-data')).toContainText(
- 'Immediate: Fast User',
- )
-
- // Verify immediate data came from server
- await expect(page.getByTestId('immediate-source')).toContainText(
- 'Immediate source: server',
- )
- await expect(page.getByTestId('loader-source')).toContainText(
- 'Loader source: server',
- )
-
- // Deferred data should eventually appear with server source
- await expect(page.getByTestId('deferred-data')).toContainText(
- 'Deferred data loaded!',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('deferred-data')).toContainText(
- 'source: server',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('deferred-server-data')).toContainText(
- 'Server: Slow User',
- { timeout: 5000 },
- )
- await expect(page.getByTestId('deferred-server-data')).toContainText(
- 'source: server',
- { timeout: 5000 },
- )
- })
-
- test('shows loading states for deferred content', async ({ page }) => {
- // Navigate with cache disabled to ensure fresh load
- await page.goto('/deferred', { waitUntil: 'commit' })
-
- // Should see loading states initially (may be very brief)
- // We check that deferred content eventually shows
- await expect(page.getByTestId('deferred-data')).toBeVisible({
- timeout: 5000,
- })
- await expect(page.getByTestId('deferred-server-data')).toBeVisible({
- timeout: 5000,
- })
- })
-
- testWithHydration(
- 'hydration works - interactive elements respond',
- async ({ page }) => {
- await page.goto('/deferred')
- await page.waitForLoadState('networkidle')
-
- // Wait for all deferred content to load
- await expect(page.getByTestId('deferred-data')).toBeVisible({
- timeout: 5000,
- })
-
- // Verify all data came from server after hydration
- await expect(page.getByTestId('loader-source')).toContainText(
- 'Loader source: server',
- )
- await expect(page.getByTestId('deferred-data')).toContainText(
- 'source: server',
- )
- },
- )
-
- test('client-side navigation to deferred route works', async ({ page }) => {
- await page.goto('/')
- await page.waitForLoadState('networkidle')
-
- // Navigate via client-side routing using nav link
- await page.getByRole('link', { name: 'Deferred' }).first().click()
- await expect(page).toHaveURL('/deferred')
-
- // Data should load
- await expect(page.getByTestId('immediate-data')).toContainText('Fast User')
- await expect(page.getByTestId('deferred-data')).toContainText(
- 'Deferred data loaded!',
- { timeout: 5000 },
- )
- })
-
- test('all data sources are server - proves SSR streaming works', async ({
- page,
- }) => {
- await page.goto('/deferred')
-
- // Wait for all deferred content
- await expect(page.getByTestId('deferred-data')).toBeVisible({
- timeout: 5000,
- })
- await expect(page.getByTestId('deferred-server-data')).toBeVisible({
- timeout: 5000,
- })
-
- // Count all elements showing 'server' source - should be 4:
- // 1. immediate-source
- // 2. loader-source
- // 3. deferred-data (contains "source: server")
- // 4. deferred-server-data (contains "source: server")
- await expect(page.getByTestId('immediate-source')).toContainText('server')
- await expect(page.getByTestId('loader-source')).toContainText('server')
- await expect(page.getByTestId('deferred-data')).toContainText(
- 'source: server',
- )
- await expect(page.getByTestId('deferred-server-data')).toContainText(
- 'source: server',
- )
- })
-})
+import '../../../streaming-ssr-specs/deferred'
diff --git a/e2e/react-start/streaming-ssr/tests/fast-serial.spec.ts b/e2e/react-start/streaming-ssr/tests/fast-serial.spec.ts
index 339d6408ea..95df0555e2 100644
--- a/e2e/react-start/streaming-ssr/tests/fast-serial.spec.ts
+++ b/e2e/react-start/streaming-ssr/tests/fast-serial.spec.ts
@@ -1,72 +1 @@
-import { expect, test, testWithHydration } from './fixtures'
-
-test.describe('Fast serialization (serialization completes before render)', () => {
- test('initial HTML contains router bootstrap + barrier', async ({ page }) => {
- let responseHtml = ''
- await page.route('/fast-serial', async (route) => {
- const response = await route.fetch()
- responseHtml = await response.text()
- await route.fulfill({ response })
- })
-
- await page.goto('/fast-serial')
- await expect(page.getByTestId('server-data')).toBeVisible()
-
- expect(responseHtml).toContain('$_TSR')
- expect(responseHtml).toContain('$_TSR.router')
- expect(responseHtml).toContain('$_TSR.e()')
- expect(responseHtml).toContain('$tsr-stream-barrier')
- })
-
- test('all data is available immediately', async ({ page }) => {
- await page.goto('/fast-serial')
- await page.waitForLoadState('networkidle')
-
- // All data should be visible
- await expect(page.getByTestId('server-data')).toContainText('small-data')
- await expect(page.getByTestId('static-data')).toContainText(
- 'This is static data',
- )
- await expect(page.getByTestId('loader-timestamp')).toBeVisible()
-
- // Verify data came from server (proves SSR streaming worked)
- await expect(page.getByTestId('loader-source')).toContainText(
- 'Loader source: server',
- )
- await expect(page.getByTestId('server-fn-source')).toContainText(
- 'Server function source: server',
- )
- })
-
- testWithHydration('hydration works correctly', async ({ page }) => {
- await page.goto('/fast-serial')
- await page.waitForLoadState('networkidle')
-
- // Verify data came from server after hydration
- await expect(page.getByTestId('loader-source')).toContainText(
- 'Loader source: server',
- )
- })
-
- test('direct navigation renders correctly', async ({ page }) => {
- // Direct navigation (SSR)
- await page.goto('/fast-serial')
-
- // Should render without errors and show server source
- await expect(page.getByTestId('server-data')).toBeVisible()
- await expect(page.getByTestId('loader-source')).toContainText(
- 'Loader source: server',
- )
- })
-
- test('client-side navigation works', async ({ page }) => {
- await page.goto('/')
- await page.waitForLoadState('networkidle')
-
- // Navigate via nav link
- await page.getByRole('link', { name: 'Fast Serial' }).first().click()
- await expect(page).toHaveURL('/fast-serial')
-
- await expect(page.getByTestId('server-data')).toContainText('small-data')
- })
-})
+import '../../../streaming-ssr-specs/fast-serial'
diff --git a/e2e/react-start/streaming-ssr/tests/fixtures.ts b/e2e/react-start/streaming-ssr/tests/fixtures.ts
deleted file mode 100644
index 71c564aebe..0000000000
--- a/e2e/react-start/streaming-ssr/tests/fixtures.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-import { test as base, expect, type Page } from '@playwright/test'
-
-/**
- * Verifies that React hydration has completed by clicking the global
- * hydration check button and verifying the status changes.
- *
- * This is the canonical way to verify hydration in streaming-ssr tests.
- * The HydrationCheck component is rendered in the root layout (__root.tsx).
- *
- * The function retries clicking until the status changes to 'hydrated',
- * which handles the case where the button is visible from SSR before
- * React has finished hydrating.
- */
-async function verifyHydration(
- page: Page,
- options: { timeout?: number } = {},
-): Promise {
- const timeout = options.timeout ?? 10000
- const button = page.getByTestId('hydration-check-btn')
- const status = page.getByTestId('hydration-status')
-
- // Ensure the button is visible
- await expect(button).toBeVisible()
-
- // Retry clicking until hydration succeeds
- // This handles the case where SSR renders the button before React hydrates
- await expect(async () => {
- // Click the button to trigger hydration verification
- await button.click()
-
- // Check if the status changed to 'hydrated'
- await expect(status).toHaveText('hydrated', { timeout: 100 })
- }).toPass({ timeout })
-}
-
-export interface StreamingSsrOptions {
- /**
- * List of error message patterns to ignore in console output.
- */
- whitelistErrors: Array
-}
-
-/**
- * Base test fixture for streaming-ssr e2e tests.
- * Provides console error monitoring.
- */
-export const test = base.extend({
- whitelistErrors: [[], { option: true }],
-
- page: async ({ page, whitelistErrors }, use) => {
- const errorMessages: Array = []
-
- page.on('console', (m) => {
- if (m.type() === 'error') {
- const text = m.text()
- for (const whitelistError of whitelistErrors) {
- if (
- (typeof whitelistError === 'string' &&
- text.includes(whitelistError)) ||
- (whitelistError instanceof RegExp && whitelistError.test(text))
- ) {
- return
- }
- }
- errorMessages.push(text)
- }
- })
-
- await use(page)
-
- // Assert no unexpected console errors
- expect(errorMessages).toEqual([])
- },
-})
-
-/**
- * Extended test fixture that automatically verifies hydration at the end.
- * Use this for tests where you want to confirm React hydration succeeded.
- */
-export const testWithHydration = test.extend({
- page: async ({ page }, use) => {
- await use(page)
-
- // Automatically verify hydration at the end of the test
- await verifyHydration(page)
- },
-})
-
-// Re-export expect for convenience
-export { expect }
diff --git a/e2e/react-start/streaming-ssr/tests/home.spec.ts b/e2e/react-start/streaming-ssr/tests/home.spec.ts
index e231d007fb..5d49d34a56 100644
--- a/e2e/react-start/streaming-ssr/tests/home.spec.ts
+++ b/e2e/react-start/streaming-ssr/tests/home.spec.ts
@@ -1,34 +1 @@
-import { expect, test, testWithHydration } from './fixtures'
-
-test.describe('Home page', () => {
- testWithHydration(
- 'renders index page with all navigation links',
- async ({ page }) => {
- await page.goto('/')
- await page.waitForLoadState('networkidle')
-
- await expect(page.getByTestId('index-title')).toContainText(
- 'Streaming SSR Test Scenarios',
- )
- // Check links exist (they're in the nav and the body)
- await expect(
- page.getByRole('link', { name: 'Deferred' }).first(),
- ).toBeVisible()
- await expect(
- page.getByRole('link', { name: 'Stream' }).first(),
- ).toBeVisible()
- },
- )
-
- testWithHydration(
- 'navigation from home to routes works',
- async ({ page }) => {
- await page.goto('/')
- await page.waitForLoadState('networkidle')
-
- // Use the link in the content (not nav)
- await page.getByTestId('link-deferred').click()
- await expect(page).toHaveURL('/deferred')
- },
- )
-})
+import '../../../streaming-ssr-specs/home'
diff --git a/e2e/react-start/streaming-ssr/tests/many-promises.spec.ts b/e2e/react-start/streaming-ssr/tests/many-promises.spec.ts
index 034ab74220..b747bd7d0a 100644
--- a/e2e/react-start/streaming-ssr/tests/many-promises.spec.ts
+++ b/e2e/react-start/streaming-ssr/tests/many-promises.spec.ts
@@ -1,93 +1 @@
-import { expect, test, testWithHydration } from './fixtures'
-
-test.describe('Many promises streaming (15 deferred)', () => {
- test('all 15 promises eventually resolve', async ({ page }) => {
- await page.goto('/many-promises')
-
- // Immediate group (0-20ms)
- await expect(page.getByTestId('immediate-1')).toContainText('immediate-1', {
- timeout: 5000,
- })
- await expect(page.getByTestId('immediate-2')).toContainText('immediate-2', {
- timeout: 5000,
- })
- await expect(page.getByTestId('immediate-3')).toContainText('immediate-3', {
- timeout: 5000,
- })
-
- // Fast group (50-125ms)
- await expect(page.getByTestId('fast-1')).toContainText('fast-1', {
- timeout: 5000,
- })
- await expect(page.getByTestId('fast-2')).toContainText('fast-2', {
- timeout: 5000,
- })
- await expect(page.getByTestId('fast-3')).toContainText('fast-3', {
- timeout: 5000,
- })
- await expect(page.getByTestId('fast-4')).toContainText('fast-4', {
- timeout: 5000,
- })
-
- // Medium group (150-250ms)
- await expect(page.getByTestId('medium-1')).toContainText('medium-1', {
- timeout: 5000,
- })
- await expect(page.getByTestId('medium-2')).toContainText('medium-2', {
- timeout: 5000,
- })
- await expect(page.getByTestId('medium-3')).toContainText('medium-3', {
- timeout: 5000,
- })
-
- // Slow group (300-500ms)
- await expect(page.getByTestId('slow-1')).toContainText('slow-1', {
- timeout: 5000,
- })
- await expect(page.getByTestId('slow-2')).toContainText('slow-2', {
- timeout: 5000,
- })
- await expect(page.getByTestId('slow-3')).toContainText('slow-3', {
- timeout: 5000,
- })
-
- // Very slow group (600-800ms)
- await expect(page.getByTestId('very-slow-1')).toContainText('very-slow-1', {
- timeout: 5000,
- })
- await expect(page.getByTestId('very-slow-2')).toContainText('very-slow-2', {
- timeout: 5000,
- })
- })
-
- testWithHydration('hydration works with many promises', async ({ page }) => {
- await page.goto('/many-promises')
- await page.waitForLoadState('networkidle')
-
- // Wait for all promises to resolve
- await expect(page.getByTestId('very-slow-2')).toBeVisible({ timeout: 5000 })
- })
-
- test('client-side navigation works', async ({ page }) => {
- await page.goto('/')
- await page.waitForLoadState('networkidle')
-
- // Navigate via nav link
- await page.getByRole('link', { name: 'Many Promises' }).click()
- await expect(page).toHaveURL('/many-promises')
-
- // All promises should eventually resolve
- await expect(page.getByTestId('very-slow-2')).toBeVisible({ timeout: 5000 })
- })
-
- test('fast promises resolve before slow ones', async ({ page }) => {
- // Navigate and check ordering - faster promises should be visible first
- await page.goto('/many-promises', { waitUntil: 'commit' })
-
- // Immediate promises should appear first
- await expect(page.getByTestId('immediate-1')).toBeVisible({ timeout: 2000 })
-
- // By the time we check very-slow, all should be visible
- await expect(page.getByTestId('very-slow-2')).toBeVisible({ timeout: 5000 })
- })
-})
+import '../../../streaming-ssr-specs/many-promises'
diff --git a/e2e/react-start/streaming-ssr/tests/nested-deferred.spec.ts b/e2e/react-start/streaming-ssr/tests/nested-deferred.spec.ts
index dbf6df4265..8df20a8a95 100644
--- a/e2e/react-start/streaming-ssr/tests/nested-deferred.spec.ts
+++ b/e2e/react-start/streaming-ssr/tests/nested-deferred.spec.ts
@@ -1,77 +1 @@
-import { expect, test, testWithHydration } from './fixtures'
-
-test.describe('Nested deferred (multiple levels of deferred data)', () => {
- test('all levels of deferred data eventually resolve', async ({ page }) => {
- await page.goto('/nested-deferred')
-
- // Plain deferred should resolve first (300ms)
- await expect(page.getByTestId('plain-deferred')).toContainText(
- 'Plain deferred resolved!',
- { timeout: 5000 },
- )
-
- // Level 1 should resolve (200ms)
- await expect(page.getByTestId('level1-data')).toContainText('Level 1:', {
- timeout: 5000,
- })
-
- // Level 2 should resolve (400ms)
- await expect(page.getByTestId('level2-data')).toContainText('Level 2:', {
- timeout: 5000,
- })
-
- // Level 3 should resolve (600ms)
- await expect(page.getByTestId('level3-data')).toContainText('Level 3:', {
- timeout: 5000,
- })
- })
-
- test('shows loading states while data is loading', async ({ page }) => {
- // Use fast navigation to catch loading states
- await page.goto('/nested-deferred', { waitUntil: 'commit' })
-
- // Eventually all data should be visible
- await expect(page.getByTestId('level3-data')).toBeVisible({
- timeout: 10000,
- })
- })
-
- testWithHydration(
- 'hydration works with nested deferred',
- async ({ page }) => {
- await page.goto('/nested-deferred')
- await page.waitForLoadState('networkidle')
-
- // Wait for all data
- await expect(page.getByTestId('level3-data')).toBeVisible({
- timeout: 10000,
- })
- },
- )
-
- test('client-side navigation works', async ({ page }) => {
- await page.goto('/')
- await page.waitForLoadState('networkidle')
-
- // Navigate via nav link
- await page.getByRole('link', { name: 'Nested Deferred' }).first().click()
- await expect(page).toHaveURL('/nested-deferred')
-
- // All levels should eventually render
- await expect(page.getByTestId('level3-data')).toBeVisible({
- timeout: 10000,
- })
- })
-
- test('data resolves in expected order (fastest first)', async ({ page }) => {
- await page.goto('/nested-deferred')
-
- // Wait for all to be visible
- await expect(page.getByTestId('level1-data')).toBeVisible({ timeout: 5000 })
- await expect(page.getByTestId('level2-data')).toBeVisible({ timeout: 5000 })
- await expect(page.getByTestId('level3-data')).toBeVisible({ timeout: 5000 })
- await expect(page.getByTestId('plain-deferred')).toBeVisible({
- timeout: 5000,
- })
- })
-})
+import '../../../streaming-ssr-specs/nested-deferred'
diff --git a/e2e/react-start/streaming-ssr/tests/preview-streaming.spec.ts b/e2e/react-start/streaming-ssr/tests/preview-streaming.spec.ts
index 319219c519..34241cfbaa 100644
--- a/e2e/react-start/streaming-ssr/tests/preview-streaming.spec.ts
+++ b/e2e/react-start/streaming-ssr/tests/preview-streaming.spec.ts
@@ -1,21 +1 @@
-import { expect, test } from './fixtures'
-
-test('vite preview streams HTML incrementally', async ({ page }) => {
- // /deferred has immediate data + deferred data with a ~1s delay.
- // Without streaming, compression buffers the entire response.
- await page.goto('/deferred', { waitUntil: 'commit' })
-
- // Immediate data should arrive in the first chunk
- await expect(page.getByTestId('immediate-data')).toBeVisible({
- timeout: 3000,
- })
-
- // Deferred data (1s delay) should still be loading at this point
- await expect(page.getByTestId('deferred-loading')).toBeVisible()
-
- // Wait for it to resolve
- await expect(page.getByTestId('deferred-data')).toContainText(
- 'Deferred data loaded!',
- { timeout: 5000 },
- )
-})
+import '../../../streaming-ssr-specs/preview-streaming'
diff --git a/e2e/react-start/streaming-ssr/tests/query-heavy.spec.ts b/e2e/react-start/streaming-ssr/tests/query-heavy.spec.ts
index 8e735040c2..e0d617106c 100644
--- a/e2e/react-start/streaming-ssr/tests/query-heavy.spec.ts
+++ b/e2e/react-start/streaming-ssr/tests/query-heavy.spec.ts
@@ -1,168 +1,18 @@
-import { expect, test, testWithHydration } from './fixtures'
+import '../../../streaming-ssr-specs/query-heavy'
+import { expect, test } from '../../../streaming-ssr-assertions'
-test.describe('Query heavy route (9 useSuspenseQuery)', () => {
- test('all queries resolve with server data', async ({ page }) => {
- await page.goto('/query-heavy')
+test('batches same-turn queries into one stream chunk', async ({ request }) => {
+ const response = await request.get('/query-heavy')
+ const html = await response.text()
+ const scripts = Array.from(
+ html.matchAll(/', endIndex)
-
- expect(endIndex).toBeGreaterThan(-1)
- expect(lastScriptOpen).toBeGreaterThan(lastScriptClose)
- expect(slowAsyncPayloadIndex).toBeGreaterThan(-1)
- expect(slowAsyncPayloadIndex).toBeLessThan(endIndex)
- expect(html.slice(lastScriptOpen, endIndex)).toContain('.return(void 0)')
- expect(endIndex).toBeLessThan(html.indexOf(''))
- })
-
- test('batches same-turn queries into one stream chunk', async ({
- request,
- }) => {
- const response = await request.get('/query-heavy')
- const html = await response.text()
- const scripts = Array.from(
- html.matchAll(/', endIndex)
+ const scriptCloseIndex = html.indexOf('', endIndex)
+ const bodyCloseIndex = html.indexOf('