From 557bf2dc886fcb9941e06db4ef5152b10d55255a Mon Sep 17 00:00:00 2001
From: Manuel Schiller <manuel.schiller@caligano.de>
Date: Sat, 7 Feb 2026 00:22:28 +0100
Subject: [PATCH 1/5] feat: add transformAssetUrls

---
 docs/start/config.json                        |   4 +
 .../framework/react/guide/cdn-asset-urls.md   | 196 ++++++++++++
 .../transform-asset-urls/.gitignore           |  18 ++
 .../transform-asset-urls/.prettierignore      |   4 +
 .../transform-asset-urls/package.json         |  54 ++++
 .../transform-asset-urls/playwright.config.ts |  63 ++++
 .../transform-asset-urls/src/routeTree.gen.ts |  86 ++++++
 .../transform-asset-urls/src/router.tsx       |  12 +
 .../src/routes/__root.tsx                     |  40 +++
 .../src/routes/about.module.css               |  14 +
 .../transform-asset-urls/src/routes/about.tsx |  19 ++
 .../transform-asset-urls/src/routes/index.tsx |  19 ++
 .../transform-asset-urls/src/server.ts        |  56 ++++
 .../transform-asset-urls/src/styles/app.css   |  11 +
 .../transform-asset-urls/tests/cdn-server.mjs |  28 ++
 .../tests/transform-asset-urls.spec.ts        | 195 ++++++++++++
 .../transform-asset-urls/tsconfig.json        |  22 ++
 .../transform-asset-urls/vite.config.ts       |  17 ++
 .../src/createStartHandler.ts                 | 232 +++++++++++++-
 packages/start-server-core/src/index.tsx      |   9 +
 .../start-server-core/src/router-manifest.ts  |  34 +--
 .../src/transformAssetUrls.ts                 | 284 ++++++++++++++++++
 pnpm-lock.yaml                                |  79 ++++-
 23 files changed, 1456 insertions(+), 40 deletions(-)
 create mode 100644 docs/start/framework/react/guide/cdn-asset-urls.md
 create mode 100644 e2e/react-start/transform-asset-urls/.gitignore
 create mode 100644 e2e/react-start/transform-asset-urls/.prettierignore
 create mode 100644 e2e/react-start/transform-asset-urls/package.json
 create mode 100644 e2e/react-start/transform-asset-urls/playwright.config.ts
 create mode 100644 e2e/react-start/transform-asset-urls/src/routeTree.gen.ts
 create mode 100644 e2e/react-start/transform-asset-urls/src/router.tsx
 create mode 100644 e2e/react-start/transform-asset-urls/src/routes/__root.tsx
 create mode 100644 e2e/react-start/transform-asset-urls/src/routes/about.module.css
 create mode 100644 e2e/react-start/transform-asset-urls/src/routes/about.tsx
 create mode 100644 e2e/react-start/transform-asset-urls/src/routes/index.tsx
 create mode 100644 e2e/react-start/transform-asset-urls/src/server.ts
 create mode 100644 e2e/react-start/transform-asset-urls/src/styles/app.css
 create mode 100644 e2e/react-start/transform-asset-urls/tests/cdn-server.mjs
 create mode 100644 e2e/react-start/transform-asset-urls/tests/transform-asset-urls.spec.ts
 create mode 100644 e2e/react-start/transform-asset-urls/tsconfig.json
 create mode 100644 e2e/react-start/transform-asset-urls/vite.config.ts
 create mode 100644 packages/start-server-core/src/transformAssetUrls.ts

diff --git a/docs/start/config.json b/docs/start/config.json
index 396b1be4af..63604bea87 100644
--- a/docs/start/config.json
+++ b/docs/start/config.json
@@ -137,6 +137,10 @@
               "label": "Server Entry Point",
               "to": "framework/react/guide/server-entry-point"
             },
