@depup/better-auth__core 1.6.23-depup.2

package/LICENSE.md

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright (c) 2024 - present, Bereket Engida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# @depup/better-auth__core
+
+> Dependency-bumped version of [@better-auth/core](https://www.npmjs.com/package/@better-auth/core)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/better-auth__core
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [@better-auth/core](https://www.npmjs.com/package/@better-auth/core) @ 1.6.23 |
+| Processed | 2026-07-21 |
+| Smoke test | passed |
+| Deps updated | 2 |
+
+## Dependency Changes
+
+| Dependency | From | To |
+|------------|------|-----|
+| @opentelemetry/semantic-conventions | ^1.39.0 | ^1.43.0 |
+| zod | ^4.3.6 | ^4.4.3 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/@better-auth/core
+
+License inherited from the original package.

package/changes.json

@@ -0,0 +1,14 @@
+{
+  "bumped": {
+    "@opentelemetry/semantic-conventions": {
+      "from": "^1.39.0",
+      "to": "^1.43.0"
+    },
+    "zod": {
+      "from": "^4.3.6",
+      "to": "^4.4.3"
+    }
+  },
+  "timestamp": "2026-07-21T16:14:57.061Z",
+  "totalUpdated": 2
+}

package/dist/api/index.d.mts

@@ -0,0 +1,281 @@
+import { BetterAuthDBSchema, ModelNames, SecondaryStorage } from "../db/type.mjs";
+import { DBAdapter } from "../db/adapter/index.mjs";
+import { createLogger } from "../env/logger.mjs";
+import { AuthContext } from "../types/context.mjs";
+import { OAuthProvider } from "../oauth2/oauth-provider.mjs";
+import * as better_call0 from "better-call";
+import { EndpointContext, EndpointOptions, StrictEndpoint } from "better-call";
+import * as _better_auth_core0 from "@better-auth/core";
+
+//#region src/api/index.d.ts
+declare const optionsMiddleware: <InputCtx extends better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>>(inputContext: InputCtx) => Promise<AuthContext>;
+declare const createAuthMiddleware: {
+  <Options extends better_call0.MiddlewareOptions, R>(options: Options, handler: (ctx: better_call0.MiddlewareContext<Options, {
+    returned?: unknown | undefined;
+    responseHeaders?: Headers | undefined;
+  } & _better_auth_core0.PluginContext<_better_auth_core0.BetterAuthOptions> & _better_auth_core0.InfoContext & {
+    options: _better_auth_core0.BetterAuthOptions;
+    trustedOrigins: string[];
+    trustedProviders: string[];
+    isTrustedOrigin: (url: string, settings?: {
+      allowRelativePaths: boolean;
+    }) => boolean;
+    oauthConfig: {
+      skipStateCookieCheck?: boolean | undefined;
+      storeStateStrategy: "database" | "cookie";
+    };
+    newSession: {
+      session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+      } & Record<string, any>;
+      user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+      } & Record<string, any>;
+    } | null;
+    session: {
+      session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+      } & Record<string, any>;
+      user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+      } & Record<string, any>;
+    } | null;
+    setNewSession: (session: {
+      session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+      } & Record<string, any>;
+      user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+      } & Record<string, any>;
+    } | null) => void;
+    socialProviders: OAuthProvider[];
+    authCookies: _better_auth_core0.BetterAuthCookies;
+    logger: ReturnType<typeof createLogger>;
+    rateLimit: {
+      enabled: boolean;
+      window: number;
+      max: number;
+      storage: "memory" | "database" | "secondary-storage";
+    } & Omit<_better_auth_core0.BetterAuthRateLimitOptions, "enabled" | "window" | "max" | "storage">;
+    adapter: DBAdapter<_better_auth_core0.BetterAuthOptions>;
+    internalAdapter: _better_auth_core0.InternalAdapter<_better_auth_core0.BetterAuthOptions>;
+    createAuthCookie: (cookieName: string, overrideAttributes?: Partial<better_call0.CookieOptions> | undefined) => _better_auth_core0.BetterAuthCookie;
+    secret: string;
+    secretConfig: string | _better_auth_core0.SecretConfig;
+    sessionConfig: {
+      updateAge: number;
+      expiresIn: number;
+      freshAge: number;
+      cookieRefreshCache: false | {
+        enabled: true;
+        updateAge: number;
+      };
+    };
+    generateId: (options: {
+      model: ModelNames;
+      size?: number | undefined;
+    }) => string | false;
+    secondaryStorage: SecondaryStorage | undefined;
+    password: {
+      hash: (password: string) => Promise<string>;
+      verify: (data: {
+        password: string;
+        hash: string;
+      }) => Promise<boolean>;
+      config: {
+        minPasswordLength: number;
+        maxPasswordLength: number;
+      };
+      checkPassword: (userId: string, ctx: _better_auth_core0.GenericEndpointContext<_better_auth_core0.BetterAuthOptions>) => Promise<boolean>;
+    };
+    tables: BetterAuthDBSchema;
+    runMigrations: () => Promise<void>;
+    publishTelemetry: (event: {
+      type: string;
+      anonymousId?: string | undefined;
+      payload: Record<string, any>;
+    }) => Promise<void>;
+    skipOriginCheck: boolean | string[];
+    skipCSRFCheck: boolean;
+    runInBackground: (promise: Promise<unknown>) => void;
+    runInBackgroundOrAwait: (promise: Promise<unknown> | void) => _better_auth_core0.Awaitable<unknown>;
+  }>) => Promise<R>): (inputContext: better_call0.MiddlewareInputContext<Options>) => Promise<R>;
+  <Options extends better_call0.MiddlewareOptions, R_1>(handler: (ctx: better_call0.MiddlewareContext<Options, {
+    returned?: unknown | undefined;
+    responseHeaders?: Headers | undefined;
+  } & _better_auth_core0.PluginContext<_better_auth_core0.BetterAuthOptions> & _better_auth_core0.InfoContext & {
+    options: _better_auth_core0.BetterAuthOptions;
+    trustedOrigins: string[];
+    trustedProviders: string[];
+    isTrustedOrigin: (url: string, settings?: {
+      allowRelativePaths: boolean;
+    }) => boolean;
+    oauthConfig: {
+      skipStateCookieCheck?: boolean | undefined;
+      storeStateStrategy: "database" | "cookie";
+    };
+    newSession: {
+      session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+      } & Record<string, any>;
+      user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+      } & Record<string, any>;
+    } | null;
+    session: {
+      session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+      } & Record<string, any>;
+      user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+      } & Record<string, any>;
+    } | null;
+    setNewSession: (session: {
+      session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+      } & Record<string, any>;
+      user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+      } & Record<string, any>;
+    } | null) => void;
+    socialProviders: OAuthProvider[];
+    authCookies: _better_auth_core0.BetterAuthCookies;
+    logger: ReturnType<typeof createLogger>;
+    rateLimit: {
+      enabled: boolean;
+      window: number;
+      max: number;
+      storage: "memory" | "database" | "secondary-storage";
+    } & Omit<_better_auth_core0.BetterAuthRateLimitOptions, "enabled" | "window" | "max" | "storage">;
+    adapter: DBAdapter<_better_auth_core0.BetterAuthOptions>;
+    internalAdapter: _better_auth_core0.InternalAdapter<_better_auth_core0.BetterAuthOptions>;
+    createAuthCookie: (cookieName: string, overrideAttributes?: Partial<better_call0.CookieOptions> | undefined) => _better_auth_core0.BetterAuthCookie;
+    secret: string;
+    secretConfig: string | _better_auth_core0.SecretConfig;
+    sessionConfig: {
+      updateAge: number;
+      expiresIn: number;
+      freshAge: number;
+      cookieRefreshCache: false | {
+        enabled: true;
+        updateAge: number;
+      };
+    };
+    generateId: (options: {
+      model: ModelNames;
+      size?: number | undefined;
+    }) => string | false;
+    secondaryStorage: SecondaryStorage | undefined;
+    password: {
+      hash: (password: string) => Promise<string>;
+      verify: (data: {
+        password: string;
+        hash: string;
+      }) => Promise<boolean>;
+      config: {
+        minPasswordLength: number;
+        maxPasswordLength: number;
+      };
+      checkPassword: (userId: string, ctx: _better_auth_core0.GenericEndpointContext<_better_auth_core0.BetterAuthOptions>) => Promise<boolean>;
+    };
+    tables: BetterAuthDBSchema;
+    runMigrations: () => Promise<void>;
+    publishTelemetry: (event: {
+      type: string;
+      anonymousId?: string | undefined;
+      payload: Record<string, any>;
+    }) => Promise<void>;
+    skipOriginCheck: boolean | string[];
+    skipCSRFCheck: boolean;
+    runInBackground: (promise: Promise<unknown>) => void;
+    runInBackgroundOrAwait: (promise: Promise<unknown> | void) => _better_auth_core0.Awaitable<unknown>;
+  }>) => Promise<R_1>): (inputContext: better_call0.MiddlewareInputContext<Options>) => Promise<R_1>;
+};
+type EndpointHandler<Path extends string, Options extends EndpointOptions, R> = (context: EndpointContext<Path, Options, AuthContext>) => Promise<R>;
+declare function createAuthEndpoint<Path extends string, Options extends EndpointOptions, R>(path: Path, options: Options, handler: EndpointHandler<Path, Options, R>): StrictEndpoint<Path, Options, R>;
+declare function createAuthEndpoint<Path extends string, Options extends EndpointOptions, R>(options: Options, handler: EndpointHandler<Path, Options, R>): StrictEndpoint<Path, Options, R>;
+declare namespace createAuthEndpoint {
+  var serverOnly: <Path extends string, Options extends EndpointOptions, R>(options: Options, handler: EndpointHandler<Path, Options, R>) => StrictEndpoint<Path, Options, R>;
+}
+type AuthEndpoint<Path extends string, Opts extends EndpointOptions, R> = ReturnType<typeof createAuthEndpoint<Path, Opts, R>>;
+type AuthMiddleware = ReturnType<typeof createAuthMiddleware>;
+//#endregion
+export { AuthEndpoint, AuthMiddleware, createAuthEndpoint, createAuthMiddleware, optionsMiddleware };

