@playfast/reform 0.0.4 → 0.0.7

package/src/runtime/loop.ts

@@ -1,169 +0,0 @@
-import { Chunk, Context, Effect, Layer, PubSub, Queue } from 'effect'
-import {
-  Channels,
-  channelsLayer,
-  Procedures,
-  proceduresLayer,
-} from '../channel/channel'
-import { notificationsLayer } from '../internal/scheduler'
-import { Bus, busLayer, type Envelope, type Tagged } from './bus'
-
-/**
- * A registered reducer, with its target store(s) already captured at
- * registration. `apply` is a pure synchronous write, so the loop needs no
- * state services in its own context — it just routes events to writers.
- */
-export interface ReducerEntry {
-  /** The reducer's name — used only to warn on duplicate registration. */
-  readonly name: string
-  readonly handles: ReadonlySet<string>
-  readonly apply: (event: Tagged) => void
-}
-
-/**
- * Mutable collector the central loop drains; reducer `.live` layers register
- * here. `byTag` indexes entries by the event tags they handle, so dispatch is
- * O(matching reducers) per event rather than O(all reducers) — the difference
- * that matters once an app has hundreds of reducers.
- */
-export interface ReducerRegistry {
-  readonly entries: Array<ReducerEntry>
-  readonly byTag: Map<string, Array<ReducerEntry>>
-  readonly register: (entry: ReducerEntry) => void
-  /**
-   * Remove a previously-registered entry. Eager reducers (built on the root scope)
-   * never call this; a lazy feature's `Reducer.live` registers on mount and
-   * unregisters on unmount (scope close), so an unmounted feature stops folding and
-   * its entry is reclaimed instead of leaking + writing to an orphaned store.
-   */
-  readonly unregister: (entry: ReducerEntry) => void
-}
-
-export class Reducers extends Context.Tag('reform/Reducers')<Reducers, ReducerRegistry>() {}
-
-/** Drop an item from a `Map<string, Array>` bucket, pruning the key when it empties. */
-const dropFromBuckets = <T>(map: Map<string, Array<T>>, key: string, item: T): void => {
-  const bucket = map.get(key)
-  if (bucket === undefined) return
-  const next = bucket.filter((entry) => entry !== item)
-  if (next.length === 0) map.delete(key)
-  else map.set(key, next)
-}
-
-const makeReducerRegistry = (): ReducerRegistry => {
-  const entries: Array<ReducerEntry> = []
-  const byTag = new Map<string, Array<ReducerEntry>>()
-  return {
-    entries,
-    byTag,
-    register: (entry) => {
-      entries.push(entry)
-      for (const tag of entry.handles) {
-        const bucket = byTag.get(tag)
-        if (bucket === undefined) byTag.set(tag, [entry])
-        else bucket.push(entry)
-      }
-    },
-    unregister: (entry) => {
-      const index = entries.indexOf(entry)
-      if (index >= 0) entries.splice(index, 1)
-      for (const tag of entry.handles) dropFromBuckets(byTag, tag, entry)
-    },
-  }
-}
-
-export const reducersLayer = Layer.sync(Reducers, makeReducerRegistry)
-
-/** High before Normal; within a priority class, dispatch order is preserved. */
-const rank = (priority: Envelope['priority']): number => (priority === 'High' ? 0 : 1)
-
-// The single drain loop: one fiber that frame-batches the bus. Each tick it
-// harvests every event dispatched in that microtask, runs all matching reducers
-// in ONE synchronous pass (so the store notifier flushes once for the batch),
-// then routes each event to the channels its procedures run on.
-const drain = Effect.gen(function* () {
-  const bus = yield* Bus
-  const reducers = yield* Reducers
-  const { byName: channels } = yield* Channels
-  const procedures = yield* Procedures
-  const subscription = yield* PubSub.subscribe(bus)
-
-  yield* Effect.forkScoped(
-    Effect.forever(
-      Effect.gen(function* () {
-        // Block until the first event, then drain the rest of this tick.
-        const first = yield* Queue.take(subscription)
-        const rest = yield* Queue.takeAll(subscription)
-        const frame = [first, ...Chunk.toArray(rest)]
-
-        // Stable priority order: High-dispatched (UI) events fold before
-        // Normal-dispatched (procedure follow-up) events in the same frame. A
-        // two-bucket partition does this in O(m) with no comparator — push order
-        // preserves intra-priority dispatch order — instead of sorting the frame.
-        const high: Array<Envelope> = []
-        const normal: Array<Envelope> = []
-        for (const envelope of frame) {
-          if (rank(envelope.priority) === 0) high.push(envelope)
-          else normal.push(envelope)
-        }
-        const ordered = high.concat(normal)
-
-        // One synchronous block: every reducer write for the frame coalesces into
-        // a single notification flush. Routing to channels happens here too, so
-        // procedure bodies (run later, off their channel fibers) see post-batch
-        // state. No `yield*` in between, or the flush could fire early.
-        const failures: Array<{ readonly event: Tagged; readonly error: unknown }> = []
-        yield* Effect.sync(() => {
-          for (const envelope of ordered) {
-            for (const reducer of reducers.byTag.get(envelope.event._tag) ?? []) {
-              // Isolate each fold: a synchronous throw in one reducer must not
-              // abandon the rest of the frame nor (via the `forever` below) kill
-              // the drain fiber and freeze the whole app. Collect and log after.
-              try {
-                reducer.apply(envelope.event)
-              } catch (error) {
-                failures.push({ event: envelope.event, error })
-              }
-            }
-          }
-          for (const envelope of ordered) {
-            // Offer to each DISTINCT channel once. Routing per-procedure would
-            // offer a shared channel multiple times for one event, and each offer
-            // re-runs every procedure on it — duplicate execution.
-            for (const channelName of procedures.channelsByTag.get(envelope.event._tag) ?? []) {
-              channels.get(channelName)?.offer(envelope.event)
-            }
-          }
-        })
-        yield* Effect.forEach(
-          failures,
-          (failure) =>
-            Effect.logError(
-              `reform: reducer threw handling '${failure.event._tag}'`,
-              failure.error,
-            ),
-          { discard: true },
-        )
-      }).pipe(
-        // Belt-and-suspenders: even a defect outside the isolated fold (a bug in
-        // the loop itself) is logged and the tick restarts, so the bus never goes
-        // permanently deaf.
-        Effect.catchAllCause((cause) => Effect.logError('reform: drain tick crashed', cause)),
-      ),
-    ),
-  )
-})
-
-/**
- * The reform engine: provides the bus + reducer/channel/procedure registries +
- * the per-runtime notification scheduler to the application and forks the single
- * drain loop. Registration mutates the live collections, so reducers/procedures/
- * channels merged alongside are picked up before the first dispatch (boot).
- */
-export const Engine: Layer.Layer<Bus | Reducers | Channels | Procedures> = Layer.scopedDiscard(
-  drain,
-).pipe(
-  Layer.provideMerge(
-    Layer.mergeAll(busLayer, reducersLayer, channelsLayer, proceduresLayer, notificationsLayer),
-  ),
-)

