@playfast/reform 1.0.1 → 1.2.0

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

@@ -0,0 +1,172 @@
+import { expect, it } from '@effect/vitest'
+import { Duration, Effect, Exit, Layer, Option, Schema as S, Scope } from 'effect'
+import { Engine, Event, Reducer, State } from '../index'
+
+// `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.
+
+const tick = Effect.sleep(Duration.millis(1))
+
+// 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* tick
+    expect(log.get()).toEqual([])
+
+    level.set(1)
+    yield* tick
+    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* tick
+    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* tick
+    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* tick
+    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* tick
+    expect(log.get()).toEqual([])
+
+    phase.set('ready')
+    yield* tick
+    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* tick
+    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* tick
+    expect(log.get()).toEqual(['0->1'])
+
+    level.set(0)
+    yield* tick
+    expect(log.get()).toEqual(['0->1'])
+  }).pipe(Effect.provide(TestLayer))
+})

package/src/event/event.test.ts

@@ -2,9 +2,6 @@ import { expect, test } from 'vitest'
 import { Schema as S } from 'effect'
 import { Event } from '../index'
 
-// An event is a pure data fact: `Event.construct` builds the tagged value the
-// bus carries, and the class carries the reflectable `manifest` + `tag`.
-
 test('Event.construct builds the tagged value `{ _tag, ...payload }`', () => {
   class Added extends Event.make('Added', S.Struct({ id: S.String })) {}
   expect(Event.construct(Added, { id: 'x' })).toEqual({ _tag: 'Added', id: 'x' })
@@ -21,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()
+})

package/src/event/event.ts

@@ -1,65 +1,140 @@
-import { Effect, PubSub, Runtime, type Schema } from 'effect'
+import { Effect, Layer, MutableRef, Option, PubSub, Runtime, Schema } from 'effect'
 import { type Manifest, definitionClass } from '../definition/definition'
+import { resolveScheduler } from '../internal/scheduler'
 import { Bus, publish, type Tagged } from '../runtime/bus'
+import type { Source } from '../state/token'
 import type { Trigger } from '../ui/trigger'
 
-/** The dispatched value of an event: `{ _tag, ...payload }`, matched with `Match.tags`. */
 export type EventOf<N extends string, P> = Tagged & { readonly _tag: N } & P
 
