@interfere/next 0.0.14 → 0.0.15-alpha.0

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

@@ -1,1168 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { sessionStore } from "../../lib/persistence/storage.js";
-import { DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS, MAX_SESSION_IDLE_TIMEOUT_SECONDS, SESSION_ID, toMs, } from "../../lib/session/constants.js";
-import { SessionChangeReason, SessionIdManager, } from "../../lib/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("updates activity timestamp when regenerating due to timeout in non-readonly mode", () => {
-            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, // readOnly = 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("prevents infinite regeneration loop when accessing expired session in readonly mode", () => {
-            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);
-            // First call in readonly mode - should regenerate session
-            const result1 = sessionManager.checkAndGetSessionAndWindowId(true, // readOnly = true (like debug calls)
-            currentTime);
-            expect(result1.sessionId).toBe(TEST_SESSION_ID);
-            expect(result1.changeReason?.[SessionChangeReason.ACTIVITY_TIMEOUT]).toBe(true);
-            // CRITICAL: The new session should have fresh activity timestamp to prevent infinite loop
-            expect(result1.lastActivityTimestamp).toBe(currentTime); // This should be currentTime, not oldTimestamp
-            // Update mock to return the new session data
-            mockPersistence.getProperty.mockReturnValue([
-                result1.lastActivityTimestamp,
-                result1.sessionId,
-                result1.sessionStartTimestamp,
-            ]);
-            // Second call in readonly mode - should NOT regenerate again
-            const result2 = sessionManager.checkAndGetSessionAndWindowId(true, // readOnly = true
-            currentTime + ONE_SECOND_MS // 1 second later
-            );
-            // Should be the same session (no regeneration)
-            expect(result2.sessionId).toBe(result1.sessionId);
-            expect(result2.changeReason).toBeUndefined(); // No change reason
-        });
-        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