@playfast/reform 1.2.0 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playfast/reform",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "The renderer-neutral core of the reform framework — typed, headless state, events, reducers, derived values, async/remote data, and compositions built on Effect.",
   "keywords": [
     "effect",

package/src/boundary/boundary.test.ts

@@ -1,16 +1,7 @@
 import { expect, it } from '@effect/vitest'
-import { Data, Duration, Effect, Layer, Schema as S } from 'effect'
+import { Data, Effect, Layer, Schema as S } from 'effect'
 import { AsyncCalc, Boundary, Calc, Engine, Event, State, StateGroup } from '../index'
-
-const tick = (ms = 10) => Effect.sleep(Duration.millis(ms))
-
-const until = <A>(read: () => A, pred: (a: A) => boolean, rounds = 200): Effect.Effect<A> =>
-  Effect.suspend(() => {
-    const a = read()
-    return pred(a) || rounds <= 0
-      ? Effect.succeed(a)
-      : Effect.flatMap(tick(10), () => until(read, pred, rounds - 1))
-  })
+import { makeFlightGate, until } from '../testkit/flight.testkit'
 
 class Boom extends Data.TaggedError('Boom')<{ readonly message: string }> {}
 
@@ -28,20 +19,20 @@ it.live('pending while ANY covered query is on its first load; one Ready when al
     alwaysOn: true,
   }) {}
   class Gate extends Boundary.make('Gate', { over: [Fast, Slow] }) {}
