@oxyhq/services 5.13.1 → 5.13.3

package/lib/commonjs/ui/context/OxyContext.js

@@ -6,10 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.useOxy = exports.default = exports.OxyProvider = exports.OxyContextProvider = void 0;
 var _react = require("react");
 var _core = require("../../core");
+var _sessionUtils = require("../../utils/sessionUtils");
 var _deviceManager = require("../../utils/deviceManager");
 var _useSessionSocket = require("../hooks/useSessionSocket");
 var _sonner = require("../../lib/sonner");
 var _authStore = require("../stores/authStore");
+var _languageUtils = require("../../utils/languageUtils");
 var _jsxRuntime = require("react/jsx-runtime");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); } // Define the context shape
 // NOTE: We intentionally avoid importing useFollow here to prevent a require cycle.
@@ -86,6 +88,8 @@ const getStorage = async () => {
 const getStorageKeys = (prefix = 'oxy_session') => ({
   activeSessionId: `${prefix}_active_session_id`,
   // Only store the active session ID
+  sessionIds: `${prefix}_session_ids`,
+  // Store all session IDs for quick account loading
   language: `${prefix}_language` // Store the selected language
 });
 const OxyProvider = ({
@@ -125,38 +129,21 @@ const OxyProvider = ({
   const [minimalUser, setMinimalUser] = (0, _react.useState)(null);
   const [sessions, setSessions] = (0, _react.useState)([]);
   const [activeSessionId, setActiveSessionId] = (0, _react.useState)(null);
+
+  // Track in-flight refresh to prevent duplicate calls
+  const refreshInFlightRef = (0, _react.useRef)(null);
   const [storage, setStorage] = (0, _react.useState)(null);
   const [currentLanguage, setCurrentLanguage] = (0, _react.useState)('en-US');
 
   // Storage keys (memoized to prevent infinite loops) - declared early for use in helpers
   const keys = (0, _react.useMemo)(() => getStorageKeys(storageKeyPrefix), [storageKeyPrefix]);
 
-  // Normalize language codes to BCP-47 (e.g., en-US)
-  const normalizeLanguageCode = (0, _react.useCallback)(lang => {
-    if (!lang) return null;
-    if (lang.includes('-')) return lang;
-    const map = {
-      en: 'en-US',
-      es: 'es-ES',
-      ca: 'ca-ES',
-      fr: 'fr-FR',
-      de: 'de-DE',
-      it: 'it-IT',
-      pt: 'pt-PT',
-      ja: 'ja-JP',
-      ko: 'ko-KR',
-      zh: 'zh-CN',
-      ar: 'ar-SA'
-    };
-    return map[lang] || lang;
-  }, []);
-
   // Helper to apply language preference from user/server
   const applyLanguagePreference = (0, _react.useCallback)(async user => {
     const userLanguage = user?.language;
     if (!userLanguage || !storage) return;
     try {
-      const serverLang = normalizeLanguageCode(userLanguage) || userLanguage;
+      const serverLang = (0, _languageUtils.normalizeLanguageCode)(userLanguage);
       await storage.setItem(keys.language, serverLang);
       setCurrentLanguage(serverLang);
     } catch (e) {
@@ -164,19 +151,45 @@ const OxyProvider = ({
         console.warn('Failed to apply server language preference', e);
       }
     }
-  }, [storage, keys.language, normalizeLanguageCode]);
-
-  // Helper to map server sessions to client sessions
-  const mapServerSessionsToClient = (0, _react.useCallback)((serverSessions, fallbackUserId) => {
-    return serverSessions.map(s => ({
+  }, [storage, keys.language]);
+  const mapSessionsToClient = (0, _react.useCallback)((sessions, fallbackDeviceId, fallbackUserId) => {
+    return sessions.map(s => ({
       sessionId: s.sessionId,
-      deviceId: s.deviceId,
-      expiresAt: s.expiresAt || new Date().toISOString(),
+      deviceId: s.deviceId || fallbackDeviceId || '',
+      expiresAt: s.expiresAt || new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
       lastActive: s.lastActive || new Date().toISOString(),
-      userId: s.userId || fallbackUserId
+      userId: s.user?.id || s.userId || s.user?._id?.toString() || fallbackUserId || '',
+      isCurrent: Boolean(s.isCurrent)
     }));
   }, []);
 
+  // Save all session IDs to storage for quick loading on initialization
+  const saveSessionIds = (0, _react.useCallback)(async sessionIds => {
+    if (!storage) return;
+    try {
+      const uniqueIds = Array.from(new Set(sessionIds));
+      await storage.setItem(keys.sessionIds, JSON.stringify(uniqueIds));
+    } catch (err) {
+      if (__DEV__) {
+        console.warn('Failed to save session IDs:', err);
+      }
+    }
+  }, [storage, keys.sessionIds]);
+  const updateSessions = (0, _react.useCallback)((newSessions, mergeWithExisting = false) => {
+    setSessions(prevSessions => {
+      const sessionsToProcess = mergeWithExisting ? (0, _sessionUtils.mergeSessions)(prevSessions, newSessions, activeSessionId, false) : (0, _sessionUtils.normalizeAndSortSessions)(newSessions, activeSessionId, false);
+
+      // Save all session IDs to storage
+      if (storage) {
+        const allSessionIds = sessionsToProcess.map(s => s.sessionId);
+        saveSessionIds(allSessionIds).catch(() => {
+          // Ignore errors - non-critical
+        });
+      }
+      return (0, _sessionUtils.sessionsArraysEqual)(prevSessions, sessionsToProcess) ? prevSessions : sessionsToProcess;
+    });
+  }, [activeSessionId, storage, saveSessionIds]);
+
   // Token ready state - start optimistically so children render immediately
   const [tokenReady, setTokenReady] = (0, _react.useState)(true);
 
@@ -185,6 +198,7 @@ const OxyProvider = ({
     if (!storage) return;
     try {
       await storage.removeItem(keys.activeSessionId);
+      await storage.removeItem(keys.sessionIds);
     } catch (err) {
       if (__DEV__) {
         console.error('Clear storage error:', err);
@@ -228,13 +242,56 @@ const OxyProvider = ({
       try {
         // Load saved language preference
         const savedLanguageRaw = await storage.getItem(keys.language);
-        const savedLanguage = normalizeLanguageCode(savedLanguageRaw) || savedLanguageRaw;
+        const savedLanguage = (0, _languageUtils.normalizeLanguageCode)(savedLanguageRaw) || savedLanguageRaw;
         if (savedLanguage) {
           setCurrentLanguage(savedLanguage);
         }
 
+        // Load all stored session IDs and validate them
+        const storedSessionIdsJson = await storage.getItem(keys.sessionIds);
+        const storedSessionIds = storedSessionIdsJson ? JSON.parse(storedSessionIdsJson) : [];
+
         // Try to restore active session from storage
         const storedActiveSessionId = await storage.getItem(keys.activeSessionId);
+        const validSessions = [];
+
+        // If we have stored session IDs, validate them (even without active session)
+        if (storedSessionIds.length > 0) {
+          if (__DEV__) {
+            console.log('Loading stored sessions on init:', storedSessionIds.length);
+          }
+
+          // Validate each stored session ID and build session list
+          for (const sessionId of storedSessionIds) {
+            try {
+              const validation = await oxyServices.validateSession(sessionId, {
+                useHeaderValidation: true
+              });
+              if (validation.valid && validation.user) {
+                validSessions.push({
+                  sessionId,
+                  userId: validation.user.id?.toString() || '',
+                  deviceId: '',
+                  expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+                  lastActive: new Date().toISOString(),
+                  isCurrent: sessionId === storedActiveSessionId
+                });
+              }
+            } catch (e) {
+              // Session invalid, skip it
+              if (__DEV__) {
+                console.warn('Session validation failed for:', sessionId, e);
+              }
+            }
+          }
+
+          // Update sessions list with validated sessions (even if no active session)
+          if (validSessions.length > 0) {
+            updateSessions(validSessions, false);
+          }
+        }
+
+        // If we have an active session, authenticate with it
         if (storedActiveSessionId) {
           try {
             const validation = await oxyServices.validateSession(storedActiveSessionId, {
@@ -251,35 +308,31 @@ const OxyProvider = ({
                 avatar: fullUser.avatar
               });
               await applyLanguagePreference(fullUser);
-
-              // Get all device sessions to support multiple accounts
               try {
                 const deviceSessions = await oxyServices.getDeviceSessions(storedActiveSessionId);
-                const allDeviceSessions = deviceSessions.map(ds => ({
-                  sessionId: ds.sessionId,
-                  deviceId: ds.deviceId,
-                  expiresAt: ds.expiresAt || new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
-                  lastActive: ds.lastActive || new Date().toISOString(),
-                  userId: ds.user?.id || ds.userId || fullUser.id
-                }));
-                setSessions(allDeviceSessions);
+                const allDeviceSessions = mapSessionsToClient(deviceSessions, undefined, fullUser.id);
+                updateSessions(allDeviceSessions, true);
               } catch (e) {
-                // Fallback to user sessions
                 if (__DEV__) {
                   console.warn('Failed to get device sessions on init, falling back to user sessions:', e);
                 }
                 const serverSessions = await oxyServices.getSessionsBySessionId(storedActiveSessionId);
-                setSessions(mapServerSessionsToClient(serverSessions, fullUser.id));
+                updateSessions(mapSessionsToClient(serverSessions, undefined, fullUser.id), false);
               }
               onAuthStateChange?.(fullUser);
             } else {
-              await clearAllStorage();
+              // Active session invalid, remove it but keep other sessions
+              await storage.removeItem(keys.activeSessionId);
+              // Update session list to remove invalid active session
+              updateSessions(validSessions.filter(s => s.sessionId !== storedActiveSessionId), false);
             }
           } catch (e) {
             if (__DEV__) {
-              console.error('Session validation error', e);
+              console.error('Active session validation error', e);
             }
-            await clearAllStorage();
+            // Remove invalid active session but keep other sessions
+            await storage.removeItem(keys.activeSessionId);
+            updateSessions(validSessions.filter(s => s.sessionId !== storedActiveSessionId), false);
           }
         }
         setTokenReady(true);
@@ -292,34 +345,28 @@ const OxyProvider = ({
       }
     };
     initAuth();
-  }, [storage, oxyServices, keys, onAuthStateChange, loginSuccess, clearAllStorage, applyLanguagePreference, mapServerSessionsToClient]);
+  }, [storage, oxyServices, keys, onAuthStateChange, loginSuccess, clearAllStorage, applyLanguagePreference, mapSessionsToClient, updateSessions]);
 
   // Save active session ID to storage (only session ID, no user data)
   const saveActiveSessionId = (0, _react.useCallback)(async sessionId => {
     if (!storage) return;
     await storage.setItem(keys.activeSessionId, sessionId);
   }, [storage, keys.activeSessionId]);
-
-  // Switch to a different session
   const switchToSession = (0, _react.useCallback)(async sessionId => {
     try {
-      // Don't set isLoading - session switches should happen silently in background
-      // Validate session first before attempting to switch
       const validation = await oxyServices.validateSession(sessionId, {
         useHeaderValidation: true
       });
       if (!validation.valid) {
-        // Session is invalid, remove it from the sessions list
-        setSessions(prevSessions => prevSessions.filter(s => s.sessionId !== sessionId));
+        updateSessions(sessions.filter(s => s.sessionId !== sessionId), false);
         throw new Error('Session is invalid or expired');
       }
-
-      // Get access token for this session
+      if (!validation.user) {
+        throw new Error('User data not available from session validation');
+      }
+      const fullUser = validation.user;
       await oxyServices.getTokenBySession(sessionId);
       setTokenReady(true);
-
-      // Load full user data - use user from validation if available, otherwise fetch
-      const fullUser = validation.user || (await oxyServices.getUserBySession(sessionId));
       setActiveSessionId(sessionId);
       loginSuccess(fullUser);
       setMinimalUser({
@@ -329,53 +376,17 @@ const OxyProvider = ({
       });
       await saveActiveSessionId(sessionId);
       await applyLanguagePreference(fullUser);
-
-      // Refresh all device sessions after switching
-      // Preserve existing sessions from other users to avoid losing accounts
-      try {
-        const deviceSessions = await oxyServices.getDeviceSessions(sessionId);
-        const allDeviceSessions = deviceSessions.map(ds => ({
-          sessionId: ds.sessionId,
-          deviceId: ds.deviceId,
-          expiresAt: ds.expiresAt || new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
-          lastActive: ds.lastActive || new Date().toISOString(),
-          userId: ds.user?.id || ds.userId || fullUser.id
-        }));
-        // Merge with existing sessions to preserve other accounts
-        setSessions(prevSessions => {
-          const existingSessionIds = new Set(prevSessions.map(s => s.sessionId));
-          const newSessions = allDeviceSessions.filter(s => !existingSessionIds.has(s.sessionId));
-          // Combine existing sessions with new ones, prioritizing new data for existing sessions
-          const sessionMap = new Map(prevSessions.map(s => [s.sessionId, s]));
-          allDeviceSessions.forEach(s => sessionMap.set(s.sessionId, s));
-          return Array.from(sessionMap.values());
-        });
-      } catch (error) {
-        // Fallback to user sessions - merge with existing to preserve other accounts
-        if (__DEV__) {
-          console.warn('Failed to get device sessions after switch, falling back to user sessions:', error);
-        }
-        const serverSessions = await oxyServices.getSessionsBySessionId(sessionId);
-        const userSessions = mapServerSessionsToClient(serverSessions, fullUser.id);
-        // Merge with existing sessions to preserve other accounts
-        setSessions(prevSessions => {
-          const existingSessionIds = new Set(prevSessions.map(s => s.sessionId));
-          const newSessions = userSessions.filter(s => !existingSessionIds.has(s.sessionId));
-          // Combine existing sessions with new ones, prioritizing new data for existing sessions
-          const sessionMap = new Map(prevSessions.map(s => [s.sessionId, s]));
-          userSessions.forEach(s => sessionMap.set(s.sessionId, s));
-          return Array.from(sessionMap.values());
-        });
-      }
+      oxyServices.getDeviceSessions(sessionId).then(deviceSessions => {
+        const allDeviceSessions = mapSessionsToClient(deviceSessions, undefined, fullUser.id);
+        updateSessions(allDeviceSessions, true);
+      }).catch(error => {
+        if (__DEV__) console.warn('Failed to get device sessions after switch:', error);
+      });
       onAuthStateChange?.(fullUser);
     } catch (error) {
-      // Check if the error is due to invalid/expired session
       const isInvalidSession = error?.response?.status === 401 || error?.message?.includes('Invalid or expired session') || error?.message?.includes('Session is invalid');
       if (isInvalidSession) {
-        // Remove invalid session from the sessions list
-        setSessions(prevSessions => prevSessions.filter(s => s.sessionId !== sessionId));
-
-        // If this was the active session, try to switch to another valid session
+        updateSessions(sessions.filter(s => s.sessionId !== sessionId), false);
         if (sessionId === activeSessionId && sessions.length > 1) {
           const otherSessions = sessions.filter(s => s.sessionId !== sessionId);
           for (const otherSession of otherSessions) {
@@ -409,9 +420,7 @@ const OxyProvider = ({
       setTokenReady(false);
       throw error; // Re-throw so calling code can handle it
     }
-  }, [oxyServices, onAuthStateChange, loginSuccess, saveActiveSessionId, applyLanguagePreference, mapServerSessionsToClient, onError, activeSessionId, sessions]);
-
-  // Login method - only store session ID, retrieve data from backend
+  }, [oxyServices, onAuthStateChange, loginSuccess, saveActiveSessionId, applyLanguagePreference, mapSessionsToClient, onError, activeSessionId, sessions]);
   const login = (0, _react.useCallback)(async (username, password, deviceName) => {
     if (!storage) throw new Error('Storage not initialized');
     _authStore.useAuthStore.setState({
@@ -434,43 +443,20 @@ const OxyProvider = ({
       const sessionResponse = response;
       await oxyServices.getTokenBySession(sessionResponse.sessionId);
       const fullUser = await oxyServices.getUserBySession(sessionResponse.sessionId);
-
-      // Get all device sessions to check for duplicates BEFORE setting the new session as active
-      // This returns all sessions on the device, not just for the current user
       let allDeviceSessions = [];
       try {
         const deviceSessions = await oxyServices.getDeviceSessions(sessionResponse.sessionId);
-
-        // Map device sessions to client format
-        // Device sessions include user info, so we can map them directly
-        allDeviceSessions = deviceSessions.map(ds => ({
-          sessionId: ds.sessionId,
-          deviceId: ds.deviceId || sessionResponse.deviceId,
-          expiresAt: ds.expiresAt || new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
-          lastActive: ds.lastActive || new Date().toISOString(),
-          userId: ds.user?.id || ds.userId || ds.user?._id?.toString() || fullUser.id
-        }));
+        allDeviceSessions = mapSessionsToClient(deviceSessions, sessionResponse.deviceId, fullUser.id);
       } catch (error) {
-        // Fallback to user sessions if device sessions fail
         if (__DEV__) {
           console.warn('Failed to get device sessions, falling back to user sessions:', error);
         }
         const serverSessions = await oxyServices.getSessionsBySessionId(sessionResponse.sessionId);
-        const userSessions = mapServerSessionsToClient(serverSessions, fullUser.id);
-
-        // Merge with existing sessions to preserve other accounts
-        const existingSessionIds = new Set((sessions || []).map(s => s.sessionId));
-        const newSessions = userSessions.filter(s => !existingSessionIds.has(s.sessionId));
-        allDeviceSessions = [...(sessions || []), ...newSessions];
+        allDeviceSessions = mapSessionsToClient(serverSessions, undefined, fullUser.id);
       }
-
-      // Check if this user is already signed in with another session on this device
-      // Compare userId as string to handle both string and ObjectId formats
       const userUserId = fullUser.id?.toString();
       const existingSession = allDeviceSessions.find(s => s.userId?.toString() === userUserId && s.sessionId !== sessionResponse.sessionId);
       if (existingSession) {
-        // User is already signed in on this device, switch to existing session instead
-        // Logout the newly created session to clean it up
         try {
           await oxyServices.logoutSession(sessionResponse.sessionId, sessionResponse.sessionId);
         } catch (logoutError) {
@@ -478,24 +464,18 @@ const OxyProvider = ({
             console.warn('Failed to logout duplicate session:', logoutError);
           }
         }
-
-        // Switch to the existing session
         await switchToSession(existingSession.sessionId);
         loginSuccess(fullUser);
         setMinimalUser(sessionResponse.user);
-
-        // Update sessions list (excluding the duplicate we just created)
-        setSessions(allDeviceSessions.filter(s => s.sessionId !== sessionResponse.sessionId));
+        updateSessions(allDeviceSessions.filter(s => s.sessionId !== sessionResponse.sessionId), false);
         onAuthStateChange?.(fullUser);
         return fullUser;
       }
-
-      // No duplicate found, proceed with the new session
       setActiveSessionId(sessionResponse.sessionId);
       await saveActiveSessionId(sessionResponse.sessionId);
       loginSuccess(fullUser);
       setMinimalUser(sessionResponse.user);
-      setSessions(allDeviceSessions);
+      updateSessions(allDeviceSessions, true);
       onAuthStateChange?.(fullUser);
       return fullUser;
     } catch (error) {
@@ -512,7 +492,7 @@ const OxyProvider = ({
         isLoading: false
       });
     }
-  }, [storage, oxyServices, saveActiveSessionId, loginSuccess, onAuthStateChange, loginFailure, mapServerSessionsToClient, onError, sessions, switchToSession]);
+  }, [storage, oxyServices, saveActiveSessionId, loginSuccess, onAuthStateChange, loginFailure, mapSessionsToClient, onError, sessions, switchToSession]);
 
   // Logout method
   const logout = (0, _react.useCallback)(async targetSessionId => {
@@ -520,18 +500,12 @@ const OxyProvider = ({
     try {
       const sessionToLogout = targetSessionId || activeSessionId;
       await oxyServices.logoutSession(activeSessionId, sessionToLogout);
-
-      // Remove session from local state
       const filteredSessions = sessions.filter(s => s.sessionId !== sessionToLogout);
-      setSessions(filteredSessions);
-
-      // If logging out active session
+      updateSessions(filteredSessions, false);
       if (sessionToLogout === activeSessionId) {
         if (filteredSessions.length > 0) {
-          // Switch to another session
           await switchToSession(filteredSessions[0].sessionId);
         } else {
-          // No sessions left
           setActiveSessionId(null);
           logoutStore();
           setMinimalUser(null);
@@ -556,8 +530,6 @@ const OxyProvider = ({
       });
     }
   }, [activeSessionId, oxyServices, sessions, switchToSession, logoutStore, storage, keys.activeSessionId, onAuthStateChange, onError]);
-
-  // Logout all sessions
   const logoutAll = (0, _react.useCallback)(async () => {
     if (!activeSessionId) {
       const error = new Error('No active session found');
@@ -573,7 +545,7 @@ const OxyProvider = ({
     }
     try {
       await oxyServices.logoutAllSessions(activeSessionId);
-      setSessions([]);
+      updateSessions([], false);
       setActiveSessionId(null);
       logoutStore();
       setMinimalUser(null);
@@ -651,28 +623,16 @@ const OxyProvider = ({
       // Get all device sessions to support multiple accounts
       try {
         const deviceSessions = await oxyServices.getDeviceSessions(response.sessionId);
-        const allDeviceSessions = deviceSessions.map(ds => ({
-          sessionId: ds.sessionId,
-          deviceId: ds.deviceId,
-          expiresAt: ds.expiresAt || new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
-          lastActive: ds.lastActive || new Date().toISOString(),
-          userId: ds.user?.id || ds.userId || fullUser.id
-        }));
-        setSessions(allDeviceSessions);
+        const allDeviceSessions = mapSessionsToClient(deviceSessions, undefined, fullUser.id);
+        updateSessions(allDeviceSessions, true);
       } catch (error) {
         // Fallback to user sessions if device sessions fail
         if (__DEV__) {
           console.warn('Failed to get device sessions for MFA, falling back to user sessions:', error);
         }
         const serverSessions = await oxyServices.getSessionsBySessionId(response.sessionId);
-        const userSessions = mapServerSessionsToClient(serverSessions, fullUser.id);
-
-        // Merge with existing sessions to preserve other accounts
-        setSessions(prevSessions => {
-          const existingSessionIds = new Set(prevSessions.map(s => s.sessionId));
-          const newSessions = userSessions.filter(s => !existingSessionIds.has(s.sessionId));
-          return [...prevSessions, ...newSessions];
-        });
+        const userSessions = mapSessionsToClient(serverSessions, undefined, fullUser.id);
+        updateSessions(userSessions, true);
       }
       onAuthStateChange?.(fullUser);
       return fullUser;
@@ -691,82 +651,73 @@ const OxyProvider = ({
       });
     }
   }, [storage, oxyServices, loginSuccess, loginFailure, saveActiveSessionId, onAuthStateChange, applyLanguagePreference, onError]);
-
-  // Switch session method (wrapper for consistency)
   const switchSession = (0, _react.useCallback)(async sessionId => {
     await switchToSession(sessionId);
   }, [switchToSession]);
-
-  // Remove session method (wrapper for consistency)
   const removeSession = (0, _react.useCallback)(async sessionId => {
     await logout(sessionId);
   }, [logout]);
-
-  // Refresh sessions method
   const refreshSessions = (0, _react.useCallback)(async () => {
     if (!activeSessionId) return;
-    try {
-      // Get all device sessions to support multiple accounts
-      const deviceSessions = await oxyServices.getDeviceSessions(activeSessionId);
-      const allDeviceSessions = deviceSessions.map(ds => ({
-        sessionId: ds.sessionId,
-        deviceId: ds.deviceId,
-        expiresAt: ds.expiresAt || new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
-        lastActive: ds.lastActive || new Date().toISOString(),
-        userId: ds.user?.id || ds.userId || user?.id
-      }));
-      setSessions(allDeviceSessions);
-    } catch (error) {
-      // Fallback to user sessions if device sessions fail
-      // Merge with existing sessions to preserve other accounts
-      if (__DEV__) {
-        console.warn('Failed to refresh device sessions, falling back to user sessions:', error);
-      }
+
+    // If a refresh is already in progress, return the existing promise
+    if (refreshInFlightRef.current) {
+      return refreshInFlightRef.current;
+    }
+
+    // Create the refresh promise
+    const refreshPromise = (async () => {
       try {
-        const serverSessions = await oxyServices.getSessionsBySessionId(activeSessionId);
-        const userSessions = mapServerSessionsToClient(serverSessions, user?.id);
-        // Merge with existing sessions to preserve other accounts
-        setSessions(prevSessions => {
-          const existingSessionIds = new Set(prevSessions.map(s => s.sessionId));
-          const newSessions = userSessions.filter(s => !existingSessionIds.has(s.sessionId));
-          // Combine existing sessions with new ones, prioritizing new data for existing sessions
-          const sessionMap = new Map(prevSessions.map(s => [s.sessionId, s]));
-          userSessions.forEach(s => sessionMap.set(s.sessionId, s));
-          return Array.from(sessionMap.values());
-        });
-      } catch (fallbackError) {
+        const deviceSessions = await oxyServices.getDeviceSessions(activeSessionId);
+        const allDeviceSessions = mapSessionsToClient(deviceSessions, undefined, user?.id);
+        updateSessions(allDeviceSessions, true);
+      } catch (error) {
         if (__DEV__) {
-          console.error('Refresh sessions error:', fallbackError);
+          console.warn('Failed to refresh device sessions, falling back to user sessions:', error);
         }
+        try {
+          const serverSessions = await oxyServices.getSessionsBySessionId(activeSessionId);
+          const userSessions = mapSessionsToClient(serverSessions, undefined, user?.id);
+          updateSessions(userSessions, true);
+        } catch (fallbackError) {
+          if (__DEV__) {
+            console.error('Refresh sessions error:', fallbackError);
+          }
 
-        // If the current session is invalid, try to find another valid session
-        if (sessions.length > 1) {
-          const otherSessions = sessions.filter(s => s.sessionId !== activeSessionId);
-          for (const session of otherSessions) {
-            try {
-              const validation = await oxyServices.validateSession(session.sessionId, {
-                useHeaderValidation: true
-              });
-              if (validation.valid) {
-                await switchToSession(session.sessionId);
-                return;
+          // If the current session is invalid, try to find another valid session
+          if (sessions.length > 1) {
+            const otherSessions = sessions.filter(s => s.sessionId !== activeSessionId);
+            for (const session of otherSessions) {
+              try {
+                const validation = await oxyServices.validateSession(session.sessionId, {
+                  useHeaderValidation: true
+                });
+                if (validation.valid) {
+                  await switchToSession(session.sessionId);
+                  return;
+                }
+              } catch {
+                continue;
               }
-            } catch {
-              continue;
             }
           }
-        }
 
-        // No valid sessions found, clear all
-        setSessions([]);
-        setActiveSessionId(null);
-        logoutStore();
-        setMinimalUser(null);
-        await clearAllStorage();
-        onAuthStateChange?.(null);
+          // No valid sessions found, clear all
+          updateSessions([], false);
+          setActiveSessionId(null);
+          logoutStore();
+          setMinimalUser(null);
+          await clearAllStorage();
+          onAuthStateChange?.(null);
+        }
+      } finally {
+        // Clear the in-flight ref when done
+        refreshInFlightRef.current = null;
       }
-    }
-  }, [activeSessionId, oxyServices, user?.id, sessions, switchToSession, logoutStore, clearAllStorage, onAuthStateChange, mapServerSessionsToClient]);
+    })();
+    refreshInFlightRef.current = refreshPromise;
+    return refreshPromise;
+  }, [activeSessionId, oxyServices, user?.id, updateSessions, sessions, switchToSession, logoutStore, clearAllStorage, onAuthStateChange, mapSessionsToClient]);
 
   // Device management methods
   const getDeviceSessions = (0, _react.useCallback)(async () => {
@@ -787,7 +738,7 @@ const OxyProvider = ({
     if (!activeSessionId) throw new Error('No active session');
     try {
       await oxyServices.logoutAllDeviceSessions(activeSessionId);
-      setSessions([]);
+      updateSessions([], false);
       setActiveSessionId(null);
       logoutStore();
       setMinimalUser(null);
@@ -913,6 +864,11 @@ const OxyProvider = ({
       return createEmptyFollowHook()(userId);
     }
   };
+
+  // Compute language metadata from currentLanguage
+  const languageMetadata = (0, _react.useMemo)(() => (0, _languageUtils.getLanguageMetadata)(currentLanguage), [currentLanguage]);
+  const languageName = (0, _react.useMemo)(() => (0, _languageUtils.getLanguageName)(currentLanguage), [currentLanguage]);
+  const nativeLanguageName = (0, _react.useMemo)(() => (0, _languageUtils.getNativeLanguageName)(currentLanguage), [currentLanguage]);
   const contextValue = (0, _react.useMemo)(() => ({
     user,
     minimalUser,
@@ -923,6 +879,9 @@ const OxyProvider = ({
     isTokenReady: tokenReady,
     error,
     currentLanguage,
+    currentLanguageMetadata: languageMetadata,
+    currentLanguageName: languageName,
+    currentNativeLanguageName: nativeLanguageName,
     login,
     logout,
     logoutAll,
@@ -944,7 +903,7 @@ const OxyProvider = ({
   // Only depend on user ID, not the entire user object
   minimalUser?.id, sessions.length,
   // Only depend on sessions count, not the entire array
-  activeSessionId, isAuthenticated, isLoading, tokenReady, error, currentLanguage, login, logout, logoutAll, signUp, completeMfaLogin, switchSession, removeSession, refreshSessions, setLanguage, getDeviceSessions, logoutAllDeviceSessions, updateDeviceName, oxyServices, bottomSheetRef, showBottomSheet, hideBottomSheet]);
+  activeSessionId, isAuthenticated, isLoading, tokenReady, error, currentLanguage, languageMetadata, languageName, nativeLanguageName, login, logout, logoutAll, signUp, completeMfaLogin, switchSession, removeSession, refreshSessions, setLanguage, getDeviceSessions, logoutAllDeviceSessions, updateDeviceName, oxyServices, bottomSheetRef, showBottomSheet, hideBottomSheet]);
 
   // Always render children - let the consuming app decide how to handle token loading state
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(OxyContext.Provider, {