@interfere/next 0.0.14 → 0.0.15-alpha.0

package/dist/__tests__/session/session-summary.test.js

@@ -1,763 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { capture as captureFn } from "../../client.js";
-import { setupSessionSummary, stopSessionSummary, } from "../../lib/session/session-summary.js";
-// Mock the client module
-vi.mock("../../client.js", () => ({
-    capture: vi.fn(),
-}));
-// Mock constants
-vi.mock("../../lib/session/constants.js", () => ({
-    ALLOW_BROWSER_AI: true,
-    SESSION_SUMMARY_ENABLED: true,
-    SESSION_SUMMARY_MAX_EVENTS: 100,
-    SESSION_SUMMARY_WINDOW_MS: 30_000,
-}));
-// Constants for tests
-const SUMMARY_WINDOW_MS = 30_000;
-const MAX_EVENTS_TO_GENERATE = 150;
-const EVENTS_TO_GENERATE = 30;
-const SAMPLE_SIZE = 20;
-const MAX_SUMMARY_LENGTH = 2000;
-const LONGER_THAN_MAX_LENGTH = 3000;
-describe("session-summary", () => {
-    let originalWindow;
-    let originalDocument;
-    let mockAddEventListener;
-    let mockRemoveEventListener;
-    let mockDocAddEventListener;
-    let mockDocRemoveEventListener;
-    let mockSetInterval;
-    let mockClearInterval;
-    let eventListeners;
-    let docEventListeners;
-    let intervalCallbacks;
-    let intervalId = 1;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Reset environment variables using vi.stubEnv
-        vi.stubEnv("NODE_ENV", "test");
-        // Store original globals
-        originalWindow = global.window;
-        originalDocument = global.document;
-        // Create event listener tracking
-        eventListeners = new Map();
-        docEventListeners = new Map();
-        intervalCallbacks = new Map();
-        // Mock window addEventListener/removeEventListener
-        mockAddEventListener = vi.fn((event, handler) => {
-            if (!eventListeners.has(event)) {
-                eventListeners.set(event, new Set());
-            }
-            eventListeners.get(event)?.add(handler);
-        });
-        mockRemoveEventListener = vi.fn((event, handler) => {
-            eventListeners.get(event)?.delete(handler);
-        });
-        // Mock document addEventListener/removeEventListener
-        mockDocAddEventListener = vi.fn((event, handler) => {
-            if (!docEventListeners.has(event)) {
-                docEventListeners.set(event, new Set());
-            }
-            docEventListeners.get(event)?.add(handler);
-        });
-        mockDocRemoveEventListener = vi.fn((event, handler) => {
-            docEventListeners.get(event)?.delete(handler);
-        });
-        // Mock setInterval/clearInterval
-        mockSetInterval = vi.fn((callback, _ms) => {
-            const id = intervalId++;
-            intervalCallbacks.set(id, callback);
-            return id;
-        });
-        mockClearInterval = vi.fn((id) => {
-            intervalCallbacks.delete(id);
-        });
-        // Setup global window and document mocks
-        global.window = {
-            addEventListener: mockAddEventListener,
-            removeEventListener: mockRemoveEventListener,
-            setInterval: mockSetInterval,
-            clearInterval: mockClearInterval,
-            ai: undefined,
-        };
-        global.document = {
-            addEventListener: mockDocAddEventListener,
-            removeEventListener: mockDocRemoveEventListener,
-            visibilityState: "visible",
-        };
-        // Mock history API
-        global.history = {
-            pushState: vi.fn(),
-            replaceState: vi.fn(),
-        };
-    });
-    afterEach(() => {
-        stopSessionSummary();
-        global.window = originalWindow;
-        global.document = originalDocument;
-        vi.resetAllMocks();
-    });
-    describe("setupSessionSummary", () => {
-        it("should initialize event listeners when in browser environment", () => {
-            setupSessionSummary();
-            // Check that event listeners were added
-            expect(mockDocAddEventListener).toHaveBeenCalledWith("click", expect.any(Function), { capture: true });
-            expect(mockDocAddEventListener).toHaveBeenCalledWith("keydown", expect.any(Function), { capture: true });
-            expect(mockAddEventListener).toHaveBeenCalledWith("popstate", expect.any(Function));
-            expect(mockAddEventListener).toHaveBeenCalledWith("error", expect.any(Function));
-            expect(mockAddEventListener).toHaveBeenCalledWith("unhandledrejection", expect.any(Function));
-            expect(mockAddEventListener).toHaveBeenCalledWith("beforeunload", expect.any(Function));
-            expect(mockDocAddEventListener).toHaveBeenCalledWith("visibilitychange", expect.any(Function));
-            // Check that interval was set
-            expect(mockSetInterval).toHaveBeenCalledWith(expect.any(Function), SUMMARY_WINDOW_MS);
-        });
-        it("should not initialize twice", () => {
-            setupSessionSummary();
-            const firstCallCount = mockAddEventListener.mock.calls.length;
-            setupSessionSummary();
-            expect(mockAddEventListener).toHaveBeenCalledTimes(firstCallCount);
-        });
-        it("should not initialize when not in browser environment", () => {
-            // Remove window to simulate non-browser environment
-            // @ts-expect-error - intentionally setting window to undefined for test
-            global.window = undefined;
-            setupSessionSummary();
-            expect(mockAddEventListener).not.toHaveBeenCalled();
-            // Restore window
-            global.window = {
-                addEventListener: mockAddEventListener,
-                removeEventListener: mockRemoveEventListener,
-            };
-        });
-        it("should not initialize when SESSION_SUMMARY_ENABLED is false", () => {
-            // This test would require re-mocking the module which is complex in vitest
-            // Skipping for now as SESSION_SUMMARY_ENABLED is always true in current implementation
-            expect(true).toBe(true);
-        });
-    });
-    describe("event tracking", () => {
-        beforeEach(() => {
-            setupSessionSummary();
-        });
-        it("should track click events", () => {
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            expect(clickHandler).toBeDefined();
-            if (clickHandler) {
-                // Simulate click with aria-label
-                const event1 = {
-                    target: {
-                        getAttribute: vi.fn((attr) => attr === "aria-label" ? "Submit Button" : null),
-                        textContent: "Click me",
-                    },
-                };
-                clickHandler(event1);
-                // Simulate click with text content
-                const event2 = {
-                    target: {
-                        getAttribute: vi.fn(() => null),
-                        textContent: "Another button with very long text that should be truncated after 60 characters",
-                    },
-                };
-                clickHandler(event2);
-                // Simulate click with no label
-                const event3 = {
-                    target: {
-                        getAttribute: vi.fn(() => null),
-                        textContent: null,
-                    },
-                };
-                clickHandler(event3);
-            }
-        });
-        it("should track keydown events", () => {
-            const keyHandler = docEventListeners
-                .get("keydown")
-                ?.values()
-                .next().value;
-            expect(keyHandler).toBeDefined();
-            if (keyHandler) {
-                // Simulate keydown event
-                keyHandler({});
-            }
-        });
-        it("should track navigation events", () => {
-            const originalPushState = vi.fn();
-            const originalReplaceState = vi.fn();
-            global.history.pushState = originalPushState;
-            global.history.replaceState = originalReplaceState;
-            setupSessionSummary();
-            // The wrapped functions should be called
-            global.history.pushState({}, "", "/new-page");
-            expect(originalPushState).toHaveBeenCalled();
-            global.history.replaceState({}, "", "/replaced-page");
-            expect(originalReplaceState).toHaveBeenCalled();
-            // Test popstate
-            const popstateHandler = eventListeners
-                .get("popstate")
-                ?.values()
-                .next().value;
-            expect(popstateHandler).toBeDefined();
-            if (popstateHandler) {
-                popstateHandler({});
-            }
-        });
-        it("should track error events", () => {
-            const errorHandler = eventListeners.get("error")?.values().next().value;
-            expect(errorHandler).toBeDefined();
-            if (errorHandler) {
-                // Simulate error event
-                errorHandler({
-                    message: "Test error message",
-                });
-                // Simulate error event without message
-                errorHandler({});
-            }
-        });
-        it("should track unhandled rejection events", () => {
-            const rejectionHandler = eventListeners
-                .get("unhandledrejection")
-                ?.values()
-                .next().value;
-            expect(rejectionHandler).toBeDefined();
-            if (rejectionHandler) {
-                // Simulate rejection with Error object
-                rejectionHandler({
-                    reason: new Error("Promise rejection error"),
-                });
-                // Simulate rejection with string reason
-                rejectionHandler({
-                    reason: "String rejection",
-                });
-                // Simulate rejection with object reason without message
-                rejectionHandler({
-                    reason: { someProperty: "value" },
-                });
-                // Simulate rejection without reason
-                rejectionHandler({});
-            }
-        });
-    });
-    describe("event buffer management", () => {
-        it("should limit buffer size to max events", () => {
-            setupSessionSummary();
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            if (clickHandler) {
-                // Generate more events than max (assuming max is 100)
-                for (let i = 0; i < MAX_EVENTS_TO_GENERATE; i++) {
-                    clickHandler({
-                        target: {
-                            getAttribute: vi.fn(() => null),
-                            textContent: `Click ${i}`,
-                        },
-                    });
-                }
-            }
-            // Buffer should be limited to max events
-            // We can't directly check buffer size, but we can verify behavior
-            // by checking that old events are removed
-        });
-    });
-    describe("summary emission", () => {
-        beforeEach(() => {
-            vi.useFakeTimers();
-            setupSessionSummary();
-        });
-        afterEach(() => {
-            vi.useRealTimers();
-        });
-        it("should emit summary on interval", async () => {
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            if (clickHandler) {
-                // Add some events
-                clickHandler({
-                    target: {
-                        getAttribute: vi.fn(() => "Test Button"),
-                        textContent: "Click",
-                    },
-                });
-            }
-            // Get the interval callback
-            const intervalCallback = Array.from(intervalCallbacks.values())[0];
-            expect(intervalCallback).toBeDefined();
-            if (intervalCallback) {
-                // Execute the interval callback
-                await intervalCallback();
-                // Check that capture was called
-                expect(vi.mocked(captureFn)).toHaveBeenCalledWith("session_summary", expect.objectContaining({
-                    version: 1,
-                    eventCount: expect.any(Number),
-                    sample: expect.any(Array),
-                    summary: null, // No AI available in test
-                }));
-            }
-        });
-        it("should emit summary on beforeunload", async () => {
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            if (clickHandler) {
-                // Add some events
-                clickHandler({
-                    target: {
-                        getAttribute: vi.fn(() => null),
-                        textContent: "Test",
-                    },
-                });
-            }
-            // Trigger beforeunload
-            const beforeUnloadHandler = eventListeners
-                .get("beforeunload")
-                ?.values()
-                .next().value;
-            expect(beforeUnloadHandler).toBeDefined();
-            if (beforeUnloadHandler) {
-                await beforeUnloadHandler();
-                expect(vi.mocked(captureFn)).toHaveBeenCalled();
-            }
-        });
-        it("should emit summary on visibility change to hidden", async () => {
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            if (clickHandler) {
-                // Add some events
-                clickHandler({
-                    target: {
-                        getAttribute: vi.fn(() => null),
-                        textContent: "Test",
-                    },
-                });
-            }
-            // Change visibility to hidden
-            Object.defineProperty(global.document, "visibilityState", {
-                value: "hidden",
-                writable: true,
-                configurable: true,
-            });
-            const visibilityHandler = docEventListeners
-                .get("visibilitychange")
-                ?.values()
-                .next().value;
-            expect(visibilityHandler).toBeDefined();
-            if (visibilityHandler) {
-                await visibilityHandler();
-                expect(vi.mocked(captureFn)).toHaveBeenCalled();
-            }
-        });
-        it("should not emit summary when no events", async () => {
-            // Get the interval callback
-            const intervalCallback = Array.from(intervalCallbacks.values())[0];
-            if (intervalCallback) {
-                // Execute without any events
-                await intervalCallback();
-                expect(vi.mocked(captureFn)).not.toHaveBeenCalled();
-            }
-        });
-        it("should handle capture errors gracefully", async () => {
-            vi.mocked(captureFn).mockImplementation(() => {
-                throw new Error("Capture failed");
-            });
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            if (clickHandler) {
-                clickHandler({
-                    target: {
-                        getAttribute: vi.fn(() => null),
-                        textContent: "Test",
-                    },
-                });
-            }
-            const intervalCallback = Array.from(intervalCallbacks.values())[0];
-            if (intervalCallback) {
-                // Should not throw
-                await expect(Promise.resolve(intervalCallback())).resolves.not.toThrow();
-            }
-        });
-    });
-    describe("browser AI summarization", () => {
-        it("should use browser AI when available", async () => {
-            // Note: Browser AI is mocked but ALLOW_BROWSER_AI constant determines if it's used
-            // Since we can't easily change the constant after module import, we'll verify
-            // the behavior with the current setting
-            const mockPrompt = vi.fn().mockResolvedValue(JSON.stringify({
-                summary: "User clicked buttons",
-                keyActions: ["click"],
-                errors: [],
-            }));
-            const mockCreateTextSession = vi.fn().mockResolvedValue({
-                prompt: mockPrompt,
-            });
-            const mockCanCreateTextSession = vi.fn().mockResolvedValue("readily");
-            global.window.ai = {
-                canCreateTextSession: mockCanCreateTextSession,
-                createTextSession: mockCreateTextSession,
-            };
-            setupSessionSummary();
-            // Add events
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            if (clickHandler) {
-                clickHandler({
-                    target: {
-                        getAttribute: vi.fn(() => "Submit"),
-                        textContent: "Submit",
-                    },
-                });
-            }
-            // Trigger summary
-            const intervalCallback = Array.from(intervalCallbacks.values())[0];
-            if (intervalCallback) {
-                await intervalCallback();
-                // With ALLOW_BROWSER_AI = true (from mock), AI should be called
-                if (mockCanCreateTextSession.mock.calls.length > 0) {
-                    expect(mockCreateTextSession).toHaveBeenCalledWith({
-                        temperature: 0.2,
-                        topK: 40,
-                        topP: 0.95,
-                    });
-                    expect(mockPrompt).toHaveBeenCalled();
-                    expect(vi.mocked(captureFn)).toHaveBeenCalledWith("session_summary", expect.objectContaining({
-                        summary: expect.stringContaining("User clicked buttons"),
-                    }));
-                }
-                else {
-                    // If AI wasn't called, verify capture was still called without summary
-                    expect(vi.mocked(captureFn)).toHaveBeenCalledWith("session_summary", expect.objectContaining({
-                        summary: null,
-                    }));
-                }
-            }
-        });
-        it("should handle AI not ready", async () => {
-            global.window.ai = {
-                canCreateTextSession: vi.fn().mockResolvedValue("no"),
-                createTextSession: vi.fn(),
-            };
-            setupSessionSummary();
-            // Add events
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            if (clickHandler) {
-                clickHandler({
-                    target: {
-                        getAttribute: vi.fn(() => null),
-                        textContent: "Test",
-                    },
-                });
-            }
-            // Trigger summary
-            const intervalCallback = Array.from(intervalCallbacks.values())[0];
-            if (intervalCallback) {
-                await intervalCallback();
-                expect(vi.mocked(captureFn)).toHaveBeenCalledWith("session_summary", expect.objectContaining({
-                    summary: null,
-                }));
-            }
-        });
-        it("should handle AI after-download state", async () => {
-            const mockPrompt = vi.fn().mockResolvedValue("AI summary");
-            global.window.ai = {
-                canCreateTextSession: vi.fn().mockResolvedValue("after-download"),
-                createTextSession: vi.fn().mockResolvedValue({
-                    prompt: mockPrompt,
-                }),
-            };
-            setupSessionSummary();
-            // Add events
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            if (clickHandler) {
-                clickHandler({
-                    target: {
-                        getAttribute: vi.fn(() => null),
-                        textContent: "Test",
-                    },
-                });
-            }
-            // Trigger summary
-            const intervalCallback = Array.from(intervalCallbacks.values())[0];
-            if (intervalCallback) {
-                await intervalCallback();
-                // AI may or may not be called depending on ALLOW_BROWSER_AI constant
-                expect(vi.mocked(captureFn)).toHaveBeenCalled();
-            }
-        });
-        it("should handle AI errors gracefully", async () => {
-            global.window.ai = {
-                canCreateTextSession: vi.fn().mockRejectedValue(new Error("AI failed")),
-                createTextSession: vi.fn(),
-            };
-            setupSessionSummary();
-            // Add events
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            if (clickHandler) {
-                clickHandler({
-                    target: {
-                        getAttribute: vi.fn(() => null),
-                        textContent: "Test",
-                    },
-                });
-            }
-            // Trigger summary
-            const intervalCallback = Array.from(intervalCallbacks.values())[0];
-            if (intervalCallback) {
-                await intervalCallback();
-                expect(vi.mocked(captureFn)).toHaveBeenCalledWith("session_summary", expect.objectContaining({
-                    summary: null,
-                }));
-            }
-        });
-        it("should truncate long AI responses", async () => {
-            const longResponse = "x".repeat(LONGER_THAN_MAX_LENGTH); // Longer than MAX_LENGTH (2000)
-            global.window.ai = {
-                canCreateTextSession: vi.fn().mockResolvedValue("readily"),
-                createTextSession: vi.fn().mockResolvedValue({
-                    prompt: vi.fn().mockResolvedValue(longResponse),
-                }),
-            };
-            setupSessionSummary();
-            // Add events
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            if (clickHandler) {
-                clickHandler({
-                    target: {
-                        getAttribute: vi.fn(() => null),
-                        textContent: "Test",
-                    },
-                });
-            }
-            // Trigger summary
-            const intervalCallback = Array.from(intervalCallbacks.values())[0];
-            if (intervalCallback) {
-                await intervalCallback();
-                expect(vi.mocked(captureFn)).toHaveBeenCalled();
-                const call = vi.mocked(captureFn).mock.calls[0];
-                // If AI was used, check truncation
-                if (call?.[1]) {
-                    const payload = call[1];
-                    if (payload.summary && payload.summary !== null) {
-                        expect(payload.summary.length).toBeLessThanOrEqual(MAX_SUMMARY_LENGTH);
-                    }
-                }
-            }
-        });
-        it("should handle empty AI response", async () => {
-            global.window.ai = {
-                canCreateTextSession: vi.fn().mockResolvedValue("readily"),
-                createTextSession: vi.fn().mockResolvedValue({
-                    prompt: vi.fn().mockResolvedValue(""),
-                }),
-            };
-            setupSessionSummary();
-            // Add events
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            if (clickHandler) {
-                clickHandler({
-                    target: {
-                        getAttribute: vi.fn(() => null),
-                        textContent: "Test",
-                    },
-                });
-            }
-            // Trigger summary
-            const intervalCallback = Array.from(intervalCallbacks.values())[0];
-            if (intervalCallback) {
-                await intervalCallback();
-                expect(vi.mocked(captureFn)).toHaveBeenCalledWith("session_summary", expect.objectContaining({
-                    summary: null,
-                }));
-            }
-        });
-    });
-    describe("stopSessionSummary", () => {
-        it("should remove all event listeners", () => {
-            setupSessionSummary();
-            // Verify listeners were added
-            expect(mockAddEventListener).toHaveBeenCalled();
-            expect(mockDocAddEventListener).toHaveBeenCalled();
-            expect(mockSetInterval).toHaveBeenCalled();
-            stopSessionSummary();
-            // Verify listeners were removed
-            expect(mockRemoveEventListener).toHaveBeenCalled();
-            expect(mockDocRemoveEventListener).toHaveBeenCalled();
-            expect(mockClearInterval).toHaveBeenCalled();
-        });
-        it("should reset initialized state", () => {
-            setupSessionSummary();
-            const firstCallCount = mockAddEventListener.mock.calls.length;
-            stopSessionSummary();
-            // Should be able to initialize again
-            setupSessionSummary();
-            expect(mockAddEventListener.mock.calls.length).toBeGreaterThan(firstCallCount);
-        });
-        it("should clear buffer", () => {
-            setupSessionSummary();
-            // Add some events
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            if (clickHandler) {
-                clickHandler({
-                    target: {
-                        getAttribute: vi.fn(() => null),
-                        textContent: "Test",
-                    },
-                });
-            }
-            stopSessionSummary();
-            // Re-initialize and check that buffer was cleared
-            setupSessionSummary();
-            // Trigger summary immediately - should have no events
-            const intervalCallback = Array.from(intervalCallbacks.values())[0];
-            if (intervalCallback) {
-                intervalCallback();
-                expect(vi.mocked(captureFn)).not.toHaveBeenCalled();
-            }
-        });
-        it("should handle teardown errors gracefully", () => {
-            setupSessionSummary();
-            // Make removeEventListener throw
-            mockRemoveEventListener.mockImplementation(() => {
-                throw new Error("Remove failed");
-            });
-            // Should not throw
-            expect(() => stopSessionSummary()).not.toThrow();
-        });
-        it("should restore original history methods", () => {
-            const originalPushState = vi.fn();
-            const originalReplaceState = vi.fn();
-            global.history.pushState = originalPushState;
-            global.history.replaceState = originalReplaceState;
-            setupSessionSummary();
-            // History methods should be wrapped
-            expect(global.history.pushState).not.toBe(originalPushState);
-            expect(global.history.replaceState).not.toBe(originalReplaceState);
-            stopSessionSummary();
-            // History methods should be restored (they are bound functions)
-            // We can verify they work correctly by calling them
-            global.history.pushState({}, "", "/test");
-            global.history.replaceState({}, "", "/test2");
-            expect(originalPushState).toHaveBeenCalledWith({}, "", "/test");
-            expect(originalReplaceState).toHaveBeenCalledWith({}, "", "/test2");
-        });
-    });
-    describe("sample events", () => {
-        it("should include last 20 events in sample", async () => {
-            setupSessionSummary();
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            if (clickHandler) {
-                // Add 30 events
-                for (let i = 0; i < EVENTS_TO_GENERATE; i++) {
-                    clickHandler({
-                        target: {
-                            getAttribute: vi.fn(() => null),
-                            textContent: `Click ${i}`,
-                        },
-                    });
-                }
-            }
-            // Trigger summary
-            const intervalCallback = Array.from(intervalCallbacks.values())[0];
-            if (intervalCallback) {
-                await intervalCallback();
-                expect(vi.mocked(captureFn)).toHaveBeenCalledWith("session_summary", expect.objectContaining({
-                    eventCount: EVENTS_TO_GENERATE,
-                    sample: expect.arrayContaining([
-                        expect.objectContaining({
-                            kind: "ui",
-                            action: "click",
-                        }),
-                    ]),
-                }));
-                const call = vi.mocked(captureFn).mock.calls[0];
-                if (call?.[1]) {
-                    const payload = call[1];
-                    expect(payload.sample.length).toBeLessThanOrEqual(SAMPLE_SIZE);
-                }
-            }
-        });
-    });
-    describe("ALLOW_BROWSER_AI flag", () => {
-        it("should not attempt AI summarization when ALLOW_BROWSER_AI is false", async () => {
-            // Re-mock constants with ALLOW_BROWSER_AI = false
-            vi.doUnmock("../../lib/session/constants.js");
-            vi.mock("../../lib/session/constants.js", () => ({
-                ALLOW_BROWSER_AI: false,
-                SESSION_SUMMARY_ENABLED: true,
-                SESSION_SUMMARY_MAX_EVENTS: 100,
-                SESSION_SUMMARY_WINDOW_MS: 30_000,
-            }));
-            // Setup AI mock
-            const mockPrompt = vi.fn();
-            global.window.ai = {
-                canCreateTextSession: vi.fn(),
-                createTextSession: vi.fn().mockResolvedValue({
-                    prompt: mockPrompt,
-                }),
-            };
-            // Re-import to get new mock
-            const module = await import("../../lib/session/session-summary.js");
-            module.setupSessionSummary();
-            // Add events
-            const clickHandler = docEventListeners
-                .get("click")
-                ?.values()
-                .next().value;
-            if (clickHandler) {
-                clickHandler({
-                    target: {
-                        getAttribute: vi.fn(() => null),
-                        textContent: "Test",
-                    },
-                });
-            }
-            // Trigger summary
-            const intervalCallback = Array.from(intervalCallbacks.values())[0];
-            if (intervalCallback) {
-                await intervalCallback();
-                // AI should not be called
-                const windowWithAI = global.window;
-                if (windowWithAI.ai) {
-                    expect(windowWithAI.ai.canCreateTextSession).not.toHaveBeenCalled();
-                }
-                expect(mockPrompt).not.toHaveBeenCalled();
-                expect(vi.mocked(captureFn)).toHaveBeenCalledWith("session_summary", expect.objectContaining({
-                    summary: null,
-                }));
-            }
-        });
-    });
-});
-//# sourceMappingURL=session-summary.test.js.map