@better-auth/expo 1.7.3 → 1.7.5

package/dist/client.d.ts

@@ -5,6 +5,35 @@ import * as _$_better_fetch_fetch0 from "@better-fetch/fetch";
 import { ClientFetchOption, ClientStore } from "@better-auth/core";
 import * as SecureStore from "expo-secure-store";
 
+//#region src/client-storage.d.ts
+/**
+ * Storage used by the Expo client for cookies and cached session data.
+ * Async access is coordinated through the provided object, so reuse it across
+ * clients that access the same stored data.
+ */
+type ExpoClientStorage = Pick<typeof SecureStore, "setItem" | "setItemAsync" | "getItem" | "getItemAsync">;
+/**
+ * Expo secure store does not support colons in the keys.
+ * This function replaces colons with underscores.
+ *
+ * @see https://github.com/better-auth/better-auth/issues/5426
+ *
+ * @param name cookie name to be saved in the storage
+ * @returns normalized cookie name
+ */
+declare function normalizeCookieName(name: string): string;
+interface ExpoStorageAdapter {
+  getItem(name: string): string | null;
+  getItemAsync(name: string): Promise<string | null>;
+  setItem(name: string, value: string): void;
+  setItemAsync(name: string, value: string): Promise<void>;
+}
+/**
+ * Wraps Expo storage with chunking, recoverable writes, and serialized async
+ * access.
+ */
+declare function storageAdapter(storage: ExpoClientStorage): ExpoStorageAdapter;
+//#endregion
 //#region src/focus-manager.d.ts
 declare function setupExpoFocusManager(): FocusManager;
 //#endregion
@@ -12,12 +41,6 @@ declare function setupExpoFocusManager(): FocusManager;
 declare function setupExpoOnlineManager(): OnlineManager;
 //#endregion
 //#region src/client.d.ts