+            {
+              "label": "CDN Asset URLs",
+              "to": "framework/react/guide/cdn-asset-urls"
+            },
             {
               "label": "Client Entry Point",
               "to": "framework/react/guide/client-entry-point"
diff --git a/docs/start/framework/react/guide/cdn-asset-urls.md b/docs/start/framework/react/guide/cdn-asset-urls.md
new file mode 100644
index 0000000000..0c5671acdb
--- /dev/null
+++ b/docs/start/framework/react/guide/cdn-asset-urls.md
@@ -0,0 +1,196 @@
+---
+id: cdn-asset-urls
+title: CDN Asset URLs
+---
+
+# CDN Asset URLs
+
+> **Experimental:** `transformAssetUrls` is experimental and subject to change.
+
+When deploying to production, you may want to serve your static assets (JavaScript, CSS) from a CDN. The `transformAssetUrls` option on `createStartHandler` lets you rewrite asset URLs at runtime — for example, prepending a CDN origin that is only known when the server starts.
+
+## Why Runtime URL Rewriting?
+
+Vite's `base` config is evaluated at build time. If your CDN URL is determined at deploy time (via environment variables, dynamic configuration, etc.), you need a way to rewrite URLs at runtime. `transformAssetUrls` solves this for the URLs that TanStack Start manages in its manifest:
+
+- `<link rel="modulepreload">` tags (JS preloads)
+- `<link rel="stylesheet">` tags (CSS)
+- The client entry `<script>` tag
+
+## Basic Usage
+
+### String Prefix
+
+The simplest usage is passing a string. Every manifest asset URL will be prefixed with it:
+
+```tsx
+// src/server.ts
+import {
+  createStartHandler,
+  defaultStreamHandler,
+} from '@tanstack/react-start/server'
+import { createServerEntry } from '@tanstack/react-start/server-entry'
+import { getRequest } from '@tanstack/react-start/server'
+
+const handler = createStartHandler({
+  handler: defaultStreamHandler,
+  transformAssetUrls: process.env.CDN_ORIGIN || '',
+})
+
+export default createServerEntry({ fetch: handler })
+```
+
+If `CDN_ORIGIN` is `https://cdn.example.com` and an asset URL is `/assets/index-abc123.js`, the resulting URL will be `https://cdn.example.com/assets/index-abc123.js`.
+
+When the string is empty (or not set), the URLs are left unchanged.
+
+### Callback
+
+For more control, pass a callback that receives `{ url, type }` and returns a new URL (or a `Promise` of one). If you need the request, call `getRequest()` inside the callback. Like the string form, the result is cached after the first request by default:
+
+```tsx
+// src/server.ts
+import {
+  createStartHandler,
+  defaultStreamHandler,
+} from '@tanstack/react-start/server'
+import { createServerEntry } from '@tanstack/react-start/server-entry'
+import { getRequest } from '@tanstack/react-start/server'
+
+const handler = createStartHandler({
+  handler: defaultStreamHandler,
+  transformAssetUrls: ({ url, type }) => {
+    // Only rewrite JS and CSS, leave client entry unchanged
+    if (type === 'clientEntry') return url
+    return `https://cdn.example.com${url}`
+  },
+})
+
+export default createServerEntry({ fetch: handler })
+```
+
+The `type` parameter tells you what kind of asset URL is being transformed:
+
+| `type`            | Description                                          |
+| ----------------- | ---------------------------------------------------- |
+| `'modulepreload'` | JS module preload URL (`<link rel="modulepreload">`) |
+| `'stylesheet'`    | CSS stylesheet URL (`<link rel="stylesheet">`)       |
+| `'clientEntry'`   | Client entry module URL (used in `import('...')`)    |
+
+### Object Form (Explicit Cache Control)
+
+For per-request transforms — where the CDN URL depends on request-specific data like headers — use the object form with `cache: false`:
+
+```tsx
+// src/server.ts
+import {
+  createStartHandler,
+  defaultStreamHandler,
+} from '@tanstack/react-start/server'
+import { createServerEntry } from '@tanstack/react-start/server-entry'
+
+const handler = createStartHandler({
+  handler: defaultStreamHandler,
+  transformAssetUrls: {
+    transform: ({ url, type }) => {
+      const region = getRequest().headers.get('x-region') || 'us'
+      const cdnBase =
+        region === 'eu'
+          ? 'https://cdn-eu.example.com'
+          : 'https://cdn-us.example.com'
+      return `${cdnBase}${url}`
+    },
+    cache: false,
+  },
+})
+
+export default createServerEntry({ fetch: handler })
+```
+
+The object form accepts:
+
+| Property          | Type                            | Description                                                                                   |
+| ----------------- | ------------------------------- | --------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| `transform`       | `string \| (context) => string` | A string prefix or callback, same as the shorthand forms above.                               |
+| `createTransform` | `({ warmup: true }              | { warmup: false; request: Request }) => (asset) => string \| Promise<string>`                 | Async factory that runs once per manifest computation and returns a per-asset transform. Mutually exclusive with `transform`. |
+| `cache`           | `boolean`                       | Whether to cache the transformed manifest. Defaults to `true`.                                |
+| `warmup`          | `boolean`                       | When `true`, warms up the cached manifest on server startup (prod only). Defaults to `false`. |
+
+If you need to do async work once (e.g. fetch a CDN origin from a service) and then transform many URLs, prefer `createTransform`:
+
+```ts
+transformAssetUrls: {
+  cache: false,
+  async createTransform(ctx) {
+    if (ctx.warmup) {
+      // optional: return a default transform during warmup
+      return ({ url }) => url
+    }
+
+    const region = ctx.request.headers.get('x-region') || 'us'
+    const cdnBase = await fetchCdnBaseForRegion(region)
+    return ({ url }) => `${cdnBase}${url}`
+  },
+}
+```
+
+## Caching Behavior
+
+By default, **all forms** of `transformAssetUrls` cache the transformed manifest after the first request (`cache: true`). This means the transform function runs once on the first request, and the result is reused for every subsequent request in production.
+
+| Form                                   | Default cache | Behavior                                                   |
+| -------------------------------------- | ------------- | ---------------------------------------------------------- |
+| String prefix                          | `true`        | Computed once, cached forever in prod.                     |
+| Callback                               | `true`        | Runs once on first request, cached forever in prod.        |
+| Object with `cache: true` (or omitted) | `true`        | Same as above.                                             |
+| Object with `cache: false`             | `false`       | Deep-clones base manifest and transforms on every request. |
+
+Use `cache: false` only when the transform depends on per-request data (e.g., geo-routing based on request headers). For static CDN prefixes, the default `cache: true` is recommended.
+
+### Optional Warmup (Avoid First-Request Latency)
+
+If you're using the object form with `cache: true`, you can set `warmup: true`
+to compute the transformed manifest in the background at server startup.
+
+```ts
+transformAssetUrls: {
+  transform: process.env.CDN_ORIGIN || '',
+  cache: true,
+  warmup: true,
+}
+```
+
+This has no effect in development mode, or when `cache: false`.
+
+> **Note:** In development mode (`TSS_DEV_SERVER`), caching is always skipped regardless of the `cache` setting, so you always get fresh manifests.
+
+## What This Does NOT Cover
+
+`transformAssetUrls` only rewrites URLs in the TanStack Start manifest — the tags emitted during SSR for preloading and bootstrapping the application.
+
+It does **not** rewrite asset URLs that are imported directly in your components:
+
+```tsx
+// This import resolves to a URL at build time by Vite
+import logo from './logo.svg'
+
+function Header() {
+  return <img src={logo} /> // This URL is NOT affected by transformAssetUrls
+}
+```
+
+For these asset imports, use Vite's `experimental.renderBuiltUrl` in your `vite.config.ts`:
+
+```ts
+// vite.config.ts
+export default defineConfig({
+  experimental: {
+    renderBuiltUrl(filename, { hostType }) {
+      if (hostType === 'js') {
+        return { relative: true }
+      }
+      return `https://cdn.example.com/${filename}`
+    },
+  },
+})
+```
diff --git a/e2e/react-start/transform-asset-urls/.gitignore b/e2e/react-start/transform-asset-urls/.gitignore
new file mode 100644
index 0000000000..afc3a33f59
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/.gitignore
@@ -0,0 +1,18 @@
+node_modules
+package-lock.json
+yarn.lock
+
+.DS_Store
+.cache
+.env
+.vercel
+.output
+
+/build/
+/api/
+/server/build
+/public/build
+/test-results/
+/playwright-report/
+/blob-report/
+/playwright/.cache/
diff --git a/e2e/react-start/transform-asset-urls/.prettierignore b/e2e/react-start/transform-asset-urls/.prettierignore
new file mode 100644
index 0000000000..40a96e8819
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/.prettierignore
@@ -0,0 +1,4 @@
+**/build
+**/public
+pnpm-lock.yaml
+routeTree.gen.ts
diff --git a/e2e/react-start/transform-asset-urls/package.json b/e2e/react-start/transform-asset-urls/package.json
new file mode 100644
index 0000000000..cef39ca13f
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/package.json
@@ -0,0 +1,54 @@
+{
+  "name": "tanstack-react-start-e2e-transform-asset-urls",
+  "private": true,
+  "sideEffects": false,
+  "type": "module",
+  "scripts": {
+    "dev": "vite dev --port 3000",
+    "dev:e2e": "vite dev",
+    "build": "vite build && tsc --noEmit",
+    "start": "pnpx srvx --prod -s ../client dist/server/server.js",
+    "manual:cdn": "CDN_PORT=3002 node tests/cdn-server.mjs",
+    "manual:app": "pnpm build && PORT=3000 CDN_ORIGIN=http://localhost:3002 pnpm start",
+    "manual:both": "sh -c \"CDN_PORT=3002 node tests/cdn-server.mjs & pnpm build && PORT=3000 CDN_ORIGIN=http://localhost:3002 pnpm start\"",
+    "manual:both:string": "TRANSFORM_ASSET_URLS_MODE=string pnpm manual:both",
+    "manual:both:function": "TRANSFORM_ASSET_URLS_MODE=function pnpm manual:both",
+    "manual:both:options": "TRANSFORM_ASSET_URLS_MODE=options TRANSFORM_ASSET_URLS_OPTIONS_KIND=createTransform pnpm manual:both",
+    "manual:both:options:transform": "TRANSFORM_ASSET_URLS_MODE=options TRANSFORM_ASSET_URLS_OPTIONS_KIND=transform pnpm manual:both",
+    "manual:both:options:createTransform": "TRANSFORM_ASSET_URLS_MODE=options TRANSFORM_ASSET_URLS_OPTIONS_KIND=createTransform pnpm manual:both",
+    "test:e2e:string": "rm -rf dist; rm -rf port*.txt; TRANSFORM_ASSET_URLS_MODE=string playwright test --project=chromium",
+    "test:e2e:function": "rm -rf dist; rm -rf port*.txt; TRANSFORM_ASSET_URLS_MODE=function playwright test --project=chromium",
+    "test:e2e:options": "rm -rf dist; rm -rf port*.txt; TRANSFORM_ASSET_URLS_MODE=options TRANSFORM_ASSET_URLS_OPTIONS_KIND=transform playwright test --project=chromium",
+    "test:e2e:options:transform": "rm -rf dist; rm -rf port*.txt; TRANSFORM_ASSET_URLS_MODE=options TRANSFORM_ASSET_URLS_OPTIONS_KIND=transform playwright test --project=chromium",
+    "test:e2e:options:createTransform": "rm -rf dist; rm -rf port*.txt; TRANSFORM_ASSET_URLS_MODE=options TRANSFORM_ASSET_URLS_OPTIONS_KIND=createTransform playwright test --project=chromium",
+    "test:e2e:options:transform:cache-true:warmup-true": "rm -rf dist; rm -rf port*.txt; TRANSFORM_ASSET_URLS_MODE=options TRANSFORM_ASSET_URLS_OPTIONS_KIND=transform TRANSFORM_ASSET_URLS_OPTIONS_CACHE=true TRANSFORM_ASSET_URLS_OPTIONS_WARMUP=true playwright test --project=chromium",
+    "test:e2e:options:transform:cache-true:warmup-false": "rm -rf dist; rm -rf port*.txt; TRANSFORM_ASSET_URLS_MODE=options TRANSFORM_ASSET_URLS_OPTIONS_KIND=transform TRANSFORM_ASSET_URLS_OPTIONS_CACHE=true TRANSFORM_ASSET_URLS_OPTIONS_WARMUP=false playwright test --project=chromium",
+    "test:e2e:options:transform:cache-false:warmup-true": "rm -rf dist; rm -rf port*.txt; TRANSFORM_ASSET_URLS_MODE=options TRANSFORM_ASSET_URLS_OPTIONS_KIND=transform TRANSFORM_ASSET_URLS_OPTIONS_CACHE=false TRANSFORM_ASSET_URLS_OPTIONS_WARMUP=true playwright test --project=chromium",
+    "test:e2e:options:transform:cache-false:warmup-false": "rm -rf dist; rm -rf port*.txt; TRANSFORM_ASSET_URLS_MODE=options TRANSFORM_ASSET_URLS_OPTIONS_KIND=transform TRANSFORM_ASSET_URLS_OPTIONS_CACHE=false TRANSFORM_ASSET_URLS_OPTIONS_WARMUP=false playwright test --project=chromium",
+    "test:e2e:options:createTransform:cache-true:warmup-true": "rm -rf dist; rm -rf port*.txt; TRANSFORM_ASSET_URLS_MODE=options TRANSFORM_ASSET_URLS_OPTIONS_KIND=createTransform TRANSFORM_ASSET_URLS_OPTIONS_CACHE=true TRANSFORM_ASSET_URLS_OPTIONS_WARMUP=true playwright test --project=chromium",
+    "test:e2e:options:createTransform:cache-true:warmup-false": "rm -rf dist; rm -rf port*.txt; TRANSFORM_ASSET_URLS_MODE=options TRANSFORM_ASSET_URLS_OPTIONS_KIND=createTransform TRANSFORM_ASSET_URLS_OPTIONS_CACHE=true TRANSFORM_ASSET_URLS_OPTIONS_WARMUP=false playwright test --project=chromium",
+    "test:e2e:options:createTransform:cache-false:warmup-true": "rm -rf dist; rm -rf port*.txt; TRANSFORM_ASSET_URLS_MODE=options TRANSFORM_ASSET_URLS_OPTIONS_KIND=createTransform TRANSFORM_ASSET_URLS_OPTIONS_CACHE=false TRANSFORM_ASSET_URLS_OPTIONS_WARMUP=true playwright test --project=chromium",
+    "test:e2e:options:createTransform:cache-false:warmup-false": "rm -rf dist; rm -rf port*.txt; TRANSFORM_ASSET_URLS_MODE=options TRANSFORM_ASSET_URLS_OPTIONS_KIND=createTransform TRANSFORM_ASSET_URLS_OPTIONS_CACHE=false TRANSFORM_ASSET_URLS_OPTIONS_WARMUP=false playwright test --project=chromium",
+    "test:e2e:options:matrix": "pnpm test:e2e:options:transform:cache-true:warmup-true && pnpm test:e2e:options:transform:cache-true:warmup-false && pnpm test:e2e:options:transform:cache-false:warmup-true && pnpm test:e2e:options:transform:cache-false:warmup-false && pnpm test:e2e:options:createTransform:cache-true:warmup-true && pnpm test:e2e:options:createTransform:cache-true:warmup-false && pnpm test:e2e:options:createTransform:cache-false:warmup-true && pnpm test:e2e:options:createTransform:cache-false:warmup-false",
+    "test:e2e": "pnpm test:e2e:string && pnpm test:e2e:function && pnpm test:e2e:options:matrix"
+  },
+  "dependencies": {
+    "@tanstack/react-router": "workspace:^",
+    "@tanstack/react-start": "workspace:^",
+    "express": "^5.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.50.1",
+    "@tanstack/router-e2e-utils": "workspace:^",
+    "@types/node": "^22.10.2",
+    "@types/react": "^19.0.8",
+    "@types/react-dom": "^19.0.3",
+    "@vitejs/plugin-react": "^4.3.4",
+    "srvx": "^0.10.1",
+    "typescript": "^5.7.2",
+    "vite": "^7.3.1",
+    "vite-tsconfig-paths": "^5.1.4"
+  }
+}
diff --git a/e2e/react-start/transform-asset-urls/playwright.config.ts b/e2e/react-start/transform-asset-urls/playwright.config.ts
new file mode 100644
index 0000000000..53cc1b38df
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/playwright.config.ts
@@ -0,0 +1,63 @@
+import { defineConfig, devices } from '@playwright/test'
+import { getTestServerPort } from '@tanstack/router-e2e-utils'
+import packageJson from './package.json' with { type: 'json' }
+
+const APP_PORT = await getTestServerPort(packageJson.name)
+const CDN_PORT = await getTestServerPort(`${packageJson.name}_cdn`)
+
+const baseURL = `http://localhost:${APP_PORT}`
+const cdnOrigin = `http://localhost:${CDN_PORT}`
+const transformMode = process.env.TRANSFORM_ASSET_URLS_MODE || 'string'
+const optionsKind =
+  process.env.TRANSFORM_ASSET_URLS_OPTIONS_KIND || 'createTransform'
+const optionsCache = process.env.TRANSFORM_ASSET_URLS_OPTIONS_CACHE || 'true'
+const optionsWarmup = process.env.TRANSFORM_ASSET_URLS_OPTIONS_WARMUP || 'true'
+
+export default defineConfig({
+  testDir: './tests',
+  workers: 1,
+  reporter: [['line']],
+
+  use: {
+    baseURL,
+  },
+
+  webServer: [
+    {
+      // CDN server — serves built client assets on a separate port with CORS
+      command: `node tests/cdn-server.mjs`,
+      url: `http://localhost:${CDN_PORT}/health`,
+      reuseExistingServer: !process.env.CI,
+      stdout: 'pipe',
+      env: {
+        CDN_PORT: String(CDN_PORT),
+      },
+    },
+    {
+      // App server — builds the project then starts the srvx server
+      // with CDN_ORIGIN so that transformAssetUrls rewrites manifest URLs
+      command: `pnpm build && pnpm start`,
+      url: baseURL,
+      reuseExistingServer: !process.env.CI,
+      stdout: 'pipe',
+      env: {
+        PORT: String(APP_PORT),
+        CDN_ORIGIN: cdnOrigin,
+        TRANSFORM_ASSET_URLS_MODE: transformMode,
+        TRANSFORM_ASSET_URLS_OPTIONS_KIND: optionsKind,
+        TRANSFORM_ASSET_URLS_OPTIONS_CACHE: optionsCache,
+        TRANSFORM_ASSET_URLS_OPTIONS_WARMUP: optionsWarmup,
+      },
+      timeout: 120_000,
+    },
+  ],
+
+  projects: [
+    {
+      name: 'chromium',
+      use: {
+        ...devices['Desktop Chrome'],
+      },
+    },
+  ],
+})
diff --git a/e2e/react-start/transform-asset-urls/src/routeTree.gen.ts b/e2e/react-start/transform-asset-urls/src/routeTree.gen.ts
new file mode 100644
index 0000000000..421daf2790
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/src/routeTree.gen.ts
@@ -0,0 +1,86 @@
+/* eslint-disable */
+
+// @ts-nocheck
+
+// noinspection JSUnusedGlobalSymbols
+
+// This file was automatically generated by TanStack Router.
+// You should NOT make any changes in this file as it will be overwritten.
+// 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 AboutRouteImport } from './routes/about'
+import { Route as IndexRouteImport } from './routes/index'
+
+const AboutRoute = AboutRouteImport.update({
+  id: '/about',
+  path: '/about',
+  getParentRoute: () => rootRouteImport,
+} as any)
+const IndexRoute = IndexRouteImport.update({
+  id: '/',
+  path: '/',
+  getParentRoute: () => rootRouteImport,
+} as any)
+
+export interface FileRoutesByFullPath {
+  '/': typeof IndexRoute
+  '/about': typeof AboutRoute
+}
+export interface FileRoutesByTo {
+  '/': typeof IndexRoute
+  '/about': typeof AboutRoute
+}
+export interface FileRoutesById {
+  __root__: typeof rootRouteImport
+  '/': typeof IndexRoute
+  '/about': typeof AboutRoute
+}
+export interface FileRouteTypes {
+  fileRoutesByFullPath: FileRoutesByFullPath
+  fullPaths: '/' | '/about'
+  fileRoutesByTo: FileRoutesByTo
+  to: '/' | '/about'
+  id: '__root__' | '/' | '/about'
+  fileRoutesById: FileRoutesById
+}
+export interface RootRouteChildren {
+  IndexRoute: typeof IndexRoute
+  AboutRoute: typeof AboutRoute
+}
+
+declare module '@tanstack/react-router' {
+  interface FileRoutesByPath {
+    '/about': {
+      id: '/about'
+      path: '/about'
+      fullPath: '/about'
+      preLoaderRoute: typeof AboutRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+    '/': {
+      id: '/'
+      path: '/'
+      fullPath: '/'
+      preLoaderRoute: typeof IndexRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+  }
+}
+
+const rootRouteChildren: RootRouteChildren = {
+  IndexRoute: IndexRoute,
+  AboutRoute: AboutRoute,
+}
+export const routeTree = rootRouteImport
+  ._addFileChildren(rootRouteChildren)
+  ._addFileTypes<FileRouteTypes>()
+
+import type { getRouter } from './router.tsx'
+import type { createStart } from '@tanstack/react-start'
+declare module '@tanstack/react-start' {
+  interface Register {
+    ssr: true
+    router: Awaited<ReturnType<typeof getRouter>>
+  }
+}
diff --git a/e2e/react-start/transform-asset-urls/src/router.tsx b/e2e/react-start/transform-asset-urls/src/router.tsx
new file mode 100644
index 0000000000..16fd65460d
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/src/router.tsx
@@ -0,0 +1,12 @@
+import { createRouter } from '@tanstack/react-router'
+import { routeTree } from './routeTree.gen'
+
+export function getRouter() {
+  const router = createRouter({
+    routeTree,
+    scrollRestoration: true,
+    defaultPreload: 'intent',
+  })
+
+  return router
+}
diff --git a/e2e/react-start/transform-asset-urls/src/routes/__root.tsx b/e2e/react-start/transform-asset-urls/src/routes/__root.tsx
new file mode 100644
index 0000000000..4d1f1321a1
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/src/routes/__root.tsx
@@ -0,0 +1,40 @@
+/// <reference types="vite/client" />
+import {
+  HeadContent,
+  Outlet,
+  Scripts,
+  createRootRoute,
+} from '@tanstack/react-router'
+
+import '~/styles/app.css'
+
+export const Route = createRootRoute({
+  head: () => ({
+    meta: [
+      {
+        charSet: 'utf-8',
+      },
+      {
+        name: 'viewport',
+        content: 'width=device-width, initial-scale=1',
+      },
+    ],
+  }),
+  component: RootComponent,
+})
+
+function RootComponent() {
+  return (
+    <html>
+      <head>
+        <HeadContent />
+      </head>
+      <body>
+        <div className="app-styled">
+          <Outlet />
+        </div>
+        <Scripts />
+      </body>
+    </html>
+  )
+}
diff --git a/e2e/react-start/transform-asset-urls/src/routes/about.module.css b/e2e/react-start/transform-asset-urls/src/routes/about.module.css
new file mode 100644
index 0000000000..2afc6c104e
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/src/routes/about.module.css
@@ -0,0 +1,14 @@
+.aboutCard {
+  background-color: #fff3c4;
+  border: 1px solid #e6d38b;
+  border-left: 6px solid #111;
+  padding: 12px 14px;
+}
+
+.title {
+  margin: 0 0 6px;
+}
+
+.content {
+  margin: 0;
+}
diff --git a/e2e/react-start/transform-asset-urls/src/routes/about.tsx b/e2e/react-start/transform-asset-urls/src/routes/about.tsx
new file mode 100644
index 0000000000..e7baeb4292
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/src/routes/about.tsx
@@ -0,0 +1,19 @@
+import { createFileRoute } from '@tanstack/react-router'
+import styles from './about.module.css'
+
+export const Route = createFileRoute('/about')({
+  component: About,
+})
+
+function About() {
+  return (
+    <div data-testid="about-card" className={styles.aboutCard}>
+      <h1 data-testid="about-heading" className={styles.title}>
+        About
+      </h1>
+      <p data-testid="about-content" className={styles.content}>
+        This route is loaded on client navigation.
+      </p>
+    </div>
+  )
+}
diff --git a/e2e/react-start/transform-asset-urls/src/routes/index.tsx b/e2e/react-start/transform-asset-urls/src/routes/index.tsx
new file mode 100644
index 0000000000..e7aa38b8d9
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/src/routes/index.tsx
@@ -0,0 +1,19 @@
+import { Link, createFileRoute } from '@tanstack/react-router'
+
+export const Route = createFileRoute('/')({
+  component: Home,
+})
+
+function Home() {
+  return (
+    <div>
+      <h1 data-testid="home-heading">Welcome Home</h1>
+      <p data-testid="home-content">
+        This page tests the transformAssetUrls feature.
+      </p>
+      <Link to="/about" data-testid="link-to-about">
+        About
+      </Link>
+    </div>
+  )
+}
diff --git a/e2e/react-start/transform-asset-urls/src/server.ts b/e2e/react-start/transform-asset-urls/src/server.ts
new file mode 100644
index 0000000000..1757f03596
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/src/server.ts
@@ -0,0 +1,56 @@
+import {
+  createStartHandler,
+  defaultStreamHandler,
+} from '@tanstack/react-start/server'
+import { createServerEntry } from '@tanstack/react-start/server-entry'
+
+const cdnOrigin = process.env.CDN_ORIGIN
+const transformMode = process.env.TRANSFORM_ASSET_URLS_MODE || 'string'
+const optionsKind =
+  process.env.TRANSFORM_ASSET_URLS_OPTIONS_KIND || 'createTransform'
+const optionsCache = process.env.TRANSFORM_ASSET_URLS_OPTIONS_CACHE || 'true'
+const optionsWarmup = process.env.TRANSFORM_ASSET_URLS_OPTIONS_WARMUP || 'true'
+
+const cache = optionsCache !== 'false'
+const warmup = optionsWarmup === 'true'
+
+console.log(
+  `[server-entry]: using custom server entry with transformAssetUrls (${transformMode}${transformMode === 'options' ? `:${optionsKind}` : ''})${cdnOrigin ? ` (CDN: ${cdnOrigin})` : ' (no CDN)'}`,
+)
+
+const handler = createStartHandler(
+  cdnOrigin
+    ? {
+        handler: defaultStreamHandler,
+        transformAssetUrls: (() => {
+          const cdn = cdnOrigin.replace(/\/+$/, '')
+
+          if (transformMode === 'function') {
+            return ({ url }: { url: string }) => `${cdn}${url}`
+          }
+
+          if (transformMode === 'options') {
+            if (optionsKind === 'transform') {
+              return {
+                transform: ({ url }: { url: string }) => `${cdn}${url}`,
+                cache,
+                warmup,
+              }
+            }
+
+            return {
+              createTransform: async () => {
+                return ({ url }: { url: string }) => `${cdn}${url}`
+              },
+              cache,
+              warmup,
+            }
+          }
+
+          return cdn
+        })(),
+      }
+    : defaultStreamHandler,
+)
+
+export default createServerEntry({ fetch: handler })
diff --git a/e2e/react-start/transform-asset-urls/src/styles/app.css b/e2e/react-start/transform-asset-urls/src/styles/app.css
new file mode 100644
index 0000000000..6963f5edf3
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/src/styles/app.css
@@ -0,0 +1,11 @@
+body {
+  font-family: sans-serif;
+  margin: 0;
+  padding: 0;
+}
+
+.app-styled {
+  color: #333;
+  background-color: #f0f0f0;
+  padding: 16px;
+}
diff --git a/e2e/react-start/transform-asset-urls/tests/cdn-server.mjs b/e2e/react-start/transform-asset-urls/tests/cdn-server.mjs
new file mode 100644
index 0000000000..8b06bf6d60
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/tests/cdn-server.mjs
@@ -0,0 +1,28 @@
+import express from 'express'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const port = process.env.CDN_PORT || 3002
+
+const app = express()
+
+// Health check endpoint for Playwright webServer readiness.
+// This should return 200 even before the client build exists.
+app.get('/health', (_req, res) => {
+  res.status(200).send('ok')
+})
+
+// Serve the built client assets with CORS headers to simulate a CDN
+app.use((req, res, next) => {
+  res.setHeader('Access-Control-Allow-Origin', '*')
+  res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS')
+  res.setHeader('Access-Control-Allow-Headers', '*')
+  next()
+})
+
+app.use(express.static(path.resolve(__dirname, '..', 'dist', 'client')))
+
+app.listen(port, () => {
+  console.info(`CDN Server: http://localhost:${port}`)
+})
diff --git a/e2e/react-start/transform-asset-urls/tests/transform-asset-urls.spec.ts b/e2e/react-start/transform-asset-urls/tests/transform-asset-urls.spec.ts
new file mode 100644
index 0000000000..62fcb0f0b8
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/tests/transform-asset-urls.spec.ts
@@ -0,0 +1,195 @@
+import { expect, type Page } from '@playwright/test'
+import { test } from '@tanstack/router-e2e-utils'
+
+/**
+ * Helper: fetch the SSR HTML for the given path using Playwright's
+ * APIRequestContext (no navigation/interception needed).
+ */
+async function getSSRHtml(page: Page, path = '/') {
+  const response = await page.request.get(path, {
+    headers: {
+      Accept: 'text/html',
+    },
+  })
+
+  expect(response.ok()).toBeTruthy()
+  const contentType = response.headers()['content-type'] || ''
+  expect(contentType).toContain('text/html')
+
+  return response.text()
+}
+
+test.describe('transformAssetUrls with CDN prefix', () => {
+  test('test run mode is set (string|function|options)', async () => {
+    expect(process.env.TRANSFORM_ASSET_URLS_MODE).toMatch(
+      /^(string|function|options)$/,
+    )
+
+    if (process.env.TRANSFORM_ASSET_URLS_MODE === 'options') {
+      expect(process.env.TRANSFORM_ASSET_URLS_OPTIONS_KIND).toMatch(
+        /^(transform|createTransform)$/,
+      )
+
+      expect(process.env.TRANSFORM_ASSET_URLS_OPTIONS_CACHE).toMatch(
+        /^(true|false)$/,
+      )
+      expect(process.env.TRANSFORM_ASSET_URLS_OPTIONS_WARMUP).toMatch(
+        /^(true|false)$/,
+      )
+    }
+  })
+
+  test('SSR HTML contains CDN-prefixed modulepreload links', async ({
+    page,
+  }) => {
+    const html = await getSSRHtml(page)
+
+    // All modulepreload links should point to the CDN origin
+    const modulepreloads = html.match(/rel="modulepreload"[^>]*href="([^"]+)"/g)
+    expect(modulepreloads).toBeTruthy()
+    expect(modulepreloads!.length).toBeGreaterThan(0)
+
+    for (const match of modulepreloads!) {
+      const href = match.match(/href="([^"]+)"/)?.[1]
+      expect(href).toBeTruthy()
+      expect(href).toMatch(/^http:\/\/localhost:\d+\//)
+    }
+  })
+
+  test('SSR HTML contains CDN-prefixed stylesheet link', async ({ page }) => {
+    const html = await getSSRHtml(page)
+
+    // The emitted stylesheet link should be CDN-prefixed
+    const stylesheetLinks = html.match(/rel="stylesheet"[^>]*href="([^"]+)"/g)
+    expect(stylesheetLinks).toBeTruthy()
+
+    const firstStylesheetLink = stylesheetLinks![0]
+    expect(firstStylesheetLink).toBeTruthy()
+
+    const href = firstStylesheetLink!.match(/href="([^"]+)"/)?.[1]
+    expect(href).toBeTruthy()
+    expect(href).toMatch(/^http:\/\/localhost:\d+\//)
+    expect(href).toMatch(/\.css(\?|$)/)
+  })
+
+  test('SSR HTML for /about references CSS modules stylesheet and style applies', async ({
+    page,
+  }) => {
+    const html = await getSSRHtml(page, '/about')
+
+    // Ensure the /about route's CSS module chunk is referenced in SSR HTML.
+    // In production builds, Vite emits hashed assets like "about.<hash>.css".
+    const stylesheetHrefs = Array.from(
+      html.matchAll(/rel="stylesheet"[^>]*href="([^"]+)"/g),
+    ).map((m) => m[1])
+
+    expect(stylesheetHrefs.length).toBeGreaterThan(0)
+
+    const aboutCssHrefs = stylesheetHrefs.filter((href) => {
+      if (!/^http:\/\/localhost:\d+\//.test(href)) return false
+
+      let pathname = ''
+      try {
+        pathname = new URL(href).pathname
+      } catch {
+        return false
+      }
+
+      const filename = pathname.split('/').pop() || ''
+      return filename.startsWith('about') && /\.css$/.test(filename)
+    })
+
+    expect(aboutCssHrefs.length).toBeGreaterThan(0)
+
+    // Now load /about and verify the CSS module style is actually applied.
+    await page.goto('/about')
+    await page.waitForLoadState('networkidle')
+
+    const bgColor = await page
+      .getByTestId('about-card')
+      .evaluate((el) => getComputedStyle(el).backgroundColor)
+
+    // #fff3c4 = rgb(255, 243, 196)
+    expect(bgColor).toBe('rgb(255, 243, 196)')
+  })
+
+  test('SSR HTML contains CDN-prefixed client entry script', async ({
+    page,
+  }) => {
+    const html = await getSSRHtml(page)
+
+    // The client entry script should contain an import() with CDN-prefixed URL
+    const clientEntryMatch = html.match(
+      /import\('(http:\/\/localhost:\d+\/[^']+)'\)/,
+    )
+    expect(clientEntryMatch).toBeTruthy()
+    expect(clientEntryMatch![1]).toMatch(/^http:\/\/localhost:\d+\//)
+  })
+
+  test('page renders correctly with CDN-served assets', async ({ page }) => {
+    await page.goto('/')
+    await page.waitForLoadState('networkidle')
+
+    // Page content renders
+    await expect(page.getByTestId('home-heading')).toHaveText('Welcome Home')
+    await expect(page.getByTestId('home-content')).toContainText(
+      'transformAssetUrls',
+    )
+  })
+
+  test('CSS is applied correctly from CDN', async ({ page }) => {
+    await page.goto('/')
+    await page.waitForLoadState('networkidle')
+
+    // Verify that the CSS from app.css is actually applied
+    // The .app-styled class sets background-color to #f0f0f0
+    const bgColor = await page
+      .locator('.app-styled')
+      .evaluate((el) => getComputedStyle(el).backgroundColor)
+
+    // #f0f0f0 = rgb(240, 240, 240)
+    expect(bgColor).toBe('rgb(240, 240, 240)')
+  })
+
+  test('browser fetches assets from CDN server', async ({ page }) => {
+    // Track network requests to verify JS/CSS assets are fetched from a
+    // different origin than the app server (i.e. the CDN)
+    const appOrigin = new URL(
+      test.info().project.use.baseURL || 'http://localhost:3000',
+    ).origin
+    const assetRequests: Array<{ url: string; fromCdn: boolean }> = []
+
+    page.on('request', (request) => {
+      const url = request.url()
+      // Look for JS/CSS asset requests
+      if (/\.(js|css)(\?|$)/.test(url)) {
+        const origin = new URL(url).origin
+        assetRequests.push({ url, fromCdn: origin !== appOrigin })
+      }
+    })
+
+    await page.goto('/')
+    await page.waitForLoadState('networkidle')
+
+    // Verify that at least some asset requests went to a non-app origin (the CDN)
+    const cdnRequests = assetRequests.filter((r) => r.fromCdn)
+    expect(cdnRequests.length).toBeGreaterThan(0)
+  })
+
+  test('client-side navigation to /about loads split chunk from CDN', async ({
+    page,
+  }) => {
+    await page.goto('/')
+    await page.waitForLoadState('networkidle')
+
+    await page.getByTestId('link-to-about').click()
+    await page.waitForURL('**/about')
+    await expect(page.getByTestId('about-heading')).toHaveText('About')
+
+    // Ensure CSS modules were loaded and applied after client navigation
+    const bgColor = await page
+      .getByTestId('about-card')
+      .evaluate((el) => getComputedStyle(el).backgroundColor)
+    expect(bgColor).toBe('rgb(255, 243, 196)')
+  })
+})
diff --git a/e2e/react-start/transform-asset-urls/tsconfig.json b/e2e/react-start/transform-asset-urls/tsconfig.json
new file mode 100644
index 0000000000..3a9fb7cd71
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/tsconfig.json
@@ -0,0 +1,22 @@
+{
+  "include": ["**/*.ts", "**/*.tsx"],
+  "compilerOptions": {
+    "strict": true,
+    "esModuleInterop": true,
+    "jsx": "react-jsx",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["DOM", "DOM.Iterable", "ES2022"],
+    "isolatedModules": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "target": "ES2022",
+    "allowJs": true,
+    "forceConsistentCasingInFileNames": true,
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["./src/*"]
+    },
+    "noEmit": true
+  }
+}
diff --git a/e2e/react-start/transform-asset-urls/vite.config.ts b/e2e/react-start/transform-asset-urls/vite.config.ts
new file mode 100644
index 0000000000..c2c28ae93b
--- /dev/null
+++ b/e2e/react-start/transform-asset-urls/vite.config.ts
@@ -0,0 +1,17 @@
+import { defineConfig } from 'vite'
+import tsConfigPaths from 'vite-tsconfig-paths'
+import { tanstackStart } from '@tanstack/react-start/plugin/vite'
+import viteReact from '@vitejs/plugin-react'
+
+export default defineConfig({
+  server: {
+    port: 3000,
+  },
+  plugins: [
+    tsConfigPaths({
+      projects: ['./tsconfig.json'],
+    }),
+    tanstackStart(),
+    viteReact(),
+  ],
+})
diff --git a/packages/start-server-core/src/createStartHandler.ts b/packages/start-server-core/src/createStartHandler.ts
index 7fa0e4a484..c81ecc6c08 100644
--- a/packages/start-server-core/src/createStartHandler.ts
+++ b/packages/start-server-core/src/createStartHandler.ts
@@ -19,6 +19,11 @@ import { runWithStartContext } from '@tanstack/start-storage-context'
 import { requestHandler } from './request-response'
 import { getStartManifest } from './router-manifest'
 import { handleServerAction } from './server-functions-handler'
