@playfast/reform 1.0.1 → 1.2.0

package/src/runtime/instrumentation.ts

@@ -1,48 +1,21 @@
 import { Effect, FiberRef, GlobalValue } from 'effect'
 import type { Priority } from './bus'
 
-/**
- * The profiler SPI — a synchronous, Effect-free hook surface the engine calls on
- * its hot paths (the drain loop, store writes, calc recomputes, renders). It is
- * Effect-free for the same reason `Store`/`Scheduler` are: these sites run
- * synchronously inside a reduce frame or a React render, where forking or even
- * building an Effect per call would dominate the very costs being measured.
- *
- * Span-shaped hooks return a {@link SpanEnd} thunk: call it when the measured
- * work completes. The default implementation is {@link noopInstrumentation};
- * every hook site captures its instance ONCE at layer build time (see
- * `resolveInstrumentation`) and may skip name plumbing entirely when the
- * captured instance IS the noop (identity check), so an unprofiled runtime pays
- * nothing per operation.
- */
 export type SpanEnd = () => void
 
 export interface Instrumentation {
-  /** An event entered the drain frame (one call per envelope, per frame). */
   eventDispatched(tag: string, priority: Priority): void
-  /** A reducer is folding one event; ends when its synchronous `apply` returns. */
   reducerRun(name: string, eventTag: string): SpanEnd
-  /** A store accepted a genuinely new value (post-`Equal` gate). */
   stateUpdated(name: string): void
-  /** A calc's projection actually ran (memo hits are not counted). */
   calcRecomputed(name: string): SpanEnd
-  /** An async calc's query effect started; ends when it resolves/fails/cancels. */
   queryRun(name: string): SpanEnd
-  /** A procedure body started on its channel; ends when the fiber completes. */
   procedureRun(name: string, channel: string, eventTag: string): SpanEnd
-  /** A composition rendered one frame (host-injected: React `Compose` / proof engine). */
   uiRendered(composition: string): SpanEnd
-  /** One drain tick: folds + routing for `eventCount` envelopes. */
   frame(eventCount: number): SpanEnd
 }
 
 const noopSpanEnd: SpanEnd = () => {}
 
