@playfast/reform 1.1.1 → 1.2.1

package/src/internal.ts

@@ -0,0 +1,222 @@
+// Quarantined surface for first-party hosts and companion packages
+// (`@playfast/reform-*`): reflection/manifest types, TypeIds, erased `Any*`
+// forms, capture callbacks, and runtime seams. Importable as
+// `@playfast/reform/internal`; not part of the app-facing API and not covered
+// by its stability expectations.
+
+export {
+  type AnyState,
+  type StateCapture,
+  type StateDefinition,
+  type StateManifest,
+  type StateName,
+  type StateSchemaReflection,
+  StateStoreTypeId,
+} from './state/state'
+export {
+  type AnyFamily,
+  type FamilyName,
+  type FamilySchemaReflection,
+  type FamilyStore,
+  type StateFamilyCapture,
+  type StateFamilyManifest,
+  StateFamilyStoreTypeId,
+} from './state/stateFamily'
+export { StateToken } from './state/token'
+export type {
+  AnySource,
+  Source,
+  SourceCapture,
+  SourceIdentifier,
+  SourceName,
+  SourceValue,
+} from './state/token'
+export type {
+  AnyEvent,
+  EventCapture,
+  EventManifest,
+  EventName,
+  EventReflection,
+  EventSchemaReflection,
+  EventType,
+} from './event/event'
+export { CalcStoreTypeId } from './calc/calc'
+export { CalcFamilyStoreTypeId } from './calc/calcFamily'
+export { AsyncCalcStoreTypeId } from './calc/asyncCalc'
+export { sameKey, type WiredSources, wireSources } from './internal/sources'
+// Optional host seams an `AsyncCalc` consults — persistence and lifecycle signals.
+// Concrete implementations live in edge packages (e.g. `@playfast/reform-query-browser`).
+export {
+  noopQueryStore,
+  QueryStore,
+  type QueryStoreApi,
+  resolveQueryStore,
+} from './internal/queryStore'
+export {
+  noopQueryEvents,
+  QueryEvents,
+  type QueryEventsApi,
+  resolveQueryEvents,
+} from './internal/queryEvents'
+export {
+  RemoteStatePendingStoreTypeId,
+  RemoteStateTruthStoreTypeId,
+  RemoteStateVisibleStoreTypeId,
+} from './remote/remoteState'
+export { SyncedStoreIdentifierTypeId } from './synced/syncedStore'
+export { BoundaryStoreTypeId } from './boundary/boundary'
+export type {
+  AnyProcedure,
+  ProcedureCapture,
+  ProcedureManifest,
+  ProcedureReflection,
+} from './procedure/procedure'
+export {
+  type ChannelRuntime,
+  Channels,
+  channelsLayer,
+  type ProcedureEntry,
+  Procedures,
+  proceduresLayer,
+} from './channel/channel'
+export { CompositionIdTypeId } from './compose/composition'
+export type {
+  AnyComposition,
+  CompositionCapture,
+  CompositionManifest,
+  CompositionPropsReceiver,
+  CompositionReflection,
+  CompositionTag,
+  HasExactCompositionId,
+  RequiredSlotIdentities,
+  SlotClassesOf,
+} from './compose/composition'
+export { StructureTypeId } from './compose/structure'
+export { type PropsId, PropsIdTypeId, type PropsTag, propsTag } from './compose/props'
+export {
+  type AnySlot,
+  type AnySlotChild,
+  type AnySlotInstance,
+  type SlotCapture,
+  type SlotChild,
+  type SlotManifest,
+  SlotServiceTypeId,
+  SlotTypeId,
+} from './compose/slot'
+export type { SlotRenderer } from './compose/host'
+export {
+  type AnyMadeView,
+  type AnyUi,
+  type MadeViewCapture,
+  type UiCapture,
+  type UiManifest,
+  type UiName,
+  type UiReflection,
+  type UiSchemaReflection,
+  UiServiceTypeId,
+  UiTypeId,
+  type WiredUi,
+  type WiredUiManifest,
+  type WireSchemas,
+} from './compose/ui'
+
+// Wire: the serializable rendered-tree model + pure diff/apply the remote
+// transport sends over the wire and the client folds back. See REMOTE_UI.md §3.
+export * as Wire from './wire/tree'
+export type { WireNode, WirePatch, WireProp, WireTree } from './wire/tree'
+// Triggers: the server-side handle registry bridging client trigger invocations
+// back to live triggers, decoding payloads via the event schema. See REMOTE_UI.md §4.
+export * as Triggers from './wire/triggers'
+export {
+  type TriggerHandle,
+  TriggerRegistry,
+  type TriggerRegistryApi,
+  UnknownTrigger,
+} from './wire/triggers'
+
+export {
+  type AnyFeatureBinding,
+  type AnyLoadedModule,
+  type CapturedFeatureBinding,
+  type FeatureBinding,
+  type FeatureBindingCapture,
+  FeatureBindingTypeId,
+  type FeatureDefinition,
+  FeatureGraphValidTypeId,
+  type FeatureIdentityToken,
+  FeatureInput,
+  type FeatureManifest,
+  featureModuleFromInput,
+  type FeatureMountProps,
+  type FeatureOpenServices,
+  type FeatureRequirement,
+  type FeatureSupportOpenServices,
+  type FeatureToken,
+  type FeatureTreeCarrier,
+  type LoadedModule,
+  type LoadedModuleCapture,
+  mountFeature,
+  type ProvideableFeature,
+  type ProvidedBy,
+  type RequireCarrier,
+} from './feature/feature'
+export {
+  type CompositionChildSummary,
+  CompositionChildSummaryTypeId,
+  type DescendantOpenServices,
+  type FeatureChildSummary,
+  FeatureChildSummaryTypeId,
+  type ModuleOpenServices,
+  type OpenServicesFromFeatureSlotWitnesses,
+  type SlotBindingSummary,
+  SlotBindingSummaryTypeId,
+  type ValidateFeatureGraphLayer,
+} from './graph/closure'
+export { type AnyScene, type AnySceneCapture, type SceneCapture, seedAnyScene } from './scene/scene'
+export { Bus, busLayer, type Envelope, type Tagged } from './runtime/bus'
+export {
+  type AnyFeatureMountHandlers,
+  type CapturedFeatureMountHandlers,
+  type FeatureMountHandlersExternalApi,
+  type UnspecifiedRuntimeServices,
+  UnspecifiedRuntimeServicesTypeId,
+} from './runtime/appRuntime'
+export {
+  EngineRequirements,
+  type EngineServices,
+  type ReducerEntry,
+  Reducers,
+  reducersLayer,
+} from './runtime/loop'
+export { CurrentEventBudget, defaultEventBudget, resolveEventBudget } from './runtime/eventBudget'
+// The profiler SPI: synchronous hooks the engine calls on its hot paths, plus
+// the FiberRef seam `@playfast/reform-profiler` writes through (`profiledScene`).
+export {
+  CurrentInstrumentation,
+  type Instrumentation,
+  noopInstrumentation,
+  resolveInstrumentation,
+  type SpanEnd,
+} from './runtime/instrumentation'
+// The runtime-wide registry of live query handles. `AsyncCalc.invalidate` /
+// `AsyncCalc.refetch` and provider layers act on a query by name through it.
+export { Queries, queriesLayer, type QueryHandle, type QueryRegistry } from './runtime/queries'
+export { CurrentTracker, readTracked, type Subscribable, type Tracker } from './internal/track'
+export { type CapturedRender, CaptureSink, type CaptureSinkApi } from './internal/capture'
+// Notification scheduler: hosts that need per-runtime isolation (concurrent SSR,
+// multiple mounted roots) provide `Notifications` upstream of their state layers;
+// everything else coalesces on the process-wide default.
+export {
+  defaultScheduler,
+  makeScheduler,
+  Notifications,
+  notificationsLayer,
+  resolveScheduler,
+  type Scheduler,
+} from './internal/scheduler'
+export { makeStore, type Store } from './internal/store'
+// Primitive-authoring toolkit — for first-party companion packages
+// (e.g. `@playfast/reform-db`, `@playfast/reform-resource`) that build their own
+// first-class `Source`s which must participate in dependency tracking and
+// reflection exactly like a `Calc`.
+export { type Kind, type Manifest, yieldableClass } from './definition/definition'

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)),
       )
     }),
   )