package/dist/api/index.mjs

@@ -0,0 +1,92 @@
+import { runWithEndpointContext } from "../context/endpoint-context.mjs";
+import { isAPIError } from "../utils/is-api-error.mjs";
+import { createEndpoint, createMiddleware, kAPIErrorHeaderSymbol } from "better-call";
+//#region src/api/index.ts
+/**
+* Better-call's createEndpoint re-throws APIError without exposing the headers
+* accumulated on ctx.responseHeaders (e.g. Set-Cookie from deleteSessionCookie
+* before throw). Attach them to the error via kAPIErrorHeaderSymbol — matching
+* better-call's createMiddleware contract so the outer pipeline can merge them
+* into the response.
+*/
+function attachResponseHeadersToAPIError(responseHeaders, e) {
+	if (!isAPIError(e) || !responseHeaders) return;
+	Object.defineProperty(e, kAPIErrorHeaderSymbol, {
+		enumerable: false,
+		configurable: true,
+		value: responseHeaders,
+		writable: false
+	});
+}
+const optionsMiddleware = createMiddleware(async () => {
+	/**
+	* This will be passed on the instance of
+	* the context. Used to infer the type
+	* here.
+	*/
+	return {};
+});
+const createAuthMiddleware = createMiddleware.create({ use: [optionsMiddleware, createMiddleware(async () => {
+	return {};
+})] });
+const use = [optionsMiddleware];
+function createAuthEndpoint(pathOrOptions, handlerOrOptions, handlerOrNever) {
+	const path = typeof pathOrOptions === "string" ? pathOrOptions : void 0;
+	const options = typeof handlerOrOptions === "object" ? handlerOrOptions : pathOrOptions;
+	const handler = typeof handlerOrOptions === "function" ? handlerOrOptions : handlerOrNever;
+	const wrapped = async (ctx) => {
+		const runtimeCtx = ctx;
+		try {
+			return await runWithEndpointContext(ctx, () => handler(ctx));
+		} catch (e) {
+			attachResponseHeadersToAPIError(runtimeCtx.responseHeaders, e);
+			throw e;
+		}
+	};
+	if (path) return createEndpoint(path, {
+		...options,
+		use: [...options?.use || [], ...use]
+	}, wrapped);
+	return createEndpoint({
+		...options,
+		use: [...options?.use || [], ...use]
+	}, wrapped);
+}
+/**
+* Set `metadata.SERVER_ONLY` while preserving any existing metadata
+* (`$Infer`, `openapi`, ...).
+*/
+function withServerOnly(options) {
+	return {
+		...options,
+		metadata: {
+			...options.metadata,
+			SERVER_ONLY: true
+		}
+	};
+}
+/**
+* Declare a **server-only** endpoint.
+*
+* The endpoint is callable through `auth.api.*` from trusted server code but is
+* never registered on the HTTP router and never emitted into the OpenAPI
+* schema. It takes no path because it has no URL to be reached at.
+*
+* Prefer this over the path-less `createAuthEndpoint({ ... }, handler)` form.
+* Setting `metadata.SERVER_ONLY` makes the intent explicit at the call site and
+* keeps the endpoint off the HTTP surface even if a path is later added by
+* mistake: better-call's router skips an endpoint when its path is missing *or*
+* when `SERVER_ONLY` is set, so the two together are defense in depth. Relying
+* on path omission alone is invisible and one keystroke away from exposure.
+*
+* @example
+* ```ts
+* viewBackupCodes: createAuthEndpoint.serverOnly(
+* 	{ method: "POST", body: schema },
+* 	async (ctx) => { ... },
+* )
+* ```
+*/
+createAuthEndpoint.serverOnly = (options, handler) => createAuthEndpoint(withServerOnly(options), handler);
+//#endregion
+export { createAuthEndpoint, createAuthMiddleware, optionsMiddleware };

