@tanstack/start-server-core 1.121.0-alpha.26 → 1.121.0-alpha.28

package/src/request-response.ts

@@ -0,0 +1,335 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+import {
+  H3Event,
+  clearSession as h3_clearSession,
+  deleteCookie as h3_deleteCookie,
+  getRequestHost as h3_getRequestHost,
+  getRequestIP as h3_getRequestIP,
+  getRequestProtocol as h3_getRequestProtocol,
+  getRequestURL as h3_getRequestURL,
+  getSession as h3_getSession,
+  getValidatedQuery as h3_getValidatedQuery,
+  parseCookies as h3_parseCookies,
+  sanitizeStatusCode as h3_sanitizeStatusCode,
+  sanitizeStatusMessage as h3_sanitizeStatusMessage,
+  sealSession as h3_sealSession,
+  setCookie as h3_setCookie,
+  toResponse as h3_toResponse,
+  unsealSession as h3_unsealSession,
+  updateSession as h3_updateSession,
+  useSession as h3_useSession,
+} from 'h3'
+import type {
+  RequestHeaderMap,
+  RequestHeaderName,
+  ResponseHeaderMap,
+  ResponseHeaderName,
+  TypedHeaders,
+} from 'fetchdts'
+
+import type { CookieSerializeOptions } from 'cookie-es'
+import type {
+  Session,
+  SessionConfig,
+  SessionData,
+  SessionManager,
+  SessionUpdate,
+} from './session'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+
+interface StartEvent {
+  h3Event: H3Event
+}
+const eventStorage = new AsyncLocalStorage<StartEvent>()
+
+export type RequestHandler = (request: Request) => Promise<Response> | Response
+
+export type { ResponseHeaderName, RequestHeaderName }
+
+export function requestHandler(handler: RequestHandler) {
+  return (request: Request): Promise<Response> | Response => {
+    const h3Event = new H3Event(request)
+
+    const response = eventStorage.run({ h3Event }, () => handler(request))
+    return h3_toResponse(response, 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
+}
+
+export function getRequest(): Request {
+  const event = getH3Event()
+  return event.req
+}
+
+export function getRequestHeaders(): TypedHeaders<RequestHeaderMap> {
+  // TODO `as any` not needed when fetchdts is updated
+  return getH3Event().req.headers as any
+}
+
+export function getRequestHeader(name: RequestHeaderName): string | undefined {
+  return getRequestHeaders().get(name) || undefined
+}
+
+export function getRequestIP(opts?: {
+  /**
+   * Use the X-Forwarded-For HTTP header set by proxies.
+   *
+   * Note: Make sure that this header can be trusted (your application running behind a CDN or reverse proxy) before enabling.
+   */
+  xForwardedFor?: boolean
+}) {
+  return h3_getRequestIP(getH3Event(), opts)
+}
+
+/**
+ * Get the request hostname.
+ *
+ * If `xForwardedHost` is `true`, it will use the `x-forwarded-host` header if it exists.
+ *
+ * If no host header is found, it will default to "localhost".
+ */
+export function getRequestHost(opts?: { xForwardedHost?: boolean }) {
+  return h3_getRequestHost(getH3Event(), opts)
+}
+
+/**
+ * Get the full incoming request URL.
+ *
+ * If `xForwardedHost` is `true`, it will use the `x-forwarded-host` header if it exists.
+ *
+ * If `xForwardedProto` is `false`, it will not use the `x-forwarded-proto` header.
+ */
+export function getRequestUrl(opts?: {
+  xForwardedHost?: boolean
+  xForwardedProto?: boolean
+}) {
+  return h3_getRequestURL(getH3Event(), opts)
+}
+
+/**
+ * Get the request protocol.
+ *
+ * If `x-forwarded-proto` header is set to "https", it will return "https". You can disable this behavior by setting `xForwardedProto` to `false`.
+ *
+ * If protocol cannot be determined, it will default to "http".
+ */
+export function getRequestProtocol(opts?: {
+  xForwardedProto?: boolean
+}): 'http' | 'https' | (string & {}) {
+  return h3_getRequestProtocol(getH3Event(), opts)
+}
+
+export function setResponseHeaders(
+  headers: TypedHeaders<ResponseHeaderMap>,
+): void {
+  const event = getH3Event()
+  for (const [name, value] of Object.entries(headers)) {
+    event.res.headers.set(name, value)
+  }
+}
+
+export function getResponseHeaders(): TypedHeaders<ResponseHeaderMap> {
+  const event = getH3Event()
+  return Object.fromEntries(event.res.headers.entries()) as any
+}
+
+export function getResponseHeader(
+  name: ResponseHeaderName,
+): string | undefined {
+  const event = getH3Event()
+  return event.res.headers.get(name) || undefined
+}
+
+export function setResponseHeader(
+  name: ResponseHeaderName,
+  value: string | Array<string>,
+): void {
+  const event = getH3Event()
+  if (Array.isArray(value)) {
+    event.res.headers.delete(name)
+    for (const valueItem of value) {
+      event.res.headers.append(name, valueItem)
+    }
+  } else {
+    event.res.headers.set(name, value)
+  }
+}
+export function removeResponseHeader(name: ResponseHeaderName): void {
+  const event = getH3Event()
+  event.res.headers.delete(name)
+}
+
+export function clearResponseHeaders(
+  headerNames?: Array<ResponseHeaderName>,
+): void {
+  const event = getH3Event()
+  // If headerNames is provided, clear only those headers
+  if (headerNames && headerNames.length > 0) {
+    for (const name of headerNames) {
+      event.res.headers.delete(name)
+    }
+    // Otherwise, clear all headers
+  } else {
+    for (const name of event.res.headers.keys()) {
+      event.res.headers.delete(name)
+    }
+  }
+}
+
+export function getResponseStatus(): number {
+  return getH3Event().res.status || 200
+}
+
+export function setResponseStatus(code?: number, text?: string): void {
+  const event = getH3Event()
+  if (code) {
+    event.res.status = h3_sanitizeStatusCode(code, event.res.status)
+  }
+  if (text) {
+    event.res.statusText = h3_sanitizeStatusMessage(text)
+  }
+}
+
+/**
+ * Parse the request to get HTTP Cookie header string and return an object of all cookie name-value pairs.
+ * @returns Object of cookie name-value pairs
+ * ```ts
+ * const cookies = getCookies()
+ * ```
+ */
+export function getCookies(): Record<string, string> {
+  const event = getH3Event()
+  return h3_parseCookies(event)
+}
+
+/**
+ * Get a cookie value by name.
+ * @param name Name of the cookie to get
+ * @returns {*} Value of the cookie (String or undefined)
+ * ```ts
+ * const authorization = getCookie('Authorization')
+ * ```
+ */
+export function getCookie(name: string): string | undefined {
+  return getCookies()[name] || undefined
+}
+
+/**
+ * Set a cookie value by name.
+ * @param name Name of the cookie to set
+ * @param value Value of the cookie to set
+ * @param options {CookieSerializeOptions} Options for serializing the cookie
+ * ```ts
+ * setCookie('Authorization', '1234567')
+ * ```
+ */
+export function setCookie(
+  name: string,
+  value: string,
+  options?: CookieSerializeOptions,
+): void {
+  const event = getH3Event()
+  h3_setCookie(event, name, value, options)
+}
+
+/**
+ * Remove a cookie by name.
+ * @param name Name of the cookie to delete
+ * @param serializeOptions {CookieSerializeOptions} Cookie options
+ * ```ts
+ * deleteCookie('SessionId')
+ * ```
+ */
+export function deleteCookie(
+  name: string,
+  options?: CookieSerializeOptions,
+): void {
+  const event = getH3Event()
+  h3_deleteCookie(event, name, options)
+}
+
+function getDefaultSessionConfig(config: SessionConfig): SessionConfig {
+  return {
+    name: 'start',
+    ...config,
+  }
+}
+
+/**
+ * Create a session manager for the current request.
+ */
+export function useSession<TSessionData extends SessionData = SessionData>(
+  config: SessionConfig,
+): Promise<SessionManager<TSessionData>> {
+  const event = getH3Event()
+  return h3_useSession(event, getDefaultSessionConfig(config))
+}
+/**
+ * Get the session for the current request
+ */
+export function getSession<TSessionData extends SessionData = SessionData>(
+  config: SessionConfig,
+): Promise<Session<TSessionData>> {
+  const event = getH3Event()
+  return h3_getSession(event, getDefaultSessionConfig(config))
+}
+
+/**
+ * Update the session data for the current request.
+ */
+export function updateSession<TSessionData extends SessionData = SessionData>(
+  config: SessionConfig,
+  update?: SessionUpdate<TSessionData>,
+): Promise<Session<TSessionData>> {
+  const event = getH3Event()
+  return h3_updateSession(event, getDefaultSessionConfig(config), update)
+}
+
+/**
+ * Encrypt and sign the session data for the current request.
+ */
+export function sealSession(config: SessionConfig): Promise<string> {
+  const event = getH3Event()
+  return h3_sealSession(event, getDefaultSessionConfig(config))
+}
+/**
+ * Decrypt and verify the session data for the current request.
+ */
+export function unsealSession(
+  config: SessionConfig,
+  sealed: string,
+): Promise<Partial<Session>> {
+  const event = getH3Event()
+  return h3_unsealSession(event, getDefaultSessionConfig(config), sealed)
+}
+
+/**
+ * Clear the session data for the current request.
+ */
+export function clearSession(config: Partial<SessionConfig>): Promise<void> {
+  const event = getH3Event()
+  return h3_clearSession(event, { name: 'start', ...config })
+}
+
+// not public API
+export function getResponse() {
+  const event = getH3Event()
+  return event._res
+}
+
+// not public API (yet)
+export function getValidatedQuery<TSchema extends StandardSchemaV1>(
+  schema: StandardSchemaV1,
+): Promise<StandardSchemaV1.InferOutput<TSchema>> {
+  return h3_getValidatedQuery(getH3Event(), schema)
+}

package/src/router-manifest.ts

@@ -1,4 +1,4 @@
-import { joinPaths, rootRouteId } from '@tanstack/router-core'
+import { rootRouteId } from '@tanstack/router-core'
 import { VIRTUAL_MODULES } from './virtual-modules'
 import { loadVirtualModule } from './loadVirtualModule'
 
@@ -19,45 +19,24 @@ export async function getStartManifest(opts: { basePath: string }) {
 
   rootRoute.assets = rootRoute.assets || []
 
-  // Get the entry for the client
-  // const ClientManifest = getManifest('client')
-
-  // const importPath =
-  //   ClientManifest.inputs[ClientManifest.handler]?.output.path
-  // if (!importPath) {
-  //   invariant(importPath, 'Could not find client entry in manifest')
-  // }
-
-  if (process.env.NODE_ENV === 'development' && !process.env.TSS_CLIENT_ENTRY) {
-    throw new Error(
-      'tanstack/start-server-core: TSS_CLIENT_ENTRY must be defined in your environment for getStartManifest()',
+  let script = `import('${startManifest.clientEntry}')`
+  if (process.env.TSS_DEV_SERVER === 'true') {
+    const { injectedHeadScripts } = await loadVirtualModule(
+      VIRTUAL_MODULES.injectedHeadScripts,
     )
+    if (injectedHeadScripts) {
+      script = `${injectedHeadScripts + ';'}${script}`
+    }
   }
-
-  if (process.env.NODE_ENV === 'development') {
-    // Always fake that HMR is ready
-    // const CLIENT_BASE = sanitizeBase(process.env.TSS_CLIENT_BASE || '')
-
-    // if (!CLIENT_BASE) {
-    //   throw new Error(
-    //     'tanstack/start-router-manifest: TSS_CLIENT_BASE must be defined in your environment for getFullRouterManifest()',
-    //   )
-    // }
-
-    const clientEntry = joinPaths([opts.basePath, process.env.TSS_CLIENT_ENTRY])
-
-    const script = `${globalThis.TSS_INJECTED_HEAD_SCRIPTS ? globalThis.TSS_INJECTED_HEAD_SCRIPTS + '; ' : ''}import('${clientEntry}')`
-
-    rootRoute.assets.push({
-      tag: 'script',
-      attrs: {
-        type: 'module',
-        suppressHydrationWarning: true,
-        async: true,
-      },
-      children: script,
-    })
-  }
+  rootRoute.assets.push({
+    tag: 'script',
+    attrs: {
+      type: 'module',
+      suppressHydrationWarning: true,
+      async: true,
+    },
+    children: script,
+  })
 
   const manifest = {
     ...startManifest,

package/src/server-functions-handler.ts

@@ -1,9 +1,9 @@
 import { isNotFound } from '@tanstack/router-core'
 import invariant from 'tiny-invariant'
 import { startSerializer } from '@tanstack/start-client-core'
-import { getEvent, getResponseStatus } from './h3'
 import { VIRTUAL_MODULES } from './virtual-modules'
 import { loadVirtualModule } from './loadVirtualModule'
+import { getResponse } from './request-response'
 
 function sanitizeBase(base: string | undefined) {
   if (!base) {
@@ -55,8 +55,7 @@ export const handleServerAction = async ({ request }: { request: Request }) => {
     throw new Error('Server function info not found for ' + serverFnId)
   }
 
-  const fnModule: undefined | { [key: string]: any } =
-    await serverFnInfo.importer()
+  const fnModule = await serverFnInfo.importer()
 
   if (!fnModule) {
     console.info('serverFnInfo', serverFnInfo)
@@ -188,10 +187,12 @@ export const handleServerAction = async ({ request }: { request: Request }) => {
         return isNotFoundResponse(result)
       }
 
+      const response = getResponse()
       return new Response(
         result !== undefined ? startSerializer.stringify(result) : undefined,
         {
-          status: getResponseStatus(getEvent()),
+          status: response?.status,
+          statusText: response?.statusText,
           headers: {
             'Content-Type': 'application/json',
           },
@@ -246,7 +247,7 @@ function isNotFoundResponse(error: any) {
   const { headers, ...rest } = error
 
   return new Response(JSON.stringify(rest), {
-    status: 200,
+    status: 404,
     headers: {
       'Content-Type': 'application/json',
       ...(headers || {}),

package/src/serverRoute.ts

@@ -42,10 +42,25 @@ export interface ServerRouteOptions<
   pathname: TFullPath
   originalIndex: number
   getParentRoute?: () => TParentRoute
-  middleware: Constrain<TMiddlewares, ReadonlyArray<AnyRequestMiddleware>>
-  methods: Record<
+  middleware?: Constrain<TMiddlewares, ReadonlyArray<AnyRequestMiddleware>>
+  methods?: Record<
     string,
-    ServerRouteMethodHandlerFn<TParentRoute, TFullPath, TMiddlewares, any, any>
+    | ServerRouteMethodHandlerFn<
+        TParentRoute,
+        TFullPath,
+        TMiddlewares,
+        any,
+        any
+      >
+    | {
+        _options: ServerRouteMethodBuilderOptions<
+          TParentRoute,
+          TFullPath,
+          TMiddlewares,
+          unknown,
+          unknown
+        >
+      }
   >
   caseSensitive?: boolean
 }
@@ -70,6 +85,7 @@ export function createServerRoute<
   const options = __opts || {}
 
   const route: ServerRoute<TParentRoute, TId, TPath, TFullPath, TChildren> = {
+    isRoot: false as any,
     path: '' as TPath,
     id: '' as TId,
     fullPath: '' as TFullPath,
@@ -162,6 +178,7 @@ export function createServerRoute<
       route.id = id as TId
       route.fullPath = fullPath as TFullPath
       route.to = fullPath as TrimPathRight<TFullPath>
+      route.isRoot = isRoot as any
     },
 
     _addFileChildren: (children) => {
@@ -290,6 +307,7 @@ export interface ServerRouteWithTypes<
     TMiddlewares,
     TMethods
   >
+  isRoot: TParentRoute extends AnyServerRouteWithTypes ? true : false
   path: TPath
   id: TId
   fullPath: TFullPath
@@ -329,6 +347,7 @@ export interface ServerRouteTypes<
   TMiddlewares,
   TMethods,
 > {
+  isRoot: TParentRoute extends AnyServerRouteWithTypes ? true : false
   id: TId
   path: TPath
   fullPath: TFullPath

package/src/session.ts

@@ -0,0 +1,75 @@
+// TODO discuss do we want to copy this interface into Start we well?
+import type { CookieSerializeOptions } from 'cookie-es'
+
+// TODO discuss do we want to copy this interface into Start as shown below?
+
+/** Algorithm used for encryption and decryption. */
+type EncryptionAlgorithm = 'aes-128-ctr' | 'aes-256-cbc'
+/** Algorithm used for integrity verification. */
+type IntegrityAlgorithm = 'sha256'
+/** @internal */
+type _Algorithm = EncryptionAlgorithm | IntegrityAlgorithm
+/**
+ * Options for customizing the key derivation algorithm used to generate encryption and integrity verification keys as well as the algorithms and salt sizes used.
+ */
+type SealOptions = Readonly<{
+  /** Encryption step options. */
+  encryption: SealOptionsSub<EncryptionAlgorithm>
+  /** Integrity step options. */
+  integrity: SealOptionsSub<IntegrityAlgorithm>
+  /* Sealed object lifetime in milliseconds where 0 means forever. Defaults to 0. */
+  ttl: number
+  /** Number of seconds of permitted clock skew for incoming expirations. Defaults to 60 seconds. */
+  timestampSkewSec: number
+  /**
+   * Local clock time offset, expressed in number of milliseconds (positive or negative). Defaults to 0.
+   */
+  localtimeOffsetMsec: number
+}>
+/** `seal()` method options. */
+type SealOptionsSub<TAlgorithm extends _Algorithm = _Algorithm> = Readonly<{
+  /** The length of the salt (random buffer used to ensure that two identical objects will generate a different encrypted result). Defaults to 256. */
+  saltBits: number
+  /** The algorithm used. Defaults to 'aes-256-cbc' for encryption and 'sha256' for integrity. */
+  algorithm: TAlgorithm
+  /** The number of iterations used to derive a key from the password. Defaults to 1. */
+  iterations: number
+  /** Minimum password size. Defaults to 32. */
+  minPasswordlength: number
+}>
+/** Password secret string or buffer.*/
+
+type SessionDataT = Record<string, any>
+export type SessionData<T extends SessionDataT = SessionDataT> = Partial<T>
+export interface Session<T extends SessionDataT = SessionDataT> {
+  id: string
+  createdAt: number
+  data: SessionData<T>
+}
+
+export type SessionUpdate<T extends SessionData = SessionData> =
+  | Partial<SessionData<T>>
+  | ((oldData: SessionData<T>) => Partial<SessionData<T>> | undefined)
+
+export interface SessionManager<T extends SessionDataT = SessionDataT> {
+  readonly id: string | undefined
+  readonly data: SessionData<T>
+  update: (update: SessionUpdate<T>) => Promise<SessionManager<T>>
+  clear: () => Promise<SessionManager<T>>
+}
+export interface SessionConfig {
+  /** Private key used to encrypt session tokens */
+  password: string
+  /** Session expiration time in seconds */
+  maxAge?: number
+  /** default is 'start' */
+  name?: string
+  /** Default is secure, httpOnly, / */
+  cookie?: false | CookieSerializeOptions
+  /** Default is x-start-session / x-{name}-session */
+  sessionHeader?: false | string
+  seal?: SealOptions
+  crypto?: Crypto
+  /** Default is Crypto.randomUUID */
+  generateId?: () => string
+}

package/src/tanstack-start.d.ts

@@ -1,18 +1,31 @@
 declare module 'tanstack-start-manifest:v' {
   import type { Manifest } from '@tanstack/router-core'
 
-  export const tsrStartManifest: () => Manifest
+  export const tsrStartManifest: () => Manifest & { clientEntry: string }
 }
 
 declare module 'tanstack-start-route-tree:v' {
-  import type { AnyServerRoute } from '@tanstack/start-server-core'
+  import type { AnyServerRouteWithTypes } from '@tanstack/start-server-core'
+  import type { AnyRoute } from '@tanstack/router-core'
 
-  export const serverRouteTree: AnyServerRoute | undefined
+  export const routeTree: AnyRoute | undefined
+  export const serverRouteTree: AnyServerRouteWithTypes | undefined
 }
 
 declare module 'tanstack-start-server-fn-manifest:v' {
-  import type { DirectiveFn } from '@tanstack/directive-functions-plugin'
+  const serverFnManifest: Record<
+    string,
+    {
+      importer: () => Promise<
+        Record<string, (...args: Array<any>) => Promise<any>> | undefined
+      >
+      functionName: string
+    }
+  >
 
-  const serverFnManifest: Record<string, DirectiveFn>
   export default serverFnManifest
 }
+
+declare module 'tanstack-start-injected-head-scripts:v' {
+  export const injectedHeadScripts: string | undefined
+}

package/src/virtual-modules.ts

@@ -4,10 +4,12 @@ export const VIRTUAL_MODULES = {
   routeTree: 'tanstack-start-route-tree:v',
   startManifest: 'tanstack-start-manifest:v',
   serverFnManifest: 'tanstack-start-server-fn-manifest:v',
+  injectedHeadScripts: 'tanstack-start-injected-head-scripts:v',
 } as const
 
 export type VirtualModules = {
   [VIRTUAL_MODULES.routeTree]: typeof import('tanstack-start-route-tree:v')
   [VIRTUAL_MODULES.startManifest]: typeof import('tanstack-start-manifest:v')
   [VIRTUAL_MODULES.serverFnManifest]: typeof import('tanstack-start-server-fn-manifest:v')
+  [VIRTUAL_MODULES.injectedHeadScripts]: typeof import('tanstack-start-injected-head-scripts:v')
 }

package/dist/cjs/createRequestHandler.cjs

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const history = require("@tanstack/history");
-const startClientCore = require("@tanstack/start-client-core");
-const ssrServer = require("./ssr-server.cjs");
-function createRequestHandler({
-  createRouter,
-  request,
-  getRouterManifest
-}) {
-  return async (cb) => {
-    const router = createRouter();
-    ssrServer.attachRouterServerSsrUtils(router, await (getRouterManifest == null ? void 0 : getRouterManifest()));
-    const url = new URL(request.url, "http://localhost");
-    const href = url.href.replace(url.origin, "");
-    const history$1 = history.createMemoryHistory({
-      initialEntries: [href]
-    });
-    router.update({
-      history: history$1
-    });
-    await router.load();
-    ssrServer.dehydrateRouter(router);
-    const responseHeaders = getRequestHeaders({
-      router
-    });
-    return cb({
-      request,
-      router,
-      responseHeaders
-    });
-  };
-}
-function getRequestHeaders(opts) {
-  let headers = startClientCore.mergeHeaders(
-    {
-      "Content-Type": "text/html; charset=UTF-8"
-    },
-    ...opts.router.state.matches.map((match) => {
-      return match.headers;
-    })
-  );
-  const { redirect } = opts.router.state;
-  if (redirect) {
-    headers = startClientCore.mergeHeaders(headers, redirect.headers);
-  }
-  return headers;
-}
-exports.createRequestHandler = createRequestHandler;
-//# sourceMappingURL=createRequestHandler.cjs.map

package/dist/cjs/createRequestHandler.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRequestHandler.cjs","sources":["../../src/createRequestHandler.ts"],"sourcesContent":["import { createMemoryHistory } from '@tanstack/history'\nimport { mergeHeaders } from '@tanstack/start-client-core'\nimport { attachRouterServerSsrUtils, dehydrateRouter } from './ssr-server'\nimport type { HandlerCallback } from './handlerCallback'\nimport type { AnyRouter, Manifest } from '@tanstack/router-core'\n\nexport type RequestHandler<TRouter extends AnyRouter> = (\n  cb: HandlerCallback<TRouter>,\n) => Promise<Response>\n\nexport function createRequestHandler<TRouter extends AnyRouter>({\n  createRouter,\n  request,\n  getRouterManifest,\n}: {\n  createRouter: () => TRouter\n  request: Request\n  getRouterManifest?: () => Manifest | Promise<Manifest>\n}): RequestHandler<TRouter> {\n  return async (cb) => {\n    const router = createRouter()\n\n    attachRouterServerSsrUtils(router, await getRouterManifest?.())\n\n    const url = new URL(request.url, 'http://localhost')\n\n    const href = url.href.replace(url.origin, '')\n\n    // Create a history for the router\n    const history = createMemoryHistory({\n      initialEntries: [href],\n    })\n\n    // Update the router with the history and context\n    router.update({\n      history,\n    })\n\n    await router.load()\n\n    dehydrateRouter(router)\n\n    const responseHeaders = getRequestHeaders({\n      router,\n    })\n\n    return cb({\n      request,\n      router,\n      responseHeaders,\n    } as any)\n  }\n}\n\nfunction getRequestHeaders(opts: { router: AnyRouter }): Headers {\n  let headers = mergeHeaders(\n    {\n      'Content-Type': 'text/html; charset=UTF-8',\n    },\n    ...opts.router.state.matches.map((match) => {\n      return match.headers\n    }),\n  )\n\n  // Handle Redirects\n  const { redirect } = opts.router.state\n\n  if (redirect) {\n    headers = mergeHeaders(headers, redirect.headers)\n  }\n\n  return headers\n}\n"],"names":["attachRouterServerSsrUtils","history","createMemoryHistory","dehydrateRouter","mergeHeaders"],"mappings":";;;;;AAUO,SAAS,qBAAgD;AAAA,EAC9D;AAAA,EACA;AAAA,EACA;AACF,GAI4B;AAC1B,SAAO,OAAO,OAAO;AACnB,UAAM,SAAS,aAAa;AAEDA,yCAAA,QAAQ,OAAM,yDAAqB;AAE9D,UAAM,MAAM,IAAI,IAAI,QAAQ,KAAK,kBAAkB;AAEnD,UAAM,OAAO,IAAI,KAAK,QAAQ,IAAI,QAAQ,EAAE;AAG5C,UAAMC,YAAUC,QAAAA,oBAAoB;AAAA,MAClC,gBAAgB,CAAC,IAAI;AAAA,IAAA,CACtB;AAGD,WAAO,OAAO;AAAA,MACZD,SAAAA;AAAAA,IAAA,CACD;AAED,UAAM,OAAO,KAAK;AAElBE,cAAAA,gBAAgB,MAAM;AAEtB,UAAM,kBAAkB,kBAAkB;AAAA,MACxC;AAAA,IAAA,CACD;AAED,WAAO,GAAG;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,IAAA,CACM;AAAA,EACV;AACF;AAEA,SAAS,kBAAkB,MAAsC;AAC/D,MAAI,UAAUC,gBAAA;AAAA,IACZ;AAAA,MACE,gBAAgB;AAAA,IAClB;AAAA,IACA,GAAG,KAAK,OAAO,MAAM,QAAQ,IAAI,CAAC,UAAU;AAC1C,aAAO,MAAM;AAAA,IACd,CAAA;AAAA,EACH;AAGA,QAAM,EAAE,SAAA,IAAa,KAAK,OAAO;AAEjC,MAAI,UAAU;AACF,cAAAA,gBAAA,aAAa,SAAS,SAAS,OAAO;AAAA,EAAA;AAG3C,SAAA;AACT;;"}