diff --git a/docs/guide/pages-routing/loaders.md b/docs/guide/pages-routing/loaders.md
index eb175d8d7..0f61c369a 100644
--- a/docs/guide/pages-routing/loaders.md
+++ b/docs/guide/pages-routing/loaders.md
@@ -237,7 +237,7 @@ export default function Dashboard(props: Props) {
 
 ### How Streaming Works
 
-On the initial page load (SSR), React uses React 19 streaming SSR and renders the nearest Suspense fallback for deferred props; the other adapters render their loading state. As each deferred function resolves, the server streams an inline `<script>` tag that delivers the data, so no extra HTTP request is needed. On SPA navigation, deferred data streams via NDJSON over the same response.
+On the initial page load (SSR), React uses React 19 streaming SSR and renders the nearest Suspense fallback for deferred props; the other adapters render their loading state. As each deferred function resolves, the server streams an inline `<script>` tag that delivers the data, so no extra HTTP request is needed. Routes with `export const ssr = false` skip server-rendered component HTML but still stream deferred resolution scripts after the client-mounted shell. On SPA navigation, deferred data streams via NDJSON over the same response.
 
 ### Deferred Props After Mutations
 
diff --git a/docs/guide/pages-routing/overview.md b/docs/guide/pages-routing/overview.md
index b08f91971..c5c53514e 100644
--- a/docs/guide/pages-routing/overview.md
+++ b/docs/guide/pages-routing/overview.md
@@ -100,6 +100,7 @@ Each page can have a companion `.server.ts` file that runs exclusively on the se
 
 - A [**loader**](./loaders), which runs on `GET` and returns the data that becomes the page component's props
 - [**Actions**](./actions-and-forms), which handle mutations from forms and programmatic calls. Export a single `action` or multiple [named actions](./actions-and-forms#named-actions) when a page has several mutations
+- `ssr = false` to opt a route out of server-rendered component HTML while keeping server loaders and client-side routing
 
 File-based routing rules are the same as [server routing](../server-routing.md): `[param]` for dynamic segments, `[...param]` for catch-all, `(group)/` for route groups.
 
@@ -107,14 +108,40 @@ File-based routing rules are the same as [server routing](../server-routing.md):
 
 Pages uses an Inertia-style protocol under the hood:
 
-| Request               | Response                                                              |
-| --------------------- | --------------------------------------------------------------------- |
-| Initial page load     | Full SSR HTML. Client hydrates automatically.                         |
-| Subsequent navigation | JSON with component name + props. Client component swap or re-render. |
-| Form submission       | Runs action, then returns fresh props or a redirect.                  |
+| Request               | Response                                                                                                       |
+| --------------------- | -------------------------------------------------------------------------------------------------------------- |
+| Initial page load     | Full SSR HTML. Client hydrates automatically. Routes with `ssr = false` return a client-mounted shell instead. |
+| Subsequent navigation | JSON with component name + props. Client component swap or re-render.                                          |
+| Form submission       | Runs action, then returns fresh props or a redirect.                                                           |
 
 This means the first page load is server-rendered for SEO and performance, while later navigations stay fast without full page reloads.
 
+To opt a specific route out of server-rendered component HTML, export `ssr = false` from its companion `.server.ts` file:
+
+```ts
+// pages/dashboard.server.ts
+import { defineHandler } from 'void';
+
+export const ssr = false;
+
+export const loader = defineHandler(async () => {
+  return { title: 'Dashboard' };
+});
+```
+
+The loader still runs on the first request, and its props are embedded in the HTML shell. The page component mounts in the browser instead of hydrating server-rendered markup.
+
+Render and prerender flags combine like this:
+
+| Page exports                           | Behavior                                                                  |
+| -------------------------------------- | ------------------------------------------------------------------------- |
+| `ssr` unset or `true`                  | Server-render component HTML on request.                                  |
+| `ssr = false`                          | Return a client-mounted shell on request.                                 |
+| `ssr = false` + `prerender = true`     | Prerender a client-mounted shell with embedded loader data.               |
+| `ssr = false` + `prerender = false`    | Return the client-mounted shell only on request; never prerender it.      |
+| Island page + `ssr = false`            | Invalid. Island pages already use the island renderer.                    |
+| `output: "static"` + `prerender` unset | Auto-prerender pages that have known paths, including client-only shells. |
+
 Use the `Link` component for SPA navigation between pages. It renders an `<a>` tag that intercepts clicks and navigates without a full page reload:
 
 ::: code-group
diff --git a/docs/reference/config.md b/docs/reference/config.md
index be5f62380..6d085465d 100644
--- a/docs/reference/config.md
+++ b/docs/reference/config.md
@@ -172,7 +172,7 @@ Output mode. Controls the default rendering strategy for pages.
 
 When set to `"static"`, all pages are prerendered at build time as static HTML files written to `dist/client/`. Individual pages can opt out with `export const prerender = false`. Dynamic pages (with route params) without a `getPrerenderPaths()` export are implicitly not prerendered.
 
-When omitted or set to `"server"`, pages are server-rendered on request. Individual pages can opt into deploy-time prerendering with `export const prerender = true`.
+When omitted or set to `"server"`, pages are server-rendered on request. Individual pages can opt into deploy-time prerendering with `export const prerender = true`, or opt out of server-rendered component HTML with `export const ssr = false`.
 
 ```json
 { "output": "static" }
diff --git a/packages/react/README.md b/packages/react/README.md
index aa4ceb2b5..aa45449bd 100644
--- a/packages/react/README.md
+++ b/packages/react/README.md
@@ -88,6 +88,10 @@ the hydrated client. Put deferred reads behind Suspense, and use a normal React
 error boundary around that Suspense boundary when rejected deferred values need a
 custom error state.
 
+Export `ssr = false` from a page's `.server.ts` file to skip server-rendered
+component HTML for that route. The loader still runs and the browser mounts the
+page with the embedded initial props.
+
 For explicit prop annotations in React pages, import `Deferred` from
 `@void/react`:
 
diff --git a/packages/react/src/plugin-pages.ts b/packages/react/src/plugin-pages.ts
index 49644554b..137af552c 100644
--- a/packages/react/src/plugin-pages.ts
+++ b/packages/react/src/plugin-pages.ts
@@ -237,6 +237,7 @@ import { renderReactPage } from "@void/react/pages-server";
 ${generateComponentManifest(scan, pagesDir)}
 
 	const PREAMBLE_SCRIPT = ${JSON.stringify(preambleScript)};
+	export const renderPreambleScript = PREAMBLE_SCRIPT;
 	
 	export async function renderPage(pageObj, assetTags) {
 	  return renderReactPage({
@@ -247,6 +248,7 @@ ${generateComponentManifest(scan, pagesDir)}
 	    preambleScript: PREAMBLE_SCRIPT,
 	  });
 }
+renderPage.preambleScript = PREAMBLE_SCRIPT;
 `;
 }
 
diff --git a/packages/react/src/runtime/pages-client.ts b/packages/react/src/runtime/pages-client.ts
index 3af5dd677..3a5e1a02a 100644
--- a/packages/react/src/runtime/pages-client.ts
+++ b/packages/react/src/runtime/pages-client.ts
@@ -12,7 +12,7 @@ import React, {
   useTransition,
   type ComponentType,
 } from 'react';
-import { hydrateRoot } from 'react-dom/client';
+import { createRoot, hydrateRoot } from 'react-dom/client';
 import {
   createRouterFacade,
   createPageNavigationEngine,
@@ -625,11 +625,17 @@ export async function startReactPages(config: ReactPagesConfig): Promise<ReactPa
     throw new Error('pages: Missing #app element for Void React pages hydration.');
   }
 
+  const app = React.createElement(App, {
+    engine,
+    router,
+    viewTransitions: config.viewTransitions,
+  });
   startTransition(() => {
-    hydrateRoot(
-      appEl,
-      React.createElement(App, { engine, router, viewTransitions: config.viewTransitions }),
-    );
+    if (appEl.getAttribute('data-void-ssr') === 'false') {
+      createRoot(appEl).render(app);
+    } else {
+      hydrateRoot(appEl, app);
+    }
   });
   appEl.setAttribute('data-hydrated', 'true');
   engine.start();
diff --git a/packages/react/test/integration/react-pages-client.test.ts b/packages/react/test/integration/react-pages-client.test.ts
index 612f1f5fc..755535559 100644
--- a/packages/react/test/integration/react-pages-client.test.ts
+++ b/packages/react/test/integration/react-pages-client.test.ts
@@ -333,6 +333,35 @@ function defineClientTests(getBase: () => string) {
     }
   });
 
