@playfast/reform 1.1.1 → 1.2.0

package/src/namespace/namespace.ts

@@ -1,3 +1,4 @@
+import type { Schema } from 'effect'
 import * as AsyncCalc from '../calc/asyncCalc'
 import * as Calc from '../calc/calc'
 import * as CalcFamily from '../calc/calcFamily'
@@ -8,65 +9,85 @@ import * as RemoteState from '../remote/remoteState'
 import * as State from '../state/state'
 import * as StateFamily from '../state/stateFamily'
 import type { AnySource } from '../state/token'
-import type { AnySchema } from '../internal/variance'
 
 export interface FeatureNamespace<Prefix extends string> {
   readonly prefix: Prefix
-  readonly Event: <const N extends string, P>(
+  readonly Event: <const N extends string, P, Encoded>(
     name: N,
-    schema: AnySchema<P>,
+    schema: Schema.Schema<P, Encoded, never>,
   ) => Event.EventClass<`${Prefix}.${N}`, P>
   readonly Channel: (name: string, config: Channel.ChannelConfig) => Channel.ChannelClass
-  readonly State: <const N extends string, A>(
+  readonly State: <const N extends string, StateSchema extends Schema.Schema.AnyNoContext>(
     name: N,
-    schema: AnySchema<A>,
+    schema: StateSchema,
     options?: State.StateOptions,
-  ) => State.StateClass<`${Prefix}.${N}`, A>
-  readonly StateFamily: <const N extends string, K, V>(
+  ) => State.StateDefinition<`${Prefix}.${N}`, Schema.Schema.Type<StateSchema>, StateSchema>
+  readonly StateFamily: <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?: StateFamily.StateFamilyMakeOptionsExternalApi,
   ) => StateFamily.StateFamilyClass<`${Prefix}.${N}`, K, V>
-  readonly Calc: <const N extends string, const Inputs extends ReadonlyArray<AnySource>, Out>(
+  readonly Calc: <
+    const N extends string,
+    const Inputs extends ReadonlyArray<AnySource>,
+    OutputSchema extends Schema.Schema.AnyNoContext,
+  >(
     name: N,
-    config: Calc.CalcConfig<Inputs, Out>,
-  ) => Calc.CalcClass<`${Prefix}.${N}`, Inputs, Out>
+    config: Calc.CalcConfig<Inputs, OutputSchema>,
+  ) => Calc.CalcClass<`${Prefix}.${N}`, Inputs, Schema.Schema.Type<OutputSchema>>
   readonly CalcFamily: <
     const N extends string,
     const Inputs extends ReadonlyArray<AnySource>,
-    K,
-    Out,
+    KeySchema extends Schema.Schema.AnyNoContext,
+    OutputSchema extends Schema.Schema.AnyNoContext,
   >(
     name: N,
-    config: CalcFamily.CalcFamilyConfig<Inputs, K, Out>,
-  ) => CalcFamily.CalcFamilyClass<`${Prefix}.${N}`, Inputs, K, Out>
+    config: CalcFamily.CalcFamilyConfig<Inputs, KeySchema, OutputSchema>,
+  ) => CalcFamily.CalcFamilyClass<
+    `${Prefix}.${N}`,
+    Inputs,
+    Schema.Schema.Type<KeySchema>,
+    Schema.Schema.Type<OutputSchema>
+  >
   readonly AsyncCalc: <
     const N extends string,
     const Inputs extends ReadonlyArray<AnySource>,
-    A,
-    E = never,
+    OutputSchema extends Schema.Schema.AnyNoContext,
+    ErrorSchema extends Schema.Schema.AnyNoContext | undefined = undefined,
     const AlwaysOn extends boolean = false,
   >(
     name: N,
-    config: AsyncCalc.AsyncCalcConfig<Inputs, A, E, AlwaysOn>,
-  ) => AsyncCalc.AsyncCalcClass<`${Prefix}.${N}`, Inputs, A, E, GatedOf<AlwaysOn>>
+    config: AsyncCalc.AsyncCalcConfig<Inputs, OutputSchema, ErrorSchema, AlwaysOn>,
+  ) => AsyncCalc.AsyncCalcClass<
+    `${Prefix}.${N}`,
+    Inputs,
+    Schema.Schema.Type<OutputSchema>,
+    ErrorSchema extends Schema.Schema.AnyNoContext ? Schema.Schema.Type<ErrorSchema> : never,
+    GatedOf<AlwaysOn>
+  >
   readonly RemoteState: <
     const N extends string,
     const Inputs extends ReadonlyArray<AnySource>,
     const Intents extends ReadonlyArray<Event.AnyEvent>,