+import {
+  buildManifestWithClientEntry,
+  resolveTransformConfig,
+  transformManifestUrls,
+} from './transformAssetUrls'
 
 import { HEADERS } from './constants'
 import { ServerFunctionSerializationAdapter } from './serializer/ServerFunctionSerializationAdapter'
@@ -39,6 +44,11 @@ import type {
   Register,
 } from '@tanstack/router-core'
 import type { HandlerCallback } from '@tanstack/router-core/ssr/server'
+import type {
+  StartManifestWithClientEntry,
+  TransformAssetUrls,
+  TransformAssetUrlsFn,
+} from './transformAssetUrls'
 
 type TODO = any
 
@@ -46,6 +56,61 @@ type AnyMiddlewareServerFn =
   | AnyRequestMiddleware['options']['server']
   | AnyFunctionMiddleware['options']['server']
 
+export interface CreateStartHandlerOptions {
+  handler: HandlerCallback<AnyRouter>
+  /**
+   * Transform asset URLs at runtime, e.g. to prepend a CDN prefix.
+   *
+   * **String** — a URL prefix prepended to every asset URL (cached by default):
+   * ```ts
+   * createStartHandler({
+   *   handler: defaultStreamHandler,
+   *   transformAssetUrls: 'https://cdn.example.com',
+   * })
+   * ```
+   *
+   * **Callback** — receives `{ url, type }` and returns a new URL
+   * (cached by default — runs once on first request):
+   * ```ts
+   * createStartHandler({
+   *   handler: defaultStreamHandler,
+   *   transformAssetUrls: ({ url, type }) => {
+   *     return `https://cdn.example.com${url}`
+   *   },
+   * })
+   * ```
+   *
+   * **Object** — for explicit cache control:
+   * ```ts
+   * createStartHandler({
+   *   handler: defaultStreamHandler,
+   *   transformAssetUrls: {
+   *     transform: ({ url }) => {
+   *       const region = getRequest().headers.get('x-region') || 'us'
+   *       return `https://cdn-${region}.example.com${url}`
+   *     },
+   *     cache: false, // transform per-request
+   *   },
+   * })
+   * ```
+   *
+   * `type` is one of `'modulepreload' | 'stylesheet' | 'clientEntry'`.
+   *
+   * By default, the transformed manifest is cached after the first request
+   * (`cache: true`). Set `cache: false` for per-request transforms.
+   *
+   * If you're using a cached transform, you can optionally set `warmup: true`
+   * (object form only) to compute the transformed manifest in the background at
+   * server startup.
+   *
+   * Note: This only transforms URLs managed by TanStack Start's manifest
+   * (JS preloads, CSS links, and the client entry script). For asset imports
+   * used directly in components (e.g. `import logo from './logo.svg'`),
+   * configure Vite's `experimental.renderBuiltUrl` in your vite.config.ts.
+   */
+  transformAssetUrls?: TransformAssetUrls
+}
+
 function getStartResponseHeaders(opts: { router: AnyRouter }) {
   const headers = mergeHeaders(
     {
@@ -66,7 +131,13 @@ let entriesPromise:
       routerEntry: RouterEntry
     }>
   | undefined
-let manifestPromise: Promise<Manifest> | undefined
+let baseManifestPromise: Promise<StartManifestWithClientEntry> | undefined
+
+/**
+ * Cached final manifest (with client entry script tag). In production,
+ * this is computed once and reused for every request when caching is enabled.
+ */
+let cachedFinalManifestPromise: Promise<Manifest> | undefined
 
 async function loadEntries() {
   // @ts-ignore when building, we currently don't respect tsconfig.ts' `include` so we are not picking up the .d.ts from start-client-core
@@ -83,16 +154,59 @@ function getEntries() {
   return entriesPromise
 }
 
-function getManifest(matchedRoutes?: ReadonlyArray<AnyRoute>) {
+/**
+ * Returns the raw manifest data (without client entry script tag baked in).
+ * In dev mode, always returns fresh data. In prod, cached.
+ */
+function getBaseManifest(
+  matchedRoutes?: ReadonlyArray<AnyRoute>,
+): Promise<StartManifestWithClientEntry> {
   // In dev mode, always get fresh manifest (no caching) to include route-specific dev styles
   if (process.env.TSS_DEV_SERVER === 'true') {
     return getStartManifest(matchedRoutes)
   }
-  // In prod, cache the manifest
-  if (!manifestPromise) {
-    manifestPromise = getStartManifest()
+  // In prod, cache the base manifest
+  if (!baseManifestPromise) {
+    baseManifestPromise = getStartManifest()
   }
-  return manifestPromise
+  return baseManifestPromise
+}
+
+/**
+ * Resolves a final Manifest for a given request.
+ *
+ * - No transform: builds client entry script tag and returns (cached in prod).
+ * - Cached transform: transforms all URLs + builds script tag, caches result.
+ * - Per-request transform: deep-clones base manifest, transforms per-request.
+ */
+async function resolveManifest(
+  matchedRoutes: ReadonlyArray<AnyRoute> | undefined,
+  transformFn: TransformAssetUrlsFn | undefined,
+  cache: boolean,
+): Promise<Manifest> {
+  const base = await getBaseManifest(matchedRoutes)
+
+  const computeFinalManifest = async () => {
+    return transformFn
+      ? await transformManifestUrls(base, transformFn, { clone: !cache })
+      : buildManifestWithClientEntry(base)
+  }
+
+  // In dev, always compute fresh to include route-specific dev styles.
+  if (process.env.TSS_DEV_SERVER === 'true') {
+    return computeFinalManifest()
+  }
+
+  // In prod, cache unless we're explicitly doing per-request transforms.
+  if (!transformFn || cache) {
+    if (!cachedFinalManifestPromise) {
+      cachedFinalManifestPromise = computeFinalManifest()
+    }
+    return cachedFinalManifestPromise
+  }
+
+  // Per-request transform — deep-clone and transform every time.
+  return computeFinalManifest()
 }
 
 // Pre-computed constants
@@ -206,9 +320,107 @@ function handlerToMiddleware(
   }
 }
 
+/**
+ * Creates the TanStack Start request handler.
+ *
+ * @example Backwards-compatible usage (handler callback only):
+ * ```ts
+ * export default createStartHandler(defaultStreamHandler)
+ * ```
+ *
+ * @example With CDN URL rewriting:
+ * ```ts
+ * export default createStartHandler({
+ *   handler: defaultStreamHandler,
+ *   transformAssetUrls: 'https://cdn.example.com',
+ * })
+ * ```
+ *
+ * @example With per-request URL rewriting:
+ * ```ts
+ * export default createStartHandler({
+ *   handler: defaultStreamHandler,
+ *   transformAssetUrls: {
+ *     transform: ({ url }) => {
+ *       const cdnBase = getRequest().headers.get('x-cdn-base') || ''
+ *       return `${cdnBase}${url}`
+ *     },
+ *     cache: false,
+ *   },
+ * })
+ * ```
+ */
 export function createStartHandler<TRegister = Register>(
-  cb: HandlerCallback<AnyRouter>,
+  cbOrOptions: HandlerCallback<AnyRouter> | CreateStartHandlerOptions,
 ): RequestHandler<TRegister> {
+  // Normalize the overloaded argument
+  const cb: HandlerCallback<AnyRouter> =
+    typeof cbOrOptions === 'function' ? cbOrOptions : cbOrOptions.handler
+  const transformAssetUrlsOption: TransformAssetUrls | undefined =
+    typeof cbOrOptions === 'function'
+      ? undefined
+      : cbOrOptions.transformAssetUrls
+
+  const warmupTransformManifest =
+    !!transformAssetUrlsOption &&
+    typeof transformAssetUrlsOption === 'object' &&
+    transformAssetUrlsOption.warmup === true
+
+  // Pre-resolve the transform function and cache flag
+  const resolvedTransformConfig = transformAssetUrlsOption
+    ? resolveTransformConfig(transformAssetUrlsOption)
+    : undefined
+  const cache = resolvedTransformConfig ? resolvedTransformConfig.cache : true
+
+  // Memoize a single createTransform() result when caching is enabled.
+  let cachedCreateTransformPromise: Promise<TransformAssetUrlsFn> | undefined
+
+  const getTransformFn = async (
+    opts: { warmup: true } | { warmup: false; request: Request },
+  ): Promise<TransformAssetUrlsFn | undefined> => {
+    if (!resolvedTransformConfig) return undefined
+    if (resolvedTransformConfig.type === 'createTransform') {
+      if (cache) {
+        if (!cachedCreateTransformPromise) {
+          cachedCreateTransformPromise = Promise.resolve(
+            resolvedTransformConfig.createTransform(opts),
+          )
+        }
+        return cachedCreateTransformPromise
+      }
+      return resolvedTransformConfig.createTransform(opts)
+    }
+    return resolvedTransformConfig.transformFn
+  }
+
+  // Background warmup for cached transforms (production only)
+  if (
+    warmupTransformManifest &&
+    cache &&
+    process.env.TSS_DEV_SERVER !== 'true' &&
+    !cachedFinalManifestPromise
+  ) {
+    // NOTE: Do not call resolveManifest() here.
+    // resolveManifest() reads from cachedFinalManifestPromise, and since we set
+    // cachedFinalManifestPromise to this warmup promise, that would create a
+    // self-referential promise and hang forever.
+    const warmupPromise = (async () => {
+      const base = await getBaseManifest(undefined)
+      const transformFn = await getTransformFn({ warmup: true })
+      return transformFn
+        ? await transformManifestUrls(base, transformFn, { clone: false })
+        : buildManifestWithClientEntry(base)
+    })()
+    cachedFinalManifestPromise = warmupPromise
+    warmupPromise.catch(() => {
+      // If warmup fails, allow the next request to retry.
+      if (cachedFinalManifestPromise === warmupPromise) {
+        cachedFinalManifestPromise = undefined
+      }
+      cachedCreateTransformPromise = undefined
+    })
+  }
+
   const startRequestResolver: RequestHandler<Register> = async (
     request,
     requestOpts,
@@ -339,7 +551,11 @@ export function createStartHandler<TRegister = Register>(
           )
         }
 
-        const manifest = await getManifest(matchedRoutes)
+        const manifest = await resolveManifest(
+          matchedRoutes,
+          await getTransformFn({ warmup: false, request }),
+          cache,
+        )
         const routerInstance = await getRouter()
 
         attachRouterServerSsrUtils({
diff --git a/packages/start-server-core/src/index.tsx b/packages/start-server-core/src/index.tsx
index 5a4d633e5c..aafbab0002 100644
--- a/packages/start-server-core/src/index.tsx
+++ b/packages/start-server-core/src/index.tsx
@@ -1,4 +1,13 @@
 export { createStartHandler } from './createStartHandler'
+export type { CreateStartHandlerOptions } from './createStartHandler'
+
+export type {
+  TransformAssetUrls,
+  TransformAssetUrlsFn,
+  TransformAssetUrlsContext,
+  TransformAssetUrlsOptions,
+  AssetUrlType,
+} from './transformAssetUrls'
 
 export {
   attachRouterServerSsrUtils,
diff --git a/packages/start-server-core/src/router-manifest.ts b/packages/start-server-core/src/router-manifest.ts
index c31435fbf7..ceec7eaf4e 100644
--- a/packages/start-server-core/src/router-manifest.ts
+++ b/packages/start-server-core/src/router-manifest.ts
@@ -1,21 +1,25 @@
 import { buildDevStylesUrl, rootRouteId } from '@tanstack/router-core'
 import type { AnyRoute, RouterManagedTag } from '@tanstack/router-core'
+import type { StartManifestWithClientEntry } from './transformAssetUrls'
 
 // Pre-computed constant for dev styles URL
 const ROUTER_BASEPATH = process.env.TSS_ROUTER_BASEPATH || '/'
 
 /**
- * @description Returns the router manifest that should be sent to the client.
+ * @description Returns the router manifest data that should be sent to the client.
  * This includes only the assets and preloads for the current route and any
  * special assets that are needed for the client. It does not include relationships
  * between routes or any other data that is not needed for the client.
  *
+ * The client entry URL is returned separately so that it can be transformed
+ * (e.g. for CDN rewriting) before being embedded into the `<script>` tag.
+ *
  * @param matchedRoutes - In dev mode, the matched routes are used to build
  * the dev styles URL for route-scoped CSS collection.
  */
 export async function getStartManifest(
   matchedRoutes?: ReadonlyArray<AnyRoute>,
-) {
+): Promise<StartManifestWithClientEntry> {
   const { tsrStartManifest } = await import('tanstack-start-manifest:v')
   const startManifest = tsrStartManifest()
 
@@ -37,22 +41,15 @@ export async function getStartManifest(
     })
   }
 
-  let script = `import('${startManifest.clientEntry}')`
+  // Collect injected head scripts in dev mode (returned separately so we can
+  // build the client entry script tag after URL transforms are applied)
+  let injectedHeadScripts: string | undefined
   if (process.env.TSS_DEV_SERVER === 'true') {
-    const { injectedHeadScripts } =
-      await import('tanstack-start-injected-head-scripts:v')
-    if (injectedHeadScripts) {
-      script = `${injectedHeadScripts + ';'}${script}`
+    const mod = await import('tanstack-start-injected-head-scripts:v')
+    if (mod.injectedHeadScripts) {
+      injectedHeadScripts = mod.injectedHeadScripts
     }
   }
-  rootRoute.assets.push({
-    tag: 'script',
-    attrs: {
-      type: 'module',
-      async: true,
-    },
-    children: script,
-  })
 
   const manifest = {
     routes: Object.fromEntries(
@@ -78,6 +75,9 @@ export async function getStartManifest(
     ),
   }
 
-  // Strip out anything that isn't needed for the client
-  return manifest
+  return {
+    manifest,
+    clientEntry: startManifest.clientEntry,
+    injectedHeadScripts,
+  }
 }
diff --git a/packages/start-server-core/src/transformAssetUrls.ts b/packages/start-server-core/src/transformAssetUrls.ts
new file mode 100644
index 0000000000..6ff6f490e8
--- /dev/null
+++ b/packages/start-server-core/src/transformAssetUrls.ts
@@ -0,0 +1,284 @@
+import { rootRouteId } from '@tanstack/router-core'
+
+import type {
+  Awaitable,
+  Manifest,
+  RouterManagedTag,
+} from '@tanstack/router-core'
+
+export type AssetUrlType = 'modulepreload' | 'stylesheet' | 'clientEntry'
+
+export interface TransformAssetUrlsContext {
+  url: string
+  type: AssetUrlType
+}
+
+export type TransformAssetUrlsFn = (
+  context: TransformAssetUrlsContext,
+) => Awaitable<string>
+
+export type CreateTransformAssetUrlsContext =
+  | {
+      /** True when the server is computing the cached manifest during startup warmup. */
+      warmup: true
+    }
+  | {
+      /**
+       * The current Request.
+       *
+       * Only available during request handling (i.e. when `warmup: false`).
+       */
+      request: Request
+      /** False when transforming URLs as part of request handling. */
+      warmup: false
+    }
+
+/**
+ * Async factory that runs once per manifest computation and returns the
+ * per-asset transform.
+ */
+export type CreateTransformAssetUrlsFn = (
+  ctx: CreateTransformAssetUrlsContext,
+) => Awaitable<TransformAssetUrlsFn>
+
+type TransformAssetUrlsOptionsBase = {
+  /**
+   * Whether to cache the transformed manifest after the first request.
+   *
+   * When `true` (default), the transform runs once on the first request and
+   * the resulting manifest is reused for all subsequent requests in production.
+   *
+   * Set to `false` for per-request transforms (e.g. geo-routing to different
+   * CDNs based on request headers).
+   *
+   * @default true
+   */
+  cache?: boolean
+
+  /**
+   * When `true`, warms up the cached transformed manifest in the background when
+   * the server starts (production only).
+   *
+   * This can reduce latency for the first request when `cache` is `true`.
+   * Has no effect when `cache: false` (per-request transforms) or in dev mode.
+   *
+   * @default false
+   */
+  warmup?: boolean
+}
+
+export type TransformAssetUrlsOptions =
+  | (TransformAssetUrlsOptionsBase & {
+      /**
+       * The transform to apply to asset URLs. Can be a string prefix or a callback.
+       *
+       * **String** — prepended to every asset URL.
+       * **Callback** — receives `{ url, type }` and returns a new URL.
+       */
+      transform: string | TransformAssetUrlsFn
+      createTransform?: never
+    })
+  | (TransformAssetUrlsOptionsBase & {
+      /**
+       * Create a per-asset transform function.
+       *
+       * This factory runs once per manifest computation (per request when
+       * `cache: false`, or once per server when `cache: true`). It can do async
+       * setup work (fetch config, read from a KV, etc.) and return a fast
+       * per-asset transformer.
+       */
+      createTransform: CreateTransformAssetUrlsFn
+      transform?: never
+    })
+
+export type TransformAssetUrls =
+  | string
+  | TransformAssetUrlsFn
+  | TransformAssetUrlsOptions
+
+export type ResolvedTransformAssetUrlsConfig =
+  | {
+      type: 'transform'
+      transformFn: TransformAssetUrlsFn
+      cache: boolean
+    }
+  | {
+      type: 'createTransform'
+      createTransform: CreateTransformAssetUrlsFn
+      cache: boolean
+    }
+
+/**
+ * Resolves a TransformAssetUrls value (string prefix, callback, or options
+ * object) into a concrete transform function and cache flag.
+ */
+export function resolveTransformConfig(
+  transform: TransformAssetUrls,
+): ResolvedTransformAssetUrlsConfig {
+  // String shorthand
+  if (typeof transform === 'string') {
+    const prefix = transform
+    return {
+      type: 'transform',
+      transformFn: ({ url }) => `${prefix}${url}`,
+      cache: true,
+    }
+  }
+
+  // Callback shorthand
+  if (typeof transform === 'function') {
+    return {
+      type: 'transform',
+      transformFn: transform,
+      cache: true,
+    }
+  }
+
+  // Options object
+  if ('createTransform' in transform && transform.createTransform) {
+    return {
+      type: 'createTransform',
+      createTransform: transform.createTransform,
+      cache: transform.cache !== false,
+    }
+  }
+
+  const transformFn =
+    typeof transform.transform === 'string'
+      ? ((({ url }: TransformAssetUrlsContext) =>
+          `${transform.transform}${url}`) as TransformAssetUrlsFn)
+      : transform.transform
+
+  return {
+    type: 'transform',
+    transformFn,
+    cache: transform.cache !== false,
+  }
+}
+
+export interface StartManifestWithClientEntry {
+  manifest: Manifest
+  clientEntry: string
+  /** Script content prepended before the client entry import (dev only) */
+  injectedHeadScripts?: string
+}
+
+/**
+ * Builds the client entry `<script>` tag from a (possibly transformed) client
+ * entry URL and optional injected head scripts.
+ */
+export function buildClientEntryScriptTag(
+  clientEntry: string,
+  injectedHeadScripts?: string,
+): RouterManagedTag {
+  let script = `import('${clientEntry}')`
+  if (injectedHeadScripts) {
+    script = `${injectedHeadScripts};${script}`
+  }
+  return {
+    tag: 'script',
+    attrs: {
+      type: 'module',
+      async: true,
+    },
+    children: script,
+  }
+}
+
+/**
+ * Applies a URL transform to every asset URL in the manifest and returns a
+ * new manifest with a client entry script tag appended to the root route's
+ * assets.
+ *
+ * The source manifest is deep-cloned so the cached original is never mutated.
+ */
+export function transformManifestUrls(
+  source: StartManifestWithClientEntry,
+  transformFn: TransformAssetUrlsFn,
+  opts?: {
+    /** When true, clone the source manifest before mutating it. */
+    clone?: boolean
+  },
+): Promise<Manifest> {
+  return (async () => {
+    const manifest = opts?.clone
+      ? structuredClone(source.manifest)
+      : source.manifest
+
+    for (const route of Object.values(manifest.routes)) {
+      // Transform preload URLs (modulepreload)
+      if (route.preloads) {
+        route.preloads = await Promise.all(
+          route.preloads.map((url) =>
+            Promise.resolve(transformFn({ url, type: 'modulepreload' })),
+          ),
+        )
+      }
+
+      // Transform asset tag URLs
+      if (route.assets) {
+        for (const asset of route.assets) {
+          if (asset.tag === 'link' && asset.attrs?.href) {
+            asset.attrs.href = await Promise.resolve(
+              transformFn({
+                url: asset.attrs.href,
+                type: 'stylesheet',
+              }),
+            )
+          }
+        }
+      }
+    }
+
+    // Transform and append the client entry script tag
+    const transformedClientEntry = await Promise.resolve(
+      transformFn({
+        url: source.clientEntry,
+        type: 'clientEntry',
+      }),
+    )
+
+    const rootRoute = manifest.routes[rootRouteId]
+    if (rootRoute) {
+      rootRoute.assets = rootRoute.assets || []
+      rootRoute.assets.push(
+        buildClientEntryScriptTag(
+          transformedClientEntry,
+          source.injectedHeadScripts,
+        ),
+      )
+    }
+
+    return manifest
+  })()
+}
+
+/**
+ * Builds a final Manifest from a StartManifestWithClientEntry without any
+ * URL transforms. Used when no transformAssetUrls option is provided.
+ *
+ * Returns a new manifest object so the cached base manifest is never mutated.
+ */
+export function buildManifestWithClientEntry(
+  source: StartManifestWithClientEntry,
+): Manifest {
+  const scriptTag = buildClientEntryScriptTag(
+    source.clientEntry,
+    source.injectedHeadScripts,
+  )
+
+  const baseRootRoute = source.manifest.routes[rootRouteId]
+  const routes = {
+    ...source.manifest.routes,
+    ...(baseRootRoute
+      ? {
+          [rootRouteId]: {
+            ...baseRootRoute,
+            assets: [...(baseRootRoute.assets || []), scriptTag],
+          },
+        }
+      : {}),
+  }
+
+  return { routes }
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index a4efb9ef37..6e146d2ef7 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -2380,6 +2380,55 @@ importers:
         specifier: ^5.7.2
         version: 5.9.2
 
+  e2e/react-start/transform-asset-urls:
+    dependencies:
+      '@tanstack/react-router':
+        specifier: workspace:*
+        version: link:../../../packages/react-router
+      '@tanstack/react-start':
+        specifier: workspace:*
+        version: link:../../../packages/react-start
+      express:
+        specifier: ^5.1.0
+        version: 5.1.0
+      react:
+        specifier: ^19.2.3
+        version: 19.2.3
+      react-dom:
+        specifier: ^19.2.3
+        version: 19.2.3(react@19.2.3)
+    devDependencies:
+      '@playwright/test':
+        specifier: ^1.57.0
+        version: 1.57.0
+      '@tanstack/router-e2e-utils':
+        specifier: workspace:^
+        version: link:../../e2e-utils
+      '@types/node':
+        specifier: 25.0.9
+        version: 25.0.9
+      '@types/react':
+        specifier: ^19.2.8
+        version: 19.2.8
+      '@types/react-dom':
+        specifier: ^19.2.3
+        version: 19.2.3(@types/react@19.2.8)
+      '@vitejs/plugin-react':
+        specifier: ^4.3.4
+        version: 4.7.0(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))
+      srvx:
+        specifier: ^0.10.1
+        version: 0.10.1
+      typescript:
+        specifier: ^5.7.2
+        version: 5.9.3
+      vite:
+        specifier: ^7.3.1
+        version: 7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1)
+      vite-tsconfig-paths:
+        specifier: ^5.1.4
+        version: 5.1.4(typescript@5.9.3)(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))
+
   e2e/react-start/virtual-routes:
     dependencies:
       '@tanstack/react-router':
@@ -8336,7 +8385,7 @@ importers:
         version: 7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1)
       vitest:
         specifier: ^3.2.4
-        version: 3.2.4(@types/node@25.0.9)(@vitest/browser@4.0.17(msw@2.7.0(@types/node@25.0.9)(typescript@5.9.3))(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))(vitest@4.0.17))(@vitest/ui@4.0.17(vitest@4.0.17))(jiti@2.6.1)(jsdom@27.0.0(postcss@8.5.6))(lightningcss@1.30.2)(msw@2.7.0(@types/node@25.0.9)(typescript@5.9.2))(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1)
+        version: 3.2.4(@types/node@25.0.9)(@vitest/browser@4.0.17(msw@2.7.0(@types/node@25.0.9)(typescript@5.9.3))(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))(vitest@4.0.17))(@vitest/ui@4.0.17)(jiti@2.6.1)(jsdom@27.0.0(postcss@8.5.6))(lightningcss@1.30.2)(msw@2.7.0(@types/node@25.0.9)(typescript@5.9.2))(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1)
       web-vitals:
         specifier: ^5.1.0
         version: 5.1.0
@@ -10626,7 +10675,7 @@ importers:
     devDependencies:
       '@netlify/vite-plugin-tanstack-start':
         specifier: ^1.1.4
-        version: 1.1.4(@tanstack/solid-start@packages+solid-start)(babel-plugin-macros@3.1.0)(db0@0.3.4(@electric-sql/pglite@0.3.2)(@libsql/client@0.15.15)(mysql2@3.15.3))(encoding@0.1.13)(ioredis@5.9.2)(rollup@4.55.3)(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))
+        version: 1.1.4(@tanstack/solid-start@packages+solid-start)(babel-plugin-macros@3.1.0)(db0@0.3.4(@electric-sql/pglite@0.3.2)(@libsql/client@0.15.15)(mysql2@3.15.3))(ioredis@5.9.2)(rollup@4.55.3)(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))
       '@tailwindcss/vite':
         specifier: ^4.1.18
         version: 4.1.18(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))
