cryptique-sdk 1.0.4 → 1.0.6

package/lib/cjs/index.js

@@ -205,6 +205,11 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
    * - Easy to add features (encryption, compression, etc.)
    * - Single place to fix storage bugs
    */
+  // In-memory cache to prevent race conditions in distinct_id generation
+  let _cachedDistinctId = null;
+  // Synchronous lock flag to prevent concurrent distinct_id generation
+  let _isGeneratingDistinctId = false;
+
   const StorageManager = {
     /**
      * Load session from sessionStorage with localStorage backup
@@ -511,44 +516,122 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
 
     /**
      * Get or create distinct_id
-     * Checks sessionStorage first, then generates new anonymous distinct_id if not found
+     * All distinct_ids (anonymous and identified) persist in localStorage
+     * Uses in-memory cache to prevent race conditions
      * 
-     * @returns {string} Current distinct_id
+     * @returns {string|Promise<string>} Current distinct_id (may be Promise if generation is in progress)
      */
     getDistinctId() {
       try {
-        // Check sessionStorage first (primary source)
-        let distinctId = sessionStorage.getItem(CONFIG.STORAGE_KEYS.DISTINCT_ID);
+        // Return cached value if we already generated one in this session
+        // This prevents race conditions during initialization
+        if (_cachedDistinctId) {
+          return _cachedDistinctId;
+        }
         
-        if (!distinctId) {
-          // Generate new anonymous distinct_id
+        // If generation is in progress, return cached or wait briefly and retry
+        if (_isGeneratingDistinctId) {
+          // Check cache again - it might have been set by the concurrent call
+          if (_cachedDistinctId) {
+            return _cachedDistinctId;
+          }
+          // If still generating, return a temporary value (shouldn't happen in practice)
+          // This prevents infinite loops
+          const tempId = `temp_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+          console.warn('⚠️ [Storage] Concurrent distinctId generation detected, returning temporary ID');
+          return tempId;
+        }
+        
+        // First check localStorage (persists across sessions for both anonymous and identified)
+        let distinctId = localStorage.getItem(CONFIG.STORAGE_KEYS.DISTINCT_ID);
+        
+        if (distinctId) {
+          // Found distinct_id in localStorage - use it and sync to sessionStorage
+          sessionStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
+          _cachedDistinctId = distinctId; // Cache it
+          return distinctId;
+        }
+        
+        // Check sessionStorage as fallback (for current session only)
+        distinctId = sessionStorage.getItem(CONFIG.STORAGE_KEYS.DISTINCT_ID);
+        
+        if (distinctId) {
+          // Found in sessionStorage - also store in localStorage for persistence
+          localStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
+          _cachedDistinctId = distinctId; // Cache it
+          return distinctId;
+        }
+        
+        // No distinct_id found - generate new anonymous one
+        // Set lock BEFORE generating to prevent concurrent generation
+        _isGeneratingDistinctId = true;
+        try {
+          // Double-check localStorage after acquiring lock (another call might have stored it)
+          let checkAgain = localStorage.getItem(CONFIG.STORAGE_KEYS.DISTINCT_ID);
+          if (checkAgain) {
+            sessionStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, checkAgain);
+            _cachedDistinctId = checkAgain;
+            return checkAgain;
+          }
+          
           const userId = this.getUserId();
           distinctId = this.generateAnonymousDistinctId(userId);
+          
+          // Store in both localStorage (persist) and sessionStorage (current session)
+          localStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
           sessionStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
+          
+          _cachedDistinctId = distinctId; // Cache it
+          return distinctId;
+        } finally {
+          _isGeneratingDistinctId = false;
         }
-        
-        return distinctId;
       } catch (err) {
         // Fallback: generate temporary distinct_id
-        console.warn('Failed to access sessionStorage for distinct_id:', err);
+        console.warn('Failed to access storage for distinct_id:', err);
         const userId = this.getUserId();
-        return this.generateAnonymousDistinctId(userId);
+        const fallbackId = this.generateAnonymousDistinctId(userId);
+        _cachedDistinctId = fallbackId; // Cache even fallback
+        _isGeneratingDistinctId = false;
+        return fallbackId;
       }
     },
 
     /**
-     * Set distinct_id in sessionStorage
+     * Set distinct_id in storage
+     * All distinct_ids (anonymous and identified) are stored in both localStorage and sessionStorage
+     * Updates in-memory cache to maintain consistency
      * 
      * @param {string} distinctId - Distinct ID to set
      */
     setDistinctId(distinctId) {
       try {
+        if (!distinctId) {
+          console.warn('⚠️ [Storage] setDistinctId called with null/undefined distinctId');
+          return;
+        }
+        
+        // Store in both localStorage (persists across sessions) and sessionStorage (current session)
+        localStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
         sessionStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
+        
+        // Update cache
+        _cachedDistinctId = distinctId;
+        
+        const type = distinctId.startsWith('anon_') ? 'anonymous' : 'identified';
+        console.log(`✅ [Storage] Stored ${type} distinct_id in localStorage and sessionStorage: ${distinctId}`);
       } catch (err) {
         console.warn('Failed to set distinct_id:', err);
       }
     },
 
+    /**
+     * Clear distinct_id cache (used during reset)
+     */
+    clearDistinctIdCache() {
+      _cachedDistinctId = null;
+    },
+
     /**
      * Get user consent status
      * 
@@ -803,6 +886,7 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
     siteId: getCurrentSiteId(),
     teamId: null,           // May be set externally or from backend
     userId: null,           // Will be set from StorageManager
+    distinctId: null,       // Will be set from StorageManager.getDistinctId()
     
     // Time fields (internal camelCase)
     startTime: null,        // ISO string
@@ -1760,6 +1844,9 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
       if (!sessionData.siteId) sessionData.siteId = currentSiteId;
       if (!sessionData.teamId) sessionData.teamId = null;
       if (!sessionData.userId) sessionData.userId = null;
+      // Always sync distinctId from storage to ensure consistency (like user_id)
+      // This ensures we use distinct_id from past sessions if it exists
+      sessionData.distinctId = StorageManager.getDistinctId();
       
       // Time fields
       if (!sessionData.startTime) sessionData.startTime = nowIso();
@@ -3868,6 +3955,7 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
         site_id: sourceData.site_id || sourceData.siteId || getCurrentSiteId() || null,
         team_id: sourceData.team_id || sourceData.teamId || null,
         user_id: sourceData.user_id || sourceData.userId || null,
+        distinct_id: sourceData.distinct_id || sourceData.distinctId || null,
         
         // Time fields (snake_case)
         start_time: sourceData.start_time || sourceData.startTime || null,
@@ -4152,6 +4240,10 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
           sessionDataToSend.sessionId = SessionIdManager.getOrCreate();
         }
 
+        // Always sync distinctId from storage before sending to backend
+        sessionDataToSend.distinctId = StorageManager.getDistinctId();
+
+
         // Transform to backend format
         const transformedData = DataTransformer.toBackendFormat(sessionDataToSend);
 
@@ -5329,6 +5421,9 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
             // Save session to storage
             StorageManager.saveSession(sessionData);
 
+            // Always sync distinctId from storage before logging/sending to ensure consistency
+            sessionData.distinctId = StorageManager.getDistinctId();
+
             // Console log raw session data intermittently
             console.log('📊 [Session] Raw Session Data:', {
               sessionData: sessionData,
@@ -5975,31 +6070,52 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
 
         const result = await response.json();
 
-        // If merge occurred or distinct_id changed, update sessionStorage and session data
-        if (result.merged && result.newDistinctId) {
-          // Update sessionStorage with new distinct_id
-          StorageManager.setDistinctId(result.newDistinctId);
+        // Always update distinct_id if present in response
+        // Prioritize result.distinctId over result.newDistinctId
+        if (result.distinctId) {
+          // Update to identified distinct_id
+          StorageManager.setDistinctId(result.distinctId);
           
           // Update session data
           if (sessionData) {
-            sessionData.distinctId = result.newDistinctId;
+            sessionData.distinctId = result.distinctId;
             sessionData.anonymous = false;
             sessionData.identified = true;
           }
           
-          console.log(`✅ [Identity] Distinct ID merged: ${currentDistinctId} → ${result.newDistinctId}`);
-        } else if (result.distinctId) {
-          // Update to identified distinct_id
-          StorageManager.setDistinctId(result.distinctId);
+          // Update stored session
+          const session = StorageManager.loadSession();
+          if (session) {
+            session.distinctId = result.distinctId;
+            session.anonymous = false;
+            session.identified = true;
+            StorageManager.saveSession(session);
+          }
+          
+          console.log(`✅ [Identity] Distinct ID updated: ${currentDistinctId} → ${result.distinctId}`);
+        } else if (result.merged && result.newDistinctId) {
+          // Fallback: use newDistinctId if distinctId not present
+          StorageManager.setDistinctId(result.newDistinctId);
           
           // Update session data
           if (sessionData) {
-            sessionData.distinctId = result.distinctId;
+            sessionData.distinctId = result.newDistinctId;
             sessionData.anonymous = false;
             sessionData.identified = true;
           }
           
-          console.log(`✅ [Identity] Distinct ID updated: ${currentDistinctId} → ${result.distinctId}`);
+          // Update stored session
+          const session = StorageManager.loadSession();
+          if (session) {
+            session.distinctId = result.newDistinctId;
+            session.anonymous = false;
+            session.identified = true;
+            StorageManager.saveSession(session);
+          }
+          
+          console.log(`✅ [Identity] Distinct ID merged: ${currentDistinctId} → ${result.newDistinctId}`);
+        } else {
+          console.warn('⚠️ [Identity] No distinctId or newDistinctId in response:', result);
         }
 
         return result;
@@ -6012,43 +6128,92 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
     /**
      * Reset identity (logout/anonymous)
      * Generates new anonymous distinct_id and clears identified state
+     * Ensures new anonymous identity exists in backend
      * 
      * @returns {Promise<Object>} Result object with new distinct_id
      */
     async reset() {
       try {
+        // Get current session and user data
+        const session = StorageManager.loadSession();
+        if (!session || !session.id) {
+          console.error('❌ [Identity] No active session found');
+          return { success: false, error: 'No active session' };
+        }
+
+        const currentUserId = StorageManager.getUserId();
+        if (!currentUserId) {
+          console.error('❌ [Identity] No user ID found');
+          return { success: false, error: 'No user ID' };
+        }
+
+        const currentSiteId = getCurrentSiteId();
+        if (!currentSiteId) {
+          console.error('❌ [Identity] Site ID not found');
+          return { success: false, error: 'Site ID not found' };
+        }
+
         // Generate new anonymous distinct_id
-        const userId = StorageManager.getUserId();
-        const newDistinctId = StorageManager.generateAnonymousDistinctId(userId);
-        
-        // Update sessionStorage
-        StorageManager.setDistinctId(newDistinctId);
+        const newDistinctId = StorageManager.generateAnonymousDistinctId(currentUserId);
         
-        // Update session data
-        const session = StorageManager.loadSession();
-        if (session) {
-          session.distinctId = newDistinctId;
-          session.anonymous = true;
-          session.identified = false;
-          StorageManager.saveSession(session);
+        // Call backend endpoint to ensure new anonymous identity exists
+        const apiUrl = CONFIG.API.TRACK.replace('/track', '/reset');
+        const response = await fetch(apiUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'X-Cryptique-Site-Id': currentSiteId
+          },
+          body: JSON.stringify({
+            siteId: currentSiteId,
+            sessionId: session.id,
+            userId: currentUserId,
+            distinctId: newDistinctId
+          })
+        });
+
+        if (!response.ok) {
+          const errorData = await response.text();
+          console.error('❌ [Identity] Reset API error:', {
+            status: response.status,
+            statusText: response.statusText,
+            error: errorData
+          });
+          throw new Error(`Reset API error: ${response.status} ${response.statusText} - ${errorData}`);
         }
+
+        const result = await response.json();
+
+        // Update local storage after backend confirms
+        StorageManager.setDistinctId(newDistinctId);
+        StorageManager.clearDistinctIdCache();
         
-        // Update sessionData if available
+        // Update sessionData
         if (sessionData) {
           sessionData.distinctId = newDistinctId;
           sessionData.anonymous = true;
           sessionData.identified = false;
         }
         
+        // Update stored session
+        const updatedSession = StorageManager.loadSession();
+        if (updatedSession) {
+          updatedSession.distinctId = newDistinctId;
+          updatedSession.anonymous = true;
+          updatedSession.identified = false;
+          StorageManager.saveSession(updatedSession);
+        }
+        
         // Clear identify_id from storage (if stored separately)
         try {
           sessionStorage.removeItem('cryptique_identify_id');
+          localStorage.removeItem('cryptique_identify_id');
         } catch (err) {
           // Ignore errors
         }
         
         console.log(`🔄 [Identity] Reset to anonymous: ${newDistinctId}`);
-        
+
         return { success: true, distinctId: newDistinctId };
       } catch (error) {
         console.error('❌ [Identity] Error in reset():', error);

package/lib/esm/index.js

@@ -203,6 +203,11 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
    * - Easy to add features (encryption, compression, etc.)
    * - Single place to fix storage bugs
    */
+  // In-memory cache to prevent race conditions in distinct_id generation
+  let _cachedDistinctId = null;
+  // Synchronous lock flag to prevent concurrent distinct_id generation
+  let _isGeneratingDistinctId = false;
+
   const StorageManager = {
     /**
      * Load session from sessionStorage with localStorage backup
@@ -509,44 +514,122 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
 
     /**
      * Get or create distinct_id
-     * Checks sessionStorage first, then generates new anonymous distinct_id if not found
+     * All distinct_ids (anonymous and identified) persist in localStorage
+     * Uses in-memory cache to prevent race conditions
      * 
-     * @returns {string} Current distinct_id
+     * @returns {string|Promise<string>} Current distinct_id (may be Promise if generation is in progress)
      */
     getDistinctId() {
       try {
-        // Check sessionStorage first (primary source)
-        let distinctId = sessionStorage.getItem(CONFIG.STORAGE_KEYS.DISTINCT_ID);
+        // Return cached value if we already generated one in this session
+        // This prevents race conditions during initialization
+        if (_cachedDistinctId) {
+          return _cachedDistinctId;
+        }
         
-        if (!distinctId) {
-          // Generate new anonymous distinct_id
+        // If generation is in progress, return cached or wait briefly and retry
+        if (_isGeneratingDistinctId) {
+          // Check cache again - it might have been set by the concurrent call
+          if (_cachedDistinctId) {
+            return _cachedDistinctId;
+          }
+          // If still generating, return a temporary value (shouldn't happen in practice)
+          // This prevents infinite loops
+          const tempId = `temp_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+          console.warn('⚠️ [Storage] Concurrent distinctId generation detected, returning temporary ID');
+          return tempId;
+        }
+        
+        // First check localStorage (persists across sessions for both anonymous and identified)
+        let distinctId = localStorage.getItem(CONFIG.STORAGE_KEYS.DISTINCT_ID);
+        
+        if (distinctId) {
+          // Found distinct_id in localStorage - use it and sync to sessionStorage
+          sessionStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
+          _cachedDistinctId = distinctId; // Cache it
+          return distinctId;
+        }
+        
+        // Check sessionStorage as fallback (for current session only)
+        distinctId = sessionStorage.getItem(CONFIG.STORAGE_KEYS.DISTINCT_ID);
+        
+        if (distinctId) {
+          // Found in sessionStorage - also store in localStorage for persistence
+          localStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
+          _cachedDistinctId = distinctId; // Cache it
+          return distinctId;
+        }
+        
+        // No distinct_id found - generate new anonymous one
+        // Set lock BEFORE generating to prevent concurrent generation
+        _isGeneratingDistinctId = true;
+        try {
+          // Double-check localStorage after acquiring lock (another call might have stored it)
+          let checkAgain = localStorage.getItem(CONFIG.STORAGE_KEYS.DISTINCT_ID);
+          if (checkAgain) {
+            sessionStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, checkAgain);
+            _cachedDistinctId = checkAgain;
+            return checkAgain;
+          }
+          
           const userId = this.getUserId();
           distinctId = this.generateAnonymousDistinctId(userId);
+          
+          // Store in both localStorage (persist) and sessionStorage (current session)
+          localStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
           sessionStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
+          
+          _cachedDistinctId = distinctId; // Cache it
+          return distinctId;
+        } finally {
+          _isGeneratingDistinctId = false;
         }
-        
-        return distinctId;
       } catch (err) {
         // Fallback: generate temporary distinct_id
-        console.warn('Failed to access sessionStorage for distinct_id:', err);
+        console.warn('Failed to access storage for distinct_id:', err);
         const userId = this.getUserId();
-        return this.generateAnonymousDistinctId(userId);
+        const fallbackId = this.generateAnonymousDistinctId(userId);
+        _cachedDistinctId = fallbackId; // Cache even fallback
+        _isGeneratingDistinctId = false;
+        return fallbackId;
       }
     },
 
     /**
-     * Set distinct_id in sessionStorage
+     * Set distinct_id in storage
+     * All distinct_ids (anonymous and identified) are stored in both localStorage and sessionStorage
+     * Updates in-memory cache to maintain consistency
      * 
      * @param {string} distinctId - Distinct ID to set
      */
     setDistinctId(distinctId) {
       try {
+        if (!distinctId) {
+          console.warn('⚠️ [Storage] setDistinctId called with null/undefined distinctId');
+          return;
+        }
+        
+        // Store in both localStorage (persists across sessions) and sessionStorage (current session)
+        localStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
         sessionStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
+        
+        // Update cache
+        _cachedDistinctId = distinctId;
+        
+        const type = distinctId.startsWith('anon_') ? 'anonymous' : 'identified';
+        console.log(`✅ [Storage] Stored ${type} distinct_id in localStorage and sessionStorage: ${distinctId}`);
       } catch (err) {
         console.warn('Failed to set distinct_id:', err);
       }
     },
 
+    /**
+     * Clear distinct_id cache (used during reset)
+     */
+    clearDistinctIdCache() {
+      _cachedDistinctId = null;
+    },
+
     /**
      * Get user consent status
      * 
@@ -801,6 +884,7 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
     siteId: getCurrentSiteId(),
     teamId: null,           // May be set externally or from backend
     userId: null,           // Will be set from StorageManager
+    distinctId: null,       // Will be set from StorageManager.getDistinctId()
     
     // Time fields (internal camelCase)
     startTime: null,        // ISO string
@@ -1758,6 +1842,9 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
       if (!sessionData.siteId) sessionData.siteId = currentSiteId;
       if (!sessionData.teamId) sessionData.teamId = null;
       if (!sessionData.userId) sessionData.userId = null;
+      // Always sync distinctId from storage to ensure consistency (like user_id)
+      // This ensures we use distinct_id from past sessions if it exists
+      sessionData.distinctId = StorageManager.getDistinctId();
       
       // Time fields
       if (!sessionData.startTime) sessionData.startTime = nowIso();
@@ -3866,6 +3953,7 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
         site_id: sourceData.site_id || sourceData.siteId || getCurrentSiteId() || null,
         team_id: sourceData.team_id || sourceData.teamId || null,
         user_id: sourceData.user_id || sourceData.userId || null,
+        distinct_id: sourceData.distinct_id || sourceData.distinctId || null,
         
         // Time fields (snake_case)
         start_time: sourceData.start_time || sourceData.startTime || null,
@@ -4150,6 +4238,10 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
           sessionDataToSend.sessionId = SessionIdManager.getOrCreate();
         }
 
+        // Always sync distinctId from storage before sending to backend
+        sessionDataToSend.distinctId = StorageManager.getDistinctId();
+
+
         // Transform to backend format
         const transformedData = DataTransformer.toBackendFormat(sessionDataToSend);
 
@@ -5327,6 +5419,9 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
             // Save session to storage
             StorageManager.saveSession(sessionData);
 
+            // Always sync distinctId from storage before logging/sending to ensure consistency
+            sessionData.distinctId = StorageManager.getDistinctId();
+
             // Console log raw session data intermittently
             console.log('📊 [Session] Raw Session Data:', {
               sessionData: sessionData,
@@ -5973,31 +6068,52 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
 
         const result = await response.json();
 
-        // If merge occurred or distinct_id changed, update sessionStorage and session data
-        if (result.merged && result.newDistinctId) {
-          // Update sessionStorage with new distinct_id
-          StorageManager.setDistinctId(result.newDistinctId);
+        // Always update distinct_id if present in response
+        // Prioritize result.distinctId over result.newDistinctId
+        if (result.distinctId) {
+          // Update to identified distinct_id
+          StorageManager.setDistinctId(result.distinctId);
           
           // Update session data
           if (sessionData) {
-            sessionData.distinctId = result.newDistinctId;
+            sessionData.distinctId = result.distinctId;
             sessionData.anonymous = false;
             sessionData.identified = true;
           }
           
-          console.log(`✅ [Identity] Distinct ID merged: ${currentDistinctId} → ${result.newDistinctId}`);
-        } else if (result.distinctId) {
-          // Update to identified distinct_id
-          StorageManager.setDistinctId(result.distinctId);
+          // Update stored session
+          const session = StorageManager.loadSession();
+          if (session) {
+            session.distinctId = result.distinctId;
+            session.anonymous = false;
+            session.identified = true;
+            StorageManager.saveSession(session);
+          }
+          
+          console.log(`✅ [Identity] Distinct ID updated: ${currentDistinctId} → ${result.distinctId}`);
+        } else if (result.merged && result.newDistinctId) {
+          // Fallback: use newDistinctId if distinctId not present
+          StorageManager.setDistinctId(result.newDistinctId);
           
           // Update session data
           if (sessionData) {
-            sessionData.distinctId = result.distinctId;
+            sessionData.distinctId = result.newDistinctId;
             sessionData.anonymous = false;
             sessionData.identified = true;
           }
           
-          console.log(`✅ [Identity] Distinct ID updated: ${currentDistinctId} → ${result.distinctId}`);
+          // Update stored session
+          const session = StorageManager.loadSession();
+          if (session) {
+            session.distinctId = result.newDistinctId;
+            session.anonymous = false;
+            session.identified = true;
+            StorageManager.saveSession(session);
+          }
+          
+          console.log(`✅ [Identity] Distinct ID merged: ${currentDistinctId} → ${result.newDistinctId}`);
+        } else {
+          console.warn('⚠️ [Identity] No distinctId or newDistinctId in response:', result);
         }
 
         return result;
@@ -6010,43 +6126,92 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
     /**
      * Reset identity (logout/anonymous)
      * Generates new anonymous distinct_id and clears identified state
+     * Ensures new anonymous identity exists in backend
      * 
      * @returns {Promise<Object>} Result object with new distinct_id
      */
     async reset() {
       try {
+        // Get current session and user data
+        const session = StorageManager.loadSession();
+        if (!session || !session.id) {
+          console.error('❌ [Identity] No active session found');
+          return { success: false, error: 'No active session' };
+        }
+
+        const currentUserId = StorageManager.getUserId();
+        if (!currentUserId) {
+          console.error('❌ [Identity] No user ID found');
+          return { success: false, error: 'No user ID' };
+        }
+
+        const currentSiteId = getCurrentSiteId();
+        if (!currentSiteId) {
+          console.error('❌ [Identity] Site ID not found');
+          return { success: false, error: 'Site ID not found' };
+        }
+
         // Generate new anonymous distinct_id
-        const userId = StorageManager.getUserId();
-        const newDistinctId = StorageManager.generateAnonymousDistinctId(userId);
-        
-        // Update sessionStorage
-        StorageManager.setDistinctId(newDistinctId);
+        const newDistinctId = StorageManager.generateAnonymousDistinctId(currentUserId);
         
-        // Update session data
-        const session = StorageManager.loadSession();
-        if (session) {
-          session.distinctId = newDistinctId;
-          session.anonymous = true;
-          session.identified = false;
-          StorageManager.saveSession(session);
+        // Call backend endpoint to ensure new anonymous identity exists
+        const apiUrl = CONFIG.API.TRACK.replace('/track', '/reset');
+        const response = await fetch(apiUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'X-Cryptique-Site-Id': currentSiteId
+          },
+          body: JSON.stringify({
+            siteId: currentSiteId,
+            sessionId: session.id,
+            userId: currentUserId,
+            distinctId: newDistinctId
+          })
+        });
+
+        if (!response.ok) {
+          const errorData = await response.text();
+          console.error('❌ [Identity] Reset API error:', {
+            status: response.status,
+            statusText: response.statusText,
+            error: errorData
+          });
+          throw new Error(`Reset API error: ${response.status} ${response.statusText} - ${errorData}`);
         }
+
+        const result = await response.json();
+
+        // Update local storage after backend confirms
+        StorageManager.setDistinctId(newDistinctId);
+        StorageManager.clearDistinctIdCache();
         
-        // Update sessionData if available
+        // Update sessionData
         if (sessionData) {
           sessionData.distinctId = newDistinctId;
           sessionData.anonymous = true;
           sessionData.identified = false;
         }
         
+        // Update stored session
+        const updatedSession = StorageManager.loadSession();
+        if (updatedSession) {
+          updatedSession.distinctId = newDistinctId;
+          updatedSession.anonymous = true;
+          updatedSession.identified = false;
+          StorageManager.saveSession(updatedSession);
+        }
+        
         // Clear identify_id from storage (if stored separately)
         try {
           sessionStorage.removeItem('cryptique_identify_id');
+          localStorage.removeItem('cryptique_identify_id');
         } catch (err) {
           // Ignore errors
         }
         
         console.log(`🔄 [Identity] Reset to anonymous: ${newDistinctId}`);
-        
+
         return { success: true, distinctId: newDistinctId };
       } catch (error) {
         console.error('❌ [Identity] Error in reset():', error);

package/lib/umd/index.js

@@ -209,6 +209,11 @@
      * - Easy to add features (encryption, compression, etc.)
      * - Single place to fix storage bugs
      */
+    // In-memory cache to prevent race conditions in distinct_id generation
+    let _cachedDistinctId = null;
+    // Synchronous lock flag to prevent concurrent distinct_id generation
+    let _isGeneratingDistinctId = false;
+
     const StorageManager = {
       /**
        * Load session from sessionStorage with localStorage backup
@@ -515,44 +520,122 @@
 
       /**
        * Get or create distinct_id
-       * Checks sessionStorage first, then generates new anonymous distinct_id if not found
+       * All distinct_ids (anonymous and identified) persist in localStorage
+       * Uses in-memory cache to prevent race conditions
        * 
-       * @returns {string} Current distinct_id
+       * @returns {string|Promise<string>} Current distinct_id (may be Promise if generation is in progress)
        */
       getDistinctId() {
         try {
-          // Check sessionStorage first (primary source)
-          let distinctId = sessionStorage.getItem(CONFIG.STORAGE_KEYS.DISTINCT_ID);
+          // Return cached value if we already generated one in this session
+          // This prevents race conditions during initialization
+          if (_cachedDistinctId) {
+            return _cachedDistinctId;
+          }
           
-          if (!distinctId) {
-            // Generate new anonymous distinct_id
+          // If generation is in progress, return cached or wait briefly and retry
+          if (_isGeneratingDistinctId) {
+            // Check cache again - it might have been set by the concurrent call
+            if (_cachedDistinctId) {
+              return _cachedDistinctId;
+            }
+            // If still generating, return a temporary value (shouldn't happen in practice)
+            // This prevents infinite loops
+            const tempId = `temp_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+            console.warn('⚠️ [Storage] Concurrent distinctId generation detected, returning temporary ID');
+            return tempId;
+          }
+          
+          // First check localStorage (persists across sessions for both anonymous and identified)
+          let distinctId = localStorage.getItem(CONFIG.STORAGE_KEYS.DISTINCT_ID);
+          
+          if (distinctId) {
+            // Found distinct_id in localStorage - use it and sync to sessionStorage
+            sessionStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
+            _cachedDistinctId = distinctId; // Cache it
+            return distinctId;
+          }
+          
+          // Check sessionStorage as fallback (for current session only)
+          distinctId = sessionStorage.getItem(CONFIG.STORAGE_KEYS.DISTINCT_ID);
+          
+          if (distinctId) {
+            // Found in sessionStorage - also store in localStorage for persistence
+            localStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
+            _cachedDistinctId = distinctId; // Cache it
+            return distinctId;
+          }
+          
+          // No distinct_id found - generate new anonymous one
+          // Set lock BEFORE generating to prevent concurrent generation
+          _isGeneratingDistinctId = true;
+          try {
+            // Double-check localStorage after acquiring lock (another call might have stored it)
+            let checkAgain = localStorage.getItem(CONFIG.STORAGE_KEYS.DISTINCT_ID);
+            if (checkAgain) {
+              sessionStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, checkAgain);
+              _cachedDistinctId = checkAgain;
+              return checkAgain;
+            }
+            
             const userId = this.getUserId();
             distinctId = this.generateAnonymousDistinctId(userId);
+            
+            // Store in both localStorage (persist) and sessionStorage (current session)
+            localStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
             sessionStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
+            
+            _cachedDistinctId = distinctId; // Cache it
+            return distinctId;
+          } finally {
+            _isGeneratingDistinctId = false;
           }
-          
-          return distinctId;
         } catch (err) {
           // Fallback: generate temporary distinct_id
-          console.warn('Failed to access sessionStorage for distinct_id:', err);
+          console.warn('Failed to access storage for distinct_id:', err);
           const userId = this.getUserId();
-          return this.generateAnonymousDistinctId(userId);
+          const fallbackId = this.generateAnonymousDistinctId(userId);
+          _cachedDistinctId = fallbackId; // Cache even fallback
+          _isGeneratingDistinctId = false;
+          return fallbackId;
         }
       },
 
       /**
-       * Set distinct_id in sessionStorage
+       * Set distinct_id in storage
+       * All distinct_ids (anonymous and identified) are stored in both localStorage and sessionStorage
+       * Updates in-memory cache to maintain consistency
        * 
        * @param {string} distinctId - Distinct ID to set
        */
       setDistinctId(distinctId) {
         try {
+          if (!distinctId) {
+            console.warn('⚠️ [Storage] setDistinctId called with null/undefined distinctId');
+            return;
+          }
+          
+          // Store in both localStorage (persists across sessions) and sessionStorage (current session)
+          localStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
           sessionStorage.setItem(CONFIG.STORAGE_KEYS.DISTINCT_ID, distinctId);
+          
+          // Update cache
+          _cachedDistinctId = distinctId;
+          
+          const type = distinctId.startsWith('anon_') ? 'anonymous' : 'identified';
+          console.log(`✅ [Storage] Stored ${type} distinct_id in localStorage and sessionStorage: ${distinctId}`);
         } catch (err) {
           console.warn('Failed to set distinct_id:', err);
         }
       },
 
+      /**
+       * Clear distinct_id cache (used during reset)
+       */
+      clearDistinctIdCache() {
+        _cachedDistinctId = null;
+      },
+
       /**
        * Get user consent status
        * 
@@ -807,6 +890,7 @@
       siteId: getCurrentSiteId(),
       teamId: null,           // May be set externally or from backend
       userId: null,           // Will be set from StorageManager
+      distinctId: null,       // Will be set from StorageManager.getDistinctId()
       
       // Time fields (internal camelCase)
       startTime: null,        // ISO string
@@ -1764,6 +1848,9 @@
         if (!sessionData.siteId) sessionData.siteId = currentSiteId;
         if (!sessionData.teamId) sessionData.teamId = null;
         if (!sessionData.userId) sessionData.userId = null;
+        // Always sync distinctId from storage to ensure consistency (like user_id)
+        // This ensures we use distinct_id from past sessions if it exists
+        sessionData.distinctId = StorageManager.getDistinctId();
         
         // Time fields
         if (!sessionData.startTime) sessionData.startTime = nowIso();
@@ -3872,6 +3959,7 @@
           site_id: sourceData.site_id || sourceData.siteId || getCurrentSiteId() || null,
           team_id: sourceData.team_id || sourceData.teamId || null,
           user_id: sourceData.user_id || sourceData.userId || null,
+          distinct_id: sourceData.distinct_id || sourceData.distinctId || null,
           
           // Time fields (snake_case)
           start_time: sourceData.start_time || sourceData.startTime || null,
@@ -4156,6 +4244,10 @@
             sessionDataToSend.sessionId = SessionIdManager.getOrCreate();
           }
 
+          // Always sync distinctId from storage before sending to backend
+          sessionDataToSend.distinctId = StorageManager.getDistinctId();
+
+
           // Transform to backend format
           const transformedData = DataTransformer.toBackendFormat(sessionDataToSend);
 
@@ -5333,6 +5425,9 @@
               // Save session to storage
               StorageManager.saveSession(sessionData);
 
+              // Always sync distinctId from storage before logging/sending to ensure consistency
+              sessionData.distinctId = StorageManager.getDistinctId();
+
               // Console log raw session data intermittently
               console.log('📊 [Session] Raw Session Data:', {
                 sessionData: sessionData,
@@ -5979,31 +6074,52 @@
 
           const result = await response.json();
 
-          // If merge occurred or distinct_id changed, update sessionStorage and session data
-          if (result.merged && result.newDistinctId) {
-            // Update sessionStorage with new distinct_id
-            StorageManager.setDistinctId(result.newDistinctId);
+          // Always update distinct_id if present in response
+          // Prioritize result.distinctId over result.newDistinctId
+          if (result.distinctId) {
+            // Update to identified distinct_id
+            StorageManager.setDistinctId(result.distinctId);
             
             // Update session data
             if (sessionData) {
-              sessionData.distinctId = result.newDistinctId;
+              sessionData.distinctId = result.distinctId;
               sessionData.anonymous = false;
               sessionData.identified = true;
             }
             
-            console.log(`✅ [Identity] Distinct ID merged: ${currentDistinctId} → ${result.newDistinctId}`);
-          } else if (result.distinctId) {
-            // Update to identified distinct_id
-            StorageManager.setDistinctId(result.distinctId);
+            // Update stored session
+            const session = StorageManager.loadSession();
+            if (session) {
+              session.distinctId = result.distinctId;
+              session.anonymous = false;
+              session.identified = true;
+              StorageManager.saveSession(session);
+            }
+            
+            console.log(`✅ [Identity] Distinct ID updated: ${currentDistinctId} → ${result.distinctId}`);
+          } else if (result.merged && result.newDistinctId) {
+            // Fallback: use newDistinctId if distinctId not present
+            StorageManager.setDistinctId(result.newDistinctId);
             
             // Update session data
             if (sessionData) {
-              sessionData.distinctId = result.distinctId;
+              sessionData.distinctId = result.newDistinctId;
               sessionData.anonymous = false;
               sessionData.identified = true;
             }
             
-            console.log(`✅ [Identity] Distinct ID updated: ${currentDistinctId} → ${result.distinctId}`);
+            // Update stored session
+            const session = StorageManager.loadSession();
+            if (session) {
+              session.distinctId = result.newDistinctId;
+              session.anonymous = false;
+              session.identified = true;
+              StorageManager.saveSession(session);
+            }
+            
+            console.log(`✅ [Identity] Distinct ID merged: ${currentDistinctId} → ${result.newDistinctId}`);
+          } else {
+            console.warn('⚠️ [Identity] No distinctId or newDistinctId in response:', result);
           }
 
           return result;
@@ -6016,43 +6132,92 @@
       /**
        * Reset identity (logout/anonymous)
        * Generates new anonymous distinct_id and clears identified state
+       * Ensures new anonymous identity exists in backend
        * 
        * @returns {Promise<Object>} Result object with new distinct_id
        */
       async reset() {
         try {
+          // Get current session and user data
+          const session = StorageManager.loadSession();
+          if (!session || !session.id) {
+            console.error('❌ [Identity] No active session found');
+            return { success: false, error: 'No active session' };
+          }
+
+          const currentUserId = StorageManager.getUserId();
+          if (!currentUserId) {
+            console.error('❌ [Identity] No user ID found');
+            return { success: false, error: 'No user ID' };
+          }
+
+          const currentSiteId = getCurrentSiteId();
+          if (!currentSiteId) {
+            console.error('❌ [Identity] Site ID not found');
+            return { success: false, error: 'Site ID not found' };
+          }
+
           // Generate new anonymous distinct_id
-          const userId = StorageManager.getUserId();
-          const newDistinctId = StorageManager.generateAnonymousDistinctId(userId);
-          
-          // Update sessionStorage
-          StorageManager.setDistinctId(newDistinctId);
+          const newDistinctId = StorageManager.generateAnonymousDistinctId(currentUserId);
           
-          // Update session data
-          const session = StorageManager.loadSession();
-          if (session) {
-            session.distinctId = newDistinctId;
-            session.anonymous = true;
-            session.identified = false;
-            StorageManager.saveSession(session);
+          // Call backend endpoint to ensure new anonymous identity exists
+          const apiUrl = CONFIG.API.TRACK.replace('/track', '/reset');
+          const response = await fetch(apiUrl, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'X-Cryptique-Site-Id': currentSiteId
+            },
+            body: JSON.stringify({
+              siteId: currentSiteId,
+              sessionId: session.id,
+              userId: currentUserId,
+              distinctId: newDistinctId
+            })
+          });
+
+          if (!response.ok) {
+            const errorData = await response.text();
+            console.error('❌ [Identity] Reset API error:', {
+              status: response.status,
+              statusText: response.statusText,
+              error: errorData
+            });
+            throw new Error(`Reset API error: ${response.status} ${response.statusText} - ${errorData}`);
           }
+
+          const result = await response.json();
+
+          // Update local storage after backend confirms
+          StorageManager.setDistinctId(newDistinctId);
+          StorageManager.clearDistinctIdCache();
           
-          // Update sessionData if available
+          // Update sessionData
           if (sessionData) {
             sessionData.distinctId = newDistinctId;
             sessionData.anonymous = true;
             sessionData.identified = false;
           }
           
+          // Update stored session
+          const updatedSession = StorageManager.loadSession();
+          if (updatedSession) {
+            updatedSession.distinctId = newDistinctId;
+            updatedSession.anonymous = true;
+            updatedSession.identified = false;
+            StorageManager.saveSession(updatedSession);
+          }
+          
           // Clear identify_id from storage (if stored separately)
           try {
             sessionStorage.removeItem('cryptique_identify_id');
+            localStorage.removeItem('cryptique_identify_id');
           } catch (err) {
             // Ignore errors
           }
           
           console.log(`🔄 [Identity] Reset to anonymous: ${newDistinctId}`);
-          
+
           return { success: true, distinctId: newDistinctId };
         } catch (error) {
           console.error('❌ [Identity] Error in reset():', error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cryptique-sdk",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "type": "module",
   "description": "Cryptique Analytics SDK - Comprehensive web analytics and user tracking for modern web applications",
   "main": "lib/cjs/index.js",