@tonyclaw/llm-inspector 1.10.0 → 1.11.0

package/.output/server/_ssr/index.mjs

@@ -1,20 +1,22 @@
+import { c as createMemoryHistory } from "../_libs/tanstack__history.mjs";
+import { a as rootRouteId, o as getNormalizedURL, p as getOrigin, q as attachRouterServerSsrUtils, u as defineHandlerCallback, v as createSerializationAdapter, w as createRawStreamRPCPlugin, i as isNotFound, b as isRedirect, x as isResolvedRedirect, y as mergeHeaders, z as executeRewriteInput, A as defaultSerovalPlugins, C as makeSerovalPlugin } from "../_libs/tanstack__router-core.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { H as H3Event, t as toResponse } from "../_libs/h3-v2.mjs";
-import { y as resolveManifestAssetLink, u as resolveManifestCssLink, k as rootRouteId, z as getNormalizedURL, A as getOrigin, C as normalizeSsrResponse, D as attachRouterServerSsrUtils, E as defineHandlerCallback, F as createSerializationAdapter, G as createRawStreamRPCPlugin, i as invariant, g as isNotFound, m as isRedirect, H as isResolvedRedirect, I as replaceSsrResponse, J as mergeHeaders, K as executeRewriteInput, L as stripSsrResponseBody, M as defaultSerovalPlugins, N as makeSerovalPlugin, s as getScriptPreloadAttrs, O as getStylesheetHref, P as isSsrResponse } from "../_libs/tanstack__router-core.mjs";
-import { i as iu, P as Pu, s as su } from "../_libs/seroval.mjs";
-import { c as createMemoryHistory } from "../_libs/tanstack__history.mjs";
+import { i as invariant } from "../_libs/tiny-invariant.mjs";
+import { a as au, I as Iu, o as ou } from "../_libs/seroval.mjs";
 import { j as jsxRuntimeExports } from "../_libs/react.mjs";
 import { r as renderRouterToStream, R as RouterProvider } from "../_libs/tanstack__react-router.mjs";
+import "../_libs/cookie-es.mjs";
+import "../_libs/seroval-plugins.mjs";
+import "node:stream/web";
+import "node:stream";
 import "../_libs/rou3.mjs";
 import "../_libs/srvx.mjs";
 import "node:http";
-import "node:stream";
 import "node:stream/promises";
 import "node:https";
 import "node:http2";
-import "../_libs/cookie-es.mjs";
-import "../_libs/seroval-plugins.mjs";
-import "node:stream/web";
+import "../_libs/tiny-warning.mjs";
 import "../_libs/react-dom.mjs";
 import "util";
 import "async_hooks";
@@ -24,108 +26,20 @@ import "../_libs/isbot.mjs";
 function StartServer(props) {
   return /* @__PURE__ */ jsxRuntimeExports.jsx(RouterProvider, { router: props.router });
 }
