@playfast/reform-proof 1.1.1 → 1.2.1

package/src/runner.ts

@@ -1,8 +1,10 @@
 import { Context, Effect, Layer } from 'effect'
-import { driveProof, executeProof } from './execution'
+import { driveProof, driveProofEffect, executeProof, executeProofEffect } from './engine'
 import type { DriveResult, Proof, ProofResult } from './index'
 
 export interface ProofRunnerApi {
+  readonly executeProofEffect: (proof: Proof) => Effect.Effect<ProofResult, never, never>
+  readonly driveProofEffect: (proof: Proof) => Effect.Effect<DriveResult, never, never>
   readonly executeProof: (proof: Proof) => Promise<ProofResult>
   readonly driveProof: (proof: Proof) => Promise<DriveResult>
 }
@@ -13,6 +15,8 @@ const ProofRunnerBase: Context.TagClass<ProofRunner, 'reform-proof/ProofRunner',
 export class ProofRunner extends ProofRunnerBase {}
 
 export const proofRunnerLayer: Layer.Layer<ProofRunner> = Layer.succeed(ProofRunner, {
+  executeProofEffect,
+  driveProofEffect,
   executeProof,
   driveProof,
 })

package/src/structure-events.test.ts

@@ -19,7 +19,10 @@ import { Product, Proof, ProductRequirement, expect as proofExpect } from './ind
 class CountState extends State.make('scount', S.Number) {}
 class MiniStates extends StateGroup.make(CountState) {}
 class Bumped extends Event.make('SBumped', S.Struct({})) {}
-class BumpReducer extends Reducer.make('SBumpReducer', { states: [CountState], events: [Bumped] }) {}
+class BumpReducer extends Reducer.make('SBumpReducer', {
+  states: [CountState],
+  events: [Bumped],
+}) {}
 const BumpReducerLive = Reducer.live(BumpReducer, (n) => n + 1)
 
 class CounterUi extends ui('SCounter')<{
@@ -31,14 +34,17 @@ class Counter extends Composition.make('SCounter', {
   states: [MiniStates],
   events: [Bumped],
   ui: CounterUi,
-}) {}
+})<Counter>() {}
 const CounterLive = Composition.live(Counter, function* () {
   const count = yield* StateGroup.select(MiniStates, 'scount')
   const bump = yield* Event.trigger(Bumped)
   return mount({ props: { count }, slots: {}, events: { bump } })
 })
 
-const presentations = provide(CounterUi, Ui.make(CounterUi, () => null))
+const presentations = provide(
+  CounterUi,
+  Ui.make(CounterUi, () => null),
+)
 const Views = CounterLive.pipe(Layer.provideMerge(presentations))
 const Logic = BumpReducerLive.pipe(
   Layer.provideMerge(Layer.mergeAll(Engine, StateGroup.live(MiniStates, { scount: 5 }))),

package/src/structure-locators.test.ts

@@ -4,7 +4,6 @@ import {
   Engine,
   each,
   mount,
-  Props,
   provide,
   scene,
   slot,
@@ -22,13 +21,15 @@ class TodosState extends State.make(
 ) {}
 class TodoStates extends StateGroup.make(TodosState) {}
 
-class ItemUi extends ui('LocItem')<{ props: { id: string; done: boolean } }>() {}
+class ItemUi extends ui('LocItem')<{
+  props: { id: string; done: boolean }
+}>() {}
 class Item extends Composition.make('LocItem', {
   title: 'LocItem',
   props: S.Struct({ id: S.String, done: S.Boolean }),
   ui: ItemUi,
-}) {}
-class ItemSlot extends slot('LocItem')<typeof Item>() {}
+})<Item>() {}
+class ItemSlot extends slot('LocItem')<ItemSlot, typeof Item>() {}
 
 class ListUi extends ui('LocList')<{
   props: { total: number }
@@ -39,25 +40,34 @@ class List extends Composition.make('LocList', {
   states: [TodoStates],
   slots: { Item: ItemSlot },
   ui: ListUi,
-}) {}
+})<List>() {}
 
 const ListLive = Composition.live(List, function* () {
   const todos = yield* StateGroup.select(TodoStates, 'locTodos')
   return mount({
     props: { total: todos.length },
     slots: {
-      Item: each(todos, { key: (t) => t.id, props: (t) => ({ id: t.id, done: t.done }) }),
+      Item: each(todos, {
+        key: (t) => t.id,
+        props: (t) => ({ id: t.id, done: t.done }),
+      }),
     },
   })
 })
 const ItemLive = Composition.live(Item, function* () {
-  const props: { id: string; done: boolean } = yield* Props
+  const props = yield* Item.props
   return mount({ props, slots: {} })
 })
 
 const presentations = Layer.mergeAll(
-  provide(ListUi, Ui.make(ListUi, () => null)),
-  provide(ItemUi, Ui.make(ItemUi, () => null)),
+  provide(
+    ListUi,
+    Ui.make(ListUi, () => null),
+  ),
+  provide(
+    ItemUi,
+    Ui.make(ItemUi, () => null),
+  ),
 )
 const wiring = provide(ItemSlot, Item)
 const Views = Layer.mergeAll(ListLive, ItemLive, wiring).pipe(Layer.provideMerge(presentations))

