@playfast/reform 1.1.1 → 1.2.1

package/src/calc/asyncCalc.ts

@@ -1,111 +1,111 @@
-import { Context, Effect, Layer, Match, Option } from 'effect'
-import type { Effect as EffectType } from 'effect/Effect'
-import { type Manifest } from '../definition/definition'
+import { Context, Effect, Layer, Match, Option, Schema } from 'effect'
+import { yieldableClass } from '../definition/definition'
 import { type AnyEvent } from '../event/event'
-import {
-  type InputsObject,
-  type InputStores,
-  type InvalidateBy,
-} from '../internal/sources'
+import { type InputStores } from '../internal/sources'
 import {
   bumpRevision,
+  type GatedOf,
+  gatedFlag,
   makeQueryDriver,
+  type QueryCodec,
   RevisionSchema,
   revisionZero,
 } from '../internal/queryDriver'
 import { type Store } from '../internal/store'
+import { readTracked } from '../internal/track'
 import * as Reducer from '../reducer/reducer'
 import { Reducers } from '../runtime/loop'
+import { Queries } from '../runtime/queries'
 import * as State from '../state/state'
-import { type AnySource } from '../state/token'
+import { type AnySource, type SourceCapture } from '../state/token'
 import { type AsyncData, narrowStore } from './asyncData'
-import type { AnySchema, AnyValue } from '../internal/variance'
-export { invalidate, make, type NamedCalc, refetch } from './asyncCalcDefinitions'
-
-export interface AsyncCalcManifest<N extends string, A, E> extends Manifest {
-  readonly kind: 'AsyncCalc'
-  readonly name: N
-  readonly output: AnySchema<A>
-  // 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 error?: AnySchema<E>
-  readonly gated: boolean
-}
-
-export interface AsyncCalcClass<
-  out N extends string,
-  out Inputs extends ReadonlyArray<AnySource>,
-  in out A,
-  in out E,
-  in out Gated extends boolean,
-> extends EffectType<AsyncData<A, E, Gated>, never, Store<AsyncData<A, E, Gated>>> {
-  new (): {}
-  readonly manifest: AsyncCalcManifest<N, A, E>
-  readonly store: Context.Tag<Store<AsyncData<A, E, Gated>>, Store<AsyncData<A, E, Gated>>>
-  readonly name: N
-  readonly inputs: Inputs
-  readonly gated: Gated
-}
-
-export interface AsyncCalcConfig<Inputs extends ReadonlyArray<AnySource>, A, E, AlwaysOn extends boolean> {
-  readonly inputs: Inputs
-  readonly output: AnySchema<A>
-  // 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 error?: AnySchema<E>
-  // 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 alwaysOn?: AlwaysOn
-}
+import type {
+  AsyncCalcClass,
+  AsyncCalcConfig,
+  AsyncCalcLive,
+  AsyncCalcLiveView,
+  AsyncCalcLiveWithInvalidateOn,
+  AsyncCalcMakeConfigExternalApi,
+  AsyncCalcManifest,
+  AsyncCalcStore,
+  DefinedAsyncCalcClass,
+} from './asyncCalcTypes'
 
-export type AsyncCalcLive<
-  Inputs extends ReadonlyArray<AnySource>,
-  A,
-  E,
-  Gated extends boolean,
-  R,
-> = {
-  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>
-  // 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'
-  // 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
-  // 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?:
-    | boolean
-    // 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 key?: string | ((inputs: InputsObject<Inputs>) => string) }
-} & (Gated extends true
-  ? // 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 }
-  : // 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?: never })
+export { AsyncCalcStoreTypeId } from './asyncCalcTypes'
+export type {
+  AsyncCalcClass,
+  AsyncCalcConfig,
+  AsyncCalcLive,
+  AsyncCalcLiveView,
+  AsyncCalcLiveWithInvalidateOn,
+  AsyncCalcManifest,
+  AsyncCalcSchemaReflection,
+  AsyncCalcStore,
+  DefinedAsyncCalcClass,
+} from './asyncCalcTypes'
 
-export type AsyncCalcLiveWithInvalidateOn<
-  Inputs extends ReadonlyArray<AnySource>,
-  A,
-  E,
-  Gated extends boolean,
-  R,
-> = AsyncCalcLive<Inputs, A, E, Gated, 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 invalidateOn?: ReadonlyArray<AnyEvent>
-}
 
