claude-session-dashboard 0.4.4 → 0.5.0

package/dist/server/server.js

@@ -1,230 +1,284 @@
-import { createMemoryHistory } from "@tanstack/history";
-import { mergeHeaders } from "@tanstack/router-core/ssr/client";
-import { parseRedirect, isRedirect, defaultSerovalPlugins, makeSerovalPlugin, rootRouteId, createRawStreamRPCPlugin, isNotFound, createSerializationAdapter, isResolvedRedirect, executeRewriteInput } from "@tanstack/router-core";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { getNormalizedURL, getOrigin, attachRouterServerSsrUtils } from "@tanstack/router-core/ssr/server";
 import { H3Event, toResponse } from "h3-v2";
+import { rootRouteId, parseRedirect, isRedirect, defaultSerovalPlugins, makeSerovalPlugin, createRawStreamRPCPlugin, isNotFound, createSerializationAdapter, isResolvedRedirect, executeRewriteInput } from "@tanstack/router-core";
 import invariant from "tiny-invariant";
 import { toCrossJSONStream, fromJSON, toCrossJSONAsync } from "seroval";
+import { createMemoryHistory } from "@tanstack/history";
+import { mergeHeaders } from "@tanstack/router-core/ssr/client";
+import { getNormalizedURL, getOrigin, attachRouterServerSsrUtils } from "@tanstack/router-core/ssr/server";
+import "react";
+import { RouterProvider } from "@tanstack/react-router";
 import { jsx } from "react/jsx-runtime";
 import { defineHandlerCallback, renderRouterToStream } from "@tanstack/react-router/ssr/server";
-import { RouterProvider } from "@tanstack/react-router";
 function StartServer(props) {
   return /* @__PURE__ */ jsx(RouterProvider, { router: props.router });
 }
-const defaultStreamHandler = defineHandlerCallback(
-  ({ request, router, responseHeaders }) => renderRouterToStream({
-    request,
-    router,
-    responseHeaders,
-    children: /* @__PURE__ */ jsx(StartServer, { router })
-  })
-);
-const TSS_FORMDATA_CONTEXT = "__TSS_CONTEXT";
-const TSS_SERVER_FUNCTION = /* @__PURE__ */ Symbol.for("TSS_SERVER_FUNCTION");
-const TSS_SERVER_FUNCTION_FACTORY = /* @__PURE__ */ Symbol.for(
-  "TSS_SERVER_FUNCTION_FACTORY"
-);
-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 */
-  CHUNK: 1,
-  /** Raw stream end (EOF) */
-  END: 2,
-  /** Raw stream error */
-  ERROR: 3
-};
-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();
+var defaultStreamHandler = defineHandlerCallback(({ request, router, responseHeaders }) => renderRouterToStream({
+  request,
+  router,
+  responseHeaders,
+  children: /* @__PURE__ */ 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";
 }
-const startStorage = globalObj$1[GLOBAL_STORAGE_KEY];
-async function runWithStartContext(context, fn) {
-  return startStorage.run(context, fn);
+function getSetCookieValues(headers) {
+  const headersWithSetCookie = headers;
+  if (typeof headersWithSetCookie.getSetCookie === "function") return headersWithSetCookie.getSetCookie();
+  const value = headers.get("set-cookie");
+  return value ? [value] : [];
 }
-function getStartContext(opts) {
-  const context = startStorage.getStore();
-  if (!context && opts?.throwIfNotFound !== false) {
+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) => {
+    const h3Event = new H3Event(request);
+    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("./assets/_tanstack-start-manifest_v-BNorjuP4.js");
+  const startManifest = tsrStartManifest();
+  const rootRoute = startManifest.routes[rootRouteId] = startManifest.routes[rootRouteId] || {};
+  rootRoute.assets = rootRoute.assets || [];
+  let injectedHeadScripts;
+  return {
+    manifest: { 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]];
+    })) },
+    clientEntry: startManifest.clientEntry,
+    injectedHeadScripts
+  };
+}
+const manifest = { "39e65590d2bc41f653f54a9b6a9e0a72f185da275304c0a4a595d811cf185572": {
+  functionName: "getProjectAnalytics_createServerFn_handler",
+  importer: () => import("./assets/project-analytics.api-6b5TIBNn.js")
+}, "44af69d3bfcf3ec46fffb3f297d2b12cd7fe4db36c654b8a322df34d549c6493": {
+  functionName: "getStats_createServerFn_handler",
+  importer: () => import("./assets/stats.api-tIZqhk4B.js")
+}, "71794080473579a94431392ab409ebd02772f6a9f6a08386cadbb8c0d3cf804a": {
+  functionName: "getSessionDetail_createServerFn_handler",
+  importer: () => import("./assets/session-detail.api-BQts3iQn.js")
+}, "72f81ef9e8fa751bab60a8bdabd7e77816e2a6723a5e6e26e03712c01b3a249c": {
+  functionName: "getSettings_createServerFn_handler",
+  importer: () => import("./assets/settings.api-Cq5KPUxN.js")
+}, "7fe8c2b131c4fc81aa9a2570aec79640ff84603fe0060d13c24928b7329cb236": {
+  functionName: "saveSettings_createServerFn_handler",
+  importer: () => import("./assets/settings.api-Cq5KPUxN.js")
+}, "04ac41a7e3e644815167d098c2d6c3375d00a72a11e5af0d37033ba771081ba9": {
+  functionName: "getAppInfo_createServerFn_handler",
+  importer: () => import("./assets/app-info.api-CrHplh0q.js")
+}, "8fd6c4e5b4d5590acf1ec73da75f249978e8aced6dd2be23de06ade8431033be": {
+  functionName: "getSessionList_createServerFn_handler",
+  importer: () => import("./assets/sessions.api-CQ-Lrk5S.js")
+}, "946cc550946f64ee7985dc35913a690eb13183d7ba83cffe398e424e697b4265": {
+  functionName: "getActiveSessionList_createServerFn_handler",
+  importer: () => import("./assets/sessions.api-CQ-Lrk5S.js")
+}, "e574977967ea9b3387e72d70704b6ca87230e72becaf69f0b98cbc91c9cd1339": {
+  functionName: "getPaginatedSessions_createServerFn_handler",
+  importer: () => import("./assets/sessions.api-CQ-Lrk5S.js")
+} };
+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(
-      `No Start context found in AsyncLocalStorage. Make sure you are using the function within the server runtime.`
+      `Server function module export not resolved for serverFn ID: ${id}`
     );
   }
