@playfast/reform-proof 1.1.1 → 1.2.1

package/src/runtimeTreeDispose.ts

@@ -1,21 +0,0 @@
-import { Array as Arr, Order } from 'effect'
-import type { TreeFeatureMount } from './runtimeTreeTypes'
-
-interface DisposeTreeMountsOptions {
-  readonly status: { disposed: boolean }
-  readonly mounts: Map<string, TreeFeatureMount>
-}
-
-export const disposeTreeMounts = ({ status, mounts }: DisposeTreeMountsOptions): 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()
-}

package/src/runtimeTreeDriver.ts

@@ -1,285 +0,0 @@
-import { Array as Arr, Effect, Match, Option, Order, Record as Rec, Schema as S } from 'effect'
-import {
-  Composition,
-  type CompositionClass,
-  isFeatureBinding,
-  isStructure,
-  type RenderEnv,
-  type RuntimeHandle,
-} from '@playfast/reform'
-import { eventsOf, type Sink, uiNameOf } from './sink'
-import { slotsOf, structureFills } from './treeBindings'
-import { disposeTreeMounts } from './runtimeTreeDispose'
-import { makeTreeSettle } from './runtimeTreeSettle'
-import {
-  encodeIdentityPart,
-  type FeatureRecordInput,
-  fillEntries,
-  type MountIdentityInput,
-  type RenderCompositionInput,
-  type TreeDriver,
-  type TreeFeatureMount,
-  type TreeNode,
-  type TreeRenderState,
-  treeFingerprint,
-} from './runtimeTreeTypes'
-
-const encodeUnknown = S.encodeSync(S.parseJson(S.Unknown))
-
-export const makeTreeDriver = (
-  runtime: RuntimeHandle,
-  root: CompositionClass<unknown>,
-  sink: Sink,
-): TreeDriver => {
-  const mounts = new Map<string, TreeFeatureMount>()
-  const runtimeIds = new WeakMap<RuntimeHandle, number>()
-  const bindingIds = new WeakMap<object, number>()
-  const sequence = { runtime: 0, binding: 0 }
-  const status = { disposed: false }
-
-  const identity = (
-    identities: WeakMap<object, number>,
-    subject: object,
-    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
-    if (record.binding.strategy === 'default') {
-      record.state = { _tag: 'Live', runtime: record.parent }
-      record.binding.boot.forEach((event) => record.parent.dispatch('High', event))
-      record.dispose = () => {}
-      return
-    }
-    record.state = { _tag: 'Loading' }
-    record.dispose = record.parent.mountFeature(record.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 renderComposition = ({
-    runtime: currentRuntime,
-    comp,
-    props,
-    key,
-    path,
-    depth,
-    seen,
-  }: RenderCompositionInput): TreeNode => {
-    const service = currentRuntime.read(comp.tag)
-    const env: RenderEnv = { props, tracker: { add: () => {} } }
-    const endRenderSpan = sink.instrumentation.uiRendered(uiNameOf(comp))
-    const frame = Effect.runSync(Composition.render(service, env))
-    endRenderSpan()
-    if (!isStructure(frame)) {
-      return Effect.runSync(
-        Effect.dieMessage(`reform-proof: composition ${uiNameOf(comp)} did not return a Structure`),
-      )
-    }
-    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 = currentRuntime.read(slotClass.tag)
-      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,
-            }),
-          ]
-        }
-        const id = mountId({
-          parent: currentRuntime,
-          parentPath: path,
-          slotName,
-          key: entry.key,
-          binding: child,
-        })
-        seen.add(id)
-        const record = featureRecord({
-          id,
-          parent: currentRuntime,
-          binding: child,
-          depth: depth + 1,
-          props: entry.props,
-        })
-        return Match.value(record.state).pipe(
-          Match.when({ _tag: 'Live' }, (live) => [
-            renderComposition({
-              runtime: live.runtime,
-              comp: child.composition,
-              props: entry.props,
-              key: Option.some(entry.key),
-              path: childPath,
-              depth: depth + 1,
-              seen,
-            }),
-          ]),
-          Match.when({ _tag: 'Failed' }, (failed) => {
-            if (child.placeholder === undefined) {
-              return []
-            }
-            return [
-              renderComposition({
-                runtime: currentRuntime,
-                comp: child.placeholder.failed,
-                props: { error: failed.error, retry: () => retryMount(record) },
-                key: Option.some(entry.key),
-                path: `${childPath}/failed`,
-                depth: depth + 1,
-                seen,
-              }),
-            ]
-          }),
-          Match.when({ _tag: 'Loading' }, () => {
-            if (child.placeholder === undefined) {
-              return []
-            }
-            return [
-              renderComposition({
-                runtime: currentRuntime,
-                comp: child.placeholder.loading,
-                props: entry.props,
-                key: Option.some(entry.key),
-                path: `${childPath}/loading`,
-                depth: depth + 1,
-                seen,
-              }),
-            ]
-          }),
-          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 => {
-    sink.reset()
-    const seen = new Set<string>()
-    const rootNode = renderComposition({
-      runtime,
-      comp: root,
-      props: {},
-      key: Option.none(),
-      path: 'root',
-      depth: 0,
-      seen,
-    })
-    disposeStale(seen)
-    return {
-      root: rootNode,
-      fingerprint: encodeUnknown(treeFingerprint(rootNode)),
-    }
-  }
-
-  const settle = makeTreeSettle(render)
-  const dispose = (): void => disposeTreeMounts({ status, mounts })
-
-  return { render, settle, dispose }
-}

