@livestore/livestore 0.4.0-dev.22 → 0.4.0-dev.23

package/src/store/StoreRegistry.test.ts

@@ -1,11 +1,12 @@
+import { describe, expect, it } from '@effect/vitest'
+
 import { makeInMemoryAdapter } from '@livestore/adapter-web'
-import { UnknownError } from '@livestore/common'
-import { sleep } from '@livestore/utils'
-import { Effect } from '@livestore/utils/effect'
-import { describe, expect, it } from 'vitest'
+import { OtelLiveDummy, UnknownError } from '@livestore/common'
+import { Effect, Fiber, type OtelTracer, type Scope, TestClock } from '@livestore/utils/effect'
+
 import { schema } from '../utils/tests/fixture.ts'
-import { type RegistryStoreOptions, StoreRegistry, storeOptions } from './StoreRegistry.ts'
 import { StoreInternalsSymbol } from './store-types.ts'
+import { type RegistryStoreOptions, StoreRegistry, storeOptions } from './StoreRegistry.ts'
 
 describe('StoreRegistry', () => {
   it('returns a promise when the store is loading', async () => {
@@ -128,382 +129,405 @@ describe('StoreRegistry', () => {
     expect(error1).toBe(error2)
   })
 
-  it('disposes store after unusedCacheTime expires', async () => {
-    const unusedCacheTime = 25
-    const storeRegistry = new StoreRegistry({ defaultOptions: { unusedCacheTime } })
-    const options = testStoreOptions()
-
-    const store = await storeRegistry.getOrLoadPromise(options)
-
-    // Store should be cached
-    expect(storeRegistry.getOrLoadPromise(options)).toBe(store)
-
-    // Wait for disposal
-    await sleep(unusedCacheTime + 50)
+  it('preload does not throw', async () => {
+    const storeRegistry = new StoreRegistry()
 
-    // After disposal, store should be removed
-    // The store is removed from cache, so next getOrLoadStore creates a new one
-    const nextStore = await storeRegistry.getOrLoadPromise(options)
+    // Create invalid options that would cause an error
+    const badOptions = testStoreOptions({
+      // @ts-expect-error - intentionally passing invalid adapter to trigger error
+      adapter: null,
+    })
 
-    // Should be a different store instance
-    expect(nextStore).not.toBe(store)
-    expect(nextStore[StoreInternalsSymbol].clientSession.debugInstanceId).toBeDefined()
+    // preload should not throw
+    await expect(storeRegistry.preload(badOptions)).resolves.toBeUndefined()
 
-    // Clean up the second store (first one was disposed)
-    await nextStore.shutdownPromise()
+    // But subsequent getOrLoadStore should throw the cached error
+    expect(() => storeRegistry.getOrLoadPromise(badOptions)).toThrow()
   })
 
-  it('does not dispose when unusedCacheTime is Infinity', async () => {
-    const storeRegistry = new StoreRegistry({ defaultOptions: { unusedCacheTime: Number.POSITIVE_INFINITY } })
+  it('warms the cache so subsequent getOrLoadStore is synchronous after preload', async () => {
+    const storeRegistry = new StoreRegistry()
     const options = testStoreOptions()
 
-    const store = await storeRegistry.getOrLoadPromise(options)
-
-    // Store should be cached
-    expect(storeRegistry.getOrLoadPromise(options)).toBe(store)
+    // Preload the store
+    await storeRegistry.preload(options)
 
-    // Wait a reasonable duration to verify no disposal
-    await sleep(100)
+    // Subsequent getOrLoadStore should return synchronously (not a Promise)
+    const store = storeRegistry.getOrLoadPromise(options)
+    expect(store).not.toBeInstanceOf(Promise)
 
-    // Store should still be cached (not disposed)
-    expect(storeRegistry.getOrLoadPromise(options)).toBe(store)
+    // TypeScript doesn't narrow the type, so we need to assert
+    if (store instanceof Promise) {
+      throw new Error('Expected store, got Promise')
+    }
 
-    // Clean up manually
+    // Clean up
     await store.shutdownPromise()
   })
 
-  it('schedules disposal if store becomes unused during loading', async () => {
-    const unusedCacheTime = 50
-    const storeRegistry = new StoreRegistry({ defaultOptions: { unusedCacheTime } })
-    const options = testStoreOptions()
-
-    // Start loading without any retain
-    const storePromise = storeRegistry.getOrLoadPromise(options)
-
-    // Wait for store to load (no retain registered)
-    const store = await storePromise
-
-    // Since there were no retain when loading completed, disposal should be scheduled
-    await sleep(unusedCacheTime + 50)
-
-    // Store should be disposed
-    const nextStore = await storeRegistry.getOrLoadPromise(options)
-    expect(nextStore).not.toBe(store)
-
-    await nextStore.shutdownPromise()
-  })
-
-  // This test is skipped because Effect doesn't yet support different `idleTimeToLive` values for each resource in `RcMap`
-  // See https://github.com/livestorejs/livestore/issues/917
-  it.skip('allows call-site options to override default options', async () => {
-    const storeRegistry = new StoreRegistry({
-      defaultOptions: {
-        unusedCacheTime: 1000, // Default is long
-      },
-    })
-
-    const options = testStoreOptions({
-      unusedCacheTime: 10, // Override with shorter time
-    })
-
-    const store = await storeRegistry.getOrLoadPromise(options)
-
-    // Wait for the override time (10ms)
-    await sleep(10)
-
-    // Should be disposed according to the override time, not default
-    const nextStore = await storeRegistry.getOrLoadPromise(options)
-    expect(nextStore).not.toBe(store)
-
-    await nextStore.shutdownPromise()
-  })
-
-  // This test is skipped because we don't yet support dynamic `unusedCacheTime` updates for cached stores.
-  // See https://github.com/livestorejs/livestore/issues/918
-  it.skip('keeps the longest unusedCacheTime seen for a store when options vary across calls', async () => {
-    const storeRegistry = new StoreRegistry()
-
-    const options = testStoreOptions({ unusedCacheTime: 10 })
-    const release = storeRegistry.retain(options)
-
-    const store = await storeRegistry.getOrLoadPromise(options)
-
-    // Call with longer unusedCacheTime
-    await storeRegistry.getOrLoadPromise(testStoreOptions({ unusedCacheTime: 100 }))
-
-    release()
+  it.layer(OtelLiveDummy)('time-dependent (using TestClock)', (it) => {
+    it.scoped('disposes store after unusedCacheTime expires', () =>
+      Effect.gen(function* () {
+        const unusedCacheTime = 25
+        const runtime = yield* Effect.runtime<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ runtime, defaultOptions: { unusedCacheTime } })
+        const options = testStoreOptions()
 
-    // After 99ms, store should still be alive (100ms unusedCacheTime used)
-    await sleep(99)
+        const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
 
-    // Store should still be cached
-    expect(storeRegistry.getOrLoadPromise(options)).toBe(store)
+        // Store should still be in cache
+        const cached = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(cached).toBe(store)
 
-    // After the full 100ms, store should be disposed
-    await sleep(1)
+        // Let the idle timer fiber register its sleep with TestClock
+        yield* Effect.yieldNow()
 
-    // Next getOrLoadStore should create a new store
-    const nextStore = await storeRegistry.getOrLoadPromise(options)
-    expect(nextStore).not.toBe(store)
+        // Advance time past unusedCacheTime → idle timer fires → entry evicted
+        yield* TestClock.adjust(unusedCacheTime)
 
-    // Clean up the second store (first one was disposed)
-    await nextStore.shutdownPromise()
-  })
+        // After eviction, a new load should produce a different store
+        const nextStore = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(nextStore).not.toBe(store)
+        expect(nextStore[StoreInternalsSymbol].clientSession.debugInstanceId).toBeDefined()
+      }),
+    )
 
-  it('preload does not throw', async () => {
-    const storeRegistry = new StoreRegistry()
+    it.scoped('does not dispose when unusedCacheTime is Infinity', () =>
+      Effect.gen(function* () {
+        const runtime = yield* Effect.runtime<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ runtime, defaultOptions: { unusedCacheTime: Number.POSITIVE_INFINITY } })
+        const options = testStoreOptions()
 
-    // Create invalid options that would cause an error
-    const badOptions = testStoreOptions({
-      // @ts-expect-error - intentionally passing invalid adapter to trigger error
-      adapter: null,
-    })
+        const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
 
-    // preload should not throw
-    await expect(storeRegistry.preload(badOptions)).resolves.toBeUndefined()
+        // Advance a large amount of time — no idle timer was started for Infinity
+        yield* TestClock.adjust(100_000)
 
-    // But subsequent getOrLoadStore should throw the cached error
-    expect(() => storeRegistry.getOrLoadPromise(badOptions)).toThrow()
-  })
+        // Store should still be cached
+        const cached = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(cached).toBe(store)
+      }),
+    )
 
-  it('handles rapid retain/release cycles without errors', async () => {
-    const unusedCacheTime = 50
-    const storeRegistry = new StoreRegistry({ defaultOptions: { unusedCacheTime } })
-    const options = testStoreOptions()
+    it.scoped('schedules disposal if store becomes unused during loading', () =>
+      Effect.gen(function* () {
+        const unusedCacheTime = 50
+        const runtime = yield* Effect.runtime<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ runtime, defaultOptions: { unusedCacheTime } })
+        const options = testStoreOptions()
 
-    const store = await storeRegistry.getOrLoadPromise(options)
+        // Load without retaining — disposal is scheduled when scope closes
+        const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
 
-    // Rapidly retain and release multiple times
-    for (let i = 0; i < 10; i++) {
-      const release = storeRegistry.retain(options)
-      release()
-    }
+        yield* Effect.yieldNow()
+        yield* TestClock.adjust(unusedCacheTime)
 
-    // Wait for disposal to trigger
-    await sleep(unusedCacheTime + 50)
+        // Store should be disposed
+        const nextStore = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(nextStore).not.toBe(store)
+      }),
+    )
 
-    // Store should be disposed after the last release
-    const nextStore = await storeRegistry.getOrLoadPromise(options)
-    expect(nextStore).not.toBe(store)
+    it.scoped('allows call-site options to override default options', () =>
+      Effect.gen(function* () {
+        const runtime = yield* Effect.runtime<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ runtime, defaultOptions: { unusedCacheTime: 10_000 } }) // Long default
 
-    await nextStore.shutdownPromise()
-  })
+        const unusedCacheTimeOverride = 25
+        const options = testStoreOptions({ unusedCacheTime: unusedCacheTimeOverride })
 
-  it('cancels disposal when new retain', async () => {
-    const unusedCacheTime = 50
-    const storeRegistry = new StoreRegistry({ defaultOptions: { unusedCacheTime } })
-    const options = testStoreOptions()
+        const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
 
-    const store = await storeRegistry.getOrLoadPromise(options)
+        yield* Effect.yieldNow()
+        yield* TestClock.adjust(unusedCacheTimeOverride)
 
-    // Wait almost to disposal threshold
-    await sleep(unusedCacheTime - 5)
+        // Should be disposed according to the override time, not default
+        const nextStore = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(nextStore).not.toBe(store)
+      }),
+    )
 
-    // Add a new retain before disposal triggers
-    const release = storeRegistry.retain(options)
+    it.scoped('disposes different stores according to their own unusedCacheTime', () =>
+      Effect.gen(function* () {
+        const runtime = yield* Effect.runtime<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ runtime, defaultOptions: { unusedCacheTime: 1000 } })
 
-    // Complete the original unusedCacheTime
-    await sleep(5)
+        const shortOptions = testStoreOptions({ storeId: 'short-lived', unusedCacheTime: 25 })
+        const longOptions = testStoreOptions({ storeId: 'long-lived', unusedCacheTime: 10_000 })
 
-    // Store should not have been disposed because we added a retain
-    expect(storeRegistry.getOrLoadPromise(options)).toBe(store)
+        const shortStore = yield* registry.getOrLoad(shortOptions).pipe(Effect.scoped)
+        const longStore = yield* registry.getOrLoad(longOptions).pipe(Effect.scoped)
 
-    // Clean up
-    release()
-    await sleep(unusedCacheTime + 50)
+        yield* Effect.yieldNow()
 
-    // Now it should be disposed
-    const nextStore = await storeRegistry.getOrLoadPromise(options)
-    expect(nextStore).not.toBe(store)
+        // Advance past short store's unusedCacheTime only
+        yield* TestClock.adjust(25)
 
-    await nextStore.shutdownPromise()
-  })
+        // Short store should be disposed, long store should still be cached
+        const nextShortStore = yield* registry.getOrLoad(shortOptions).pipe(Effect.scoped)
+        expect(nextShortStore).not.toBe(shortStore)
 
-  it('aborts loading when disposal fires while store is still loading', async () => {
-    const unusedCacheTime = 10
-    const storeRegistry = new StoreRegistry({ defaultOptions: { unusedCacheTime } })
-    const options = testStoreOptions()
+        const cachedLongStore = yield* registry.getOrLoad(longOptions).pipe(Effect.scoped)
+        expect(cachedLongStore).toBe(longStore)
+      }),
+    )
 
-    // Retain briefly to trigger getOrLoadStore and then release
-    const release = storeRegistry.retain(options)
+    // This test is skipped because we don't yet support dynamic `unusedCacheTime` updates for cached stores.
+    // See https://github.com/livestorejs/livestore/issues/918
+    it.scoped.skip('keeps the longest unusedCacheTime seen for a store when options vary across calls', () =>
+      Effect.gen(function* () {
+        const runtime = yield* Effect.runtime<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ runtime })
 
-    // Start loading
-    const loadPromise = storeRegistry.getOrLoadPromise(options)
+        const options = testStoreOptions({ unusedCacheTime: 10 })
+        const release = registry.retain(options)
 
-    // Attach a catch handler to prevent unhandled rejection when the load is aborted
-    const abortedPromise = (loadPromise as Promise<unknown>).catch(() => {
-      // Expected: load was aborted by disposal
-    })
+        const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
 
-    // Release immediately, which schedules disposal
-    release()
+        // Call with longer unusedCacheTime
+        yield* registry.getOrLoad(testStoreOptions({ unusedCacheTime: 100 })).pipe(Effect.scoped)
 
-    // Wait for disposal to trigger
-    await sleep(unusedCacheTime + 50)
+        release()
+        yield* Effect.yieldNow()
 
-    // Wait for the abort to complete
-    await abortedPromise
+        // After 99ms, store should still be alive (100ms unusedCacheTime used)
+        yield* TestClock.adjust(99)
 
-    // After abort, a new getOrLoadStore should start a fresh load
-    const freshLoadPromise = storeRegistry.getOrLoadPromise(options)
+        const cached = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(cached).toBe(store)
 
-    // This should be a new promise (not the aborted one)
-    expect(freshLoadPromise).toBeInstanceOf(Promise)
-    expect(freshLoadPromise).not.toBe(loadPromise)
+        // After 1 more ms, store should be disposed
+        yield* TestClock.adjust(1)
 
-    // Wait for fresh load to complete
-    const store = await freshLoadPromise
-    expect(store).toBeDefined()
+        const nextStore = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(nextStore).not.toBe(store)
+      }),
+    )
 
