@playfast/reform 1.1.1 → 1.2.1

package/src/calc/asyncCalc.test.ts

@@ -1,19 +1,36 @@
 import { expect, it } from '@effect/vitest'
-import { Data, Duration, Effect, Layer, Schema as S } from 'effect'
-import { AsyncCalc, Engine, Event, State, StateGroup } from '../index'
+import { Data, Effect, Layer, MutableRef, Schema as S } from 'effect'
+import { AsyncCalc, Engine, Event, Reducer, State, StateGroup } from '../index'
+import { makeFlightGate, until } from '../testkit/flight.testkit'
 
-const tick = (ms = 10) => Effect.sleep(Duration.millis(ms))
+class Boom extends Data.TaggedError('Boom')<{ readonly message: string }> {}
 
-const until = <A>(read: () => A, pred: (a: A) => boolean, rounds = 200): Effect.Effect<A> =>
+interface Notifier {
+  readonly subscribe: (listener: () => void) => () => void
+}
+
+// The notification scheduler drains every listener of a write in one pass, and a
+// driver subscribes before the test does: our own notification proves its
+// trigger already ran, so an inert change can be asserted without waiting.
+const afterNotify = <A, E, R>(
+  source: Notifier,
+  write: Effect.Effect<A, E, R>,
+): Effect.Effect<void, E, R> =>
   Effect.suspend(() => {
-    const a = read()
-    return pred(a) || rounds <= 0
-      ? Effect.succeed(a)
-      : Effect.flatMap(tick(10), () => until(read, pred, rounds - 1))
+    const fired = MutableRef.make(false)
+    const off = source.subscribe(() => MutableRef.set(fired, true))
+    return write.pipe(
+      Effect.zipRight(
+        until(
+          () => MutableRef.get(fired),
+          (value) => value,
+        ),
+      ),
+      Effect.ensuring(Effect.sync(off)),
+      Effect.asVoid,
+    )
   })
 
-class Boom extends Data.TaggedError('Boom')<{ readonly message: string }> {}
-
 it.live('runs the query and resolves Loading -> Success', () => {
   class Count extends State.make('count', S.Number) {}
   class Inputs extends StateGroup.make(Count) {}
@@ -22,16 +39,24 @@ it.live('runs the query and resolves Loading -> Success', () => {
     output: S.Number,
     alwaysOn: true,
   }) {}
+  const gate = makeFlightGate()
+  // Armed before the layer builds, so the very first flight parks at the gate.
+  Effect.runSync(gate.hold)
   const DoubledLive = AsyncCalc.live(Doubled, {
-    query: ({ count }) => Effect.succeed(count * 2).pipe(Effect.delay(Duration.millis(20))),
+    query: ({ count }) => gate.through(Effect.succeed(count * 2)),
   })
   const TestLayer = DoubledLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 5 })))
 
   return Effect.gen(function* () {
     const store = yield* Doubled.store
+    yield* gate.awaitEntry(1)
     expect(store.get()._tag).toBe('Loading')
-    yield* tick(40)
-    const value = store.get()
+
+    yield* gate.release
+    const value = yield* until(
+      () => store.get(),
+      (state) => state._tag === 'Success',
+    )
     expect(value._tag).toBe('Success')
     if (value._tag === 'Success') {
       expect(value.value).toBe(10)
@@ -56,8 +81,10 @@ it.live('a failing query resolves to Error carrying the failure', () => {
 
   return Effect.gen(function* () {
     const store = yield* Q.store
-    yield* tick()
-    const value = store.get()
+    const value = yield* until(
+      () => store.get(),
+      (state) => state._tag === 'Error',
+    )
     expect(value._tag).toBe('Error')
     if (value._tag === 'Error') {
       expect(value.error.message).toBe('nope')
@@ -74,23 +101,33 @@ it.live('a dependency change re-fetches, keeping the last value with refetching:
     output: S.Number,
     alwaysOn: true,
   }) {}
+  const gate = makeFlightGate()
   const DoubledLive = AsyncCalc.live(Doubled, {
-    query: ({ count }) => Effect.succeed(count * 2).pipe(Effect.delay(Duration.millis(20))),
+    query: ({ count }) => gate.through(Effect.succeed(count * 2)),
   })
   const TestLayer = DoubledLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 5 })))
 
   return Effect.gen(function* () {
     const source = yield* StateGroup.select(Inputs, 'count').store
     const store = yield* Doubled.store
-    yield* tick(40)
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
     expect(store.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: false })
 
+    // Hold the re-fetch at the gate: the previous value stays visible under it.
+    yield* gate.hold
     source.set(7)
-    yield* tick(5)
+    yield* gate.awaitEntry(2)
     expect(store.get()).toMatchObject({ _tag: 'Success', value: 10, refetching: true })
 
-    yield* tick(40)
-    expect(store.get()).toMatchObject({ _tag: 'Success', value: 14, refetching: false })
+    yield* gate.release
+    const settled = yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    )
+    expect(settled).toMatchObject({ _tag: 'Success', value: 14, refetching: false })
   }).pipe(Effect.provide(TestLayer))
 })
 