+  // Held before the layer builds so Slow is parked in flight from its very first run.
+  const slowGate = makeFlightGate()
+  Effect.runSync(slowGate.hold)
   const TestLayer = Boundary.live(Gate).pipe(
     Layer.provideMerge(
       Layer.merge(
-        AsyncCalc.live(Fast, {
-          query: ({ seed }) => Effect.succeed(seed).pipe(Effect.delay('10 millis')),
-        }),
-        AsyncCalc.live(Slow, {
-          query: ({ seed }) => Effect.succeed(seed).pipe(Effect.delay('40 millis')),
-        }),
+        AsyncCalc.live(Fast, { query: ({ seed }) => Effect.succeed(seed) }),
+        AsyncCalc.live(Slow, { query: ({ seed }) => slowGate.through(Effect.succeed(seed)) }),
       ),
     ),
     Layer.provideMerge(StateGroup.live(Inputs, { seed: 1 })),
   )
   return Effect.gen(function* () {
+    const fastStore = yield* Fast.store
     const store = yield* Gate.store
     const observed: Array<string> = []
     store.subscribe(() => {
@@ -49,9 +40,14 @@ it.live('pending while ANY covered query is on its first load; one Ready when al
     })
     expect(store.get()._tag).toBe('Pending')
 
-    yield* tick(20)
+    yield* until(
+      () => fastStore.get()._tag,
+      (t) => t === 'Success',
+    )
+    yield* slowGate.awaitEntry(1)
     expect(store.get()._tag).toBe('Pending')
 
+    yield* slowGate.release
     yield* until(
       () => store.get()._tag,
       (t) => t === 'Ready',
@@ -190,16 +186,17 @@ it.live('settle-gap pin: a chained gate never leaks Ready between hops', () => {
     output: S.Number,
   }) {}
   class Gate extends Boundary.make('Gate', { over: [A, B] }) {}
+  const gateA = makeFlightGate()
+  const gateB = makeFlightGate()
+  Effect.runSync(Effect.zipRight(gateA.hold, gateB.hold))
   const TestLayer = Boundary.live(Gate).pipe(
     Layer.provideMerge(
       AsyncCalc.live(B, {
-        query: () => Effect.succeed(2).pipe(Effect.delay('15 millis')),
+        query: () => gateB.through(Effect.succeed(2)),
         disabled: ({ A: a }) => a._tag !== 'Success',
       }),
     ),
-    Layer.provideMerge(
-      AsyncCalc.live(A, { query: () => Effect.succeed(1).pipe(Effect.delay('15 millis')) }),
-    ),
+    Layer.provideMerge(AsyncCalc.live(A, { query: () => gateA.through(Effect.succeed(1)) })),
     Layer.provideMerge(StateGroup.live(Inputs, { seed: 1 })),
   )
   return Effect.gen(function* () {
@@ -210,11 +207,17 @@ it.live('settle-gap pin: a chained gate never leaks Ready between hops', () => {
     })
     expect(store.get()._tag).toBe('Pending')
 
+    yield* gateA.awaitEntry(1)
+    yield* gateA.release
+    // B entering the gate proves A settled and the next hop opened — no Ready may exist in that seam.
+    yield* gateB.awaitEntry(1)
+    expect(store.get()._tag).toBe('Pending')
+
+    yield* gateB.release
     yield* until(
       () => store.get()._tag,
       (t) => t === 'Ready',
     )
-    yield* tick(30)
     expect(observed).toEqual(['Ready'])
   }).pipe(Effect.provide(TestLayer))
 })

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

@@ -1,10 +1,30 @@
 import { expect, it } from '@effect/vitest'
-import { Duration, Effect, Layer, ManagedRuntime, MutableRef, Option, Schema as S } from 'effect'
+import { 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'
+import { makeFlightGate, until } from '../testkit/flight.testkit'
 
-const tick = (ms = 10) => Effect.sleep(Duration.millis(ms))
+// Yielding through a runtime resumes at the tail of its scheduler queue, so work
+// already scheduled there — a hydration continuation, a consumer wake — has run.
+const scheduled: Effect.Effect<void> = Effect.yieldNow()
+
+interface Notifier {
+  readonly subscribe: (listener: () => void) => () => void
+}
+
+// One write notifies every listener in a single scheduler drain, and the driver
+// subscribed before the test did: our own notification proves its trigger ran.
+const afterNotify = (source: Notifier, write: () => void): Effect.Effect<void> =>
+  Effect.suspend(() => {
+    const fired = MutableRef.make(false)
+    const off = source.subscribe(() => MutableRef.set(fired, true))
+    write()
+    return until(
+      () => MutableRef.get(fired),
+      (value) => value,
+    ).pipe(Effect.ensuring(Effect.sync(off)), Effect.asVoid)
+  })
 
 const isStale = (name: string) =>
   Effect.map(Queries, (q) => q.byName.get(name)?.snapshot().isStale ?? false)
@@ -73,16 +93,24 @@ it.live('invalidate marks stale without fetching; a fresh subscriber then refetc
 
   return Effect.gen(function* () {
     const store = yield* Q.store
-    yield* tick()
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    )
     expect(runs.n).toBe(1)
 
+    // A refetch would mark the state fetching inside `invalidate` itself, so the
+    // reader-less mark is observable without waiting for anything.
     yield* AsyncCalc.invalidate(Q)
-    yield* tick()
     expect(yield* isStale('Q')).toBe(true)
+    expect(store.get()).toMatchObject({ _tag: 'Success', refetching: false })
     expect(runs.n).toBe(1)
 
     store.subscribe(() => {})
-    yield* tick()
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success' && v.refetching === false && runs.n > 1,
+    )
     expect(runs.n).toBe(2)
     expect(yield* isStale('Q')).toBe(false)
   }).pipe(Effect.provide(TestLayer))
@@ -97,12 +125,15 @@ it.live('invalidate with an active reader auto-refetches immediately, keeping th
     output: S.Number,
     alwaysOn: true,
   }) {}
+  const gate = makeFlightGate()
   const QLive = AsyncCalc.live(Q, {
     query: ({ count }) =>
-      Effect.sync(() => {
-        runs.n += 1
-        return count
-      }).pipe(Effect.delay(Duration.millis(20))),
+      gate.through(
+        Effect.sync(() => {
+          runs.n += 1
+          return count
+        }),
+      ),
   })
   const TestLayer = QLive.pipe(
     Layer.provideMerge(StateGroup.live(Inputs, { count: 7 })),
@@ -112,15 +143,26 @@ it.live('invalidate with an active reader auto-refetches immediately, keeping th
   return Effect.gen(function* () {
     const store = yield* Q.store
     store.subscribe(() => {})
-    yield* tick(40)
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    )
     expect(store.get()).toMatchObject({ _tag: 'Success', value: 7, refetching: false })
     expect(runs.n).toBe(1)
 
+    // The auto-refetch is parked at the gate, so "kept the value while
+    // refetching" is a stable state rather than a window to catch.
+    yield* gate.hold
     yield* AsyncCalc.invalidate(Q)
-    yield* tick(5)
+    yield* gate.awaitEntry(2)
     expect(store.get()).toMatchObject({ _tag: 'Success', value: 7, refetching: true })
-    yield* tick(40)
-    expect(store.get()).toMatchObject({ _tag: 'Success', value: 7, refetching: false })
+
+    yield* gate.release
+    const settled = yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    )
+    expect(settled).toMatchObject({ _tag: 'Success', value: 7, refetching: false })
     expect(runs.n).toBe(2)
   }).pipe(Effect.provide(TestLayer))
 })
