@playfast/reform 1.1.1 → 1.2.1

package/src/runtime/appRuntime.test.ts

@@ -1,18 +1,19 @@
-import { Context, Duration, Effect, Layer, Schema as S } from "effect";
-import { expect, it } from "@effect/vitest";
-import * as Composition from "../compose/composition";
-import { provide } from "../compose/provide";
-import { mount } from "../compose/structure";
-import * as Ui from "../compose/ui";
-import { ui } from "../compose/ui";
-import * as Event from "../event/event";
-import * as Feature from "../feature/feature";
-import { featureModule } from "../feature/feature";
-import * as Reducer from "../reducer/reducer";
-import { scene } from "../scene/scene";
-import * as State from "../state/state";
-import { Engine, Reducers } from "./loop";
-import { makeAppRuntime } from "./appRuntime";
+import { Context, Effect, Layer, Option, Schema as S } from 'effect'
+import { expect, it } from '@effect/vitest'
+import * as Composition from '../compose/composition'
+import { provide } from '../compose/provide'
+import { mount } from '../compose/structure'
+import * as Ui from '../compose/ui'
+import { ui } from '../compose/ui'
+import * as Event from '../event/event'
+import * as Feature from '../feature/feature'
+import { featureModule } from '../feature/feature'
+import * as Reducer from '../reducer/reducer'
+import { scene } from '../scene/scene'
+import * as State from '../state/state'
+import { until } from '../testkit/flight.testkit'
+import { Engine, Reducers } from './loop'
+import { makeAppRuntime } from './appRuntime'
 
 // The host-level mount lifecycle: `RuntimeHandle.mountFeature` forks the mount,
 // and its disposer must CANCEL a mount whose fiber has not run yet (StrictMode
@@ -20,38 +21,42 @@ import { makeAppRuntime } from "./appRuntime";
 // stale mount would still register reducers and dispatch `binding.boot` onto the
 // shared bus.
 
-class Tick extends Event.make("appRuntime.Tick", S.Struct({})) {}
-class Count extends State.make("appRuntime.count", S.Number) {}
-class CountReducer extends Reducer.make("appRuntime.CountReducer", {
+class Tick extends Event.make('appRuntime.Tick', S.Struct({})) {}
+class Count extends State.make('appRuntime.count', S.Number) {}
+class CountReducer extends Reducer.make('appRuntime.CountReducer', {
   states: [Count],
   events: [Tick],
 }) {}
 
-class CtrUi extends ui("appRuntime.CtrUi")<{ props: {} }>() {}
-class CtrComp extends Composition.make("appRuntime.CtrComp", {
-  title: "Counter",
+class CtrUi extends ui('appRuntime.CtrUi')<{ props: {} }>() {}
+class CtrComp extends Composition.make('appRuntime.CtrComp', {
+  title: 'Counter',
   ui: CtrUi,
-}) {}
+})<CtrComp>() {}
+const CtrLive = Composition.live(CtrComp, function* () {
+  return mount({ props: {}, slots: {}, events: {} })
+})
 
-class CounterFeature extends Feature.make("appRuntime.counter", {
+class CounterFeature extends Feature.make('appRuntime.counter', {
   composition: CtrComp,
   module: featureModule(
     [],
-    Reducer.live(CountReducer, (n) => n + 1).pipe(
-      Layer.provideMerge(State.live(Count, 0)),
+    Layer.merge(
+      CtrLive,
+      Reducer.live(CountReducer, (n) => n + 1).pipe(Layer.provideMerge(State.live(Count, 0))),
     ),
   ),
   boot: [Event.construct(Tick, {})],
 }) {}
 
-class RootUi extends ui("appRuntime.RootUi")<{ props: {} }>() {}
-class RootComp extends Composition.make("appRuntime.RootComp", {
-  title: "Root",
+class RootUi extends ui('appRuntime.RootUi')<{ props: {} }>() {}
+class RootComp extends Composition.make('appRuntime.RootComp', {
+  title: 'Root',
   ui: RootUi,
-}) {}
+})<RootComp>() {}
 const RootLive = Composition.live(RootComp, function* () {
-  return mount({ props: {}, slots: {}, events: {} });
-});
+  return mount({ props: {}, slots: {}, events: {} })
+})
 
 const rootScene = () =>
   scene(RootComp, {
@@ -66,132 +71,203 @@ const rootScene = () =>
         Layer.provideMerge(Engine),
       ),
     ],
-  });
+  })
 
