@playfast/reform 1.0.1 → 1.2.0

package/src/scene/scene.ts

@@ -1,7 +1,14 @@
-import { Layer, Struct } from 'effect'
-import type { CompositionClass, CompositionService } from '../compose/composition'
+import { Layer, Predicate, Struct } from 'effect'
+import type {
+  AnyComposition,
+  CompositionClass,
+  CompositionId,
+  CompositionReflection,
+  HasExactCompositionId,
+} from '../compose/composition'
 import type { UiContract } from '../compose/ui'
 import type { EventOf } from '../event/event'
+import { type EagerFeatureClass, type FeatureRequirement, tree } from '../feature/feature'
 import { CurrentSeedOverrides } from '../internal/seeds'
 import type { SeedsOf } from '../state/stateGroup'
 import type { Bus } from '../runtime/bus'
@@ -10,121 +17,257 @@ import {
   type Instrumentation,
   noopInstrumentation,
 } from '../runtime/instrumentation'
+import type { EngineServices } from '../runtime/loop'
 
-// 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
-
-// A scene's boot list holds CONSTRUCTED events (`Event.construct(E, payload)`),
-// not bare tagged objects — a lightweight nudge toward the real builder. It is
-// not a guarantee the event is handled by the wiring (reform carries no
-// type-level union of handled tags), only that it came from an event definition.
-type BootEvent = EventOf<string, unknown>
+export type MountedServices = CompositionId<string> | Bus
+
+export type SceneCapture<C extends UiContract, S extends ReadonlyArray<unknown>, Result> = <
+  Services,
+  P,
+  N extends string,
+  Identity,
+>(
+  scene: CapturedScene<C, S, Services, P, N, Identity>,
+) => Result
+
+export type AnySceneCapture<Result> = <
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  Services,
+  P,
+  N extends string,
+  Identity,
+>(
+  scene: CapturedScene<C, S, Services, P, N, Identity>,
+) => Result
+
+interface SceneOptionalFields {
+  readonly boot: ReadonlyArray<BootEvent>
+  // Hosts record render spans outside the scene's layer context.
+  readonly instrumentation: Instrumentation
+}
+
+export interface AnySceneExternalApi extends Partial<SceneOptionalFields> {
+  readonly kind: 'Scene'
+  readonly composition: AnyComposition
+  readonly captureAny: <Result>(visit: AnySceneCapture<Result>) => Result
+}
+
+export type AnyScene = AnySceneExternalApi
 
 export interface Scene<
   C extends UiContract = UiContract,
   S extends ReadonlyArray<unknown> = ReadonlyArray<unknown>,