-    await store.shutdownPromise()
-  })
+    it.scoped('handles rapid retain/release cycles without errors', () =>
+      Effect.gen(function* () {
+        const unusedCacheTime = 50
+        const runtime = yield* Effect.runtime<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ runtime, defaultOptions: { unusedCacheTime } })
+        const options = testStoreOptions()
 
-  it('retain keeps store alive past unusedCacheTime', async () => {
-    const unusedCacheTime = 50
-    const storeRegistry = new StoreRegistry({ defaultOptions: { unusedCacheTime } })
-    const options = testStoreOptions()
+        const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
 
-    // Load the store
-    const store = await storeRegistry.getOrLoadPromise(options)
+        // Rapidly retain and release multiple times
+        for (let i = 0; i < 10; i++) {
+          const release = registry.retain(options)
+          release()
+        }
 
-    // Retain the store before disposal could fire
-    const release = storeRegistry.retain(options)
+        yield* Effect.yieldNow()
+        yield* TestClock.adjust(unusedCacheTime)
 
-    // Wait past the unusedCacheTime
-    await sleep(unusedCacheTime + 50)
+        // Store should be disposed after the last release
+        const nextStore = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(nextStore).not.toBe(store)
+      }),
+    )
 
-    // Store should still be cached because retain keeps it alive
-    const cachedStore = storeRegistry.getOrLoadPromise(options)
-    expect(cachedStore).toBe(store)
+    it.scoped('cancels disposal when new retain', () =>
+      Effect.gen(function* () {
+        const unusedCacheTime = 50
+        const runtime = yield* Effect.runtime<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ runtime, defaultOptions: { unusedCacheTime } })
+        const options = testStoreOptions()
 
-    release()
-    await store.shutdownPromise()
-  })
+        const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
 
