@interfere/next 0.0.0-alpha.10 → 0.0.1

package/dist/__tests__/core/session-manager.test.js

@@ -0,0 +1,1132 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { sessionStore } from "../../persistence/storage.js";
+import { DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS, MAX_SESSION_IDLE_TIMEOUT_SECONDS, SESSION_ID, toMs, } from "../../session/constants.js";
+import { SessionChangeReason, SessionIdManager, } from "../../session/session-manager.js";
+// Mock dependencies
+vi.mock("../storage/index.js");
+vi.mock("./persistence.js");
+describe("SessionIdManager", () => {
+    let mockClock;
+    let sessionIdGenerator;
+    let windowIdGenerator;
+    let currentTime;
+    // Test constants
+    const TEST_SURFACE = "test_surface";
+    const TEST_SESSION_ID = "test-session-id";
+    const TEST_WINDOW_ID = "test-window-id";
+    const TEST_TIMESTAMP = 1_603_107_479_471;
+    const MINUTES_IN_HOUR = 60;
+    const SECONDS_IN_MINUTE = 60;
+    const MS_IN_SECOND = 1000;
+    const HOURS_IN_DAY = 24;
+    const THIRTY_MINUTES = 30;
+    const THIRTY_MINUTES_MS = THIRTY_MINUTES * SECONDS_IN_MINUTE * MS_IN_SECOND;
+    const TWENTY_FOUR_HOURS_MS = HOURS_IN_DAY * MINUTES_IN_HOUR * SECONDS_IN_MINUTE * MS_IN_SECOND;
+    const ONE_HOUR_MS = MINUTES_IN_HOUR * SECONDS_IN_MINUTE * MS_IN_SECOND;
+    const ONE_SECOND_MS = MS_IN_SECOND;
+    const FIVE_MINUTES = 5;
+    const FIVE_MINUTES_SECONDS = FIVE_MINUTES * SECONDS_IN_MINUTE;
+    const THIRTY_SECONDS = 30;
+    const ONE_HUNDRED_EXTRA_SECONDS = 100;
+    const FIVE_THOUSAND_MULTIPLIER = 5;
+    const FIVE_THOUSAND_MS = FIVE_THOUSAND_MULTIPLIER * MS_IN_SECOND;
+    const ONE_HUNDRED_MS = 100;
+    const TWO_HUNDRED_MS = 200;
+    const THROTTLE_PERCENTAGE = 0.1;
+    const IDLE_TIMEOUT_BUFFER = 1.1;
+    const HEARTBEAT_INTERVAL_MS = 5000;
+    const STALE_WINDOW_TIMEOUT_MS = 61_000; // Updated to match new 60s timeout + 1s
+    const RECENT_HEARTBEAT_MS = 10_000;
+    const NEWER_TIMESTAMP_OFFSET = 1000;
+    const OLDER_TIMESTAMP_OFFSET = 500;
+    const FUTURE_TIMESTAMP_OFFSET = 10_000;
+    const PAST_TIMESTAMP_OFFSET = 1000;
+    const ZERO_TIMESTAMP = 0;
+    const createTestConfig = (overrides = {}) => ({
+        persistence: "localStorage",
+        ...overrides,
+    });
+    const createSessionManager = (config = createTestConfig(), persistenceOverrides = {}) => {
+        const persistence = {
+            register: vi.fn(),
+            getProperty: vi
+                .fn()
+                .mockReturnValue([ZERO_TIMESTAMP, null, ZERO_TIMESTAMP]),
+            isDisabled: vi.fn().mockReturnValue(false),
+            ...persistenceOverrides,
+        };
+        return new SessionIdManager(TEST_SURFACE, config, persistence, {
+            sessionId: sessionIdGenerator,
+            windowId: windowIdGenerator,
+            clock: mockClock,
+        });
+    };
+    beforeEach(() => {
+        currentTime = TEST_TIMESTAMP;
+        // Mock clock
+        mockClock = {
+            now: vi.fn(() => currentTime),
+            setTimeout: vi.fn((callback, delay) => setTimeout(callback, delay)),
+            clearTimeout: vi.fn((id) => clearTimeout(id)),
+        };
+        // Mock ID generators
+        sessionIdGenerator = vi.fn(() => TEST_SESSION_ID);
+        windowIdGenerator = vi.fn(() => TEST_WINDOW_ID);
+        // Mock sessionStore
+        const mockSessionStore = sessionStore;
+        mockSessionStore._is_supported = vi.fn().mockReturnValue(true);
+        mockSessionStore._parse = vi.fn().mockReturnValue(null);
+        mockSessionStore._set = vi.fn();
+        mockSessionStore._remove = vi.fn();
+        // Clear all mocks
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    describe("initialization", () => {
+        it("generates initial session and window IDs on first use", () => {
+            const sessionManager = createSessionManager();
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(result).toMatchObject({
+                sessionId: TEST_SESSION_ID,
+                windowId: TEST_WINDOW_ID,
+                sessionStartTimestamp: currentTime,
+                lastActivityTimestamp: currentTime,
+                changeReason: {
+                    [SessionChangeReason.NO_SESSION_ID]: true,
+                    [SessionChangeReason.ACTIVITY_TIMEOUT]: true,
+                    [SessionChangeReason.SESSION_PAST_MAXIMUM_LENGTH]: false,
+                },
+            });
+        });
+        it("generates initial session even in read-only mode", () => {
+            const sessionManager = createSessionManager();
+            const result = sessionManager.checkAndGetSessionAndWindowId(true, currentTime);
+            expect(result.sessionId).toBe(TEST_SESSION_ID);
+            expect(result.windowId).toBe(TEST_WINDOW_ID);
+        });
+        it("uses bootstrap session ID from config", () => {
+            const bootstrapSessionId = "bootstrap-session-id";
+            const config = createTestConfig({ sessionId: bootstrapSessionId });
+            const sessionManager = createSessionManager(config);
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(result.sessionId).toBe(bootstrapSessionId);
+        });
+        it("handles invalid bootstrap session ID gracefully", () => {
+            const config = createTestConfig({ sessionId: "invalid-id" });
+            const mockPersistence = {
+                register: vi.fn(() => {
+                    throw new Error("Invalid session ID");
+                }),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([ZERO_TIMESTAMP, null, ZERO_TIMESTAMP]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            // Should not throw and should generate new session ID
+            expect(() => createSessionManager(config, mockPersistence)).not.toThrow();
+        });
+        it("sets up window ID persistence correctly", () => {
+            const mockSessionStore = sessionStore;
+            mockSessionStore._parse = vi
+                .fn()
+                .mockReturnValueOnce("existing-window-id") // window ID
+                .mockReturnValueOnce(undefined); // primary window exists
+            createSessionManager();
+            expect(mockSessionStore._set).toHaveBeenCalledWith("interfere_test_surface_primary_window_exists", true);
+        });
+        it("cycles window ID when primary window already exists", () => {
+            const mockSessionStore = sessionStore;
+            mockSessionStore._parse = vi
+                .fn()
+                .mockReturnValueOnce("existing-window-id") // window ID
+                .mockReturnValueOnce(true); // primary window exists
+            createSessionManager();
+            expect(mockSessionStore._remove).toHaveBeenCalledWith("interfere_test_surface_window_id");
+        });
+        it("handles disabled persistence correctly", () => {
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([ZERO_TIMESTAMP, null, ZERO_TIMESTAMP]),
+                isDisabled: vi.fn().mockReturnValue(true),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(result.sessionId).toBe(TEST_SESSION_ID);
+            expect(sessionStore._set).not.toHaveBeenCalled();
+        });
+    });
+    describe("session timeout configuration", () => {
+        const createSessionManagerWithTimeout = (timeout) => {
+            const config = createTestConfig({
+                sessionIdleTimeoutSeconds: timeout,
+            });
+            return createSessionManager(config);
+        };
+        it("uses static session timeout regardless of config", () => {
+            const sessionManager = createSessionManagerWithTimeout(FIVE_MINUTES_SECONDS);
+            // Session timeout is now static - always uses default
+            expect(sessionManager.sessionTimeoutMs).toBe(toMs(DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS));
+        });
+        it("clamps timeout to default when below minimum", () => {
+            const sessionManager = createSessionManagerWithTimeout(THIRTY_SECONDS);
+            expect(sessionManager.sessionTimeoutMs).toBe(toMs(DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS));
+        });
+        it("clamps timeout to default when above maximum", () => {
+            const sessionManager = createSessionManagerWithTimeout(MAX_SESSION_IDLE_TIMEOUT_SECONDS + ONE_HUNDRED_EXTRA_SECONDS);
+            expect(sessionManager.sessionTimeoutMs).toBe(toMs(DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS));
+        });
+        it("uses default timeout when undefined", () => {
+            const sessionManager = createSessionManagerWithTimeout(undefined);
+            expect(sessionManager.sessionTimeoutMs).toBe(toMs(DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS));
+        });
+    });
+    describe("session persistence and retrieval", () => {
+        it("reuses existing session when not expired", () => {
+            const existingTimestamp = currentTime - ONE_SECOND_MS;
+            const startTimestamp = existingTimestamp - ONE_HOUR_MS;
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([
+                    existingTimestamp,
+                    "existing-session-id",
+                    startTimestamp,
+                ]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const mockSessionStore = sessionStore;
+            mockSessionStore._parse = vi.fn().mockReturnValue("existing-window-id");
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(result).toEqual({
+                sessionId: "existing-session-id",
+                windowId: "existing-window-id",
+                sessionStartTimestamp: startTimestamp,
+                lastActivityTimestamp: currentTime, // Updated to current time
+            });
+        });
+        it("generates new session when activity timeout exceeded", () => {
+            const oldTimestamp = currentTime - (THIRTY_MINUTES_MS + ONE_SECOND_MS);
+            const startTimestamp = oldTimestamp - ONE_HOUR_MS;
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([oldTimestamp, "old-session-id", startTimestamp]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(result).toMatchObject({
+                sessionId: TEST_SESSION_ID,
+                windowId: TEST_WINDOW_ID,
+                sessionStartTimestamp: currentTime,
+                lastActivityTimestamp: currentTime,
+                changeReason: {
+                    [SessionChangeReason.ACTIVITY_TIMEOUT]: true,
+                    [SessionChangeReason.NO_SESSION_ID]: false,
+                    [SessionChangeReason.SESSION_PAST_MAXIMUM_LENGTH]: false,
+                },
+            });
+        });
+        it("generates new session when maximum session length exceeded", () => {
+            const oldTimestamp = currentTime - ONE_SECOND_MS;
+            const startTimestamp = currentTime - (TWENTY_FOUR_HOURS_MS + ONE_SECOND_MS);
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([oldTimestamp, "old-session-id", startTimestamp]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(result).toMatchObject({
+                sessionId: TEST_SESSION_ID,
+                windowId: TEST_WINDOW_ID,
+                sessionStartTimestamp: currentTime,
+                changeReason: {
+                    [SessionChangeReason.ACTIVITY_TIMEOUT]: false,
+                    [SessionChangeReason.NO_SESSION_ID]: false,
+                    [SessionChangeReason.SESSION_PAST_MAXIMUM_LENGTH]: true,
+                },
+            });
+        });
+        it("generates new session when maximum length exceeded even in read-only mode", () => {
+            const oldTimestamp = currentTime - ONE_SECOND_MS;
+            const startTimestamp = currentTime - (TWENTY_FOUR_HOURS_MS + ONE_SECOND_MS);
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([oldTimestamp, "old-session-id", startTimestamp]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const result = sessionManager.checkAndGetSessionAndWindowId(true, currentTime);
+            expect(result.sessionId).toBe(TEST_SESSION_ID);
+            expect(result.changeReason?.[SessionChangeReason.SESSION_PAST_MAXIMUM_LENGTH]).toBe(true);
+        });
+        it("does not update activity timestamp in read-only mode for active sessions", () => {
+            const oldTimestamp = currentTime - ONE_SECOND_MS;
+            const startTimestamp = oldTimestamp - ONE_HOUR_MS;
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([
+                    oldTimestamp,
+                    "existing-session-id",
+                    startTimestamp,
+                ]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const mockSessionStore = sessionStore;
+            mockSessionStore._parse = vi.fn().mockReturnValue("existing-window-id");
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const result = sessionManager.checkAndGetSessionAndWindowId(true, currentTime);
+            expect(result.lastActivityTimestamp).toBe(oldTimestamp); // Not updated
+            expect(mockPersistence.register).toHaveBeenCalledWith({
+                [SESSION_ID]: [oldTimestamp, "existing-session-id", startTimestamp],
+            });
+        });
+        it("populates session start timestamp when missing", () => {
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi.fn().mockReturnValue([
+                    currentTime,
+                    "existing-session-id",
+                    // Missing start timestamp (legacy format)
+                ]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const mockSessionStore = sessionStore;
+            mockSessionStore._parse = vi.fn().mockReturnValue("existing-window-id");
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(result.sessionStartTimestamp).toBe(currentTime);
+            expect(mockPersistence.register).toHaveBeenCalledWith({
+                [SESSION_ID]: [currentTime, "existing-session-id", currentTime],
+            });
+        });
+        it("uses current time when no timestamp provided", () => {
+            const sessionManager = createSessionManager();
+            // Mock Date.now to return a specific time
+            const mockNow = TEST_TIMESTAMP + FIVE_THOUSAND_MS;
+            mockClock.now = vi.fn(() => mockNow);
+            const result = sessionManager.checkAndGetSessionAndWindowId(false);
+            expect(result.sessionStartTimestamp).toBe(mockNow);
+            expect(result.lastActivityTimestamp).toBe(mockNow);
+        });
+    });
+    describe("window ID management", () => {
+        it("generates new window ID when none exists", () => {
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([currentTime, "existing-session-id", currentTime]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const mockSessionStore = sessionStore;
+            mockSessionStore._parse = vi.fn().mockReturnValue(null); // No existing window ID
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(result.windowId).toBe(TEST_WINDOW_ID);
+            expect(result.sessionId).toBe("existing-session-id"); // Session ID unchanged
+            expect(mockSessionStore._set).toHaveBeenCalledWith("interfere_test_surface_window_id", TEST_WINDOW_ID);
+        });
+        it("handles session storage not supported", () => {
+            const mockSessionStore = sessionStore;
+            mockSessionStore._is_supported = vi.fn().mockReturnValue(false);
+            const sessionManager = createSessionManager();
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(result.windowId).toBe(TEST_WINDOW_ID);
+            expect(mockSessionStore._set).not.toHaveBeenCalled();
+        });
+        it("stores and retrieves window ID correctly", () => {
+            const mockSessionStore = sessionStore;
+            mockSessionStore._parse = vi.fn().mockReturnValue("stored-window-id");
+            const sessionManager = createSessionManager();
+            // Access private method for testing
+            const windowId = sessionManager._getWindowId();
+            expect(windowId).toBe("stored-window-id");
+        });
+    });
+    describe("session callbacks", () => {
+        it("calls registered callbacks when session changes", () => {
+            const callback = vi.fn();
+            const sessionManager = createSessionManager();
+            sessionManager.onSessionId(callback);
+            sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(callback).toHaveBeenCalledWith(TEST_SESSION_ID, TEST_WINDOW_ID, expect.objectContaining({
+                [SessionChangeReason.NO_SESSION_ID]: true,
+            }));
+        });
+        it("calls callback immediately if session already exists", () => {
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([currentTime, "existing-session-id", currentTime]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const mockSessionStore = sessionStore;
+            mockSessionStore._parse = vi.fn().mockReturnValue("existing-window-id");
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            sessionManager.checkAndGetSessionAndWindowId(false, currentTime); // Initialize session
+            const callback = vi.fn();
+            sessionManager.onSessionId(callback);
+            expect(callback).toHaveBeenCalledWith("existing-session-id", "existing-window-id", undefined // No change reason for existing session
+            );
+        });
+        it("allows unsubscribing from callbacks", () => {
+            const callback = vi.fn();
+            const sessionManager = createSessionManager();
+            const unsubscribe = sessionManager.onSessionId(callback);
+            // Callback is called immediately with initial state (null, null) and change reason
+            expect(callback).toHaveBeenCalledWith(null, null, {
+                [SessionChangeReason.NO_SESSION_ID]: true,
+            });
+            callback.mockClear();
+            unsubscribe();
+            sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            // Should not be called again after unsubscribing
+            expect(callback).not.toHaveBeenCalled();
+        });
+        it("does not call callbacks when values do not change", () => {
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([
+                    currentTime - ONE_SECOND_MS,
+                    "existing-session-id",
+                    currentTime - ONE_HOUR_MS,
+                ]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const mockSessionStore = sessionStore;
+            mockSessionStore._parse = vi.fn().mockReturnValue("existing-window-id");
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            sessionManager.checkAndGetSessionAndWindowId(false, currentTime); // Initialize
+            const callback = vi.fn();
+            sessionManager.onSessionId(callback);
+            callback.mockClear(); // Clear the immediate call
+            sessionManager.checkAndGetSessionAndWindowId(false, currentTime + ONE_SECOND_MS); // Second call
+            expect(callback).not.toHaveBeenCalled();
+        });
+    });
+    describe("idle timeout enforcement", () => {
+        beforeEach(() => {
+            vi.useFakeTimers();
+        });
+        it("starts idle timeout timer on initialization", () => {
+            const sessionManager = createSessionManager();
+            expect(sessionManager
+                ._enforceIdleTimeout).toBeDefined();
+            expect(mockClock.setTimeout).toHaveBeenCalled();
+        });
+        it("resets idle timer when checking session (non-read-only)", () => {
+            const sessionManager = createSessionManager();
+            // Advance time to ensure throttling doesn't prevent timer reset
+            currentTime +=
+                sessionManager.sessionTimeoutMs * THROTTLE_PERCENTAGE + ONE_SECOND_MS;
+            mockClock.now = vi.fn(() => currentTime);
+            const clearTimeoutSpy = vi.spyOn(mockClock, "clearTimeout");
+            const setTimeoutSpy = vi.spyOn(mockClock, "setTimeout");
+            sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(clearTimeoutSpy).toHaveBeenCalled();
+            expect(setTimeoutSpy).toHaveBeenCalled();
+        });
+        it("does not reset idle timer in read-only mode", () => {
+            const sessionManager = createSessionManager();
+            const originalTimer = sessionManager._enforceIdleTimeout;
+            sessionManager.checkAndGetSessionAndWindowId(true, currentTime);
+            expect(sessionManager
+                ._enforceIdleTimeout).toEqual(originalTimer);
+        });
+        it("resets session when idle timeout is exceeded", () => {
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi.fn(),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            // Set up initial active session
+            mockPersistence.getProperty.mockReturnValue([
+                currentTime,
+                "active-session-id",
+                currentTime,
+            ]);
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const resetSpy = vi.spyOn(sessionManager, "resetSessionId");
+            const callback = vi.fn();
+            sessionManager.onSessionId(callback);
+            callback.mockClear(); // Clear initial call
+            // Simulate session becoming idle
+            const idleTimestamp = currentTime - (sessionManager.sessionTimeoutMs + ONE_SECOND_MS);
+            mockPersistence.getProperty.mockReturnValue([
+                idleTimestamp,
+                "active-session-id",
+                currentTime,
+            ]);
+            // Fast-forward time to trigger idle timeout
+            vi.advanceTimersByTime(sessionManager.sessionTimeoutMs * IDLE_TIMEOUT_BUFFER + ONE_SECOND_MS);
+            // Verify reset was called with correct reason and callbacks were fired
+            expect(resetSpy).toHaveBeenCalledWith({
+                [SessionChangeReason.ACTIVITY_TIMEOUT]: true,
+            });
+            expect(callback).toHaveBeenCalledWith(null, null, {
+                [SessionChangeReason.ACTIVITY_TIMEOUT]: true,
+            });
+        });
+        it("does not reset session if activity is recent when timer fires", () => {
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi.fn(),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const resetSpy = vi.spyOn(sessionManager, "resetSessionId");
+            // Initially set up idle session
+            const idleTimestamp = currentTime - (sessionManager.sessionTimeoutMs + ONE_SECOND_MS);
+            mockPersistence.getProperty.mockReturnValue([
+                idleTimestamp,
+                "session-id",
+                currentTime,
+            ]);
+            // Fast-forward almost to timeout (buffer now divides, so timer fires earlier)
+            const timeAdvance1 = sessionManager.sessionTimeoutMs / IDLE_TIMEOUT_BUFFER - ONE_HUNDRED_MS;
+            vi.advanceTimersByTime(timeAdvance1);
+            currentTime += timeAdvance1;
+            mockClock.now = vi.fn(() => currentTime);
+            // Before timer fires, simulate recent activity
+            const recentTimestamp = currentTime - ONE_SECOND_MS; // Recent activity
+            mockPersistence.getProperty.mockReturnValue([
+                recentTimestamp,
+                "session-id",
+                currentTime,
+            ]);
+            // Let timer fire
+            const timeAdvance2 = TWO_HUNDRED_MS;
+            vi.advanceTimersByTime(timeAdvance2);
+            currentTime += timeAdvance2;
+            mockClock.now = vi.fn(() => currentTime);
+            expect(resetSpy).not.toHaveBeenCalled();
+        });
+        it("always resets idle timer for non-read-only calls", () => {
+            const sessionManager = createSessionManager();
+            const clearTimeoutSpy = vi.spyOn(mockClock, "clearTimeout");
+            const setTimeoutSpy = vi.spyOn(mockClock, "setTimeout");
+            clearTimeoutSpy.mockClear();
+            setTimeoutSpy.mockClear();
+            // First call should reset timer
+            sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(clearTimeoutSpy).toHaveBeenCalledTimes(1);
+            expect(setTimeoutSpy).toHaveBeenCalledTimes(1);
+            clearTimeoutSpy.mockClear();
+            setTimeoutSpy.mockClear();
+            // Second call should also reset timer (no more throttling)
+            currentTime += ONE_HUNDRED_MS;
+            mockClock.now = vi.fn(() => currentTime);
+            sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(clearTimeoutSpy).toHaveBeenCalledTimes(1);
+            expect(setTimeoutSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("session reset", () => {
+        it("clears existing session data", () => {
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([currentTime, "existing-session-id", currentTime]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            sessionManager.resetSessionId();
+            expect(mockPersistence.register).toHaveBeenCalledWith({
+                [SESSION_ID]: [null, null, null],
+            });
+        });
+        it("generates new session after reset", () => {
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi.fn(),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            // Start with existing session
+            mockPersistence.getProperty.mockReturnValue([
+                currentTime,
+                "existing-session-id",
+                currentTime,
+            ]);
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            // Reset the session
+            sessionManager.resetSessionId();
+            // After reset, getProperty should return null values
+            mockPersistence.getProperty.mockReturnValue([null, null, null]);
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(result.sessionId).toBe(TEST_SESSION_ID);
+            expect(result.changeReason?.[SessionChangeReason.NO_SESSION_ID]).toBe(true);
+        });
+    });
+    describe("cleanup and disposal", () => {
+        it("clears timeout on disposal", () => {
+            const sessionManager = createSessionManager();
+            const clearTimeoutSpy = vi.spyOn(mockClock, "clearTimeout");
+            sessionManager.dispose();
+            expect(clearTimeoutSpy).toHaveBeenCalled();
+            expect(sessionManager
+                ._enforceIdleTimeout).toBeUndefined();
+        });
+        it("removes event listeners on disposal", () => {
+            // Mock window and addEventListener
+            const mockRemoveEventListener = vi.fn();
+            const originalWindow = globalThis.window;
+            globalThis.window = {
+                addEventListener: vi.fn(),
+                removeEventListener: mockRemoveEventListener,
+            };
+            const sessionManager = createSessionManager();
+            sessionManager.dispose();
+            expect(mockRemoveEventListener).toHaveBeenCalledWith("beforeunload", expect.any(Function));
+            // Restore original window
+            globalThis.window = originalWindow;
+        });
+        it("clears session change handlers on disposal", () => {
+            const sessionManager = createSessionManager();
+            const callback = vi.fn();
+            sessionManager.onSessionId(callback);
+            sessionManager.dispose();
+            expect(sessionManager
+                ._sessionIdChangedHandlers).toEqual([]);
+        });
+        it("handles disposal when no window is available", () => {
+            const originalWindow = globalThis.window;
+            // Set window to undefined to simulate no window environment
+            globalThis.window = undefined;
+            const sessionManager = createSessionManager();
+            expect(() => sessionManager.dispose()).not.toThrow();
+            // Restore window
+            globalThis.window = originalWindow;
+        });
+    });
+    describe("beforeunload handling", () => {
+        it("removes window ID and conditionally removes primary window flag on beforeunload", () => {
+            const mockRemoveEventListener = vi.fn();
+            const mockAddEventListener = vi.fn();
+            const originalWindow = globalThis.window;
+            globalThis.window = {
+                addEventListener: mockAddEventListener,
+                removeEventListener: mockRemoveEventListener,
+            };
+            // Mock sessionStore to simulate this window being the primary window
+            const mockSessionStore = sessionStore;
+            mockSessionStore._parse.mockImplementation((key) => {
+                if (key.includes("window_id")) {
+                    return TEST_WINDOW_ID; // Return the same window ID that the manager will have
+                }
+                return null;
+            });
+            const sessionManager = createSessionManager();
+            // Initialize session to set up window ID
+            sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            // Get the registered beforeunload handler
+            const beforeUnloadHandler = mockAddEventListener.mock.calls.find((call) => call[0] === "beforeunload")?.[1];
+            expect(beforeUnloadHandler).toBeDefined();
+            // Call the handler
+            beforeUnloadHandler?.();
+            // Should remove window ID, heartbeat, and primary window flag (since this is the primary window)
+            expect(sessionStore._remove).toHaveBeenCalledWith("interfere_test_surface_window_id");
+            expect(sessionStore._remove).toHaveBeenCalledWith("interfere_test_surface_window_id_heartbeat");
+            expect(sessionStore._remove).toHaveBeenCalledWith("interfere_test_surface_primary_window_exists");
+            const EXPECTED_REMOVE_CALLS = 3; // window ID + heartbeat + primary window flag
+            expect(sessionStore._remove).toHaveBeenCalledTimes(EXPECTED_REMOVE_CALLS);
+            // Restore window
+            globalThis.window = originalWindow;
+        });
+        it("does not set up beforeunload handler when window is undefined", () => {
+            const originalWindow = globalThis.window;
+            globalThis.window = undefined;
+            expect(() => createSessionManager()).not.toThrow();
+            // Restore window
+            globalThis.window = originalWindow;
+        });
+    });
+    describe("heartbeat logic", () => {
+        let originalWindow;
+        let originalDocument;
+        beforeEach(() => {
+            vi.useFakeTimers();
+            // Store originals
+            originalWindow = globalThis.window;
+            originalDocument = globalThis.document;
+            // Mock window and document
+            globalThis.window = {
+                addEventListener: vi.fn(),
+                removeEventListener: vi.fn(),
+            };
+            globalThis.document = {
+                visibilityState: "visible",
+                addEventListener: vi.fn(),
+                removeEventListener: vi.fn(),
+            };
+        });
+        afterEach(() => {
+            vi.useRealTimers();
+            // Restore originals
+            globalThis.window = originalWindow;
+            globalThis.document = originalDocument;
+        });
+        it("writes initial heartbeat on initialization", () => {
+            const mockSessionStore = sessionStore;
+            mockSessionStore._is_supported.mockReturnValue(true);
+            mockSessionStore._parse.mockReturnValue(null); // No existing data
+            createSessionManager();
+            expect(mockSessionStore._set).toHaveBeenCalledWith("interfere_test_surface_window_id_heartbeat", currentTime);
+        });
+        it("starts periodic heartbeat interval", () => {
+            const setIntervalSpy = vi.spyOn(globalThis, "setInterval");
+            createSessionManager();
+            expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), HEARTBEAT_INTERVAL_MS);
+        });
+        it("skips heartbeat when document visibility is not visible", () => {
+            const mockSessionStore = sessionStore;
+            // Set document to hidden
+            globalThis.document = {
+                visibilityState: "hidden",
+                addEventListener: vi.fn(),
+                removeEventListener: vi.fn(),
+            };
+            createSessionManager();
+            // Clear initial heartbeat call
+            mockSessionStore._set.mockClear();
+            // Advance time to trigger heartbeat
+            vi.advanceTimersByTime(HEARTBEAT_INTERVAL_MS);
+            // Should not have written heartbeat due to hidden visibility
+            expect(mockSessionStore._set).not.toHaveBeenCalledWith("interfere_test_surface_window_id_heartbeat", expect.any(Number));
+        });
+        it("writes heartbeat when document becomes visible", () => {
+            const mockSessionStore = sessionStore;
+            // Start hidden
+            globalThis.document = {
+                visibilityState: "hidden",
+                addEventListener: vi.fn(),
+                removeEventListener: vi.fn(),
+            };
+            createSessionManager();
+            mockSessionStore._set.mockClear();
+            // Make visible and advance time
+            globalThis.document = {
+                visibilityState: "visible",
+                addEventListener: vi.fn(),
+                removeEventListener: vi.fn(),
+            };
+            currentTime += HEARTBEAT_INTERVAL_MS;
+            mockClock.now = vi.fn(() => currentTime);
+            vi.advanceTimersByTime(HEARTBEAT_INTERVAL_MS);
+            expect(mockSessionStore._set).toHaveBeenCalledWith("interfere_test_surface_window_id_heartbeat", currentTime);
+        });
+        it("recovers correctly when storage throws during heartbeat", () => {
+            const mockSessionStore = sessionStore;
+            createSessionManager();
+            // Make storage throw on heartbeat after initial setup
+            let heartbeatCalls = 0;
+            mockSessionStore._set.mockImplementation((key, _value) => {
+                if (key.includes("heartbeat")) {
+                    heartbeatCalls++;
+                    if (heartbeatCalls > 1) {
+                        // Allow first heartbeat, fail subsequent ones
+                        throw new Error("Storage quota exceeded");
+                    }
+                }
+            });
+            // Advance time to trigger heartbeat - should not throw
+            expect(() => {
+                vi.advanceTimersByTime(HEARTBEAT_INTERVAL_MS);
+            }).not.toThrow();
+            // Verify that heartbeat errors were handled gracefully (no exception thrown)
+            // The storage cache invalidation happens when actual storage errors occur during heartbeat writes
+        });
+        it("does not start heartbeat when window is undefined", () => {
+            const savedWindow = globalThis.window;
+            globalThis.window = undefined;
+            const setIntervalSpy = vi.spyOn(globalThis, "setInterval");
+            createSessionManager();
+            expect(setIntervalSpy).not.toHaveBeenCalled();
+            // Restore window
+            globalThis.window = savedWindow;
+        });
+    });
+    describe("stale window cleanup", () => {
+        beforeEach(() => {
+            vi.useFakeTimers();
+        });
+        afterEach(() => {
+            vi.useRealTimers();
+        });
+        it("removes flags when heartbeat is older than 60 seconds", () => {
+            const mockSessionStore = sessionStore;
+            mockSessionStore._is_supported.mockReturnValue(true);
+            // Mock stale heartbeat (older than 60 seconds)
+            const staleHeartbeat = currentTime - STALE_WINDOW_TIMEOUT_MS;
+            mockSessionStore._parse.mockImplementation((key) => {
+                if (key.includes("heartbeat")) {
+                    return staleHeartbeat;
+                }
+                return null;
+            });
+            createSessionManager();
+            // Should have removed the primary window flag due to stale heartbeat
+            expect(mockSessionStore._remove).toHaveBeenCalledWith("interfere_test_surface_primary_window_exists");
+        });
+        it("removes phantom primary flag when no heartbeat exists", () => {
+            const mockSessionStore = sessionStore;
+            mockSessionStore._is_supported.mockReturnValue(true);
+            // Mock no heartbeat but primary window exists
+            mockSessionStore._parse.mockImplementation((key) => {
+                if (key.includes("heartbeat")) {
+                    return null; // No heartbeat
+                }
+                if (key.includes("primary_window_exists")) {
+                    return true; // But primary flag exists (phantom)
+                }
+                return null;
+            });
+            createSessionManager();
+            // Should have removed the phantom primary window flag
+            expect(mockSessionStore._remove).toHaveBeenCalledWith("interfere_test_surface_primary_window_exists");
+        });
+        it("does not remove flags when heartbeat is recent", () => {
+            const mockSessionStore = sessionStore;
+            mockSessionStore._is_supported.mockReturnValue(true);
+            // Mock recent heartbeat (within 60 seconds)
+            const recentHeartbeat = currentTime - RECENT_HEARTBEAT_MS;
+            mockSessionStore._parse.mockImplementation((key) => {
+                if (key.includes("heartbeat")) {
+                    return recentHeartbeat;
+                }
+                return null;
+            });
+            createSessionManager();
+            // Should not have removed any flags due to recent heartbeat
+            expect(mockSessionStore._remove).not.toHaveBeenCalledWith("interfere_test_surface_primary_window_exists");
+        });
+        it("handles cleanup gracefully when storage throws", () => {
+            const mockSessionStore = sessionStore;
+            mockSessionStore._is_supported.mockReturnValue(true);
+            mockSessionStore._parse.mockImplementation((key) => {
+                if (key.includes("heartbeat")) {
+                    throw new Error("Storage error");
+                }
+                return null;
+            });
+            // Should not throw even when storage fails during cleanup
+            expect(() => createSessionManager()).not.toThrow();
+        });
+    });
+    describe("optimistic locking in persistence", () => {
+        it("syncs local state when another tabs activity timestamp is newer", () => {
+            const newerTimestamp = currentTime + NEWER_TIMESTAMP_OFFSET;
+            const olderLocalTimestamp = currentTime;
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValueOnce([
+                    olderLocalTimestamp,
+                    "local-session-id",
+                    currentTime,
+                ])
+                    .mockReturnValue([
+                    newerTimestamp,
+                    "remote-session-id",
+                    currentTime - PAST_TIMESTAMP_OFFSET,
+                ]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            // Initialize with local session
+            sessionManager.checkAndGetSessionAndWindowId(false, olderLocalTimestamp);
+            // Try to update with older timestamp - should sync from persistence instead
+            sessionManager.checkAndGetSessionAndWindowId(false, olderLocalTimestamp + OLDER_TIMESTAMP_OFFSET);
+            // Should have synced to the newer remote session
+            const result = sessionManager.checkAndGetSessionAndWindowId(true, currentTime);
+            expect(result.sessionId).toBe("remote-session-id");
+            expect(result.lastActivityTimestamp).toBe(newerTimestamp);
+        });
+        it("adds jitter in production but not in test environment", () => {
+            // Test environment should not add jitter
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([ZERO_TIMESTAMP, null, ZERO_TIMESTAMP]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            // In test environment, timestamp should be exact (no jitter)
+            expect(mockPersistence.register).toHaveBeenCalledWith({
+                [SESSION_ID]: [currentTime, TEST_SESSION_ID, currentTime],
+            });
+        });
+        it("handles equal timestamps correctly", () => {
+            const sameTimestamp = currentTime;
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([sameTimestamp, "existing-session-id", currentTime]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            // With same timestamp, should proceed with local update
+            sessionManager.checkAndGetSessionAndWindowId(false, sameTimestamp);
+            expect(mockPersistence.register).toHaveBeenCalledWith({
+                [SESSION_ID]: [sameTimestamp, "existing-session-id", currentTime],
+            });
+        });
+        it("gracefully handles persistence failures during optimistic locking", () => {
+            const mockPersistence = {
+                register: vi.fn().mockImplementation(() => {
+                    throw new Error("Storage quota exceeded");
+                }),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([ZERO_TIMESTAMP, null, ZERO_TIMESTAMP]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            // Should not throw even when persistence fails
+            expect(() => {
+                sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            }).not.toThrow();
+        });
+    });
+    describe("activity timestamp edge cases", () => {
+        it("handles clock skew backwards gracefully", () => {
+            const futureTimestamp = currentTime + FUTURE_TIMESTAMP_OFFSET;
+            const pastTimestamp = currentTime - PAST_TIMESTAMP_OFFSET;
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([futureTimestamp, "session-id", currentTime]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            // Access with past timestamp (clock moved backwards)
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, pastTimestamp);
+            // Session should still be considered active despite backwards clock
+            expect(result.sessionId).toBe("session-id");
+            expect(result.lastActivityTimestamp).toBe(pastTimestamp); // Updated to current
+        });
+        it("does not update last activity timestamp when regenerating due to timeout", () => {
+            const oldTimestamp = currentTime - (THIRTY_MINUTES_MS + ONE_SECOND_MS);
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi
+                    .fn()
+                    .mockReturnValue([
+                    oldTimestamp,
+                    "old-session-id",
+                    currentTime - ONE_HOUR_MS,
+                ]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            // New session should have current time as last activity
+            expect(result.sessionId).toBe(TEST_SESSION_ID);
+            expect(result.lastActivityTimestamp).toBe(currentTime);
+            expect(result.changeReason?.[SessionChangeReason.ACTIVITY_TIMEOUT]).toBe(true);
+        });
+        it("handles timestamp validation errors gracefully", () => {
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi.fn().mockReturnValue([
+                    "invalid-timestamp", // Not a number
+                    "session-id",
+                    "invalid-start-timestamp",
+                ]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            // Should generate new session due to invalid data
+            expect(result.sessionId).toBe(TEST_SESSION_ID);
+            // Invalid timestamp data triggers activity timeout (not no session)
+            expect(result.changeReason).toMatchObject({
+                [SessionChangeReason.ACTIVITY_TIMEOUT]: true,
+            });
+        });
+    });
+    describe("reset session with explicit reason", () => {
+        it("propagates explicit reset reason to handlers", () => {
+            const callback = vi.fn();
+            const sessionManager = createSessionManager();
+            sessionManager.onSessionId(callback);
+            callback.mockClear(); // Clear initial call
+            const explicitReason = {
+                [SessionChangeReason.SESSION_PAST_MAXIMUM_LENGTH]: true,
+            };
+            sessionManager.resetSessionId(explicitReason);
+            expect(callback).toHaveBeenCalledWith(null, null, explicitReason);
+        });
+        it("uses default reason when no explicit reason provided", () => {
+            const callback = vi.fn();
+            const sessionManager = createSessionManager();
+            sessionManager.onSessionId(callback);
+            callback.mockClear(); // Clear initial call
+            sessionManager.resetSessionId();
+            expect(callback).toHaveBeenCalledWith(null, null, {
+                [SessionChangeReason.NO_SESSION_ID]: true,
+            });
+        });
+        it("calls resetSessionId with correct reason during idle timeout", () => {
+            vi.useFakeTimers();
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi.fn(),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            // Set up initial active session
+            mockPersistence.getProperty.mockReturnValue([
+                currentTime,
+                "active-session-id",
+                currentTime,
+            ]);
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const callback = vi.fn();
+            sessionManager.onSessionId(callback);
+            callback.mockClear(); // Clear initial call
+            // Simulate session becoming idle
+            const idleTimestamp = currentTime - (sessionManager.sessionTimeoutMs + ONE_SECOND_MS);
+            mockPersistence.getProperty.mockReturnValue([
+                idleTimestamp,
+                "active-session-id",
+                currentTime,
+            ]);
+            // Fast-forward time to trigger idle timeout
+            vi.advanceTimersByTime(sessionManager.sessionTimeoutMs + ONE_SECOND_MS);
+            expect(callback).toHaveBeenCalledWith(null, null, {
+                [SessionChangeReason.ACTIVITY_TIMEOUT]: true,
+            });
+            vi.useRealTimers();
+        });
+    });
+    describe("dispose with active heartbeat", () => {
+        it("clears heartbeat interval on disposal", () => {
+            // Ensure window exists for heartbeat to start
+            const originalWindow = globalThis.window;
+            globalThis.window = {
+                addEventListener: vi.fn(),
+                removeEventListener: vi.fn(),
+            };
+            const clearIntervalSpy = vi.spyOn(globalThis, "clearInterval");
+            const sessionManager = createSessionManager();
+            sessionManager.dispose();
+            expect(clearIntervalSpy).toHaveBeenCalled();
+            // Verify heartbeat interval is cleared
+            expect(sessionManager._heartbeatInterval).toBeNull();
+            // Restore window
+            globalThis.window = originalWindow;
+        });
+        it("handles disposal when no heartbeat interval exists", () => {
+            const clearIntervalSpy = vi.spyOn(globalThis, "clearInterval");
+            // Create manager without heartbeat (window undefined)
+            const originalWindow = globalThis.window;
+            globalThis.window = undefined;
+            const sessionManager = createSessionManager();
+            sessionManager.dispose();
+            // Should not call clearInterval if no interval was created
+            expect(clearIntervalSpy).not.toHaveBeenCalled();
+            // Restore window
+            globalThis.window = originalWindow;
+        });
+        it("clears both timeout and interval on disposal", () => {
+            // Ensure window exists for heartbeat to start
+            const originalWindow = globalThis.window;
+            globalThis.window = {
+                addEventListener: vi.fn(),
+                removeEventListener: vi.fn(),
+            };
+            const clearTimeoutSpy = vi.spyOn(mockClock, "clearTimeout");
+            const clearIntervalSpy = vi.spyOn(globalThis, "clearInterval");
+            const sessionManager = createSessionManager();
+            sessionManager.dispose();
+            expect(clearTimeoutSpy).toHaveBeenCalled();
+            expect(clearIntervalSpy).toHaveBeenCalled();
+            // Verify both are cleared
+            expect(sessionManager
+                ._enforceIdleTimeout).toBeUndefined();
+            expect(sessionManager._heartbeatInterval).toBeNull();
+            // Restore window
+            globalThis.window = originalWindow;
+        });
+    });
+    describe("edge cases and error handling", () => {
+        it("handles malformed session data gracefully", () => {
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi.fn().mockReturnValue("invalid-data"),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(result.sessionId).toBe(TEST_SESSION_ID);
+            expect(result.changeReason?.[SessionChangeReason.NO_SESSION_ID]).toBe(true);
+        });
+        it("handles empty session array gracefully", () => {
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi.fn().mockReturnValue([]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(result.sessionId).toBe(TEST_SESSION_ID);
+        });
+        it("handles session data with wrong types", () => {
+            const NUMBER_NOT_STRING = 123;
+            const mockPersistence = {
+                register: vi.fn(),
+                getProperty: vi.fn().mockReturnValue([
+                    "not-a-number",
+                    NUMBER_NOT_STRING, // Not a string
+                    "also-not-a-number",
+                ]),
+                isDisabled: vi.fn().mockReturnValue(false),
+            };
+            const sessionManager = createSessionManager(createTestConfig(), mockPersistence);
+            const result = sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            expect(result.sessionId).toBe(TEST_SESSION_ID);
+        });
+        it("handles storage errors gracefully", () => {
+            // Create session manager first, then mock the storage to throw
+            const sessionManager = createSessionManager();
+            const mockSessionStore = sessionStore;
+            mockSessionStore._set = vi.fn((_key, _value) => {
+                throw new Error("Storage error");
+            });
+            // This should not throw even though storage fails
+            expect(() => {
+                sessionManager.checkAndGetSessionAndWindowId(false, currentTime);
+            }).not.toThrow();
+        });
+        it("generates consistent session timeout", () => {
+            const config = createTestConfig();
+            const sessionManager = createSessionManager(config);
+            // Session timeout is now static - always uses default
+            expect(sessionManager.sessionTimeoutMs).toBe(toMs(DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS));
+        });
+    });
+});
+//# sourceMappingURL=session-manager.test.js.map