@tanstack/start-server-core 1.131.7 → 1.132.0-alpha.0

package/dist/esm/virtual-modules.js

@@ -1,7 +1,8 @@
 const VIRTUAL_MODULES = {
   routeTree: "tanstack-start-route-tree:v",
   startManifest: "tanstack-start-manifest:v",
-  serverFnManifest: "tanstack-start-server-fn-manifest:v"
+  serverFnManifest: "tanstack-start-server-fn-manifest:v",
+  injectedHeadScripts: "tanstack-start-injected-head-scripts:v"
 };
 export {
   VIRTUAL_MODULES

package/dist/esm/virtual-modules.js.map

@@ -1 +1 @@
-{"version":3,"file":"virtual-modules.js","sources":["../../src/virtual-modules.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/consistent-type-imports */\n\nexport const VIRTUAL_MODULES = {\n  routeTree: 'tanstack-start-route-tree:v',\n  startManifest: 'tanstack-start-manifest:v',\n  serverFnManifest: 'tanstack-start-server-fn-manifest:v',\n} as const\n\nexport type VirtualModules = {\n  [VIRTUAL_MODULES.routeTree]: typeof import('tanstack-start-route-tree:v')\n  [VIRTUAL_MODULES.startManifest]: typeof import('tanstack-start-manifest:v')\n  [VIRTUAL_MODULES.serverFnManifest]: typeof import('tanstack-start-server-fn-manifest:v')\n}\n"],"names":[],"mappings":"AAEO,MAAM,kBAAkB;AAAA,EAC7B,WAAW;AAAA,EACX,eAAe;AAAA,EACf,kBAAkB;AACpB;"}
+{"version":3,"file":"virtual-modules.js","sources":["../../src/virtual-modules.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/consistent-type-imports */\n\nexport const VIRTUAL_MODULES = {\n  routeTree: 'tanstack-start-route-tree:v',\n  startManifest: 'tanstack-start-manifest:v',\n  serverFnManifest: 'tanstack-start-server-fn-manifest:v',\n  injectedHeadScripts: 'tanstack-start-injected-head-scripts:v',\n} as const\n\nexport type VirtualModules = {\n  [VIRTUAL_MODULES.routeTree]: typeof import('tanstack-start-route-tree:v')\n  [VIRTUAL_MODULES.startManifest]: typeof import('tanstack-start-manifest:v')\n  [VIRTUAL_MODULES.serverFnManifest]: typeof import('tanstack-start-server-fn-manifest:v')\n  [VIRTUAL_MODULES.injectedHeadScripts]: typeof import('tanstack-start-injected-head-scripts:v')\n}\n"],"names":[],"mappings":"AAEO,MAAM,kBAAkB;AAAA,EAC7B,WAAW;AAAA,EACX,eAAe;AAAA,EACf,kBAAkB;AAAA,EAClB,qBAAqB;AACvB;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/start-server-core",
-  "version": "1.131.7",
+  "version": "1.132.0-alpha.0",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -30,10 +30,6 @@
       "import": {
         "types": "./dist/esm/index.d.ts",
         "default": "./dist/esm/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/index.d.cts",
-        "default": "./dist/cjs/index.cjs"
       }
     },
     "./package.json": "./package.json"
@@ -47,21 +43,15 @@
     "node": ">=12"
   },
   "dependencies": {
-    "h3": "1.13.0",
-    "isbot": "^5.1.22",
+    "@standard-schema/spec": "^1.0.0",
+    "cookie-es": "^2.0.0",
+    "fetchdts": "^0.1.6",
+    "h3": "2.0.0-beta.3",
     "tiny-invariant": "^1.3.3",
-    "tiny-warning": "^1.0.3",
-    "unctx": "^2.4.1",
-    "@tanstack/history": "1.131.2",
-    "@tanstack/start-client-core": "1.131.7",
-    "@tanstack/start-storage-context": "1.131.7",
-    "@tanstack/router-core": "1.131.7"
-  },
-  "devDependencies": {
-    "esbuild": "^0.25.0",
-    "typescript": "^5.7.2",
-    "vite": "^6.3.5",
-    "@tanstack/directive-functions-plugin": "1.131.2"
+    "@tanstack/history": "1.132.0-alpha.0",
+    "@tanstack/router-core": "1.132.0-alpha.0",
+    "@tanstack/start-client-core": "1.132.0-alpha.0",
+    "@tanstack/start-storage-context": "1.132.0-alpha.0"
   },
   "scripts": {}
 }

package/src/createStartHandler.ts

@@ -14,7 +14,7 @@ import {
 } from '@tanstack/router-core'
 import { attachRouterServerSsrUtils } from '@tanstack/router-core/ssr/server'
 import { runWithStartContext } from '@tanstack/start-storage-context'