@@ -10852,7 +10901,7 @@ importers:
         version: 2.11.10(@testing-library/jest-dom@6.6.3)(solid-js@1.9.10)(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))
       vitest:
         specifier: ^3.2.4
-        version: 3.2.4(@types/node@25.0.9)(@vitest/browser@4.0.17(msw@2.7.0(@types/node@25.0.9)(typescript@5.9.3))(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))(vitest@4.0.17))(@vitest/ui@4.0.17(vitest@4.0.17))(jiti@2.6.1)(jsdom@27.0.0(postcss@8.5.6))(lightningcss@1.30.2)(msw@2.7.0(@types/node@25.0.9)(typescript@5.9.2))(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1)
+        version: 3.2.4(@types/node@25.0.9)(@vitest/browser@4.0.17(msw@2.7.0(@types/node@25.0.9)(typescript@5.9.3))(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))(vitest@4.0.17))(@vitest/ui@4.0.17)(jiti@2.6.1)(jsdom@27.0.0(postcss@8.5.6))(lightningcss@1.30.2)(msw@2.7.0(@types/node@25.0.9)(typescript@5.9.2))(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1)
       web-vitals:
         specifier: ^5.1.0
         version: 5.1.0
@@ -27293,13 +27342,13 @@ snapshots:
       uuid: 11.1.0
       write-file-atomic: 5.0.1
 