-const settle = Effect.sleep(Duration.millis(50));
 const appRuntime = Effect.acquireRelease(
   Effect.sync(() => makeAppRuntime(rootScene())),
   (app) => Effect.sync(() => app.dispose()),
-);
+)
 
 interface ParentValueService {
-  readonly value: string;
+  readonly value: string
 }
-const ParentValueBase: Context.TagClass<
-  ParentValue,
-  "appRuntime.ParentValue",
-  ParentValueService
-> = Context.Tag("appRuntime.ParentValue")<ParentValue, ParentValueService>();
+const ParentValueBase: Context.TagClass<ParentValue, 'appRuntime.ParentValue', ParentValueService> =
+  Context.Tag('appRuntime.ParentValue')<ParentValue, ParentValueService>()
 class ParentValue extends ParentValueBase {}
 
 interface ChildValueService {
-  readonly value: string;
+  readonly value: string
 }
-const ChildValueBase: Context.TagClass<
-  ChildValue,
-  "appRuntime.ChildValue",
-  ChildValueService
-> = Context.Tag("appRuntime.ChildValue")<ChildValue, ChildValueService>();
+const ChildValueBase: Context.TagClass<ChildValue, 'appRuntime.ChildValue', ChildValueService> =
+  Context.Tag('appRuntime.ChildValue')<ChildValue, ChildValueService>()
 class ChildValue extends ChildValueBase {}
 