package/src/scene/scene.ts

@@ -1,76 +0,0 @@
-import { Layer } from 'effect'
-import type { CompositionClass, CompositionService } from '../compose/composition'
-import type { UiContract } from '../compose/ui'
-import { CurrentSeedOverrides } from '../internal/seeds'
-import type { Bus, Tagged } from '../runtime/bus'
-
-// A scene is a VALUE — a composition plus the closed wiring that runs it: the
-// layers that supply its logic/views (each seeding its own live state) and the
-// boot events to dispatch once the runtime is live. Nothing self-registers on
-// import. A scene is the single handle every consumer takes instead of a bare
-// composition: the react host renders it, a proof runs against it, and the dev
-// tool previews it — all from the same closed `provide`.
-//
-// There is no seeded-`state` dict: variation (Default/Empty/Errored) comes from
-// providing different closed layers, exactly as production wiring does. The
-// composition's contract `C` is preserved (not erased to `unknown`) so a proof's
-// facade stays fully typed from `scene.composition`.
-
-/**
- * The services a built reform runtime exposes to its host: every composition's
- * logic and the event `Bus`. A scene's `provide` must close to these (a fully
- * wired app layer provides far more; this is the subset hosts read directly).
- */
-export type MountedServices = CompositionService | Bus
-
-export interface Scene<C extends UiContract = UiContract> {
-  readonly kind: 'Scene'
-  /** The composition to run, with its contract preserved for typed consumers. */
-  readonly composition: CompositionClass<unknown, C>
-  /** Closed wiring (logic + views), each layer seeding its own live state. */
-  readonly provide: ReadonlyArray<Layer.Layer<MountedServices, never, never>>
-  /** Events dispatched once the runtime is live (e.g. `RequestedTodos`). */
-  readonly boot?: ReadonlyArray<Tagged>
-}
-
-/**
- * Define a scene — `scene(TodoApp, { provide: [makeTestApp(client, seeds)] })`.
- * The composition's contract flows through `C`, so consumers stay typed.
- */
-export const scene = <C extends UiContract>(
-  composition: CompositionClass<unknown, C>,
-  config: {
-    readonly provide: ReadonlyArray<Layer.Layer<MountedServices, never, never>>
-    readonly boot?: ReadonlyArray<Tagged>
-  },
-): Scene<C> => ({
-  kind: 'Scene',
-  composition,
-  provide: config.provide,
-  ...(config.boot !== undefined ? { boot: config.boot } : {}),
-})
-
-/**
- * Overlay seed values onto a CLOSED scene — the tooling/test seam (dev-tool
- * inspector overrides, proofs). Scenes stay closed for authors: this does not
- * reopen `provide`, it wraps each layer with `Layer.locally(CurrentSeedOverrides,
- * seeds)` so `State.live` boots matching stores from the override instead of
- * the authored seed.
- *
- * Keys are state MEMBER NAMES as reflected in `manifest.states` (e.g. `count`),
- * not group names. If two groups in one scene share a member name, both receive
- * the override (documented limitation). Values are schema-validated at build:
- * an invalid value silently falls back to the authored seed. `StateFamily`
- * entries are not covered.
- */
-export const seedScene = <C extends UiContract>(
-  base: Scene<C>,
-  seeds: Readonly<Record<string, unknown>>,
-): Scene<C> =>
-  Object.keys(seeds).length === 0
-    ? base
-    : { ...base, provide: base.provide.map(Layer.locally(CurrentSeedOverrides, seeds)) }
-
-/** Reflection guard: is this exported value a scene? */
-export const isScene = (v: unknown): v is Scene =>
-  typeof v === 'object' && v !== null && (v as { readonly kind?: unknown }).kind === 'Scene'