-    A,
-    E = never,
+    OutputSchema extends Schema.Schema.AnyNoContext,
+    ErrorSchema extends Schema.Schema.AnyNoContext | undefined = undefined,
     const AlwaysOn extends boolean = false,
   >(
     name: N,
-    config: RemoteState.RemoteStateConfigExternalApi<Inputs, Intents, A, E, AlwaysOn>,
+    config: RemoteState.RemoteStateConfigExternalApi<
+      Inputs,
+      Intents,
+      OutputSchema,
+      ErrorSchema,
+      AlwaysOn
+    >,
   ) => RemoteState.RemoteStateClass<
     `${Prefix}.${N}`,
     Inputs,
     Intents,
-    A,
-    E,
+    Schema.Schema.Type<OutputSchema>,
+    ErrorSchema extends Schema.Schema.AnyNoContext ? Schema.Schema.Type<ErrorSchema> : never,
     GatedOf<AlwaysOn>
   >
 }

package/src/procedure/procedure.ts

@@ -3,7 +3,6 @@ import type { YieldWrap } from 'effect/Utils'
 import { type ChannelClass, type ProcedureEntry, Procedures } from '../channel/channel'
 import { type Manifest, definitionClass } from '../definition/definition'
 import { type AnyEvent, type EventType } from '../event/event'
-import { type Ctx } from '../internal/ctx'
 import { Bus, narrowHandled } from '../runtime/bus'
 import type { AnyValue } from '../internal/variance'
 
@@ -11,29 +10,52 @@ export interface ProcedureManifest extends Manifest {
   readonly kind: 'Procedure'
 }
 
