@playfast/reform 1.1.1 → 1.2.1

package/src/scene/scene.ts

@@ -1,13 +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,
-  EngineServices,
-  FeatureRequirement,
-  ProvidedBy,
-} from '../feature/feature'
+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'
@@ -16,88 +17,257 @@ import {
   type Instrumentation,
   noopInstrumentation,
 } from '../runtime/instrumentation'
+import type { EngineServices } from '../runtime/loop'
 
-export type MountedServices = CompositionService | Bus
+export type MountedServices = CompositionId<string> | Bus
 
-type BootEvent = EventOf<string, unknown>
+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'
-  readonly composition: CompositionClass<unknown, C, S>
-  readonly provide: ReadonlyArray<Layer.Layer<MountedServices, never, never>>
-  // 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>
-  // instrumentation on the scene (not only layers): host render spans live outside 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 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 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 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 } : {}),
-})
-
-export interface FeatureSceneConfig<
-  Requires extends ReadonlyArray<FeatureRequirement>,
-> {
-  readonly provide: Layer.Layer<EngineServices | ProvidedBy<Requires>, never, never>
+export interface FeatureSceneConfig<OpenServices> {
+  readonly provide: Layer.Layer<EngineServices | OpenServices, never, never>
 }
 
 export const featureScene = <
+  FeatureIdentity,
   P,
   C extends UiContract,
   ROut,
-  Requires extends ReadonlyArray<FeatureRequirement>,
+  DirectRequires extends ReadonlyArray<FeatureRequirement>,
+  OpenServices,
+  S extends ReadonlyArray<unknown>,
+  N extends string,
+  Identity,
 >(
-  feature: EagerFeatureClass<P, C, ROut, Requires>,
-  config: FeatureSceneConfig<Requires>,
-): Scene<C> => {
-  const app = feature.eagerModule.layer.pipe(Layer.provideMerge(config.provide))
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- close the generic root module's erased output to the host-readable Scene subset
-  const closed = app as Layer.Layer<MountedServices, never, never>
-  return scene(feature.composition, {
-    provide: [closed],
-    boot: feature.binding.boot,
+  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,
   })
 }
 
-// Tooling seam: wrap closed layers with seed overrides; keys are member names (not group names)
-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)) }
+): 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 profiledScene = <C extends UiContract, S extends ReadonlyArray<unknown>>(
+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,
+): 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> => ({
-  ...base,
-  instrumentation,
-  provide: base.provide.map(Layer.locally(CurrentInstrumentation, 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: Scene): Instrumentation =>
+export const sceneInstrumentation = (candidate: AnyScene): Instrumentation =>
   candidate.instrumentation ?? noopInstrumentation
 
-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, 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))
+})