-  it('manages multiple stores with different IDs independently', async () => {
-    const unusedCacheTime = 50
-    const storeRegistry = new StoreRegistry({ defaultOptions: { unusedCacheTime } })
+        yield* Effect.yieldNow()
 
-    const options1 = testStoreOptions({ storeId: 'store-1' })
-    const options2 = testStoreOptions({ storeId: 'store-2' })
+        // Advance almost to disposal threshold
+        yield* TestClock.adjust(unusedCacheTime - 5)
 
-    const store1 = await storeRegistry.getOrLoadPromise(options1)
-    const store2 = await storeRegistry.getOrLoadPromise(options2)
+        // Add a new retain before disposal triggers
+        const release = registry.retain(options)
 
-    // Should be different store instances
-    expect(store1).not.toBe(store2)
+        // Complete the original unusedCacheTime
+        yield* TestClock.adjust(5)
 
-    // Both should be cached independently
-    expect(storeRegistry.getOrLoadPromise(options1)).toBe(store1)
-    expect(storeRegistry.getOrLoadPromise(options2)).toBe(store2)
+        // Store should not have been disposed because retain keeps it alive
+        const cached = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(cached).toBe(store)
 
-    // Wait for both stores to be disposed
-    await sleep(unusedCacheTime + 50)
+        // Release retain — new idle timer starts
+        release()
+        yield* Effect.yieldNow()
 
-    // Both stores should be disposed, so next getOrLoadStore creates new ones
-    const newStore1 = await storeRegistry.getOrLoadPromise(options1)
-    expect(newStore1).not.toBe(store1)
+        yield* TestClock.adjust(unusedCacheTime)
 
-    const newStore2 = await storeRegistry.getOrLoadPromise(options2)
-    expect(newStore2).not.toBe(store2)
+        // Now it should be disposed
+        const nextStore = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(nextStore).not.toBe(store)
+      }),
+    )
 
