@playfast/reform 1.1.1 → 1.2.0

package/src/scene/seedScene.test.ts

@@ -1,5 +1,5 @@
-import { Effect, Layer, Schema as S } from "effect";
-import { expect, it } from "@effect/vitest";
+import { Effect, Layer, Schema as S } from 'effect'
+import { expect, it } from '@effect/vitest'
 import {
   Composition,
   Engine,
@@ -10,90 +10,82 @@ import {
   publish,
   Reducer,
   type RenderEnv,
-  type Scene,
   scene,
   seedScene,
   State,
   StateGroup,
   Ui,
   ui,
-} from "../index";
-import { CurrentSeedOverrides } from "../internal/seeds";
+} from '../index'
+import { CurrentSeedOverrides } from '../internal/seeds'
 
-class CountState extends State.make("count", S.Number) {}
+class CountState extends State.make('count', S.Number) {}
 class MiniStates extends StateGroup.make(CountState) {}
 
-class Bumped extends Event.make("Bumped", S.Struct({})) {}
+class Bumped extends Event.make('Bumped', S.Struct({})) {}
 
-class BumpReducer extends Reducer.make("BumpReducer", {
+class BumpReducer extends Reducer.make('BumpReducer', {
   states: [CountState],
   events: [Bumped],
 }) {}
-const BumpReducerLive = Reducer.live(BumpReducer, (n) => n + 1);
+const BumpReducerLive = Reducer.live(BumpReducer, (n) => n + 1)
 
-class CounterUi extends ui("Counter")<{ props: { count: number } }>() {}
-class Counter extends Composition.make("Counter", {
-  title: "Counter",
+class CounterUi extends ui('Counter')<{ props: { count: number } }>() {}
+class Counter extends Composition.make('Counter', {
+  title: 'Counter',
   states: [MiniStates],
   events: [Bumped],
   ui: CounterUi,
-}) {}
+})<Counter>() {}
 const CounterLive = Composition.live(Counter, function* () {
-  const count = yield* StateGroup.select(MiniStates, "count");
-  return mount({ props: { count }, slots: {} });
-});
+  const count = yield* StateGroup.select(MiniStates, 'count')
+  return mount({ props: { count }, slots: {} })
+})
 
 const presentations = provide(
   CounterUi,
   Ui.make(CounterUi, () => null),
-);
-const Views = CounterLive.pipe(Layer.provideMerge(presentations));
+)
+const Views = CounterLive.pipe(Layer.provideMerge(presentations))
 const Logic = Layer.mergeAll(BumpReducerLive).pipe(
-  Layer.provideMerge(
-    Layer.mergeAll(Engine, StateGroup.live(MiniStates, { count: 1 })),
-  ),
-);
-const MiniApp = Views.pipe(Layer.provideMerge(Logic));
+  Layer.provideMerge(Layer.mergeAll(Engine, StateGroup.live(MiniStates, { count: 1 }))),
+)
+const MiniApp = Views.pipe(Layer.provideMerge(Logic))
 
-const CounterScene = scene(Counter, { provide: [MiniApp] });
+const CounterScene = scene(Counter, { provide: [MiniApp] })
 
 const overlayRawSeeds = (
-  base: Scene,
+  base: typeof CounterScene,
   seeds: Readonly<Record<string, unknown>>,
-): Scene => ({
+): typeof CounterScene => ({
   ...base,
   provide: base.provide.map(Layer.locally(CurrentSeedOverrides, seeds)),
-});
+})
 
 const headlessEnv: RenderEnv = {
   props: {},
   tracker: { add: () => {} },
-};
+}
 
 const isCountProps = (props: unknown): props is { readonly count: number } =>
-  typeof props === "object" &&
-  props !== null &&
-  "count" in props &&
-  typeof props.count === "number";
+  typeof props === 'object' && props !== null && 'count' in props && typeof props.count === 'number'
 
-const makeHarness = (s: Scene) => {
-  const layer = s.provide.reduce((a, b) => Layer.merge(a, b));
+const makeHarness = (s: typeof CounterScene) => {
+  const layer = s.provide.reduce((a, b) => Layer.merge(a, b))
   const read = Effect.flatMap(Counter.tag, (c) =>
     Composition.render(c, headlessEnv).pipe(
       Effect.flatMap((frame) => {
         if (!isStructure(frame)) {
-          return Effect.dieMessage("Counter must render a Structure");
+          return Effect.dieMessage('Counter must render a Structure')
         }
         return isCountProps(frame.props)
           ? Effect.succeed(frame.props.count)
-          : Effect.dieMessage(
-              "Counter Structure props must include numeric count",
-            );
+          : Effect.dieMessage('Counter Structure props must include numeric count')
       }),
     ),
-  );
-  return { layer, read };
-};
+  )
+  return { layer, read }
+}
 
 const waitUntil = <A, R>(
   read: Effect.Effect<A, never, R>,
@@ -103,54 +95,45 @@ const waitUntil = <A, R>(
   Effect.flatMap(read, (a) =>
     pred(a) || rounds <= 0
       ? Effect.succeed(a)
-      : Effect.flatMap(Effect.yieldNow(), () =>
-          waitUntil(read, pred, rounds - 1),
-        ),
-  );
+      : Effect.flatMap(Effect.yieldNow(), () => waitUntil(read, pred, rounds - 1)),
+  )
 
-it.scopedLive("a seeded scene boots its store from the override", () => {
-  const { layer, read } = makeHarness(seedScene(CounterScene, { count: 5 }));
+it.scopedLive('a seeded scene boots its store from the override', () => {
+  const { layer, read } = makeHarness(seedScene(CounterScene, { count: 5 }))
   return Effect.gen(function* () {
-    expect(yield* read).toBe(5);
-  }).pipe(Effect.provide(layer));
-});
+    expect(yield* read).toBe(5)
+  }).pipe(Effect.provide(layer))
+})
 