-export interface AsyncCalcLiveView<Inputs extends ReadonlyArray<AnySource>, A, E, R> {
-  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>
-  // 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
-  // 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'
-  // 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
-  // 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?:
-    | boolean
-    // 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 key?: string | ((inputs: InputsObject<Inputs>) => string) }
+export function make<
+  const N extends string,
+  const Inputs extends ReadonlyArray<AnySource>,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+  ErrorSchema extends Schema.Schema.AnyNoContext | undefined = undefined,
+  const AlwaysOn extends boolean = false,
+>(
+  name: N,
+  config: AsyncCalcConfig<Inputs, OutputSchema, ErrorSchema, AlwaysOn>,
+): DefinedAsyncCalcClass<
+  N,
+  Inputs,
+  Schema.Schema.Type<OutputSchema>,
+  ErrorSchema extends Schema.Schema.AnyNoContext ? Schema.Schema.Type<ErrorSchema> : never,
+  GatedOf<AlwaysOn>
+>
+export function make<
+  const N extends string,
+  const Inputs extends ReadonlyArray<AnySource>,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+  ErrorSchema extends Schema.Schema.AnyNoContext | undefined = undefined,
+  const AlwaysOn extends boolean = false,
+>(
+  name: N,
+  config: AsyncCalcMakeConfigExternalApi<Inputs, OutputSchema, ErrorSchema, AlwaysOn>,
+): DefinedAsyncCalcClass<
+  N,
+  Inputs,
+  Schema.Schema.Type<OutputSchema>,
+  ErrorSchema extends Schema.Schema.AnyNoContext ? Schema.Schema.Type<ErrorSchema> : never,
+  GatedOf<AlwaysOn>
+> {
+  type A = Schema.Schema.Type<OutputSchema>
+  type E = ErrorSchema extends Schema.Schema.AnyNoContext ? Schema.Schema.Type<ErrorSchema> : never
+  const store = Context.GenericTag<
+    AsyncCalcStore<N, A, E, GatedOf<AlwaysOn>>,
+    Store<AsyncData<A, E, GatedOf<AlwaysOn>>>
+  >(`reform/asyncCalc/${name}`)
+  const gated = gatedFlag(config.alwaysOn)
+  const manifest: AsyncCalcManifest<N, A, E> = {
+    kind: 'AsyncCalc',
+    name,
+    output: config.output,
+    gated,
+    ...(config.error !== undefined ? { error: config.error } : {}),
+  }
+  const codec: QueryCodec<A> = {
+    encode: Schema.encode(config.output),
+    decode: Schema.decodeUnknown(config.output),
+  }
+  const read = Effect.flatMap(store, readTracked)
+  const calc: DefinedAsyncCalcClass<N, Inputs, A, E, GatedOf<AlwaysOn>> = yieldableClass(read, {
+    manifest,
+    codec,
+    store,
+    name,
+    inputs: config.inputs,
+    gated,
+    capture: <Result>(visit: SourceCapture<Result>): Result => visit(calc),
+  })
+  return calc
 }
 
 export function live<
@@ -120,7 +120,7 @@ export function live<
   config: AsyncCalcLive<Inputs, A, E, Gated, R> & {
     readonly invalidateOn: ReadonlyArray<AnyEvent>
   },
-): Layer.Layer<Store<AsyncData<A, E, Gated>>, never, InputStores<Inputs> | R | Reducers>
+): Layer.Layer<AsyncCalcStore<N, A, E, Gated>, never, InputStores<Inputs> | R | Reducers>
 export function live<
   N extends string,
   Inputs extends ReadonlyArray<AnySource>,