@@ -103,24 +140,35 @@ it.live('latest-wins: a rapid second change cancels the in-flight run', () => {
     output: S.Number,
     alwaysOn: true,
   }) {}
+  const gate = makeFlightGate()
   const DoubledLive = AsyncCalc.live(Doubled, {
     query: ({ count }) =>
-      Effect.sync(() => {
-        runs.n += 1
-        return count * 2
-      }).pipe(Effect.delay(Duration.millis(25))),
+      gate.through(
+        Effect.sync(() => {
+          runs.n += 1
+          return count * 2
+        }),
+      ),
   })
   const TestLayer = DoubledLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })))
 
   return Effect.gen(function* () {
     const source = yield* StateGroup.select(Inputs, 'count').store
     const store = yield* Doubled.store
-    yield* tick(40)
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
     expect(store.get()).toMatchObject({ _tag: 'Success', value: 2 })
 
+    // `4` lands while `3` is still parked at the gate, so it can only win by
+    // cancelling it.
+    yield* gate.hold
     source.set(3)
-    yield* tick(5)
+    yield* gate.awaitEntry(2)
     source.set(4)
+    yield* gate.awaitEntry(3)
+    yield* gate.release
     const settled = yield* until(
       () => store.get(),
       (v) => v._tag === 'Success' && v.refetching === false && v.value !== 2,
@@ -136,8 +184,9 @@ it.live('a gated query starts Idle while disabled and runs once enabled', () =>
     inputs: [StateGroup.select(Inputs, 'count')],
     output: S.Number,
   }) {}
+  const gate = makeFlightGate()
   const DoubledLive = AsyncCalc.live(Doubled, {
-    query: ({ count }) => Effect.succeed(count * 2),
+    query: ({ count }) => gate.through(Effect.succeed(count * 2)),
     disabled: ({ count }) => count < 0,
   })
   const TestLayer = DoubledLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: -1 })))
@@ -145,12 +194,16 @@ it.live('a gated query starts Idle while disabled and runs once enabled', () =>
   return Effect.gen(function* () {
     const source = yield* StateGroup.select(Inputs, 'count').store
     const store = yield* Doubled.store
-    yield* tick()
     expect(store.get()._tag).toBe('Idle')
 
     source.set(5)
-    yield* tick()
-    expect(store.get()).toMatchObject({ _tag: 'Success', value: 10 })
+    const settled = yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
+    expect(settled).toMatchObject({ _tag: 'Success', value: 10 })
+    // Exactly one flight ever ran: the disabled window produced none.
+    expect(gate.entered()).toBe(1)
   }).pipe(Effect.provide(TestLayer))
 })
 
@@ -164,12 +217,15 @@ it.live('invalidateBy: an input change outside the key does not re-fetch', () =>
     output: S.Number,
     alwaysOn: true,
   }) {}