-export interface EventManifest<N extends string, P> extends Manifest {
+export interface EventSchemaReflection {
+  readonly ast: Schema.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface EventManifest<N extends string> extends Manifest {
   readonly kind: 'Event'
   readonly name: N
-  readonly schema: Schema.Schema<P, any>
+  readonly schema: EventSchemaReflection
 }
 
-export interface EventClass<out N extends string, in out P> {
+export interface EventReflection<out N extends string = string, out P = unknown> {
   new (): {}
-  readonly manifest: EventManifest<N, P>
+  readonly manifest: EventManifest<N>
   readonly tag: N
-  /** Carrier for `Event.construct` — builds the tagged value `{ _tag, ...payload }`. */
+  readonly Payload: P
+}
+
+export type EventCapture<Result> = <N extends string, P>(event: EventClass<N, P>) => Result
+
+export interface AnyEvent extends EventReflection {
+  readonly buildUnknown: (payload: unknown) => Tagged
+  readonly capture: <Result>(visit: EventCapture<Result>) => Result
+}
+
+export interface EventClass<out N extends string, in out P> extends EventReflection<N, P> {
   readonly build: (payload: P) => EventOf<N, P>
-  /** Carrier for `Event.trigger` — the UI callback effect (High priority). */
   readonly trigger: Effect.Effect<Trigger<P>, never, Bus>
+  readonly buildUnknown: (payload: unknown) => Tagged
+  readonly capture: <Result>(visit: EventCapture<Result>) => Result
 }
 
-export type AnyEvent = EventClass<string, any>
-export type EventType<E> = E extends EventClass<infer N, infer P> ? EventOf<N, P> : never
+export type EventName<E> = E extends EventReflection<infer N, infer _P> ? N : never
+export type EventPayload<E> = E extends EventReflection<string, infer P> ? P : never
+export type EventType<E> = E extends EventReflection<infer N, infer P> ? EventOf<N, P> : never
 
-/** A pure data fact. Events depend on nothing — only reducers tie them to state. */
-export const make = <const N extends string, P>(
+export const make = <const N extends string, P, Encoded>(
   name: N,
-  schema: Schema.Schema<P, any>,
+  schema: Schema.Schema<P, Encoded, never>,
 ): EventClass<N, P> => {
-  const build = (payload: P): EventOf<N, P> => ({ _tag: name, ...payload })
+  const build = (payload: P): EventOf<N, P> => ({ ...payload, _tag: name })
+  // Payloads at existential boundaries are already-decoded domain values, so
+  // check the Type side — decodeUnknownSync would reject transforming schemas
+  // (e.g. a real Option, whose _tag lives on the prototype).
+  const validatePayload = Schema.validateSync(schema)
+  const buildUnknown = (payload: unknown): Tagged => build(validatePayload(payload))
   const trigger = Effect.gen(function* () {
     const bus = yield* Bus
     const runtime = yield* Effect.runtime<never>()
-    // Dispatch synchronously: on the unbounded bus `publish` only enqueues and
-    // returns, so `runSync` never suspends and no fiber is forked per UI event.
-    // The drain loop still folds reducers on its own fiber — publish is pure offer.
     return (payload: P) => {
       Runtime.runSync(runtime)(PubSub.publish(bus, { priority: 'High', event: build(payload) }))
     }
   })
-  return definitionClass<EventClass<N, P>>({
+  const event: EventClass<N, P> = definitionClass<EventClass<N, P>>({
     manifest: { kind: 'Event' as const, name, schema },
     tag: name,
     build,
+    buildUnknown,
     trigger,
+    capture: <Result>(visit: EventCapture<Result>): Result => visit(event),
   })
+  return event
 }
 
-/** Construct the tagged value for an event (used for `boot` events). */
-export const construct = <N extends string, P>(event: EventClass<N, P>, payload: P): EventOf<N, P> =>
-  event.build(payload)
+export function construct<N extends string, P>(event: EventClass<N, P>, payload: P): EventOf<N, P>
+export function construct<E extends AnyEvent>(event: E, payload: EventPayload<E>): EventType<E>
+export function construct(event: AnyEvent, payload: unknown): Tagged {
+  return event.buildUnknown(payload)
+}
 
-/** Dispatch as a follow-up (Normal priority) from a procedure/effect. */
-export const dispatch = <N extends string, P>(
-  event: EventClass<N, P>,
-  payload: P,
-): Effect.Effect<void, never, Bus> => publish('Normal', event.build(payload))
+export const dispatch = <E extends AnyEvent>(
+  event: E,
+  payload: EventPayload<E>,
+): Effect.Effect<void, never, Bus> => publish('Normal', event.buildUnknown(payload))
 
-/** A callback for the UI that dispatches at High priority via the runtime. */
 export const trigger = <N extends string, P>(
   event: EventClass<N, P>,
 ): Effect.Effect<Trigger<P>, never, Bus> => event.trigger
+
+export interface SourceChange<A> {
+  readonly previous: Option.Option<A>
+  readonly current: A
+}
+
+export interface SourceEventConfigExternalApi<A, P> {
+  readonly emitInitial?: boolean
+  readonly payload: (change: SourceChange<A>) => Option.Option<P>
+}
+export type SourceEventConfig<A, P> = SourceEventConfigExternalApi<A, P>
+
+export const liveFromSource = <N extends string, P, SourceName extends string, A, Identifier>(
+  event: EventClass<N, P>,
+  source: Source<SourceName, A, Identifier>,
+  config: SourceEventConfigExternalApi<A, P>,
+): Layer.Layer<never, never, Identifier | Bus> =>
+  Layer.scopedDiscard(
+    Effect.gen(function* () {
+      const store = yield* source.store
+      const scheduler = yield* resolveScheduler
+      const runtime = yield* Effect.runtime<Bus>()
+      const initial = store.getSnapshot()
+      // The scheduler coalesces bursts, so track the last value this adapter observed.
+      const seen = MutableRef.make(initial)
+      // A queued notification may outlive unsubscribe within the same tick.
+      const active = MutableRef.make(true)
+      const emit = (change: SourceChange<A>): void => {
+        if (!MutableRef.get(active)) {
+          return
+        }
+        const payload = config.payload(change)
+        if (Option.isSome(payload)) {
+          Runtime.runSync(runtime)(publish('Normal', event.build(payload.value)))
+        }
+      }
+      const unsubscribe = store.subscribe(() => {
+        const current = store.getSnapshot()
+        const previous = MutableRef.get(seen)
+        MutableRef.set(seen, current)
+        emit({ previous: Option.some(previous), current })
+      })
+      yield* Effect.addFinalizer(() =>
+        Effect.sync(() => {
+          MutableRef.set(active, false)
+          unsubscribe()
+        }),
+      )
+      if (config.emitInitial === true) {
+        // Defer until reducers and procedures from the same layer build have registered.
+        scheduler.schedule([() => emit({ previous: Option.none(), current: initial })])
+      }
+    }),
+  )

package/src/event/eventGroup.ts

@@ -7,7 +7,6 @@ export interface EventGroupClass<Members extends ReadonlyArray<AnyEvent>> {
   readonly members: Members
 }
 
-/** Compose events into a group, the same variadic shape as `StateGroup`/`RpcGroup`. */
 export const make = <const Members extends ReadonlyArray<AnyEvent>>(
   ...members: Members
 ): EventGroupClass<Members> =>

package/src/feature/feature.mount.test.ts

@@ -1,7 +1,8 @@
-import { type Cause, Duration, Effect, Exit, Layer, ManagedRuntime, Scope } from 'effect'
+import { type Cause, Context, Duration, Effect, Exit, Layer, Scope } from 'effect'
 import { Schema as S } from 'effect'
-import { expect, test } from 'vitest'
+import { expect, it } from '@effect/vitest'
 import * as Composition from '../compose/composition'
+import { mount } from '../compose/structure'
 import { ui } from '../compose/ui'
 import * as Event from '../event/event'
 import * as Reducer from '../reducer/reducer'
@@ -16,16 +17,45 @@ import { type EngineServices, featureModule, mountFeature } from './feature'
 // (Reducers registry) OPEN, so `mountFeature` builds it against the live engine.
 class Tick extends Event.make('Tick', S.Struct({})) {}
 class Count extends State.make('count', S.Number) {}
-class CountReducer extends Reducer.make('CountReducer', { states: [Count], events: [Tick] }) {}
+class CountReducer extends Reducer.make('CountReducer', {
+  states: [Count],
+  events: [Tick],
+}) {}
 
-const mod = featureModule(
-  [],
-  Reducer.live(CountReducer, (n) => n + 1).pipe(Layer.provideMerge(State.live(Count, 0))),
-)
+class MountedCounterProbe extends Context.Tag('test/MountedCounterProbe')<
+  MountedCounterProbe,
+  { readonly value: number }
+>() {}
+
+class LazyMountedProbe extends Context.Tag('test/LazyMountedProbe')<
+  LazyMountedProbe,
+  { readonly value: string }
+>() {}
+
+class UnmountedProbe extends Context.Tag('test/UnmountedProbe')<
+  UnmountedProbe,
+  { readonly value: boolean }
+>() {}
 
 // A trivial composition to hang the feature off (definitions only).
 class CtrUi extends ui('CtrUi')<{ props: {}; events: {} }>() {}
-class CtrComp extends Composition.make('CtrComp', { title: 'Counter', ui: CtrUi }) {}
+class CtrComp extends Composition.make('CtrComp', {
+  title: 'Counter',
+  ui: CtrUi,
+})<CtrComp>() {}
+
+const CtrLive = Composition.live(CtrComp, function* () {
+  return mount({ props: {}, slots: {} })
+})
+
+const mod = featureModule(
+  [],
+  Layer.mergeAll(
+    CtrLive,
+    Reducer.live(CountReducer, (n) => n + 1).pipe(Layer.provideMerge(State.live(Count, 0))),
+    Layer.succeed(MountedCounterProbe, { value: 42 }),
+  ),
+)
 
 class CounterFeature extends Feature.make('counter', {
   composition: CtrComp,
@@ -33,6 +63,43 @@ class CounterFeature extends Feature.make('counter', {
   boot: [Event.construct(Tick, {})],
 }) {}
 
+const lazyMod = featureModule(
+  [],
+  Layer.merge(CtrLive, Layer.succeed(LazyMountedProbe, { value: 'lazy' })),
+)
+
+class LazyCounterFeature extends Feature.make('lazy-counter', {
+  composition: CtrComp,
+  loadingStrategy: 'lazy',
+  load: Effect.succeed(lazyMod),
+  placeholder: { loading: CtrComp, failed: CtrComp },
+}) {}
+
+const CounterNative = Feature.tree<typeof CounterFeature>(CounterFeature.token)
+const LazyCounterNative = Feature.tree<typeof LazyCounterFeature>(LazyCounterFeature.token)
+
+const mountCounterFeature = (engineContext: Context.Context<EngineServices>) =>
+  mountFeature(CounterNative.binding, engineContext)
+
+const mountLazyCounterFeature = (engineContext: Context.Context<EngineServices>) =>
+  mountFeature(LazyCounterNative.binding, engineContext)
+
+type ContextServices<C> = C extends Context.Context<infer Services> ? Services : never
+type EagerMountedServices = ContextServices<
+  Effect.Effect.Success<ReturnType<typeof mountCounterFeature>>
+>
+type LazyMountedServices = ContextServices<
+  Effect.Effect.Success<ReturnType<typeof mountLazyCounterFeature>>
+>
+type Includes<Services, Candidate> = Candidate extends Services ? true : false
+
+const mountedServiceTypeProof: readonly [
+  Includes<EagerMountedServices, MountedCounterProbe>,
+  Includes<EagerMountedServices, UnmountedProbe>,
+  Includes<LazyMountedServices, LazyMountedProbe>,
+  Includes<LazyMountedServices, UnmountedProbe>,
+] = [true, false, true, false]
+
 // Poll a read until it satisfies a predicate (the loop drains on a forked fiber).
 const waitUntil = <A, R>(
   read: Effect.Effect<A, never, R>,
@@ -44,39 +111,51 @@ const waitUntil = <A, R>(
       : Effect.flatMap(Effect.sleep(Duration.millis(1)), () => waitUntil(read, pred)),
   ).pipe(Effect.timeout(Duration.seconds(2)))
 
-test('a mounted feature registers on the shared loop, boots, and folds dispatched events', async () => {
-  const runtime = ManagedRuntime.make(Engine)
-  try {
-    await runtime.runPromise(
-      Effect.gen(function* () {
-        const engineContext = yield* Effect.context<EngineServices>()
-        const reducers = yield* Reducers
-        const baseline = reducers.entries.length
-
-        const scope = yield* Scope.make()
-        const ctx = yield* mountFeature(CounterFeature.binding, engineContext).pipe(
-          Effect.provideService(Scope.Scope, scope),
-        )
-        // Registered into the SHARED registry.
-        expect(reducers.entries.length).toBe(baseline + 1)
-
-        // boot dispatched Tick → Count folds to 1 on the shared loop.
-        const booted = yield* waitUntil(Count.pipe(Effect.provide(ctx)), (n) => n === 1)
-        expect(booted).toBe(1)
-
-        // A further dispatch on the shared bus folds again → 2.
-        yield* publish('High', Event.construct(Tick, {}))
-        const folded = yield* waitUntil(Count.pipe(Effect.provide(ctx)), (n) => n === 2)
-        expect(folded).toBe(2)
-
-        // Unmount: closing the feature scope unregisters its reducer — the entry is
-        // reclaimed, not left folding onto an orphaned store.
-        yield* Scope.close(scope, Exit.succeed(undefined))
-        expect(reducers.entries.length).toBe(baseline)
-        expect(reducers.byTag.get('Tick')).toBeUndefined()
-      }),
+it.scopedLive(
+  'a mounted feature registers on the shared loop, boots, and folds dispatched events',
+  () =>
+    Effect.gen(function* () {
+      const engineContext = yield* Effect.context<EngineServices>()
+      const reducers = yield* Reducers
+      const baseline = reducers.entries.length
+
+      const scope = yield* Scope.make()
+      const ctx = yield* mountCounterFeature(engineContext).pipe(
+        Effect.provideService(Scope.Scope, scope),
+      )
+      expect(mountedServiceTypeProof).toEqual([true, false, true, false])
+      expect(Context.get(ctx, MountedCounterProbe).value).toBe(42)
+      expect(Context.getOption(ctx, UnmountedProbe)._tag).toBe('None')
+      // Registered into the SHARED registry.
+      expect(reducers.entries.length).toBe(baseline + 1)
+
+      // boot dispatched Tick → Count folds to 1 on the shared loop.
+      const booted = yield* waitUntil(Count.pipe(Effect.provide(ctx)), (n) => n === 1)
+      expect(booted).toBe(1)
+
+      // A further dispatch on the shared bus folds again → 2.
+      yield* publish('High', Event.construct(Tick, {}))
+      const folded = yield* waitUntil(Count.pipe(Effect.provide(ctx)), (n) => n === 2)
+      expect(folded).toBe(2)
+
+      // Unmount: closing the feature scope unregisters its reducer — the entry is
+      // reclaimed, not left folding onto an orphaned store.
+      yield* Scope.close(scope, Exit.succeed(undefined))
+      expect(reducers.entries.length).toBe(baseline)
+      expect(reducers.byTag.get('Tick')).toBeUndefined()
+    }).pipe(Effect.provide(Engine)),
+)
+
+it.scopedLive('a lazy feature retains its mounted service type', () =>
+  Effect.gen(function* () {
+    const engineContext = yield* Effect.context<EngineServices>()
+    const scope = yield* Scope.make()
+    const ctx = yield* mountLazyCounterFeature(engineContext).pipe(
+      Effect.provideService(Scope.Scope, scope),
     )
-  } finally {
-    await runtime.dispose()
-  }
-})
+
+    expect(Context.get(ctx, LazyMountedProbe).value).toBe('lazy')
+    expect(Context.getOption(ctx, UnmountedProbe)._tag).toBe('None')
+    yield* Scope.close(scope, Exit.succeed(undefined))
+  }).pipe(Effect.provide(Engine)),
+)