@tracelog/lib 0.0.8 → 0.2.0

package/dist/esm/managers/session.manager.js

@@ -1,583 +1,328 @@
-import { DEFAULT_MOTION_THRESHOLD, DEFAULT_SESSION_TIMEOUT_MS, DEFAULT_THROTTLE_DELAY_MS, DEFAULT_VISIBILITY_TIMEOUT_MS, } from '../constants';
-import { DeviceType, EventType } from '../types';
-import { generateUUID, getDeviceType } from '../utils';
+import { BROADCAST_CHANNEL_NAME, DEFAULT_SESSION_TIMEOUT, SESSION_STORAGE_KEY } from '../constants';
+import { EventType } from '../types';
 import { debugLog } from '../utils/logging';
-import { ActivityListenerManager, KeyboardListenerManager, MouseListenerManager, TouchListenerManager, UnloadListenerManager, VisibilityListenerManager, } from '../listeners';
 import { StateManager } from './state.manager';
-import { SessionRecoveryManager } from './session-recovery.manager';
 export class SessionManager extends StateManager {
-    constructor(onActivity, onInactivity, eventManager, storageManager, sessionEndConfig) {
+    constructor(storageManager, eventManager) {
         super();
-        this.eventManager = null;
-        this.storageManager = null;
-        this.listenerManagers = [];
-        // Recovery manager
-        this.recoveryManager = null;
-        this.isSessionActive = false;
-        this.lastActivityTime = 0;
-        this.inactivityTimer = null;
-        this.sessionStartTime = 0;
-        this.throttleTimeout = null;
-        // Track visibility change timeout for proper cleanup
-        this.visibilityChangeTimeout = null;
-        // Session End Management
-        this.pendingSessionEnd = false;
-        this.sessionEndPromise = null;
-        this.sessionEndLock = Promise.resolve({
-            success: true,
-            reason: 'manual_stop',
-            timestamp: Date.now(),
-            eventsFlushed: 0,
-            method: 'async',
-        });
-        this.cleanupHandlers = [];
-        this.sessionEndReason = null;
-        this.sessionEndPriority = {
-            page_unload: 4,
-            manual_stop: 3,
-            orphaned_cleanup: 2,
-            inactivity: 1,
-            tab_closed: 0,
-        };
-        this.sessionEndStats = {
-            totalSessionEnds: 0,
-            successfulEnds: 0,
-            failedEnds: 0,
-            duplicatePrevented: 0,
-            reasonCounts: {
-                inactivity: 0,
-                page_unload: 0,
-                manual_stop: 0,
-                orphaned_cleanup: 0,
-                tab_closed: 0,
-            },
-        };
-        // Session health monitoring
-        this.sessionHealth = {
-            recoveryAttempts: 0,
-            sessionTimeouts: 0,
-            crossTabConflicts: 0,
-            lastHealthCheck: Date.now(),
-        };
-        this.handleActivity = () => {
-            const now = Date.now();
-            if (now - this.lastActivityTime < this.config.throttleDelay) {
+        this.sessionTimeoutId = null;
+        this.broadcastChannel = null;
+        this.activityHandler = null;
+        this.visibilityChangeHandler = null;
+        this.beforeUnloadHandler = null;
+        this.isTracking = false;
+        this.storageManager = storageManager;
+        this.eventManager = eventManager;
+    }
+    /**
+     * Initialize cross-tab synchronization
+     */
+    initCrossTabSync() {
+        if (typeof BroadcastChannel === 'undefined') {
+            debugLog.warn('SessionManager', 'BroadcastChannel not supported');
+            return;
+        }
+        const projectId = this.getProjectId();
+        this.broadcastChannel = new BroadcastChannel(BROADCAST_CHANNEL_NAME(projectId));
+        this.broadcastChannel.onmessage = (event) => {
+            const { action, sessionId, timestamp, projectId: messageProjectId } = event.data ?? {};
+            if (messageProjectId !== projectId) {
                 return;
             }
-            this.lastActivityTime = now;
-            if (this.isSessionActive) {
-                // Always call onActivity to update cross-tab session activity
-                this.onActivity();
-                this.resetInactivityTimer();
+            if (action === 'session_end') {
+                debugLog.debug('SessionManager', 'Session end synced from another tab');
+                this.resetSessionState();
+                return;
             }
-            else {
-                if (this.throttleTimeout) {
-                    clearTimeout(this.throttleTimeout);
-                    this.throttleTimeout = null;
+            if (sessionId && typeof timestamp === 'number' && timestamp > Date.now() - 5000) {
+                this.set('sessionId', sessionId);
+                this.set('hasStartSession', true);
+                this.persistSession(sessionId, timestamp);
+                if (this.isTracking) {
+                    this.setupSessionTimeout();
                 }
-                this.throttleTimeout = window.setTimeout(() => {
-                    this.onActivity();
-                    this.throttleTimeout = null;
-                }, 100);
-            }
-        };
-        this.handleInactivity = () => {
-            // Track session timeout for health monitoring
-            this.trackSessionHealth('timeout');
-            this.onInactivity();
-        };
-        this.handleVisibilityChange = () => {
-            if (document.hidden) {
-                if (this.isSessionActive) {
-                    if (this.inactivityTimer) {
-                        clearTimeout(this.inactivityTimer);
-                        this.inactivityTimer = null;
-                    }
-                    this.inactivityTimer = window.setTimeout(this.handleInactivity, this.config.visibilityTimeout);
-                }
-            }
-            else {
-                this.handleActivity();
-            }
-        };
-        this.resetInactivityTimer = () => {
-            if (this.inactivityTimer) {
-                clearTimeout(this.inactivityTimer);
-                this.inactivityTimer = null;
+                debugLog.debug('SessionManager', 'Session synced from another tab', { sessionId });
             }
-            if (this.isSessionActive) {
-                this.inactivityTimer = window.setTimeout(() => {
-                    this.handleInactivity();
-                }, this.config.timeout);
-            }
-        };
-        this.config = {
-            throttleDelay: DEFAULT_THROTTLE_DELAY_MS,
-            visibilityTimeout: DEFAULT_VISIBILITY_TIMEOUT_MS,
-            motionThreshold: DEFAULT_MOTION_THRESHOLD,
-            timeout: this.get('config')?.sessionTimeout ?? DEFAULT_SESSION_TIMEOUT_MS,
         };
-        this.sessionEndConfig = {
-            enablePageUnloadHandlers: true,
-            syncTimeoutMs: 1000,
-            maxRetries: 2,
-            debugMode: false,
-            ...sessionEndConfig,
-        };
-        this.onActivity = onActivity;
-        this.onInactivity = onInactivity;
-        this.eventManager = eventManager ?? null;
-        this.storageManager = storageManager ?? null;
-        this.deviceCapabilities = this.detectDeviceCapabilities();
-        this.initializeRecoveryManager();
-        this.initializeListenerManagers();
-        this.setupAllListeners();
-        if (this.sessionEndConfig.enablePageUnloadHandlers) {
-            this.setupPageUnloadHandlers();
-        }
-        debugLog.debug('SessionManager', 'SessionManager initialized', {
-            sessionTimeout: this.config.timeout,
-            deviceCapabilities: this.deviceCapabilities,
-            unloadHandlersEnabled: this.sessionEndConfig.enablePageUnloadHandlers,
-        });
     }
     /**
-     * Initialize recovery manager
+     * Share session with other tabs
      */
-    initializeRecoveryManager() {
-        if (!this.storageManager)
-            return;
-        const projectId = this.get('config')?.id;
-        if (!projectId)
+    shareSession(sessionId) {
+        this.broadcastChannel?.postMessage({
+            action: 'session_start',
+            projectId: this.getProjectId(),
+            sessionId,
+            timestamp: Date.now(),
+        });
+    }
+    broadcastSessionEnd(sessionId, reason) {
+        if (!sessionId) {
             return;
-        try {
-            // Initialize session recovery manager (always enabled)
-            this.recoveryManager = new SessionRecoveryManager(this.storageManager, projectId, this.eventManager ?? undefined);
-            debugLog.debug('SessionManager', 'Recovery manager initialized', { projectId });
-        }
-        catch (error) {
-            debugLog.error('SessionManager', 'Failed to initialize recovery manager', { error, projectId });
         }
+        this.broadcastChannel?.postMessage({
+            action: 'session_end',
+            projectId: this.getProjectId(),
+            sessionId,
+            reason,
+            timestamp: Date.now(),
+        });
     }
     /**
-     * Store session context for recovery
+     * Cleanup cross-tab sync
      */
-    storeSessionContextForRecovery() {
-        if (!this.recoveryManager)
-            return;
-        const sessionId = this.get('sessionId');
-        if (!sessionId)
-            return;
-        const sessionContext = {
-            sessionId,
-            startTime: this.sessionStartTime,
-            lastActivity: this.lastActivityTime,
-            tabCount: 1, // This will be updated by cross-tab manager
-            recoveryAttempts: 0,
-            metadata: {
-                userAgent: navigator.userAgent,
-                pageUrl: this.get('pageUrl'),
-            },
-        };
-        this.recoveryManager.storeSessionContextForRecovery(sessionContext);
-    }
-    startSession() {
-        const now = Date.now();
-        // Attempt session recovery first
-        let sessionId = '';
-        let wasRecovered = false;
-        if (this.recoveryManager?.hasRecoverableSession()) {
-            const recoveryResult = this.recoveryManager.attemptSessionRecovery();
-            if (recoveryResult.recovered && recoveryResult.recoveredSessionId) {
-                sessionId = recoveryResult.recoveredSessionId;
-                wasRecovered = true;
-                // Track session recovery for health monitoring
-                this.trackSessionHealth('recovery');
-                // Update session timing from recovery context
-                if (recoveryResult.context) {
-                    this.sessionStartTime = recoveryResult.context.startTime;
-                    this.lastActivityTime = now;
-                }
-                else {
-                    this.sessionStartTime = now;
-                    this.lastActivityTime = now;
-                }
-                debugLog.info('SessionManager', 'Session successfully recovered', {
-                    sessionId,
-                    recoveryAttempts: this.sessionHealth.recoveryAttempts,
-                });
-            }
-        }
-        // If no recovery, create new session
-        if (!wasRecovered) {
-            sessionId = generateUUID();
-            this.sessionStartTime = now;
-            this.lastActivityTime = now;
-            debugLog.info('SessionManager', 'New session started', { sessionId });
+    cleanupCrossTabSync() {
+        if (this.broadcastChannel) {
+            this.broadcastChannel.close();
+            this.broadcastChannel = null;
         }
-        this.isSessionActive = true;
-        this.resetInactivityTimer();
-        // Store session context for future recovery
-        this.storeSessionContextForRecovery();
-        return { sessionId, recovered: wasRecovered };
     }
-    endSession() {
-        if (this.sessionStartTime === 0) {
-            return 0;
+    /**
+     * Recover session from localStorage if it exists and hasn't expired
+     */
+    recoverSession() {
+        const storedSession = this.loadStoredSession();
+        if (!storedSession) {
+            return null;
         }
-        const durationMs = Date.now() - this.sessionStartTime;
-        this.sessionStartTime = 0;
-        this.isSessionActive = false;
-        if (this.inactivityTimer) {
-            clearTimeout(this.inactivityTimer);
-            this.inactivityTimer = null;
+        const sessionTimeout = this.get('config')?.sessionTimeout ?? DEFAULT_SESSION_TIMEOUT;
+        if (Date.now() - storedSession.lastActivity > sessionTimeout) {
+            debugLog.debug('SessionManager', 'Stored session expired');
+            this.clearStoredSession();
+            return null;
         }
-        return durationMs;
+        debugLog.info('SessionManager', 'Session recovered from storage', { sessionId: storedSession.id });
+        return storedSession.id;
     }
-    destroy() {
-        this.clearTimers();
-        this.cleanupAllListeners();
-        this.resetState();
-        this.cleanupHandlers.forEach((cleanup) => cleanup());
-        this.cleanupHandlers = [];
-        this.pendingSessionEnd = false;
-        this.sessionEndPromise = null;
-        this.sessionEndLock = Promise.resolve({
-            success: true,
-            reason: 'manual_stop',
-            timestamp: Date.now(),
-            eventsFlushed: 0,
-            method: 'async',
+    /**
+     * Persist session data to localStorage
+     */
+    persistSession(sessionId, lastActivity = Date.now()) {
+        this.saveStoredSession({
+            id: sessionId,
+            lastActivity,
         });
-        if (this.recoveryManager) {
-            this.recoveryManager.cleanupOldRecoveryAttempts();
-            this.recoveryManager = null;
-        }
     }
-    detectDeviceCapabilities() {
-        const hasTouch = 'ontouchstart' in window || navigator.maxTouchPoints > 0;
-        const hasMouse = window.matchMedia('(pointer: fine)').matches;
-        const hasKeyboard = !window.matchMedia('(pointer: coarse)').matches;
-        const isMobile = getDeviceType() === DeviceType.Mobile;
-        return { hasTouch, hasMouse, hasKeyboard, isMobile };
+    clearStoredSession() {
+        const storageKey = this.getSessionStorageKey();
+        this.storageManager.removeItem(storageKey);
     }
-    initializeListenerManagers() {
-        this.listenerManagers.push(new ActivityListenerManager(this.handleActivity));
-        if (this.deviceCapabilities.hasTouch) {
-            this.listenerManagers.push(new TouchListenerManager(this.handleActivity, this.config.motionThreshold));
+    loadStoredSession() {
+        const storageKey = this.getSessionStorageKey();
+        const storedData = this.storageManager.getItem(storageKey);
+        if (!storedData) {
+            return null;
         }
-        if (this.deviceCapabilities.hasMouse) {
-            this.listenerManagers.push(new MouseListenerManager(this.handleActivity));
+        try {
+            const parsed = JSON.parse(storedData);
+            if (!parsed.id || typeof parsed.lastActivity !== 'number') {
+                return null;
+            }
+            return parsed;
         }
-        if (this.deviceCapabilities.hasKeyboard) {
-            this.listenerManagers.push(new KeyboardListenerManager(this.handleActivity));
+        catch {
+            this.storageManager.removeItem(storageKey);
+            return null;
         }
-        this.listenerManagers.push(new VisibilityListenerManager(this.handleActivity, this.handleVisibilityChange, this.deviceCapabilities.isMobile));
-        this.listenerManagers.push(new UnloadListenerManager(this.handleInactivity));
     }
-    setupAllListeners() {
-        this.listenerManagers.forEach((manager) => manager.setup());
+    saveStoredSession(session) {
+        const storageKey = this.getSessionStorageKey();
+        this.storageManager.setItem(storageKey, JSON.stringify(session));
+    }
+    getSessionStorageKey() {
+        return SESSION_STORAGE_KEY(this.getProjectId());
     }
-    cleanupAllListeners() {
-        this.listenerManagers.forEach((manager) => manager.cleanup());
+    getProjectId() {
+        return this.get('config')?.id ?? '';
     }
-    clearTimers() {
-        if (this.inactivityTimer) {
-            clearTimeout(this.inactivityTimer);
-            this.inactivityTimer = null;
+    /**
+     * Start session tracking
+     */
+    async startTracking() {
+        if (this.isTracking) {
+            debugLog.warn('SessionManager', 'Session tracking already active');
+            return;
         }
-        if (this.throttleTimeout) {
-            clearTimeout(this.throttleTimeout);
-            this.throttleTimeout = null;
+        const recoveredSessionId = this.recoverSession();
+        const sessionId = recoveredSessionId ?? this.generateSessionId();
+        const isRecovered = Boolean(recoveredSessionId);
+        this.isTracking = true;
+        try {
+            this.set('sessionId', sessionId);
+            this.persistSession(sessionId);
+            // Track session start event
+            this.eventManager.track({
+                type: EventType.SESSION_START,
+                ...(isRecovered && { session_start_recovered: true }),
+            });
+            // Initialize components
+            this.initCrossTabSync();
+            this.shareSession(sessionId);
+            this.setupSessionTimeout();
+            this.setupActivityListeners();
+            this.setupLifecycleListeners();
+            debugLog.info('SessionManager', 'Session tracking started', { sessionId, recovered: isRecovered });
+        }
+        catch (error) {
+            this.isTracking = false;
+            this.clearSessionTimeout();
+            this.cleanupActivityListeners();
+            this.cleanupLifecycleListeners();
+            this.cleanupCrossTabSync();
+            this.set('sessionId', null);
+            throw error;
         }
     }
-    resetState() {
-        this.isSessionActive = false;
-        this.lastActivityTime = 0;
-        this.sessionStartTime = 0;
+    /**
+     * Generate unique session ID
+     */
+    generateSessionId() {
+        return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
     }
-    clearInactivityTimer() {
-        if (this.inactivityTimer) {
-            clearTimeout(this.inactivityTimer);
-            this.inactivityTimer = null;
-        }
+    /**
+     * Setup session timeout
+     */
+    setupSessionTimeout() {
+        this.clearSessionTimeout();
+        const sessionTimeout = this.get('config')?.sessionTimeout ?? DEFAULT_SESSION_TIMEOUT;
+        this.sessionTimeoutId = setTimeout(() => {
+            this.endSession('inactivity');
+        }, sessionTimeout);
     }
-    shouldProceedWithSessionEnd(reason) {
-        return !this.sessionEndReason || this.sessionEndPriority[reason] > this.sessionEndPriority[this.sessionEndReason];
+    /**
+     * Reset session timeout and update activity
+     */
+    resetSessionTimeout() {
+        this.setupSessionTimeout();
+        const sessionId = this.get('sessionId');
+        if (sessionId) {
+            this.persistSession(sessionId);
+        }
     }
-    async waitForCompletion() {
-        if (this.sessionEndPromise) {
-            return await this.sessionEndPromise;
+    /**
+     * Clear session timeout
+     */
+    clearSessionTimeout() {
+        if (this.sessionTimeoutId) {
+            clearTimeout(this.sessionTimeoutId);
+            this.sessionTimeoutId = null;
         }
-        return {
-            success: false,
-            reason: 'inactivity',
-            timestamp: Date.now(),
-            eventsFlushed: 0,
-            method: 'async',
-        };
     }
-    async endSessionManaged(reason) {
-        return (this.sessionEndLock = this.sessionEndLock.then(async () => {
-            this.sessionEndStats.totalSessionEnds++;
-            this.sessionEndStats.reasonCounts[reason]++;
-            if (this.pendingSessionEnd) {
-                this.sessionEndStats.duplicatePrevented++;
-                debugLog.debug('SessionManager', 'Session end already pending, waiting for completion', { reason });
-                return this.waitForCompletion();
-            }
-            if (!this.shouldProceedWithSessionEnd(reason)) {
-                if (this.sessionEndConfig.debugMode) {
-                    debugLog.debug('SessionManager', `Session end skipped due to lower priority. Current: ${this.sessionEndReason}, Requested: ${reason}`);
-                }
-                return {
-                    success: false,
-                    reason,
-                    timestamp: Date.now(),
-                    eventsFlushed: 0,
-                    method: 'async',
-                };
-            }
-            this.sessionEndReason = reason;
-            this.pendingSessionEnd = true;
-            this.sessionEndPromise = this.performSessionEnd(reason, 'async');
-            try {
-                const result = await this.sessionEndPromise;
-                return result;
-            }
-            finally {
-                this.pendingSessionEnd = false;
-                this.sessionEndPromise = null;
-                this.sessionEndReason = null;
-            }
-        }));
+    /**
+     * Setup activity listeners to track user engagement
+     */
+    setupActivityListeners() {
+        this.activityHandler = () => this.resetSessionTimeout();
+        document.addEventListener('click', this.activityHandler, { passive: true });
+        document.addEventListener('keydown', this.activityHandler, { passive: true });
+        document.addEventListener('scroll', this.activityHandler, { passive: true });
     }
-    endSessionSafely(reason, options) {
-        const shouldUseSync = options?.forceSync ?? (options?.allowSync && ['page_unload', 'tab_closed'].includes(reason));
-        if (shouldUseSync) {
-            return this.endSessionManagedSync(reason);
+    /**
+     * Clean up activity listeners
+     */
+    cleanupActivityListeners() {
+        if (this.activityHandler) {
+            document.removeEventListener('click', this.activityHandler);
+            document.removeEventListener('keydown', this.activityHandler);
+            document.removeEventListener('scroll', this.activityHandler);
+            this.activityHandler = null;
         }
-        return this.endSessionManaged(reason);
-    }
-    isPendingSessionEnd() {
-        return this.pendingSessionEnd;
     }
     /**
-     * Track session health events for monitoring and diagnostics
+     * Setup page lifecycle listeners (visibility and unload)
      */
-    trackSessionHealth(event) {
-        const now = Date.now();
-        // Update health counters
-        switch (event) {
-            case 'recovery':
-                this.sessionHealth.recoveryAttempts++;
-                break;
-            case 'timeout':
-                this.sessionHealth.sessionTimeouts++;
-                break;
-            case 'conflict':
-                this.sessionHealth.crossTabConflicts++;
-                break;
+    setupLifecycleListeners() {
+        if (this.visibilityChangeHandler || this.beforeUnloadHandler) {
+            return;
         }
-        this.sessionHealth.lastHealthCheck = now;
-        // Send health degradation event if recovery attempts are high
-        if (this.sessionHealth.recoveryAttempts > 3 && this.eventManager) {
-            this.eventManager.track({
-                type: EventType.CUSTOM,
-                custom_event: {
-                    name: 'session_health_degraded',
-                    metadata: {
-                        ...this.sessionHealth,
-                        event_trigger: event,
-                    },
-                },
-            });
-            if (this.sessionEndConfig.debugMode) {
-                debugLog.warn('SessionManager', `Session health degraded: ${this.sessionHealth.recoveryAttempts} recovery attempts`);
+        this.visibilityChangeHandler = () => {
+            if (document.hidden) {
+                this.clearSessionTimeout();
             }
+            else {
+                const sessionId = this.get('sessionId');
+                if (sessionId) {
+                    this.setupSessionTimeout();
+                }
+            }
+        };
+        this.beforeUnloadHandler = () => {
+            this.eventManager.flushImmediatelySync();
+        };
+        // Handle tab visibility changes
+        document.addEventListener('visibilitychange', this.visibilityChangeHandler);
+        // Handle page unload
+        window.addEventListener('beforeunload', this.beforeUnloadHandler);
+    }
+    cleanupLifecycleListeners() {
+        if (this.visibilityChangeHandler) {
+            document.removeEventListener('visibilitychange', this.visibilityChangeHandler);
+            this.visibilityChangeHandler = null;
         }
-        if (this.sessionEndConfig.debugMode) {
-            debugLog.debug('SessionManager', `Session health event tracked: ${event}`);
+        if (this.beforeUnloadHandler) {
+            window.removeEventListener('beforeunload', this.beforeUnloadHandler);
+            this.beforeUnloadHandler = null;
         }
     }
-    async performSessionEnd(reason, method) {
-        const timestamp = Date.now();
-        let eventsFlushed = 0;
-        try {
-            debugLog.info('SessionManager', 'Starting session end', { method, reason, timestamp });
-            if (this.eventManager) {
-                this.eventManager.track({
-                    type: EventType.SESSION_END,
-                    session_end_reason: reason,
-                });
-                eventsFlushed = this.eventManager.getQueueLength();
-                const flushResult = await this.eventManager.flushImmediately();
-                this.cleanupSession();
-                const result = {
-                    success: flushResult,
-                    reason,
-                    timestamp,
-                    eventsFlushed,
-                    method,
-                };
-                if (flushResult) {
-                    this.sessionEndStats.successfulEnds++;
-                }
-                else {
-                    this.sessionEndStats.failedEnds++;
-                }
-                return result;
-            }
-            this.cleanupSession();
-            const result = {
-                success: true,
-                reason,
-                timestamp,
-                eventsFlushed: 0,
-                method,
-            };
-            this.sessionEndStats.successfulEnds++;
-            return result;
+    /**
+     * End current session
+     */
+    endSession(reason) {
+        const sessionId = this.get('sessionId');
+        if (!sessionId) {
+            debugLog.warn('SessionManager', 'endSession called without active session', { reason });
+            this.resetSessionState();
+            return;
         }
-        catch (error) {
-            this.sessionEndStats.failedEnds++;
-            debugLog.error('SessionManager', 'Session end failed', { error, reason, method });
-            this.cleanupSession();
-            return {
-                success: false,
-                reason,
-                timestamp,
-                eventsFlushed,
-                method,
-            };
+        debugLog.info('SessionManager', 'Ending session', { sessionId, reason });
+        this.eventManager.track({
+            type: EventType.SESSION_END,
+            session_end_reason: reason,
+        });
+        const finalize = () => {
+            this.broadcastSessionEnd(sessionId, reason);
+            this.resetSessionState();
+        };
+        const flushResult = this.eventManager.flushImmediatelySync();
+        if (flushResult) {
+            finalize();
+            return;
         }
+        this.eventManager
+            .flushImmediately()
+            .then(finalize)
+            .catch((error) => {
+            debugLog.warn('SessionManager', 'Async flush failed during session end', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+            });
+            finalize();
+        });
     }
-    cleanupSession() {
-        this.endSession();
-        this.clearTimers();
+    resetSessionState() {
+        this.clearSessionTimeout();
+        this.cleanupActivityListeners();
+        this.cleanupLifecycleListeners();
+        this.cleanupCrossTabSync();
+        this.clearStoredSession();
         this.set('sessionId', null);
         this.set('hasStartSession', false);
+        this.isTracking = false;
     }
-    endSessionManagedSync(reason) {
-        this.sessionEndStats.totalSessionEnds++;
-        this.sessionEndStats.reasonCounts[reason]++;
-        if (this.pendingSessionEnd) {
-            this.sessionEndStats.duplicatePrevented++;
-            debugLog.warn('SessionManager', 'Sync session end called while async end pending', { reason });
-        }
-        if (!this.shouldProceedWithSessionEnd(reason)) {
-            if (this.sessionEndConfig.debugMode) {
-                debugLog.debug('SessionManager', `Sync session end skipped due to lower priority. Current: ${this.sessionEndReason}, Requested: ${reason}`);
-            }
-            return {
-                success: false,
-                reason,
-                timestamp: Date.now(),
-                eventsFlushed: 0,
-                method: 'sync',
-            };
-        }
-        this.sessionEndReason = reason;
-        this.pendingSessionEnd = true;
-        try {
-            return this.performSessionEndSync(reason);
-        }
-        finally {
-            this.pendingSessionEnd = false;
-            this.sessionEndPromise = null;
-            this.sessionEndReason = null;
-        }
-    }
-    performSessionEndSync(reason) {
-        const timestamp = Date.now();
-        let eventsFlushed = 0;
-        try {
-            if (this.eventManager) {
-                this.eventManager.track({
-                    type: EventType.SESSION_END,
-                    session_end_reason: reason,
-                });
-                eventsFlushed = this.eventManager.getQueueLength();
-                const success = this.eventManager.flushImmediatelySync();
-                this.cleanupSession();
-                const result = {
-                    success,
-                    reason,
-                    timestamp,
-                    eventsFlushed,
-                    method: 'sync',
-                };
-                if (success) {
-                    this.sessionEndStats.successfulEnds++;
-                }
-                else {
-                    this.sessionEndStats.failedEnds++;
-                }
-                return result;
-            }
-            this.cleanupSession();
-            const result = {
-                success: true,
-                reason,
-                timestamp,
-                eventsFlushed: 0,
-                method: 'sync',
-            };
-            this.sessionEndStats.successfulEnds++;
-            return result;
-        }
-        catch (error) {
-            this.sessionEndStats.failedEnds++;
-            this.cleanupSession();
-            debugLog.error('SessionManager', 'Sync session end failed', { error, reason });
-            return {
-                success: false,
-                reason,
-                timestamp,
-                eventsFlushed,
-                method: 'sync',
-            };
-        }
+    /**
+     * Stop session tracking
+     */
+    async stopTracking() {
+        this.endSession('manual_stop');
     }
-    setupPageUnloadHandlers() {
-        let unloadHandled = false;
-        const handlePageUnload = () => {
-            if (unloadHandled || !this.get('sessionId')) {
-                return;
-            }
-            unloadHandled = true;
-            this.clearInactivityTimer();
-            this.endSessionSafely('page_unload', { forceSync: true });
-        };
-        // Primary handler for modern browsers
-        const beforeUnloadHandler = () => {
-            handlePageUnload();
-        };
-        // Fallback for older browsers and mobile Safari
-        const pageHideHandler = (event) => {
-            if (!event.persisted) {
-                handlePageUnload();
-            }
-        };
-        // Delayed handler for visibility changes (gives time for page transitions)
-        const visibilityChangeHandler = () => {
-            if (document.visibilityState === 'hidden' && this.get('sessionId') && !unloadHandled) {
-                this.visibilityChangeTimeout = window.setTimeout(() => {
-                    if (document.visibilityState === 'hidden' && this.get('sessionId') && !unloadHandled) {
-                        handlePageUnload();
-                    }
-                    this.visibilityChangeTimeout = null;
-                }, 1000);
-            }
-        };
-        window.addEventListener('beforeunload', beforeUnloadHandler);
-        window.addEventListener('pagehide', pageHideHandler);
-        document.addEventListener('visibilitychange', visibilityChangeHandler);
-        this.cleanupHandlers.push(() => window.removeEventListener('beforeunload', beforeUnloadHandler), () => window.removeEventListener('pagehide', pageHideHandler), () => document.removeEventListener('visibilitychange', visibilityChangeHandler), () => {
-            if (this.visibilityChangeTimeout) {
-                clearTimeout(this.visibilityChangeTimeout);
-                this.visibilityChangeTimeout = null;
-            }
-        });
+    /**
+     * Clean up all resources
+     */
+    destroy() {
+        this.clearSessionTimeout();
+        this.cleanupActivityListeners();
+        this.cleanupCrossTabSync();
+        this.cleanupLifecycleListeners();
+        this.isTracking = false;
+        this.set('hasStartSession', false);
     }
 }