@playfast/reform 1.0.1 → 1.2.0

package/src/calc/asyncCalc.invalidate.test.ts

@@ -1,18 +1,14 @@
 import { expect, it } from '@effect/vitest'
-import { Duration, Effect, Layer, Option, Schema as S } from 'effect'
-import { AsyncCalc, Engine, Queries, QueryStore, State, StateGroup } from '../index'
-
-// The data-oriented half of AsyncCalc: `invalidate` flips `isStale` only (no
-// fetch), `refetch` forces a run, a stale query with active readers (or a fresh
-// subscriber) refetches, and `persist` hydrates + writes through an optional
-// QueryStore. `isStale` is read off the `Queries` registry handle.
+import { Duration, Effect, Layer, ManagedRuntime, MutableRef, Option, Schema as S } from 'effect'
+import { AsyncCalc, Engine, forceSync, RemoteState, State, StateGroup } from '../index'
+import { QueryStore } from '../internal/queryStore'
+import { Queries } from '../runtime/queries'
 
 const tick = (ms = 10) => Effect.sleep(Duration.millis(ms))
 
 const isStale = (name: string) =>
   Effect.map(Queries, (q) => q.byName.get(name)?.snapshot().isStale ?? false)
 
-// An in-memory QueryStore, so persistence is exercised with no DOM.
 const fakeQueryStore = (seed: Record<string, unknown> = {}) => {
   const map = new Map<string, unknown>(Object.entries(seed))
   const layer = Layer.succeed(QueryStore, {
@@ -23,6 +19,37 @@ const fakeQueryStore = (seed: Record<string, unknown> = {}) => {
   return { map, layer }
 }
 
+const controlled = <A>() => {
+  const resolver = MutableRef.make<(value: A) => void>(() => {})
+  const promise = new Promise<A>((resume) => {
+    MutableRef.set(resolver, resume)
+  })
+  return { promise, resolve: (value: A) => MutableRef.get(resolver)(value) }
+}
+
+const promiseQueryStore = (get: (key: string) => Promise<Option.Option<unknown>>) => {
+  const map = new Map<string, unknown>()
+  const layer = Layer.succeed(QueryStore, {
+    get: (key) => Effect.promise(() => get(key)),
+    set: (key, value) => Effect.sync(() => void map.set(key, value)),
+    remove: (key) => Effect.sync(() => void map.delete(key)),
+  })
+  return { map, layer }
+}
+
+const rearmOnEveryChange = (subscribe: (listener: () => void) => () => void): (() => void) => {
+  const current = MutableRef.make<() => void>(() => {})
+  const arm = () => {
+    const unsubscribe = subscribe(() => {
+      MutableRef.get(current)()
+      arm()
+    })
+    MutableRef.set(current, unsubscribe)
+  }
+  arm()
+  return () => MutableRef.get(current)()
+}
+
 it.live('invalidate marks stale without fetching; a fresh subscriber then refetches', () => {
   class Count extends State.make('count', S.Number) {}
   class Inputs extends StateGroup.make(Count) {}
@@ -49,13 +76,11 @@ it.live('invalidate marks stale without fetching; a fresh subscriber then refetc
     yield* tick()
     expect(runs.n).toBe(1)
 
-    // No active readers: invalidate flips the flag but fetches nothing.
     yield* AsyncCalc.invalidate(Q)
     yield* tick()
     expect(yield* isStale('Q')).toBe(true)
     expect(runs.n).toBe(1)
 
-    // A reader arriving over a stale query (the resubscribe/mount analog) refetches.
     store.subscribe(() => {})
     yield* tick()
     expect(runs.n).toBe(2)
@@ -86,12 +111,11 @@ it.live('invalidate with an active reader auto-refetches immediately, keeping th
 
   return Effect.gen(function* () {
     const store = yield* Q.store
-    store.subscribe(() => {}) // active reader
+    store.subscribe(() => {})
     yield* tick(40)
     expect(store.get()).toMatchObject({ _tag: 'Success', value: 7, refetching: false })
     expect(runs.n).toBe(1)
 
-    // Stale + active ⇒ refetch now; the last value stays visible (SWR).
     yield* AsyncCalc.invalidate(Q)
     yield* tick(5)
     expect(store.get()).toMatchObject({ _tag: 'Success', value: 7, refetching: true })
@@ -127,40 +151,502 @@ it.live('refetch forces a run regardless of staleness', () => {
     expect(runs.n).toBe(1)
     expect(yield* isStale('Q')).toBe(false)
 
-    // Not stale, no key movement — refetch still runs.
     yield* AsyncCalc.refetch(Q)
     yield* tick()
     expect(runs.n).toBe(2)
   }).pipe(Effect.provide(TestLayer))
 })
 
-it.live('persist: hydrates from the QueryStore (stale) then writes the settled value through', () => {
-  class Count extends State.make('count', S.Number) {}
+it.live(
+  'persist: hydrates from the QueryStore (stale) then writes the settled value through',
+  () => {
+    class Count extends State.make('count', S.Number) {}
+    class Inputs extends StateGroup.make(Count) {}
+    const store = fakeQueryStore({ P: 99 })
+    class Q extends AsyncCalc.make('Q', {
+      inputs: [StateGroup.select(Inputs, 'count')],
+      output: S.Number,
+      alwaysOn: true,
+    }) {}
+    const QLive = AsyncCalc.live(Q, {
+      query: ({ count }) => Effect.succeed(count * 2).pipe(Effect.delay(Duration.millis(25))),
+      persist: { key: 'P' },
+    })
+    const TestLayer = QLive.pipe(
+      Layer.provideMerge(StateGroup.live(Inputs, { count: 5 })),
+      Layer.provideMerge(store.layer),
+      Layer.provideMerge(Engine),
+    )
+
+    return Effect.gen(function* () {
+      const view = yield* Q.store
+      expect(view.get()).toMatchObject({ _tag: 'Success', value: 99, refetching: true })
+
+      yield* tick(45)
+      expect(view.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: false })
+      expect(store.map.get('P')).toBe(10)
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
+
+it('persist: a re-armed watcher does not duplicate the generation covering hydration', async () => {
+  const cached = controlled<Option.Option<unknown>>()
+  const fresh = controlled<number>()
+  const persisted = promiseQueryStore(() => cached.promise)
+  const runs = { n: 0 }
+  class Q extends AsyncCalc.make('CoveredHydrationQ', {
+    inputs: [],
+    output: S.Number,
+    alwaysOn: true,
+  }) {}
+  const TestLayer = AsyncCalc.live(Q, {
+    query: () =>
+      Effect.sync(() => {
+        runs.n += 1
+      }).pipe(Effect.zipRight(Effect.promise(() => fresh.promise))),
+    coalesce: 'trailing',
+    persist: true,
+  }).pipe(Layer.provideMerge(persisted.layer), Layer.provideMerge(Engine))
+  const runtime = ManagedRuntime.make(TestLayer)
+
+  const view = forceSync(() => runtime.runSync(Q.store))
+  const stop = rearmOnEveryChange(view.subscribe)
+  await runtime.runPromise(tick())
+  expect(runs.n).toBe(1)
+
+  cached.resolve(Option.some(99))
+  await runtime.runPromise(tick())
+  expect(view.get()).toMatchObject({ _tag: 'Success', value: 99, refetching: true })
+
+  fresh.resolve(10)
+  await runtime.runPromise(tick())
+  expect(runs.n).toBe(1)
+  expect(view.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: false })
+  stop()
+  await runtime.dispose()
+})
+
+it('persist: an explicit refetch still trails the generation covering hydration', async () => {
+  const cached = controlled<Option.Option<unknown>>()
+  const fresh = controlled<number>()
+  const persisted = promiseQueryStore(() => cached.promise)
+  const runs = { n: 0 }
+  class CoveredHydrationRefetchQ extends AsyncCalc.make('CoveredHydrationRefetchQ', {
+    inputs: [],
+    output: S.Number,
+    alwaysOn: true,
+  }) {}
+  const TestLayer = AsyncCalc.live(CoveredHydrationRefetchQ, {
+    query: () =>
+      Effect.sync(() => {
+        runs.n += 1
+      }).pipe(Effect.zipRight(Effect.promise(() => fresh.promise))),
+    coalesce: 'trailing',
+    persist: true,
+  }).pipe(Layer.provideMerge(persisted.layer), Layer.provideMerge(Engine))
+  const runtime = ManagedRuntime.make(TestLayer)
+
+  const view = forceSync(() => runtime.runSync(CoveredHydrationRefetchQ.store))
+  const stop = rearmOnEveryChange(view.subscribe)
+  await runtime.runPromise(tick())
+  cached.resolve(Option.some(99))
+  await runtime.runPromise(tick())
+
+  await runtime.runPromise(AsyncCalc.refetch(CoveredHydrationRefetchQ))
+  fresh.resolve(10)
+  await runtime.runPromise(tick())
+  expect(runs.n).toBe(2)
+  expect(view.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: false })
+  stop()
+  await runtime.dispose()
+})
+
+it('invalidate after a requested generation stays uncovered when hydration lands', async () => {
+  const cached = controlled<Option.Option<unknown>>()
+  const fresh = controlled<number>()
+  const persisted = promiseQueryStore(() => cached.promise)
+  const runs = { n: 0 }
+  class InFlightInvalidateQ extends AsyncCalc.make('InFlightInvalidateQ', {
+    inputs: [],
+    output: S.Number,
+    alwaysOn: true,
+  }) {}
+  const TestLayer = AsyncCalc.live(InFlightInvalidateQ, {
+    query: () =>
+      Effect.sync(() => {
+        runs.n += 1
+      }).pipe(Effect.zipRight(Effect.promise(() => fresh.promise))),
+    coalesce: 'trailing',
+    persist: true,
+  }).pipe(Layer.provideMerge(persisted.layer), Layer.provideMerge(Engine))
+  const runtime = ManagedRuntime.make(TestLayer)
+
+  const view = forceSync(() => runtime.runSync(InFlightInvalidateQ.store))
+  await runtime.runPromise(tick())
+  expect(runs.n).toBe(1)
+
+  await runtime.runPromise(AsyncCalc.invalidate(InFlightInvalidateQ))
+  expect(await runtime.runPromise(isStale('InFlightInvalidateQ'))).toBe(true)
+  cached.resolve(Option.some(99))
+  await runtime.runPromise(tick())
+  expect(view.get()).toMatchObject({ _tag: 'Success', value: 99, refetching: true })
+
+  const stop = rearmOnEveryChange(view.subscribe)
+  fresh.resolve(7)
+  await runtime.runPromise(tick())
+  expect(runs.n).toBe(2)
+  expect(view.get()).toMatchObject({ _tag: 'Success', value: 7, refetching: false })
+  stop()
+  await runtime.dispose()
+})
+
+it('a failed refetch leaves its stale mark uncovered, so a fresh subscriber retries', async () => {
+  const runs = { n: 0 }
+  class FailedCoverQ extends AsyncCalc.make('FailedCoverQ', {
+    inputs: [],
+    output: S.Number,
+    error: S.String,
+    alwaysOn: true,
+  }) {}
+  const runtime = ManagedRuntime.make(
+    AsyncCalc.live(FailedCoverQ, {
+      query: () =>
+        Effect.suspend((): Effect.Effect<number, string> => {
+          runs.n += 1
+          return runs.n === 2 ? Effect.fail('boom') : Effect.succeed(runs.n)
+        }),
+    }).pipe(Layer.provideMerge(Engine)),
+  )
+
+  const view = forceSync(() => runtime.runSync(FailedCoverQ.store))
+  await runtime.runPromise(tick())
+  expect(runs.n).toBe(1)
+
+  // Invalidate with no readers, then attach one: that reader's refetch covers the
+  // stale mark, and it fails.
+  await runtime.runPromise(AsyncCalc.invalidate(FailedCoverQ))
+  const first = view.subscribe(() => {})
+  await runtime.runPromise(tick())
+  expect(runs.n).toBe(2)
+  expect(view.get()).toMatchObject({ _tag: 'Error', error: 'boom' })
+  expect(await runtime.runPromise(isStale('FailedCoverQ'))).toBe(true)
+
+  // Nothing successful has covered the mark, so the next subscriber still retries.
+  first()
+  view.subscribe(() => {})
+  await runtime.runPromise(tick())
+  expect(runs.n).toBe(3)
+  expect(view.get()).toMatchObject({ _tag: 'Success', value: 3, refetching: false })
+  await runtime.dispose()
+})
+
+it('persist: hydration before any request still gets one initial revalidation', async () => {
+  const fresh = controlled<number>()
+  const persisted = fakeQueryStore({ SyncHydrationQ: 99 })
+  const runs = { n: 0 }
+  class Q extends AsyncCalc.make('SyncHydrationQ', {
+    inputs: [],
+    output: S.Number,
+    alwaysOn: true,
+  }) {}
+  const TestLayer = AsyncCalc.live(Q, {
+    query: () =>
+      Effect.sync(() => {
+        runs.n += 1
+      }).pipe(Effect.zipRight(Effect.promise(() => fresh.promise))),
+    coalesce: 'trailing',
+    persist: true,
+  }).pipe(Layer.provideMerge(persisted.layer), Layer.provideMerge(Engine))
+  const runtime = ManagedRuntime.make(TestLayer)
+
+  const view = forceSync(() => runtime.runSync(Q.store))
+  const stop = rearmOnEveryChange(view.subscribe)
+  await runtime.runPromise(tick())
+  expect(runs.n).toBe(1)
+  expect(view.get()).toMatchObject({ _tag: 'Success', value: 99, refetching: true })
+
+  fresh.resolve(10)
+  await runtime.runPromise(tick())
+  expect(runs.n).toBe(1)
+  expect(view.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: false })
+  stop()
+  await runtime.dispose()
+})
+
+it('a genuine key change still enqueues a trailing generation', async () => {
+  const release = controlled<void>()
+  const runs = { n: 0 }
+  class Count extends State.make('key-change-count', S.Number) {}
   class Inputs extends StateGroup.make(Count) {}
-  const store = fakeQueryStore({ P: 99 }) // a previously-persisted value
-  class Q extends AsyncCalc.make('Q', {
-    inputs: [StateGroup.select(Inputs, 'count')],
+  class Q extends AsyncCalc.make('InFlightKeyChangeQ', {
+    inputs: [StateGroup.select(Inputs, 'key-change-count')],
     output: S.Number,
     alwaysOn: true,
   }) {}
-  const QLive = AsyncCalc.live(Q, {
-    query: ({ count }) => Effect.succeed(count * 2).pipe(Effect.delay(Duration.millis(25))),
+  const TestLayer = AsyncCalc.live(Q, {
+    query: ({ 'key-change-count': count }) =>
+      Effect.sync(() => {
+        runs.n += 1
+      }).pipe(Effect.zipRight(Effect.promise(() => release.promise)), Effect.as(count)),
+    coalesce: 'trailing',
+  }).pipe(
+    Layer.provideMerge(StateGroup.live(Inputs, { 'key-change-count': 1 })),
+    Layer.provideMerge(Engine),
+  )
+  const runtime = ManagedRuntime.make(TestLayer)
+
+  const view = forceSync(() => runtime.runSync(Q.store))
+  const count = runtime.runSync(Count.store)
+  await runtime.runPromise(tick())
+  expect(runs.n).toBe(1)
+
+  count.set(2)
+  await runtime.runPromise(tick())
+  expect(runs.n).toBe(1)
+  release.resolve()
+  await runtime.runPromise(tick())
+  expect(runs.n).toBe(2)
+  expect(view.get()).toMatchObject({ _tag: 'Success', value: 2, refetching: false })
+  await runtime.dispose()
+})
+
+it('persist: promise-backed hydration keeps construction synchronous and preserves SWR ordering', async () => {
+  const cached = controlled<Option.Option<unknown>>()
+  const fresh = controlled<number>()
+  const store = promiseQueryStore(() => cached.promise)
+  const runs = { n: 0 }
+  class Q extends AsyncCalc.make('AsyncPersistQ', {
+    inputs: [],
+    output: S.Number,
+    alwaysOn: true,
+  }) {}
+  const TestLayer = AsyncCalc.live(Q, {
+    query: () => {
+      runs.n += 1
+      return Effect.promise(() => fresh.promise)
+    },
     persist: { key: 'P' },
+  }).pipe(Layer.provideMerge(store.layer), Layer.provideMerge(Engine))
+  const runtime = ManagedRuntime.make(TestLayer)
+
+  const view = forceSync(() => runtime.runSync(Q.store))
+  expect(view.get()).toMatchObject({ _tag: 'Loading' })
+  await runtime.runPromise(tick())
+  expect(runs.n).toBe(1)
+
+  cached.resolve(Option.some(99))
+  await runtime.runPromise(tick())
+  expect(view.get()).toMatchObject({ _tag: 'Success', value: 99, refetching: true })
+
+  fresh.resolve(10)
+  await runtime.runPromise(tick())
+  expect(view.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: false })
+  expect(store.map.get('P')).toBe(10)
+  await runtime.dispose()
+})
+
+it('persist: late or corrupt hydration cannot overwrite fresh truth or a changed source key', async () => {
+  const cacheByKey = new Map<string, ReturnType<typeof controlled<Option.Option<unknown>>>>()
+  const store = promiseQueryStore((key) => {
+    const pending = controlled<Option.Option<unknown>>()
+    cacheByKey.set(key, pending)
+    return pending.promise
   })
-  const TestLayer = QLive.pipe(
-    Layer.provideMerge(StateGroup.live(Inputs, { count: 5 })),
+  class Count extends State.make('count', S.Number) {}
+  class Inputs extends StateGroup.make(Count) {}
+  class Q extends AsyncCalc.make('AsyncPersistKeyed', {
+    inputs: [StateGroup.select(Inputs, 'count')],
+    output: S.Number,
+    alwaysOn: true,
+  }) {}
+  const TestLayer = AsyncCalc.live(Q, {
+    query: ({ count }) => Effect.succeed(count * 10),
+    persist: { key: ({ count }) => `P:${count}` },
+  }).pipe(
+    Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })),
     Layer.provideMerge(store.layer),
     Layer.provideMerge(Engine),
   )
+  const runtime = ManagedRuntime.make(TestLayer)
+  const view = forceSync(() => runtime.runSync(Q.store))
+  const count = runtime.runSync(Count.store)
 
-  return Effect.gen(function* () {
-    const view = yield* Q.store
-    // The persisted value shows instantly, marked refetching (stale-while-revalidate).
-    expect(view.get()).toMatchObject({ _tag: 'Success', value: 99, refetching: true })
-
-    // The fresh fetch lands and is written through to the store.
-    yield* tick(45)
-    expect(view.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: false })
-    expect(store.map.get('P')).toBe(10)
-  }).pipe(Effect.provide(TestLayer))
+  count.set(2)
+  await runtime.runPromise(tick())
+  expect(view.get()).toMatchObject({ _tag: 'Success', value: 20, refetching: false })
+  cacheByKey.get('P:1')?.resolve(Option.some(99))
+  await runtime.runPromise(tick())
+  expect(view.get()).toMatchObject({ _tag: 'Success', value: 20, refetching: false })
+
+  await runtime.dispose()
+
+  const churnedCache = controlled<Option.Option<unknown>>()
+  const churnedStore = promiseQueryStore(() => churnedCache.promise)
+  const churnedRuntime = ManagedRuntime.make(
+    AsyncCalc.live(Q, {
+      query: () => Effect.never,
+      persist: { key: ({ count }) => `churned:${count}` },
+    }).pipe(
+      Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })),
+      Layer.provideMerge(churnedStore.layer),
+      Layer.provideMerge(Engine),
+    ),
+  )
+  const churnedView = forceSync(() => churnedRuntime.runSync(Q.store))
+  const churnedCount = churnedRuntime.runSync(Count.store)
+  churnedCount.set(2)
+  await churnedRuntime.runPromise(tick())
+  churnedCount.set(1)
+  await churnedRuntime.runPromise(tick())
+  churnedCache.resolve(Option.some(99))
+  await churnedRuntime.runPromise(tick())
+  expect(churnedView.get()).toMatchObject({ _tag: 'Loading' })
+  await churnedRuntime.dispose()
+
+  const erroredCache = controlled<Option.Option<unknown>>()
+  const erroredStore = promiseQueryStore(() => erroredCache.promise)
+  class ErroredQ extends AsyncCalc.make('AsyncPersistErrored', {
+    inputs: [],
+    output: S.Number,
+    error: S.String,
+    alwaysOn: true,
+  }) {}
+  const erroredRuntime = ManagedRuntime.make(
+    AsyncCalc.live(ErroredQ, {
+      query: () => Effect.fail('fresh-error'),
+      persist: true,
+    }).pipe(Layer.provideMerge(erroredStore.layer), Layer.provideMerge(Engine)),
+  )
+  const erroredView = forceSync(() => erroredRuntime.runSync(ErroredQ.store))
+  const queries = erroredRuntime.runSync(Queries)
+  await erroredRuntime.runPromise(tick())
+  expect(erroredView.get()).toMatchObject({ _tag: 'Error', error: 'fresh-error' })
+  erroredCache.resolve(Option.some(99))
+  await erroredRuntime.runPromise(tick())
+  expect(erroredView.get()).toMatchObject({ _tag: 'Error', error: 'fresh-error' })
+  const erroredHandle = queries.byName.get('AsyncPersistErrored')
+  expect(erroredHandle).toBeDefined()
+  if (erroredHandle !== undefined) {
+    expect(Option.isNone(erroredHandle.snapshot().data)).toBe(true)
+  }
+  await erroredRuntime.dispose()
+
+  const corrupt = controlled<Option.Option<unknown>>()
+  const pendingFresh = controlled<number>()
+  const corruptStore = promiseQueryStore(() => corrupt.promise)
+  const corruptRuntime = ManagedRuntime.make(
+    AsyncCalc.live(Q, {
+      query: () => Effect.promise(() => pendingFresh.promise),
+      persist: { key: 'corrupt' },
+    }).pipe(
+      Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })),
+      Layer.provideMerge(corruptStore.layer),
+      Layer.provideMerge(Engine),
+    ),
+  )
+  const corruptView = forceSync(() => corruptRuntime.runSync(Q.store))
+  corrupt.resolve(Option.some('not-a-number'))
+  await corruptRuntime.runPromise(tick())
+  expect(corruptView.get()).toMatchObject({ _tag: 'Loading' })
+  pendingFresh.resolve(7)
+  await corruptRuntime.runPromise(tick())
+  expect(corruptView.get()).toMatchObject({ _tag: 'Success', value: 7, refetching: false })
+  await corruptRuntime.dispose()
+})
+
+it('persist: finalization and gating prevent late or unnecessary hydration', async () => {
+  const cached = controlled<Option.Option<unknown>>()
+  const store = promiseQueryStore(() => cached.promise)
+  class Q extends AsyncCalc.make('FinalizedPersistQ', {
+    inputs: [],
+    output: S.Number,
+    alwaysOn: true,
+  }) {}
+  const runtime = ManagedRuntime.make(
+    AsyncCalc.live(Q, {
+      query: () => Effect.never,
+      persist: true,
+    }).pipe(Layer.provideMerge(store.layer), Layer.provideMerge(Engine)),
+  )
+  const view = forceSync(() => runtime.runSync(Q.store))
+  await runtime.dispose()
+
+  cached.resolve(Option.some(99))
+  await Effect.runPromise(tick())
+  expect(view.get()).toMatchObject({ _tag: 'Loading' })
+  expect(store.map.size).toBe(0)
+
+  const disabledCalls = { gets: 0, runs: 0 }
+  const disabledStore = promiseQueryStore(() => {
+    disabledCalls.gets += 1
+    return Promise.resolve(Option.some(1))
+  })
+  class Enabled extends State.make('disabled-persist-enabled', S.Boolean) {}
+  class DisabledInputs extends StateGroup.make(Enabled) {}
+  class DisabledQ extends AsyncCalc.make('DisabledPersistQ', {
+    inputs: [StateGroup.select(DisabledInputs, 'disabled-persist-enabled')],
+    output: S.Number,
+  }) {}
+  const disabledRuntime = ManagedRuntime.make(
+    AsyncCalc.live(DisabledQ, {
+      query: () => Effect.sync(() => (disabledCalls.runs += 1)),
+      disabled: ({ 'disabled-persist-enabled': enabled }) => !enabled,
+      persist: true,
+    }).pipe(
+      Layer.provideMerge(StateGroup.live(DisabledInputs, { 'disabled-persist-enabled': false })),
+      Layer.provideMerge(disabledStore.layer),
+      Layer.provideMerge(Engine),
+    ),
+  )
+  const disabledView = forceSync(() => disabledRuntime.runSync(DisabledQ.store))
+  const enabled = disabledRuntime.runSync(Enabled.store)
+  await disabledRuntime.runPromise(tick())
+  expect(disabledView.get()).toMatchObject({ _tag: 'Idle' })
+  expect(disabledCalls).toEqual({ gets: 0, runs: 0 })
+
+  enabled.set(true)
+  await disabledRuntime.runPromise(tick())
+  expect(disabledView.get()).toMatchObject({ _tag: 'Success', value: 1 })
+  expect(disabledCalls).toEqual({ gets: 0, runs: 1 })
+  await disabledRuntime.dispose()
+})
+
+it('persist: promise hydration is shared by RemoteState and participates in reuse', async () => {
+  const Item = S.Struct({ id: S.String, name: S.String })
+  type Item = typeof Item.Type
+  const cached = controlled<Option.Option<unknown>>()
+  const fresh = controlled<ReadonlyArray<Item>>()
+  const store = promiseQueryStore(() => cached.promise)
+  class Items extends RemoteState.make('AsyncPersistRemoteItems', {
+    inputs: [],
+    output: S.Array(Item),
+    intents: [],
+    alwaysOn: true,
+  }) {}
+  const runtime = ManagedRuntime.make(
+    RemoteState.live(Items, {
+      query: () => Effect.promise(() => fresh.promise),
+      send: () => Effect.void,
+      apply: (items) => items,
+      persist: true,
+      reuse: true,
+    }).pipe(Layer.provideMerge(store.layer), Layer.provideMerge(Engine)),
+  )
+  const view = forceSync(() => runtime.runSync(Items.store))
+  const cachedItem = { id: 'a', name: 'alpha' }
+  cached.resolve(Option.some([cachedItem]))
+  await runtime.runPromise(tick())
+  const hydrated = view.get()
+  expect(hydrated).toMatchObject({ _tag: 'Success', refetching: true })
+  if (hydrated._tag === 'Success') {
+    fresh.resolve([{ id: 'a', name: 'alpha' }])
+    await runtime.runPromise(tick())
+    const settled = view.get()
+    expect(settled).toMatchObject({ _tag: 'Success', refetching: false })
+    if (settled._tag === 'Success') {
+      expect(settled.value[0]).toBe(hydrated.value[0])
+      expect(store.map.get('AsyncPersistRemoteItems')).toEqual([{ id: 'a', name: 'alpha' }])
+    }
+  }
+  await runtime.dispose()
 })