-/**
- * The shared do-nothing instrumentation. A single instance (and a single shared
- * `SpanEnd`), so hook sites can detect "profiling off" by identity and skip
- * their argument construction entirely.
- */
 export const noopInstrumentation: Instrumentation = {
   eventDispatched: () => {},
   reducerRun: () => noopSpanEnd,
@@ -54,40 +27,13 @@ export const noopInstrumentation: Instrumentation = {
   frame: () => noopSpanEnd,
 }
 
-/**
- * The sanctioned profiling seam for CLOSED scenes — the same mechanism as
- * `CurrentSeedOverrides` (`internal/seeds.ts`): a scene's layers are
- * pre-composed, but a FiberRef set via `Layer.locally(ref, value)(layer)` IS
- * visible inside the construction effects of nested layers. Engine/state/calc
- * layers consult this ref once at build time and capture the resolved instance
- * into their hot-path closures.
- *
- * Defaults to {@link noopInstrumentation} — production wiring never touches it.
- * `profileScene` (in `@playfast/reform-profiler`) is the intended writer.
- * `globalValue` keeps a single ref instance even if the module is loaded twice
- * (duplicated bundles, HMR), so the writer and the reader always agree.
- */
-export const CurrentInstrumentation: FiberRef.FiberRef<Instrumentation> =
-  GlobalValue.globalValue(Symbol.for('reform/CurrentInstrumentation'), () =>
-    FiberRef.unsafeMake<Instrumentation>(noopInstrumentation),
-  )
+export const CurrentInstrumentation: FiberRef.FiberRef<Instrumentation> = GlobalValue.globalValue(
+  Symbol.for('reform/CurrentInstrumentation'),
+  () => FiberRef.unsafeMake<Instrumentation>(noopInstrumentation),
+)
 
-/**
- * Resolve the ambient instrumentation at layer build time. Layers capture the
- * result into their closures; they must not re-read it per operation.
- */
 export const resolveInstrumentation: Effect.Effect<Instrumentation> =
   FiberRef.get(CurrentInstrumentation)
 
-/**
- * The store `onChange` hook for one named state/calc: a bound
- * `stateUpdated(name)` closure when profiled, the shared no-op otherwise — so
- * an unprofiled store's write path never constructs the name-carrying call.
- */
-export const stateUpdateHook = (
-  instrumentation: Instrumentation,
-  name: string,
-): (() => void) =>
-  instrumentation === noopInstrumentation
-    ? noopSpanEnd
-    : () => instrumentation.stateUpdated(name)
+export const stateUpdateHook = (instrumentation: Instrumentation, name: string): (() => void) =>
+  instrumentation === noopInstrumentation ? noopSpanEnd : () => instrumentation.stateUpdated(name)

package/src/runtime/loop.test.ts

@@ -2,10 +2,6 @@ import { expect, it } from '@effect/vitest'
 import { Duration, Effect, Layer, Schema as S, TestClock } from 'effect'
 import { Channel, Engine, Event, Procedure, publish, Reducer, State } from '../index'
 
-// Headless tests for the single frame-batched drain loop and channels, written
-// with `@effect/vitest`: `it.live` for cases that lean on the real microtask
-// queue (the store notifier), `it.effect` + `TestClock` for time-based channels.
-
 it.live('a frame of events drains in one pass with a single notification flush', () => {
   class Counter extends State.make('counter', S.Number) {}
   class Bumped extends Event.make('Bumped', S.Struct({ to: S.Number })) {}
@@ -23,8 +19,6 @@ it.live('a frame of events drains in one pass with a single notification flush',
       notifications.n += 1
     })
 
-    // Three events in one tick batch into one frame, fold in order, and the
-    // coalesced store notifier wakes the subscriber exactly once.
     yield* publish('Normal', Event.construct(Bumped, { to: 1 }))
     yield* publish('Normal', Event.construct(Bumped, { to: 2 }))
     yield* publish('Normal', Event.construct(Bumped, { to: 3 }))
@@ -61,15 +55,11 @@ it.live('an exclusive channel serializes procedures that share it', () => {
     yield* publish('Normal', Event.construct(StartA, {}))
     yield* publish('Normal', Event.construct(StartB, {}))
     yield* Effect.sleep(Duration.millis(60))
-    // Without exclusivity both would run concurrently (max === 2).
     expect(concurrency.max).toBe(1)
   }).pipe(Effect.provide(TestLayer))
 })
 
 it.live('two procedures sharing a channel each run once for one shared event', () => {
-  // Both procedures handle the SAME event on the SAME channel. The loop must
-  // offer the event to the channel once, so each procedure runs exactly once —
-  // not once per matching procedure (which would double every run).
   class Shared extends Event.make('Shared', S.Struct({})) {}
   class Lane extends Channel.make('Lane', { policy: { _tag: 'merge' } }) {}
 
@@ -115,9 +105,7 @@ it.effect('a debounce channel collapses a burst into a single run', () => {
     yield* publish('Normal', Event.construct(Typed, {}))
     yield* publish('Normal', Event.construct(Typed, {}))
     yield* publish('Normal', Event.construct(Typed, {}))
-    // Let the loop route the frame into the channel and arm the debounce window.
     yield* Effect.yieldNow().pipe(Effect.repeatN(20))
-    // Advance the simulated clock past the window: the burst emits once.
     yield* TestClock.adjust(Duration.millis(31))
     yield* Effect.yieldNow().pipe(Effect.repeatN(20))
     expect(runs.n).toBe(1)
@@ -137,11 +125,9 @@ it.live('a reducer ignores events outside its declared set (no-op)', () => {
 
   return Effect.gen(function* () {
     const store = yield* Counter.store
-    // An event the reducer doesn't declare never reaches its fold.
     yield* publish('Normal', Event.construct(Unrelated, {}))
     yield* Effect.sleep(Duration.millis(10))
     expect(store.get()).toBe(0)
-    // A declared event does.
     yield* publish('Normal', Event.construct(Bump, {}))
     yield* Effect.sleep(Duration.millis(10))
     expect(store.get()).toBe(1)
@@ -163,16 +149,49 @@ it.effect('a latest channel cancels the in-flight run when a new event arrives',
   const TestLayer = Layer.mergeAll(Channel.live(Latest), WorkLive).pipe(Layer.provideMerge(Engine))
 
   return Effect.gen(function* () {
-    // First tick starts a run that parks on its 50ms sleep.
     yield* publish('Normal', Event.construct(Tick, {}))
     yield* Effect.yieldNow().pipe(Effect.repeatN(20))
-    // Second tick switches the channel, interrupting the first run mid-sleep.
     yield* publish('Normal', Event.construct(Tick, {}))
     yield* Effect.yieldNow().pipe(Effect.repeatN(20))
     yield* TestClock.adjust(Duration.millis(60))
     yield* Effect.yieldNow().pipe(Effect.repeatN(20))
-    // Both runs began, but only the latest survived to completion.
     expect(counts.started).toBe(2)
     expect(counts.completed).toBe(1)
   }).pipe(Effect.provide(TestLayer))
 })
+
+it.live('a fold returning the previous reference keeps the exact store value', () => {
+  const Viewer = S.Union(
+    S.TaggedStruct('Closed', {}),
+    S.TaggedStruct('Open', { revision: S.Number }),
+  )
+  class ViewerState extends State.make('viewer', Viewer) {}
+  class Poked extends Event.make('Poked', S.Struct({})) {}
+  class PokeReducer extends Reducer.make('PokeReducer', {
+    states: [ViewerState],
+    events: [Poked],
+  }) {}
+  // Closed is a fixpoint: the fold hands back the previous reference untouched.
+  const PokeReducerLive = Reducer.live(PokeReducer, (viewer) =>
+    viewer._tag === 'Open' ? { ...viewer, revision: viewer.revision + 1 } : viewer,
+  )
+
+  const TestLayer = PokeReducerLive.pipe(
+    Layer.provideMerge(Layer.mergeAll(State.live(ViewerState, { _tag: 'Closed' }), Engine)),
+  )
+
+  return Effect.gen(function* () {
+    const store = yield* ViewerState.store
+    const before = store.get()
+    const notifications = { n: 0 }
+    store.subscribe(() => {
+      notifications.n += 1
+    })
+    yield* publish('Normal', Event.construct(Poked, {}))
+    yield* Effect.sleep(Duration.millis(20))
+    // Reference identity is the repaint signal: an unchanged fold must not be
+    // re-decoded into a fresh, structurally-equal value that wakes subscribers.
+    expect(store.get()).toBe(before)
+    expect(notifications.n).toBe(0)
+  }).pipe(Effect.provide(TestLayer))
+})

package/src/runtime/loop.ts

@@ -1,97 +1,93 @@
-import { Array as Arr, Chunk, Context, Effect, Layer, Option, PubSub, Queue } from 'effect'
-import {
-  Channels,
-  channelsLayer,
-  Procedures,
-  proceduresLayer,
-} from '../channel/channel'
+import { Array as Arr, Cause, Chunk, Context, Effect, Layer, Option, PubSub, Queue } from 'effect'
+import { Channels, channelsLayer, Procedures, proceduresLayer } from '../channel/channel'
+import { makeBucketCache } from '../internal/bucketCache'
 import { notificationsLayer } from '../internal/scheduler'
 import { Bus, busLayer, type Envelope, type Tagged } from './bus'
+import { enforceBudget, makeTickCounter, resolveCurrentEventBudget } from './eventBudget'
 import { type Instrumentation, resolveInstrumentation } from './instrumentation'
 import { Queries, queriesLayer } from './queries'
 
-/**
- * A registered reducer, with its target store(s) already captured at
- * registration. `apply` is a pure synchronous write, so the loop needs no
- * state services in its own context — it just routes events to writers.
- */
 export interface ReducerEntry {
-  /** The reducer's name — used only to warn on duplicate registration. */
   readonly name: string
   readonly handles: ReadonlySet<string>
   readonly apply: (event: Tagged) => void
 }
 
-/**
- * Mutable collector the central loop drains; reducer `.live` layers register
- * here. `byTag` indexes entries by the event tags they handle, so dispatch is
- * O(matching reducers) per event rather than O(all reducers) — the difference
- * that matters once an app has hundreds of reducers.
- */
 export interface ReducerRegistry {
   readonly entries: Array<ReducerEntry>
-  readonly byTag: Map<string, Array<ReducerEntry>>
+  readonly byName: Map<string, Set<ReducerEntry>>
+  readonly byTag: Map<string, Set<ReducerEntry>>
+  readonly tagged: (tag: string) => ReadonlyArray<ReducerEntry>
   readonly register: (entry: ReducerEntry) => void
-  /**
-   * Remove a previously-registered entry. Eager reducers (built on the root scope)
-   * never call this; a lazy feature's `Reducer.live` registers on mount and
-   * unregisters on unmount (scope close), so an unmounted feature stops folding and
-   * its entry is reclaimed instead of leaking + writing to an orphaned store.
-   */
   readonly unregister: (entry: ReducerEntry) => void
 }
 
-const ReducersBase: Context.TagClass<Reducers, 'reform/Reducers', ReducerRegistry> =
-  Context.Tag('reform/Reducers')<Reducers, ReducerRegistry>()
+const ReducersBase: Context.TagClass<Reducers, 'reform/Reducers', ReducerRegistry> = Context.Tag(
+  'reform/Reducers',
+)<Reducers, ReducerRegistry>()
 export class Reducers extends ReducersBase {}
 
-/** Drop a target from a `Map<string, Array>` bucket, pruning the key when it empties. */
-const dropFromBuckets = <T>(map: Map<string, Array<T>>, key: string, target: T): void => {
+const dropFromBuckets = <T>(map: Map<string, Set<T>>, key: string, target: T): void => {
   const bucket = map.get(key)
   if (bucket === undefined) {
     return
   }
-  const next = bucket.filter((entry) => entry !== target)
-  if (next.length === 0) {
+  bucket.delete(target)
+  if (bucket.size === 0) {
     map.delete(key)
-  } else {
-    map.set(key, next)
   }
 }
 
 const makeReducerRegistry = (): ReducerRegistry => {
-  const byTag = new Map<string, Array<ReducerEntry>>()
-  // Single live array reference, replaced immutably on register/unregister and
-  // exposed through the `entries` getter so consumers always read the current set.
-  const state: { entries: Array<ReducerEntry> } = { entries: [] }
+  const entries = new Set<ReducerEntry>()
+  const byName = new Map<string, Set<ReducerEntry>>()
+  const byTag = new Map<string, Set<ReducerEntry>>()
+  const tagged = makeBucketCache(byTag)
+  const snapshot: { value: Option.Option<Array<ReducerEntry>> } = {
+    value: Option.some([]),
+  }
   return {
     get entries() {
-      return state.entries
+      return Option.getOrElse(snapshot.value, () => {
+        const current = Array.from(entries)
+        snapshot.value = Option.some(current)
+        return current
+      })
     },
+    byName,
     byTag,
+    tagged: tagged.read,
     register: (entry) => {
-      state.entries = [...state.entries, entry]
+      entries.add(entry)
+      snapshot.value = Option.none()
+      getOrCreateBucket(byName, entry.name).add(entry)
       entry.handles.forEach((tag) => {
-        const bucket = byTag.get(tag)
-        if (bucket === undefined) {
-          byTag.set(tag, [entry])
-        } else {
-          byTag.set(tag, [...bucket, entry])
-        }
+        getOrCreateBucket(byTag, tag).add(entry)
+        tagged.invalidate(tag)
       })
     },
     unregister: (entry) => {
-      state.entries = state.entries.filter((existing) => existing !== entry)
-      entry.handles.forEach((tag) => dropFromBuckets(byTag, tag, entry))
+      entries.delete(entry)
+      snapshot.value = Option.none()
+      dropFromBuckets(byName, entry.name, entry)
+      entry.handles.forEach((tag) => {
+        dropFromBuckets(byTag, tag, entry)
+        tagged.invalidate(tag)
+      })
     },
   }
 }
 
-/** Read a bucket array, defaulting to empty without a falsy fallback. */
-const bucketOf = <V>(map: Map<string, Array<V>>, tag: string): Array<V> =>
-  Option.getOrElse(Option.fromNullable(map.get(tag)), (): Array<V> => [])
+const getOrCreateBucket = <T>(map: Map<string, Set<T>>, key: string): Set<T> => {
+  const existing = map.get(key)
+  if (existing !== undefined) {
+    return existing
+  }
+  const created = new Set<T>()
+  map.set(key, created)
+  return created
+}
 
-/** Run one reducer in isolation; a synchronous throw becomes a collected failure. */
 const isolateApply = (
   reducer: ReducerEntry,
   event: Tagged,
@@ -100,9 +96,10 @@ const isolateApply = (
   const end = instrumentation.reducerRun(reducer.name, event._tag)
   return Effect.runSync(
     Effect.match(
-      Effect.try({ try: () => reducer.apply(event), catch: (error) => error }).pipe(
-        Effect.ensuring(Effect.sync(end)),
-      ),
+      Effect.try({
+        try: () => reducer.apply(event),
+        catch: (error) => error,
+      }).pipe(Effect.ensuring(Effect.sync(end))),
       {
         onFailure: (error) => Option.some({ event, error }),
         onSuccess: () => Option.none(),
@@ -113,59 +110,49 @@ const isolateApply = (
 
 export const reducersLayer: Layer.Layer<Reducers> = Layer.sync(Reducers, makeReducerRegistry)
 
-/** High before Normal; within a priority class, dispatch order is preserved. */
+// Partitioning keeps dispatch order stable within each priority.
 const rank = (priority: Envelope['priority']): number => (priority === 'High' ? 0 : 1)
 
-// The single drain loop: one fiber that frame-batches the bus. Each tick it
-// harvests every event dispatched in that microtask, runs all matching reducers
-// in ONE synchronous pass (so the store notifier flushes once for the batch),
-// then routes each event to the channels its procedures run on.
 const drain = Effect.gen(function* () {
   const bus = yield* Bus
   const reducers = yield* Reducers
   const { byName: channels } = yield* Channels
   const procedures = yield* Procedures
-  // Captured once at engine build; the noop instance costs nothing per frame.
   const instrumentation = yield* resolveInstrumentation
+  const budget = yield* resolveCurrentEventBudget
+  // Child feature runtimes share this engine-level counter with the root.
+  const counter = makeTickCounter(budget)
   const subscription = yield* PubSub.subscribe(bus)
 
   yield* Effect.forkScoped(
     Effect.forever(
       Effect.gen(function* () {
-        // Block until the first event, then drain the rest of this tick.
         const first = yield* Queue.take(subscription)
         const rest = yield* Queue.takeAll(subscription)
         const frame = [first, ...Chunk.toArray(rest)]
 
-        // Stable priority order: High-dispatched (UI) events fold before
-        // Normal-dispatched (procedure follow-up) events in the same frame. A
-        // two-bucket partition does this in O(m) with no comparator — partition
-        // preserves intra-priority dispatch order — instead of sorting the frame.
         const [high, normal] = Arr.partition(frame, (envelope) => rank(envelope.priority) !== 0)
         const ordered = [...high, ...normal]
 
-        // One synchronous block: every reducer write for the frame coalesces into
-        // a single notification flush. Routing to channels happens here too, so
-        // procedure bodies (run later, off their channel fibers) see post-batch
-        // state. No `yield*` in between, or the flush could fire early.
+        // Check before folding so runaway frames stop at the hard limit.
+        const sample = yield* Effect.sync(() => counter.add(ordered.length))
+        yield* enforceBudget(budget, sample)
+
+        // One synchronous block coalesces reducer writes into a single flush.
         const failures = yield* Effect.sync(() => {
           const endFrame = instrumentation.frame(ordered.length)
           ordered.forEach((envelope) =>
             instrumentation.eventDispatched(envelope.event._tag, envelope.priority),
           )
-          // Isolate each fold: a synchronous throw in one reducer must not abandon
-          // the rest of the frame nor (via the `forever` below) kill the drain fiber
-          // and freeze the whole app. Collect failures here, log after the block.
           const collected = Arr.flatMap(ordered, (envelope) =>
-            Arr.filterMap(bucketOf(reducers.byTag, envelope.event._tag), (reducer) =>
+            // A reducer defect must not abandon the remaining frame.
+            Arr.filterMap(reducers.tagged(envelope.event._tag), (reducer) =>
               isolateApply(reducer, envelope.event, instrumentation),
             ),
           )
-          // Offer to each DISTINCT channel once. Routing per-procedure would offer a
-          // shared channel multiple times for one event, and each offer re-runs every
-          // procedure on it — duplicate execution.
           ordered.forEach((envelope) => {
-            bucketOf(procedures.channelsByTag, envelope.event._tag).forEach((channelName) => {
+            // channelsFor is distinct; per-procedure offers would double-run shared channels.
+            procedures.channelsFor(envelope.event._tag).forEach((channelName) => {
               channels.get(channelName)?.offer(envelope.event)
             })
           })
@@ -182,21 +169,23 @@ const drain = Effect.gen(function* () {
           { discard: true },
         )
       }).pipe(
-        // Belt-and-suspenders: even a defect outside the isolated fold (a bug in
-        // the loop itself) is logged and the tick restarts, so the bus never goes
-        // permanently deaf.
-        Effect.catchAllCause((cause) => Effect.logError('reform: drain tick crashed', cause)),
+        // Typed overflow halts the loop; defects are logged and the next tick continues.
+        Effect.catchAllCause((cause) =>
+          Option.match(Cause.failureOption(cause), {
+            onSome: () => Effect.failCause(cause),
+            onNone: () => Effect.logError('reform: drain tick crashed', cause),
+          }),
+        ),
+      ),
+    ).pipe(
+      Effect.tapErrorCause((cause) =>
+        Effect.logError('reform: event budget exceeded — the drain loop has been halted', cause),
       ),
+      Effect.tapError((overflow) => Effect.sync(() => budget.onOverflow(overflow))),
     ),
   )
 })
 
-/**
- * The reform engine: provides the bus + reducer/channel/procedure registries +
- * the per-runtime notification scheduler to the application and forks the single
- * drain loop. Registration mutates the live collections, so reducers/procedures/
- * channels merged alongside are picked up before the first dispatch (boot).
- */
 export const Engine: Layer.Layer<Bus | Reducers | Channels | Procedures | Queries> =
   Layer.scopedDiscard(drain).pipe(
     Layer.provideMerge(
@@ -210,3 +199,13 @@ export const Engine: Layer.Layer<Bus | Reducers | Channels | Procedures | Querie
       ),
     ),
   )
+
+export const EngineRequirements: readonly [
+  typeof Bus,
+  typeof Reducers,
+  typeof Channels,
+  typeof Procedures,
+  typeof Queries,
+] = [Bus, Reducers, Channels, Procedures, Queries]
+
+export type EngineServices = Layer.Layer.Success<typeof Engine>

package/src/runtime/queries.ts

@@ -1,25 +1,11 @@
 import { Context, Layer } from 'effect'
 import { type QueryState } from '../calc/queryState'
 
-// The `Queries` registry: the runtime-wide index of live query handles, the same
-// shape as `Reducers`/`Channels`/`Procedures` (`loop.ts`, `channel.ts`). Each
-// `AsyncCalc.live` driver registers its handle here scoped — so `AsyncCalc.invalidate`
-// / `AsyncCalc.refetch` (and any provider layer) can act on a calc by name without
-// holding its store tag. A base in-memory registry ships in `Engine`; provider
-// layers (persistence, focus/online managers) build on top by calling the handles.
-//
-// The per-calc generics are erased through function signatures (reads are
-// covariant; `subscribe` is uniform), so the heterogeneous registry needs no cast.
-
 export interface QueryHandle {
   readonly name: string
-  /** Mark the query's value stale (`isStale := true`). Does not fetch. */
   readonly invalidate: () => void
-  /** Force a run of the current key, bypassing the no-op-key guard. */
   readonly refetch: () => void
-  /** Read the current state (erased to the open value type). */
   readonly snapshot: () => QueryState<unknown, unknown>
-  /** Subscribe to state changes; returns an unsubscribe thunk. */
   readonly subscribe: (listener: () => void) => () => void
 }
 
@@ -41,9 +27,6 @@ const makeQueryRegistry = (): QueryRegistry => {
     register: (handle) => {
       byName.set(handle.name, handle)
     },
-    // Only drop the entry if it is still the one we registered: a same-named
-    // re-registration (re-mount before the old scope's finalizer runs) must not
-    // be clobbered by the stale handle's unregister.
     unregister: (handle) => {
       if (byName.get(handle.name) === handle) {
         byName.delete(handle.name)

package/src/scene/featureScene.test.ts

@@ -0,0 +1,61 @@
+import { Context, Effect, Layer, Schema as S } from 'effect'
+import { expect, test } from '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 Feature from '../feature/feature'
+import { featureModule } from '../feature/feature'
+import { makeAppRuntime } from '../runtime/appRuntime'
+import { Engine } from '../runtime/loop'
+import { featureScene } from './scene'
+
+interface GreetingService {
+  readonly value: string
+}
+
+const GreetingBase: Context.TagClass<Greeting, 'featureScene.Greeting', GreetingService> =
+  Context.Tag('featureScene.Greeting')<Greeting, GreetingService>()
+class Greeting extends GreetingBase {}
+
+class Started extends Event.make('featureScene.Started', S.Struct({})) {}
+class RootUi extends ui('featureScene.RootUi')<{
+  props: { readonly greeting: string }
+}>() {}
+class RootComp extends Composition.make('featureScene.RootComp', {
+  title: 'Feature root',
+  ui: RootUi,
+})<RootComp>() {}
+
+const RootLive = Composition.live(RootComp, function* () {
+  const greeting = yield* Greeting
+  return mount({ props: { greeting: greeting.value }, slots: {} })
+})
+
+class RootFeature extends Feature.make('featureScene.root', {
+  composition: RootComp,
+  module: featureModule([Greeting], RootLive),
+  boot: [Event.construct(Started, {})],
+}) {}
+
+test('featureScene closes an eager root Feature with its typed requirements and boot', () => {
+  const root = featureScene(RootFeature, {
+    provide: Layer.mergeAll(Engine, Layer.succeed(Greeting, { value: 'hello' })),
+  })
+  const app = makeAppRuntime(root)
+
+  try {
+    const rendered = Effect.runSync(
+      Composition.render(app.read(RootComp.tag), {
+        props: {},
+        tracker: { add: () => {} },
+      }),
+    )
+
+    expect(root.composition).toBe(RootComp)
+    expect(root.boot).toEqual([Event.construct(Started, {})])
+    expect(rendered.props).toEqual({ greeting: 'hello' })
+  } finally {
+    app.dispose()
+  }
+})