-it.scopedLive("the live reducer drives the SAME overridden store", () => {
-  const { layer, read } = makeHarness(seedScene(CounterScene, { count: 5 }));
+it.scopedLive('the live reducer drives the SAME overridden store', () => {
+  const { layer, read } = makeHarness(seedScene(CounterScene, { count: 5 }))
+  return Effect.gen(function* () {
+    expect(yield* read).toBe(5)
+    yield* publish('High', Event.construct(Bumped, {}))
+    const next = yield* waitUntil(read, (n) => n === 6)
+    expect(next).toBe(6)
+  }).pipe(Effect.provide(layer))
+})
+
+it.scopedLive('an absent key leaves the authored seed in place', () => {
+  const { layer, read } = makeHarness(overlayRawSeeds(CounterScene, { other: 1 }))
   return Effect.gen(function* () {
-    expect(yield* read).toBe(5);
-    yield* publish("High", Event.construct(Bumped, {}));
-    const next = yield* waitUntil(read, (n) => n === 6);
-    expect(next).toBe(6);
-  }).pipe(Effect.provide(layer));
-});
-
-it.scopedLive("an absent key leaves the authored seed in place", () => {
-  const { layer, read } = makeHarness(
-    overlayRawSeeds(CounterScene, { other: 1 }),
-  );
+    expect(yield* read).toBe(1)
+  }).pipe(Effect.provide(layer))
+})
+
+it.scopedLive('a schema-invalid override falls back to the authored seed', () => {
+  const { layer, read } = makeHarness(overlayRawSeeds(CounterScene, { count: 'not-a-number' }))
   return Effect.gen(function* () {
-    expect(yield* read).toBe(1);
-  }).pipe(Effect.provide(layer));
-});
-
-it.scopedLive(
-  "a schema-invalid override falls back to the authored seed",
-  () => {
-    const { layer, read } = makeHarness(
-      overlayRawSeeds(CounterScene, { count: "not-a-number" }),
-    );
-    return Effect.gen(function* () {
-      expect(yield* read).toBe(1);
-    }).pipe(Effect.provide(layer));
-  },
-);
-
-it.scopedLive("seeding does not leak into the original scene", () => {
-  const seeded = makeHarness(seedScene(CounterScene, { count: 5 }));
-  const original = makeHarness(CounterScene);
+    expect(yield* read).toBe(1)
+  }).pipe(Effect.provide(layer))
+})
+
+it.scopedLive('seeding does not leak into the original scene', () => {
+  const seeded = makeHarness(seedScene(CounterScene, { count: 5 }))
+  const original = makeHarness(CounterScene)
   return Effect.gen(function* () {
-    expect(yield* seeded.read.pipe(Effect.provide(seeded.layer))).toBe(5);
-    expect(yield* original.read.pipe(Effect.provide(original.layer))).toBe(1);
-  });
-});
+    expect(yield* seeded.read.pipe(Effect.provide(seeded.layer))).toBe(5)
+    expect(yield* original.read.pipe(Effect.provide(original.layer))).toBe(1)
+  })
+})

package/src/state/state.nominal.typecheck.ts