package/dist/async_hooks/index.d.mts

@@ -0,0 +1,6 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/async_hooks/index.d.ts
+declare function getAsyncLocalStorage(): Promise<typeof AsyncLocalStorage>;
+//#endregion
+export { type AsyncLocalStorage, getAsyncLocalStorage };

package/dist/async_hooks/index.mjs

@@ -0,0 +1,20 @@
+//#region src/async_hooks/index.ts
+const AsyncLocalStoragePromise = import(
+	/* @vite-ignore */
+	/* webpackIgnore: true */
+	"node:async_hooks"
+).then((mod) => mod.AsyncLocalStorage).catch((err) => {
+	if ("AsyncLocalStorage" in globalThis) return globalThis.AsyncLocalStorage;
+	if (typeof window !== "undefined") return null;
+	console.warn("[better-auth] Warning: AsyncLocalStorage is not available in this environment. Some features may not work as expected.");
+	console.warn("[better-auth] Please read more about this warning at https://better-auth.com/docs/installation#mount-handler");
+	console.warn("[better-auth] If you are using Cloudflare Workers, please see: https://developers.cloudflare.com/workers/configuration/compatibility-flags/#nodejs-compatibility-flag");
+	throw err;
+});
+async function getAsyncLocalStorage() {
+	const mod = await AsyncLocalStoragePromise;
+	if (mod === null) throw new Error("getAsyncLocalStorage is only available in server code");
+	else return mod;
+}
+//#endregion
+export { getAsyncLocalStorage };