-class ParentFeature extends Feature.make("appRuntime.parent", {
+class ParentFeature extends Feature.make('appRuntime.parent', {
   composition: CtrComp,
   module: featureModule(
     [],
-    Layer.succeed(ParentValue, { value: "from-parent" }),
+    Layer.merge(CtrLive, Layer.succeed(ParentValue, { value: 'from-parent' })),
   ),
 }) {}
 
-class ChildFeature extends Feature.make("appRuntime.child", {
+class ChildFeature extends Feature.make('appRuntime.child', {
   composition: CtrComp,
   module: featureModule(
     [ParentValue],
-    Layer.effect(
-      ChildValue,
-      Effect.map(ParentValue, ({ value }) => ({ value })),
+    Layer.merge(
+      CtrLive,
+      Layer.effect(
+        ChildValue,
+        Effect.map(ParentValue, ({ value }) => ({ value })),
+      ),
     ),
   ),
 }) {}
 
+const CounterNative = Feature.tree<typeof CounterFeature>(CounterFeature.token)
+const ParentNative = Feature.tree<typeof ParentFeature>(ParentFeature.token)
+const ChildNative = Feature.tree<typeof ChildFeature>(ChildFeature.token)
+
 it.scopedLive(
-  "disposing a mount before its fiber runs cancels it — no registration, no boot, no handler calls",
+  'disposing a mount before its fiber runs cancels it — no registration, no boot, no handler calls',
   () =>
     Effect.gen(function* () {
-      const app = yield* appRuntime;
-      const baseline = app.read(Reducers).entries.length;
-      const calls = { live: 0, failed: 0 };
-      const dispose = app.mountFeature(CounterFeature.binding, {
+      const app = yield* appRuntime
+      const baseline = app.read(Reducers).entries.length
+      const calls = { live: 0, failed: 0 }
+      const dispose = app.mountFeature(CounterNative.binding, {
         onLive: () => {
-          calls.live += 1;
+          calls.live += 1
         },
         onFailed: () => {
-          calls.failed += 1;
+          calls.failed += 1
         },
-      });
+      })
       // Same-tick dispose (the StrictMode cleanup shape): the fork has not run yet.
-      dispose();
-      yield* settle;
-      expect(calls).toEqual({ live: 0, failed: 0 });
-      expect(app.read(Reducers).entries.length).toBe(baseline);
-      expect(app.read(Reducers).byTag.get("appRuntime.Tick")).toBeUndefined();
+      dispose()
+      // A probe mount forked behind the cancelled one: once it is live, the
+      // cancelled fork's turn has provably passed.
+      const probe = { live: 0, failed: 0 }
+      const disposeProbe = app.mountFeature(CounterNative.binding, {
+        onLive: () => {
+          probe.live += 1
+        },
+        onFailed: () => {
+          probe.failed += 1
+        },
+      })
+      yield* until(
+        () => probe.live + probe.failed,
+        (n) => n > 0,
+      )
+      expect(calls).toEqual({ live: 0, failed: 0 })
+      expect(app.read(Reducers).entries.length).toBe(baseline + 1)
+
+      disposeProbe()
+      yield* until(
+        () => app.read(Reducers).entries.length,
+        (n) => n === baseline,
+      )
+      expect(app.read(Reducers).entries.length).toBe(baseline)
+      expect(app.read(Reducers).byTag.get('appRuntime.Tick')).toBeUndefined()
     }),
-);
+)
 
 it.scopedLive(
-  "an undisposed mount still goes live, and disposing it after live reclaims the registration",
+  'an undisposed mount still goes live, and disposing it after live reclaims the registration',
   () =>
     Effect.gen(function* () {
-      const app = yield* appRuntime;
-      const baseline = app.read(Reducers).entries.length;
-      const calls = { live: 0, failed: 0 };
-      const dispose = app.mountFeature(CounterFeature.binding, {
+      const app = yield* appRuntime
+      const baseline = app.read(Reducers).entries.length
+      const calls = { live: 0, failed: 0 }
+      const dispose = app.mountFeature(CounterNative.binding, {
         onLive: () => {
-          calls.live += 1;
+          calls.live += 1
         },
         onFailed: () => {
-          calls.failed += 1;
+          calls.failed += 1
+        },
+      })
+      yield* until(
+        () => calls.live,
+        (n) => n === 1,
+      )
+      expect(calls).toEqual({ live: 1, failed: 0 })
+      expect(app.read(Reducers).entries.length).toBe(baseline + 1)
+      dispose()
+      yield* until(
+        () => app.read(Reducers).entries.length,
+        (n) => n === baseline,
+      )
+      expect(app.read(Reducers).entries.length).toBe(baseline)
+    }),
+)
+
+it.scopedLive('a nested Feature mounts against its immediate parent context', () =>
+  Effect.gen(function* () {
+    const app = yield* appRuntime
+    const observed: Array<string> = []
+    const disposers: Array<() => void> = []
+    yield* Effect.addFinalizer(() =>
+      Effect.sync(() => disposers.reverse().forEach((dispose) => dispose())),
+    )
+    disposers.push(
+      app.mountFeature(ParentNative.binding, {
+        onFailed: () => observed.push('parent-failed'),
+        onLive: (parent) => {
+          disposers.push(
+            parent.mountFeature(ChildNative.binding, {
+              onFailed: () => observed.push('child-failed'),
+              onLive: (child) => observed.push(child.read(ChildValue).value),
+            }),
+          )
+        },
+      }),
+    )
+    yield* until(
+      () => observed.length,
+      (n) => n > 0,
+    )
+    expect(observed).toEqual(['from-parent'])
+  }),
+)
+
+it.scopedLive(
+  'an existential Feature binding validates its graph and exposes only safe optional reads',
+  () =>
+    Effect.gen(function* () {
+      const app = yield* appRuntime
+      const observed: Array<string> = []
+      const binding: Feature.AnyFeatureBinding = ParentNative.binding
+      const dispose = app.mountAnyFeature(binding, {
+        props: {},
+        onFailed: () => observed.push('failed'),
+        onLive: (child) => {
+          const service = child.readOption(ParentValue)
+          observed.push(
+            Option.match(service, {
+              onNone: () => 'missing',
+              onSome: ({ value }) => value,
+            }),
+          )
         },
-      });
-      yield* Effect.sleep(Duration.millis(1)).pipe(
-        Effect.repeat({ until: () => calls.live === 1 }),
-        Effect.timeout(Duration.seconds(2)),
-      );
-      expect(calls).toEqual({ live: 1, failed: 0 });
-      expect(app.read(Reducers).entries.length).toBe(baseline + 1);
-      dispose();
-      yield* settle;
-      expect(app.read(Reducers).entries.length).toBe(baseline);
+      })
+      yield* Effect.addFinalizer(() => Effect.sync(dispose))
+      yield* until(
+        () => observed.length,
+        (n) => n > 0,
+      )
+      expect(observed).toEqual(['from-parent'])
     }),
-);
+)
 
 it.scopedLive(
-  "a nested Feature mounts against its immediate parent context",
+  'an existential Feature binding fails before build when a requirement is absent',
   () =>
     Effect.gen(function* () {
-      const app = yield* appRuntime;
-      const observed: Array<string> = [];
-      const disposers: Array<() => void> = [];
-      yield* Effect.addFinalizer(() =>
-        Effect.sync(() => disposers.reverse().forEach((dispose) => dispose())),
-      );
-      disposers.push(
-        app.mountFeature(ParentFeature.binding, {
-          onFailed: () => observed.push("parent-failed"),
-          onLive: (parent) => {
-            disposers.push(
-              parent.mountFeature(ChildFeature.binding, {
-                onFailed: () => observed.push("child-failed"),
-                onLive: (child) =>
-                  observed.push(child.read(ChildValue).value),
-              }),
-            );
-          },
-        }),
-      );
-      yield* Effect.sleep(Duration.millis(1)).pipe(
-        Effect.repeat({ until: () => observed.length > 0 }),
-        Effect.timeout(Duration.seconds(2)),
-      );
-      expect(observed).toEqual(["from-parent"]);
+      const app = yield* appRuntime
+      const observed: Array<string> = []
+      const binding: Feature.AnyFeatureBinding = ChildNative.binding
+      const dispose = app.mountAnyFeature(binding, {
+        props: {},
+        onFailed: () => observed.push('failed'),
+        onLive: () => observed.push('live'),
+      })
+      yield* Effect.addFinalizer(() => Effect.sync(dispose))
+      yield* until(
+        () => observed.length,
+        (n) => n > 0,
+      )
+      expect(observed).toEqual(['failed'])
     }),
-);
+)

package/src/runtime/appRuntime.ts

@@ -1,131 +1,37 @@
-import { Cause, Context, Effect, Exit, Fiber, Layer, ManagedRuntime, Option, Scope } from 'effect'
-import { FeatureLoadFailed, forceSync } from '../internal/errors'
-import { type FeatureBinding, mountFeature } from '../feature/feature'
-import { type Node } from '../ui/node'
-import { type MountedServices, type Scene, sceneInstrumentation } from '../scene/scene'
-import { publish, type Priority, type Tagged } from './bus'
-import { CurrentEventBudget, type ReformOptions, resolveEventBudget } from './eventBudget'
-import { type Instrumentation } from './instrumentation'
-
-export interface FeatureMountHandlersExternalApi {
-  readonly props?: unknown
-  readonly onLive: (runtime: RuntimeHandle) => void
-  readonly onFailed: (error: FeatureLoadFailed) => void
-}
-export type FeatureMountHandlers = FeatureMountHandlersExternalApi
-
-export interface RuntimeHandle {
-  read<Identifier, Service>(tag: Context.Tag<Identifier, Service>): Service
-  runRender(effect: Effect.Effect<Node, never, never>): Node
-  dispatch(priority: Priority, event: Tagged): void
-  mountFeature(binding: FeatureBinding, handlers: FeatureMountHandlers): () => void
-  readonly instrumentation: Instrumentation
-}
-
-export interface AppRuntime extends RuntimeHandle {
-  boot(): void
-  dispose(): void
-  isDisposed(): boolean
-}
-
-export const makeAppRuntime = (scene: Scene, options: ReformOptions = {}): AppRuntime => {
-  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 rootContext = forceSync(() => runtime.runSync(Effect.context<MountedServices>()))
-
-  // Inert past dispose: host may still render tearing-down trees; forked fibers outlive cleanup
-  const status = { disposed: false, booted: false }
-
-  // Self-contained Effect runs on default runtime after dispose (never throw mid-render)
-  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) {
-      return
-    }
-    runtime.runFork(publish(priority, event))
-  }
-
-  const makeChildRuntime = <R>(context: Context.Context<R>): RuntimeHandle => ({
-    read: <Identifier, Service>(tag: Context.Tag<Identifier, Service>): Service =>
-      Context.unsafeGet(context, tag),
-    runRender,
-    dispatch,
-    mountFeature: (binding, handlers) => mountFeatureOnto(context, binding, handlers),
-    instrumentation,
-  })
-
-  const mountFeatureOnto = <R>(
-    hostContext: Context.Context<R>,
-    binding: FeatureBinding,
-    handlers: FeatureMountHandlers,
-  ): (() => void) => {
-    if (status.disposed) {
-      return () => {}
-    }
-    const scope = Effect.runSync(Scope.make())
-    const fiber = runtime.runFork(
-      mountFeature(binding, hostContext, handlers.props).pipe(
-        Effect.provideService(Scope.Scope, scope),
-        Effect.matchCause({
-          onFailure: (cause) => {
-            // Disposer-cancelled mounts are not failures
-            if (!Cause.isInterruptedOnly(cause)) {
-              handlers.onFailed(
-                Option.getOrElse(
-                  Cause.failureOption(cause),
-                  () => new FeatureLoadFailed({ cause }),
-                ),
-              )
-            }
-          },
-          onSuccess: (context) => handlers.onLive(makeChildRuntime(context)),
-        }),
-      ),
-    )
-    return () => {
-      // Interrupt sync before scheduler: Scope.close alone does not interrupt (StrictMode)
-      fiber.unsafeInterruptAsFork(fiber.id())
-      // Await mount so mid-build finalizers register before scope reclaim; close on default runtime if disposed
-      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 app: AppRuntime = {
-    // Read captured context so tearing-down trees never hit ManagedRuntime disposed
-    read: <Identifier, Service>(tag: Context.Tag<Identifier, Service>): Service =>
-      Context.unsafeGet(rootContext, tag),
-    runRender,
-    dispatch,
-    mountFeature: (binding, handlers) => mountFeatureOnto(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
-      void runtime.dispose()
-    },
-    isDisposed: () => status.disposed,
-    instrumentation,
-  }
-  return app
+import type { CompositionId, RequiredSlotIdentities } from '../compose/composition'
+import type { UiContract } from '../compose/ui'
+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,
+  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>>>
+export function makeAppRuntime<C extends UiContract, S extends ReadonlyArray<unknown>>(
+  scene: Scene<C, S>,
+  options?: ReformOptions,
+): AppRuntime<UnspecifiedRuntimeServices>
+export function makeAppRuntime(scene: AnyScene, options: ReformOptions = {}): unknown {
+  return scene.captureAny<unknown>((exactScene) => makeCapturedAppRuntime(exactScene, options))
 }