@playfast/reform 1.0.1 → 1.2.0

package/src/runtime/eventBudget.test.ts

@@ -0,0 +1,152 @@
+import { expect, it } from '@effect/vitest'
+import { Duration, Effect, Layer, LogLevel, Logger, Option, Schema as S } from 'effect'
+import { Engine, Event, publish, Reducer, State } from '../index'
+import type { EventLoopOverflow } from '../internal/errors'
+import {
+  CurrentEventBudget,
+  type EventBudget,
+  makeDefaultBudget,
+  makeTickCounter,
+  resolveEventBudget,
+} from './eventBudget'
+
+it('defaults resolve to errorAt 10_000, with the warning gated on dev', () => {
+  expect(makeDefaultBudget(true).errorAt).toBe(10_000)
+  expect(makeDefaultBudget(true).warningAt).toEqual(Option.some(500))
+  expect(makeDefaultBudget(false).warningAt).toEqual(Option.none())
+
+  const resolved = resolveEventBudget({})
+  expect(resolved.errorAt).toBe(10_000)
+
+  expect(resolveEventBudget({ maxEventsPerJsTick: { errorAt: 42 } }).errorAt).toBe(42)
+  expect(resolveEventBudget({ maxEventsPerJsTick: { warningAt: 7 } }).errorAt).toBe(10_000)
+  expect(resolveEventBudget({ maxEventsPerJsTick: { warningAt: 7 } }).warningAt).toEqual(
+    Option.some(7),
+  )
+})
+
+it('the tick counter accumulates across frames and warns exactly once', () => {
+  const budget: EventBudget = {
+    errorAt: 1_000,
+    warningAt: Option.some(5),
+    onOverflow: () => {},
+  }
+  const counter = makeTickCounter(budget)
+  expect(counter.add(3)).toEqual({ total: 3, warnNow: false })
+  expect(counter.add(3)).toEqual({ total: 6, warnNow: true })
+  expect(counter.add(3)).toEqual({ total: 9, warnNow: false })
+})
+
+it.live('crossing the soft limit logs one warning; the frame still folds', () => {
+  class Counter extends State.make('counter', S.Number) {}
+  class Bumped extends Event.make('Bumped', S.Struct({ to: S.Number })) {}
+  class BumpReducer extends Reducer.make('BumpReducer', { states: [Counter], events: [Bumped] }) {}
+  const BumpReducerLive = Reducer.live(BumpReducer, (_, event) => event.to)
+
+  const budget: EventBudget = {
+    errorAt: 1_000,
+    warningAt: Option.some(5),
+    onOverflow: () => {},
+  }
+  const TestLayer = BumpReducerLive.pipe(
+    Layer.provideMerge(Layer.mergeAll(State.live(Counter, 0), Engine)),
+    Layer.locally(CurrentEventBudget, budget),
+  )
+
+  const warnings: Array<string> = []
+  const recordingLogger = Logger.replace(
+    Logger.defaultLogger,
+    Logger.make(({ logLevel, message }) => {
+      if (logLevel._tag === 'Warning') {
+        warnings.push(String(message))
+      }
+    }),
+  )
+
+  return Effect.gen(function* () {
+    const store = yield* Counter.store
+    yield* Effect.forEach(
+      Array.from({ length: 10 }, (_, index) => index + 1),
+      (to) => publish('Normal', Event.construct(Bumped, { to })),
+      { discard: true },
+    )
+    yield* Effect.sleep(Duration.millis(20))
+
+    expect(store.get()).toBe(10)
+    const budgetWarnings = warnings.filter((message) => message.includes('reform:'))
+    expect(budgetWarnings).toHaveLength(1)
+  }).pipe(Effect.provide(TestLayer), Effect.provide(recordingLogger))
+})
+
+it.live('crossing the hard limit halts the runtime with EventLoopOverflow', () => {
+  class Counter extends State.make('counter', S.Number) {}
+  class Bumped extends Event.make('Bumped', S.Struct({ to: S.Number })) {}
+  class BumpReducer extends Reducer.make('BumpReducer', { states: [Counter], events: [Bumped] }) {}
+  const BumpReducerLive = Reducer.live(BumpReducer, (_, event) => event.to)
+
+  const captured: Array<EventLoopOverflow> = []
+  const budget: EventBudget = {
+    errorAt: 50,
+    warningAt: Option.none(),
+    onOverflow: (error) => captured.push(error),
+  }
+  const TestLayer = BumpReducerLive.pipe(
+    Layer.provideMerge(Layer.mergeAll(State.live(Counter, 0), Engine)),
+    Layer.locally(CurrentEventBudget, budget),
+  )
+
+  return Effect.gen(function* () {
+    const store = yield* Counter.store
+    yield* Effect.forEach(
+      Array.from({ length: 60 }, (_, index) => index + 1),
+      (to) => publish('Normal', Event.construct(Bumped, { to })),
+      { discard: true },
+    )
+    yield* Effect.sleep(Duration.millis(20))
+
+    expect(captured).toHaveLength(1)
+    expect(captured[0]?._tag).toBe('reform/EventLoopOverflow')
+    expect(captured[0]!.count).toBeGreaterThan(captured[0]!.limit)
+
+    const before = store.get()
+    yield* publish('Normal', Event.construct(Bumped, { to: 9_999 }))
+    yield* Effect.sleep(Duration.millis(20))
+    expect(store.get()).toBe(before)
+  }).pipe(Effect.provide(TestLayer), Logger.withMinimumLogLevel(LogLevel.None))
+})
+
+it.live('the window resets when the event loop yields — bursty traffic never trips', () => {
+  class Counter extends State.make('counter', S.Number) {}
+  class Bumped extends Event.make('Bumped', S.Struct({ to: S.Number })) {}
+  class BumpReducer extends Reducer.make('BumpReducer', { states: [Counter], events: [Bumped] }) {}
+  const BumpReducerLive = Reducer.live(BumpReducer, (_, event) => event.to)
+
+  const captured: Array<EventLoopOverflow> = []
+  const budget: EventBudget = {
+    errorAt: 50,
+    warningAt: Option.none(),
+    onOverflow: (error) => captured.push(error),
+  }
+  const TestLayer = BumpReducerLive.pipe(
+    Layer.provideMerge(Layer.mergeAll(State.live(Counter, 0), Engine)),
+    Layer.locally(CurrentEventBudget, budget),
+  )
+
+  const burst = (from: number) =>
+    Effect.forEach(
+      Array.from({ length: 40 }, (_, index) => from + index),
+      (to) => publish('Normal', Event.construct(Bumped, { to })),
+      { discard: true },
+    )
+
+  return Effect.gen(function* () {
+    const store = yield* Counter.store
+    yield* burst(1)
+    yield* Effect.sleep(Duration.millis(10))
+    yield* burst(41)
+    yield* Effect.sleep(Duration.millis(10))
+
+    expect(captured).toHaveLength(0)
+    expect(store.get()).toBe(80)
+  }).pipe(Effect.provide(TestLayer))
+})