-  '@netlify/dev@4.6.3(db0@0.3.4(@electric-sql/pglite@0.3.2)(@libsql/client@0.15.15)(mysql2@3.15.3))(encoding@0.1.13)(ioredis@5.9.2)(rollup@4.55.3)':
+  '@netlify/dev@4.6.3(db0@0.3.4(@electric-sql/pglite@0.3.2)(@libsql/client@0.15.15)(mysql2@3.15.3))(ioredis@5.9.2)(rollup@4.55.3)':
     dependencies:
       '@netlify/blobs': 10.1.0
       '@netlify/config': 23.2.0
       '@netlify/dev-utils': 4.3.0
       '@netlify/edge-functions-dev': 1.0.0
-      '@netlify/functions-dev': 1.0.0(encoding@0.1.13)(rollup@4.55.3)
+      '@netlify/functions-dev': 1.0.0(rollup@4.55.3)
       '@netlify/headers': 2.1.0
       '@netlify/images': 1.3.0(@netlify/blobs@10.1.0)(db0@0.3.4(@electric-sql/pglite@0.3.2)(@libsql/client@0.15.15)(mysql2@3.15.3))(ioredis@5.9.2)
       '@netlify/redirects': 3.1.0
@@ -27367,12 +27416,12 @@ snapshots:
     dependencies:
       '@netlify/types': 2.1.0
 