package/src/state/state.ts

@@ -1,91 +0,0 @@
-import { Context, Effect, FiberRef, Layer, Option, Schema } from 'effect'
-import { type Manifest, yieldableClass } from '../definition/definition'
-import { resolveScheduler } from '../internal/scheduler'
-import { CurrentSeedOverrides } from '../internal/seeds'
-import { makeStore, type Store } from '../internal/store'
-import { readTracked } from '../internal/track'
-
-export interface StateOptions {
-  readonly title?: string
-  readonly description?: string
-}
-
-export interface StateManifest<N extends string, A> extends Manifest {
-  readonly kind: 'State'
-  readonly name: N
-  readonly schema: Schema.Schema<A, any>
-  readonly title?: string
-  readonly description?: string
-}
-
-export interface StateClass<out N extends string, in out A> extends Effect.Effect<A, never, Store<A>> {
-  new (): {}
-  readonly manifest: StateManifest<N, A>
-  /** Internal DI tag holding the live store. The loop reads/writes through it. */
-  readonly store: Context.Tag<Store<A>, Store<A>>
-}
-
-export type AnyState = StateClass<string, any>
-export type StateValue<S> = S extends StateClass<string, infer A> ? A : never
-export type StateName<S> = S extends StateClass<infer N, any> ? N : never
-
-/**
- * Atomic reactive state. `State.make` is the *definition* (a reflectable
- * manifest + an internal store tag); it carries no starting value — the seed is
- * an implementation detail supplied at create-time by `State.live(state, seed)`.
- * Composed into a `StateGroup` exactly as `@effect/rpc` composes rpcs.
- */
-export const make = <const N extends string, A>(
-  name: N,
-  schema: Schema.Schema<A, any>,
-  options: StateOptions = {},
-): StateClass<N, A> => {
-  const store = Context.GenericTag<Store<A>, Store<A>>(`reform/state/${name}`)
-  const manifest: StateManifest<N, A> = {
-    kind: 'State',
-    name,
-    schema,
-    ...(options.title !== undefined ? { title: options.title } : {}),
-    ...(options.description !== undefined ? { description: options.description } : {}),
-  }
-  const read = Effect.flatMap(store, readTracked)
-  return yieldableClass(read, { manifest, store })
-}
-
-/**
- * Resolve the value a store should boot from: the ambient seed override when
- * one is present (and valid) for this state's member name, else the authored
- * `initial`. Reads `CurrentSeedOverrides` — empty outside the tooling seam
- * (`Scene.seedScene`), so production wiring always boots from `initial`. An
- * override is decoded against the state's schema; an invalid value silently
- * falls back to `initial` — a half-typed override from the dev tool must never
- * crash a preview.
- */
-const resolveSeed = <S extends AnyState>(
-  state: S,
-  initial: StateValue<S>,
-): Effect.Effect<StateValue<S>> =>
-  Effect.map(FiberRef.get(CurrentSeedOverrides), (overrides) =>
-    state.manifest.name in overrides
-      ? Option.getOrElse(
-          Schema.decodeUnknownOption(state.manifest.schema)(overrides[state.manifest.name]),
-          () => initial,
-        )
-      : initial,
-  )
-
-/**
- * Allocate a state's store, seeded with `initial` — `State.live(Feed, seed)`.
- * The seed lives here (implementation), not on the definition, so the same
- * definition can boot from different values in app vs. test wiring.
- */
-export const live = <S extends AnyState>(
-  state: S,
-  initial: StateValue<S>,
-): Layer.Layer<Store<StateValue<S>>> =>
-  Layer.effect(
-    state.store,
-    Effect.zipWith(resolveScheduler, resolveSeed(state, initial), (scheduler, seed) =>
-      makeStore(seed, scheduler),
-    ),
-  )