-    // Clean up
-    await newStore1.shutdownPromise()
-    await newStore2.shutdownPromise()
-  })
+    it.scoped('aborts loading when disposal fires while store is still loading', () =>
+      Effect.gen(function* () {
+        const unusedCacheTime = 10
+        const loadDelay = 1000
+        const runtime = yield* Effect.runtime<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ runtime, defaultOptions: { unusedCacheTime } })
+
+        // Adapter that takes time to load (controlled by TestClock)
+        const baseAdapter = makeInMemoryAdapter()
+        const options = testStoreOptions({
+          adapter: ((args: any) =>
+            Effect.gen(function* () {
+              yield* Effect.sleep(loadDelay)
+              return yield* baseAdapter(args)
+            })) as any,
+        })
+
+        // Retain triggers loading (won't complete until clock advances past loadDelay)
+        const release = registry.retain(options)
+        yield* Effect.yieldNow()
+
+        // Release immediately — schedules disposal after unusedCacheTime
+        release()
+        yield* Effect.yieldNow()
+
+        // Advance past unusedCacheTime but NOT past loadDelay → disposal fires, interrupts loading
+        yield* TestClock.adjust(unusedCacheTime)
+
+        // Start a fresh load — since the first was aborted, this should be a new entry
+        const freshLoadFiber = yield* Effect.fork(registry.getOrLoad(options).pipe(Effect.scoped))
+        yield* Effect.yieldNow()
+
+        // Advance enough for the fresh load to complete
+        yield* TestClock.adjust(loadDelay)
+        const store = yield* Fiber.join(freshLoadFiber)
+
+        expect(store).toBeDefined()
+      }),
+    )
+
+    it.scoped('retain keeps store alive past unusedCacheTime', () =>
+      Effect.gen(function* () {
+        const unusedCacheTime = 50
+        const runtime = yield* Effect.runtime<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ runtime, defaultOptions: { unusedCacheTime } })
+        const options = testStoreOptions()
 
-  it('applies default options from constructor', async () => {
-    const storeRegistry = new StoreRegistry({
-      defaultOptions: {
-        unusedCacheTime: 100,
-      },
-    })
+        // Load the store
+        const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
 
-    const options = testStoreOptions()
+        // Retain the store before disposal could fire
+        const release = registry.retain(options)
 
-    const store = await storeRegistry.getOrLoadPromise(options)
+        yield* Effect.yieldNow()
 
-    // Verify the store loads successfully
-    expect(store).toBeDefined()
-    expect(store[StoreInternalsSymbol].clientSession.debugInstanceId).toBeDefined()
+        // Advance past unusedCacheTime — idle timer fires but refCount > 0, so no eviction
+        yield* TestClock.adjust(unusedCacheTime + 50)
 
-    // Verify configured default unusedCacheTime is applied by checking disposal doesn't happen before it
-    await sleep(50)
+        // Store should still be cached because retain keeps it alive
+        const cached = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(cached).toBe(store)
 
-    // Store should still be cached after 50ms (default is 100ms)
-    expect(storeRegistry.getOrLoadPromise(options)).toBe(store)
+        release()
+      }),
+    )
 