@@ -0,0 +1,68 @@
+import { Layer, Schema as S } from 'effect'
+import type { ProvidedBy } from '../feature/feature'
+import * as State from './state'
+import * as StateFamily from './stateFamily'
+
+type Equal<Left, Right> =
+  (<Value>() => Value extends Left ? 1 : 2) extends <Value>() => Value extends Right ? 1 : 2
+    ? true
+    : false
+type Expect<Value extends true> = Value
+
+class FirstState extends State.make('nominal.first', S.Number) {}
+class SecondState extends State.make('nominal.second', S.Number) {}
+class FirstFamily extends StateFamily.make('nominal.firstFamily', S.String, S.Number) {}
+class SecondFamily extends StateFamily.make('nominal.secondFamily', S.String, S.Number) {}
+
+const FirstStateLive = State.live(FirstState, 0)
+const SecondStateLive = State.live(SecondState, 0)
+const FirstFamilyLive = StateFamily.live(FirstFamily, 0)
+const SecondFamilyLive = StateFamily.live(SecondFamily, 0)
+
+type StateLiveKeepsDefinitionIdentity = Expect<
+  Equal<Layer.Layer.Success<typeof FirstStateLive>, State.StateStore<'nominal.first', number>>
+>
+type FamilyLiveKeepsDefinitionIdentity = Expect<
+  Equal<
+    Layer.Layer.Success<typeof FirstFamilyLive>,
+    StateFamily.StateFamilyStore<'nominal.firstFamily', string, number>
+  >
+>
+type WrongStateDoesNotCloseRequirement = Expect<
+  Equal<
+    Exclude<State.StateStore<'nominal.first', number>, Layer.Layer.Success<typeof SecondStateLive>>,
+    State.StateStore<'nominal.first', number>
+  >
+>
+type WrongFamilyDoesNotCloseRequirement = Expect<
+  Equal<
+    Exclude<
+      StateFamily.StateFamilyStore<'nominal.firstFamily', string, number>,
+      Layer.Layer.Success<typeof SecondFamilyLive>
+    >,
+    StateFamily.StateFamilyStore<'nominal.firstFamily', string, number>
+  >
+>
+type ProvidedByKeepsStateIdentity = Expect<
+  Equal<ProvidedBy<readonly [typeof FirstState]>, State.StateStore<'nominal.first', number>>
+>
+type ProvidedByKeepsFamilyIdentity = Expect<
+  Equal<
+    ProvidedBy<readonly [typeof FirstFamily]>,
+    StateFamily.StateFamilyStore<'nominal.firstFamily', string, number>
+  >
+>
+
+type StateIdentityProofs = [
+  StateLiveKeepsDefinitionIdentity,
+  FamilyLiveKeepsDefinitionIdentity,
+  WrongStateDoesNotCloseRequirement,
+  WrongFamilyDoesNotCloseRequirement,
+  ProvidedByKeepsStateIdentity,
+  ProvidedByKeepsFamilyIdentity,
+]
+declare const stateIdentityProofs: StateIdentityProofs
+
+void stateIdentityProofs
+
+export {}

package/src/state/state.test.ts

@@ -0,0 +1,17 @@
+import { expect, it } from '@effect/vitest'
+import { Effect, Layer, Schema as S } from 'effect'
+import { State } from '../index'
+
+it.live('same-shaped states resolve their own stores', () => {
+  class First extends State.make('state.nominal.first', S.Number) {}
+  class Second extends State.make('state.nominal.second', S.Number) {}
+  const Live = Layer.mergeAll(State.live(First, 1), State.live(Second, 2))
+
+  return Effect.gen(function* () {
+    const first = yield* First
+    const second = yield* Second
+
+    expect(first).toBe(1)
+    expect(second).toBe(2)
+  }).pipe(Effect.provide(Live))
+})

package/src/state/state.ts

@@ -1,4 +1,4 @@
-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'
@@ -7,7 +7,6 @@ import { resolveInstrumentation, stateUpdateHook } from '../runtime/instrumentat
 import { claimStateTag } from '../internal/stateRegistry'
 import { makeStore, type Store } from '../internal/store'
 import { readTracked } from '../internal/track'
-import type { AnySchema, AnyValue } from '../internal/variance'
 
 export interface StateOptionsExternalApi {
   readonly title?: string
@@ -15,34 +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: AnySchema<A>
+  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 EffectType<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>
-  readonly store: Context.Tag<Store<A>, Store<A>>
+  readonly manifest: StateManifest<string>
+  readonly capture: <Result>(visit: StateCapture<Result>) => Result
 }
 
-export type AnyState = StateClass<string, AnyValue>
-export type StateValue<S> = S extends StateClass<string, infer A> ? A : never
-export type StateName<S> = S extends StateClass<infer N, AnyValue> ? 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>
+}
 
-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: AnySchema<A>,
+  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,
@@ -50,25 +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
 }
 
-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)
   })
 
-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

@@ -4,6 +4,20 @@ import { Engine, Event, publish, Reducer, StateFamily } from '../index'
 
 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)

package/src/state/stateFamily.ts

@@ -1,11 +1,10 @@
-import { Context, Effect, Layer, Option } 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'
 import { resolveInstrumentation, stateUpdateHook } from '../runtime/instrumentation'
 import { makeStore, type Store } from '../internal/store'
 import { readTracked } from '../internal/track'
-import type { AnySchema, AnyValue } from '../internal/variance'
 
 export const Tombstone: unique symbol = Symbol.for('reform/StateFamily/Tombstone')
 export type Tombstone = typeof Tombstone
@@ -84,41 +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: AnySchema<K>
-  readonly value: AnySchema<V>
+  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> {
+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, AnyValue, AnyValue>
-export type FamilyKey<F> = F extends StateFamilyClass<string, infer K, AnyValue> ? K : never
-export type FamilyValue<F> = F extends StateFamilyClass<string, AnyValue, 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
 
 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: AnySchema<K>,
-  valueSchema: AnySchema<V>,
+  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,
@@ -126,22 +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
 }
 
 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)))
 
 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) =>