package/src/test-clock.test.ts

@@ -0,0 +1,135 @@
+import { Duration, Effect, Layer, Schema as S } from 'effect'
+import {
+  Channel,
+  Composition,
+  Engine,
+  Event,
+  mount,
+  Procedure,
+  provide,
+  publish,
+  Reducer,
+  scene,
+  State,
+  StateGroup,
+  type Trigger,
+  Ui,
+  ui,
+} from '@playfast/reform'
+import { describe, expect, test } from 'vitest'
+import { Product, Proof, ProductRequirement, expect as proofExpect } from './index'
+
+// A scene's product timers live inside its procedures, on the real clock: a proof
+// could only observe one by waiting it out, which spends real seconds AND races the
+// runner (a fixed sleep past the timer assumes the woken fiber is scheduled before
+// the next read). `Proof.withTestClock` puts a virtual clock behind the scene so
+// `app.advance(...)` moves that time exactly, instantly, and only on demand.
+
+const FLASH = Duration.millis(1500)
+
+class FlashState extends State.make('flash', S.Boolean) {}
+class FlashStates extends StateGroup.make(FlashState) {}
+
+class Submitted extends Event.make('TCSubmitted', S.Struct({})) {}
+class FlashEnded extends Event.make('TCFlashEnded', S.Struct({})) {}
+
+class EndFlash extends Reducer.make('TCEndFlash', {
+  states: [FlashState],
+  events: [FlashEnded],
+}) {}
+const EndFlashLive = Reducer.live(EndFlash, () => false)
+
+class FlashLane extends Channel.make('TCFlashLane', { policy: { _tag: 'latest' } }) {}
+class FlashTimer extends Procedure.make('TCFlashTimer', {
+  events: [Submitted],
+  channel: FlashLane,
+}) {}
+// The product timer under test: a success flash that clears itself 1500ms later.
+const FlashTimerLive = Procedure.live(FlashTimer, function* () {
+  yield* Effect.sleep(FLASH)
+  yield* publish('Normal', Event.construct(FlashEnded, {}))
+})
+
+class FlashUi extends ui('TCFlash')<{
+  props: { flash: boolean }
+  events: { submit: Trigger<Record<string, never>> }
+}>() {}
+class Flash extends Composition.make('TCFlash', {
+  title: 'TCFlash',
+  states: [FlashStates],
+  events: [Submitted],
+  ui: FlashUi,
+})<Flash>() {}
+const FlashLive = Composition.live(Flash, function* () {
+  const flash = yield* StateGroup.select(FlashStates, 'flash')
+  const submit = yield* Event.trigger(Submitted)
+  return mount({ props: { flash }, slots: {}, events: { submit } })
+})
+
+const presentations = provide(FlashUi, Ui.make(FlashUi, () => null))
+const Views = FlashLive.pipe(Layer.provideMerge(presentations))
+const Logic = Layer.mergeAll(EndFlashLive, FlashTimerLive, Channel.live(FlashLane)).pipe(
+  Layer.provideMerge(Layer.mergeAll(Engine, StateGroup.live(FlashStates, { flash: true }))),
+)
+const App = Views.pipe(Layer.provideMerge(Logic))
+
+const VirtualScene = scene(Flash, { provide: [Proof.withTestClock(App)] })
+const RealScene = scene(Flash, { provide: [App] })
+
+class ClearsFlash extends ProductRequirement.make(Flash, 'clears the flash after the window', {
+  events: ['submit'],
+}) {}
+class FlashProduct extends Product.make(Flash, { requirements: [ClearsFlash] }) {}
+
+describe('Proof.withTestClock', () => {
+  test('app.advance elapses a product timer without spending real time', async () => {
+    const proof = Proof.implement(ClearsFlash, VirtualScene, function* (app) {
+      yield* proofExpect((yield* app.props).flash).toBe(true)
+      yield* app.actions.submit({})
+      // The timer is armed but no virtual time has passed, so the flash still shows.
+      // On the real clock this frame is a race; here it is a fact.
+      yield* proofExpect((yield* app.props).flash).toBe(true)
+      yield* app.advance(FLASH)
+      yield* proofExpect((yield* app.props).flash).toBe(false)
+    })
+
+    const startedAt = performance.now()
+    const result = await Proof.run(Proof.suite(FlashProduct, { proofs: [proof] }))
+    const elapsed = performance.now() - startedAt
+
+    expect(result.results.map((entry) => entry.error)).toEqual([undefined])
+    expect(result.ok).toBe(true)
+    // The assertion that matters: 1500ms of product time cost a fraction of it in
+    // real time. Generous enough not to flake on a loaded runner, tight enough that
+    // a regression to the real clock (>= 1500ms) fails here.
+    expect(elapsed).toBeLessThan(750)
+  })
+
+  test('the timer does not fire on its own — only advancing moves it', async () => {
+    // The complement of the test above: if the virtual clock were a no-op and the
+    // procedure were really sleeping on the wall clock, this proof would go green the
+    // moment the settle loop outlasted the window. It must stay red instead.
+    const proof = Proof.implement(ClearsFlash, VirtualScene, function* (app) {
+      yield* app.actions.submit({})
+      yield* app.frame
+      yield* app.frame
+      yield* proofExpect((yield* app.props).flash).toBe(false)
+    })
+
+    const result = await Proof.run(Proof.suite(FlashProduct, { proofs: [proof] }))
+
+    expect(result.ok).toBe(false)
+  })
+
+  test('app.advance against the real clock dies rather than silently no-opping', async () => {
+    const proof = Proof.implement(ClearsFlash, RealScene, function* (app) {
+      yield* app.actions.submit({})
+      yield* app.advance(FLASH)
+    })
+
+    const result = await Proof.run(Proof.suite(FlashProduct, { proofs: [proof] }))
+
+    expect(result.ok).toBe(false)
+    expect(result.results[0]?.error).toContain('Proof.withTestClock')
+  })
+})