@@ -131,7 +131,7 @@ export function live<
 >(
   calc: AsyncCalcClass<N, Inputs, A, E, Gated>,
   config: AsyncCalcLive<Inputs, A, E, Gated, R>,
-): Layer.Layer<Store<AsyncData<A, E, Gated>>, never, InputStores<Inputs> | R>
+): Layer.Layer<AsyncCalcStore<N, A, E, Gated>, never, InputStores<Inputs> | R>
 export function live<
   N extends string,
   Inputs extends ReadonlyArray<AnySource>,
@@ -142,7 +142,7 @@ export function live<
 >(
   calc: AsyncCalcClass<N, Inputs, A, E, Gated>,
   config: AsyncCalcLiveWithInvalidateOn<Inputs, A, E, Gated, R>,
-): Layer.Layer<Store<AsyncData<A, E, Gated>>, never, AnyValue> {
+): Layer.Layer<AsyncCalcStore<N, A, E, Gated>, never, InputStores<Inputs> | R | Reducers> {
   const revisionState =
     config.invalidateOn === undefined
       ? undefined
@@ -151,18 +151,21 @@ export function live<
   const driver = Layer.scoped(
     calc.store,
     Effect.gen(function* () {
-      // oxlint-disable-next-line reform-rules/no-type-assertion -- loose runtime view: `disabled` is type-erased to `never` for non-gated calcs, no guard recovers it
-      const cfg = config as AsyncCalcLiveView<Inputs, A, E, R>
+      const cfg: AsyncCalcLiveView<Inputs, A, E, R> = config
 
       const persistOption = cfg.persist
       const persistKey =
         persistOption === true || persistOption === undefined || persistOption === false
           ? calc.manifest.name
-          : persistOption.key ?? calc.manifest.name
+          : (persistOption.key ?? calc.manifest.name)
+      const persistCodec: QueryCodec<A> = {
+        encode: Schema.encode(calc.manifest.output),
+        decode: Schema.decodeUnknown(calc.manifest.output),
+      }
       const persist =
         persistOption === undefined || persistOption === false
           ? undefined
-          : { key: persistKey, schema: calc.manifest.output }
+          : { key: persistKey, codec: persistCodec }
 
       const revision = yield* Match.value(revisionState).pipe(
         Match.when(undefined, () => Effect.succeed(undefined)),
@@ -204,3 +207,15 @@ export function live<
     Layer.provide(State.live(revisionState, revisionZero)),
   )
 }
+
+export interface NamedCalc {
+  readonly name: string
+}
+
+export const invalidate = (calc: NamedCalc): Effect.Effect<void, never, Queries> =>
+  Effect.flatMap(Queries, (queries) =>
+    Effect.sync(() => queries.byName.get(calc.name)?.invalidate()),
+  )
+
+export const refetch = (calc: NamedCalc): Effect.Effect<void, never, Queries> =>
+  Effect.flatMap(Queries, (queries) => Effect.sync(() => queries.byName.get(calc.name)?.refetch()))

package/src/calc/asyncCalcTypes.ts

@@ -0,0 +1,147 @@
+import type { Context, Effect, Schema } from 'effect'
+import type { Effect as EffectType } from 'effect/Effect'
+import type { Manifest } from '../definition/definition'
+import type { AnyEvent } from '../event/event'
+import type { InputsObject, InvalidateBy } from '../internal/sources'
+import type { QueryCodec } from '../internal/queryDriver'
+import type { Store } from '../internal/store'
+import type { AnySchema } from '../internal/variance'
+import type { AnySource, Source, SourceCapture } from '../state/token'
+import type { AsyncData } from './asyncData'
+
+export interface AsyncCalcSchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface AsyncCalcManifest<N extends string, A = unknown, E = never> extends Manifest {
+  readonly kind: 'AsyncCalc'
+  readonly name: N
+  readonly output: AnySchema<A>
+  // 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 error?: AnySchema<E>
+  readonly gated: boolean
+}
+
+export const AsyncCalcStoreTypeId: unique symbol = Symbol.for('reform/AsyncCalcStore')
+export type AsyncCalcStoreTypeId = typeof AsyncCalcStoreTypeId
+
+interface AsyncCalcStoreCompatibilityExternalApi<
+  N extends string,
+  in out A,
+  in out E,
+  in out Gated extends boolean,
+> extends Store<AsyncData<A, E, Gated>> {
+  readonly [AsyncCalcStoreTypeId]?: N
+}
+
+export type AsyncCalcStore<
+  N extends string,
+  A,
+  E,
+  Gated extends boolean,
+> = AsyncCalcStoreCompatibilityExternalApi<N, A, E, Gated>
+
+export interface AsyncCalcClass<
+  N extends string,
+  Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E,
+  Gated extends boolean,
+>
+  extends
+    EffectType<AsyncData<A, E, Gated>, never, AsyncCalcStore<N, A, E, Gated>>,
+    Source<N, AsyncData<A, E, Gated>, AsyncCalcStore<N, A, E, Gated>> {
+  new (): {}
+  readonly manifest: AsyncCalcManifest<N, A, E>
+  readonly store: Context.Tag<AsyncCalcStore<N, A, E, Gated>, Store<AsyncData<A, E, Gated>>>
+  readonly name: N
+  readonly inputs: Inputs
+  readonly gated: Gated
+}
+
+export interface DefinedAsyncCalcClass<
+  N extends string,
+  Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E,
+  Gated extends boolean,
+> extends AsyncCalcClass<N, Inputs, A, E, Gated> {
+  readonly codec: QueryCodec<A>
+  readonly capture: <Result>(visit: SourceCapture<Result>) => Result
+}
+
+type ConfigSchema<ValueOrSchema> = [ValueOrSchema] extends [Schema.Schema.AnyNoContext]
+  ? ValueOrSchema
+  : AnySchema<ValueOrSchema>
+
+type ConfigErrorSchema<ValueOrSchema> = [ValueOrSchema] extends [undefined]
+  ? ValueOrSchema
+  : ConfigSchema<ValueOrSchema>
+
+export interface AsyncCalcConfig<
+  Inputs extends ReadonlyArray<AnySource>,
+  OutputSchema,
+  ErrorSchema,
+  AlwaysOn extends boolean,
+> {
+  readonly inputs: Inputs
+  readonly output: ConfigSchema<OutputSchema>
+  // 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 error?: ConfigErrorSchema<ErrorSchema>
+  // 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 alwaysOn?: AlwaysOn
+}
+
+export interface AsyncCalcMakeConfigExternalApi<
+  Inputs extends ReadonlyArray<AnySource>,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+  ErrorSchema extends Schema.Schema.AnyNoContext | undefined,
+  AlwaysOn extends boolean,
+> {
+  readonly inputs: Inputs
+  readonly output: OutputSchema
+  readonly error?: ErrorSchema
+  readonly alwaysOn?: AlwaysOn
+}
+
+export type AsyncCalcLive<
+  Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E,
+  Gated extends boolean,
+  R,
+> = {
+  readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
+  readonly invalidateBy?: InvalidateBy<Inputs>
+  // 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'
+  // 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
+  // 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?:
+    | boolean
+    | { readonly key?: string | ((inputs: InputsObject<Inputs>) => string) }
+} & (Gated extends true
+  ? { readonly disabled?: (inputs: InputsObject<Inputs>) => boolean }
+  : { readonly disabled?: never })
+
+export type AsyncCalcLiveWithInvalidateOn<
+  Inputs extends ReadonlyArray<AnySource>,
+  A,
+  E,
+  Gated extends boolean,
+  R,
+> = AsyncCalcLive<Inputs, A, E, Gated, R> & {
+  readonly invalidateOn?: ReadonlyArray<AnyEvent>
+}
+
+export interface AsyncCalcLiveView<Inputs extends ReadonlyArray<AnySource>, A, E, R> {
+  readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
+  readonly invalidateBy?: InvalidateBy<Inputs>
+  readonly disabled?: (inputs: InputsObject<Inputs>) => boolean
+  readonly coalesce?: 'switch' | 'trailing'
+  readonly reuse?: boolean
+  readonly persist?:
+    | boolean
+    | { readonly key?: string | ((inputs: InputsObject<Inputs>) => string) }
+}

package/src/calc/calc.test.ts

@@ -1,8 +1,7 @@
 import { expect, it } from '@effect/vitest'
-import { Duration, Effect, Layer, Schema as S } from 'effect'
+import { Effect, Layer, Schema as S } from 'effect'
 import { Calc, State, StateGroup } from '../index'
-
-const tick = Effect.sleep(Duration.millis(1))
+import { flush } from '../testkit/flight.testkit'
 
 it.live('a source change that does not move the output notifies no subscriber', () => {
   class Count extends State.make('count', S.Number) {}
@@ -30,12 +29,12 @@ it.live('a source change that does not move the output notifies no subscriber',
     expect(derived.get()).toBe(true)
 
     source.set(2)
-    yield* tick
+    yield* flush()
     expect(notifications.n).toBe(0)
     expect(derived.get()).toBe(true)
 
     source.set(-1)
-    yield* tick
+    yield* flush()
     expect(notifications.n).toBe(1)
     expect(derived.get()).toBe(false)
   }).pipe(Effect.provide(TestLayer))
@@ -89,7 +88,7 @@ it.live('a calc can depend on another calc as an input source', () => {
     const derived = yield* PlusDoubled.store
     expect(derived.get()).toBe(15)
     source.set(3)
-    yield* tick
+    yield* flush()
     expect(derived.get()).toBe(9)
   }).pipe(Effect.provide(TestLayer))
 })
@@ -125,7 +124,7 @@ it.live('a diamond dependency resolves in one flush with a single leaf notificat
     expect(c.get()).toBe(11)
 
     source.set(5)
-    yield* tick
+    yield* flush()
     expect(c.get()).toBe(21)
     expect(wakes.n).toBe(1)
   }).pipe(Effect.provide(TestLayer))
@@ -158,12 +157,12 @@ it.live('invalidateBy: a calc recomputes only when the projected key moves', ()
     expect(sum.get()).toBe(2)
 
     sb.set(100)
-    yield* tick
+    yield* flush()
     expect(runs.n).toBe(base)
     expect(sum.get()).toBe(2)
 
     sa.set(5)
-    yield* tick
+    yield* flush()
     expect(sum.get()).toBe(105)
   }).pipe(Effect.provide(TestLayer))
 })