-  '@netlify/functions-dev@1.0.0(encoding@0.1.13)(rollup@4.55.3)':
+  '@netlify/functions-dev@1.0.0(rollup@4.55.3)':
     dependencies:
       '@netlify/blobs': 10.1.0
       '@netlify/dev-utils': 4.3.0
       '@netlify/functions': 5.0.0
-      '@netlify/zip-it-and-ship-it': 14.1.11(encoding@0.1.13)(rollup@4.55.3)
+      '@netlify/zip-it-and-ship-it': 14.1.11(rollup@4.55.3)
       cron-parser: 4.9.0
       decache: 4.6.2
       extract-zip: 2.0.1
@@ -27462,9 +27511,9 @@ snapshots:
 
   '@netlify/types@2.1.0': {}
 
-  '@netlify/vite-plugin-tanstack-start@1.1.4(@tanstack/solid-start@packages+solid-start)(babel-plugin-macros@3.1.0)(db0@0.3.4(@electric-sql/pglite@0.3.2)(@libsql/client@0.15.15)(mysql2@3.15.3))(encoding@0.1.13)(ioredis@5.9.2)(rollup@4.55.3)(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))':
+  '@netlify/vite-plugin-tanstack-start@1.1.4(@tanstack/solid-start@packages+solid-start)(babel-plugin-macros@3.1.0)(db0@0.3.4(@electric-sql/pglite@0.3.2)(@libsql/client@0.15.15)(mysql2@3.15.3))(ioredis@5.9.2)(rollup@4.55.3)(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))':
     dependencies:
