@solidjs/web 2.0.0-beta.3 → 2.0.0-beta.30

package/server-functions/dist/server.js

@@ -0,0 +1,875 @@
+import { sharedConfig } from 'solid-js';
+import { fromCrossJSON, Feature, toCrossJSONStream } from 'seroval';
+import { AbortSignalPlugin, CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin } from 'seroval-plugins/web';
+
+const ENVELOPE = Symbol.for("solid.ResponseEnvelope");
+function isResponseEnvelope(value) {
+  return !!(value && typeof value === "object" && value[ENVELOPE]);
+}
+const REVALIDATE_HEADER = "X-Revalidate";
+
+Feature.AggregateError | Feature.BigIntTypedArray;
+const serializeOnlyDisabledFeatures = () => process.env.NODE_ENV === "development" ? 0 : Feature.ErrorPrototypeStack;
+const DEFAULT_WEB_PLUGINS = Object.freeze([AbortSignalPlugin,
+CustomEventPlugin, DOMExceptionPlugin, EventPlugin,
+FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLSearchParamsPlugin, URLPlugin]);
+function resolveSerializerPlugins(customPlugins) {
+  return customPlugins ? [...customPlugins, ...DEFAULT_WEB_PLUGINS] : [...DEFAULT_WEB_PLUGINS];
+}
+const JSON_CODEC_DISABLED_FEATURES = 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
+  };
+}
+function serializeJSON(value, {
+  onParse,
+  onDone,
+  onError,
+  ...codecOptions
+}) {
+  const resolved = resolveCodecOptions(codecOptions);
+  return toCrossJSONStream(value, {
+    onParse,
+    onDone,
+    onError,
+    ...resolved,
+    disabledFeatures: resolved.disabledFeatures | serializeOnlyDisabledFeatures()
+  });
+}
+function createJSONDeserializer(options) {
+  const refs = new Map();
+  const resolved = resolveCodecOptions(options);
+  return function deserializeJSONChunk(node) {
+    return fromCrossJSON(node, {
+      refs,
+      ...resolved
+    });
+  };
+}
+
+const RequestContext = Symbol.for("solid.RequestContext");
+function getRequestEvent() {
+  return globalThis[RequestContext] ? globalThis[RequestContext].getStore() || sharedConfig.context && 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;
+}
+
+const codecConfig = {
+  codec: undefined
+};
+function configureServerFunctionsCodec(codec) {
+  codecConfig.codec = codec;
+}
+function getServerFunctionsCodec() {
+  return codecConfig.codec;
+}
+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?";
+const NEEDS_ENCODING = /[^\x20-\x7e\xa0-\xff]/;
+function encodeErrorHeaderValue(value) {
+  let stripped = String(value).replace(/[\r\n]+/g, "");
+  if (!NEEDS_ENCODING.test(stripped) && !stripped.startsWith(ERROR_HEADER_MARKER) && stripped === stripped.trim()) {
+    return stripped;
+  }
+  if (typeof stripped.toWellFormed === "function") {
+    stripped = stripped.toWellFormed();
+  } else {
+    stripped = stripped.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "\uFFFD");
+  }
+  return ERROR_HEADER_MARKER + encodeURIComponent(stripped);
+}
+function decodeErrorHeaderValue(value) {
+  if (typeof value !== "string" || !value.startsWith(ERROR_HEADER_MARKER)) {
+    return value;
+  }
+  try {
+    return decodeURIComponent(value.slice(ERROR_HEADER_MARKER.length));
+  } catch {
+    return value;
+  }
+}
+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",
+  FormData: "2",
+  URLSearchParams: "3",
+  Blob: "4",
+  File: "5",
+  ArrayBuffer: "6",
+  Uint8Array: "7",
+  Json: "8"
+};
+function getHeadersAndBody(body) {
+  switch (true) {
+    case typeof body === "string":
+      return {
+        headers: {
+          "Content-Type": "text/plain",
+          [BODY_FORMAT_HEADER]: BodyFormat.String
+        },
+        body
+      };
+    case body instanceof FormData:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.FormData
+        },
+        body
+      };
+    case body instanceof URLSearchParams:
+      return {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          [BODY_FORMAT_HEADER]: BodyFormat.URLSearchParams
+        },
+        body
+      };
+    case typeof File !== "undefined" && body instanceof File:
+      {
+        const formData = new FormData();
+        formData.append(FILE_FORM_KEY, body, body.name);
+        return {
+          headers: {
+            [BODY_FORMAT_HEADER]: BodyFormat.File
+          },
+          body: formData
+        };
+      }
+    case body instanceof Blob:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.Blob
+        },
+        body
+      };
+    case body instanceof ArrayBuffer:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.ArrayBuffer
+        },
+        body
+      };
+    case body instanceof Uint8Array:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.Uint8Array
+        },
+        body: new Uint8Array(body)
+      };
+    default:
+      return undefined;
+  }
+}
+async function extractBody(source, codecOptions) {
+  const contentType = source.headers.get("content-type");
+  const format = source.headers.get(BODY_FORMAT_HEADER);
+  const clone = source.clone();
+  switch (true) {
+    case format === BodyFormat.Serialized:
+      return await deserializeStream(clone, codecOptions);
+    case format === BodyFormat.Json:
+      return JSON.parse(await clone.text());
+    case format === BodyFormat.String:
+      return await clone.text();
+    case format === BodyFormat.File:
+      {
+        const formData = await clone.formData();
+        return formData.get(FILE_FORM_KEY);
+      }
+    case format === BodyFormat.FormData:
+    case contentType && contentType.startsWith("multipart/form-data"):
+      return await clone.formData();
+    case format === BodyFormat.URLSearchParams:
+    case contentType && contentType.startsWith("application/x-www-form-urlencoded"):
+      return new URLSearchParams(await clone.text());
+    case format === BodyFormat.Blob:
+      return await clone.blob();
+    case format === BodyFormat.ArrayBuffer:
+      return await clone.arrayBuffer();
+    case format === BodyFormat.Uint8Array:
+      return new Uint8Array(await clone.arrayBuffer());
+  }
+  return undefined;
+}
+function createChunk(data) {
+  const encodeData = new TextEncoder().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(encodeData, 12);
+  return chunk;
+}
+class ChunkReader {
+  constructor(stream) {
+    this.reader = stream.getReader();
+    this.buffer = new Uint8Array(0);
+    this.done = false;
+  }
+  async readChunk() {
+    const chunk = await this.reader.read();
+    if (!chunk.done) {
+      const newBuffer = new Uint8Array(this.buffer.length + chunk.value.length);
+      newBuffer.set(this.buffer);
+      newBuffer.set(chunk.value, this.buffer.length);
+      this.buffer = newBuffer;
+    } else {
+      this.done = true;
+    }
+  }
+  async next() {
+    while (this.buffer.length < 12) {
+      if (this.done) {
+        if (this.buffer.length === 0) return {
+          done: true,
+          value: undefined
+        };
+        throw new Error("Malformed server function stream.");
+      }
+      await this.readChunk();
+    }
+    const head = new TextDecoder().decode(this.buffer.subarray(1, 11));
+    const bytes = Number.parseInt(head, 16);
+    if (Number.isNaN(bytes)) {
+      throw new Error("Malformed server function stream.");
+    }
+    while (bytes > this.buffer.length - 12) {
+      if (this.done) {
+        throw new Error("Malformed server function stream.");
+      }
+      await this.readChunk();
+    }
+    const partial = new TextDecoder().decode(this.buffer.subarray(12, 12 + bytes));
+    this.buffer = this.buffer.subarray(12 + bytes);
+    return {
+      done: false,
+      value: partial
+    };
+  }
+  async drain(interpret) {
+    while (true) {
+      const result = await this.next();
+      if (result.done) {
+        break;
+      }
+      interpret(result.value);
+    }
+  }
+}
+function serializeStream(value, codecOptions) {
+  return new ReadableStream({
+    start(controller) {
+      serializeJSON(value, {
+        ...codecOptions,
+        onParse(node) {
+          controller.enqueue(createChunk(JSON.stringify(node)));
+        },
+        onDone() {
+          controller.close();
+        },
+        onError(error) {
+          controller.error(error);
+        }
+      });
+    }
+  });
+}
+async function deserializeStream(source, codecOptions) {
+  if (!source.body) {
+    throw new Error("missing body");
+  }
+  const reader = new ChunkReader(source.body);
+  const result = await reader.next();
+  if (!result.done) {
+    const deserializeChunk = createJSONDeserializer(codecOptions);
+    function interpretChunk(chunk) {
+      return deserializeChunk(JSON.parse(chunk));
+    }
+    void reader.drain(interpretChunk);
+    return interpretChunk(result.value);
+  }
+  return undefined;
+}
+async function deserializeString(text, codecOptions) {
+  return await deserializeStream(new Response(text), codecOptions);
+}
+async function decodeResponse(response, codecOptions) {
+  if (!response.body) return undefined;
+  return await extractBody(response, codecOptions === undefined ? codecConfig.codec : codecOptions);
+}
+async function decodeResponsePayload(response, codecOptions) {
+  const decoded = await decodeResponse(response, codecOptions);
+  if (decoded !== undefined && response.headers.has(SINGLE_FLIGHT_HEADER)) {
+    return {
+      value: decoded.value,
+      flightData: decoded.data
+    };
+  }
+  return {
+    value: decoded
+  };
+}
+
+function encodeInputValue(value) {
+  if (value instanceof FormData) return {
+    $f: [...value.entries()].filter(([, v]) => typeof v === "string")
+  };
+  if (value instanceof URLSearchParams) return {
+    $u: [...value.entries()]
+  };
+  return value;
+}
+function decodeInputValue(value) {
+  if (value && typeof value === "object") {
+    if (Array.isArray(value.$f)) {
+      const form = new FormData();
+      for (const [k, v] of value.$f) form.append(k, v);
+      return form;
+    }
+    if (Array.isArray(value.$u)) return new URLSearchParams(value.$u);
+  }
+  return value;
+}
+function encodeFlashCookie(url, result, input, thrown) {
+  const isError = result instanceof Error;
+  const payload = {
+    url,
+    result: isError ? result.message : result,
+    error: isError,
+    thrown: !!thrown,
+    input: input.map(encodeInputValue)
+  };
+  return `${FLASH_COOKIE}=${encodeURIComponent(JSON.stringify(payload))}; Secure; HttpOnly; Path=/`;
+}
+function decodeFlashCookie(cookieHeader) {
+  const match = matchFlashCookie(cookieHeader);
+  if (!match) return;
+  try {
+    const payload = JSON.parse(decodeURIComponent(match));
+    if (!payload || !payload.result) return;
+    const result = payload.error ? new Error(payload.result) : payload.result;
+    return {
+      input: Array.isArray(payload.input) ? payload.input.map(decodeInputValue) : [],
+      url: payload.url,
+      result: payload.thrown ? undefined : result,
+      error: payload.thrown ? result : undefined
+    };
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+const config = {
+  provideEvent: undefined,
+  collectFlightData: undefined,
+  transformResult: undefined,
+  transformFlightResult: undefined,
+  transformDirectResult: undefined,
+  handleNoJS: undefined,
+  endpoint: "/_server"
+};
+function configureServerFunctionsServer({
+  provideEvent,
+  collectFlightData,
+  transformResult,
+  transformFlightResult,
+  transformDirectResult,
+  handleNoJS,
+  endpoint,
+  codec
+} = {}) {
+  if (provideEvent !== undefined) config.provideEvent = provideEvent;
+  if (collectFlightData !== undefined) config.collectFlightData = collectFlightData;
+  if (transformResult !== undefined) config.transformResult = transformResult;
+  if (transformFlightResult !== undefined) config.transformFlightResult = transformFlightResult;
+  if (transformDirectResult !== undefined) config.transformDirectResult = transformDirectResult;
+  if (handleNoJS !== undefined) config.handleNoJS = handleNoJS;
+  if (endpoint !== undefined) config.endpoint = endpoint;
+  if (codec !== undefined) configureServerFunctionsCodec(codec);
+}
+function provideEvent(event, fn) {
+  if (config.provideEvent) return config.provideEvent(event, fn);
+  const ctx = globalThis[RequestContext];
+  if (ctx) return ctx.run(event, fn);
+  throw new Error("No request event provider. Configure one with configureServerFunctionsServer({ provideEvent }).");
+}
+const REGISTRATIONS = new Map();
+const METHODS = new Map();
+const INVOCATIONS = new WeakMap();
+function registerServerFunction(id, callback) {
+  REGISTRATIONS.set(id, callback);
+  return callback;
+}
+function getServerFunction(id) {
+  const fn = REGISTRATIONS.get(id);
+  if (fn) {
+    return fn;
+  }
+  throw new Error("invalid server function: " + id);
+}
+function registerServerReference(id, fn, name) {
+  registerServerFunction(id, fn);
+  return {
+    id,
+    fn,
+    name
+  };
+}
+function createServerReference({
+  id,
+  fn,
+  name
+}) {
+  if (typeof fn !== "function") throw new Error("Export from a 'use server' module must be a function");
+  const metadata = name === undefined ? {} : {
+    name
+  };
+  return new Proxy(fn, {
+    get(target, prop) {
+      if (prop === "id") return id;
+      if (prop === "url") {
+        return `${config.endpoint}?id=${encodeURIComponent(id)}`;
+      }
+      if (prop === SERVER_FUNCTION_METADATA) return metadata;
+      return target[prop];
+    },
+    apply(target, thisArg, args) {
+      const ogEvt = getRequestEvent();
+      if (!ogEvt) throw new Error("Cannot call server function outside of a request");
+      const evt = {
+        ...ogEvt
+      };
+      INVOCATIONS.set(evt, {
+        id
+      });
+      evt.serverOnly = true;
+      const result = provideEvent(evt, () => {
+        return fn.apply(thisArg, args);
+      });
+      const transform = config.transformDirectResult;
+      if (transform && result && typeof result.then === "function") {
+        return result.then(value => transform(value, {
+          id,
+          args,
+          event: evt
+        }));
+      }
+      return transform ? transform(result, {
+        id,
+        args,
+        event: evt
+      }) : result;
+    }
+  });
+}
+function GET(fn) {
+  if (!isServerFunction(fn) || typeof fn.id !== "string") {
+    throw new Error("GET expects a server function reference");
+  }
+  METHODS.set(fn.id, "GET");
+  return withMeta(fn, {
+    method: "GET"
+  });
+}
+function getServerFunctionInvocation() {
+  return getEventServerFunctionInvocation(getRequestEvent());
+}
+function getEventServerFunctionInvocation(event) {
+  return event && INVOCATIONS.get(event);
+}
+function resolveFunctionId(request, url) {
+  const reference = request.headers.get(FUNCTION_HEADER);
+  if (reference) {
+    return reference.split("#")[0];
+  }
+  return url.searchParams.get("id");
+}
+async function parseArguments(request, url, instance, codec) {
+  const parsed = [];
+  const bodyFormat = request.method === "POST" ? request.headers.get(BODY_FORMAT_HEADER) : null;
+  if (!instance || request.method === "GET" || bodyFormat !== BodyFormat.Serialized) {
+    const args = url.searchParams.get("args");
+    if (args) {
+      const result = args.startsWith(";0x") ? await deserializeString(args, codec) : JSON.parse(args);
+      for (const arg of result) {
+        parsed.push(arg);
+      }
+    }
+  }
+  if (request.method === "POST" && request.body !== null) {
+    const decoded = await extractBody(request.clone(), codec);
+    if (bodyFormat === BodyFormat.Serialized || bodyFormat === BodyFormat.Json) {
+      return decoded;
+    }
+    parsed.push(decoded);
+  }
+  return parsed;
+}
+async function foldFlightData(hook, event, headers, outcome, context = {}) {
+  if (outcome.value instanceof Response && outcome.value.body) return outcome.value;
+  digestOutcome(event, outcome);
+  const data = await hook(event, outcome);
+  if (data === undefined) return outcome.value;
+  headers.set(SINGLE_FLIGHT_HEADER, "true");
+  if (context.transformFlightResult) {
+    const transformed = await context.transformFlightResult(event, {
+      value: outcome.value,
+      data
+    }, context);
+    if (transformed !== undefined) {
+      for (const cookie of headers.getSetCookie()) transformed.headers.append("Set-Cookie", cookie);
+      headers.forEach((value, key) => {
+        if (key !== "set-cookie" && !transformed.headers.has(key)) {
+          transformed.headers.set(key, value);
+        }
+      });
+      return transformed;
+    }
+  }
+  return {
+    value: outcome.value,
+    data
+  };
+}
+function digestOutcome(event, outcome) {
+  const {
+    request,
+    response
+  } = outcome;
+  outcome.revalidateKeys = response?.headers.get(REVALIDATE_HEADER)?.split(",");
+  outcome.foldedHeaders = foldSetCookies(request.headers, [...(event.response?.headers?.getSetCookie() ?? []), ...(response?.headers?.getSetCookie() ?? [])]);
+  try {
+    const referrer = request.headers.get("referer");
+    if (referrer) {
+      const location = response?.headers.get("Location");
+      const target = location ? new URL(location, request.url) : new URL(referrer);
+      if (target.origin === new URL(request.url).origin) outcome.targetUrl = target.toString();
+    }
+  } catch {
+  }
+}
+function parseSetCookie(setCookie) {
+  const [pair, ...attributes] = setCookie.split(";");
+  const eq = pair.indexOf("=");
+  if (eq < 0) return undefined;
+  const parsed = {
+    name: pair.slice(0, eq).trim(),
+    value: pair.slice(eq + 1).trim()
+  };
+  for (const attribute of attributes) {
+    const attrEq = attribute.indexOf("=");
+    const key = (attrEq < 0 ? attribute : attribute.slice(0, attrEq)).trim().toLowerCase();
+    const value = attrEq < 0 ? "" : attribute.slice(attrEq + 1).trim();
+    if (key === "max-age") parsed.maxAge = Number(value);else if (key === "expires") parsed.expires = new Date(value);
+  }
+  return parsed;
+}
+function foldSetCookies(headers, setCookies) {
+  const folded = new Headers(headers);
+  if (!setCookies.length) return folded;
+  const cookies = {};
+  for (const pair of folded.get("cookie")?.split(";") ?? []) {
+    const eq = pair.indexOf("=");
+    if (eq > -1) cookies[pair.slice(0, eq).trim()] = pair.slice(eq + 1).trim();
+  }
+  for (const setCookie of setCookies) {
+    const parsed = parseSetCookie(setCookie);
+    if (!parsed) continue;
+    if (parsed.maxAge != null && parsed.maxAge <= 0 || parsed.expires != null && parsed.expires.getTime() <= Date.now()) {
+      delete cookies[parsed.name];
+    } else {
+      cookies[parsed.name] = parsed.value;
+    }
+  }
+  folded.delete("cookie");
+  const serialized = Object.entries(cookies).map(([name, value]) => `${name}=${value}`).join("; ");
+  if (serialized) folded.set("cookie", serialized);
+  return folded;
+}
+const validRedirectStatuses = new Set([301, 302, 303, 307, 308]);
+function createNoJSHandler({
+  base = ""
+} = {}) {
+  return function handleNoJS(result, request, args, thrown) {
+    const url = new URL(request.url);
+    let back = new URL(base || "/", url.origin).toString();
+    try {
+      const referer = request.headers.get("referer");
+      if (referer) back = new URL(referer).toString();
+    } catch {}
+    let status = 303;
+    let headers;
+    if (result instanceof Response) {
+      headers = new 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;
+      } else {
+        headers.set("Location", back);
+      }
+      headers.delete("Content-Type");
+      headers.delete("Content-Length");
+    } else {
+      headers = new Headers({
+        Location: back
+      });
+    }
+    if (result && !(result instanceof Response)) {
+      headers.append("Set-Cookie", encodeFlashCookie(url.pathname + url.search, result, args, thrown));
+    }
+    return new Response(null, {
+      status,
+      headers
+    });
+  };
+}
+let defaultNoJSHandler;
+function isFormPost(request) {
+  if (request.method !== "POST" || request.headers.has(BODY_FORMAT_HEADER)) return false;
+  const type = request.headers.get("content-type") || "";
+  return type.startsWith("application/x-www-form-urlencoded") || type.startsWith("multipart/form-data");
+}
+function serializedResponse(value, headers, codec) {
+  headers.set(BODY_FORMAT_HEADER, BodyFormat.Serialized);
+  headers.set("Content-Type", "text/plain");
+  return new Response(serializeStream(value, codec), {
+    headers
+  });
+}
+function encodeResult(value, headers, status, codec) {
+  const direct = getHeadersAndBody(value);
+  if (direct) {
+    for (const [key, val] of Object.entries(direct.headers || {})) {
+      headers.set(key, val);
+    }
+    return new Response(direct.body, {
+      status,
+      headers
+    });
+  }
+  const response = serializedResponse(value, headers, codec);
+  return status === 200 ? response : new Response(response.body, {
+    status,
+    headers
+  });
+}
+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, {
+      status: 404
+    });
+  }
+  let serverFunction;
+  try {
+    serverFunction = getServerFunction(functionId);
+  } catch {
+    return new Response(process.env.NODE_ENV === "development" ? `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, {
+      status: 405,
+      headers: {
+        Allow: "POST"
+      }
+    });
+  }
+  const event = options.createEvent ? options.createEvent(request) : {
+    request,
+    locals: {}
+  };
+  const provide = options.provideEvent || provideEvent;
+  const flightHook = options.collectFlightData !== undefined ? options.collectFlightData : config.collectFlightData;
+  const transformResult = options.transformResult !== undefined ? options.transformResult : config.transformResult;
+  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));
+  const parsed = await parseArguments(request, url, instance, codec);
+  const flightContext = {
+    id: functionId,
+    args: parsed,
+    instance,
+    request,
+    collectsFlight,
+    codec,
+    transformFlightResult
+  };
+  const headers = new Headers();
+  try {
+    let result = await provide(event, async () => {
+      INVOCATIONS.set(event, {
+        id: functionId
+      });
+      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
+        });
+      }
+      let status = 200;
+      let metadata;
+      if (isResponseEnvelope(x)) {
+        const {
+          response,
+          value
+        } = x;
+        if (response && response.headers) {
+          response.headers.forEach((val, key) => headers.append(key, val));
+        }
+        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) {
+          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;
+        }
+      }
+      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);
+    }
+    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);
+  }
+}
+
+export { ERROR_HEADER, FLASH_COOKIE, FUNCTION_HEADER, GET, INSTANCE_HEADER, SINGLE_FLIGHT_HEADER, clearFlashCookie, configureServerFunctionsServer, createNoJSHandler, createServerReference, decodeErrorHeaderValue, decodeFlashCookie, decodeResponse, decodeResponsePayload, encodeErrorHeaderValue, encodeFlashCookie, foldSetCookies, getEventServerFunctionInvocation, getServerFunction, getServerFunctionInvocation, getServerFunctionMetadata, handleServerFunctionRequest, hasFlashCookie, isServerFunction, registerServerFunction, registerServerReference, subscribeFlightData, withMeta };