package/src/runtime/eventBudget.ts

@@ -0,0 +1,120 @@
+import { Boolean as Bool, Effect, FiberRef, GlobalValue, MutableRef, Option } from 'effect'
+import { isDev } from '../internal/env'
+import { EventLoopOverflow } from '../internal/errors'
+
+interface EventLimitFields {
+  readonly errorAt: number
+  readonly warningAt: number
+}
+
+interface ReformOptionFields {
+  readonly maxEventsPerJsTick: Partial<EventLimitFields>
+}
+
+export interface ReformOptions extends Partial<ReformOptionFields> {}
+
+export interface EventBudget {
+  readonly errorAt: number
+  readonly warningAt: Option.Option<number>
+  readonly onOverflow: (error: EventLoopOverflow) => void
+}
+
+const rethrowOverflow = (error: EventLoopOverflow): void =>
+  queueMicrotask(() => {
+    // oxlint-disable-next-line reform-rules/no-throw -- only way to surface the halt to the host's global error handler
+    throw error
+  })
+
+const DEFAULT_ERROR_AT = 10_000
+const DEFAULT_WARNING_AT = 500
+
+export const makeDefaultBudget = (dev: boolean): EventBudget => ({
+  errorAt: DEFAULT_ERROR_AT,
+  warningAt: Bool.match(dev, {
+    onTrue: () => Option.some(DEFAULT_WARNING_AT),
+    onFalse: () => Option.none<number>(),
+  }),
+  onOverflow: rethrowOverflow,
+})
+
+export const defaultEventBudget: EventBudget = makeDefaultBudget(isDev)
+
+export const resolveEventBudget = (options: ReformOptions): EventBudget => {
+  const limits = Option.fromNullable(options.maxEventsPerJsTick)
+  return {
+    errorAt: Option.getOrElse(
+      Option.flatMapNullable(limits, (limit) => limit.errorAt),
+      () => defaultEventBudget.errorAt,
+    ),
+    warningAt: Option.orElse(
+      Option.flatMapNullable(limits, (limit) => limit.warningAt),
+      () => defaultEventBudget.warningAt,
+    ),
+    onOverflow: defaultEventBudget.onOverflow,
+  }
+}
+
+export const CurrentEventBudget: FiberRef.FiberRef<EventBudget> = GlobalValue.globalValue(
+  Symbol.for('reform/CurrentEventBudget'),
+  () => FiberRef.unsafeMake<EventBudget>(defaultEventBudget),
+)
+
+export const resolveCurrentEventBudget: Effect.Effect<EventBudget> =
+  FiberRef.get(CurrentEventBudget)
+
+export interface TickSample {
+  readonly total: number
+  readonly warnNow: boolean
+}
+
+export interface TickCounter {
+  readonly add: (eventCount: number) => TickSample
+}
+
+export const makeTickCounter = (budget: EventBudget): TickCounter => {
+  const count = MutableRef.make(0)
+  const armed = MutableRef.make(false)
+  const warned = MutableRef.make(false)
+  const reset = (): void => {
+    MutableRef.set(count, 0)
+    MutableRef.set(armed, false)
+    MutableRef.set(warned, false)
+  }
+  return {
+    add: (eventCount) => {
+      if (!MutableRef.get(armed)) {
+        MutableRef.set(armed, true)
+        // oxlint-disable-next-line reform-rules/no-set-timeout-interval -- the macrotask boundary IS the tick window; only a real timer can observe "the event loop yielded" from this synchronous hot path
+        setTimeout(reset, 0)
+      }
+      const total = MutableRef.get(count) + eventCount
+      MutableRef.set(count, total)
+      const crossed = Option.match(budget.warningAt, {
+        onNone: () => false,
+        onSome: (warningAt) => total >= warningAt,
+      })
+      const warnNow = crossed && !MutableRef.get(warned)
+      if (warnNow) {
+        MutableRef.set(warned, true)
+      }
+      return { total, warnNow }
+    },
+  }
+}
+
+export const enforceBudget: (
+  budget: EventBudget,
+  sample: TickSample,
+) => Effect.Effect<void, EventLoopOverflow> = Effect.fn('enforceBudget')(function* (
+  budget: EventBudget,
+  sample: TickSample,
+): Effect.fn.Return<void, EventLoopOverflow> {
+  if (sample.total > budget.errorAt) {
+    return yield* Effect.fail(new EventLoopOverflow({ count: sample.total, limit: budget.errorAt }))
+  }
+  if (sample.warnNow) {
+    yield* Effect.logWarning(
+      `reform: ${sample.total} events processed without yielding to the event loop — possible event feedback loop`,
+    )
+  }
+})