-export interface ProcedureClass<Events extends ReadonlyArray<AnyEvent>> {
+export interface ProcedureReflection<
+  out Events extends ReadonlyArray<AnyEvent> = ReadonlyArray<AnyEvent>,
+> {
   new (): {}
   readonly manifest: ProcedureManifest
   readonly events: Events
   readonly channel: ChannelClass
 }
 
+export type ProcedureCapture<Result> = <Events extends ReadonlyArray<AnyEvent>>(
+  procedure: ProcedureClass<Events>,
+) => Result
+
+export interface AnyProcedure extends ProcedureReflection {
+  readonly capture: <Result>(visit: ProcedureCapture<Result>) => Result
+}
+
+export interface ProcedureClass<
+  Events extends ReadonlyArray<AnyEvent>,
+> extends ProcedureReflection<Events> {
+  readonly capture: <Result>(visit: ProcedureCapture<Result>) => Result
+}
+
 export interface ProcedureConfig<Events extends ReadonlyArray<AnyEvent>> {
   readonly events: Events
   readonly channel: ChannelClass
 }
 
-export type AnyProcedure = ProcedureClass<ReadonlyArray<AnyEvent>>
-
 export const make = <const Events extends ReadonlyArray<AnyEvent>>(
   name: string,
   config: ProcedureConfig<Events>,
-): ProcedureClass<Events> =>
-  definitionClass<ProcedureClass<Events>>({
+): ProcedureClass<Events> => {
+  const procedure: ProcedureClass<Events> = definitionClass<ProcedureClass<Events>>({
     manifest: { kind: 'Procedure' as const, name } satisfies ProcedureManifest,
     events: config.events,
     channel: config.channel,
+    capture: <Result>(visit: ProcedureCapture<Result>): Result => visit(procedure),
   })
+  return procedure
+}
+
+type GeneratorContext<Eff> = [Eff] extends [never]
+  ? never
+  : [Eff] extends [YieldWrap<Effect.Effect<AnyValue, AnyValue, infer Context>>]
+    ? Context
+    : never
 
 export const live = <
   Events extends ReadonlyArray<AnyEvent>,
@@ -42,7 +64,7 @@ export const live = <
 >(
   procedure: ProcedureClass<Events>,
   body: (event: EventType<Events[number]>) => Generator<Eff, Done, never>,
-): Layer.Layer<never, never, Procedures | Bus | Ctx<Eff>> => {
+): Layer.Layer<never, never, Procedures | Bus | GeneratorContext<Eff>> => {
   const name = procedure.manifest.name
   const channelName = procedure.channel.manifest.name
   const handles = new Set(procedure.events.map((event) => event.tag))
@@ -52,15 +74,20 @@ export const live = <
       if (procedures.entries.some((entry) => entry.name === name)) {
         yield* Effect.logWarning(`reform: duplicate procedure name '${name}' registered`)
       }
-      const runtime = yield* Effect.runtime<Bus | Ctx<Eff>>()
+      const runtime = yield* Effect.runtime<Bus | GeneratorContext<Eff>>()
       const entry: ProcedureEntry = {
         name,
         channelName,
         handles,
-        run: (event) => Effect.provide(Effect.gen(() => body(narrowHandled(event))), runtime),
+        run: (event) =>
+          Effect.provide(
+            Effect.gen(() => body(narrowHandled(event))),
+            runtime,
+          ),
       }
-      yield* Effect.acquireRelease(Effect.sync(() => procedures.register(entry)), () =>
-        Effect.sync(() => procedures.unregister(entry)),
+      yield* Effect.acquireRelease(
+        Effect.sync(() => procedures.register(entry)),
+        () => Effect.sync(() => procedures.unregister(entry)),
       )
     }),
   )

package/src/reducer/reducer.ts

@@ -2,18 +2,17 @@ import { Effect, Layer, Predicate } from 'effect'
 import { type Manifest, definitionClass } from '../definition/definition'
 import { AsyncReducer } from '../internal/errors'
 import { type AnyEvent, type EventType } from '../event/event'
-import type { Store } from '../internal/store'
-import { type AnyState, type StateValue } from '../state/state'
+import { type AnyState, type StateName, type StateStore, type StateValue } from '../state/state'
 import {
   type AnyFamily,
   type FamilyKey,
-  type FamilyStore,
+  type FamilyName,
   type FamilyValue,
+  type StateFamilyStore,
   Tombstone,
 } from '../state/stateFamily'
 import { narrowHandled, type Tagged } from '../runtime/bus'
 import { type ReducerEntry, Reducers } from '../runtime/loop'
-import type { AnyValue } from '../internal/variance'
 
 export interface ReducerManifest extends Manifest {
   readonly kind: 'Reducer'
@@ -44,6 +43,26 @@ export interface FamilyReducerClass<F extends AnyFamily, Events extends Readonly
   readonly handles: ReadonlySet<string>
 }
 
+type ErasedFold = (...args: ReadonlyArray<never>) => unknown
+
+interface RuntimeStateReducerConfig {
+  readonly states: readonly [AnyState]
+  readonly events: ReadonlyArray<AnyEvent>
+}
+
+interface RuntimeFamilyReducerConfig {
+  readonly family: AnyFamily
+  readonly keyOf: ErasedFold
+  readonly events: ReadonlyArray<AnyEvent>
+}
+
+interface RuntimeReducerClass {
+  new (): {}
+  readonly manifest: ReducerManifest
+  readonly config: RuntimeStateReducerConfig | RuntimeFamilyReducerConfig
+  readonly handles: ReadonlySet<string>
+}
+
 export function make<S extends AnyState, const Events extends ReadonlyArray<AnyEvent>>(
   name: string,
   config: StateReducerConfig<S, Events>,
@@ -54,9 +73,7 @@ export function make<F extends AnyFamily, const Events extends ReadonlyArray<Any
 ): FamilyReducerClass<F, Events>
 export function make(
   name: string,
-  config:
-    | StateReducerConfig<AnyState, ReadonlyArray<AnyEvent>>
-    | FamilyReducerConfig<AnyFamily, ReadonlyArray<AnyEvent>>,
+  config: RuntimeStateReducerConfig | RuntimeFamilyReducerConfig,
 ): unknown {
   return definitionClass<unknown>({
     manifest: { kind: 'Reducer' as const, name } satisfies ReducerManifest,
@@ -79,48 +96,75 @@ const sync = <A>(candidate: A): A => {
 export function live<S extends AnyState, Events extends ReadonlyArray<AnyEvent>>(
   reducer: StateReducerClass<S, Events>,
   fold: (value: StateValue<S>, event: EventType<Events[number]>) => StateValue<S>,
-): Layer.Layer<never, never, Reducers | Store<StateValue<S>>>
+): Layer.Layer<never, never, Reducers | StateStore<StateName<S>, StateValue<S>>>
 export function live<F extends AnyFamily, Events extends ReadonlyArray<AnyEvent>>(
   reducer: FamilyReducerClass<F, Events>,
   fold: (entry: FamilyValue<F>, event: EventType<Events[number]>) => FamilyValue<F> | Tombstone,
-): Layer.Layer<never, never, Reducers | FamilyStore<FamilyKey<F>, FamilyValue<F>>>
+): Layer.Layer<
+  never,
+  never,
+  Reducers | StateFamilyStore<FamilyName<F>, FamilyKey<F>, FamilyValue<F>>
+>
 export function live(
-  reducer:
-    | StateReducerClass<AnyState, ReadonlyArray<AnyEvent>>
-    | FamilyReducerClass<AnyFamily, ReadonlyArray<AnyEvent>>,
-  // oxlint-disable-next-line reform-rules/no-explicit-any-value -- overload-impl signature: `unknown` params fail contravariance against the State/Family folds (TS2394); only `any` subsumes both
-  fold: (acc: AnyValue, event: AnyValue) => AnyValue,
-): Layer.Layer<never, never, AnyValue> {
+  reducer: RuntimeReducerClass,
+  fold: ErasedFold,
+): Layer.Layer<never, never, unknown> {
   const { config, handles } = reducer
   const name = reducer.manifest.name
   return Layer.scopedDiscard(
     Effect.gen(function* () {
       const reducers = yield* Reducers
-      if (reducers.entries.some((existing) => existing.name === name)) {
+      if (reducers.byName.has(name)) {
         yield* Effect.logWarning(`reform: duplicate reducer name '${name}' registered`)
       }
       const entry: ReducerEntry = yield* Effect.gen(function* () {
         if ('family' in config) {
-          const family = yield* config.family.store
-          return {
-            name,
-            handles,
-            apply: (event: Tagged) => {
-              const key = config.keyOf(narrowHandled(event))
-              const next = fold(family.at(key).get(), event)
-              if (next === Tombstone) {
-                family.forget(key)
-              } else {
-                family.at(key).set(sync(next))
-              }
-            },
-          }
+          return yield* config.family.capture<Effect.Effect<ReducerEntry, never, unknown>>(
+            (familyDefinition) =>
+              Effect.map(familyDefinition.store, (family) => ({
+                name,
+                handles,
+                apply: (event: Tagged) => {
+                  // The loop calls entries only for handled events. At this
+                  // existential boundary the family's decoders restore the
+                  // exact key/value types before either touches its store.
+                  const key = familyDefinition.decodeKeySync(
+                    sync(Reflect.apply(config.keyOf, undefined, [narrowHandled(event)])),
+                  )
+                  const previous = family.at(key).get()
+                  const next = sync(Reflect.apply(fold, undefined, [previous, event]))
+                  if (next === Tombstone) {
+                    family.forget(key)
+                  } else if (next !== previous) {
+                    // Same-reference return means "no change": skip the nominal re-decode,
+                    // which would mint a fresh value and repaint every tracker of this slice.
+                    family.at(key).set(familyDefinition.decodeValueSync(next))
+                  }
+                },
+              })),
+          )
         }
-        const store = yield* config.states[0].store
-        return { name, handles, apply: (event: Tagged) => store.set(sync(fold(store.get(), event))) }
+        return yield* config.states[0].capture<Effect.Effect<ReducerEntry, never, unknown>>(
+          (state) =>
+            Effect.map(state.store, (store) => ({
+              name,
+              handles,
+              apply: (event: Tagged) => {
+                const previous = store.get()
+                const next = sync(Reflect.apply(fold, undefined, [previous, event]))
+                // Same-reference return means "no change": skip the nominal re-decode,
+                // which would mint a fresh value and repaint every tracker of this slice.
+                if (next === previous) {
+                  return
+                }
+                store.set(state.decodeUnknownSync(next))
+              },
+            })),
+        )
       })
-      yield* Effect.acquireRelease(Effect.sync(() => reducers.register(entry)), () =>
-        Effect.sync(() => reducers.unregister(entry)),
+      yield* Effect.acquireRelease(
+        Effect.sync(() => reducers.register(entry)),
+        () => Effect.sync(() => reducers.unregister(entry)),
       )
     }),
   )