package/dist/async_hooks/pure.index.d.mts

@@ -0,0 +1,6 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/async_hooks/pure.index.d.ts
+declare function getAsyncLocalStorage(): Promise<typeof AsyncLocalStorage>;
+//#endregion
+export { getAsyncLocalStorage };

package/dist/async_hooks/pure.index.mjs

@@ -0,0 +1,33 @@
+//#region src/async_hooks/pure.index.ts
+/**
+* Due to the lack of AsyncLocalStorage in some environments (like Convex),
+*
+* We assume serverless functions are short-lived and single-threaded, so we can use a simple polyfill.
+*/
+var AsyncLocalStoragePolyfill = class {
+	#current = void 0;
+	run(store, fn) {
+		const prev = this.#current;
+		this.#current = store;
+		const result = fn();
+		if (result instanceof Promise) return result.finally(() => {
+			this.#current = prev;
+		});
+		this.#current = prev;
+		return result;
+	}
+	getStore() {
+		return this.#current;
+	}
+};
+const AsyncLocalStoragePromise = Promise.resolve().then(() => {
+	if ("AsyncLocalStorage" in globalThis) return globalThis.AsyncLocalStorage;
+	return AsyncLocalStoragePolyfill;
+});
+async function getAsyncLocalStorage() {
+	const mod = await AsyncLocalStoragePromise;
+	if (mod === null) throw new Error("getAsyncLocalStorage is only available in server code");
+	else return mod;
+}
+//#endregion
+export { getAsyncLocalStorage };