package/src/runtime/hardening.test.ts

@@ -1,10 +1,7 @@
 import { expect, it } from '@effect/vitest'
-import { Cause, Duration, Effect, Exit, Layer, LogLevel, Logger, Schema as S } from 'effect'
-import { Channel, Engine, Event, publish, Reducer, State } from '../index'
-
-// Robustness guards for the drain loop and registries: a buggy reducer must not
-// take down the bus, and a name clash that would silently drop a registration
-// must be rejected.
+import { Cause, Duration, Effect, Exit, Layer, LogLevel, Logger, Schema as S, Scope } from 'effect'
+import { Channel, Engine, Event, Procedure, publish, Reducer, State } from '../index'
+import { Channels } from '../channel/channel'
 
 it.live('a reducer that throws is isolated; the loop keeps draining', () => {
   class Counter extends State.make('counter', S.Number) {}
@@ -24,20 +21,14 @@ it.live('a reducer that throws is isolated; the loop keeps draining', () => {
   return Effect.gen(function* () {
     const store = yield* Counter.store
 
-    // A fold that throws is caught and logged — the drain fiber survives.
     yield* publish('Normal', Event.construct(Bad, {}))
     yield* Effect.sleep(Duration.millis(10))
     expect(store.get()).toBe(0)
 
-    // A later, healthy event still processes: the bus did not go deaf.
     yield* publish('Normal', Event.construct(Good, {}))
     yield* Effect.sleep(Duration.millis(10))
     expect(store.get()).toBe(1)
-  }).pipe(
-    Effect.provide(TestLayer),
-    // The isolated failure logs an error; silence it so the passing test is quiet.
-    Logger.withMinimumLogLevel(LogLevel.None),
-  )
+  }).pipe(Effect.provide(TestLayer), Logger.withMinimumLogLevel(LogLevel.None))
 })
 
 it.effect('two different channels registered under one name are rejected', () => {
@@ -56,6 +47,19 @@ it.effect('two different channels registered under one name are rejected', () =>
   })
 })
 
