diff --git a/.changeset/ssr-data-only.md b/.changeset/ssr-data-only.md
new file mode 100644
index 000000000..6cb06a6f1
--- /dev/null
+++ b/.changeset/ssr-data-only.md
@@ -0,0 +1,5 @@
+---
+"@solidjs/start": minor
+---
+
+Add `ssr: "data-only"`. The app renders on the client without hydration, as with `ssr: false`, but the server runs the requested page's route `preload`s and streams their query results with the HTML shell, so the client doesn't fetch that data again.
diff --git a/packages/start/config/index.d.ts b/packages/start/config/index.d.ts
index bb1613f64..5b9052b52 100644
--- a/packages/start/config/index.d.ts
+++ b/packages/start/config/index.d.ts
@@ -15,7 +15,18 @@ type ViteCustomizableConfig = CustomizableConfig & {
 
 type SolidStartInlineConfig = {
   publicDir?: string;
-  ssr?: boolean;
+  /**
+   * Enable or disable server-side rendering.
+   *
+   * - `true` — SSR (default)
+   * - `false` — client-side rendering only (SPA mode)
+   * - `"data-only"` — SPA mode, but the server runs the route `preload`s for the
+   *   requested page and sends their query results with the HTML shell. The
+   *   client renders without hydrating and without fetching that data again.
+   *
+   * @default true
+   */
+  ssr?: boolean | "data-only";
   solid?: Options;
   extensions?: string[];
   server?: AppOptions["server"];
diff --git a/packages/start/config/index.js b/packages/start/config/index.js
index 53d1946af..7fb6f3758 100644
--- a/packages/start/config/index.js
+++ b/packages/start/config/index.js
@@ -97,7 +97,9 @@ export function defineConfig(baseConfig = {}) {
   
   const routeDir = join(start.appRoot, start.routeDir);
   let server = start.server;
-  if (!start.ssr) {
+  // Data-only mode runs each page's preloads per request, so it can't use a
+  // prerendered shell.
+  if (start.ssr === false) {
     server = { ...server, prerender: { routes: ["/"] } };
   }
   let entryExtension = ".tsx";
@@ -129,7 +131,7 @@ export function defineConfig(baseConfig = {}) {
         },
         handler: `${start.appRoot}/entry-server${entryExtension}`,
         middleware: start.middleware,
-        routes: solidStartServerFsRouter({ dir: routeDir, extensions, dataOnly: !start.ssr }),
+        routes: solidStartServerFsRouter({ dir: routeDir, extensions, dataOnly: start.ssr !== true }),
         extensions,
         target: "server",
         plugins: async () => {
@@ -158,7 +160,7 @@ export function defineConfig(baseConfig = {}) {
                 alias: {
                   "#start/app": join(process.cwd(), start.appRoot, `app${entryExtension}`),
                   "~": join(process.cwd(), start.appRoot),
-                  ...(!start.ssr
+                  ...(start.ssr !== true
                     ? {
                         "@solidjs/start/server": "@solidjs/start/server/spa"
                       }
@@ -173,7 +175,8 @@ export function defineConfig(baseConfig = {}) {
                 ),
                 "import.meta.env.START_ISLANDS": JSON.stringify(start.experimental.islands),
                 "import.meta.env.SSR": JSON.stringify(true),
-                "import.meta.env.START_SSR": JSON.stringify(start.ssr),
+                "import.meta.env.START_SSR": JSON.stringify(start.ssr === true),
+                "import.meta.env.START_SSR_DATA": JSON.stringify(start.ssr === "data-only"),
                 "import.meta.env.START_DEV_OVERLAY": JSON.stringify(start.devOverlay),
                 "import.meta.env.SEROVAL_MODE": JSON.stringify(serializationMode),
                 ...userConfig.define
@@ -214,7 +217,7 @@ export function defineConfig(baseConfig = {}) {
             ...plugins,
             SolidStartServerFnsPlugin.client,
             start.experimental.islands ? serverComponents.client() : null,
-            solid({ ...start.solid, ssr: start.ssr, extensions: extensions.map(ext => `.${ext}`) }),
+            solid({ ...start.solid, ssr: start.ssr === true, extensions: extensions.map(ext => `.${ext}`) }),
             config("app-client", {
               resolve: {
                 alias: {
@@ -225,7 +228,7 @@ export function defineConfig(baseConfig = {}) {
                         "@solidjs/start/client": "@solidjs/start/client/islands"
                       }
                     : {}),
-                  ...(!start.ssr
+                  ...(start.ssr !== true
                     ? {
                         "@solidjs/start/client": "@solidjs/start/client/spa"
                       }
@@ -240,7 +243,8 @@ export function defineConfig(baseConfig = {}) {
                 ),
                 "import.meta.env.START_ISLANDS": JSON.stringify(start.experimental.islands),
                 "import.meta.env.SSR": JSON.stringify(false),
-                "import.meta.env.START_SSR": JSON.stringify(start.ssr),
+                "import.meta.env.START_SSR": JSON.stringify(start.ssr === true),
+                "import.meta.env.START_SSR_DATA": JSON.stringify(start.ssr === "data-only"),
                 "import.meta.env.START_DEV_OVERLAY": JSON.stringify(start.devOverlay),
                 "import.meta.env.SERVER_BASE_URL": JSON.stringify(server?.baseURL ?? ""),
                 "import.meta.env.SEROVAL_MODE": JSON.stringify(serializationMode),
@@ -259,7 +263,7 @@ export function defineConfig(baseConfig = {}) {
         ),
         middleware: start.middleware,
         target: "server",
-        routes: solidStartServerFsRouter({ dir: routeDir, extensions, dataOnly: !start.ssr }),
+        routes: solidStartServerFsRouter({ dir: routeDir, extensions, dataOnly: start.ssr !== true }),
         plugins: async () => {
           const userConfig =
             typeof vite === "function" ? await vite({ router: "server-function" }) : { ...vite };
@@ -287,7 +291,7 @@ export function defineConfig(baseConfig = {}) {
                 alias: {
                   "#start/app": join(process.cwd(), start.appRoot, `app${entryExtension}`),
                   "~": join(process.cwd(), start.appRoot),
-                  ...(!start.ssr
+                  ...(start.ssr !== true
                     ? {
                         "@solidjs/start/server": "@solidjs/start/server/spa"
                       }
@@ -301,7 +305,8 @@ export function defineConfig(baseConfig = {}) {
                 ),
                 "import.meta.env.START_ISLANDS": JSON.stringify(start.experimental.islands),
                 "import.meta.env.SSR": JSON.stringify(true),
-                "import.meta.env.START_SSR": JSON.stringify(start.ssr),
+                "import.meta.env.START_SSR": JSON.stringify(start.ssr === true),
+                "import.meta.env.START_SSR_DATA": JSON.stringify(start.ssr === "data-only"),
                 "import.meta.env.START_DEV_OVERLAY": JSON.stringify(start.devOverlay),
                 "import.meta.env.SEROVAL_MODE": JSON.stringify(serializationMode),
                 ...userConfig.define
diff --git a/packages/start/env.d.ts b/packages/start/env.d.ts
index 14f796189..5da13e884 100644
--- a/packages/start/env.d.ts
+++ b/packages/start/env.d.ts
@@ -20,6 +20,7 @@ interface ImportMetaEnv extends Record<`VITE_${string}`, any>, SolidStartMetaEnv
 
 interface SolidStartMetaEnv {
   START_SSR: boolean;
+  START_SSR_DATA: boolean;
   START_ISLANDS: boolean;
   START_DEV_OVERLAY: boolean;
   SERVER_BASE_URL: string;
diff --git a/packages/start/src/client/spa/index.tsx b/packages/start/src/client/spa/index.tsx
index f18442ff8..c09939a6f 100644
--- a/packages/start/src/client/spa/index.tsx
+++ b/packages/start/src/client/spa/index.tsx
@@ -2,9 +2,15 @@
 import type { JSX } from "solid-js";
 import { render, type MountableElement } from "solid-js/web";
 import "vinxi/client";
+import { seedInitialData } from "./initial-data";
 
 export function mount(fn: () => JSX.Element, el: MountableElement) {
-  render(fn, el);
+  const restore = import.meta.env.START_SSR_DATA ? seedInitialData() : undefined;
+  try {
+    render(fn, el);
+  } finally {
+    restore?.();
+  }
 }
 
 export { StartClient, StartClientTanstack } from "../StartClient";
diff --git a/packages/start/src/client/spa/initial-data.spec.ts b/packages/start/src/client/spa/initial-data.spec.ts
new file mode 100644
index 000000000..35693541c
--- /dev/null
+++ b/packages/start/src/client/spa/initial-data.spec.ts
@@ -0,0 +1,29 @@
+import { sharedConfig } from "solid-js";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { seedInitialData } from "./initial-data";
+
+describe("seedInitialData", () => {
+  afterEach(() => {
+    delete (globalThis as any)._$HY;
+  });
+
+  it("does nothing without streamed data", () => {
+    expect(seedInitialData()).toBeUndefined();
+    expect(sharedConfig.has).toBeUndefined();
+  });
+
+  it("lets the first render read the streamed data, then puts sharedConfig back", () => {
+    const value = Promise.resolve({ id: 1 });
+    (globalThis as any)._$HY = { r: { 'user["1"]': value } };
+
+    const restore = seedInitialData()!;
+    expect(sharedConfig.has!('user["1"]')).toBe(true);
+    expect(sharedConfig.has!("other[]")).toBe(false);
+    expect(sharedConfig.load!('user["1"]')).toBe(value);
+
+    restore();
+    expect(sharedConfig.has).toBeUndefined();
+    expect(sharedConfig.load).toBeUndefined();
+  });
+});
diff --git a/packages/start/src/client/spa/initial-data.ts b/packages/start/src/client/spa/initial-data.ts
new file mode 100644
index 000000000..e1a60e8c4
--- /dev/null
+++ b/packages/start/src/client/spa/initial-data.ts
@@ -0,0 +1,25 @@
+import { sharedConfig } from "solid-js";
+
+/**
+ * With `ssr: "data-only"`, the HTML shell streams the query results of the
+ * requested page into `_$HY.r`, which is where hydration keeps serialized
+ * data. The router's `query` already reads that through `sharedConfig.has` and
+ * `sharedConfig.load` on a cache miss, but those are only set while
+ * hydrating. Set them for the first render so the queries take the streamed
+ * results instead of fetching them again.
+ *
+ * Returns a function that puts `sharedConfig` back once the first render has
+ * made its queries.
+ */
+export function seedInitialData(): (() => void) | undefined {
+  const records = (globalThis as { _$HY?: { r?: Record<string, unknown> } })._$HY?.r;
+  if (!records) return;
+
+  const { has, load } = sharedConfig;
+  sharedConfig.has = key => key in records;
+  sharedConfig.load = key => records[key];
+  return () => {
+    sharedConfig.has = has;
+    sharedConfig.load = load;
+  };
+}
diff --git a/packages/start/src/server/handler.ts b/packages/start/src/server/handler.ts
index 01714c1ac..bb1d443a5 100644
--- a/packages/start/src/server/handler.ts
+++ b/packages/start/src/server/handler.ts
@@ -70,7 +70,7 @@ export function createBaseHandler(
         // @ts-ignore
         if (resolvedOptions.nonce) context.nonce = resolvedOptions.nonce;
 
-        if (mode === "sync" || !import.meta.env.START_SSR) {
+        if (mode === "sync" || (!import.meta.env.START_SSR && !import.meta.env.START_SSR_DATA)) {
           const html = renderToString(() => {
             (sharedConfig.context as any).event = context;
             return fn(context);
diff --git a/packages/start/src/server/spa/StartServer.tsx b/packages/start/src/server/spa/StartServer.tsx
index 1173e2afe..2c49a887e 100644
--- a/packages/start/src/server/spa/StartServer.tsx
+++ b/packages/start/src/server/spa/StartServer.tsx
@@ -1,10 +1,11 @@
 // @refresh skip
 // @ts-ignore
 import type { Component } from "solid-js";
-import { NoHydration, getRequestEvent, ssr } from "solid-js/web";
+import { Hydration, HydrationScript, NoHydration, getRequestEvent, ssr } from "solid-js/web";
 import { TopErrorBoundary } from "../../shared/ErrorBoundary";
 import { renderAsset } from "../renderAsset";
 import type { DocumentComponentProps, PageEvent } from "../types";
+import { InitialData } from "./initial-data";
 
 const docType = ssr("<!DOCTYPE html>");
 
@@ -21,10 +22,27 @@ export function StartServer(props: { document: Component<DocumentComponentProps>
       {docType as unknown as any}
       <TopErrorBoundary>
         <props.document
-          assets={<>{context.assets.map((m: any) => renderAsset(m))}</>}
+          assets={
+            <>
+              {import.meta.env.START_SSR_DATA && (
+                // Defines `_$HY.r` for the streamed data. Nothing hydrates, so
+                // it doesn't need to capture events for replay. The client
+                // types don't list `eventNames`, the server implementation
+                // takes it.
+                // @ts-ignore
+                <HydrationScript eventNames={[]} />
+              )}
+              {context.assets.map((m: any) => renderAsset(m))}
+            </>
+          }
           scripts={
             nonce ? (
               <>
+                {import.meta.env.START_SSR_DATA && (
+                  <Hydration>
+                    <InitialData />
+                  </Hydration>
+                )}
                 <script
                   nonce={nonce}
                   innerHTML={`window.manifest = ${JSON.stringify(context.manifest)}`}
@@ -40,6 +58,11 @@ export function StartServer(props: { document: Component<DocumentComponentProps>
               </>
             ) : (
               <>
+                {import.meta.env.START_SSR_DATA && (
+                  <Hydration>
+                    <InitialData />
+                  </Hydration>
+                )}
                 <script innerHTML={`window.manifest = ${JSON.stringify(context.manifest)}`} />
                 <script
                   type="module"
diff --git a/packages/start/src/server/spa/handler.ts b/packages/start/src/server/spa/handler.ts
index bb0212b58..f76ee6803 100644
--- a/packages/start/src/server/spa/handler.ts
+++ b/packages/start/src/server/spa/handler.ts
@@ -1,5 +1,6 @@
 import { createBaseHandler } from "../handler";
 import { FetchEvent, HandlerOptions, PageEvent } from "../types";
+import { loadInitialData } from "./initial-data";
 
 /**
  *
@@ -15,6 +16,7 @@ export function createHandler(
 
 export async function createPageEvent(ctx: FetchEvent) {
   const clientManifest = import.meta.env.MANIFEST["client"]!;
+  ctx.response.headers.set("Content-Type", "text/html");
   const pageEvent: PageEvent = Object.assign(ctx, {
     manifest: await clientManifest.json(),
     assets: [...(await clientManifest.inputs[clientManifest.handler]!.assets())],
@@ -26,5 +28,7 @@ export async function createPageEvent(ctx: FetchEvent) {
     $islands: new Set<string>()
   });
 
+  if (import.meta.env.START_SSR_DATA) await loadInitialData(pageEvent);
+
   return pageEvent;
 }
diff --git a/packages/start/src/server/spa/index.tsx b/packages/start/src/server/spa/index.tsx
index 13c2071a4..aa567d90e 100644
--- a/packages/start/src/server/spa/index.tsx
+++ b/packages/start/src/server/spa/index.tsx
@@ -2,4 +2,7 @@
 export * from "../types";
 export { StartServer } from "./StartServer";
 export { createHandler } from "./handler";
+import { getServerFunctionMeta as getServerFunctionMeta_ } from "../../shared/serverFunction";
 
+/** @deprecated */
+export const getServerFunctionMeta = getServerFunctionMeta_;
diff --git a/packages/start/src/server/spa/initial-data.spec.ts b/packages/start/src/server/spa/initial-data.spec.ts
new file mode 100644
index 000000000..0d6da8739
--- /dev/null
+++ b/packages/start/src/server/spa/initial-data.spec.ts
@@ -0,0 +1,165 @@
+import { sharedConfig } from "solid-js";
+import { getRequestEvent } from "solid-js/web";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { PageEvent } from "../types";
+import { InitialData, loadInitialData } from "./initial-data";
+
+vi.mock("solid-js/web", async () => {
+  const { sharedConfig } = await import("solid-js");
+  return {
+    renderToString: (fn: () => unknown) => {
+      sharedConfig.context = {} as any;
+      try {
+        return fn();
+      } finally {
+        sharedConfig.context = undefined;
+      }
+    },
+    getRequestEvent: vi.fn()
+  };
+});
+
+vi.mock("../../router/FileRoutes", () => ({
+  createRoutes: () => []
+}));
+
+// Stands in for the router: in data-only mode it records each query call in
+// `event.router.data`, the way `query` does.
+let queries: Record<string, () => unknown> = {};
+let currentEvent: PageEvent;
+vi.mock("#start/app", () => ({
+  default: () => {
+    const router = (currentEvent as any).router;
+    if (!router.dataOnly) return;
+    router.data ||= {};
+    for (const key in queries) router.data[key] = queries[key]!();
+  }
+}));
+
+function createEvent(): PageEvent {
+  return {
+    request: new Request("http://localhost/page"),
+    response: { headers: new Headers() }
+  } as unknown as PageEvent;
+}
+
+function serializeInitialData(event: PageEvent, async = true) {
+  const serialize = vi.fn();
+  vi.mocked(getRequestEvent).mockReturnValue(event);
+  sharedConfig.context = { async, serialize } as any;
+  try {
+    InitialData();
+  } finally {
+    sharedConfig.context = undefined;
+  }
+  return Object.fromEntries(
+    serialize.mock.calls.map(([key, value]) => [key, value as Promise<unknown>])
+  );
+}
+
+describe("ssr: data-only initial data", () => {
+  beforeEach(() => {
+    queries = {};
+    currentEvent = createEvent();
+  });
+
+  it("streams the result of each query the page's preloads made", async () => {
+    queries = {
+      'user["1"]': () => Promise.resolve({ id: 1 }),
+      "list[]": () => Promise.resolve([1, 2])
+    };
+    await loadInitialData(currentEvent);
+
+    const data = serializeInitialData(currentEvent);
+    expect(Object.keys(data)).toEqual(['user["1"]', "list[]"]);
+    await expect(data['user["1"]']).resolves.toEqual({ id: 1 });
+    await expect(data["list[]"]).resolves.toEqual([1, 2]);
+  });
+
+  it("leaves the router out of data-only mode afterwards", async () => {
+    queries = { "a[]": () => Promise.resolve(1) };
+    await loadInitialData(currentEvent);
+    expect((currentEvent as any).router.dataOnly).toBeUndefined();
+    expect((currentEvent as any).router.data).toBeUndefined();
+  });
+
+  it("skips queries the router left out", async () => {
+    queries = { "a[]": () => undefined, "b[]": () => Promise.resolve(2) };
+    await loadInitialData(currentEvent);
+    expect(Object.keys(serializeInitialData(currentEvent))).toEqual(["b[]"]);
+  });
+
+  it("sends the body of a json() response and keeps its headers except the body ones", async () => {
+    queries = {
+      "a[]": () => {
+        const response = new Response(null, {
+          headers: {
+            "content-type": "application/json",
+            "set-cookie": "a=1",
+            "x-custom": "yes"
+          }
+        });
+        (response as any).customBody = () => ({ ok: true });
+        return Promise.resolve(response);
+      }
+    };
+    currentEvent.response.headers.set("content-type", "text/html");
+    currentEvent.response.headers.append("set-cookie", "b=2");
+    await loadInitialData(currentEvent);
+
+    await expect(serializeInitialData(currentEvent)["a[]"]).resolves.toEqual({ ok: true });
+    expect(currentEvent.response.headers.get("content-type")).toBe("text/html");
+    expect(currentEvent.response.headers.getSetCookie()).toEqual(["b=2", "a=1"]);
+    expect(currentEvent.response.headers.get("x-custom")).toBe("yes");
+  });
+
+  it("turns a returned redirect into a redirect of the page", async () => {
+    queries = {
+      "a[]": () =>
+        Promise.resolve(new Response(null, { status: 307, headers: { Location: "/login" } }))
+    };
+    await loadInitialData(currentEvent);
+
+    await expect(serializeInitialData(currentEvent)["a[]"]).resolves.toBeUndefined();
+    expect(currentEvent.response.headers.get("Location")).toBe("/login");
+    expect(currentEvent.response.status).toBe(307);
+  });
+
+  it("does not report a thrown redirect as an error", async () => {
+    queries = {
+      "a[]": () => Promise.reject(new Response(null, { status: 302, headers: { Location: "/" } }))
+    };
+    await loadInitialData(currentEvent);
+
+    await expect(serializeInitialData(currentEvent)["a[]"]).resolves.toBeUndefined();
+    expect(currentEvent.response.headers.get("Location")).toBe("/");
+  });
+
+  it("streams a failed query as a rejection", async () => {
+    const error = new Error("boom");
+    queries = { "a[]": () => Promise.reject(error) };
+    await loadInitialData(currentEvent);
+
+    await expect(serializeInitialData(currentEvent)["a[]"]).rejects.toBe(error);
+  });
+
+  it("sends nothing from a render that can't stream", async () => {
+    queries = { "a[]": () => Promise.resolve(1) };
+    await loadInitialData(currentEvent);
+    expect(serializeInitialData(currentEvent, false)).toEqual({});
+  });
+
+  it("sends nothing when the root can't render on the server", async () => {
+    const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
+    queries = {
+      "a[]": () => {
+        throw new Error("window is not defined");
+      }
+    };
+    await loadInitialData(currentEvent);
+
+    expect(consoleError).toHaveBeenCalled();
+    expect(serializeInitialData(currentEvent)).toEqual({});
+  });
+});
diff --git a/packages/start/src/server/spa/initial-data.ts b/packages/start/src/server/spa/initial-data.ts
new file mode 100644
index 000000000..2dec317e2
--- /dev/null
+++ b/packages/start/src/server/spa/initial-data.ts
@@ -0,0 +1,96 @@
+import { sharedConfig } from "solid-js";
+import { getRequestEvent, renderToString } from "solid-js/web";
+
+import { createRoutes } from "../../router/FileRoutes";
+import type { PageEvent } from "../types";
+
+const BODY_HEADERS = new Set(["content-type", "content-length", "content-encoding"]);
+const initialData = new WeakMap<PageEvent, [key: string, value: Promise<unknown>][]>();
+let App: ((props: {}) => unknown) | undefined;
+
+/**
+ * Runs the route `preload`s for the requested page and keeps the promises of
+ * their queries, so the HTML shell can stream the results to the client.
+ *
+ * This is the same pass single-flight mutations use: with
+ * `event.router.dataOnly` set, the router runs the matched routes' `preload`s
+ * without rendering any page, and `query` stores each call in
+ * `event.router.data`. In SPA builds the server routes have no page components
+ * at all, only their `preload`s.
+ */
+export async function loadInitialData(event: PageEvent): Promise<void> {
+  // @ts-ignore
+  App || (App = (await import("#start/app")).default);
+  const router = (event as any).router || ((event as any).router = {});
+  event.routes = createRoutes();
+  router.dataOnly = true;
+  try {
+    renderToString(() => {
+      (sharedConfig.context as any).event = event;
+      return App!({});
+    });
+  } catch (error) {
+    // The root is written for the browser in SPA mode. If it can't render on
+    // the server, the client fetches its data as usual.
+    console.error(error);
+  }
+  const data: Record<string, unknown> | undefined = router.data;
+  delete router.dataOnly;
+  delete router.data;
+  if (!data) return;
+
+  const entries: [string, Promise<unknown>][] = [];
+  for (const key in data) {
+    if (data[key] === undefined) continue;
+    const promise = Promise.resolve(data[key]).then(
+      value => handleResponse(event, value),
+      async error => {
+        const value = await handleResponse(event, error);
+        // A thrown redirect ends the page, so there is no error to show.
+        if (!event.response.headers.has("Location")) throw value;
+      }
+    );
+    // Serialization reads the rejection; until the shell renders, nothing does.
+    promise.catch(() => {});
+    entries.push([key, promise]);
+  }
+  initialData.set(event, entries);
+}
+
+/**
+ * Streams the query results collected by `loadInitialData` into `_$HY.r`,
+ * where the router's `query` looks for serialized data. It has to render under
+ * `<Hydration>`, because Solid skips serialization inside `<NoHydration>`.
+ */
+export function InitialData() {
+  const context = sharedConfig.context as any;
+  // Only a streamed render can send results that settle after the shell.
+  if (!context?.async) return null;
+  const entries = initialData.get(getRequestEvent() as PageEvent);
+  if (entries) {
+    for (const [key, value] of entries) context.serialize(key, value);
+  }
+  return null;
+}
+
+/**
+ * `query` normally applies a returned `Response` itself, but it skips that in
+ * data-only mode. Apply it here the same way: copy its headers to the page
+ * response, turn a `Location` into a redirect of the page, and send the body
+ * of a `json()` response instead of the response. The body headers describe
+ * the query's response, not the page, so they stay behind.
+ */
+async function handleResponse(event: PageEvent, value: unknown): Promise<unknown> {
+  if (!(value instanceof Response)) return value;
+  for (const [key, header] of value.headers) {
+    if (BODY_HEADERS.has(key)) continue;
+    if (key === "set-cookie") event.response.headers.append(key, header);
+    else event.response.headers.set(key, header);
+  }
+  if (value.headers.has("Location")) {
+    event.response.status = value.status;
+    return undefined;
+  }
+  const customBody = (value as Response & { customBody?: () => unknown }).customBody;
+  return customBody ? await customBody() : value;
+}