+  const gate = makeFlightGate()
   const QLive = AsyncCalc.live(Q, {
     query: ({ page }) =>
-      Effect.sync(() => {
-        runs.n += 1
-        return page
-      }),
+      gate.through(
+        Effect.sync(() => {
+          runs.n += 1
+          return page
+        }),
+      ),
     invalidateBy: ({ page }) => [page],
   })
   const TestLayer = QLive.pipe(
@@ -180,17 +236,27 @@ it.live('invalidateBy: an input change outside the key does not re-fetch', () =>
     const status = yield* StateGroup.select(Inputs, 'status').store
     const page = yield* StateGroup.select(Inputs, 'page').store
     const store = yield* Q.store
-    yield* tick()
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
     expect(runs.n).toBe(1)
 
-    status.set('b')
-    yield* tick()
+    // Holding the gate means any flight the status churn triggered would still
+    // be marked fetching here, and could not have settled back out of view.
+    yield* gate.hold
+    yield* afterNotify(status, Effect.sync(() => status.set('b')))
+    expect(store.get()).toMatchObject({ _tag: 'Success', refetching: false })
     expect(runs.n).toBe(1)
+    yield* gate.release
 
     page.set(2)
-    yield* tick()
+    const settled = yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success' && v.refetching === false && v.value === 2,
+    )
     expect(runs.n).toBe(2)
-    expect(store.get()).toMatchObject({ _tag: 'Success', value: 2 })
+    expect(settled).toMatchObject({ _tag: 'Success', value: 2 })
   }).pipe(Effect.provide(TestLayer))
 })
 
@@ -216,7 +282,10 @@ it.live('reuse: a refetch returning mostly-equal data keeps unchanged element id
   return Effect.gen(function* () {
     const source = yield* StateGroup.select(Inputs, 'page').store
     const store = yield* Rows.store
-    const first = yield* until(() => store.get(), (v) => v._tag === 'Success')
+    const first = yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
     if (first._tag !== 'Success') return
 
     source.set(2)
@@ -231,80 +300,107 @@ it.live('reuse: a refetch returning mostly-equal data keeps unchanged element id
   }).pipe(Effect.provide(TestLayer))
 })
 
