@playfast/reform 1.1.1 → 1.2.1

package/src/compose/ui.ts

@@ -1,33 +1,33 @@
 import type { FunctionComponent } from 'react'
 import { Context, type Schema } from 'effect'
+import type { AST } from 'effect/SchemaAST'
 import { type Manifest, definitionClass } from '../definition/definition'
 import type { Trigger } from '../ui/trigger'
-import { type Node, type SlotClass, type SlotInstance, type SlotProps } from './slot'
-import type { AnyValue } from '../internal/variance'
+import { type AnySlot, type AnySlotInstance, type Node, type SlotProps } from './slot'
 
-export interface UiContract {
+// Field presence drives conditional slot/event inference; Option would erase it.
+interface UiContractOptionalFields {
+  slots: Record<string, AnySlotInstance>
+  events: Record<string, Trigger<never>>
+}
+
+export interface UiContract extends Partial<UiContractOptionalFields> {
   props: unknown
-  // Optional so local `ui('X')<{ props }>()` stays terse and `C extends { slots/events: … }` discriminates presence
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- presence drives `extends {...}` contract inference (see note above)
-  slots?: Record<string, SlotInstance<AnyValue>>
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- presence drives `extends {...}` contract inference (see note above)
-  events?: Record<string, Trigger<AnyValue>>
 }
 
 type PropsOf<C extends UiContract> = C['props']
-export type EventsOf<C extends UiContract> = C extends { events: infer E } ? E : Record<never, never>
-// Slots are Partial FunctionComponents: parent may supply props; remote placeholder omits them.
-// slotKey selects one keyed list child on the wire; framework-handled, never a child prop.
+export type EventsOf<C extends UiContract> = C extends { events: infer E }
+  ? E
+  : Readonly<Record<PropertyKey, never>>
+
+// slotKey is framework-only selection; Partial also permits prop-less remote placeholders.
 type SlotsOf<C extends UiContract> = C extends { slots: infer S }
   ? {
-      // slotKey inside Partial so `any` child props still collapse to `any` (outer & would break unknown)
-      // Handle = renderable FC + inspectable `.props` fills (engine fixes multiplicity)
       readonly [K in keyof S]: FunctionComponent<
-        // oxlint-disable-next-line reform-rules/no-optional-fields -- React/JSX component-prop shape (`<slots.Row slotKey={id} />`); singleton slots omit it, framework-handled
-        Partial<SlotProps<S[K]> & { readonly slotKey?: string }>
+        Partial<SlotProps<S[K]> & { readonly slotKey: string }>
       > & { readonly props: ReadonlyArray<SlotProps<S[K]>> }
     }
-  : Record<never, never>
+  : Readonly<Record<PropertyKey, never>>
 
 export type ViewImpl<C extends UiContract> = (
   props: PropsOf<C>,
@@ -38,51 +38,86 @@ export type ViewImpl<C extends UiContract> = (
 export const UiTypeId: unique symbol = Symbol.for('reform/Ui')
 export type UiTypeId = typeof UiTypeId
 
-export interface UiManifest extends Manifest {
+export const UiServiceTypeId: unique symbol = Symbol.for('reform/UiService')
+export type UiServiceTypeId = typeof UiServiceTypeId
+
+export interface UiService<N extends string> {
+  readonly [UiServiceTypeId]: N
+}
+
+export type CallableView = (...args: ReadonlyArray<never>) => unknown
+
+export interface UiSchemaReflection {
+  readonly ast: AST
+}
+
+interface UiManifestOptionalFields {
+  readonly props: UiSchemaReflection
+  readonly events: Readonly<Record<string, UiSchemaReflection>>
+}
+
+export interface UiManifest extends Manifest, Partial<UiManifestOptionalFields> {
   readonly kind: 'Ui'
-  // Schema variance needs any in encoded/context; present only on wired form for discrimination
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- wire manifest field present only on the wired form (see note above)
-  readonly props?: Schema.Schema.AnyNoContext
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- wire manifest field present only on the wired form (see note above)
-  readonly events?: Readonly<Record<string, Schema.Schema.AnyNoContext>>
 }
 
 export interface WiredUiManifest extends UiManifest {
-  readonly props: Schema.Schema.AnyNoContext
+  readonly props: UiSchemaReflection
 }
 
-// Not yieldable: bodies return Structure; host resolves view via `impl`
-export interface UiClass<C extends UiContract> {
+export type UiCapture<Result> = <C extends UiContract, N extends string>(
+  contract: UiClass<C, N>,
+) => Result
+
+export interface UiReflection<
+  out C extends UiContract = UiContract,
+  out N extends string = string,
+> {
+  new (): {}
+  readonly [UiTypeId]: UiTypeId
+  readonly manifest: UiManifest & { readonly name: N }
+  readonly Contract: C
+}
+
+export interface AnyUi {
   new (): {}
   readonly [UiTypeId]: UiTypeId
   readonly manifest: UiManifest
-  readonly impl: Context.Tag<ViewImpl<C>, ViewImpl<C>>
+  readonly capture: <Result>(visit: UiCapture<Result>) => Result
+}
+
+export interface UiClass<C extends UiContract, N extends string> extends UiReflection<C, N> {
+  readonly capture: <Result>(visit: UiCapture<Result>) => Result
+  readonly impl: Context.Tag<UiService<N>, ViewImpl<C>>
+  readonly provider: Context.Tag<UiService<N>, CallableView>
 }
 
-export type Contract<U> = U extends UiClass<infer C> ? C : never
+export type Contract<U> = U extends UiReflection<infer C, infer _N> ? C : never
+export type UiName<U> = U extends UiReflection<infer _C, infer N> ? N : never
+
+export type WiredUi<C extends UiContract, N extends string> = UiClass<C, N> & {
+  readonly manifest: WiredUiManifest
+}
 
-export type WiredUi<C extends UiContract> = UiClass<C> & { readonly manifest: WiredUiManifest }
+interface WireSchemasOptionalFields {
+  readonly events: Readonly<Record<string, Schema.Schema.AnyNoContext>>
+  readonly slots: Readonly<Record<string, AnySlot>>
+}
 
-export interface WireSchemas {
+export interface WireSchemas extends Partial<WireSchemasOptionalFields> {
   readonly props: Schema.Schema.AnyNoContext
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- presence drives `extends {...}` derivation (DerivedEvents)
-  readonly events?: Readonly<Record<string, Schema.Schema.AnyNoContext>>
-  // Slot CLASSES (not instances) so the contract facade derives InstanceType
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- presence drives `extends {...}` derivation (DerivedSlots)
-  readonly slots?: Readonly<Record<string, SlotClass>>
 }
 
 type DerivedEvents<Sch extends WireSchemas> = Sch extends {
   readonly events: infer E extends Record<string, Schema.Schema.AnyNoContext>
 }
   ? { readonly [K in keyof E]: Trigger<Schema.Schema.Type<E[K]>> }
-  : Record<never, never>
+  : Readonly<Record<PropertyKey, never>>
 
 type DerivedSlots<Sch extends WireSchemas> = Sch extends {
-  readonly slots: infer S extends Record<string, SlotClass>
+  readonly slots: infer S extends Record<string, AnySlot>
 }
   ? { readonly [K in keyof S]: InstanceType<S[K]> }
-  : Record<never, never>
+  : Readonly<Record<PropertyKey, never>>
 
 export type DerivedContract<Sch extends WireSchemas> = {
   readonly props: Schema.Schema.Type<Sch['props']>
@@ -90,40 +125,98 @@ export type DerivedContract<Sch extends WireSchemas> = {
   readonly events: DerivedEvents<Sch>
 }
 
-export const isUi = (candidate: unknown): candidate is UiClass<UiContract> =>
+export const isUi = (candidate: unknown): candidate is AnyUi =>
   (typeof candidate === 'function' || typeof candidate === 'object') &&
   candidate !== null &&
   UiTypeId in candidate
 
-const buildUi = <C extends UiContract, M extends UiManifest>(
-  name: string,
+type UiDefinitionStatics<
+  C extends UiContract,
+  N extends string,
+  M extends UiManifest & { readonly name: N },
+> = Pick<
+  UiClass<C, N> & { readonly manifest: M },
+  typeof UiTypeId | 'manifest' | 'impl' | 'provider' | 'capture'
+>
+
+const buildUi = <
+  N extends string,
+  C extends UiContract,
+  M extends UiManifest & { readonly name: N },
+>(
+  name: N,
   manifest: M,
-): UiClass<C> & { readonly manifest: M } => {
-  const impl = Context.GenericTag<ViewImpl<C>, ViewImpl<C>>(`reform/ui/${name}`)
-  return definitionClass<UiClass<C> & { readonly manifest: M }>({
+): UiClass<C, N> & { readonly manifest: M } => {
+  const impl = Context.GenericTag<UiService<N>, ViewImpl<C>>(`reform/ui/${name}`)
+  const provider = Context.GenericTag<UiService<N>, CallableView>(`reform/ui/${name}`)
+  const contract = definitionClass<UiClass<C, N> & { readonly manifest: M }>({
     [UiTypeId]: UiTypeId,
     manifest,
     impl,
-  })
+    provider,
+    capture: <Result>(visit: UiCapture<Result>): Result => visit(contract),
+  } satisfies UiDefinitionStatics<C, N, M>)
+  return contract
 }
 
-export function ui(name: string): <C extends UiContract>() => UiClass<C>
-export function ui<const Sch extends WireSchemas>(name: string, schemas: Sch): WiredUi<DerivedContract<Sch>>
+type UiDefinition<N extends string> = (<C extends UiContract>() => UiClass<C, N>) | AnyUi
+
+export function ui<const N extends string>(name: N): <C extends UiContract>() => UiClass<C, N>
+export function ui<const N extends string, const Sch extends WireSchemas>(
+  name: N,
+  schemas: Sch,
+): WiredUi<DerivedContract<Sch>, N>
 // oxlint-disable-next-line reform-rules/min-var-name -- `ui` is the public framework contract-authoring API; renaming would break every caller across the monorepo
-export function ui(name: string, schemas?: WireSchemas): unknown {
+export function ui<const N extends string>(name: N, schemas?: WireSchemas): UiDefinition<N> {
   if (schemas === undefined) {
-    return <C extends UiContract>(): UiClass<C> => buildUi<C, UiManifest>(name, { kind: 'Ui', name })
+    return <C extends UiContract>(): UiClass<C, N> =>
+      buildUi<N, C, UiManifest & { readonly name: N }>(name, {
+        kind: 'Ui',
+        name,
+      })
   }
   const eventFields = schemas.events === undefined ? {} : { events: schemas.events }
-  const manifest: WiredUiManifest = { kind: 'Ui', name, props: schemas.props, ...eventFields }
-  return buildUi<DerivedContract<WireSchemas>, WiredUiManifest>(name, manifest)
+  const manifest: WiredUiManifest & { readonly name: N } = {
+    kind: 'Ui',
+    name,
+    props: schemas.props,
+    ...eventFields,
+  }
+  return buildUi<N, DerivedContract<WireSchemas>, WiredUiManifest & { readonly name: N }>(
+    name,
+    manifest,
+  )
 }
 
 export const UiViewContract: unique symbol = Symbol.for('reform/ui/view-contract')
 export type UiViewContract = typeof UiViewContract
 
-export type MadeView<C extends UiContract> = ViewImpl<C> & { readonly [UiViewContract]: UiClass<C> }
+export type MadeViewCapture<Result> = <C extends UiContract, N extends string, U extends AnyUi>(
+  view: MadeView<C, N, U>,
+) => Result
+
+export type MadeView<
+  C extends UiContract,
+  N extends string,
+  U extends AnyUi = UiClass<C, N>,
+> = ViewImpl<C> & {
+  readonly [UiViewContract]: U
+  readonly capture: <Result>(visit: MadeViewCapture<Result>) => Result
+}
 
-export const make = <C extends UiContract>(contract: UiClass<C>, view: ViewImpl<C>): MadeView<C> =>
-  // oxlint-disable-next-line reform-rules/no-object-assign -- `view` is a callable function; spread would drop callability, so the brand is attached in place
-  Object.assign(view, { [UiViewContract]: contract })
+export type AnyMadeView = CallableView & {
+  readonly [UiViewContract]: AnyUi
+  readonly capture: <Result>(visit: MadeViewCapture<Result>) => Result
+}
+
+export const make = <U extends AnyUi>(
+  contract: U,
+  view: ViewImpl<Contract<U>>,
+): MadeView<Contract<U>, UiName<U>, U> => {
+  // oxlint-disable-next-line reform-rules/no-object-assign -- `view` is callable; spread would drop callability, so its reflection statics are attached in place
+  const made: MadeView<Contract<U>, UiName<U>, U> = Object.assign(view, {
+    [UiViewContract]: contract,
+    capture: <Result>(visit: MadeViewCapture<Result>): Result => visit(made),
+  })
+  return made
+}

package/src/compose/ui.typecheck.ts

@@ -1,4 +1,5 @@
 import { Schema as S } from 'effect'
+import { slot, type SlotService } from './slot'
 import {
   type Contract,
   type DerivedContract,
@@ -7,13 +8,32 @@ import {
   ui,
   type UiClass,
   type UiContract,
+  type UiService,
   type WiredUi,
 } from './ui'
 
-declare function acceptsAny<C extends UiContract>(contract: UiClass<C>): void
-declare function acceptsWired<C extends UiContract>(contract: WiredUi<C>): void
+type ExpectFalse<Value extends false> = Value
+
+declare function acceptsAny<C extends UiContract, N extends string>(contract: UiClass<C, N>): void
+declare function acceptsWired<C extends UiContract, N extends string>(contract: WiredUi<C, N>): void
 
 class LocalUi extends ui('Local')<{ props: { n: number } }>() {}
+class SameShapeUi extends ui('SameShape')<{ props: { n: number } }>() {}
+class FirstSlot extends slot('FirstSlot')<FirstSlot>() {}
+class SecondSlot extends slot('SecondSlot')<SecondSlot>() {}
+
+type SameShapedUiDefinitionsRemainDistinct = ExpectFalse<
+  typeof LocalUi extends typeof SameShapeUi ? true : false
+>
+type SameShapedSlotDefinitionsRemainDistinct = ExpectFalse<
+  typeof FirstSlot extends typeof SecondSlot ? true : false
+>
+type WrongUiDoesNotCloseRequirement = ExpectFalse<
+  UiService<'SameShape'> extends UiService<'Local'> ? true : false
+>
+type WrongSlotDoesNotCloseRequirement = ExpectFalse<
+  SlotService<'SecondSlot', SecondSlot> extends SlotService<'FirstSlot', FirstSlot> ? true : false
+>
 const wiredSchemas: {
   readonly props: S.Struct<{ n: typeof S.Number }>
   readonly events: { readonly bump: S.Struct<{ by: typeof S.Number }> }
@@ -21,7 +41,10 @@ const wiredSchemas: {
   props: S.Struct({ n: S.Number }),
   events: { bump: S.Struct({ by: S.Number }) },
 }
-const WiredUiClassBase: WiredUi<DerivedContract<typeof wiredSchemas>> = ui('Wired', wiredSchemas)
+const WiredUiClassBase: WiredUi<DerivedContract<typeof wiredSchemas>, 'Wired'> = ui(
+  'Wired',
+  wiredSchemas,
+)
 class WiredUiClass extends WiredUiClassBase {}
 
 acceptsAny(LocalUi)
@@ -32,7 +55,7 @@ acceptsWired(WiredUiClass)
 // @ts-expect-error -- LocalUi is `UiClass`, not `WiredUi`
 acceptsWired(LocalUi)
 
-export const derivedView: MadeView<Contract<typeof WiredUiClass>> = make(
+const derivedView: MadeView<Contract<typeof WiredUiClass>, 'Wired'> = make(
   WiredUiClass,
   ({ n: count }, _slots, { bump }) => {
     const numeric: number = count
@@ -40,3 +63,16 @@ export const derivedView: MadeView<Contract<typeof WiredUiClass>> = make(
     return `${numeric}`
   },
 )
+
+type UiTypeProofs = [
+  SameShapedUiDefinitionsRemainDistinct,
+  SameShapedSlotDefinitionsRemainDistinct,
+  WrongUiDoesNotCloseRequirement,
+  WrongSlotDoesNotCloseRequirement,
+]
+declare const uiTypeProofs: UiTypeProofs
+
+void uiTypeProofs
+void derivedView
+
+export {}

package/src/definition/definition.ts

@@ -30,28 +30,41 @@ export interface Manifest {
   readonly name: string
 }
 
-export const yieldableClass = <A, E, R, Statics extends object>(
+export function yieldableClass<A, E, R, Statics extends object>(
   read: Effect.Effect<A, E, R>,
   statics: Statics,
-): { new (): {} } & Effect.Effect<A, E, R> & Statics => {
+): { new (): {} } & Effect.Effect<A, E, R> & Statics
+export function yieldableClass(
+  read: Effect.Effect<unknown, unknown, unknown>,
+  statics: object,
+): unknown {
   class Base {}
   Object.setPrototypeOf(Base, read)
   Reflect.ownKeys(statics).forEach((key) => {
     const staticValue = Reflect.get(statics, key)
-    Object.defineProperty(Base, key, { value: staticValue, writable: true, enumerable: true, configurable: true })
+    Object.defineProperty(Base, key, {
+      value: staticValue,
+      writable: true,
+      enumerable: true,
+      configurable: true,
+    })
   })
   attachInspectable(Base, () => describe(statics))
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- phantom-shaped static side cannot structurally satisfy the yieldable Effect & Statics type
-  return Base as never
+  return Base
 }
 
-export const definitionClass = <Class>(statics: object): Class => {
+export function definitionClass<Class>(statics: object): Class
+export function definitionClass(statics: object): unknown {
   const Base = class {}
   Reflect.ownKeys(statics).forEach((key) => {
     const staticValue = Reflect.get(statics, key)
-    Object.defineProperty(Base, key, { value: staticValue, writable: true, enumerable: true, configurable: true })
+    Object.defineProperty(Base, key, {
+      value: staticValue,
+      writable: true,
+      enumerable: true,
+      configurable: true,
+    })
   })
   attachInspectable(Base, () => describe(statics))
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- the one documented seam: phantom type-only fields mean the assembled class cannot structurally satisfy Class
-  return Base as unknown as Class
+  return Base
 }

package/src/event/event.fromSource.test.ts

@@ -0,0 +1,172 @@
+import { expect, it } from '@effect/vitest'
+import { Effect, Exit, Layer, Option, Schema as S, Scope } from 'effect'
+import { Engine, Event, Reducer, State } from '../index'
+import { flush } from '../testkit/flight.testkit'
+
+// `Event.liveFromSource` turns a Source *transition* into an ordinary event, so
+// a rule can be triggered by a value moving rather than by a UI dispatch. Every
+// case observes through a reducer — the framework's own writer — so what the
+// log holds is exactly what the bus carried, with no spy in the middle.
+
+
+// One string carrying both ends of a transition: `none->0` for the initial
+// emission (nothing preceded it), `0->1` for a change.
+const rendered = (change: Event.SourceChange<number>): string => {
+  const before = Option.match(change.previous, {
+    onNone: () => 'none',
+    onSome: (level) => `${level}`,
+  })
+  return `${before}->${change.current}`
+}
+
+const append = (entries: ReadonlyArray<string>, event: { readonly label: string }) => [
+  ...entries,
+  event.label,
+]
+
+const Label = S.Struct({ label: S.String })
+
+it.live('emits nothing for the value present at construction (changes only)', () => {
+  class Level extends State.make('changes-only/level', S.Number) {}
+  class Moved extends Event.make('ChangesOnlyMoved', Label) {}
+  class Log extends State.make('changes-only/log', S.Array(S.String)) {}
+  class LogReducer extends Reducer.make('ChangesOnlyLog', { states: [Log], events: [Moved] }) {}
+
+  // The adapter is wired DOWNSTREAM of the reducer that observes it: an
+  // emission is an ordinary dispatch, so — like a scene's boot events — it can
+  // only be folded by handlers already registered when it lands.
+  const TestLayer = Event.liveFromSource(Moved, Level, {
+    payload: (change) => Option.some({ label: rendered(change) }),
+  }).pipe(
+    Layer.provideMerge(Reducer.live(LogReducer, append)),
+    Layer.provideMerge(Layer.mergeAll(State.live(Level, 0), State.live(Log, []))),
+    Layer.provideMerge(Engine),
+  )
+
+  return Effect.gen(function* () {
+    const level = yield* Level.store
+    const log = yield* Log.store
+
+    yield* flush()
+    expect(log.get()).toEqual([])
+
+    level.set(1)
+    yield* flush()
+    expect(log.get()).toEqual(['0->1'])
+
+    // Store equality is the framework's, not this adapter's: re-setting the same
+    // value is not a change, so nothing notifies and nothing is emitted.
+    level.set(1)
+    yield* flush()
+    expect(log.get()).toEqual(['0->1'])
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('emitInitial reports the construction value once, with no previous', () => {
+  class Level extends State.make('emit-initial/level', S.Number) {}
+  class Moved extends Event.make('EmitInitialMoved', Label) {}
+  class Log extends State.make('emit-initial/log', S.Array(S.String)) {}
+  class LogReducer extends Reducer.make('EmitInitialLog', { states: [Log], events: [Moved] }) {}
+
+  const TestLayer = Event.liveFromSource(Moved, Level, {
+    emitInitial: true,
+    payload: (change) => Option.some({ label: rendered(change) }),
+  }).pipe(
+    Layer.provideMerge(Reducer.live(LogReducer, append)),
+    Layer.provideMerge(Layer.mergeAll(State.live(Level, 2), State.live(Log, []))),
+    Layer.provideMerge(Engine),
+  )
+
+  return Effect.gen(function* () {
+    const level = yield* Level.store
+    const log = yield* Log.store
+
+    yield* flush()
+    expect(log.get()).toEqual(['none->2'])
+
+    // The initial emission seeds `previous`: the next change reports the
+    // construction value as its left-hand side, not another `none`.
+    level.set(1)
+    yield* flush()
+    expect(log.get()).toEqual(['none->2', '2->1'])
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('a payload of Option.none() suppresses a non-qualifying transition', () => {
+  class Phase extends State.make('suppressed/phase', S.Literal('idle', 'busy', 'ready')) {}
+  class BecameReady extends Event.make('SuppressedBecameReady', S.Struct({ from: S.String })) {}
+  class Log extends State.make('suppressed/log', S.Array(S.String)) {}
+  class LogReducer extends Reducer.make('SuppressedLog', {
+    states: [Log],
+    events: [BecameReady],
+  }) {}
+
+  // The exact transition predicate lives in the projection: only a move INTO
+  // 'ready' yields a payload — every other transition emits nothing at all.
+  const TestLayer = Event.liveFromSource(BecameReady, Phase, {
+    payload: (change) =>
+      change.current === 'ready'
+        ? Option.some({
+            from: Option.match(change.previous, { onNone: () => 'none', onSome: (phase) => phase }),
+          })
+        : Option.none(),
+  }).pipe(
+    Layer.provideMerge(Reducer.live(LogReducer, (entries, event) => [...entries, event.from])),
+    Layer.provideMerge(Layer.mergeAll(State.live(Phase, 'idle'), State.live(Log, []))),
+    Layer.provideMerge(Engine),
+  )
+
+  return Effect.gen(function* () {
+    const phase = yield* Phase.store
+    const log = yield* Log.store
+
+    phase.set('busy')
+    yield* flush()
+    expect(log.get()).toEqual([])
+
+    phase.set('ready')
+    yield* flush()
+    expect(log.get()).toEqual(['busy'])
+  }).pipe(Effect.provide(TestLayer))
+})
+
+it.live('closing the scope ends the emissions, including one already in flight', () => {
+  class Level extends State.make('scoped/level', S.Number) {}
+  class Moved extends Event.make('ScopedMoved', Label) {}
+  class Log extends State.make('scoped/log', S.Array(S.String)) {}
+  class LogReducer extends Reducer.make('ScopedLog', { states: [Log], events: [Moved] }) {}
+
+  const AdapterLive = Event.liveFromSource(Moved, Level, {
+    payload: (change) => Option.some({ label: rendered(change) }),
+  })
+  // Everything except the adapter outlives the closed scope, so a lost emission
+  // can only mean the adapter stopped — not that its observer went away.
+  const TestLayer = Reducer.live(LogReducer, append).pipe(
+    Layer.provideMerge(Layer.mergeAll(State.live(Level, 0), State.live(Log, []))),
+    Layer.provideMerge(Engine),
+  )
+
+  return Effect.gen(function* () {
+    const scope = yield* Scope.make()
+    yield* Layer.buildWithScope(AdapterLive, scope)
+    const level = yield* Level.store
+    const log = yield* Log.store
+
+    level.set(1)
+    yield* flush()
+    expect(log.get()).toEqual(['0->1'])
+
+    // A write that already handed the listener to the notification scheduler,
+    // released before that flush runs: unsubscribing alone would not stop it.
+    yield* Effect.zipRight(
+      Effect.sync(() => level.set(2)),
+      Scope.close(scope, Exit.void),
+    )
+    yield* flush()
+    expect(log.get()).toEqual(['0->1'])
+
+    level.set(0)
+    yield* flush()
+    expect(log.get()).toEqual(['0->1'])
+  }).pipe(Effect.provide(TestLayer))
+})

package/src/event/event.test.ts

@@ -18,3 +18,13 @@ test('empty-payload events construct to just their tag', () => {
   class Pinged extends Event.make('Pinged', S.Struct({})) {}
   expect(Event.construct(Pinged, {})).toEqual({ _tag: 'Pinged' })
 })
+
+test('an existential event validates payloads before constructing', () => {
+  class Added extends Event.make('Added', S.Struct({ id: S.String })) {}
+  const reflected: Event.AnyEvent = Added
+  expect(reflected.buildUnknown({ id: 'safe' })).toEqual({
+    _tag: 'Added',
+    id: 'safe',
+  })
+  expect(() => reflected.buildUnknown({ id: 1 })).toThrow()
+})