+it.effect('structurally identical channel policies do not die', () => {
+  class LatestA extends Channel.make('SamePolicy', { policy: { _tag: 'latest' } }) {}
+  class LatestB extends Channel.make('SamePolicy', { policy: { _tag: 'latest' } }) {}
+  const layer = Layer.mergeAll(Channel.live(LatestA), Channel.live(LatestB)).pipe(
+    Layer.provideMerge(Engine),
+  )
+
+  return Effect.gen(function* () {
+    const exit = yield* Effect.scoped(Layer.build(layer)).pipe(Effect.exit)
+    expect(Exit.isSuccess(exit)).toBe(true)
+  })
+})
+
 it.effect('the same channel registered twice is idempotent (shared lane)', () => {
   class Lane extends Channel.make('Lane', { policy: { _tag: 'exclusive' } }) {}
   const layer = Layer.mergeAll(Channel.live(Lane), Channel.live(Lane)).pipe(
@@ -67,3 +71,59 @@ it.effect('the same channel registered twice is idempotent (shared lane)', () =>
     expect(Exit.isSuccess(exit)).toBe(true)
   })
 })
+
+it.live('remount overlap keeps the channel alive', () => {
+  class Fired extends Event.make('OverlapFired', S.Struct({})) {}
+  class FirstLane extends Channel.make('OverlapLane', { policy: { _tag: 'latest' } }) {}
+  class SecondLane extends Channel.make('OverlapLane', { policy: { _tag: 'latest' } }) {}
+  class Work extends Procedure.make('OverlapWork', { events: [Fired], channel: SecondLane }) {}
+
+  const runs = { n: 0 }
+  const WorkLive = Procedure.live(Work, function* () {
+    runs.n += 1
+  })
+
+  return Effect.gen(function* () {
+    const channels = yield* Channels
+    const firstScope = yield* Scope.make()
+    const secondScope = yield* Scope.make()
+
+    yield* Layer.buildWithScope(Channel.live(FirstLane), firstScope)
+    yield* Layer.buildWithScope(Layer.mergeAll(Channel.live(SecondLane), WorkLive), secondScope)
+    yield* Scope.close(firstScope, Exit.void)
+
+    yield* publish('Normal', Event.construct(Fired, {}))
+    yield* Effect.sleep(Duration.millis(20))
+    expect(runs.n).toBe(1)
+
+    yield* Scope.close(secondScope, Exit.void)
+    expect(channels.byName.has('OverlapLane')).toBe(false)
+  }).pipe(Effect.provide(Engine))
+})
+
+it.effect('last-release cleanup allows a fresh channel registration', () => {
+  class FirstLane extends Channel.make('CleanupLane', { policy: { _tag: 'merge' } }) {}
+  class SecondLane extends Channel.make('CleanupLane', { policy: { _tag: 'merge' } }) {}
+  class FreshLane extends Channel.make('CleanupLane', { policy: { _tag: 'merge' } }) {}
+
+  return Effect.gen(function* () {
+    const channels = yield* Channels
+    const firstScope = yield* Scope.make()
+    const secondScope = yield* Scope.make()
+    const freshScope = yield* Scope.make()
+
+    yield* Layer.buildWithScope(Channel.live(FirstLane), firstScope)
+    yield* Layer.buildWithScope(Channel.live(SecondLane), secondScope)
+    yield* Scope.close(firstScope, Exit.void)
+    expect(channels.byName.has('CleanupLane')).toBe(true)
+
+    yield* Scope.close(secondScope, Exit.void)
+    expect(channels.byName.has('CleanupLane')).toBe(false)
+
+    yield* Layer.buildWithScope(Channel.live(FreshLane), freshScope)
+    expect(channels.byName.has('CleanupLane')).toBe(true)
+
+    yield* Scope.close(freshScope, Exit.void)
+    expect(channels.byName.has('CleanupLane')).toBe(false)
+  }).pipe(Effect.provide(Engine))
+})