-      '@netlify/vite-plugin': 2.7.4(babel-plugin-macros@3.1.0)(db0@0.3.4(@electric-sql/pglite@0.3.2)(@libsql/client@0.15.15)(mysql2@3.15.3))(encoding@0.1.13)(ioredis@5.9.2)(rollup@4.55.3)(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))
+      '@netlify/vite-plugin': 2.7.4(babel-plugin-macros@3.1.0)(db0@0.3.4(@electric-sql/pglite@0.3.2)(@libsql/client@0.15.15)(mysql2@3.15.3))(ioredis@5.9.2)(rollup@4.55.3)(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))
       vite: 7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1)
     optionalDependencies:
       '@tanstack/solid-start': link:packages/solid-start
@@ -27492,9 +27541,9 @@ snapshots:
       - supports-color
       - uploadthing
 
-  '@netlify/vite-plugin@2.7.4(babel-plugin-macros@3.1.0)(db0@0.3.4(@electric-sql/pglite@0.3.2)(@libsql/client@0.15.15)(mysql2@3.15.3))(encoding@0.1.13)(ioredis@5.9.2)(rollup@4.55.3)(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))':
+  '@netlify/vite-plugin@2.7.4(babel-plugin-macros@3.1.0)(db0@0.3.4(@electric-sql/pglite@0.3.2)(@libsql/client@0.15.15)(mysql2@3.15.3))(ioredis@5.9.2)(rollup@4.55.3)(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))':
     dependencies:
-      '@netlify/dev': 4.6.3(db0@0.3.4(@electric-sql/pglite@0.3.2)(@libsql/client@0.15.15)(mysql2@3.15.3))(encoding@0.1.13)(ioredis@5.9.2)(rollup@4.55.3)
+      '@netlify/dev': 4.6.3(db0@0.3.4(@electric-sql/pglite@0.3.2)(@libsql/client@0.15.15)(mysql2@3.15.3))(ioredis@5.9.2)(rollup@4.55.3)
       '@netlify/dev-utils': 4.3.0
       dedent: 1.7.0(babel-plugin-macros@3.1.0)
       vite: 7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1)
@@ -27522,13 +27571,13 @@ snapshots:
       - supports-color
       - uploadthing
 
-  '@netlify/zip-it-and-ship-it@14.1.11(encoding@0.1.13)(rollup@4.55.3)':
+  '@netlify/zip-it-and-ship-it@14.1.11(rollup@4.55.3)':
     dependencies:
       '@babel/parser': 7.28.5
       '@babel/types': 7.28.4
       '@netlify/binary-info': 1.0.0
       '@netlify/serverless-functions-api': 2.7.1
-      '@vercel/nft': 0.29.4(encoding@0.1.13)(rollup@4.55.3)
+      '@vercel/nft': 0.29.4(rollup@4.55.3)
       archiver: 7.0.1
       common-path-prefix: 3.0.0
       copy-file: 11.1.0
@@ -30733,7 +30782,7 @@ snapshots:
   '@unrs/resolver-binding-win32-x64-msvc@1.11.1':
     optional: true
 
-  '@vercel/nft@0.29.4(encoding@0.1.13)(rollup@4.55.3)':
+  '@vercel/nft@0.29.4(rollup@4.55.3)':
     dependencies:
       '@mapbox/node-pre-gyp': 2.0.0(encoding@0.1.13)
       '@rollup/pluginutils': 5.1.4(rollup@4.55.3)
@@ -38200,7 +38249,7 @@ snapshots:
     optionalDependencies:
       vite: 7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1)
 
-  vitest@3.2.4(@types/node@25.0.9)(@vitest/browser@4.0.17(msw@2.7.0(@types/node@25.0.9)(typescript@5.9.3))(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))(vitest@4.0.17))(@vitest/ui@4.0.17(vitest@4.0.17))(jiti@2.6.1)(jsdom@27.0.0(postcss@8.5.6))(lightningcss@1.30.2)(msw@2.7.0(@types/node@25.0.9)(typescript@5.9.2))(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1):
+  vitest@3.2.4(@types/node@25.0.9)(@vitest/browser@4.0.17(msw@2.7.0(@types/node@25.0.9)(typescript@5.9.3))(vite@7.3.1(@types/node@25.0.9)(jiti@2.6.1)(lightningcss@1.30.2)(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1))(vitest@4.0.17))(@vitest/ui@4.0.17)(jiti@2.6.1)(jsdom@27.0.0(postcss@8.5.6))(lightningcss@1.30.2)(msw@2.7.0(@types/node@25.0.9)(typescript@5.9.2))(sass-embedded@1.97.2)(sass@1.97.2)(terser@5.37.0)(tsx@4.20.3)(yaml@2.8.1):
     dependencies:
       '@types/chai': 5.2.2
       '@vitest/expect': 3.2.4

From 19ca303385a062af21a01b75511ce3cadefda6c3 Mon Sep 17 00:00:00 2001
From: Manuel Schiller <manuel.schiller@caligano.de>
Date: Sat, 7 Feb 2026 00:29:37 +0100
Subject: [PATCH 2/5] fix docs

---
 .../framework/react/guide/cdn-asset-urls.md   | 21 ++++++++++---------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/docs/start/framework/react/guide/cdn-asset-urls.md b/docs/start/framework/react/guide/cdn-asset-urls.md
index 0c5671acdb..dda3971a5a 100644
--- a/docs/start/framework/react/guide/cdn-asset-urls.md
+++ b/docs/start/framework/react/guide/cdn-asset-urls.md
@@ -30,7 +30,6 @@ import {
   defaultStreamHandler,
 } from '@tanstack/react-start/server'
 import { createServerEntry } from '@tanstack/react-start/server-entry'
