@better-auth/expo 1.7.2 → 1.7.4

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,10 +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.
- */
-type ExpoClientStorage = Pick<typeof SecureStore, "setItem" | "setItemAsync" | "getItem" | "getItemAsync">;
 interface ExpoClientOptions {
   scheme?: string | undefined;
   storage: ExpoClientStorage;
@@ -74,35 +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;
-declare function storageAdapter(storage: ExpoClientStorage): {
-  /**
-   * Reads a value, reassembling it if it was split across chunk keys. A value
-   * that fit is returned as-is (values written before chunking still read
-   * back); a missing chunk returns `null` so a torn write fails closed.
-   */
-  getItem: (name: string) => string | null;
-  getItemAsync: (name: string) => Promise<string | null>;
-  /**
-   * Stores `value`, splitting it across chunk keys when it exceeds the
-   * per-write limit. The base key is cleared before the chunks are rewritten
-   * and set to the marker last, as the commit point, so a write interrupted
-   * partway through reads as absent rather than a mix of old and new chunks.
-   * Failures are logged, not thrown: persistence is best-effort and must not
-   * break the request.
-   */
-  setItem: (name: string, value: string) => void;
-  setItemAsync: (name: string, value: string) => Promise<void>;
-};
 declare const expoClient: (opts: ExpoClientOptions) => {
   id: "expo";
   version: string;
@@ -189,4 +185,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-D-tGaVc4.js";
+import { t as PACKAGE_VERSION } from "./version-CuQDLAg7.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,6 +12,385 @@ 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/client-storage.ts
+/**
+* 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
+*/
+function normalizeCookieName(name) {
+	return name.replace(/:/g, "_");
+}
+/**
+* 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
+* active slot and retain the previous slot's chunk count for recovery.
+*
+* @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);
+	if (!Number.isInteger(count) || count < 1 || count > MAX_STORAGE_CHUNKS) return null;
+	return count;
+}
+function parseChunkMarker(baseValue) {
+	const parts = baseValue.slice(11).split(":");
+	if (parts.length > 3) return null;
+	const [countValue, slotValue, fallbackCountValue] = parts;
+	const count = parseChunkCount(countValue);
+	if (count === null) return null;
+	if (slotValue === void 0) return fallbackCountValue === void 0 ? {
+		count,
+		slot: null,
+		fallbackCount: null
+	} : null;
+	if (slotValue !== "0" && slotValue !== "1") return null;
+	const fallbackCount = parseChunkCount(fallbackCountValue);
+	if (fallbackCountValue !== void 0 && fallbackCount === null) return null;
+	return {
+		count,
+		slot: slotValue === "0" ? 0 : 1,
+		fallbackCount
+	};
+}
+function getChunkKey(key, marker, index) {
+	return marker.slot === null ? `${key}.${index}` : `${key}.${marker.slot}.${index}`;
+}
+function getOtherSlot(slot) {
+	return slot === 0 ? 1 : 0;
+}
+function serializeChunkMarker(marker) {
+	if (marker.slot === null) return `${CHUNK_MARKER}${marker.count}`;
+	const fallback = marker.fallbackCount === null ? "" : `:${marker.fallbackCount}`;
+	return `${CHUNK_MARKER}${marker.count}:${marker.slot}${fallback}`;
+}
+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) return null;
+		value += chunk;
+	}
+	return value;
+}
+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) return null;
+		value += chunk;
+	}
+	return value;
+}
+function readStoredValue(storage, key, baseValue) {
+	if (baseValue == null || !baseValue.startsWith(CHUNK_MARKER)) return baseValue;
+	const marker = parseChunkMarker(baseValue);
+	if (!marker) return null;
+	const value = readChunks(storage, key, marker);
+	if (value !== null || marker.slot === null || marker.fallbackCount === null) return value;
+	return readChunks(storage, key, {
+		count: marker.fallbackCount,
+		slot: getOtherSlot(marker.slot),
+		fallbackCount: null
+	});
+}
+async function readStoredValueAsync(storage, key, baseValue) {
+	if (baseValue == null || !baseValue.startsWith(CHUNK_MARKER)) return baseValue;
+	const marker = parseChunkMarker(baseValue);
+	if (!marker) return null;
+	const value = await readChunksAsync(storage, key, marker);
+	if (value !== null || marker.slot === null || marker.fallbackCount === null) return value;
+	return readChunksAsync(storage, key, {
+		count: marker.fallbackCount,
+		slot: getOtherSlot(marker.slot),
+		fallbackCount: null
+	});
+}
+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,
+		fallbackCount: currentMarker?.slot == null ? null : currentMarker.count
+	};
+	const writes = [];
+	if (currentMarker?.slot != null && currentMarker.fallbackCount !== null) writes.push([key, serializeChunkMarker({
+		...currentMarker,
+		fallbackCount: null
+	})]);
+	for (const [index, chunk] of chunks.entries()) writes.push([getChunkKey(key, marker, index), chunk]);
+	writes.push([key, serializeChunkMarker(marker)]);
+	return {
+		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;
+}
+function enqueueStorageWrite(state, operation) {
+	state.pendingWrites++;
+	return enqueueStorageOperation(state, async () => {
+		try {
+			return await operation();
+		} finally {
+			state.pendingWrites--;
+		}
+	});
+}
+/** @internal */
+function createManagedStorage(storage) {
+	const logWriteError = (key, 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 = (name) => {
+		const key = normalizeCookieName(name);
+		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) => {
+		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) => {
+		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);
+		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 {
+			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);
+		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, currentBaseValue);
+			} catch (error) {
+				state.cleanupComplete = false;
+				logWriteError(key, error);
+			}
+		});
+	};
+	const updateItemAsync = (name, update) => {
+		const key = normalizeCookieName(name);
+		const state = getStorageState(storage, key);
+		return enqueueStorageWrite(state, async () => {
+			try {
+				const currentBaseValue = await storage.getItemAsync(key);
+				const previousValue = await readStoredValueAsync(storage, key, currentBaseValue);
+				const value = update(previousValue);
+				await writeItemAsync(key, value, currentBaseValue);
+				return {
+					previousValue,
+					value
+				};
+			} catch (error) {
+				state.cleanupComplete = false;
+				logWriteError(key, error);
+				return null;
+			}
+		});
+	};
+	return {
+		getItem,
+		getItemAsync,
+		setItem,
+		setItemAsync,
+		updateItemAsync
+	};
+}
+/**
+* Wraps Expo storage with chunking, recoverable writes, and serialized async
+* access.
+*/
+function storageAdapter(storage) {
+	const managedStorage = createManagedStorage(storage);
+	return {
+		getItem: managedStorage.getItem,
+		getItemAsync: managedStorage.getItemAsync,
+		setItem: managedStorage.setItem,
+		setItemAsync: managedStorage.setItemAsync
+	};
+}
+//#endregion
 //#region src/focus-manager.ts
 var ExpoFocusManager = class {
 	listeners = /* @__PURE__ */ new Set();
@@ -183,111 +563,12 @@ function hasBetterAuthCookies(setCookieHeader, cookiePrefix) {
 	}
 	return false;
 }
