@playfast/reform 1.2.0 → 1.2.1

package/src/runtime/appRuntime.ts

@@ -1,476 +1,21 @@
-import { Cause, Context, Effect, Exit, Fiber, Layer, ManagedRuntime, Option, Scope } from 'effect'
-import type {
-  CompositionActivation,
-  CompositionId,
-  RequiredSlotIdentities,
-} from '../compose/composition'
+import type { CompositionId, RequiredSlotIdentities } from '../compose/composition'
 import type { UiContract } from '../compose/ui'
-import {
-  type AnyFeatureBinding,
-  type CapturedFeatureBinding,
-  type FeatureBinding,
-  FeatureInput,
-  type FeatureRequirement,
-} from '../feature/feature'
-import type {
-  AnyFeatureGraphSummary,
-  FeatureSummaryCompositionIdentity,
-  FeatureSummaryContract,
-  FeatureSummaryInput,
-  FeatureSummaryMountProps,
-  FeatureSummaryName,
-  FeatureSummaryOpenServices,
-  FeatureSummaryUsesInput,
-} from '../graph/closure'
-import { FeatureLoadFailed, forceSync } from '../internal/errors'
-import { type Node } from '../ui/node'
-import { type AnyScene, type CapturedScene, type Scene, sceneInstrumentation } from '../scene/scene'
-import { Bus, publish, type Priority, type Tagged } from './bus'
-import { CurrentEventBudget, type ReformOptions, resolveEventBudget } from './eventBudget'
-import { type Instrumentation } from './instrumentation'
-import { EngineRequirements, type EngineServices } from './loop'
-
-export const UnspecifiedRuntimeServicesTypeId: unique symbol = Symbol.for(
-  'reform/UnspecifiedRuntimeServices',
-)
-export type UnspecifiedRuntimeServicesTypeId = typeof UnspecifiedRuntimeServicesTypeId
-export interface UnspecifiedRuntimeServices {
-  readonly [UnspecifiedRuntimeServicesTypeId]: UnspecifiedRuntimeServicesTypeId
-}
-
-export type FeatureMountHandlersExternalApi<UsesInput extends boolean, Input, Services> = {
-  readonly onLive: (runtime: RuntimeHandle<Services>) => void
-  readonly onFailed: (error: FeatureLoadFailed) => void
-} & (UsesInput extends true ? { readonly props: Input } : { readonly props?: never })
-
-export type FeatureMountHandlers<
-  UsesInput extends boolean,
-  Input,
-  Services,
-> = FeatureMountHandlersExternalApi<UsesInput, Input, Services>
-
-export type RuntimeFeatureAvailability<Services, OpenServices> = [
-  EngineServices | OpenServices,
-] extends [Services]
-  ? object
-  : {
-      readonly missingFeatureServices: Exclude<EngineServices | OpenServices, Services>
-    }
-
-export interface AnyFeatureMountHandlers {
-  readonly props: unknown
-  readonly onLive: <Services>(runtime: RuntimeHandle<Services>) => void
-  readonly onFailed: (error: FeatureLoadFailed) => void
-}
-
-export interface CapturedFeatureMountHandlers<
-  Props,
-  HostServices,
-  FeatureServices,
-  C extends UiContract,
-  N extends string,
-  Identity,
-> {
-  readonly props: Props
-  readonly onLive: (
-    runtime: RuntimeHandle<
-      HostServices | FeatureServices | CompositionId<N, Identity, RequiredSlotIdentities<C>>
-    >,
-  ) => void
-  readonly onFailed: (error: FeatureLoadFailed) => void
-}
-
-const isObjectLike = (candidate: unknown): candidate is object =>
-  (typeof candidate === 'object' || typeof candidate === 'function') && candidate !== null
-
-const isContextTag = (candidate: unknown): candidate is Context.Tag<unknown, unknown> =>
-  isObjectLike(candidate) &&
-  Context.TagTypeId in candidate &&
-  'key' in candidate &&
-  typeof candidate.key === 'string'
-
-const isUnknownArray = (candidate: unknown): candidate is ReadonlyArray<unknown> =>
-  Array.isArray(candidate)
-
-const requirementAvailable = <Services>(
-  context: Context.Context<Services>,
-  requirement: unknown,
-): boolean => {
-  if (isContextTag(requirement)) {
-    return Option.isSome(Context.getOption(context, requirement))
-  }
-  if (!isObjectLike(requirement)) {
-    return false
-  }
-  if ('store' in requirement) {
-    return requirementAvailable(context, requirement.store)
-  }
-  if ('members' in requirement && isUnknownArray(requirement.members)) {
-    return requirement.members.every((member) => requirementAvailable(context, member))
-  }
-  return false
-}
-
-const hasFeatureRequirements = <
-  Services,
-  OpenServices,
-  const DirectRequires extends ReadonlyArray<FeatureRequirement>,
->(
-  context: Context.Context<Services>,
-  requires: DirectRequires,
-): context is Context.Context<Services | EngineServices | OpenServices> =>
-  EngineRequirements.every((tag) => requirementAvailable(context, tag)) &&
-  requires.every((requirement) => requirementAvailable(context, requirement))
-
-const featureMountFailure = (message: string): FeatureLoadFailed =>
-  new FeatureLoadFailed({ cause: message })
-
-export interface RuntimeHandle<Services = UnspecifiedRuntimeServices> {
-  read<Identifier extends Services, Service>(tag: Context.Tag<Identifier, Service>): Service
-  readOption<Identifier, Service>(tag: Context.Tag<Identifier, Service>): Option.Option<Service>
-  runRender(effect: Effect.Effect<Node, never, never>): Node
-  dispatch(priority: Priority, event: Tagged): void
-  mountScoped(activation: CompositionActivation): () => void
-  mountFeature<
-    Summary extends AnyFeatureGraphSummary,
-    ROut,
-    const DirectRequires extends ReadonlyArray<FeatureRequirement>,
-  >(
-    binding: [EngineServices | FeatureSummaryOpenServices<Summary>] extends [Services]
-      ? FeatureBinding<Summary, ROut, DirectRequires>
-      : never,
-    handlers: FeatureMountHandlers<
-      FeatureSummaryUsesInput<Summary>,
-      FeatureSummaryInput<Summary>,
-      Services | ROut
-    >,
-  ): () => void
-  mountCapturedFeature<
-    Summary extends AnyFeatureGraphSummary,
-    ROut,
-    const DirectRequires extends ReadonlyArray<FeatureRequirement>,
-  >(
-    binding: CapturedFeatureBinding<Summary, ROut, DirectRequires> &
-      RuntimeFeatureAvailability<Services, FeatureSummaryOpenServices<Summary>>,
-    handlers: CapturedFeatureMountHandlers<
-      FeatureSummaryMountProps<Summary>,
-      Services,
-      ROut,
-      FeatureSummaryContract<Summary>,
-      FeatureSummaryName<Summary>,
-      FeatureSummaryCompositionIdentity<Summary>
-    >,
-  ): () => void
-  mountAnyFeature(binding: AnyFeatureBinding, handlers: AnyFeatureMountHandlers): () => void
-  readonly instrumentation: Instrumentation
-}
-
-export interface AppRuntime<Services = UnspecifiedRuntimeServices> extends RuntimeHandle<Services> {
-  boot(): void
-  dispose(): void
-  isDisposed(): boolean
-}
-
-const makeCapturedAppRuntime = <
-  C extends UiContract,
-  S extends ReadonlyArray<unknown>,
-  Services,
-  P,
-  N extends string,
-  Identity,
->(
-  scene: CapturedScene<C, S, Services, P, N, Identity>,
-  options: ReformOptions = {},
-): AppRuntime<Services | CompositionId<N, Identity, RequiredSlotIdentities<C>>> => {
-  const instrumentation = sceneInstrumentation(scene)
-  const provide = scene.provide.map(Layer.locally(CurrentEventBudget, resolveEventBudget(options)))
-  const layer = provide.reduce((accLayer, nextLayer) => Layer.merge(accLayer, nextLayer))
-  const runtime = ManagedRuntime.make(layer)
-  const capturedContext = forceSync(() => runtime.runSync(Effect.context<Services>()))
-  const rootCompositionService = Option.getOrThrow(
-    Context.getOption(capturedContext, scene.composition.tag),
-  )
-  // Re-add the exact tag so the captured context retains the root's nominal identity.
-  const rootContext = Context.add(capturedContext, scene.composition.tag, rootCompositionService)
-  const rootBus = Context.getOption(rootContext, Bus)
-
-  // Hosts can still render tearing-down trees after the managed runtime is disposed.
-  const status = { disposed: false, booted: false }
-  const activationDisposers = new Set<() => void>()
-
-  // A closed render Effect remains safe on the default runtime after disposal.
-  const runRender = (effect: Effect.Effect<Node, never, never>): Node =>
-    status.disposed ? Effect.runSync(effect) : runtime.runSync(effect)
-
-  const dispatch = (priority: Priority, event: Tagged): void => {
-    if (status.disposed || Option.isNone(rootBus)) {
-      return
-    }
-    runtime.runFork(publish(priority, event).pipe(Effect.provideService(Bus, rootBus.value)))
-  }
-
-  const mountScoped = (activation: CompositionActivation): (() => void) => {
-    if (status.disposed) {
-      return () => {}
-    }
-    const scope = Effect.runSync(Scope.make())
-    const liveness = { active: true }
-    const fiber = runtime.runFork(
-      Layer.build(activation).pipe(Effect.provideService(Scope.Scope, scope)),
-    )
-    const dispose = (): void => {
-      if (!liveness.active) {
-        return
-      }
-      liveness.active = false
-      fiber.unsafeInterruptAsFork(fiber.id())
-      const close = Fiber.await(fiber).pipe(
-        Effect.zipRight(Scope.close(scope, Exit.succeed(undefined))),
-        Effect.ensuring(Effect.sync(() => activationDisposers.delete(dispose))),
-      )
-      Effect.runFork(close)
-    }
-    activationDisposers.add(dispose)
-    return dispose
-  }
-
-  const makeChildRuntime = <ChildServices>(
-    context: Context.Context<ChildServices>,
-  ): RuntimeHandle<ChildServices> => ({
-    read: <Identifier extends ChildServices, Service>(
-      tag: Context.Tag<Identifier, Service>,
-    ): Service => Context.get(context, tag),
-    readOption: <Identifier, Service>(
-      tag: Context.Tag<Identifier, Service>,
-    ): Option.Option<Service> => Context.getOption(context, tag),
-    runRender,
-    dispatch,
-    mountScoped,
-    mountFeature: (binding, handlers) => mountFeatureOnto(context, binding, handlers),
-    mountCapturedFeature: (binding, handlers) =>
-      mountCapturedFeatureOnto(context, binding, handlers),
-    mountAnyFeature: (binding, handlers) => mountAnyFeatureOnto(context, binding, handlers),
-    instrumentation,
-  })
-
-  const mountFeatureOnto = <
-    HostServices,
-    Summary extends AnyFeatureGraphSummary,
-    ROut,
-    const DirectRequires extends ReadonlyArray<FeatureRequirement>,
-  >(
-    hostContext: Context.Context<HostServices>,
-    binding: FeatureBinding<Summary, ROut, DirectRequires>,
-    handlers: FeatureMountHandlers<
-      FeatureSummaryUsesInput<Summary>,
-      FeatureSummaryInput<Summary>,
-      HostServices | ROut
-    >,
-  ): (() => void) => {
-    if (status.disposed) {
-      return () => {}
-    }
-    const scope = Effect.runSync(Scope.make())
-    const mount = Effect.flatMap(binding.load, (loaded) => {
-      if (
-        !hasFeatureRequirements<HostServices, FeatureSummaryOpenServices<Summary>, DirectRequires>(
-          hostContext,
-          loaded.requires,
-        )
-      ) {
-        return Effect.fail(
-          featureMountFailure(
-            `Feature ${binding.manifest.name} requires services missing from the host runtime`,
-          ),
-        )
-      }
-      return Effect.gen(function* () {
-        const bus = Context.get(hostContext, Bus)
-        const featureContext = Context.add(hostContext, FeatureInput, handlers.props)
-        const context = yield* Layer.build(
-          Layer.provide(loaded.layer, Layer.succeedContext(featureContext)),
-        )
-        yield* Effect.forEach(binding.boot, (event) => publish('High', event), {
-          discard: true,
-        }).pipe(Effect.provideService(Bus, bus))
-        const merged = Context.merge(hostContext, context)
-        yield* Effect.sync(() => handlers.onLive(makeChildRuntime<HostServices | ROut>(merged)))
-      })
-    })
-    const fiber = runtime.runFork(
-      mount.pipe(
-        Effect.provideService(Scope.Scope, scope),
-        Effect.matchCause({
-          onFailure: (cause) => {
-            // Disposer interruption is cancellation, not a failed feature.
-            if (!Cause.isInterruptedOnly(cause)) {
-              handlers.onFailed(
-                Option.getOrElse(
-                  Cause.failureOption(cause),
-                  () => new FeatureLoadFailed({ cause }),
-                ),
-              )
-            }
-          },
-          onSuccess: () => undefined,
-        }),
-      ),
-    )
-    return () => {
-      // Interrupt first, then await finalizer registration before closing the scope.
-      fiber.unsafeInterruptAsFork(fiber.id())
-      const close = Fiber.await(fiber).pipe(
-        Effect.zipRight(Scope.close(scope, Exit.succeed(undefined))),
-      )
-      if (status.disposed) {
-        Effect.runFork(close)
-      } else {
-        runtime.runFork(close)
-      }
-    }
-  }
-
-  const mountCapturedFeatureOnto = <
-    HostServices,
-    Summary extends AnyFeatureGraphSummary,
-    ROut,
-    const DirectRequires extends ReadonlyArray<FeatureRequirement>,
-  >(
-    hostContext: Context.Context<HostServices>,
-    binding: CapturedFeatureBinding<Summary, ROut, DirectRequires>,
-    handlers: CapturedFeatureMountHandlers<
-      FeatureSummaryMountProps<Summary>,
-      HostServices,
-      ROut,
-      FeatureSummaryContract<Summary>,
-      FeatureSummaryName<Summary>,
-      FeatureSummaryCompositionIdentity<Summary>
-    >,
-  ): (() => void) => {
-    if (status.disposed) {
-      return () => {}
-    }
-    const scope = Effect.runSync(Scope.make())
-    const mount = Effect.flatMap(binding.load, (loaded) => {
-      if (
-        !hasFeatureRequirements<HostServices, FeatureSummaryOpenServices<Summary>, DirectRequires>(
-          hostContext,
-          loaded.requires,
-        )
-      ) {
-        return Effect.fail(
-          featureMountFailure(
-            `Feature ${binding.manifest.name} requires services missing from the host runtime`,
-          ),
-        )
-      }
-      const input = loaded.usesInput ? binding.parseInput(handlers.props) : Option.some(undefined)
-      return Option.match(input, {
-        onNone: () =>
-          Effect.fail(
-            featureMountFailure(`Feature ${binding.manifest.name} received invalid props`),
-          ),
-        onSome: (props) =>
-          Effect.gen(function* () {
-            const bus = Context.get(hostContext, Bus)
-            const featureContext = Context.add(hostContext, FeatureInput, props)
-            const context = yield* Layer.build(
-              Layer.provide(loaded.layer, Layer.succeedContext(featureContext)),
-            )
-            yield* Effect.forEach(binding.boot, (event) => publish('High', event), {
-              discard: true,
-            }).pipe(Effect.provideService(Bus, bus))
-            const merged = Context.merge(hostContext, context)
-            const compositionService = Option.getOrThrow(
-              Context.getOption(merged, binding.composition.tag),
-            )
-            const rooted = Context.add(merged, binding.composition.tag, compositionService)
-            yield* Effect.sync(() => handlers.onLive(makeChildRuntime(rooted)))
-          }),
-      })
-    })
-    const fiber = runtime.runFork(
-      mount.pipe(
-        Effect.provideService(Scope.Scope, scope),
-        Effect.matchCause({
-          onFailure: (cause) => {
-            if (!Cause.isInterruptedOnly(cause)) {
-              handlers.onFailed(
-                Option.getOrElse(
-                  Cause.failureOption(cause),
-                  () => new FeatureLoadFailed({ cause }),
-                ),
-              )
-            }
-          },
-          onSuccess: () => undefined,
-        }),
-      ),
-    )
-    return () => {
-      fiber.unsafeInterruptAsFork(fiber.id())
-      const close = Fiber.await(fiber).pipe(
-        Effect.zipRight(Scope.close(scope, Exit.succeed(undefined))),
-      )
-      if (status.disposed) {
-        Effect.runFork(close)
-      } else {
-        runtime.runFork(close)
-      }
-    }
-  }
-
-  const mountAnyFeatureOnto = <HostServices>(
-    hostContext: Context.Context<HostServices>,
-    binding: AnyFeatureBinding,
-    handlers: AnyFeatureMountHandlers,
-  ): (() => void) =>
-    binding.capture((exactBinding) =>
-      mountCapturedFeatureOnto(hostContext, exactBinding, {
-        props: handlers.props,
-        onLive: (childRuntime) => handlers.onLive(childRuntime),
-        onFailed: handlers.onFailed,
-      }),
-    )
-
-  type RootServices = Services | CompositionId<N, Identity, RequiredSlotIdentities<C>>
-  const app: AppRuntime<RootServices> = {
-    // Captured reads stay available while the managed runtime is tearing down.
-    read: <Identifier extends RootServices, Service>(
-      tag: Context.Tag<Identifier, Service>,
-    ): Service => Context.get(rootContext, tag),
-    readOption: <Identifier, Service>(
-      tag: Context.Tag<Identifier, Service>,
-    ): Option.Option<Service> => Context.getOption(rootContext, tag),
-    runRender,
-    dispatch,
-    mountScoped,
-    mountFeature: (binding, handlers) => mountFeatureOnto(rootContext, binding, handlers),
-    mountCapturedFeature: (binding, handlers) =>
-      mountCapturedFeatureOnto(rootContext, binding, handlers),
-    mountAnyFeature: (binding, handlers) => mountAnyFeatureOnto(rootContext, binding, handlers),
-    boot: () => {
-      if (status.disposed || status.booted) {
-        return
-      }
-      status.booted = true
-      Option.fromNullable(scene.boot)
-        .pipe(Option.getOrElse((): ReadonlyArray<Tagged> => []))
-        .forEach((event) => dispatch('High', event))
-    },
-    dispose: () => {
-      if (status.disposed) {
-        return
-      }
-      status.disposed = true
-      activationDisposers.forEach((dispose) => dispose())
-      void runtime.dispose()
-    },
-    isDisposed: () => status.disposed,
-    instrumentation,
-  }
-  return app
-}
+import type { AnyScene, CapturedScene, Scene } from '../scene/scene'
+import { makeCapturedAppRuntime } from './capturedAppRuntime'
+import type { ReformOptions } from './eventBudget'
+import type { AppRuntime, UnspecifiedRuntimeServices } from './runtimeHandle'
+
+export { UnspecifiedRuntimeServicesTypeId } from './runtimeHandle'
+export type {
+  AnyFeatureMountHandlers,
+  AppRuntime,
+  CapturedFeatureMountHandlers,
+  FeatureMountHandlers,
+  FeatureMountHandlersExternalApi,
+  RuntimeFeatureAvailability,
+  RuntimeHandle,
+  UnspecifiedRuntimeServices,
+} from './runtimeHandle'
 
 export function makeAppRuntime<
   C extends UiContract,