@playfast/reform 1.1.1 → 1.2.1

package/src/internal/errors.ts

@@ -4,7 +4,9 @@ type TaggedErrorClass<Tag extends string, A extends Record<string, unknown>> = n
   args: A,
 ) => Cause.YieldableError & { readonly _tag: Tag } & Readonly<A>
 
-type EmptyTaggedErrorClass<Tag extends string> = new () => Cause.YieldableError & { readonly _tag: Tag }
+type EmptyTaggedErrorClass<Tag extends string> = new () => Cause.YieldableError & {
+  readonly _tag: Tag
+}
 
 const InvalidProvideTargetBase: EmptyTaggedErrorClass<'reform/InvalidProvideTarget'> =
   Data.TaggedError('reform/InvalidProvideTarget')<{}>
@@ -15,8 +17,10 @@ export class InvalidProvideTarget extends InvalidProvideTargetBase {
   }
 }
 
-const UnknownGroupStateBase: TaggedErrorClass<'reform/UnknownGroupState', { readonly name: string }> =
-  Data.TaggedError('reform/UnknownGroupState')<{ readonly name: string }>
+const UnknownGroupStateBase: TaggedErrorClass<
+  'reform/UnknownGroupState',
+  { readonly name: string }
+> = Data.TaggedError('reform/UnknownGroupState')<{ readonly name: string }>
 
 export class UnknownGroupState extends UnknownGroupStateBase {
   override get message(): string {
@@ -24,8 +28,10 @@ export class UnknownGroupState extends UnknownGroupStateBase {
   }
 }
 
-const FeatureLoadFailedBase: TaggedErrorClass<'reform/FeatureLoadFailed', { readonly cause: unknown }> =
-  Data.TaggedError('reform/FeatureLoadFailed')<{ readonly cause: unknown }>
+const FeatureLoadFailedBase: TaggedErrorClass<
+  'reform/FeatureLoadFailed',
+  { readonly cause: unknown }
+> = Data.TaggedError('reform/FeatureLoadFailed')<{ readonly cause: unknown }>
 
 export class FeatureLoadFailed extends FeatureLoadFailedBase {
   override get message(): string {
@@ -33,8 +39,9 @@ export class FeatureLoadFailed extends FeatureLoadFailedBase {
   }
 }
 
-const AsyncReducerBase: EmptyTaggedErrorClass<'reform/AsyncReducer'> =
-  Data.TaggedError('reform/AsyncReducer')<{}>
+const AsyncReducerBase: EmptyTaggedErrorClass<'reform/AsyncReducer'> = Data.TaggedError(
+  'reform/AsyncReducer',
+)<{}>
 
 export class AsyncReducer extends AsyncReducerBase {
   override get message(): string {
@@ -42,8 +49,9 @@ export class AsyncReducer extends AsyncReducerBase {
   }
 }
 
-const AsyncSceneLayerBase: EmptyTaggedErrorClass<'reform/AsyncSceneLayer'> =
-  Data.TaggedError('reform/AsyncSceneLayer')<{}>
+const AsyncSceneLayerBase: EmptyTaggedErrorClass<'reform/AsyncSceneLayer'> = Data.TaggedError(
+  'reform/AsyncSceneLayer',
+)<{}>
 
 export class AsyncSceneLayer extends AsyncSceneLayerBase {
   override get message(): string {
@@ -81,7 +89,10 @@ export const forceSync = <A>(thunk: () => A): A => {
 const DuplicateRegistrationBase: TaggedErrorClass<
   'reform/DuplicateRegistration',
   { readonly kind: string; readonly name: string }
-> = Data.TaggedError('reform/DuplicateRegistration')<{ readonly kind: string; readonly name: string }>
+> = Data.TaggedError('reform/DuplicateRegistration')<{
+  readonly kind: string
+  readonly name: string
+}>
 
 export class DuplicateRegistration extends DuplicateRegistrationBase {
   override get message(): string {

package/src/internal/queryDriver.ts

@@ -1,35 +1,20 @@
-import {
-  Cause,
-  Chunk,
-  Effect,
-  MutableRef,
-  Option,
-  Queue,
-  type Scope,
-  Stream,
-} from 'effect'
+import { Cause, Chunk, Effect, MutableRef, Option, Queue, Runtime, type Scope, Stream } from 'effect'
 import { empty, type QueryState } from '../calc/queryState'
 import { Queries, type QueryHandle } from '../runtime/queries'
 import { reuse } from './reuse'
 import { resolveInstrumentation } from '../runtime/instrumentation'
 import { resolveQueryStore } from './queryStore'
-import type { QueryDriver, QueryDriverOptions } from './queryDriverTypes'
+import { hydratePersistedQuery } from './queryDriverHydrate'
 import {
-  hydrateQuery,
   incrementGeneration,
-  makePersistWriter,
   makeQueryProjection,
   subscribeQuerySources,
   settleQueryError,
   withReaderTracking,
 } from './queryDriverStore'
+import type { QueryDriver, QueryDriverOptions } from './queryDriverTypes'
 import { resolveScheduler } from './scheduler'
-import {
-  type InputsObject,
-  type InputStores,
-  sameKey,
-  wireSources,
-} from './sources'
+import { type InputsObject, type InputStores, sameKey, wireSources } from './sources'
 import { makeStore } from './store'
 import { type AnySource } from '../state/token'
 
@@ -37,6 +22,7 @@ export {
   bumpRevision,
   gatedFlag,
   type GatedOf,
+  type QueryCodec,
   type QueryDriver,
   type QueryDriverOptions,
   Revision,
@@ -58,6 +44,10 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
 
     const keyOf = (args: InputsObject<Inputs>): ReadonlyArray<unknown> =>
       extraKey === undefined ? sources.keyOf(args) : [...sources.keyOf(args), extraKey.read()]
+    const persistKey = (
+      key: string | ((inputs: InputsObject<Inputs>) => string),
+      args: InputsObject<Inputs>,
+    ): string => (typeof key === 'function' ? key(args) : key)
     const disabledNow = (args: InputsObject<Inputs> = sources.snapshot()): boolean =>
       options.gated && options.disabled !== undefined ? options.disabled(args) : false
 
@@ -67,8 +57,17 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
     const readers = MutableRef.make(0)
 
     const lastKey = MutableRef.make<ReadonlyArray<unknown> | undefined>(undefined)
+    // Monotonic source epoch for the one startup hydration attempt. Comparing
+    // only the current key is insufficient: A → B → A would otherwise let the
+    // original A cache land over the later A request. Same-key refetches do not
+    // move this epoch, so cache may still paint during an in-flight revalidation.
+    const sourceEpoch = MutableRef.make(0)
     const generation = MutableRef.make(0)
     const nextGeneration = (): number => incrementGeneration(generation)
+    // A stale cause needs a strictly newer requested generation. Hydration
+    // captures this before the startup kick, while invalidation captures it when
+    // the value is marked stale.
+    const staleAtGeneration = MutableRef.make(0)
     const markFetching = () => {
       const state = stateStore.get()
       if (!state.isFetching) {
@@ -89,7 +88,24 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
       })
       return shared
     }
-    const persistWrite = makePersistWriter<Inputs, A>({ persist, queryStore })
+    const settleError = (error: E, failedGeneration: number) => {
+      // Preserve the stale cause after failure without duplicating a newer request.
+      MutableRef.update(staleAtGeneration, (current) => Math.max(current, failedGeneration))
+      settleQueryError(stateStore, error)
+    }
+
+    const persistWriteTo = (
+      target: NonNullable<typeof persist>,
+      produced: A,
+      args: InputsObject<Inputs>,
+    ): Effect.Effect<void> =>
+      target.codec.encode(produced).pipe(
+        Effect.flatMap((encoded) => queryStore.set(persistKey(target.key, args), encoded)),
+        // Persistence is best-effort and must not block the visible write.
+        Effect.ignore,
+      )
+    const persistWrite = (produced: A, args: InputsObject<Inputs>): Effect.Effect<void> =>
+      persist === undefined ? Effect.void : persistWriteTo(persist, produced, args)
 
     const derived = makeQueryProjection({ gated: options.gated, scheduler, stateStore })
     yield* Effect.addFinalizer(() => Effect.sync(derived.unsubscribe))
@@ -123,7 +139,7 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
           onFailure: (cause): Option.Option<A> => {
             const failure = Cause.failureOption(cause)
             if (Option.isSome(failure) && !disabledNow()) {
-              settleQueryError(stateStore, failure.value)
+              settleError(failure.value, request.generation)
             }
             return Option.none()
           },
@@ -161,6 +177,9 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
     const enqueue = (force: boolean) => {
       const args = sources.snapshot()
       if (disabledNow(args)) {
+        if (MutableRef.get(lastKey) !== undefined) {
+          MutableRef.update(sourceEpoch, (current) => current + 1)
+        }
         MutableRef.set(lastKey, undefined)
         stateStore.set(idle)
         return
@@ -170,6 +189,9 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
       if (!force && previous !== undefined && sameKey(key, previous)) {
         return
       }
+      if (previous !== undefined && !sameKey(key, previous)) {
+        MutableRef.update(sourceEpoch, (current) => current + 1)
+      }
       MutableRef.set(lastKey, key)
       markFetching()
       Queue.unsafeOffer(requests, { args, generation: nextGeneration() })
@@ -178,7 +200,8 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
     const refetch = () => enqueue(true)
 
     const maybeAutoRefetch = () => {
-      if (stateStore.get().isStale && MutableRef.get(readers) > 0) {
+      const hasCoveringRequest = MutableRef.get(generation) > MutableRef.get(staleAtGeneration)
+      if (stateStore.get().isStale && MutableRef.get(readers) > 0 && !hasCoveringRequest) {
         refetch()
       }
     }
@@ -187,6 +210,7 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
       if (state.isStale) {
         return
       }
+      MutableRef.set(staleAtGeneration, MutableRef.get(generation))
       stateStore.set({ ...state, isStale: true })
       maybeAutoRefetch()
     }
@@ -194,14 +218,26 @@ export const makeQueryDriver = <Inputs extends ReadonlyArray<AnySource>, A, E, R
     const unsubscribe = subscribeQuerySources(sources, extraKey, trigger)
     yield* Effect.addFinalizer(() => Effect.sync(unsubscribe))
 
+    // Fork hydration so an asynchronous store never blocks layer acquisition.
     if (persist !== undefined && !disabledNow()) {
       const hydrateArgs = sources.snapshot()
-      yield* hydrateQuery({
-        cacheKey: typeof persist.key === 'function' ? persist.key(hydrateArgs) : persist.key,
+      const hydrateSourceKey = keyOf(hydrateArgs)
+      const hydrateSourceEpoch = MutableRef.get(sourceEpoch)
+      const hydrate = hydratePersistedQuery({
         queryStore,
-        schema: persist.schema,
+        cacheKey: persistKey(persist.key, hydrateArgs),
+        codec: persist.codec,
         stateStore,
+        staleAtGeneration,
+        capturedGeneration: MutableRef.get(generation),
+        isSuperseded: () =>
+          disabledNow() ||
+          hydrateSourceEpoch !== MutableRef.get(sourceEpoch) ||
+          !sameKey(hydrateSourceKey, keyOf(sources.snapshot())),
       })
+      const runtime = yield* Effect.runtime<never>()
+      const scope = yield* Effect.scope
+      Runtime.runFork(runtime)(hydrate, { immediate: true, scope })
     }
 
     const initial = sources.snapshot()

package/src/internal/queryDriverHydrate.ts

@@ -0,0 +1,45 @@
+import { Effect, MutableRef, Option } from 'effect'
+import type { QueryState } from '../calc/queryState'
+import type { QueryStoreApi } from './queryStore'
+import type { QueryCodec } from './queryDriverTypes'
+import type { Store } from './store'
+
+interface HydratePersistedOptions<A, E> {
+  readonly queryStore: QueryStoreApi
+  readonly cacheKey: string
+  readonly codec: QueryCodec<A>
+  readonly stateStore: Store<QueryState<A, E>>
+  readonly staleAtGeneration: MutableRef.MutableRef<number>
+  readonly capturedGeneration: number
+  // True once the sources moved past the snapshot this hydration was captured for.
+  readonly isSuperseded: () => boolean
+}
+
+const paint = <A, E>(options: HydratePersistedOptions<A, E>, decoded: A): void => {
+  const state = options.stateStore.get()
+  if (options.isSuperseded() || Option.isSome(state.data) || Option.isSome(state.error)) {
+    return
+  }
+  MutableRef.update(options.staleAtGeneration, (current) =>
+    Math.max(current, options.capturedGeneration),
+  )
+  options.stateStore.set({ ...state, data: Option.some(decoded), isStale: true })
+}
+
+// Epoch, key, and settled-state guards prevent a late cache from replacing newer truth.
+export const hydratePersistedQuery = <A, E>(
+  options: HydratePersistedOptions<A, E>,
+): Effect.Effect<void> =>
+  options.queryStore.get(options.cacheKey).pipe(
+    Effect.flatMap((cached) =>
+      Option.match(cached, {
+        onNone: () => Effect.void,
+        onSome: (raw) =>
+          options.codec
+            .decode(raw)
+            .pipe(Effect.tap((decoded) => Effect.sync(() => paint(options, decoded)))),
+      }),
+    ),
+    // Corrupt/incompatible cache: ignore and fetch fresh.
+    Effect.ignore,
+  )

package/src/internal/queryDriverStore.ts

@@ -15,9 +15,7 @@ interface HydrateQueryOptions<A, E> {
   readonly stateStore: Store<QueryState<A, E>>
 }
 
-export const hydrateQuery = <A, E>(
-  options: HydrateQueryOptions<A, E>,
-): Effect.Effect<void> =>
+export const hydrateQuery = <A, E>(options: HydrateQueryOptions<A, E>): Effect.Effect<void> =>
   Effect.flatMap(options.queryStore.get(options.cacheKey), (cached) =>
     Option.match(cached, {
       onNone: () => Effect.void,
@@ -52,7 +50,10 @@ export const persistQueryValue = <A>(options: PersistQueryValueOptions<A>): Effe
 
 interface PersistWriterOptions<Inputs extends ReadonlyArray<AnySource>, A> {
   readonly persist:
-    | { readonly key: string | ((inputs: InputsObject<Inputs>) => string); readonly schema: AnySchema<A> }
+    | {
+        readonly key: string | ((inputs: InputsObject<Inputs>) => string)
+        readonly schema: AnySchema<A>
+      }
     | undefined
   readonly queryStore: QueryStoreApi
 }
@@ -136,7 +137,9 @@ interface ReaderStoreOptions<A, E> {
   readonly onFirstReader: () => void
 }
 
-export const withReaderTracking = <A, E>(options: ReaderStoreOptions<A, E>): Store<AnyAsyncData<A, E>> => ({
+export const withReaderTracking = <A, E>(
+  options: ReaderStoreOptions<A, E>,
+): Store<AnyAsyncData<A, E>> => ({
   ...options.store,
   subscribe: (listener) => {
     const before = MutableRef.get(options.readers)

package/src/internal/queryDriverTypes.ts

@@ -1,13 +1,14 @@
-import { Brand, Effect, Schema } from 'effect'
+import { Brand, Effect, type ParseResult, Schema } from 'effect'
 import type { AnyAsyncData } from '../calc/asyncData'
 import type { InputsObject, InvalidateBy } from './sources'
 import type { Store } from './store'
 import type { AnySource } from '../state/token'
-import type { AnySchema } from './variance'
 
 export type GatedOf<AlwaysOn extends boolean> = AlwaysOn extends true ? false : true
 
-export const gatedFlag = <AlwaysOn extends boolean>(alwaysOn: AlwaysOn | undefined): GatedOf<AlwaysOn> =>
+export const gatedFlag = <AlwaysOn extends boolean>(
+  alwaysOn: AlwaysOn | undefined,
+): GatedOf<AlwaysOn> =>
   // oxlint-disable-next-line reform-rules/no-type-assertion -- restate the runtime boolean as its conditional `GatedOf` literal; no guard maps a boolean to a conditional type
   (alwaysOn !== true) as GatedOf<AlwaysOn>
 
@@ -19,35 +20,34 @@ export const RevisionSchema: Schema.Schema<Revision, number> = Schema.Number.pip
 export const revisionZero: Revision = Revision(0)
 export const bumpRevision = (revision: Revision): Revision => Revision(revision + 1)
 
+// Keep schema invariance behind a covariant persistence boundary.
+export interface QueryCodec<A> {
+  readonly encode: (value: A) => Effect.Effect<unknown, ParseResult.ParseError, never>
+  readonly decode: (input: unknown) => Effect.Effect<A, ParseResult.ParseError, never>
+}
+
 export interface QueryDriverOptions<Inputs extends ReadonlyArray<AnySource>, A, E, R> {
   readonly name: string
   readonly label: string
   readonly gated: boolean
   readonly inputs: Inputs
   readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly invalidateBy?: InvalidateBy<Inputs> | undefined
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly disabled?: ((inputs: InputsObject<Inputs>) => boolean) | undefined
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly coalesce?: 'switch' | 'trailing' | undefined
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly reuse?: boolean | undefined
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly extraKey?:
     | {
         readonly read: () => unknown
         readonly subscribe: (listener: () => void) => () => void
       }
     | undefined
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly persist?:
     | {
         readonly key: string | ((inputs: InputsObject<Inputs>) => string)
-        readonly schema: AnySchema<A>
+        readonly codec: QueryCodec<A>
       }
     | undefined
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- caller-omitted option built at the asyncCalc/remoteState construction site; Option<T> would change that call shape
   readonly onSettled?: ((generation: number) => void) | undefined
 }
 

package/src/internal/reuse.test.ts

@@ -13,7 +13,10 @@ describe('reuse', () => {
     const e0 = { id: 1, name: 'a' }
     const e1 = { id: 2, name: 'b' }
     const prev = [e0, e1]
-    const next = [{ id: 1, name: 'a' }, { id: 2, name: 'B' }]
+    const next = [
+      { id: 1, name: 'a' },
+      { id: 2, name: 'B' },
+    ]
     const out = reuse(prev, next)
     expect(out).not.toBe(prev)
     expect(out[0]).toBe(e0)
@@ -49,7 +52,10 @@ describe('reuse', () => {
     class View extends S.Class<View>('View')({ title: S.String, rows: S.Array(Row) }) {}
     const keep = new Row({ id: 1, name: 'a' })
     const prev = new View({ title: 't', rows: [keep, new Row({ id: 2, name: 'b' })] })
-    const next = new View({ title: 't', rows: [new Row({ id: 1, name: 'a' }), new Row({ id: 2, name: 'B' })] })
+    const next = new View({
+      title: 't',
+      rows: [new Row({ id: 1, name: 'a' }), new Row({ id: 2, name: 'B' })],
+    })
     const out = reuse(prev, next)
     expect(out).not.toBe(prev)
     expect(out).toBeInstanceOf(View)
@@ -77,7 +83,8 @@ describe('reuse', () => {
 
   it('returns next below the depth bound', () => {
     type Nest = { readonly n?: Nest; readonly v: number }
-    const deep = (depth: number): Nest => (depth === 0 ? { v: 0 } : { v: depth, n: deep(depth - 1) })
+    const deep = (depth: number): Nest =>
+      depth === 0 ? { v: 0 } : { v: depth, n: deep(depth - 1) }
     const prev = deep(20)
     const next = deep(20)
     const out = reuse(prev, next)

package/src/internal/reuse.ts

@@ -54,10 +54,13 @@ const reconcile = ({ prev, next, depth }: ReconcileArgs): unknown => {
   }
   if (Array.isArray(prev) && Array.isArray(next)) {
     const reconciled = next.map((element, index) =>
-      index < prev.length ? reconcile({ prev: prev[index], next: element, depth: depth - 1 }) : element,
+      index < prev.length
+        ? reconcile({ prev: prev[index], next: element, depth: depth - 1 })
+        : element,
     )
     const unchanged =
-      prev.length === next.length && reconciled.every((entry, index) => Object.is(entry, prev[index]))
+      prev.length === next.length &&
+      reconciled.every((entry, index) => Object.is(entry, prev[index]))
     return unchanged ? prev : reconciled
   }
   if (isPlainRecord(prev) && isPlainRecord(next)) {

package/src/internal/scheduler.ts

@@ -54,7 +54,10 @@ const NotificationsBase: Context.TagClass<Notifications, 'reform/Notifications',
   Context.Tag('reform/Notifications')<Notifications, Scheduler>()
 export class Notifications extends NotificationsBase {}
 
-export const notificationsLayer: Layer.Layer<Notifications> = Layer.sync(Notifications, makeScheduler)
+export const notificationsLayer: Layer.Layer<Notifications> = Layer.sync(
+  Notifications,
+  makeScheduler,
+)
 
 export const resolveScheduler: Effect.Effect<Scheduler> = Effect.map(
   Effect.serviceOption(Notifications),

package/src/internal/sources.ts

@@ -1,15 +1,20 @@
-import { type Context, Effect, Equal, Predicate } from 'effect'
-import { type AnySource, type SourceName, type SourceValue } from '../state/token'
-import { type Store } from './store'
-import type { AnyValue } from './variance'
+import { Context, Effect, Equal, Predicate } from 'effect'
+import {
+  type AnySource,
+  type SourceIdentifier,
+  type SourceName,
+  type SourceValue,
+} from '../state/token'
 
 export type InputsObject<Inputs extends ReadonlyArray<AnySource>> = {
   readonly [S in Inputs[number] as SourceName<S>]: SourceValue<S>
 }
 
 export type StoresOf<Items extends ReadonlyArray<unknown>> = {
-  [I in keyof Items]: Items[I] extends { readonly store: Context.Tag<infer Svc, AnyValue> }
-    ? Svc
+  [I in keyof Items]: Items[I] extends {
+    readonly store: Context.Tag<infer Service, infer _Store>
+  }
+    ? Service
     : never
 }[number]
 
@@ -26,8 +31,20 @@ const inputKey = (input: AnySource): string =>
     ? input.manifest['name']
     : input.name
 
+// Capture an invariant source tag through a covariant read-only surface.
+interface ReadableStore<out A> {
+  readonly getSnapshot: () => A
+  readonly subscribe: (listener: () => void) => () => void
+}
+
+const readStore = <Source extends AnySource>(
+  source: Source,
+): Effect.Effect<ReadableStore<SourceValue<Source>>, never, SourceIdentifier<Source>> =>
+  Context.GenericTag<SourceIdentifier<Source>, ReadableStore<SourceValue<Source>>>(source.store.key)
+
 export const sameKey = (left: ReadonlyArray<unknown>, right: ReadonlyArray<unknown>): boolean =>
-  left.length === right.length && left.every((element, index) => Equal.equals(element, right[index]))
+  left.length === right.length &&
+  left.every((element, index) => Equal.equals(element, right[index]))
 
 export interface WiredSources<Inputs extends ReadonlyArray<AnySource>> {
   readonly snapshot: () => InputsObject<Inputs>
@@ -41,10 +58,7 @@ export const wireSources = <Inputs extends ReadonlyArray<AnySource>>(
 ): Effect.Effect<WiredSources<Inputs>, never, InputStores<Inputs>> =>
   // oxlint-disable-next-line reform-rules/no-type-assertion -- restate the precise InputStores<Inputs> union the signature promises; Effect.forEach over a heterogeneous tuple widens R (the single seam this cast lives at)
   Effect.gen(function* () {
-    const sources: ReadonlyArray<Store<unknown>> = yield* Effect.forEach(
-      inputs,
-      (input) => input.store,
-    )
+    const sources = yield* Effect.forEach(inputs, readStore)
 
     const snapshot = (): InputsObject<Inputs> => {
       const args: Record<string, unknown> = {}

package/src/internal/store.test.ts

@@ -1,7 +1,14 @@
 import { expect, test } from 'vitest'
 import { makeStore } from './store'
 
-const tick = () => new Promise<void>((resolve) => queueMicrotask(resolve))
+// Notifications land on the microtask queue — poll turns of it, never wall-clock.
+const until = async (predicate: () => boolean, rounds = 1000): Promise<void> => {
+  if (predicate() || rounds <= 0) {
+    return
+  }
+  await new Promise<void>((resolve) => queueMicrotask(resolve))
+  return until(predicate, rounds - 1)
+}
 
 const counter = () => ({ n: 0 })
 
@@ -14,19 +21,26 @@ test('subscribe observes changes; getSnapshot is always current', async () => {
 
   store.set(1)
   expect(store.getSnapshot()).toBe(1)
-  await tick()
+  await until(() => notifications.n > 0)
   expect(notifications.n).toBe(1)
 })
 
 test('a no-op write notifies no one', async () => {
   const store = makeStore('same')
+  const witness = makeStore(0)
   const notifications = counter()
+  const witnessWakes = counter()
   store.subscribe(() => {
     notifications.n++
   })
+  witness.subscribe(() => {
+    witnessWakes.n++
+  })
 
   store.set('same')
-  await tick()
+  // Both stores share the scheduler, so the witness flush drains anything the no-op could have queued.
+  witness.set(1)
+  await until(() => witnessWakes.n > 0)
   expect(notifications.n).toBe(0)
   expect(store.getSnapshot()).toBe('same')
 })
@@ -42,7 +56,8 @@ test('a batch of writes coalesces into a single notification per microtask', asy
   store.set(2)
   store.set(3)
   expect(store.getSnapshot()).toBe(3)
-  await tick()
+  // The drain is synchronous: the first wake already carries every write the batch would have fired.
+  await until(() => notifications.n > 0)
   expect(notifications.n).toBe(1)
 })
 
@@ -59,20 +74,26 @@ test('stores are independent — one slice does not wake another', async () => {
   })
 
   a.set(1)
-  await tick()
+  await until(() => aWakes.n > 0)
   expect(aWakes.n).toBe(1)
   expect(bWakes.n).toBe(0)
 })
 
 test('unsubscribe stops notifications', async () => {
   const store = makeStore(0)
+  const witness = makeStore(0)
   const notifications = counter()
+  const witnessWakes = counter()
   const unsubscribe = store.subscribe(() => {
     notifications.n++
   })
+  witness.subscribe(() => {
+    witnessWakes.n++
+  })
 
   unsubscribe()
   store.set(1)
-  await tick()
+  witness.set(1)
+  await until(() => witnessWakes.n > 0)
   expect(notifications.n).toBe(0)
 })

package/src/internal/track.ts

@@ -10,8 +10,9 @@ export interface Tracker {
   add(source: Subscribable): void
 }
 
-const CurrentTrackerBase: Context.TagClass<CurrentTracker, 'reform/Tracker', Tracker> =
-  Context.Tag('reform/Tracker')<CurrentTracker, Tracker>()
+const CurrentTrackerBase: Context.TagClass<CurrentTracker, 'reform/Tracker', Tracker> = Context.Tag(
+  'reform/Tracker',
+)<CurrentTracker, Tracker>()
 export class CurrentTracker extends CurrentTrackerBase {}
 
 export const readTracked = <A>(store: Store<A>): Effect.Effect<A> =>