@proveanything/smartlinks-auth-ui 0.1.19 → 0.1.21

package/dist/index.js

@@ -11148,6 +11148,7 @@ const TOKEN_KEY = 'token';
 const USER_KEY = 'user';
 const ACCOUNT_DATA_KEY = 'account_data';
 const ACCOUNT_INFO_KEY = 'account_info';
+const CONTACT_ID_KEY = 'contact_id';
 const ACCOUNT_INFO_TTL = 5 * 60 * 1000; // 5 minutes default
 /**
  * Token Storage Layer
@@ -11198,6 +11199,7 @@ const tokenStorage = {
         await this.clearUser();
         await this.clearAccountData();
         await this.clearAccountInfo();
+        await this.clearContactId();
     },
     async saveAccountData(data) {
         const storage = await getStorage();
@@ -11235,20 +11237,69 @@ const tokenStorage = {
         const storage = await getStorage();
         await storage.removeItem(ACCOUNT_INFO_KEY);
     },
+    async saveContactId(contactId) {
+        const storage = await getStorage();
+        await storage.setItem(CONTACT_ID_KEY, contactId);
+    },
+    async getContactId() {
+        const storage = await getStorage();
+        return await storage.getItem(CONTACT_ID_KEY);
+    },
+    async clearContactId() {
+        const storage = await getStorage();
+        await storage.removeItem(CONTACT_ID_KEY);
+    },
 };
 
 const AuthContext = React.createContext(undefined);
-const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 * 1000, preloadAccountInfo = false }) => {
+const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 * 1000, preloadAccountInfo = false, 
+// Contact & Interaction features
+collectionId, enableContactSync, enableInteractionTracking, interactionAppId, interactionConfig, }) => {
     const [user, setUser] = React.useState(null);
     const [token, setToken] = React.useState(null);
     const [accountData, setAccountData] = React.useState(null);
     const [accountInfo, setAccountInfo] = React.useState(null);
     const [isLoading, setIsLoading] = React.useState(true);
+    const [isVerified, setIsVerified] = React.useState(false);
+    const [isOnline, setIsOnline] = React.useState(typeof navigator !== 'undefined' ? navigator.onLine : true);
+    // Contact state
+    const [contact, setContact] = React.useState(null);
+    const [contactId, setContactId] = React.useState(null);
     const callbacksRef = React.useRef(new Set());
-    // Initialization guard to prevent concurrent runs (NOT persisted across remounts)
     const initializingRef = React.useRef(false);
+    const pendingVerificationRef = React.useRef(false);
+    // Default to enabled if collectionId is provided
+    const shouldSyncContacts = enableContactSync ?? !!collectionId;
+    const shouldTrackInteractions = enableInteractionTracking ?? !!collectionId;
+    // Helper to detect if an error is a network error vs auth error
+    const isNetworkError = React.useCallback((error) => {
+        if (!error)
+            return false;
+        const errorMessage = error?.message?.toLowerCase() || '';
+        const errorName = error?.name?.toLowerCase() || '';
+        if (errorName === 'typeerror' && errorMessage.includes('fetch'))
+            return true;
+        if (errorMessage.includes('network') || errorMessage.includes('offline'))
+            return true;
+        if (errorMessage.includes('failed to fetch'))
+            return true;
+        if (errorMessage.includes('net::err_'))
+            return true;
+        if (errorMessage.includes('timeout'))
+            return true;
+        if (errorMessage.includes('dns'))
+            return true;
+        if (error?.code === 'ENOTFOUND' || error?.code === 'ETIMEDOUT')
+            return true;
+        const status = error?.status || error?.response?.status;
+        if (status === 401 || status === 403)
+            return false;
+        if (typeof navigator !== 'undefined' && !navigator.onLine)
+            return true;
+        return false;
+    }, []);
     // Notify all subscribers of auth state changes
-    const notifyAuthStateChange = React.useCallback((type, currentUser, currentToken, currentAccountData, currentAccountInfo) => {
+    const notifyAuthStateChange = React.useCallback((type, currentUser, currentToken, currentAccountData, currentAccountInfo, verified, currentContact, currentContactId) => {
         callbacksRef.current.forEach(callback => {
             try {
                 callback({
@@ -11256,7 +11307,10 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
                     user: currentUser,
                     token: currentToken,
                     accountData: currentAccountData,
-                    accountInfo: currentAccountInfo
+                    accountInfo: currentAccountInfo,
+                    isVerified: verified,
+                    contact: currentContact,
+                    contactId: currentContactId,
                 });
             }
             catch (error) {
@@ -11264,9 +11318,128 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
             }
         });
     }, []);
-    // Initialize auth state - different behavior for proxy mode vs standalone mode
+    // Sync contact to Smartlinks (non-blocking)
+    const syncContact = React.useCallback(async (authUser, customFields) => {
+        if (!collectionId || !shouldSyncContacts) {
+            console.log('[AuthContext] Contact sync skipped: no collectionId or disabled');
+            return null;
+        }
+        try {
+            console.log('[AuthContext] Syncing contact for user:', authUser.uid);
+            const result = await smartlinks__namespace.contact.publicUpsert(collectionId, {
+                userId: authUser.uid,
+                email: authUser.email,
+                displayName: authUser.displayName,
+                phone: authUser.phoneNumber,
+                customFields: customFields || {},
+                source: 'authkit',
+            });
+            console.log('[AuthContext] Contact synced:', result.contactId);
+            // Store contact ID locally
+            if (!proxyMode) {
+                await tokenStorage.saveContactId(result.contactId);
+            }
+            setContactId(result.contactId);
+            // Fetch full contact to get customFields
+            try {
+                const fullContact = await smartlinks__namespace.contact.lookup(collectionId, {
+                    email: authUser.email
+                });
+                setContact(fullContact);
+                notifyAuthStateChange('CONTACT_SYNCED', authUser, token, accountData, accountInfo, isVerified, fullContact, result.contactId);
+            }
+            catch (lookupErr) {
+                console.warn('[AuthContext] Failed to lookup full contact:', lookupErr);
+            }
+            return result.contactId;
+        }
+        catch (err) {
+            console.warn('[AuthContext] Contact sync failed (non-blocking):', err);
+            return null;
+        }
+    }, [collectionId, shouldSyncContacts, proxyMode, token, accountData, accountInfo, isVerified, notifyAuthStateChange]);
+    // Track interaction event (non-blocking)
+    const trackInteraction = React.useCallback(async (eventType, userId, currentContactId, metadata) => {
+        if (!collectionId || !shouldTrackInteractions) {
+            console.log('[AuthContext] Interaction tracking skipped: no collectionId or disabled');
+            return;
+        }
+        const interactionIdMap = {
+            login: interactionConfig?.login || 'authkit.login',
+            logout: interactionConfig?.logout || 'authkit.logout',
+            signup: interactionConfig?.signup || 'authkit.signup',
+            session_restore: interactionConfig?.sessionRestore,
+        };
+        const interactionId = interactionIdMap[eventType];
+        if (!interactionId) {
+            console.log(`[AuthContext] No interaction ID for ${eventType}, skipping`);
+            return;
+        }
+        try {
+            console.log(`[AuthContext] Tracking interaction: ${interactionId}`);
+            await smartlinks__namespace.interactions.submitPublicEvent(collectionId, {
+                collectionId,
+                interactionId,
+                userId,
+                contactId: currentContactId || undefined,
+                appId: interactionAppId,
+                eventType,
+                outcome: 'completed',
+                metadata: {
+                    ...metadata,
+                    timestamp: new Date().toISOString(),
+                    source: 'authkit',
+                },
+            });
+            console.log(`[AuthContext] Tracked interaction: ${interactionId}`);
+            notifyAuthStateChange('INTERACTION_TRACKED', user, token, accountData, accountInfo, isVerified, contact, contactId);
+        }
+        catch (err) {
+            console.warn('[AuthContext] Interaction tracking failed (non-blocking):', err);
+        }
+    }, [collectionId, shouldTrackInteractions, interactionAppId, interactionConfig, user, token, accountData, accountInfo, isVerified, contact, contactId, notifyAuthStateChange]);
+    // Get contact (with optional refresh)
+    const getContact = React.useCallback(async (forceRefresh = false) => {
+        if (!collectionId) {
+            console.log('[AuthContext] getContact: no collectionId');
+            return null;
+        }
+        // Need either email or userId to lookup contact
+        if (!user?.email && !user?.uid) {
+            console.log('[AuthContext] getContact: no user email or uid');
+            return null;
+        }
+        if (contact && !forceRefresh) {
+            return contact;
+        }
+        try {
+            // Prefer email lookup, fallback to userId for phone-only users
+            const lookupParams = user.email
+                ? { email: user.email }
+                : { userId: user.uid };
+            console.log('[AuthContext] Fetching contact with:', lookupParams);
+            const result = await smartlinks__namespace.contact.lookup(collectionId, lookupParams);
+            setContact(result);
+            setContactId(result.contactId);
+            return result;
+        }
+        catch (err) {
+            console.warn('[AuthContext] Failed to get contact:', err);
+            return null;
+        }
+    }, [collectionId, user, contact]);
+    // Update contact custom fields
+    const updateContactCustomFields = React.useCallback(async (customFields) => {
+        if (!collectionId || !contactId) {
+            throw new Error('No contact to update. Ensure collectionId is provided and user is synced.');
+        }
+        console.log('[AuthContext] Updating contact custom fields:', contactId);
+        const updated = await smartlinks__namespace.contact.update(collectionId, contactId, { customFields });
+        setContact(updated);
+        return updated;
+    }, [collectionId, contactId]);
+    // Initialize auth state
     React.useEffect(() => {
-        // Prevent concurrent initialization only
         if (initializingRef.current) {
             console.log('[AuthContext] Skipping initialization - already in progress');
             return;
@@ -11280,12 +11453,9 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
                     console.log('[AuthContext] Proxy mode: checking for existing session via auth.getAccount()');
                     try {
                         const accountResponse = await smartlinks__namespace.auth.getAccount();
-                        // auth.getAccount() always returns a response object, but uid will be
-                        // empty/undefined if no user is logged in
                         const accountAny = accountResponse;
                         const hasValidSession = accountAny?.uid && accountAny.uid.length > 0;
                         if (hasValidSession && isMounted) {
-                            // User is logged in with valid account
                             const userFromAccount = {
                                 uid: accountAny.uid,
                                 email: accountAny?.email,
@@ -11295,8 +11465,11 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
                             setUser(userFromAccount);
                             setAccountData(accountResponse);
                             setAccountInfo(accountResponse);
+                            setIsVerified(true);
                             console.log('[AuthContext] Proxy mode: initialized from parent account, uid:', accountAny.uid);
-                            notifyAuthStateChange('LOGIN', userFromAccount, null, accountResponse, accountResponse);
+                            notifyAuthStateChange('LOGIN', userFromAccount, null, accountResponse, accountResponse, true);
+                            // Sync contact in background (proxy mode)
+                            syncContact(userFromAccount, accountResponse);
                         }
                         else if (isMounted) {
                             console.log('[AuthContext] Proxy mode: no valid session (no uid), awaiting login');
@@ -11311,27 +11484,56 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
                     }
                     return;
                 }
-                // STANDALONE MODE: Load from persistent storage
+                // STANDALONE MODE: Optimistic restoration with background verification
                 const storedToken = await tokenStorage.getToken();
                 const storedUser = await tokenStorage.getUser();
                 const storedAccountData = await tokenStorage.getAccountData();
+                const storedContactId = await tokenStorage.getContactId();
                 if (storedToken && storedUser) {
-                    // Verify token FIRST before setting state
+                    if (isMounted) {
+                        setToken(storedToken.token);
+                        setUser(storedUser);
+                        setAccountData(storedAccountData);
+                        if (storedContactId) {
+                            setContactId(storedContactId);
+                        }
+                        console.log('[AuthContext] Session restored optimistically (pending verification)');
+                        notifyAuthStateChange('SESSION_RESTORED_OFFLINE', storedUser, storedToken.token, storedAccountData || null, null, false, null, storedContactId);
+                    }
+                    // BACKGROUND: Verify token
                     try {
-                        console.log('[AuthContext] Verifying stored token...');
+                        console.log('[AuthContext] Verifying stored token in background...');
                         await smartlinks__namespace.auth.verifyToken(storedToken.token);
-                        // Only set state if verification succeeded and component still mounted
                         if (isMounted) {
-                            setToken(storedToken.token);
-                            setUser(storedUser);
-                            setAccountData(storedAccountData);
-                            console.log('[AuthContext] Session restored successfully');
+                            setIsVerified(true);
+                            pendingVerificationRef.current = false;
+                            console.log('[AuthContext] Session verified successfully');
+                            notifyAuthStateChange('SESSION_VERIFIED', storedUser, storedToken.token, storedAccountData || null, null, true, null, storedContactId);
+                            // Track session restore interaction (optional)
+                            if (interactionConfig?.sessionRestore) {
+                                trackInteraction('session_restore', storedUser.uid, storedContactId);
+                            }
                         }
                     }
                     catch (err) {
-                        console.warn('[AuthContext] Token verification failed, clearing stored credentials:', err);
-                        await tokenStorage.clearAll();
-                        // Don't set user state - leave as logged out
+                        if (isNetworkError(err)) {
+                            console.warn('[AuthContext] Network error during verification, will retry on reconnect:', err);
+                            pendingVerificationRef.current = true;
+                        }
+                        else {
+                            console.warn('[AuthContext] Token verification failed (auth error), clearing credentials:', err);
+                            if (isMounted) {
+                                setToken(null);
+                                setUser(null);
+                                setAccountData(null);
+                                setContactId(null);
+                                setContact(null);
+                                setIsVerified(false);
+                                pendingVerificationRef.current = false;
+                            }
+                            await tokenStorage.clearAll();
+                            notifyAuthStateChange('LOGOUT', null, null, null, null, false);
+                        }
                     }
                 }
                 // Load cached account info if available
@@ -11353,18 +11555,16 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
             }
         };
         initializeAuth();
-        // Cleanup for hot reload
         return () => {
             isMounted = false;
         };
-    }, [proxyMode, notifyAuthStateChange]);
+    }, [proxyMode, notifyAuthStateChange, isNetworkError, syncContact, trackInteraction, interactionConfig?.sessionRestore]);
     // Listen for parent auth state changes (proxy mode only)
     React.useEffect(() => {
         if (!proxyMode)
             return;
         console.log('[AuthContext] Proxy mode: setting up parent message listener');
         const handleParentMessage = (event) => {
-            // Handle auth state pushed from parent
             if (event.data?.type === 'smartlinks:authkit:state') {
                 const { user: parentUser, accountData: parentAccountData, authenticated } = event.data.payload || {};
                 console.log('[AuthContext] Proxy mode: received state from parent:', { authenticated });
@@ -11378,15 +11578,20 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
                     setUser(userObj);
                     setAccountData(parentAccountData || null);
                     setAccountInfo(parentAccountData || null);
-                    notifyAuthStateChange('CROSS_TAB_SYNC', userObj, null, parentAccountData || null, parentAccountData || null);
+                    setIsVerified(true);
+                    notifyAuthStateChange('CROSS_TAB_SYNC', userObj, null, parentAccountData || null, parentAccountData || null, true);
+                    // Sync contact on cross-tab state
+                    syncContact(userObj, parentAccountData);
                 }
                 else {
-                    // Parent indicates no session / logged out
                     setUser(null);
                     setToken(null);
                     setAccountData(null);
                     setAccountInfo(null);
-                    notifyAuthStateChange('LOGOUT', null, null, null, null);
+                    setContact(null);
+                    setContactId(null);
+                    setIsVerified(false);
+                    notifyAuthStateChange('LOGOUT', null, null, null, null, false);
                 }
             }
         };
@@ -11395,54 +11600,60 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
             console.log('[AuthContext] Proxy mode: cleaning up parent message listener');
             window.removeEventListener('message', handleParentMessage);
         };
-    }, [proxyMode, notifyAuthStateChange]);
+    }, [proxyMode, notifyAuthStateChange, syncContact]);
     // Cross-tab synchronization - standalone mode only
     React.useEffect(() => {
         if (proxyMode)
-            return; // Skip cross-tab sync in proxy mode
+            return;
         console.log('[AuthContext] Setting up cross-tab synchronization');
         const unsubscribe = onStorageChange(async (event) => {
             console.log('[AuthContext] Cross-tab storage event:', event.type, event.key);
             try {
                 if (event.type === 'clear') {
-                    // Another tab cleared all storage (logout)
                     console.log('[AuthContext] Detected logout in another tab');
                     setToken(null);
                     setUser(null);
                     setAccountData(null);
                     setAccountInfo(null);
+                    setContact(null);
+                    setContactId(null);
+                    setIsVerified(false);
                     smartlinks__namespace.auth.logout();
-                    notifyAuthStateChange('CROSS_TAB_SYNC', null, null, null);
+                    notifyAuthStateChange('CROSS_TAB_SYNC', null, null, null, null, false);
                 }
                 else if (event.type === 'remove' && (event.key === 'token' || event.key === 'user')) {
-                    // Another tab removed token or user (logout)
                     console.log('[AuthContext] Detected token/user removal in another tab');
                     setToken(null);
                     setUser(null);
                     setAccountData(null);
                     setAccountInfo(null);
+                    setContact(null);
+                    setContactId(null);
+                    setIsVerified(false);
                     smartlinks__namespace.auth.logout();
-                    notifyAuthStateChange('CROSS_TAB_SYNC', null, null, null);
+                    notifyAuthStateChange('CROSS_TAB_SYNC', null, null, null, null, false);
                 }
                 else if (event.type === 'set' && event.key === 'token') {
-                    // Another tab set a new token (login)
                     console.log('[AuthContext] Detected login in another tab');
                     const storedToken = await tokenStorage.getToken();
                     const storedUser = await tokenStorage.getUser();
                     const storedAccountData = await tokenStorage.getAccountData();
+                    const storedContactId = await tokenStorage.getContactId();
                     if (storedToken && storedUser) {
                         setToken(storedToken.token);
                         setUser(storedUser);
                         setAccountData(storedAccountData);
-                        // Set bearer token in global Smartlinks SDK
+                        if (storedContactId) {
+                            setContactId(storedContactId);
+                        }
+                        setIsVerified(true);
                         smartlinks__namespace.auth.verifyToken(storedToken.token).catch(err => {
                             console.warn('[AuthContext] Failed to restore bearer token from cross-tab sync:', err);
                         });
-                        notifyAuthStateChange('CROSS_TAB_SYNC', storedUser, storedToken.token, storedAccountData);
+                        notifyAuthStateChange('CROSS_TAB_SYNC', storedUser, storedToken.token, storedAccountData, null, true, null, storedContactId);
                     }
                 }
                 else if (event.type === 'set' && event.key === 'account_info') {
-                    // Another tab fetched fresh account info
                     const cached = await tokenStorage.getAccountInfo();
                     if (cached && !cached.isStale) {
                         setAccountInfo(cached.data);
@@ -11459,7 +11670,7 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
             unsubscribe();
         };
     }, [proxyMode, notifyAuthStateChange]);
-    const login = React.useCallback(async (authToken, authUser, authAccountData) => {
+    const login = React.useCallback(async (authToken, authUser, authAccountData, isNewUser) => {
         try {
             // Only persist to storage in standalone mode
             if (!proxyMode) {
@@ -11468,7 +11679,6 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
                 if (authAccountData) {
                     await tokenStorage.saveAccountData(authAccountData);
                 }
-                // Set bearer token in global Smartlinks SDK via auth.verifyToken
                 smartlinks__namespace.auth.verifyToken(authToken).catch(err => {
                     console.warn('Failed to set bearer token on login:', err);
                 });
@@ -11477,8 +11687,9 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
             setToken(authToken);
             setUser(authUser);
             setAccountData(authAccountData || null);
+            setIsVerified(true);
+            pendingVerificationRef.current = false;
             // Cross-iframe auth state synchronization
-            // Always notify parent frame of login (both modes, but especially important in proxy mode)
             if (smartlinks.iframe.isIframe()) {
                 console.log('[AuthContext] Notifying parent of login via postMessage');
                 smartlinks.iframe.sendParentCustom('smartlinks:authkit:login', {
@@ -11487,7 +11698,13 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
                     accountData: authAccountData || null
                 });
             }
-            notifyAuthStateChange('LOGIN', authUser, authToken, authAccountData || null);
+            notifyAuthStateChange('LOGIN', authUser, authToken, authAccountData || null, null, true);
+            // Sync contact (non-blocking)
+            const newContactId = await syncContact(authUser, authAccountData);
+            // Track interaction (non-blocking)
+            trackInteraction(isNewUser ? 'signup' : 'login', authUser.uid, newContactId, {
+                provider: authUser.email ? 'email' : 'phone',
+            });
             // Optionally preload account info on login (standalone mode only)
             if (!proxyMode && preloadAccountInfo) {
                 getAccount(true).catch(error => {
@@ -11499,8 +11716,10 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
             console.error('Failed to save auth data to storage:', error);
             throw error;
         }
-    }, [proxyMode, notifyAuthStateChange, preloadAccountInfo]);
+    }, [proxyMode, notifyAuthStateChange, preloadAccountInfo, syncContact, trackInteraction]);
     const logout = React.useCallback(async () => {
+        const currentUser = user;
+        const currentContactId = contactId;
         try {
             // Only clear persistent storage in standalone mode
             if (!proxyMode) {
@@ -11512,21 +11731,27 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
             setUser(null);
             setAccountData(null);
             setAccountInfo(null);
+            setContact(null);
+            setContactId(null);
+            setIsVerified(false);
+            pendingVerificationRef.current = false;
             // Cross-iframe auth state synchronization
-            // Always notify parent frame of logout
             if (smartlinks.iframe.isIframe()) {
                 console.log('[AuthContext] Notifying parent of logout via postMessage');
                 smartlinks.iframe.sendParentCustom('smartlinks:authkit:logout', {});
             }
-            notifyAuthStateChange('LOGOUT', null, null, null);
+            notifyAuthStateChange('LOGOUT', null, null, null, null, false);
+            // Track logout interaction (fire and forget)
+            if (currentUser && collectionId && shouldTrackInteractions) {
+                trackInteraction('logout', currentUser.uid, currentContactId);
+            }
         }
         catch (error) {
             console.error('Failed to clear auth data from storage:', error);
         }
-    }, [proxyMode, notifyAuthStateChange]);
+    }, [proxyMode, notifyAuthStateChange, user, contactId, collectionId, shouldTrackInteractions, trackInteraction]);
     const getToken = React.useCallback(async () => {
         if (proxyMode) {
-            // In proxy mode, token is managed by parent - return memory state
             return token;
         }
         const storedToken = await tokenStorage.getToken();
@@ -11535,23 +11760,19 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
     const refreshToken = React.useCallback(async () => {
         throw new Error('Token refresh must be implemented via your backend API');
     }, []);
-    // Get account with intelligent caching (or direct parent fetch in proxy mode)
     const getAccount = React.useCallback(async (forceRefresh = false) => {
         try {
             if (proxyMode) {
-                // PROXY MODE: Always fetch from parent via proxied API, no local cache
                 console.log('[AuthContext] Proxy mode: fetching account from parent');
                 const freshAccountInfo = await smartlinks__namespace.auth.getAccount();
                 setAccountInfo(freshAccountInfo);
                 setAccountData(freshAccountInfo);
-                notifyAuthStateChange('ACCOUNT_REFRESH', user, token, freshAccountInfo, freshAccountInfo);
+                notifyAuthStateChange('ACCOUNT_REFRESH', user, token, freshAccountInfo, freshAccountInfo, isVerified, contact, contactId);
                 return freshAccountInfo;
             }
-            // STANDALONE MODE: Use caching
             if (!token) {
                 throw new Error('Not authenticated. Please login first.');
             }
-            // Check cache unless force refresh
             if (!forceRefresh) {
                 const cached = await tokenStorage.getAccountInfo();
                 if (cached && !cached.isStale) {
@@ -11559,18 +11780,15 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
                     return cached.data;
                 }
             }
-            // Fetch fresh data from API
             console.log('[AuthContext] Fetching fresh account info from API');
             const freshAccountInfo = await smartlinks__namespace.auth.getAccount();
-            // Cache the fresh data
             await tokenStorage.saveAccountInfo(freshAccountInfo, accountCacheTTL);
             setAccountInfo(freshAccountInfo);
-            notifyAuthStateChange('ACCOUNT_REFRESH', user, token, accountData, freshAccountInfo);
+            notifyAuthStateChange('ACCOUNT_REFRESH', user, token, accountData, freshAccountInfo, isVerified, contact, contactId);
             return freshAccountInfo;
         }
         catch (error) {
             console.error('[AuthContext] Failed to get account info:', error);
-            // Fallback to stale cache if API fails (standalone mode only)
             if (!proxyMode) {
                 const cached = await tokenStorage.getAccountInfo();
                 if (cached) {
@@ -11580,12 +11798,10 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
             }
             throw error;
         }
-    }, [proxyMode, token, accountCacheTTL, user, accountData, notifyAuthStateChange]);
-    // Convenience method for explicit refresh
+    }, [proxyMode, token, accountCacheTTL, user, accountData, isVerified, contact, contactId, notifyAuthStateChange]);
     const refreshAccount = React.useCallback(async () => {
         return await getAccount(true);
     }, [getAccount]);
-    // Clear account cache (no-op in proxy mode)
     const clearAccountCache = React.useCallback(async () => {
         if (!proxyMode) {
             await tokenStorage.clearAccountInfo();
@@ -11594,19 +11810,77 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
     }, [proxyMode]);
     const onAuthStateChange = React.useCallback((callback) => {
         callbacksRef.current.add(callback);
-        // Return unsubscribe function
         return () => {
             callbacksRef.current.delete(callback);
         };
     }, []);
+    const retryVerification = React.useCallback(async () => {
+        if (!token || !user) {
+            console.log('[AuthContext] No session to verify');
+            return false;
+        }
+        if (isVerified) {
+            console.log('[AuthContext] Session already verified');
+            return true;
+        }
+        try {
+            console.log('[AuthContext] Retrying session verification...');
+            await smartlinks__namespace.auth.verifyToken(token);
+            setIsVerified(true);
+            pendingVerificationRef.current = false;
+            console.log('[AuthContext] Session verified on retry');
+            notifyAuthStateChange('SESSION_VERIFIED', user, token, accountData, accountInfo, true, contact, contactId);
+            return true;
+        }
+        catch (err) {
+            if (isNetworkError(err)) {
+                console.warn('[AuthContext] Network still unavailable, will retry later');
+                return false;
+            }
+            else {
+                console.warn('[AuthContext] Session invalid on retry, logging out');
+                await logout();
+                return false;
+            }
+        }
+    }, [token, user, isVerified, accountData, accountInfo, contact, contactId, notifyAuthStateChange, isNetworkError, logout]);
+    // Online/offline event listener for auto-retry verification
+    React.useEffect(() => {
+        if (proxyMode)
+            return;
+        const handleOnline = () => {
+            console.log('[AuthContext] Network reconnected');
+            setIsOnline(true);
+            if (pendingVerificationRef.current && token && user) {
+                console.log('[AuthContext] Retrying pending verification after reconnect...');
+                retryVerification();
+            }
+        };
+        const handleOffline = () => {
+            console.log('[AuthContext] Network disconnected');
+            setIsOnline(false);
+        };
+        window.addEventListener('online', handleOnline);
+        window.addEventListener('offline', handleOffline);
+        return () => {
+            window.removeEventListener('online', handleOnline);
+            window.removeEventListener('offline', handleOffline);
+        };
+    }, [proxyMode, token, user, retryVerification]);
     const value = {
         user,
         token,
         accountData,
         accountInfo,
         isAuthenticated: !!user,
+        isVerified,
         isLoading,
+        isOnline,
         proxyMode,
+        contact,
+        contactId,
+        getContact,
+        updateContactCustomFields,
         login,
         logout,
         getToken,
@@ -11615,6 +11889,7 @@ const AuthProvider = ({ children, proxyMode = false, accountCacheTTL = 5 * 60 *
         refreshAccount,
         clearAccountCache,
         onAuthStateChange,
+        retryVerification,
     };
     return jsxRuntime.jsx(AuthContext.Provider, { value: value, children: children });
 };
@@ -11893,7 +12168,7 @@ const SmartlinksAuthUI = ({ apiEndpoint, clientId, clientName, accountData, onAu
                 const verificationMode = response.emailVerificationMode || config?.emailVerification?.mode || 'verify-then-auto-login';
                 if ((verificationMode === 'verify-then-auto-login' || verificationMode === 'immediate') && response.token) {
                     // Auto-login modes: Log the user in immediately if token is provided
-                    auth.login(response.token, response.user, response.accountData);
+                    auth.login(response.token, response.user, response.accountData, true);
                     setAuthSuccess(true);
                     setSuccessMessage('Email verified successfully! You are now logged in.');
                     onAuthSuccess(response.token, response.user, response.accountData);
@@ -11936,7 +12211,7 @@ const SmartlinksAuthUI = ({ apiEndpoint, clientId, clientName, accountData, onAu
                 const response = await api.verifyMagicLink(token);
                 // Auto-login with magic link if token is provided
                 if (response.token) {
-                    auth.login(response.token, response.user, response.accountData);
+                    auth.login(response.token, response.user, response.accountData, true);
                     setAuthSuccess(true);
                     setSuccessMessage('Magic link verified! You are now logged in.');
                     onAuthSuccess(response.token, response.user, response.accountData);
@@ -12011,8 +12286,8 @@ const SmartlinksAuthUI = ({ apiEndpoint, clientId, clientName, accountData, onAu
             if (mode === 'register') {
                 // Handle different verification modes
                 if (verificationMode === 'immediate' && response.token) {
-                    // Immediate mode: Log in right away if token is provided
-                    auth.login(response.token, response.user, response.accountData);
+                    // Immediate mode: Log in right away if token is provided (isNewUser=true for registration)
+                    auth.login(response.token, response.user, response.accountData, true);
                     setAuthSuccess(true);
                     const deadline = response.emailVerificationDeadline
                         ? new Date(response.emailVerificationDeadline).toLocaleString()
@@ -12048,7 +12323,7 @@ const SmartlinksAuthUI = ({ apiEndpoint, clientId, clientName, accountData, onAu
                     if (response.requiresEmailVerification) {
                         throw new Error('Please verify your email before logging in. Check your inbox for the verification link.');
                     }
-                    auth.login(response.token, response.user, response.accountData);
+                    auth.login(response.token, response.user, response.accountData, false);
                     setAuthSuccess(true);
                     setSuccessMessage('Login successful!');
                     onAuthSuccess(response.token, response.user, response.accountData);
@@ -12208,7 +12483,8 @@ const SmartlinksAuthUI = ({ apiEndpoint, clientId, clientName, accountData, onAu
                                     tokenType: 'access_token',
                                 });
                                 if (authResponse.token) {
-                                    auth.login(authResponse.token, authResponse.user, authResponse.accountData);
+                                    // Google OAuth can be login or signup - use isNewUser flag from backend if available
+                                    auth.login(authResponse.token, authResponse.user, authResponse.accountData, authResponse.isNewUser);
                                     setAuthSuccess(true);
                                     setSuccessMessage('Google login successful!');
                                     onAuthSuccess(authResponse.token, authResponse.user, authResponse.accountData);
@@ -12257,7 +12533,8 @@ const SmartlinksAuthUI = ({ apiEndpoint, clientId, clientName, accountData, onAu
                             const idToken = response.credential;
                             const authResponse = await api.loginWithGoogle(idToken);
                             if (authResponse.token) {
-                                auth.login(authResponse.token, authResponse.user, authResponse.accountData);
+                                // Google OAuth can be login or signup - use isNewUser flag from backend if available
+                                auth.login(authResponse.token, authResponse.user, authResponse.accountData, authResponse.isNewUser);
                                 setAuthSuccess(true);
                                 setSuccessMessage('Google login successful!');
                                 onAuthSuccess(authResponse.token, authResponse.user, authResponse.accountData);
@@ -12318,7 +12595,8 @@ const SmartlinksAuthUI = ({ apiEndpoint, clientId, clientName, accountData, onAu
                 const response = await api.verifyPhoneCode(phoneNumber, verificationCode);
                 // Update auth context with account data if token is provided
                 if (response.token) {
-                    auth.login(response.token, response.user, response.accountData);
+                    // Phone auth can be login or signup - use isNewUser flag from backend if available
+                    auth.login(response.token, response.user, response.accountData, response.isNewUser);
                     onAuthSuccess(response.token, response.user, response.accountData);
                     if (redirectUrl) {
                         window.location.href = redirectUrl;