package/src/runtimeTreeFacade.ts

@@ -1,134 +0,0 @@
-import { Array as Arr, Effect, Option } from 'effect'
-import type { CompositionClass, RuntimeHandle } from '@playfast/reform'
-import { AssertionFailed, UnknownAction, UnknownSlot } from './errors'
-import { matchProps } from './assertions'
-import { makeTreeDriver } from './runtimeTreeDriver'
-import type { RuntimeTreeFacade, TreeNode } from './runtimeTreeTypes'
-import { keyed, type Sink, uiNameOf } from './sink'
-import type { MountedFacade, MountedSlotFacade } from './runtimeFacade'
-
-export type { RuntimeTreeFacade } from './runtimeTreeTypes'
-
-export const makeRuntimeTreeFacade = (
-  runtime: RuntimeHandle,
-  root: CompositionClass<unknown>,
-  sink: Sink,
-  dispatched: Set<string>,
-): RuntimeTreeFacade => {
-  const driver = makeTreeDriver(runtime, root, sink)
-  const currentRoot = (): TreeNode => driver.render().root
-
-  const nodeFacade = (resolve: () => TreeNode): MountedFacade => ({
-    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
-          return resolve().props
-        }),
-    ),
-    slots: keyed((slotName) => slotFacade(resolve, slotName)),
-    frame: driver.settle,
-  })
-
-  const slotFacade = (resolveParent: () => TreeNode, slotName: string): MountedSlotFacade => {
-    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 childAt = (index: number): MountedFacade =>
-      nodeFacade(() => children()[index] ?? missingChild(index))
-    const childByKey = (key: string): MountedFacade =>
-      nodeFacade(() => {
-        return Option.getOrElse(
-          Arr.findFirst(children(), (candidate) => Option.contains(candidate.key, key)),
-          () => missingKey(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),
-    settle: driver.settle,
-    dispose: driver.dispose,
-  }
-}
-

package/src/runtimeTreeSettle.ts

@@ -1,34 +0,0 @@
-import { Effect } from 'effect'
-import { SETTLE_MAX_RENDERS, SETTLE_STEP, settleDrain } from './sink'
-import type { SettleProgress } from './treeBindings'
-import type { TreeRenderState } from './runtimeTreeTypes'
-
-export const makeTreeSettle: (
-  render: () => TreeRenderState,
-) => Effect.Effect<void, never, never> = Effect.fn('makeTreeSettle')(function* (
-  render: () => TreeRenderState,
-): Effect.fn.Return<void, never, never> {
-    yield* settleDrain
-    const first = render()
-    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,
-            }
-          }),
-      },
-    )
-})

package/src/sink.ts

@@ -1,73 +0,0 @@
-import { Effect, Layer, MutableRef } from 'effect'
-import {
-  Bus,
-  CaptureSink,
-  type CaptureSinkApi,
-  type CompositionClass,
-  type CompositionService,
-  type Instrumentation,
-  noopInstrumentation,
-  type Scene,
-  type SlotChild,
-  type Structure,
-  type Trigger,
-  type UiCapture,
-  type UiContract,
-} from '@playfast/reform'
-
-const SETTLE_DRAIN = 30
-export const SETTLE_STEP = '1 milli'
-export const SETTLE_MAX_RENDERS = 100
-
-export const settleDrain: Effect.Effect<void> = Effect.yieldNow().pipe(Effect.repeatN(SETTLE_DRAIN))
-
-export 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)) })
-}
-
-export const messageOf = (error: unknown): string =>
-  error instanceof Error ? error.message : String(error)
-
-export const uiNameOf = (comp: CompositionClass<unknown>): string => comp.manifest.ui.manifest.name
-
-export const eventsOf = (structure: Structure<UiContract>): Record<string, Trigger<unknown>> => ({
-  ...structure.events,
-})
-
-export interface Sink {
-  readonly api: CaptureSinkApi
-  readonly captures: ReadonlyArray<UiCapture>
-  readonly instrumentation: Instrumentation
-  reset(): void
-}
-
-export const makeSink = (instrumentation: Instrumentation = noopInstrumentation): Sink => {
-  const captures = MutableRef.make<UiCapture[]>([])
-  return {
-    api: {
-      record: (capture) => {
-        MutableRef.update(captures, (current) => [...current, capture])
-      },
-    },
-    get captures() {
-      return MutableRef.get(captures)
-    },
-    instrumentation,
-    reset: () => {
-      MutableRef.set(captures, [])
-    },
-  }
-}
-
-export type RuntimeServices = CompositionService | SlotChild | Bus
-
-export const proofLayer = (scene: Scene, sink: Sink): Layer.Layer<RuntimeServices, never, never> => {
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- the one erasure boundary: the scene's host-read `MountedServices` layer widens to the broader `RuntimeServices` a proof resolves
-  const sceneLayer = scene.provide.reduce((merged, layer) => Layer.merge(merged, layer)) as unknown as Layer.Layer<
-    RuntimeServices,
-    never,
-    never
-  >
-  return Layer.provideMerge(sceneLayer, Layer.succeed(CaptureSink, sink.api))
-}

