better-auth 1.7.11 → 1.7.13

package/dist/client/vanilla.d.mts

@@ -5,13 +5,12 @@ import { BetterAuthClientOptions } from "@better-auth/core";
 import { BASE_ERROR_CODES } from "@better-auth/core/error";
 import { Atom } from "nanostores";
 import { BetterFetchError, BetterFetchResponse } from "@better-fetch/fetch";
-
 //#region src/client/vanilla.d.ts
 type InferResolvedHooks<O extends BetterAuthClientOptions> = O extends {
   plugins: Array<infer Plugin>;
 } ? UnionToIntersection<Plugin extends {
   getAtoms?: infer GetAtoms;
-} ? GetAtoms extends ((fetch: any) => infer Atoms) ? Atoms extends Record<string, any> ? { [key in keyof Atoms as IsSignal<key> extends true ? never : key extends string ? `use${Capitalize<key>}` : never]: Atoms[key] } : {} : {} : {}> : {};
+} ? GetAtoms extends ((fetch: any) => infer Atoms) ? Atoms extends Record<string, any> ? { [key in keyof Atoms as IsSignal<key> extends true ? never : key extends string ? `use${Capitalize<key>}` : never]: Atoms[key]; } : {} : {} : {}> : {};
 type ClientConfig = ReturnType<typeof getClientConfig>;
 type ClientSession<Option extends BetterAuthClientOptions> = InferClientAPI<Option> extends {
   getSession: () => Promise<infer Res>;
@@ -19,7 +18,7 @@ type ClientSession<Option extends BetterAuthClientOptions> = InferClientAPI<Opti
 /**
  * Client returned by `createAuthClient`.
  */
-type AuthClient<Option extends BetterAuthClientOptions> = UnionToIntersection<InferResolvedHooks<Option>> & InferClientAPI<Option> & InferActions<Option> & {
+export type AuthClient<Option extends BetterAuthClientOptions> = UnionToIntersection<InferResolvedHooks<Option>> & InferClientAPI<Option> & InferActions<Option> & {
   hydrateSession(session: NonNullable<ClientSession<Option>> | null): void;
   useSession: Atom<{
     data: ClientSession<Option>;
@@ -37,6 +36,6 @@ type AuthClient<Option extends BetterAuthClientOptions> = UnionToIntersection<In
   };
   $ERROR_CODES: PrettifyDeep<InferErrorCodes<Option> & typeof BASE_ERROR_CODES>;
 };
-declare function createAuthClient<Option extends BetterAuthClientOptions>(options?: Option | undefined): AuthClient<Option>;
+export declare function createAuthClient<Option extends BetterAuthClientOptions>(options?: Option | undefined): AuthClient<Option>;
 //#endregion
-export { AuthClient, createAuthClient };
+export {};

package/dist/client/vanilla.mjs

@@ -6,13 +6,14 @@ function createAuthClient(options) {
 	const { pluginPathMethods, pluginsActions, pluginsAtoms, hydrateSession, $fetch, atomListeners, $store } = getClientConfig(options);
 	const resolvedHooks = {};
 	for (const [key, value] of Object.entries(pluginsAtoms)) resolvedHooks[`use${capitalizeFirstLetter(key)}`] = value;
-	return createDynamicPathProxy({
+	const routes = {
 		...pluginsActions,
 		...resolvedHooks,
 		hydrateSession,
 		$fetch,
 		$store
-	}, $fetch, pluginPathMethods, pluginsAtoms, atomListeners);
+	};
+	return createDynamicPathProxy(routes, $fetch, pluginPathMethods, pluginsAtoms, atomListeners);
 }
 //#endregion
 export { createAuthClient };

package/dist/client/vue/index.d.mts

@@ -5,15 +5,14 @@ import { BetterAuthClientOptions } from "@better-auth/core";
 import { BASE_ERROR_CODES } from "@better-auth/core/error";
 import { BetterFetchError, BetterFetchResponse } from "@better-fetch/fetch";
 import { DeepReadonly, Ref, WatchSource } from "vue";
-export * from "nanostores";
-export * from "@better-fetch/fetch";
-
+export type * from "nanostores";
+export type * from "@better-fetch/fetch";
 //#region src/client/vue/index.d.ts
 type InferResolvedHooks<O extends BetterAuthClientOptions> = O extends {
   plugins: Array<infer Plugin>;
 } ? UnionToIntersection<Plugin extends {
   getAtoms?: infer GetAtoms;
-} ? GetAtoms extends ((fetch: any) => infer Atoms) ? Atoms extends Record<string, any> ? { [key in keyof Atoms as IsSignal<key> extends true ? never : key extends string ? `use${Capitalize<key>}` : never]: () => DeepReadonly<Ref<ReturnType<Atoms[key]["get"]>>> } : {} : {} : {}> : {};
+} ? GetAtoms extends ((fetch: any) => infer Atoms) ? Atoms extends Record<string, any> ? { [key in keyof Atoms as IsSignal<key> extends true ? never : key extends string ? `use${Capitalize<key>}` : never]: () => DeepReadonly<Ref<ReturnType<Atoms[key]["get"]>>>; } : {} : {} : {}> : {};
 type ClientConfig = ReturnType<typeof getClientConfig>;
 type ClientSession<Option extends BetterAuthClientOptions> = InferClientAPI<Option> extends {
   getSession: () => Promise<infer Res>;
@@ -51,7 +50,7 @@ type SessionFetchResult<Option extends BetterAuthClientOptions> = {
 /**
  * Vue client returned by `createAuthClient`.
  */
-type VueAuthClient<Option extends BetterAuthClientOptions> = UnionToIntersection<InferResolvedHooks<Option>> & InferClientAPI<Option> & InferActions<Option> & {
+export type VueAuthClient<Option extends BetterAuthClientOptions> = UnionToIntersection<InferResolvedHooks<Option>> & InferClientAPI<Option> & InferActions<Option> & {
   hydrateSession(session: NonNullable<ClientSession<Option>> | null): void;
   useSession(): VueSessionState<Option>;
   useSession(useFetch: SessionFetch): Promise<SessionFetchResult<Option>>;
@@ -62,6 +61,6 @@ type VueAuthClient<Option extends BetterAuthClientOptions> = UnionToIntersection
   $store: ClientConfig["$store"];
   $ERROR_CODES: PrettifyDeep<InferErrorCodes<Option> & typeof BASE_ERROR_CODES>;
 };
-declare function createAuthClient<Option extends BetterAuthClientOptions>(options?: Option | undefined): VueAuthClient<Option>;
+export declare function createAuthClient<Option extends BetterAuthClientOptions>(options?: Option | undefined): VueAuthClient<Option>;
 //#endregion
-export { ExtractPluginField, HasRequiredKeys, InferPluginFieldFromTuple, IsAny, OverrideMerge, Prettify, PrettifyDeep, RequiredKeysOf, StripEmptyObjects, type UnionToIntersection, VueAuthClient, createAuthClient };
+export type { ExtractPluginField, HasRequiredKeys, InferPluginFieldFromTuple, IsAny, OverrideMerge, Prettify, PrettifyDeep, RequiredKeysOf, StripEmptyObjects, UnionToIntersection };

package/dist/client/vue/index.mjs

@@ -41,14 +41,15 @@ function createAuthClient(options) {
 		}
 		return resolvedHooks.useSession();
 	}
-	return createDynamicPathProxy({
+	const routes = {
 		...pluginsActions,
 		...resolvedHooks,
 		hydrateSession,
 		useSession,
 		$fetch,
 		$store
-	}, $fetch, pluginPathMethods, pluginsAtoms, atomListeners);
+	};
+	return createDynamicPathProxy(routes, $fetch, pluginPathMethods, pluginsAtoms, atomListeners);
 }
 //#endregion
 export { createAuthClient };

package/dist/context/create-context.mjs

@@ -19,7 +19,7 @@ import { runtimeSchemaCheckFor, schemaCheckFor } from "@better-auth/core/db/inte
 import { socialProviders } from "@better-auth/core/social-providers";
 import { findInvalidTrustedProxies } from "@better-auth/core/utils/ip";
 import { createTelemetry } from "@better-auth/telemetry";
-import defu$1 from "defu";
+import defu from "defu";
 //#region src/context/create-context.ts
 /**
 * Estimates the entropy of a string in bits.
@@ -46,13 +46,13 @@ function validateSecret(secret, logger) {
 }
 async function createAuthContext(adapter, options, getDatabaseType) {
 	const isStateful = hasServerSessionStore(options);
-	if (!isStateful) options = defu$1(options, { session: { cookieCache: {
+	if (!isStateful) options = defu(options, { session: { cookieCache: {
 		enabled: true,
 		strategy: "jwe",
 		refreshCache: true,
-		maxAge: options.session?.expiresIn || 3600 * 24 * 7
+		maxAge: options.session?.expiresIn || 604800
 	} } });
-	if (!options.database) options = defu$1(options, { account: { storeAccountCookie: true } });
+	if (!options.database) options = defu(options, { account: { storeAccountCookie: true } });
 	const plugins = options.plugins || [];
 	const internalPlugins = getInternalPlugins(options);
 	const logger = createLogger(options.logger);
@@ -144,9 +144,9 @@ Most of the features of Better Auth will not work correctly.`);
 			return this.trustedOrigins.some((origin) => matchesOriginPattern(url, origin, settings));
 		},
 		sessionConfig: {
-			updateAge: options.session?.updateAge !== void 0 ? options.session.updateAge : 1440 * 60,
-			expiresIn: options.session?.expiresIn || 3600 * 24 * 7,
-			freshAge: options.session?.freshAge === void 0 ? 3600 * 24 : options.session.freshAge,
+			updateAge: options.session?.updateAge !== void 0 ? options.session.updateAge : 86400,
+			expiresIn: options.session?.expiresIn || 604800,
+			freshAge: options.session?.freshAge === void 0 ? 86400 : options.session.freshAge,
 			cookieRefreshCache: (() => {
 				const refreshCache = options.session?.cookieCache?.refreshCache;
 				const maxAge = options.session?.cookieCache?.maxAge || 300;

package/dist/context/helpers.mjs

@@ -4,7 +4,7 @@ import { createCookieGetter, getCookies } from "../cookies/index.mjs";
 import { createInternalAdapter } from "../db/internal-adapter.mjs";
 import { env } from "@better-auth/core/env";
 import { BetterAuthError } from "@better-auth/core/error";
-import { defu } from "defu";
+import { defu as defu$1 } from "defu";
 import { isLoopbackHost } from "@better-auth/core/utils/host";
 //#region src/context/helpers.ts
 async function runPluginInit(context) {
@@ -25,7 +25,7 @@ async function runPluginInit(context) {
 					hooks: databaseHooks
 				});
 				if (trustedOrigins) pluginTrustedOrigins.push(trustedOrigins);
-				options = defu(options, restOpts);
+				options = defu$1(options, restOpts);
 			}
 			if (result.context) Object.assign(context, result.context);
 		}
@@ -115,7 +115,8 @@ function resolveDynamicTrustedProxyHeaders(options) {
 */
 async function resolveRequestContext(ctx, source, trustedProxyHeaders) {
 	const dynamicBaseURLConfig = ctx.options.baseURL;
-	const baseURL = resolveBaseURL(dynamicBaseURLConfig, ctx.options.basePath || "/api/auth", source, void 0, trustedProxyHeaders);
+	const basePath = ctx.options.basePath || "/api/auth";
+	const baseURL = resolveBaseURL(dynamicBaseURLConfig, basePath, source, void 0, trustedProxyHeaders);
 	if (!baseURL) throw new BetterAuthError("Could not resolve base URL from request. Check your allowedHosts config.");
 	const resolved = Object.create(Object.getPrototypeOf(ctx), Object.getOwnPropertyDescriptors(ctx));
 	resolved.baseURL = baseURL;
@@ -129,10 +130,11 @@ async function resolveRequestContext(ctx, source, trustedProxyHeaders) {
 	};
 	const needsRequest = typeof ctx.options.trustedOrigins === "function" || typeof ctx.options.account?.accountLinking?.trustedProviders === "function";
 	let callbackRequest;
-	if (needsRequest) if (isRequestLike(source)) callbackRequest = source;
-	else if (source) callbackRequest = new Request(baseURL, { headers: source });
-	else callbackRequest = void 0;
-	else callbackRequest = void 0;
+	if (needsRequest) {
+		if (isRequestLike(source)) callbackRequest = source;
+		else if (source) callbackRequest = new Request(baseURL, { headers: source });
+		else callbackRequest = void 0;
+	} else callbackRequest = void 0;
 	resolved.trustedOrigins = await getTrustedOrigins(trustedOriginOptions, callbackRequest);
 	resolved.trustedProviders = await getTrustedProviders(resolved.options, callbackRequest);
 	if (ctx.options.advanced?.crossSubDomainCookies?.enabled) {

package/dist/cookies/cookie-utils.d.mts

@@ -1,5 +1,5 @@
 //#region src/cookies/cookie-utils.d.ts
-interface CookieAttributes {
+export interface CookieAttributes {
   value: string;
   "max-age"?: number | undefined;
   expires?: Date | undefined;
@@ -21,24 +21,24 @@ interface ParsedCookieOptions {
   partitioned?: boolean | undefined;
   sameSite?: CookieAttributes["samesite"];
 }
-declare const SECURE_COOKIE_PREFIX = "__Secure-";
-declare const HOST_COOKIE_PREFIX = "__Host-";
+export declare const SECURE_COOKIE_PREFIX = "__Secure-";
+export declare const HOST_COOKIE_PREFIX = "__Host-";
 /**
  * Remove __Secure- or __Host- prefix from cookie name.
  */
-declare function stripSecureCookiePrefix(cookieName: string): string;
+export declare function stripSecureCookiePrefix(cookieName: string): string;
 /**
  * Split a comma-joined `Set-Cookie` header string into individual cookies.
  */
-declare function splitSetCookieHeader(setCookie: string): string[];
-declare function parseSetCookieHeader(setCookie: string): Map<string, CookieAttributes>;
-declare function toCookieOptions(attributes: CookieAttributes): ParsedCookieOptions;
+export declare function splitSetCookieHeader(setCookie: string): string[];
+export declare function parseSetCookieHeader(setCookie: string): Map<string, CookieAttributes>;
+export declare function toCookieOptions(attributes: CookieAttributes): ParsedCookieOptions;
 /**
  * Cookie-name token char set per RFC 7230 §3.2.6.
  *
  * @see https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.6
  */
-declare const cookieNameRegex: RegExp;
+export declare const cookieNameRegex: RegExp;
 /**
  * Tolerates `;` separators without the SP that RFC 6265 §4.2.1 mandates,
  * since proxies and runtimes commonly strip it. Silently drops entries
@@ -46,7 +46,7 @@ declare const cookieNameRegex: RegExp;
  * cookie-octet (plus space and comma). Strips optional surrounding
  * double-quotes per RFC 6265 §4.1.1.
  */
-declare function parseCookies(cookie: string): Map<string, string>;
+export declare function parseCookies(cookie: string): Map<string, string>;
 /**
  * Add or replace a cookie in the request `Cookie` header.
  *
@@ -55,7 +55,7 @@ declare function parseCookies(cookie: string): Map<string, string>;
  * breaks downstream cookie parsing. This builds the header value via
  * parse-mutate-serialize.
  */
-declare function setRequestCookie(headers: Headers, name: string, value: string): void;
+export declare function setRequestCookie(headers: Headers, name: string, value: string): void;
 /**
  * Merge `Set-Cookie` header values into the target's `Cookie` header.
  * Mutates `target`.
@@ -64,9 +64,9 @@ declare function setRequestCookie(headers: Headers, name: string, value: string)
  * (expiration, domain/path scoping, ordering) are out of scope. Suitable
  * for single-request proxy, middleware, and test contexts.
  */
-declare function applySetCookies(target: Headers, setCookieValues: Iterable<string>): void;
-declare function setCookieToHeader(headers: Headers): (context: {
+export declare function applySetCookies(target: Headers, setCookieValues: Iterable<string>): void;
+export declare function setCookieToHeader(headers: Headers): (context: {
   response: Response;
 }) => void;
 //#endregion
-export { CookieAttributes, HOST_COOKIE_PREFIX, SECURE_COOKIE_PREFIX, applySetCookies, cookieNameRegex, parseCookies, parseSetCookieHeader, setCookieToHeader, setRequestCookie, splitSetCookieHeader, stripSecureCookiePrefix, toCookieOptions };
+export {};

package/dist/cookies/cookie-utils.mjs

@@ -82,9 +82,7 @@ function parseSetCookieHeader(setCookie) {
 				case "partitioned":
 					attrObj.partitioned = true;
 					break;
-				default:
-					attrObj[normalizedAttrName] = attrValue ? attrValue.trim() : true;
-					break;
+				default: attrObj[normalizedAttrName] = attrValue ? attrValue.trim() : true;
 			}
 		});
 		cookies.set(name, attrObj);

package/dist/cookies/index.d.mts

@@ -1,13 +1,12 @@
 import { Session, User } from "../types/models.mjs";
+import "../types/index.mjs";
 import { CookieAttributes, HOST_COOKIE_PREFIX, SECURE_COOKIE_PREFIX, applySetCookies, cookieNameRegex, parseCookies, parseSetCookieHeader, setCookieToHeader, setRequestCookie, splitSetCookieHeader, stripSecureCookiePrefix, toCookieOptions } from "./cookie-utils.mjs";
 import { createSessionStore, getAccountCookie, getChunkedCookie, setAccountCookie } from "./session-store.mjs";
 import { Awaitable, BetterAuthCookie, BetterAuthCookies, BetterAuthOptions, CookieCachePayload, GenericEndpointContext } from "@better-auth/core";
-import * as _$better_call0 from "better-call";
 import { CookieOptions } from "better-call";
 import { JSONWebKeySet } from "jose";
-
 //#region src/cookies/index.d.ts
-declare function createCookieGetter(options: BetterAuthOptions): (cookieName: string, overrideAttributes?: Partial<CookieOptions>) => {
+export declare function createCookieGetter(options: BetterAuthOptions): (cookieName: string, overrideAttributes?: Partial<CookieOptions>) => {
   name: string;
   attributes: {
     domain?: string | undefined;
@@ -18,10 +17,10 @@ declare function createCookieGetter(options: BetterAuthOptions): (cookieName: st
     secure: boolean;
     sameSite: "Strict" | "Lax" | "None" | "strict" | "lax" | "none";
     partitioned?: boolean;
-    prefix?: _$better_call0.CookiePrefixOptions;
+    prefix?: import("better-call").CookiePrefixOptions;
   };
 };
-declare function getCookies(options: BetterAuthOptions): {
+export declare function getCookies(options: BetterAuthOptions): {
   sessionToken: {
     name: string;
     attributes: {
@@ -33,7 +32,7 @@ declare function getCookies(options: BetterAuthOptions): {
       secure: boolean;
       sameSite: "Strict" | "Lax" | "None" | "strict" | "lax" | "none";
       partitioned?: boolean;
-      prefix?: _$better_call0.CookiePrefixOptions;
+      prefix?: import("better-call").CookiePrefixOptions;
     };
   };
   /**
@@ -51,7 +50,7 @@ declare function getCookies(options: BetterAuthOptions): {
       secure: boolean;
       sameSite: "Strict" | "Lax" | "None" | "strict" | "lax" | "none";
       partitioned?: boolean;
-      prefix?: _$better_call0.CookiePrefixOptions;
+      prefix?: import("better-call").CookiePrefixOptions;
     };
   };
   dontRememberToken: {
@@ -65,7 +64,7 @@ declare function getCookies(options: BetterAuthOptions): {
       secure: boolean;
       sameSite: "Strict" | "Lax" | "None" | "strict" | "lax" | "none";
       partitioned?: boolean;
-      prefix?: _$better_call0.CookiePrefixOptions;
+      prefix?: import("better-call").CookiePrefixOptions;
     };
   };
   accountData: {
@@ -79,35 +78,35 @@ declare function getCookies(options: BetterAuthOptions): {
       secure: boolean;
       sameSite: "Strict" | "Lax" | "None" | "strict" | "lax" | "none";
       partitioned?: boolean;
-      prefix?: _$better_call0.CookiePrefixOptions;
+      prefix?: import("better-call").CookiePrefixOptions;
     };
   };
 };
-declare function setCookieCache(ctx: GenericEndpointContext, session: {
+export declare function setCookieCache(ctx: GenericEndpointContext, session: {
   session: Session & Record<string, unknown>;
   user: User;
 }, dontRememberMe: boolean): Promise<void>;
-declare function decodeCookieCache(ctx: GenericEndpointContext, value: string): Promise<{
+export declare function decodeCookieCache(ctx: GenericEndpointContext, value: string): Promise<{
   session: CookieCachePayload;
   expiresAt: number;
 } | null>;
-declare function setSessionCookie(ctx: GenericEndpointContext, session: {
+export declare function setSessionCookie(ctx: GenericEndpointContext, session: {
   session: Session & Record<string, unknown>;
   user: User;
 }, dontRememberMe?: boolean | undefined, overrides?: Partial<CookieOptions> | undefined): Promise<void>;
 /**
  * Expires a cookie by setting `maxAge: 0` while preserving its attributes
  */
-declare function expireCookie(ctx: GenericEndpointContext, cookie: BetterAuthCookie): void;
-declare function deleteSessionCookie(ctx: GenericEndpointContext, skipDontRememberMe?: boolean | undefined): void;
-type EligibleCookies = (string & {}) | (keyof BetterAuthCookies & {});
-declare const getSessionCookie: (request: Request | Headers, config?: {
+export declare function expireCookie(ctx: GenericEndpointContext, cookie: BetterAuthCookie): void;
+export declare function deleteSessionCookie(ctx: GenericEndpointContext, skipDontRememberMe?: boolean | undefined): void;
+export type EligibleCookies = (string & {}) | (keyof BetterAuthCookies & {});
+export declare const getSessionCookie: (request: Request | Headers, config?: {
   cookiePrefix?: string;
   cookieName?: string;
   path?: string;
 } | undefined) => string | null;
 type CookieCacheVersion = string | ((session: CookieCachePayload["session"], user: CookieCachePayload["user"]) => Awaitable<string>);
-declare const getCookieCache: <S extends CookieCachePayload = CookieCachePayload>(request: Request | Headers, config?: {
+export declare const getCookieCache: <S extends CookieCachePayload = CookieCachePayload>(request: Request | Headers, config?: {
   cookiePrefix?: string;
   cookieName?: string;
   isSecure?: boolean;
@@ -121,4 +120,4 @@ declare const getCookieCache: <S extends CookieCachePayload = CookieCachePayload
   version?: CookieCacheVersion;
 } | undefined) => Promise<S | null>;
 //#endregion
-export { CookieAttributes, EligibleCookies, HOST_COOKIE_PREFIX, SECURE_COOKIE_PREFIX, applySetCookies, cookieNameRegex, createCookieGetter, createSessionStore, decodeCookieCache, deleteSessionCookie, expireCookie, getAccountCookie, getChunkedCookie, getCookieCache, getCookies, getSessionCookie, parseCookies, parseSetCookieHeader, setAccountCookie, setCookieCache, setCookieToHeader, setRequestCookie, setSessionCookie, splitSetCookieHeader, stripSecureCookiePrefix, toCookieOptions };
+export { CookieAttributes, HOST_COOKIE_PREFIX, SECURE_COOKIE_PREFIX, applySetCookies, cookieNameRegex, createSessionStore, getAccountCookie, getChunkedCookie, parseCookies, parseSetCookieHeader, setAccountCookie, setCookieToHeader, setRequestCookie, splitSetCookieHeader, stripSecureCookiePrefix, toCookieOptions };

package/dist/cookies/index.mjs

@@ -115,11 +115,13 @@ async function setCookieCache(ctx, session, dontRememberMe) {
 	sessionStore.setCookies(sessionStore.chunk(data, options));
 	if (ctx.context.options.account?.storeAccountCookie && !hasPendingSetCookie(ctx, ctx.context.authCookies.accountData.name)) {
 		const accountData = await getAccountCookie(ctx);
-		if (accountData) if (!shouldBindAccountCookieToSessionUser(ctx.context.options) || accountData.userId === session.user.id) await setAccountCookie(ctx, accountData);
-		else {
-			expireCookie(ctx, ctx.context.authCookies.accountData);
-			const accountStore = createAccountStore(ctx.context.authCookies.accountData.name, ctx.context.authCookies.accountData.attributes, ctx);
-			accountStore.setCookies(accountStore.clean());
+		if (accountData) {
+			if (!shouldBindAccountCookieToSessionUser(ctx.context.options) || accountData.userId === session.user.id) await setAccountCookie(ctx, accountData);
+			else {
+				expireCookie(ctx, ctx.context.authCookies.accountData);
+				const accountStore = createAccountStore(ctx.context.authCookies.accountData.name, ctx.context.authCookies.accountData.attributes, ctx);
+				accountStore.setCookies(accountStore.clean());
+			}
 		}
 	}
 }
@@ -300,7 +302,8 @@ const getCookieCache = async (request, config) => {
 		if (strategy === "jwe") {
 			const secret = config?.secret || env.BETTER_AUTH_SECRET;
 			if (!secret) throw new BetterAuthError("getCookieCache requires a secret to be provided. Either pass it as an option or set the BETTER_AUTH_SECRET environment variable");
-			const payload = parseCookieCachePayload(await symmetricDecodeJWT(sessionData, secret, "better-auth-session"));
+			const decoded = await symmetricDecodeJWT(sessionData, secret, "better-auth-session");
+			const payload = parseCookieCachePayload(decoded);
 			if (!payload) return null;
 			if (config?.version) {
 				if (!await matchesVersion(payload, config.version)) return null;
@@ -317,7 +320,8 @@ const getCookieCache = async (request, config) => {
 			else {
 				const secret = config?.secret || env.BETTER_AUTH_SECRET;
 				if (!secret) throw new BetterAuthError("getCookieCache requires a secret to be provided. Either pass it as an option or set the BETTER_AUTH_SECRET environment variable");
-				payload = parseCookieCachePayload(await verifyJWT(sessionData, secret));
+				const decoded = await verifyJWT(sessionData, secret);
+				payload = parseCookieCachePayload(decoded);
 			}
 			if (!payload) return null;
 			if (config?.version) {

package/dist/cookies/jwt.mjs

@@ -31,7 +31,8 @@ async function verifySessionCookieJwtWithJwks(token, jwks, options) {
 		if (!key) return null;
 		const alg = key.alg ?? header.alg;
 		if (!alg) return null;
-		const { payload } = await jwtVerify(token, await importJWK(key, alg), {
+		const publicKey = await importJWK(key, alg);
+		const { payload } = await jwtVerify(token, publicKey, {
 			...getSessionCookieJwtVerifyOptions(options),
 			algorithms: [alg]
 		});

package/dist/cookies/session-store.d.mts

@@ -1,19 +1,20 @@
 import { GenericEndpointContext } from "@better-auth/core";
 import { CookieOptions } from "better-call";
+import "zod";
 //#region src/cookies/session-store.d.ts
 interface Cookie {
   name: string;
   value: string;
   attributes: CookieOptions;
 }
-declare const createSessionStore: (cookieName: string, cookieOptions: CookieOptions, ctx: GenericEndpointContext) => {
+export declare const createSessionStore: (cookieName: string, cookieOptions: CookieOptions, ctx: GenericEndpointContext) => {
   chunk(value: string, options?: Partial<CookieOptions>): Cookie[];
   clean(): Cookie[];
   setCookies(cookies: Cookie[]): void;
 };
-declare function getChunkedCookie(ctx: GenericEndpointContext, cookieName: string): string | null;
-declare function setAccountCookie(c: GenericEndpointContext, accountData: Record<string, any>): Promise<void>;
-declare function getAccountCookie(c: GenericEndpointContext): Promise<{
+export declare function getChunkedCookie(ctx: GenericEndpointContext, cookieName: string): string | null;
+export declare function setAccountCookie(c: GenericEndpointContext, accountData: Record<string, any>): Promise<void>;
+export declare function getAccountCookie(c: GenericEndpointContext): Promise<{
   id: string;
   createdAt: Date;
   updatedAt: Date;
@@ -29,4 +30,4 @@ declare function getAccountCookie(c: GenericEndpointContext): Promise<{
   password?: string | null | undefined;
 } | null>;
 //#endregion
-export { createSessionStore, getAccountCookie, getChunkedCookie, setAccountCookie };
+export {};

package/dist/cookies/session-store.mjs

@@ -24,7 +24,8 @@ const MAX_COOKIE_CHUNKS = 100;
 * wire. Non-positive when the name and attributes alone overflow.
 */
 function getMaxCookieValueSize(name, options) {
-	return MAX_COOKIE_SIZE - serializeCookie(name, "", { ...options }).length;
+	const overhead = serializeCookie(name, "", { ...options }).length;
+	return MAX_COOKIE_SIZE - overhead;
 }
 function parseCookieChunkIndex(cookieName, name) {
 	const prefix = `${cookieName}.`;
@@ -50,7 +51,7 @@ function readExistingChunks(cookieName, ctx) {
 * Split a cookie value into chunks if needed
 */
 function chunkCookie(storeName, cookie, chunks, logger) {
-	const chunkSize = getMaxCookieValueSize(`${cookie.name}.${MAX_COOKIE_CHUNKS - 1}`, cookie.attributes);
+	const chunkSize = getMaxCookieValueSize(`${cookie.name}.99`, cookie.attributes);
 	const chunkCount = chunkSize > 0 ? Math.ceil(cookie.value.length / chunkSize) : Infinity;
 	if (chunkCount <= 1) {
 		chunks[cookie.name] = cookie.value;

package/dist/crypto/buffer.d.mts

@@ -2,6 +2,5 @@
 /**
  * Compare two buffers in constant time.
  */
-declare function constantTimeEqual(a: ArrayBuffer | Uint8Array | string, b: ArrayBuffer | Uint8Array | string): boolean;
-//#endregion
-export { constantTimeEqual };
+export declare function constantTimeEqual(a: ArrayBuffer | Uint8Array | string, b: ArrayBuffer | Uint8Array | string): boolean;
+//#endregion

package/dist/crypto/index.d.mts

@@ -3,30 +3,23 @@ import { signJWT, symmetricDecodeJWT, symmetricEncodeJWT, verifyJWT } from "./jw
 import { hashPassword, verifyPassword } from "./password.mjs";
 import { generateRandomString } from "./random.mjs";
 import { SecretConfig } from "@better-auth/core";
-
 //#region src/crypto/index.d.ts
-declare function parseEnvelope(data: string): {
+export declare function parseEnvelope(data: string): {
   version: number;
   ciphertext: string;
 } | null;
-declare function formatEnvelope(version: number, ciphertext: string): string;
-type SymmetricEncryptOptions = {
+export declare function formatEnvelope(version: number, ciphertext: string): string;
+export type SymmetricEncryptOptions = {
   key: string | SecretConfig;
   data: string;
 };
-declare const symmetricEncrypt: ({
-  key,
-  data
-}: SymmetricEncryptOptions) => Promise<string>;
-type SymmetricDecryptOptions = {
+export declare const symmetricEncrypt: ({ key, data }: SymmetricEncryptOptions) => Promise<string>;
+export type SymmetricDecryptOptions = {
   key: string | SecretConfig;
   data: string;
 };
-declare const symmetricDecrypt: ({
-  key,
-  data
-}: SymmetricDecryptOptions) => Promise<string>;
-declare const getCryptoKey: (secret: string | BufferSource) => Promise<CryptoKey>;
-declare const makeSignature: (value: string, secret: string | BufferSource) => Promise<string>;
+export declare const symmetricDecrypt: ({ key, data }: SymmetricDecryptOptions) => Promise<string>;
+export declare const getCryptoKey: (secret: string | BufferSource) => Promise<CryptoKey>;
+export declare const makeSignature: (value: string, secret: string | BufferSource) => Promise<string>;
 //#endregion
-export { type SecretConfig, SymmetricDecryptOptions, SymmetricEncryptOptions, constantTimeEqual, formatEnvelope, generateRandomString, getCryptoKey, hashPassword, makeSignature, parseEnvelope, signJWT, symmetricDecodeJWT, symmetricDecrypt, symmetricEncodeJWT, symmetricEncrypt, verifyJWT, verifyPassword };
+export { type SecretConfig, constantTimeEqual, generateRandomString, hashPassword, signJWT, symmetricDecodeJWT, symmetricEncodeJWT, verifyJWT, verifyPassword };

package/dist/crypto/index.mjs

@@ -30,7 +30,8 @@ function formatEnvelope(version, ciphertext) {
 async function rawEncrypt(secret, data) {
 	const keyAsBytes = await createHash("SHA-256").digest(secret);
 	const dataAsBytes = utf8ToBytes(data);
-	return bytesToHex(managedNonce(xchacha20poly1305)(new Uint8Array(keyAsBytes)).encrypt(dataAsBytes));
+	const chacha = managedNonce(xchacha20poly1305)(new Uint8Array(keyAsBytes));
+	return bytesToHex(chacha.encrypt(dataAsBytes));
 }
 async function rawDecrypt(secret, hex) {
 	const keyAsBytes = await createHash("SHA-256").digest(secret);

package/dist/crypto/jwt.d.mts

@@ -1,9 +1,7 @@
 import { SecretConfig } from "./index.mjs";
-
 //#region src/crypto/jwt.d.ts
-declare function signJWT(payload: any, secret: string, expiresIn?: number): Promise<string>;
-declare function verifyJWT<T = any>(token: string, secret: string): Promise<T | null>;
-declare function symmetricEncodeJWT<T extends Record<string, any>>(payload: T, secret: string | SecretConfig, salt: string, expiresIn?: number): Promise<string>;
-declare function symmetricDecodeJWT<T = any>(token: string, secret: string | SecretConfig, salt: string): Promise<T | null>;
-//#endregion
-export { signJWT, symmetricDecodeJWT, symmetricEncodeJWT, verifyJWT };
+export declare function signJWT(payload: any, secret: string, expiresIn?: number): Promise<string>;
+export declare function verifyJWT<T = any>(token: string, secret: string): Promise<T | null>;
+export declare function symmetricEncodeJWT<T extends Record<string, any>>(payload: T, secret: string | SecretConfig, salt: string, expiresIn?: number): Promise<string>;
+export declare function symmetricDecodeJWT<T = any>(token: string, secret: string | SecretConfig, salt: string): Promise<T | null>;
+//#endregion

package/dist/crypto/jwt.mjs

@@ -129,7 +129,8 @@ async function symmetricDecodeJWT(token, secret, salt) {
 		if (secrets.length <= 1) return null;
 		for (let i = 1; i < secrets.length; i++) try {
 			const s = secrets[i];
-			const { payload } = await jwtDecrypt(token, deriveEncryptionSecret(s.value, salt), jwtDecryptOpts);
+			const encryptionSecret = deriveEncryptionSecret(s.value, salt);
+			const { payload } = await jwtDecrypt(token, encryptionSecret, jwtDecryptOpts);
 			return payload;
 		} catch {
 			continue;

package/dist/crypto/password.d.mts

@@ -1,11 +1,7 @@
 import { hashPassword } from "@better-auth/utils/password";
-
 //#region src/crypto/password.d.ts
 declare const hashPassword$1: typeof hashPassword;
-declare const verifyPassword$1: ({
-  hash,
-  password
-}: {
+declare const verifyPassword$1: ({ hash, password }: {
   hash: string;
   password: string;
 }) => Promise<boolean>;

package/dist/crypto/random.d.mts

@@ -1,4 +1,3 @@
 //#region src/crypto/random.d.ts
-declare const generateRandomString: <SubA extends "a-z" | "A-Z" | "0-9" | "-_">(length: number, ...alphabets: SubA[]) => string;
-//#endregion
-export { generateRandomString };
+export declare const generateRandomString: <SubA extends "a-z" | "A-Z" | "0-9" | "-_">(length: number, ...alphabets: SubA[]) => string;
+//#endregion

package/dist/db/adapter-base.d.mts

@@ -1,7 +1,5 @@
 import { BetterAuthOptions } from "@better-auth/core";
 import { DBAdapter } from "@better-auth/core/db/adapter";
-
 //#region src/db/adapter-base.d.ts
-declare function getBaseAdapter(options: BetterAuthOptions, handleDirectDatabase: (options: BetterAuthOptions) => Promise<DBAdapter<BetterAuthOptions>>): Promise<DBAdapter<BetterAuthOptions>>;
-//#endregion
-export { getBaseAdapter };
+export declare function getBaseAdapter(options: BetterAuthOptions, handleDirectDatabase: (options: BetterAuthOptions) => Promise<DBAdapter<BetterAuthOptions>>): Promise<DBAdapter<BetterAuthOptions>>;
+//#endregion

package/dist/db/adapter-kysely.d.mts

@@ -1,7 +1,5 @@
 import { BetterAuthOptions } from "@better-auth/core";
 import { DBAdapter } from "@better-auth/core/db/adapter";
-
 //#region src/db/adapter-kysely.d.ts
-declare function getAdapter(options: BetterAuthOptions): Promise<DBAdapter<BetterAuthOptions>>;
-//#endregion
-export { getAdapter };
+export declare function getAdapter(options: BetterAuthOptions): Promise<DBAdapter<BetterAuthOptions>>;
+//#endregion

package/dist/db/field-converter.d.mts

@@ -1,7 +1,5 @@
 import { DBFieldAttribute } from "@better-auth/core/db";
-
 //#region src/db/field-converter.d.ts
-declare function convertToDB<T extends Record<string, any>>(fields: Record<string, DBFieldAttribute>, values: T): T;
-declare function convertFromDB<T extends Record<string, any>>(fields: Record<string, DBFieldAttribute>, values: T | null): T | null;
-//#endregion
-export { convertFromDB, convertToDB };
+export declare function convertToDB<T extends Record<string, any>>(fields: Record<string, DBFieldAttribute>, values: T): T;
+export declare function convertFromDB<T extends Record<string, any>>(fields: Record<string, DBFieldAttribute>, values: T | null): T | null;
+//#endregion