-> {
+> extends AnySceneExternalApi {
+  readonly composition: AnyComposition & CompositionReflection<unknown, C, S>
+  readonly capture: <Result>(visit: SceneCapture<C, S, Result>) => Result
+}
+
+type BootEvent = EventOf<string, unknown>
+
+export interface CapturedScene<
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  Services,
+  P,
+  N extends string,
+  Identity = unknown,
+> extends Scene<C, S> {
   readonly kind: 'Scene'
-  /** The composition to run, with its contract + states preserved for typed consumers. */
-  readonly composition: CompositionClass<unknown, C, S>
-  /** 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`). */
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- presence-optional boot read as `scene.boot ?? []` across non-batch hosts (drive/proof/remote/react/editor); Option would break them
-  readonly boot?: ReadonlyArray<BootEvent>
-  /**
-   * The profiler hooks this scene records into, when profiled (`profiledScene`).
-   * Hosts read it via {@link sceneInstrumentation} to time renders — kept on the
-   * scene (not only inside the layers) because render spans live in the HOST
-   * (React `Compose`, the proof engine), outside the runtime's layer context.
-   */
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- presence-optional carrier like `boot`; absent on every unprofiled scene, so Option would tax all authoring call sites
-  readonly instrumentation?: Instrumentation
+  readonly composition: CompositionClass<P, C, S, N, Identity>
+  readonly provide: ReadonlyArray<Layer.Layer<Services, never, never>>
+}
+
+interface SceneConfigOptionalFields {
+  readonly boot: ReadonlyArray<BootEvent>
+}
+
+export interface SceneConfig<Services> extends Partial<SceneConfigOptionalFields> {
+  readonly provide: ReadonlyArray<Layer.Layer<Services, never, never>>
+}
+
+type SceneConfigIncludingRootComposition<Services, N extends string, Identity> =
+  HasExactCompositionId<Services, N, Identity> extends true
+    ? SceneConfig<Services>
+    : SceneConfig<Services> & {
+        readonly missingCompositionService: 'The scene must provide its root composition'
+      }
+
+interface SceneValueConfigExternalApi<Services>
+  extends SceneConfig<Services>, Partial<Pick<SceneOptionalFields, 'instrumentation'>> {}
+
+const makeSceneValue = <
+  P,
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+  Services,
+>(
+  composition: CompositionClass<P, C, S, N, Identity>,
+  config: SceneValueConfigExternalApi<Services>,
+): CapturedScene<C, S, Services, P, N, Identity> => {
+  const sceneValue: CapturedScene<C, S, Services, P, N, Identity> = {
+    kind: 'Scene',
+    composition,
+    provide: config.provide,
+    ...(config.boot !== undefined ? { boot: config.boot } : {}),
+    ...(config.instrumentation !== undefined ? { instrumentation: config.instrumentation } : {}),
+    capture: <Result>(visit: SceneCapture<C, S, Result>): Result => visit(sceneValue),
+    captureAny: <Result>(visit: AnySceneCapture<Result>): Result => visit(sceneValue),
+  }
+  return sceneValue
+}
+
+export const scene = <
+  P,
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+  Services,
+>(
+  composition: CompositionClass<P, C, S, N, Identity>,
+  config: SceneConfigIncludingRootComposition<Services, N, Identity>,
+): CapturedScene<C, S, Services, P, N, Identity> => {
+  return makeSceneValue(composition, config)
+}
+
+export interface FeatureSceneConfig<OpenServices> {
+  readonly provide: Layer.Layer<EngineServices | OpenServices, never, never>
 }
 
-/** Closed wiring + optional boot events handed to {@link scene}. */
-export interface SceneConfig {
-  readonly provide: ReadonlyArray<Layer.Layer<MountedServices, never, never>>
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- mirrors Scene.boot; presence-optional to keep the authoring call site terse and back-compatible
-  readonly boot?: ReadonlyArray<BootEvent>
+export const featureScene = <
+  FeatureIdentity,
+  P,
+  C extends UiContract,
+  ROut,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
+>(
+  feature: EagerFeatureClass<
+    FeatureIdentity,
+    P,
+    C,
+    ROut,
+    DirectRequires,
+    OpenServices,
+    S,
+    N,
+    Identity
+  >,
+  config: FeatureSceneConfig<OpenServices>,
+): CapturedScene<C, S, ROut | EngineServices | OpenServices, P, N, Identity> => {
+  const native = tree<typeof feature>(feature.token)
+  const app = native.eagerModule.layer.pipe(Layer.provideMerge(config.provide))
+  return makeSceneValue(native.composition, {
+    provide: [app],
+    boot: native.binding.boot,
+  })
 }
 
-/**
- * Define a scene — `scene(TodoApp, { provide: [makeTestApp(client, seeds)] })`.
- * The composition's contract `C` and state tuple `S` flow through, so consumers
- * (the facade, `seedScene`) stay typed.
- */
-export const scene = <C extends UiContract, S extends ReadonlyArray<unknown>>(
-  composition: CompositionClass<unknown, C, S>,
-  config: SceneConfig,
-): Scene<C, S> => ({
-  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, S extends ReadonlyArray<unknown>>(
+export function seedScene<
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  Services,
+  P,
+  N extends string,
+  Identity,
+>(
+  base: CapturedScene<C, S, Services, P, N, Identity>,
+  seeds: SeedsOf<S>,
+): CapturedScene<C, S, Services, P, N, Identity>
+export function seedScene<C extends UiContract, S extends ReadonlyArray<unknown>>(
   base: Scene<C, S>,
   seeds: SeedsOf<S>,
-): Scene<C, S> =>
-  Struct.keys(seeds).length === 0
-    ? base
-    : { ...base, provide: base.provide.map(Layer.locally(CurrentSeedOverrides, seeds)) }
-
-/**
- * Overlay profiler hooks onto a CLOSED scene — the profiling analog of
- * {@link seedScene}. Wraps each provided layer with
- * `Layer.locally(CurrentInstrumentation, instr)` so engine/state/calc layers
- * capture `instr` at build time, and carries `instr` on the scene so hosts can
- * time renders. Scenes stay closed; production wiring never calls this —
- * `@playfast/reform-profiler`'s `profileScene` is the intended caller.
- */
-export const profiledScene = <C extends UiContract, S extends ReadonlyArray<unknown>>(
+): Scene<C, S>
+export function seedScene<C extends UiContract, S extends ReadonlyArray<unknown>>(
   base: Scene<C, S>,
+  seeds: SeedsOf<S>,
+): Scene<C, S> {
+  if (Struct.keys(seeds).length === 0) {
+    return base
+  }
+  // Tooling overlays closed layers; member names, not group names, are the keys.
+  return base.capture<Scene<C, S>>(
+    (exactScene): Scene<C, S> =>
+      makeSceneValue(exactScene.composition, {
+        provide: exactScene.provide.map(Layer.locally(CurrentSeedOverrides, seeds)),
+        ...(exactScene.boot === undefined ? {} : { boot: exactScene.boot }),
+        ...(exactScene.instrumentation === undefined
+          ? {}
+          : { instrumentation: exactScene.instrumentation }),
+      }),
+  )
+}
+
+export const seedAnyScene = (
+  base: AnyScene,
+  seeds: Readonly<Record<string, unknown>>,
+): AnyScene => {
+  if (Struct.keys(seeds).length === 0) {
+    return base
+  }
+  return base.captureAny<AnyScene>(
+    (exactScene): AnyScene =>
+      makeSceneValue(exactScene.composition, {
+        provide: exactScene.provide.map(Layer.locally(CurrentSeedOverrides, seeds)),
+        ...(exactScene.boot === undefined ? {} : { boot: exactScene.boot }),
+        ...(exactScene.instrumentation === undefined
+          ? {}
+          : { instrumentation: exactScene.instrumentation }),
+      }),
+  )
+}
+
+export function profiledScene<
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  Services,
+  P,
+  N extends string,
+  Identity,
+>(
+  base: CapturedScene<C, S, Services, P, N, Identity>,
   instrumentation: Instrumentation,
-): Scene<C, S> => ({
-  ...base,
-  instrumentation,
-  provide: base.provide.map(Layer.locally(CurrentInstrumentation, instrumentation)),
-})
-
-/** The instrumentation a host records render spans into — noop when unprofiled. */
-export const sceneInstrumentation = (candidate: Scene): Instrumentation =>
+): CapturedScene<C, S, Services, P, N, Identity>
+export function profiledScene<C extends UiContract, S extends ReadonlyArray<unknown>>(
+  base: Scene<C, S>,
+  instrumentation: Instrumentation,
+): Scene<C, S>
+export function profiledScene<C extends UiContract, S extends ReadonlyArray<unknown>>(
+  base: Scene<C, S>,
+  instrumentation: Instrumentation,
+): Scene<C, S> {
+  return base.capture<Scene<C, S>>(
+    (exactScene): Scene<C, S> =>
+      makeSceneValue(exactScene.composition, {
+        provide: exactScene.provide.map(Layer.locally(CurrentInstrumentation, instrumentation)),
+        ...(exactScene.boot === undefined ? {} : { boot: exactScene.boot }),
+        instrumentation,
+      }),
+  )
+}
+
+export const sceneInstrumentation = (candidate: AnyScene): Instrumentation =>
   candidate.instrumentation ?? noopInstrumentation
 
-/** Reflection guard: is this exported value a scene? */
-export const isScene = (candidate: unknown): candidate is Scene =>
-  typeof candidate === 'object' &&
-  candidate !== null &&
-  'kind' in candidate &&
-  candidate.kind === 'Scene'
+const isReflectableComposition = (candidate: unknown): candidate is AnyComposition =>
+  typeof candidate === 'function' &&
+  Predicate.hasProperty(candidate, 'manifest') &&
+  Predicate.isRecord(candidate.manifest) &&
+  candidate.manifest['kind'] === 'Composition' &&
+  Predicate.hasProperty(candidate, 'parseProps') &&
+  typeof candidate.parseProps === 'function' &&
+  Predicate.hasProperty(candidate, 'capture') &&
+  typeof candidate.capture === 'function'
+
+export const isScene = (candidate: unknown): candidate is AnyScene =>
+  Predicate.isRecord(candidate) &&
+  candidate['kind'] === 'Scene' &&
+  isReflectableComposition(candidate['composition']) &&
+  typeof candidate['capture'] === 'function' &&
+  typeof candidate['captureAny'] === 'function'

package/src/scene/seedScene.test.ts

@@ -1,5 +1,5 @@
-import { Effect, Layer, ManagedRuntime, Schema as S } from 'effect'
-import { expect, test } from 'vitest'
+import { Effect, Layer, Schema as S } from 'effect'
+import { expect, it } from '@effect/vitest'
 import {
   Composition,
   Engine,
@@ -10,7 +10,6 @@ import {
   publish,
   Reducer,
   type RenderEnv,
-  type Scene,
   scene,
   seedScene,
   State,
@@ -20,13 +19,6 @@ import {
 } from '../index'
 import { CurrentSeedOverrides } from '../internal/seeds'
 
-// `seedScene` is the tooling seam over CLOSED scenes: the app bundle below seeds
-// `count: 1` itself (no open store), and the overlay must reach the nested
-// `State.live` through `Layer.locally(CurrentSeedOverrides, …)` on the scene's
-// pre-composed layers. The harness mirrors the dev-tool preview: merge the
-// scene's `provide`, mount it in a ManagedRuntime, and read the root
-// composition's rendered props through the headless Structure.
-
 class CountState extends State.make('count', S.Number) {}
 class MiniStates extends StateGroup.make(CountState) {}
 
@@ -44,15 +36,16 @@ class Counter extends Composition.make('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: {} })
 })
 
-// The closed app layer a scene provides: views + logic + Engine, with the state
-// group seeding its AUTHORED value `count: 1` itself.
-const presentations = provide(CounterUi, Ui.make(CounterUi, () => null))
+const presentations = provide(
+  CounterUi,
+  Ui.make(CounterUi, () => null),
+)
 const Views = CounterLive.pipe(Layer.provideMerge(presentations))
 const Logic = Layer.mergeAll(BumpReducerLive).pipe(
   Layer.provideMerge(Layer.mergeAll(Engine, StateGroup.live(MiniStates, { count: 1 }))),
@@ -61,12 +54,10 @@ const MiniApp = Views.pipe(Layer.provideMerge(Logic))
 
 const CounterScene = scene(Counter, { provide: [MiniApp] })
 
-// The dev-tool inspector overlays raw, user-typed seeds (`Record<string, unknown>`)
-// — the untyped seam that `seedScene` wraps once a composition's state tuple is
-// known. These two cases (absent key / schema-invalid value) are compile errors
-// through the now-typed `seedScene`, so they're exercised here at the raw overlay
-// to prove `resolveSeed`'s runtime defensiveness still falls back to the seed.
-const overlayRawSeeds = (base: Scene, seeds: Readonly<Record<string, unknown>>): Scene => ({
+const overlayRawSeeds = (
+  base: typeof CounterScene,
+  seeds: Readonly<Record<string, unknown>>,
+): typeof CounterScene => ({
   ...base,
   provide: base.provide.map(Layer.locally(CurrentSeedOverrides, seeds)),
 })
@@ -77,17 +68,10 @@ const headlessEnv: RenderEnv = {
 }
 
 const isCountProps = (props: unknown): props is { readonly count: number } =>
-  typeof props === 'object' &&
-  props !== null &&
-  'count' in props &&
-  typeof props.count === 'number'
-
-// One ManagedRuntime per scene under test. Each `read` re-renders the root
-// composition and reads the Structure built from the stores that runtime actually
-// constructed.
-const makeHarness = (s: Scene) => {
+  typeof props === 'object' && props !== null && 'count' in props && typeof props.count === 'number'
+
+const makeHarness = (s: typeof CounterScene) => {
   const layer = s.provide.reduce((a, b) => Layer.merge(a, b))
-  const runtime = ManagedRuntime.make(layer)
   const read = Effect.flatMap(Counter.tag, (c) =>
     Composition.render(c, headlessEnv).pipe(
       Effect.flatMap((frame) => {
@@ -100,10 +84,9 @@ const makeHarness = (s: Scene) => {
       }),
     ),
   )
-  return { runtime, read }
+  return { layer, read }
 }
 
-// Drive a read until a predicate holds, handing forked fibers the scheduler.
 const waitUntil = <A, R>(
   read: Effect.Effect<A, never, R>,
   pred: (a: A) => boolean,
@@ -115,62 +98,42 @@ const waitUntil = <A, R>(
       : Effect.flatMap(Effect.yieldNow(), () => waitUntil(read, pred, rounds - 1)),
   )
 
-test('a seeded scene boots its store from the override', async () => {
-  const { runtime, read } = makeHarness(seedScene(CounterScene, { count: 5 }))
-  try {
-    expect(await runtime.runPromise(read)).toBe(5)
-  } finally {
-    await runtime.dispose()
-  }
+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))
 })
 
-test('the live reducer drives the SAME overridden store', async () => {
-  const { runtime, read } = makeHarness(seedScene(CounterScene, { count: 5 }))
-  try {
-    const next = await runtime.runPromise(
-      Effect.gen(function* () {
-        expect(yield* read).toBe(5)
-        yield* publish('High', Event.construct(Bumped, {}))
-        return yield* waitUntil(read, (n) => n === 6)
-      }),
-    )
+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)
-  } finally {
-    await runtime.dispose()
-  }
+  }).pipe(Effect.provide(layer))
 })
 
-test('an absent key leaves the authored seed in place', async () => {
-  const { runtime, read } = makeHarness(overlayRawSeeds(CounterScene, { other: 1 }))
-  try {
-    expect(await runtime.runPromise(read)).toBe(1)
-  } finally {
-    await runtime.dispose()
-  }
+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(1)
+  }).pipe(Effect.provide(layer))
 })
 
-test('a schema-invalid override falls back to the authored seed', async () => {
-  const { runtime, read } = makeHarness(overlayRawSeeds(CounterScene, { count: 'not-a-number' }))
-  try {
-    expect(await runtime.runPromise(read)).toBe(1)
-  } finally {
-    await runtime.dispose()
-  }
+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))
 })
 
-test('seeding does not leak into the original scene', async () => {
+it.scopedLive('seeding does not leak into the original scene', () => {
   const seeded = makeHarness(seedScene(CounterScene, { count: 5 }))
-  try {
-    expect(await seeded.runtime.runPromise(seeded.read)).toBe(5)
-  } finally {
-    await seeded.runtime.dispose()
-  }
-  // Building the ORIGINAL scene's layers again boots from the authored seed —
-  // the overlay lives only on the seeded variant's wrapped layers.
   const original = makeHarness(CounterScene)
-  try {
-    expect(await original.runtime.runPromise(original.read)).toBe(1)
-  } finally {
-    await original.runtime.dispose()
-  }
+  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)
+  })
 })

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