-/**
- * Storage used by the Expo client for cookies and cached session data.
- * Write coordination is scoped to the provided object, so reuse it across
- * clients that access the same stored data.
- */
-type ExpoClientStorage = Pick<typeof SecureStore, "setItem" | "setItemAsync" | "getItem" | "getItemAsync">;
 interface ExpoClientOptions {
   scheme?: string | undefined;
   storage: ExpoClientStorage;
@@ -76,27 +99,6 @@ declare function getCookie(cookie: string | null): string;
  * @returns true if the header contains better-auth cookies, false otherwise
  */
 declare function hasBetterAuthCookies(setCookieHeader: string, cookiePrefix: string | string[]): boolean;
-/**
- * Expo secure store does not support colons in the keys.
- * This function replaces colons with underscores.
- *
- * @see https://github.com/better-auth/better-auth/issues/5426
- *
- * @param name cookie name to be saved in the storage
- * @returns normalized cookie name
- */
-declare function normalizeCookieName(name: string): string;
-interface ExpoStorageAdapter {
-  getItem(name: string): string | null;
-  getItemAsync(name: string): Promise<string | null>;
-  setItem(name: string, value: string): void;
-  setItemAsync(name: string, value: string): Promise<void>;
-}
-/**
- * Wraps Expo storage with chunking, recoverable writes, and serialized async
- * updates.
- */
-declare function storageAdapter(storage: ExpoClientStorage): ExpoStorageAdapter;
 declare const expoClient: (opts: ExpoClientOptions) => {
   id: "expo";
   version: string;
@@ -123,7 +125,6 @@ declare const expoClient: (opts: ExpoClientOptions) => {
       onSuccess(context: _$_better_fetch_fetch0.SuccessContext<any>): Promise<void>;
     };
     init(url: string, options: ({
-      priority?: RequestPriority | undefined;
       method?: string | undefined;
       redirect?: RequestRedirect | undefined;
       window?: null | undefined;
@@ -132,9 +133,11 @@ declare const expoClient: (opts: ExpoClientOptions) => {
       integrity?: string | undefined;
       keepalive?: boolean | undefined;
       mode?: RequestMode | undefined;
+      priority?: RequestPriority | undefined;
       referrer?: string | undefined;
       referrerPolicy?: ReferrerPolicy | undefined;
       signal?: (AbortSignal | null) | undefined;
+    } & {
       onRequest?: (<T extends Record<string, any>>(context: _$_better_fetch_fetch0.RequestContext<T>) => Promise<_$_better_fetch_fetch0.RequestContext | void> | _$_better_fetch_fetch0.RequestContext | void) | undefined;
       onResponse?: ((context: _$_better_fetch_fetch0.ResponseContext) => Promise<Response | void | _$_better_fetch_fetch0.ResponseContext> | Response | _$_better_fetch_fetch0.ResponseContext | void) | undefined;
       onSuccess?: ((context: _$_better_fetch_fetch0.SuccessContext<any>) => Promise<void> | void) | undefined;
@@ -173,9 +176,11 @@ declare const expoClient: (opts: ExpoClientOptions) => {
       jsonParser?: ((text: string) => Promise<any> | any) | undefined;
       retry?: _$_better_fetch_fetch0.RetryOptions | undefined;
       retryAttempt?: number | undefined;
+      method?: ("POST" | "PUT" | "DELETE" | "PATCH" | "GET" | "HEAD" | "OPTIONS" | (string & {})) | undefined;
       output?: (_$_better_fetch_fetch0.StandardSchemaV1 | typeof Blob | typeof File) | undefined;
       errorSchema?: _$_better_fetch_fetch0.StandardSchemaV1 | undefined;
       disableValidation?: boolean | undefined;
+      signal?: (AbortSignal | null) | undefined;
     } & Record<string, any>) | undefined): Promise<{
       url: string;
       options: ClientFetchOption;
@@ -183,4 +188,4 @@ declare const expoClient: (opts: ExpoClientOptions) => {
   }[];
 };
 //#endregion
-export { ExpoClientStorage, expoClient, getCookie, getSetCookie, hasBetterAuthCookies, normalizeCookieName, parseSetCookieHeader, setupExpoFocusManager, setupExpoOnlineManager, storageAdapter };
+export { type ExpoClientStorage, expoClient, getCookie, getSetCookie, hasBetterAuthCookies, normalizeCookieName, parseSetCookieHeader, setupExpoFocusManager, setupExpoOnlineManager, storageAdapter };

package/dist/client.js

@@ -1,9 +1,10 @@
-import { t as PACKAGE_VERSION } from "./version-DddGjO8z.js";
+import { t as PACKAGE_VERSION } from "./version-Db7MRDhd.js";
 import { safeJSONParse } from "@better-auth/core/utils/json";
 import { SECURE_COOKIE_PREFIX, parseSetCookieHeader, parseSetCookieHeader as parseSetCookieHeader$1, stripSecureCookiePrefix } from "better-auth/cookies/utils";
 import Constants from "expo-constants";
 import * as Linking from "expo-linking";
 import { AppState, Platform } from "react-native";
+import { logger } from "@better-auth/core/env";
 import { kFocusManager, kOnlineManager } from "better-auth/client";
 //#region \0rolldown/runtime.js
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
@@ -11,178 +12,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
 });
 //#endregion
-//#region src/focus-manager.ts
-var ExpoFocusManager = class {
-	listeners = /* @__PURE__ */ new Set();
-	subscription;
-	isFocused;
-	subscribe(listener) {
-		this.listeners.add(listener);
-		return () => {
-			this.listeners.delete(listener);
-		};
-	}
-	setFocused(focused) {
-		if (this.isFocused === focused) return;
-		this.isFocused = focused;
-		this.listeners.forEach((listener) => listener(focused));
-	}
-	setup() {
-		this.subscription = AppState.addEventListener("change", (state) => {
-			this.setFocused(state === "active");
-		});
-		return () => {
-			this.subscription?.remove();
-		};
-	}
-};
-function setupExpoFocusManager() {
-	if (!globalThis[kFocusManager]) globalThis[kFocusManager] = new ExpoFocusManager();
-	return globalThis[kFocusManager];
-}
-//#endregion
-//#region src/online-manager.ts
-var ExpoOnlineManager = class {
-	listeners = /* @__PURE__ */ new Set();
-	isOnline = true;
-	unsubscribe;
-	subscribe(listener) {
-		this.listeners.add(listener);
-		return () => {
-			this.listeners.delete(listener);
-		};
-	}
-	setOnline(online) {
-		if (this.isOnline === online) return;
-		this.isOnline = online;
-		this.listeners.forEach((listener) => listener(online));
-	}
-	setup() {
-		import("expo-network").then(({ addNetworkStateListener }) => {
-			const subscription = addNetworkStateListener((state) => {
-				this.setOnline(!!state.isInternetReachable);
-			});
-			this.unsubscribe = () => subscription.remove();
-		}).catch(() => {
-			this.setOnline(true);
-		});
-		return () => {
-			this.unsubscribe?.();
-		};
-	}
-};
-function setupExpoOnlineManager() {
-	if (!globalThis[kOnlineManager]) globalThis[kOnlineManager] = new ExpoOnlineManager();
-	return globalThis[kOnlineManager];
-}
-//#endregion
-//#region src/client.ts
-if (Platform.OS !== "web") {
-	setupExpoFocusManager();
-	setupExpoOnlineManager();
-}
-function defineExpoClientPlugin(plugin) {
-	return plugin;
-}
-function getSetCookie(header, prevCookie) {
-	const parsed = parseSetCookieHeader$1(header);
-	const toSetCookie = safeJSONParse(prevCookie) ?? {};
-	parsed.forEach((cookie, key) => {
-		const expiresAt = cookie["expires"];
-		const maxAge = cookie["max-age"];
-		if (maxAge !== void 0 && Number(maxAge) <= 0) {
-			delete toSetCookie[key];
-			return;
-		}
-		const expires = maxAge ? new Date(Date.now() + Number(maxAge) * 1e3) : expiresAt ? new Date(String(expiresAt)) : null;
-		if (expires && expires.getTime() <= Date.now()) {
-			delete toSetCookie[key];
-			return;
-		}
-		toSetCookie[key] = {
-			value: cookie["value"],
-			expires: expires ? expires.toISOString() : null
-		};
-	});
-	return JSON.stringify(toSetCookie);
-}
-function getCookie(cookie) {
-	const parsed = safeJSONParse(cookie) ?? {};
-	return Object.entries(parsed).reduce((acc, [key, value]) => {
-		if (value.expires && new Date(value.expires) < /* @__PURE__ */ new Date()) return acc;
-		return acc ? `${acc}; ${key}=${value.value}` : `${key}=${value.value}`;
-	}, "");
-}
-function getOAuthStateValue(cookieJson, cookiePrefix) {
-	if (!cookieJson) return null;
-	const parsed = safeJSONParse(cookieJson);
-	if (!parsed) return null;
-	const prefixes = Array.isArray(cookiePrefix) ? cookiePrefix : [cookiePrefix];
-	for (const prefix of prefixes) {
-		const candidates = [`${SECURE_COOKIE_PREFIX}${prefix}.oauth_state`, `${prefix}.oauth_state`];
-		for (const name of candidates) {
-			const value = parsed?.[name]?.value;
-			if (value) return value;
-		}
-	}
-	return null;
-}
-function getOrigin(scheme) {
-	return Linking.createURL("", { scheme });
-}
-/**
-* Compare if session cookies have actually changed by comparing their values.
-* Ignores expiry timestamps that naturally change on each request.
-*
-* @param prevCookie - Previous cookie JSON string
-* @param newCookie - New cookie JSON string
-* @returns true if session cookies have changed, false otherwise
-*/
-function hasSessionCookieChanged(prevCookie, newCookie) {
-	if (!prevCookie) return true;
-	try {
-		const prev = JSON.parse(prevCookie);
-		const next = JSON.parse(newCookie);
-		const sessionKeys = /* @__PURE__ */ new Set();
-		Object.keys(prev).forEach((key) => {
-			if (key.includes("session_token") || key.includes("session_data")) sessionKeys.add(key);
-		});
-		Object.keys(next).forEach((key) => {
-			if (key.includes("session_token") || key.includes("session_data")) sessionKeys.add(key);
-		});
-		for (const key of sessionKeys) if (prev[key]?.value !== next[key]?.value) return true;
-		return false;
-	} catch {
-		return true;
-	}
-}
-/**
-* Check if the Set-Cookie header contains better-auth cookies.
-* This prevents infinite refetching when non-better-auth cookies (like third-party cookies) change.
-*
-* Supports multiple cookie naming patterns:
-* - Default: "better-auth.session_token", "better-auth-passkey", "__Secure-better-auth.session_token"
-* - Custom prefix: "myapp.session_token", "myapp-passkey", "__Secure-myapp.session_token"
-* - Custom full names: "my_custom_session_token", "custom_session_data"
-* - No prefix (cookiePrefix=""): matches any cookie with known suffixes
-* - Multiple prefixes: ["better-auth", "my-app"] matches cookies starting with any of the prefixes
-*
-* @param setCookieHeader - The Set-Cookie header value
-* @param cookiePrefix - The cookie prefix(es) to check for. Can be a string, array of strings, or empty string.
-* @returns true if the header contains better-auth cookies, false otherwise
-*/
-function hasBetterAuthCookies(setCookieHeader, cookiePrefix) {
-	const cookies = parseSetCookieHeader$1(setCookieHeader);
-	const cookieSuffixes = ["session_token", "session_data"];
-	const prefixes = Array.isArray(cookiePrefix) ? cookiePrefix : [cookiePrefix];
-	for (const name of cookies.keys()) {
-		const nameWithoutSecure = stripSecureCookiePrefix(name);
-		for (const prefix of prefixes) if (prefix) {
-			if (nameWithoutSecure.startsWith(prefix)) return true;
-		} else for (const suffix of cookieSuffixes) if (nameWithoutSecure.endsWith(suffix)) return true;
-	}
-	return false;
-}
+//#region src/client-storage.ts
 /**
 * Expo secure store does not support colons in the keys.
 * This function replaces colons with underscores.
@@ -196,15 +26,38 @@ function normalizeCookieName(name) {
 	return name.replace(/:/g, "_");
 }
 /**
-* Max characters written per `setItem`. Native secure stores silently reject
-* oversized writes (iOS Keychain refuses values above ~2KB), losing the cookie,
-* so a larger value is split across keys here. Mirrors the server's
-* `chunkCookie`/`joinChunks` in `session-store.ts`; keep the two in sync.
+* UTF-8 byte budget per stored chunk. Some native stores reject large values,
+* so larger strings are split across keys.
 *
 * @see https://github.com/better-auth/better-auth/issues/9151
 */
 const STORAGE_VALUE_LIMIT = 1800;
 const MAX_STORAGE_CHUNKS = 100;
+function getUtf8ByteLength(character) {
+	const codePoint = character.codePointAt(0) ?? 0;
+	if (codePoint <= 127) return 1;
+	if (codePoint <= 2047) return 2;
+	if (codePoint <= 65535) return 3;
+	return 4;
+}
+function splitStorageValue(value) {
+	const chunks = [];
+	let start = 0;
+	let end = 0;
+	let bytes = 0;
+	for (const character of value) {
+		const characterBytes = getUtf8ByteLength(character);
+		if (bytes + characterBytes > STORAGE_VALUE_LIMIT) {
+			chunks.push(value.slice(start, end));
+			start = end;
+			bytes = 0;
+		}
+		bytes += characterBytes;
+		end += character.length;
+	}
+	chunks.push(value.slice(start));
+	return chunks;
+}
 /**
 * Marks a base key whose value is split across multiple storage keys. Legacy
 * markers contain only the chunk count. Current markers also identify the
@@ -213,6 +66,11 @@ const MAX_STORAGE_CHUNKS = 100;
 * @see https://github.com/better-auth/better-auth/issues/11082
 */
 const CHUNK_MARKER = "
ba-chunks:";
+const CHUNK_SLOTS = [
+	null,
+	0,
+	1
+];
 function parseChunkCount(value) {
 	if (value === void 0) return null;
 	const count = Number(value);
@@ -254,7 +112,7 @@ function readChunks(storage, key, marker) {
 	let value = "";
 	for (let i = 0; i < marker.count; i++) {
 		const chunk = storage.getItem(getChunkKey(key, marker, i));
-		if (chunk == null) return null;
+		if (!chunk) return null;
 		value += chunk;
 	}
 	return value;
@@ -263,7 +121,7 @@ async function readChunksAsync(storage, key, marker) {
 	let value = "";
 	for (let i = 0; i < marker.count; i++) {
 		const chunk = await storage.getItemAsync(getChunkKey(key, marker, i));
-		if (chunk == null) return null;
+		if (!chunk) return null;
 		value += chunk;
 	}
 	return value;
@@ -292,11 +150,15 @@ async function readStoredValueAsync(storage, key, baseValue) {
 		fallbackCount: null
 	});
 }
-function getStorageWrites(key, value, currentBaseValue) {
-	if (value.length <= STORAGE_VALUE_LIMIT) return [[key, value]];
-	const count = Math.ceil(value.length / STORAGE_VALUE_LIMIT);
-	if (count > MAX_STORAGE_CHUNKS) throw new Error(`Storage value requires ${count} chunks, exceeding the limit of ${MAX_STORAGE_CHUNKS}`);
+function getStorageWritePlan(key, value, currentBaseValue) {
 	const currentMarker = currentBaseValue?.startsWith(CHUNK_MARKER) ? parseChunkMarker(currentBaseValue) : null;
+	const chunks = splitStorageValue(value);
+	if (chunks.length === 1) return {
+		writes: [[key, value]],
+		cleanup: getUnusedChunkRanges(key, currentMarker, null)
+	};
+	const count = chunks.length;
+	if (count > MAX_STORAGE_CHUNKS) throw new Error(`Storage value requires ${count} chunks, exceeding the limit of ${MAX_STORAGE_CHUNKS}`);
 	const marker = {
 		count,
 		slot: currentMarker?.slot === 0 ? 1 : 0,
@@ -307,82 +169,190 @@ function getStorageWrites(key, value, currentBaseValue) {
 		...currentMarker,
 		fallbackCount: null
 	})]);
-	for (let i = 0; i < count; i++) {
-		const start = i * STORAGE_VALUE_LIMIT;
-		writes.push([getChunkKey(key, marker, i), value.slice(start, start + STORAGE_VALUE_LIMIT)]);
-	}
+	for (const [index, chunk] of chunks.entries()) writes.push([getChunkKey(key, marker, index), chunk]);
 	writes.push([key, serializeChunkMarker(marker)]);
-	return writes;
-}
-function createKeyedWriteQueue() {
-	const tails = /* @__PURE__ */ new Map();
 	return {
-		pending(key) {
-			return tails.has(key);
-		},
-		enqueue(key, operation) {
-			const queued = (tails.get(key) ?? Promise.resolve()).then(operation, operation);
-			tails.set(key, queued);
-			const cleanup = () => {
-				if (tails.get(key) === queued) tails.delete(key);
-			};
-			queued.then(cleanup, cleanup);
-			return queued;
-		}
+		writes,
+		cleanup: getUnusedChunkRanges(key, currentMarker, marker)
+	};
+}
+function getSlotChunkCount(marker, slot) {
+	if (!marker) return 0;
+	if (marker.slot === slot) return marker.count;
+	if (marker.slot === null || slot === null) return 0;
+	return marker.fallbackCount ?? 0;
+}
+function getUnusedChunkRanges(key, previousMarker, marker) {
+	return CHUNK_SLOTS.map((slot) => ({
+		prefix: slot === null ? key : `${key}.${slot}`,
+		start: getSlotChunkCount(marker, slot),
+		end: getSlotChunkCount(previousMarker, slot)
+	}));
+}
+const storageStates = /* @__PURE__ */ new WeakMap();
+function getStorageState(storage, key) {
+	let states = storageStates.get(storage);
+	if (!states) {
+		states = /* @__PURE__ */ new Map();
+		storageStates.set(storage, states);
+	}
+	let state = states.get(key);
+	if (!state) {
+		state = {
+			pending: null,
+			pendingWrites: 0,
+			activeRead: null,
+			cleanupComplete: false
+		};
+		states.set(key, state);
+	}
+	return state;
+}
+function enqueueStorageOperation(state, operation) {
+	const queued = (state.pending ?? Promise.resolve()).then(operation, operation);
+	state.pending = queued;
+	const cleanup = () => {
+		if (state.pending === queued) state.pending = null;
 	};
+	queued.then(cleanup, cleanup);
+	return queued;
 }
-const storageWriteQueues = /* @__PURE__ */ new WeakMap();
-function getStorageWriteQueue(storage) {
-	const existing = storageWriteQueues.get(storage);
-	if (existing) return existing;
-	const queue = createKeyedWriteQueue();
-	storageWriteQueues.set(storage, queue);
-	return queue;
+function enqueueStorageWrite(state, operation) {
+	state.pendingWrites++;
+	return enqueueStorageOperation(state, async () => {
+		try {
+			return await operation();
+		} finally {
+			state.pendingWrites--;
+		}
+	});
 }
+/** @internal */
 function createManagedStorage(storage) {
-	const writeQueue = getStorageWriteQueue(storage);
 	const logWriteError = (key, error) => {
-		console.error(`[better-auth/expo] failed to persist "${key}" to storage`, error);
+		logger.error(`[better-auth/expo] failed to persist "${key}" to storage`, error);
+	};
+	const logCleanupError = (key, error) => {
+		logger.error(`[better-auth/expo] failed to clear unused chunks for "${key}"`, error);
 	};
 	const getItem = (name) => {
 		const key = normalizeCookieName(name);
 		return readStoredValue(storage, key, storage.getItem(key));
 	};
-	const getItemAsync = async (name) => {
+	const getItemAsync = (name) => {
 		const key = normalizeCookieName(name);
-		return readStoredValueAsync(storage, key, await storage.getItemAsync(key));
+		const state = getStorageState(storage, key);
+		return enqueueStorageOperation(state, async () => {
+			const read = { snapshot: null };
+			state.activeRead = read;
+			try {
+				const value = await readStoredValueAsync(storage, key, await storage.getItemAsync(key));
+				return read.snapshot ? read.snapshot.value : value;
+			} finally {
+				state.activeRead = null;
+			}
+		});
 	};
 	const writeItem = (key, value, currentBaseValue) => {
-		for (const [writeKey, writeValue] of getStorageWrites(key, value, currentBaseValue)) storage.setItem(writeKey, writeValue);
+		const state = getStorageState(storage, key);
+		const { writes, cleanup } = getStorageWritePlan(key, value, currentBaseValue);
+		for (const [writeKey, writeValue] of writes) storage.setItem(writeKey, writeValue);
+		try {
+			const scanContiguousOrphans = !state.cleanupComplete;
+			for (const { prefix, start, end } of cleanup) {
+				if (scanContiguousOrphans) {
+					const orphanStart = Math.max(start, end);
+					let orphanEnd = orphanStart;
+					for (; orphanEnd < MAX_STORAGE_CHUNKS; orphanEnd++) if (!storage.getItem(`${prefix}.${orphanEnd}`)) break;
+					for (let i = orphanEnd - 1; i >= orphanStart; i--) storage.setItem(`${prefix}.${i}`, "");
+				}
+				for (let i = end - 1; i >= start; i--) storage.setItem(`${prefix}.${i}`, "");
+			}
+			state.cleanupComplete = true;
+		} catch (error) {
+			state.cleanupComplete = false;
+			logCleanupError(key, error);
+		}
 	};
 	const writeItemAsync = async (key, value, currentBaseValue) => {
-		for (const [writeKey, writeValue] of getStorageWrites(key, value, currentBaseValue)) await storage.setItemAsync(writeKey, writeValue);
+		const state = getStorageState(storage, key);
+		const { writes, cleanup } = getStorageWritePlan(key, value, currentBaseValue);
+		for (const [writeKey, writeValue] of writes) await storage.setItemAsync(writeKey, writeValue);
+		try {
+			const scanContiguousOrphans = !state.cleanupComplete;
+			for (const { prefix, start, end } of cleanup) {
+				if (scanContiguousOrphans) {
+					const orphanStart = Math.max(start, end);
+					let orphanEnd = orphanStart;
+					for (; orphanEnd < MAX_STORAGE_CHUNKS; orphanEnd++) if (!await storage.getItemAsync(`${prefix}.${orphanEnd}`)) break;
+					for (let i = orphanEnd - 1; i >= orphanStart; i--) await storage.setItemAsync(`${prefix}.${i}`, "");
+				}
+				for (let i = end - 1; i >= start; i--) await storage.setItemAsync(`${prefix}.${i}`, "");
+			}
+			state.cleanupComplete = true;
+		} catch (error) {
+			state.cleanupComplete = false;
+			logCleanupError(key, error);
+		}
 	};
 	const setItem = (name, value) => {
 		const key = normalizeCookieName(name);
-		if (writeQueue.pending(key)) {
+		const state = getStorageState(storage, key);
+		if (state.pendingWrites > 0) {
 			logWriteError(key, /* @__PURE__ */ new Error("Cannot write synchronously while an async write is pending"));
 			return;
 		}
+		let currentBaseValue = null;
 		try {
-			writeItem(key, value, value.length > STORAGE_VALUE_LIMIT ? storage.getItem(key) : null);
+			currentBaseValue = storage.getItem(key);
 		} catch (error) {
+			state.cleanupComplete = false;
+			if (splitStorageValue(value).length > 1) {
+				logWriteError(key, error);
+				return;
+			}
+		}
+		const read = state.activeRead;
+		if (read && read.snapshot === null) try {
+			read.snapshot = { value: readStoredValue(storage, key, currentBaseValue) };
+		} catch {
+			read.snapshot = { value: null };
+		}
+		try {
+			writeItem(key, value, currentBaseValue);
+		} catch (error) {
+			state.cleanupComplete = false;
 			logWriteError(key, error);
+			return;
 		}
+		if (read) read.snapshot = { value };
 	};
 	const setItemAsync = (name, value) => {
 		const key = normalizeCookieName(name);
-		return writeQueue.enqueue(key, async () => {
+		const state = getStorageState(storage, key);
+		return enqueueStorageWrite(state, async () => {
+			let currentBaseValue = null;
+			try {
+				currentBaseValue = await storage.getItemAsync(key);
+			} catch (error) {
+				state.cleanupComplete = false;
+				if (splitStorageValue(value).length > 1) {
+					logWriteError(key, error);
+					return;
+				}
+			}
 			try {
-				await writeItemAsync(key, value, value.length > STORAGE_VALUE_LIMIT ? await storage.getItemAsync(key) : null);
+				await writeItemAsync(key, value, currentBaseValue);
 			} catch (error) {
+				state.cleanupComplete = false;
 				logWriteError(key, error);
 			}
 		});
 	};
 	const updateItemAsync = (name, update) => {
 		const key = normalizeCookieName(name);
-		return writeQueue.enqueue(key, async () => {
+		const state = getStorageState(storage, key);
+		return enqueueStorageWrite(state, async () => {
 			try {
 				const currentBaseValue = await storage.getItemAsync(key);
 				const previousValue = await readStoredValueAsync(storage, key, currentBaseValue);
@@ -393,6 +363,7 @@ function createManagedStorage(storage) {
 					value
 				};
 			} catch (error) {
+				state.cleanupComplete = false;
 				logWriteError(key, error);
 				return null;
 			}
@@ -408,7 +379,7 @@ function createManagedStorage(storage) {
 }
 /**
 * Wraps Expo storage with chunking, recoverable writes, and serialized async
-* updates.
+* access.
 */
 function storageAdapter(storage) {
 	const managedStorage = createManagedStorage(storage);
@@ -419,6 +390,179 @@ function storageAdapter(storage) {
 		setItemAsync: managedStorage.setItemAsync
 	};
 }
+//#endregion
+//#region src/focus-manager.ts
+var ExpoFocusManager = class {
+	listeners = /* @__PURE__ */ new Set();
+	subscription;
+	isFocused;
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	setFocused(focused) {
+		if (this.isFocused === focused) return;
+		this.isFocused = focused;
+		this.listeners.forEach((listener) => listener(focused));
+	}
+	setup() {
+		this.subscription = AppState.addEventListener("change", (state) => {
+			this.setFocused(state === "active");
+		});
+		return () => {
+			this.subscription?.remove();
+		};
+	}
+};
+function setupExpoFocusManager() {
+	if (!globalThis[kFocusManager]) globalThis[kFocusManager] = new ExpoFocusManager();
+	return globalThis[kFocusManager];
+}
+//#endregion
+//#region src/online-manager.ts
+var ExpoOnlineManager = class {
+	listeners = /* @__PURE__ */ new Set();
+	isOnline = true;
+	unsubscribe;
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	setOnline(online) {
+		if (this.isOnline === online) return;
+		this.isOnline = online;
+		this.listeners.forEach((listener) => listener(online));
+	}
+	setup() {
+		import("expo-network").then(({ addNetworkStateListener }) => {
+			const subscription = addNetworkStateListener((state) => {
+				this.setOnline(!!state.isInternetReachable);
+			});
+			this.unsubscribe = () => subscription.remove();
+		}).catch(() => {
+			this.setOnline(true);
+		});
+		return () => {
+			this.unsubscribe?.();
+		};
+	}
+};
+function setupExpoOnlineManager() {
+	if (!globalThis[kOnlineManager]) globalThis[kOnlineManager] = new ExpoOnlineManager();
+	return globalThis[kOnlineManager];
+}
+//#endregion
+//#region src/client.ts
+if (Platform.OS !== "web") {
+	setupExpoFocusManager();
+	setupExpoOnlineManager();
+}
+function defineExpoClientPlugin(plugin) {
+	return plugin;
+}
+function getSetCookie(header, prevCookie) {
+	const parsed = parseSetCookieHeader$1(header);
+	const toSetCookie = safeJSONParse(prevCookie) ?? {};
+	parsed.forEach((cookie, key) => {
+		const expiresAt = cookie["expires"];
+		const maxAge = cookie["max-age"];
+		if (maxAge !== void 0 && Number(maxAge) <= 0) {
+			delete toSetCookie[key];
+			return;
+		}
+		const expires = maxAge ? new Date(Date.now() + Number(maxAge) * 1e3) : expiresAt ? new Date(String(expiresAt)) : null;
+		if (expires && expires.getTime() <= Date.now()) {
+			delete toSetCookie[key];
+			return;
+		}
+		toSetCookie[key] = {
+			value: cookie["value"],
+			expires: expires ? expires.toISOString() : null
+		};
+	});
+	return JSON.stringify(toSetCookie);
+}
+function getCookie(cookie) {
+	const parsed = safeJSONParse(cookie) ?? {};
+	return Object.entries(parsed).reduce((acc, [key, value]) => {
+		if (value.expires && new Date(value.expires) < /* @__PURE__ */ new Date()) return acc;
+		return acc ? `${acc}; ${key}=${value.value}` : `${key}=${value.value}`;
+	}, "");
+}
+function getOAuthStateValue(cookieJson, cookiePrefix) {
+	if (!cookieJson) return null;
+	const parsed = safeJSONParse(cookieJson);
+	if (!parsed) return null;
+	const prefixes = Array.isArray(cookiePrefix) ? cookiePrefix : [cookiePrefix];
+	for (const prefix of prefixes) {
+		const candidates = [`${SECURE_COOKIE_PREFIX}${prefix}.oauth_state`, `${prefix}.oauth_state`];
+		for (const name of candidates) {
+			const value = parsed?.[name]?.value;
+			if (value) return value;
+		}
+	}
+	return null;
+}
+function getOrigin(scheme) {
+	return Linking.createURL("", { scheme });
+}
+/**
+* Compare if session cookies have actually changed by comparing their values.
+* Ignores expiry timestamps that naturally change on each request.
+*
+* @param prevCookie - Previous cookie JSON string
+* @param newCookie - New cookie JSON string
+* @returns true if session cookies have changed, false otherwise
+*/
+function hasSessionCookieChanged(prevCookie, newCookie) {
+	if (!prevCookie) return true;
+	try {
+		const prev = JSON.parse(prevCookie);
+		const next = JSON.parse(newCookie);
+		const sessionKeys = /* @__PURE__ */ new Set();
+		Object.keys(prev).forEach((key) => {
+			if (key.includes("session_token") || key.includes("session_data")) sessionKeys.add(key);
+		});
+		Object.keys(next).forEach((key) => {
+			if (key.includes("session_token") || key.includes("session_data")) sessionKeys.add(key);
+		});
+		for (const key of sessionKeys) if (prev[key]?.value !== next[key]?.value) return true;
+		return false;
+	} catch {
+		return true;
+	}
+}
+/**
+* Check if the Set-Cookie header contains better-auth cookies.
+* This prevents infinite refetching when non-better-auth cookies (like third-party cookies) change.
+*
+* Supports multiple cookie naming patterns:
+* - Default: "better-auth.session_token", "better-auth-passkey", "__Secure-better-auth.session_token"
+* - Custom prefix: "myapp.session_token", "myapp-passkey", "__Secure-myapp.session_token"
+* - Custom full names: "my_custom_session_token", "custom_session_data"
+* - No prefix (cookiePrefix=""): matches any cookie with known suffixes
+* - Multiple prefixes: ["better-auth", "my-app"] matches cookies starting with any of the prefixes
+*
+* @param setCookieHeader - The Set-Cookie header value
+* @param cookiePrefix - The cookie prefix(es) to check for. Can be a string, array of strings, or empty string.
+* @returns true if the header contains better-auth cookies, false otherwise
+*/
+function hasBetterAuthCookies(setCookieHeader, cookiePrefix) {
+	const cookies = parseSetCookieHeader$1(setCookieHeader);
+	const cookieSuffixes = ["session_token", "session_data"];
+	const prefixes = Array.isArray(cookiePrefix) ? cookiePrefix : [cookiePrefix];
+	for (const name of cookies.keys()) {
+		const nameWithoutSecure = stripSecureCookiePrefix(name);
+		for (const prefix of prefixes) if (prefix) {
+			if (nameWithoutSecure.startsWith(prefix)) return true;
+		} else for (const suffix of cookieSuffixes) if (nameWithoutSecure.endsWith(suffix)) return true;
+	}
+	return false;
+}
 const expoClient = (opts) => {
 	let store = null;
 	const storagePrefix = opts?.storagePrefix || "better-auth";

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as PACKAGE_VERSION } from "./version-DddGjO8z.js";
+import { t as PACKAGE_VERSION } from "./version-Db7MRDhd.js";
 import { createAuthMiddleware } from "@better-auth/core/api";
 import { HIDE_METADATA } from "better-auth";
 import { APIError, createAuthEndpoint } from "better-auth/api";

package/dist/plugins/index.js

@@ -1,4 +1,4 @@
-import { t as PACKAGE_VERSION } from "../version-DddGjO8z.js";
+import { t as PACKAGE_VERSION } from "../version-Db7MRDhd.js";
 //#region src/plugins/last-login-method.ts
 const paths = [
 	"/callback/",

package/dist/{version-DddGjO8z.js → version-Db7MRDhd.js}

@@ -1,5 +1,5 @@
 //#endregion
 //#region src/version.ts
-const PACKAGE_VERSION = "1.7.3";
+const PACKAGE_VERSION = "1.7.5";
 //#endregion
 export { PACKAGE_VERSION as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better-auth/expo",
-  "version": "1.7.3",
+  "version": "1.7.5",
   "description": "Better Auth integration for Expo and React Native applications.",
   "type": "module",
   "license": "MIT",
@@ -58,12 +58,12 @@
     }
   },
   "dependencies": {
-    "@better-fetch/fetch": "1.3.1",
+    "@better-fetch/fetch": "1.3.2",
     "better-call": "1.4.0",
     "zod": "^4.5.4"
   },
   "devDependencies": {
-    "@better-fetch/fetch": "1.3.1",
+    "@better-fetch/fetch": "1.3.2",
     "expo-constants": "~56.0.18",
     "expo-linking": "~56.0.14",
     "expo-network": "~56.0.5",
@@ -71,8 +71,8 @@
     "expo-web-browser": "~56.0.5",
     "react-native": "~0.86.0",
     "tsdown": "0.21.10",
-    "@better-auth/core": "1.7.3",
-    "better-auth": "1.7.3"
+    "@better-auth/core": "1.7.5",
+    "better-auth": "1.7.5"
   },
   "peerDependencies": {
     "expo-constants": ">=17.0.0",
@@ -80,8 +80,8 @@
     "expo-network": ">=8.0.7",
     "expo-secure-store": ">=12.5.0",
     "expo-web-browser": ">=14.0.0",
-    "@better-auth/core": "^1.7.3",
-    "better-auth": "^1.7.3"
+    "@better-auth/core": "^1.7.5",
+    "better-auth": "^1.7.5"
   },
   "peerDependenciesMeta": {
     "expo-constants": {