@playfast/reform 1.0.1 → 1.2.0

package/src/reducer/reducer.ts

@@ -2,19 +2,18 @@ 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'
 
-/** The reflectable descriptor a reducer carries, like every other primitive's `*Manifest`. */
 export interface ReducerManifest extends Manifest {
   readonly kind: 'Reducer'
 }
@@ -33,7 +32,6 @@ export interface FamilyReducerConfig<F extends AnyFamily, Events extends Readonl
 export interface StateReducerClass<S extends AnyState, Events extends ReadonlyArray<AnyEvent>> {
   new (): {}
   readonly manifest: ReducerManifest
-  /** Marker data read by `Reducer.live`. */
   readonly config: StateReducerConfig<S, Events>
   readonly handles: ReadonlySet<string>
 }
@@ -45,12 +43,26 @@ export interface FamilyReducerClass<F extends AnyFamily, Events extends Readonly
   readonly handles: ReadonlySet<string>
 }
 
-/**
- * Reducers are the only writers of state. The *definition* (`Reducer.make`)
- * declares which state and events it touches; the *implementation*
- * (`Reducer.live`) is the pure fold. An unhandled event is a no-op because
- * it is never in `handles`.
- */
+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>,
@@ -61,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,
@@ -72,11 +82,9 @@ export function make(
   })
 }
 
-/** A thenable check that excludes null/undefined without an assertion. */
 const isThenable = (candidate: unknown): candidate is PromiseLike<unknown> =>
   Predicate.isRecord(candidate) && typeof candidate['then'] === 'function'
 
-/** Reject an accidentally-async fold up front: a reducer must be a pure sync write. */
 const sync = <A>(candidate: A): A => {
   if (isThenable(candidate)) {
     // oxlint-disable-next-line reform-rules/no-throw -- sync reducer-write boundary can't yield an Effect; an async fold is a programmer defect
@@ -88,57 +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: any, event: any) => any,
-): Layer.Layer<never, never, any> {
+  reducer: RuntimeReducerClass,
+  fold: ErasedFold,
+): Layer.Layer<never, never, unknown> {
   const { config, handles } = reducer
   const name = reducer.manifest.name
-  // Scoped registration: register on build, unregister on scope close. For an eager
-  // app the scope is the root runtime's (closes only at dispose), so behavior is
-  // unchanged; for a lazy feature the scope is the feature's, so unmount removes the
-  // entry — it stops folding and is reclaimed instead of leaking onto a dead store.
   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) => {
-              // The loop only invokes `apply` for events in `handles`, so `event`
-              // is one of this reducer's declared events; `narrowHandled` restores
-              // that typed view from the erased `Tagged` envelope `keyOf` is fed.
-              const key = config.keyOf(narrowHandled(event))
-              const next = fold(family.at(key).get(), event)
-              // A fold may return the eviction sentinel to drop the key's store
-              // (bounding an otherwise-unbounded family) instead of a new value.
-              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)),
       )
     }),
   )