package/src/state/stateFamily.ts

@@ -1,171 +0,0 @@
-import { Context, Effect, Layer, type Schema } from 'effect'
-import { type Manifest, definitionClass } from '../definition/definition'
-import { resolveScheduler, type Scheduler } from '../internal/scheduler'
-import { makeStore, type Store } from '../internal/store'
-import { readTracked } from '../internal/track'
-
-/**
- * A reducer fold returns this to evict the key it folded over, instead of a new
- * value. The loop drops the entry's store from the family, so a normalized
- * collection (chat messages, search hits, transient rows) does not grow without
- * bound — the one fix for the otherwise-unbounded per-key `Map`.
- */
-export const Tombstone: unique symbol = Symbol.for('reform/StateFamily/Tombstone')
-export type Tombstone = typeof Tombstone
-
-/** Per-key stores, created lazily so a write to one key wakes only its subscribers. */
-export interface FamilyStore<K, V> {
-  at(key: K): Store<V>
-  /**
-   * Drop a key's store so it stops occupying memory. A live subscriber keeps its
-   * own closure over the previous store, so eviction is for keys whose entity is
-   * gone (the component is unmounting) — re-`at`-ing the key allocates a fresh,
-   * reseeded store.
-   */
-  forget(key: K): void
-  /** Drop every key's store — a wholesale reset of the family. */
-  clear(): void
-  /** Number of live keys — for tests/diagnostics. */
-  size(): number
-}
-
-/** Options for a family's keyed store. */
-export interface FamilyOptions {
-  /**
-   * Drop a key's store automatically once it has no live subscribers (checked on
-   * the next microtask, so a same-commit re-subscribe — e.g. a key that just moved
-   * position in a list — cancels the eviction). This bounds an otherwise-unbounded
-   * family without explicit `Tombstone`s, but it also DISCARDS the key's value —
-   * re-`at`-ing a dropped key reseeds from `initial`. Use only for keys whose value
-   * is disposable when nothing renders them (search hits, transient rows); for a
-   * source-of-truth entity that may be temporarily off-screen (a virtualized list),
-   * keep this off and reclaim with an explicit reducer `Tombstone`. Default: off.
-   */
-  readonly evictWhenUnused?: boolean
-}
-
-const makeFamilyStore = <K, V>(
-  seed: (key: K) => V,
-  scheduler: Scheduler,
-  options: FamilyOptions = {},
-): FamilyStore<K, V> => {
-  const entries = new Map<K, Store<V>>()
-  const evictWhenUnused = options.evictWhenUnused === true
-  // Live subscriber count per key — maintained only when eviction is on.
-  const subscribers = new Map<K, number>()
-
-  // Wrap a store's `subscribe` to ref-count, evicting the key when it falls idle.
-  // `get`/`set`/`getVersion` are delegated unchanged, so the loop writes and the
-  // host reads see the same cell; only subscribe/unsubscribe are instrumented.
-  const refCounted = (key: K, store: Store<V>): Store<V> => ({
-    ...store,
-    subscribe: (listener) => {
-      subscribers.set(key, (subscribers.get(key) ?? 0) + 1)
-      const off = store.subscribe(listener)
-      const released = { done: false }
-      return () => {
-        if (released.done) return
-        released.done = true
-        off()
-        const remaining = (subscribers.get(key) ?? 1) - 1
-        if (remaining > 0) {
-          subscribers.set(key, remaining)
-          return
-        }
-        subscribers.delete(key)
-        queueMicrotask(() => {
-          if ((subscribers.get(key) ?? 0) === 0) entries.delete(key)
-        })
-      }
-    },
-  })
-
-  return {
-    at: (key) => {
-      const existing = entries.get(key)
-      if (existing !== undefined) return existing
-      const base = makeStore(seed(key), scheduler)
-      const created = evictWhenUnused ? refCounted(key, base) : base
-      entries.set(key, created)
-      return created
-    },
-    forget: (key) => {
-      entries.delete(key)
-      subscribers.delete(key)
-    },
-    clear: () => {
-      entries.clear()
-      subscribers.clear()
-    },
-    size: () => entries.size,
-  }
-}
-
-export interface StateFamilyManifest<N extends string, K, V> extends Manifest {
-  readonly kind: 'StateFamily'
-  readonly name: N
-  readonly key: Schema.Schema<K, any>
-  readonly value: Schema.Schema<V, any>
-  readonly title?: string
-  readonly description?: string
-}
-
-export interface StateFamilyClass<out N extends string, in out K, in out V> {
-  /** Instance carries the key phantom so `Family['Key']` resolves in `keyOf` types. */
-  new (): { readonly Key: K }
-  readonly manifest: StateFamilyManifest<N, K, V>
-  readonly store: Context.Tag<FamilyStore<K, V>, FamilyStore<K, V>>
-}
-
-export type AnyFamily = StateFamilyClass<string, any, any>
-export type FamilyKey<F> = F extends StateFamilyClass<any, infer K, any> ? K : never
-export type FamilyValue<F> = F extends StateFamilyClass<any, any, infer V> ? V : never
-
-/**
- * Normalized keyed state: one logical State per key, backed by a single family
- * store. Scales with the collection without re-rendering unrelated entries.
- */
-export const make = <const N extends string, K, V>(
-  name: N,
-  key: Schema.Schema<K, any>,
-  value: Schema.Schema<V, any>,
-  options: { readonly title?: string; readonly description?: string } = {},
-): StateFamilyClass<N, K, V> => {
-  const store = Context.GenericTag<FamilyStore<K, V>, FamilyStore<K, V>>(`reform/family/${name}`)
-  const manifest: StateFamilyManifest<N, K, V> = {
-    kind: 'StateFamily',
-    name,
-    key,
-    value,
-    ...(options.title !== undefined ? { title: options.title } : {}),
-    ...(options.description !== undefined ? { description: options.description } : {}),
-  }
-  return definitionClass<StateFamilyClass<N, K, V>>({ manifest, store })
-}
-
-/**
- * Read one entry by key — `StateFamily.read(ItemUi, id)`. Inside a render it
- * subscribes that key's slice; elsewhere it just snapshots (D5).
- */
-export const read = <N extends string, K, V>(
-  family: StateFamilyClass<N, K, V>,
-  key: K,
-): Effect.Effect<V, never, FamilyStore<K, V>> =>
-  Effect.flatMap(family.store, (fs) => readTracked(fs.at(key)))
-
-/**
- * Allocate a family's keyed store — `StateFamily.live(ItemUi, seed)`. The seed
- * is a plain value or a factory; a factory receives the key, so a new entry can
- * derive its starting value from its own id (`(id) => ({ ...blank, id }))`).
- */
-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>> => {
-  const seed: (key: K) => V = typeof initial === 'function' ? (initial as (key: K) => V) : () => initial
-  return Layer.effect(
-    family.store,
-    Effect.map(resolveScheduler, (scheduler) => makeFamilyStore<K, V>(seed, scheduler, options)),
-  )
-}