-/**
-* 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
-*/
-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.
-*
-* @see https://github.com/better-auth/better-auth/issues/9151
-*/
-const STORAGE_VALUE_LIMIT = 1800;
-/**
-* Marks a base key whose value is split across `<key>.0..N` chunks. The leading
-* control char can't start a JSON value (so it never collides) and, unlike NUL,
-* survives the native storage bridge without C-string truncation.
-*/
-const CHUNK_MARKER = "
ba-chunks:";
-function getStorageWrites(key, value) {
-	if (value.length <= STORAGE_VALUE_LIMIT) return [[key, value]];
-	const count = Math.ceil(value.length / STORAGE_VALUE_LIMIT);
-	const writes = [[key, ""]];
-	for (let i = 0; i < count; i++) {
-		const start = i * STORAGE_VALUE_LIMIT;
-		writes.push([`${key}.${i}`, value.slice(start, start + STORAGE_VALUE_LIMIT)]);
-	}
-	writes.push([key, `${CHUNK_MARKER}${count}`]);
-	return writes;
-}
-function storageAdapter(storage) {
-	return {
-		/**
-		* Reads a value, reassembling it if it was split across chunk keys. A value
-		* that fit is returned as-is (values written before chunking still read
-		* back); a missing chunk returns `null` so a torn write fails closed.
-		*/
-		getItem: (name) => {
-			const key = normalizeCookieName(name);
-			const stored = storage.getItem(key);
-			if (stored == null || !stored.startsWith(CHUNK_MARKER)) return stored;
-			const count = Number(stored.slice(11));
-			if (!Number.isInteger(count) || count < 1) return null;
-			let value = "";
-			for (let i = 0; i < count; i++) {
-				const chunk = storage.getItem(`${key}.${i}`);
-				if (chunk == null) return null;
-				value += chunk;
-			}
-			return value;
-		},
-		getItemAsync: async (name) => {
-			const key = normalizeCookieName(name);
-			const stored = await storage.getItemAsync(key);
-			if (stored == null || !stored.startsWith(CHUNK_MARKER)) return stored;
-			const count = Number(stored.slice(11));
-			if (!Number.isInteger(count) || count < 1) return null;
-			let value = "";
-			for (let i = 0; i < count; i++) {
-				const chunk = await storage.getItemAsync(`${key}.${i}`);
-				if (chunk == null) return null;
-				value += chunk;
-			}
-			return value;
-		},
-		/**
-		* Stores `value`, splitting it across chunk keys when it exceeds the
-		* per-write limit. The base key is cleared before the chunks are rewritten
-		* and set to the marker last, as the commit point, so a write interrupted
-		* partway through reads as absent rather than a mix of old and new chunks.
-		* Failures are logged, not thrown: persistence is best-effort and must not
-		* break the request.
-		*/
-		setItem: (name, value) => {
-			const key = normalizeCookieName(name);
-			try {
-				for (const [writeKey, writeValue] of getStorageWrites(key, value)) storage.setItem(writeKey, writeValue);
-			} catch (error) {
-				console.error(`[better-auth/expo] failed to persist "${key}" to storage`, error);
-			}
-		},
-		setItemAsync: async (name, value) => {
-			const key = normalizeCookieName(name);
-			try {
-				for (const [writeKey, writeValue] of getStorageWrites(key, value)) await storage.setItemAsync(writeKey, writeValue);
-			} catch (error) {
-				console.error(`[better-auth/expo] failed to persist "${key}" to storage`, error);
-			}
-		}
-	};
-}
 const expoClient = (opts) => {
 	let store = null;
 	const storagePrefix = opts?.storagePrefix || "better-auth";
 	const cookieName = `${storagePrefix}_cookie`;
 	const localCacheName = `${storagePrefix}_session_data`;
-	const storage = storageAdapter(opts.storage);
+	const storage = createManagedStorage(opts.storage);
 	const isWeb = Platform.OS === "web";
 	const cookiePrefix = opts?.cookiePrefix || "better-auth";
 	let sessionCacheHydration;
@@ -359,12 +640,8 @@ getCookie: async () => {
 				const setCookie = context.response.headers.get("set-cookie");
 				if (setCookie) {
 					if (hasBetterAuthCookies(setCookie, cookiePrefix)) {
-						const prevCookie = await storage.getItemAsync(cookieName);
-						const toSetCookie = getSetCookie(setCookie || "", prevCookie ?? void 0);
-						if (hasSessionCookieChanged(prevCookie, toSetCookie)) {
-							await storage.setItemAsync(cookieName, toSetCookie);
-							store?.notify("$sessionSignal");
-						} else await storage.setItemAsync(cookieName, toSetCookie);
+						const update = await storage.updateItemAsync(cookieName, (currentValue) => getSetCookie(setCookie, currentValue ?? void 0));
+						if (update && hasSessionCookieChanged(update.previousValue, update.value)) store?.notify("$sessionSignal");
 					}
 				}
 				if (pathname.endsWith("/get-session") && !opts?.disableCache) {
@@ -398,9 +675,7 @@ getCookie: async () => {
 					if (result.type !== "success") return;
 					const cookie = new URL(result.url).searchParams.get("cookie");
 					if (!cookie) return;
-					const toSetCookie = getSetCookie(cookie, await storage.getItemAsync(cookieName) ?? void 0);
-					await storage.setItemAsync(cookieName, toSetCookie);
-					store?.notify("$sessionSignal");
+					if (await storage.updateItemAsync(cookieName, (currentValue) => getSetCookie(cookie, currentValue ?? void 0))) store?.notify("$sessionSignal");
 				}
 			} },
 			async init(url, options) {

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as PACKAGE_VERSION } from "./version-D-tGaVc4.js";
+import { t as PACKAGE_VERSION } from "./version-CuQDLAg7.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-D-tGaVc4.js";
+import { t as PACKAGE_VERSION } from "../version-CuQDLAg7.js";
 //#region src/plugins/last-login-method.ts
 const paths = [
 	"/callback/",

package/dist/{version-D-tGaVc4.js → version-CuQDLAg7.js}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better-auth/expo",
-  "version": "1.7.2",
+  "version": "1.7.4",
   "description": "Better Auth integration for Expo and React Native applications.",
   "type": "module",
   "license": "MIT",
@@ -60,7 +60,7 @@
   "dependencies": {
     "@better-fetch/fetch": "1.3.1",
     "better-call": "1.4.0",
-    "zod": "^4.3.6"
+    "zod": "^4.5.4"
   },
   "devDependencies": {
     "@better-fetch/fetch": "1.3.1",
@@ -71,8 +71,8 @@
     "expo-web-browser": "~56.0.5",
     "react-native": "~0.86.0",
     "tsdown": "0.21.10",
-    "@better-auth/core": "1.7.2",
-    "better-auth": "1.7.2"
+    "@better-auth/core": "1.7.4",
+    "better-auth": "1.7.4"
   },
   "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.2",
-    "better-auth": "^1.7.2"
+    "@better-auth/core": "^1.7.4",
+    "better-auth": "^1.7.4"
   },
   "peerDependenciesMeta": {
     "expo-constants": {