package/src/treeBindings.ts

@@ -1,121 +0,0 @@
-import { Effect, Match, Option, Record as Rec } from 'effect'
-import {
-  type CompositionClass,
-  isFeatureBinding,
-  type SlotChild,
-  type SlotClass,
-  type SlotFill,
-  type Structure,
-  type UiContract,
-} from '@playfast/reform'
-import { eventsOf, type Sink, uiNameOf } from './sink'
-
-export interface Mounted {
-  readonly comp: CompositionClass<unknown>
-  readonly props: unknown
-  readonly key: Option.Option<string>
-}
-
-export interface NodeRef {
-  readonly name: string
-  readonly index: number
-}
-
-export interface SettleProgress {
-  readonly previous: string
-  readonly remaining: number
-  readonly stable: boolean
-}
-
-export interface PumpStep {
-  readonly input: unknown
-  readonly index: number
-}
-
-export const childComposition = (child: SlotChild): CompositionClass<unknown> =>
-  isFeatureBinding(child) ? child.composition : child
-
-export const slotsOf = (comp: CompositionClass<unknown>): Record<string, SlotClass> =>
-  Option.getOrElse(Option.fromNullable(comp.manifest.slots), () => ({}))
-
-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')
-
-export const structureFills = (
-  structure: Structure<UiContract>,
-): Record<string, SlotFill<unknown>> =>
-  Rec.fromEntries(
-    Rec.toEntries(structure.slots).flatMap(([slotName, fillValue]) =>
-      isSlotFill(fillValue) ? [[slotName, fillValue] as const] : [],
-    ),
-  )
-
-export const collectBindings: (
-  root: CompositionClass<unknown>,
-) => Effect.Effect<Map<SlotClass, CompositionClass<unknown>>, never, SlotChild> = Effect.fn(
-  'collectBindings',
-)(function* (
-  root: CompositionClass<unknown>,
-): Effect.fn.Return<Map<SlotClass, CompositionClass<unknown>>, never, SlotChild> {
-  const bindings = new Map<SlotClass, CompositionClass<unknown>>()
-  const walk: (comp: CompositionClass<unknown>) => Effect.Effect<void, never, SlotChild> = Effect.fn(
-    'collectBindings.walk',
-  )(function* (comp: CompositionClass<unknown>): Effect.fn.Return<void, never, SlotChild> {
-    yield* Effect.forEach(Rec.values(slotsOf(comp)), (slotClass) =>
-      Effect.gen(function* () {
-        if (bindings.has(slotClass)) {
-          return
-        }
-        const child = childComposition(yield* slotClass.tag)
-        bindings.set(slotClass, child)
-        yield* walk(child)
-      }),
-    )
-  })
-  yield* walk(root)
-  return bindings
-})
-
-const enqueueFill = (
-  slotName: string,
-  fill: SlotFill<unknown>,
-  child: CompositionClass<unknown>,
-): ReadonlyArray<Mounted> =>
-  Match.value(fill).pipe(
-    Match.when({ _tag: 'Each' }, (each) =>
-      each.items.map((entry) => ({
-        comp: child,
-        props: entry.props,
-        key: Option.some(entry.key),
-      })),
-    ),
-    Match.when({ _tag: 'One' }, (oneFill) => [
-      { comp: child, props: oneFill.props, key: Option.some(`${slotName}.0`) },
-    ]),
-    Match.when({ _tag: 'Absent' }, () => []),
-    Match.exhaustive,
-  )
-
-export const driveStructure = (
-  comp: CompositionClass<unknown>,
-  structure: Structure<UiContract>,
-  key: Option.Option<string>,
-  sink: Sink,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-): ReadonlyArray<Mounted> => {
-  sink.api.record({
-    name: uiNameOf(comp),
-    props: structure.props,
-    events: eventsOf(structure),
-    ...(Option.isSome(key) ? { key: key.value } : {}),
-  })
-  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(slotName, fill, child)
-  })
-}