-var defaultStreamHandler = defineHandlerCallback(({ request, router, responseHeaders }) => renderRouterToStream({
-  request,
-  router,
-  responseHeaders,
-  children: /* @__PURE__ */ jsxRuntimeExports.jsx(StartServer, { router })
-}));
-var GLOBAL_EVENT_STORAGE_KEY = /* @__PURE__ */ Symbol.for("tanstack-start:event-storage");
-var globalObj$1 = globalThis;
-if (!globalObj$1[GLOBAL_EVENT_STORAGE_KEY]) globalObj$1[GLOBAL_EVENT_STORAGE_KEY] = new AsyncLocalStorage();
-var eventStorage = globalObj$1[GLOBAL_EVENT_STORAGE_KEY];
-function isPromiseLike(value) {
-  return typeof value.then === "function";
-}
-function getSetCookieValues(headers) {
-  const headersWithSetCookie = headers;
-  if (typeof headersWithSetCookie.getSetCookie === "function") return headersWithSetCookie.getSetCookie();
-  const value = headers.get("set-cookie");
-  return value ? [value] : [];
-}
-function mergeEventResponseHeaders(response, event) {
-  if (response.ok) return;
-  const eventSetCookies = getSetCookieValues(event.res.headers);
-  if (eventSetCookies.length === 0) return;
-  const responseSetCookies = getSetCookieValues(response.headers);
-  response.headers.delete("set-cookie");
-  for (const cookie of responseSetCookies) response.headers.append("set-cookie", cookie);
-  for (const cookie of eventSetCookies) response.headers.append("set-cookie", cookie);
-}
-function attachResponseHeaders(value, event) {
-  if (isPromiseLike(value)) return value.then((resolved) => {
-    if (resolved instanceof Response) mergeEventResponseHeaders(resolved, event);
-    return resolved;
-  });
-  if (value instanceof Response) mergeEventResponseHeaders(value, event);
-  return value;
-}
-function requestHandler(handler) {
-  return (request, requestOpts) => {
-    let h3Event;
-    try {
-      h3Event = new H3Event(request);
-    } catch (error) {
-      if (error instanceof URIError) return new Response(null, {
-        status: 400,
-        statusText: "Bad Request"
-      });
-      throw error;
-    }
-    return toResponse(attachResponseHeaders(eventStorage.run({ h3Event }, () => handler(request, requestOpts)), h3Event), h3Event);
-  };
-}
-function getH3Event() {
-  const event = eventStorage.getStore();
-  if (!event) throw new Error(`No StartEvent found in AsyncLocalStorage. Make sure you are using the function within the server runtime.`);
-  return event.h3Event;
-}
-function getResponse() {
-  return getH3Event().res;
-}
-var HEADERS = { TSS_SHELL: "X-TSS_SHELL" };
-async function getStartManifest(matchedRoutes) {
-  const { tsrStartManifest } = await import("../_tanstack-start-manifest_v-DFoSjBkb.mjs");
-  const startManifest = tsrStartManifest();
-  let routes = startManifest.routes;
-  routes[rootRouteId];
-  const manifestRoutes = {};
-  for (const k in routes) {
-    const v = routes[k];
-    const result = {};
-    if (v.preloads && v.preloads.length > 0) result.preloads = v.preloads;
-    if (v.scripts && v.scripts.length > 0) result.scripts = v.scripts;
-    if (v.css?.length) result.css = v.css;
-    if (result.preloads || result.scripts || result.css) manifestRoutes[k] = result;
-  }
-  return {
-    ...startManifest.scriptFormat ? { scriptFormat: startManifest.scriptFormat } : {},
-    ...startManifest.inlineCss ? { inlineCss: startManifest.inlineCss } : {},
-    routes: manifestRoutes
-  };
-}
-const manifest = {};
-async function getServerFnById(id, access) {
-  const serverFnInfo = manifest[id];
-  if (!serverFnInfo) {
-    throw new Error("Server function info not found for " + id);
-  }
-  const fnModule = serverFnInfo.module ?? await serverFnInfo.importer();
-  if (!fnModule) {
-    throw new Error("Server function module not resolved for " + id);
-  }
-  const action = fnModule[serverFnInfo.functionName];
-  if (!action) {
-    throw new Error("Server function module export not resolved for serverFn ID: " + id);
-  }
-  return action;
-}
-var TSS_FORMDATA_CONTEXT = "__TSS_CONTEXT";
-var TSS_SERVER_FUNCTION = /* @__PURE__ */ Symbol.for("TSS_SERVER_FUNCTION");
-var X_TSS_SERIALIZED = "x-tss-serialized";
-var X_TSS_RAW_RESPONSE = "x-tss-raw";
-var TSS_CONTENT_TYPE_FRAMED = "application/x-tss-framed";
-var FrameType = {
+const defaultStreamHandler = defineHandlerCallback(
+  ({ request, router, responseHeaders }) => renderRouterToStream({
+    request,
+    router,
+    responseHeaders,
+    children: /* @__PURE__ */ jsxRuntimeExports.jsx(StartServer, { router })
+  })
+);
+const TSS_FORMDATA_CONTEXT = "__TSS_CONTEXT";
+const TSS_SERVER_FUNCTION = /* @__PURE__ */ Symbol.for("TSS_SERVER_FUNCTION");
+const X_TSS_SERIALIZED = "x-tss-serialized";
+const X_TSS_RAW_RESPONSE = "x-tss-raw";
+const TSS_CONTENT_TYPE_FRAMED = "application/x-tss-framed";
+const FrameType = {
   /** Seroval JSON chunk (NDJSON line) */
   JSON: 0,
   /** Raw stream data chunk */
@@ -135,47 +49,66 @@ var FrameType = {
   /** Raw stream error */
   ERROR: 3
 };
-var FRAME_HEADER_SIZE = 9;
-var TSS_CONTENT_TYPE_FRAMED_VERSIONED = `${TSS_CONTENT_TYPE_FRAMED}; v=1`;
+const FRAME_HEADER_SIZE = 9;
+const TSS_FRAMED_PROTOCOL_VERSION = 1;
+const TSS_CONTENT_TYPE_FRAMED_VERSIONED = `${TSS_CONTENT_TYPE_FRAMED}; v=${TSS_FRAMED_PROTOCOL_VERSION}`;
+const GLOBAL_STORAGE_KEY = /* @__PURE__ */ Symbol.for("tanstack-start:start-storage-context");
+const globalObj$1 = globalThis;
+if (!globalObj$1[GLOBAL_STORAGE_KEY]) {
+  globalObj$1[GLOBAL_STORAGE_KEY] = new AsyncLocalStorage();
+}
+const startStorage = globalObj$1[GLOBAL_STORAGE_KEY];
+async function runWithStartContext(context, fn) {
+  return startStorage.run(context, fn);
+}
+function getStartContext(opts) {
+  const context = startStorage.getStore();
+  if (!context && opts?.throwIfNotFound !== false) {
+    throw new Error(
+      `No Start context found in AsyncLocalStorage. Make sure you are using the function within the server runtime.`
+    );
+  }
+  return context;
+}
+const getStartOptions = () => getStartContext().startOptions;
 function isSafeKey(key) {
   return key !== "__proto__" && key !== "constructor" && key !== "prototype";
 }
 function safeObjectMerge(target, source) {
   const result = /* @__PURE__ */ Object.create(null);
   if (target) {
-    for (const key of Object.keys(target)) if (isSafeKey(key)) result[key] = target[key];
+    for (const key of Object.keys(target)) {
+      if (isSafeKey(key)) result[key] = target[key];
+    }
   }
   if (source && typeof source === "object") {
-    for (const key of Object.keys(source)) if (isSafeKey(key)) result[key] = source[key];
+    for (const key of Object.keys(source)) {
+      if (isSafeKey(key)) result[key] = source[key];
+    }
   }
   return result;
 }
 function createNullProtoObject(source) {
   if (!source) return /* @__PURE__ */ Object.create(null);
   const obj = /* @__PURE__ */ Object.create(null);
-  for (const key of Object.keys(source)) if (isSafeKey(key)) obj[key] = source[key];
+  for (const key of Object.keys(source)) {
+    if (isSafeKey(key)) obj[key] = source[key];
+  }
   return obj;
 }
-var GLOBAL_STORAGE_KEY = /* @__PURE__ */ Symbol.for("tanstack-start:start-storage-context");
-var globalObj = globalThis;
-if (!globalObj[GLOBAL_STORAGE_KEY]) globalObj[GLOBAL_STORAGE_KEY] = new AsyncLocalStorage();
-var startStorage = globalObj[GLOBAL_STORAGE_KEY];
-async function runWithStartContext(context, fn) {
-  return startStorage.run(context, fn);
-}
-function getStartContext(opts) {
-  const context = startStorage.getStore();
-  if (!context && opts?.throwIfNotFound !== false) throw new Error(`No Start context found in AsyncLocalStorage. Make sure you are using the function within the server runtime.`);
-  return context;
-}
-var getStartOptions = () => getStartContext().startOptions;
 function flattenMiddlewares(middlewares, maxDepth = 100) {
   const seen = /* @__PURE__ */ new Set();
   const flattened = [];
   const recurse = (middleware, depth) => {
-    if (depth > maxDepth) throw new Error(`Middleware nesting depth exceeded maximum of ${maxDepth}. Check for circular references.`);
+    if (depth > maxDepth) {
+      throw new Error(
+        `Middleware nesting depth exceeded maximum of ${maxDepth}. Check for circular references.`
+      );
+    }
     middleware.forEach((m) => {
-      if (m.options.middleware) recurse(m.options.middleware, depth + 1);
+      if (m.options.middleware) {
+        recurse(m.options.middleware, depth + 1);
+      }
       if (!seen.has(m)) {
         seen.add(m);
         flattened.push(m);
@@ -185,88 +118,119 @@ function flattenMiddlewares(middlewares, maxDepth = 100) {
   recurse(middlewares, 0);
   return flattened;
 }
-var createMiddleware = (options, __opts) => {
-  const resolvedOptions = {
-    type: "request",
-    ...__opts || options
-  };
-  return {
-    options: resolvedOptions,
-    middleware: (middleware) => {
-      return createMiddleware({}, Object.assign(resolvedOptions, { middleware }));
-    },
-    inputValidator: (inputValidator) => {
-      return createMiddleware({}, Object.assign(resolvedOptions, { inputValidator }));
-    },
-    client: (client) => {
-      return createMiddleware({}, Object.assign(resolvedOptions, { client }));
-    },
-    server: (server2) => {
-      return createMiddleware({}, Object.assign(resolvedOptions, { server: server2 }));
-    }
-  };
-};
-var innerCreateCsrfMiddleware = (opts = {}) => {
-  const middleware = createMiddleware().server(async (ctx) => {
-    const csrfCtx = ctx;
-    if (opts.filter && !await opts.filter(csrfCtx)) return ctx.next();
-    if (await isCsrfRequestAllowed(opts, csrfCtx)) return ctx.next();
-    return getFailureResponse(opts, csrfCtx);
-  });
-  return middleware;
-};
-var createCsrfMiddleware = innerCreateCsrfMiddleware;
-async function isCsrfRequestAllowed(opts, ctx) {
-  const result = await getCsrfRequestValidationResult(opts, ctx);
-  return result === true || result === void 0 && opts.allowRequestsWithoutOriginCheck === true;
+function getDefaultSerovalPlugins() {
+  const start = getStartOptions();
+  const adapters = start?.serializationAdapters;
+  return [
+    ...adapters?.map(makeSerovalPlugin) ?? [],
+    ...defaultSerovalPlugins
+  ];
+}
+const GLOBAL_EVENT_STORAGE_KEY = /* @__PURE__ */ Symbol.for("tanstack-start:event-storage");
+const globalObj = globalThis;
+if (!globalObj[GLOBAL_EVENT_STORAGE_KEY]) {
+  globalObj[GLOBAL_EVENT_STORAGE_KEY] = new AsyncLocalStorage();
+}
+const eventStorage = globalObj[GLOBAL_EVENT_STORAGE_KEY];
+function isPromiseLike(value) {
+  return typeof value.then === "function";
 }
-async function getCsrfRequestValidationResult(opts, ctx) {
-  const fetchSite = ctx.request.headers.get("Sec-Fetch-Site");
-  if (fetchSite !== null) return matchValue(opts.secFetchSite ?? "same-origin", fetchSite, ctx);
-  const origin = ctx.request.headers.get("Origin");
-  if (origin !== null) {
-    if (opts.origin) return matchValue(opts.origin, origin, ctx);
-    return origin === new URL(ctx.request.url).origin;
-  }
-  const referer = ctx.request.headers.get("Referer");
-  if (referer === null || opts.referer === false) return;
-  if (typeof opts.referer === "function") return opts.referer(referer, ctx);
-  if (opts.origin) {
-    const refererOrigin = getOriginFromUrl(referer);
-    return refererOrigin !== void 0 && matchValue(opts.origin, refererOrigin, ctx);
+function getSetCookieValues(headers) {
+  const headersWithSetCookie = headers;
+  if (typeof headersWithSetCookie.getSetCookie === "function") {
+    return headersWithSetCookie.getSetCookie();
   }
-  return isRefererSameOrigin(referer, new URL(ctx.request.url).origin);
-}
-async function matchValue(matcher, value, ctx) {
-  if (typeof matcher === "function") return matcher(value, ctx);
-  if (Array.isArray(matcher)) return matcher.includes(value);
-  return value === matcher;
+  const value = headers.get("set-cookie");
+  return value ? [value] : [];
 }
-function getOriginFromUrl(url) {
-  try {
-    return new URL(url).origin;
-  } catch {
+function mergeEventResponseHeaders(response, event) {
+  if (response.ok) {
+    return;
+  }
+  const eventSetCookies = getSetCookieValues(event.res.headers);
+  if (eventSetCookies.length === 0) {
     return;
   }
+  const responseSetCookies = getSetCookieValues(response.headers);
+  response.headers.delete("set-cookie");
+  for (const cookie of responseSetCookies) {
+    response.headers.append("set-cookie", cookie);
+  }
+  for (const cookie of eventSetCookies) {
+    response.headers.append("set-cookie", cookie);
+  }
 }
-function isRefererSameOrigin(referer, requestOrigin) {
-  if (referer === requestOrigin) return true;
-  if (!referer.startsWith(requestOrigin)) return false;
-  if (referer.length === requestOrigin.length) return true;
-  const code = referer.charCodeAt(requestOrigin.length);
-  return code === 47 || code === 63 || code === 35;
+function attachResponseHeaders(value, event) {
+  if (isPromiseLike(value)) {
+    return value.then((resolved) => {
+      if (resolved instanceof Response) {
+        mergeEventResponseHeaders(resolved, event);
+      }
+      return resolved;
+    });
+  }
+  if (value instanceof Response) {
+    mergeEventResponseHeaders(value, event);
+  }
+  return value;
 }
-async function getFailureResponse(opts, ctx) {
-  if (typeof opts.failureResponse === "function") return opts.failureResponse(ctx);
-  return opts.failureResponse?.clone() ?? new Response("Forbidden", {
-    status: 403
-  });
+function requestHandler(handler) {
+  return (request, requestOpts) => {
+    const h3Event = new H3Event(request);
+    const response = eventStorage.run(
+      { h3Event },
+      () => handler(request, requestOpts)
+    );
+    return toResponse(attachResponseHeaders(response, h3Event), h3Event);
+  };
 }
-function getDefaultSerovalPlugins() {
-  return [...getStartOptions()?.serializationAdapters?.map(makeSerovalPlugin) ?? [], ...defaultSerovalPlugins];
+function getH3Event() {
+  const event = eventStorage.getStore();
+  if (!event) {
+    throw new Error(
+      `No StartEvent found in AsyncLocalStorage. Make sure you are using the function within the server runtime.`
+    );
+  }
+  return event.h3Event;
 }
-var textEncoder = new TextEncoder();
-var EMPTY_PAYLOAD = new Uint8Array(0);
+function getResponse() {
+  const event = getH3Event();
+  return event.res;
+}
+async function getStartManifest(matchedRoutes) {
+  const { tsrStartManifest } = await import("../_tanstack-start-manifest_v-Cm2Owszu.mjs");
+  const startManifest = tsrStartManifest();
+  const rootRoute = startManifest.routes[rootRouteId] = startManifest.routes[rootRouteId] || {};
+  rootRoute.assets = rootRoute.assets || [];
+  let injectedHeadScripts;
+  const manifest2 = {
+    routes: Object.fromEntries(
+      Object.entries(startManifest.routes).flatMap(([k, v]) => {
+        const result = {};
+        let hasData = false;
+        if (v.preloads && v.preloads.length > 0) {
+          result["preloads"] = v.preloads;
+          hasData = true;
+        }
+        if (v.assets && v.assets.length > 0) {
+          result["assets"] = v.assets;
+          hasData = true;
+        }
+        if (!hasData) {
+          return [];
+        }
+        return [[k, result]];
+      })
+    )
+  };
+  return {
+    manifest: manifest2,
+    clientEntry: startManifest.clientEntry,
+    injectedHeadScripts
+  };
+}
+const textEncoder$1 = new TextEncoder();
+const EMPTY_PAYLOAD = new Uint8Array(0);
 function encodeFrame(type, streamId, payload) {
   const frame = new Uint8Array(FRAME_HEADER_SIZE + payload.length);
   frame[0] = type;
@@ -282,7 +246,7 @@ function encodeFrame(type, streamId, payload) {
   return frame;
 }
 function encodeJSONFrame(json) {
-  return encodeFrame(FrameType.JSON, 0, textEncoder.encode(json));
+  return encodeFrame(FrameType.JSON, 0, textEncoder$1.encode(json));
 }
 function encodeChunkFrame(streamId, chunk) {
   return encodeFrame(FrameType.CHUNK, streamId, chunk);
@@ -292,151 +256,162 @@ function encodeEndFrame(streamId) {
 }
 function encodeErrorFrame(streamId, error) {
   const message = error instanceof Error ? error.message : String(error ?? "Unknown error");
-  return encodeFrame(FrameType.ERROR, streamId, textEncoder.encode(message));
+  return encodeFrame(FrameType.ERROR, streamId, textEncoder$1.encode(message));
 }
-function createMultiplexedStream(jsonStream, rawStreams, lateStreamSource) {
-  let controller;
+function createMultiplexedStream(jsonStream, rawStreams) {
+  let activePumps = 1 + rawStreams.size;
+  let controllerRef = null;
   let cancelled = false;
-  const readers = [];
-  const enqueue = (frame) => {
-    if (cancelled) return false;
+  const cancelReaders = [];
+  const safeEnqueue = (chunk) => {
+    if (cancelled || !controllerRef) return;
     try {
-      controller.enqueue(frame);
-      return true;
+      controllerRef.enqueue(chunk);
     } catch {
-      return false;
     }
   };
-  const errorOutput = (error) => {
-    if (cancelled) return;
-    cancelled = true;
+  const safeError = (err) => {
+    if (cancelled || !controllerRef) return;
     try {
-      controller.error(error);
+      controllerRef.error(err);
     } catch {
     }
-    for (const reader of readers) reader.cancel().catch(() => {
-    });
   };
-  async function pumpRawStream(streamId, stream) {
-    const reader = stream.getReader();
-    readers.push(reader);
+  const safeClose = () => {
+    if (cancelled || !controllerRef) return;
     try {
-      while (!cancelled) {
-        const { done, value } = await reader.read();
-        if (done) {
-          enqueue(encodeEndFrame(streamId));
-          return;
-        }
-        if (!enqueue(encodeChunkFrame(streamId, value))) return;
-      }
-    } catch (error) {
-      enqueue(encodeErrorFrame(streamId, error));
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  async function pumpJSON() {
-    const reader = jsonStream.getReader();
-    readers.push(reader);
-    try {
-      while (!cancelled) {
-        const { done, value } = await reader.read();
-        if (done) return;
-        if (!enqueue(encodeJSONFrame(value))) return;
-      }
-    } catch (error) {
-      errorOutput(error);
-      throw error;
-    } finally {
-      reader.releaseLock();
+      controllerRef.close();
+    } catch {
     }
-  }
-  async function pumpLateStreams() {
-    if (!lateStreamSource) return [];
-    const lateStreamPumps = [];
-    const reader = lateStreamSource.getReader();
-    readers.push(reader);
-    try {
-      while (!cancelled) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        lateStreamPumps.push(pumpRawStream(value.id, value.stream));
-      }
-    } finally {
-      reader.releaseLock();
+  };
+  const checkComplete = () => {
+    activePumps--;
+    if (activePumps === 0) {
+      safeClose();
     }
-    return lateStreamPumps;
-  }
+  };
   return new ReadableStream({
-    async start(ctrl) {
-      controller = ctrl;
-      const pumps = [pumpJSON()];
-      for (const [streamId, stream] of rawStreams) pumps.push(pumpRawStream(streamId, stream));
-      if (lateStreamSource) pumps.push(pumpLateStreams());
-      try {
-        const latePumps = (await Promise.all(pumps)).find(Array.isArray);
-        if (latePumps && latePumps.length > 0) await Promise.all(latePumps);
-        if (!cancelled) try {
-          controller.close();
-        } catch {
+    start(controller) {
+      controllerRef = controller;
+      cancelReaders.length = 0;
+      const pumpJSON = async () => {
+        const reader = jsonStream.getReader();
+        cancelReaders.push(() => {
+          reader.cancel().catch(() => {
+          });
+        });
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (cancelled) break;
+            if (done) break;
+            safeEnqueue(encodeJSONFrame(value));
+          }
+        } catch (error) {
+          safeError(error);
+        } finally {
+          reader.releaseLock();
+          checkComplete();
+        }
+      };
+      const pumpRawStream = async (streamId, stream) => {
+        const reader = stream.getReader();
+        cancelReaders.push(() => {
+          reader.cancel().catch(() => {
+          });
+        });
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (cancelled) break;
+            if (done) {
+              safeEnqueue(encodeEndFrame(streamId));
+              break;
+            }
+            safeEnqueue(encodeChunkFrame(streamId, value));
+          }
+        } catch (error) {
+          safeEnqueue(encodeErrorFrame(streamId, error));
+        } finally {
+          reader.releaseLock();
+          checkComplete();
         }
-      } catch {
+      };
+      pumpJSON();
+      for (const [streamId, stream] of rawStreams) {
+        pumpRawStream(streamId, stream);
       }
     },
     cancel() {
       cancelled = true;
-      for (const reader of readers) reader.cancel().catch(() => {
-      });
-      readers.length = 0;
+      controllerRef = null;
+      for (const cancelReader of cancelReaders) {
+        cancelReader();
+      }
+      cancelReaders.length = 0;
     }
   });
 }
-var serovalPlugins = void 0;
-var FORM_DATA_CONTENT_TYPES = ["multipart/form-data", "application/x-www-form-urlencoded"];
-var MAX_PAYLOAD_SIZE = 1e6;
-var handleServerAction = async ({ request, context, serverFnId }) => {
-  const methodUpper = request.method.toUpperCase();
+const manifest = {};
+async function getServerFnById(id) {
+  const serverFnInfo = manifest[id];
+  if (!serverFnInfo) {
+    throw new Error("Server function info not found for " + id);
+  }
+  const fnModule = await serverFnInfo.importer();
+  if (!fnModule) {
+    console.info("serverFnInfo", serverFnInfo);
+    throw new Error("Server function module not resolved for " + id);
+  }
+  const action = fnModule[serverFnInfo.functionName];
+  if (!action) {
+    console.info("serverFnInfo", serverFnInfo);
+    console.info("fnModule", fnModule);
+    throw new Error(
+      `Server function module export not resolved for serverFn ID: ${id}`
+    );
+  }
+  return action;
+}
+let serovalPlugins = void 0;
+const textEncoder = new TextEncoder();
+const FORM_DATA_CONTENT_TYPES = [
+  "multipart/form-data",
+  "application/x-www-form-urlencoded"
+];
+const MAX_PAYLOAD_SIZE = 1e6;
+const handleServerAction = async ({
+  request,
+  context,
+  serverFnId
+}) => {
+  const method = request.method;
+  const methodUpper = method.toUpperCase();
+  const methodLower = method.toLowerCase();
   const url = new URL(request.url);
   const action = await getServerFnById(serverFnId);
-  if (action.method && methodUpper !== action.method) return new Response(`expected ${action.method} method. Got ${methodUpper}`, {
-    status: 405,
-    headers: { Allow: action.method }
-  });
   const isServerFn = request.headers.get("x-tsr-serverFn") === "true";
-  if (!serovalPlugins) serovalPlugins = getDefaultSerovalPlugins();
+  if (!serovalPlugins) {
+    serovalPlugins = getDefaultSerovalPlugins();
+  }
   const contentType = request.headers.get("Content-Type");
   function parsePayload(payload) {
-    return Pu(payload, { plugins: serovalPlugins });
+    const parsedPayload = Iu(payload, { plugins: serovalPlugins });
+    return parsedPayload;
   }
-  return await (async () => {
+  const response = await (async () => {
     try {
       let serializeResult = function(res2) {
         let nonStreamingBody = void 0;
         const alsResponse = getResponse();
         if (res2 !== void 0) {
           const rawStreams = /* @__PURE__ */ new Map();
-          let initialPhase = true;
-          let lateStreamWriter;
-          let lateStreamReadable = void 0;
-          const pendingLateStreams = [];
-          const plugins = [createRawStreamRPCPlugin((id, stream) => {
-            if (initialPhase) {
-              rawStreams.set(id, stream);
-              return;
-            }
-            if (lateStreamWriter) {
-              lateStreamWriter.write({
-                id,
-                stream
-              }).catch(() => {
-              });
-              return;
+          const rawStreamPlugin = createRawStreamRPCPlugin(
+            (id, stream2) => {
+              rawStreams.set(id, stream2);
             }
-            pendingLateStreams.push({
-              id,
-              stream
-            });
-          }), ...serovalPlugins || []];
+          );
+          const plugins = [rawStreamPlugin, ...serovalPlugins || []];
           let done = false;
           const callbacks = {
             onParse: (value) => {
@@ -449,7 +424,7 @@ var handleServerAction = async ({ request, context, serverFnId }) => {
               throw error;
             }
           };
-          iu(res2, {
+          au(res2, {
             refs: /* @__PURE__ */ new Map(),
             plugins,
             onParse(value) {
@@ -462,57 +437,73 @@ var handleServerAction = async ({ request, context, serverFnId }) => {
               callbacks.onError(error);
             }
           });
-          initialPhase = false;
-          if (done && rawStreams.size === 0) return new Response(nonStreamingBody ? JSON.stringify(nonStreamingBody) : void 0, {
-            status: alsResponse.status,
-            statusText: alsResponse.statusText,
-            headers: {
-              "Content-Type": "application/json",
-              [X_TSS_SERIALIZED]: "true"
-            }
-          });
-          const { readable, writable } = new TransformStream();
-          lateStreamReadable = readable;
-          lateStreamWriter = writable.getWriter();
-          for (const registration of pendingLateStreams) lateStreamWriter.write(registration).catch(() => {
-          });
-          pendingLateStreams.length = 0;
-          const multiplexedStream = createMultiplexedStream(new ReadableStream({
+          if (done && rawStreams.size === 0) {
+            return new Response(
+              nonStreamingBody ? JSON.stringify(nonStreamingBody) : void 0,
+              {
+                status: alsResponse.status,
+                statusText: alsResponse.statusText,
+                headers: {
+                  "Content-Type": "application/json",
+                  [X_TSS_SERIALIZED]: "true"
+                }
+              }
+            );
+          }
+          if (rawStreams.size > 0) {
+            const jsonStream = new ReadableStream({
+              start(controller) {
+                callbacks.onParse = (value) => {
+                  controller.enqueue(JSON.stringify(value) + "\n");
+                };
+                callbacks.onDone = () => {
+                  try {
+                    controller.close();
+                  } catch {
+                  }
+                };
+                callbacks.onError = (error) => controller.error(error);
+                if (nonStreamingBody !== void 0) {
+                  callbacks.onParse(nonStreamingBody);
+                }
+              }
+            });
+            const multiplexedStream = createMultiplexedStream(
+              jsonStream,
+              rawStreams
+            );
+            return new Response(multiplexedStream, {
+              status: alsResponse.status,
+              statusText: alsResponse.statusText,
+              headers: {
+                "Content-Type": TSS_CONTENT_TYPE_FRAMED_VERSIONED,
+                [X_TSS_SERIALIZED]: "true"
+              }
+            });
+          }
+          const stream = new ReadableStream({
             start(controller) {
-              callbacks.onParse = (value) => {
-                controller.enqueue(JSON.stringify(value) + "\n");
-              };
+              callbacks.onParse = (value) => controller.enqueue(
+                textEncoder.encode(JSON.stringify(value) + "\n")
+              );
               callbacks.onDone = () => {
                 try {
                   controller.close();
-                } catch {
+                } catch (error) {
+                  controller.error(error);
                 }
-                lateStreamWriter?.close().catch(() => {
-                }).finally(() => {
-                  lateStreamWriter = void 0;
-                });
               };
-              callbacks.onError = (error) => {
-                controller.error(error);
-                lateStreamWriter?.abort(error).catch(() => {
-                }).finally(() => {
-                  lateStreamWriter = void 0;
-                });
-              };
-              if (nonStreamingBody !== void 0) callbacks.onParse(nonStreamingBody);
-              if (done) callbacks.onDone();
-            },
-            cancel() {
-              lateStreamWriter?.abort().catch(() => {
-              });
-              lateStreamWriter = void 0;
+              callbacks.onError = (error) => controller.error(error);
+              if (nonStreamingBody !== void 0) {
+                callbacks.onParse(nonStreamingBody);
+              }
             }
-          }), rawStreams, lateStreamReadable);
-          return new Response(multiplexedStream, {
+          });
+          return new Response(stream, {
             status: alsResponse.status,
             statusText: alsResponse.statusText,
             headers: {
-              "Content-Type": TSS_CONTENT_TYPE_FRAMED_VERSIONED,
+              "Content-Type": "application/x-ndjson",
               [X_TSS_SERIALIZED]: "true"
             }
           });
@@ -523,11 +514,13 @@ var handleServerAction = async ({ request, context, serverFnId }) => {
         });
       };
       let res = await (async () => {
-        if (FORM_DATA_CONTENT_TYPES.some((type) => contentType && contentType.includes(type))) {
-          if (methodUpper === "GET") {
-            if (false) ;
-            invariant();
-          }
+        if (FORM_DATA_CONTENT_TYPES.some(
+          (type) => contentType && contentType.includes(type)
+        )) {
+          invariant(
+            methodLower !== "get",
+            "GET requests with FormData payloads are not supported"
+          );
           const formData = await request.formData();
           const serializedContext = formData.get(TSS_FORMDATA_CONTEXT);
           formData.delete(TSS_FORMDATA_CONTEXT);
@@ -536,54 +529,85 @@ var handleServerAction = async ({ request, context, serverFnId }) => {
             data: formData,
             method: methodUpper
           };
-          if (typeof serializedContext === "string") try {
-            const deserializedContext = Pu(JSON.parse(serializedContext), { plugins: serovalPlugins });
-            if (typeof deserializedContext === "object" && deserializedContext) params.context = safeObjectMerge(deserializedContext, context);
-          } catch (e) {
-            if (false) ;
+          if (typeof serializedContext === "string") {
+            try {
+              const parsedContext = JSON.parse(serializedContext);
+              const deserializedContext = Iu(parsedContext, {
+                plugins: serovalPlugins
+              });
+              if (typeof deserializedContext === "object" && deserializedContext) {
+                params.context = safeObjectMerge(
+                  context,
+                  deserializedContext
+                );
+              }
+            } catch (e) {
+              if (false) ;
+            }
           }
           return await action(params);
         }
-        if (methodUpper === "GET") {
+        if (methodLower === "get") {
           const payloadParam = url.searchParams.get("payload");
-          if (payloadParam && payloadParam.length > MAX_PAYLOAD_SIZE) throw new Error("Payload too large");
+          if (payloadParam && payloadParam.length > MAX_PAYLOAD_SIZE) {
+            throw new Error("Payload too large");
+          }
           const payload2 = payloadParam ? parsePayload(JSON.parse(payloadParam)) : {};
-          payload2.context = safeObjectMerge(payload2.context, context);
+          payload2.context = safeObjectMerge(context, payload2.context);
           payload2.method = methodUpper;
           return await action(payload2);
         }
+        if (methodLower !== "post") {
+          throw new Error("expected POST method");
+        }
         let jsonPayload;
-        if (contentType?.includes("application/json")) jsonPayload = await request.json();
+        if (contentType?.includes("application/json")) {
+          jsonPayload = await request.json();
+        }
         const payload = jsonPayload ? parsePayload(jsonPayload) : {};
         payload.context = safeObjectMerge(payload.context, context);
         payload.method = methodUpper;
         return await action(payload);
       })();
       const unwrapped = res.result || res.error;
-      if (isNotFound(res)) res = isNotFoundResponse(res);
-      if (!isServerFn) return unwrapped;
+      if (isNotFound(res)) {
+        res = isNotFoundResponse(res);
+      }
+      if (!isServerFn) {
+        return unwrapped;
+      }
       if (unwrapped instanceof Response) {
-        if (isRedirect(unwrapped)) return unwrapped;
+        if (isRedirect(unwrapped)) {
+          return unwrapped;
+        }
         unwrapped.headers.set(X_TSS_RAW_RESPONSE, "true");
         return unwrapped;
       }
       return serializeResult(res);
     } catch (error) {
-      if (error instanceof Response) return error;
-      if (isNotFound(error)) return isNotFoundResponse(error);
+      if (error instanceof Response) {
+        return error;
+      }
+      if (isNotFound(error)) {
+        return isNotFoundResponse(error);
+      }
       console.info();
       console.info("Server Fn Error!");
       console.info();
       console.error(error);
       console.info();
-      const serializedError = JSON.stringify(await Promise.resolve(su(error, {
-        refs: /* @__PURE__ */ new Map(),
-        plugins: serovalPlugins
-      })));
-      const response = getResponse();
+      const serializedError = JSON.stringify(
+        await Promise.resolve(
+          ou(error, {
+            refs: /* @__PURE__ */ new Map(),
+            plugins: serovalPlugins
+          })
+        )
+      );
+      const response2 = getResponse();
       return new Response(serializedError, {
-        status: response.status ?? 500,
-        statusText: response.statusText,
+        status: response2.status ?? 500,
+        statusText: response2.statusText,
         headers: {
           "Content-Type": "application/json",
           [X_TSS_SERIALIZED]: "true"
@@ -591,6 +615,7 @@ var handleServerAction = async ({ request, context, serverFnId }) => {
       });
     }
   })();
+  return response;
 };
 function isNotFoundResponse(error) {
   const { headers, ...rest } = error;
@@ -602,534 +627,115 @@ function isNotFoundResponse(error) {
     }
   });
 }
-var LINK_PARAM_TOKEN_RE = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
-var PRELOAD_AS_VALUES = /* @__PURE__ */ new Set([
-  "fetch",
-  "font",
-  "image",
-  "script",
-  "style",
-  "track"
-]);
-function buildLinkParam(name, value) {
-  if (value === void 0) return name;
-  if (LINK_PARAM_TOKEN_RE.test(value)) return `${name}=${value}`;
-  return `${name}=${JSON.stringify(value)}`;
-}
-function serializeEarlyHint(hint) {
-  const parts = [`<${hint.href}>`, buildLinkParam("rel", hint.rel)];
-  if (hint.as) parts.push(buildLinkParam("as", hint.as));
-  if (hint.crossOrigin !== void 0) parts.push(buildLinkParam("crossorigin", hint.crossOrigin || void 0));
-  if (hint.type) parts.push(buildLinkParam("type", hint.type));
-  if (hint.integrity) parts.push(buildLinkParam("integrity", hint.integrity));
-  if (hint.referrerPolicy) parts.push(buildLinkParam("referrerpolicy", hint.referrerPolicy));
-  if (hint.fetchPriority) parts.push(buildLinkParam("fetchpriority", hint.fetchPriority));
-  return parts.join("; ");
-}
-function getStringAttr(attrs, name, fallbackName) {
-  const value = attrs?.[name] ?? (fallbackName ? attrs?.[fallbackName] : void 0);
-  return typeof value === "string" ? value : void 0;
-}
-function getPreloadAs(attrs) {
-  const as = getStringAttr(attrs, "as");
-  return as && PRELOAD_AS_VALUES.has(as) ? as : void 0;
-}
-function addEarlyHintFetchAttrs(hint, attrs) {
-  const crossOrigin = getStringAttr(attrs, "crossOrigin", "crossorigin");
-  const type = getStringAttr(attrs, "type");
-  const integrity = getStringAttr(attrs, "integrity");
-  const referrerPolicy = getStringAttr(attrs, "referrerPolicy", "referrerpolicy");
-  const fetchPriority = getStringAttr(attrs, "fetchPriority", "fetchpriority");
-  if (crossOrigin !== void 0) hint.crossOrigin = crossOrigin;
-  if (type) hint.type = type;
-  if (integrity) hint.integrity = integrity;
-  if (referrerPolicy) hint.referrerPolicy = referrerPolicy;
-  if (fetchPriority) hint.fetchPriority = fetchPriority;
-}
-function linkAttrsToEarlyHint(attrs) {
-  const href = getStringAttr(attrs, "href");
-  const rel = getStringAttr(attrs, "rel");
-  if (!href || !rel) return void 0;
-  const relTokens = rel.split(/\s+/);
-  let hintRel;
-  let hintAs;
-  if (relTokens.includes("modulepreload")) {
-    hintRel = "modulepreload";
-    hintAs = "script";
-  } else if (relTokens.includes("stylesheet")) {
-    hintRel = "preload";
-    hintAs = "style";
-  } else if (relTokens.includes("preload")) {
-    hintAs = getPreloadAs(attrs);
-    if (!hintAs) return void 0;
-    hintRel = "preload";
-  } else if (relTokens.includes("preconnect")) {
-    hintRel = "preconnect";
-    hintAs = void 0;
-  } else if (relTokens.includes("dns-prefetch")) {
-    hintRel = "dns-prefetch";
-    hintAs = void 0;
-  }
-  if (!hintRel) return void 0;
-  const hint = {
-    href,
-    rel: hintRel
-  };
-  if (hintAs) hint.as = hintAs;
-  addEarlyHintFetchAttrs(hint, attrs);
-  return hint;
-}
-function collectStaticHintsFromManifest(manifest2, matchedRoutes) {
-  const hints = [];
-  for (const route of matchedRoutes) {
-    const routeManifest = manifest2.routes[route.id];
-    if (!routeManifest) continue;
-    for (const link of routeManifest.preloads ?? []) {
-      const attrs = getScriptPreloadAttrs(manifest2, link);
-      const hint = {
-        href: attrs.href,
-        rel: attrs.rel,
-        as: "script"
-      };
-      if (attrs.crossOrigin !== void 0) hint.crossOrigin = attrs.crossOrigin;
-      hints.push(hint);
-    }
-    for (const link of routeManifest.css ?? []) {
-      const stylesheetHref = getStylesheetHref(link);
-      if (manifest2.inlineCss?.styles[stylesheetHref] !== void 0) continue;
-      const resolvedLink = resolveManifestCssLink(link);
-      const hint = {
-        href: stylesheetHref,
-        rel: "preload",
-        as: "style"
-      };
-      if (resolvedLink.crossOrigin !== void 0) hint.crossOrigin = resolvedLink.crossOrigin;
-      hints.push(hint);
-    }
-  }
-  return hints;
-}
-function collectDynamicHintsFromMatches(matches) {
-  const hints = [];
-  for (const match of matches) {
-    const links = match.links;
-    if (!Array.isArray(links)) continue;
-    for (const link of links) {
-      const hint = linkAttrsToEarlyHint(link);
-      if (hint) hints.push(hint);
-    }
-  }
-  return hints;
-}
-function createEarlyHintsEvent(opts) {
-  const nextHints = [];
-  const nextLinks = [];
-  for (const hint of opts.hints) {
-    const link = serializeEarlyHint(hint);
-    if (opts.sentLinks.has(link)) continue;
-    opts.sentLinks.add(link);
-    opts.sentHints.push(hint);
-    nextHints.push(hint);
-    nextLinks.push(link);
-  }
-  if (!nextHints.length && opts.phase !== "dynamic") return void 0;
-  return {
-    phase: opts.phase,
-    hints: nextHints,
-    links: nextLinks,
-    allHints: opts.sentHints.slice(),
-    allLinks: Array.from(opts.sentLinks)
-  };
-}
-function createResponseLinkHeaderEntries(opts) {
-  for (const hint of opts.hints) {
-    const link = serializeEarlyHint(hint);
-    if (opts.sentLinks.has(link)) continue;
-    opts.sentLinks.add(link);
-    opts.entries.push({
-      phase: opts.phase,
-      hint,
-      link
-    });
-  }
-}
-function getResponseLinkHeaderEntries(opts) {
-  if (!opts.filter) return opts.entries.map((entry) => entry.link);
-  try {
-    const links = [];
-    for (const entry of opts.entries) if (opts.filter(entry)) links.push(entry.link);
-    return links;
-  } catch (err) {
-    console.error("Error filtering response Link headers:", err);
-    return [];
-  }
-}
-function notifyEarlyHints(phase, event, onEarlyHints) {
-  try {
-    const result = onEarlyHints(event);
-    if (result) Promise.resolve(result).catch((err) => {
-      console.error(`Error sending ${phase} early hints:`, err);
-    });
-  } catch (err) {
-    console.error(`Error sending ${phase} early hints:`, err);
-  }
-}
-function getResponseLinkHeaderFilter(responseLinkHeader) {
-  if (typeof responseLinkHeader !== "object") return;
-  return responseLinkHeader.filter;
-}
-function appendResponseLinkHeaders(opts) {
-  for (const link of getResponseLinkHeaderEntries(opts)) opts.responseHeaders.append("Link", link);
-}
-function collectResponseLinkHeaderEntries(opts) {
-  for (let index = 0; index < opts.event.hints.length; index++) opts.entries.push({
-    phase: opts.phase,
-    hint: opts.event.hints[index],
-    link: opts.event.links[index]
-  });
-}
-function collectEarlyHintsPhase(opts) {
-  const event = opts.onEarlyHints ? createEarlyHintsEvent({
-    phase: opts.phase,
-    hints: opts.hints,
-    sentLinks: opts.sentLinks,
-    sentHints: opts.sentHints
-  }) : void 0;
-  if (event) notifyEarlyHints(opts.phase, event, opts.onEarlyHints);
-  if (!opts.responseLinkHeaderEntries) return;
-  if (event) {
-    collectResponseLinkHeaderEntries({
-      phase: opts.phase,
-      event,
-      entries: opts.responseLinkHeaderEntries
-    });
-    return;
-  }
-  createResponseLinkHeaderEntries({
-    phase: opts.phase,
-    hints: opts.hints,
-    sentLinks: opts.sentLinks,
-    entries: opts.responseLinkHeaderEntries
-  });
-}
-function createEarlyHintsCollector(opts) {
-  if (!opts?.onEarlyHints && !opts?.responseLinkHeader) return;
-  const sentLinks = /* @__PURE__ */ new Set();
-  const sentHints = opts.onEarlyHints ? new Array() : void 0;
-  const responseLinkHeaderEntries = opts.responseLinkHeader ? new Array() : void 0;
-  const responseLinkHeaderFilter = getResponseLinkHeaderFilter(opts.responseLinkHeader);
-  return {
-    collectStatic: ({ manifest: manifest2, matchedRoutes }) => {
-      if (!matchedRoutes?.length) return;
-      collectEarlyHintsPhase({
-        phase: "static",
-        hints: collectStaticHintsFromManifest(manifest2, matchedRoutes),
-        sentLinks,
-        sentHints,
-        onEarlyHints: opts.onEarlyHints,
-        responseLinkHeaderEntries
-      });
-    },
-    collectDynamic: (matches) => {
-      collectEarlyHintsPhase({
-        phase: "dynamic",
-        hints: collectDynamicHintsFromMatches(matches),
-        sentLinks,
-        sentHints,
-        onEarlyHints: opts.onEarlyHints,
-        responseLinkHeaderEntries
-      });
-    },
-    appendResponseHeaders: (headers) => {
-      if (!responseLinkHeaderEntries?.length) return;
-      appendResponseLinkHeaders({
-        responseHeaders: headers,
-        entries: responseLinkHeaderEntries,
-        filter: responseLinkHeaderFilter
-      });
-    }
-  };
-}
-function normalizeTransformAssetResult(result) {
-  if (typeof result === "string") return { href: result };
-  return result;
-}
-function escapeCssString(value) {
-  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\a ").replace(/\r/g, "\\d ").replace(/\f/g, "\\c ");
-}
-async function transformInlineCssTemplate(options) {
-  const { strings, urls } = options.template;
-  if (strings.length !== urls.length + 1) throw new Error(`TanStack Start inlineCss template for ${options.stylesheetHref} is invalid`);
-  let css = strings[0];
-  for (let index = 0; index < urls.length; index++) {
-    const transformed = normalizeTransformAssetResult(await options.transformFn({
-      kind: "css-url",
-      url: urls[index],
-      stylesheetHref: options.stylesheetHref
-    }));
-    css += escapeCssString(transformed.href) + strings[index + 1];
-  }
-  return css;
-}
-async function transformInlineCssStyles(inlineCss, transformFn) {
-  const transformedStyles = {};
-  const transformedEntries = await Promise.all(Object.entries(inlineCss.styles).map(async ([stylesheetHref, css]) => {
-    const template = inlineCss.templates?.[stylesheetHref];
-    return [stylesheetHref, template ? await transformInlineCssTemplate({
-      stylesheetHref,
-      template,
-      transformFn
-    }) : css];
-  }));
-  for (const [stylesheetHref, css] of transformedEntries) transformedStyles[stylesheetHref] = css;
-  return {
-    styles: transformedStyles,
-    ...inlineCss.templates ? { templates: inlineCss.templates } : {}
-  };
-}
-function resolveTransformAssetsCrossOrigin(config, kind) {
-  if (!config) return void 0;
-  if (typeof config === "string") return config;
-  return config[kind];
-}
-function isObjectShorthand(transform) {
-  return "prefix" in transform;
-}
-function resolveTransformAssetsConfig(transform) {
+function resolveTransformConfig(transform) {
   if (typeof transform === "string") {
     const prefix = transform;
     return {
       type: "transform",
-      transformFn: ({ url }) => ({ href: `${prefix}${url}` }),
+      transformFn: ({ url }) => `${prefix}${url}`,
       cache: true
     };
   }
-  if (typeof transform === "function") return {
-    type: "transform",
-    transformFn: transform,
-    cache: true
-  };
-  if (isObjectShorthand(transform)) {
-    const { prefix, crossOrigin } = transform;
+  if (typeof transform === "function") {
     return {
       type: "transform",
-      transformFn: ({ url, kind }) => {
-        const href = `${prefix}${url}`;
-        if (kind === "css-url") return { href };
-        const co = resolveTransformAssetsCrossOrigin(crossOrigin, kind);
-        return co ? {
-          href,
-          crossOrigin: co
-        } : { href };
-      },
+      transformFn: transform,
       cache: true
     };
   }
-  if ("createTransform" in transform && transform.createTransform) return {
-    type: "createTransform",
-    createTransform: transform.createTransform,
-    cache: transform.cache !== false
-  };
+  if ("createTransform" in transform && transform.createTransform) {
+    return {
+      type: "createTransform",
+      createTransform: transform.createTransform,
+      cache: transform.cache !== false
+    };
+  }
+  const transformFn = typeof transform.transform === "string" ? (({ url }) => `${transform.transform}${url}`) : transform.transform;
   return {
     type: "transform",
-    transformFn: typeof transform.transform === "string" ? (({ url }) => ({ href: `${transform.transform}${url}` })) : transform.transform,
+    transformFn,
     cache: transform.cache !== false
   };
 }
-function assignManifestLink(link, next) {
-  if (typeof link === "string") return next.crossOrigin ? next : next.href;
-  const nextLink = {
-    ...link,
-    href: next.href
-  };
-  if (next.crossOrigin) nextLink.crossOrigin = next.crossOrigin;
-  else delete nextLink.crossOrigin;
-  return nextLink;
-}
-async function transformManifestAssets(source, transformFn, _opts) {
-  const manifest2 = structuredClone(source);
-  const inlineCssEnabled = _opts?.inlineCss !== false;
-  const scriptTransforms = /* @__PURE__ */ new Map();
-  const transformScript = (url) => {
-    const cached = scriptTransforms.get(url);
-    if (cached) return cached;
-    const transformed = Promise.resolve(transformFn({
-      url,
-      kind: "script"
-    })).then(normalizeTransformAssetResult);
-    scriptTransforms.set(url, transformed);
-    return transformed;
-  };
-  if (!inlineCssEnabled) delete manifest2.inlineCss;
-  else if (manifest2.inlineCss) manifest2.inlineCss = await transformInlineCssStyles(manifest2.inlineCss, transformFn);
-  for (const route of Object.values(manifest2.routes)) {
-    if (route.preloads?.length) route.preloads = await Promise.all(route.preloads.map(async (link) => {
-      const result = await transformScript(resolveManifestAssetLink(link).href);
-      return assignManifestLink(link, {
-        href: result.href,
-        crossOrigin: result.crossOrigin
-      });
-    }));
-    if (route.css?.length && !manifest2.inlineCss) route.css = await Promise.all(route.css.map(async (link) => {
-      const result = normalizeTransformAssetResult(await transformFn({
-        url: resolveManifestCssLink(link).href,
-        kind: "stylesheet"
-      }));
-      return assignManifestLink(link, {
-        href: result.href,
-        crossOrigin: result.crossOrigin
-      });
-    }));
-    if (route.scripts?.length) for (const script of route.scripts) {
-      const src = script.attrs?.src;
-      if (typeof src !== "string") continue;
-      const result = await transformScript(src);
-      script.attrs = {
-        ...script.attrs,
-        src: result.href
-      };
-      if (result.crossOrigin) script.attrs.crossOrigin = result.crossOrigin;
-      else delete script.attrs.crossOrigin;
-    }
+function buildClientEntryScriptTag(clientEntry, injectedHeadScripts) {
+  const clientEntryLiteral = JSON.stringify(clientEntry);
+  let script = `import(${clientEntryLiteral})`;
+  if (injectedHeadScripts) {
+    script = `${injectedHeadScripts};${script}`;
   }
-  return manifest2;
-}
-function buildManifest(source, opts) {
   return {
-    ...source.scriptFormat ? { scriptFormat: source.scriptFormat } : {},
-    ...opts?.inlineCss !== false && source.inlineCss ? { inlineCss: structuredClone(source.inlineCss) } : {},
-    routes: { ...source.routes }
-  };
-}
-function getStaticHandlerInlineCssDefault(handlerInlineCss) {
-  if (typeof handlerInlineCss === "function") return;
-  return handlerInlineCss ?? true;
-}
-async function resolveInlineCssForRequest(opts) {
-  if (opts.requestInlineCss !== void 0) return opts.requestInlineCss;
-  if (typeof opts.handlerInlineCss === "function") return await opts.handlerInlineCss({ request: opts.request });
-  return opts.handlerInlineCss ?? true;
-}
-function createCachedBaseManifestLoader(loadBaseManifest) {
-  let baseManifestPromise;
-  return () => {
-    if (!baseManifestPromise) baseManifestPromise = loadBaseManifest().catch((error) => {
-      baseManifestPromise = void 0;
-      throw error;
-    });
-    return baseManifestPromise;
+    tag: "script",
+    attrs: {
+      type: "module",
+      async: true
+    },
+    children: script
   };
 }
-function createFinalManifestTransformResolver(transformAssets, opts) {
-  const transformConfig = transformAssets !== void 0 ? resolveTransformAssetsConfig(transformAssets) : void 0;
-  const cache = transformConfig ? transformConfig.cache : true;
-  const warmup = !!transformAssets && typeof transformAssets === "object" && "warmup" in transformAssets && transformAssets.warmup === true;
-  let cachedCreateTransformPromise;
-  const clearCachedCreateTransform = () => {
-    cachedCreateTransformPromise = void 0;
-  };
-  return {
-    cache,
-    warmup,
-    clearCachedCreateTransform,
-    getTransformFn: async (ctx) => {
-      if (!transformConfig) return void 0;
-      if (transformConfig.type !== "createTransform") return transformConfig.transformFn;
-      if (!cache || false) return transformConfig.createTransform(ctx);
-      if (!cachedCreateTransformPromise) cachedCreateTransformPromise = Promise.resolve(transformConfig.createTransform(ctx)).catch((error) => {
-        clearCachedCreateTransform();
-        throw error;
-      });
-      return cachedCreateTransformPromise;
+function transformManifestUrls(source, transformFn, opts) {
+  return (async () => {
+    const manifest2 = opts?.clone ? structuredClone(source.manifest) : source.manifest;
+    for (const route of Object.values(manifest2.routes)) {
+      if (route.preloads) {
+        route.preloads = await Promise.all(
+          route.preloads.map(
+            (url) => Promise.resolve(transformFn({ url, type: "modulepreload" }))
+          )
+        );
+      }
+      if (route.assets) {
+        for (const asset of route.assets) {
+          if (asset.tag === "link" && asset.attrs?.href) {
+            asset.attrs.href = await Promise.resolve(
+              transformFn({
+                url: asset.attrs.href,
+                type: "stylesheet"
+              })
+            );
+          }
+        }
+      }
     }
-  };
-}
-function createFinalManifestResolver(opts) {
-  const finalManifestCache = /* @__PURE__ */ new Map();
-  const transformResolver = createFinalManifestTransformResolver(opts.transformAssets);
-  const handlerDefaultInlineCss = getStaticHandlerInlineCssDefault(opts.inlineCss);
-  const getRequestManifestOptions = async (requestOpts) => {
-    const transformFn = await transformResolver.getTransformFn({
-      warmup: false,
-      request: requestOpts.request
-    });
-    const inlineCss = await resolveInlineCssForRequest({
-      request: requestOpts.request,
-      handlerInlineCss: opts.inlineCss,
-      requestInlineCss: requestOpts.requestInlineCss
-    });
-    return {
-      getBaseManifest: requestOpts.getBaseManifest,
-      transformFn,
-      cache: transformResolver.cache,
-      inlineCss
-    };
-  };
-  const resolveRequest = async (requestOpts, cache) => {
-    return resolveFinalManifest({
-      ...await getRequestManifestOptions(requestOpts),
-      finalManifestCache: cache
-    });
-  };
-  return {
-    warmup: ({ getBaseManifest: getBaseManifest2 }) => warmupFinalManifest({
-      enabled: transformResolver.warmup,
-      handlerDefaultInlineCss,
-      cache: transformResolver.cache,
-      finalManifestCache,
-      getBaseManifest: getBaseManifest2,
-      getTransformFn: () => transformResolver.getTransformFn({ warmup: true }),
-      onError: transformResolver.clearCachedCreateTransform
-    }),
-    resolveCached: (requestOpts) => resolveRequest(requestOpts, finalManifestCache),
-    resolveUncached: (requestOpts) => resolveRequest(requestOpts, void 0)
-  };
-}
-function getFinalManifestCacheKey(inlineCss) {
-  return inlineCss ? "inline-css" : "linked-css";
-}
-function cacheFinalManifestPromise(cachedFinalManifestPromises, cacheKey, promise) {
-  const cachedFinalManifestPromise = promise.catch((error) => {
-    if (cachedFinalManifestPromises.get(cacheKey) === cachedFinalManifestPromise) cachedFinalManifestPromises.delete(cacheKey);
-    throw error;
-  });
-  cachedFinalManifestPromises.set(cacheKey, cachedFinalManifestPromise);
-  return cachedFinalManifestPromise;
-}
-function getOrCreateCachedFinalManifestPromise(cachedFinalManifestPromises, cacheKey, computeFinalManifest) {
-  const cachedFinalManifestPromise = cachedFinalManifestPromises.get(cacheKey);
-  if (cachedFinalManifestPromise) return cachedFinalManifestPromise;
-  return cacheFinalManifestPromise(cachedFinalManifestPromises, cacheKey, Promise.resolve().then(computeFinalManifest));
-}
-async function buildFinalManifest(opts) {
-  return opts.transformFn ? await transformManifestAssets(opts.base, opts.transformFn, { inlineCss: opts.inlineCss }) : buildManifest(opts.base, { inlineCss: opts.inlineCss });
+    const transformedClientEntry = await Promise.resolve(
+      transformFn({
+        url: source.clientEntry,
+        type: "clientEntry"
+      })
+    );
+    const rootRoute = manifest2.routes[rootRouteId];
+    if (rootRoute) {
+      rootRoute.assets = rootRoute.assets || [];
+      rootRoute.assets.push(
+        buildClientEntryScriptTag(
+          transformedClientEntry,
+          source.injectedHeadScripts
+        )
+      );
+    }
+    return manifest2;
+  })();
 }
-async function resolveFinalManifest(opts) {
-  const computeFinalManifest = async () => {
-    return buildFinalManifest({
-      base: await opts.getBaseManifest(),
-      transformFn: opts.transformFn,
-      inlineCss: opts.inlineCss
-    });
+function buildManifestWithClientEntry(source) {
+  const scriptTag = buildClientEntryScriptTag(
+    source.clientEntry,
+    source.injectedHeadScripts
+  );
+  const baseRootRoute = source.manifest.routes[rootRouteId];
+  const routes = {
+    ...source.manifest.routes,
+    ...baseRootRoute ? {
+      [rootRouteId]: {
+        ...baseRootRoute,
+        assets: [...baseRootRoute.assets || [], scriptTag]
+      }
+    } : {}
   };
-  if (opts.finalManifestCache && (!opts.transformFn || opts.cache)) return getOrCreateCachedFinalManifestPromise(opts.finalManifestCache, getFinalManifestCacheKey(opts.inlineCss), computeFinalManifest);
-  return computeFinalManifest();
+  return { routes };
 }
-function warmupFinalManifest(opts) {
-  if (!opts.enabled || opts.handlerDefaultInlineCss === void 0 || !opts.cache) return;
-  const inlineCss = opts.handlerDefaultInlineCss;
-  const warmupPromise = getOrCreateCachedFinalManifestPromise(opts.finalManifestCache, getFinalManifestCacheKey(inlineCss), async () => {
-    const [base, transformFn] = await Promise.all([opts.getBaseManifest(), opts.getTransformFn()]);
-    return buildFinalManifest({
-      base,
-      transformFn,
-      inlineCss
-    });
-  });
-  if (opts.onError) warmupPromise.catch(opts.onError);
-  return warmupPromise;
-}
-var ServerFunctionSerializationAdapter = createSerializationAdapter({
+const HEADERS = {
+  TSS_SHELL: "X-TSS_SHELL"
+};
+const ServerFunctionSerializationAdapter = createSerializationAdapter({
   key: "$TSS/serverfn",
   test: (v) => {
     if (typeof v !== "function") return false;
@@ -1139,44 +745,63 @@ var ServerFunctionSerializationAdapter = createSerializationAdapter({
   toSerializable: ({ serverFnMeta }) => ({ functionId: serverFnMeta.id }),
   fromSerializable: ({ functionId }) => {
     const fn = async (opts, signal) => {
-      return (await (await getServerFnById(functionId))(opts ?? {}, signal)).result;
+      const serverFn = await getServerFnById(functionId);
+      const result = await serverFn(opts ?? {}, signal);
+      return result.result;
     };
     return fn;
   }
 });
 function getStartResponseHeaders(opts) {
-  return mergeHeaders({ "Content-Type": "text/html; charset=utf-8" }, ...opts.router.stores.matches.get().map((match) => {
-    return match.headers;
-  }));
-}
-var entriesPromise;
-var defaultCsrfMiddleware = createCsrfMiddleware({ filter: (ctx) => ctx.handlerType === "serverFn" });
-var getCachedBaseManifest = createCachedBaseManifestLoader(() => getStartManifest());
-var getProdBaseManifest = () => getCachedBaseManifest();
-var getBaseManifest = getProdBaseManifest;
-var createEarlyHintsForRequest = createEarlyHintsCollector;
+  const headers = mergeHeaders(
+    {
+      "Content-Type": "text/html; charset=utf-8"
+    },
+    ...opts.router.state.matches.map((match) => {
+      return match.headers;
+    })
+  );
+  return headers;
+}
+let entriesPromise;
+let baseManifestPromise;
+let cachedFinalManifestPromise;
 async function loadEntries() {
-  const [routerEntry, startEntry, pluginAdapters] = await Promise.all([
-    import("./router-BR4XO8XJ.mjs").then((n) => n.r),
-    import("./start-HYkvq4Ni.mjs"),
-    import("./empty-plugin-adapters-BFgPZ6_d.mjs")
-  ]);
-  return {
-    routerEntry,
-    startEntry,
-    pluginAdapters
-  };
+  const routerEntry = await import("./router-BVxfVFsb.mjs").then((n) => n.r);
+  const startEntry = await import("./start-HYkvq4Ni.mjs");
+  return { startEntry, routerEntry };
 }
 function getEntries() {
-  if (!entriesPromise) entriesPromise = loadEntries();
+  if (!entriesPromise) {
+    entriesPromise = loadEntries();
+  }
   return entriesPromise;
 }
-var ROUTER_BASEPATH = "/";
-var SERVER_FN_BASE = "/_serverFn/";
-var IS_PRERENDERING = process.env.TSS_PRERENDERING === "true";
-var IS_SHELL_ENV = process.env.TSS_SHELL === "true";
-var ERR_NO_RESPONSE = "Internal Server Error";
-var ERR_NO_DEFER = "Internal Server Error";
+function getBaseManifest(matchedRoutes) {
+  if (!baseManifestPromise) {
+    baseManifestPromise = getStartManifest();
+  }
+  return baseManifestPromise;
+}
+async function resolveManifest(matchedRoutes, transformFn, cache) {
+  const base = await getBaseManifest();
+  const computeFinalManifest = async () => {
+    return transformFn ? await transformManifestUrls(base, transformFn, { clone: !cache }) : buildManifestWithClientEntry(base);
+  };
+  if (!transformFn || cache) {
+    if (!cachedFinalManifestPromise) {
+      cachedFinalManifestPromise = computeFinalManifest();
+    }
+    return cachedFinalManifestPromise;
+  }
+  return computeFinalManifest();
+}
+const ROUTER_BASEPATH = "/";
+const SERVER_FN_BASE = "/_serverFn/";
+const IS_PRERENDERING = process.env.TSS_PRERENDERING === "true";
+const IS_SHELL_ENV = process.env.TSS_SHELL === "true";
+const ERR_NO_RESPONSE = "Internal Server Error";
+const ERR_NO_DEFER = "Internal Server Error";
 function throwRouteHandlerError() {
   throw new Error(ERR_NO_RESPONSE);
 }
@@ -1187,267 +812,316 @@ function isSpecialResponse(value) {
   return value instanceof Response || isRedirect(value);
 }
 function handleCtxResult(result) {
-  if (isSsrResponse(result) || isSpecialResponse(result)) return { response: result };
+  if (isSpecialResponse(result)) {
+    return { response: result };
+  }
   return result;
 }
-async function executeMiddleware(middlewares, ctx) {
+function executeMiddleware(middlewares, ctx) {
   let index = -1;
-  let streamResponse;
-  const setResponse = (response) => {
-    if (isSsrResponse(response)) {
-      if (response.serverSsrCleanup === "stream") streamResponse = response;
-      ctx.response = response.response;
-      return;
-    }
-    ctx.response = response;
-  };
-  const disposeStreamResponse = async (reason) => {
-    const response = streamResponse;
-    if (!response) return;
-    streamResponse = void 0;
-    const currentResponse = ctx.response;
-    if (currentResponse === response.response || currentResponse instanceof Response && response.response.body !== null && currentResponse.body === response.response.body) ctx.response = void 0;
-    await response.dispose(reason);
-  };
-  const getFinalResponse = async () => {
-    const response = ctx.response;
-    if (!response) throwRouteHandlerError();
-    if (!streamResponse) return response;
-    if (response === streamResponse.response) return streamResponse;
-    if (streamResponse.response.body !== null && response.body === streamResponse.response.body) return {
-      ...streamResponse,
-      response
-    };
-    await disposeStreamResponse("middleware response replaced");
-    return response;
-  };
   const next = async (nextCtx) => {
     if (nextCtx) {
-      if (nextCtx.context) ctx.context = safeObjectMerge(ctx.context, nextCtx.context);
-      for (const key of Object.keys(nextCtx)) if (key === "response") setResponse(nextCtx.response);
-      else if (key !== "context") ctx[key] = nextCtx[key];
+      if (nextCtx.context) {
+        ctx.context = safeObjectMerge(ctx.context, nextCtx.context);
+      }
+      for (const key of Object.keys(nextCtx)) {
+        if (key !== "context") {
+          ctx[key] = nextCtx[key];
+        }
+      }
     }
     index++;
     const middleware = middlewares[index];
     if (!middleware) return ctx;
     let result;
     try {
-      result = await middleware({
-        ...ctx,
-        next
-      });
+      result = await middleware({ ...ctx, next });
     } catch (err) {
       if (isSpecialResponse(err)) {
-        setResponse(err);
+        ctx.response = err;
         return ctx;
       }
-      await disposeStreamResponse("middleware error");
       throw err;
     }
     const normalized = handleCtxResult(result);
     if (normalized) {
-      if (normalized.response !== void 0) setResponse(normalized.response);
-      if (normalized.context) ctx.context = safeObjectMerge(ctx.context, normalized.context);
+      if (normalized.response !== void 0) {
+        ctx.response = normalized.response;
+      }
+      if (normalized.context) {
+        ctx.context = safeObjectMerge(ctx.context, normalized.context);
+      }
     }
     return ctx;
   };
-  await next();
-  return {
-    ctx,
-    response: await getFinalResponse()
-  };
+  return next();
 }
 function handlerToMiddleware(handler, mayDefer = false) {
-  if (mayDefer) return handler;
+  if (mayDefer) {
+    return handler;
+  }
   return async (ctx) => {
-    const response = await handler({
-      ...ctx,
-      next: throwIfMayNotDefer
-    });
-    if (!response) throwRouteHandlerError();
+    const response = await handler({ ...ctx, next: throwIfMayNotDefer });
+    if (!response) {
+      throwRouteHandlerError();
+    }
     return response;
   };
 }
 function createStartHandler(cbOrOptions) {
-  const handlerOptions = typeof cbOrOptions === "function" ? {} : cbOrOptions;
   const cb = typeof cbOrOptions === "function" ? cbOrOptions : cbOrOptions.handler;
-  const finalManifestResolver = createFinalManifestResolver({
-    ...handlerOptions
-  });
-  const resolveManifestForRequest = finalManifestResolver.resolveCached;
-  finalManifestResolver.warmup({ getBaseManifest: () => getBaseManifest() });
+  const transformAssetUrlsOption = typeof cbOrOptions === "function" ? void 0 : cbOrOptions.transformAssetUrls;
+  const warmupTransformManifest = !!transformAssetUrlsOption && typeof transformAssetUrlsOption === "object" && transformAssetUrlsOption.warmup === true;
+  const resolvedTransformConfig = transformAssetUrlsOption ? resolveTransformConfig(transformAssetUrlsOption) : void 0;
+  const cache = resolvedTransformConfig ? resolvedTransformConfig.cache : true;
+  let cachedCreateTransformPromise;
+  const getTransformFn = async (opts) => {
+    if (!resolvedTransformConfig) return void 0;
+    if (resolvedTransformConfig.type === "createTransform") {
+      if (cache) {
+        if (!cachedCreateTransformPromise) {
+          cachedCreateTransformPromise = Promise.resolve(
+            resolvedTransformConfig.createTransform(opts)
+          );
+        }
+        return cachedCreateTransformPromise;
+      }
+      return resolvedTransformConfig.createTransform(opts);
+    }
+    return resolvedTransformConfig.transformFn;
+  };
+  if (warmupTransformManifest && cache && true && !cachedFinalManifestPromise) {
+    const warmupPromise = (async () => {
+      const base = await getBaseManifest();
+      const transformFn = await getTransformFn({ warmup: true });
+      return transformFn ? await transformManifestUrls(base, transformFn, { clone: false }) : buildManifestWithClientEntry(base);
+    })();
+    cachedFinalManifestPromise = warmupPromise;
+    warmupPromise.catch(() => {
+      if (cachedFinalManifestPromise === warmupPromise) {
+        cachedFinalManifestPromise = void 0;
+      }
+      cachedCreateTransformPromise = void 0;
+    });
+  }
   const startRequestResolver = async (request, requestOpts) => {
     let router = null;
-    let responseOwnsCleanup = false;
+    let cbWillCleanup = false;
     try {
       const { url, handledProtocolRelativeURL } = getNormalizedURL(request.url);
       const href = url.pathname + url.search + url.hash;
       const origin = getOrigin(request);
-      if (handledProtocolRelativeURL) return Response.redirect(url, 308);
+      if (handledProtocolRelativeURL) {
+        return Response.redirect(url, 308);
+      }
       const entries = await getEntries();
-      const hasStartInstance = !!entries.startEntry.startInstance;
       const startOptions = await entries.startEntry.startInstance?.getOptions() || {};
-      const { hasPluginAdapters, pluginSerializationAdapters } = entries.pluginAdapters;
       const serializationAdapters = [
         ...startOptions.serializationAdapters || [],
-        ...hasPluginAdapters ? pluginSerializationAdapters : [],
         ServerFunctionSerializationAdapter
       ];
       const requestStartOptions = {
         ...startOptions,
-        requestMiddleware: hasStartInstance ? startOptions.requestMiddleware : [defaultCsrfMiddleware],
         serializationAdapters
       };
-      const flattenedRequestMiddlewares = requestStartOptions.requestMiddleware ? flattenMiddlewares(requestStartOptions.requestMiddleware) : [];
-      const executedRequestMiddlewares = new Set(flattenedRequestMiddlewares);
+      const flattenedRequestMiddlewares = startOptions.requestMiddleware ? flattenMiddlewares(startOptions.requestMiddleware) : [];
+      const executedRequestMiddlewares = new Set(
+        flattenedRequestMiddlewares
+      );
       const getRouter = async () => {
         if (router) return router;
         router = await entries.routerEntry.getRouter();
         let isShell = IS_SHELL_ENV;
-        if (IS_PRERENDERING && !isShell) isShell = request.headers.get(HEADERS.TSS_SHELL) === "true";
-        const history = createMemoryHistory({ initialEntries: [href] });
+        if (IS_PRERENDERING && !isShell) {
+          isShell = request.headers.get(HEADERS.TSS_SHELL) === "true";
+        }
+        const history = createMemoryHistory({
+          initialEntries: [href]
+        });
         router.update({
           history,
           isShell,
           isPrerendering: IS_PRERENDERING,
           origin: router.options.origin ?? origin,
-          defaultSsr: requestStartOptions.defaultSsr,
-          serializationAdapters: [...requestStartOptions.serializationAdapters, ...router.options.serializationAdapters || []],
+          ...{
+            defaultSsr: requestStartOptions.defaultSsr,
+            serializationAdapters: [
+              ...requestStartOptions.serializationAdapters,
+              ...router.options.serializationAdapters || []
+            ]
+          },
           basepath: ROUTER_BASEPATH
         });
         return router;
       };
       if (SERVER_FN_BASE && url.pathname.startsWith(SERVER_FN_BASE)) {
-        if (false) ;
         const serverFnId = url.pathname.slice(SERVER_FN_BASE.length).split("/")[0];
-        if (!serverFnId) throw new Error("Invalid server action param for serverFnId");
+        if (!serverFnId) {
+          throw new Error("Invalid server action param for serverFnId");
+        }
         const serverFnHandler = async ({ context }) => {
-          return runWithStartContext({
-            getRouter,
-            startOptions: requestStartOptions,
-            contextAfterGlobalMiddlewares: context,
-            request,
-            executedRequestMiddlewares,
-            handlerType: "serverFn"
-          }, () => handleServerAction({
-            request,
-            context: requestOpts?.context,
-            serverFnId
-          }));
+          return runWithStartContext(
+            {
+              getRouter,
+              startOptions: requestStartOptions,
+              contextAfterGlobalMiddlewares: context,
+              request,
+              executedRequestMiddlewares
+            },
+            () => handleServerAction({
+              request,
+              context: requestOpts?.context,
+              serverFnId
+            })
+          );
         };
-        const { response: middlewareResponse2 } = await executeMiddleware([...flattenedRequestMiddlewares.map((d) => d.options.server), serverFnHandler], {
+        const middlewares2 = flattenedRequestMiddlewares.map(
+          (d) => d.options.server
+        );
+        const ctx2 = await executeMiddleware([...middlewares2, serverFnHandler], {
           request,
           pathname: url.pathname,
-          handlerType: "serverFn",
           context: createNullProtoObject(requestOpts?.context)
         });
-        const result = await handleRedirectResponse(middlewareResponse2, request, getRouter);
-        responseOwnsCleanup = result.serverSsrCleanup === "stream";
-        return result.response;
+        return handleRedirectResponse(ctx2.response, request, getRouter);
       }
       const executeRouter = async (serverContext, matchedRoutes) => {
-        const acceptParts = (request.headers.get("Accept") || "*/*").split(",");
-        if (!["*/*", "text/html"].some((mimeType) => acceptParts.some((part) => part.trim().startsWith(mimeType)))) return normalizeSsrResponse(Response.json({ error: "Only HTML requests are supported here" }, { status: 500 }));
-        const manifest2 = await resolveManifestForRequest({
-          request,
-          requestInlineCss: requestOpts?.inlineCss,
-          getBaseManifest: () => getBaseManifest(matchedRoutes)
-        });
-        const earlyHints = createEarlyHintsForRequest({
-          onEarlyHints: requestOpts?.onEarlyHints,
-          responseLinkHeader: requestOpts?.responseLinkHeader
-        });
-        earlyHints?.collectStatic({
-          manifest: manifest2,
-          matchedRoutes
-        });
+        const acceptHeader = request.headers.get("Accept") || "*/*";
+        const acceptParts = acceptHeader.split(",");
+        const supportedMimeTypes = ["*/*", "text/html"];
+        const isSupported = supportedMimeTypes.some(
+          (mimeType) => acceptParts.some((part) => part.trim().startsWith(mimeType))
+        );
+        if (!isSupported) {
+          return Response.json(
+            { error: "Only HTML requests are supported here" },
+            { status: 500 }
+          );
+        }
+        const manifest2 = await resolveManifest(
+          matchedRoutes,
+          await getTransformFn({ warmup: false, request }),
+          cache
+        );
         const routerInstance = await getRouter();
         attachRouterServerSsrUtils({
           router: routerInstance,
-          manifest: manifest2,
-          getRequestAssets: () => getStartContext({ throwIfNotFound: false })?.requestAssets
+          manifest: manifest2
         });
         routerInstance.update({ additionalContext: { serverContext } });
         await routerInstance.load();
-        if (routerInstance.state.redirect) return normalizeSsrResponse(routerInstance.state.redirect);
-        earlyHints?.collectDynamic(routerInstance.stores.matches.get());
-        const ctx = getStartContext({ throwIfNotFound: false });
-        await routerInstance.serverSsr.dehydrate({ requestAssets: ctx?.requestAssets });
-        const responseHeaders = getStartResponseHeaders({ router: routerInstance });
-        earlyHints?.appendResponseHeaders(responseHeaders);
-        return normalizeSsrResponse(await cb({
+        if (routerInstance.state.redirect) {
+          return routerInstance.state.redirect;
+        }
+        await routerInstance.serverSsr.dehydrate();
+        const responseHeaders = getStartResponseHeaders({
+          router: routerInstance
+        });
+        cbWillCleanup = true;
+        return cb({
           request,
           router: routerInstance,
           responseHeaders
-        }));
+        });
       };
       const requestHandlerMiddleware = async ({ context }) => {
-        return runWithStartContext({
-          getRouter,
-          startOptions: requestStartOptions,
-          contextAfterGlobalMiddlewares: context,
-          request,
-          executedRequestMiddlewares,
-          handlerType: "router"
-        }, async () => {
-          try {
-            return await handleServerRoutes({
-              getRouter,
-              request,
-              url,
-              executeRouter,
-              context,
-              executedRequestMiddlewares
-            });
-          } catch (err) {
-            if (err instanceof Response) return err;
-            throw err;
+        return runWithStartContext(
+          {
+            getRouter,
+            startOptions: requestStartOptions,
+            contextAfterGlobalMiddlewares: context,
+            request,
+            executedRequestMiddlewares
+          },
+          async () => {
+            try {
+              return await handleServerRoutes({
+                getRouter,
+                request,
+                url,
+                executeRouter,
+                context,
+                executedRequestMiddlewares
+              });
+            } catch (err) {
+              if (err instanceof Response) {
+                return err;
+              }
+              throw err;
+            }
           }
-        });
+        );
       };
-      const { response: middlewareResponse } = await executeMiddleware([...flattenedRequestMiddlewares.map((d) => d.options.server), requestHandlerMiddleware], {
-        request,
-        pathname: url.pathname,
-        handlerType: "router",
-        context: createNullProtoObject(requestOpts?.context)
-      });
-      const response = await handleRedirectResponse(middlewareResponse, request, getRouter);
-      responseOwnsCleanup = response.serverSsrCleanup === "stream";
-      return response.response;
+      const middlewares = flattenedRequestMiddlewares.map(
+        (d) => d.options.server
+      );
+      const ctx = await executeMiddleware(
+        [...middlewares, requestHandlerMiddleware],
+        {
+          request,
+          pathname: url.pathname,
+          context: createNullProtoObject(requestOpts?.context)
+        }
+      );
+      return handleRedirectResponse(ctx.response, request, getRouter);
     } finally {
-      if (router?.serverSsr && !responseOwnsCleanup) router.serverSsr.cleanup();
+      if (router && !cbWillCleanup) {
+        router.serverSsr?.cleanup();
+      }
       router = null;
     }
   };
   return requestHandler(startRequestResolver);
 }
 async function handleRedirectResponse(response, request, getRouter) {
-  const ssrResponse = normalizeSsrResponse(response);
-  if (!isRedirect(ssrResponse.response)) return ssrResponse;
-  if (isResolvedRedirect(ssrResponse.response)) {
-    if (request.headers.get("x-tsr-serverFn") === "true") return replaceSsrResponse(ssrResponse, Response.json({
-      ...ssrResponse.response.options,
-      isSerializedRedirect: true
-    }, { headers: ssrResponse.response.headers }), "redirect response replaced");
-    return ssrResponse;
+  if (!isRedirect(response)) {
+    return response;
   }
-  const opts = ssrResponse.response.options;
-  if (opts.to && typeof opts.to === "string" && !opts.to.startsWith("/")) throw new Error(`Server side redirects must use absolute paths via the 'href' or 'to' options. The redirect() method's "to" property accepts an internal path only. Use the "href" property to provide an external URL. Received: ${JSON.stringify(opts)}`);
-  if ([
-    "params",
-    "search",
-    "hash"
-  ].some((d) => typeof opts[d] === "function")) throw new Error(`Server side redirects must use static search, params, and hash values and do not support functional values. Received functional values for: ${Object.keys(opts).filter((d) => typeof opts[d] === "function").map((d) => `"${d}"`).join(", ")}`);
-  const redirect = (await getRouter()).resolveRedirect(ssrResponse.response);
-  if (request.headers.get("x-tsr-serverFn") === "true") return replaceSsrResponse(ssrResponse, Response.json({
-    ...ssrResponse.response.options,
-    isSerializedRedirect: true
-  }, { headers: ssrResponse.response.headers }), "redirect response replaced");
-  return replaceSsrResponse(ssrResponse, redirect, "redirect response replaced");
+  if (isResolvedRedirect(response)) {
+    if (request.headers.get("x-tsr-serverFn") === "true") {
+      return Response.json(
+        { ...response.options, isSerializedRedirect: true },
+        { headers: response.headers }
+      );
+    }
+    return response;
+  }
+  const opts = response.options;
+  if (opts.to && typeof opts.to === "string" && !opts.to.startsWith("/")) {
+    throw new Error(
+      `Server side redirects must use absolute paths via the 'href' or 'to' options. The redirect() method's "to" property accepts an internal path only. Use the "href" property to provide an external URL. Received: ${JSON.stringify(opts)}`
+    );
+  }
+  if (["params", "search", "hash"].some(
+    (d) => typeof opts[d] === "function"
+  )) {
+    throw new Error(
+      `Server side redirects must use static search, params, and hash values and do not support functional values. Received functional values for: ${Object.keys(
+        opts
+      ).filter((d) => typeof opts[d] === "function").map((d) => `"${d}"`).join(", ")}`
+    );
+  }
+  const router = await getRouter();
+  const redirect = router.resolveRedirect(response);
+  if (request.headers.get("x-tsr-serverFn") === "true") {
+    return Response.json(
+      { ...response.options, isSerializedRedirect: true },
+      { headers: response.headers }
+    );
+  }
+  return redirect;
 }
-async function handleServerRoutes({ getRouter, request, url, executeRouter, context, executedRequestMiddlewares }) {
+async function handleServerRoutes({
+  getRouter,
+  request,
+  url,
+  executeRouter,
+  context,
+  executedRequestMiddlewares
+}) {
   const router = await getRouter();
-  const pathname = executeRewriteInput(router.rewrite, url).pathname;
+  const rewrittenUrl = executeRewriteInput(router.rewrite, url);
+  const pathname = rewrittenUrl.pathname;
   const { matchedRoutes, foundRoute, routeParams } = router.getMatchedRoutes(pathname);
   const isExactMatch = foundRoute && routeParams["**"] === void 0;
   const routeMiddlewares = [];
@@ -1455,41 +1129,45 @@ async function handleServerRoutes({ getRouter, request, url, executeRouter, cont
     const serverMiddleware = route.options.server?.middleware;
     if (serverMiddleware) {
       const flattened = flattenMiddlewares(serverMiddleware);
-      for (const m of flattened) if (!executedRequestMiddlewares.has(m)) routeMiddlewares.push(m.options.server);
+      for (const m of flattened) {
+        if (!executedRequestMiddlewares.has(m)) {
+          routeMiddlewares.push(m.options.server);
+        }
+      }
     }
   }
   const server2 = foundRoute?.options.server;
-  let isHeadFallback = false;
   if (server2?.handlers && isExactMatch) {
     const handlers = typeof server2.handlers === "function" ? server2.handlers({ createHandlers: (d) => d }) : server2.handlers;
     const requestMethod = request.method.toUpperCase();
-    const handler = requestMethod === "HEAD" ? handlers["HEAD"] ?? handlers["GET"] ?? handlers["ANY"] : handlers[requestMethod] ?? handlers["ANY"];
-    isHeadFallback = requestMethod === "HEAD" && handler !== void 0 && !handlers["HEAD"];
+    const handler = handlers[requestMethod] ?? handlers["ANY"];
     if (handler) {
       const mayDefer = !!foundRoute.options.component;
-      if (typeof handler === "function") routeMiddlewares.push(handlerToMiddleware(handler, mayDefer));
-      else {
+      if (typeof handler === "function") {
+        routeMiddlewares.push(handlerToMiddleware(handler, mayDefer));
+      } else {
         if (handler.middleware?.length) {
           const handlerMiddlewares = flattenMiddlewares(handler.middleware);
-          for (const m of handlerMiddlewares) routeMiddlewares.push(m.options.server);
+          for (const m of handlerMiddlewares) {
+            routeMiddlewares.push(m.options.server);
+          }
+        }
+        if (handler.handler) {
+          routeMiddlewares.push(handlerToMiddleware(handler.handler, mayDefer));
         }
-        if (handler.handler) routeMiddlewares.push(handlerToMiddleware(handler.handler, mayDefer));
       }
     }
   }
-  routeMiddlewares.push(((ctx2) => executeRouter(ctx2.context, matchedRoutes)));
-  const { ctx, response } = await executeMiddleware(routeMiddlewares, {
+  routeMiddlewares.push(
+    (ctx2) => executeRouter(ctx2.context, matchedRoutes)
+  );
+  const ctx = await executeMiddleware(routeMiddlewares, {
     request,
     context,
     params: routeParams,
-    pathname,
-    handlerType: "router"
+    pathname
   });
-  if (isHeadFallback) {
-    if (!ctx.response) throwRouteHandlerError();
-    return stripSsrResponseBody(await handleRedirectResponse(response, request, getRouter), "HEAD body stripped");
-  }
-  return normalizeSsrResponse(response);
+  return ctx.response;
 }
 const fetch = createStartHandler(defaultStreamHandler);
 function createServerEntry(entry) {