@jmruthers/pace-core 0.6.5 → 0.6.7

package/src/hooks/__tests__/usePublicEvent.unit.test.ts

@@ -14,42 +14,23 @@ vi.mock('../../components/PublicLayout/PublicPageProvider', () => ({
   }))
 }));
 
-// Mock Supabase client
-const mockSupabaseClient = {
-  rpc: vi.fn(),
-  from: vi.fn(() => ({
-    select: vi.fn(() => ({
-      eq: vi.fn(() => ({
-        eq: vi.fn(() => ({
-          not: vi.fn(() => ({
-            limit: vi.fn(() => ({
-              single: vi.fn()
-            }))
-          }))
-        }))
-      }))
-    }))
-  }))
-};
-
-// Helper to create table query mocks
-const createTableQueryMock = () => ({
-  data: null,
-  error: null,
-  mockResolvedValueOnce: vi.fn(),
-  mockResolvedValue: vi.fn()
-});
-
-// Helper to create a complete table query chain
-const createTableQueryChain = (finalResult: any) => {
-  const mockChain = {
+// Mock Supabase client with proper query builder chain
+// usePublicEvent uses: .from('core_events').select(...).eq(...).eq(...).not(...).limit(1).single()
+const createMockQueryBuilder = (mockData: any = null, mockError: any = null) => {
+  const builder: any = {
     select: vi.fn().mockReturnThis(),
     eq: vi.fn().mockReturnThis(),
     not: vi.fn().mockReturnThis(),
     limit: vi.fn().mockReturnThis(),
-    single: vi.fn().mockResolvedValue(finalResult)
+    single: vi.fn().mockResolvedValue({ data: mockData, error: mockError }),
+    maybeSingle: vi.fn().mockResolvedValue({ data: mockData, error: mockError })
   };
-  return mockChain;
+  return builder;
+};
+
+const mockSupabaseClient = {
+  rpc: vi.fn().mockResolvedValue({ data: null, error: null }),
+  from: vi.fn(() => createMockQueryBuilder())
 };
 
 // Mock createClient
@@ -110,7 +91,7 @@ describe('usePublicEvent', () => {
       expect(result.current.error).toBe(null);
     });
 
-    it('should fetch event data successfully via RPC', async () => {
+    it('should fetch event data successfully via table query', async () => {
       const mockEventData = {
         event_id: '123',
         event_name: 'Test Event',
@@ -131,16 +112,24 @@ describe('usePublicEvent', () => {
         event_logo: null
       };
 
-      mockSupabaseClient.rpc.mockResolvedValueOnce({
-        data: [mockEventData],
-        error: null
+      // usePublicEvent makes TWO queries: core_events + core_file_references (logo)
+      const mockEventQueryBuilder = createMockQueryBuilder({
+        ...mockEventData,
+        event_code: 'test-event',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
       });
+      const mockLogoQueryBuilder = createMockQueryBuilder(null, null);
+      mockSupabaseClient.from
+        .mockReturnValueOnce(mockEventQueryBuilder)
+        .mockReturnValueOnce(mockLogoQueryBuilder);
 
       const { result } = renderHook(() => usePublicEvent('test-event'));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
+      }, { interval: 10, timeout: 2000 });
 
       expect(result.current.event).toEqual({
         id: '123',
@@ -210,22 +199,30 @@ describe('usePublicEvent', () => {
         event_email: 'event@example.com'
       };
 
-      mockSupabaseClient.rpc.mockResolvedValueOnce({
-        data: [mockEventData],
-        error: null
+      // usePublicEvent makes TWO queries: core_events + core_file_references (logo)
+      const mockEventQueryBuilder = createMockQueryBuilder({
+        ...mockEventData,
+        event_code: 'test-event',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
       });
+      const mockLogoQueryBuilder = createMockQueryBuilder(null, null);
+      mockSupabaseClient.from
+        .mockReturnValueOnce(mockEventQueryBuilder)
+        .mockReturnValueOnce(mockLogoQueryBuilder);
 
       const { result, rerender } = renderHook(() => usePublicEvent('test-event'));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
+      }, { interval: 10, timeout: 2000 });
 
-      // Rerender with same event code - should use cache
+      // Rerender with same event code - should use cache (no new queries)
       rerender();
       
-      // Should not call RPC again
-      expect(mockSupabaseClient.rpc).toHaveBeenCalledTimes(1);
+      // Should not call query again (cached) - only initial fetch: 2 calls (event + logo)
+      expect(mockSupabaseClient.from).toHaveBeenCalledTimes(2);
     });
 
     it('should respect cache TTL', async () => {
@@ -248,28 +245,40 @@ describe('usePublicEvent', () => {
         event_email: 'event@example.com'
       };
 
-      mockSupabaseClient.rpc.mockResolvedValueOnce({
-        data: [mockEventData],
-        error: null
+      // usePublicEvent makes TWO queries: core_events + core_file_references (logo)
+      const mockEventQueryBuilder = createMockQueryBuilder({
+        ...mockEventData,
+        event_code: 'test-event',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
       });
+      const mockLogoQueryBuilder = createMockQueryBuilder(null, null);
+      // Need mocks for both hook instances: initial (2 calls) + after cache expires (2 calls) = 4 total
+      mockSupabaseClient.from
+        .mockReturnValueOnce(mockEventQueryBuilder) // First hook: event
+        .mockReturnValueOnce(mockLogoQueryBuilder)  // First hook: logo
+        .mockReturnValueOnce(mockEventQueryBuilder) // Second hook (after cache expires): event
+        .mockReturnValueOnce(mockLogoQueryBuilder); // Second hook (after cache expires): logo
 
       const { result } = renderHook(() => usePublicEvent('test-event', { cacheTtl: 100 }));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
+      }, { interval: 10, timeout: 2000 });
 
       // Wait for cache to expire
       await new Promise(resolve => setTimeout(resolve, 150));
 
-      // Rerender should fetch again
+      // New hook instance should fetch again (cache expired)
       const { result: result2 } = renderHook(() => usePublicEvent('test-event', { cacheTtl: 100 }));
       
       await waitFor(() => {
         expect(result2.current.isLoading).toBe(false);
-      }, { interval: 10 });
+      }, { interval: 10, timeout: 2000 });
 
-      expect(mockSupabaseClient.rpc).toHaveBeenCalledTimes(2);
+      // Each fetch makes 2 calls (event + logo), so 2 fetches = 4 calls
+      expect(mockSupabaseClient.from).toHaveBeenCalledTimes(4);
     });
 
     it('should disable caching when requested', async () => {
@@ -297,14 +306,33 @@ describe('usePublicEvent', () => {
       const { clearPublicEventCache } = await import('../public/usePublicEvent');
       clearPublicEventCache();
 
-      // Use mockImplementation to handle multiple calls
+      // usePublicEvent makes TWO queries per fetch: core_events + core_file_references (logo)
       let callCount = 0;
-      mockSupabaseClient.rpc.mockImplementation(() => {
+      const mockEventQueryBuilder1 = createMockQueryBuilder({
+        ...mockEventData,
+        event_code: 'test-event',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      });
+      const mockLogoQueryBuilder1 = createMockQueryBuilder(null, null);
+      const mockEventQueryBuilder2 = createMockQueryBuilder({
+        ...mockEventData,
+        event_code: 'test-event-2',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      });
+      const mockLogoQueryBuilder2 = createMockQueryBuilder(null, null);
+      
+      mockSupabaseClient.from.mockImplementation(() => {
         callCount++;
-        return Promise.resolve({
-          data: [mockEventData],
-          error: null
-        });
+        // First fetch: event1 + logo1, Second fetch: event2 + logo2
+        if (callCount <= 2) {
+          return callCount === 1 ? mockEventQueryBuilder1 : mockLogoQueryBuilder1;
+        } else {
+          return callCount === 3 ? mockEventQueryBuilder2 : mockLogoQueryBuilder2;
+        }
       });
 
       const { result, rerender } = renderHook(
@@ -314,44 +342,36 @@ describe('usePublicEvent', () => {
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
+      }, { interval: 10, timeout: 2000 });
 
       // Change the event code to force a new fetch
       rerender({ eventCode: 'test-event-2' });
       
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
+      }, { interval: 10, timeout: 2000 });
 
-      expect(callCount).toBe(2);
+      // Each fetch makes 2 calls (event + logo), so 2 fetches = 4 calls
+      expect(callCount).toBe(4);
     });
   });
 
   describe('Error Handling', () => {
-    it('should handle RPC errors', async () => {
-      // Mock the RPC call to return an error object
+    it('should handle query errors', async () => {
+      // usePublicEvent uses table query, not RPC
       const testError = { message: 'Database error', details: 'Test error details', hint: null, code: 'TEST_ERROR' };
-      mockSupabaseClient.rpc.mockImplementation(() => 
-        Promise.resolve({
-          data: null,
-          error: testError
-        })
-      );
+      const mockQueryBuilder = createMockQueryBuilder(null, testError);
+      mockSupabaseClient.from.mockReturnValue(mockQueryBuilder);
 
       const { result } = renderHook(() => usePublicEvent('test-event'));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
+      }, { interval: 10, timeout: 2000 });
 
       expect(result.current.error).toBeInstanceOf(Error);
       expect(result.current.error?.message).toBe('Database error');
       expect(result.current.event).toBe(null);
-      
-      // Verify the mock was called
-      expect(mockSupabaseClient.rpc).toHaveBeenCalledWith('get_public_event_by_code', {
-        event_code_param: 'test-event'
-      });
     });
 
     it('should handle missing Supabase client', async () => {
@@ -411,16 +431,24 @@ describe('usePublicEvent', () => {
         event_logo: null
       };
 
-      mockSupabaseClient.rpc.mockResolvedValueOnce({
-        data: [mockEventData],
-        error: null
+      // usePublicEvent makes TWO queries: core_events + core_file_references (logo)
+      const mockEventQueryBuilder = createMockQueryBuilder({
+        ...mockEventData,
+        event_code: 'test-event',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
       });
+      const mockLogoQueryBuilder = createMockQueryBuilder(null, null);
+      mockSupabaseClient.from
+        .mockReturnValueOnce(mockEventQueryBuilder)
+        .mockReturnValueOnce(mockLogoQueryBuilder);
 
       const { result } = renderHook(() => usePublicEvent('test-event'));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
+      }, { interval: 10, timeout: 2000 });
 
       expect(result.current.event).toBeTruthy();
     });
@@ -447,23 +475,35 @@ describe('usePublicEvent', () => {
         event_email: 'event@example.com'
       };
 
-      mockSupabaseClient.rpc.mockResolvedValue({
-        data: [mockEventData],
-        error: null
+      // usePublicEvent makes TWO queries: core_events + core_file_references (logo)
+      const mockEventQueryBuilder = createMockQueryBuilder({
+        ...mockEventData,
+        event_code: 'test-event',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
       });
+      const mockLogoQueryBuilder = createMockQueryBuilder(null, null);
+      // Need mocks for initial fetch (2 calls) + refetch (2 calls) = 4 total
+      mockSupabaseClient.from
+        .mockReturnValueOnce(mockEventQueryBuilder) // Initial: event
+        .mockReturnValueOnce(mockLogoQueryBuilder)  // Initial: logo
+        .mockReturnValueOnce(mockEventQueryBuilder) // Refetch: event
+        .mockReturnValueOnce(mockLogoQueryBuilder); // Refetch: logo
 
       const { result } = renderHook(() => usePublicEvent('test-event'));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
+      }, { interval: 10, timeout: 2000 });
 
       // Call refetch
       await act(async () => {
         await result.current.refetch();
       });
 
-      expect(mockSupabaseClient.rpc).toHaveBeenCalledTimes(2);
+      // Each fetch makes 2 calls (event + logo), so 2 fetches = 4 calls
+      expect(mockSupabaseClient.from).toHaveBeenCalledTimes(4);
     });
 
     it('should clear cache when refetch is called', async () => {
@@ -486,24 +526,36 @@ describe('usePublicEvent', () => {
         event_email: 'event@example.com'
       };
 
-      mockSupabaseClient.rpc.mockResolvedValue({
-        data: [mockEventData],
-        error: null
+      // usePublicEvent makes TWO queries: core_events + core_file_references (logo)
+      const mockEventQueryBuilder = createMockQueryBuilder({
+        ...mockEventData,
+        event_code: 'test-event',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
       });
+      const mockLogoQueryBuilder = createMockQueryBuilder(null, null);
+      // Need mocks for initial fetch (2 calls) + refetch (2 calls) = 4 total
+      mockSupabaseClient.from
+        .mockReturnValueOnce(mockEventQueryBuilder) // Initial: event
+        .mockReturnValueOnce(mockLogoQueryBuilder)  // Initial: logo
+        .mockReturnValueOnce(mockEventQueryBuilder) // Refetch: event
+        .mockReturnValueOnce(mockLogoQueryBuilder); // Refetch: logo
 
       const { result } = renderHook(() => usePublicEvent('test-event'));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
+      }, { interval: 10, timeout: 2000 });
 
       // Call refetch
       await act(async () => {
         await result.current.refetch();
       });
 
-      // Should call RPC again (cache was cleared)
-      expect(mockSupabaseClient.rpc).toHaveBeenCalledTimes(2);
+      // Should call query again (cache was cleared)
+      // Each fetch makes 2 calls (event + logo), so 2 fetches = 4 calls
+      expect(mockSupabaseClient.from).toHaveBeenCalledTimes(4);
     });
   });
 
@@ -530,52 +582,49 @@ describe('usePublicEvent', () => {
   });
 
   describe('Edge Cases', () => {
-    it('should handle null event data from RPC', async () => {
-      mockSupabaseClient.rpc.mockResolvedValueOnce({
-        data: null,
-        error: null
-      });
+    it('should handle null event data from query', async () => {
+      // usePublicEvent uses table query, not RPC
+      const mockQueryBuilder = createMockQueryBuilder(null, null);
+      mockSupabaseClient.from.mockReturnValue(mockQueryBuilder);
 
       const { result } = renderHook(() => usePublicEvent('test-event'));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
+      }, { interval: 10, timeout: 2000 });
 
       expect(result.current.event).toBe(null);
-      expect(result.current.error).toEqual(new Error('Event not found'));
+      expect(result.current.error?.message).toBe('Event not found');
     });
 
-    it('should handle empty event data array from RPC', async () => {
-      mockSupabaseClient.rpc.mockResolvedValueOnce({
-        data: [],
-        error: null
-      });
+    it('should handle query returning null (event not found)', async () => {
+      // usePublicEvent uses table query, not RPC
+      const mockQueryBuilder = createMockQueryBuilder(null, { code: 'PGRST116', message: 'No rows found' });
+      mockSupabaseClient.from.mockReturnValue(mockQueryBuilder);
 
       const { result } = renderHook(() => usePublicEvent('test-event'));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
+      }, { interval: 10, timeout: 2000 });
 
       expect(result.current.event).toBe(null);
-      expect(result.current.error).toEqual(new Error('Event not found'));
+      expect(result.current.error?.message).toBe('Event not found');
     });
 
-    it('should handle undefined event data from RPC', async () => {
-      mockSupabaseClient.rpc.mockResolvedValueOnce({
-        data: [undefined],
-        error: null
-      });
+    it('should handle undefined event data from query', async () => {
+      // usePublicEvent uses table query, not RPC
+      const mockQueryBuilder = createMockQueryBuilder(null, null);
+      mockSupabaseClient.from.mockReturnValue(mockQueryBuilder);
 
       const { result } = renderHook(() => usePublicEvent('test-event'));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
+      }, { interval: 10, timeout: 2000 });
 
       expect(result.current.event).toBe(null);
-      expect(result.current.error).toEqual(new Error('Event not found'));
+      expect(result.current.error?.message).toBe('Event not found');
     });
   });
 });

package/src/hooks/__tests__/useSessionDraft.test.ts

@@ -0,0 +1,163 @@
+/**
+ * @file useSessionDraft Hook Tests
+ * @package @jmruthers/pace-core
+ * @module Hooks/__tests__
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useSessionDraft } from '../useSessionDraft';
+
+describe('useSessionDraft', () => {
+  beforeEach(() => {
+    // Clear sessionStorage before each test
+    sessionStorage.clear();
+  });
+
+  afterEach(() => {
+    // Clear sessionStorage after each test
+    sessionStorage.clear();
+  });
+
+  it('should initialize with initialState when no draft exists', () => {
+    const { result } = renderHook(() =>
+      useSessionDraft('test-key', { value: 'initial' })
+    );
+
+    expect(result.current.state).toEqual({ value: 'initial' });
+    expect(result.current.wasRestored).toBe(false);
+  });
+
+  it('should restore state from sessionStorage on mount', () => {
+    // Set up initial draft
+    const draft = {
+      version: 1,
+      data: { value: 'restored' },
+      timestamp: Date.now(),
+    };
+    sessionStorage.setItem('pace-core:draft:test-key', JSON.stringify(draft));
+
+    const { result } = renderHook(() =>
+      useSessionDraft('test-key', { value: 'initial' })
+    );
+
+    expect(result.current.state).toEqual({ value: 'restored' });
+    expect(result.current.wasRestored).toBe(true);
+  });
+
+  it('should persist state changes with debouncing', async () => {
+    vi.useFakeTimers();
+
+    const { result } = renderHook(() =>
+      useSessionDraft('test-key', { value: 'initial' })
+    );
+
+    act(() => {
+      result.current.setState({ value: 'updated' });
+    });
+
+    // State should update immediately
+    expect(result.current.state).toEqual({ value: 'updated' });
+
+    // But storage should not be updated yet (debounced)
+    expect(sessionStorage.getItem('pace-core:draft:test-key')).toBeNull();
+
+    // Fast-forward past debounce delay
+    await act(async () => {
+      vi.advanceTimersByTime(300);
+    });
+
+    // Now storage should be updated
+    const stored = sessionStorage.getItem('pace-core:draft:test-key');
+    expect(stored).not.toBeNull();
+    if (stored) {
+      const parsed = JSON.parse(stored);
+      expect(parsed.data).toEqual({ value: 'updated' });
+    }
+
+    vi.useRealTimers();
+  });
+
+  it('should clear draft when clearDraft is called', () => {
+    const { result } = renderHook(() =>
+      useSessionDraft('test-key', { value: 'initial' })
+    );
+
+    act(() => {
+      result.current.setState({ value: 'updated' });
+      result.current.saveImmediately();
+    });
+
+    expect(sessionStorage.getItem('pace-core:draft:test-key')).not.toBeNull();
+
+    act(() => {
+      result.current.clearDraft();
+    });
+
+    expect(sessionStorage.getItem('pace-core:draft:test-key')).toBeNull();
+    expect(result.current.state).toEqual({ value: 'initial' });
+  });
+
+  it('should handle storage quota errors gracefully', () => {
+    // Mock sessionStorage.setItem to throw quota error
+    const originalSetItem = sessionStorage.setItem;
+    sessionStorage.setItem = vi.fn(() => {
+      const error = new DOMException('QuotaExceededError');
+      error.name = 'QuotaExceededError';
+      throw error;
+    });
+
+    const { result } = renderHook(() =>
+      useSessionDraft('test-key', { value: 'initial' })
+    );
+
+    // Should not throw, just fail silently
+    expect(() => {
+      act(() => {
+        result.current.setState({ value: 'updated' });
+        result.current.saveImmediately();
+      });
+    }).not.toThrow();
+
+    // Restore original
+    sessionStorage.setItem = originalSetItem;
+  });
+
+  it('should handle corrupted stored data gracefully', () => {
+    // Set corrupted data
+    sessionStorage.setItem('pace-core:draft:test-key', 'invalid json');
+
+    const { result } = renderHook(() =>
+      useSessionDraft('test-key', { value: 'initial' })
+    );
+
+    // Should fall back to initial state
+    expect(result.current.state).toEqual({ value: 'initial' });
+    expect(result.current.wasRestored).toBe(false);
+
+    // Corrupted data should be cleared
+    expect(sessionStorage.getItem('pace-core:draft:test-key')).toBeNull();
+  });
+
+  it('should reject drafts with mismatched schema version', () => {
+    // Set draft with wrong version
+    const draft = {
+      version: 999, // Wrong version
+      data: { value: 'old' },
+      timestamp: Date.now(),
+    };
+    sessionStorage.setItem('pace-core:draft:test-key', JSON.stringify(draft));
+
+    const { result } = renderHook(() =>
+      useSessionDraft('test-key', { value: 'initial' })
+    );
+
+    // Should fall back to initial state
+    expect(result.current.state).toEqual({ value: 'initial' });
+    expect(result.current.wasRestored).toBe(false);
+
+    // Old draft should be cleared
+    expect(sessionStorage.getItem('pace-core:draft:test-key')).toBeNull();
+  });
+});
+

package/src/hooks/__tests__/useSessionRestoration.unit.test.tsx

@@ -28,7 +28,8 @@ vi.mock('../../utils/core/logger', () => {
 import { createLogger } from '../../utils/core/logger';
 const getMockLogger = () => createLogger('test');
 
-const SESSION_RESTORATION_TIMEOUT_MS = 5000;
+// Match the actual timeout value from useSessionRestoration.ts
+const SESSION_RESTORATION_TIMEOUT_MS = 10000; // 10 seconds (matches implementation)
 
 describe('useSessionRestoration', () => {
   let mockContext: { sessionRestoration: SessionRestorationState };
@@ -136,9 +137,11 @@ describe('useSessionRestoration', () => {
       // Advance time past timeout
       await act(async () => {
         vi.advanceTimersByTime(SESSION_RESTORATION_TIMEOUT_MS + 100);
+        // Wait for state update after timeout
+        await vi.runAllTimersAsync();
       });
 
-      // With fake timers, the timeout should fire immediately
+      // With fake timers, the timeout should fire after advancing
       expect(result.current.hasTimedOut).toBe(true);
 
       const logger = getMockLogger();
@@ -310,7 +313,7 @@ describe('useSessionRestoration', () => {
       expect(result.current.isRestoring).toBe(true);
     });
 
-    it('resets hasTimedOut when restoration state changes', () => {
+    it('resets hasTimedOut when restoration state changes', async () => {
       mockContext.sessionRestoration = {
         isRestoring: true,
         restorationComplete: false,
@@ -321,11 +324,13 @@ describe('useSessionRestoration', () => {
       const { result, rerender } = renderHook(() => useSessionRestoration(), { wrapper });
 
       // Trigger timeout - advance timers
-      act(() => {
+      await act(async () => {
         vi.advanceTimersByTime(SESSION_RESTORATION_TIMEOUT_MS + 100);
+        // Wait for state update after timeout
+        await vi.runAllTimersAsync();
       });
 
-      // Verify timeout occurred (with fake timers, setTimeout fires immediately)
+      // Verify timeout occurred (with fake timers, setTimeout fires after advancing)
       expect(result.current.hasTimedOut).toBe(true);
 
       // Reset restoration state