-  return context;
+  return action;
 }
-const getStartOptions = () => getStartContext().startOptions;
-const getStartContextServerOnly = getStartContext;
+var TSS_FORMDATA_CONTEXT = "__TSS_CONTEXT";
+var TSS_SERVER_FUNCTION = /* @__PURE__ */ Symbol.for("TSS_SERVER_FUNCTION");
+var TSS_SERVER_FUNCTION_FACTORY = /* @__PURE__ */ Symbol.for("TSS_SERVER_FUNCTION_FACTORY");
+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 = {
+  JSON: 0,
+  CHUNK: 1,
+  END: 2,
+  ERROR: 3
+};
+var FRAME_HEADER_SIZE = 9;
+var TSS_CONTENT_TYPE_FRAMED_VERSIONED = `${TSS_CONTENT_TYPE_FRAMED}; v=1`;
 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;
 }
-const createServerFn = (options, __opts) => {
+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;
+var getStartContextServerOnly = getStartContext;
+var createServerFn = (options, __opts) => {
   const resolvedOptions = __opts || options || {};
-  if (typeof resolvedOptions.method === "undefined") {
-    resolvedOptions.method = "GET";
-  }
+  if (typeof resolvedOptions.method === "undefined") resolvedOptions.method = "GET";
   const res = {
     options: resolvedOptions,
     middleware: (middleware) => {
       const newMiddleware = [...resolvedOptions.middleware || []];
       middleware.map((m) => {
         if (TSS_SERVER_FUNCTION_FACTORY in m) {
-          if (m.options.middleware) {
-            newMiddleware.push(...m.options.middleware);
-          }
-        } else {
-          newMiddleware.push(m);
-        }
+          if (m.options.middleware) newMiddleware.push(...m.options.middleware);
+        } else newMiddleware.push(m);
       });
-      const newOptions = {
+      const res2 = createServerFn(void 0, {
         ...resolvedOptions,
         middleware: newMiddleware
-      };
-      const res2 = createServerFn(void 0, newOptions);
+      });
       res2[TSS_SERVER_FUNCTION_FACTORY] = true;
       return res2;
     },
     inputValidator: (inputValidator) => {
-      const newOptions = { ...resolvedOptions, inputValidator };
-      return createServerFn(void 0, newOptions);
+      return createServerFn(void 0, {
+        ...resolvedOptions,
+        inputValidator
+      });
     },
     handler: (...args) => {
       const [extractedFn, serverFn] = args;
-      const newOptions = { ...resolvedOptions, extractedFn, serverFn };
-      const resolvedMiddleware = [
-        ...newOptions.middleware || [],
-        serverFnBaseToMiddleware(newOptions)
-      ];
-      return Object.assign(
-        async (opts) => {
-          const result = await executeMiddleware$1(resolvedMiddleware, "client", {
-            ...extractedFn,
-            ...newOptions,
-            data: opts?.data,
-            headers: opts?.headers,
-            signal: opts?.signal,
-            fetch: opts?.fetch,
-            context: createNullProtoObject()
-          });
-          const redirect = parseRedirect(result.error);
-          if (redirect) {
-            throw redirect;
-          }
-          if (result.error) throw result.error;
-          return result.result;
-        },
-        {
-          // This copies over the URL, function ID
+      const newOptions = {
+        ...resolvedOptions,
+        extractedFn,
+        serverFn
+      };
+      const resolvedMiddleware = [...newOptions.middleware || [], serverFnBaseToMiddleware(newOptions)];
+      extractedFn.method = resolvedOptions.method;
+      return Object.assign(async (opts) => {
+        const result = await executeMiddleware$1(resolvedMiddleware, "client", {
           ...extractedFn,
-          // The extracted function on the server-side calls
-          // this function
-          __executeServer: async (opts) => {
-            const startContext = getStartContextServerOnly();
-            const serverContextAfterGlobalMiddlewares = startContext.contextAfterGlobalMiddlewares;
-            const ctx = {
-              ...extractedFn,
-              ...opts,
-              // Ensure we use the full serverFnMeta from the provider file's extractedFn
-              // (which has id, name, filename) rather than the partial one from SSR/client
-              // callers (which only has id)
-              serverFnMeta: extractedFn.serverFnMeta,
-              // Use safeObjectMerge for opts.context which comes from client
-              context: safeObjectMerge(
-                serverContextAfterGlobalMiddlewares,
-                opts.context
-              ),
-              request: startContext.request
-            };
-            const result = await executeMiddleware$1(
-              resolvedMiddleware,
-              "server",
-              ctx
-            ).then((d) => ({
-              // Only send the result and sendContext back to the client
-              result: d.result,
-              error: d.error,
-              context: d.sendContext
-            }));
-            return result;
-          }
+          ...newOptions,
+          data: opts?.data,
+          headers: opts?.headers,
+          signal: opts?.signal,
+          fetch: opts?.fetch,
+          context: createNullProtoObject()
+        });
+        const redirect = parseRedirect(result.error);
+        if (redirect) throw redirect;
+        if (result.error) throw result.error;
+        return result.result;
+      }, {
+        ...extractedFn,
+        method: resolvedOptions.method,
+        __executeServer: async (opts) => {
+          const startContext = getStartContextServerOnly();
+          const serverContextAfterGlobalMiddlewares = startContext.contextAfterGlobalMiddlewares;
+          return await executeMiddleware$1(resolvedMiddleware, "server", {
+            ...extractedFn,
+            ...opts,
+            serverFnMeta: extractedFn.serverFnMeta,
+            context: safeObjectMerge(serverContextAfterGlobalMiddlewares, opts.context),
+            request: startContext.request
+          }).then((d) => ({
+            result: d.result,
+            error: d.error,
+            context: d.sendContext
+          }));
         }
-      );
+      });
     }
   };
   const fun = (options2) => {
-    const newOptions = {
+    return createServerFn(void 0, {
       ...resolvedOptions,
       ...options2
-    };
-    return createServerFn(void 0, newOptions);
+    });
   };
   return Object.assign(fun, res);
 };
 async function executeMiddleware$1(middlewares, env, opts) {
-  const globalMiddlewares = getStartOptions()?.functionMiddleware || [];
-  let flattenedMiddlewares = flattenMiddlewares([
-    ...globalMiddlewares,
-    ...middlewares
-  ]);
+  let flattenedMiddlewares = flattenMiddlewares([...getStartOptions()?.functionMiddleware || [], ...middlewares]);
   if (env === "server") {
     const startContext = getStartContextServerOnly({ throwIfNotFound: false });
-    if (startContext?.executedRequestMiddlewares) {
-      flattenedMiddlewares = flattenedMiddlewares.filter(
-        (m) => !startContext.executedRequestMiddlewares.has(m)
-      );
-    }
+    if (startContext?.executedRequestMiddlewares) flattenedMiddlewares = flattenedMiddlewares.filter((m) => !startContext.executedRequestMiddlewares.has(m));
   }
   const callNextMiddleware = async (ctx) => {
     const nextMiddleware = flattenedMiddlewares.shift();
-    if (!nextMiddleware) {
-      return ctx;
-    }
+    if (!nextMiddleware) return ctx;
     try {
-      if ("inputValidator" in nextMiddleware.options && nextMiddleware.options.inputValidator && env === "server") {
-        ctx.data = await execValidator(
-          nextMiddleware.options.inputValidator,
-          ctx.data
-        );
-      }
+      if ("inputValidator" in nextMiddleware.options && nextMiddleware.options.inputValidator && env === "server") ctx.data = await execValidator(nextMiddleware.options.inputValidator, ctx.data);
       let middlewareFn = void 0;
       if (env === "client") {
-        if ("client" in nextMiddleware.options) {
-          middlewareFn = nextMiddleware.options.client;
-        }
-      } else if ("server" in nextMiddleware.options) {
-        middlewareFn = nextMiddleware.options.server;
-      }
+        if ("client" in nextMiddleware.options) middlewareFn = nextMiddleware.options.client;
+      } else if ("server" in nextMiddleware.options) middlewareFn = nextMiddleware.options.server;
       if (middlewareFn) {
         const userNext = async (userCtx = {}) => {
-          const nextCtx = {
+          const result2 = await callNextMiddleware({
             ...ctx,
             ...userCtx,
             context: safeObjectMerge(ctx.context, userCtx.context),
@@ -234,34 +288,23 @@ async function executeMiddleware$1(middlewares, env, opts) {
             fetch: ctx._callSiteFetch ?? userCtx.fetch ?? ctx.fetch,
             result: userCtx.result !== void 0 ? userCtx.result : userCtx instanceof Response ? userCtx : ctx.result,
             error: userCtx.error ?? ctx.error
-          };
-          const result2 = await callNextMiddleware(nextCtx);
-          if (result2.error) {
-            throw result2.error;
-          }
+          });
+          if (result2.error) throw result2.error;
           return result2;
         };
         const result = await middlewareFn({
           ...ctx,
           next: userNext
         });
-        if (isRedirect(result)) {
-          return {
-            ...ctx,
-            error: result
-          };
-        }
-        if (result instanceof Response) {
-          return {
-            ...ctx,
-            result
-          };
-        }
-        if (!result) {
-          throw new Error(
-            "User middleware returned undefined. You must call next() or return a result in your middlewares."
-          );
-        }
+        if (isRedirect(result)) return {
+          ...ctx,
+          error: result
+        };
+        if (result instanceof Response) return {
+          ...ctx,
+          result
+        };
+        if (!result) throw new Error("User middleware returned undefined. You must call next() or return a result in your middlewares.");
         return result;
       }
       return callNextMiddleware(ctx);
@@ -284,15 +327,9 @@ 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);
@@ -306,16 +343,11 @@ async function execValidator(validator, input) {
   if (validator == null) return {};
   if ("~standard" in validator) {
     const result = await validator["~standard"].validate(input);
-    if (result.issues)
-      throw new Error(JSON.stringify(result.issues, void 0, 2));
+    if (result.issues) throw new Error(JSON.stringify(result.issues, void 0, 2));
     return result.value;
   }
-  if ("parse" in validator) {
-    return validator.parse(input);
-  }
-  if (typeof validator === "function") {
-    return validator(input);
-  }
+  if ("parse" in validator) return validator.parse(input);
+  if (typeof validator === "function") return validator(input);
   throw new Error("Invalid validator type!");
 }
 function serverFnBaseToMiddleware(options) {
@@ -326,12 +358,10 @@ function serverFnBaseToMiddleware(options) {
       client: async ({ next, sendContext, fetch: fetch2, ...ctx }) => {
         const payload = {
           ...ctx,
-          // switch the sendContext over to context
           context: sendContext,
           fetch: fetch2
         };
-        const res = await options.extractedFn?.(payload);
-        return next(res);
+        return next(await options.extractedFn?.(payload));
       },
       server: async ({ next, ...ctx }) => {
         const result = await options.serverFn?.(ctx);
@@ -344,118 +374,10 @@ function serverFnBaseToMiddleware(options) {
   };
 }
 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";
-}
-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) => {
-    const h3Event = new H3Event(request);
-    const response = eventStorage.run(
-      { h3Event },
-      () => handler(request, requestOpts)
-    );
-    return toResponse(attachResponseHeaders(response, 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() {
-  const event = getH3Event();
-  return event.res;
+  return [...getStartOptions()?.serializationAdapters?.map(makeSerovalPlugin) ?? [], ...defaultSerovalPlugins];
 }
-async function getStartManifest(matchedRoutes) {
-  const { tsrStartManifest } = await import("./assets/_tanstack-start-manifest_v-Dmhlhehg.js");
-  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);
+var textEncoder$1 = new TextEncoder();
+var EMPTY_PAYLOAD = new Uint8Array(0);
 function encodeFrame(type, streamId, payload) {
   const frame = new Uint8Array(FRAME_HEADER_SIZE + payload.length);
   frame[0] = type;
@@ -511,9 +433,7 @@ function createMultiplexedStream(jsonStream, rawStreams) {
   };
   const checkComplete = () => {
     activePumps--;
-    if (activePumps === 0) {
-      safeClose();
-    }
+    if (activePumps === 0) safeClose();
   };
   return new ReadableStream({
     start(controller) {
@@ -563,107 +483,44 @@ function createMultiplexedStream(jsonStream, rawStreams) {
         }
       };
       pumpJSON();
-      for (const [streamId, stream] of rawStreams) {
-        pumpRawStream(streamId, stream);
-      }
+      for (const [streamId, stream] of rawStreams) pumpRawStream(streamId, stream);
     },
     cancel() {
       cancelled = true;
       controllerRef = null;
-      for (const cancelReader of cancelReaders) {
-        cancelReader();
-      }
+      for (const cancelReader of cancelReaders) cancelReader();
       cancelReaders.length = 0;
     }
   });
 }
-const manifest = { "ff8a3161afdfa175e9c519e4146a56ab5bce6e80745e99cfc2191ebbb7a859bb": {
-  functionName: "getSessionDetail_createServerFn_handler",
-  importer: () => import("./assets/session-detail.server-BIoOQwSE.js")
-}, "4b9a58c176f487b49800a372100037cdf33cf048f3592a449f115c7e3f5ea799": {
-  functionName: "getStats_createServerFn_handler",
-  importer: () => import("./assets/stats.server-DhzOihwM.js")
-}, "810657681a273df5b4e58f0d8fcc6a5451598b489431b9bcaa98eea0ad815da8": {
-  functionName: "getSettings_createServerFn_handler",
-  importer: () => import("./assets/settings.server-6B2PvLgf.js")
-}, "3050115d92ca91ab1fd8fd698e33076328aae80dc64ca27c088eee16cebccc1a": {
-  functionName: "saveSettings_createServerFn_handler",
-  importer: () => import("./assets/settings.server-6B2PvLgf.js")
-}, "bf8e4a7901f1843bdc9c46be1ad5ad59c615b8bbe611b73eb3ff28f20e43ee0d": {
-  functionName: "getSessionList_createServerFn_handler",
-  importer: () => import("./assets/sessions.server-Biq8gbAJ.js")
-}, "839d29fe93dfa2a6d506af7b48ca25197190a5ff4c796e970ddfdc6e8c98827f": {
-  functionName: "getActiveSessionList_createServerFn_handler",
-  importer: () => import("./assets/sessions.server-Biq8gbAJ.js")
-}, "a3f42f9012fd83586787da8f7cb90649da739dd947d867eb67572f68735ff495": {
-  functionName: "getPaginatedSessions_createServerFn_handler",
-  importer: () => import("./assets/sessions.server-Biq8gbAJ.js")
-}, "955327d72ca3168c4751159ca07b8fb0fe0d2381dd0b991f06b941480959fbe8": {
-  functionName: "getAppInfo_createServerFn_handler",
-  importer: () => import("./assets/app-info.server-CXcS0a5s.js")
-}, "64052f224a1d6696436e5d3deeee2b798f0742e1292ffabd038c3a7bf75e6fcb": {
-  functionName: "getProjectAnalytics_createServerFn_handler",
-  importer: () => import("./assets/project-analytics.server-Bxk8-NnT.js")
-} };
-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();
+var serovalPlugins = void 0;
+var textEncoder = new TextEncoder();
+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 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) {
-    const parsedPayload = fromJSON(payload, { plugins: serovalPlugins });
-    return parsedPayload;
+    return fromJSON(payload, { plugins: serovalPlugins });
   }
-  const response = await (async () => {
+  return await (async () => {
     try {
       let serializeResult = function(res2) {
         let nonStreamingBody = void 0;
         const alsResponse = getResponse();
         if (res2 !== void 0) {
           const rawStreams = /* @__PURE__ */ new Map();
-          const rawStreamPlugin = createRawStreamRPCPlugin(
-            (id, stream2) => {
-              rawStreams.set(id, stream2);
-            }
-          );
-          const plugins = [rawStreamPlugin, ...serovalPlugins || []];
+          const plugins = [createRawStreamRPCPlugin((id, stream2) => {
+            rawStreams.set(id, stream2);
+          }), ...serovalPlugins || []];
           let done = false;
           const callbacks = {
             onParse: (value) => {
@@ -689,41 +546,28 @@ const handleServerAction = async ({
               callbacks.onError(error);
             }
           });
-          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 (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(new ReadableStream({ start(controller) {
+              callbacks.onParse = (value) => {
+                controller.enqueue(JSON.stringify(value) + "\n");
+              };
+              callbacks.onDone = () => {
+                try {
+                  controller.close();
+                } catch {
                 }
-              }
-            });
-            const multiplexedStream = createMultiplexedStream(
-              jsonStream,
-              rawStreams
-            );
+              };
+              callbacks.onError = (error) => controller.error(error);
+              if (nonStreamingBody !== void 0) callbacks.onParse(nonStreamingBody);
+            } }), rawStreams);
             return new Response(multiplexedStream, {
               status: alsResponse.status,
               statusText: alsResponse.statusText,
@@ -733,24 +577,18 @@ const handleServerAction = async ({
               }
             });
           }
-          const stream = new ReadableStream({
-            start(controller) {
-              callbacks.onParse = (value) => controller.enqueue(
-                textEncoder.encode(JSON.stringify(value) + "\n")
-              );
-              callbacks.onDone = () => {
-                try {
-                  controller.close();
-                } catch (error) {
-                  controller.error(error);
-                }
-              };
-              callbacks.onError = (error) => controller.error(error);
-              if (nonStreamingBody !== void 0) {
-                callbacks.onParse(nonStreamingBody);
+          const stream = new ReadableStream({ start(controller) {
+            callbacks.onParse = (value) => controller.enqueue(textEncoder.encode(JSON.stringify(value) + "\n"));
+            callbacks.onDone = () => {
+              try {
+                controller.close();
+              } catch (error) {
+                controller.error(error);
               }
-            }
-          });
+            };
+            callbacks.onError = (error) => controller.error(error);
+            if (nonStreamingBody !== void 0) callbacks.onParse(nonStreamingBody);
+          } });
           return new Response(stream, {
             status: alsResponse.status,
             statusText: alsResponse.statusText,
@@ -766,13 +604,8 @@ const handleServerAction = async ({
         });
       };
       let res = await (async () => {
-        if (FORM_DATA_CONTENT_TYPES.some(
-          (type) => contentType && contentType.includes(type)
-        )) {
-          invariant(
-            methodLower !== "get",
-            "GET requests with FormData payloads are not supported"
-          );
+        if (FORM_DATA_CONTENT_TYPES.some((type) => contentType && contentType.includes(type))) {
+          invariant(methodUpper !== "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);
@@ -781,85 +614,54 @@ const handleServerAction = async ({
             data: formData,
             method: methodUpper
           };
-          if (typeof serializedContext === "string") {
-            try {
-              const parsedContext = JSON.parse(serializedContext);
-              const deserializedContext = fromJSON(parsedContext, {
-                plugins: serovalPlugins
-              });
-              if (typeof deserializedContext === "object" && deserializedContext) {
-                params.context = safeObjectMerge(
-                  context,
-                  deserializedContext
-                );
-              }
-            } catch (e) {
-              if (false) ;
-            }
+          if (typeof serializedContext === "string") try {
+            const deserializedContext = fromJSON(JSON.parse(serializedContext), { plugins: serovalPlugins });
+            if (typeof deserializedContext === "object" && deserializedContext) params.context = safeObjectMerge(context, deserializedContext);
+          } catch (e) {
+            if (false) ;
           }
           return await action(params);
         }
-        if (methodLower === "get") {
+        if (methodUpper === "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(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(
-          toCrossJSONAsync(error, {
-            refs: /* @__PURE__ */ new Map(),
-            plugins: serovalPlugins
-          })
-        )
-      );
-      const response2 = getResponse();
+      const serializedError = JSON.stringify(await Promise.resolve(toCrossJSONAsync(error, {
+        refs: /* @__PURE__ */ new Map(),
+        plugins: serovalPlugins
+      })));
+      const response = getResponse();
       return new Response(serializedError, {
-        status: response2.status ?? 500,
-        statusText: response2.statusText,
+        status: response.status ?? 500,
+        statusText: response.statusText,
         headers: {
           "Content-Type": "application/json",
           [X_TSS_SERIALIZED]: "true"
@@ -867,7 +669,6 @@ const handleServerAction = async ({
       });
     }
   })();
-  return response;
 };
 function isNotFoundResponse(error) {
   const { headers, ...rest } = error;
@@ -888,33 +689,25 @@ function resolveTransformConfig(transform) {
       cache: true
     };
   }
-  if (typeof transform === "function") {
-    return {
-      type: "transform",
-      transformFn: transform,
-      cache: true
-    };
-  }
-  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;
+  if (typeof transform === "function") return {
+    type: "transform",
+    transformFn: transform,
+    cache: true
+  };
+  if ("createTransform" in transform && transform.createTransform) return {
+    type: "createTransform",
+    createTransform: transform.createTransform,
+    cache: transform.cache !== false
+  };
   return {
     type: "transform",
-    transformFn,
+    transformFn: typeof transform.transform === "string" ? (({ url }) => `${transform.transform}${url}`) : transform.transform,
     cache: transform.cache !== false
   };
 }
 function buildClientEntryScriptTag(clientEntry, injectedHeadScripts) {
-  const clientEntryLiteral = JSON.stringify(clientEntry);
-  let script = `import(${clientEntryLiteral})`;
-  if (injectedHeadScripts) {
-    script = `${injectedHeadScripts};${script}`;
-  }
+  let script = `import(${JSON.stringify(clientEntry)})`;
+  if (injectedHeadScripts) script = `${injectedHeadScripts};${script}`;
   return {
     tag: "script",
     attrs: {
@@ -928,66 +721,41 @@ 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.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"
-              })
-            );
-          }
-        }
+        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"
+        }));
       }
     }
-    const transformedClientEntry = await Promise.resolve(
-      transformFn({
-        url: source.clientEntry,
-        type: "clientEntry"
-      })
-    );
+    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
-        )
-      );
+      rootRoute.assets.push(buildClientEntryScriptTag(transformedClientEntry, source.injectedHeadScripts));
     }
     return manifest2;
   })();
 }
 function buildManifestWithClientEntry(source) {
-  const scriptTag = buildClientEntryScriptTag(
-    source.clientEntry,
-    source.injectedHeadScripts
-  );
+  const scriptTag = buildClientEntryScriptTag(source.clientEntry, source.injectedHeadScripts);
   const baseRootRoute = source.manifest.routes[rootRouteId];
-  const routes = {
+  return { routes: {
     ...source.manifest.routes,
-    ...baseRootRoute ? {
-      [rootRouteId]: {
-        ...baseRootRoute,
-        assets: [...baseRootRoute.assets || [], scriptTag]
-      }
-    } : {}
-  };
-  return { routes };
+    ...baseRootRoute ? { [rootRouteId]: {
+      ...baseRootRoute,
+      assets: [...baseRootRoute.assets || [], scriptTag]
+    } } : {}
+  } };
 }
-const HEADERS = {
-  TSS_SHELL: "X-TSS_SHELL"
-};
-const ServerFunctionSerializationAdapter = createSerializationAdapter({
+var ServerFunctionSerializationAdapter = createSerializationAdapter({
   key: "$TSS/serverfn",
   test: (v) => {
     if (typeof v !== "function") return false;
@@ -997,42 +765,32 @@ const ServerFunctionSerializationAdapter = createSerializationAdapter({
   toSerializable: ({ serverFnMeta }) => ({ functionId: serverFnMeta.id }),
   fromSerializable: ({ functionId }) => {
     const fn = async (opts, signal) => {
-      const serverFn = await getServerFnById(functionId);
-      const result = await serverFn(opts ?? {}, signal);
-      return result.result;
+      return (await (await getServerFnById(functionId))(opts ?? {}, signal)).result;
     };
     return fn;
   }
 });
 function getStartResponseHeaders(opts) {
-  const headers = mergeHeaders(
-    {
-      "Content-Type": "text/html; charset=utf-8"
-    },
-    ...opts.router.state.matches.map((match) => {
-      return match.headers;
-    })
-  );
-  return headers;
+  return mergeHeaders({ "Content-Type": "text/html; charset=utf-8" }, ...opts.router.state.matches.map((match) => {
+    return match.headers;
+  }));
 }
-let entriesPromise;
-let baseManifestPromise;
-let cachedFinalManifestPromise;
+var entriesPromise;
+var baseManifestPromise;
+var cachedFinalManifestPromise;
 async function loadEntries() {
-  const routerEntry = await import("./assets/router-5hznwWqr.js").then((n) => n.r);
-  const startEntry = await import("./assets/start-HYkvq4Ni.js");
-  return { startEntry, routerEntry };
+  const routerEntry = await import("./assets/router-DAepjaOj.js").then((n) => n.r);
+  return {
+    startEntry: await import("./assets/start-HYkvq4Ni.js"),
+    routerEntry
+  };
 }
 function getEntries() {
-  if (!entriesPromise) {
-    entriesPromise = loadEntries();
-  }
+  if (!entriesPromise) entriesPromise = loadEntries();
   return entriesPromise;
 }
 function getBaseManifest(matchedRoutes) {
-  if (!baseManifestPromise) {
-    baseManifestPromise = getStartManifest();
-  }
+  if (!baseManifestPromise) baseManifestPromise = getStartManifest();
   return baseManifestPromise;
 }
 async function resolveManifest(matchedRoutes, transformFn, cache) {
@@ -1041,19 +799,17 @@ async function resolveManifest(matchedRoutes, transformFn, cache) {
     return transformFn ? await transformManifestUrls(base, transformFn, { clone: !cache }) : buildManifestWithClientEntry(base);
   };
   if (!transformFn || cache) {
-    if (!cachedFinalManifestPromise) {
-      cachedFinalManifestPromise = computeFinalManifest();
-    }
+    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";
+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 throwRouteHandlerError() {
   throw new Error(ERR_NO_RESPONSE);
 }
@@ -1064,30 +820,25 @@ function isSpecialResponse(value) {
   return value instanceof Response || isRedirect(value);
 }
 function handleCtxResult(result) {
-  if (isSpecialResponse(result)) {
-    return { response: result };
-  }
+  if (isSpecialResponse(result)) return { response: result };
   return result;
 }
 function executeMiddleware(middlewares, ctx) {
   let index = -1;
   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 !== "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)) {
         ctx.response = err;
@@ -1097,26 +848,21 @@ function executeMiddleware(middlewares, ctx) {
     }
     const normalized = handleCtxResult(result);
     if (normalized) {
-      if (normalized.response !== void 0) {
-        ctx.response = 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;
   };
   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;
   };
 }
@@ -1131,11 +877,7 @@ function createStartHandler(cbOrOptions) {
     if (!resolvedTransformConfig) return void 0;
     if (resolvedTransformConfig.type === "createTransform") {
       if (cache) {
-        if (!cachedCreateTransformPromise) {
-          cachedCreateTransformPromise = Promise.resolve(
-            resolvedTransformConfig.createTransform(opts)
-          );
-        }
+        if (!cachedCreateTransformPromise) cachedCreateTransformPromise = Promise.resolve(resolvedTransformConfig.createTransform(opts));
         return cachedCreateTransformPromise;
       }
       return resolvedTransformConfig.createTransform(opts);
@@ -1150,9 +892,7 @@ function createStartHandler(cbOrOptions) {
     })();
     cachedFinalManifestPromise = warmupPromise;
     warmupPromise.catch(() => {
-      if (cachedFinalManifestPromise === warmupPromise) {
-        cachedFinalManifestPromise = void 0;
-      }
+      if (cachedFinalManifestPromise === warmupPromise) cachedFinalManifestPromise = void 0;
       cachedCreateTransformPromise = void 0;
     });
   }
@@ -1163,98 +903,62 @@ function createStartHandler(cbOrOptions) {
       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 startOptions = await entries.startEntry.startInstance?.getOptions() || {};
-      const serializationAdapters = [
-        ...startOptions.serializationAdapters || [],
-        ServerFunctionSerializationAdapter
-      ];
+      const serializationAdapters = [...startOptions.serializationAdapters || [], ServerFunctionSerializationAdapter];
       const requestStartOptions = {
         ...startOptions,
         serializationAdapters
       };
       const flattenedRequestMiddlewares = startOptions.requestMiddleware ? flattenMiddlewares(startOptions.requestMiddleware) : [];
-      const executedRequestMiddlewares = new Set(
-        flattenedRequestMiddlewares
-      );
+      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)) {
         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
-            },
-            () => handleServerAction({
-              request,
-              context: requestOpts?.context,
-              serverFnId
-            })
-          );
+          return runWithStartContext({
+            getRouter,
+            startOptions: requestStartOptions,
+            contextAfterGlobalMiddlewares: context,
+            request,
+            executedRequestMiddlewares
+          }, () => handleServerAction({
+            request,
+            context: requestOpts?.context,
+            serverFnId
+          }));
         };
-        const middlewares2 = flattenedRequestMiddlewares.map(
-          (d) => d.options.server
-        );
-        const ctx2 = await executeMiddleware([...middlewares2, serverFnHandler], {
+        return handleRedirectResponse((await executeMiddleware([...flattenedRequestMiddlewares.map((d) => d.options.server), serverFnHandler], {
           request,
           pathname: url.pathname,
           context: createNullProtoObject(requestOpts?.context)
-        });
-        return handleRedirectResponse(ctx2.response, request, getRouter);
+        })).response, request, getRouter);
       }
       const executeRouter = async (serverContext, 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 acceptParts = (request.headers.get("Accept") || "*/*").split(",");
+        if (!["*/*", "text/html"].some((mimeType) => acceptParts.some((part) => part.trim().startsWith(mimeType)))) 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,
@@ -1262,13 +966,9 @@ function createStartHandler(cbOrOptions) {
         });
         routerInstance.update({ additionalContext: { serverContext } });
         await routerInstance.load();
-        if (routerInstance.state.redirect) {
-          return routerInstance.state.redirect;
-        }
+        if (routerInstance.state.redirect) return routerInstance.state.redirect;
         await routerInstance.serverSsr.dehydrate();
-        const responseHeaders = getStartResponseHeaders({
-          router: routerInstance
-        });
+        const responseHeaders = getStartResponseHeaders({ router: routerInstance });
         cbWillCleanup = true;
         return cb({
           request,
@@ -1277,103 +977,66 @@ function createStartHandler(cbOrOptions) {
         });
       };
       const requestHandlerMiddleware = async ({ context }) => {
-        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;
-            }
+        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 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);
+      return handleRedirectResponse((await executeMiddleware([...flattenedRequestMiddlewares.map((d) => d.options.server), requestHandlerMiddleware], {
+        request,
+        pathname: url.pathname,
+        context: createNullProtoObject(requestOpts?.context)
+      })).response, request, getRouter);
     } finally {
-      if (router && !cbWillCleanup) {
-        router.serverSsr?.cleanup();
-      }
+      if (router && !cbWillCleanup) router.serverSsr?.cleanup();
       router = null;
     }
   };
   return requestHandler(startRequestResolver);
 }
 async function handleRedirectResponse(response, request, getRouter) {
-  if (!isRedirect(response)) {
-    return response;
-  }
+  if (!isRedirect(response)) return response;
   if (isResolvedRedirect(response)) {
-    if (request.headers.get("x-tsr-serverFn") === "true") {
-      return Response.json(
-        { ...response.options, isSerializedRedirect: true },
-        { headers: response.headers }
-      );
-    }
+    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 }
-    );
-  }
+  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(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 rewrittenUrl = executeRewriteInput(router.rewrite, url);
-  const pathname = rewrittenUrl.pathname;
+  const pathname = executeRewriteInput(router.rewrite, url).pathname;
   const { matchedRoutes, foundRoute, routeParams } = router.getMatchedRoutes(pathname);
   const isExactMatch = foundRoute && routeParams["**"] === void 0;
   const routeMiddlewares = [];
@@ -1381,45 +1044,32 @@ async function handleServerRoutes({
     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;
   if (server2?.handlers && isExactMatch) {
     const handlers = typeof server2.handlers === "function" ? server2.handlers({ createHandlers: (d) => d }) : server2.handlers;
-    const requestMethod = request.method.toUpperCase();
-    const handler = handlers[requestMethod] ?? handlers["ANY"];
+    const handler = handlers[request.method.toUpperCase()] ?? 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);
-          }
-        }
-        if (handler.handler) {
-          routeMiddlewares.push(handlerToMiddleware(handler.handler, mayDefer));
+          for (const m of handlerMiddlewares) routeMiddlewares.push(m.options.server);
         }
+        if (handler.handler) routeMiddlewares.push(handlerToMiddleware(handler.handler, mayDefer));
       }
     }
   }
-  routeMiddlewares.push(
-    (ctx2) => executeRouter(ctx2.context, matchedRoutes)
-  );
-  const ctx = await executeMiddleware(routeMiddlewares, {
+  routeMiddlewares.push((ctx) => executeRouter(ctx.context, matchedRoutes));
+  return (await executeMiddleware(routeMiddlewares, {
     request,
     context,
     params: routeParams,
     pathname
-  });
-  return ctx.response;
+  })).response;
 }
 const fetch = createStartHandler(defaultStreamHandler);
 function createServerEntry(entry) {