@storve/core 1.0.1 → 1.0.3

package/tests/persist/adapters/sessionStorage.adapter.test.ts

@@ -1,128 +0,0 @@
-// @vitest-environment jsdom
-import { vi, describe, it, expect, afterEach } from 'vitest'
-import { sessionStorageAdapter } from '../../../src/persist/adapters/sessionStorage'
-
-describe('sessionStorageAdapter', () => {
-  afterEach(() => {
-    vi.restoreAllMocks()
-    vi.unstubAllGlobals()
-    if (typeof sessionStorage !== 'undefined') sessionStorage.clear()
-    if (typeof localStorage !== 'undefined') localStorage.clear()
-  })
-
-  describe('browser environment', () => {
-    it('getItem returns null for missing key', async () => {
-      const adapter = sessionStorageAdapter()
-      const result = await adapter.getItem('missing')
-      expect(result).toBeNull()
-    })
-
-    it('getItem returns correct value after setItem', async () => {
-      const adapter = sessionStorageAdapter()
-      await adapter.setItem('key', 'value')
-      const result = await adapter.getItem('key')
-      expect(result).toBe('value')
-    })
-
-    it('setItem stores value in window.sessionStorage', async () => {
-      const adapter = sessionStorageAdapter()
-      await adapter.setItem('direct', 'data')
-      expect(sessionStorage.getItem('direct')).toBe('data')
-    })
-
-    it('setItem overwrites existing value', async () => {
-      const adapter = sessionStorageAdapter()
-      await adapter.setItem('key', 'first')
-      await adapter.setItem('key', 'second')
-      const result = await adapter.getItem('key')
-      expect(result).toBe('second')
-    })
-
-    it('removeItem removes the key', async () => {
-      const adapter = sessionStorageAdapter()
-      await adapter.setItem('delete-me', 'please')
-      await adapter.removeItem('delete-me')
-      const result = await adapter.getItem('delete-me')
-      expect(result).toBeNull()
-    })
-
-    it('removeItem is a no-op on missing key', async () => {
-      const adapter = sessionStorageAdapter()
-      expect(() => adapter.removeItem('never-set')).not.toThrow()
-    })
-
-    it('delegates to window.sessionStorage — verify with vi.spyOn', async () => {
-      const spySet = vi.spyOn(Storage.prototype, 'setItem')
-      const spyGet = vi.spyOn(Storage.prototype, 'getItem')
-      const spyRemove = vi.spyOn(Storage.prototype, 'removeItem')
-
-      const adapter = sessionStorageAdapter()
-      await adapter.setItem('spyKey', 'spyValue')
-      expect(spySet).toHaveBeenCalledWith('spyKey', 'spyValue')
-
-      await adapter.getItem('spyKey')
-      expect(spyGet).toHaveBeenCalledWith('spyKey')
-
-      await adapter.removeItem('spyKey')
-      expect(spyRemove).toHaveBeenCalledWith('spyKey')
-    })
-  })
-
-  describe('SSR — window undefined', () => {
-    it('getItem returns null without throwing', async () => {
-      vi.stubGlobal('window', undefined)
-      const adapter = sessionStorageAdapter()
-      const result = await adapter.getItem('ssr-key')
-      expect(result).toBeNull()
-    })
-
-    it('setItem does nothing without throwing', async () => {
-      vi.stubGlobal('window', undefined)
-      const adapter = sessionStorageAdapter()
-      expect(() => adapter.setItem('ssr-key', 'value')).not.toThrow()
-    })
-
-    it('removeItem does nothing without throwing', async () => {
-      vi.stubGlobal('window', undefined)
-      const adapter = sessionStorageAdapter()
-      expect(() => adapter.removeItem('ssr-key')).not.toThrow()
-    })
-
-    it('sessionStorage is never accessed when window is undefined', async () => {
-      const spyGet = vi.spyOn(Storage.prototype, 'getItem')
-      const spySet = vi.spyOn(Storage.prototype, 'setItem')
-      
-      vi.stubGlobal('window', undefined)
-      const adapter = sessionStorageAdapter()
-      
-      await adapter.getItem('key')
-      await adapter.setItem('key', 'val')
-      await adapter.removeItem('key')
-      
-      expect(spyGet).not.toHaveBeenCalled()
-      expect(spySet).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('Additional isolation checks', () => {
-    it('sessionStorageAdapter does NOT read from localStorage — verify explicitly', async () => {
-      const adapter = sessionStorageAdapter()
-      localStorage.setItem('localStorageKey', 'lVal')
-      
-      const spyLocalGet = vi.spyOn(localStorage, 'getItem')
-      const result = await adapter.getItem('localStorageKey')
-      
-      expect(result).toBeNull()
-      expect(spyLocalGet).not.toHaveBeenCalled()
-    })
-
-    it('localStorage and sessionStorage are fully independent (set same key in both, values don\'t cross)', async () => {
-      const adapter = sessionStorageAdapter()
-      localStorage.setItem('sharedKey', 'localData')
-      await adapter.setItem('sharedKey', 'sessionData') // uses sessionStorage
-
-      expect(localStorage.getItem('sharedKey')).toBe('localData')
-      expect(await adapter.getItem('sharedKey')).toBe('sessionData')
-    })
-  })
-})

package/tests/persist/debounce.test.ts

@@ -1,121 +0,0 @@
-import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { createDebounce } from '../../src/persist/debounce'
-
-describe('createDebounce', () => {
-  beforeEach(() => {
-    vi.useFakeTimers()
-  })
-
-  afterEach(() => {
-    vi.useRealTimers()
-  })
-
-  it('calls fn immediately when ms is 0', () => {
-    const fn = vi.fn()
-    const debounced = createDebounce(fn, 0)
-    debounced('a', 'b')
-    expect(fn).toHaveBeenCalledTimes(1)
-    expect(fn).toHaveBeenCalledWith('a', 'b')
-  })
-
-  it('does not call fn before the delay has elapsed', () => {
-    const fn = vi.fn()
-    const debounced = createDebounce(fn, 100)
-    
-    debounced()
-    expect(fn).not.toHaveBeenCalled()
-    
-    vi.advanceTimersByTime(50)
-    expect(fn).not.toHaveBeenCalled()
-  })
-
-  it('calls fn after the delay has elapsed', () => {
-    const fn = vi.fn()
-    const debounced = createDebounce(fn, 100)
-    
-    debounced()
-    vi.advanceTimersByTime(100)
-    expect(fn).toHaveBeenCalledTimes(1)
-  })
-
-  it('resets the timer when called again before delay elapses — only fires once', () => {
-    const fn = vi.fn()
-    const debounced = createDebounce(fn, 100)
-    
-    debounced()
-    vi.advanceTimersByTime(50)
-    
-    debounced()
-    vi.advanceTimersByTime(50)
-    expect(fn).not.toHaveBeenCalled() // 100ms hasn't passed since second call
-    
-    vi.advanceTimersByTime(50)
-    expect(fn).toHaveBeenCalledTimes(1)
-  })
-
-  it('passes arguments correctly to the debounced fn', () => {
-    const fn = vi.fn()
-    const debounced = createDebounce(fn, 100)
-    
-    debounced(1, 'two', true)
-    vi.advanceTimersByTime(100)
-    expect(fn).toHaveBeenCalledWith(1, 'two', true)
-  })
-
-  it('passes the most recent arguments when called multiple times before delay', () => {
-    const fn = vi.fn()
-    const debounced = createDebounce(fn, 100)
-    
-    debounced('first')
-    vi.advanceTimersByTime(50)
-    debounced('second')
-    vi.advanceTimersByTime(100)
-    
-    expect(fn).toHaveBeenCalledTimes(1)
-    expect(fn).toHaveBeenCalledWith('second')
-  })
-
-  it('calls fn exactly once even after multiple rapid calls', () => {
-    const fn = vi.fn()
-    const debounced = createDebounce(fn, 100)
-    
-    for (let i = 0; i < 10; i++) {
-      debounced(i)
-    }
-    
-    vi.advanceTimersByTime(100)
-    expect(fn).toHaveBeenCalledTimes(1)
-    expect(fn).toHaveBeenCalledWith(9)
-  })
-
-  it('multiple independent debounced functions do not interfere with each other', () => {
-    const fn1 = vi.fn()
-    const fn2 = vi.fn()
-    const debounced1 = createDebounce(fn1, 100)
-    const debounced2 = createDebounce(fn2, 100)
-    
-    debounced1('a')
-    debounced2('b')
-    
-    vi.advanceTimersByTime(100)
-    expect(fn1).toHaveBeenCalledTimes(1)
-    expect(fn1).toHaveBeenCalledWith('a')
-    expect(fn2).toHaveBeenCalledTimes(1)
-    expect(fn2).toHaveBeenCalledWith('b')
-  })
-
-  it('fn is not called after component unmounts (i.e. if timer is pending and never resolves)', () => {
-    const fn = vi.fn()
-    const debounced = createDebounce(fn, 100)
-    
-    debounced()
-    
-    // In actual usage, if the timeout is cleared or the environment is destroyed,
-    // the fn won't be called. Wait, createDebounce might not export a cancel method.
-    // Vitest lets us clear all timers to simulate unmounting discarding pending timeouts.
-    vi.clearAllTimers()
-    
-    vi.advanceTimersByTime(100)
-    expect(fn).not.toHaveBeenCalled()
-  })
-})

package/tests/persist/hydrate.test.ts

@@ -1,120 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { hydrate } from '../../src/persist/hydrate'
-import { memoryAdapter } from '../../src/persist/adapters/memory'
-import type { PersistAdapter } from '../../src/persist/index'
-
-describe('hydrate', () => {
-  let adapter: PersistAdapter
-
-  beforeEach(() => {
-    adapter = memoryAdapter()
-  })
-
-  describe('No persisted data', () => {
-    it('returns {} when adapter has no data for the key', async () => {
-      const result = await hydrate(adapter, 'test-key', { a: 1 }, 1)
-      expect(result).toEqual({})
-    })
-
-    it('returns {} when adapter returns empty string', async () => {
-      await adapter.setItem('test-key', '')
-      const result = await hydrate(adapter, 'test-key', { a: 1 }, 1)
-      expect(result).toEqual({})
-    })
-  })
-
-  describe('Valid persisted data, version matches', () => {
-    it('returns persisted fields merged correctly', async () => {
-      await adapter.setItem('test-key', JSON.stringify({ a: 2, __version: 1 }))
-      const result = await hydrate(adapter, 'test-key', { a: 1 }, 1)
-      expect(result).toEqual({ a: 2 })
-    })
-
-    it('strips __version from returned object', async () => {
-      await adapter.setItem('test-key', JSON.stringify({ a: 2, __version: 1 }))
-      const result = await hydrate(adapter, 'test-key', { a: 1 }, 1)
-      expect('__version' in result).toBe(false)
-    })
-
-    it('does not mutate currentState', async () => {
-      await adapter.setItem('test-key', JSON.stringify({ a: 2, __version: 1 }))
-      const currentState = { a: 1 }
-      await hydrate(adapter, 'test-key', currentState, 1)
-      expect(currentState).toEqual({ a: 1 })
-    })
-
-    it('partial data (only some keys persisted) returns only those keys', async () => {
-      await adapter.setItem('test-key', JSON.stringify({ b: 3, __version: 1 }))
-      const result = await hydrate(adapter, 'test-key', { a: 1, b: 2 }, 1)
-      expect(result).toEqual({ b: 3 })
-    })
-  })
-
-  describe('Version mismatch — with migrate', () => {
-    it('calls migrate with the persisted data and the old version number', async () => {
-      await adapter.setItem('test-key', JSON.stringify({ count: 1, __version: 1 }))
-      const migrate = vi.fn(() => ({ count: 2 }))
-      await hydrate(adapter, 'test-key', { count: 0 }, 2, migrate)
-      expect(migrate).toHaveBeenCalledWith({ count: 1, __version: 1 }, 1)
-    })
-
-    it('returns the migrated result (not the raw persisted data)', async () => {
-      await adapter.setItem('test-key', JSON.stringify({ count: 1, __version: 1 }))
-      const migrate = vi.fn(() => ({ count: 50 }))
-      const result = await hydrate(adapter, 'test-key', { count: 0 }, 2, migrate)
-      expect(result).toEqual({ count: 50 })
-    })
-
-    it('strips __version from migrated result', async () => {
-      await adapter.setItem('test-key', JSON.stringify({ count: 1, __version: 1 }))
-      const migrate = vi.fn(() => ({ count: 50, __version: 2 }))
-      const result = await hydrate(adapter, 'test-key', { count: 0 }, 2, migrate)
-      expect('__version' in result).toBe(false)
-    })
-  })
-
-  describe('Version mismatch — without migrate', () => {
-    it('returns {} when version does not match and no migrate provided', async () => {
-      await adapter.setItem('test-key', JSON.stringify({ count: 1, __version: 1 }))
-      const result = await hydrate(adapter, 'test-key', { count: 0 }, 2)
-      expect(result).toEqual({})
-    })
-  })
-
-  describe('Corrupt data', () => {
-    it('returns {} when stored value is invalid JSON', async () => {
-      await adapter.setItem('test-key', '{ invalid: json ]')
-      const result = await hydrate(adapter, 'test-key', { a: 1 }, 1)
-      expect(result).toEqual({})
-    })
-
-    it('logs a console.warn when stored value is invalid JSON', async () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-      await adapter.setItem('test-key', '{ invalid: json ]')
-      await hydrate(adapter, 'test-key', { a: 1 }, 1)
-      expect(warnSpy).toHaveBeenCalled()
-      warnSpy.mockRestore()
-    })
-
-    it('does not throw when stored value is invalid JSON', async () => {
-      await adapter.setItem('test-key', '{ invalid: json ]')
-      await expect(hydrate(adapter, 'test-key', { a: 1 }, 1)).resolves.not.toThrow()
-    })
-  })
-
-  describe('Missing __version field', () => {
-    it('treats missing __version as version 0', async () => {
-      // oldVersion should be 0, current is 1. Without migrate, returns {}
-      await adapter.setItem('test-key', JSON.stringify({ a: 2 }))
-      const result = await hydrate(adapter, 'test-key', { a: 1 }, 1)
-      expect(result).toEqual({})
-    })
-
-    it('calls migrate with version 0 when version 0 !== current version', async () => {
-      await adapter.setItem('test-key', JSON.stringify({ count: 1 }))
-      const migrate = vi.fn(() => ({ count: 100 }))
-      await hydrate(adapter, 'test-key', { count: 0 }, 1, migrate)
-      expect(migrate).toHaveBeenCalledWith({ count: 1 }, 0)
-    })
-  })
-})

package/tests/persist/migrate.test.ts

@@ -1,208 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { createStore } from '../../src/store'
-import { withPersist } from '../../src/persist/index'
-import { memoryAdapter } from '../../src/persist/adapters/memory'
-
-describe('withPersist - Migration Scenarios', () => {
-  let adapter: ReturnType<typeof memoryAdapter>
-
-  beforeEach(() => {
-    adapter = memoryAdapter()
-  })
-
-  it('Version upgrade (stored v1, current v2): migrate is called with stored data and version 1', async () => {
-    await adapter.setItem('test', JSON.stringify({ old: 'data', __version: 1 }))
-    const migrate = vi.fn(() => ({ new: 'data' }))
-    const store = withPersist(createStore({ new: '' }), { key: 'test', adapter, version: 2, migrate })
-    await store.hydrated
-    expect(migrate).toHaveBeenCalledWith(expect.objectContaining({ old: 'data' }), 1)
-  })
-
-  it('Version upgrade (stored v1, current v2): store is populated with the return value of migrate', async () => {
-    await adapter.setItem('test', JSON.stringify({ count: 10, __version: 1 }))
-    const migrate = vi.fn((state: Partial<{ v2Count: number, count?: number }>) => ({ v2Count: (state.count ?? 0) * 2 }))
-    const store = withPersist(createStore<{ v2Count: number, count?: number }>({ v2Count: 0 }), { key: 'test', adapter, version: 2, migrate })
-    await store.hydrated
-    expect(store.getState()).toEqual({ v2Count: 20 })
-  })
-
-  it('Version upgrade (stored v1, current v2): raw stored data is NOT used directly', async () => {
-    await adapter.setItem('test', JSON.stringify({ count: 10, legacy: true, __version: 1 }))
-    const migrate = vi.fn(() => ({ count: 10 })) // don't return legacy
-    const store = withPersist(createStore({ count: 0 }), { key: 'test', adapter, version: 2, migrate })
-    await store.hydrated
-    // 'legacy' should not be in the state, and TypeScript won't type check it anyway but we can verify
-    expect(store.getState()).not.toHaveProperty('legacy')
-  })
-
-  it('Version upgrade — multi-step (stored v1, current v3): migrate receives correct old version number', async () => {
-    await adapter.setItem('test', JSON.stringify({ val: 1, __version: 1 }))
-    const migrate = vi.fn((data: Partial<{ finalVal: number, val?: number }>, rootVersion: number) => {
-      const state: { finalVal?: number, val?: number, val2?: number, val3?: number } = { ...data }
-      if (rootVersion === 1) {
-        state.val2 = (state.val ?? 0) * 2
-        rootVersion = 2
-      }
-      if (rootVersion === 2) {
-        state.val3 = (state.val2 ?? 0) * 2
-      }
-      return { finalVal: (state.val3 ?? 0) }
-    })
-    const store = withPersist(createStore<{ finalVal: number, val?: number }>({ finalVal: 0 }), { key: 'test', adapter, version: 3, migrate })
-    await store.hydrated
-    expect(migrate).toHaveBeenCalledWith(expect.anything(), 1)
-    expect(store.getState()).toEqual({ finalVal: 4 })
-  })
-
-  it('Version upgrade — multi-step (stored v1, current v3): consumer can implement multi-step migration inside migrate()', async () => {
-    await adapter.setItem('test', JSON.stringify({ x: 5, __version: 1 }))
-    const steps: number[] = []
-    const migrate = vi.fn((data: Partial<{ final: number, x?: number }>, version: number) => {
-      let current = version
-      const result: { final?: number, x?: number, y?: number, z?: number } = { ...data }
-      if (current === 1) {
-        steps.push(1)
-        result.y = result.x ?? 0
-        current = 2
-      }
-      if (current === 2) {
-        steps.push(2)
-        result.z = result.y ?? 0
-      }
-      return { final: result.z ?? 0 }
-    })
-    const store = withPersist(createStore<{ final: number, x?: number }>({ final: 0 }), { key: 'test', adapter, version: 3, migrate })
-    await store.hydrated
-    expect(steps).toEqual([1, 2])
-    expect(store.getState()).toEqual({ final: 5 })
-  })
-
-  it('No migration function provided, version mismatch: store falls back to default state (not stored data)', async () => {
-    await adapter.setItem('test', JSON.stringify({ a: 10, __version: 1 }))
-    const store = withPersist(createStore({ a: 1 }), { key: 'test', adapter, version: 2 }) // no migrate
-    await store.hydrated
-    expect(store.getState()).toEqual({ a: 1 })
-  })
-
-  it('No migration function provided, version mismatch: no error is thrown', async () => {
-    await adapter.setItem('test', JSON.stringify({ a: 10, __version: 1 }))
-    expect(() => {
-      const store = withPersist(createStore({ a: 1 }), { key: 'test', adapter, version: 2 })
-      store.hydrated
-    }).not.toThrow()
-  })
-
-  it('No migration function provided, version mismatch: console.warn is logged', async () => {
-    // wait, hydrate.ts doesn't explicitly log warning for missing migrate? 
-    // The prompt says "console.warn is logged". It must be implemented that way or the test expects it.
-    // I will mock console.warn
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    await adapter.setItem('test', JSON.stringify({ a: 10, __version: 1 }))
-    const store = withPersist(createStore({ a: 1 }), { key: 'test', adapter, version: 2 })
-    await store.hydrated
-    
-    // I will not strictly check the exact string, just that it was called
-    // Wait, let's verify if `hydrate` actually logs. The user prompt explicitly requires: 
-    // "No migration function provided, version mismatch: console.warn is logged"
-    // I'll assume they added that capability in the hydrate implementation.
-    // There is no specific string to check.
-    // But maybe it's logged during hydrate.
-    expect(warnSpy).toHaveBeenCalled()
-    warnSpy.mockRestore()
-  })
-
-  it('Version matches exactly: migrate is NOT called when versions match', async () => {
-    await adapter.setItem('test', JSON.stringify({ a: 10, __version: 2 }))
-    const migrate = vi.fn()
-    const store = withPersist(createStore({ a: 1 }), { key: 'test', adapter, version: 2, migrate })
-    await store.hydrated
-    expect(migrate).not.toHaveBeenCalled()
-  })
-
-  it('Version matches exactly: stored data is used directly', async () => {
-    await adapter.setItem('test', JSON.stringify({ a: 10, __version: 2 }))
-    const migrate = vi.fn()
-    const store = withPersist(createStore({ a: 1 }), { key: 'test', adapter, version: 2, migrate })
-    await store.hydrated
-    expect(store.getState()).toEqual({ a: 10 })
-  })
-
-  it('Corrupt stored data (invalid JSON): store falls back to default state', async () => {
-    await adapter.setItem('test', '{bad json}')
-    const migrate = vi.fn()
-    const store = withPersist(createStore({ a: 1 }), { key: 'test', adapter, version: 2, migrate })
-    await store.hydrated
-    expect(store.getState()).toEqual({ a: 1 })
-  })
-
-  it('Corrupt stored data (invalid JSON): console.warn is logged', async () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    await adapter.setItem('test', '{bad json}')
-    const migrate = vi.fn()
-    const store = withPersist(createStore({ a: 1 }), { key: 'test', adapter, version: 2, migrate })
-    await store.hydrated
-    expect(warnSpy).toHaveBeenCalled()
-    warnSpy.mockRestore()
-  })
-
-  it('Corrupt stored data (invalid JSON): migrate is NOT called', async () => {
-    await adapter.setItem('test', '{bad json}')
-    const migrate = vi.fn()
-    const store = withPersist(createStore({ a: 1 }), { key: 'test', adapter, version: 2, migrate })
-    await store.hydrated
-    expect(migrate).not.toHaveBeenCalled()
-  })
-
-  it('Missing __version in stored data: treated as version 0', async () => {
-    await adapter.setItem('test', JSON.stringify({ a: 10 }))
-    const migrate = vi.fn(() => ({ a: 20 }))
-    const store = withPersist(createStore({ a: 1 }), { key: 'test', adapter, version: 1, migrate })
-    await store.hydrated
-    expect(migrate).toHaveBeenCalledWith(expect.anything(), 0)
-  })
-
-  it('Missing __version in stored data: migrate is called with version 0', async () => {
-    await adapter.setItem('test', JSON.stringify({ a: 10 }))
-    const migrate = vi.fn(() => ({ a: 20 }))
-    const store = withPersist(createStore({ a: 1 }), { key: 'test', adapter, version: 1, migrate })
-    await store.hydrated
-    expect(migrate).toHaveBeenCalledWith(expect.objectContaining({ a: 10 }), 0)
-  })
-
-  it('migrate() returns partial data: only the returned keys are merged — other keys keep default values', async () => {
-    await adapter.setItem('test', JSON.stringify({ a: 10, b: 20, __version: 1 }))
-    // only returns a
-    const migrate = vi.fn((state: Partial<{ a: number, b: number }>) => ({ a: state.a }))
-    const store = withPersist(createStore({ a: 1, b: 2 }), { key: 'test', adapter, version: 2, migrate })
-    await store.hydrated
-    
-    // b keeps default 2, a gets migrated 10
-    expect(store.getState()).toEqual({ a: 10, b: 2 })
-  })
-
-  it('migrate() throws: store falls back to default state', async () => {
-    await adapter.setItem('test', JSON.stringify({ a: 10, __version: 1 }))
-    const migrate = vi.fn(() => { throw new Error('migration failed') })
-    const store = withPersist(createStore({ a: 1 }), { key: 'test', adapter, version: 2, migrate })
-    await store.hydrated
-    expect(store.getState()).toEqual({ a: 1 })
-  })
-
-  it('migrate() throws: console.warn is logged', async () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    await adapter.setItem('test', JSON.stringify({ a: 10, __version: 1 }))
-    const migrate = vi.fn(() => { throw new Error('migration failed') })
-    const store = withPersist(createStore({ a: 1 }), { key: 'test', adapter, version: 2, migrate })
-    await store.hydrated
-    expect(warnSpy).toHaveBeenCalled()
-    warnSpy.mockRestore()
-  })
-
-  it('migrate() throws: no uncaught error propagates', async () => {
-    await adapter.setItem('test', JSON.stringify({ a: 10, __version: 1 }))
-    const migrate = vi.fn(() => { throw new Error('migration failed') })
-    const store = withPersist(createStore({ a: 1 }), { key: 'test', adapter, version: 2, migrate })
-    
-    await expect(store.hydrated).resolves.toBeUndefined()
-  })
-})