@playfast/reform 0.0.2 → 0.0.4

package/src/runtime/loop.ts

@@ -0,0 +1,169 @@
+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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,171 @@
+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

@@ -0,0 +1,78 @@
+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>>
+}

package/{dist/dts/state/token.d.ts → src/state/token.ts}

@@ -1,16 +1,24 @@
-import { Context, Effect, Effectable } from 'effect';
-import type { Store } from '../internal/store.js';
+import { Context, Effect, Effectable } from 'effect'
+import type { Store } from '../internal/store'
+import { readTracked } from '../internal/track'
+
 /**
  * A reference to one slice of state: yieldable to its current value (`yield*`
  * reads + — under React — subscribes) and carrying the metadata calcs need
  * (its `name` and backing store tag). Returned by `StateGroup.select(group, name)`.
  */
-export declare class StateToken<out N extends string, in out A> extends Effectable.Class<A, never, Store<A>> {
-    readonly name: N;
-    readonly store: Context.Tag<Store<A>, Store<A>>;
-    constructor(name: N, store: Context.Tag<Store<A>, Store<A>>);
-    commit(): Effect.Effect<A, never, Store<A>>;
+export class StateToken<out N extends string, in out A> extends Effectable.Class<A, never, Store<A>> {
+  constructor(
+    readonly name: N,
+    readonly store: Context.Tag<Store<A>, Store<A>>,
+  ) {
+    super()
+  }
+  commit(): Effect.Effect<A, never, Store<A>> {
+    return Effect.flatMap(this.store, readTracked)
+  }
 }
+
 /**
  * Anything a derived value can read and depend on: a named slice backed by a
  * subscribable store tag. A `StateToken` (group member), a `Calc`, and an
@@ -21,10 +29,10 @@ export declare class StateToken<out N extends string, in out A> extends Effectab
  * satisfy the same shape so the three are interchangeable as calc inputs.
  */
 export interface Source<out N extends string, in out A> {
-    readonly name: N;
-    readonly store: Context.Tag<Store<A>, Store<A>>;
+  readonly name: N
+  readonly store: Context.Tag<Store<A>, Store<A>>
 }
-export type AnySource = Source<string, any>;
-export type SourceName<S> = S extends Source<infer N, any> ? N : never;
-export type SourceValue<S> = S extends Source<any, infer A> ? A : never;
-//# sourceMappingURL=token.d.ts.map
+
+export type AnySource = Source<string, any>
+export type SourceName<S> = S extends Source<infer N, any> ? N : never
+export type SourceValue<S> = S extends Source<any, infer A> ? A : never

package/{dist/dts/ui/node.d.ts → src/ui/node.ts}

@@ -1,9 +1,9 @@
-import type { ReactNode } from 'react';
+import type { ReactNode } from 'react'
+
 /**
  * What a view renders. Reform targets React, so a node is a `ReactNode` — this
  * is a *type-only* dependency: core never imports the React runtime nor renders
  * anything itself (that is `@reform/react`). Typing it precisely lets the `.ui`
  * presentations author real JSX and lets slots be valid components.
  */
-export type Node = ReactNode;
-//# sourceMappingURL=node.d.ts.map
+export type Node = ReactNode

package/{dist/dts/ui/trigger.d.ts → src/ui/trigger.ts}

@@ -3,5 +3,4 @@
  * (High priority) through the runtime. The UI never sees Effect — it just calls
  * `events.submit({ text })`.
  */
-export type Trigger<P> = (payload: P) => void;
-//# sourceMappingURL=trigger.d.ts.map
+export type Trigger<P> = (payload: P) => void