@@ -147,12 +189,19 @@ it.live('refetch forces a run regardless of staleness', () => {
   )
 
   return Effect.gen(function* () {
-    yield* tick()
+    const store = yield* Q.store
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    )
     expect(runs.n).toBe(1)
     expect(yield* isStale('Q')).toBe(false)
 
     yield* AsyncCalc.refetch(Q)
-    yield* tick()
+    yield* until(
+      () => runs.n,
+      (n) => n > 1,
+    )
     expect(runs.n).toBe(2)
   }).pipe(Effect.provide(TestLayer))
 })
@@ -168,8 +217,12 @@ it.live(
       output: S.Number,
       alwaysOn: true,
     }) {}
+    const gate = makeFlightGate()
+    // Armed before the layer builds: the revalidation parks, so the hydrated
+    // (stale) paint is a stable state rather than a window to catch.
+    Effect.runSync(gate.hold)
     const QLive = AsyncCalc.live(Q, {
-      query: ({ count }) => Effect.succeed(count * 2).pipe(Effect.delay(Duration.millis(25))),
+      query: ({ count }) => gate.through(Effect.succeed(count * 2)),
       persist: { key: 'P' },
     })
     const TestLayer = QLive.pipe(
@@ -180,10 +233,19 @@ it.live(
 
     return Effect.gen(function* () {
       const view = yield* Q.store
+      yield* gate.awaitEntry(1)
       expect(view.get()).toMatchObject({ _tag: 'Success', value: 99, refetching: true })
 
-      yield* tick(45)
-      expect(view.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: false })
+      yield* gate.release
+      const settled = yield* until(
+        () => view.get(),
+        (v) => v._tag === 'Success' && v.refetching === false,
+      )
+      expect(settled).toMatchObject({ _tag: 'Success', value: 10, refetching: false })
+      yield* until(
+        () => store.map.get('P'),
+        (persisted) => persisted === 10,
+      )
       expect(store.map.get('P')).toBe(10)
     }).pipe(Effect.provide(TestLayer))
   },
@@ -211,15 +273,32 @@ it('persist: a re-armed watcher does not duplicate the generation covering hydra
 
   const view = forceSync(() => runtime.runSync(Q.store))
   const stop = rearmOnEveryChange(view.subscribe)
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => runs.n,
+      (n) => n > 0,
+    ),
+  )
   expect(runs.n).toBe(1)
 
   cached.resolve(Option.some(99))
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Success',
+    ),
+  )
   expect(view.get()).toMatchObject({ _tag: 'Success', value: 99, refetching: true })
 
+  // A duplicated generation would leave a trailing request pending, so settling
+  // out of `refetching` is what proves the run was covered exactly once.
   fresh.resolve(10)
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    ),
+  )
   expect(runs.n).toBe(1)
   expect(view.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: false })
   stop()
@@ -248,13 +327,28 @@ it('persist: an explicit refetch still trails the generation covering hydration'
 
   const view = forceSync(() => runtime.runSync(CoveredHydrationRefetchQ.store))
   const stop = rearmOnEveryChange(view.subscribe)
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => runs.n,
+      (n) => n > 0,
+    ),
+  )
   cached.resolve(Option.some(99))
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Success',
+    ),
+  )
 
   await runtime.runPromise(AsyncCalc.refetch(CoveredHydrationRefetchQ))
   fresh.resolve(10)
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    ),
+  )
   expect(runs.n).toBe(2)
   expect(view.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: false })
   stop()
@@ -282,18 +376,33 @@ it('invalidate after a requested generation stays uncovered when hydration lands
   const runtime = ManagedRuntime.make(TestLayer)
 
   const view = forceSync(() => runtime.runSync(InFlightInvalidateQ.store))
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => runs.n,
+      (n) => n > 0,
+    ),
+  )
   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())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Success',