package/src/state/stateGroup.ts

@@ -1,78 +0,0 @@
-import { Layer } from 'effect'
-import { definitionClass } from '../definition/definition'
-import { UnknownGroupState } from '../internal/errors'
-// A group's members each carry a `store` tag, so the shared `StoresOf` (used for
-// calc inputs too) distributes them into the union of distinct stores their
-// `live` layer provides — no group-specific mapped type needed.
-import { type StoresOf } from '../internal/sources'
-import { type AnyState, live as stateLive, type StateClass, type StateName } from './state'
-import { StateToken } from './token'
-
-type ValueForName<Members extends ReadonlyArray<AnyState>, N extends string> =
-  Extract<Members[number], StateClass<N, any>> extends StateClass<any, infer A> ? A : never
-
-export interface StateGroupClass<Members extends ReadonlyArray<AnyState>> {
-  new (): {}
-  readonly kind: 'StateGroup'
-  readonly members: Members
-  /** Members indexed by name, so `select` is an O(1) lookup instead of a scan. */
-  readonly byName: ReadonlyMap<string, AnyState>
-}
-
-export type AnyStateGroup = StateGroupClass<ReadonlyArray<AnyState>>
-
-// The seed record `StateGroup.live` requires: one entry per member, keyed by the
-// member's name and typed to that member's value (so a missing or mistyped seed
-// is a compile error). Written against the group class, so call sites read
-// `GroupSeeds<typeof TodosStates>`.
-export type GroupSeeds<G extends AnyStateGroup> =
-  G extends StateGroupClass<infer Members>
-    ? { readonly [N in StateName<Members[number]>]: ValueForName<Members, N> }
-    : never
-
-/** Compose atomic States into a group provided (and addressed) as a unit. */
-export const make = <const Members extends ReadonlyArray<AnyState>>(
-  ...members: Members
-): StateGroupClass<Members> =>
-  definitionClass<StateGroupClass<Members>>({
-    kind: 'StateGroup' as const,
-    members,
-    byName: new Map(members.map((m) => [m.manifest.name, m] as const)),
-  })
-
-/**
- * Address a member by its tag — `StateGroup.select(TodosStates, 'feed')` —
- * yielding a `StateToken` for reads and calc inputs (still `yield*`-able).
- *
- * Data-first only (not `dual`): the member name's type depends on the group, and
- * a group is not `Pipeable`, so a data-last form would be both more verbose and
- * harder to type than the direct call. Effect reserves `dual` for operators on a
- * `Pipeable` self with an independent value arg (e.g. `ref.pipe(Ref.set(v))`);
- * this is not that shape.
- */
-export const select = <Members extends ReadonlyArray<AnyState>, N extends StateName<Members[number]>>(
-  group: StateGroupClass<Members>,
-  name: N,
-): StateToken<N, ValueForName<Members, N>> => {
-  const member = group.byName.get(name)
-  if (member === undefined) throw new UnknownGroupState({ name })
-  return new StateToken(name, member.store) as StateToken<N, ValueForName<Members, N>>
-}
-
-/**
- * Allocate every member's store as one merged layer, each seeded from `seeds`
- * keyed by member name — `StateGroup.live(BoardStates, { board: { _tag: 'Idle' } })`.
- */
-export const live = <Members extends ReadonlyArray<AnyState>>(
-  group: StateGroupClass<Members>,
-  seeds: GroupSeeds<StateGroupClass<Members>>,
-): Layer.Layer<StoresOf<Members>> => {
-  // Index the typed seed record by the member's runtime name — a genuine
-  // reflection boundary (string key into a mapped type). Each member's store
-  // layer is then merged; the union of stores is exactly `StoresOf<Members>`,
-  // which `reduce`'s single-layer accumulator can't express, so restate it.
-  const seedRecord = seeds as Record<string, unknown>
-  return group.members
-    .map((m) => stateLive(m, seedRecord[m.manifest.name]))
-    .reduce((a, b) => Layer.merge(a, b)) as Layer.Layer<StoresOf<Members>>
-}