package/src/typed-seams.test.ts

@@ -25,24 +25,27 @@ class BumpReducer extends Reducer.make('BumpReducer', { states: [CountState], ev
 const BumpReducerLive = Reducer.live(BumpReducer, (n) => n + 1)
 
 class LabelUi extends ui('Label')<{ props: { text: string } }>() {}
-class Label extends Composition.make('Label', { title: 'Label', ui: LabelUi }) {}
+
+class Label extends Composition.make('Label', { title: 'Label', ui: LabelUi })<Label>() {}
 const LabelLive = Composition.live(Label, function* () {
   return mount({ props: { text: 'count' }, slots: {} })
 })
-class LabelSlot extends slot('Label')<typeof Label>() {}
+
+class LabelSlot extends slot('Label')<LabelSlot, typeof Label>() {}
 
 class CounterUi extends ui('Counter')<{
   props: { count: number }
   slots: { Label: LabelSlot }
   events: { bump: Trigger<Record<string, never>> }
 }>() {}
+
 class Counter extends Composition.make('Counter', {
   title: 'Counter',
   states: [MiniStates],
   events: [Bumped],
   slots: { Label: LabelSlot },
   ui: CounterUi,
-}) {}
+})<Counter>() {}
 const CounterLive = Composition.live(Counter, function* () {
   const count = yield* StateGroup.select(MiniStates, 'count')
   const bump = yield* Event.trigger(Bumped)

package/src/driverTypes.ts

@@ -1,19 +0,0 @@
-import type { UiCapture } from '@playfast/reform'
-
-export interface StepFrame {
-  readonly index: number
-  readonly captures: ReadonlyArray<UiCapture>
-}
-
-export interface DriveResult {
-  readonly requirement: string
-  readonly frames: ReadonlyArray<StepFrame>
-  readonly ok: boolean
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- serialized result DTO read as `error ?? …` by the editor timeline (external); optional kept for wire compat
-  readonly error?: string
-}
-
-export interface ProofDriver {
-  readonly requirement: string
-  readonly run: () => Promise<DriveResult>
-}

package/src/execution.ts

@@ -1,100 +0,0 @@
-import { Cause, Effect, Option, Ref } from 'effect'
-import { yieldWrapGet } from 'effect/Utils'
-import {
-  Bus,
-  type CompositionService,
-  publish,
-  type Scene,
-  sceneInstrumentation,
-} from '@playfast/reform'
-import type { DriveResult, Proof, ProofResult, StepFrame } from './index'
-import { makeFacadeEffect } from './facade'
-import { makeSink, messageOf, proofLayer, type RuntimeServices, type Sink } from './sink'
-import type { PumpStep } from './treeBindings'
-
-const missingCoverage = (proof: Proof, dispatched: Set<string>): ReadonlyArray<string> =>
-  Option.match(proof.requirement.manifest.events, {
-    onNone: () => [],
-    onSome: (declared) => declared.map(String).filter((event) => !dispatched.has(event)),
-  })
-
-const bootScene = (scene: Scene): Effect.Effect<void, never, Bus> =>
-  Effect.forEach(
-    Option.getOrElse(Option.fromNullable(scene.boot), () => []),
-    (event) => publish('High', event),
-  ).pipe(Effect.asVoid)
-
-const executeProofEffect = Effect.fn('executeProofEffect')(function* (
-  proof: Proof,
-  sink: Sink,
-): Effect.fn.Return<ProofResult, never, RuntimeServices> {
-  const dispatched = new Set<string>()
-  const statement = proof.requirement.manifest.statement
-  return yield* Effect.gen(function* () {
-    const { facade, settle } = yield* makeFacadeEffect(proof.scene.composition, sink, dispatched)
-    yield* bootScene(proof.scene)
-    yield* settle
-    yield* Effect.gen(() => proof.body(facade))
-    const missing = missingCoverage(proof, dispatched)
-    const coverageError = `requirement declares events never dispatched: ${missing.join(', ')}`
-    return missing.length > 0
-      ? { requirement: statement, ok: false, error: coverageError }
-      : { requirement: statement, ok: true }
-  }).pipe(
-    Effect.catchAllCause((cause) =>
-      Effect.succeed({ requirement: statement, ok: false, error: messageOf(Cause.squash(cause)) }),
-    ),
-  )
-})
-
-export const executeProof = async (proof: Proof): Promise<ProofResult> => {
-  const sink = makeSink(sceneInstrumentation(proof.scene))
-  return Effect.runPromise(executeProofEffect(proof, sink).pipe(Effect.provide(proofLayer(proof.scene, sink))))
-}
-
-const driveProofEffect = Effect.fn('driveProofEffect')(function* (
-  proof: Proof,
-  sink: Sink,
-): Effect.fn.Return<DriveResult, never, RuntimeServices> {
-  const frames = yield* Ref.make<ReadonlyArray<StepFrame>>([])
-  const statement = proof.requirement.manifest.statement
-  const dispatched = new Set<string>()
-  const record = (index: number): Effect.Effect<void> =>
-    Ref.update(frames, (current) => [...current, { index, captures: [...sink.captures] }])
-  const pump = Effect.fn('pump')(function* (
-    generator: ReturnType<Proof['body']>,
-    step: PumpStep,
-  ): Effect.fn.Return<void, unknown, CompositionService> {
-    const next = generator.next(step.input)
-    if (next.done === true) {
-      return
-    }
-    const output = yield* yieldWrapGet(next.value)
-    yield* record(step.index)
-    yield* pump(generator, { input: output, index: step.index + 1 })
-  })
-  return yield* Effect.gen(function* () {
-    const { facade, settle } = yield* makeFacadeEffect(proof.scene.composition, sink, dispatched)
-    yield* bootScene(proof.scene)
-    yield* settle
-    yield* record(0)
-    yield* pump(proof.body(facade), { input: undefined, index: 1 })
-    return { requirement: statement, frames: yield* Ref.get(frames), ok: true }
-  }).pipe(
-    Effect.catchAllCause((cause) =>
-      Ref.get(frames).pipe(
-        Effect.map((collected) => ({
-          requirement: statement,
-          frames: collected,
-          ok: false,
-          error: messageOf(Cause.squash(cause)),
-        })),
-      ),
-    ),
-  )
-})
-
-export const driveProof = async (proof: Proof): Promise<DriveResult> => {
-  const sink = makeSink(sceneInstrumentation(proof.scene))
-  return Effect.runPromise(driveProofEffect(proof, sink).pipe(Effect.provide(proofLayer(proof.scene, sink))))
-}

package/src/runtimeFacade.ts

@@ -1,269 +0,0 @@
-import { Array as Arr, Effect, Option, Record as Rec } from 'effect'
-import {
-  Composition,
-  type CompositionClass,
-  isStructure,
-  type RenderEnv,
-  type RuntimeHandle,
-  type SlotClass,
-  type Trigger,
-} from '@playfast/reform'
-import { AssertionFailed, UnknownAction, UnknownSlot } from './errors'
-import { matchProps } from './assertions'
-import { capturesFor, fingerprint } from './facade'
-import {
-  keyed,
-  SETTLE_MAX_RENDERS,
-  SETTLE_STEP,
-  settleDrain,
-  type Sink,
-  uiNameOf,
-} from './sink'
-import {
-  childComposition,
-  driveStructure,
-  type Mounted,
-  type NodeRef,
-  type SettleProgress,
-  slotsOf,
-} from './treeBindings'
-
-export interface MountedFacade {
-  readonly props: Effect.Effect<unknown, never, never>
-  readonly expectProps: (partial: unknown) => Effect.Effect<void, never, never>
-  readonly actions: Record<string, (payload: unknown) => Effect.Effect<unknown, never, never>>
-  readonly slots: Record<string, MountedSlotFacade>
-  readonly frame: Effect.Effect<void, never, never>
-}
-
-export interface MountedSlotFacade extends MountedFacade {
-  readonly first: Effect.Effect<MountedFacade, never, never>
-  readonly at: (index: number) => Effect.Effect<MountedFacade, never, never>
-  readonly all: Effect.Effect<ReadonlyArray<MountedFacade>, never, never>
-  readonly byKey: (key: string) => Effect.Effect<MountedFacade, never, never>
-  readonly where: (
-    predicate: (props: unknown) => boolean,
-  ) => Effect.Effect<ReadonlyArray<MountedFacade>, never, never>
-  readonly count: Effect.Effect<number, never, never>
-}
-
-const collectRuntimeBindings = (
-  root: CompositionClass<unknown>,
-  runtime: RuntimeHandle,
-): Map<SlotClass, CompositionClass<unknown>> => {
-  const bindings = new Map<SlotClass, CompositionClass<unknown>>()
-  const walk = (comp: CompositionClass<unknown>): void => {
-    Rec.values(slotsOf(comp)).forEach((slotClass) => {
-      if (bindings.has(slotClass)) {
-        return
-      }
-      const child = childComposition(runtime.read(slotClass.tag))
-      bindings.set(slotClass, child)
-      walk(child)
-    })
-  }
-  walk(root)
-  return bindings
-}
-
-const renderMountedRuntime = (
-  runtime: RuntimeHandle,
-  mounted: Mounted,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-  sink: Sink,
-): ReadonlyArray<Mounted> => {
-  const service = runtime.read(mounted.comp.tag)
-  const env: RenderEnv = { props: mounted.props, tracker: { add: () => {} } }
-  const endRenderSpan = sink.instrumentation.uiRendered(uiNameOf(mounted.comp))
-  const frame = Effect.runSync(Composition.render(service, env))
-  endRenderSpan()
-  if (!isStructure(frame)) {
-    return Effect.runSync(
-      Effect.dieMessage(
-        `reform-proof: composition ${uiNameOf(mounted.comp)} did not return a Structure`,
-      ),
-    )
-  }
-  return driveStructure(mounted.comp, frame, mounted.key, sink, bindings)
-}
-
-const renderLevelRuntime = (
-  runtime: RuntimeHandle,
-  frontier: ReadonlyArray<Mounted>,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-  sink: Sink,
-): void => {
-  if (frontier.length === 0) {
-    return
-  }
-  const levels = frontier.map((mounted) => renderMountedRuntime(runtime, mounted, bindings, sink))
-  renderLevelRuntime(runtime, levels.flat(), bindings, sink)
-}
-
-const renderTreeRuntime = (
-  runtime: RuntimeHandle,
-  root: CompositionClass<unknown>,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-  sink: Sink,
-): Effect.Effect<void, never, never> =>
-  Effect.sync(() => {
-    sink.reset()
-    renderLevelRuntime(runtime, [{ comp: root, props: {}, key: Option.none() }], bindings, sink)
-  })
-
-const settleTreeRuntime = Effect.fn('settleTreeRuntime')(function* (
-  runtime: RuntimeHandle,
-  root: CompositionClass<unknown>,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-  sink: Sink,
-): Effect.fn.Return<void, never, never> {
-  yield* settleDrain
-  yield* renderTreeRuntime(runtime, root, bindings, sink)
-  yield* Effect.iterate(
-    {
-      previous: fingerprint(sink),
-      remaining: SETTLE_MAX_RENDERS,
-      stable: false,
-    },
-    {
-      while: (progress: SettleProgress) => !progress.stable && progress.remaining > 0,
-      body: (progress) =>
-        Effect.gen(function* () {
-          yield* settleDrain
-          yield* Effect.sleep(SETTLE_STEP)
-          yield* renderTreeRuntime(runtime, root, bindings, sink)
-          const current = fingerprint(sink)
-          return {
-            previous: current,
-            remaining: progress.remaining - 1,
-            stable: current === progress.previous,
-          }
-        }),
-    },
-  )
-})
-
-const makeMountedFacade = (
-  runtime: RuntimeHandle,
-  root: CompositionClass<unknown>,
-  sink: Sink,
-  dispatched: Set<string>,
-): {
-  readonly facade: MountedFacade
-  readonly settle: Effect.Effect<void, never, never>
-} => {
-  const bindings = collectRuntimeBindings(root, runtime)
-  const settle = settleTreeRuntime(runtime, root, bindings, sink)
-  const rerender = renderTreeRuntime(runtime, root, bindings, sink)
-
-  const triggerOf = (ref: NodeRef, event: string): Effect.Effect<Trigger<unknown>, never, never> =>
-    Option.match(Option.fromNullable(capturesFor(sink, ref.name)[ref.index]?.events[event]), {
-      onNone: () =>
-        Effect.dieMessage(
-          new UnknownAction({
-            composition: ref.name,
-            action: event,
-            rendered: capturesFor(sink, ref.name).length,
-          }).message,
-        ),
-      onSome: Effect.succeed,
-    })
-
-  const propsFor = (ref: NodeRef): Effect.Effect<unknown, never, never> =>
-    Effect.map(rerender, () => capturesFor(sink, ref.name)[ref.index]?.props)
-
-  const nodeFacade = (ref: NodeRef, comp: CompositionClass<unknown>): MountedFacade => ({
-    props: propsFor(ref),
-    expectProps: (partial) =>
-      propsFor(ref).pipe(
-        Effect.flatMap((props) => {
-          const mismatch = matchProps({ actual: props, expected: partial })
-          return mismatch === undefined
-            ? Effect.void
-            : Effect.dieMessage(new AssertionFailed({ detail: mismatch }).message)
-        }),
-      ),
-    actions: keyed(
-      (event) => (payload: unknown) =>
-        rerender.pipe(
-          Effect.flatMap(() => triggerOf(ref, event)),
-          Effect.flatMap((trigger) =>
-            Effect.sync(() => {
-              dispatched.add(event)
-              trigger(payload)
-            }),
-          ),
-          Effect.flatMap(() => settle),
-          Effect.flatMap(() => propsFor(ref)),
-        ),
-    ),
-    slots: keyed((slotName) => slotFacade(comp, slotName)),
-    frame: settle,
-  })
-
-  const slotFacade = (parent: CompositionClass<unknown>, slotName: string): MountedSlotFacade => {
-    const slotClass = slotsOf(parent)[slotName]
-    const child = slotClass && bindings.get(slotClass)
-    if (child === undefined) {
-      return Effect.runSync(
-        Effect.dieMessage(new UnknownSlot({ parent: uiNameOf(parent), slot: slotName }).message),
-      )
-    }
-    const childName = uiNameOf(child)
-    const atIndex = (index: number): Effect.Effect<MountedFacade, never, never> =>
-      Effect.as(rerender, nodeFacade({ name: childName, index }, child))
-    const first = nodeFacade({ name: childName, index: 0 }, child)
-    const indexOfKey = (key: string): Option.Option<number> =>
-      Arr.findFirstIndex(capturesFor(sink, childName), (capture) => capture.key === key)
-    return {
-      first: atIndex(0),
-      at: atIndex,
-      all: Effect.map(rerender, () =>
-        capturesFor(sink, childName).map((_capture, index) =>
-          nodeFacade({ name: childName, index }, child),
-        ),
-      ),
-      byKey: (key) =>
-        Effect.flatMap(rerender, () =>
-          Option.match(indexOfKey(key), {
-            onNone: () =>
-              Effect.dieMessage(
-                new UnknownSlot({
-                  parent: uiNameOf(parent),
-                  slot: `${slotName}[key=${key}]`,
-                }).message,
-              ),
-            onSome: (index) => Effect.succeed(nodeFacade({ name: childName, index }, child)),
-          }),
-        ),
-      where: (predicate) =>
-        Effect.map(rerender, () =>
-          capturesFor(sink, childName).flatMap((capture, index) =>
-            predicate(capture.props) ? [nodeFacade({ name: childName, index }, child)] : [],
-          ),
-        ),
-      count: Effect.map(rerender, () => capturesFor(sink, childName).length),
-      props: first.props,
-      expectProps: first.expectProps,
-      actions: first.actions,
-      slots: first.slots,
-      frame: first.frame,
-    }
-  }
-
-  return {
-    facade: nodeFacade({ name: uiNameOf(root), index: 0 }, root),
-    settle,
-  }
-}
-
-export const makeRuntimeHandleFacade = (
-  runtime: RuntimeHandle,
-  root: CompositionClass<unknown>,
-  sink: Sink,
-  dispatched: Set<string>,
-): {
-  readonly facade: MountedFacade
-  readonly settle: Effect.Effect<void, never, never>
-} => makeMountedFacade(runtime, root, sink, dispatched)
-