@neondatabase/auth 0.1.0-beta.9 → 0.2.0-beta.1

package/dist/{adapter-core-C_NEMs0b.mjs → adapter-core-CtmnMMJ7.mjs}

@@ -1,5 +1,7 @@
+import { a as NEON_AUTH_POPUP_PARAM_NAME, c as SESSION_CACHE_TTL_MS, i as NEON_AUTH_POPUP_CALLBACK_ROUTE, o as NEON_AUTH_SESSION_VERIFIER_PARAM_NAME, r as NEON_AUTH_POPUP_CALLBACK_PARAM_NAME, s as OAUTH_POPUP_MESSAGE_TYPE, t as CLOCK_SKEW_BUFFER_MS } from "./constants-Cupc_bln.mjs";
 import { getGlobalBroadcastChannel } from "better-auth/client";
-import { adminClient, anonymousClient, emailOTPClient, jwtClient, organizationClient } from "better-auth/client/plugins";
+import { adminClient, emailOTPClient, jwtClient, organizationClient } from "better-auth/client/plugins";
+import z from "zod";
 
 //#region src/core/in-flight-request-manager.ts
 /**
@@ -99,25 +101,6 @@ var InFlightRequestManager = class {
 	}
 };
 
-//#endregion
-//#region src/core/constants.ts
-/**
-* Session caching configuration constants
-*
-* Uses industry-standard 60s cache TTL (common across auth providers).
-*
-* Note: Token refresh detection is now automatic via Better Auth's
-* fetchOptions.onSuccess callback. No polling is needed.
-*/
-/** Session cache TTL in milliseconds (60 seconds) */
-const SESSION_CACHE_TTL_MS = 6e4;
-/** Clock skew buffer for token expiration checks in milliseconds (10 seconds) */
-const CLOCK_SKEW_BUFFER_MS = 1e4;
-/** Default session expiry duration in milliseconds (1 hour) */
-const DEFAULT_SESSION_EXPIRY_MS = 36e5;
-/** Name of the session verifier parameter in the URL, used for the OAUTH flow */
-const NEON_AUTH_SESSION_VERIFIER_PARAM_NAME = "neon_auth_session_verifier";
-
 //#endregion
 //#region src/utils/jwt.ts
 /**
@@ -136,16 +119,68 @@ function getJwtExpiration(jwt) {
 	}
 }
 
+//#endregion
+//#region src/core/token-cache.ts
+var TokenCache = class {
+	cache = null;
+	/**
+	* Get cached data if not expired.
+	* Returns null if cache is empty or expired.
+	*/
+	get() {
+		if (!this.cache) return null;
+		if (Date.now() > this.cache.expiresAt) {
+			this.cache = null;
+			return null;
+		}
+		return this.cache.data;
+	}
+	/**
+	* Set cached data with TTL.
+	* If jwt is provided, TTL is calculated from its expiration.
+	* Otherwise, uses default SESSION_CACHE_TTL_MS.
+	*/
+	set(data, jwt) {
+		const ttl = this.calculateTTL(jwt);
+		this.cache = {
+			data,
+			expiresAt: Date.now() + ttl
+		};
+	}
+	/**
+	* Clear the cache.
+	*/
+	clear() {
+		this.cache = null;
+	}
+	/**
+	* Check if cache has valid (non-expired) data.
+	*/
+	has() {
+		return this.get() !== null;
+	}
+	/**
+	* Calculate cache TTL from JWT expiration.
+	* Falls back to default TTL if JWT is invalid or missing.
+	*/
+	calculateTTL(jwt) {
+		if (!jwt) return SESSION_CACHE_TTL_MS;
+		const exp = getJwtExpiration(jwt);
+		if (!exp) return SESSION_CACHE_TTL_MS;
+		const now = Date.now();
+		const ttl = exp * 1e3 - now - CLOCK_SKEW_BUFFER_MS;
+		return Math.max(ttl, 1e3);
+	}
+};
+
 //#endregion
 //#region src/core/session-cache-manager.ts
 /**
 * Manages in-memory session cache with TTL expiration.
 *
-* Features:
-* - Stores sessions in Better Auth native format
-* - Automatic expiration based on JWT token expiration
+* Built on TokenCache, adding session-specific features:
 * - Invalidation flag for sign-out scenarios
-* - TTL calculation with clock skew buffer
+* - Token refresh detection via lastSessionData comparison
 *
 * Example:
 * ```typescript
@@ -155,48 +190,40 @@ function getJwtExpiration(jwt) {
 * ```
 */
 var SessionCacheManager = class {
-	cache = null;
+	cache = new TokenCache();
 	lastSessionData = null;
+	invalidated = false;
 	/**
 	* Get cached session if valid and not expired.
 	* Returns null if cache is invalid, expired, or doesn't exist.
 	*/
 	getCachedSession() {
-		if (!this.cache || this.cache.invalidated) return null;
-		if (Date.now() > this.cache.expiresAt) {
-			this.clearSessionCache();
-			return null;
-		}
-		return this.cache.data;
+		if (this.invalidated) return null;
+		return this.cache.get();
 	}
 	/**
-	* Set cached session with optional TTL.
-	* If TTL not provided, calculates from JWT expiration.
+	* Set cached session with JWT-based TTL.
 	* Skips caching if cache was invalidated (sign-out scenario).
 	*/
-	setCachedSession(data, ttl) {
-		if (this.cache?.invalidated) return;
-		this.lastSessionData = this.cache?.data ?? null;
-		const calculatedTtl = ttl ?? this.calculateCacheTTL(data.session.token);
-		this.cache = {
-			data,
-			expiresAt: Date.now() + calculatedTtl,
-			invalidated: false
-		};
+	setCachedSession(data) {
+		if (this.invalidated) return;
+		this.lastSessionData = this.cache.get();
+		this.cache.set(data, data.session.token);
 	}
 	/**
 	* Invalidate cache (marks as invalid but doesn't clear).
 	* Useful for sign-out scenarios where in-flight requests should not cache.
 	*/
 	invalidateSessionCache() {
-		if (this.cache) this.cache.invalidated = true;
+		this.invalidated = true;
 	}
 	/**
 	* Clear cache completely.
 	*/
 	clearSessionCache() {
-		this.cache = null;
+		this.cache.clear();
 		this.lastSessionData = null;
+		this.invalidated = false;
 	}
 	/**
 	* Check if token was refreshed by comparing tokens with previous session.
@@ -206,20 +233,101 @@ var SessionCacheManager = class {
 		if (!this.lastSessionData?.session?.token || !data?.session?.token) return false;
 		return this.lastSessionData.session.token !== data.session.token;
 	}
+};
+
+//#endregion
+//#region src/core/anonymous-token-cache-manager.ts
+/**
+* Manages in-memory anonymous token cache with TTL expiration.
+*
+* Stores the full anonymous token response (token + expires_at).
+* Unlike SessionCacheManager, doesn't need:
+* - Invalidation flag (no sign-out scenario for anonymous tokens)
+* - Refresh detection (anonymous tokens are stateless)
+*/
+var AnonymousTokenCacheManager = class {
+	cache = new TokenCache();
+	/**
+	* Get cached anonymous token response if not expired.
+	* Returns null if cache is empty or expired.
+	*/
+	getCachedResponse() {
+		return this.cache.get();
+	}
 	/**
-	* Calculate cache TTL from JWT expiration.
-	* Falls back to default TTL if JWT is invalid or missing.
+	* Set cached anonymous token response with JWT-based TTL.
+	* TTL is automatically calculated from the JWT expiration.
 	*/
-	calculateCacheTTL(jwt) {
-		if (!jwt) return SESSION_CACHE_TTL_MS;
-		const exp = getJwtExpiration(jwt);
-		if (!exp) return SESSION_CACHE_TTL_MS;
-		const now = Date.now();
-		const ttl = exp * 1e3 - now - CLOCK_SKEW_BUFFER_MS;
-		return Math.max(ttl, 1e3);
+	setCachedResponse(data) {
+		this.cache.set(data, data.token);
+	}
+	/**
+	* Clear the cache.
+	*/
+	clearCache() {
+		this.cache.clear();
+	}
+	/**
+	* Check if cache has a valid (non-expired) response.
+	*/
+	hasCachedResponse() {
+		return this.cache.has();
 	}
 };
 
+//#endregion
+//#region src/core/oauth-popup.ts
+/**
+* Opens an OAuth popup window and waits for completion.
+*
+* This is used when the app is running inside an iframe, where OAuth
+* redirect flows don't work due to X-Frame-Options/CSP restrictions.
+* The popup completes the OAuth flow and sends a postMessage back
+* with the session verifier needed to fetch the session.
+*
+* @param url - The OAuth authorization URL to open in the popup
+* @returns Promise that resolves with the session verifier when OAuth completes
+* @throws Error if popup is blocked, closed by user, or times out
+*/
+async function openOAuthPopup(url) {
+	const timeout = 12e4;
+	const pollInterval = 500;
+	return new Promise((resolve, reject) => {
+		const popup = globalThis.open(url, "neon_oauth_popup", "width=500,height=700,popup=yes");
+		if (!popup || popup.closed) {
+			reject(/* @__PURE__ */ new Error("Popup blocked. Please allow popups for this site."));
+			return;
+		}
+		const timeoutId = setTimeout(() => {
+			cleanup();
+			try {
+				popup.close();
+			} catch {}
+			reject(/* @__PURE__ */ new Error("OAuth popup timed out. Please try again."));
+		}, timeout);
+		const pollId = setInterval(() => {
+			try {
+				if (popup.closed) {
+					cleanup();
+					reject(/* @__PURE__ */ new Error("OAuth popup was closed. Please try again."));
+				}
+			} catch {}
+		}, pollInterval);
+		function cleanup() {
+			clearTimeout(timeoutId);
+			clearInterval(pollId);
+			globalThis.removeEventListener("message", handleMessage);
+		}
+		function handleMessage(event) {
+			if (event.origin !== globalThis.location.origin) return;
+			if (event.data?.type !== OAUTH_POPUP_MESSAGE_TYPE) return;
+			cleanup();
+			resolve({ verifier: event.data.verifier || null });
+		}
+		globalThis.addEventListener("message", handleMessage);
+	});
+}
+
 //#endregion
 //#region src/utils/browser.ts
 /**
@@ -229,20 +337,91 @@ var SessionCacheManager = class {
 const isBrowser = () => {
 	return globalThis.window !== void 0 && typeof document !== "undefined";
 };
+/**
+* Checks if the code is running inside an iframe
+* Used to detect embedded contexts where OAuth redirect won't work
+* @returns true if in iframe, false otherwise
+*/
+const isIframe = () => {
+	if (!isBrowser()) return false;
+	try {
+		return globalThis.self !== globalThis.top;
+	} catch {
+		return true;
+	}
+};
+
+//#endregion
+//#region src/plugins/anonymous-token.ts
+const ANONYMOUS_TOKEN_ENDPOINT = "/token/anonymous";
+const anonymousTokenResponseSchema = z.object({
+	token: z.string(),
+	expires_at: z.number()
+});
+const anonymousTokenClient = () => {
+	return {
+		id: "anonymous-token",
+		pathMethods: { [ANONYMOUS_TOKEN_ENDPOINT]: "GET" },
+		getActions: ($fetch) => {
+			return { getAnonymousToken: async (fetchOptions) => {
+				return await $fetch(ANONYMOUS_TOKEN_ENDPOINT, {
+					method: "GET",
+					...fetchOptions
+				});
+			} };
+		}
+	};
+};
 
 //#endregion
 //#region src/core/better-auth-methods.ts
 const CURRENT_TAB_CLIENT_ID = crypto.randomUUID();
 const BETTER_AUTH_METHODS_IN_FLIGHT_REQUESTS = new InFlightRequestManager();
 const BETTER_AUTH_METHODS_CACHE = new SessionCacheManager();
+const BETTER_AUTH_ANONYMOUS_TOKEN_CACHE = new AnonymousTokenCacheManager();
 const BETTER_AUTH_ENDPOINTS = {
 	signUp: "/sign-up",
 	signIn: "/sign-in",
 	signOut: "/sign-out",
 	updateUser: "/update-user",
 	getSession: "/get-session",
-	token: "/token"
+	token: "/token",
+	anonymousSignIn: "/sign-in/anonymous",
+	anonymousToken: "/token/anonymous"
 };
+/**
+* Handles social sign-in via popup when running inside an iframe.
+* This is necessary because OAuth redirects don't work in iframes due to
+* X-Frame-Options/CSP restrictions from OAuth providers.
+*
+* Flow:
+* 1. Request OAuth URL from server (with disableRedirect)
+* 2. Open popup window with the OAuth URL
+* 3. Wait for popup to complete and send back the session verifier
+* 4. Navigate to callbackURL with verifier - normal page load handles session
+*/
+async function handleSocialSignInViaPopup(input, init) {
+	const body = JSON.parse(init?.body || "{}");
+	const originalCallbackURL = body.callbackURL || "/";
+	const popupCallbackUrl = new URL(NEON_AUTH_POPUP_CALLBACK_ROUTE, globalThis.location.origin);
+	popupCallbackUrl.searchParams.set(NEON_AUTH_POPUP_PARAM_NAME, "1");
+	popupCallbackUrl.searchParams.set(NEON_AUTH_POPUP_CALLBACK_PARAM_NAME, originalCallbackURL);
+	body.callbackURL = popupCallbackUrl.toString();
+	body.disableRedirect = true;
+	const response = await fetch(input, {
+		...init,
+		body: JSON.stringify(body)
+	});
+	const data = await response.json();
+	const oauthUrl = data.url;
+	if (!oauthUrl) throw new Error("Failed to get OAuth URL");
+	const popupResult = await openOAuthPopup(oauthUrl);
+	if (!popupResult.verifier) throw new Error("OAuth completed but no session verifier received");
+	const navigationUrl = new URL(originalCallbackURL, globalThis.location.origin);
+	navigationUrl.searchParams.set(NEON_AUTH_SESSION_VERIFIER_PARAM_NAME, popupResult.verifier);
+	globalThis.location.href = navigationUrl.toString();
+	return Response.json(data, { status: response.status });
+}
 const BETTER_AUTH_METHODS_HOOKS = {
 	signUp: {
 		onRequest: () => {},
@@ -261,6 +440,10 @@ const BETTER_AUTH_METHODS_HOOKS = {
 		}
 	},
 	signIn: {
+		beforeFetch: (input, init) => {
+			if (!(typeof input === "string" ? input : input.toString()).includes("/sign-in/social") || !isIframe()) return null;
+			return handleSocialSignInViaPopup(input, init);
+		},
 		onRequest: () => {},
 		onSuccess: (responseData) => {
 			if (isSessionResponseData(responseData)) {
@@ -289,17 +472,24 @@ const BETTER_AUTH_METHODS_HOOKS = {
 	updateUser: {
 		onRequest: () => {},
 		onSuccess: (responseData) => {
-			if (isSessionResponseData(responseData)) emitAuthEvent({
-				type: "USER_UPDATE",
-				data: {
+			if (isSessionResponseData(responseData)) {
+				const sessionData = {
 					session: responseData.session,
 					user: responseData.user
-				}
-			});
+				};
+				BETTER_AUTH_METHODS_CACHE.setCachedSession(sessionData);
+				emitAuthEvent({
+					type: "USER_UPDATE",
+					data: sessionData
+				});
+			} else {
+				BETTER_AUTH_METHODS_CACHE.clearSessionCache();
+				emitAuthEvent({ type: "USER_UPDATE" });
+			}
 		}
 	},
 	getSession: {
-		beforeRequest: () => {
+		beforeFetch: () => {
 			const cachedData = BETTER_AUTH_METHODS_CACHE.getCachedSession();
 			if (!cachedData) return null;
 			return Response.json(cachedData, { status: 200 });
@@ -337,6 +527,18 @@ const BETTER_AUTH_METHODS_HOOKS = {
 				}
 			}
 		}
+	},
+	anonymousToken: {
+		beforeFetch: () => {
+			const cachedResponse = BETTER_AUTH_ANONYMOUS_TOKEN_CACHE.getCachedResponse();
+			if (!cachedResponse) return null;
+			return Response.json(cachedResponse, { status: 200 });
+		},
+		onRequest: () => {},
+		onSuccess: (responseData) => {
+			const parsed = anonymousTokenResponseSchema.safeParse(responseData);
+			if (parsed.success) BETTER_AUTH_ANONYMOUS_TOKEN_CACHE.setCachedResponse(parsed.data);
+		}
 	}
 };
 /**
@@ -394,6 +596,8 @@ function isSessionResponseData(responseData) {
 	return Boolean(responseData && typeof responseData === "object" && "session" in responseData && "user" in responseData && responseData.session !== null && responseData.user !== null);
 }
 function deriveBetterAuthMethodFromUrl(url) {
+	if (url.includes("/sign-in/anonymous")) return "anonymousSignIn";
+	if (url.includes(BETTER_AUTH_ENDPOINTS.anonymousToken)) return "anonymousToken";
 	if (url.includes(BETTER_AUTH_ENDPOINTS.signIn)) return "signIn";
 	if (url.includes(BETTER_AUTH_ENDPOINTS.signUp)) return "signUp";
 	if (url.includes(BETTER_AUTH_ENDPOINTS.signOut)) return "signOut";
@@ -401,6 +605,20 @@ function deriveBetterAuthMethodFromUrl(url) {
 	if (url.includes(BETTER_AUTH_ENDPOINTS.getSession) || url.includes(BETTER_AUTH_ENDPOINTS.token)) return "getSession";
 }
 function initBroadcastChannel() {
+	if (isBrowser() && globalThis.opener && globalThis.opener !== globalThis) {
+		const params = new URLSearchParams(globalThis.location.search);
+		if (params.has(NEON_AUTH_POPUP_PARAM_NAME)) {
+			const verifier = params.get(NEON_AUTH_SESSION_VERIFIER_PARAM_NAME);
+			const originalCallback = params.get(NEON_AUTH_POPUP_CALLBACK_PARAM_NAME);
+			globalThis.opener.postMessage({
+				type: OAUTH_POPUP_MESSAGE_TYPE,
+				verifier,
+				originalCallback
+			}, "*");
+			globalThis.close();
+			return;
+		}
+	}
 	getGlobalBroadcastChannel().subscribe((message) => {
 		if (message.clientId === CURRENT_TAB_CLIENT_ID) return;
 		const trigger = message.data?.trigger;
@@ -408,6 +626,96 @@ function initBroadcastChannel() {
 	});
 }
 
+//#endregion
+//#region package.json
+var name = "@neondatabase/auth";
+var version = "0.1.0-beta.21";
+
+//#endregion
+//#region ../internal/dist/index.mjs
+const X_NEON_CLIENT_INFO_HEADER = "X-Neon-Client-Info";
+/**
+* Type guard for checking if a property exists on globalThis
+*/
+function hasGlobalProperty(key) {
+	return key in globalThis;
+}
+/**
+* Detects the JavaScript framework being used at runtime.
+* Detection order matters to avoid false positives (e.g., Next.js includes React).
+*/
+function detectFramework() {
+	if (typeof process !== "undefined" && process.env && (process.env.NEXT_RUNTIME || process.env.__NEXT_PRIVATE_ORIGIN)) return "next";
+	if (typeof globalThis.window !== "undefined") {
+		if (hasGlobalProperty("__NEXT_DATA__")) return "next";
+		if (hasGlobalProperty("__remixContext")) return "remix";
+		if (hasGlobalProperty("__REACT_DEVTOOLS_GLOBAL_HOOK__")) return "react";
+		if (hasGlobalProperty("__VUE__")) return "vue";
+		if (hasGlobalProperty("Zone")) return "angular";
+	}
+}
+function getClientInfo(sdkName, sdkVersion) {
+	const base = {
+		sdk: sdkName,
+		version: sdkVersion,
+		runtime: "unknown",
+		runtimeVersion: "unknown",
+		platform: "unknown",
+		arch: "unknown"
+	};
+	let result;
+	if (typeof process !== "undefined" && process.versions?.node) result = {
+		...base,
+		runtime: "node",
+		runtimeVersion: process.versions.node,
+		platform: process.platform,
+		arch: process.arch
+	};
+	else if (typeof Deno !== "undefined") result = {
+		...base,
+		runtime: "deno",
+		runtimeVersion: Deno.version?.deno ?? "unknown",
+		platform: Deno.build?.os ?? "unknown",
+		arch: Deno.build?.arch ?? "unknown"
+	};
+	else if (typeof Bun !== "undefined") result = {
+		...base,
+		runtime: "bun",
+		runtimeVersion: Bun.version ?? "unknown",
+		platform: process?.platform ?? "unknown",
+		arch: process?.arch ?? "unknown"
+	};
+	else if (typeof EdgeRuntime !== "undefined" || typeof process !== "undefined" && !process.versions?.node && typeof globalThis.window === "undefined" && typeof document === "undefined") result = {
+		...base,
+		runtime: "edge"
+	};
+	else if (globalThis.window !== void 0 && typeof document !== "undefined") result = {
+		...base,
+		runtime: "browser",
+		runtimeVersion: "unknown",
+		platform: "web",
+		arch: "unknown"
+	};
+	else result = base;
+	const framework = detectFramework();
+	if (framework) result.framework = framework;
+	return result;
+}
+function createClientInfoInjector(defaultSdkName, defaultSdkVersion) {
+	const cachedClientInfo = JSON.stringify(getClientInfo(defaultSdkName, defaultSdkVersion));
+	return function injectClientInfo$1(headers, sdkOverride) {
+		const result = new Headers(headers);
+		if (result.has(X_NEON_CLIENT_INFO_HEADER)) return result;
+		const clientInfoString = sdkOverride ? JSON.stringify(getClientInfo(sdkOverride.name, sdkOverride.version)) : cachedClientInfo;
+		result.set(X_NEON_CLIENT_INFO_HEADER, clientInfoString);
+		return result;
+	};
+}
+
+//#endregion
+//#region src/utils/client-info.ts
+const injectClientInfo = createClientInfoInjector(name, version);
+
 //#endregion
 //#region src/core/adapter-core.ts
 const FORCE_FETCH_HEADER = "X-Force-Fetch";
@@ -416,7 +724,7 @@ const supportedBetterAuthClientPlugins = [
 	adminClient(),
 	organizationClient(),
 	emailOTPClient(),
-	anonymousClient()
+	anonymousTokenClient()
 ];
 var NeonAuthAdapterCore = class {
 	betterAuthOptions;
@@ -440,9 +748,9 @@ var NeonAuthAdapterCore = class {
 					userOnRequest?.(request);
 				},
 				customFetchImpl: async (url, init) => {
-					if (init?.headers && FORCE_FETCH_HEADER in init.headers) {
-						const headers = { ...init.headers };
-						delete headers[FORCE_FETCH_HEADER];
+					const headers = injectClientInfo(init?.headers);
+					if (headers.has(FORCE_FETCH_HEADER)) {
+						headers.delete(FORCE_FETCH_HEADER);
 						const response$1 = await fetch(url, {
 							...init,
 							headers
@@ -458,11 +766,14 @@ var NeonAuthAdapterCore = class {
 					}
 					const betterAuthMethod = deriveBetterAuthMethodFromUrl(url.toString());
 					if (betterAuthMethod) {
-						const response$1 = await BETTER_AUTH_METHODS_HOOKS[betterAuthMethod].beforeRequest?.(url, init);
+						const response$1 = await BETTER_AUTH_METHODS_HOOKS[betterAuthMethod].beforeFetch?.(url, init);
 						if (response$1) return response$1;
 					}
 					const key = `${init?.method || "GET"}:${url}:${init?.body || ""}`;
-					const response = await BETTER_AUTH_METHODS_IN_FLIGHT_REQUESTS.deduplicate(key, () => fetch(url, init));
+					const response = await BETTER_AUTH_METHODS_IN_FLIGHT_REQUESTS.deduplicate(key, () => fetch(url, {
+						...init,
+						headers
+					}));
 					if (!response.ok) {
 						const errorBody = await response.clone().json().catch(() => ({}));
 						const err = new Error(errorBody.message || `HTTP ${response.status} ${response.statusText}`);
@@ -486,7 +797,21 @@ var NeonAuthAdapterCore = class {
 		};
 		initBroadcastChannel();
 	}
+	/**
+	* Get JWT token for authenticated or anonymous access.
+	* Single source of truth for token retrieval logic.
+	*
+	* @param allowAnonymous - When true, fetches anonymous token if no session exists
+	* @returns JWT token string or null if unavailable
+	*/
+	async getJWTToken(allowAnonymous) {
+		const client = this.getBetterAuthInstance();
+		const session = await client.getSession();
+		if (session.data?.session?.token) return session.data.session.token;
+		if (allowAnonymous) return (await client.getAnonymousToken()).data?.token ?? null;
+		return null;
+	}
 };
 
 //#endregion
-export { DEFAULT_SESSION_EXPIRY_MS as a, CURRENT_TAB_CLIENT_ID as i, BETTER_AUTH_METHODS_CACHE as n, BETTER_AUTH_METHODS_HOOKS as r, NeonAuthAdapterCore as t };
+export { CURRENT_TAB_CLIENT_ID as i, BETTER_AUTH_METHODS_CACHE as n, BETTER_AUTH_METHODS_HOOKS as r, NeonAuthAdapterCore as t };