-it.live('coalesce trailing: a burst during one flight completes it and runs ONE trailing refetch', () => {
-  class Count extends State.make('count', S.Number) {}
-  class Inputs extends StateGroup.make(Count) {}
-  const completed: number[] = []
-  class Doubled extends AsyncCalc.make('Doubled', {
-    inputs: [StateGroup.select(Inputs, 'count')],
-    output: S.Number,
-    alwaysOn: true,
-  }) {}
-  const DoubledLive = AsyncCalc.live(Doubled, {
-    query: ({ count }) =>
-      Effect.sync(() => {
-        completed.push(count)
-        return count * 2
-      }).pipe(Effect.delay(Duration.millis(25))),
-    coalesce: 'trailing',
-  })
-  const TestLayer = DoubledLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })))
-
-  return Effect.gen(function* () {
-    const source = yield* StateGroup.select(Inputs, 'count').store
-    const store = yield* Doubled.store
-    yield* until(() => store.get(), (v) => v._tag === 'Success')
-    expect(completed).toEqual([1])
-
-    source.set(2)
-    yield* tick(5)
-    source.set(3)
-    yield* tick(5)
-    source.set(4)
-    const settled = yield* until(
-      () => store.get(),
-      (v) => v._tag === 'Success' && v.refetching === false && v.value === 8,
-    )
-    expect(settled).toMatchObject({ _tag: 'Success', value: 8, refetching: false })
-    expect(completed).toEqual([1, 2, 4])
-  }).pipe(Effect.provide(TestLayer))
-})
-
-it.live('coalesce trailing: the stale settle re-flags refetching until the trailing run lands', () => {
-  class Count extends State.make('count', S.Number) {}
-  class Inputs extends StateGroup.make(Count) {}
-  class Doubled extends AsyncCalc.make('Doubled', {
-    inputs: [StateGroup.select(Inputs, 'count')],
-    output: S.Number,
-    alwaysOn: true,
-  }) {}
-  const DoubledLive = AsyncCalc.live(Doubled, {
-    query: ({ count }) => Effect.succeed(count * 2).pipe(Effect.delay(Duration.millis(30))),
-    coalesce: 'trailing',
-  })
-  const TestLayer = DoubledLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })))
-
-  return Effect.gen(function* () {
-    const source = yield* StateGroup.select(Inputs, 'count').store
-    const store = yield* Doubled.store
-    yield* until(() => store.get(), (v) => v._tag === 'Success')
-
-    source.set(2)
-    yield* tick(5)
-    source.set(3)
-    const midflight = yield* until(
-      () => store.get(),
-      (v) => v._tag === 'Success' && v.value === 4,
-    )
-    expect(midflight).toMatchObject({ _tag: 'Success', value: 4, refetching: true })
-
-    const settled = yield* until(
-      () => store.get(),
-      (v) => v._tag === 'Success' && v.refetching === false,
-    )
-    expect(settled).toMatchObject({ _tag: 'Success', value: 6 })
-  }).pipe(Effect.provide(TestLayer))
-})
+it.live(
+  'coalesce trailing: a burst during one flight completes it and runs ONE trailing refetch',
+  () => {
+    class Count extends State.make('count', S.Number) {}
+    class Inputs extends StateGroup.make(Count) {}
+    const completed: number[] = []
+    class Doubled extends AsyncCalc.make('Doubled', {
+      inputs: [StateGroup.select(Inputs, 'count')],
+      output: S.Number,
+      alwaysOn: true,
+    }) {}
+    const gate = makeFlightGate()
+    const DoubledLive = AsyncCalc.live(Doubled, {
+      query: ({ count }) =>
+        gate.through(
+          Effect.sync(() => {
+            completed.push(count)
+            return count * 2
+          }),
+        ),
+      coalesce: 'trailing',
+    })
+    const TestLayer = DoubledLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })))
+
+    return Effect.gen(function* () {
+      const source = yield* StateGroup.select(Inputs, 'count').store
+      const store = yield* Doubled.store
+      yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success',
+      )
+      expect(completed).toEqual([1])
+
+      // Hold the `2` flight at the gate so 3 and 4 land, in that order, while it
+      // is in flight.
+      yield* gate.hold
+      source.set(2)
+      yield* gate.awaitEntry(2)
+      yield* afterNotify(source, Effect.sync(() => source.set(3)))
+      yield* afterNotify(source, Effect.sync(() => source.set(4)))
+      yield* gate.release
+      const settled = yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success' && v.refetching === false && v.value === 8,
+      )
+      expect(settled).toMatchObject({ _tag: 'Success', value: 8, refetching: false })
+      expect(completed).toEqual([1, 2, 4])
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
+
+it.live(
+  'coalesce trailing: the stale settle re-flags refetching until the trailing run lands',
+  () => {
+    class Count extends State.make('count', S.Number) {}
+    class Inputs extends StateGroup.make(Count) {}
+    class Doubled extends AsyncCalc.make('Doubled', {
+      inputs: [StateGroup.select(Inputs, 'count')],
+      output: S.Number,
+      alwaysOn: true,
+    }) {}
+    // Two gates: one parks the flight the burst interrupts, the other parks the
+    // trailing run, so the stale settle in between is a stable state, not a race.
+    const firstGate = makeFlightGate()
+    const trailingGate = makeFlightGate()
+    const DoubledLive = AsyncCalc.live(Doubled, {
+      query: ({ count }) =>
+        count === 3
+          ? trailingGate.through(Effect.succeed(count * 2))
+          : firstGate.through(Effect.succeed(count * 2)),
+      coalesce: 'trailing',
+    })
+    const TestLayer = DoubledLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })))
+
+    return Effect.gen(function* () {
+      const source = yield* StateGroup.select(Inputs, 'count').store
+      const store = yield* Doubled.store
+      yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success',
+      )
+
+      yield* firstGate.hold
+      yield* trailingGate.hold
+      source.set(2)
+      yield* firstGate.awaitEntry(2)
+      yield* afterNotify(source, Effect.sync(() => source.set(3)))
+
+      yield* firstGate.release
+      yield* trailingGate.awaitEntry(1)
+      expect(store.get()).toMatchObject({ _tag: 'Success', value: 4, refetching: true })
+
+      yield* trailingGate.release
+      const settled = yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success' && v.refetching === false,
+      )
+      expect(settled).toMatchObject({ _tag: 'Success', value: 6 })
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
 
 it.live('coalesce trailing: a disable while a request waits in the slot skips the run', () => {
   class Count extends State.make('count', S.Number) {}
@@ -314,12 +410,15 @@ it.live('coalesce trailing: a disable while a request waits in the slot skips th
     inputs: [StateGroup.select(Inputs, 'count')],
     output: S.Number,
   }) {}
+  const gate = makeFlightGate()
   const QLive = AsyncCalc.live(Q, {
     query: ({ count }) =>
-      Effect.sync(() => {
-        completed.push(count)
-        return count * 2
-      }).pipe(Effect.delay(Duration.millis(25))),
+      gate.through(
+        Effect.sync(() => {
+          completed.push(count)
+          return count * 2
+        }),
+      ),
     disabled: ({ count }) => count < 0,
     coalesce: 'trailing',
   })
@@ -328,19 +427,29 @@ it.live('coalesce trailing: a disable while a request waits in the slot skips th
   return Effect.gen(function* () {
     const source = yield* StateGroup.select(Inputs, 'count').store
     const store = yield* Q.store
-    yield* until(() => store.get(), (v) => v._tag === 'Success')
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
 
+    // 3 queues behind the held `2` flight, then the disable overtakes it: the
+    // queued run must be dropped, not executed on release.
+    yield* gate.hold
     source.set(2)
-    yield* tick(5)
-    source.set(3)
-    yield* tick(2)
-    source.set(-1)
-    yield* tick(60)
+    yield* gate.awaitEntry(2)
+    yield* afterNotify(source, Effect.sync(() => source.set(3)))
+    yield* afterNotify(source, Effect.sync(() => source.set(-1)))
+    yield* gate.release
     expect(store.get()._tag).toBe('Idle')
     expect(completed).toEqual([1, 2])
 
+    // The queue is FIFO: once 5 has landed, 3's fate is settled, and it must not
+    // appear between them.
     source.set(5)
-    const settled = yield* until(() => store.get(), (v) => v._tag === 'Success')
+    const settled = yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success',
+    )
     expect(settled).toMatchObject({ _tag: 'Success', value: 10 })
     expect(completed).toEqual([1, 2, 5])
   }).pipe(Effect.provide(TestLayer))
@@ -356,12 +465,15 @@ it.live('invalidateOn: dispatching a listed event re-fetches with refetching: tr
     output: S.Number,
     alwaysOn: true,
   }) {}
