@playfast/reform-proof 1.2.0 → 1.3.0

package/src/engine.ts

@@ -1,1414 +1,41 @@
-import {
-  Array as Arr,
-  Cause,
-  Context,
-  Effect,
-  Layer,
-  ManagedRuntime,
-  Match,
-  MutableRef,
-  Option,
-  Order,
-  Record as Rec,
-  Ref,
-} from 'effect'
+import { Cause, Effect, Option, Record as Rec, Ref } from 'effect'
 import { yieldWrapGet } from 'effect/Utils'
-import { AssertionFailed, UnknownAction, UnknownSlot } from './errors'
 import {
   type CapturedScene,
-  Composition,
   type CompositionClass,
-  type CompositionService,
-  type FeatureLoadFailed,
-  isFeatureBinding,
-  isSlot,
-  isStructure,
   makeAppRuntime,
-  publish,
-  type RuntimeHandle,
   sceneInstrumentation,
-  type SlotFill,
-  type Structure,
-  type Trigger,
   type UiContract,
 } from '@playfast/reform'
+import { type AnyComposition, type AnyScene } from '@playfast/reform/internal'
 import {
-  type AnyComposition,
-  type AnyFeatureBinding,
-  type AnyScene,
-  type AnySlot,
-  type AnySlotChild,
-  Bus,
-  type CapturedRender,
-  CaptureSink,
-  type CaptureSinkApi,
-  type Instrumentation,
-  noopInstrumentation,
-} from '@playfast/reform/internal'
-import { matchProps } from './index'
-import type {
-  DriveResult,
-  Facade,
-  Proof,
-  ProofCase,
-  ProductComposition,
-  ProofResult,
-  SlotFacade,
-  SlotFacadesOf,
-  StepFrame,
-} from './index'
-import { formatFingerprint } from './fingerprint'
-
-type RenderRuntime = Pick<RuntimeHandle, 'dispatch' | 'instrumentation' | 'readOption'>
-
-type HostRuntime = Pick<
-  RuntimeHandle,
-  'dispatch' | 'instrumentation' | 'mountAnyFeature' | 'readOption'
->
-
-type RuntimeRootComposition<
-  Identifier,
-  P,
-  C extends UiContract,
-  S extends ReadonlyArray<unknown>,
-  N extends string,
-  Identity,
-> = CompositionClass<P, C, S, N, Identity> & {
-  readonly tag: Context.Tag<Identifier, CompositionService<P, C>>
-}
-
-interface MountedFacadeErasure {
-  readonly props: Effect.Effect<unknown, never, never>
-  readonly expectProps: (partial: unknown) => Effect.Effect<void, never, never>
-  readonly actions: Readonly<
-    Record<string, (payload: unknown) => Effect.Effect<unknown, never, never>>
-  >
-  readonly slots: Readonly<Record<string, MountedSlotFacadeErasure>>
-  readonly frame: Effect.Effect<void, never, never>
-}
-
-interface MountedSlotFacadeErasure extends MountedFacadeErasure {
-  readonly first: Effect.Effect<MountedFacadeErasure, never, never>
-  readonly at: (index: number) => Effect.Effect<MountedFacadeErasure, never, never>
-  readonly all: Effect.Effect<ReadonlyArray<MountedFacadeErasure>, never, never>
-  readonly byKey: (key: string) => Effect.Effect<MountedFacadeErasure, never, never>
-  readonly where: (
-    predicate: (props: unknown) => boolean,
-  ) => Effect.Effect<ReadonlyArray<MountedFacadeErasure>, never, never>
-  readonly count: Effect.Effect<number, never, never>
-}
-
-interface MountedFacadeHandleErasure {
-  readonly facade: {
-    readonly props: Effect.Effect<unknown, never, never>
-    readonly expectProps: (partial: never) => Effect.Effect<void, never, never>
-    readonly actions: object
-    readonly slots: object
-    readonly frame: Effect.Effect<void, never, never>
-  }
-  readonly settle: Effect.Effect<void, never, never>
-}
-
-type Settlement = Effect.Effect<void, never, never>
-type SettleBoundary = (settlement: Settlement) => Settlement
-
-const directSettle: SettleBoundary = (settlement) => settlement
-
-// Cooperative yields flush synchronous fibers; the real-time sleep prevents a
-// genuinely delayed flow from looking stable between renders.
-const SETTLE_DRAIN = 30
-const SETTLE_STEP = '1 milli'
-const SETTLE_MAX_RENDERS = 100
-
-const settleDrain = Effect.yieldNow().pipe(Effect.repeatN(SETTLE_DRAIN))
-
-const keyed = <V>(get: (key: string) => V): Record<string, V> => {
-  const target: Record<string, V> = Object.create(null)
-  return new Proxy(target, { get: (_target, key) => get(String(key)) })
-}
-
-const messageOf = (error: unknown): string =>
-  error instanceof Error ? error.message : String(error)
-
-const uiNameOf = (comp: AnyComposition): string => comp.manifest.ui.manifest.name
-
-// UiContract erases event values to never, so this boundary needs no assertion.
-const eventsOf = (structure: Structure<UiContract>): Record<string, Trigger<unknown>> => ({
-  ...structure.events,
-})
-
-interface ExpectedProps {
-  readonly actual: unknown
-  readonly expected: unknown
-}
-
-const expectMatchingProps = ({
-  actual,
-  expected,
-}: ExpectedProps): Effect.Effect<void, never, never> =>
-  Option.match(Option.fromNullable(matchProps({ actual, expected })), {
-    onNone: () => Effect.void,
-    onSome: (detail) => Effect.dieMessage(new AssertionFailed({ detail }).message),
-  })
-
-const invalidCompositionProps = (composition: AnyComposition): string =>
-  `reform-proof: invalid props for composition ${composition.manifest.name}`
-
-const renderCompositionRuntime = (
-  runtime: RenderRuntime,
-  composition: AnyComposition,
-  props: unknown,
-): Structure<UiContract> =>
-  composition.capture(
-    <P, C extends UiContract, S extends ReadonlyArray<unknown>, N extends string, Identity>(
-      exact: CompositionClass<P, C, S, N, Identity>,
-    ): Structure<UiContract> => {
-      const resolved = Option.flatMap(exact.parseProps(props), (parsed) =>
-        Option.map(runtime.readOption(exact.tag), (service) => ({
-          parsed,
-          service,
-        })),
-      )
-      return Option.match(resolved, {
-        onNone: () => Effect.runSync(Effect.dieMessage(invalidCompositionProps(composition))),
-        onSome: ({ parsed, service }) => {
-          const frame = Effect.runSync(
-            Composition.render(service, {
-              props: parsed,
-              tracker: { add: () => {} },
-            }),
-          )
-          if (isStructure(frame)) {
-            return frame
-          }
-          return Effect.runSync(
-            Effect.dieMessage(
-              `reform-proof: composition ${composition.manifest.name} did not return a Structure`,
-            ),
-          )
-        },
-      })
-    },
-  )
-
-export interface Sink {
-  readonly api: CaptureSinkApi
-  readonly captures: ReadonlyArray<CapturedRender>
-  readonly instrumentation: Instrumentation
-  reset(): void
-}
-
-export const makeSink = (instrumentation: Instrumentation = noopInstrumentation): Sink => {
-  // CaptureSink.record is synchronous, so this uses MutableRef rather than Ref.
-  const captures = MutableRef.make<CapturedRender[]>([])
-  return {
-    api: {
-      record: (capture) => {
-        MutableRef.update(captures, (current) => [...current, capture])
-      },
-    },
-    get captures() {
-      return MutableRef.get(captures)
-    },
-    instrumentation,
-    reset: () => {
-      MutableRef.set(captures, [])
-    },
-  }
-}
-
-export type MountedSlotFacadesOf<C extends UiContract> = SlotFacadesOf<C, never>
-
-export type MountedFacade<C extends UiContract> = Facade<C, never>
-
-export type MountedSlotFacade<C extends UiContract> = SlotFacade<C, never>
-
-export const proofLayer = <
-  C extends UiContract,
-  S extends ReadonlyArray<unknown>,
-  Services,
-  P,
-  N extends string,
-  Identity,
->(
-  scene: CapturedScene<C, S, Services, P, N, Identity>,
-  sink: Sink,
-): Layer.Layer<Services | CaptureSink, never, never> => {
-  const sceneLayer = scene.provide.reduce((merged, layer) => Layer.merge(merged, layer))
-  return Layer.merge(sceneLayer, Layer.succeed(CaptureSink, sink.api))
-}
-
-const missingRuntimeBus = (): never =>
-  Effect.runSync(Effect.dieMessage('reform-proof: scene does not provide Bus'))
-
-const renderRuntimeFromContext = <Services>(
-  context: Context.Context<Services>,
-  instrumentation: Instrumentation,
-): RenderRuntime => {
-  const bus = Context.getOption(context, Bus)
-  return {
-    dispatch: (priority, event) =>
-      Option.match(bus, {
-        onNone: missingRuntimeBus,
-        onSome: (service) =>
-          Effect.runSync(publish(priority, event).pipe(Effect.provideService(Bus, service))),
-      }),
-    instrumentation,
-    readOption: (tag) => Context.getOption(context, tag),
-  }
-}
-
-interface Mounted {
-  readonly comp: AnyComposition
-  readonly props: unknown
-  readonly ref: NodeRef
-}
-
-interface SlotInstanceRef {
-  readonly name: string
-  readonly index: number
-  readonly key: Option.Option<string>
-  readonly keyOccurrence: number
-}
-
-interface NodeRef {
-  readonly name: string
-  readonly parent: Option.Option<NodeRef>
-  readonly slot: Option.Option<SlotInstanceRef>
-}
-
-interface NodeCapture {
-  readonly ref: NodeRef
-  readonly capture: CapturedRender
-}
-
-interface CaptureLookup {
-  readonly captures: ReadonlyArray<NodeCapture>
-  record(ref: NodeRef, capture: CapturedRender): void
-  reset(): void
-}
-
-const makeCaptureLookup = (): CaptureLookup => {
-  const captures = MutableRef.make<ReadonlyArray<NodeCapture>>([])
-  return {
-    get captures() {
-      return MutableRef.get(captures)
-    },
-    record: (ref, capture) => {
-      MutableRef.update(captures, (current) => [...current, { ref, capture }])
-    },
-    reset: () => {
-      MutableRef.set(captures, [])
-    },
-  }
-}
-
-const sameSlotInstance = (expected: SlotInstanceRef, actual: SlotInstanceRef): boolean =>
-  expected.name === actual.name &&
-  Option.match(expected.key, {
-    onNone: () => expected.index === actual.index,
-    onSome: (key) =>
-      expected.keyOccurrence === actual.keyOccurrence && Option.contains(actual.key, key),
-  })
-
-const sameNodeRef = (expected: NodeRef, actual: NodeRef): boolean =>
-  expected.name === actual.name &&
-  Option.match(expected.parent, {
-    onNone: () => Option.isNone(actual.parent) && Option.isNone(actual.slot),
-    onSome: (expectedParent) =>
-      Option.isSome(actual.parent) &&
-      Option.isSome(expected.slot) &&
-      Option.isSome(actual.slot) &&
-      sameNodeRef(expectedParent, actual.parent.value) &&
-      sameSlotInstance(expected.slot.value, actual.slot.value),
-  })
-
-const rootRef = (root: AnyComposition): NodeRef => ({
-  name: uiNameOf(root),
-  parent: Option.none(),
-  slot: Option.none(),
-})
-
-const nodeCaptureFor = (lookup: CaptureLookup, ref: NodeRef): Option.Option<CapturedRender> =>
-  Option.map(
-    Arr.findFirst(lookup.captures, (entry) => sameNodeRef(ref, entry.ref)),
-    (entry) => entry.capture,
-  )
-
-const slotCapturesFor = (
-  lookup: CaptureLookup,
-  parent: NodeRef,
-  slotName: string,
-): ReadonlyArray<NodeCapture> =>
-  lookup.captures.filter(
-    (entry) =>
-      Option.isSome(entry.ref.parent) &&
-      Option.isSome(entry.ref.slot) &&
-      sameNodeRef(parent, entry.ref.parent.value) &&
-      entry.ref.slot.value.name === slotName,
-  )
-
-interface SettleProgress {
-  readonly previous: string
-  readonly remaining: number
-  readonly stable: boolean
-}
-
-const ensureSettled = (progress: SettleProgress): Effect.Effect<void, never, never> => {
-  if (progress.stable) {
-    return Effect.void
-  }
-  return Effect.dieMessage(`reform-proof: tree did not settle after ${SETTLE_MAX_RENDERS} renders`)
-}
-
-interface PumpStep {
-  readonly input: unknown
-  readonly index: number
-}
-
-const childComposition = (child: AnySlotChild): AnyComposition =>
-  isFeatureBinding(child) ? child.capture<AnyComposition>((binding) => binding.composition) : child
-
-const isUnknownRecord = (candidate: unknown): candidate is Record<string, unknown> =>
-  typeof candidate === 'object' && candidate !== null && !Array.isArray(candidate)
-
-const slotsOf = (comp: AnyComposition): Record<string, AnySlot> =>
-  comp.capture<Record<string, AnySlot>>((exact) => {
-    if (!('slots' in exact.manifest)) {
-      return {}
-    }
-    const candidate: unknown = exact.manifest.slots
-    if (!isUnknownRecord(candidate)) {
-      return {}
-    }
-    return Rec.fromEntries(
-      Rec.toEntries(candidate).flatMap(
-        ([name, slotDefinition]): ReadonlyArray<readonly [string, AnySlot]> =>
-          isSlot(slotDefinition) ? [[name, slotDefinition]] : [],
-      ),
-    )
-  })
-
-interface RuntimeSlotRead {
-  readonly runtime: RenderRuntime
-  readonly slotDefinition: AnySlot
-  readonly parent: AnyComposition
-}
-
-const readRuntimeSlotChild = ({ runtime, slotDefinition, parent }: RuntimeSlotRead): AnySlotChild =>
-  slotDefinition.capture<AnySlotChild>((exact) =>
-    Option.match(runtime.readOption(exact.provider), {
-      onNone: () =>
-        Effect.runSync(
-          Effect.dieMessage(`reform-proof: slot provider missing in ${uiNameOf(parent)}`),
-        ),
-      onSome: (child) => child,
-    }),
-  )
-
-// UiContract erases per-slot fill types here, so recover them by discriminant.
-const isSlotFill = (candidate: unknown): candidate is SlotFill<unknown> =>
-  typeof candidate === 'object' &&
-  candidate !== null &&
-  '_tag' in candidate &&
-  (candidate._tag === 'Each' || candidate._tag === 'One' || candidate._tag === 'Absent')
-
-const structureFills = (structure: Structure<UiContract>): Record<string, SlotFill<unknown>> =>
-  Rec.fromEntries(
-    Rec.toEntries(structure.slots).flatMap(
-      ([slotName, fillValue]): ReadonlyArray<readonly [string, SlotFill<unknown>]> =>
-        isSlotFill(fillValue) ? [[slotName, fillValue]] : [],
-    ),
-  )
-
-const enqueueFill = (
-  parent: NodeRef,
-  slotName: string,
-  fill: SlotFill<unknown>,
-  child: AnyComposition,
-): ReadonlyArray<Mounted> =>
-  Match.value(fill).pipe(
-    Match.when({ _tag: 'Each' }, (each) =>
-      each.items.map((entry, index) => ({
-        comp: child,
-        props: entry.props,
-        ref: {
-          name: uiNameOf(child),
-          parent: Option.some(parent),
-          slot: Option.some({
-            name: slotName,
-            index,
-            key: Option.some(entry.key),
-            keyOccurrence: each.items
-              .slice(0, index)
-              .filter((candidate) => candidate.key === entry.key).length,
-          }),
-        },
-      })),
-    ),
-    Match.when({ _tag: 'One' }, (oneFill) => [
-      {
-        comp: child,
-        props: oneFill.props,
-        ref: {
-          name: uiNameOf(child),
-          parent: Option.some(parent),
-          slot: Option.some({
-            name: slotName,
-            index: 0,
-            key: Option.some(`${slotName}.0`),
-            keyOccurrence: 0,
-          }),
-        },
-      },
-    ]),
-    Match.when({ _tag: 'Absent' }, () => []),
-    Match.exhaustive,
-  )
-
-const driveStructure = (
-  comp: AnyComposition,
-  structure: Structure<UiContract>,
-  ref: NodeRef,
-  sink: Sink,
-  lookup: CaptureLookup,
-  bindings: ReadonlyMap<AnySlot, AnyComposition>,
-): ReadonlyArray<Mounted> => {
-  const key = Option.flatMap(ref.slot, (instance) => instance.key)
-  const capture: CapturedRender = {
-    name: uiNameOf(comp),
-    props: structure.props,
-    events: eventsOf(structure),
-    ...(Option.isSome(key) ? { key: key.value } : {}),
-  }
-  sink.api.record(capture)
-  lookup.record(ref, capture)
-  const fills = structureFills(structure)
-  return Rec.toEntries(slotsOf(comp)).flatMap(([slotName, slotClass]) => {
-    const child = bindings.get(slotClass)
-    const fill = fills[slotName]
-    return child === undefined || fill === undefined ? [] : enqueueFill(ref, slotName, fill, child)
-  })
-}
-
-const fingerprint = (lookup: CaptureLookup): string =>
-  formatFingerprint(lookup.captures.map(({ ref, capture }) => [ref, capture.props]))
-
-export function makeFacade<
-  C extends UiContract,
-  S extends ReadonlyArray<unknown>,
-  Services,
-  P,
-  N extends string,
-  Identity,
->(
-  runtime: ManagedRuntime.ManagedRuntime<Services | CaptureSink, never>,
-  scene: CapturedScene<C, S, Services, P, N, Identity>,
-  sink: Sink,
-  dispatched: Set<string>,
-): {
-  readonly facade: Facade<C, never>
-  readonly settle: Effect.Effect<void, never, never>
-} {
-  const context = runtime.runSync(Effect.context<Services | CaptureSink>())
-  return makeMountedFacade(
-    renderRuntimeFromContext(context, sink.instrumentation),
-    scene.composition,
-    sink,
-    dispatched,
-    (settlement) => Effect.promise(() => runtime.runPromise(settlement)),
-  )
-}
-
-const collectRuntimeBindings = (
-  root: AnyComposition,
-  runtime: RenderRuntime,
-): Map<AnySlot, AnyComposition> => {
-  const bindings = new Map<AnySlot, AnyComposition>()
-  const walk = (comp: AnyComposition): void => {
-    Rec.values(slotsOf(comp)).forEach((slotClass) => {
-      if (bindings.has(slotClass)) {
-        return
-      }
-      const child = childComposition(
-        readRuntimeSlotChild({
-          runtime,
-          slotDefinition: slotClass,
-          parent: comp,
-        }),
-      )
-      bindings.set(slotClass, child)
-      walk(child)
-    })
-  }
-  walk(root)
-  return bindings
-}
-
-const renderMountedRuntime = (
-  runtime: RenderRuntime,
-  mounted: Mounted,
-  bindings: ReadonlyMap<AnySlot, AnyComposition>,
-  sink: Sink,
-  lookup: CaptureLookup,
-): ReadonlyArray<Mounted> => {
-  const endRenderSpan = sink.instrumentation.uiRendered(uiNameOf(mounted.comp))
-  const frame = renderCompositionRuntime(runtime, mounted.comp, mounted.props)
-  endRenderSpan()
-  return driveStructure(mounted.comp, frame, mounted.ref, sink, lookup, bindings)
-}
-
-const renderLevelRuntime = (
-  runtime: RenderRuntime,
-  frontier: ReadonlyArray<Mounted>,
-  bindings: ReadonlyMap<AnySlot, AnyComposition>,
-  sink: Sink,
-  lookup: CaptureLookup,
-): void => {
-  if (frontier.length === 0) {
-    return
-  }
-  const levels = frontier.map((mounted) =>
-    renderMountedRuntime(runtime, mounted, bindings, sink, lookup),
-  )
-  renderLevelRuntime(runtime, levels.flat(), bindings, sink, lookup)
-}
-
-const renderTreeRuntime = (
-  runtime: RenderRuntime,
-  root: AnyComposition,
-  bindings: ReadonlyMap<AnySlot, AnyComposition>,
-  sink: Sink,
-  lookup: CaptureLookup,
-): Effect.Effect<void, never, never> =>
-  Effect.sync(() => {
-    sink.reset()
-    lookup.reset()
-    renderLevelRuntime(
-      runtime,
-      [{ comp: root, props: {}, ref: rootRef(root) }],
-      bindings,
-      sink,
-      lookup,
-    )
-  })
-
-const settleTreeRuntime = Effect.fn('settleTreeRuntime')(function* (
-  runtime: RenderRuntime,
-  root: AnyComposition,
-  bindings: ReadonlyMap<AnySlot, AnyComposition>,
-  sink: Sink,
-  lookup: CaptureLookup,
-): Effect.fn.Return<void, never, never> {
-  yield* settleDrain
-  yield* renderTreeRuntime(runtime, root, bindings, sink, lookup)
-  const progress = yield* Effect.iterate(
-    {
-      previous: fingerprint(lookup),
-      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, lookup)
-          const current = fingerprint(lookup)
-          return {
-            previous: current,
-            remaining: progress.remaining - 1,
-            stable: current === progress.previous,
-          }
-        }),
-    },
-  )
-  yield* ensureSettled(progress)
-})
-
-function makeMountedFacade<
-  P,
-  C extends UiContract,
-  S extends ReadonlyArray<unknown>,
-  N extends string,
-  Identity,
->(
-  runtime: RenderRuntime,
-  root: CompositionClass<P, C, S, N, Identity>,
-  sink: Sink,
-  dispatched: Set<string>,
-  settleBoundary: SettleBoundary,
-): {
-  readonly facade: MountedFacade<C>
-  readonly settle: Effect.Effect<void, never, never>
-}
-function makeMountedFacade(
-  runtime: RenderRuntime,
-  root: AnyComposition,
-  sink: Sink,
-  dispatched: Set<string>,
-  settleBoundary: SettleBoundary,
-): MountedFacadeHandleErasure
-function makeMountedFacade(
-  runtime: RenderRuntime,
-  root: AnyComposition,
-  sink: Sink,
-  dispatched: Set<string>,
-  settleBoundary: SettleBoundary,
-): MountedFacadeHandleErasure {
-  const bindings = collectRuntimeBindings(root, runtime)
-  const lookup = makeCaptureLookup()
-  const settle = settleBoundary(settleTreeRuntime(runtime, root, bindings, sink, lookup))
-  const rerender = renderTreeRuntime(runtime, root, bindings, sink, lookup)
-
-  const triggerOf = (ref: NodeRef, event: string): Effect.Effect<Trigger<unknown>, never, never> =>
-    Option.match(
-      Option.flatMap(nodeCaptureFor(lookup, ref), (capture) =>
-        Option.fromNullable(capture.events[event]),
-      ),
-      {
-        onNone: () =>
-          Effect.dieMessage(
-            new UnknownAction({
-              composition: ref.name,
-              action: event,
-              rendered: lookup.captures.filter((entry) => entry.ref.name === ref.name).length,
-            }).message,
-          ),
-        onSome: Effect.succeed,
-      },
-    )
-
-  const propsFor = (ref: NodeRef): Effect.Effect<unknown, never, never> =>
-    Effect.map(rerender, () =>
-      Option.match(nodeCaptureFor(lookup, ref), {
-        onNone: () => undefined,
-        onSome: (capture) => capture.props,
-      }),
-    )
-
-  const nodeFacade = (ref: NodeRef, comp: AnyComposition): MountedFacadeErasure => ({
-    props: propsFor(ref),
-    expectProps: (partial) =>
-      propsFor(ref).pipe(
-        Effect.flatMap((props) => expectMatchingProps({ actual: props, expected: partial })),
-      ),
-    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(ref, comp, slotName)),
-    frame: settle,
-  })
-
-  const slotFacade = (
-    parentRef: NodeRef,
-    parent: AnyComposition,
-    slotName: string,
-  ): MountedSlotFacadeErasure => {
-    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 childRefAt = (index: number): NodeRef =>
-      slotCapturesFor(lookup, parentRef, slotName)[index]?.ref ?? {
-        name: childName,
-        parent: Option.some(parentRef),
-        slot: Option.some({
-          name: slotName,
-          index,
-          key: Option.none(),
-          keyOccurrence: 0,
-        }),
-      }
-    const atIndex = (index: number): Effect.Effect<MountedFacadeErasure, never, never> =>
-      Effect.as(rerender, nodeFacade(childRefAt(index), child))
-    const first = nodeFacade(childRefAt(0), child)
-    return {
-      first: atIndex(0),
-      at: atIndex,
-      all: Effect.map(rerender, () =>
-        slotCapturesFor(lookup, parentRef, slotName).map((entry) => nodeFacade(entry.ref, child)),
-      ),
-      byKey: (key) =>
-        Effect.flatMap(rerender, () =>
-          Option.match(
-            Arr.findFirst(
-              slotCapturesFor(lookup, parentRef, slotName),
-              (entry) => entry.capture.key === key,
-            ),
-            {
-              onNone: () =>
-                Effect.dieMessage(
-                  new UnknownSlot({
-                    parent: uiNameOf(parent),
-                    slot: `${slotName}[key=${key}]`,
-                  }).message,
-                ),
-              onSome: (entry) => Effect.succeed(nodeFacade(entry.ref, child)),
-            },
-          ),
-        ),
-      where: (predicate) =>
-        Effect.map(rerender, () =>
-          slotCapturesFor(lookup, parentRef, slotName).flatMap((entry) =>
-            predicate(entry.capture.props) ? [nodeFacade(entry.ref, child)] : [],
-          ),
-        ),
-      count: Effect.map(rerender, () => slotCapturesFor(lookup, parentRef, slotName).length),
-      props: first.props,
-      expectProps: first.expectProps,
-      actions: first.actions,
-      slots: first.slots,
-      frame: first.frame,
-    }
-  }
-
-  return {
-    facade: nodeFacade(rootRef(root), root),
-    settle,
-  }
-}
-
-export const makeProofFacade = <
-  C extends UiContract,
-  S extends ReadonlyArray<unknown>,
-  Services,
-  P,
-  N extends string,
-  Identity,
->(
-  runtime: ManagedRuntime.ManagedRuntime<Services | CaptureSink, never>,
-  scene: CapturedScene<C, S, Services, P, N, Identity>,
-  sink: Sink,
-  dispatched: Set<string>,
-): {
-  readonly facade: Facade<C, never>
-  readonly settle: Effect.Effect<void, never, never>
-} => {
-  return makeFacade(runtime, scene, sink, dispatched)
-}
-
-export const makeRuntimeHandleFacade = <
-  Services,
-  RootIdentifier extends NoInfer<Services>,
-  P,
-  C extends UiContract,
-  S extends ReadonlyArray<unknown>,
-  N extends string,
-  Identity,
->(
-  runtime: RuntimeHandle<Services>,
-  root: RuntimeRootComposition<RootIdentifier, P, C, S, N, Identity>,
-  sink: Sink,
-  dispatched: Set<string>,
-): {
-  readonly facade: MountedFacade<C>
-  readonly settle: Effect.Effect<void, never, never>
-} => makeMountedFacade(runtime, root, sink, dispatched, directSettle)
-
-type FeatureMountState =
-  | { readonly _tag: 'Loading' }
-  | { readonly _tag: 'Live'; readonly runtime: HostRuntime }
-  | { readonly _tag: 'Failed'; readonly error: FeatureLoadFailed }
-
-interface TreeFeatureMount {
-  readonly id: string
-  readonly binding: AnyFeatureBinding
-  readonly parent: HostRuntime
-  readonly depth: number
-  readonly props: unknown
-  attempt: number
-  state: FeatureMountState
-  dispose: () => void
-}
-
-interface TreeNode {
-  readonly path: string
-  readonly depth: number
-  readonly key: Option.Option<string>
-  readonly comp: AnyComposition
-  readonly props: unknown
-  readonly events: Record<string, Trigger<unknown>>
-  readonly slots: Readonly<Record<string, ReadonlyArray<TreeNode>>>
-}
-
-interface TreeRenderState {
-  readonly root: TreeNode
-  readonly fingerprint: string
-}
-
-export interface RuntimeTreeFacade<C extends UiContract> {
-  readonly facade: MountedFacade<C>
-  readonly settle: Effect.Effect<void, never, never>
-  dispose(): void
-}
-
-interface RuntimeTreeFacadeErasure extends MountedFacadeHandleErasure {
-  dispose(): void
-}
-
-interface TreeDriver {
-  readonly render: () => TreeRenderState
-  readonly settle: Effect.Effect<void, never, never>
-  readonly dispose: () => void
-}
-
-interface MountIdentityInput {
-  readonly parent: HostRuntime
-  readonly parentPath: string
-  readonly slotName: string
-  readonly key: string
-  readonly binding: AnyFeatureBinding
-}
-
-interface FeatureRecordInput {
-  readonly id: string
-  readonly parent: HostRuntime
-  readonly binding: AnyFeatureBinding
-  readonly depth: number
-  readonly props: unknown
-}
-
-interface RenderCompositionInput {
-  readonly runtime: HostRuntime
-  readonly comp: AnyComposition
-  readonly props: unknown
-  readonly key: Option.Option<string>
-  readonly path: string
-  readonly depth: number
-  readonly seen: Set<string>
-  readonly mountMissing: boolean
-}
-
-const encodeIdentityPart = (part: string): string => `${part.length}:${part}`
-
-const fillEntries = (
-  slotName: string,
-  fill: SlotFill<unknown>,
-): ReadonlyArray<{ readonly key: string; readonly props: unknown }> =>
-  Match.value(fill).pipe(
-    Match.when({ _tag: 'Each' }, (each) => each.items),
-    Match.when({ _tag: 'One' }, (oneFill) => [{ key: `${slotName}.0`, props: oneFill.props }]),
-    Match.when({ _tag: 'Absent' }, () => []),
-    Match.exhaustive,
-  )
-
-const treeFingerprint = (node: TreeNode): unknown => [
-  uiNameOf(node.comp),
-  node.key,
-  node.props,
-  Rec.map(node.slots, (children) => children.map(treeFingerprint)),
-]
-
-const makeTreeDriver = (
-  runtime: HostRuntime,
-  root: AnyComposition,
-  rootProps: unknown,
-  sink: Sink,
-): TreeDriver => {
-  const mounts = new Map<string, TreeFeatureMount>()
-  const runtimeIds = new WeakMap<HostRuntime, number>()
-  const bindingIds = new WeakMap<object, number>()
-  const sequence = { runtime: 0, binding: 0 }
-  const status = { disposed: false }
-
-  const identity = <Subject extends object>(
-    identities: WeakMap<Subject, number>,
-    subject: Subject,
-    next: () => number,
-  ): number => {
-    const current = identities.get(subject)
-    if (current !== undefined) {
-      return current
-    }
-    const created = next()
-    identities.set(subject, created)
-    return created
-  }
-
-  const mountId = ({ parent, parentPath, slotName, key, binding }: MountIdentityInput): string => {
-    const runtimeId = identity(runtimeIds, parent, () => ++sequence.runtime)
-    const bindingId = identity(bindingIds, binding, () => ++sequence.binding)
-    return [String(runtimeId), parentPath, slotName, String(bindingId), key]
-      .map(encodeIdentityPart)
-      .join('')
-  }
-
-  const startMount = (record: TreeFeatureMount): void => {
-    record.attempt += 1
-    const attempt = record.attempt
-    record.binding.capture<void>((binding) => {
-      if (binding.strategy === 'default') {
-        record.state = { _tag: 'Live', runtime: record.parent }
-        binding.boot.forEach((event) => record.parent.dispatch('High', event))
-        record.dispose = () => {}
-        return
-      }
-      record.state = { _tag: 'Loading' }
-      record.dispose = record.parent.mountAnyFeature(binding, {
-        props: record.props,
-        onLive: (childRuntime) => {
-          if (status.disposed || record.attempt !== attempt || mounts.get(record.id) !== record) {
-            return
-          }
-          record.state = { _tag: 'Live', runtime: childRuntime }
-        },
-        onFailed: (error) => {
-          if (status.disposed || record.attempt !== attempt || mounts.get(record.id) !== record) {
-            return
-          }
-          record.state = { _tag: 'Failed', error }
-        },
-      })
-    })
-  }
-
-  const retryMount = (record: TreeFeatureMount): void => {
-    if (status.disposed || mounts.get(record.id) !== record || record.state._tag !== 'Failed') {
-      return
-    }
-    record.dispose()
-    startMount(record)
-  }
-
-  const featureRecord = ({
-    id,
-    parent,
-    binding,
-    depth,
-    props,
-  }: FeatureRecordInput): TreeFeatureMount => {
-    const current = mounts.get(id)
-    if (current !== undefined && current.binding === binding && current.parent === parent) {
-      return current
-    }
-    if (current !== undefined) {
-      current.attempt += 1
-      current.dispose()
-    }
-    const created: TreeFeatureMount = {
-      id,
-      binding,
-      parent,
-      depth,
-      props,
-      attempt: 0,
-      state: { _tag: 'Loading' },
-      dispose: () => {},
-    }
-    mounts.set(id, created)
-    startMount(created)
-    return created
-  }
-  const featureRecordForRender = (
-    input: FeatureRecordInput,
-    mountMissing: boolean,
-  ): TreeFeatureMount | undefined => {
-    const current = mounts.get(input.id)
-    if (current !== undefined || !mountMissing) {
-      return current
-    }
-    return featureRecord(input)
-  }
-
-  const renderComposition = ({
-    runtime: currentRuntime,
-    comp,
-    props,
-    key,
-    path,
-    depth,
-    seen,
-    mountMissing,
-  }: RenderCompositionInput): TreeNode => {
-    const endRenderSpan = sink.instrumentation.uiRendered(uiNameOf(comp))
-    const frame = renderCompositionRuntime(currentRuntime, comp, props)
-    endRenderSpan()
-    sink.api.record({
-      name: uiNameOf(comp),
-      props: frame.props,
-      events: eventsOf(frame),
-      ...(Option.isSome(key) ? { key: key.value } : {}),
-    })
-
-    const fills = structureFills(frame)
-    const renderedSlots = Rec.map(slotsOf(comp), (slotClass, slotName) => {
-      const fill = fills[slotName]
-      if (fill === undefined) {
-        return []
-      }
-      const child = readRuntimeSlotChild({
-        runtime: currentRuntime,
-        slotDefinition: slotClass,
-        parent: comp,
-      })
-      return fillEntries(slotName, fill).flatMap((entry) => {
-        const childPath = `${path}${encodeIdentityPart(slotName)}${encodeIdentityPart(entry.key)}`
-        if (!isFeatureBinding(child)) {
-          return [
-            renderComposition({
-              runtime: currentRuntime,
-              comp: child,
-              props: entry.props,
-              key: Option.some(entry.key),
-              path: childPath,
-              depth: depth + 1,
-              seen,
-              mountMissing,
-            }),
-          ]
-        }
-        const id = mountId({
-          parent: currentRuntime,
-          parentPath: path,
-          slotName,
-          key: entry.key,
-          binding: child,
-        })
-        seen.add(id)
-        const record = featureRecordForRender(
-          {
-            id,
-            parent: currentRuntime,
-            binding: child,
-            depth: depth + 1,
-            props: entry.props,
-          },
-          mountMissing,
-        )
-        if (record === undefined) {
-          return []
-        }
-        return child.capture<ReadonlyArray<TreeNode>>((binding) =>
-          Match.value(record.state).pipe(
-            Match.when({ _tag: 'Live' }, (live) => [
-              renderComposition({
-                runtime: live.runtime,
-                comp: binding.composition,
-                props: entry.props,
-                key: Option.some(entry.key),
-                path: childPath,
-                depth: depth + 1,
-                seen,
-                mountMissing,
-              }),
-            ]),
-            Match.when({ _tag: 'Failed' }, (failed) =>
-              Option.match(binding.placeholder, {
-                onNone: () => [],
-                onSome: (placeholder) => [
-                  renderComposition({
-                    runtime: currentRuntime,
-                    comp: placeholder.failed,
-                    props: {
-                      error: failed.error,
-                      retry: () => retryMount(record),
-                    },
-                    key: Option.some(entry.key),
-                    path: `${childPath}/failed`,
-                    depth: depth + 1,
-                    seen,
-                    mountMissing,
-                  }),
-                ],
-              }),
-            ),
-            Match.when({ _tag: 'Loading' }, () =>
-              Option.match(binding.placeholder, {
-                onNone: () => [],
-                onSome: (placeholder) => [
-                  renderComposition({
-                    runtime: currentRuntime,
-                    comp: placeholder.loading,
-                    props: entry.props,
-                    key: Option.some(entry.key),
-                    path: `${childPath}/loading`,
-                    depth: depth + 1,
-                    seen,
-                    mountMissing,
-                  }),
-                ],
-              }),
-            ),
-            Match.exhaustive,
-          ),
-        )
-      })
-    })
-
-    return {
-      path,
-      depth,
-      key,
-      comp,
-      props: frame.props,
-      events: eventsOf(frame),
-      slots: renderedSlots,
-    }
-  }
-
-  const disposeStale = (seen: ReadonlySet<string>): void => {
-    Arr.sortWith(
-      Array.from(mounts.values()).filter((record) => !seen.has(record.id)),
-      (record) => -record.depth,
-      Order.number,
-    ).forEach((record) => {
-      mounts.delete(record.id)
-      record.attempt += 1
-      record.dispose()
-    })
-  }
-
-  const render = (): TreeRenderState => {
-    // Discover the desired graph without acquiring missing Features, then release
-    // removed scopes deepest-first before the live pass mounts replacements.
-    sink.reset()
-    const retained = new Set<string>()
-    renderComposition({
-      runtime,
-      comp: root,
-      props: rootProps,
-      key: Option.none(),
-      path: 'root',
-      depth: 0,
-      seen: retained,
-      mountMissing: false,
-    })
-    disposeStale(retained)
-    sink.reset()
-    const seen = new Set<string>()
-    const rootNode = renderComposition({
-      runtime,
-      comp: root,
-      props: rootProps,
-      key: Option.none(),
-      path: 'root',
-      depth: 0,
-      seen,
-      mountMissing: true,
-    })
-    return {
-      root: rootNode,
-      fingerprint: formatFingerprint(treeFingerprint(rootNode)),
-    }
-  }
-
-  const settle = Effect.gen(function* () {
-    yield* settleDrain
-    const first = render()
-    const progress = yield* Effect.iterate(
-      {
-        previous: first.fingerprint,
-        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)
-            const current = render()
-            return {
-              previous: current.fingerprint,
-              remaining: progress.remaining - 1,
-              stable: current.fingerprint === progress.previous,
-            }
-          }),
-      },
-    )
-    yield* ensureSettled(progress)
-  })
-
-  const dispose = (): void => {
-    if (status.disposed) {
-      return
-    }
-    status.disposed = true
-    Arr.sortWith(Array.from(mounts.values()), (record) => -record.depth, Order.number).forEach(
-      (record) => {
-        record.attempt += 1
-        record.dispose()
-      },
-    )
-    mounts.clear()
-  }
-
-  return { render, settle, dispose }
-}
-
-export function makeRuntimeTreeFacade<
-  Services,
-  RootIdentifier extends NoInfer<Services>,
-  P,
-  C extends UiContract,
-  S extends ReadonlyArray<unknown>,
-  N extends string,
-  Identity,
->(
-  runtime: RuntimeHandle<Services>,
-  root: RuntimeRootComposition<RootIdentifier, P, C, S, N, Identity>,
-  rootProps: P,
-  sink: Sink,
-  dispatched: Set<string>,
-): RuntimeTreeFacade<C>
-export function makeRuntimeTreeFacade(
-  runtime: HostRuntime,
-  root: AnyComposition,
-  rootProps: unknown,
-  sink: Sink,
-  dispatched: Set<string>,
-): RuntimeTreeFacadeErasure {
-  const driver = makeTreeDriver(runtime, root, rootProps, sink)
-  const currentRoot = (): TreeNode => driver.render().root
-
-  // `peek` is the non-dying half of `resolve`: None once the node has left the
-  // tree, so an action that removed its own node can still report a result.
-  const nodeFacade = (
-    resolve: () => TreeNode,
-    peek: () => Option.Option<TreeNode>,
-  ): MountedFacadeErasure => ({
-    props: Effect.sync(() => resolve().props),
-    expectProps: (partial) =>
-      Effect.sync(() => {
-        const mismatch = matchProps({
-          actual: resolve().props,
-          expected: partial,
-        })
-        if (mismatch !== undefined) {
-          return Effect.runSync(
-            Effect.dieMessage(new AssertionFailed({ detail: mismatch }).message),
-          )
-        }
-      }),
-    actions: keyed(
-      (event) => (payload: unknown) =>
-        Effect.gen(function* () {
-          const node = resolve()
-          const trigger = node.events[event]
-          if (trigger === undefined) {
-            return yield* Effect.dieMessage(
-              new UnknownAction({
-                composition: uiNameOf(node.comp),
-                action: event,
-                rendered: 1,
-              }).message,
-            )
-          }
-          dispatched.add(event)
-          trigger(payload)
-          yield* driver.settle
-          // A self-removing action leaves nothing to re-read; report what the
-          // node last rendered instead of dying on the vanished child.
-          return Option.match(peek(), {
-            onNone: () => node.props,
-            onSome: (settled) => settled.props,
-          })
-        }),
-    ),
-    slots: keyed((slotName) => slotFacade(resolve, slotName)),
-    frame: driver.settle,
-  })
-
-  const slotFacade = (
-    resolveParent: () => TreeNode,
-    slotName: string,
-  ): MountedSlotFacadeErasure => {
-    const children = (): ReadonlyArray<TreeNode> => {
-      const parent = resolveParent()
-      const resolved = parent.slots[slotName]
-      if (resolved === undefined) {
-        return Effect.runSync(
-          Effect.dieMessage(
-            new UnknownSlot({ parent: uiNameOf(parent.comp), slot: slotName }).message,
-          ),
-        )
-      }
-      return resolved
-    }
-    const peekAt = (index: number): Option.Option<TreeNode> =>
-      Option.fromNullable(children()[index])
-    const peekByKey = (key: string): Option.Option<TreeNode> =>
-      Arr.findFirst(children(), (candidate) => Option.contains(candidate.key, key))
-    const childAt = (index: number): MountedFacadeErasure =>
-      nodeFacade(
-        () => children()[index] ?? missingChild(index),
-        () => peekAt(index),
-      )
-    const childByKey = (key: string): MountedFacadeErasure =>
-      nodeFacade(
-        () => Option.getOrElse(peekByKey(key), () => missingKey(key)),
-        () => peekByKey(key),
-      )
-    const missingChild = (index: number): never => {
-      const parent = resolveParent()
-      return Effect.runSync(
-        Effect.dieMessage(
-          new UnknownSlot({
-            parent: uiNameOf(parent.comp),
-            slot: `${slotName}[${index}]`,
-          }).message,
-        ),
-      )
-    }
-    const missingKey = (key: string): never => {
-      const parent = resolveParent()
-      return Effect.runSync(
-        Effect.dieMessage(
-          new UnknownSlot({
-            parent: uiNameOf(parent.comp),
-            slot: `${slotName}[key=${key}]`,
-          }).message,
-        ),
-      )
-    }
-    const first = childAt(0)
-    return {
-      first: Effect.sync(() => childAt(0)),
-      at: (index) => Effect.sync(() => childAt(index)),
-      all: Effect.sync(() => children().map((_child, index) => childAt(index))),
-      byKey: (key) =>
-        Effect.sync(() => {
-          const child = Arr.findFirst(children(), (candidate) =>
-            Option.contains(candidate.key, key),
-          )
-          return Option.isNone(child) ? missingKey(key) : childByKey(key)
-        }),
-      where: (predicate) =>
-        Effect.sync(() =>
-          children().flatMap((child, index) => (predicate(child.props) ? [childAt(index)] : [])),
-        ),
-      count: Effect.sync(() => children().length),
-      props: first.props,
-      expectProps: first.expectProps,
-      actions: first.actions,
-      slots: first.slots,
-      frame: driver.settle,
-    }
-  }
-
-  return {
-    facade: nodeFacade(currentRoot, () => Option.some(currentRoot())),
-    settle: driver.settle,
-    dispose: driver.dispose,
-  }
-}
+  invalidCompositionProps,
+  type HostRuntime,
+  makeSink,
+  messageOf,
+  type RenderRuntime,
+  type Sink,
+} from './engineSink'
+import { childComposition, readRuntimeSlotChild, slotsOf } from './engineTree'
+import type { RuntimeTreeFacade } from './engineTreeTypes'
+import { makeRuntimeTreeFacade } from './engineTreeFacade'
+import type { ProofCase, ProofResult } from './proofCase'
+import type { PumpStep } from './engineTree'
+import type { DriveResult, StepFrame } from './index'
+import type { ProductComposition } from './product'
+import type { Proof } from './index'
+
+export { makeSink } from './engineSink'
+export type { Sink } from './engineSink'
+export { proofLayer } from './engineTree'
+export { makeFacade, makeProofFacade, makeRuntimeHandleFacade } from './engineMounted'
+export type {
+  MountedFacade,
+  MountedSlotFacade,
+  MountedSlotFacadesOf,
+} from './engineSink'
+export { makeRuntimeTreeFacade } from './engineTreeFacade'
+export type { RuntimeTreeFacade } from './engineTreeTypes'
 
 const proofRootProps = <
   P,
@@ -1655,3 +282,4 @@ export const driveProofEffect = (proof: Proof): Effect.Effect<DriveResult, never
 
 export const driveProof = (proof: Proof): Promise<DriveResult> =>
   Effect.runPromise(driveProofEffect(proof))
+