package/src/runtime/instrumentation.test.ts

@@ -1,17 +1,13 @@
 import { expect, it } from '@effect/vitest'
-import { test } from 'vitest'
-import { Duration, Effect, Layer, ManagedRuntime, Schema as S } from 'effect'
+import { Duration, Effect, Layer, Schema as S } from 'effect'
 import {
   AsyncCalc,
   Calc,
   Channel,
   Composition,
-  CurrentInstrumentation,
   Engine,
   Event,
-  type Instrumentation,
   mount,
-  noopInstrumentation,
   type Priority,
   Procedure,
   profiledScene,
@@ -25,12 +21,11 @@ import {
   Ui,
   ui,
 } from '../index'
-
-// The profiler SPI: every engine hot path consults `CurrentInstrumentation` once
-// at layer build time. These tests inject a recording instance the same way
-// `profileScene` will — `Layer.locally` on the wiring — and assert each hook
-// fires with the right names/counts, that spans end, and that the seam does not
-// leak into unprofiled wiring.
+import {
+  CurrentInstrumentation,
+  type Instrumentation,
+  noopInstrumentation,
+} from './instrumentation'
 
 const tick = (ms = 20) => Effect.sleep(Duration.millis(ms))
 
@@ -86,14 +81,27 @@ const makeRecorder = () => {
       }
     },
   }
