diff --git a/.changeset/start-render-mode.md b/.changeset/start-render-mode.md
new file mode 100644
index 0000000..b4586c4
--- /dev/null
+++ b/.changeset/start-render-mode.md
@@ -0,0 +1,5 @@
+---
+'@solidjs/vite-plugin': minor
+---
+
+`start.renderMode: 'stream' | 'async'` (default `'stream'`), plus a per-request form and a runtime override — the fix for streaming SSR leaving `<Loading>` fallbacks unresolved for clients that never run JavaScript (solidjs/solid#3280). `'async'` makes the generated handler adopt the `renderToStream` result's thenable, which resolves with the complete HTML once every boundary has settled: nothing has flushed, so each boundary's content is spliced in place of its placeholder — no fallback markup, no swap templates or scripts — while hydration data still serializes and JavaScript clients hydrate as before. The string then takes `createSSRResponse`'s string path: the response head commits, the document gets the doctype and client-entry injection, and a `Location` written mid-render becomes a real 3xx instead of the post-flush script redirect. The tradeoffs are inherent and documented: time-to-first-byte waits for the slowest boundary and the whole page buffers in memory; `deferStream` is moot (everything defers). The per-request form follows the `middleware`/`setup` convention — `renderMode: './src/render-mode.ts'`, a module default-exporting `(event) => 'stream' | 'async' | Promise<...>` run inside the request scope after the middleware chain — for policies like "complete documents for crawler user agents or `?nojs`, streaming for everyone else". Hosts driving the handler directly pass `handleRequest(request, { renderMode })`; precedence is that runtime option, then the module function, then the static config, and an invalid value from any source is rejected with an actionable error (unknown literals and missing module paths fail at config time). Works identically for authored entries. Generated entries also commit the response head at render completion (`onCompleteAll`) so `httpStatus`/`httpHeader` declarations survive the runtime's dispose-before-resolve in the awaited path; stream mode is unchanged.
diff --git a/README.md b/README.md
index dfda345..c523f1b 100644
--- a/README.md
+++ b/README.md
@@ -180,8 +180,8 @@ same server functions.
 The object form carries the options (`start: true` is pure sugar for
 `start: {}` — both mean the identical start mode with defaults, and
 `false`/absent means off): `app`, `document`, `entryServer`, `entryClient`,
-`middleware`, `setup`, `env`, `devtools`, `errorBoundary`, `css`, `external`,
-all documented below.
+`middleware`, `setup`, `renderMode`, `env`, `devtools`, `errorBoundary`,
+`css`, `external`, all documented below.
 
 Install `@solidjs/start-devtools` as a development dependency to add the
 development toolbar with runtime errors and server function calls:
@@ -376,6 +376,76 @@ whatever the hook renders must be matched client-side for hydration —
 routers that own both sides (their client entry re-creates the router and
 hydrates the same tree) fit naturally.
 
+**`renderMode`** — how a page render becomes a response body: `'stream'`
+(the default) or `'async'`, or a module path deciding per request.
+
+Streaming flushes the document shell as soon as it is ready, with every
+`<Loading>` fallback in place, and streams the boundaries' content behind it
+in later chunks; inline scripts swap that content into the page as it
+arrives. That is the best time-to-first-byte a server render can have, but a
+client that never runs JavaScript — a crawler, `curl`, a browser with
+scripts disabled — is left looking at the fallbacks forever
+([solidjs/solid#3280](https://github.com/solidjs/solid/issues/3280)).
+`'async'` is the other end of that trade: the handler awaits the render until
+every boundary has settled and sends one complete document.
+
+```ts
+solid({ start: { renderMode: 'async' }, ssr: true });
+```
+
+Because nothing has flushed when a boundary resolves, its content is spliced
+in place of its placeholder — the document carries no fallback markup, no
+swap templates, no swap scripts — while hydration data still serializes
+exactly as before, so JavaScript clients hydrate the settled document the
+same way they hydrate a streamed one. The tradeoffs are inherent: the
+response waits for the slowest boundary before its first byte, and the whole
+page buffers in memory before it goes out. Two consequences worth knowing:
+`deferStream` is moot under `'async'` (everything defers), and a `Location`
+header written mid-render — the post-flush script redirect in stream mode —
+becomes a real 3xx with no body, which is exactly what a no-JS client needs.
+
+Most apps want streaming for browsers and a complete document for the few
+clients that cannot run the swap. The per-request form is a module path
+(relative to the Vite root, following the `middleware`/`setup` convention
+— a Vite config cannot serialize a closure into the generated handler)
+default-exporting `(event) => 'stream' | 'async' | Promise<'stream' |
+'async'>`. It runs inside the request scope after the middleware chain, so
+`event.locals` is decorated by the time it decides:
+
+```ts
+// vite.config.ts
+solid({ start: { renderMode: './src/render-mode.ts' }, ssr: true });
+
+// src/render-mode.ts
+import type { RequestEvent } from '@solidjs/web';
+
+const CRAWLER = /Googlebot|bingbot|DuckDuckBot|Slurp|Baiduspider|YandexBot/i;
+
+export default function renderMode(event: RequestEvent) {
+  const { request } = event;
+  if (new URL(request.url).searchParams.has('nojs')) return 'async';
+  if (CRAWLER.test(request.headers.get('user-agent') ?? '')) return 'async';
+  return 'stream';
+}
+```
+
+Hosts driving the handler directly can decide per call instead:
+`handleRequest(request, { renderMode: 'async' })`. Precedence is that
+runtime option, then the module function's result, then the static config;
+an unknown value from any of the three is an error naming its source. The
+mode applies to generated and authored entries alike — an authored
+`render()` returning a `renderToStream` result is awaited the same way (and
+in production its client-entry reference is still rewritten). One caveat for
+authored entries: `httpStatus()` / `httpHeader()` declarations made during
+the render are reverted when the runtime disposes it, which under `'async'`
+happens before the response head is committed — the generated entry commits
+the head at render completion (`renderToStream`'s `onCompleteAll`) to keep
+them, so an authored entry that needs them under `'async'` should pass the
+same hook (`onCompleteAll: () => commitResponseStub(getRequestEvent().response)`);
+a `Location` written straight onto `event.response.headers` is unaffected.
+Server mode only — in client mode the served shell has no boundaries to
+settle, so the option is a documented no-op there.
+
 **`env`** — first-party typed environment variables. A schema file at the
 project root — `env.ts` (or `env.js`), probed automatically; point
 elsewhere with `start: { env: './path' }`, disable with `env: false` —
diff --git a/examples/start-ssr/src/render-mode.ts b/examples/start-ssr/src/render-mode.ts
new file mode 100644
index 0000000..5493f3d
--- /dev/null
+++ b/examples/start-ssr/src/render-mode.ts
@@ -0,0 +1,21 @@
+// Per-request render-mode policy for the render-mode e2e mode
+// (SSR_RENDER_MODE=module wires it through `start.renderMode` in
+// vite.config.ts). Server-only: only the generated handler imports it. The
+// recipe from the README: serve one complete, settled document to clients
+// that will never run the streaming swap scripts — crawlers and an explicit
+// `?nojs` opt-in — and stream for everyone else. The `x-render-mode` header
+// is the test's deterministic switch. Runs inside the request scope after
+// the middleware chain (`event.locals` is decorated by then), and may be
+// async — the handler awaits it before the render starts.
+import type { RequestEvent } from '@solidjs/web';
+
+const CRAWLER_UA = /Googlebot|bingbot|DuckDuckBot|Slurp|Baiduspider|YandexBot/i;
+
+export default function renderMode(event: RequestEvent): 'stream' | 'async' {
+  const { request } = event;
+  const header = request.headers.get('x-render-mode');
+  if (header === 'stream' || header === 'async') return header;
+  if (new URL(request.url).searchParams.has('nojs')) return 'async';
+  if (CRAWLER_UA.test(request.headers.get('user-agent') || '')) return 'async';
+  return 'stream';
+}
diff --git a/examples/start-ssr/test/run.mjs b/examples/start-ssr/test/run.mjs
index ada2273..5b16dda 100644
--- a/examples/start-ssr/test/run.mjs
+++ b/examples/start-ssr/test/run.mjs
@@ -101,6 +101,16 @@
 //   - `vite preview` serves the production artifact with no server file:
 //     dist/client statically, everything else (pages, /_server, middleware,
 //     the lifecycle) through the built handler,
+//   - `start.renderMode` (render-mode mode, SSR_RENDER_MODE): 'async' sends
+//     one settled document — no Loading fallback markup, no swap scripts,
+//     boundary content in place, hydration data intact (the streamed page's
+//     browser checks pass against it) — with httpStatus/httpHeader still on
+//     the wire and a mid-render Location as a real 3xx; the per-request
+//     module form (src/render-mode.ts) switches modes within one server by
+//     header / crawler UA / `?nojs`; the `handleRequest(request,
+//     { renderMode })` override wins over both; authored entries get the same
+//     treatment; invalid config and runtime values are rejected with the fix
+//     in the message,
 //   - lazy asset keys survive module identities beyond plain root-relative
 //     paths (the /lazy-assets surface, dev and prod): a query-suffixed lazy
 //     import keeps its query through the manifest key / dev URL (#299), and
@@ -112,7 +122,7 @@
 //
 // Requires the plugin built (pnpm build at the repo root) and Google Chrome.
 // Usage: node test/run.mjs
-// [dev|prod|document|css-filter|entries|endpoint|configure|no-middleware|middleware|preview|base|builder-order|builder-prepare|babel-hmr|frames]
+// [dev|prod|document|css-filter|entries|endpoint|configure|no-middleware|middleware|preview|render-mode|base|builder-order|builder-prepare|babel-hmr|frames]
 // (default: all)
 
 import { spawn, execSync } from 'node:child_process';
@@ -792,11 +802,15 @@ async function runBrowserChecks(
         await cdp.waitFor('document.querySelector("[data-solid-dev-toolbar]") !== null'),
       );
     } else if (devtools === false) {
+      const toolbar = await cdp.evalJs(
+        'document.querySelector("[data-solid-dev-toolbar]")?.outerHTML.slice(0, 200) ?? null',
+      );
       record(
         mode,
         'devtools',
         'no development toolbar in the DOM',
-        (await cdp.evalJs('document.querySelector("[data-solid-dev-toolbar]")')) === null,
+        toolbar === null,
+        `found: ${JSON.stringify(toolbar)}`,
       );
     }
 
@@ -2968,6 +2982,622 @@ async function runPreviewMode() {
   }
 }
 
+// `start.renderMode` (SSR_RENDER_MODE in vite.config.ts): the fix for
+// solidjs/solid#3280 — streaming leaves `<Loading>` fallbacks unresolved for
+// clients that never run the swap scripts. Asserted in dev, prod, and on
+// direct handler dispatch:
+// - 'async' (static config): the handler adopts the renderToStream
+//   thenable, so one complete document goes out — no Loading fallback
+//   markup, no swap templates/scripts, every boundary's content in place —
+//   with hydration data still serialized (the same browser checks as the
+//   streamed page: clean hydration, interactivity, server functions),
+// - the response-head lifecycle under async: httpStatus/httpHeader still
+//   reach the wire (the generated entry commits the head at completion,
+//   before the runtime disposes the render), and a Location written
+//   mid-render — the post-flush script fallback in stream mode — becomes a
+//   real 3xx with no body,
+// - stream mode is byte-for-byte the streaming story it always was (the
+//   default: dev/prod modes above; here re-asserted next to async),
+// - the per-request module form (src/render-mode.ts) switches modes within
+//   one server — a header, a crawler user agent, `?nojs` → async; everyone
+//   else streams,
+// - the `handleRequest(request, { renderMode })` runtime override wins over
+//   both the module function and the static config, and rejects an invalid
+//   value with an actionable error,
+// - authored entries get the same treatment (their renderToStream result
+//   has the same thenable), the prod client-entry rewrite included,
+// - config validation: an unknown literal and a missing module path are
+//   rejected at config time with the fix in the message.
+async function runRenderModeMode() {
+  const mode = 'render-mode';
+  console.log(`\n=== ${mode.toUpperCase()} ===`);
+
+  // A settled document, as a no-JS client sees it: no fallback markup, no
+  // swap machinery, the streamed boundary's content sitting where the
+  // fallback would have been — and still hydratable.
+  const assertComplete = (tag, phase, html, { app = true } = {}) => {
+    record(
+      tag,
+      phase,
+      'complete document (doctype … </html> in one piece)',
+      html.startsWith('<!DOCTYPE html><html') && html.trimEnd().endsWith('</html>'),
+    );
+    record(
+      tag,
+      phase,
+      'no Loading fallback markup',
+      !html.includes('stream-fallback') && !html.includes('streaming…'),
+    );
+    record(
+      tag,
+      phase,
+      'no swap templates or swap scripts',
+      !/<template id=/.test(html) && !html.includes('$df(') && !html.includes('$dfj('),
+    );
+    if (app) {
+      record(
+        tag,
+        phase,
+        'boundary content rendered in place',
+        /<p[^>]*id="streamed"[^>]*>STREAMED-ASYNC-CONTENT<\/p>/.test(html),
+      );
+      record(
+        tag,
+        phase,
+        'hydration data serialized',
+        html.includes('_$HY') && /_\$HY\.r\[|_\$HY\.set\(/.test(html),
+      );
+    }
+  };
+  // The streamed shape, from the full body alone (works for in-process
+  // Responses too): the fallback markup and the swap template both present.
+  const isStreamedMarkup = (html) =>
+    html.includes('stream-fallback') && /<template id=/.test(html) && html.includes('STREAMED-ASYNC-CONTENT');
+  const readAll = async (response) => {
+    const chunks = [];
+    if (response.body) {
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(decoder.decode(value));
+      }
+    }
+    return { status: response.status, headers: response.headers, chunks, html: chunks.join('') };
+  };
+  // The redirect surfaces under async: both the pre-flush one (httpHeader,
+  // ledgered — reverted at disposal unless the head was committed first)
+  // and the mid-render one (a direct stub write 300ms into the render, the
+  // script fallback in stream mode) must be real 3xx responses.
+  const assertAsyncHttp = async (tag, origin, { ledgered = true } = {}) => {
+    if (ledgered) {
+      const missing = await fetchStreamed(origin + '/missing');
+      record(
+        tag,
+        'http',
+        'httpStatus(404) survives to the wire under async',
+        missing.status === 404 && missing.html.includes('NOT-FOUND-PAGE'),
+        `status ${missing.status}`,
+      );
+      record(
+        tag,
+        'http',
+        'httpHeader lands on the async response',
+        missing.headers.get('x-page') === 'missing',
+        `x-page: ${JSON.stringify(missing.headers.get('x-page'))}`,
+      );
+      const pre = await fetch(origin + '/redirect-pre', {
+        headers: { accept: 'text/html' },
+        redirect: 'manual',
+      });
+      record(
+        tag,
+        'http',
+        'pre-flush Location stays a real 3xx under async',
+        pre.status === 302 && pre.headers.get('location') === '/redirected-target',
+        `status ${pre.status}, location ${JSON.stringify(pre.headers.get('location'))}`,
+      );
+      await pre.arrayBuffer();
+    }
+    const post = await fetch(origin + '/redirect-post', {
+      headers: { accept: 'text/html' },
+      redirect: 'manual',
+    });
+    const postBody = await post.text();
+    record(
+      tag,
+      'http',
+      'mid-render Location becomes a real 3xx under async (no script fallback)',
+      post.status === 302,
+      `status ${post.status}`,
+    );
+    record(
+      tag,
+      'http',
+      'mid-render redirect keeps its Location and ships no body',
+      post.headers.get('location') === '/redirected-target' && postBody === '',
+      `location ${JSON.stringify(post.headers.get('location'))}, body ${JSON.stringify(postBody.slice(0, 60))}`,
+    );
+  };
+  const spawnDev = (port, env) =>
+    startProcess('pnpm', ['exec', 'vite', '--port', String(port), '--strictPort'], {
+      cwd: exampleDir,
+      env: { ...process.env, SSR_DEVTOOLS: '0', ...env },
+    });
+  const spawnProd = (port, env) =>
+    startProcess('node', ['server.js'], {
+      cwd: exampleDir,
+      env: { ...process.env, ...env, PORT: String(port), NODE_ENV: 'production' },
+    });
+  // Builds pin NODE_ENV: an in-process `createServer`/`resolveConfig(...,
+  // 'serve')` (the probes below, and earlier modes' probes in a full run)
+  // sets process.env.NODE_ENV to 'development' for the rest of this
+  // process, and a spawned `vite build` inheriting it resolves the
+  // `development` export conditions — the authored fixture's DevToolbar
+  // import would then ship the toolbar into "production" assets.
+  const build = (env) =>
+    execSync('pnpm run build', {
+      cwd: exampleDir,
+      stdio: 'pipe',
+      env: { ...process.env, NODE_ENV: 'production', ...env },
+    });
+  // And the probes themselves put NODE_ENV back the way they found it.
+  const withNodeEnvRestored = async (fn) => {
+    const before = process.env.NODE_ENV;
+    try {
+      return await fn();
+    } finally {
+      if (before === undefined) delete process.env.NODE_ENV;
+      else process.env.NODE_ENV = before;
+    }
+  };
+  const kill = (child) => {
+    if (!child) return;
+    try {
+      process.kill(-child.pid, 'SIGTERM');
+    } catch {}
+  };
+
+  let server;
+  let serverLog = '';
+  const captureLog = (child) => {
+    child.stdout.on('data', (d) => (serverLog += d));
+    child.stderr.on('data', (d) => (serverLog += d));
+  };
+
+  // ---- Config validation --------------------------------------------------
+  // Resolved in-process: the plugin's config hook must reject an unknown
+  // literal and a missing module path with the fix in the message.
+  for (const [value, label] of [
+    ['bogus', 'unknown literal'],
+    ['./src/no-such-render-mode.ts', 'missing module path'],
+  ]) {
+    process.env.SSR_RENDER_MODE = value;
+    let error = '';
+    try {
+      await withNodeEnvRestored(() => resolveConfig({ root: exampleDir }, 'serve'));
+    } catch (e) {
+      error = String(e && e.message ? e.message : e);
+    } finally {
+      delete process.env.SSR_RENDER_MODE;
+    }
+    record(
+      mode,
+      'config',
+      `${label} rejected at config time with an actionable message`,
+      error.includes('start.renderMode') &&
+        error.includes("'stream'") &&
+        error.includes("'async'") &&
+        error.includes('module') &&
+        error.includes(value),
+      error ? error.slice(0, 300) : 'config resolved without error',
+    );
+  }
+
+  // ---- Direct dispatch: the runtime override (default config = stream) -----
+  // A host driving the handler itself (in-process module runner, like the
+  // external/detect modes): the per-call option decides, and an invalid
+  // value is rejected rather than silently streamed.
+  let probe;
+  try {
+    probe = await withNodeEnvRestored(() =>
+      createServer({ root: exampleDir, server: { middlewareMode: true } }),
+    );
+    const handler = await probe.environments.ssr.runner.import('virtual:solid-ssr-handler');
+    const page = (init) =>
+      new Request('http://localhost/', { headers: { accept: 'text/html', ...(init || {}) } });
+    const overridden = await readAll(await handler.handleRequest(page(), { renderMode: 'async' }));
+    record(
+      mode,
+      'override',
+      'handleRequest({ renderMode: "async" }) beats the stream default',
+      overridden.status === 200 && !isStreamedMarkup(overridden.html),
+      `status ${overridden.status}`,
+    );
+    assertComplete(mode, 'override', overridden.html);
+    const plain = await readAll(await handler.handleRequest(page()));
+    record(
+      mode,
+      'override',
+      'without the option the default still streams (fallback + swap template)',
+      plain.status === 200 && isStreamedMarkup(plain.html),
+    );
+    let rejection = '';
+    try {
+      await handler.handleRequest(page(), { renderMode: 'bogus' });
+    } catch (e) {
+      rejection = String(e && e.message ? e.message : e);
+    }
+    record(
+      mode,
+      'override',
+      'invalid runtime renderMode rejected with an actionable error',
+      rejection.includes('renderMode') && rejection.includes("'stream' or 'async'") && rejection.includes('bogus'),
+      rejection.slice(0, 200) || 'resolved without error',
+    );
+    // Codegen: with no option configured, the handler carries no module
+    // import for a render-mode policy (pure codegen, like setup/middleware).
+    const transformed = await probe.environments.ssr.transformRequest('virtual:solid-ssr-handler');
+    record(
+      mode,
+      'codegen',
+      'no render-mode module import without the option',
+      !!transformed && !transformed.code.includes('render-mode.ts'),
+    );
+  } catch (e) {
+    record(mode, 'override', 'direct dispatch completed', false, String(e));
+  } finally {
+    await probe?.close();
+  }
+
+  // ---- Direct dispatch: override beats the per-request module too -----------
+  process.env.SSR_RENDER_MODE = 'module';
+  try {
+    probe = await withNodeEnvRestored(() =>
+      createServer({ root: exampleDir, server: { middlewareMode: true } }),
+    );
+    const handler = await probe.environments.ssr.runner.import('virtual:solid-ssr-handler');
+    const asyncHeader = { accept: 'text/html', 'x-render-mode': 'async' };
+    const viaModule = await readAll(
+      await handler.handleRequest(new Request('http://localhost/', { headers: asyncHeader })),
+    );
+    record(
+      mode,
+      'override',
+      'module function answers per request (header → async)',
+      viaModule.status === 200 && !isStreamedMarkup(viaModule.html) && viaModule.html.includes('STREAMED-ASYNC-CONTENT'),
+    );
+    const forcedStream = await readAll(
+      await handler.handleRequest(new Request('http://localhost/', { headers: asyncHeader }), {
+        renderMode: 'stream',
+      }),
+    );
+    record(
+      mode,
+      'override',
+      'handleRequest({ renderMode: "stream" }) beats the module function (precedence)',
+      forcedStream.status === 200 && isStreamedMarkup(forcedStream.html),
+    );
+    const transformed = await probe.environments.ssr.transformRequest('virtual:solid-ssr-handler');
+    record(
+      mode,
+      'codegen',
+      'handler imports the configured render-mode module',
+      !!transformed && transformed.code.includes('render-mode.ts'),
+    );
+  } catch (e) {
+    record(mode, 'override', 'module-config direct dispatch completed', false, String(e));
+  } finally {
+    await probe?.close();
+    delete process.env.SSR_RENDER_MODE;
+  }
+
+  // ---- Dev: static async --------------------------------------------------
+  const devAsyncPort = 3178;
+  const devAsyncOrigin = `http://localhost:${devAsyncPort}`;
+  try {
+    server = spawnDev(devAsyncPort, { SSR_RENDER_MODE: 'async' });
+    captureLog(server);
+    await waitForHttp(devAsyncOrigin + '/src/api.ts', 30000);
+    const page = await fetchStreamed(devAsyncOrigin + '/');
+    record('rm-dev-async', 'ssr', 'responds 200', page.status === 200, `status ${page.status}`);
+    record('rm-dev-async', 'ssr', 'app server-rendered', page.html.includes('SSR Start Mode'));
+    assertComplete('rm-dev-async', 'ssr', page.html);
+    record(
+      'rm-dev-async',
+      'dev',
+      'dev head still injected on the string path (Vite client + entry CSS)',
+      page.html.includes('/@vite/client') &&
+        page.html.includes('virtual:solid-ssr-entry-client.tsx') &&
+        /<style[^>]*data-vite-dev-id="[^"]*App\.css"/.test(page.html),
+    );
+    await assertAsyncHttp('rm-dev-async', devAsyncOrigin);
+    // The async document must still hydrate and be interactive — the same
+    // browser checks the streamed page passes (clean hydration, counter,
+    // server functions, clientOnly swap, styles).
+    await runBrowserChecks('rm-dev-async', devAsyncOrigin, { devCss: true });
+  } catch (e) {
+    record(
+      'rm-dev-async',
+      'run',
+      'dev async completed',
+      false,
+      String(e) + (serverLog ? `\nserver: ${serverLog.slice(-2000)}` : ''),
+    );
+  } finally {
+    kill(server);
+    server = undefined;
+    serverLog = '';
+  }
+
+  // ---- Dev: per-request module --------------------------------------------
+  const devModulePort = 3179;
+  const devModuleOrigin = `http://localhost:${devModulePort}`;
+  const perRequestChecks = async (tag, origin) => {
+    const plain = await fetchStreamed(origin + '/');
+    const contentAt = plain.chunks.findIndex((c) => c.includes('STREAMED-ASYNC-CONTENT'));
+    record(
+      tag,
+      'per-request',
+      'default request streams (shell with fallback first, content later)',
+      plain.chunks.length > 1 &&
+        contentAt > 0 &&
+        plain.chunks.slice(0, contentAt).join('').includes('stream-fallback'),
+      `${plain.chunks.length} chunk(s), content in chunk ${contentAt}`,
+    );
+    const viaHeader = await fetch(origin + '/', {
+      headers: { accept: 'text/html', 'x-render-mode': 'async' },
+    });
+    const viaHeaderHtml = await viaHeader.text();
+    record(tag, 'per-request', 'x-render-mode: async → complete document', viaHeader.status === 200);
+    assertComplete(tag, 'per-request(header)', viaHeaderHtml);
+    const viaUa = await fetch(origin + '/', {
+      headers: {
+        accept: 'text/html',
+        'user-agent': 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)',
+      },
+    });
+    const viaUaHtml = await viaUa.text();
+    record(
+      tag,
+      'per-request',
+      'crawler user agent → complete document',
+      viaUa.status === 200 && !isStreamedMarkup(viaUaHtml) && viaUaHtml.includes('STREAMED-ASYNC-CONTENT'),
+    );
+    const viaFlag = await fetch(origin + '/?nojs', { headers: { accept: 'text/html' } });
+    const viaFlagHtml = await viaFlag.text();
+    record(
+      tag,
+      'per-request',
+      '?nojs → complete document',
+      viaFlag.status === 200 && !isStreamedMarkup(viaFlagHtml) && viaFlagHtml.includes('STREAMED-ASYNC-CONTENT'),
+    );
+    const forced = await fetchStreamed(origin + '/');
+    record(
+      tag,
+      'per-request',
+      'same server keeps streaming for the next plain request',
+      forced.chunks.length > 1 && isStreamedMarkup(forced.html),
+      `${forced.chunks.length} chunk(s)`,
+    );
+  };
+  try {
+    server = spawnDev(devModulePort, { SSR_RENDER_MODE: 'module' });
+    captureLog(server);
+    await waitForHttp(devModuleOrigin + '/src/api.ts', 30000);
+    await perRequestChecks('rm-dev-module', devModuleOrigin);
+  } catch (e) {
+    record(
+      'rm-dev-module',
+      'run',
+      'dev module completed',
+      false,
+      String(e) + (serverLog ? `\nserver: ${serverLog.slice(-2000)}` : ''),
+    );
+  } finally {
+    kill(server);
+    server = undefined;
+    serverLog = '';
+  }
+
+  // ---- Prod: static async ---------------------------------------------------
+  const prodAsyncPort = 3180;
+  const prodAsyncOrigin = `http://localhost:${prodAsyncPort}`;
+  try {
+    console.log('  building (async)…');
+    build({ SSR_RENDER_MODE: 'async' });
+    const serverBundle = readFileSync(path.join(exampleDir, 'dist/server/server.js'), 'utf-8');
+    record(
+      'rm-prod-async',
+      'build',
+      'static mode baked into the handler bundle',
+      serverBundle.includes('"async"') && serverBundle.includes('assertRenderMode'),
+    );
+    // Override on the built handler, before the server boots: the static
+    // config is async, the per-call option streams anyway.
+    const built = await import(
+      pathToFileURL(path.join(exampleDir, 'dist/server/server.js')).href + `?rm=${Date.now()}`
+    );
+    const forcedStream = await readAll(
+      await built.handleRequest(new Request(prodAsyncOrigin + '/', { headers: { accept: 'text/html' } }), {
+        renderMode: 'stream',
+      }),
+    );
+    record(
+      'rm-prod-async',
+      'override',
+      'handleRequest({ renderMode: "stream" }) beats the static async config',
+      forcedStream.status === 200 && isStreamedMarkup(forcedStream.html),
+    );
+
+    server = spawnProd(prodAsyncPort, { SSR_RENDER_MODE: 'async' });
+    captureLog(server);
+    await waitForHttp(prodAsyncOrigin + '/', 30000, { headers: { accept: 'text/html' } });
+    const page = await fetchStreamed(prodAsyncOrigin + '/');
+    record('rm-prod-async', 'ssr', 'responds 200', page.status === 200, `status ${page.status}`);
+    assertComplete('rm-prod-async', 'ssr', page.html);
+    record(
+      'rm-prod-async',
+      'prod',
+      'hashed client entry + css injected on the string path',
+      /<script type="module" src="\/assets\/[^"]+\.js" async><\/script>/.test(page.html) &&
+        /<link rel="stylesheet" href="\/assets\/[^"]+\.css">/.test(page.html),
+    );
+    record('rm-prod-async', 'prod', 'no dev injections leaked', !page.html.includes('/@vite/client'));
+    await assertAsyncHttp('rm-prod-async', prodAsyncOrigin);
+    await runBrowserChecks('rm-prod-async', prodAsyncOrigin, { devtools: false });
+  } catch (e) {
+    record(
+      'rm-prod-async',
+      'run',
+      'prod async completed',
+      false,
+      String(e) + (serverLog ? `\nserver: ${serverLog.slice(-2000)}` : ''),
+    );
+  } finally {
+    kill(server);
+    server = undefined;
+    serverLog = '';
+  }
+
+  // ---- Prod: per-request module ----------------------------------------------
+  const prodModulePort = 3181;
+  const prodModuleOrigin = `http://localhost:${prodModulePort}`;
+  try {
+    console.log('  building (module)…');
+    build({ SSR_RENDER_MODE: 'module' });
+    const serverBundle = readFileSync(path.join(exampleDir, 'dist/server/server.js'), 'utf-8');
+    record(
+      'rm-prod-module',
+      'build',
+      'render-mode module bundled into the handler chunk',
+      serverBundle.includes('x-render-mode'),
+    );
+    const assetsDir = path.join(exampleDir, 'dist/client/assets');
+    const leaks = readdirSync(assetsDir).filter((f) =>
+      readFileSync(path.join(assetsDir, f), 'utf-8').includes('x-render-mode'),
+    );
+    record(
+      'rm-prod-module',
+      'build',
+      'render-mode module absent from client assets',
+      leaks.length === 0,
+      leaks.join(', '),
+    );
+    server = spawnProd(prodModulePort, { SSR_RENDER_MODE: 'module' });
+    captureLog(server);
+    await waitForHttp(prodModuleOrigin + '/', 30000, { headers: { accept: 'text/html' } });
+    await perRequestChecks('rm-prod-module', prodModuleOrigin);
+  } catch (e) {
+    record(
+      'rm-prod-module',
+      'run',
+      'prod module completed',
+      false,
+      String(e) + (serverLog ? `\nserver: ${serverLog.slice(-2000)}` : ''),
+    );
+  } finally {
+    kill(server);
+    server = undefined;
+    serverLog = '';
+  }
+
+  // ---- Authored entries -----------------------------------------------------
+  // The same thenable adoption for an authored `render()` (the classic
+  // renderToStream entry): dev with the static async config, and the module
+  // form switching per request; prod with the async config, where the
+  // string path still rewrites the authored client-entry reference.
+  const authoredDevPort = 3182;
+  const authoredDevOrigin = `http://localhost:${authoredDevPort}`;
+  const authoredProdPort = 3183;
+  const authoredProdOrigin = `http://localhost:${authoredProdPort}`;
+  for (const [file, source] of Object.entries(ENTRY_FIXTURES)) {
+    writeFileSync(path.join(exampleDir, file), source);
+  }
+  try {
+    server = spawnDev(authoredDevPort, { SSR_RENDER_MODE: 'async' });
+    captureLog(server);
+    await waitForHttp(authoredDevOrigin + '/src/api.ts', 30000);
+    const page = await fetchStreamed(authoredDevOrigin + '/');
+    record(
+      'rm-authored',
+      'dev',
+      'authored entry rendered (custom title)',
+      page.status === 200 && page.html.includes('<title>Authored Entries</title>'),
+    );
+    assertComplete('rm-authored', 'dev', page.html);
+    // The mid-render redirect is a direct stub write, so it holds for
+    // authored entries too; the ledgered httpStatus/httpHeader surfaces are
+    // covered by the generated-entry runs (see the README note).
+    await assertAsyncHttp('rm-authored', authoredDevOrigin, { ledgered: false });
+    kill(server);
+    server = undefined;
+
+    server = spawnDev(authoredDevPort, { SSR_RENDER_MODE: 'module' });
+    captureLog(server);
+    await waitForHttp(authoredDevOrigin + '/src/api.ts', 30000);
+    const streamed = await fetchStreamed(authoredDevOrigin + '/');
+    record(
+      'rm-authored',
+      'per-request',
+      'authored entry streams by default under the module form',
+      streamed.chunks.length > 1 && isStreamedMarkup(streamed.html),
+      `${streamed.chunks.length} chunk(s)`,
+    );
+    const settled = await fetch(authoredDevOrigin + '/?nojs', { headers: { accept: 'text/html' } });
+    const settledHtml = await settled.text();
+    record(
+      'rm-authored',
+      'per-request',
+      'authored entry settles for ?nojs under the module form',
+      settled.status === 200 && !isStreamedMarkup(settledHtml) && settledHtml.includes('STREAMED-ASYNC-CONTENT'),
+    );
+    kill(server);
+    server = undefined;
+
+    console.log('  building (authored, async)…');
+    build({ SSR_RENDER_MODE: 'async' });
+    server = spawnProd(authoredProdPort, { SSR_RENDER_MODE: 'async' });
+    captureLog(server);
+    await waitForHttp(authoredProdOrigin + '/', 30000, { headers: { accept: 'text/html' } });
+    const prod = await fetchStreamed(authoredProdOrigin + '/');
+    record(
+      'rm-authored',
+      'prod',
+      'authored entry rendered in prod',
+      prod.status === 200 && prod.html.includes('<title>Authored Entries</title>'),
+    );
+    assertComplete('rm-authored', 'prod', prod.html);
+    record(
+      'rm-authored',
+      'prod',
+      'authored client entry reference rewritten on the string path',
+      !prod.html.includes('/src/entry-client.tsx') &&
+        /<script type="module" src="\/assets\/[^"]+\.js" async>/.test(prod.html),
+    );
+    await runBrowserChecks('rm-authored', authoredProdOrigin, { devtools: false });
+  } catch (e) {
+    record(
+      'rm-authored',
+      'run',
+      'authored completed',
+      false,
+      String(e) + (serverLog ? `\nserver: ${serverLog.slice(-2000)}` : ''),
+    );
+  } finally {
+    kill(server);
+    server = undefined;
+    for (const file of Object.keys(ENTRY_FIXTURES)) {
+      rmSync(path.join(exampleDir, file), { force: true });
+    }
+    // Leave dist in the standard state for anyone poking at it.
+    try {
+      build();
+    } catch {}
+  }
+}
+
 // Non-root Vite `base` (SOLID_BASE=/app/): the base must hold end to end on
 // every start-mode surface. Regression coverage for the brenelz base cluster:
 // - #300: `vite preview` strips the base from req.url before the plugin's