-import { getRequest } from '@tanstack/react-start/server'
 
 const handler = createStartHandler({
   handler: defaultStreamHandler,
@@ -46,7 +45,7 @@ When the string is empty (or not set), the URLs are left unchanged.
 
 ### Callback
 
-For more control, pass a callback that receives `{ url, type }` and returns a new URL (or a `Promise` of one). If you need the request, call `getRequest()` inside the callback. Like the string form, the result is cached after the first request by default:
+For more control, pass a callback that receives `{ url, type }` and returns a new URL (or a `Promise` of one). By default, the transformed manifest is cached after the first request (`cache: true`), so the callback only runs once in production:
 
 ```tsx
 // src/server.ts
@@ -55,7 +54,6 @@ import {
   defaultStreamHandler,
 } from '@tanstack/react-start/server'
 import { createServerEntry } from '@tanstack/react-start/server-entry'
-import { getRequest } from '@tanstack/react-start/server'
 
 const handler = createStartHandler({
   handler: defaultStreamHandler,
@@ -69,6 +67,8 @@ const handler = createStartHandler({
 export default createServerEntry({ fetch: handler })
 ```
 
+If you need per-request behavior (for example, choosing a CDN based on a header), use the object form with `cache: false`.
+
 The `type` parameter tells you what kind of asset URL is being transformed:
 
 | `type`            | Description                                          |
@@ -88,6 +88,7 @@ import {
   defaultStreamHandler,
 } from '@tanstack/react-start/server'
 import { createServerEntry } from '@tanstack/react-start/server-entry'
+import { getRequest } from '@tanstack/react-start/server'
 
 const handler = createStartHandler({
   handler: defaultStreamHandler,
@@ -109,14 +110,14 @@ export default createServerEntry({ fetch: handler })
 
 The object form accepts:
 
-| Property          | Type                            | Description                                                                                   |
-| ----------------- | ------------------------------- | --------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
-| `transform`       | `string \| (context) => string` | A string prefix or callback, same as the shorthand forms above.                               |
-| `createTransform` | `({ warmup: true }              | { warmup: false; request: Request }) => (asset) => string \| Promise<string>`                 | Async factory that runs once per manifest computation and returns a per-asset transform. Mutually exclusive with `transform`. |
-| `cache`           | `boolean`                       | Whether to cache the transformed manifest. Defaults to `true`.                                |
-| `warmup`          | `boolean`                       | When `true`, warms up the cached manifest on server startup (prod only). Defaults to `false`. |
+| Property          | Type | Description |
+| ----------------- | ---- | ----------- |
+| `transform`       | `string \| (asset) => string \| Promise<string>` | A string prefix or callback, same as the shorthand forms above. |
+| `createTransform` | `(ctx: { warmup: true } \| { warmup: false; request: Request }) => (asset) => string \| Promise<string>` | Async factory that runs once per manifest computation and returns a per-asset transform. Mutually exclusive with `transform`. |
+| `cache`           | `boolean` | Whether to cache the transformed manifest. Defaults to `true`. |
+| `warmup`          | `boolean` | When `true`, warms up the cached manifest on server startup (prod only). Defaults to `false`. |
 
-If you need to do async work once (e.g. fetch a CDN origin from a service) and then transform many URLs, prefer `createTransform`:
+If you need to do async work once per manifest computation (e.g. fetch a CDN origin from a service) and then transform many URLs, prefer `createTransform`:
 
 ```ts
 transformAssetUrls: {

From 46136b016cb47627f510fbbd6122bc47f0293bab Mon Sep 17 00:00:00 2001
From: Manuel Schiller <manuel.schiller@caligano.de>
Date: Sat, 7 Feb 2026 00:41:55 +0100
Subject: [PATCH 3/5] stringify safely

---
 packages/start-server-core/src/transformAssetUrls.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/start-server-core/src/transformAssetUrls.ts b/packages/start-server-core/src/transformAssetUrls.ts
index 6ff6f490e8..50ab5f4dc9 100644
--- a/packages/start-server-core/src/transformAssetUrls.ts
+++ b/packages/start-server-core/src/transformAssetUrls.ts
@@ -171,7 +171,8 @@ export function buildClientEntryScriptTag(
   clientEntry: string,
   injectedHeadScripts?: string,
 ): RouterManagedTag {
-  let script = `import('${clientEntry}')`
+  const clientEntryLiteral = JSON.stringify(clientEntry)
+  let script = `import(${clientEntryLiteral})`
   if (injectedHeadScripts) {
     script = `${injectedHeadScripts};${script}`
   }

From 024b837c88e999e1f88feacb4e88049e3a79fa29 Mon Sep 17 00:00:00 2001
From: Manuel Schiller <manuel.schiller@caligano.de>
Date: Sat, 7 Feb 2026 01:28:47 +0100
Subject: [PATCH 4/5] fix test

---
 .../transform-asset-urls/tests/transform-asset-urls.spec.ts     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/e2e/react-start/transform-asset-urls/tests/transform-asset-urls.spec.ts b/e2e/react-start/transform-asset-urls/tests/transform-asset-urls.spec.ts
index 62fcb0f0b8..c2bc6da1c4 100644
--- a/e2e/react-start/transform-asset-urls/tests/transform-asset-urls.spec.ts
+++ b/e2e/react-start/transform-asset-urls/tests/transform-asset-urls.spec.ts
@@ -120,7 +120,7 @@ test.describe('transformAssetUrls with CDN prefix', () => {
 
     // The client entry script should contain an import() with CDN-prefixed URL
     const clientEntryMatch = html.match(
-      /import\('(http:\/\/localhost:\d+\/[^']+)'\)/,
+      /import\("(http:\/\/localhost:\d+\/[^"]+)"\)/,
     )
     expect(clientEntryMatch).toBeTruthy()
     expect(clientEntryMatch![1]).toMatch(/^http:\/\/localhost:\d+\//)

From 70eaf7a6819ed842cd51902b7f84ab0cc19e62e9 Mon Sep 17 00:00:00 2001
From: Manuel Schiller <manuel.schiller@caligano.de>
Date: Sat, 7 Feb 2026 01:56:07 +0100
Subject: [PATCH 5/5] fix

---
 .../framework/react/guide/cdn-asset-urls.md   | 37 +++++++++++++++---
 .../tests/transform-asset-urls.spec.ts        | 38 +++++++++++++++++--
 .../transform-asset-urls/vite.config.ts       |  1 +
 3 files changed, 67 insertions(+), 9 deletions(-)

diff --git a/docs/start/framework/react/guide/cdn-asset-urls.md b/docs/start/framework/react/guide/cdn-asset-urls.md
index dda3971a5a..977c030c68 100644
--- a/docs/start/framework/react/guide/cdn-asset-urls.md
+++ b/docs/start/framework/react/guide/cdn-asset-urls.md
@@ -110,12 +110,12 @@ export default createServerEntry({ fetch: handler })
 
 The object form accepts:
 
-| Property          | Type | Description |
-| ----------------- | ---- | ----------- |
-| `transform`       | `string \| (asset) => string \| Promise<string>` | A string prefix or callback, same as the shorthand forms above. |
+| Property          | Type                                                                                                     | Description                                                                                                                   |
+| ----------------- | -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| `transform`       | `string \| (asset) => string \| Promise<string>`                                                         | A string prefix or callback, same as the shorthand forms above.                                                               |
 | `createTransform` | `(ctx: { warmup: true } \| { warmup: false; request: Request }) => (asset) => string \| Promise<string>` | Async factory that runs once per manifest computation and returns a per-asset transform. Mutually exclusive with `transform`. |
-| `cache`           | `boolean` | Whether to cache the transformed manifest. Defaults to `true`. |
-| `warmup`          | `boolean` | When `true`, warms up the cached manifest on server startup (prod only). Defaults to `false`. |
+| `cache`           | `boolean`                                                                                                | Whether to cache the transformed manifest. Defaults to `true`.                                                                |
+| `warmup`          | `boolean`                                                                                                | When `true`, warms up the cached manifest on server startup (prod only). Defaults to `false`.                                 |
 
 If you need to do async work once per manifest computation (e.g. fetch a CDN origin from a service) and then transform many URLs, prefer `createTransform`:
 
@@ -165,6 +165,33 @@ This has no effect in development mode, or when `cache: false`.
 
 > **Note:** In development mode (`TSS_DEV_SERVER`), caching is always skipped regardless of the `cache` setting, so you always get fresh manifests.
 
+## Recommended: Set `base: ''` for Client-Side Navigation
+
+`transformAssetUrls` rewrites the URLs in the SSR HTML — modulepreload hints, stylesheets, and the client entry script. This means the browser's initial page load fetches all assets from the CDN.
+
+However, when users navigate client-side (e.g., clicking a `<Link>`), TanStack Router lazy-loads route chunks using `import()` calls with paths that were baked in at **build time** by Vite. By default, Vite uses `base: '/'`, which produces absolute paths like `/assets/about-abc123.js`. These resolve against the **app server's origin**, not the CDN — even though the entry module was loaded from the CDN.
+
+To fix this, set `base: ''` in your Vite config:
+
+```ts
+// vite.config.ts
+export default defineConfig({
+  base: '',
+  // ... plugins, etc.
+})
+```
+
+With `base: ''`, Vite generates **relative** import paths for client-side chunks. Since the client entry module was loaded from the CDN (thanks to `transformAssetUrls`), all relative `import()` calls resolve against the CDN origin. This ensures that lazy-loaded route chunks during client-side navigation are also served from the CDN.
+
+Using an empty string rather than `'./'` is important — both produce relative client-side imports, but `base: ''` preserves the correct root-relative paths (`/assets/...`) in the SSR manifest so that `transformAssetUrls` can properly prepend the CDN origin.
+
+| `base` setting  | SSR assets (initial load)      | Client-side navigation chunks  |
+| --------------- | ------------------------------ | ------------------------------ |
+| `'/'` (default) | CDN (via `transformAssetUrls`) | App server                     |
+| `''`            | CDN (via `transformAssetUrls`) | CDN (relative to entry module) |
+
+> **Tip:** `base: ''` is recommended whenever you use `transformAssetUrls` so that all assets — both on initial load and during client-side navigation — are consistently served from the CDN.
+
 ## What This Does NOT Cover
 
 `transformAssetUrls` only rewrites URLs in the TanStack Start manifest — the tags emitted during SSR for preloading and bootstrapping the application.
diff --git a/e2e/react-start/transform-asset-urls/tests/transform-asset-urls.spec.ts b/e2e/react-start/transform-asset-urls/tests/transform-asset-urls.spec.ts
index c2bc6da1c4..5ab10da6f2 100644
--- a/e2e/react-start/transform-asset-urls/tests/transform-asset-urls.spec.ts
+++ b/e2e/react-start/transform-asset-urls/tests/transform-asset-urls.spec.ts
@@ -103,7 +103,7 @@ test.describe('transformAssetUrls with CDN prefix', () => {
 
     // Now load /about and verify the CSS module style is actually applied.
     await page.goto('/about')
-    await page.waitForLoadState('networkidle')
+    await expect(page.getByTestId('about-card')).toBeVisible()
 
     const bgColor = await page
       .getByTestId('about-card')
@@ -119,8 +119,9 @@ test.describe('transformAssetUrls with CDN prefix', () => {
     const html = await getSSRHtml(page)
 
     // The client entry script should contain an import() with CDN-prefixed URL
+    // JSON.stringify produces double quotes; bundler optimisation may use single quotes
     const clientEntryMatch = html.match(
-      /import\("(http:\/\/localhost:\d+\/[^"]+)"\)/,
+      /import\(["'](http:\/\/localhost:\d+\/[^"']+)["']\)/,
     )
     expect(clientEntryMatch).toBeTruthy()
     expect(clientEntryMatch![1]).toMatch(/^http:\/\/localhost:\d+\//)
@@ -128,7 +129,6 @@ test.describe('transformAssetUrls with CDN prefix', () => {
 
   test('page renders correctly with CDN-served assets', async ({ page }) => {
     await page.goto('/')
-    await page.waitForLoadState('networkidle')
 
     // Page content renders
     await expect(page.getByTestId('home-heading')).toHaveText('Welcome Home')
@@ -139,7 +139,7 @@ test.describe('transformAssetUrls with CDN prefix', () => {
 
   test('CSS is applied correctly from CDN', async ({ page }) => {
     await page.goto('/')
-    await page.waitForLoadState('networkidle')
+    await expect(page.locator('.app-styled')).toBeVisible()
 
     // Verify that the CSS from app.css is actually applied
     // The .app-styled class sets background-color to #f0f0f0
@@ -179,17 +179,47 @@ test.describe('transformAssetUrls with CDN prefix', () => {
   test('client-side navigation to /about loads split chunk from CDN', async ({
     page,
   }) => {
+    const appOrigin = new URL(
+      test.info().project.use.baseURL || 'http://localhost:3000',
+    ).origin
+
     await page.goto('/')
     await page.waitForLoadState('networkidle')
 
+    // Start tracking network requests after initial page load so we only
+    // capture requests triggered by the client-side navigation
+    const navigationAssetRequests: Array<{
+      url: string
+      fromCdn: boolean
+    }> = []
+
+    page.on('request', (request) => {
+      const url = request.url()
+      if (/\.(js|css)(\?|$)/.test(url)) {
+        const origin = new URL(url).origin
+        navigationAssetRequests.push({ url, fromCdn: origin !== appOrigin })
+      }
+    })
+
     await page.getByTestId('link-to-about').click()
     await page.waitForURL('**/about')
     await expect(page.getByTestId('about-heading')).toHaveText('About')
 
     // Ensure CSS modules were loaded and applied after client navigation
+    await expect(page.getByTestId('about-card')).toBeVisible()
     const bgColor = await page
       .getByTestId('about-card')
       .evaluate((el) => getComputedStyle(el).backgroundColor)
     expect(bgColor).toBe('rgb(255, 243, 196)')
+
+    // With base: '', lazy-loaded route chunks should come from the CDN, not the app server.
+    // Filter to JS requests only (the route chunk import)
+    const jsRequests = navigationAssetRequests.filter((r) =>
+      /\.js(\?|$)/.test(r.url),
+    )
+    expect(jsRequests.length).toBeGreaterThan(0)
+
+    const cdnJsRequests = jsRequests.filter((r) => r.fromCdn)
+    expect(cdnJsRequests.length).toBeGreaterThan(0)
   })
 })
diff --git a/e2e/react-start/transform-asset-urls/vite.config.ts b/e2e/react-start/transform-asset-urls/vite.config.ts
index c2c28ae93b..ca16b6425b 100644
--- a/e2e/react-start/transform-asset-urls/vite.config.ts
+++ b/e2e/react-start/transform-asset-urls/vite.config.ts
@@ -4,6 +4,7 @@ import { tanstackStart } from '@tanstack/react-start/plugin/vite'
 import viteReact from '@vitejs/plugin-react'
 
 export default defineConfig({
+  base: '',
   server: {
     port: 3000,
   },