@@ -211,11 +210,9 @@ it.live('reuse: an unchanged subtree keeps its identity across recompute', () =>
     inputs: [StateGroup.select(Inputs, 'a'), StateGroup.select(Inputs, 'b')],
     output: Pair,
   }) {}
-  const SplitLive = Calc.live(
-    Split,
-    ({ a, b }) => ({ left: { value: a }, right: { value: b } }),
-    { reuse: true },
-  )
+  const SplitLive = Calc.live(Split, ({ a, b }) => ({ left: { value: a }, right: { value: b } }), {
+    reuse: true,
+  })
   const TestLayer = SplitLive.pipe(Layer.provideMerge(StateGroup.live(Inputs, { a: 1, b: 1 })))
 
   return Effect.gen(function* () {
@@ -224,7 +221,7 @@ it.live('reuse: an unchanged subtree keeps its identity across recompute', () =>
     const before = derived.get()
 
     b.set(2)
-    yield* tick
+    yield* flush()
     const after = derived.get()
     expect(after).not.toBe(before)
     expect(after.left).toBe(before.left)
@@ -256,7 +253,7 @@ it.live('reuse: a value-equal recompute keeps the previous reference and wakes n
     const before = derived.get()
 
     source.set(2)
-    yield* tick
+    yield* flush()
     expect(derived.get()).toBe(before)
     expect(notifications.n).toBe(0)
   }).pipe(Effect.provide(TestLayer))

package/src/calc/calc.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, Layer, MutableRef } from 'effect'
+import { Context, Effect, Layer, MutableRef, type Schema } from 'effect'
 import type { Effect as EffectType } from 'effect/Effect'
 import { type Manifest, yieldableClass } from '../definition/definition'
 import {
@@ -13,8 +13,7 @@ import { resolveInstrumentation, stateUpdateHook } from '../runtime/instrumentat
 import { reuse } from '../internal/reuse'
 import { makeDerivedStore, type Store } from '../internal/store'
 import { readTracked } from '../internal/track'
-import { type AnySource } from '../state/token'
-import type { AnySchema } from '../internal/variance'
+import { type AnySource, type Source, type SourceCapture } from '../state/token'
 
 export { type InputsObject, type InputStores, type InvalidateBy } from '../internal/sources'
 
@@ -23,41 +22,68 @@ export interface CalcOptionsExternalApi<Inputs extends ReadonlyArray<AnySource>>
   readonly reuse?: boolean
 }
 
-export interface CalcManifest<N extends string, Out> extends Manifest {
+export interface CalcSchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface CalcManifest<N extends string> extends Manifest {
   readonly kind: 'Calc'
   readonly name: N
-  readonly output: AnySchema<Out>
+  readonly output: CalcSchemaReflection
+}
+
+export const CalcStoreTypeId: unique symbol = Symbol.for('reform/CalcStore')
+export type CalcStoreTypeId = typeof CalcStoreTypeId
+
+export interface CalcStore<N extends string, in out Out> extends Store<Out> {
+  readonly [CalcStoreTypeId]: N
 }
 
-export interface CalcClass<out N extends string, out Inputs extends ReadonlyArray<AnySource>, in out Out>
-  extends EffectType<Out, never, Store<Out>> {
+export interface CalcClass<N extends string, Inputs extends ReadonlyArray<AnySource>, Out>
+  extends EffectType<Out, never, CalcStore<N, Out>>, Source<N, Out, CalcStore<N, Out>> {
   new (): {}
-  readonly manifest: CalcManifest<N, Out>
-  readonly store: Context.Tag<Store<Out>, Store<Out>>
+  readonly manifest: CalcManifest<N>
+  readonly store: Context.Tag<CalcStore<N, Out>, Store<Out>>
   readonly name: N
   readonly inputs: Inputs
+  readonly capture: <Result>(visit: SourceCapture<Result>) => Result
 }
 
-export interface CalcConfig<Inputs extends ReadonlyArray<AnySource>, Out> {
+export interface CalcConfig<
+  Inputs extends ReadonlyArray<AnySource>,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+> {
   readonly inputs: Inputs
-  readonly output: AnySchema<Out>
+  readonly output: OutputSchema
 }
 
-export const make = <const N extends string, const Inputs extends ReadonlyArray<AnySource>, Out>(
+export const make = <
+  const N extends string,
+  const Inputs extends ReadonlyArray<AnySource>,
+  OutputSchema extends Schema.Schema.AnyNoContext,
+>(
   name: N,
-  config: CalcConfig<Inputs, Out>,
-): CalcClass<N, Inputs, Out> => {
-  const store = Context.GenericTag<Store<Out>, Store<Out>>(`reform/calc/${name}`)
-  const manifest: CalcManifest<N, Out> = { kind: 'Calc', name, output: config.output }
+  config: CalcConfig<Inputs, OutputSchema>,
+): CalcClass<N, Inputs, Schema.Schema.Type<OutputSchema>> => {
+  type Out = Schema.Schema.Type<OutputSchema>
+  const store = Context.GenericTag<CalcStore<N, Out>, Store<Out>>(`reform/calc/${name}`)
+  const manifest: CalcManifest<N> = { kind: 'Calc', name, output: config.output }
   const read = Effect.flatMap(store, readTracked)
-  return yieldableClass(read, { manifest, store, name, inputs: config.inputs })
+  const calc: CalcClass<N, Inputs, Out> = yieldableClass(read, {
+    manifest,
+    store,
+    name,
+    inputs: config.inputs,
+    capture: <Result>(visit: SourceCapture<Result>): Result => visit(calc),
+  })
+  return calc
 }
 
 export const live = <N extends string, Inputs extends ReadonlyArray<AnySource>, Out>(
   calc: CalcClass<N, Inputs, Out>,
   compute: (inputs: InputsObject<Inputs>) => Out,
   options: CalcOptionsExternalApi<Inputs> = {},
-): Layer.Layer<Store<Out>, never, InputStores<Inputs>> =>
+): Layer.Layer<CalcStore<N, Out>, never, InputStores<Inputs>> =>
   Layer.scoped(
     calc.store,
     Effect.gen(function* () {