@@ -3478,6 +4108,7 @@ const ALL_MODES = [
   'no-middleware',
   'middleware',
   'preview',
+  'render-mode',
   'base',
   'builder-order',
   'builder-prepare',
@@ -3500,6 +4131,7 @@ for (const mode of modes) {
   else if (mode === 'no-middleware') await runNoMiddlewareMode();
   else if (mode === 'middleware') await runMiddlewareMode();
   else if (mode === 'preview') await runPreviewMode();
+  else if (mode === 'render-mode') await runRenderModeMode();
   else if (mode === 'base') await runBaseMode();
   else if (mode === 'builder-order') await runBuilderOrderMode();
   else if (mode === 'builder-prepare') await runBuilderPrepareMode();
diff --git a/examples/start-ssr/vite.config.ts b/examples/start-ssr/vite.config.ts
index 6b069f8..1907049 100644
--- a/examples/start-ssr/vite.config.ts
+++ b/examples/start-ssr/vite.config.ts
@@ -27,6 +27,11 @@ import solidPlugin from '@solidjs/vite-plugin';
 // - SSR_SETUP=1 wires src/setup.tsx through `start.setup` (middleware mode):
 //   the per-request app-setup hook, awaited between the middleware chain and
 //   renderToStream with the shared request event in hand.
+// - SSR_RENDER_MODE sets `start.renderMode` (render-mode mode): `module`
+//   wires src/render-mode.ts (the per-request policy: header / crawler UA /
+//   `?nojs`); any other value passes through verbatim — `async` for the
+//   static complete-document mode, and bogus literals or missing paths for
+//   the config-validation assertions.
 // - SERVER_FN_DEV_MIDDLEWARE=0 disables the built-in dev middleware via
 //   `serverFunctions.devMiddleware` (no-middleware mode) — endpoint dispatch
 //   becomes the host's job, like a Cloudflare-style environment plugin.
@@ -161,6 +166,17 @@ export default defineConfig({
               // renderToStream, receiving the event and returning the
               // component to render (the TanStack-style async router seam).
               ...(process.env.SSR_SETUP ? { setup: './src/setup.tsx' } : {}),
+              // SSR_RENDER_MODE (render-mode mode): `module` → the
+              // per-request policy module; anything else verbatim
+              // (`async`, or an invalid value for the validation checks).
+              ...(process.env.SSR_RENDER_MODE
+                ? {
+                    renderMode:
+                      process.env.SSR_RENDER_MODE === 'module'
+                        ? './src/render-mode.ts'
+                        : process.env.SSR_RENDER_MODE,
+                  }
+                : {}),
             },
       serverFunctions: serverComponents
         ? { components: true }
diff --git a/src/ssr/index.ts b/src/ssr/index.ts
index f98a2f4..daf7480 100644
--- a/src/ssr/index.ts
+++ b/src/ssr/index.ts
@@ -31,6 +31,11 @@
 //   it, and page responses go through the runtime's `createSSRResponse`
 //   head lifecycle (commit at shell flush, real pre-flush redirects, the
 //   script fallback post-flush).
+// - `start.renderMode` decides how a page render becomes a body: `'stream'`
+//   (default) flushes the shell with fallbacks and streams boundaries in
+//   behind it; `'async'` awaits the settled document (no fallbacks or swap
+//   scripts — complete for no-JS clients); a module path decides per
+//   request, and `handleRequest(request, { renderMode })` overrides both.
 // - `vite preview` serves dist/client statically and dispatches everything
 //   else through the built handler — the production path, middleware
 //   included, with no server file needed.
@@ -188,6 +193,43 @@ export interface StartOptions {
    * @default undefined
    */
   setup?: string;
+  /**
+   * How the generated handler turns a page render into a response body.
+   *
+   * - `'stream'` (default): the document shell flushes as soon as it is
+   *   ready, with `<Loading>` fallbacks in place; boundary content follows
+   *   in later chunks and is swapped in by inline scripts. Best TTFB, but
+   *   a client that never runs JavaScript (crawlers, `curl`, no-JS
+   *   browsers) is left looking at the fallbacks (solidjs/solid#3280).
+   * - `'async'`: the handler awaits the render until every boundary has
+   *   settled and sends one complete document. Nothing has flushed, so
+   *   each resolved boundary is spliced in place of its placeholder — no
+   *   fallback markup, no swap templates or scripts — while hydration data
+   *   still serializes, so JavaScript clients hydrate exactly as before.
+   *   The tradeoffs are inherent: time-to-first-byte waits for the slowest
+   *   boundary, and the whole page buffers in memory before it is sent.
+   *   `deferStream` is moot here (everything defers), and a `Location`
+   *   header written mid-render becomes a real 3xx instead of the
+   *   post-flush script fallback.
+   * - A module path (resolved relative to the Vite root, following the
+   *   `middleware`/`setup` convention — a Vite config cannot serialize a
+   *   closure into the generated handler): the module default-exports
+   *   `(event) => 'stream' | 'async' | Promise<'stream' | 'async'>`, called
+   *   per request inside the request scope after the middleware chain (so
+   *   `event.locals` decoration is visible) — e.g. `'async'` for crawler
+   *   user agents or a `?nojs` flag, `'stream'` for everyone else.
+   *
+   * Hosts driving the handler directly can override all of the above per
+   * call with `handleRequest(request, { renderMode })`; precedence is that
+   * runtime option, then the module function's result, then this static
+   * value. Applies to generated and authored entries alike (an authored
+   * `render()` returning a `renderToStream` result is awaited the same
+   * way). Server mode only — ignored in client mode, where the served
+   * shell has no boundaries to settle.
+   *
+   * @default 'stream'
+   */
+  renderMode?: 'stream' | 'async' | (string & {});
   /**
    * Typed, validated environment variables. A schema file — conventionally
    * `env.ts` (or `env.js`) at the project root, probed automatically —
@@ -326,6 +368,47 @@ function normalizeUserPath(root: string, spec: string, option: string): string {
   return relative;
 }
 
+type RenderMode = 'stream' | 'async';
+
+/**
+ * Resolves `start.renderMode` at config time: a literal mode, or the
+ * absolute path of a per-request module (`mode` stays the `'stream'`
+ * default then; the module decides per request). Anything else is a
+ * config error with the fix in the message — an unknown literal is far
+ * more likely a typo than a file, so the message names both readings.
+ */
+function resolveRenderMode(
+  root: string,
+  value: StartOptions['renderMode'],
+): { mode: RenderMode; path: string | null } {
+  if (value === undefined) return { mode: 'stream', path: null };
+  // (`string & {}` keeps editor completion for the literals; TS cannot
+  // narrow it away by equality, hence the assertion.)
+  if (value === 'stream' || value === 'async') return { mode: value as RenderMode, path: null };
+  const usage =
+    `start.renderMode must be 'stream' (the default), 'async', or the path of a module ` +
+    `(relative to the Vite root) default-exporting a per-request function ` +
+    `((event) => 'stream' | 'async' | Promise<...>)`;
+  if (typeof value !== 'string') {
+    throw new Error(
+      `[@solidjs/vite-plugin] ${usage}; got ${typeof value}. A Vite config cannot serialize a ` +
+        `closure into the generated handler — put the function in a module (e.g. ` +
+        `./src/render-mode.ts) and pass its path instead.`,
+    );
+  }
+  const absolute = path.isAbsolute(value) ? value : path.resolve(root, value);
+  if (!existsSync(absolute)) {
+    throw new Error(
+      `[@solidjs/vite-plugin] ${usage}; got ${JSON.stringify(value)}, which is neither a mode ` +
+        `nor an existing file.`,
+    );
+  }
+  return {
+    mode: 'stream',
+    path: path.resolve(root, normalizeUserPath(root, value, 'renderMode')),
+  };
+}
+
 interface ResolvedEntries {
   /** Root-relative path or virtual id. */
   entryServer: string;
@@ -484,6 +567,14 @@ export function startServe(
   let middlewarePath: string | null = null;
   /** Absolute path of the per-request setup module, when configured (server mode). */
   let setupPath: string | null = null;
+  /**
+   * `start.renderMode`, resolved at config time: the static mode baked into
+   * the handler, or the absolute path of the per-request module deciding it
+   * (server mode only — a documented no-op in client mode, whose shell has
+   * no boundaries to settle).
+   */
+  let renderMode: RenderMode = 'stream';
+  let renderModePath: string | null = null;
 
   function requireEntries(): ResolvedEntries {
     // config() always runs before resolveId/load/configureServer.
@@ -671,9 +762,9 @@ export function startServe(
       ].join('\n');
     }
     const { app } = requireEntries();
-    const streamOptions = `{ manifest${serverComponents ? ', plugins: [ServerComponentPlugin]' : ''} }`;
+    const streamOptions = `{ manifest, onCompleteAll: commitResponseHead${serverComponents ? ', plugins: [ServerComponentPlugin]' : ''} }`;
     return [
-      `import { renderToStream${setupPath ? ', getRequestEvent' : ''} } from '@solidjs/web';`,
+      `import { renderToStream, getRequestEvent, commitResponseStub } from '@solidjs/web';`,
       ...(serverComponents
         ? [
             `import { configureServerFunctionsServer } from '@solidjs/web/server-functions';`,
@@ -706,6 +797,19 @@ export function startServe(
             ``,
           ]
         : []),
+      // Commits the response head when the render completes — BEFORE the
+      // runtime disposes the render. `httpStatus`/`httpHeader` register
+      // cleanups that revert their declarations unless the stub is already
+      // committed; streaming commits at shell flush (this is a no-op there),
+      // but the async render mode resolves the complete document only after
+      // that disposal (`renderToStream(...).then` disposes, then resolves),
+      // so without this the settled 404 / Location would be reverted before
+      // createSSRResponse's string path could commit them.
+      `function commitResponseHead() {`,
+      `  const event = getRequestEvent();`,
+      `  if (event) commitResponseStub(event.response);`,
+      `}`,
+      ``,
       ...(setupPath
         ? [
             // The per-request seam: the hook sees the same event the
@@ -866,6 +970,9 @@ export function startServe(
       ...(middlewarePath
         ? [`import middlewareModule from ${JSON.stringify(middlewarePath)};`]
         : []),
+      ...(renderModePath
+        ? [`import renderModeModule from ${JSON.stringify(renderModePath)};`]
+        : []),
       ...(externalDev ? [`import DEV_STYLES_HEAD from ${JSON.stringify(DEV_STYLES_ID)};`] : []),
       ...(composeServerFunctions
         ? [
@@ -925,6 +1032,43 @@ export function startServe(
       lines.push(`const runMiddleware = (request, next) => next(request);`);
     }
 
+    // Render mode (`start.renderMode`): 'stream' flushes the shell with
+    // fallbacks in place and streams boundary content after it; 'async'
+    // adopts the renderToStream result's thenable — which waits for the
+    // complete render — so one settled document goes out (the fix for
+    // no-JS clients, solidjs/solid#3280). Precedence per request: the
+    // `handleRequest` option (hosts driving the handler directly), then the
+    // configured module's per-request result, then the static config. Every
+    // source is validated against the two literals with the offender named.
+    lines.push(
+      ``,
+      `function assertRenderMode(mode, source) {`,
+      `  if (mode !== 'stream' && mode !== 'async') {`,
+      `    throw new Error('[@solidjs/vite-plugin] ' + source + " must be 'stream' or 'async', got " + JSON.stringify(mode));`,
+      `  }`,
+      `  return mode;`,
+      `}`,
+    );
+    if (renderModePath) {
+      lines.push(
+        `if (typeof renderModeModule !== 'function') {`,
+        `  throw new Error('[@solidjs/vite-plugin] start.renderMode must default-export a function ' +`,
+        `    "((event) => 'stream' | 'async' | Promise<...>): " + ${JSON.stringify(renderModePath)});`,
+        `}`,
+        `async function resolveRenderMode(event, options) {`,
+        `  if (options.renderMode !== undefined) return assertRenderMode(options.renderMode, 'handleRequest options.renderMode');`,
+        `  return assertRenderMode(await renderModeModule(event), 'the start.renderMode module (' + ${JSON.stringify(renderModePath)} + ') result');`,
+        `}`,
+      );
+    } else {
+      lines.push(
+        `function resolveRenderMode(event, options) {`,
+        `  if (options.renderMode !== undefined) return assertRenderMode(options.renderMode, 'handleRequest options.renderMode');`,
+        `  return ${JSON.stringify(renderMode)};`,
+        `}`,
+      );
+    }
+
     // No `_$SC` bootstrap injection: the runtime's serialized
     // server-component references self-bootstrap the registry (each
     // hydration script's first reference carries it as an idempotent
@@ -1049,6 +1193,10 @@ export function startServe(
       isBuild
         ? `  const clientEntry = options.clientEntry || resolveClientEntry();`
         : `  const clientEntry = options.clientEntry || ${JSON.stringify(devClientEntryUrl())};`,
+      // Decided before the render starts (the module form may be async),
+      // inside the request scope and after the middleware chain, so a
+      // per-request policy sees the decorated event.
+      `  const renderMode = await resolveRenderMode(event, options);`,
       `  let result = entry.render(request, { clientEntry, ...options.context });`,
       // renderToStream results are thenables whose then() waits for the
       // *complete* render — check for pipe first so streaming survives, and
@@ -1064,6 +1212,16 @@ export function startServe(
             `  if (result && result.${STREAM_BOX}) result = result.${STREAM_BOX};`,
           ]
         : []),
+      // Async mode adopts the thenable deliberately — the very thing the
+      // pipe-first check and the setup box exist to avoid in stream mode.
+      // It resolves with the full HTML once every boundary settled, each
+      // spliced in place pre-flush (no fallbacks, no swap scripts; hydration
+      // data still serialized), and the string then takes
+      // createSSRResponse's string path below: stub commit, transformChunk
+      // on the whole document, and a mid-render Location as a real 3xx.
+      `  if (renderMode === 'async' && result && typeof result.then === 'function') {`,
+      `    result = await result;`,
+      `  }`,
       // Raw Responses fold at the handler edge (handleRequest), after the
       // middleware chain unwinds — not here, where middleware above this
       // frame could still legitimately mutate headers.
@@ -1144,6 +1302,14 @@ export function startServe(
               `(remove start.setup or the authored entry): ${options.setup}`,
           );
         }
+        // Server-mode only as well: the client-mode shell renders no app,
+        // so there is nothing to settle. Validated in every mode though —
+        // a typo should not hide behind the `ssr` boolean.
+        ({ mode: renderMode, path: renderModePath } = resolveRenderMode(root, options.renderMode));
+        if (clientMode) {
+          renderMode = 'stream';
+          renderModePath = null;
+        }
         if (env.isPreview) {
           if (clientMode) {
             // Client-mode builds emit a real dist/client/index.html (the
diff --git a/virtual-solid-manifest.d.ts b/virtual-solid-manifest.d.ts
index 51e2c11..f26db65 100644
--- a/virtual-solid-manifest.d.ts
+++ b/virtual-solid-manifest.d.ts
@@ -49,6 +49,16 @@ declare module "virtual:solid-ssr-handler" {
       context?: Record<string, unknown>;
       /** Status/headers for the HTML response. */
       responseInit?: ResponseInit;
+      /**
+       * Per-call render mode, overriding `start.renderMode` (static value or
+       * per-request module alike). `'stream'` flushes the document shell
+       * with `<Loading>` fallbacks and streams boundary content behind it;
+       * `'async'` awaits the render until every boundary settled and sends
+       * one complete document — no fallbacks, no swap scripts, hydration
+       * data intact — for clients that never run JavaScript. A mid-render
+       * `Location` becomes a real 3xx under `'async'`.
+       */
+      renderMode?: 'stream' | 'async';
       /**
        * Extra fields spread into the request event at creation — the public
        * wrapper→event extension seam. Conventionally `nativeEvent` carries