package/dist/context/endpoint-context.d.mts

@@ -0,0 +1,18 @@
+import { AuthContext } from "../types/context.mjs";
+import { EndpointContext, InputContext } from "better-call";
+import { AsyncLocalStorage } from "@better-auth/core/async_hooks";
+
+//#region src/context/endpoint-context.d.ts
+type AuthEndpointContext = Partial<InputContext<string, any> & EndpointContext<string, any>> & {
+  context: AuthContext;
+};
+/**
+ * This is for internal use only. Most users should use `getCurrentAuthContext` instead.
+ *
+ * It is exposed for advanced use cases where you need direct access to the AsyncLocalStorage instance.
+ */
+declare function getCurrentAuthContextAsyncLocalStorage(): Promise<AsyncLocalStorage<AuthEndpointContext>>;
+declare function getCurrentAuthContext(): Promise<AuthEndpointContext>;
+declare function runWithEndpointContext<T>(context: AuthEndpointContext, fn: () => T): Promise<T>;
+//#endregion
+export { AuthEndpointContext, getCurrentAuthContext, getCurrentAuthContextAsyncLocalStorage, runWithEndpointContext };

package/dist/context/endpoint-context.mjs

@@ -0,0 +1,29 @@
+import { __getBetterAuthGlobal } from "./global.mjs";
+import { getAsyncLocalStorage } from "@better-auth/core/async_hooks";
+//#region src/context/endpoint-context.ts
+const ensureAsyncStorage = async () => {
+	const betterAuthGlobal = __getBetterAuthGlobal();
+	if (!betterAuthGlobal.context.endpointContextAsyncStorage) {
+		const AsyncLocalStorage = await getAsyncLocalStorage();
+		betterAuthGlobal.context.endpointContextAsyncStorage = new AsyncLocalStorage();
+	}
+	return betterAuthGlobal.context.endpointContextAsyncStorage;
+};
+/**
+* This is for internal use only. Most users should use `getCurrentAuthContext` instead.
+*
+* It is exposed for advanced use cases where you need direct access to the AsyncLocalStorage instance.
+*/
+async function getCurrentAuthContextAsyncLocalStorage() {
+	return ensureAsyncStorage();
+}
+async function getCurrentAuthContext() {
+	const context = (await ensureAsyncStorage()).getStore();
+	if (!context) throw new Error("No auth context found. Please make sure you are calling this function within a `runWithEndpointContext` callback.");
+	return context;
+}
+async function runWithEndpointContext(context, fn) {
+	return (await ensureAsyncStorage()).run(context, fn);
+}
+//#endregion
+export { getCurrentAuthContext, getCurrentAuthContextAsyncLocalStorage, runWithEndpointContext };

package/dist/context/global.d.mts

@@ -0,0 +1,6 @@
+import { AsyncLocalStorage } from "@better-auth/core/async_hooks";
+
+//#region src/context/global.d.ts
+declare function getBetterAuthVersion(): string;
+//#endregion
+export { getBetterAuthVersion };

package/dist/context/global.mjs

@@ -0,0 +1,36 @@
+//#region src/context/global.ts
+const symbol = Symbol.for("better-auth:global");
+let bind = null;
+const __context = {};
+const __betterAuthVersion = "1.6.23";
+/**
+* We store context instance in the globalThis.
+*
+* The reason we do this is that some bundlers, web framework, or package managers might
+* create multiple copies of BetterAuth in the same process intentionally or unintentionally.
+*
+* For example, yarn v1, Next.js, SSR, Vite...
+*
+* @internal
+*/
+function __getBetterAuthGlobal() {
+	if (!globalThis[symbol]) {
+		globalThis[symbol] = {
+			version: __betterAuthVersion,
+			epoch: 1,
+			context: __context
+		};
+		bind = globalThis[symbol];
+	}
+	bind = globalThis[symbol];
+	if (bind.version !== __betterAuthVersion) {
+		bind.version = __betterAuthVersion;
+		bind.epoch++;
+	}
+	return globalThis[symbol];
+}
+function getBetterAuthVersion() {
+	return __getBetterAuthGlobal().version;
+}
+//#endregion
+export { __getBetterAuthGlobal, getBetterAuthVersion };

