@playfast/reform 1.1.1 → 1.2.1

package/src/state/state.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, FiberRef, Layer, Option, Schema } from 'effect'
+import { Context, Effect, FiberRef, Layer, Option, type ParseResult, Schema } from 'effect'
 import type { Effect as EffectType } from 'effect/Effect'
 import { type Manifest, yieldableClass } from '../definition/definition'
 import { resolveScheduler } from '../internal/scheduler'
@@ -7,7 +7,6 @@ import { resolveInstrumentation, stateUpdateHook } from '../runtime/instrumentat
 import { claimStateTag } from '../internal/stateRegistry'
 import { makeStore, type Store } from '../internal/store'
 import { readTracked } from '../internal/track'
-import type { AnySchema, AnyValue } from '../internal/variance'
 
 export interface StateOptionsExternalApi {
   readonly title?: string
@@ -15,34 +14,72 @@ export interface StateOptionsExternalApi {
 }
 export type StateOptions = StateOptionsExternalApi
 
-export interface StateManifestExternalApi<N extends string, A> extends Manifest {
+// Full Schema parameters are invariant; heterogeneous manifests expose only their AST.
+export interface StateSchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface StateManifestExternalApi<N extends string> extends Manifest {
   readonly kind: 'State'
   readonly name: N
-  readonly schema: AnySchema<A>
+  readonly schema: StateSchemaReflection
   readonly title?: string
   readonly description?: string
 }
-export type StateManifest<N extends string, A> = StateManifestExternalApi<N, A>
+export type StateManifest<N extends string> = StateManifestExternalApi<N>
+
+export const StateStoreTypeId: unique symbol = Symbol.for('reform/StateStore')
+export type StateStoreTypeId = typeof StateStoreTypeId
+
+export interface StateStore<N extends string, in out A> extends Store<A> {
+  readonly [StateStoreTypeId]: N
+}
 
-export interface StateClass<out N extends string, in out A> extends EffectType<A, never, Store<A>> {
+export type StateCapture<Result> = <N extends string, A>(state: StateClass<N, A>) => Result
+
+export interface AnyState {
   new (): {}
-  readonly manifest: StateManifest<N, A>
-  readonly store: Context.Tag<Store<A>, Store<A>>
+  readonly manifest: StateManifest<string>
+  readonly capture: <Result>(visit: StateCapture<Result>) => Result
 }
 
-export type AnyState = StateClass<string, AnyValue>
-export type StateValue<S> = S extends StateClass<string, infer A> ? A : never
-export type StateName<S> = S extends StateClass<infer N, AnyValue> ? N : never
+interface StateStatics<N extends string, A> {
+  readonly manifest: StateManifest<N>
+  // Subclasses change the class function name; this preserves the authored source name.
+  readonly name: N
+  readonly capture: <Result>(visit: StateCapture<Result>) => Result
+  readonly store: Context.Tag<StateStore<N, A>, Store<A>>
+  readonly decodeUnknown: (input: unknown) => Effect.Effect<A, ParseResult.ParseError, never>
+  readonly decodeUnknownSync: (input: unknown) => A
+  readonly decodeUnknownOption: (input: unknown) => Option.Option<A>
+}
 
-export const make = <const N extends string, A>(
+export interface StateClass<N extends string, A>
+  extends EffectType<A, never, StateStore<N, A>>, StateStatics<N, A> {
+  new (): {}
+}
+
+export type StateDefinition<
+  N extends string,
+  A,
+  StateSchema extends Schema.Schema.AnyNoContext,
+> = StateClass<N, A> & {
+  readonly manifest: StateManifest<N> & { readonly schema: StateSchema }
+}
+
+export type StateValue<S> = S extends StateClass<infer _N, infer A> ? A : never
+export type StateName<S> = S extends StateClass<infer N, infer _A> ? N : never
+
+export const make = <const N extends string, StateSchema extends Schema.Schema.AnyNoContext>(
   name: N,
-  schema: AnySchema<A>,
+  schema: StateSchema,
   options: StateOptions = {},
-): StateClass<N, A> => {
+): StateDefinition<N, Schema.Schema.Type<StateSchema>, StateSchema> => {
+  type A = Schema.Schema.Type<StateSchema>
   const identifier = `reform/state/${name}`
   claimStateTag(identifier)
-  const store = Context.GenericTag<Store<A>, Store<A>>(identifier)
-  const manifest: StateManifest<N, A> = {
+  const store = Context.GenericTag<StateStore<N, A>, Store<A>>(identifier)
+  const manifest: StateManifest<N> & { readonly schema: StateSchema } = {
     kind: 'State',
     name,
     schema,
@@ -50,25 +87,41 @@ export const make = <const N extends string, A>(
     ...(options.description !== undefined ? { description: options.description } : {}),
   }
   const read = Effect.flatMap(store, readTracked)
-  return yieldableClass(read, { manifest, store })
+  const state: StateDefinition<N, A, StateSchema> = yieldableClass<
+    A,
+    never,
+    StateStore<N, A>,
+    StateStatics<N, A> & {
+      readonly manifest: StateManifest<N> & { readonly schema: StateSchema }
+    }
+  >(read, {
+    manifest,
+    name,
+    store,
+    decodeUnknown: Schema.decodeUnknown(schema),
+    decodeUnknownSync: Schema.decodeUnknownSync(schema),
+    decodeUnknownOption: Schema.decodeUnknownOption(schema),
+    capture: <Result>(visit: StateCapture<Result>): Result => visit(state),
+  })
+  return state
 }
 
-const resolveSeed = <S extends AnyState>(
-  state: S,
-  initial: StateValue<S>,
-): Effect.Effect<StateValue<S>> =>
+const resolveSeed = <N extends string, A>(
+  state: StateClass<N, A>,
+  initial: A,
+): Effect.Effect<A, never, never> =>
   Effect.map(FiberRef.get(CurrentSeedOverrides), (overrides) => {
     if (!(state.manifest.name in overrides)) {
       return initial
     }
-    const override = Schema.decodeUnknownOption(state.manifest.schema)(overrides[state.manifest.name])
+    const override = state.decodeUnknownOption(overrides[state.manifest.name])
     return Option.getOrElse(override, () => initial)
   })
 
-export const live = <S extends AnyState>(
-  state: S,
-  initial: StateValue<S>,
-): Layer.Layer<Store<StateValue<S>>> =>
+export const live = <N extends string, A>(
+  state: StateClass<N, A>,
+  initial: A,
+): Layer.Layer<StateStore<N, A>> =>
   Layer.effect(
     state.store,
     Effect.all([resolveScheduler, resolveSeed(state, initial), resolveInstrumentation]).pipe(

package/src/state/stateFamily.test.ts

@@ -1,8 +1,26 @@
 import { expect, it } from '@effect/vitest'
-import { Duration, Effect, Layer, Schema as S } from 'effect'
+import { Effect, Layer, Schema as S } from 'effect'
 import { Engine, Event, publish, Reducer, StateFamily } from '../index'
+import { until } from '../testkit/flight.testkit'
 
-const tick = Effect.sleep(Duration.millis(1))
+// Eviction is queued with queueMicrotask; one turn of the queue provably drains it.
+const drainMicrotasks = Effect.promise(
+  () => new Promise<void>((resolve) => queueMicrotask(resolve)),
+)
+
+it.live('same-shaped families resolve their own stores', () => {
+  class First extends StateFamily.make('family.nominal.first', S.String, S.Number) {}
+  class Second extends StateFamily.make('family.nominal.second', S.String, S.Number) {}
+  const Live = Layer.mergeAll(StateFamily.live(First, 1), StateFamily.live(Second, 2))
+
+  return Effect.gen(function* () {
+    const first = yield* First.store
+    const second = yield* Second.store
+
+    expect(first.at('key').get()).toBe(1)
+    expect(second.at('key').get()).toBe(2)
+  }).pipe(Effect.provide(Live))
+})
 
 it.live("writing one key does not notify another key's subscribers", () => {
   class Items extends StateFamily.make('items', S.String, S.Number) {}
@@ -22,7 +40,10 @@ it.live("writing one key does not notify another key's subscribers", () => {
     })
 
     a.set(1)
-    yield* tick
+    yield* until(
+      () => aWakes.n,
+      (n) => n > 0,
+    )
     expect(aWakes.n).toBe(1)
     expect(bWakes.n).toBe(0)
     expect(b.get()).toBe(0)
@@ -67,12 +88,16 @@ it.live('evictWhenUnused drops a key once its last subscriber leaves', () => {
     const offB = store.subscribe(() => {})
     expect(family.size()).toBe(1)
 
+    // Releasing one of two subscribers queues no eviction at all — assert with no window.
     offA()
-    yield* tick
+    yield* drainMicrotasks
     expect(family.size()).toBe(1)
 
     offB()
-    yield* tick
+    yield* until(
+      () => family.size(),
+      (size) => size === 0,
+    )
     expect(family.size()).toBe(0)
     expect(family.at('k').get()).toBe(0)
   }).pipe(Effect.provide(TestLayer))
@@ -89,7 +114,7 @@ it.live('evictWhenUnused: a same-tick re-subscribe cancels eviction', () => {
     const off = store.subscribe(() => {})
     off()
     store.subscribe(() => {})
-    yield* tick
+    yield* drainMicrotasks
     expect(family.size()).toBe(1)
     expect(family.at('k').get()).toBe(7)
   }).pipe(Effect.provide(TestLayer))
@@ -116,12 +141,18 @@ it.live('a family reducer fold returning Tombstone evicts the key', () => {
     const family = yield* Items.store
 
     yield* publish('High', Event.construct(Bumped, { id: 'a' }))
-    yield* Effect.sleep(Duration.millis(5))
+    yield* until(
+      () => family.at('a').get(),
+      (value) => value === 1,
+    )
     const before = family.at('a')
     expect(before.get()).toBe(1)
 
     yield* publish('High', Event.construct(Removed, { id: 'a' }))
-    yield* Effect.sleep(Duration.millis(5))
+    yield* until(
+      () => family.at('a'),
+      (store) => store !== before,
+    )
     const after = family.at('a')
     expect(after).not.toBe(before)
     expect(after.get()).toBe(0)

package/src/state/stateFamily.ts

@@ -1,11 +1,10 @@
-import { Context, Effect, Layer, Option } from 'effect'
+import { Context, Effect, Layer, Option, Schema } from 'effect'
 import { type Manifest, definitionClass } from '../definition/definition'
 import { resolveScheduler, type Scheduler } from '../internal/scheduler'
 import { claimStateTag } from '../internal/stateRegistry'
 import { resolveInstrumentation, stateUpdateHook } from '../runtime/instrumentation'
 import { makeStore, type Store } from '../internal/store'
 import { readTracked } from '../internal/track'
-import type { AnySchema, AnyValue } from '../internal/variance'
 
 export const Tombstone: unique symbol = Symbol.for('reform/StateFamily/Tombstone')
 export type Tombstone = typeof Tombstone
@@ -84,41 +83,66 @@ const makeFamilyStore = <K, V>(
   }
 }
 
-export interface StateFamilyManifestExternalApi<N extends string, K, V> extends Manifest {
+// Full Schema parameters are invariant; heterogeneous manifests expose only their AST.
+export interface FamilySchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface StateFamilyManifestExternalApi<N extends string> extends Manifest {
   readonly kind: 'StateFamily'
   readonly name: N
-  readonly key: AnySchema<K>
-  readonly value: AnySchema<V>
+  readonly key: FamilySchemaReflection
+  readonly value: FamilySchemaReflection
   readonly title?: string
   readonly description?: string
 }
-export type StateFamilyManifest<N extends string, K, V> = StateFamilyManifestExternalApi<N, K, V>
+export type StateFamilyManifest<N extends string> = StateFamilyManifestExternalApi<N>
+
+export const StateFamilyStoreTypeId: unique symbol = Symbol.for('reform/StateFamilyStore')
+export type StateFamilyStoreTypeId = typeof StateFamilyStoreTypeId
+
+export interface StateFamilyStore<N extends string, in out K, in out V> extends FamilyStore<K, V> {
+  readonly [StateFamilyStoreTypeId]: N
+}
 
-export interface StateFamilyClass<out N extends string, in out K, in out V> {
+export type StateFamilyCapture<Result> = <N extends string, K, V>(
+  family: StateFamilyClass<N, K, V>,
+) => Result
+
+export interface AnyFamily {
+  new (): {}
+  readonly manifest: StateFamilyManifest<string>
+  readonly capture: <Result>(visit: StateFamilyCapture<Result>) => Result
+}
+
+export interface StateFamilyClass<N extends string, K, V> {
   new (): { readonly Key: K }
-  readonly manifest: StateFamilyManifest<N, K, V>
-  readonly store: Context.Tag<FamilyStore<K, V>, FamilyStore<K, V>>
+  readonly manifest: StateFamilyManifest<N>
+  readonly capture: <Result>(visit: StateFamilyCapture<Result>) => Result
+  readonly store: Context.Tag<StateFamilyStore<N, K, V>, FamilyStore<K, V>>
+  readonly decodeKeySync: (input: unknown) => K
+  readonly decodeValueSync: (input: unknown) => V
 }
 
-export type AnyFamily = StateFamilyClass<string, AnyValue, AnyValue>
-export type FamilyKey<F> = F extends StateFamilyClass<string, infer K, AnyValue> ? K : never
-export type FamilyValue<F> = F extends StateFamilyClass<string, AnyValue, infer V> ? V : never
+export type FamilyName<F> = F extends StateFamilyClass<infer N, infer _K, infer _V> ? N : never
+export type FamilyKey<F> = F extends StateFamilyClass<infer _N, infer K, infer _V> ? K : never
+export type FamilyValue<F> = F extends StateFamilyClass<infer _N, infer _K, infer V> ? V : never
 
 export interface StateFamilyMakeOptionsExternalApi {
   readonly title?: string
   readonly description?: string
 }
 
-export const make = <const N extends string, K, V>(
+export const make = <const N extends string, K, KeyEncoded, V, ValueEncoded>(
   name: N,
-  key: AnySchema<K>,
-  valueSchema: AnySchema<V>,
+  key: Schema.Schema<K, KeyEncoded, never>,
+  valueSchema: Schema.Schema<V, ValueEncoded, never>,
   options: StateFamilyMakeOptionsExternalApi = {},
 ): StateFamilyClass<N, K, V> => {
   const identifier = `reform/family/${name}`
   claimStateTag(identifier)
-  const store = Context.GenericTag<FamilyStore<K, V>, FamilyStore<K, V>>(identifier)
-  const manifest: StateFamilyManifest<N, K, V> = {
+  const store = Context.GenericTag<StateFamilyStore<N, K, V>, FamilyStore<K, V>>(identifier)
+  const manifest: StateFamilyManifest<N> = {
     kind: 'StateFamily',
     name,
     key,
@@ -126,22 +150,31 @@ export const make = <const N extends string, K, V>(
     ...(options.title !== undefined ? { title: options.title } : {}),
     ...(options.description !== undefined ? { description: options.description } : {}),
   }
-  return definitionClass<StateFamilyClass<N, K, V>>({ manifest, store })
+  const family: StateFamilyClass<N, K, V> = definitionClass<StateFamilyClass<N, K, V>>({
+    manifest,
+    store,
+    decodeKeySync: Schema.decodeUnknownSync(key),
+    decodeValueSync: Schema.decodeUnknownSync(valueSchema),
+    capture: <Result>(visit: StateFamilyCapture<Result>): Result => visit(family),
+  })
+  return family
 }
 
 export const read = <N extends string, K, V>(
   family: StateFamilyClass<N, K, V>,
   key: K,
-): Effect.Effect<V, never, FamilyStore<K, V>> =>
+): Effect.Effect<V, never, StateFamilyStore<N, K, V>> =>
   Effect.flatMap(family.store, (familyStore) => readTracked(familyStore.at(key)))
 
 export const live = <N extends string, K, V>(
   family: StateFamilyClass<N, K, V>,
   initial: V | ((key: K) => V),
   options: FamilyOptions = {},
-): Layer.Layer<FamilyStore<K, V>> => {
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- value-or-factory union can't be discriminated for a generic V without a cast
-  const seed: (key: K) => V = typeof initial === 'function' ? (initial as (key: K) => V) : () => initial
+): Layer.Layer<StateFamilyStore<N, K, V>> => {
+  const seed = (key: K): V =>
+    typeof initial === 'function'
+      ? family.decodeValueSync(Reflect.apply(initial, undefined, [key]))
+      : initial
   return Layer.effect(
     family.store,
     Effect.zipWith(resolveScheduler, resolveInstrumentation, (scheduler, instrumentation) =>

package/src/state/stateGroup.ts

@@ -1,13 +1,25 @@
-import { Array as Arr, Layer, Option } from 'effect'
+import { Array as Arr, Context, Effect, Layer, Option } from 'effect'
 import { definitionClass } from '../definition/definition'
 import { DuplicateRegistration, UnknownGroupState } from '../internal/errors'
 import { type StoresOf } from '../internal/sources'
-import { type AnyState, live as stateLive, type StateClass, type StateName } from './state'
+import type { Store } from '../internal/store'
+import {
+  type AnyState,
+  live as stateLive,
+  type StateName,
+  type StateStore,
+  type StateValue,
+} from './state'
 import { StateToken } from './token'
-import type { AnyValue } from '../internal/variance'
 
-type ValueForName<Members extends ReadonlyArray<AnyState>, N extends string> =
-  Extract<Members[number], StateClass<N, AnyValue>> extends StateClass<string, infer A> ? A : never
+type MemberForName<Members extends ReadonlyArray<AnyState>, N extends string> = Extract<
+  Members[number],
+  { readonly manifest: { readonly name: N } }
+>
+
+type ValueForName<Members extends ReadonlyArray<AnyState>, N extends string> = StateValue<
+  MemberForName<Members, N>
+>
 
 export interface StateGroupClass<Members extends ReadonlyArray<AnyState>> {
   new (): {}
@@ -23,7 +35,10 @@ type DuplicateStateName<N extends string> = readonly ['reform: duplicate state n
 type NoDuplicateNames<
   Members extends ReadonlyArray<AnyState>,
   Seen extends string = never,
-> = Members extends readonly [infer Head extends AnyState, ...infer Tail extends ReadonlyArray<AnyState>]
+> = Members extends readonly [
+  infer Head extends AnyState,
+  ...infer Tail extends ReadonlyArray<AnyState>,
+]
   ? readonly [
       StateName<Head> extends Seen ? DuplicateStateName<StateName<Head>> : Head,
       ...NoDuplicateNames<Tail, Seen | StateName<Head>>,
@@ -43,7 +58,9 @@ type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) exten
 
 type EntrySeeds<G> = G extends AnyStateGroup ? GroupSeeds<G> : never
 
-export type SeedsOf<St extends ReadonlyArray<unknown>> = Partial<UnionToIntersection<EntrySeeds<St[number]>>>
+export type SeedsOf<St extends ReadonlyArray<unknown>> = Partial<
+  UnionToIntersection<EntrySeeds<St[number]>>
+>
 
 export const make = <const Members extends ReadonlyArray<AnyState>>(
   ...members: Members & NoDuplicateNames<Members>
@@ -66,7 +83,10 @@ export const make = <const Members extends ReadonlyArray<AnyState>>(
   })
 }
 
-export const select = <Members extends ReadonlyArray<AnyState>, N extends StateName<Members[number]>>(
+export const select = <
+  Members extends ReadonlyArray<AnyState>,
+  N extends StateName<Members[number]>,
+>(
   group: StateGroupClass<Members>,
   name: N,
 ): StateToken<N, ValueForName<Members, N>> => {
@@ -75,17 +95,33 @@ export const select = <Members extends ReadonlyArray<AnyState>, N extends StateN
     // oxlint-disable-next-line reform-rules/no-throw -- definition-time invariant; sync lookup has no Effect context (see internal/errors.ts)
     throw new UnknownGroupState({ name })
   }
-  return new StateToken(name, member.store)
+  const store = Context.GenericTag<
+    StateStore<N, ValueForName<Members, N>>,
+    Store<ValueForName<Members, N>>
+  >(`reform/state/${name}`)
+  return new StateToken(name, store)
 }
 
-export const live = <Members extends ReadonlyArray<AnyState>>(
+export function live<Members extends ReadonlyArray<AnyState>>(
   group: StateGroupClass<Members>,
   seeds: GroupSeeds<StateGroupClass<Members>>,
-): Layer.Layer<StoresOf<Members>> => {
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- reflection boundary: index a mapped seed type by runtime member name
-  const seedRecord = seeds as Record<string, unknown>
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- union-of-stores Rout can't be expressed by reduce's single-layer accumulator
-  return group.members
-    .map((member) => stateLive(member, seedRecord[member.manifest.name]))
-    .reduce((accumulator, layer) => Layer.merge(accumulator, layer)) as Layer.Layer<StoresOf<Members>>
+): Layer.Layer<StoresOf<Members>>
+export function live(
+  group: AnyStateGroup,
+  seeds: Readonly<Record<string, unknown>>,
+): Layer.Layer<never> {
+  const layers = group.members.map((member) =>
+    member.capture<Layer.Layer<never>>((state) =>
+      Layer.unwrapEffect(
+        state.decodeUnknown(seeds[state.manifest.name]).pipe(
+          Effect.orDie,
+          Effect.map((seed) => stateLive(state, seed)),
+        ),
+      ),
+    ),
+  )
+  return layers.reduce<Layer.Layer<never>>(
+    (merged, memberLayer) => Layer.merge(merged, memberLayer),
+    Layer.empty,
+  )
 }

package/src/state/token.ts

@@ -1,26 +1,56 @@
 import { Context, Effect, Effectable } from 'effect'
 import type { Store } from '../internal/store'
-import type { AnyValue } from '../internal/variance'
 import { readTracked } from '../internal/track'
+import type { StateStore } from './state'
 
-export class StateToken<out N extends string, in out A> extends Effectable.Class<A, never, Store<A>> {
+export class StateToken<
+  N extends string,
+  in out A,
+  Identifier = StateStore<N, A>,
+> extends Effectable.Class<A, never, Identifier> {
   readonly name: N
-  readonly store: Context.Tag<Store<A>, Store<A>>
-  constructor(name: N, store: Context.Tag<Store<A>, Store<A>>) {
+  readonly store: Context.Tag<Identifier, Store<A>>
+  constructor(name: N, store: Context.Tag<Identifier, Store<A>>) {
     super()
     this.name = name
     this.store = store
   }
-  commit(): Effect.Effect<A, never, Store<A>> {
+  commit(): Effect.Effect<A, never, Identifier> {
     return Effect.flatMap(this.store, readTracked)
   }
+  capture<Result>(visit: SourceCapture<Result>): Result {
+    return visit(this)
+  }
+}
+
+export type SourceCapture<Result> = <N extends string, A, Identifier>(
+  source: Source<N, A, Identifier>,
+) => Result
+
+export interface AnySource {
+  readonly name: string
+  readonly store: { readonly key: string }
 }
 
-export interface Source<out N extends string, in out A> {
+export interface Source<N extends string, A, Identifier> extends AnySource {
   readonly name: N
-  readonly store: Context.Tag<Store<A>, Store<A>>
+  readonly store: Context.Tag<Identifier, Store<A>>
 }
 
-export type AnySource = Source<string, AnyValue>
-export type SourceName<S> = S extends Source<infer N, AnyValue> ? N : never
-export type SourceValue<S> = S extends Source<AnyValue, infer A> ? A : never
+export type SourceName<S> = S extends {
+  readonly manifest: { readonly name: infer N extends string }
+}
+  ? N
+  : S extends { readonly name: infer N extends string }
+    ? N
+    : never
+export type SourceValue<S> = S extends {
+  readonly store: Context.Tag<infer _Identifier, Store<infer A>>
+}
+  ? A
+  : never
+export type SourceIdentifier<S> = S extends {
+  readonly store: Context.Tag<infer Identifier, infer _Service>
+}
+  ? Identifier
+  : never

package/src/synced/syncedStore.ts

@@ -1,49 +1,66 @@
-import { Context, Effect, Layer, Option, type Scope } from 'effect'
+import { Context, Effect, Layer, Option, type Schema, type Scope } from 'effect'
 import type { Effect as EffectType } from 'effect/Effect'
 import { type Manifest, yieldableClass } from '../definition/definition'
 import { resolveScheduler } from '../internal/scheduler'
 import { makeDerivedStore, type Store } from '../internal/store'
 import { readTracked } from '../internal/track'
-import type { Source } from '../state/token'
+import type { AnySource, Source, SourceCapture } from '../state/token'
 import type { StateOptions } from '../state/state'
-import type { AnySchema, AnyValue } from '../internal/variance'
 
 export interface SyncedSource<A> {
   readonly snapshot: () => A
   readonly subscribe: (onChange: () => void) => () => void
 }
 
-export interface SyncedStoreManifest<N extends string, A> extends Manifest {
+export interface SyncedStoreSchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface SyncedStoreManifest<N extends string> extends Manifest {
   readonly kind: 'SyncedStore'
   readonly name: N
-  readonly schema: AnySchema<A>
+  readonly schema: SyncedStoreSchemaReflection
   readonly title: Option.Option<string>
   readonly description: Option.Option<string>
 }
 
-export interface SyncedStoreClass<out N extends string, in out A>
-  extends EffectType<A, never, Store<A>>,
-    Source<N, A> {
+export const SyncedStoreIdentifierTypeId: unique symbol = Symbol.for('reform/SyncedStoreIdentifier')
+export type SyncedStoreIdentifierTypeId = typeof SyncedStoreIdentifierTypeId
+
+export interface SyncedStoreIdentifier<N extends string, in out A> extends Store<A> {
+  readonly [SyncedStoreIdentifierTypeId]: N
+}
+
+export interface SyncedStoreClass<N extends string, in out A>
+  extends
+    EffectType<A, never, SyncedStoreIdentifier<N, A>>,
+    Source<N, A, SyncedStoreIdentifier<N, A>> {
   new (): {}
-  readonly manifest: SyncedStoreManifest<N, A>
-  readonly store: Context.Tag<Store<A>, Store<A>>
+  readonly manifest: SyncedStoreManifest<N>
+  readonly store: Context.Tag<SyncedStoreIdentifier<N, A>, Store<A>>
   readonly name: N
+  readonly capture: <Result>(visit: SourceCapture<Result>) => Result
 }
 
-export interface StoreCarrier<A> {
-  readonly store: Context.Tag<Store<A>, Store<A>>
+export interface StoreCarrier<Identifier, A> {
+  readonly store: Context.Tag<Identifier, Store<A>>
 }
 
-export type AnySyncedStore = SyncedStoreClass<string, AnyValue>
-export type SyncedValue<S> = S extends SyncedStoreClass<string, infer A> ? A : never
+export type AnySyncedStore = AnySource & {
+  readonly manifest: Manifest & { readonly kind: 'SyncedStore' }
+}
+export type SyncedValue<S> = S extends SyncedStoreClass<infer _N, infer A> ? A : never
 
-export const make = <const N extends string, A>(
+export const make = <const N extends string, ValueSchema extends Schema.Schema.AnyNoContext>(
   name: N,
-  schema: AnySchema<A>,
+  schema: ValueSchema,
   options: StateOptions = {},
-): SyncedStoreClass<N, A> => {
-  const store = Context.GenericTag<Store<A>, Store<A>>(`reform/syncedStore/${name}`)
-  const manifest: SyncedStoreManifest<N, A> = {
+): SyncedStoreClass<N, Schema.Schema.Type<ValueSchema>> => {
+  type A = Schema.Schema.Type<ValueSchema>
+  const store = Context.GenericTag<SyncedStoreIdentifier<N, A>, Store<A>>(
+    `reform/syncedStore/${name}`,
+  )
+  const manifest: SyncedStoreManifest<N> = {
     kind: 'SyncedStore',
     name,
     schema,
@@ -51,13 +68,19 @@ export const make = <const N extends string, A>(
     description: Option.fromNullable(options.description),
   }
   const read = Effect.flatMap(store, readTracked)
-  return yieldableClass(read, { manifest, store, name })
+  const synced: SyncedStoreClass<N, A> = yieldableClass(read, {
+    manifest,
+    store,
+    name,
+    capture: <Result>(visit: SourceCapture<Result>): Result => visit(synced),
+  })
+  return synced
 }
 
-export const live = <A, R>(
-  def: StoreCarrier<A>,
+export const live = <Identifier, A, R>(
+  def: StoreCarrier<Identifier, A>,
   acquire: Effect.Effect<SyncedSource<A>, never, R>,
-): Layer.Layer<Store<A>, never, Exclude<R, Scope.Scope>> =>
+): Layer.Layer<Identifier, never, Exclude<R, Scope.Scope>> =>
   Layer.scoped(
     def.store,
     Effect.gen(function* () {