@playfast/reform 1.0.1 → 1.2.0

package/src/state/state.ts

@@ -1,4 +1,5 @@
-import { Context, Effect, FiberRef, Layer, Option, Schema } from 'effect'
+import { Context, Effect, FiberRef, Layer, Option, type ParseResult, Schema } from 'effect'
+import type { Effect as EffectType } from 'effect/Effect'
 import { type Manifest, yieldableClass } from '../definition/definition'
 import { resolveScheduler } from '../internal/scheduler'
 import { CurrentSeedOverrides } from '../internal/seeds'
@@ -13,41 +14,72 @@ export interface StateOptionsExternalApi {
 }
 export type StateOptions = StateOptionsExternalApi
 
-export interface StateManifestExternalApi<N extends string, A> extends Manifest {
+// Full Schema parameters are invariant; heterogeneous manifests expose only their AST.
+export interface StateSchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface StateManifestExternalApi<N extends string> extends Manifest {
   readonly kind: 'State'
   readonly name: N
-  readonly schema: Schema.Schema<A, any>
+  readonly schema: StateSchemaReflection
   readonly title?: string
   readonly description?: string
 }
-export type StateManifest<N extends string, A> = StateManifestExternalApi<N, A>
+export type StateManifest<N extends string> = StateManifestExternalApi<N>
+
+export const StateStoreTypeId: unique symbol = Symbol.for('reform/StateStore')
+export type StateStoreTypeId = typeof StateStoreTypeId
+
+export interface StateStore<N extends string, in out A> extends Store<A> {
+  readonly [StateStoreTypeId]: N
+}
 
-export interface StateClass<out N extends string, in out A> extends Effect.Effect<A, never, Store<A>> {
+export type StateCapture<Result> = <N extends string, A>(state: StateClass<N, A>) => Result
+
+export interface AnyState {
   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>>
+  readonly manifest: StateManifest<string>
+  readonly capture: <Result>(visit: StateCapture<Result>) => Result
 }
 
-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
+interface StateStatics<N extends string, A> {
+  readonly manifest: StateManifest<N>
+  // Subclasses change the class function name; this preserves the authored source name.
+  readonly name: N
+  readonly capture: <Result>(visit: StateCapture<Result>) => Result
+  readonly store: Context.Tag<StateStore<N, A>, Store<A>>
+  readonly decodeUnknown: (input: unknown) => Effect.Effect<A, ParseResult.ParseError, never>
+  readonly decodeUnknownSync: (input: unknown) => A
+  readonly decodeUnknownOption: (input: unknown) => Option.Option<A>
+}
 
-/**
- * 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>(
+export interface StateClass<N extends string, A>
+  extends EffectType<A, never, StateStore<N, A>>, StateStatics<N, A> {
+  new (): {}
+}
+
+export type StateDefinition<
+  N extends string,
+  A,
+  StateSchema extends Schema.Schema.AnyNoContext,
+> = StateClass<N, A> & {
+  readonly manifest: StateManifest<N> & { readonly schema: StateSchema }
+}
+
+export type StateValue<S> = S extends StateClass<infer _N, infer A> ? A : never
+export type StateName<S> = S extends StateClass<infer N, infer _A> ? N : never
+
+export const make = <const N extends string, StateSchema extends Schema.Schema.AnyNoContext>(
   name: N,
-  schema: Schema.Schema<A, any>,
+  schema: StateSchema,
   options: StateOptions = {},
-): StateClass<N, A> => {
+): StateDefinition<N, Schema.Schema.Type<StateSchema>, StateSchema> => {
+  type A = Schema.Schema.Type<StateSchema>
   const identifier = `reform/state/${name}`
   claimStateTag(identifier)
-  const store = Context.GenericTag<Store<A>, Store<A>>(identifier)
-  const manifest: StateManifest<N, A> = {
+  const store = Context.GenericTag<StateStore<N, A>, Store<A>>(identifier)
+  const manifest: StateManifest<N> & { readonly schema: StateSchema } = {
     kind: 'State',
     name,
     schema,
@@ -55,39 +87,41 @@ export const make = <const N extends string, A>(
     ...(options.description !== undefined ? { description: options.description } : {}),
   }
   const read = Effect.flatMap(store, readTracked)
-  return yieldableClass(read, { manifest, store })
+  const state: StateDefinition<N, A, StateSchema> = yieldableClass<
+    A,
+    never,
+    StateStore<N, A>,
+    StateStatics<N, A> & {
+      readonly manifest: StateManifest<N> & { readonly schema: StateSchema }
+    }
+  >(read, {
+    manifest,
+    name,
+    store,
+    decodeUnknown: Schema.decodeUnknown(schema),
+    decodeUnknownSync: Schema.decodeUnknownSync(schema),
+    decodeUnknownOption: Schema.decodeUnknownOption(schema),
+    capture: <Result>(visit: StateCapture<Result>): Result => visit(state),
+  })
+  return state
 }
 
-/**
- * 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>> =>
+const resolveSeed = <N extends string, A>(
+  state: StateClass<N, A>,
+  initial: A,
+): Effect.Effect<A, never, never> =>
   Effect.map(FiberRef.get(CurrentSeedOverrides), (overrides) => {
     if (!(state.manifest.name in overrides)) {
       return initial
     }
-    const override = Schema.decodeUnknownOption(state.manifest.schema)(overrides[state.manifest.name])
+    const override = state.decodeUnknownOption(overrides[state.manifest.name])
     return Option.getOrElse(override, () => 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>>> =>
+export const live = <N extends string, A>(
+  state: StateClass<N, A>,
+  initial: A,
+): Layer.Layer<StateStore<N, A>> =>
   Layer.effect(
     state.store,
     Effect.all([resolveScheduler, resolveSeed(state, initial), resolveInstrumentation]).pipe(

package/src/state/stateFamily.test.ts

@@ -2,11 +2,22 @@ import { expect, it } from '@effect/vitest'
 import { Duration, Effect, Layer, Schema as S } from 'effect'
 import { Engine, Event, publish, Reducer, StateFamily } from '../index'
 
-// A family is normalized keyed state: one logical slice per key, so a write to
-// one key must wake only that key's subscribers (the point of the primitive).
-
 const tick = Effect.sleep(Duration.millis(1))
 
+it.live('same-shaped families resolve their own stores', () => {
+  class First extends StateFamily.make('family.nominal.first', S.String, S.Number) {}
+  class Second extends StateFamily.make('family.nominal.second', S.String, S.Number) {}
+  const Live = Layer.mergeAll(StateFamily.live(First, 1), StateFamily.live(Second, 2))
+
+  return Effect.gen(function* () {
+    const first = yield* First.store
+    const second = yield* Second.store
+
+    expect(first.at('key').get()).toBe(1)
+    expect(second.at('key').get()).toBe(2)
+  }).pipe(Effect.provide(Live))
+})
+
 it.live("writing one key does not notify another key's subscribers", () => {
   class Items extends StateFamily.make('items', S.String, S.Number) {}
   const TestLayer = StateFamily.live(Items, 0)
@@ -53,7 +64,6 @@ it.live('forget(key) drops the store; re-reading the key reseeds it', () => {
     expect(family.at('k').get()).toBe(42)
 
     family.forget('k')
-    // A fresh store, reseeded to the family's initial value — not the old 42.
     const reseeded = family.at('k')
     expect(reseeded).not.toBe(first)
     expect(reseeded.get()).toBe(0)
@@ -71,16 +81,13 @@ it.live('evictWhenUnused drops a key once its last subscriber leaves', () => {
     const offB = store.subscribe(() => {})
     expect(family.size()).toBe(1)
 
-    // One subscriber leaving keeps the key (another still reads it).
     offA()
     yield* tick
     expect(family.size()).toBe(1)
 
-    // The last subscriber leaving evicts the key on the next microtask.
     offB()
     yield* tick
     expect(family.size()).toBe(0)
-    // Re-reading reseeds a fresh store.
     expect(family.at('k').get()).toBe(0)
   }).pipe(Effect.provide(TestLayer))
 })
@@ -94,10 +101,9 @@ it.live('evictWhenUnused: a same-tick re-subscribe cancels eviction', () => {
     const store = family.at('k')
     store.set(7)
     const off = store.subscribe(() => {})
-    off() // count → 0, eviction scheduled for the next microtask
-    store.subscribe(() => {}) // re-subscribe in the same tick → count back to 1
+    off()
+    store.subscribe(() => {})
     yield* tick
-    // Not evicted: the value survives and `at` returns the same live store.
     expect(family.size()).toBe(1)
     expect(family.at('k').get()).toBe(7)
   }).pipe(Effect.provide(TestLayer))
@@ -128,7 +134,6 @@ it.live('a family reducer fold returning Tombstone evicts the key', () => {
     const before = family.at('a')
     expect(before.get()).toBe(1)
 
-    // The fold returns the eviction sentinel: the key's store is dropped.
     yield* publish('High', Event.construct(Removed, { id: 'a' }))
     yield* Effect.sleep(Duration.millis(5))
     const after = family.at('a')

package/src/state/stateFamily.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, Layer, Option, type Schema } from 'effect'
+import { Context, Effect, Layer, Option, Schema } from 'effect'
 import { type Manifest, definitionClass } from '../definition/definition'
 import { resolveScheduler, type Scheduler } from '../internal/scheduler'
 import { claimStateTag } from '../internal/stateRegistry'
@@ -6,43 +6,17 @@ import { resolveInstrumentation, stateUpdateHook } from '../runtime/instrumentat
 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 FamilyOptionsExternalApi {
-  /**
-   * 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
 }
 export type FamilyOptions = FamilyOptionsExternalApi
@@ -55,14 +29,10 @@ const makeFamilyStore = <K, V>(
 ): 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>()
   const liveSubscriberCount = (key: K): number =>
     Option.getOrElse(Option.fromNullable(subscribers.get(key)), () => 0)
 
-  // 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) => {
@@ -113,46 +83,66 @@ const makeFamilyStore = <K, V>(
   }
 }
 
-export interface StateFamilyManifestExternalApi<N extends string, K, V> extends Manifest {
+// Full Schema parameters are invariant; heterogeneous manifests expose only their AST.
+export interface FamilySchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface StateFamilyManifestExternalApi<N extends string> extends Manifest {
   readonly kind: 'StateFamily'
   readonly name: N
-  readonly key: Schema.Schema<K, any>
-  readonly value: Schema.Schema<V, any>
+  readonly key: FamilySchemaReflection
+  readonly value: FamilySchemaReflection
   readonly title?: string
   readonly description?: string
 }
-export type StateFamilyManifest<N extends string, K, V> = StateFamilyManifestExternalApi<N, K, V>
+export type StateFamilyManifest<N extends string> = StateFamilyManifestExternalApi<N>
+
+export const StateFamilyStoreTypeId: unique symbol = Symbol.for('reform/StateFamilyStore')
+export type StateFamilyStoreTypeId = typeof StateFamilyStoreTypeId
+
+export interface StateFamilyStore<N extends string, in out K, in out V> extends FamilyStore<K, V> {
+  readonly [StateFamilyStoreTypeId]: N
+}
 
-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. */
+export type StateFamilyCapture<Result> = <N extends string, K, V>(
+  family: StateFamilyClass<N, K, V>,
+) => Result
+
+export interface AnyFamily {
+  new (): {}
+  readonly manifest: StateFamilyManifest<string>
+  readonly capture: <Result>(visit: StateFamilyCapture<Result>) => Result
+}
+
+export interface StateFamilyClass<N extends string, K, V> {
   new (): { readonly Key: K }
-  readonly manifest: StateFamilyManifest<N, K, V>
-  readonly store: Context.Tag<FamilyStore<K, V>, FamilyStore<K, V>>
+  readonly manifest: StateFamilyManifest<N>
+  readonly capture: <Result>(visit: StateFamilyCapture<Result>) => Result
+  readonly store: Context.Tag<StateFamilyStore<N, K, V>, FamilyStore<K, V>>
+  readonly decodeKeySync: (input: unknown) => K
+  readonly decodeValueSync: (input: unknown) => 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
+export type FamilyName<F> = F extends StateFamilyClass<infer N, infer _K, infer _V> ? N : never
+export type FamilyKey<F> = F extends StateFamilyClass<infer _N, infer K, infer _V> ? K : never
+export type FamilyValue<F> = F extends StateFamilyClass<infer _N, infer _K, 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 interface StateFamilyMakeOptionsExternalApi {
   readonly title?: string
   readonly description?: string
 }
 
-export const make = <const N extends string, K, V>(
+export const make = <const N extends string, K, KeyEncoded, V, ValueEncoded>(
   name: N,
-  key: Schema.Schema<K, any>,
-  valueSchema: Schema.Schema<V, any>,
+  key: Schema.Schema<K, KeyEncoded, never>,
+  valueSchema: Schema.Schema<V, ValueEncoded, never>,
   options: StateFamilyMakeOptionsExternalApi = {},
 ): StateFamilyClass<N, K, V> => {
   const identifier = `reform/family/${name}`
   claimStateTag(identifier)
-  const store = Context.GenericTag<FamilyStore<K, V>, FamilyStore<K, V>>(identifier)
-  const manifest: StateFamilyManifest<N, K, V> = {
+  const store = Context.GenericTag<StateFamilyStore<N, K, V>, FamilyStore<K, V>>(identifier)
+  const manifest: StateFamilyManifest<N> = {
     kind: 'StateFamily',
     name,
     key,
@@ -160,31 +150,31 @@ export const make = <const N extends string, K, V>(
     ...(options.title !== undefined ? { title: options.title } : {}),
     ...(options.description !== undefined ? { description: options.description } : {}),
   }
-  return definitionClass<StateFamilyClass<N, K, V>>({ manifest, store })
+  const family: StateFamilyClass<N, K, V> = definitionClass<StateFamilyClass<N, K, V>>({
+    manifest,
+    store,
+    decodeKeySync: Schema.decodeUnknownSync(key),
+    decodeValueSync: Schema.decodeUnknownSync(valueSchema),
+    capture: <Result>(visit: StateFamilyCapture<Result>): Result => visit(family),
+  })
+  return family
 }
 
-/**
- * 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.Effect<V, never, StateFamilyStore<N, K, V>> =>
   Effect.flatMap(family.store, (familyStore) => readTracked(familyStore.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>> => {
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- value-or-factory union can't be discriminated for a generic V without a cast
-  const seed: (key: K) => V = typeof initial === 'function' ? (initial as (key: K) => V) : () => initial
+): Layer.Layer<StateFamilyStore<N, K, V>> => {
+  const seed = (key: K): V =>
+    typeof initial === 'function'
+      ? family.decodeValueSync(Reflect.apply(initial, undefined, [key]))
+      : initial
   return Layer.effect(
     family.store,
     Effect.zipWith(resolveScheduler, resolveInstrumentation, (scheduler, instrumentation) =>

package/src/state/stateGroup.ts

@@ -1,82 +1,70 @@
-import { Array as Arr, Layer, Option } from 'effect'
+import { Array as Arr, Context, Effect, Layer, Option } from 'effect'
 import { definitionClass } from '../definition/definition'
 import { DuplicateRegistration, 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 type { Store } from '../internal/store'
+import {
+  type AnyState,
+  live as stateLive,
+  type StateName,
+  type StateStore,
+  type StateValue,
+} 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
+type MemberForName<Members extends ReadonlyArray<AnyState>, N extends string> = Extract<
+  Members[number],
+  { readonly manifest: { readonly name: N } }
+>
+
+type ValueForName<Members extends ReadonlyArray<AnyState>, N extends string> = StateValue<
+  MemberForName<Members, N>
+>
 
 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>>
 
-/**
- * Compile-time uniqueness guard for `StateGroup.make`. Member names key the tag,
- * the seed record, `byName`, and `select` — duplicates are unaddressable, so a
- * repeated name is replaced (positionally) by this marker tuple, which a real
- * `StateClass` is not assignable to. The offending argument fails to typecheck
- * with the colliding name spelled out in the message, rather than collapsing
- * silently. Runtime `make` throws the same clash for seeds the root tsconfig
- * never typechecks (test files live outside it).
- */
 type DuplicateStateName<N extends string> = readonly ['reform: duplicate state name in group', N]
 
 type NoDuplicateNames<
   Members extends ReadonlyArray<AnyState>,
   Seen extends string = never,
-> = Members extends readonly [infer Head extends AnyState, ...infer Tail extends ReadonlyArray<AnyState>]
+> = Members extends readonly [
+  infer Head extends AnyState,
+  ...infer Tail extends ReadonlyArray<AnyState>,
+]
   ? readonly [
       StateName<Head> extends Seen ? DuplicateStateName<StateName<Head>> : Head,
       ...NoDuplicateNames<Tail, Seen | StateName<Head>>,
     ]
   : readonly []
 
-// 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
 
-// Collapse a union of records into their intersection — merges every group's
-// seed record into one. (The classic contravariant-position trick.)
 type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (
   k: infer I,
 ) => void
   ? I
   : never
 
-/** The seed record for one tuple entry: a group's `GroupSeeds`, else nothing. */
 type EntrySeeds<G> = G extends AnyStateGroup ? GroupSeeds<G> : never
 
-/**
- * The optional seed overrides for a composition's whole `states` tuple, keyed by
- * member name and typed to each member's value. Every key is optional (seeds are
- * overrides over the authored initial). Tuple entries that aren't state groups
- * contribute no keys, so a partially-grouped `states` still types its groups.
- * Powers `seedScene` — a typo'd key or mistyped value is a compile error.
- */
-export type SeedsOf<St extends ReadonlyArray<unknown>> = Partial<UnionToIntersection<EntrySeeds<St[number]>>>
+export type SeedsOf<St extends ReadonlyArray<unknown>> = Partial<
+  UnionToIntersection<EntrySeeds<St[number]>>
+>
 
-/** Compose atomic States into a group provided (and addressed) as a unit. */
 export const make = <const Members extends ReadonlyArray<AnyState>>(
   ...members: Members & NoDuplicateNames<Members>
 ): StateGroupClass<Members> => {
-  // `byName` already de-dupes, so a smaller map than the member list means two
-  // members claimed one name — unaddressable, and a silent footgun on merge.
   const names = members.map((member) => member.manifest.name)
   const duplicate = Arr.findFirst(names, (name, index) =>
     Option.exists(
@@ -95,17 +83,10 @@ export const make = <const Members extends ReadonlyArray<AnyState>>(
   })
 }
 
-/**
- * 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]>>(
+export const select = <
+  Members extends ReadonlyArray<AnyState>,
+  N extends StateName<Members[number]>,
+>(
   group: StateGroupClass<Members>,
   name: N,
 ): StateToken<N, ValueForName<Members, N>> => {
@@ -114,25 +95,33 @@ export const select = <Members extends ReadonlyArray<AnyState>, N extends StateN
     // oxlint-disable-next-line reform-rules/no-throw -- definition-time invariant; sync lookup has no Effect context (see internal/errors.ts)
     throw new UnknownGroupState({ name })
   }
-  return new StateToken(name, member.store)
+  const store = Context.GenericTag<
+    StateStore<N, ValueForName<Members, N>>,
+    Store<ValueForName<Members, N>>
+  >(`reform/state/${name}`)
+  return new StateToken(name, store)
 }
 
-/**
- * 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>>(
+export function 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.
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- reflection boundary: index a mapped seed type by runtime member name
-  const seedRecord = seeds as Record<string, unknown>
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- union-of-stores Rout can't be expressed by reduce's single-layer accumulator
-  return group.members
-    .map((member) => stateLive(member, seedRecord[member.manifest.name]))
-    .reduce((accumulator, layer) => Layer.merge(accumulator, layer)) as Layer.Layer<StoresOf<Members>>
+): Layer.Layer<StoresOf<Members>>
+export function live(
+  group: AnyStateGroup,
+  seeds: Readonly<Record<string, unknown>>,
+): Layer.Layer<never> {
+  const layers = group.members.map((member) =>
+    member.capture<Layer.Layer<never>>((state) =>
+      Layer.unwrapEffect(
+        state.decodeUnknown(seeds[state.manifest.name]).pipe(
+          Effect.orDie,
+          Effect.map((seed) => stateLive(state, seed)),
+        ),
+      ),
+    ),
+  )
+  return layers.reduce<Layer.Layer<never>>(
+    (merged, memberLayer) => Layer.merge(merged, memberLayer),
+    Layer.empty,
+  )
 }