-import { getResponseHeaders, requestHandler } from './h3'
+import { getResponseHeaders, requestHandler } from './request-response'
 import { getStartManifest } from './router-manifest'
 import { handleServerAction } from './server-functions-handler'
 import { VIRTUAL_MODULES } from './virtual-modules'
@@ -25,7 +25,7 @@ import type {
   AnyServerRouteWithTypes,
   ServerRouteMethodHandlerFn,
 } from './serverRoute'
-import type { RequestHandler } from './h3'
+import type { RequestHandler } from './request-response'
 import type {
   AnyRoute,
   AnyRouter,
@@ -43,9 +43,9 @@ export type CustomizeStartHandler<TRouter extends AnyRouter> = (
 
 function getStartResponseHeaders(opts: { router: AnyRouter }) {
   const headers = mergeHeaders(
-    getResponseHeaders(),
+    getResponseHeaders() as Headers,
     {
-      'Content-Type': 'text/html; charset=UTF-8',
+      'Content-Type': 'text/html; charset=utf-8',
     },
     ...opts.router.state.matches.map((match) => {
       return match.headers
@@ -71,7 +71,7 @@ export function createStartHandler<TRouter extends AnyRouter>({
   return (cb) => {
     const originalFetch = globalThis.fetch
 
-    const startRequestResolver: RequestHandler = async ({ request }) => {
+    const startRequestResolver: RequestHandler = async (request) => {
       // Patching fetch function to use our request resolver
       // if the input starts with `/` which is a common pattern for
       // client-side routing.
@@ -80,7 +80,7 @@ export function createStartHandler<TRouter extends AnyRouter>({
       globalThis.fetch = async function (input, init) {
         function resolve(url: URL, requestOptions: RequestInit | undefined) {
           const fetchRequest = new Request(url, requestOptions)
-          return startRequestResolver({ request: fetchRequest })
+          return startRequestResolver(fetchRequest)
         }
 
         function getOrigin() {
@@ -111,7 +111,7 @@ export function createStartHandler<TRouter extends AnyRouter>({
       }
 
       const url = new URL(request.url)
-      const href = url.href.replace(url.origin, '')
+      const href = decodeURIComponent(url.href.replace(url.origin, ''))
 
       const APP_BASE = process.env.TSS_APP_BASE || '/'
 

package/src/global.d.ts

@@ -1,7 +1,4 @@
-/* eslint-disable no-var */
 declare global {
-  var TSS_INJECTED_HEAD_SCRIPTS: string | undefined
-
   namespace NodeJS {
     interface ProcessEnv {
       TSS_APP_BASE?: string
@@ -9,6 +6,7 @@ declare global {
       TSS_OUTPUT_PUBLIC_DIR?: string
       TSS_SHELL?: 'true' | 'false'
       TSS_PRERENDERING?: 'true' | 'false'
+      TSS_DEV_SERVER?: 'true' | 'false'
     }
   }
 }

package/src/index.tsx

@@ -12,7 +12,7 @@ export type { HandlerCallback } from '@tanstack/router-core/ssr/server'
 
 export { handleServerAction } from './server-functions-handler'
 
-export * from './h3'
+export * from './request-response'
 
 export {
   createServerRoute,

package/src/loadVirtualModule.ts

@@ -15,6 +15,8 @@ export async function loadVirtualModule<TId extends keyof VirtualModules>(
       return (await import('tanstack-start-manifest:v')) as any
     case VIRTUAL_MODULES.serverFnManifest:
       return (await import('tanstack-start-server-fn-manifest:v')) as any
+    case VIRTUAL_MODULES.injectedHeadScripts:
+      return (await import('tanstack-start-injected-head-scripts:v')) as any
     default:
       throw new Error(`Unknown virtual module: ${id}`)
   }

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

@@ -20,9 +20,12 @@ export async function getStartManifest(opts: { basePath: string }) {
   rootRoute.assets = rootRoute.assets || []
 
   let script = `import('${startManifest.clientEntry}')`
-  if (process.env.NODE_ENV === 'development') {
-    if (globalThis.TSS_INJECTED_HEAD_SCRIPTS) {
-      script = `${globalThis.TSS_INJECTED_HEAD_SCRIPTS + ';'}${script}`
+  if (process.env.TSS_DEV_SERVER === 'true') {
+    const { injectedHeadScripts } = await loadVirtualModule(
+      VIRTUAL_MODULES.injectedHeadScripts,
+    )
+    if (injectedHeadScripts) {
+      script = `${injectedHeadScripts + ';'}${script}`
     }
   }
   rootRoute.assets.push({

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) {
@@ -15,36 +15,35 @@ function sanitizeBase(base: string | undefined) {
   return base.replace(/^\/|\/$/g, '')
 }
 
-async function revive(root: any, reviver?: (key: string, value: any) => any) {
-  async function reviveNode(holder: any, key: string) {
-    const value = holder[key]
+export const handleServerAction = async ({ request }: { request: Request }) => {
+  const controller = new AbortController()
+  const signal = controller.signal
+  const abort = () => controller.abort()
+  request.signal.addEventListener('abort', abort)
 
-    if (value && typeof value === 'object') {
-      await Promise.all(Object.keys(value).map((k) => reviveNode(value, k)))
-    }
+  const method = request.method
+  const url = new URL(request.url, 'http://localhost:3000')
+  // extract the serverFnId from the url as host/_serverFn/:serverFnId
+  // Define a regex to match the path and extract the :thing part
+  const regex = new RegExp(
+    `${sanitizeBase(process.env.TSS_SERVER_FN_BASE)}/([^/?#]+)`,
+  )
 
-    if (reviver) {
-      holder[key] = await reviver(key, holder[key])
-    }
+  // Execute the regex
+  const match = url.pathname.match(regex)
+  const serverFnId = match ? match[1] : null
+  const search = Object.fromEntries(url.searchParams.entries()) as {
+    payload?: any
+    createServerFn?: boolean
   }
 
-  const holder = { '': root }
-  await reviveNode(holder, '')
-  return holder['']
-}
+  const isCreateServerFn = 'createServerFn' in search
+  const isRaw = 'raw' in search
 
-async function reviveServerFns(key: string, value: any) {
-  if (value && value.__serverFn === true && value.functionId) {
-    const serverFn = await getServerFnById(value.functionId)
-    return async (opts: any, signal: any): Promise<any> => {
-      const result = await serverFn(opts ?? {}, signal)
-      return result.result
-    }
+  if (typeof serverFnId !== 'string') {
+    throw new Error('Invalid server action param for serverFnId: ' + serverFnId)
   }
-  return value
-}
 
-async function getServerFnById(serverFnId: string) {
   const { default: serverFnManifest } = await loadVirtualModule(
     VIRTUAL_MODULES.serverFnManifest,
   )
@@ -72,45 +71,6 @@ async function getServerFnById(serverFnId: string) {
       `Server function module export not resolved for serverFn ID: ${serverFnId}`,
     )
   }
-  return action
-}
-
-async function parsePayload(payload: any) {
-  const parsedPayload = startSerializer.parse(payload)
-  await revive(parsedPayload, reviveServerFns)
-  return parsedPayload
-}
-
-export const handleServerAction = async ({ request }: { request: Request }) => {
-  const controller = new AbortController()
-  const signal = controller.signal
-  const abort = () => controller.abort()
-  request.signal.addEventListener('abort', abort)
-
-  const method = request.method
-  const url = new URL(request.url, 'http://localhost:3000')
-  // extract the serverFnId from the url as host/_serverFn/:serverFnId
-  // Define a regex to match the path and extract the :thing part
-  const regex = new RegExp(
-    `${sanitizeBase(process.env.TSS_SERVER_FN_BASE)}/([^/?#]+)`,
-  )
-
-  // Execute the regex
-  const match = url.pathname.match(regex)
-  const serverFnId = match ? match[1] : null
-  const search = Object.fromEntries(url.searchParams.entries()) as {
-    payload?: any
-    createServerFn?: boolean
-  }
-
-  const isCreateServerFn = 'createServerFn' in search
-  const isRaw = 'raw' in search
-
-  if (typeof serverFnId !== 'string') {
-    throw new Error('Invalid server action param for serverFnId: ' + serverFnId)
-  }
-
-  const action = await getServerFnById(serverFnId)
 
   // Known FormData 'Content-Type' header values
   const formDataContentTypes = [
@@ -149,7 +109,7 @@ export const handleServerAction = async ({ request }: { request: Request }) => {
           }
 
           // If there's a payload, we should try to parse it
-          payload = payload ? await parsePayload(payload) : payload
+          payload = payload ? startSerializer.parse(payload) : payload
 
           // Send it through!
           return await action(payload, signal)
@@ -160,7 +120,7 @@ export const handleServerAction = async ({ request }: { request: Request }) => {
 
         // We should probably try to deserialize the payload
         // as JSON, but we'll just pass it through for now.
-        const payload = await parsePayload(jsonPayloadAsString)
+        const payload = startSerializer.parse(jsonPayloadAsString)
 
         // If this POST request was created by createServerFn,
         // it's payload will be the only argument
@@ -227,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',
           },
@@ -285,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 || {}),