package/dist/context/index.d.mts

@@ -0,0 +1,5 @@
+import { AuthEndpointContext, getCurrentAuthContext, getCurrentAuthContextAsyncLocalStorage, runWithEndpointContext } from "./endpoint-context.mjs";
+import { getBetterAuthVersion } from "./global.mjs";
+import { RequestState, RequestStateWeakMap, defineRequestState, getCurrentRequestState, getRequestStateAsyncLocalStorage, hasRequestState, runWithRequestState } from "./request-state.mjs";
+import { getCurrentAdapter, getCurrentDBAdapterAsyncLocalStorage, queueAfterTransactionHook, runWithAdapter, runWithTransaction } from "./transaction.mjs";
+export { type AuthEndpointContext, type RequestState, type RequestStateWeakMap, defineRequestState, getBetterAuthVersion, getCurrentAdapter, getCurrentAuthContext, getCurrentAuthContextAsyncLocalStorage, getCurrentDBAdapterAsyncLocalStorage, getCurrentRequestState, getRequestStateAsyncLocalStorage, hasRequestState, queueAfterTransactionHook, runWithAdapter, runWithEndpointContext, runWithRequestState, runWithTransaction };

package/dist/context/index.mjs

@@ -0,0 +1,5 @@
+import { getBetterAuthVersion } from "./global.mjs";
+import { getCurrentAuthContext, getCurrentAuthContextAsyncLocalStorage, runWithEndpointContext } from "./endpoint-context.mjs";
+import { defineRequestState, getCurrentRequestState, getRequestStateAsyncLocalStorage, hasRequestState, runWithRequestState } from "./request-state.mjs";
+import { getCurrentAdapter, getCurrentDBAdapterAsyncLocalStorage, queueAfterTransactionHook, runWithAdapter, runWithTransaction } from "./transaction.mjs";
+export { defineRequestState, getBetterAuthVersion, getCurrentAdapter, getCurrentAuthContext, getCurrentAuthContextAsyncLocalStorage, getCurrentDBAdapterAsyncLocalStorage, getCurrentRequestState, getRequestStateAsyncLocalStorage, hasRequestState, queueAfterTransactionHook, runWithAdapter, runWithEndpointContext, runWithRequestState, runWithTransaction };

package/dist/context/request-state.d.mts

@@ -0,0 +1,27 @@
+import { AsyncLocalStorage } from "@better-auth/core/async_hooks";
+
+//#region src/context/request-state.d.ts
+type RequestStateWeakMap = WeakMap<object, any>;
+declare function getRequestStateAsyncLocalStorage(): Promise<AsyncLocalStorage<RequestStateWeakMap>>;
+declare function hasRequestState(): Promise<boolean>;
+declare function getCurrentRequestState(): Promise<RequestStateWeakMap>;
+declare function runWithRequestState<T>(store: RequestStateWeakMap, fn: () => T): Promise<T>;
+interface RequestState<T> {
+  get(): Promise<T>;
+  set(value: T): Promise<void>;
+  readonly ref: Readonly<object>;
+}
+/**
+ * Defines a request-scoped state with lazy initialization.
+ *
+ * @param initFn - A function that initializes the state. It is called the first time `get()` is invoked within each request context, and only once per context.
+ * @returns A RequestState object with `get` and `set` methods, and a unique `ref` for debugging.
+ *
+ * @example
+ * const userState = defineRequestState(() => ({ id: '', name: '' }));
+ * // Later, within a request context:
+ * const user = await userState.get();
+ */
+declare function defineRequestState<T>(initFn: () => T | Promise<T>): RequestState<T>;
+//#endregion
+export { RequestState, RequestStateWeakMap, defineRequestState, getCurrentRequestState, getRequestStateAsyncLocalStorage, hasRequestState, runWithRequestState };