-    await store.shutdownPromise()
-  })
+    it.scoped('manages multiple stores with different IDs independently', () =>
+      Effect.gen(function* () {
+        const unusedCacheTime = 50
+        const runtime = yield* Effect.runtime<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ runtime, defaultOptions: { unusedCacheTime } })
 
-  it('prevents getOrLoadStore from returning a dying store', async () => {
-    const unusedCacheTime = 25
-    const storeRegistry = new StoreRegistry({ defaultOptions: { unusedCacheTime } })
-    const options = testStoreOptions()
+        const options1 = testStoreOptions({ storeId: 'store-1' })
+        const options2 = testStoreOptions({ storeId: 'store-2' })
 
-    // Load the store and wait for it to be ready
-    const originalStore = await storeRegistry.getOrLoadPromise(options)
+        const store1 = yield* registry.getOrLoad(options1).pipe(Effect.scoped)
+        const store2 = yield* registry.getOrLoad(options2).pipe(Effect.scoped)
 
-    // Verify store is cached
-    expect(storeRegistry.getOrLoadPromise(options)).toBe(originalStore)
+        // Should be different store instances
+        expect(store1).not.toBe(store2)
 
-    // Wait for disposal to trigger
-    await sleep(unusedCacheTime + 50)
+        // Both should be cached independently
+        const cached1 = yield* registry.getOrLoad(options1).pipe(Effect.scoped)
+        const cached2 = yield* registry.getOrLoad(options2).pipe(Effect.scoped)
+        expect(cached1).toBe(store1)
+        expect(cached2).toBe(store2)
 
-    // After disposal, the cache should be cleared
-    // Calling getOrLoadStore should start a fresh load (return Promise)
-    const storeOrPromise = storeRegistry.getOrLoadPromise(options)
+        yield* Effect.yieldNow()
+        yield* TestClock.adjust(unusedCacheTime)
 
-    if (!(storeOrPromise instanceof Promise)) {
-      expect.fail('getOrLoadStore returned dying store synchronously instead of starting fresh load')
-    }
+        // Both stores should be disposed
+        const newStore1 = yield* registry.getOrLoad(options1).pipe(Effect.scoped)
+        const newStore2 = yield* registry.getOrLoad(options2).pipe(Effect.scoped)
+        expect(newStore1).not.toBe(store1)
+        expect(newStore2).not.toBe(store2)
+      }),
+    )
 