+  const gate = makeFlightGate()
   const QLive = AsyncCalc.live(Q, {
     query: ({ count }) =>
-      Effect.sync(() => {
-        runs.n += 1
-        return count * 2
-      }).pipe(Effect.delay(Duration.millis(15))),
+      gate.through(
+        Effect.sync(() => {
+          runs.n += 1
+          return count * 2
+        }),
+      ),
     invalidateOn: [Poke],
   })
   const TestLayer = QLive.pipe(
@@ -371,99 +483,135 @@ it.live('invalidateOn: dispatching a listed event re-fetches with refetching: tr
 
   return Effect.gen(function* () {
     const store = yield* Q.store
-    yield* tick(30)
+    yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    )
     expect(store.get()).toMatchObject({ _tag: 'Success', value: 4, refetching: false })
     expect(runs.n).toBe(1)
 
+    yield* gate.hold
     yield* Event.dispatch(Poke, {})
-    yield* tick(5)
+    yield* gate.awaitEntry(2)
     expect(store.get()).toMatchObject({ _tag: 'Success', value: 4, refetching: true })
-    yield* tick(30)
-    expect(store.get()).toMatchObject({ _tag: 'Success', value: 4, refetching: false })
-    expect(runs.n).toBe(2)
-  }).pipe(Effect.provide(TestLayer))
-})
 
-it.live('invalidateOn: composes with invalidateBy — non-key churn stays inert, the event re-fetches', () => {
-  class Status extends State.make('status', S.String) {}
-  class Page extends State.make('page', S.Number) {}
-  class Inputs extends StateGroup.make(Status, Page) {}
-  class Poke extends Event.make('Poke', S.Struct({})) {}
-  const runs = { n: 0 }
-  class Q extends AsyncCalc.make('Q', {
-    inputs: [StateGroup.select(Inputs, 'status'), StateGroup.select(Inputs, 'page')],
-    output: S.Number,
-    alwaysOn: true,
-  }) {}
-  const QLive = AsyncCalc.live(Q, {
-    query: ({ page }) =>
-      Effect.sync(() => {
-        runs.n += 1
-        return page
-      }),
-    invalidateBy: ({ page }) => [page],
-    invalidateOn: [Poke],
-  })
-  const TestLayer = QLive.pipe(
-    Layer.provideMerge(StateGroup.live(Inputs, { status: 'a', page: 1 })),
-    Layer.provideMerge(Engine),
-  )
-
-  return Effect.gen(function* () {
-    const status = yield* StateGroup.select(Inputs, 'status').store
-    yield* tick()
-    expect(runs.n).toBe(1)
-
-    status.set('b')
-    yield* tick()
-    expect(runs.n).toBe(1)
-
-    yield* Event.dispatch(Poke, {})
-    yield* tick()
+    yield* gate.release
+    const settled = yield* until(
+      () => store.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    )
+    expect(settled).toMatchObject({ _tag: 'Success', value: 4, refetching: false })
     expect(runs.n).toBe(2)
   }).pipe(Effect.provide(TestLayer))
 })
 
