@better-auth/expo 1.7.1 → 1.7.3

package/dist/client.d.ts

@@ -14,6 +14,8 @@ declare function setupExpoOnlineManager(): OnlineManager;
 //#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 {
@@ -84,25 +86,17 @@ declare function hasBetterAuthCookies(setCookieHeader: string, cookiePrefix: str
  * @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>;
-};
+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;

package/dist/client.js

@@ -1,4 +1,4 @@
-import { t as PACKAGE_VERSION } from "./version-BdmvArPe.js";
+import { t as PACKAGE_VERSION } from "./version-DddGjO8z.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";
@@ -204,82 +204,219 @@ function normalizeCookieName(name) {
 * @see https://github.com/better-auth/better-auth/issues/9151
 */
 const STORAGE_VALUE_LIMIT = 1800;
+const MAX_STORAGE_CHUNKS = 100;
 /**
-* 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.
+* 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:";
-function getStorageWrites(key, value) {
+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 == null) 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 == null) 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 getStorageWrites(key, value, currentBaseValue) {
 	if (value.length <= STORAGE_VALUE_LIMIT) return [[key, value]];
 	const count = Math.ceil(value.length / STORAGE_VALUE_LIMIT);
-	const writes = [[key, ""]];
+	if (count > MAX_STORAGE_CHUNKS) throw new Error(`Storage value requires ${count} chunks, exceeding the limit of ${MAX_STORAGE_CHUNKS}`);
+	const currentMarker = currentBaseValue?.startsWith(CHUNK_MARKER) ? parseChunkMarker(currentBaseValue) : null;
+	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 (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([getChunkKey(key, marker, i), value.slice(start, start + STORAGE_VALUE_LIMIT)]);
 	}
-	writes.push([key, `${CHUNK_MARKER}${count}`]);
+	writes.push([key, serializeChunkMarker(marker)]);
 	return writes;
 }
-function storageAdapter(storage) {
+function createKeyedWriteQueue() {
+	const tails = /* @__PURE__ */ new Map();
 	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;
+		pending(key) {
+			return tails.has(key);
 		},
-		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);
+		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;
+		}
+	};
+}
+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 createManagedStorage(storage) {
+	const writeQueue = getStorageWriteQueue(storage);
+	const logWriteError = (key, error) => {
+		console.error(`[better-auth/expo] failed to persist "${key}" to storage`, error);
+	};
+	const getItem = (name) => {
+		const key = normalizeCookieName(name);
+		return readStoredValue(storage, key, storage.getItem(key));
+	};
+	const getItemAsync = async (name) => {
+		const key = normalizeCookieName(name);
+		return readStoredValueAsync(storage, key, await storage.getItemAsync(key));
+	};
+	const writeItem = (key, value, currentBaseValue) => {
+		for (const [writeKey, writeValue] of getStorageWrites(key, value, currentBaseValue)) storage.setItem(writeKey, writeValue);
+	};
+	const writeItemAsync = async (key, value, currentBaseValue) => {
+		for (const [writeKey, writeValue] of getStorageWrites(key, value, currentBaseValue)) await storage.setItemAsync(writeKey, writeValue);
+	};
+	const setItem = (name, value) => {
+		const key = normalizeCookieName(name);
+		if (writeQueue.pending(key)) {
+			logWriteError(key, /* @__PURE__ */ new Error("Cannot write synchronously while an async write is pending"));
+			return;
+		}
+		try {
+			writeItem(key, value, value.length > STORAGE_VALUE_LIMIT ? storage.getItem(key) : null);
+		} catch (error) {
+			logWriteError(key, error);
+		}
+	};
+	const setItemAsync = (name, value) => {
+		const key = normalizeCookieName(name);
+		return writeQueue.enqueue(key, async () => {
 			try {
-				for (const [writeKey, writeValue] of getStorageWrites(key, value)) storage.setItem(writeKey, writeValue);
+				await writeItemAsync(key, value, value.length > STORAGE_VALUE_LIMIT ? await storage.getItemAsync(key) : null);
 			} catch (error) {
-				console.error(`[better-auth/expo] failed to persist "${key}" to storage`, error);
+				logWriteError(key, error);
 			}
-		},
-		setItemAsync: async (name, value) => {
-			const key = normalizeCookieName(name);
+		});
+	};
+	const updateItemAsync = (name, update) => {
+		const key = normalizeCookieName(name);
+		return writeQueue.enqueue(key, async () => {
 			try {
-				for (const [writeKey, writeValue] of getStorageWrites(key, value)) await storage.setItemAsync(writeKey, writeValue);
+				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) {
-				console.error(`[better-auth/expo] failed to persist "${key}" to storage`, error);
+				logWriteError(key, error);
+				return null;
 			}
-		}
+		});
+	};
+	return {
+		getItem,
+		getItemAsync,
+		setItem,
+		setItemAsync,
+		updateItemAsync
+	};
+}
+/**
+* Wraps Expo storage with chunking, recoverable writes, and serialized async
+* updates.
+*/
+function storageAdapter(storage) {
+	const managedStorage = createManagedStorage(storage);
+	return {
+		getItem: managedStorage.getItem,
+		getItemAsync: managedStorage.getItemAsync,
+		setItem: managedStorage.setItem,
+		setItemAsync: managedStorage.setItemAsync
 	};
 }
 const expoClient = (opts) => {
@@ -287,7 +424,7 @@ const expoClient = (opts) => {
 	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 +496,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 +531,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-BdmvArPe.js";
+import { t as PACKAGE_VERSION } from "./version-DddGjO8z.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-BdmvArPe.js";
+import { t as PACKAGE_VERSION } from "../version-DddGjO8z.js";
 //#region src/plugins/last-login-method.ts
 const paths = [
 	"/callback/",

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better-auth/expo",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "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.1",
-    "better-auth": "1.7.1"
+    "@better-auth/core": "1.7.3",
+    "better-auth": "1.7.3"
   },
   "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.1",
-    "better-auth": "^1.7.1"
+    "@better-auth/core": "^1.7.3",
+    "better-auth": "^1.7.3"
   },
   "peerDependenciesMeta": {
     "expo-constants": {