-    const freshStore = await storeOrPromise
-    // A fresh load was triggered because cache was cleared
-    expect(freshStore).not.toBe(originalStore)
-    await freshStore.shutdownPromise()
-  })
+    it.scoped('applies default options from constructor', () =>
+      Effect.gen(function* () {
+        const runtime = yield* Effect.runtime<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ runtime, defaultOptions: { unusedCacheTime: 100 } })
+        const options = testStoreOptions()
 
-  it('warms the cache so subsequent getOrLoadStore is synchronous after preload', async () => {
-    const storeRegistry = new StoreRegistry()
-    const options = testStoreOptions()
+        const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
 
-    // Preload the store
-    await storeRegistry.preload(options)
+        // Verify the store loads successfully
+        expect(store).toBeDefined()
+        expect(store[StoreInternalsSymbol].clientSession.debugInstanceId).toBeDefined()
 
-    // Subsequent getOrLoadStore should return synchronously (not a Promise)
-    const store = storeRegistry.getOrLoadPromise(options)
-    expect(store).not.toBeInstanceOf(Promise)
+        yield* Effect.yieldNow()
 
-    // TypeScript doesn't narrow the type, so we need to assert
-    if (store instanceof Promise) {
-      throw new Error('Expected store, got Promise')
-    }
+        // After 50ms, store should still be cached (default is 100ms)
+        yield* TestClock.adjust(50)
 
-    // Clean up
-    await store.shutdownPromise()
-  })
+        const cached = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(cached).toBe(store)
+      }),
+    )
 