-it.live('invalidateOn: a listed event while disabled stays Idle, and enabling re-fetches once', () => {
-  class Count extends State.make('count', S.Number) {}
-  class Inputs extends StateGroup.make(Count) {}
-  class Poke extends Event.make('Poke', S.Struct({})) {}
-  const runs = { n: 0 }
-  class Q extends AsyncCalc.make('Q', {
-    inputs: [StateGroup.select(Inputs, 'count')],
-    output: S.Number,
-  }) {}
-  const QLive = AsyncCalc.live(Q, {
-    query: ({ count }) =>
-      Effect.sync(() => {
-        runs.n += 1
-        return count * 2
-      }),
-    disabled: ({ count }) => count < 0,
-    invalidateOn: [Poke],
-  })
-  const TestLayer = QLive.pipe(
-    Layer.provideMerge(StateGroup.live(Inputs, { count: -1 })),
-    Layer.provideMerge(Engine),
-  )
-
-  return Effect.gen(function* () {
-    const source = yield* StateGroup.select(Inputs, 'count').store
-    const store = yield* Q.store
-    yield* tick()
-    expect(store.get()._tag).toBe('Idle')
+it.live(
+  'invalidateOn: composes with invalidateBy — non-key churn stays inert, the event re-fetches',
+  () => {
+    class Status extends State.make('status', S.String) {}
+    class Page extends State.make('page', S.Number) {}
+    class Inputs extends StateGroup.make(Status, Page) {}
+    class Poke extends Event.make('Poke', S.Struct({})) {}
+    const runs = { n: 0 }
+    class Q extends AsyncCalc.make('Q', {
+      inputs: [StateGroup.select(Inputs, 'status'), StateGroup.select(Inputs, 'page')],
+      output: S.Number,
+      alwaysOn: true,
+    }) {}
+    const gate = makeFlightGate()
+    const QLive = AsyncCalc.live(Q, {
+      query: ({ page }) =>
+        gate.through(
+          Effect.sync(() => {
+            runs.n += 1
+            return page
+          }),
+        ),
+      invalidateBy: ({ page }) => [page],
+      invalidateOn: [Poke],
+    })
+    const TestLayer = QLive.pipe(
+      Layer.provideMerge(StateGroup.live(Inputs, { status: 'a', page: 1 })),
+      Layer.provideMerge(Engine),
+    )
 
-    yield* Event.dispatch(Poke, {})
-    yield* tick()
-    expect(store.get()._tag).toBe('Idle')
-    expect(runs.n).toBe(0)
+    return Effect.gen(function* () {
+      const status = yield* StateGroup.select(Inputs, 'status').store
+      const store = yield* Q.store
+      yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success' && v.refetching === false,
+      )
+      expect(runs.n).toBe(1)
+
+      yield* gate.hold
+      yield* afterNotify(status, Effect.sync(() => status.set('b')))
+      expect(store.get()).toMatchObject({ _tag: 'Success', refetching: false })
+      expect(runs.n).toBe(1)
+      yield* gate.release
+
+      yield* Event.dispatch(Poke, {})
+      yield* gate.awaitEntry(2)
+      expect(runs.n).toBe(2)
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
+
+it.live(
+  'invalidateOn: a listed event while disabled stays Idle, and enabling re-fetches once',
+  () => {
+    class Count extends State.make('count', S.Number) {}
+    class Inputs extends StateGroup.make(Count) {}
+    class Poke extends Event.make('Poke', S.Struct({})) {}
+    // A second reducer on the same event: reducers of one frame apply in a single
+    // pass, so this state landing proves the query's revision write landed too.
+    class Pokes extends State.make('pokes', S.Number) {}
+    const PokesReducer = Reducer.make('pokes', { states: [Pokes], events: [Poke] })
+    const runs = { n: 0 }
+    class Q extends AsyncCalc.make('Q', {
+      inputs: [StateGroup.select(Inputs, 'count')],
+      output: S.Number,
+    }) {}
+    const QLive = AsyncCalc.live(Q, {
+      query: ({ count }) =>
+        Effect.sync(() => {
+          runs.n += 1
+          return count * 2
+        }),
+      disabled: ({ count }) => count < 0,
+      invalidateOn: [Poke],
+    })
+    const TestLayer = Layer.mergeAll(
+      QLive,
+      Reducer.live(PokesReducer, (seen) => seen + 1),
+    ).pipe(
+      Layer.provideMerge(StateGroup.live(Inputs, { count: -1 })),
+      Layer.provideMerge(State.live(Pokes, 0)),
+      Layer.provideMerge(Engine),
+    )
 
-    source.set(5)
-    yield* tick()
-    expect(store.get()).toMatchObject({ _tag: 'Success', value: 10 })
-    expect(runs.n).toBe(1)
-  }).pipe(Effect.provide(TestLayer))
-})
+    return Effect.gen(function* () {
+      const source = yield* StateGroup.select(Inputs, 'count').store
+      const pokes = yield* Pokes.store
+      const store = yield* Q.store
+      expect(store.get()._tag).toBe('Idle')
+
+      // An enqueued run marks the state fetching before it can run, so staying
+      // Idle across the frame is proof that nothing was enqueued.
+      yield* afterNotify(pokes, Event.dispatch(Poke, {}))
+      expect(store.get()._tag).toBe('Idle')
+      expect(runs.n).toBe(0)
+
+      source.set(5)
+      const settled = yield* until(
+        () => store.get(),
+        (v) => v._tag === 'Success',
+      )
+      expect(settled).toMatchObject({ _tag: 'Success', value: 10 })
+      expect(runs.n).toBe(1)
+    }).pipe(Effect.provide(TestLayer))
+  },
+)
 
 it.live('invalidateOn: two async calcs keep independent hidden revisions', () => {
   class Count extends State.make('count', S.Number) {}
@@ -481,38 +629,62 @@ it.live('invalidateOn: two async calcs keep independent hidden revisions', () =>
     output: S.Number,
     alwaysOn: true,
   }) {}
+  const gateA = makeFlightGate()
+  const gateB = makeFlightGate()
   const TestLayer = Layer.mergeAll(
     AsyncCalc.live(QA, {
       query: ({ count }) =>
-        Effect.sync(() => {
-          runs.a += 1
-          return count
-        }),
+        gateA.through(
+          Effect.sync(() => {
+            runs.a += 1
+            return count
+          }),
+        ),
       invalidateOn: [PokeA],
     }),
     AsyncCalc.live(QB, {
       query: ({ count }) =>
-        Effect.sync(() => {
-          runs.b += 1
-          return count
-        }),
+        gateB.through(
+          Effect.sync(() => {
+            runs.b += 1
+            return count
+          }),
+        ),
       invalidateOn: [PokeB],
     }),
-  ).pipe(
-    Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })),
-    Layer.provideMerge(Engine),
-  )
+  ).pipe(Layer.provideMerge(StateGroup.live(Inputs, { count: 1 })), Layer.provideMerge(Engine))
 
   return Effect.gen(function* () {
-    yield* tick()
+    const storeA = yield* QA.store
+    const storeB = yield* QB.store
+    yield* until(
+      () => storeA.get()._tag === 'Success' && storeB.get()._tag === 'Success',
+      (both) => both,
+    )
     expect(runs).toEqual({ a: 1, b: 1 })
 
+    // B's gate is held, so a revision leak from PokeA would leave B visibly
+    // fetching instead of settling back out of sight.
+    yield* gateB.hold
     yield* Event.dispatch(PokeA, {})
-    yield* tick()
+    yield* gateA.awaitEntry(2)
+    yield* until(
+      () => storeA.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    )
+    expect(storeB.get()).toMatchObject({ _tag: 'Success', refetching: false })
     expect(runs).toEqual({ a: 2, b: 1 })
+    yield* gateB.release
 
+    yield* gateA.hold
     yield* Event.dispatch(PokeB, {})
-    yield* tick()
+    yield* gateB.awaitEntry(2)
+    yield* until(
+      () => storeB.get(),
+      (v) => v._tag === 'Success' && v.refetching === false,
+    )
+    expect(storeA.get()).toMatchObject({ _tag: 'Success', refetching: false })
     expect(runs).toEqual({ a: 2, b: 2 })
+    yield* gateA.release
   }).pipe(Effect.provide(TestLayer))
 })