+    ),
+  )
   expect(view.get()).toMatchObject({ _tag: 'Success', value: 99, refetching: true })
 
   const stop = rearmOnEveryChange(view.subscribe)
   fresh.resolve(7)
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    ),
+  )
   expect(runs.n).toBe(2)
   expect(view.get()).toMatchObject({ _tag: 'Success', value: 7, refetching: false })
   stop()
@@ -319,14 +428,24 @@ it('a failed refetch leaves its stale mark uncovered, so a fresh subscriber retr
   )
 
   const view = forceSync(() => runtime.runSync(FailedCoverQ.store))
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Success',
+    ),
+  )
   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())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Error',
+    ),
+  )
   expect(runs.n).toBe(2)
   expect(view.get()).toMatchObject({ _tag: 'Error', error: 'boom' })
   expect(await runtime.runPromise(isStale('FailedCoverQ'))).toBe(true)
@@ -334,7 +453,12 @@ it('a failed refetch leaves its stale mark uncovered, so a fresh subscriber retr
   // Nothing successful has covered the mark, so the next subscriber still retries.
   first()
   view.subscribe(() => {})
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    ),
+  )
   expect(runs.n).toBe(3)
   expect(view.get()).toMatchObject({ _tag: 'Success', value: 3, refetching: false })
   await runtime.dispose()
@@ -361,12 +485,22 @@ it('persist: hydration before any request still gets one initial revalidation',
 
   const view = forceSync(() => runtime.runSync(Q.store))
   const stop = rearmOnEveryChange(view.subscribe)
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => runs.n,
+      (n) => n > 0,
+    ),
+  )
   expect(runs.n).toBe(1)
   expect(view.get()).toMatchObject({ _tag: 'Success', value: 99, refetching: true })
 
   fresh.resolve(10)
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    ),
+  )
   expect(runs.n).toBe(1)
   expect(view.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: false })
   stop()
@@ -397,14 +531,24 @@ it('a genuine key change still enqueues a trailing generation', async () => {
 
   const view = forceSync(() => runtime.runSync(Q.store))
   const count = runtime.runSync(Count.store)
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => runs.n,
+      (n) => n > 0,
+    ),
+  )
   expect(runs.n).toBe(1)
 
-  count.set(2)
-  await runtime.runPromise(tick())
+  // The change is enqueued, not run: the first generation still owns the slot.
+  await runtime.runPromise(afterNotify(count, () => count.set(2)))
   expect(runs.n).toBe(1)
   release.resolve()
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Success' && v.value === 2 && v.refetching === false,
+    ),
+  )
   expect(runs.n).toBe(2)
   expect(view.get()).toMatchObject({ _tag: 'Success', value: 2, refetching: false })
   await runtime.dispose()
@@ -431,16 +575,37 @@ it('persist: promise-backed hydration keeps construction synchronous and preserv
 
   const view = forceSync(() => runtime.runSync(Q.store))
   expect(view.get()).toMatchObject({ _tag: 'Loading' })
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => runs.n,
+      (n) => n > 0,
+    ),
+  )
   expect(runs.n).toBe(1)
 
   cached.resolve(Option.some(99))
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Success',
+    ),
+  )
   expect(view.get()).toMatchObject({ _tag: 'Success', value: 99, refetching: true })
 
   fresh.resolve(10)
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    ),
+  )
   expect(view.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: false })
+  await runtime.runPromise(
+    until(
+      () => store.map.get('P'),
+      (persisted) => persisted === 10,
+    ),
+  )
   expect(store.map.get('P')).toBe(10)
   await runtime.dispose()
 })
@@ -472,10 +637,18 @@ it('persist: late or corrupt hydration cannot overwrite fresh truth or a changed
   const count = runtime.runSync(Count.store)
 
   count.set(2)
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Success' && v.value === 20 && v.refetching === false,
+    ),
+  )
   expect(view.get()).toMatchObject({ _tag: 'Success', value: 20, refetching: false })
+  // Awaiting the same promise, then a scheduler round, lands after every
+  // continuation the superseded hydration could still have been holding.
   cacheByKey.get('P:1')?.resolve(Option.some(99))
-  await runtime.runPromise(tick())
+  await cacheByKey.get('P:1')?.promise
+  await runtime.runPromise(scheduled)
   expect(view.get()).toMatchObject({ _tag: 'Success', value: 20, refetching: false })
 
   await runtime.dispose()
@@ -494,12 +667,11 @@ it('persist: late or corrupt hydration cannot overwrite fresh truth or a changed
   )
   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())
