@livestore/livestore 0.4.0 → 0.5.0-dev.0

package/src/store/StoreRegistry.test.ts

@@ -166,11 +166,11 @@ describe('StoreRegistry', () => {
   })
 
   it.layer(OtelLiveDummy)('time-dependent (using TestClock)', (it) => {
-    it.scoped('disposes store after unusedCacheTime expires', () =>
+    it.effect('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 services = yield* Effect.context<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ context: services, defaultOptions: { unusedCacheTime } })
         const options = testStoreOptions()
 
         const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
@@ -180,7 +180,7 @@ describe('StoreRegistry', () => {
         expect(cached).toBe(store)
 
         // Let the idle timer fiber register its sleep with TestClock
-        yield* Effect.yieldNow()
+        yield* Effect.yieldNow
 
         // Advance time past unusedCacheTime → idle timer fires → entry evicted
         yield* TestClock.adjust(unusedCacheTime)
@@ -192,10 +192,13 @@ describe('StoreRegistry', () => {
       }),
     )
 
-    it.scoped('does not dispose when unusedCacheTime is Infinity', () =>
+    it.effect('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 services = yield* Effect.context<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({
+          context: services,
+          defaultOptions: { unusedCacheTime: Number.POSITIVE_INFINITY },
+        })
         const options = testStoreOptions()
 
         const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
@@ -209,17 +212,17 @@ describe('StoreRegistry', () => {
       }),
     )
 
-    it.scoped('schedules disposal if store becomes unused during loading', () =>
+    it.effect('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 services = yield* Effect.context<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ context: services, defaultOptions: { unusedCacheTime } })
         const options = testStoreOptions()
 
         // Load without retaining — disposal is scheduled when scope closes
         const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
 
-        yield* Effect.yieldNow()
+        yield* Effect.yieldNow
         yield* TestClock.adjust(unusedCacheTime)
 
         // Store should be disposed
@@ -228,17 +231,17 @@ describe('StoreRegistry', () => {
       }),
     )
 
-    it.scoped('allows call-site options to override default options', () =>
+    it.effect('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
+        const services = yield* Effect.context<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ context: services, defaultOptions: { unusedCacheTime: 10_000 } }) // Long default
 
         const unusedCacheTimeOverride = 25
         const options = testStoreOptions({ unusedCacheTime: unusedCacheTimeOverride })
 
         const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
 
-        yield* Effect.yieldNow()
+        yield* Effect.yieldNow
         yield* TestClock.adjust(unusedCacheTimeOverride)
 
         // Should be disposed according to the override time, not default
@@ -247,10 +250,10 @@ describe('StoreRegistry', () => {
       }),
     )
 
-    it.scoped('disposes different stores according to their own unusedCacheTime', () =>
+    it.effect('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 } })
+        const services = yield* Effect.context<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ context: services, defaultOptions: { unusedCacheTime: 1000 } })
 
         const shortOptions = testStoreOptions({ storeId: 'short-lived', unusedCacheTime: 25 })
         const longOptions = testStoreOptions({ storeId: 'long-lived', unusedCacheTime: 10_000 })
@@ -258,7 +261,7 @@ describe('StoreRegistry', () => {
         const shortStore = yield* registry.getOrLoad(shortOptions).pipe(Effect.scoped)
         const longStore = yield* registry.getOrLoad(longOptions).pipe(Effect.scoped)
 
-        yield* Effect.yieldNow()
+        yield* Effect.yieldNow
 
         // Advance past short store's unusedCacheTime only
         yield* TestClock.adjust(25)
@@ -274,10 +277,10 @@ describe('StoreRegistry', () => {
 
     // 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', () =>
+    it.effect.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 })
+        const services = yield* Effect.context<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ context: services })
 
         const options = testStoreOptions({ unusedCacheTime: 10 })
         const release = registry.retain(options)
@@ -288,7 +291,7 @@ describe('StoreRegistry', () => {
         yield* registry.getOrLoad(testStoreOptions({ unusedCacheTime: 100 })).pipe(Effect.scoped)
 
         release()
-        yield* Effect.yieldNow()
+        yield* Effect.yieldNow
 
         // After 99ms, store should still be alive (100ms unusedCacheTime used)
         yield* TestClock.adjust(99)
@@ -304,11 +307,11 @@ describe('StoreRegistry', () => {
       }),
     )
 
-    it.scoped('handles rapid retain/release cycles without errors', () =>
+    it.effect('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 services = yield* Effect.context<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ context: services, defaultOptions: { unusedCacheTime } })
         const options = testStoreOptions()
 
         const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
@@ -319,7 +322,7 @@ describe('StoreRegistry', () => {
           release()
         }
 
-        yield* Effect.yieldNow()
+        yield* Effect.yieldNow
         yield* TestClock.adjust(unusedCacheTime)
 
         // Store should be disposed after the last release
@@ -328,16 +331,16 @@ describe('StoreRegistry', () => {
       }),
     )
 
-    it.scoped('cancels disposal when new retain', () =>
+    it.effect('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 services = yield* Effect.context<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ context: services, defaultOptions: { unusedCacheTime } })
         const options = testStoreOptions()
 
         const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
 
-        yield* Effect.yieldNow()
+        yield* Effect.yieldNow
 
         // Advance almost to disposal threshold
         yield* TestClock.adjust(unusedCacheTime - 5)
@@ -354,7 +357,7 @@ describe('StoreRegistry', () => {
 
         // Release retain — new idle timer starts
         release()
-        yield* Effect.yieldNow()
+        yield* Effect.yieldNow
 
         yield* TestClock.adjust(unusedCacheTime)
 
@@ -364,12 +367,12 @@ describe('StoreRegistry', () => {
       }),
     )
 
-    it.scoped('aborts loading when disposal fires while store is still loading', () =>
+    it.effect('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 } })
+        const services = yield* Effect.context<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ context: services, defaultOptions: { unusedCacheTime } })
 
         // Adapter that takes time to load (controlled by TestClock)
         const baseAdapter = makeInMemoryAdapter()
@@ -383,18 +386,18 @@ describe('StoreRegistry', () => {
 
         // Retain triggers loading (won't complete until clock advances past loadDelay)
         const release = registry.retain(options)
-        yield* Effect.yieldNow()
+        yield* Effect.yieldNow
 
         // Release immediately — schedules disposal after unusedCacheTime
         release()
-        yield* Effect.yieldNow()
+        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()
+        const freshLoadFiber = yield* Effect.forkChild(registry.getOrLoad(options).pipe(Effect.scoped))
+        yield* Effect.yieldNow
 
         // Advance enough for the fresh load to complete
         yield* TestClock.adjust(loadDelay)
@@ -404,11 +407,11 @@ describe('StoreRegistry', () => {
       }),
     )
 
-    it.scoped('retain keeps store alive past unusedCacheTime', () =>
+    it.effect('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 services = yield* Effect.context<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ context: services, defaultOptions: { unusedCacheTime } })
         const options = testStoreOptions()
 
         // Load the store
@@ -417,7 +420,7 @@ describe('StoreRegistry', () => {
         // Retain the store before disposal could fire
         const release = registry.retain(options)
 
-        yield* Effect.yieldNow()
+        yield* Effect.yieldNow
 
         // Advance past unusedCacheTime — idle timer fires but refCount > 0, so no eviction
         yield* TestClock.adjust(unusedCacheTime + 50)
@@ -430,11 +433,11 @@ describe('StoreRegistry', () => {
       }),
     )
 
-    it.scoped('manages multiple stores with different IDs independently', () =>
+    it.effect('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 } })
+        const services = yield* Effect.context<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ context: services, defaultOptions: { unusedCacheTime } })
 
         const options1 = testStoreOptions({ storeId: 'store-1' })
         const options2 = testStoreOptions({ storeId: 'store-2' })
@@ -451,7 +454,7 @@ describe('StoreRegistry', () => {
         expect(cached1).toBe(store1)
         expect(cached2).toBe(store2)
 
-        yield* Effect.yieldNow()
+        yield* Effect.yieldNow
         yield* TestClock.adjust(unusedCacheTime)
 
         // Both stores should be disposed
@@ -462,10 +465,10 @@ describe('StoreRegistry', () => {
       }),
     )
 
-    it.scoped('applies default options from constructor', () =>
+    it.effect('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 services = yield* Effect.context<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ context: services, defaultOptions: { unusedCacheTime: 100 } })
         const options = testStoreOptions()
 
         const store = yield* registry.getOrLoad(options).pipe(Effect.scoped)
@@ -474,7 +477,7 @@ describe('StoreRegistry', () => {
         expect(store).toBeDefined()
         expect(store[StoreInternalsSymbol].clientSession.debugInstanceId).toBeDefined()
 
-        yield* Effect.yieldNow()
+        yield* Effect.yieldNow
 
         // After 50ms, store should still be cached (default is 100ms)
         yield* TestClock.adjust(50)
@@ -484,11 +487,11 @@ describe('StoreRegistry', () => {
       }),
     )
 
-    it.scoped('does not serve a disposed store from cache', () =>
+    it.effect('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 services = yield* Effect.context<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ context: services, defaultOptions: { unusedCacheTime } })
         const options = testStoreOptions()
 
         const originalStore = yield* registry.getOrLoad(options).pipe(Effect.scoped)
@@ -497,7 +500,7 @@ describe('StoreRegistry', () => {
         const cached = yield* registry.getOrLoad(options).pipe(Effect.scoped)
         expect(cached).toBe(originalStore)
 
-        yield* Effect.yieldNow()
+        yield* Effect.yieldNow
         yield* TestClock.adjust(unusedCacheTime)
 
         // After disposal, calling getOrLoad should produce a fresh store
@@ -506,11 +509,11 @@ describe('StoreRegistry', () => {
       }),
     )
 
-    it.scoped('schedules disposal after preload if no retainers are added', () =>
+    it.effect('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 services = yield* Effect.context<Scope.Scope | OtelTracer.OtelTracer>()
+        const registry = new StoreRegistry({ context: services, defaultOptions: { unusedCacheTime } })
         const options = testStoreOptions()
 
         // Preload without retaining (load + immediate release)
@@ -520,7 +523,7 @@ describe('StoreRegistry', () => {
         const cached = yield* registry.getOrLoad(options).pipe(Effect.scoped)
         expect(cached).toBe(store)
 
-        yield* Effect.yieldNow()
+        yield* Effect.yieldNow
         yield* TestClock.adjust(unusedCacheTime)
 
         // Store should be disposed since no retainers were added

package/src/store/StoreRegistry.ts

@@ -1,8 +1,9 @@
-import { LogConfig, OtelLiveDummy, provideOtel, UnknownError } from '@livestore/common'
+import { OtelLiveDummy, provideOtel, UnknownError } from '@livestore/common'
 import type { LiveStoreSchema } from '@livestore/common/schema'
-import { omitUndefineds } from '@livestore/utils'
+import { isDevEnv, omitUndefineds } from '@livestore/utils'
 import {
   Cause,
+  type Context,
   Effect,
   Equal,
   Exit,
@@ -10,16 +11,17 @@ import {
   Hash,
   Layer,
   ManagedRuntime,
+  Result,
   type OtelTracer,
   RcMap,
-  Runtime,
+  References,
   type Schema,
-  type Scope,
+  Scope,
 } from '@livestore/utils/effect'
 
-import { createStore, type CreateStoreOptions } from './create-store.ts'
-import type { Store } from './store.ts'
+import { type CreateStoreOptions, createStore } from './create-store.ts'
 import type { OtelOptions } from './store-types.ts'
+import type { Store } from './store.ts'
 
 /**
  * Default time to keep unused stores in cache.
@@ -47,7 +49,7 @@ export const DEFAULT_UNUSED_CACHE_TIME = typeof window === 'undefined' ? Number.
 export interface RegistryStoreOptions<
   TSchema extends LiveStoreSchema = LiveStoreSchema.Any,
   TContext = {},
-  TSyncPayloadSchema extends Schema.Schema<any> = typeof Schema.JsonValue,
+  TSyncPayloadSchema extends Schema.Codec<Schema.Json, Schema.Json> = typeof Schema.Json,
 > extends CreateStoreOptions<TSchema, TContext, TSyncPayloadSchema> {
   /**
    * OpenTelemetry configuration for tracing store operations.
@@ -99,10 +101,10 @@ type StoreRegistryConfig = {
     >
   >
   /**
-   * Custom Effect runtime for all registry operations (loading, caching, etc.).
-   * When the runtime's scope closes, all managed stores are automatically shut down.
+   * Custom Effect context for all registry operations (loading, caching, etc.).
+   * When the context's scope closes, all managed stores are automatically shut down.
    */
-  runtime?: Runtime.Runtime<Scope.Scope | OtelTracer.OtelTracer>
+  context?: Context.Context<Scope.Scope | OtelTracer.OtelTracer>
 }
 
 /**
@@ -150,14 +152,14 @@ export class StoreRegistry {
   readonly #rcMap: RcMap.RcMap<StoreCacheKey, Store<any, any>, UnknownError>
 
   /**
-   * Effect runtime providing Scope and OtelTracer for all registry operations.
-   * When the runtime's scope closes, all managed stores are automatically shut down.
+   * Effect context providing Scope and OtelTracer for all registry operations.
+   * When the context's scope closes, all managed stores are automatically shut down.
    */
-  readonly #runtime: Runtime.Runtime<Scope.Scope | OtelTracer.OtelTracer>
+  readonly #context: Context.Context<Scope.Scope | OtelTracer.OtelTracer>
 
   /**
    * Disposal callback for the runtime created by the registry.
-   * Undefined when caller provided their own runtime (caller owns cleanup in that case).
+   * Undefined when caller provided their own services (caller owns cleanup in that case).
    */
   readonly #disposeOwnedRuntime: (() => Promise<void>) | undefined
 
@@ -181,11 +183,11 @@ export class StoreRegistry {
    * ```
    */
   constructor(config: StoreRegistryConfig = {}) {
-    if (config.runtime !== undefined) {
-      this.#runtime = config.runtime
+    if (config.context !== undefined) {
+      this.#context = config.context
     } else {
-      const ownedRuntime = ManagedRuntime.make(Layer.mergeAll(Layer.scope, OtelLiveDummy))
-      this.#runtime = ownedRuntime.runtimeEffect.pipe(Effect.runSync)
+      const ownedRuntime = ManagedRuntime.make(Layer.mergeAll(Layer.effect(Scope.Scope, Effect.scope), OtelLiveDummy))
+      this.#context = ownedRuntime.contextEffect.pipe(Effect.runSync)
       this.#disposeOwnedRuntime = () => ownedRuntime.dispose()
     }
 
@@ -194,9 +196,17 @@ export class StoreRegistry {
         // Merge registry defaults with call-site options (call-site takes precedence)
         const mergedOptions = { ...config.defaultOptions, ...options }
         return createStore(mergedOptions).pipe(
-          Effect.catchAllDefect((cause) => UnknownError.make({ cause })),
+          Effect.catchDefect((cause) => UnknownError.make({ cause })),
           Effect.withSpan(`StoreRegistry.lookup:${mergedOptions.storeId}`),
-          LogConfig.withLoggerConfig(mergedOptions, { threadName: 'window' }),
+          Effect.provide(
+            Layer.mergeAll(
+              mergedOptions.logger ?? Layer.empty,
+              Layer.succeed(
+                References.MinimumLogLevel,
+                mergedOptions.logLevel ?? (isDevEnv() === true ? 'Debug' : 'Info'),
+              ),
+            ),
+          ),
           provideOtel(
             omitUndefineds({
               parentSpanContext: mergedOptions.otelOptions?.rootSpanContext,
@@ -205,8 +215,9 @@ export class StoreRegistry {
           ),
         )
       },
-      idleTimeToLive: ({ options }: StoreCacheKey) => options.unusedCacheTime ?? config.defaultOptions?.unusedCacheTime ?? DEFAULT_UNUSED_CACHE_TIME,
-    }).pipe(Runtime.runSync(this.#runtime))
+      idleTimeToLive: ({ options }: StoreCacheKey) =>
+        options.unusedCacheTime ?? config.defaultOptions?.unusedCacheTime ?? DEFAULT_UNUSED_CACHE_TIME,
+    }).pipe(Effect.runSyncWith(this.#context))
   }
 
   /**
@@ -226,11 +237,11 @@ export class StoreRegistry {
   getOrLoad = <
     TSchema extends LiveStoreSchema,
     TContext = {},
-    TSyncPayloadSchema extends Schema.Schema<any> = typeof Schema.JsonValue,
+    TSyncPayloadSchema extends Schema.Codec<Schema.Json, Schema.Json> = typeof Schema.Json,
   >(
     options: RegistryStoreOptions<TSchema, TContext, TSyncPayloadSchema>,
   ): Effect.Effect<Store<TSchema, TContext>, UnknownError, Scope.Scope> =>
-    Effect.gen(this, function* () {
+    Effect.gen({ self: this }, function* () {
       // Cast options to satisfy StoreCacheKey's wider type (type safety enforced at API boundary)
       const key = new StoreCacheKey(options)
       const store = yield* RcMap.get(this.#rcMap, key)
@@ -257,22 +268,22 @@ export class StoreRegistry {
   getOrLoadPromise = <
     TSchema extends LiveStoreSchema,
     TContext = {},
-    TSyncPayloadSchema extends Schema.Schema<any> = typeof Schema.JsonValue,
+    TSyncPayloadSchema extends Schema.Codec<Schema.Json, Schema.Json> = typeof Schema.Json,
   >(
     options: RegistryStoreOptions<TSchema, TContext, TSyncPayloadSchema>,
   ): Store<TSchema, TContext> | Promise<Store<TSchema, TContext>> => {
-    const exit = this.getOrLoad(options).pipe(Effect.scoped, Runtime.runSyncExit(this.#runtime))
+    const exit = this.getOrLoad(options).pipe(Effect.scoped, Effect.runSyncExitWith(this.#context))
 
     if (Exit.isSuccess(exit) === true) return exit.value
 
     // Check if the failure is due to async work
-    const defect = Cause.dieOption(exit.cause)
-    if (defect._tag !== 'Some') {
+    const defect = Cause.findDefect(exit.cause)
+    if (Result.isFailure(defect) === true) {
       // Handle synchronous failure
       throw Cause.squash(exit.cause)
     }
 
-    if (Runtime.isAsyncFiberException(defect.value) === false) {
+    if (Cause.isAsyncFiberError(defect.success) === false) {
       // Handle synchronous failure
       throw Cause.squash(exit.cause)
     }
@@ -284,9 +295,9 @@ export class StoreRegistry {
     if (cached !== undefined) return cached as Promise<Store<TSchema, TContext>>
 
     // Create and cache the promise
-    const fiber = defect.value.fiber as Fiber.RuntimeFiber<Store<TSchema, TContext>>
+    const fiber = defect.success.fiber as Fiber.Fiber<Store<TSchema, TContext>>
     const promise = Fiber.join(fiber)
-      .pipe(Runtime.runPromise(this.#runtime))
+      .pipe(Effect.runPromiseWith(this.#context))
       .finally(() => this.#loadingPromises.delete(storeId))
 
     this.#loadingPromises.set(storeId, promise)
@@ -309,19 +320,19 @@ export class StoreRegistry {
   retain = <
     TSchema extends LiveStoreSchema,
     TContext = {},
-    TSyncPayloadSchema extends Schema.Schema<any> = typeof Schema.JsonValue,
+    TSyncPayloadSchema extends Schema.Codec<Schema.Json, Schema.Json> = typeof Schema.Json,
   >(
     options: RegistryStoreOptions<TSchema, TContext, TSyncPayloadSchema>,
   ): (() => void) => {
-    const release = Effect.gen(this, function* () {
+    const release = Effect.gen({ self: this }, function* () {
       // Cast options to satisfy StoreCacheKey's wider type (type safety enforced at API boundary)
       const key = new StoreCacheKey(options)
       yield* RcMap.get(this.#rcMap, key)
       // Effect.never suspends indefinitely, keeping the RcMap reference alive.
       // When `release()` is called, the fiber is interrupted, closing the scope
       // and releasing the RcMap entry (which may trigger disposal after idleTimeToLive).
-      yield* Effect.never
-    }).pipe(Effect.scoped, Runtime.runCallback(this.#runtime))
+      return yield* Effect.never
+    }).pipe(Effect.scoped, Effect.runCallbackWith(this.#context))
 
     return () => release()
   }
@@ -342,7 +353,7 @@ export class StoreRegistry {
   preload = async <
     TSchema extends LiveStoreSchema,
     TContext = {},
-    TSyncPayloadSchema extends Schema.Schema<any> = typeof Schema.JsonValue,
+    TSyncPayloadSchema extends Schema.Codec<Schema.Json, Schema.Json> = typeof Schema.Json,
   >(
     options: RegistryStoreOptions<TSchema, TContext, TSyncPayloadSchema>,
   ): Promise<void> => {
@@ -364,7 +375,7 @@ export class StoreRegistry {
    * @returns A promise that resolves when disposal is complete
    *
    * @remarks
-   * - No-op if a custom `runtime` was provided to the constructor (caller owns cleanup)
+   * - No-op if a custom `context` was provided to the constructor (caller owns cleanup)
    * - Idempotent: safe to call multiple times
    * - After disposal, the registry should not be used
    */
@@ -412,7 +423,7 @@ export class StoreRegistry {
 export const storeOptions = <
   TSchema extends LiveStoreSchema,
   TContext = {},
-  TSyncPayloadSchema extends Schema.Schema<any> = typeof Schema.JsonValue,
+  TSyncPayloadSchema extends Schema.Codec<Schema.Json, Schema.Json> = typeof Schema.Json,
 >(
   options: RegistryStoreOptions<TSchema, TContext, TSyncPayloadSchema>,
 ): RegistryStoreOptions<TSchema, TContext, TSyncPayloadSchema> => options