better-call 0.3.3 → 1.0.0-beta.3

package/dist/index.js

@@ -1,250 +1,216 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+// src/error.ts
+var _statusCode = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  RANGE_NOT_SATISFIABLE: 416,
+  EXPECTATION_FAILED: 417,
+  "I'M_A_TEAPOT": 418,
+  MISDIRECTED_REQUEST: 421,
+  UNPROCESSABLE_ENTITY: 422,
+  LOCKED: 423,
+  FAILED_DEPENDENCY: 424,
+  TOO_EARLY: 425,
+  UPGRADE_REQUIRED: 426,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505,
+  VARIANT_ALSO_NEGOTIATES: 506,
+  INSUFFICIENT_STORAGE: 507,
+  LOOP_DETECTED: 508,
+  NOT_EXTENDED: 510,
+  NETWORK_AUTHENTICATION_REQUIRED: 511
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+var APIError = class extends Error {
+  constructor(status = "INTERNAL_SERVER_ERROR", body = void 0, headers = {}, statusCode = typeof status === "number" ? status : _statusCode[status]) {
+    super(body?.message);
+    this.status = status;
+    this.body = body;
+    this.headers = headers;
+    this.statusCode = statusCode;
+    this.name = "APIError";
+    this.status = status;
+    this.headers = headers;
+    this.statusCode = statusCode;
+    this.body = body ? {
+      code: body?.message?.toUpperCase().replace(/ /g, "_").replace(/[^A-Z0-9_]/g, ""),
+      ...body
+    } : void 0;
+    this.stack = "";
   }
-  return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-// node_modules/set-cookie-parser/lib/set-cookie.js
-var require_set_cookie = __commonJS({
-  "node_modules/set-cookie-parser/lib/set-cookie.js"(exports, module) {
-    "use strict";
-    var defaultParseOptions = {
-      decodeValues: true,
-      map: false,
-      silent: false
-    };
-    function isNonEmptyString(str) {
-      return typeof str === "string" && !!str.trim();
-    }
-    function parseString(setCookieValue, options) {
-      var parts = setCookieValue.split(";").filter(isNonEmptyString);
-      var nameValuePairStr = parts.shift();
-      var parsed = parseNameValuePair(nameValuePairStr);
-      var name = parsed.name;
-      var value = parsed.value;
-      options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
-      try {
-        value = options.decodeValues ? decodeURIComponent(value) : value;
-      } catch (e) {
-        console.error(
-          "set-cookie-parser encountered an error while decoding a cookie with value '" + value + "'. Set options.decodeValues to false to disable this feature.",
-          e
-        );
-      }
-      var cookie = {
-        name,
-        value
-      };
-      parts.forEach(function(part) {
-        var sides = part.split("=");
-        var key = sides.shift().trimLeft().toLowerCase();
-        var value2 = sides.join("=");
-        if (key === "expires") {
-          cookie.expires = new Date(value2);
-        } else if (key === "max-age") {
-          cookie.maxAge = parseInt(value2, 10);
-        } else if (key === "secure") {
-          cookie.secure = true;
-        } else if (key === "httponly") {
-          cookie.httpOnly = true;
-        } else if (key === "samesite") {
-          cookie.sameSite = value2;
-        } else if (key === "partitioned") {
-          cookie.partitioned = true;
-        } else {
-          cookie[key] = value2;
-        }
+// src/to-response.ts
+function isJSONSerializable(value) {
+  if (value === void 0) {
+    return false;
+  }
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean" || t === null) {
+    return true;
+  }
+  if (t !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return true;
+  }
+  if (value.buffer) {
+    return false;
+  }
+  return value.constructor && value.constructor.name === "Object" || typeof value.toJSON === "function";
+}
+function toResponse(data, init) {
+  if (data instanceof Response) {
+    if (init?.headers instanceof Headers) {
+      init.headers.forEach((value, key) => {
+        data.headers.set(key, value);
       });
-      return cookie;
     }
-    function parseNameValuePair(nameValuePairStr) {
-      var name = "";
-      var value = "";
-      var nameValueArr = nameValuePairStr.split("=");
-      if (nameValueArr.length > 1) {
-        name = nameValueArr.shift();
-        value = nameValueArr.join("=");
-      } else {
-        value = nameValuePairStr;
-      }
-      return { name, value };
-    }
-    function parse2(input, options) {
-      options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
-      if (!input) {
-        if (!options.map) {
-          return [];
-        } else {
-          return {};
-        }
-      }
-      if (input.headers) {
-        if (typeof input.headers.getSetCookie === "function") {
-          input = input.headers.getSetCookie();
-        } else if (input.headers["set-cookie"]) {
-          input = input.headers["set-cookie"];
-        } else {
-          var sch = input.headers[Object.keys(input.headers).find(function(key) {
-            return key.toLowerCase() === "set-cookie";
-          })];
-          if (!sch && input.headers.cookie && !options.silent) {
-            console.warn(
-              "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
-            );
-          }
-          input = sch;
-        }
-      }
-      if (!Array.isArray(input)) {
-        input = [input];
-      }
-      if (!options.map) {
-        return input.filter(isNonEmptyString).map(function(str) {
-          return parseString(str, options);
-        });
-      } else {
-        var cookies = {};
-        return input.filter(isNonEmptyString).reduce(function(cookies2, str) {
-          var cookie = parseString(str, options);
-          cookies2[cookie.name] = cookie;
-          return cookies2;
-        }, cookies);
-      }
+    return data;
+  }
+  if (data?._flag === "json") {
+    const routerResponse = data.routerResponse;
+    if (routerResponse instanceof Response) {
+      return routerResponse;
     }
-    function splitCookiesString2(cookiesString) {
-      if (Array.isArray(cookiesString)) {
-        return cookiesString;
-      }
-      if (typeof cookiesString !== "string") {
-        return [];
-      }
-      var cookiesStrings = [];
-      var pos = 0;
-      var start;
-      var ch;
-      var lastComma;
-      var nextStart;
-      var cookiesSeparatorFound;
-      function skipWhitespace() {
-        while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
-          pos += 1;
-        }
-        return pos < cookiesString.length;
-      }
-      function notSpecialChar() {
-        ch = cookiesString.charAt(pos);
-        return ch !== "=" && ch !== ";" && ch !== ",";
-      }
-      while (pos < cookiesString.length) {
-        start = pos;
-        cookiesSeparatorFound = false;
-        while (skipWhitespace()) {
-          ch = cookiesString.charAt(pos);
-          if (ch === ",") {
-            lastComma = pos;
-            pos += 1;
-            skipWhitespace();
-            nextStart = pos;
-            while (pos < cookiesString.length && notSpecialChar()) {
-              pos += 1;
-            }
-            if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
-              cookiesSeparatorFound = true;
-              pos = nextStart;
-              cookiesStrings.push(cookiesString.substring(start, lastComma));
-              start = pos;
-            } else {
-              pos = lastComma + 1;
-            }
-          } else {
-            pos += 1;
-          }
-        }
-        if (!cookiesSeparatorFound || pos >= cookiesString.length) {
-          cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
-        }
+    return toResponse(data.body, {
+      headers: data.headers,
+      status: data.status
+    });
+  }
+  if (data instanceof APIError) {
+    return toResponse(data.body, {
+      status: data.statusCode,
+      statusText: data.status.toString(),
+      headers: {
+        ...data.headers instanceof Headers ? Object.fromEntries(data.headers.entries()) : data?.headers,
+        ...init?.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : init?.headers
       }
-      return cookiesStrings;
-    }
-    module.exports = parse2;
-    module.exports.parse = parse2;
-    module.exports.parseString = parseString;
-    module.exports.splitCookiesString = splitCookiesString2;
+    });
   }
-});
-
-// src/endpoint.ts
-import { ZodError } from "zod";
+  let body = data;
+  let headers = new Headers(init?.headers);
+  if (!data) {
+    headers.set("content-type", "application/json");
+  } else if (typeof data === "string") {
+    body = data;
+    headers.set("Content-Type", "text/plain");
+  } else if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+    body = data;
+    headers.set("Content-Type", "application/octet-stream");
+  } else if (data instanceof Blob) {
+    body = data;
+    headers.set("Content-Type", data.type || "application/octet-stream");
+  } else if (data instanceof FormData) {
+    body = data;
+  } else if (data instanceof URLSearchParams) {
+    body = data;
+    headers.set("Content-Type", "application/x-www-form-urlencoded");
+  } else if (data instanceof ReadableStream) {
+    body = data;
+    headers.set("Content-Type", "application/octet-stream");
+  } else if (isJSONSerializable(data)) {
+    body = JSON.stringify(data);
+    headers.set("Content-Type", "application/json");
+  }
+  return new Response(body, {
+    ...init,
+    headers
+  });
+}
 
-// src/error.ts
-var APIError = class extends Error {
-  constructor(status, body, headers) {
-    super(`API Error: ${status} ${body?.message ?? ""}`, {
-      cause: body
-    });
-    __publicField(this, "status");
-    __publicField(this, "headers");
-    __publicField(this, "body");
-    this.status = status;
-    this.body = body ?? {};
-    this.body.code = body?.message ? body.message.toUpperCase().replace(/ /g, "_").replace(/[^A-Z0-9_]/g, "") : status;
-    this.stack = "";
-    this.headers = headers ?? new Headers();
-    if (!this.headers.has("Content-Type")) {
-      this.headers.set("Content-Type", "application/json");
+// src/validator.ts
+async function runValidation(options, context = {}) {
+  let request = {
+    body: context.body,
+    query: context.query
+  };
+  if (options.body) {
+    const result = await options.body["~standard"].validate(context.body);
+    if (result.issues) {
+      return {
+        data: null,
+        error: fromError(result.issues, "body")
+      };
     }
-    this.name = "BetterCallAPIError";
+    request.body = result.value;
+  }
+  if (options.query) {
+    const result = await options.query["~standard"].validate(context.query);
+    if (result.issues) {
+      return {
+        data: null,
+        error: fromError(result.issues, "query")
+      };
+    }
+    request.query = result.value;
+  }
+  if (options.requireHeaders && !context.headers) {
+    return {
+      data: null,
+      error: { message: "Headers is required" }
+    };
+  }
+  if (options.requireRequest && !context.request) {
+    return {
+      data: null,
+      error: { message: "Request is required" }
+    };
   }
-};
-
-// src/helper.ts
-var json = (body, option) => {
   return {
-    response: {
-      body: option?.body ?? body,
-      status: option?.status ?? 200,
-      statusText: option?.statusText ?? "OK",
-      headers: option?.headers
-    },
-    body,
-    _flag: "json"
+    data: request,
+    error: null
   };
-};
+}
+function fromError(error, validating) {
+  const errorMessages = [];
+  for (const issue of error) {
+    const message = issue.message;
+    errorMessages.push(message);
+  }
+  return {
+    message: `Invalid ${validating} parameters`
+  };
+}
 
-// src/cookie.ts
+// src/crypto.ts
 import { subtle } from "uncrypto";
 var algorithm = { name: "HMAC", hash: "SHA-256" };
 var getCryptoKey = async (secret) => {
   const secretBuf = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
   return await subtle.importKey("raw", secretBuf, algorithm, false, ["sign", "verify"]);
 };
-var makeSignature = async (value, secret) => {
-  const key = await getCryptoKey(secret);
-  const signature = await subtle.sign(algorithm.name, key, new TextEncoder().encode(value));
-  return btoa(String.fromCharCode(...new Uint8Array(signature)));
-};
 var verifySignature = async (base64Signature, value, secret) => {
   try {
     const signatureBinStr = atob(base64Signature);
@@ -257,54 +223,54 @@ var verifySignature = async (base64Signature, value, secret) => {
     return false;
   }
 };
-var validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
-var validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
-var parse = (cookie, name) => {
-  const pairs = cookie.trim().split(";");
-  return pairs.reduce((parsedCookie, pairStr) => {
-    pairStr = pairStr.trim();
-    const valueStartPos = pairStr.indexOf("=");
-    if (valueStartPos === -1) {
-      return parsedCookie;
-    }
-    const cookieName = pairStr.substring(0, valueStartPos).trim();
-    if (name && name !== cookieName || !validCookieNameRegEx.test(cookieName)) {
-      return parsedCookie;
-    }
-    let cookieValue = pairStr.substring(valueStartPos + 1).trim();
-    if (cookieValue.startsWith('"') && cookieValue.endsWith('"')) {
-      cookieValue = cookieValue.slice(1, -1);
-    }
-    if (validCookieValueRegEx.test(cookieValue)) {
-      parsedCookie[cookieName] = decodeURIComponent(cookieValue);
-    }
-    return parsedCookie;
-  }, {});
+var makeSignature = async (value, secret) => {
+  const key = await getCryptoKey(secret);
+  const signature = await subtle.sign(algorithm.name, key, new TextEncoder().encode(value));
+  return btoa(String.fromCharCode(...new Uint8Array(signature)));
 };
-var parseSigned = async (cookie, secret, name) => {
-  const parsedCookie = {};
-  const secretKey = await getCryptoKey(secret);
-  for (const [key, value] of Object.entries(parse(cookie, name))) {
-    const signatureStartPos = value.lastIndexOf(".");
-    if (signatureStartPos < 1) {
-      continue;
-    }
-    const signedValue = value.substring(0, signatureStartPos);
-    const signature = value.substring(signatureStartPos + 1);
-    if (signature.length !== 44 || !signature.endsWith("=")) {
-      continue;
+var signCookieValue = async (value, secret) => {
+  const signature = await makeSignature(value, secret);
+  value = `${value}.${signature}`;
+  value = encodeURIComponent(value);
+  return value;
+};
+
+// src/cookies.ts
+var getCookieKey = (key, prefix) => {
+  let finalKey = key;
+  if (prefix) {
+    if (prefix === "secure") {
+      finalKey = "__Secure-" + key;
+    } else if (prefix === "host") {
+      finalKey = "__Host-" + key;
+    } else {
+      return void 0;
     }
-    const isVerified = await verifySignature(signature, signedValue, secretKey);
-    parsedCookie[key] = isVerified ? signedValue : false;
   }
-  return parsedCookie;
+  return finalKey;
 };
-var _serialize = (name, value, opt = {}) => {
-  let cookie = `${name}=${value}`;
-  if (name.startsWith("__Secure-") && !opt.secure) {
+function parseCookies(cookieHeader) {
+  const cookies = cookieHeader.split(";");
+  const cookieMap = /* @__PURE__ */ new Map();
+  cookies.forEach((cookie) => {
+    const [name, value] = cookie.trim().split("=");
+    cookieMap.set(name, decodeURIComponent(value));
+  });
+  return cookieMap;
+}
+var _serialize = (key, value, opt = {}) => {
+  let cookie;
+  if (opt?.prefix === "secure") {
+    cookie = `${`__Secure-${key}`}=${value}`;
+  } else if (opt?.prefix === "host") {
+    cookie = `${`__Host-${key}`}=${value}`;
+  } else {
+    cookie = `${key}=${value}`;
+  }
+  if (key.startsWith("__Secure-") && !opt.secure) {
     opt.secure = true;
   }
-  if (name.startsWith("__Host-")) {
+  if (key.startsWith("__Host-")) {
     if (!opt.secure) {
       opt.secure = true;
     }
@@ -348,111 +314,209 @@ var _serialize = (name, value, opt = {}) => {
   }
   if (opt.partitioned) {
     if (!opt.secure) {
-      throw new Error("Partitioned Cookie must have Secure attributes");
+      opt.secure = true;
     }
     cookie += "; Partitioned";
   }
   return cookie;
 };
-var serialize = (name, value, opt) => {
+var serializeCookie = (key, value, opt) => {
   value = encodeURIComponent(value);
-  return _serialize(name, value, opt);
+  return _serialize(key, value, opt);
 };
-var serializeSigned = async (name, value, secret, opt = {}) => {
-  const signature = await makeSignature(value, secret);
-  value = `${value}.${signature}`;
-  value = encodeURIComponent(value);
-  return _serialize(name, value, opt);
-};
-var signCookieValue = async (value, secret) => {
-  const signature = await makeSignature(value, secret);
-  value = `${value}.${signature}`;
-  value = encodeURIComponent(value);
-  return value;
+var serializeSignedCookie = async (key, value, secret, opt) => {
+  value = await signCookieValue(value, secret);
+  return _serialize(key, value, opt);
 };
 
-// src/cookie-utils.ts
-var getCookie = (cookie, key, prefix) => {
-  if (!cookie) {
-    return void 0;
-  }
-  let finalKey = key;
-  if (prefix) {
-    if (prefix === "secure") {
-      finalKey = "__Secure-" + key;
-    } else if (prefix === "host") {
-      finalKey = "__Host-" + key;
-    } else {
-      return void 0;
-    }
-  }
-  const obj = parse(cookie, finalKey);
-  return obj[finalKey];
-};
-var setCookie = (header, name, value, opt) => {
-  const existingCookies = header.get("Set-Cookie");
-  if (existingCookies) {
-    const cookies = existingCookies.split(", ");
-    const updatedCookies = cookies.filter((cookie2) => !cookie2.startsWith(`${name}=`));
-    header.delete("Set-Cookie");
-    updatedCookies.forEach((cookie2) => header.append("Set-Cookie", cookie2));
-  }
-  let cookie;
-  if (opt?.prefix === "secure") {
-    cookie = serialize("__Secure-" + name, value, { path: "/", ...opt, secure: true });
-  } else if (opt?.prefix === "host") {
-    cookie = serialize("__Host-" + name, value, {
-      ...opt,
-      path: "/",
-      secure: true,
-      domain: void 0
+// src/context.ts
+var createInternalContext = async (context, {
+  options,
+  path
+}) => {
+  const headers = new Headers();
+  const { data, error } = await runValidation(options, context);
+  if (error) {
+    throw new APIError(400, {
+      message: error.message,
+      code: "VALIDATION_ERROR"
     });
-  } else {
-    cookie = serialize(name, value, { path: "/", ...opt });
   }
-  header.append("Set-Cookie", cookie);
-};
-var setSignedCookie = async (header, name, value, secret, opt) => {
-  let cookie;
-  if (opt?.prefix === "secure") {
-    cookie = await serializeSigned("__Secure-" + name, value, secret, {
-      path: "/",
-      ...opt,
-      secure: true
-    });
-  } else if (opt?.prefix === "host") {
-    cookie = await serializeSigned("__Host-" + name, value, secret, {
-      ...opt,
-      path: "/",
-      secure: true,
-      domain: void 0
+  const requestHeaders = "headers" in context ? context.headers instanceof Headers ? context.headers : new Headers(context.headers) : "request" in context && context.request instanceof Request ? context.request.headers : null;
+  const requestCookies = requestHeaders?.get("cookie");
+  const parsedCookies = requestCookies ? parseCookies(requestCookies) : void 0;
+  const internalContext = {
+    ...context,
+    body: data.body,
+    query: data.query,
+    path: context.path || path,
+    context: "context" in context && context.context ? context.context : {},
+    returned: void 0,
+    headers: context?.headers,
+    request: context?.request,
+    params: "params" in context ? context.params : void 0,
+    method: context.method,
+    setHeader: (key, value) => {
+      headers.set(key, value);
+    },
+    getHeader: (key) => {
+      if (!requestHeaders) return null;
+      return requestHeaders.get(key);
+    },
+    getCookie: (key, prefix) => {
+      const finalKey = getCookieKey(key, prefix);
+      if (!finalKey) {
+        return null;
+      }
+      return parsedCookies?.get(finalKey) || null;
+    },
+    getSignedCookie: async (key, secret, prefix) => {
+      const finalKey = getCookieKey(key, prefix);
+      if (!finalKey) {
+        return null;
+      }
+      const value = parsedCookies?.get(finalKey);
+      if (!value) {
+        return null;
+      }
+      const signatureStartPos = value.lastIndexOf(".");
+      if (signatureStartPos < 1) {
+        return null;
+      }
+      const signedValue = value.substring(0, signatureStartPos);
+      const signature = value.substring(signatureStartPos + 1);
+      if (signature.length !== 44 || !signature.endsWith("=")) {
+        return null;
+      }
+      const secretKey = await getCryptoKey(secret);
+      const isVerified = await verifySignature(signature, signedValue, secretKey);
+      return isVerified ? signedValue : false;
+    },
+    setCookie: (key, value, options2) => {
+      const cookie = serializeCookie(key, value, options2);
+      headers.append("set-cookie", cookie);
+      return cookie;
+    },
+    setSignedCookie: async (key, value, secret, options2) => {
+      const cookie = await serializeSignedCookie(key, value, secret, options2);
+      headers.append("set-cookie", cookie);
+      return cookie;
+    },
+    redirect: (url) => {
+      headers.set("location", url);
+      return new APIError("FOUND", void 0, headers);
+    },
+    error: (status, body, headers2) => {
+      return new APIError(status, body, headers2);
+    },
+    json: (json, routerResponse) => {
+      if (!context.asResponse) {
+        return json;
+      }
+      return {
+        body: routerResponse?.body || json,
+        routerResponse,
+        _flag: "json"
+      };
+    },
+    responseHeaders: headers
+  };
+  for (const middleware of options.use || []) {
+    const response = await middleware({
+      ...internalContext,
+      returnHeaders: true,
+      asResponse: false
     });
-  } else {
-    cookie = await serializeSigned(name, value, secret, { path: "/", ...opt });
+    if (response.response) {
+      Object.assign(internalContext.context, response.response);
+    }
+    if (response.headers) {
+      response.headers.forEach((value, key) => {
+        internalContext.responseHeaders.set(key, value);
+      });
+    }
   }
-  header.append("Set-Cookie", cookie);
+  return internalContext;
 };
-var getSignedCookie = async (header, secret, key, prefix) => {
-  const cookie = header.get("cookie");
-  if (!cookie) {
-    return void 0;
-  }
-  let finalKey = key;
-  if (prefix) {
-    if (prefix === "secure") {
-      finalKey = "__Secure-" + key;
-    } else if (prefix === "host") {
-      finalKey = "__Host-" + key;
+
+// src/middleware.ts
+function createMiddleware(optionsOrHandler, handler) {
+  const internalHandler = async (inputCtx) => {
+    const context = inputCtx;
+    const _handler = typeof optionsOrHandler === "function" ? optionsOrHandler : handler;
+    const options = typeof optionsOrHandler === "function" ? {} : optionsOrHandler;
+    const internalContext = await createInternalContext(context, {
+      options,
+      path: "/"
+    });
+    if (!_handler) {
+      throw new Error("handler must be defined");
+    }
+    const response = await _handler(internalContext);
+    const headers = internalContext.responseHeaders;
+    return context.returnHeaders ? {
+      headers,
+      response
+    } : response;
+  };
+  internalHandler.options = typeof optionsOrHandler === "function" ? {} : optionsOrHandler;
+  return internalHandler;
+}
+createMiddleware.create = (opts) => {
+  function fn(optionsOrHandler, handler) {
+    if (typeof optionsOrHandler === "function") {
+      return createMiddleware(
+        {
+          use: opts?.use
+        },
+        optionsOrHandler
+      );
     }
+    if (!handler) {
+      throw new Error("Middleware handler is required");
+    }
+    const middleware = createMiddleware(
+      {
+        ...optionsOrHandler,
+        method: "*",
+        use: [...opts?.use || [], ...optionsOrHandler.use || []]
+      },
+      handler
+    );
+    return middleware;
   }
-  const obj = await parseSigned(cookie, secret, finalKey);
-  return obj[finalKey];
+  return fn;
 };
 
 // src/endpoint.ts
-function createEndpointCreator(opts) {
+var createEndpoint2 = (path, options, handler) => {
+  const internalHandler = async (...inputCtx) => {
+    const context = inputCtx[0] || {};
+    const internalContext = await createInternalContext(context, {
+      options,
+      path
+    });
+    const response = await handler(internalContext).catch((e) => {
+      if (e instanceof APIError && context.asResponse) {
+        return e;
+      }
+      throw e;
+    });
+    const headers = internalContext.responseHeaders;
+    return context.asResponse ? toResponse(response, {
+      headers
+    }) : context.returnHeaders ? {
+      headers,
+      response
+    } : response;
+  };
+  internalHandler.options = options;
+  internalHandler.path = path;
+  return internalHandler;
+};
+createEndpoint2.create = (opts) => {
   return (path, options, handler) => {
-    return createEndpoint(
+    return createEndpoint2(
       path,
       {
         ...options,
@@ -461,152 +525,300 @@ function createEndpointCreator(opts) {
       handler
     );
   };
+};
+
+// src/router.ts
+import { createRouter as createRou3Router, addRoute, findRoute, findAllRoutes } from "rou3";
+
+// src/openapi.ts
+import { ZodObject, ZodOptional, ZodSchema } from "zod";
+var paths = {};
+function getTypeFromZodType(zodType) {
+  switch (zodType.constructor.name) {
+    case "ZodString":
+      return "string";
+    case "ZodNumber":
+      return "number";
+    case "ZodBoolean":
+      return "boolean";
+    case "ZodObject":
+      return "object";
+    case "ZodArray":
+      return "array";
+    default:
+      return "string";
+  }
 }
-function createEndpoint(path, options, handler) {
-  let responseHeader = new Headers();
-  const handle = async (...ctx) => {
-    let internalCtx = {
-      setHeader(key, value) {
-        responseHeader.set(key, value);
-      },
-      setCookie(key, value, options2) {
-        setCookie(responseHeader, key, value, options2);
-      },
-      getCookie(key, prefix) {
-        const header = ctx[0]?.headers;
-        const cookieH = header?.get("cookie");
-        const cookie = getCookie(cookieH || "", key, prefix);
-        return cookie;
+function getParameters(options) {
+  const parameters = [];
+  if (options.metadata?.openAPI?.parameters) {
+    parameters.push(...options.metadata.openAPI.parameters);
+    return parameters;
+  }
+  if (options.query instanceof ZodObject) {
+    Object.entries(options.query.shape).forEach(([key, value]) => {
+      if (value instanceof ZodSchema) {
+        parameters.push({
+          name: key,
+          in: "query",
+          schema: {
+            type: getTypeFromZodType(value),
+            ..."minLength" in value && value.minLength ? {
+              minLength: value.minLength
+            } : {},
+            description: value.description
+          }
+        });
+      }
+    });
+  }
+  return parameters;
+}
+function getRequestBody(options) {
+  if (options.metadata?.openAPI?.requestBody) {
+    return options.metadata.openAPI.requestBody;
+  }
+  if (!options.body) return void 0;
+  if (options.body instanceof ZodObject || options.body instanceof ZodOptional) {
+    const shape = options.body.shape;
+    if (!shape) return void 0;
+    const properties = {};
+    const required = [];
+    Object.entries(shape).forEach(([key, value]) => {
+      if (value instanceof ZodSchema) {
+        properties[key] = {
+          type: getTypeFromZodType(value),
+          description: value.description
+        };
+        if (!(value instanceof ZodOptional)) {
+          required.push(key);
+        }
+      }
+    });
+    return {
+      required: options.body instanceof ZodOptional ? false : options.body ? true : false,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties,
+            required
+          }
+        }
+      }
+    };
+  }
+  return void 0;
+}
+function getResponse(responses) {
+  return {
+    "400": {
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              message: {
+                type: "string"
+              }
+            },
+            required: ["message"]
+          }
+        }
       },
-      getSignedCookie(key, secret, prefix) {
-        const header = ctx[0]?.headers;
-        if (!header) {
-          throw new TypeError("Headers are required");
+      description: "Bad Request. Usually due to missing parameters, or invalid parameters."
+    },
+    "401": {
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              message: {
+                type: "string"
+              }
+            },
+            required: ["message"]
+          }
         }
-        const cookie = getSignedCookie(header, secret, key, prefix);
-        return cookie;
       },
-      async setSignedCookie(key, value, secret, options2) {
-        await setSignedCookie(responseHeader, key, value, secret, options2);
+      description: "Unauthorized. Due to missing or invalid authentication."
+    },
+    "403": {
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              message: {
+                type: "string"
+              }
+            }
+          }
+        }
       },
-      redirect(url) {
-        responseHeader.set("Location", url);
-        return new APIError("FOUND");
+      description: "Forbidden. You do not have permission to access this resource or to perform this action."
+    },
+    "404": {
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              message: {
+                type: "string"
+              }
+            }
+          }
+        }
       },
-      json,
-      context: ctx[0]?.context || {},
-      _flag: ctx[0]?.asResponse ? "router" : ctx[0]?._flag,
-      responseHeader,
-      path,
-      ...ctx[0] || {}
-    };
-    if (options.use?.length) {
-      let middlewareContexts = {};
-      let middlewareBody = {};
-      for (const middleware of options.use) {
-        if (typeof middleware !== "function") {
-          console.warn("Middleware is not a function", {
-            middleware
-          });
-          continue;
+      description: "Not Found. The requested resource was not found."
+    },
+    "429": {
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              message: {
+                type: "string"
+              }
+            }
+          }
         }
-        const res = await middleware(internalCtx);
-        if (res) {
-          const body = res.options?.body ? res.options.body.parse(internalCtx.body) : void 0;
-          middlewareContexts = {
-            ...middlewareContexts,
-            ...res
-          };
-          middlewareBody = {
-            ...middlewareBody,
-            ...body
-          };
+      },
+      description: "Too Many Requests. You have exceeded the rate limit. Try again later."
+    },
+    "500": {
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              message: {
+                type: "string"
+              }
+            }
+          }
         }
-      }
-      internalCtx = {
-        ...internalCtx,
-        body: {
-          ...middlewareBody,
-          ...internalCtx.body
-        },
-        context: {
-          ...internalCtx.context || {},
-          ...middlewareContexts
+      },
+      description: "Internal Server Error. This is a problem with the server that you cannot fix."
+    },
+    ...responses
+  };
+}
+async function generator(endpoints, config) {
+  const components = {
+    schemas: {}
+  };
+  Object.entries(endpoints).forEach(([_, value]) => {
+    const options = value.options;
+    if (options.metadata?.SERVER_ONLY) return;
+    if (options.method === "GET") {
+      paths[value.path] = {
+        get: {
+          tags: ["Default", ...options.metadata?.openAPI?.tags || []],
+          description: options.metadata?.openAPI?.description,
+          operationId: options.metadata?.openAPI?.operationId,
+          security: [
+            {
+              bearerAuth: []
+            }
+          ],
+          parameters: getParameters(options),
+          responses: getResponse(options.metadata?.openAPI?.responses)
         }
       };
     }
-    try {
-      const body = options.body ? options.body.parse(internalCtx.body) : internalCtx.body;
-      internalCtx = {
-        ...internalCtx,
-        body: body ? {
-          ...body,
-          ...internalCtx.body
-        } : internalCtx.body
+    if (options.method === "POST") {
+      const body = getRequestBody(options);
+      paths[value.path] = {
+        post: {
+          tags: ["Default", ...options.metadata?.openAPI?.tags || []],
+          description: options.metadata?.openAPI?.description,
+          operationId: options.metadata?.openAPI?.operationId,
+          security: [
+            {
+              bearerAuth: []
+            }
+          ],
+          parameters: getParameters(options),
+          ...body ? { requestBody: body } : {
+            requestBody: {
+              //set body none
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    properties: {}
+                  }
+                }
+              }
+            }
+          },
+          responses: getResponse(options.metadata?.openAPI?.responses)
+        }
       };
-      internalCtx.query = options.query ? options.query.parse(internalCtx.query) : internalCtx.query;
-    } catch (e) {
-      if (e instanceof ZodError) {
-        throw new APIError("BAD_REQUEST", {
-          message: e.message,
-          details: e.errors
-        });
-      }
-      throw e;
-    }
-    if (options.requireHeaders && !internalCtx.headers) {
-      throw new APIError("BAD_REQUEST", {
-        message: "Headers are required"
-      });
     }
-    if (options.requireRequest && !internalCtx.request) {
-      throw new APIError("BAD_REQUEST", {
-        message: "Request is required"
-      });
-    }
-    if (internalCtx.request && !internalCtx.headers) {
-      internalCtx.headers = internalCtx.request.headers;
-    }
-    try {
-      let res = await handler(internalCtx);
-      let actualResponse = res;
-      if (res && typeof res === "object" && "_flag" in res) {
-        if (res._flag === "json" && internalCtx._flag === "router") {
-          const h = res.response.headers;
-          Object.keys(h || {}).forEach((key) => {
-            responseHeader.set(key, h[key]);
-          });
-          responseHeader.set("Content-Type", "application/json");
-          actualResponse = new Response(JSON.stringify(res.response.body), {
-            status: res.response.status ?? 200,
-            statusText: res.response.statusText,
-            headers: responseHeader
-          });
-        } else {
-          actualResponse = res.body;
-        }
+  });
+  const res = {
+    openapi: "3.1.1",
+    info: {
+      title: "Better Auth",
+      description: "API Reference for your Better Auth Instance",
+      version: "1.1.0"
+    },
+    components,
+    security: [
+      {
+        apiKeyCookie: []
       }
-      responseHeader = new Headers();
-      return actualResponse;
-    } catch (e) {
-      if (e instanceof APIError) {
-        responseHeader.set("Content-Type", "application/json");
-        e.headers = responseHeader;
-        responseHeader = new Headers();
-        throw e;
+    ],
+    servers: [
+      {
+        url: config?.url
       }
-      throw e;
-    }
+    ],
+    tags: [
+      {
+        name: "Default",
+        description: "Default endpoints that are included with Better Auth by default. These endpoints are not part of any plugin."
+      }
+    ],
+    paths
   };
-  handle.path = path;
-  handle.options = options;
-  handle.method = options.method;
-  handle.headers = responseHeader;
-  return handle;
+  return res;
 }
-
-// src/router.ts
-import { createRouter as createRou3Router, addRoute, findRoute, findAllRoutes } from "rou3";
+var getHTML = (apiReference, config) => `<!doctype html>
+<html>
+  <head>
+    <title>Scalar API Reference</title>
+    <meta charset="utf-8" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1" />
+  </head>
+  <body>
+    <script
+      id="api-reference"
+      type="application/json">
+    ${JSON.stringify(apiReference)}
+    </script>
+	 <script>
+      var configuration = {
+	  	favicon: ${config?.logo ? `data:image/svg+xml;utf8,${encodeURIComponent(config.logo)}` : void 0} ,
+	   	theme: ${config?.theme || "saturn"},
+        metaData: {
+			title: ${config?.title || "Open API Reference"},
+			description: ${config?.description || "Better Call Open API"},
+		}
+      }
+      document.getElementById('api-reference').dataset.configuration =
+        JSON.stringify(configuration)
+    </script>
+	  <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+  </body>
+</html>`;
 
 // src/utils.ts
 async function getBody(request) {
@@ -648,180 +860,89 @@ async function getBody(request) {
   }
   return await request.text();
 }
-function shouldSerialize(body) {
-  return typeof body === "object" && body !== null && !(body instanceof Blob) && !(body instanceof FormData);
-}
-var statusCode = {
-  OK: 200,
-  CREATED: 201,
-  ACCEPTED: 202,
-  NO_CONTENT: 204,
-  MULTIPLE_CHOICES: 300,
-  MOVED_PERMANENTLY: 301,
-  FOUND: 302,
-  SEE_OTHER: 303,
-  NOT_MODIFIED: 304,
-  TEMPORARY_REDIRECT: 307,
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  PAYMENT_REQUIRED: 402,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  METHOD_NOT_ALLOWED: 405,
-  NOT_ACCEPTABLE: 406,
-  PROXY_AUTHENTICATION_REQUIRED: 407,
-  REQUEST_TIMEOUT: 408,
-  CONFLICT: 409,
-  GONE: 410,
-  LENGTH_REQUIRED: 411,
-  PRECONDITION_FAILED: 412,
-  PAYLOAD_TOO_LARGE: 413,
-  URI_TOO_LONG: 414,
-  UNSUPPORTED_MEDIA_TYPE: 415,
-  RANGE_NOT_SATISFIABLE: 416,
-  EXPECTATION_FAILED: 417,
-  "I'M_A_TEAPOT": 418,
-  MISDIRECTED_REQUEST: 421,
-  UNPROCESSABLE_ENTITY: 422,
-  LOCKED: 423,
-  FAILED_DEPENDENCY: 424,
-  TOO_EARLY: 425,
-  UPGRADE_REQUIRED: 426,
-  PRECONDITION_REQUIRED: 428,
-  TOO_MANY_REQUESTS: 429,
-  REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
-  UNAVAILABLE_FOR_LEGAL_REASONS: 451,
-  INTERNAL_SERVER_ERROR: 500,
-  NOT_IMPLEMENTED: 501,
-  BAD_GATEWAY: 502,
-  SERVICE_UNAVAILABLE: 503,
-  GATEWAY_TIMEOUT: 504,
-  HTTP_VERSION_NOT_SUPPORTED: 505,
-  VARIANT_ALSO_NEGOTIATES: 506,
-  INSUFFICIENT_STORAGE: 507,
-  LOOP_DETECTED: 508,
-  NOT_EXTENDED: 510,
-  NETWORK_AUTHENTICATION_REQUIRED: 511
-};
 
 // src/router.ts
 var createRouter = (endpoints, config) => {
-  const _endpoints = Object.values(endpoints);
-  const router = createRou3Router();
-  for (const endpoint of _endpoints) {
-    if (endpoint.options.metadata?.SERVER_ONLY) continue;
-    if (Array.isArray(endpoint.options?.method)) {
-      for (const method of endpoint.options.method) {
-        addRoute(router, method, endpoint.path, endpoint);
+  if (!config?.openAPI?.disabled) {
+    const openAPI = {
+      path: "/api/reference",
+      ...config?.openAPI
+    };
+    endpoints["openAPI"] = createEndpoint2(
+      openAPI.path,
+      {
+        method: "GET"
+      },
+      async (c) => {
+        const schema = await generator(endpoints);
+        return new Response(getHTML(schema, openAPI.scalar), {
+          headers: {
+            "Content-Type": "text/html"
+          }
+        });
       }
-    } else {
-      addRoute(router, endpoint.options.method, endpoint.path, endpoint);
-    }
+    );
   }
+  const router = createRou3Router();
   const middlewareRouter = createRou3Router();
-  for (const route of config?.routerMiddleware || []) {
-    addRoute(middlewareRouter, "*", route.path, route.middleware);
+  for (const endpoint of Object.values(endpoints)) {
+    if (!endpoint.options) {
+      continue;
+    }
+    if (endpoint.options?.metadata?.SERVER_ONLY) continue;
+    const methods = Array.isArray(endpoint.options?.method) ? endpoint.options.method : [endpoint.options?.method];
+    for (const method of methods) {
+      addRoute(router, method, endpoint.path, endpoint);
+    }
   }
-  const handler = async (request) => {
-    const url = new URL(request.url);
-    let path = url.pathname;
-    if (config?.basePath) {
-      path = path.split(config.basePath)[1];
+  if (config?.routerMiddleware?.length) {
+    for (const { path, middleware } of config.routerMiddleware) {
+      addRoute(middlewareRouter, "*", path, middleware);
     }
+  }
+  const processRequest = async (request) => {
+    const url = new URL(request.url);
+    const path = config?.basePath ? url.pathname.split(config.basePath)[1] : url.pathname;
     if (!path?.length) {
-      config?.onError?.(new APIError("NOT_FOUND"));
-      console.warn(
-        `[better-call]: Make sure the URL has the basePath (${config?.basePath}).`
-      );
-      return new Response(null, {
-        status: 404,
-        statusText: "Not Found"
-      });
+      config?.onError?.(new Error("NOT_FOUND"));
+      return new Response(null, { status: 404, statusText: "Not Found" });
     }
-    const method = request.method;
-    const route = findRoute(router, method, path);
-    const handler2 = route?.data;
-    const body = await getBody(request);
-    const headers = request.headers;
-    const query = Object.fromEntries(url.searchParams);
-    const routerMiddleware = findAllRoutes(middlewareRouter, "*", path);
-    if (!handler2) {
-      return new Response(null, {
-        status: 404,
-        statusText: "Not Found"
-      });
+    const route = findRoute(router, request.method, path);
+    if (!route?.data) {
+      return new Response(null, { status: 404, statusText: "Not Found" });
     }
+    const handler = route.data;
+    const context = {
+      path,
+      method: request.method,
+      headers: request.headers,
+      params: route.params,
+      request,
+      body: await getBody(handler.options.cloneRequest ? request.clone() : request),
+      query: Object.fromEntries(url.searchParams),
+      _flag: "router",
+      asResponse: true,
+      context: config?.routerContext
+    };
     try {
-      let middlewareContext = {};
-      if (routerMiddleware?.length) {
-        for (const route2 of routerMiddleware) {
-          const middleware = route2.data;
+      const middlewareRoutes = findAllRoutes(middlewareRouter, "*", path);
+      if (middlewareRoutes?.length) {
+        for (const { data: middleware, params } of middlewareRoutes) {
           const res = await middleware({
-            path,
-            method,
-            headers,
-            params: route2?.params,
-            request,
-            body,
-            query,
-            context: {
-              ...config?.extraContext
-            }
+            ...context,
+            params,
+            asResponse: false
           });
-          if (res instanceof Response) {
-            return res;
-          }
-          if (res?._flag === "json") {
-            return new Response(JSON.stringify(res), {
-              headers: res.headers
-            });
-          }
-          if (res) {
-            middlewareContext = {
-              ...res,
-              ...middlewareContext
-            };
-          }
-        }
-      }
-      const handlerRes = await handler2({
-        path,
-        method,
-        headers,
-        params: route?.params,
-        request,
-        body,
-        query,
-        _flag: "router",
-        context: {
-          ...middlewareContext,
-          ...config?.extraContext
-        }
-      });
-      if (handlerRes instanceof Response) {
-        return handlerRes;
-      }
-      const resBody = shouldSerialize(handlerRes) ? JSON.stringify(handlerRes) : handlerRes;
-      return new Response(resBody, {
-        headers: handler2.headers
-      });
-    } catch (e) {
-      if (config?.onError) {
-        const onErrorRes = await config.onError(e);
-        if (onErrorRes instanceof Response) {
-          return onErrorRes;
+          if (res instanceof Response) return res;
         }
       }
-      if (e instanceof APIError) {
-        return new Response(e.body ? JSON.stringify(e.body) : null, {
-          status: statusCode[e.status],
-          statusText: e.status,
-          headers: e.headers
-        });
-      }
-      if (config?.throwError) {
-        throw e;
+      const response = await handler(context);
+      return response;
+    } catch (error) {
+      if (error instanceof APIError) {
+        return toResponse(error);
       }
+      console.error(`# SERVER_ERROR: `, error);
       return new Response(null, {
         status: 500,
         statusText: "Internal Server Error"
@@ -835,7 +956,7 @@ var createRouter = (endpoints, config) => {
         return onReq;
       }
       const req = onReq instanceof Request ? onReq : request;
-      const res = await handler(req);
+      const res = await processRequest(req);
       const onRes = await config?.onResponse?.(res);
       if (onRes instanceof Response) {
         return onRes;
@@ -845,224 +966,19 @@ var createRouter = (endpoints, config) => {
     endpoints
   };
 };
-
-// src/middleware.ts
-function createMiddleware(optionsOrHandler, handler) {
-  if (typeof optionsOrHandler === "function") {
-    return createEndpoint(
-      "*",
-      {
-        method: "*"
-      },
-      optionsOrHandler
-    );
-  }
-  if (!handler) {
-    throw new Error("Middleware handler is required");
-  }
-  const endpoint = createEndpoint(
-    "*",
-    {
-      ...optionsOrHandler,
-      method: "*"
-    },
-    handler
-  );
-  return endpoint;
-}
-var createMiddlewareCreator = (opts) => {
-  function fn(optionsOrHandler, handler) {
-    if (typeof optionsOrHandler === "function") {
-      return createEndpoint(
-        "*",
-        {
-          method: "*"
-        },
-        optionsOrHandler
-      );
-    }
-    if (!handler) {
-      throw new Error("Middleware handler is required");
-    }
-    const endpoint = createEndpoint(
-      "*",
-      {
-        ...optionsOrHandler,
-        method: "*"
-      },
-      handler
-    );
-    return endpoint;
-  }
-  return fn;
-};
-
-// src/types.ts
-import "zod";
-
-// src/adapter/request.ts
-var set_cookie_parser = __toESM(require_set_cookie(), 1);
-function get_raw_body(req, body_size_limit) {
-  const h = req.headers;
-  if (!h["content-type"]) return null;
-  const content_length = Number(h["content-length"]);
-  if (req.httpVersionMajor === 1 && isNaN(content_length) && h["transfer-encoding"] == null || content_length === 0) {
-    return null;
-  }
-  let length = content_length;
-  if (body_size_limit) {
-    if (!length) {
-      length = body_size_limit;
-    } else if (length > body_size_limit) {
-      throw Error(
-        `Received content-length of ${length}, but only accept up to ${body_size_limit} bytes.`
-      );
-    }
-  }
-  if (req.destroyed) {
-    const readable = new ReadableStream();
-    readable.cancel();
-    return readable;
-  }
-  let size = 0;
-  let cancelled = false;
-  return new ReadableStream({
-    start(controller) {
-      req.on("error", (error) => {
-        cancelled = true;
-        controller.error(error);
-      });
-      req.on("end", () => {
-        if (cancelled) return;
-        controller.close();
-      });
-      req.on("data", (chunk) => {
-        if (cancelled) return;
-        size += chunk.length;
-        if (size > length) {
-          cancelled = true;
-          controller.error(
-            new Error(
-              `request body size exceeded ${content_length ? "'content-length'" : "BODY_SIZE_LIMIT"} of ${length}`
-            )
-          );
-          return;
-        }
-        controller.enqueue(chunk);
-        if (controller.desiredSize === null || controller.desiredSize <= 0) {
-          req.pause();
-        }
-      });
-    },
-    pull() {
-      req.resume();
-    },
-    cancel(reason) {
-      cancelled = true;
-      req.destroy(reason);
-    }
-  });
-}
-function getRequest({
-  request,
-  base,
-  bodySizeLimit
-}) {
-  return new Request(base + request.url, {
-    // @ts-expect-error
-    duplex: "half",
-    method: request.method,
-    body: get_raw_body(request, bodySizeLimit),
-    headers: request.headers
-  });
-}
-async function setResponse(res, response) {
-  for (const [key, value] of response.headers) {
-    try {
-      res.setHeader(
-        key,
-        key === "set-cookie" ? set_cookie_parser.splitCookiesString(response.headers.get(key)) : value
-      );
-    } catch (error) {
-      res.getHeaderNames().forEach((name) => res.removeHeader(name));
-      res.writeHead(500).end(String(error));
-      return;
-    }
-  }
-  res.writeHead(response.status);
-  if (!response.body) {
-    res.end();
-    return;
-  }
-  if (response.body.locked) {
-    res.end(
-      "Fatal error: Response body is locked. This can happen when the response was already read (for example through 'response.json()' or 'response.text()')."
-    );
-    return;
-  }
-  const reader = response.body.getReader();
-  if (res.destroyed) {
-    reader.cancel();
-    return;
-  }
-  const cancel = (error) => {
-    res.off("close", cancel);
-    res.off("error", cancel);
-    reader.cancel(error).catch(() => {
-    });
-    if (error) res.destroy(error);
-  };
-  res.on("close", cancel);
-  res.on("error", cancel);
-  next();
-  async function next() {
-    try {
-      for (; ; ) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        if (!res.write(value)) {
-          res.once("drain", next);
-          return;
-        }
-      }
-      res.end();
-    } catch (error) {
-      cancel(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-}
-
-// src/adapter/node.ts
-function toNodeHandler(handler) {
-  return async (req, res) => {
-    const protocol = req.headers["x-forwarded-proto"] || (req.socket.encrypted ? "https" : "http");
-    const base = `${protocol}://${req.headers[":authority"] || req.headers.host}`;
-    const response = await handler(getRequest({ base, request: req }));
-    setResponse(res, response);
-  };
-}
 export {
   APIError,
-  createEndpoint,
-  createEndpointCreator,
+  _statusCode,
+  createEndpoint2 as createEndpoint,
+  createInternalContext,
   createMiddleware,
-  createMiddlewareCreator,
   createRouter,
-  getBody,
-  getCookie,
-  getRequest,
-  getSignedCookie,
-  json,
-  parse,
-  parseSigned,
-  serialize,
-  serializeSigned,
-  setCookie,
-  setResponse,
-  setSignedCookie,
-  shouldSerialize,
-  signCookieValue,
-  statusCode,
-  toNodeHandler
+  generator,
+  getCookieKey,
+  getHTML,
+  parseCookies,
+  serializeCookie,
+  serializeSignedCookie,
+  toResponse
 };
 //# sourceMappingURL=index.js.map