+  await churnedRuntime.runPromise(afterNotify(churnedCount, () => churnedCount.set(2)))
+  await churnedRuntime.runPromise(afterNotify(churnedCount, () => churnedCount.set(1)))
   churnedCache.resolve(Option.some(99))
-  await churnedRuntime.runPromise(tick())
+  await churnedCache.promise
+  await churnedRuntime.runPromise(scheduled)
   expect(churnedView.get()).toMatchObject({ _tag: 'Loading' })
   await churnedRuntime.dispose()
 
@@ -519,10 +691,16 @@ it('persist: late or corrupt hydration cannot overwrite fresh truth or a changed
   )
   const erroredView = forceSync(() => erroredRuntime.runSync(ErroredQ.store))
   const queries = erroredRuntime.runSync(Queries)
-  await erroredRuntime.runPromise(tick())
+  await erroredRuntime.runPromise(
+    until(
+      () => erroredView.get(),
+      (v) => v._tag === 'Error',
+    ),
+  )
   expect(erroredView.get()).toMatchObject({ _tag: 'Error', error: 'fresh-error' })
   erroredCache.resolve(Option.some(99))
-  await erroredRuntime.runPromise(tick())
+  await erroredCache.promise
+  await erroredRuntime.runPromise(scheduled)
   expect(erroredView.get()).toMatchObject({ _tag: 'Error', error: 'fresh-error' })
   const erroredHandle = queries.byName.get('AsyncPersistErrored')
   expect(erroredHandle).toBeDefined()
@@ -546,10 +724,16 @@ it('persist: late or corrupt hydration cannot overwrite fresh truth or a changed
   )
   const corruptView = forceSync(() => corruptRuntime.runSync(Q.store))
   corrupt.resolve(Option.some('not-a-number'))
-  await corruptRuntime.runPromise(tick())
+  await corrupt.promise
+  await corruptRuntime.runPromise(scheduled)
   expect(corruptView.get()).toMatchObject({ _tag: 'Loading' })
   pendingFresh.resolve(7)
-  await corruptRuntime.runPromise(tick())
+  await corruptRuntime.runPromise(
+    until(
+      () => corruptView.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    ),
+  )
   expect(corruptView.get()).toMatchObject({ _tag: 'Success', value: 7, refetching: false })
   await corruptRuntime.dispose()
 })
@@ -571,8 +755,11 @@ it('persist: finalization and gating prevent late or unnecessary hydration', asy
   const view = forceSync(() => runtime.runSync(Q.store))
   await runtime.dispose()
 
+  // The scope is closed, so awaiting the cache promise is enough: any surviving
+  // hydration would resume on that same continuation.
   cached.resolve(Option.some(99))
-  await Effect.runPromise(tick())
+  await cached.promise
+  await Effect.runPromise(scheduled)
   expect(view.get()).toMatchObject({ _tag: 'Loading' })
   expect(store.map.size).toBe(0)
 
@@ -600,12 +787,18 @@ it('persist: finalization and gating prevent late or unnecessary hydration', asy
   )
   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 })
 
+  // Enabling is the anchor: once its run has landed, a hydration read during the
+  // disabled window would already have shown up in the counts.
   enabled.set(true)
-  await disabledRuntime.runPromise(tick())
+  await disabledRuntime.runPromise(
+    until(
+      () => disabledView.get(),
+      (v) => v._tag === 'Success',
+    ),
+  )
   expect(disabledView.get()).toMatchObject({ _tag: 'Success', value: 1 })
   expect(disabledCalls).toEqual({ gets: 0, runs: 1 })
   await disabledRuntime.dispose()
@@ -635,12 +828,22 @@ it('persist: promise hydration is shared by RemoteState and participates in reus
   const view = forceSync(() => runtime.runSync(Items.store))
   const cachedItem = { id: 'a', name: 'alpha' }
   cached.resolve(Option.some([cachedItem]))
-  await runtime.runPromise(tick())
+  await runtime.runPromise(
+    until(
+      () => view.get(),
+      (v) => v._tag === 'Success',
+    ),
+  )
   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())
+    await runtime.runPromise(
+      until(
+        () => view.get(),
+        (v) => v._tag === 'Success' && v.refetching === false,
+      ),
+    )
     const settled = view.get()
     expect(settled).toMatchObject({ _tag: 'Success', refetching: false })
     if (settled._tag === 'Success') {