@solidjs/web 2.0.0-beta.31 → 2.0.0-beta.33

package/server-functions/dist/server.cjs

@@ -1,65 +1,81 @@
 'use strict';
 
 var solidJs = require('solid-js');
-var seroval = require('seroval');
-var web = require('seroval-plugins/web');
 
 const ENVELOPE = Symbol.for("solid.ResponseEnvelope");
 function isResponseEnvelope(value) {
   return !!(value && typeof value === "object" && value[ENVELOPE]);
 }
+const SAFE_ERROR = Symbol.for("solid.SafeError");
+function isSafeError(value) {
+  return !!(value && (typeof value === "object" || typeof value === "function") && value[SAFE_ERROR]);
+}
 const REVALIDATE_HEADER = "X-Revalidate";
 
-seroval.Feature.AggregateError | seroval.Feature.BigIntTypedArray;
-const serializeOnlyDisabledFeatures = () => process.env.NODE_ENV === "development" ? 0 : seroval.Feature.ErrorPrototypeStack;
-const DEFAULT_WEB_PLUGINS = Object.freeze([web.AbortSignalPlugin,
-web.CustomEventPlugin, web.DOMExceptionPlugin, web.EventPlugin,
-web.FormDataPlugin, web.HeadersPlugin, web.ReadableStreamPlugin, web.RequestPlugin, web.ResponsePlugin, web.URLSearchParamsPlugin, web.URLPlugin]);
-function resolveSerializerPlugins(customPlugins) {
-  return customPlugins ? [...customPlugins, ...DEFAULT_WEB_PLUGINS] : [...DEFAULT_WEB_PLUGINS];
-}
-const JSON_CODEC_DISABLED_FEATURES = seroval.Feature.RegExp;
-const JSON_CODEC_DEPTH_LIMIT = 64;
-function resolveCodecOptions({
-  plugins,
-  disabledFeatures,
-  depthLimit
-} = {}) {
-  return {
-    plugins: resolveSerializerPlugins(plugins),
-    disabledFeatures: disabledFeatures === undefined ? JSON_CODEC_DISABLED_FEATURES : disabledFeatures,
-    depthLimit: depthLimit === undefined ? JSON_CODEC_DEPTH_LIMIT : depthLimit
-  };
+const SERVER_FUNCTION_METADATA = Symbol.for("solid.ServerFunctionMetadata");
+function getServerFunctionMetadata(fn) {
+  if (typeof fn !== "function") return undefined;
+  return fn[SERVER_FUNCTION_METADATA] || undefined;
 }
-function serializeJSON(value, {
-  onParse,
-  onDone,
-  onError,
-  ...codecOptions
-}) {
-  const resolved = resolveCodecOptions(codecOptions);
-  return seroval.toCrossJSONStream(value, {
-    onParse,
-    onDone,
-    onError,
-    ...resolved,
-    disabledFeatures: resolved.disabledFeatures | serializeOnlyDisabledFeatures()
-  });
+function isServerFunction(fn) {
+  return typeof fn === "function" && !!fn[SERVER_FUNCTION_METADATA];
 }
-function createJSONDeserializer(options) {
-  const refs = new Map();
-  const resolved = resolveCodecOptions(options);
-  return function deserializeJSONChunk(node) {
-    return seroval.fromCrossJSON(node, {
-      refs,
-      ...resolved
-    });
-  };
+function withMeta(fn, meta) {
+  const metadata = getServerFunctionMetadata(fn);
+  if (!metadata) {
+    throw new Error("withMeta expects a server function reference");
+  }
+  Object.assign(metadata, meta);
+  return fn;
+}
+const SERVER_FUNCTION_RPC = Symbol.for("solid.ServerFunctionRPC");
+function provideServerFunctionRPC(rpc) {
+  globalThis[SERVER_FUNCTION_RPC] || (globalThis[SERVER_FUNCTION_RPC] = rpc);
 }
 
-const RequestContext = Symbol.for("solid.RequestContext");
-function getRequestEvent() {
-  return globalThis[RequestContext] ? globalThis[RequestContext].getStore() || solidJs.sharedConfig.context && solidJs.sharedConfig.context.event || console.warn("RequestEvent is missing. This is most likely due to accessing `getRequestEvent` non-managed async scope in a partially polyfilled environment. Try moving it above all `await` calls.") : undefined;
+function parseCookieHeader(header) {
+  const cookies = {};
+  if (!header) return cookies;
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq < 0) continue;
+    const name = decodeSafe(part.slice(0, eq).trim());
+    let value = part.slice(eq + 1).trim();
+    if (value.length > 1 && value[0] === '"' && value[value.length - 1] === '"') {
+      value = value.slice(1, -1);
+    }
+    cookies[name] = decodeSafe(value);
+  }
+  return cookies;
+}
+function decodeSafe(text) {
+  try {
+    return decodeURIComponent(text);
+  } catch {
+    return text;
+  }
+}
+function serializeCookie(name, value, options = {}) {
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  cookie += `; Path=${options.path === undefined ? "/" : options.path}`;
+  if (options.domain) cookie += `; Domain=${options.domain}`;
+  if (options.maxAge !== undefined) cookie += `; Max-Age=${Math.trunc(options.maxAge)}`;
+  if (options.expires) cookie += `; Expires=${options.expires.toUTCString()}`;
+  if (options.httpOnly) cookie += "; HttpOnly";
+  if (options.secure) cookie += "; Secure";
+  if (options.sameSite) {
+    const sameSite = options.sameSite.toLowerCase();
+    cookie += `; SameSite=${sameSite === "none" ? "None" : sameSite === "strict" ? "Strict" : "Lax"}`;
+  }
+  return cookie;
+}
+const FLASH_COOKIE = "flash";
+const FLASH_MATCHER = new RegExp(`(?:^|;\\s*)${FLASH_COOKIE}=([^;]+)`);
+function hasFlashCookie(cookieHeader) {
+  return !!cookieHeader && FLASH_MATCHER.test(cookieHeader);
+}
+function clearFlashCookie() {
+  return `${FLASH_COOKIE}=; Max-Age=0; Path=/`;
 }
 
 const codecConfig = {
@@ -75,22 +91,6 @@ function subscribeFlightData(consumer) {
   return () => {
   };
 }
-const SERVER_FUNCTION_METADATA = Symbol.for("solid.ServerFunctionMetadata");
-function getServerFunctionMetadata(fn) {
-  if (typeof fn !== "function") return undefined;
-  return fn[SERVER_FUNCTION_METADATA] || undefined;
-}
-function isServerFunction(fn) {
-  return typeof fn === "function" && !!fn[SERVER_FUNCTION_METADATA];
-}
-function withMeta(fn, meta) {
-  const metadata = getServerFunctionMetadata(fn);
-  if (!metadata) {
-    throw new Error("withMeta expects a server function reference");
-  }
-  Object.assign(metadata, meta);
-  return fn;
-}
 const FUNCTION_HEADER = "X-Server-Function-Id";
 const ERROR_HEADER = "X-Server-Function-Error";
 const ERROR_HEADER_MARKER = "=?1?";
@@ -121,18 +121,6 @@ const INSTANCE_HEADER = "X-Server-Function-Instance";
 const BODY_FORMAT_HEADER = "X-Server-Function-Format";
 const SINGLE_FLIGHT_HEADER = "X-Single-Flight";
 const FILE_FORM_KEY = "__server_function_file__";
-const FLASH_COOKIE = "flash";
-const FLASH_MATCHER = new RegExp(`(?:^|;\\s*)${FLASH_COOKIE}=([^;]+)`);
-function hasFlashCookie(cookieHeader) {
-  return !!cookieHeader && FLASH_MATCHER.test(cookieHeader);
-}
-function matchFlashCookie(cookieHeader) {
-  const match = cookieHeader && cookieHeader.match(FLASH_MATCHER);
-  return match ? match[1] : undefined;
-}
-function clearFlashCookie() {
-  return `${FLASH_COOKIE}=; Max-Age=0; Path=/`;
-}
 const BodyFormat = {
   Serialized: "0",
   String: "1",
@@ -144,6 +132,38 @@ const BodyFormat = {
   Uint8Array: "7",
   Json: "8"
 };
+const JSON_SAFE_DEPTH_LIMIT = 10000;
+const EXIT = {};
+function isJSONSafe(value) {
+  const stack = [value];
+  const ancestors = new Set();
+  while (stack.length) {
+    const v = stack.pop();
+    if (v === EXIT) {
+      ancestors.delete(stack.pop());
+      continue;
+    }
+    if (v === null) continue;
+    const t = typeof v;
+    if (t === "string" || t === "boolean") continue;
+    if (t === "number") {
+      if (!Number.isFinite(v)) return false;
+      continue;
+    }
+    if (t !== "object") return false;
+    if (ancestors.has(v) || ancestors.size >= JSON_SAFE_DEPTH_LIMIT) return false;
+    ancestors.add(v);
+    stack.push(v, EXIT);
+    if (Array.isArray(v)) {
+      for (let i = 0; i < v.length; i++) stack.push(v[i]);
+    } else {
+      const proto = Object.getPrototypeOf(v);
+      if (proto !== Object.prototype && proto !== null) return false;
+      for (const k in v) stack.push(v[k]);
+    }
+  }
+  return true;
+}
 function getHeadersAndBody(body) {
   switch (true) {
     case typeof body === "string":
@@ -237,13 +257,11 @@ async function extractBody(source, codecOptions) {
   return undefined;
 }
 function createChunk(data) {
-  const encodeData = new TextEncoder().encode(data);
+  const encoder = new TextEncoder();
+  const encodeData = encoder.encode(data);
   const bytes = encodeData.length;
-  const baseHex = bytes.toString(16);
-  const totalHex = "00000000".substring(0, 8 - baseHex.length) + baseHex;
-  const head = new TextEncoder().encode(`;0x${totalHex};`);
   const chunk = new Uint8Array(12 + bytes);
-  chunk.set(head);
+  chunk.set(encoder.encode(`;0x${bytes.toString(16).padStart(8, "0")};`));
   chunk.set(encodeData, 12);
   return chunk;
 }
@@ -275,8 +293,8 @@ class ChunkReader {
       }
       await this.readChunk();
     }
-    const head = new TextDecoder().decode(this.buffer.subarray(1, 11));
-    const bytes = Number.parseInt(head, 16);
+    const decoder = new TextDecoder();
+    const bytes = Number.parseInt(decoder.decode(this.buffer.subarray(1, 11)), 16);
     if (Number.isNaN(bytes)) {
       throw new Error("Malformed server function stream.");
     }
@@ -286,7 +304,7 @@ class ChunkReader {
       }
       await this.readChunk();
     }
-    const partial = new TextDecoder().decode(this.buffer.subarray(12, 12 + bytes));
+    const partial = decoder.decode(this.buffer.subarray(12, 12 + bytes));
     this.buffer = this.buffer.subarray(12 + bytes);
     return {
       done: false,
@@ -305,7 +323,10 @@ class ChunkReader {
 }
 function serializeStream(value, codecOptions) {
   return new ReadableStream({
-    start(controller) {
+    async start(controller) {
+      const {
+        serializeJSON
+      } = await import('@solidjs/web/serialization');
       serializeJSON(value, {
         ...codecOptions,
         onParse(node) {
@@ -328,6 +349,9 @@ async function deserializeStream(source, codecOptions) {
   const reader = new ChunkReader(source.body);
   const result = await reader.next();
   if (!result.done) {
+    const {
+      createJSONDeserializer
+    } = await import('@solidjs/web/serialization/decode');
     const deserializeChunk = createJSONDeserializer(codecOptions);
     function interpretChunk(chunk) {
       return deserializeChunk(JSON.parse(chunk));
@@ -357,6 +381,77 @@ async function decodeResponsePayload(response, codecOptions) {
   };
 }
 
+const RequestContext = Symbol.for("solid.RequestContext");
+function getRequestEvent() {
+  return globalThis[RequestContext] ? globalThis[RequestContext].getStore() || solidJs.sharedConfig.context && solidJs.sharedConfig.context.event || console.warn("RequestEvent is missing. This is most likely due to accessing `getRequestEvent` non-managed async scope in a partially polyfilled environment. Try moving it above all `await` calls.") : undefined;
+}
+function reportLostHeaderWrite(method, name) {
+  const message = `Response header write dropped: headers.${method}(${JSON.stringify(String(name))}) ` + "ran after the response head was sent. Write headers before the shell flushes " + "(or before the handler returns).";
+  console.error(message);
+}
+function commitResponseStub(stub, {
+  allowLateLocation = false
+} = {}) {
+  if (!stub || stub.committed) return stub;
+  stub.committed = true;
+  const headers = stub.headers;
+  if (!headers || typeof headers.set !== "function") return stub;
+  for (const method of ["set", "append", "delete"]) {
+    const original = headers[method].bind(headers);
+    headers[method] = function (name, ...rest) {
+      if (allowLateLocation && method === "set" && String(name).toLowerCase() === "location") {
+        return original(name, ...rest);
+      }
+      reportLostHeaderWrite(method, name);
+    };
+  }
+  return stub;
+}
+function copyInitHeaders(init) {
+  if (!init || !init.getSetCookie) return new Headers(init);
+  const headers = new Headers();
+  init.forEach((value, key) => {
+    if (key !== "set-cookie") headers.append(key, value);
+  });
+  for (const cookie of init.getSetCookie()) headers.append("Set-Cookie", cookie);
+  return headers;
+}
+const STUB_GAP_FILL_EXCLUDED = /*#__PURE__*/new Set([ERROR_HEADER, BODY_FORMAT_HEADER, SINGLE_FLIGHT_HEADER, REVALIDATE_HEADER, "Location"].map(header => header.toLowerCase()));
+function fillsStubGap(key, headers, response) {
+  if (key === "set-cookie" || STUB_GAP_FILL_EXCLUDED.has(key)) return false;
+  if (response.body === null && (key === "content-type" || key === "content-length")) return false;
+  return !headers.has(key);
+}
+function commitEventResponse(response, event = getRequestEvent()) {
+  const stub = event && event.response;
+  if (!stub || !stub.headers || stub.committed) return response;
+  const cookies = stub.headers.getSetCookie ? stub.headers.getSetCookie() : [];
+  commitResponseStub(stub);
+  let hasGaps = false;
+  stub.headers.forEach((value, key) => {
+    if (fillsStubGap(key, response.headers, response)) hasGaps = true;
+  });
+  if (!cookies.length && !hasGaps) return response;
+  try {
+    for (const cookie of cookies) response.headers.append("Set-Cookie", cookie);
+    stub.headers.forEach((value, key) => {
+      if (fillsStubGap(key, response.headers, response)) response.headers.set(key, value);
+    });
+    return response;
+  } catch {
+    const headers = copyInitHeaders(response.headers);
+    for (const cookie of cookies) headers.append("Set-Cookie", cookie);
+    stub.headers.forEach((value, key) => {
+      if (fillsStubGap(key, headers, response)) headers.set(key, value);
+    });
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+}
+
 function encodeInputValue(value) {
   if (value instanceof FormData) return {
     $f: [...value.entries()].filter(([, v]) => typeof v === "string")
@@ -386,13 +481,16 @@ function encodeFlashCookie(url, result, input, thrown) {
     thrown: !!thrown,
     input: input.map(encodeInputValue)
   };
-  return `${FLASH_COOKIE}=${encodeURIComponent(JSON.stringify(payload))}; Secure; HttpOnly; Path=/`;
+  return serializeCookie(FLASH_COOKIE, JSON.stringify(payload), {
+    secure: true,
+    httpOnly: true
+  });
 }
 function decodeFlashCookie(cookieHeader) {
-  const match = matchFlashCookie(cookieHeader);
+  const match = parseCookieHeader(cookieHeader)[FLASH_COOKIE];
   if (!match) return;
   try {
-    const payload = JSON.parse(decodeURIComponent(match));
+    const payload = JSON.parse(match);
     if (!payload || !payload.result) return;
     const result = payload.error ? new Error(payload.result) : payload.result;
     return {
@@ -408,6 +506,7 @@ function decodeFlashCookie(cookieHeader) {
 
 const config = {
   provideEvent: undefined,
+  wrapInvocation: undefined,
   collectFlightData: undefined,
   transformResult: undefined,
   transformFlightResult: undefined,
@@ -417,6 +516,7 @@ const config = {
 };
 function configureServerFunctionsServer({
   provideEvent,
+  wrapInvocation,
   collectFlightData,
   transformResult,
   transformFlightResult,
@@ -426,6 +526,7 @@ function configureServerFunctionsServer({
   codec
 } = {}) {
   if (provideEvent !== undefined) config.provideEvent = provideEvent;
+  if (wrapInvocation !== undefined) config.wrapInvocation = wrapInvocation;
   if (collectFlightData !== undefined) config.collectFlightData = collectFlightData;
   if (transformResult !== undefined) config.transformResult = transformResult;
   if (transformFlightResult !== undefined) config.transformFlightResult = transformFlightResult;
@@ -443,7 +544,17 @@ function provideEvent(event, fn) {
 const REGISTRATIONS = new Map();
 const METHODS = new Map();
 const INVOCATIONS = new WeakMap();
+let rpcProvided = false;
+function provideRPC() {
+  if (rpcProvided) return;
+  rpcProvided = true;
+  provideServerFunctionRPC({
+    GET,
+    decodeResponse
+  });
+}
 function registerServerFunction(id, callback) {
+  provideRPC();
   REGISTRATIONS.set(id, callback);
   return callback;
 }
@@ -468,6 +579,7 @@ function createServerReference({
   name
 }) {
   if (typeof fn !== "function") throw new Error("Export from a 'use server' module must be a function");
+  provideRPC();
   const metadata = name === undefined ? {} : {
     name
   };
@@ -491,7 +603,13 @@ function createServerReference({
       });
       evt.serverOnly = true;
       const result = provideEvent(evt, () => {
-        return fn.apply(thisArg, args);
+        const run = () => fn.apply(thisArg, args);
+        return config.wrapInvocation ? config.wrapInvocation(run, {
+          id,
+          args,
+          event: evt,
+          direct: true
+        }) : run();
       });
       const transform = config.transformDirectResult;
       if (transform && result && typeof result.then === "function") {
@@ -573,7 +691,9 @@ async function foldFlightData(hook, event, headers, outcome, context = {}) {
       return transformed;
     }
   }
-  return {
+  return outcome.value === undefined ? {
+    data
+  } : {
     value: outcome.value,
     data
   };
@@ -633,6 +753,16 @@ function foldSetCookies(headers, setCookies) {
   if (serialized) folded.set("cookie", serialized);
   return folded;
 }
+function mergeResponseHeaders(target, source) {
+  source.forEach((value, key) => {
+    if (key !== "set-cookie") target.append(key, value);
+  });
+  if (source.getSetCookie) {
+    for (const cookie of source.getSetCookie()) target.append("Set-Cookie", cookie);
+  } else if (source.has("set-cookie")) {
+    target.append("Set-Cookie", source.get("set-cookie"));
+  }
+}
 const validRedirectStatuses = new Set([301, 302, 303, 307, 308]);
 function createNoJSHandler({
   base = ""
@@ -647,7 +777,8 @@ function createNoJSHandler({
     let status = 303;
     let headers;
     if (result instanceof Response) {
-      headers = new Headers(result.headers);
+      headers = new Headers();
+      mergeResponseHeaders(headers, result.headers);
       if (result.headers.has("Location")) {
         headers.set("Location", new URL(result.headers.get("Location"), url.origin + base).toString());
         if (validRedirectStatuses.has(result.status)) status = result.status;
@@ -694,19 +825,46 @@ function encodeResult(value, headers, status, codec) {
       headers
     });
   }
+  if (value === undefined) {
+    return new Response(null, {
+      status,
+      headers
+    });
+  }
+  try {
+    if (isJSONSafe(value)) {
+      headers.set(BODY_FORMAT_HEADER, BodyFormat.Json);
+      headers.set("Content-Type", "application/json");
+      return new Response(JSON.stringify(value), {
+        status,
+        headers
+      });
+    }
+  } catch {
+  }
   const response = serializedResponse(value, headers, codec);
   return status === 200 ? response : new Response(response.body, {
     status,
     headers
   });
 }
+const GENERIC_SERVER_ERROR_MESSAGE = "Internal Server Error";
+let DEV = false === true;
+function setServerFunctionsDev(dev) {
+  DEV = !!dev;
+}
+function sanitizeServerError(value) {
+  if (DEV) return value;
+  if (isSafeError(value)) return value;
+  return new Error(GENERIC_SERVER_ERROR_MESSAGE);
+}
 async function handleServerFunctionRequest(request, options = {}) {
   const codec = options.codec !== undefined ? options.codec : getServerFunctionsCodec();
   const url = new URL(request.url);
   const instance = request.headers.get(INSTANCE_HEADER);
   const functionId = resolveFunctionId(request, url);
   if (!functionId) {
-    return new Response(process.env.NODE_ENV === "development" ? "Server function not found" : null, {
+    return new Response(DEV ? "Server function not found" : null, {
       status: 404
     });
   }
@@ -714,12 +872,12 @@ async function handleServerFunctionRequest(request, options = {}) {
   try {
     serverFunction = getServerFunction(functionId);
   } catch {
-    return new Response(process.env.NODE_ENV === "development" ? `Unknown server function: ${functionId}` : null, {
+    return new Response(DEV ? `Unknown server function: ${functionId}` : null, {
       status: 404
     });
   }
   if (request.method === "GET" && METHODS.get(functionId) !== "GET") {
-    return new Response(process.env.NODE_ENV === "development" ? `Method not allowed for server function: ${functionId}` : null, {
+    return new Response(DEV ? `Method not allowed for server function: ${functionId}` : null, {
       status: 405,
       headers: {
         Allow: "POST"
@@ -733,6 +891,7 @@ async function handleServerFunctionRequest(request, options = {}) {
   const provide = options.provideEvent || provideEvent;
   const flightHook = options.collectFlightData !== undefined ? options.collectFlightData : config.collectFlightData;
   const transformResult = options.transformResult !== undefined ? options.transformResult : config.transformResult;
+  const wrapInvocation = options.wrapInvocation !== undefined ? options.wrapInvocation : config.wrapInvocation;
   const transformFlightResult = options.transformFlightResult !== undefined ? options.transformFlightResult : config.transformFlightResult;
   const handleNoJS = options.handleNoJS !== undefined ? options.handleNoJS : config.handleNoJS !== undefined ? config.handleNoJS : isFormPost(request) ? defaultNoJSHandler || (defaultNoJSHandler = createNoJSHandler()) : undefined;
   const collectsFlight = !!(flightHook && instance && request.headers.has(SINGLE_FLIGHT_HEADER));
@@ -747,136 +906,148 @@ async function handleServerFunctionRequest(request, options = {}) {
     transformFlightResult
   };
   const headers = new Headers();
-  try {
-    let result = await provide(event, async () => {
-      INVOCATIONS.set(event, {
-        id: functionId
+  const dispatch = async () => {
+    try {
+      let result = await provide(event, async () => {
+        INVOCATIONS.set(event, {
+          id: functionId
+        });
+        const run = () => serverFunction(...parsed);
+        return wrapInvocation ? wrapInvocation(run, {
+          id: functionId,
+          args: parsed,
+          event,
+          request,
+          direct: false
+        }) : run();
       });
-      return serverFunction(...parsed);
-    });
-    if (transformResult) {
-      result = await transformResult(event, result, flightContext);
-    }
-    let status = 200;
-    let metadata;
-    if (isResponseEnvelope(result)) {
-      const {
-        response,
-        value
-      } = result;
-      if (!instance && !handleNoJS && response && response.body) {
-        return response;
-      }
-      if (response && response.headers) {
-        response.headers.forEach((val, key) => headers.append(key, val));
-      }
-      if (response && response.status && (response.status < 300 || response.status >= 400)) {
-        status = response.status;
-      }
-      metadata = response;
-      result = value;
-    } else if (result instanceof Response) {
-      if (result.headers && result.headers.has("X-Content-Raw")) return result;
-      if (instance) {
-        if (result.headers) {
-          result.headers.forEach((value, key) => headers.append(key, value));
-        }
-        if (result.status && (result.status < 300 || result.status >= 400)) {
-          status = result.status;
-        }
-        metadata = result;
-        if (result.body == null) {
-          result = null;
-        }
-      }
-    }
-    if (collectsFlight) {
-      result = await foldFlightData(flightHook, event, headers, {
-        id: functionId,
-        value: result,
-        response: metadata,
-        request,
-        thrown: false
-      }, flightContext);
-      if (result instanceof Response && result.headers.has("X-Content-Raw")) return result;
-    }
-    if (!instance) {
-      if (handleNoJS) return handleNoJS(result, request, parsed);
-      if (result instanceof Response) return result;
-      return encodeResult(result, headers, 200, codec);
-    }
-    return encodeResult(result, headers, status, codec);
-  } catch (x) {
-    if (x instanceof Response || isResponseEnvelope(x)) {
       if (transformResult) {
-        x = await transformResult(event, x, {
-          ...flightContext,
-          thrown: true
-        });
+        result = await transformResult(event, result, flightContext);
       }
       let status = 200;
       let metadata;
-      if (isResponseEnvelope(x)) {
+      if (isResponseEnvelope(result)) {
         const {
           response,
           value
-        } = x;
+        } = result;
+        if (!instance && !handleNoJS && response && response.body) {
+          return response;
+        }
         if (response && response.headers) {
-          response.headers.forEach((val, key) => headers.append(key, val));
+          mergeResponseHeaders(headers, response.headers);
         }
-        if (response && response.status && (!instance || response.status < 300 || response.status >= 400)) {
+        if (response && response.status && (response.status < 300 || response.status >= 400)) {
           status = response.status;
         }
         metadata = response;
-        x = value;
-      } else if (x instanceof Response) {
-        if (x.headers) {
-          x.headers.forEach((value, key) => headers.append(key, value));
-        }
-        if (x.status && (!instance || x.status < 300 || x.status >= 400)) {
-          status = x.status;
-        }
-        metadata = x;
-        if (x.body == null) {
-          x = null;
+        result = value;
+      } else if (result instanceof Response) {
+        if (result.headers && result.headers.has("X-Content-Raw")) return result;
+        if (instance) {
+          if (result.headers) {
+            mergeResponseHeaders(headers, result.headers);
+          }
+          if (result.status && (result.status < 300 || result.status >= 400)) {
+            status = result.status;
+          }
+          metadata = result;
+          if (result.body == null) {
+            result = null;
+          }
         }
       }
       if (collectsFlight) {
-        x = await foldFlightData(flightHook, event, headers, {
+        result = await foldFlightData(flightHook, event, headers, {
           id: functionId,
-          value: x,
+          value: result,
           response: metadata,
           request,
-          thrown: true
+          thrown: false
         }, flightContext);
-        if (x instanceof Response && x.headers.has("X-Content-Raw")) {
-          x.headers.set(ERROR_HEADER, "true");
-          return x;
+        if (result instanceof Response && result.headers.has("X-Content-Raw")) return result;
+      }
+      if (!instance) {
+        if (handleNoJS) return handleNoJS(result, request, parsed);
+        if (result instanceof Response) return result;
+        return encodeResult(result, headers, 200, codec);
+      }
+      return encodeResult(result, headers, status, codec);
+    } catch (x) {
+      if (x instanceof Response || isResponseEnvelope(x)) {
+        if (transformResult) {
+          x = await transformResult(event, x, {
+            ...flightContext,
+            thrown: true
+          });
+        }
+        let status = 200;
+        let metadata;
+        if (isResponseEnvelope(x)) {
+          const {
+            response,
+            value
+          } = x;
+          if (response && response.headers) {
+            mergeResponseHeaders(headers, response.headers);
+          }
+          if (response && response.status && (!instance || response.status < 300 || response.status >= 400)) {
+            status = response.status;
+          }
+          metadata = response;
+          x = value;
+        } else if (x instanceof Response) {
+          if (x.headers) {
+            mergeResponseHeaders(headers, x.headers);
+          }
+          if (x.status && (!instance || x.status < 300 || x.status >= 400)) {
+            status = x.status;
+          }
+          metadata = x;
+          if (x.body == null) {
+            x = null;
+          }
+        }
+        if (collectsFlight) {
+          x = await foldFlightData(flightHook, event, headers, {
+            id: functionId,
+            value: x,
+            response: metadata,
+            request,
+            thrown: true
+          }, flightContext);
+          if (x instanceof Response && x.headers.has("X-Content-Raw")) {
+            x.headers.set(ERROR_HEADER, "true");
+            return x;
+          }
         }
+        headers.set(ERROR_HEADER, "true");
+        if (!instance) {
+          if (handleNoJS) return handleNoJS(x ?? metadata, request, parsed, true);
+          if (x instanceof Response) return x;
+        }
+        return encodeResult(x, headers, status, codec);
       }
-      headers.set(ERROR_HEADER, "true");
+      const safe = sanitizeServerError(x);
       if (!instance) {
-        if (handleNoJS) return handleNoJS(x ?? metadata, request, parsed, true);
-        if (x instanceof Response) return x;
+        if (handleNoJS) return handleNoJS(safe, request, parsed, true);
+        const message = safe instanceof Error ? safe.message : String(safe);
+        return new Response(DEV ? message : null, {
+          status: 500
+        });
       }
-      return encodeResult(x, headers, status, codec);
+      const error = safe instanceof Error ? safe.message : typeof safe === "string" ? safe : "true";
+      headers.set(ERROR_HEADER, encodeErrorHeaderValue(error));
+      return encodeResult(safe, headers, 200, codec);
     }
-    if (!instance) {
-      if (handleNoJS) return handleNoJS(x, request, parsed, true);
-      const message = x instanceof Error ? x.message : String(x);
-      return new Response(process.env.NODE_ENV === "development" ? message : null, {
-        status: 500
-      });
-    }
-    const error = x instanceof Error ? x.message : typeof x === "string" ? x : "true";
-    headers.set(ERROR_HEADER, encodeErrorHeaderValue(error));
-    return encodeResult(x, headers, 200, codec);
-  }
+  };
+  return commitEventResponse(await dispatch(), event);
 }
 
 exports.ERROR_HEADER = ERROR_HEADER;
 exports.FLASH_COOKIE = FLASH_COOKIE;
 exports.FUNCTION_HEADER = FUNCTION_HEADER;
+exports.GENERIC_SERVER_ERROR_MESSAGE = GENERIC_SERVER_ERROR_MESSAGE;
 exports.GET = GET;
 exports.INSTANCE_HEADER = INSTANCE_HEADER;
 exports.SINGLE_FLIGHT_HEADER = SINGLE_FLIGHT_HEADER;
@@ -900,5 +1071,7 @@ exports.hasFlashCookie = hasFlashCookie;
 exports.isServerFunction = isServerFunction;
 exports.registerServerFunction = registerServerFunction;
 exports.registerServerReference = registerServerReference;
+exports.sanitizeServerError = sanitizeServerError;
+exports.setServerFunctionsDev = setServerFunctionsDev;
 exports.subscribeFlightData = subscribeFlightData;
 exports.withMeta = withMeta;