-  return { instrumentation, events, reducers, states, calcs, queries, procedures, frames, ends }
+  return {
+    instrumentation,
+    events,
+    reducers,
+    states,
+    calcs,
+    queries,
+    procedures,
+    frames,
+    ends,
+  }
 }
 
 it.live('the engine reports frames, events, reducer spans, and state updates', () => {
   const recorder = makeRecorder()
   class Counter extends State.make('instr-counter', S.Number) {}
   class Bumped extends Event.make('InstrBumped', S.Struct({ to: S.Number })) {}
-  class Fold extends Reducer.make('InstrFold', { states: [Counter], events: [Bumped] }) {}
+  class Fold extends Reducer.make('InstrFold', {
+    states: [Counter],
+    events: [Bumped],
+  }) {}
   const FoldLive = Reducer.live(Fold, (_, event) => event.to)
 
   const TestLayer = FoldLive.pipe(
@@ -106,7 +114,6 @@ it.live('the engine reports frames, events, reducer spans, and state updates', (
     yield* publish('Normal', Event.construct(Bumped, { to: 2 }))
     yield* tick()
 
-    // Both events landed in one frame; High folds before Normal.
     expect(recorder.frames).toEqual([2])
     expect(recorder.ends.frame).toBe(1)
     expect(recorder.events).toEqual([
@@ -118,7 +125,6 @@ it.live('the engine reports frames, events, reducer spans, and state updates', (
       { name: 'InstrFold', eventTag: 'InstrBumped' },
     ])
     expect(recorder.ends.reducer).toBe(2)
-    // Two genuinely new values (0 -> 1 -> 2), one update per fold.
     expect(recorder.states).toEqual(['instr-counter', 'instr-counter'])
   }).pipe(Effect.provide(TestLayer))
 })
@@ -127,7 +133,10 @@ it.live('an equal-value write is not reported as a state update', () => {
   const recorder = makeRecorder()
   class Cell extends State.make('instr-cell', S.Number) {}
   class Wrote extends Event.make('InstrWrote', S.Struct({ to: S.Number })) {}
-  class Write extends Reducer.make('InstrWrite', { states: [Cell], events: [Wrote] }) {}
+  class Write extends Reducer.make('InstrWrite', {
+    states: [Cell],
+    events: [Wrote],
+  }) {}
   const WriteLive = Reducer.live(Write, (_, event) => event.to)
 
   const TestLayer = WriteLive.pipe(
@@ -138,7 +147,6 @@ it.live('an equal-value write is not reported as a state update', () => {
   return Effect.gen(function* () {
     yield* publish('High', Event.construct(Wrote, { to: 7 }))
     yield* tick()
-    // The reducer ran, but the store's Equal gate suppressed the write.
     expect(recorder.reducers.length).toBe(1)
     expect(recorder.states).toEqual([])
   }).pipe(Effect.provide(TestLayer))
@@ -161,7 +169,6 @@ it.live('calc recomputes are spanned; memo hits are not counted', () => {
 
   return Effect.gen(function* () {
     const derived = yield* Doubled.store
-    // The derived store computes once at build; repeated reads hit the memo.
     const builds = recorder.calcs.length
     expect(derived.get()).toBe(10)
     expect(derived.get()).toBe(10)
@@ -174,7 +181,6 @@ it.live('calc recomputes are spanned; memo hits are not counted', () => {
     expect(recorder.calcs.length).toBe(builds + 1)
     expect(recorder.calcs.every((name) => name === 'InstrDoubled')).toBe(true)
     expect(recorder.ends.calc).toBe(recorder.calcs.length)
-    // The calc's output moved twice (build seeds silently; 10 -> 12 notifies once).
     expect(recorder.states).toContain('InstrDoubled')
   }).pipe(Effect.provide(TestLayer))
 })
@@ -189,7 +195,8 @@ it.live('async calc query runs are spanned start-to-settle', () => {
     alwaysOn: true,
   }) {}
   const FetchedLive = AsyncCalc.live(Fetched, {
-    query: (inputs) => Effect.succeed(inputs['instr-query-count'] * 2).pipe(Effect.delay(Duration.millis(5))),
+    query: (inputs) =>
+      Effect.succeed(inputs['instr-query-count'] * 2).pipe(Effect.delay(Duration.millis(5))),
   })
 
   const TestLayer = FetchedLive.pipe(
@@ -200,7 +207,6 @@ it.live('async calc query runs are spanned start-to-settle', () => {
   return Effect.gen(function* () {
     const store = yield* Fetched.store
     yield* tick(40)
-    // The run fiber picked the request, started the span, and ended it on settle.
     expect(store.get()._tag).toBe('Success')
     expect(recorder.queries).toEqual(['InstrFetched'])
     expect(recorder.ends.query).toBe(1)
@@ -211,7 +217,10 @@ it.live('procedure runs are spanned with their channel and trigger tag', () => {
   const recorder = makeRecorder()
   class Kicked extends Event.make('InstrKicked', S.Struct({})) {}
   class Lane extends Channel.make('InstrLane', { policy: { _tag: 'merge' } }) {}
-  class Work extends Procedure.make('InstrWork', { events: [Kicked], channel: Lane }) {}
+  class Work extends Procedure.make('InstrWork', {
+    events: [Kicked],
+    channel: Lane,
+  }) {}
   const WorkLive = Procedure.live(Work, function* () {
     yield* tick(5)
   })
@@ -231,9 +240,6 @@ it.live('procedure runs are spanned with their channel and trigger tag', () => {
   }).pipe(Effect.provide(TestLayer))
 })
 
-// ── The scene seam: `profiledScene` must reach layers inside a CLOSED scene and
-// carry the handle for hosts, without leaking into the original scene. ─────────
-
 class SceneCount extends State.make('instr-scene-count', S.Number) {}
 class SceneStates extends StateGroup.make(SceneCount) {}
 class SceneBumped extends Event.make('InstrSceneBumped', S.Struct({})) {}
@@ -249,17 +255,24 @@ class SceneRoot extends Composition.make('InstrScene', {
   states: [SceneStates],
   events: [SceneBumped],
   ui: SceneUi,
-}) {}
+})<SceneRoot>() {}
 const SceneRootLive = Composition.live(SceneRoot, function* () {
   const count = yield* StateGroup.select(SceneStates, 'instr-scene-count')
   return mount({ props: { count }, slots: {} })
 })
 
 const SceneApp = SceneRootLive.pipe(
-  Layer.provideMerge(provide(SceneUi, Ui.make(SceneUi, () => null))),
+  Layer.provideMerge(
+    provide(
+      SceneUi,
+      Ui.make(SceneUi, () => null),
+    ),
+  ),
   Layer.provideMerge(
     Layer.mergeAll(SceneBumpLive).pipe(
-      Layer.provideMerge(Layer.mergeAll(Engine, StateGroup.live(SceneStates, { 'instr-scene-count': 0 }))),
+      Layer.provideMerge(
+        Layer.mergeAll(Engine, StateGroup.live(SceneStates, { 'instr-scene-count': 0 })),
+      ),
     ),
   ),
 )
@@ -267,37 +280,27 @@ const InstrScene = scene(SceneRoot, { provide: [SceneApp] })
 
 const runScene = (target: typeof InstrScene) => {
   const layer = target.provide.reduce((a, b) => Layer.merge(a, b))
-  const runtime = ManagedRuntime.make(layer)
   const drive = Effect.gen(function* () {
     yield* publish('High', Event.construct(SceneBumped, {}))
     yield* tick()
   })
-  return { runtime, drive }
+  return { layer, drive }
 }
 
-test('profiledScene reaches nested layers and carries the handle', async () => {
-  const recorder = makeRecorder()
-  const profiled = profiledScene(InstrScene, recorder.instrumentation)
-  expect(sceneInstrumentation(profiled)).toBe(recorder.instrumentation)
+it.scopedLive('profiledScene reaches nested layers and carries the handle', () =>
+  Effect.gen(function* () {
+    const recorder = makeRecorder()
+    const profiled = profiledScene(InstrScene, recorder.instrumentation)
+    expect(sceneInstrumentation(profiled)).toBe(recorder.instrumentation)
 
-  const { runtime, drive } = runScene(profiled)
-  try {
-    await runtime.runPromise(drive)
+    const profiledHarness = runScene(profiled)
+    yield* profiledHarness.drive.pipe(Effect.provide(profiledHarness.layer))
     expect(recorder.reducers).toEqual([{ name: 'InstrSceneBump', eventTag: 'InstrSceneBumped' }])
     expect(recorder.states).toEqual(['instr-scene-count'])
-  } finally {
-    await runtime.dispose()
-  }
-
-  // Building the ORIGINAL scene again records nothing — the overlay lives only
-  // on the profiled variant's wrapped layers.
-  const before = recorder.reducers.length
-  expect(sceneInstrumentation(InstrScene)).toBe(noopInstrumentation)
-  const original = runScene(InstrScene)
-  try {
-    await original.runtime.runPromise(original.drive)
+    const before = recorder.reducers.length
+    expect(sceneInstrumentation(InstrScene)).toBe(noopInstrumentation)
+    const original = runScene(InstrScene)
+    yield* original.drive.pipe(Effect.provide(original.layer))
     expect(recorder.reducers.length).toBe(before)
-  } finally {
-    await original.runtime.dispose()
-  }
-})
+  }),
+)