better-auth 1.8.0-beta.2 → 1.8.0-beta.4

package/dist/client/types.d.mts

@@ -3,9 +3,9 @@ import { StripEmptyObjects, UnionToIntersection } from "../types/helper.mjs";
 import { InferRoutes } from "./path-to-object.mjs";
 import { Session as Session$1, User as User$1 } from "../types/models.mjs";
 import { Auth } from "../types/auth.mjs";
+import "../types/index.mjs";
 import { BetterAuthClientOptions as BetterAuthClientOptions$1, BetterAuthClientPlugin, ClientAtomListener as ClientAtomListener$1, ClientStore as ClientStore$1 } from "@better-auth/core";
 import { DBFieldAttribute, InferDBFieldsOutput } from "@better-auth/core/db";
-
 //#region src/client/types.d.ts
 type ClientPluginError<K extends string = string> = {
   readonly code: K;
@@ -16,36 +16,36 @@ type InferPluginEndpoints<Plugins> = Plugins extends Array<infer Pl> ? UnionToIn
 } ? Plug extends {
   endpoints?: infer Endpoints;
 } ? Endpoints extends Record<string, unknown> ? Endpoints : {} : {} : {}> : {};
-type InferClientAPI<O extends BetterAuthClientOptions$1> = InferRoutes<O["plugins"] extends Array<any> ? Omit<Auth["api"], keyof InferPluginEndpoints<O["plugins"]>> & InferPluginEndpoints<O["plugins"]> : Auth["api"], O>;
-type InferActions<O extends BetterAuthClientOptions$1> = (O["plugins"] extends Array<infer Plugin> ? UnionToIntersection<Plugin extends {
+export type InferClientAPI<O extends BetterAuthClientOptions$1> = InferRoutes<O["plugins"] extends Array<any> ? Omit<Auth["api"], keyof InferPluginEndpoints<O["plugins"]>> & InferPluginEndpoints<O["plugins"]> : Auth["api"], O>;
+export type InferActions<O extends BetterAuthClientOptions$1> = (O["plugins"] extends Array<infer Plugin> ? UnionToIntersection<Plugin extends {
   getActions?: infer GetActions;
 } ? GetActions extends ((...args: any) => infer Actions) ? Actions : {} : {}> : {}) & InferRoutes<O["$InferAuth"] extends {
   plugins: infer Plugins;
 } ? Plugins extends Array<infer Plugin> ? Plugin extends {
   endpoints?: infer Endpoints;
 } ? Endpoints extends Record<string, unknown> ? Endpoints : {} : {} : {} : {}, O>;
-type InferErrorCodes<O extends BetterAuthClientOptions$1> = O["plugins"] extends Array<infer Plugin> ? UnionToIntersection<Plugin extends {
+export type InferErrorCodes<O extends BetterAuthClientOptions$1> = O["plugins"] extends Array<infer Plugin> ? UnionToIntersection<Plugin extends {
   $InferServerPlugin?: infer ServerPlugin;
 } ? ServerPlugin extends {
   $ERROR_CODES?: infer E;
-} ? { [K in keyof E & string]: E[K] extends ClientPluginError ? ClientPluginError<K> : never } : {} : {}> : {};
+} ? { [K in keyof E & string]: E[K] extends ClientPluginError ? ClientPluginError<K> : never; } : {} : {}> : {};
 /**
  * signals are just used to recall a computed value.
  * as a convention they start with "$"
  */
-type IsSignal<T> = T extends `$${infer _}` ? true : false;
-type InferSessionFromClient<O extends BetterAuthClientOptions$1> = StripEmptyObjects<Session$1 & UnionToIntersection<InferAdditionalFromClient<O, "session", "output">>>;
-type InferUserFromClient<O extends BetterAuthClientOptions$1> = StripEmptyObjects<User$1 & UnionToIntersection<InferAdditionalFromClient<O, "user", "output">>>;
-type InferAdditionalFromClient<Options extends BetterAuthClientOptions$1, Key extends string, Format extends "input" | "output" = "output"> = Options["plugins"] extends Array<infer Plugin> ? Plugin extends {
+export type IsSignal<T> = T extends `$${infer _}` ? true : false;
+export type InferSessionFromClient<O extends BetterAuthClientOptions$1> = StripEmptyObjects<Session$1 & UnionToIntersection<InferAdditionalFromClient<O, "session", "output">>>;
+export type InferUserFromClient<O extends BetterAuthClientOptions$1> = StripEmptyObjects<User$1 & UnionToIntersection<InferAdditionalFromClient<O, "user", "output">>>;
+export type InferAdditionalFromClient<Options extends BetterAuthClientOptions$1, Key extends string, Format extends "input" | "output" = "output"> = Options["plugins"] extends Array<infer Plugin> ? Plugin extends {
   $InferServerPlugin?: infer ServerPlugin;
 } ? ServerPlugin extends {
   schema?: infer Schema;
 } ? Schema extends Record<Key, {
   fields: infer Fields;
 }> ? Fields extends Record<string, DBFieldAttribute> ? Format extends "input" ? InferFieldsInputClient<Fields> : InferDBFieldsOutput<Fields> : {} : {} : {} : {} : {};
-type SessionQueryParams = {
+export type SessionQueryParams = {
   disableCookieCache?: boolean | undefined;
   disableRefresh?: boolean | undefined;
 };
 //#endregion
-export { type BetterAuthClientOptions$1 as BetterAuthClientOptions, type BetterAuthClientPlugin, type ClientAtomListener$1 as ClientAtomListener, type ClientStore$1 as ClientStore, InferActions, InferAdditionalFromClient, InferClientAPI, InferErrorCodes, InferSessionFromClient, InferUserFromClient, IsSignal, SessionQueryParams };
+export type { BetterAuthClientOptions$1 as BetterAuthClientOptions, BetterAuthClientPlugin, ClientAtomListener$1 as ClientAtomListener, ClientStore$1 as ClientStore };

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

@@ -1,3 +1,4 @@
+import { trimTrailingSlashes } from "../../utils/url.mjs";
 import { getClientConfig } from "../config.mjs";
 import { createDynamicPathProxy } from "../proxy.mjs";
 import { useStore } from "./vue-store.mjs";
@@ -16,18 +17,23 @@ function toHeadersInit(headers) {
 }
 function createAuthClient(options) {
 	const { baseURL, pluginPathMethods, pluginsActions, pluginsAtoms, hydrateSession, $sessionSignal, $fetch, $store, atomListeners } = getClientConfig(options, false);
-	const sessionCacheKey = [
-		"better-auth",
-		"session",
-		options?.baseURL || "inferred",
-		options?.basePath ?? "/api/auth"
-	].join(":");
+	const baseURLKey = options?.baseURL || "inferred";
+	const basePath = options?.basePath ?? "/api/auth";
+	const sessionCacheKey = `better-auth:session:${baseURLKey}:${basePath}`;
+	const sessionPath = trimTrailingSlashes(basePath.startsWith("/") ? basePath : `/${basePath}`);
+	/**
+	* Stays relative without an explicit `baseURL` so the SSR session fetch
+	* forwards the incoming cookies.
+	*
+	* @see https://nuxt.com/docs/4.x/getting-started/data-fetching
+	*/
+	const sessionURL = `${options?.baseURL ? baseURL : sessionPath}/get-session`;
 	const resolvedHooks = {};
 	for (const [key, value] of Object.entries(pluginsAtoms)) resolvedHooks[getAtomKey(key)] = () => useStore(value);
 	function useSession(useFetch) {
 		if (useFetch) {
 			const sessionSignal = useStore($sessionSignal);
-			return useFetch(`${baseURL}/get-session`, {
+			return useFetch(sessionURL, {
 				headers: toHeadersInit(options?.fetchOptions?.headers),
 				key: sessionCacheKey,
 				watch: [sessionSignal]
@@ -41,14 +47,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/context/secret-utils.mjs

@@ -12,12 +12,12 @@ function estimateEntropy(str) {
 }
 function parseSecretsEnv(envValue) {
 	if (!envValue) return null;
-	return envValue.split(",").map((entry) => {
+	return envValue.split(",").map((entry, index) => {
 		entry = entry.trim();
 		const colonIdx = entry.indexOf(":");
-		if (colonIdx === -1) throw new BetterAuthError(`Invalid BETTER_AUTH_SECRETS entry: "${entry}". Expected format: "<version>:<secret>"`);
+		if (colonIdx === -1) throw new BetterAuthError(`Invalid BETTER_AUTH_SECRETS entry at position ${index + 1}. Expected format: "<version>:<secret>"`);
 		const version = parseInt(entry.slice(0, colonIdx), 10);
-		if (!Number.isInteger(version) || version < 0) throw new BetterAuthError(`Invalid version in BETTER_AUTH_SECRETS: "${entry.slice(0, colonIdx)}". Version must be a non-negative integer.`);
+		if (!Number.isInteger(version) || version < 0) throw new BetterAuthError(`Invalid version in BETTER_AUTH_SECRETS entry at position ${index + 1}. Version must be a non-negative integer.`);
 		const value = entry.slice(colonIdx + 1).trim();
 		if (!value) throw new BetterAuthError(`Empty secret value for version ${version} in BETTER_AUTH_SECRETS.`);
 		return {

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