@playcademy/better-auth 0.0.14-beta.2 → 0.0.14

package/dist/server.d.ts

@@ -185,7 +185,7 @@ export declare function playcademy(): {
             } & {
                 asResponse?: boolean;
                 returnHeaders?: boolean;
-                use?: import("better-call").Middleware[];
+                use?: any[];
                 path?: string;
             } & {
                 asResponse?: AsResponse | undefined;

package/dist/server.js

@@ -15177,6 +15177,718 @@ var defuReplaceArrays = createDefu((obj, key, value) => {
     return true;
   }
 });
+// ../../node_modules/.bun/better-call@1.3.5+3c5d820c62823f0b/node_modules/better-call/dist/error.mjs
+function isErrorStackTraceLimitWritable2() {
+  const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+  if (desc === undefined)
+    return Object.isExtensible(Error);
+  return Object.prototype.hasOwnProperty.call(desc, "writable") ? desc.writable : desc.set !== undefined;
+}
+function hideInternalStackFrames2(stack) {
+  const lines = stack.split(`
+    at `);
+  if (lines.length <= 1)
+    return stack;
+  lines.splice(1, 1);
+  return lines.join(`
+    at `);
+}
+function makeErrorForHideStackFrame2(Base, clazz) {
+
+  class HideStackFramesError extends Base {
+    #hiddenStack;
+    constructor(...args) {
+      if (isErrorStackTraceLimitWritable2()) {
+        const limit = Error.stackTraceLimit;
+        Error.stackTraceLimit = 0;
+        super(...args);
+        Error.stackTraceLimit = limit;
+      } else
+        super(...args);
+      const stack = (/* @__PURE__ */ new Error()).stack;
+      if (stack)
+        this.#hiddenStack = hideInternalStackFrames2(stack.replace(/^Error/, this.name));
+    }
+    get errorStack() {
+      return this.#hiddenStack;
+    }
+  }
+  Object.defineProperty(HideStackFramesError.prototype, "constructor", {
+    get() {
+      return clazz;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  return HideStackFramesError;
+}
+var statusCodes = {
+  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 InternalAPIError2 = class extends Error {
+  constructor(status = "INTERNAL_SERVER_ERROR", body = undefined, headers = {}, statusCode = typeof status === "number" ? status : statusCodes[status]) {
+    super(body?.message, body?.cause ? { cause: body.cause } : undefined);
+    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;
+  }
+};
+var ValidationError2 = class extends InternalAPIError2 {
+  constructor(message2, issues) {
+    super(400, {
+      message: message2,
+      code: "VALIDATION_ERROR"
+    });
+    this.message = message2;
+    this.issues = issues;
+    this.issues = issues;
+  }
+};
+var BetterCallError = class extends Error {
+  constructor(message2) {
+    super(message2);
+    this.name = "BetterCallError";
+  }
+};
+var kAPIErrorHeaderSymbol = Symbol.for("better-call:api-error-headers");
+var APIError2 = makeErrorForHideStackFrame2(InternalAPIError2, Error);
+
+// ../../node_modules/.bun/better-call@1.3.5+3c5d820c62823f0b/node_modules/better-call/dist/utils.mjs
+function isAPIError2(error3) {
+  return error3 instanceof APIError2 || error3?.name === "APIError";
+}
+function tryDecode2(str) {
+  try {
+    return str.includes("%") ? decodeURIComponent(str) : str;
+  } catch {
+    return str;
+  }
+}
+async function tryCatch(promise) {
+  try {
+    return {
+      data: await promise,
+      error: null
+    };
+  } catch (error3) {
+    return {
+      data: null,
+      error: error3
+    };
+  }
+}
+function isRequest(obj) {
+  return obj instanceof Request || Object.prototype.toString.call(obj) === "[object Request]";
+}
+
+// ../../node_modules/.bun/better-call@1.3.5+3c5d820c62823f0b/node_modules/better-call/dist/to-response.mjs
+function isJSONSerializable3(value) {
+  if (value === undefined)
+    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 safeStringify2(obj, replacer, space) {
+  let id = 0;
+  const seen = /* @__PURE__ */ new WeakMap;
+  const safeReplacer = (key, value) => {
+    if (typeof value === "bigint")
+      return value.toString();
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value))
+        return `[Circular ref-${seen.get(value)}]`;
+      seen.set(value, id++);
+    }
+    if (replacer)
+      return replacer(key, value);
+    return value;
+  };
+  return JSON.stringify(obj, safeReplacer, space);
+}
+function isJSONResponse2(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  return "_flag" in value && value._flag === "json";
+}
+var REQUEST_ONLY_HEADERS = new Set([
+  "host",
+  "user-agent",
+  "referer",
+  "from",
+  "expect",
+  "authorization",
+  "proxy-authorization",
+  "cookie",
+  "origin",
+  "accept-charset",
+  "accept-encoding",
+  "accept-language",
+  "if-match",
+  "if-none-match",
+  "if-modified-since",
+  "if-unmodified-since",
+  "if-range",
+  "range",
+  "max-forwards",
+  "connection",
+  "keep-alive",
+  "transfer-encoding",
+  "te",
+  "upgrade",
+  "trailer",
+  "proxy-connection",
+  "content-length"
+]);
+function stripRequestOnlyHeaders(headers) {
+  for (const name of REQUEST_ONLY_HEADERS)
+    headers.delete(name);
+}
+function toResponse2(data, init) {
+  if (data instanceof Response) {
+    if (init?.headers) {
+      const safeHeaders = new Headers(init.headers);
+      stripRequestOnlyHeaders(safeHeaders);
+      safeHeaders.forEach((value, key) => {
+        data.headers.set(key, value);
+      });
+    }
+    return data;
+  }
+  if (isJSONResponse2(data)) {
+    const body2 = data.body;
+    const routerResponse = data.routerResponse;
+    if (routerResponse instanceof Response)
+      return routerResponse;
+    const headers2 = new Headers;
+    if (routerResponse?.headers) {
+      const headers3 = new Headers(routerResponse.headers);
+      for (const [key, value] of headers3.entries())
+        headers3.set(key, value);
+    }
+    if (data.headers)
+      for (const [key, value] of new Headers(data.headers).entries())
+        headers2.set(key, value);
+    if (init?.headers) {
+      const safeHeaders = new Headers(init.headers);
+      stripRequestOnlyHeaders(safeHeaders);
+      for (const [key, value] of safeHeaders.entries())
+        headers2.set(key, value);
+    }
+    headers2.set("Content-Type", "application/json");
+    return new Response(JSON.stringify(body2), {
+      ...routerResponse,
+      headers: headers2,
+      status: data.status ?? init?.status ?? routerResponse?.status,
+      statusText: init?.statusText ?? routerResponse?.statusText
+    });
+  }
+  if (isAPIError2(data))
+    return toResponse2(data.body, {
+      status: init?.status ?? data.statusCode,
+      statusText: data.status.toString(),
+      headers: init?.headers || data.headers
+    });
+  let body = data;
+  const headers = new Headers(init?.headers);
+  stripRequestOnlyHeaders(headers);
+  if (!data) {
+    if (data === null)
+      body = JSON.stringify(null);
+    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 (isJSONSerializable3(data)) {
+    body = safeStringify2(data);
+    headers.set("Content-Type", "application/json");
+  }
+  return new Response(body, {
+    ...init,
+    headers
+  });
+}
+
+// ../../node_modules/.bun/@better-auth+utils@0.4.0/node_modules/@better-auth/utils/dist/index.mjs
+function getWebcryptoSubtle2() {
+  const cr = typeof globalThis !== "undefined" && globalThis.crypto;
+  if (cr && typeof cr.subtle === "object" && cr.subtle != null)
+    return cr.subtle;
+  throw new Error("crypto.subtle must be defined");
+}
+
+// ../../node_modules/.bun/better-call@1.3.5+3c5d820c62823f0b/node_modules/better-call/dist/crypto.mjs
+var algorithm2 = {
+  name: "HMAC",
+  hash: "SHA-256"
+};
+var getCryptoKey2 = async (secret) => {
+  const secretBuf = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
+  return await getWebcryptoSubtle2().importKey("raw", secretBuf, algorithm2, false, ["sign", "verify"]);
+};
+var verifySignature2 = async (base64Signature, value, secret) => {
+  try {
+    const signatureBinStr = atob(base64Signature);
+    const signature = new Uint8Array(signatureBinStr.length);
+    for (let i = 0, len = signatureBinStr.length;i < len; i++)
+      signature[i] = signatureBinStr.charCodeAt(i);
+    return await getWebcryptoSubtle2().verify(algorithm2, secret, signature, new TextEncoder().encode(value));
+  } catch (e) {
+    return false;
+  }
+};
+var makeSignature2 = async (value, secret) => {
+  const key = await getCryptoKey2(secret);
+  const signature = await getWebcryptoSubtle2().sign(algorithm2.name, key, new TextEncoder().encode(value));
+  return btoa(String.fromCharCode(...new Uint8Array(signature)));
+};
+var signCookieValue2 = async (value, secret) => {
+  const signature = await makeSignature2(value, secret);
+  value = `${value}.${signature}`;
+  value = encodeURIComponent(value);
+  return value;
+};
+
+// ../../node_modules/.bun/better-call@1.3.5+3c5d820c62823f0b/node_modules/better-call/dist/cookies.mjs
+var getCookieKey2 = (key, prefix) => {
+  let finalKey = key;
+  if (prefix)
+    if (prefix === "secure")
+      finalKey = "__Secure-" + key;
+    else if (prefix === "host")
+      finalKey = "__Host-" + key;
+    else
+      return;
+  return finalKey;
+};
+function parseCookies2(str) {
+  if (typeof str !== "string")
+    throw new TypeError("argument str must be a string");
+  const cookies = /* @__PURE__ */ new Map;
+  let index = 0;
+  while (index < str.length) {
+    const eqIdx = str.indexOf("=", index);
+    if (eqIdx === -1)
+      break;
+    let endIdx = str.indexOf(";", index);
+    if (endIdx === -1)
+      endIdx = str.length;
+    else if (endIdx < eqIdx) {
+      index = str.lastIndexOf(";", eqIdx - 1) + 1;
+      continue;
+    }
+    const key = str.slice(index, eqIdx).trim();
+    if (!cookies.has(key)) {
+      let val = str.slice(eqIdx + 1, endIdx).trim();
+      if (val.codePointAt(0) === 34)
+        val = val.slice(1, -1);
+      cookies.set(key, tryDecode2(val));
+    }
+    index = endIdx + 1;
+  }
+  return cookies;
+}
+var _serialize2 = (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 (key.startsWith("__Host-")) {
+    if (!opt.secure)
+      opt.secure = true;
+    if (opt.path !== "/")
+      opt.path = "/";
+    if (opt.domain)
+      opt.domain = undefined;
+  }
+  if (opt && typeof opt.maxAge === "number" && opt.maxAge >= 0) {
+    if (opt.maxAge > 34560000)
+      throw new Error("Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration.");
+    cookie += `; Max-Age=${Math.floor(opt.maxAge)}`;
+  }
+  if (opt.domain && opt.prefix !== "host")
+    cookie += `; Domain=${opt.domain}`;
+  if (opt.path)
+    cookie += `; Path=${opt.path}`;
+  if (opt.expires) {
+    if (opt.expires.getTime() - Date.now() > 34560000000)
+      throw new Error("Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future.");
+    cookie += `; Expires=${opt.expires.toUTCString()}`;
+  }
+  if (opt.httpOnly)
+    cookie += "; HttpOnly";
+  if (opt.secure)
+    cookie += "; Secure";
+  if (opt.sameSite)
+    cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`;
+  if (opt.partitioned) {
+    if (!opt.secure)
+      opt.secure = true;
+    cookie += "; Partitioned";
+  }
+  return cookie;
+};
+var serializeCookie2 = (key, value, opt) => {
+  value = encodeURIComponent(value);
+  return _serialize2(key, value, opt);
+};
+var serializeSignedCookie2 = async (key, value, secret, opt) => {
+  value = await signCookieValue2(value, secret);
+  return _serialize2(key, value, opt);
+};
+
+// ../../node_modules/.bun/better-call@1.3.5+3c5d820c62823f0b/node_modules/better-call/dist/validator.mjs
+async function runValidation2(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: fromError2(result.issues, "body")
+      };
+    request.body = result.value;
+  }
+  if (options.query) {
+    const result = await options.query["~standard"].validate(context.query);
+    if (result.issues)
+      return {
+        data: null,
+        error: fromError2(result.issues, "query")
+      };
+    request.query = result.value;
+  }
+  if (options.requireHeaders && !context.headers)
+    return {
+      data: null,
+      error: {
+        message: "Headers is required",
+        issues: []
+      }
+    };
+  if (options.requireRequest && !context.request)
+    return {
+      data: null,
+      error: {
+        message: "Request is required",
+        issues: []
+      }
+    };
+  return {
+    data: request,
+    error: null
+  };
+}
+function fromError2(error3, validating) {
+  return {
+    message: error3.map((e) => {
+      return `[${e.path?.length ? `${validating}.` + e.path.map((x) => typeof x === "object" ? x.key : x).join(".") : validating}] ${e.message}`;
+    }).join("; "),
+    issues: error3
+  };
+}
+
+// ../../node_modules/.bun/better-call@1.3.5+3c5d820c62823f0b/node_modules/better-call/dist/context.mjs
+var createInternalContext2 = async (context, { options, path }) => {
+  const headers = new Headers;
+  let responseStatus = undefined;
+  const { data, error: error3 } = await runValidation2(options, context);
+  if (error3)
+    throw new ValidationError2(error3.message, error3.issues);
+  const requestHeaders = "headers" in context ? context.headers instanceof Headers ? context.headers : new Headers(context.headers) : ("request" in context) && isRequest(context.request) ? context.request.headers : null;
+  const requestCookies = requestHeaders?.get("cookie");
+  const parsedCookies = requestCookies ? parseCookies2(requestCookies) : undefined;
+  const internalContext = {
+    ...context,
+    body: data.body,
+    query: data.query,
+    path: context.path || path || "virtual:",
+    context: "context" in context && context.context ? context.context : {},
+    returned: undefined,
+    headers: context?.headers,
+    request: context?.request,
+    params: "params" in context ? context.params : undefined,
+    method: context.method ?? (Array.isArray(options.method) ? options.method[0] : options.method === "*" ? "GET" : options.method),
+    setHeader: (key, value) => {
+      headers.set(key, value);
+    },
+    getHeader: (key) => {
+      if (!requestHeaders)
+        return null;
+      return requestHeaders.get(key);
+    },
+    getCookie: (key, prefix) => {
+      const finalKey = getCookieKey2(key, prefix);
+      if (!finalKey)
+        return null;
+      return parsedCookies?.get(finalKey) || null;
+    },
+    getSignedCookie: async (key, secret, prefix) => {
+      const finalKey = getCookieKey2(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;
+      return await verifySignature2(signature, signedValue, await getCryptoKey2(secret)) ? signedValue : false;
+    },
+    setCookie: (key, value, options2) => {
+      const cookie = serializeCookie2(key, value, options2);
+      headers.append("set-cookie", cookie);
+      return cookie;
+    },
+    setSignedCookie: async (key, value, secret, options2) => {
+      const cookie = await serializeSignedCookie2(key, value, secret, options2);
+      headers.append("set-cookie", cookie);
+      return cookie;
+    },
+    redirect: (url) => {
+      headers.set("location", url);
+      return new APIError2("FOUND", undefined, headers);
+    },
+    error: (status, body, headers2) => {
+      return new APIError2(status, body, headers2);
+    },
+    setStatus: (status) => {
+      responseStatus = status;
+    },
+    json: (json, routerResponse) => {
+      if (!context.asResponse)
+        return json;
+      return {
+        body: routerResponse?.body || json,
+        routerResponse,
+        _flag: "json"
+      };
+    },
+    responseHeaders: headers,
+    get responseStatus() {
+      return responseStatus;
+    }
+  };
+  for (const middleware of options.use || []) {
+    const response = await middleware({
+      ...internalContext,
+      returnHeaders: true,
+      asResponse: false
+    });
+    if (response.response)
+      Object.assign(internalContext.context, response.response);
+    if (response.headers)
+      response.headers.forEach((value, key) => {
+        internalContext.responseHeaders.set(key, value);
+      });
+  }
+  return internalContext;
+};
+
+// ../../node_modules/.bun/better-call@1.3.5+3c5d820c62823f0b/node_modules/better-call/dist/endpoint.mjs
+function createEndpoint(pathOrOptions, handlerOrOptions, handlerOrNever) {
+  const path = typeof pathOrOptions === "string" ? pathOrOptions : undefined;
+  const options = typeof handlerOrOptions === "object" ? handlerOrOptions : pathOrOptions;
+  const handler = typeof handlerOrOptions === "function" ? handlerOrOptions : handlerOrNever;
+  if ((options.method === "GET" || options.method === "HEAD") && options.body)
+    throw new BetterCallError("Body is not allowed with GET or HEAD methods");
+  if (path && /\/{2,}/.test(path))
+    throw new BetterCallError("Path cannot contain consecutive slashes");
+  const internalHandler = async (...inputCtx) => {
+    const context = inputCtx[0] || {};
+    const { data: internalContext, error: validationError } = await tryCatch(createInternalContext2(context, {
+      options,
+      path
+    }));
+    if (validationError) {
+      if (!(validationError instanceof ValidationError2))
+        throw validationError;
+      if (options.onValidationError)
+        await options.onValidationError({
+          message: validationError.message,
+          issues: validationError.issues
+        });
+      throw new APIError2(400, {
+        message: validationError.message,
+        code: "VALIDATION_ERROR"
+      });
+    }
+    const response = await handler(internalContext).catch(async (e) => {
+      if (isAPIError2(e)) {
+        const onAPIError = options.onAPIError;
+        if (onAPIError)
+          await onAPIError(e);
+        if (context.asResponse)
+          return e;
+      }
+      throw e;
+    });
+    const headers = internalContext.responseHeaders;
+    const status = internalContext.responseStatus;
+    return context.asResponse ? toResponse2(response, {
+      headers,
+      status
+    }) : context.returnHeaders ? context.returnStatus ? {
+      headers,
+      response,
+      status
+    } : {
+      headers,
+      response
+    } : context.returnStatus ? {
+      response,
+      status
+    } : response;
+  };
+  internalHandler.options = options;
+  internalHandler.path = path;
+  return internalHandler;
+}
+createEndpoint.create = (opts) => {
+  return (path, options, handler) => {
+    return createEndpoint(path, {
+      ...options,
+      use: [...options?.use || [], ...opts?.use || []]
+    }, handler);
+  };
+};
+
+// ../../node_modules/.bun/better-call@1.3.5+3c5d820c62823f0b/node_modules/better-call/dist/middleware.mjs
+function createMiddleware2(optionsOrHandler, handler) {
+  const internalHandler = async (inputCtx) => {
+    const context = inputCtx;
+    const _handler = typeof optionsOrHandler === "function" ? optionsOrHandler : handler;
+    const internalContext = await createInternalContext2(context, {
+      options: typeof optionsOrHandler === "function" ? {} : optionsOrHandler,
+      path: "/"
+    });
+    if (!_handler)
+      throw new Error("handler must be defined");
+    try {
+      const response = await _handler(internalContext);
+      const headers = internalContext.responseHeaders;
+      return context.returnHeaders ? {
+        headers,
+        response
+      } : response;
+    } catch (e) {
+      if (isAPIError2(e))
+        Object.defineProperty(e, kAPIErrorHeaderSymbol, {
+          enumerable: false,
+          configurable: true,
+          get() {
+            return internalContext.responseHeaders;
+          }
+        });
+      throw e;
+    }
+  };
+  internalHandler.options = typeof optionsOrHandler === "function" ? {} : optionsOrHandler;
+  return internalHandler;
+}
+createMiddleware2.create = (opts) => {
+  function fn(optionsOrHandler, handler) {
+    if (typeof optionsOrHandler === "function")
+      return createMiddleware2({ use: opts?.use }, optionsOrHandler);
+    if (!handler)
+      throw new Error("Middleware handler is required");
+    return createMiddleware2({
+      ...optionsOrHandler,
+      method: "*",
+      use: [...opts?.use || [], ...optionsOrHandler.use || []]
+    }, handler);
+  }
+  return fn;
+};
+
 // ../sdk/dist/server.js
 import { existsSync, readdirSync, statSync } from "fs";
 import { readFile } from "fs/promises";
@@ -15761,7 +16473,7 @@ async function hasValidSession(adapter, sessionToken, userId) {
 }
 async function buildCrossSiteCookie(options) {
   const { cookieName, sessionToken, secret, maxAge, path, userAgent, domain } = options;
-  const signed = await serializeSignedCookie(cookieName, sessionToken, secret);
+  const signed = await serializeSignedCookie2(cookieName, sessionToken, secret);
   const nameValue = signed.split(";")[0];
   const parts = [nameValue, `Max-Age=${maxAge}`, `Path=${path}`];
   if (domain) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@playcademy/better-auth",
-    "version": "0.0.14-beta.2",
+    "version": "0.0.14",
     "type": "module",
     "exports": {
         "./server": {
@@ -25,14 +25,14 @@
     "dependencies": {
         "@better-auth/utils": "^0.3.0",
         "@better-fetch/fetch": "^1.1.18",
-        "@playcademy/sdk": "0.9.0",
+        "@playcademy/sdk": "0.10.0",
         "better-auth": "1.3.33",
         "better-call": "^1.0.19"
     },
     "devDependencies": {
         "@inquirer/prompts": "^7.9.0",
         "@playcademy/utils": "0.0.1",
-        "@types/bun": "latest",
+        "@types/bun": "1.3.5",
         "typescript": "^5.7.2"
     },
     "peerDependencies": {