+  it('client-only page uses the shell on first load and mounts from loader props', async () => {
+    const htmlRes = await fetch(BASE + '/client-only');
+    expect(htmlRes.status).toBe(200);
+    const html = await htmlRes.text();
+    expect(html).toContain('__VOID_PAGE_DATA__');
+    expect(html).toContain('data-void-ssr="false"');
+    expect(html).toContain('<title>Client-only Route | React Pages Demo</title>');
+    expect(html).toContain('React Pages client-only route');
+    expect(html).toContain('Client-only Route');
+    expect(html).not.toContain('Client-only Page');
+    expect(html).not.toContain('client-only page component rendered on the server');
+
+    const page = await newPage();
+    try {
+      await page.goto(BASE + '/client-only');
+      await waitForHydration(page);
+      await page.waitForFunction(() =>
+        document.querySelector('h1')?.textContent?.includes('Client-only Page'),
+      );
+
+      expect(await page.textContent('[data-testid="client-only-title"]')).toBe('Client-only Route');
+      expect(await page.textContent('[data-testid="client-only-marker"]')).toBe(
+        'loader-props-available',
+      );
+    } finally {
+      await page.context().close();
+    }
+  });
+
   it('layout persists across navigation', async () => {
     const page = await newPage();
 
diff --git a/packages/react/test/unit/plugin-pages.test.ts b/packages/react/test/unit/plugin-pages.test.ts
index 9f883ede7..1c70120f9 100644
--- a/packages/react/test/unit/plugin-pages.test.ts
+++ b/packages/react/test/unit/plugin-pages.test.ts
@@ -104,4 +104,19 @@ describe('pagesPlugin dev config', () => {
 
     expect(renderer).toContain('"test": () => import');
   });
+
+  it('exposes the React dev preamble for client-only page shells', async () => {
+    writePage('index.tsx', 'export default function Index() { return <h1>Home</h1>; }\n');
+
+    const plugin = pagesPlugin(PAGES_DIR) as PagesPluginHooks;
+    getHookHandler(plugin.config)({}, { command: 'serve' });
+    await getHookHandler(plugin.buildStart).call({});
+
+    const load = getHookHandler(plugin.load);
+    const renderer = await load('\0virtual:void-pages-renderer');
+
+    expect(renderer).toContain('__vite_plugin_react_preamble_installed__ = true');
+    expect(renderer).toContain('export const renderPreambleScript = PREAMBLE_SCRIPT');
+    expect(renderer).toContain('renderPage.preambleScript = PREAMBLE_SCRIPT');
+  });
 });
diff --git a/packages/solid/README.md b/packages/solid/README.md
index 0b1b1a48c..bc11b8043 100644
--- a/packages/solid/README.md
+++ b/packages/solid/README.md
@@ -109,6 +109,10 @@ import { defineHandler } from 'void';
 export const loader = defineHandler(() => ({ title: 'Home' }));
 ```
 
+Export `ssr = false` from a page's `.server.ts` file to skip server-rendered
+component HTML for that route while still running its loader on the first
+request.
+
 ## Tests
 
 - `test/unit/use-form.test.ts`
diff --git a/packages/solid/src/plugin-pages.ts b/packages/solid/src/plugin-pages.ts
index 827eb85aa..a0585d95b 100644
--- a/packages/solid/src/plugin-pages.ts
+++ b/packages/solid/src/plugin-pages.ts
@@ -257,7 +257,7 @@ function generateClientEntry(
 ): string {
   return `
 import { createSignal, createComponent, batch } from "solid-js";
-import { hydrate } from "solid-js/web";
+import { hydrate, render } from "solid-js/web";
 import { SharedContext, ErrorsContext, ParamsContext, RouterContext, NavigationContext, setActionRouter } from "@void/solid";
 import { createRouterFacade, createVoidRouter, idleNavigationState } from "void/pages-client";
 import { parseCacheFor } from "void/pages-prefetch";
@@ -360,7 +360,12 @@ function App() {
 }
 
 const appEl = document.getElementById("app");
-hydrate(() => createComponent(App, {}), appEl);
+if (!appEl) throw new Error("pages: Missing #app element for Void Solid pages hydration.");
+if (appEl.getAttribute("data-void-ssr") === "false") {
+  render(() => createComponent(App, {}), appEl);
+} else {
+  hydrate(() => createComponent(App, {}), appEl);
+}
 appEl.setAttribute("data-hydrated", "true");
 export { reactiveRouter as router };
 start();
diff --git a/packages/svelte/README.md b/packages/svelte/README.md
index f8b3c6734..85a502002 100644
--- a/packages/svelte/README.md
+++ b/packages/svelte/README.md
@@ -105,6 +105,10 @@ import { defineHandler } from 'void';
 export const loader = defineHandler(() => ({ title: 'Home' }));
 ```
 
+Export `ssr = false` from a page's `.server.ts` file to skip server-rendered
+component HTML for that route while still running its loader on the first
+request.
+
 ## Tests
 
 - `test/unit/use-form.test.ts`
diff --git a/packages/svelte/src/plugin-pages.ts b/packages/svelte/src/plugin-pages.ts
index 3caf50ac4..70ee90d39 100644
--- a/packages/svelte/src/plugin-pages.ts
+++ b/packages/svelte/src/plugin-pages.ts
@@ -239,7 +239,7 @@ function generateClientEntry(
   staticPageData?: StaticPageDataBuildOptions,
 ): string {
   return `
-import { hydrate } from "svelte";
+import { hydrate, mount } from "svelte";
 import { writable } from "svelte/store";
 import App from "@void/svelte/App.svelte";
 import { setActionRouter } from "@void/svelte";
@@ -307,7 +307,8 @@ routeParams = initialPageData.params || {};
 paramsStore.set(routeParams);
 
 const appEl = document.getElementById("app");