-  it('schedules disposal after preload if no retainers are added', async () => {
-    const unusedCacheTime = 50
-    const storeRegistry = new StoreRegistry({ defaultOptions: { unusedCacheTime } })
-    const options = testStoreOptions()
+    it.scoped('does not serve a disposed store from cache', () =>
+      Effect.gen(function* () {
+        const unusedCacheTime = 25
+        const runtime = yield* Effect.runtime<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ runtime, defaultOptions: { unusedCacheTime } })
+        const options = testStoreOptions()
 
-    // Preload without retaining
-    await storeRegistry.preload(options)
+        const originalStore = yield* registry.getOrLoad(options).pipe(Effect.scoped)
 
-    // Get the store
-    const store = storeRegistry.getOrLoadPromise(options)
-    expect(store).not.toBeInstanceOf(Promise)
+        // Verify store is cached
+        const cached = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(cached).toBe(originalStore)
 
-    // Wait for disposal to trigger
-    await sleep(unusedCacheTime + 50)
+        yield* Effect.yieldNow()
+        yield* TestClock.adjust(unusedCacheTime)
 
-    // Store should be disposed since no retainers were added
-    const nextStore = await storeRegistry.getOrLoadPromise(options)
-    expect(nextStore).not.toBe(store)
+        // After disposal, calling getOrLoad should produce a fresh store
+        const freshStore = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(freshStore).not.toBe(originalStore)
+      }),
+    )
 
-    await nextStore.shutdownPromise()
+    it.scoped('schedules disposal after preload if no retainers are added', () =>
+      Effect.gen(function* () {
+        const unusedCacheTime = 50
+        const runtime = yield* Effect.runtime<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ runtime, defaultOptions: { unusedCacheTime } })
+        const options = testStoreOptions()
+
+        // Preload without retaining (load + immediate release)
+        const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+
+        // Verify it's cached
+        const cached = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(cached).toBe(store)
+
+        yield* Effect.yieldNow()
+        yield* TestClock.adjust(unusedCacheTime)
+
+        // Store should be disposed since no retainers were added
+        const nextStore = yield* registry.getOrLoad(options).pipe(Effect.scoped)
+        expect(nextStore).not.toBe(store)
+      }),
+    )
   })
 })