-hydrate(App, {
+if (!appEl) throw new Error("pages: Missing #app element for Void Svelte pages hydration.");
+const appOptions = {
   target: appEl,
   props: {
     page: initialComponent,
@@ -330,7 +331,12 @@ hydrate(App, {
       navigation: navigationStore,
     },
   },
-});
+};
+if (appEl.getAttribute("data-void-ssr") === "false") {
+  mount(App, appOptions);
+} else {
+  hydrate(App, appOptions);
+}
 
 appEl.setAttribute("data-hydrated", "true");
 export { reactiveRouter as router };
diff --git a/packages/void/src/cli/deploy.ts b/packages/void/src/cli/deploy.ts
index 856ca2e58..4c07a69a9 100644
--- a/packages/void/src/cli/deploy.ts
+++ b/packages/void/src/cli/deploy.ts
@@ -1603,7 +1603,8 @@ async function runFullDeploy(
   // with no backend features, deploy as a static site (no worker needed)
   if (deployConfig.output === 'static' && pageScan && !isSsr) {
     const allPrerenderable = pageScan.pages.every(
-      (p) => p.prerender && ((p.params.length === 0 && !p.catchAll) || p.hasGetPrerenderPaths),
+      (p) =>
+        p.shouldPrerender && ((p.params.length === 0 && !p.catchAll) || p.hasGetPrerenderPaths),
     );
     const hasNonPageBackend =
       hasRoutes || hasMiddleware || hasWebSockets || authEnabled || liveConfig !== undefined;
diff --git a/packages/void/src/pages/protocol.ts b/packages/void/src/pages/protocol.ts
index 74375673f..7788ac7ba 100644
--- a/packages/void/src/pages/protocol.ts
+++ b/packages/void/src/pages/protocol.ts
@@ -1,8 +1,16 @@
 import type { CloudBindings, CloudContext } from '../runtime/handler.ts';
 import { isConvertedResponse } from '../runtime/response.ts';
 import { DEFERRED, separateDeferred, type ResolvedDeferredGroup } from './defer.ts';
-import { resolveHead, type HeadDescriptor, type HeadConfig } from './head.ts';
-import type { DevCssAsset } from './types.ts';
+import {
+  resolveHead,
+  renderBodyAttrs,
+  renderHeadToString,
+  renderHtmlAttrs,
+  type HeadDescriptor,
+  type HeadConfig,
+} from './head.ts';
+import { serializePageData } from './serialize.ts';
+import type { DevCssAsset, PageRenderMode } from './types.ts';
 import { ValidationError } from './validation-error.ts';
 
 export { ValidationError };
@@ -53,6 +61,9 @@ type PageHandler = ((c: CloudContext) => unknown | Promise<unknown>) | undefined
 type PageHeadHandler =
   | ((c: CloudContext, props: Record<string, unknown>) => HeadDescriptor | undefined)
   | undefined;
+type PageRenderOptions = {
+  renderMode?: PageRenderMode;
+};
 type AssetTags = {
   css: string;
   preloads: string;
@@ -61,6 +72,9 @@ type AssetTags = {
   devCssNonce?: string;
 };
 type RenderPage = (pageObj: PageObject, assetTags: AssetTags) => Promise<PageRenderResult>;
+type RenderPageWithMetadata = RenderPage & {
+  preambleScript?: string;
+};
 type GetAssetTags = (req: Request, env: CloudBindings, componentId: string) => Promise<AssetTags>;
 
 function isPagesRequest(c: CloudContext): boolean {
@@ -194,6 +208,28 @@ async function renderWithAssetTags(
   }
 }
 
+function renderClientOnlyPage(
+  pageObj: PageObject,
+  assetTags: AssetTags,
+  renderFn: RenderPageWithMetadata,
+): string {
+  const pageData = serializePageData(pageObj);
+  const headHtml = pageObj.head ? renderHeadToString(pageObj.head) : '';
+  const htmlAttrs = pageObj.head ? renderHtmlAttrs(pageObj.head) : '';
+  const bodyAttrs = pageObj.head ? renderBodyAttrs(pageObj.head) : '';
+  const preambleScript = typeof renderFn.preambleScript === 'string' ? renderFn.preambleScript : '';
+
+  return `<!doctype html>
+<html${htmlAttrs}>
+<head>${headHtml}${preambleScript}${assetTags.css}${assetTags.preloads}</head>
+<body${bodyAttrs}>
+  <script id="__VOID_PAGE_DATA__" type="application/json">${pageData}</script>
+  <div id="app" data-void-ssr="false"></div>
+  ${assetTags.body}
+</body>
+</html>`;
+}
+
 function pageJsonResponse(c: CloudContext, pageObj: PageObject): Response {
   return Response.json(pageObj, {
     headers: pageResponseHeaders(c, {
@@ -342,8 +378,9 @@ export async function handlePageGet(
   renderFn: RenderPage,
   getAssetTags: GetAssetTags,
   configHead?: HeadConfig,
-  island?: boolean,
+  options?: PageRenderOptions,
 ): Promise<Response> {
+  const renderMode = options?.renderMode ?? 'server';
   const shared = (c.get('shared') as Record<string, unknown> | undefined) ?? {};
 
   // Run loader and check for redirect/error responses before extracting props
@@ -401,7 +438,7 @@ export async function handlePageGet(
   };
 
   // Island pages always render HTML — no Inertia JSON navigation
-  if (!island && isPagesRequest(c)) {
+  if (renderMode !== 'island' && isPagesRequest(c)) {
     // Prefetch requests: resolve all deferred props inline (plain JSON, no streaming)
     const isPrefetch = c.req.header('purpose') === 'prefetch';
     if (isPrefetch && hasDeferred) {
@@ -447,7 +484,10 @@ export async function handlePageGet(
   }
 
   const assetTags = prepareAssetTags(await getAssetTags(c.req.raw, c.env, componentId));
-  const html = await renderWithAssetTags(renderFn, pageObj, assetTags);
+  const html =
+    renderMode === 'client'
+      ? renderClientOnlyPage(pageObj, assetTags, renderFn)
+      : await renderWithAssetTags(renderFn, pageObj, assetTags);
 
   if (!hasDeferred) {
     return renderedResponse(c, html, 'text/html; charset=utf-8', assetTags);
@@ -477,8 +517,9 @@ export async function handlePageMutation(
   renderFn: RenderPage,
   getAssetTags: GetAssetTags,
   configHead?: HeadConfig,
-  island?: boolean,
+  options?: PageRenderOptions,
 ): Promise<Response> {
+  const renderMode = options?.renderMode ?? 'server';
   const shared = (c.get('shared') as Record<string, unknown> | undefined) ?? {};
   const middlewareHead = c.get('headDefaults') as HeadDescriptor | undefined;
 
@@ -504,7 +545,7 @@ export async function handlePageMutation(
     result = mutationHandler ? await mutationHandler(c) : undefined;
   } catch (e) {
     if (e instanceof ValidationError) {
-      if (island) {
+      if (renderMode === 'island') {
         return Response.json({ errors: e.errors }, { status: 422 });
       }
       const rawProps = getHandler ? await extractProps(await getHandler(c)) : {};
@@ -514,12 +555,11 @@ export async function handlePageMutation(
         return pageJsonResponse(c, pageObj);
       }
       const assetTags = prepareAssetTags(await getAssetTags(c.req.raw, c.env, componentId));
-      return renderedResponse(
-        c,
-        await renderWithAssetTags(renderFn, pageObj, assetTags),
-        'text/html; charset=utf-8',
-        assetTags,
-      );
+      const html =
+        renderMode === 'client'
+          ? renderClientOnlyPage(pageObj, assetTags, renderFn)
+          : await renderWithAssetTags(renderFn, pageObj, assetTags);
+      return renderedResponse(c, html, 'text/html; charset=utf-8', assetTags);
     }
     throw e;
   }
@@ -535,7 +575,7 @@ export async function handlePageMutation(
     if (status === 400) {
       const body = await result.json();
       const errors = flattenValidationErrors(body);
-      if (island) {
+      if (renderMode === 'island') {
         return Response.json({ errors }, { status: 422 });
       }
       const rawProps = getHandler ? await extractProps(await getHandler(c)) : {};
@@ -545,12 +585,11 @@ export async function handlePageMutation(
         return pageJsonResponse(c, pageObj);
       }
       const assetTags = prepareAssetTags(await getAssetTags(c.req.raw, c.env, componentId));
-      return renderedResponse(
-        c,
-        await renderWithAssetTags(renderFn, pageObj, assetTags),
-        'text/html; charset=utf-8',
-        assetTags,
-      );
+      const html =
+        renderMode === 'client'
+          ? renderClientOnlyPage(pageObj, assetTags, renderFn)
+          : await renderWithAssetTags(renderFn, pageObj, assetTags);
+      return renderedResponse(c, html, 'text/html; charset=utf-8', assetTags);
     }
     // 204 (void from withValidator) — fall through to re-run GET
     if (status !== 204) {
@@ -559,7 +598,7 @@ export async function handlePageMutation(
   }
 
   // void — re-run GET with fresh props
-  if (island) {
+  if (renderMode === 'island') {
     return Response.json({ success: true });
   }
   const rawProps = getHandler ? await extractProps(await getHandler(c)) : {};
@@ -569,10 +608,9 @@ export async function handlePageMutation(
     return pageJsonResponse(c, pageObj);
   }
   const assetTags = prepareAssetTags(await getAssetTags(c.req.raw, c.env, componentId));
-  return renderedResponse(
-    c,
-    await renderWithAssetTags(renderFn, pageObj, assetTags),
-    'text/html; charset=utf-8',
-    assetTags,
-  );
+  const html =
+    renderMode === 'client'
+      ? renderClientOnlyPage(pageObj, assetTags, renderFn)
+      : await renderWithAssetTags(renderFn, pageObj, assetTags);
+  return renderedResponse(c, html, 'text/html; charset=utf-8', assetTags);
 }
diff --git a/packages/void/src/pages/scan.ts b/packages/void/src/pages/scan.ts
index c0135ea84..1f98323ac 100644
--- a/packages/void/src/pages/scan.ts
+++ b/packages/void/src/pages/scan.ts
@@ -5,27 +5,79 @@ import { readProjectPaths, type ProjectPaths } from '../project-paths.ts';
 import { parseRouteFilename } from '../router/parse-filename.ts';
 import { resolveNamedLayout } from './layout-resolution.ts';
 import type {
+  ExplicitBoolean,
   PageDefinition,
+  PageRenderMode,
+  PrerenderMode,
   LayoutDefinition,
   NamedLayoutDefinition,
   PageScanResult,
+  SsrMode,
 } from './types.ts';
 
 const COMPONENT_EXTENSIONS = ['vue', 'tsx', 'jsx', 'svelte', 'md'];
 const SERVER_EXTENSIONS = ['ts', 'tsx', 'js', 'mjs', 'mts'];
 const PAGES_EXPORT_RE = /export\s+(?:const|function|async\s+function)\s+(loader|actions?)\b/g;
-const REVALIDATE_RE = /export\s+const\s+revalidate\s*=\s*(\d+)\s*;/;
-const PRERENDER_RE = /export\s+const\s+prerender\s*=\s*true\s*;/;
-const PRERENDER_FALSE_RE = /export\s+const\s+prerender\s*=\s*false\s*;/;
+const REVALIDATE_RE = /export\s+const\s+revalidate\s*=\s*(\d+)\s*;?/;
+const PRERENDER_RE = /export\s+const\s+prerender\s*=\s*true\s*;?/;
+const PRERENDER_FALSE_RE = /export\s+const\s+prerender\s*=\s*false\s*;?/;
+const SSR_TRUE_RE = /export\s+const\s+ssr\s*=\s*true\s*;?/;
+const SSR_FALSE_RE = /export\s+const\s+ssr\s*=\s*false\s*;?/;
 const GET_PRERENDER_PATHS_RE = /export\s+(?:async\s+)?function\s+getPrerenderPaths\b/;
 const LAYOUT_STRING_RE = /export\s+const\s+layout\s*=\s*["']([^"']+)["']\s*;?/;
 const LAYOUT_FALSE_RE = /export\s+const\s+layout\s*=\s*false\s*;?/;
 export const MAX_REVALIDATE = 31536000; // 1 year in seconds
 
-export async function scanPages(
-  root: string,
-  options?: { output?: 'server' | 'static'; paths?: ProjectPaths; pagesDir?: string },
-): Promise<PageScanResult> {
+type PageRenderingSource = {
+  componentPath: string;
+  island?: boolean;
+  ssr?: ExplicitBoolean;
+  prerender?: ExplicitBoolean;
+  methods: Array<string>;
+  params: Array<string>;
+  catchAll: boolean;
+  hasGetPrerenderPaths?: boolean;
+};
+
+type PageScanOptions = { output?: 'server' | 'static'; paths?: ProjectPaths; pagesDir?: string };
+
+type ResolvedPageRendering = {
+  ssrMode: SsrMode;
+  prerenderMode: PrerenderMode;
+  renderMode: PageRenderMode;
+  shouldPrerender: boolean;
+};
+
+function inferAutoPrerender(page: PageRenderingSource, options?: PageScanOptions): boolean {
+  const isDynamic = page.params.length > 0 || page.catchAll;
+
+  if (options?.output === 'static') {
+    return !isDynamic || page.hasGetPrerenderPaths === true;
+  }
+
+  return page.island === true && !page.methods.includes('loader') && !isDynamic;
+}
+
+function resolvePageRendering(
+  page: PageRenderingSource,
+  options?: PageScanOptions,
+): ResolvedPageRendering {
+  if (page.island && page.ssr === false) {
+    throw new Error(`pages: ssr = false is not valid for island page '${page.componentPath}'.`);
+  }
+
+  const ssrMode: SsrMode = page.ssr === true ? 'server' : page.ssr === false ? 'client' : 'auto';
+  const prerenderMode: PrerenderMode =
+    page.prerender === true ? 'force' : page.prerender === false ? 'disabled' : 'auto';
+  const renderMode: PageRenderMode =
+    page.island === true ? 'island' : ssrMode === 'client' ? 'client' : 'server';
+  const shouldPrerender =
+    prerenderMode === 'force' || (prerenderMode === 'auto' && inferAutoPrerender(page, options));
+
+  return { ssrMode, prerenderMode, renderMode, shouldPrerender };
+}
+
+export async function scanPages(root: string, options?: PageScanOptions): Promise<PageScanResult> {
   const pagesDir = options?.pagesDir ?? options?.paths?.pagesDir ?? readProjectPaths(root).pagesDir;
   if (!existsSync(pagesDir)) {
     return { pages: [], layouts: [], namedLayouts: [] };
@@ -106,8 +158,8 @@ export async function scanPages(
     let serverPath: string | null = null;
     const methods: Array<string> = [];
     let revalidate: number | undefined;
-    let prerender: boolean | undefined;
-    let prerenderExplicitlyFalse = false;
+    let prerender: ExplicitBoolean;
+    let ssr: ExplicitBoolean;
     let hasGetPrerenderPaths: boolean | undefined;
     const serverBase = hasIslandSuffix ? file.replace(`.island${ext}`, '') : file.replace(ext, '');
     for (const serverExt of SERVER_EXTENSIONS) {
@@ -124,9 +176,13 @@ export async function scanPages(
         }
         if (PRERENDER_RE.test(content)) {
           prerender = true;
+        } else if (PRERENDER_FALSE_RE.test(content)) {
+          prerender = false;
         }
-        if (PRERENDER_FALSE_RE.test(content)) {
-          prerenderExplicitlyFalse = true;
+        if (SSR_TRUE_RE.test(content)) {
+          ssr = true;
+        } else if (SSR_FALSE_RE.test(content)) {
+          ssr = false;
         }
         if (GET_PRERENDER_PATHS_RE.test(content)) {
           hasGetPrerenderPaths = true;
@@ -135,31 +191,22 @@ export async function scanPages(
       }
     }
 
-    const isStaticOutput = options?.output === 'static';
-    if (isStaticOutput) {
-      // Static output: default prerender=true for all pages unless explicitly false.
-      // Dynamic pages without getPrerenderPaths stay false (can't prerender without known paths).
-      if (!prerenderExplicitlyFalse && prerender !== true) {
-        const isDynamic = route.params.length > 0 || route.catchAll;
-        if (!isDynamic || hasGetPrerenderPaths) {
-          prerender = true;
-        }
-      }
-    } else {
-      // Auto-static: island page with no loader and no params → prerender
-      if (
-        island &&
-        !methods.includes('loader') &&
-        route.params.length === 0 &&
-        !route.catchAll &&
-        !prerenderExplicitlyFalse
-      ) {
-        prerender = true;
-      }
-    }
+    const rendering = resolvePageRendering(
+      {
+        componentPath: file,
+        island,
+        ssr,
+        prerender,
+        methods,
+        params: route.params,
+        catchAll: route.catchAll,
+        hasGetPrerenderPaths,
+      },
+      options,
+    );
 
     // Prerender → max revalidate (applies to all pages)
-    if (prerender && revalidate === undefined) {
+    if (rendering.shouldPrerender && revalidate === undefined) {
       revalidate = MAX_REVALIDATE;
     }
 
@@ -190,6 +237,8 @@ export async function scanPages(
       componentId,
       revalidate,
       prerender,
+      ssr,
+      ...rendering,
       hasGetPrerenderPaths,
       island,
       metadata,
diff --git a/packages/void/src/pages/types.ts b/packages/void/src/pages/types.ts
index 9e17e0190..e2b515adf 100644
--- a/packages/void/src/pages/types.ts
+++ b/packages/void/src/pages/types.ts
@@ -1,3 +1,11 @@
+export type ExplicitBoolean = true | false | undefined;
+
+export type SsrMode = 'auto' | 'server' | 'client';
+
+export type PrerenderMode = 'auto' | 'force' | 'disabled';
+
+export type PageRenderMode = 'server' | 'client' | 'island';
+
 export type PageDefinition = {
   /** URL pattern, e.g. "/users/:id" */
   pattern: string;
@@ -15,8 +23,18 @@ export type PageDefinition = {
   componentId: string;
   /** Edge caching revalidate TTL in seconds, from .server.ts export */
   revalidate?: number;
-  /** Whether `export const prerender = true` is set in server handler */
-  prerender?: boolean;
+  /** Whether `export const prerender = true/false` is set in server handler */
+  prerender?: ExplicitBoolean;
+  /** Whether `export const ssr = true/false` is set in server handler */
+  ssr?: ExplicitBoolean;
+  /** Normalized SSR mode from the public `ssr` export */
+  ssrMode: SsrMode;
+  /** Normalized prerender mode from the public `prerender` export */
+  prerenderMode: PrerenderMode;
+  /** Normalized page render mode */
+  renderMode: PageRenderMode;
+  /** Whether this page should participate in prerender collection */
+  shouldPrerender: boolean;
   /** Whether `export function getPrerenderPaths` is defined in server handler */
   hasGetPrerenderPaths?: boolean;
   /** Whether this is an island page (.island.tsx/.island.vue) */
diff --git a/packages/void/src/router/compile.ts b/packages/void/src/router/compile.ts
index dff42c6d1..dd2fad021 100644
--- a/packages/void/src/router/compile.ts
+++ b/packages/void/src/router/compile.ts
@@ -1705,11 +1705,13 @@ function compilePrerenderCollector(
   options: CompileOptions,
 ): void {
   const staticPaths = scan.pages.pages
-    .filter((page) => page.prerender && page.params.length === 0 && !page.catchAll)
+    .filter((page) => page.shouldPrerender && page.params.length === 0 && !page.catchAll)
     .map((page) => page.pattern);
   const dynamicPages = scan.pages.pages.filter(
     (page) =>
-      page.prerender && page.hasGetPrerenderPaths && (page.params.length > 0 || page.catchAll),
+      page.shouldPrerender &&
+      page.hasGetPrerenderPaths &&
+      (page.params.length > 0 || page.catchAll),
   );
   const explicitPaths = options.explicitPrerenderPaths ?? [];
 
@@ -1791,17 +1793,22 @@ function compilePageRoutes(
   lines.push(
     `import { renderHeadToString, renderHtmlAttrs, renderBodyAttrs } from ${JSON.stringify(pages.headPath)};`,
   );
-  lines.push(`import { renderPage } from "virtual:void-pages-renderer";`);
+  lines.push(`import * as __voidPagesRenderer from "virtual:void-pages-renderer";`);
   if (options.dev) {
     lines.push(`import { getVoidPagesDevCss } from "virtual:void-pages-dev-assets";`);
   }
 
   // Import island renderer if any island pages exist
-  const hasIslandPages = scan.pages.pages.some((p) => p.island);
+  const hasIslandPages = scan.pages.pages.some((p) => p.renderMode === 'island');
   if (hasIslandPages) {
     lines.push(`import { renderIslandPage } from "virtual:void-islands-renderer";`);
   }
   lines.push('');
+  lines.push(`const renderPage = __voidPagesRenderer.renderPage;`);
+  lines.push(`if (typeof __voidPagesRenderer.renderPreambleScript === "string") {`);
+  lines.push(`  renderPage.preambleScript = __voidPagesRenderer.renderPreambleScript;`);
+  lines.push(`}`);
+  lines.push('');
 
   // Emit head config constant from void.json
   lines.push(`const __voidHeadConfig = ${JSON.stringify(pages.headConfig ?? null)};`);
@@ -2138,11 +2145,13 @@ function compilePageRoutes(
       mdHeadRef = headVarName;
     }
 
-    // Choose renderer and asset tags based on island flag
-    const renderer = page.island ? 'renderIslandPage' : 'renderPage';
+    // Choose renderer and asset tags based on normalized render mode
+    const renderer = page.renderMode === 'island' ? 'renderIslandPage' : 'renderPage';
     const assetTags =
-      page.island && pages.islandClientEntryId ? 'getIslandsAssetTags' : 'getPagesAssetTags';
-    const islandFlag = page.island ? ', true' : '';
+      page.renderMode === 'island' && pages.islandClientEntryId
+        ? 'getIslandsAssetTags'
+        : 'getPagesAssetTags';
+    const renderOptions = `, ${JSON.stringify({ renderMode: page.renderMode })}`;
 
     // Loader (always registered — pages always handle GET)
     lines.push(`app.get(${JSON.stringify(page.pattern)}, async (c) => {`);
@@ -2150,12 +2159,12 @@ function compilePageRoutes(
       const loaderName = `_pload_${safeId}`;
       lines.push(`  const mod = await ${loaderName}();`);
       lines.push(
-        `  return handlePageGet(mod.loader, mod.head, c, ${JSON.stringify(page.componentId)}, ${renderer}, ${assetTags}, __voidHeadConfig${islandFlag});`,
+        `  return handlePageGet(mod.loader, mod.head, c, ${JSON.stringify(page.componentId)}, ${renderer}, ${assetTags}, __voidHeadConfig${renderOptions});`,
       );
     } else {
       const headArg = mdHeadRef ?? 'undefined';
       lines.push(
-        `  return handlePageGet(undefined, ${headArg}, c, ${JSON.stringify(page.componentId)}, ${renderer}, ${assetTags}, __voidHeadConfig${islandFlag});`,
+        `  return handlePageGet(undefined, ${headArg}, c, ${JSON.stringify(page.componentId)}, ${renderer}, ${assetTags}, __voidHeadConfig${renderOptions});`,
       );
     }
     lines.push(`});`);
@@ -2183,7 +2192,7 @@ function compilePageRoutes(
       }
 
       lines.push(
-        `  return handlePageMutation(handler, mod.loader, mod.head, c, ${JSON.stringify(page.componentId)}, ${renderer}, ${assetTags}, __voidHeadConfig${islandFlag});`,
+        `  return handlePageMutation(handler, mod.loader, mod.head, c, ${JSON.stringify(page.componentId)}, ${renderer}, ${assetTags}, __voidHeadConfig${renderOptions});`,
       );
       lines.push(`});`);
     }
diff --git a/packages/void/test/integration/static-pages.test.ts b/packages/void/test/integration/static-pages.test.ts
index be96cf918..dbc8ca66e 100644
--- a/packages/void/test/integration/static-pages.test.ts
+++ b/packages/void/test/integration/static-pages.test.ts
@@ -78,6 +78,27 @@ describe('playground/static-pages build (output: static)', () => {
     expect(aboutData.props.content).toBe('About page content');
   });
 
+  it('prerenders client-only pages as shells with static page data', () => {
+    const clientOnlyPath = join(DIST, 'client/client-only.html');
+    expect(existsSync(clientOnlyPath)).toBe(true);
+
+    const html = readFileSync(clientOnlyPath, 'utf-8');
+    expect(html).toContain('<!doctype html>');
+    expect(html).toContain('__VOID_PAGE_DATA__');
+    expect(html).toContain('data-void-ssr="false"');
+    expect(html).toContain('Client-only Static Page');
+    expect(html).not.toContain('data-testid="client-only-title"');
+    expect(html).not.toContain('client-only static page component rendered on the server');
+
+    const pageData = JSON.parse(
+      readFileSync(join(DIST, 'client/_void/pages/client-only.json'), 'utf-8'),
+    ) as { component: string; props: Record<string, unknown>; url: string };
+    expect(pageData.component).toBe('client-only');
+    expect(pageData.url).toBe('/client-only');
+    expect(pageData.props.title).toBe('Client-only Static Page');
+    expect(pageData.props.marker).toBe('static-loader-props');
+  });
+
   it('prerenders dynamic pages with getPrerenderPaths', () => {
     // posts/[slug] exports getPrerenderPaths returning [{slug:"hello"},{slug:"world"}]
     const helloPath = join(DIST, 'client/posts/hello.html');
@@ -102,6 +123,7 @@ describe('playground/static-pages build (output: static)', () => {
       expect.arrayContaining([
         '/',
         '/about',
+        '/client-only',
         '/posts/hello',
         '/posts/world',
         '/tags/vue',
diff --git a/packages/void/test/unit/compile.test.ts b/packages/void/test/unit/compile.test.ts
index 64a8ddd6b..777765d90 100644
--- a/packages/void/test/unit/compile.test.ts
+++ b/packages/void/test/unit/compile.test.ts
@@ -2146,6 +2146,10 @@ describe('default-target dev parity', () => {
               params: [],
               catchAll: false,
               methods: [],
+              ssrMode: 'auto',
+              prerenderMode: 'auto',
+              renderMode: 'server',
+              shouldPrerender: false,
             },
           ],
           layouts: [],
diff --git a/packages/void/test/unit/pages-compile.test.ts b/packages/void/test/unit/pages-compile.test.ts
index 295272a15..188d7410f 100644
--- a/packages/void/test/unit/pages-compile.test.ts
+++ b/packages/void/test/unit/pages-compile.test.ts
@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vite-plus/test';
+import type { PageDefinition, PageScanResult } from '../../src/pages/types.ts';
 import { compileRouteTable, type PagesCompileOptions } from '../../src/router/compile.ts';
 import type { ScanResult } from '../../src/router/scan.ts';
 
@@ -22,13 +23,36 @@ const pagesOptions: PagesCompileOptions = {
   clientEntryId: 'virtual:void-pages-client',
 };
 
-function makeScan(pages: ScanResult['pages']): ScanResult {
+type TestPageDefinition = Omit<
+  PageDefinition,
+  'ssrMode' | 'prerenderMode' | 'renderMode' | 'shouldPrerender'
+> &
+  Partial<Pick<PageDefinition, 'ssrMode' | 'prerenderMode' | 'renderMode' | 'shouldPrerender'>>;
+
+function withRenderingDefaults(page: TestPageDefinition): PageDefinition {
+  const renderMode =
+    page.renderMode ?? (page.island ? 'island' : page.ssr === false ? 'client' : 'server');
+  return {
+    ...page,
+    ssrMode:
+      page.ssrMode ?? (page.ssr === true ? 'server' : page.ssr === false ? 'client' : 'auto'),
+    prerenderMode:
+      page.prerenderMode ??
+      (page.prerender === true ? 'force' : page.prerender === false ? 'disabled' : 'auto'),
+    renderMode,
+    shouldPrerender: page.shouldPrerender ?? page.prerender === true,
+  };
+}
+
+function makeScan(
+  pages: Omit<PageScanResult, 'pages'> & { pages: Array<TestPageDefinition> },
+): ScanResult {
   return {
     routes: [],
     middleware: [],
     jobs: [],
     queues: [],
-    pages,
+    pages: { ...pages, pages: pages.pages.map(withRenderingDefaults) },
   };
 }
 
@@ -66,7 +90,7 @@ describe('compileRouteTable with pages', () => {
     );
   });
 
-  it('imports renderPage from virtual module', () => {
+  it('imports renderPage from the virtual module namespace', () => {
     const scan = makeScan({
       pages: [
         {
@@ -94,7 +118,8 @@ describe('compileRouteTable with pages', () => {
       pagesOptions,
     );
 
-    expect(code).toContain(`import { renderPage } from "virtual:void-pages-renderer"`);
+    expect(code).toContain(`import * as __voidPagesRenderer from "virtual:void-pages-renderer"`);
+    expect(code).toContain('const renderPage = __voidPagesRenderer.renderPage');
   });
 
   it('imports the dev CSS asset bridge in dev builds', () => {
@@ -277,6 +302,43 @@ describe('compileRouteTable with pages', () => {
     expect(code).toContain('handlePageMutation(handler, mod.loader, mod.head');
   });
 
+  it('passes normalized client render mode to page handlers', () => {
+    const scan = makeScan({
+      pages: [
+        {
+          pattern: '/analytics',
+          params: [],
+          catchAll: false,
+          componentPath: 'analytics.vue',
+          serverPath: 'analytics.server.ts',
+          methods: ['loader', 'action'],
+          componentId: 'analytics',
+          ssr: false,
+        },
+      ],
+      layouts: [],
+      namedLayouts: [],
+    });
+
+    const code = compileRouteTable(
+      scan,
+      '/routes',
+      '/middleware',
+      '/crons',
+      '/queues',
+      null,
+      testOptions,
+      pagesOptions,
+    );
+
+    expect(code).toContain(
+      'handlePageGet(mod.loader, mod.head, c, "analytics", renderPage, getPagesAssetTags, __voidHeadConfig, {"renderMode":"client"})',
+    );
+    expect(code).toContain(
+      'handlePageMutation(handler, mod.loader, mod.head, c, "analytics", renderPage, getPagesAssetTags, __voidHeadConfig, {"renderMode":"client"})',
+    );
+  });
+
   it('generates catch-all for SPA navigation', () => {
     const scan = makeScan({
       pages: [
@@ -447,7 +509,7 @@ describe('compileRouteTable with pages', () => {
     expect(code).toContain(`import { renderIslandPage } from "virtual:void-islands-renderer"`);
     expect(code).toContain('renderIslandPage');
     expect(code).toContain('getIslandsAssetTags');
-    expect(code).toContain(', true)');
+    expect(code).toContain('{"renderMode":"island"}');
   });
 
   it('non-island page does not use island renderer', () => {
@@ -526,7 +588,8 @@ describe('compileRouteTable with pages', () => {
       islandPagesOptions,
     );
 
-    expect(code).toContain(`import { renderPage } from "virtual:void-pages-renderer"`);
+    expect(code).toContain(`import * as __voidPagesRenderer from "virtual:void-pages-renderer"`);
+    expect(code).toContain('const renderPage = __voidPagesRenderer.renderPage');
     expect(code).toContain(`import { renderIslandPage } from "virtual:void-islands-renderer"`);
   });
 
diff --git a/packages/void/test/unit/pages-protocol.test.ts b/packages/void/test/unit/pages-protocol.test.ts
index 2d9d9a06a..cc9d73462 100644
--- a/packages/void/test/unit/pages-protocol.test.ts
+++ b/packages/void/test/unit/pages-protocol.test.ts
@@ -262,7 +262,7 @@ describe('handlePageGet', () => {
       renderFn,
       mockGetAssetTags,
       undefined,
-      true,
+      { renderMode: 'island' },
     );
 
     expect(response.headers.get('content-type')).toContain('text/html');
@@ -283,7 +283,7 @@ describe('handlePageGet', () => {
       renderFn,
       mockGetAssetTags,
       undefined,
-      false,
+      { renderMode: 'server' },
     );
 
     expect(response.headers.get('X-VoidPages')).toBe('true');
@@ -704,7 +704,7 @@ describe('handlePageMutation', () => {
       mockRenderFn,
       mockGetAssetTags,
       undefined,
-      true,
+      { renderMode: 'island' },
     );
 
     expect(response.status).toBe(422);
@@ -737,7 +737,7 @@ describe('handlePageMutation', () => {
       mockRenderFn,
       mockGetAssetTags,
       undefined,
-      true,
+      { renderMode: 'island' },
     );
 
     expect(response.status).toBe(422);
@@ -759,7 +759,7 @@ describe('handlePageMutation', () => {
       mockRenderFn,
       mockGetAssetTags,
       undefined,
-      true,
+      { renderMode: 'island' },
     );
 
     expect(response.status).toBe(200);
@@ -785,7 +785,7 @@ describe('handlePageMutation', () => {
       mockRenderFn,
       mockGetAssetTags,
       undefined,
-      true,
+      { renderMode: 'island' },
     );
 
     expect(response.status).toBe(302);
@@ -924,6 +924,62 @@ describe('handlePageGet with deferred props', () => {
     expect(response.headers.get('content-type')).toBe('text/html; charset=utf-8');
   });
 
+  it('client-only page — returns an empty app shell with initial page data', async () => {
+    const c = await createTestContext('GET', '/analytics');
+
+    const handler = vi.fn(() => ({ title: 'Analytics' }));
+    const renderFn = Object.assign(
+      vi.fn(async () => '<html>server rendered</html>'),
+      {
+        preambleScript: '<script type="module">window.__reactPreamble = true</script>',
+      },
+    );
+    const response = await handlePageGet(
+      handler,
+      () => ({ title: 'Analytics | App' }),
+      c,
+      'analytics',
+      renderFn,
+      mockGetAssetTags,
+      undefined,
+      { renderMode: 'client' },
+    );
+
+    const html = await response.text();
+    expect(renderFn).not.toHaveBeenCalled();
+    expect(html).toContain('<title>Analytics | App</title>');
+    expect(html).toContain('window.__reactPreamble = true');
+    expect(html).toContain('<div id="app" data-void-ssr="false"></div>');
+    expect(html).toContain('__VOID_PAGE_DATA__');
+    expect(html).toContain('"component":"analytics"');
+    expect(html).toContain('"title":"Analytics"');
+    expect(html).not.toContain('server rendered');
+  });
+
+  it('client-only page — streams deferred script tags after the shell', async () => {
+    const c = await createTestContext('GET', '/analytics');
+
+    const response = await handlePageGet(
+      () => ({
+        title: 'Analytics',
+        stats: defer(() => Promise.resolve({ visits: 12 })),
+      }),
+      undefined,
+      c,
+      'analytics',
+      mockRenderFn,
+      mockGetAssetTags,
+      undefined,
+      { renderMode: 'client' },
+    );
+
+    const html = await response.text();
+    expect(html).toContain('<div id="app" data-void-ssr="false"></div>');
+    expect(html).toContain('"deferred":["stats"]');
+    expect(html).toContain('window.__resolveDeferred("stats",');
+    expect(html).toContain('"visits":12');
+  });
+
   it('deferred named group — resolves all keys together', async () => {
     const c = await createTestContext('GET', '/dashboard', {
       headers: { 'x-voidpages': 'true' },
diff --git a/packages/void/test/unit/pages-scan.test.ts b/packages/void/test/unit/pages-scan.test.ts
index 02f47b785..006a47fb3 100644
--- a/packages/void/test/unit/pages-scan.test.ts
+++ b/packages/void/test/unit/pages-scan.test.ts
@@ -200,6 +200,41 @@ describe('scanPages', () => {
     const page = result.pages.find((p) => p.componentId === 'products');
     expect(page).toBeDefined();
     expect(page!.prerender).toBe(true);
+    expect(page!.prerenderMode).toBe('force');
+    expect(page!.shouldPrerender).toBe(true);
+  });
+
+  it('detects ssr = false from .server.ts and resolves client render mode', async () => {
+    writeFile('analytics.vue', '<template><div>Analytics</div></template>');
+    writeFile('analytics.server.ts', 'export const ssr = false;\nexport const loader = () => [];');
+
+    const result = await scanPages(TMP);
+    const page = result.pages.find((p) => p.componentId === 'analytics');
+    expect(page).toBeDefined();
+    expect(page!.ssr).toBe(false);
+    expect(page!.ssrMode).toBe('client');
+    expect(page!.renderMode).toBe('client');
+  });
+
+  it('detects ssr = true from .server.ts and resolves server render mode', async () => {
+    writeFile('analytics.vue', '<template><div>Analytics</div></template>');
+    writeFile('analytics.server.ts', 'export const ssr = true;\nexport const loader = () => [];');
+
+    const result = await scanPages(TMP);
+    const page = result.pages.find((p) => p.componentId === 'analytics');
+    expect(page).toBeDefined();
+    expect(page!.ssr).toBe(true);
+    expect(page!.ssrMode).toBe('server');
+    expect(page!.renderMode).toBe('server');
+  });
+
+  it('throws when ssr = false is used on an island page', async () => {
+    writeFile('analytics.island.vue', '<template><div>Analytics</div></template>');
+    writeFile('analytics.server.ts', 'export const ssr = false;');
+
+    await expect(scanPages(TMP)).rejects.toThrow(
+      "pages: ssr = false is not valid for island page 'analytics.island.vue'.",
+    );
   });
 
   it('detects getPrerenderPaths from .server.ts', async () => {
@@ -213,6 +248,8 @@ describe('scanPages', () => {
     const page = result.pages.find((p) => p.componentId === 'blog/[slug]');
     expect(page).toBeDefined();
     expect(page!.prerender).toBe(true);
+    expect(page!.prerenderMode).toBe('force');
+    expect(page!.shouldPrerender).toBe(true);
     expect(page!.hasGetPrerenderPaths).toBe(true);
   });
 
@@ -288,6 +325,8 @@ describe('scanPages', () => {
     const page = result.pages.find((p) => p.componentId === 'about');
     expect(page).toBeDefined();
     expect(page!.prerender).toBeUndefined();
+    expect(page!.prerenderMode).toBe('auto');
+    expect(page!.shouldPrerender).toBe(false);
     expect(page!.hasGetPrerenderPaths).toBeUndefined();
   });
 
@@ -295,7 +334,9 @@ describe('scanPages', () => {
     writeFile('pricing.island.vue', '<template><div>Pricing</div></template>');
     const result = await scanPages(TMP);
     const page = result.pages.find((p) => p.componentId === 'pricing');
-    expect(page!.prerender).toBe(true);
+    expect(page!.prerender).toBeUndefined();
+    expect(page!.prerenderMode).toBe('auto');
+    expect(page!.shouldPrerender).toBe(true);
     expect(page!.revalidate).toBe(MAX_REVALIDATE);
   });
 
@@ -306,7 +347,8 @@ describe('scanPages', () => {
     );
     const result = await scanPages(TMP);
     const page = result.pages.find((p) => p.componentId === 'pricing');
-    expect(page!.prerender).toBe(true);
+    expect(page!.prerender).toBeUndefined();
+    expect(page!.shouldPrerender).toBe(true);
     expect(page!.revalidate).toBe(MAX_REVALIDATE);
   });
 
@@ -316,6 +358,7 @@ describe('scanPages', () => {
     const result = await scanPages(TMP);
     const page = result.pages.find((p) => p.componentId === 'products');
     expect(page!.prerender).toBeUndefined();
+    expect(page!.shouldPrerender).toBe(false);
   });
 
   it('does not auto-prerender dynamic island page', async () => {
@@ -323,6 +366,7 @@ describe('scanPages', () => {
     const result = await scanPages(TMP);
     const page = result.pages.find((p) => p.componentId === 'blog/[slug]');
     expect(page!.prerender).toBeUndefined();
+    expect(page!.shouldPrerender).toBe(false);
   });
 
   it('auto-sets max revalidate for explicit prerender on any page', async () => {
@@ -331,6 +375,8 @@ describe('scanPages', () => {
     const result = await scanPages(TMP);
     const page = result.pages.find((p) => p.componentId === 'about');
     expect(page!.prerender).toBe(true);
+    expect(page!.prerenderMode).toBe('force');
+    expect(page!.shouldPrerender).toBe(true);
     expect(page!.revalidate).toBe(MAX_REVALIDATE);
   });
 
@@ -340,9 +386,37 @@ describe('scanPages', () => {
     const result = await scanPages(TMP);
     const page = result.pages.find((p) => p.componentId === 'about');
     expect(page!.prerender).toBe(true);
+    expect(page!.shouldPrerender).toBe(true);
     expect(page!.revalidate).toBe(3600);
   });
 
+  it('detects render config exports without semicolons', async () => {
+    writeFile('about.vue', '<template><div>About</div></template>');
+    writeFile(
+      'about.server.ts',
+      'export const ssr = false\nexport const prerender = true\nexport const revalidate = 120',
+    );
+    const result = await scanPages(TMP);
+    const page = result.pages.find((p) => p.componentId === 'about');
+    expect(page!.ssr).toBe(false);
+    expect(page!.prerender).toBe(true);
+    expect(page!.renderMode).toBe('client');
+    expect(page!.prerenderMode).toBe('force');
+    expect(page!.shouldPrerender).toBe(true);
+    expect(page!.revalidate).toBe(120);
+  });
+
+  it('preserves explicit prerender = false as disabled prerender mode', async () => {
+    writeFile('pricing.island.vue', '<template><div>Pricing</div></template>');
+    writeFile('pricing.server.ts', 'export const prerender = false;');
+    const result = await scanPages(TMP);
+    const page = result.pages.find((p) => p.componentId === 'pricing');
+    expect(page!.prerender).toBe(false);
+    expect(page!.prerenderMode).toBe('disabled');
+    expect(page!.shouldPrerender).toBe(false);
+    expect(page!.revalidate).toBeUndefined();
+  });
+
   it('scans .md files as island pages', async () => {
     writeFile('docs/getting-started.md', '# Getting Started\n\nHello world.');
     const result = await scanPages(TMP);
@@ -358,7 +432,8 @@ describe('scanPages', () => {
     writeFile('docs/guide.md', '# Guide');
     const result = await scanPages(TMP);
     const page = result.pages.find((p) => p.componentId === 'docs/guide');
-    expect(page!.prerender).toBe(true);
+    expect(page!.prerender).toBeUndefined();
+    expect(page!.shouldPrerender).toBe(true);
     expect(page!.revalidate).toBe(MAX_REVALIDATE);
   });
 
@@ -368,6 +443,7 @@ describe('scanPages', () => {
     const page = result.pages.find((p) => p.componentId === 'blog/[slug]');
     expect(page!.island).toBe(true);
     expect(page!.prerender).toBeUndefined();
+    expect(page!.shouldPrerender).toBe(false);
   });
 
   it('picks up companion .server.ts for .md page', async () => {
@@ -379,6 +455,7 @@ describe('scanPages', () => {
     expect(page!.methods).toEqual(['loader']);
     // Has loader → no auto-prerender
     expect(page!.prerender).toBeUndefined();
+    expect(page!.shouldPrerender).toBe(false);
   });
 
   it('scans .md index file correctly', async () => {
@@ -395,7 +472,8 @@ describe('scanPages', () => {
     writeFile('pricing.server.ts', 'export const revalidate = 60;');
     const result = await scanPages(TMP);
     const page = result.pages.find((p) => p.componentId === 'pricing');
-    expect(page!.prerender).toBe(true);
+    expect(page!.prerender).toBeUndefined();
+    expect(page!.shouldPrerender).toBe(true);
     expect(page!.revalidate).toBe(60);
   });
 
diff --git a/packages/void/test/unit/route-types.test.ts b/packages/void/test/unit/route-types.test.ts
index 16db4b8ea..8f36dc239 100644
--- a/packages/void/test/unit/route-types.test.ts
+++ b/packages/void/test/unit/route-types.test.ts
@@ -1,7 +1,15 @@
 import { describe, expect, it } from 'vite-plus/test';
 import { generateRouteTypes } from '../../src/codegen/route-types.ts';
+import type { PageDefinition } from '../../src/pages/types.ts';
 import type { ScanResult } from '../../src/router/scan.ts';
 
+const pageRenderingDefaults = {
+  ssrMode: 'auto',
+  prerenderMode: 'auto',
+  renderMode: 'server',
+  shouldPrerender: false,
+} satisfies Pick<PageDefinition, 'ssrMode' | 'prerenderMode' | 'renderMode' | 'shouldPrerender'>;
+
 describe('generateRouteTypes', () => {
   it('generates route type declarations for single-method routes', () => {
     const scan: ScanResult = {
@@ -196,6 +204,7 @@ describe('generateRouteTypes', () => {
       pages: {
         pages: [
           {
+            ...pageRenderingDefaults,
             pattern: '/users',
             params: [],
             catchAll: false,
@@ -227,6 +236,7 @@ describe('generateRouteTypes', () => {
       pages: {
         pages: [
           {
+            ...pageRenderingDefaults,
             pattern: '/users/:id',
             params: ['id'],
             catchAll: false,
@@ -289,6 +299,7 @@ describe('generateRouteTypes', () => {
       pages: {
         pages: [
           {
+            ...pageRenderingDefaults,
             pattern: '/about',
             params: [],
             catchAll: false,
@@ -318,6 +329,7 @@ describe('generateRouteTypes', () => {
       pages: {
         pages: [
           {
+            ...pageRenderingDefaults,
             pattern: '/users',
             params: [],
             catchAll: false,
@@ -350,6 +362,7 @@ describe('generateRouteTypes', () => {
       pages: {
         pages: [
           {
+            ...pageRenderingDefaults,
             pattern: '/users/:id',
             params: ['id'],
             catchAll: false,
@@ -381,6 +394,7 @@ describe('generateRouteTypes', () => {
       pages: {
         pages: [
           {
+            ...pageRenderingDefaults,
             pattern: '/users',
             params: [],
             catchAll: false,
@@ -409,6 +423,7 @@ describe('generateRouteTypes', () => {
       pages: {
         pages: [
           {
+            ...pageRenderingDefaults,
             pattern: '/users',
             params: [],
             catchAll: false,
diff --git a/packages/vue/README.md b/packages/vue/README.md
index ea55b9e59..9096b2df3 100644
--- a/packages/vue/README.md
+++ b/packages/vue/README.md
@@ -105,6 +105,10 @@ import { defineHandler } from 'void';
 export const loader = defineHandler(() => ({ title: 'Home' }));
 ```
 
+Export `ssr = false` from a page's `.server.ts` file to skip server-rendered
+component HTML for that route while still running its loader on the first
+request.
+
 ## Tests
 
 - `test/unit/use-form.test.ts`
diff --git a/packages/vue/src/plugin-pages.ts b/packages/vue/src/plugin-pages.ts
index a2844d623..860225e10 100644
--- a/packages/vue/src/plugin-pages.ts
+++ b/packages/vue/src/plugin-pages.ts
@@ -326,7 +326,7 @@ function generateClientEntry(
   staticPageData?: StaticPageDataBuildOptions,
 ): string {
   return `
-import { createSSRApp, h, reactive, provide, shallowRef, nextTick, ref } from "vue";
+import { createApp, createSSRApp, h, reactive, provide, shallowRef, nextTick, ref } from "vue";
 import { createDeferred, resolveDeferred, rejectDeferred } from "@void/vue/deferred";
 import { setActionRouter } from "@void/vue";
 import { createRouterFacade, createVoidRouter, idleNavigationState } from "void/pages-client";
@@ -398,7 +398,10 @@ currentProps.value = initialPageData.props;
 currentComponent.value = initialComponent;
 currentLayouts.value = initialLayouts;
 
-const app = createSSRApp({
+const appEl = document.getElementById("app");
+if (!appEl) throw new Error("pages: Missing #app element for Void Vue pages hydration.");
+const createVoidApp = appEl?.getAttribute("data-void-ssr") === "false" ? createApp : createSSRApp;
+const app = createVoidApp({
   setup() {
     provide("__void_shared", shared);
     provide("__void_errors", errors);
@@ -419,8 +422,8 @@ const app = createSSRApp({
   }
 });
 
-app.mount("#app");
-document.getElementById("app").setAttribute("data-hydrated", "true");
+app.mount(appEl);
+appEl.setAttribute("data-hydrated", "true");
 export { reactiveRouter as router };
 start();
 `;
diff --git a/playground/react-pages/pages/client-only.server.ts b/playground/react-pages/pages/client-only.server.ts
new file mode 100644
index 000000000..4b0be33dc
--- /dev/null
+++ b/playground/react-pages/pages/client-only.server.ts
@@ -0,0 +1,15 @@
+import { defineHandler, defineHead, type InferProps } from 'void';
+
+export const ssr = false;
+
+export const loader = defineHandler(() => ({
+  title: 'Client-only Route',
+  marker: 'loader-props-available',
+}));
+
+export type Props = InferProps<typeof loader>;
+
+export const head = defineHead<Props>((_c, props) => ({
+  title: props.title,
+  meta: [{ name: 'description', content: 'React Pages client-only route' }],
+}));
diff --git a/playground/react-pages/pages/client-only.tsx b/playground/react-pages/pages/client-only.tsx
new file mode 100644
index 000000000..570d09b80
--- /dev/null
+++ b/playground/react-pages/pages/client-only.tsx
@@ -0,0 +1,15 @@
+import type { Props } from './client-only.server.ts';
+
+export default function ClientOnlyPage(props: Props) {
+  if (typeof window === 'undefined') {
+    throw new Error('client-only page component rendered on the server');
+  }
+
+  return (
+    <main>
+      <h1>Client-only Page</h1>
+      <p data-testid="client-only-title">{props.title}</p>
+      <p data-testid="client-only-marker">{props.marker}</p>
+    </main>
+  );
+}
diff --git a/playground/react-pages/pages/index.tsx b/playground/react-pages/pages/index.tsx
index 8733d0d83..9b1722216 100644
--- a/playground/react-pages/pages/index.tsx
+++ b/playground/react-pages/pages/index.tsx
@@ -11,6 +11,7 @@ export default function HomePage({ title }: Props) {
       </Link>{' '}
       <Link href="/link-behavior">Link behavior</Link>{' '}
       <Link href="/action-error">Form behavior lab</Link> <Link href="/live">Live streams</Link>
+      <Link href="/client-only">Client-only route</Link>
     </div>
   );
 }
diff --git a/playground/react-pages/pages/layout.tsx b/playground/react-pages/pages/layout.tsx
index bf183e2f2..b02598ad6 100644
--- a/playground/react-pages/pages/layout.tsx
+++ b/playground/react-pages/pages/layout.tsx
@@ -32,6 +32,10 @@ export default function Layout({ children }: { children: React.ReactNode }) {
         <Link href="/action-error" prefetch>
           Form Lab
         </Link>{' '}
+        |{' '}
+        <Link href="/client-only" prefetch>
+          Client-only
+        </Link>{' '}
         | <span>{shared.appName}</span>
       </nav>
       <hr />
diff --git a/playground/static-pages/pages/client-only.server.ts b/playground/static-pages/pages/client-only.server.ts
new file mode 100644
index 000000000..a1cbd0896
--- /dev/null
+++ b/playground/static-pages/pages/client-only.server.ts
@@ -0,0 +1,11 @@
+import { defineHandler, type InferProps } from 'void';
+
+export const ssr = false;
+export const prerender = true;
+
+export const loader = defineHandler(() => ({
+  title: 'Client-only Static Page',
+  marker: 'static-loader-props',
+}));
+
+export type Props = InferProps<typeof loader>;
diff --git a/playground/static-pages/pages/client-only.vue b/playground/static-pages/pages/client-only.vue
new file mode 100644
index 000000000..69d2f60b6
--- /dev/null
+++ b/playground/static-pages/pages/client-only.vue
@@ -0,0 +1,16 @@
+<script setup lang="ts">
+import type { Props } from './client-only.server.ts';
+
+if (typeof window === 'undefined') {
+  throw new Error('client-only static page component rendered on the server');
+}
+
+defineProps<Props>();
+</script>
+
+<template>
+  <main>
+    <h1 data-testid="client-only-title">{{ title }}</h1>
+    <p data-testid="client-only-marker">{{ marker }}</p>
+  </main>
+</template>
diff --git a/playground/static-pages/pages/layout.vue b/playground/static-pages/pages/layout.vue
index 0f4d15291..6bdbed102 100644
--- a/playground/static-pages/pages/layout.vue
+++ b/playground/static-pages/pages/layout.vue
@@ -1,8 +1,8 @@
 <template>
   <div id="app">
     <nav>
-      <a href="/">Home</a> |
-      <a href="/about">About</a>
+      <a href="/">Home</a> | <a href="/about">About</a> |
+      <a href="/client-only">Client-only</a>
     </nav>
     <hr />
     <slot />