@playfast/reform 1.2.1 → 1.4.0

package/src/runtime/capturedAppRuntime.ts

@@ -1,7 +1,26 @@
-import { Context, Effect, Exit, Fiber, Layer, ManagedRuntime, Option, Scope } from 'effect'
-import type { CompositionActivation, CompositionId, RequiredSlotIdentities } from '../compose/composition'
+import {
+  Context,
+  Effect,
+  ExecutionStrategy,
+  Exit,
+  Layer,
+  ManagedRuntime,
+  Option,
+  Scope,
+} from 'effect'
+import type {
+  CompositionActivation,
+  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 AnyFeatureBinding,
+  type CapturedFeatureBinding,
+  type FeatureBinding,
+  FeatureInput,
+  type FeatureRequirement,
+} from '../feature/feature'
 import type {
   AnyFeatureGraphSummary,
   FeatureSummaryCompositionIdentity,
@@ -17,7 +36,16 @@ import { type Node } from '../ui/node'
 import { type CapturedScene, sceneInstrumentation } from '../scene/scene'
 import { Bus, publish, type Priority, type Tagged } from './bus'
 import { CurrentEventBudget, type ReformOptions, resolveEventBudget } from './eventBudget'
-import { featureMountFailure, forkFeatureMount, hasFeatureRequirements } from './featureMount'
+import {
+  invalidMountProps,
+  missingHostServices,
+  type FeatureMountHost,
+  forkFeatureMount,
+  hasFeatureRequirements,
+  mountActivation,
+  startMount,
+  withInstrumentation,
+} from './featureMount'
 import type {
   AnyFeatureMountHandlers,
   AppRuntime,
@@ -52,8 +80,15 @@ export const makeCapturedAppRuntime = <
   // Hosts can still render tearing-down trees after the managed runtime is disposed.
   const status = { disposed: false, booted: false }
   const activationDisposers = new Set<() => void>()
-  const mountHost = {
-    runFork: (effect: Effect.Effect<void, never, never>) => runtime.runFork(effect),
+  // Everything this runtime mounts is forked from here, so `dispose()` closes it all
+  // without having to be handed each mount's disposer. A forked scope deregisters
+  // itself from its owner when it closes first, so churn does not accumulate.
+  // Parallel: the root's finalizers are one independent mount each, so a teardown that
+  // takes a turn must not withhold its siblings'.
+  const rootScope = Effect.runSync(Scope.make(ExecutionStrategy.parallel))
+  const instrumented = withInstrumentation(instrumentation)
+  const mountHost: FeatureMountHost = {
+    runFork: <A>(effect: Effect.Effect<A, never, never>) => runtime.runFork(effect),
     isDisposed: () => status.disposed,
   }
 
@@ -68,33 +103,22 @@ export const makeCapturedAppRuntime = <
     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 mountScopedOnto = (
+    ownerScope: Scope.Scope,
+    activation: CompositionActivation,
+  ): (() => void) =>
+    mountActivation(
+      mountHost,
+      activationDisposers,
+      instrumented(Layer.build(activation)),
+      ownerScope,
     )
-    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
-  }
 
+  // A feature's handle mounts into the feature's own scope: whatever it mounts must
+  // not outlive the context it was built against.
   const makeChildRuntime = <ChildServices>(
     context: Context.Context<ChildServices>,
+    ownerScope: Scope.Scope,
   ): RuntimeHandle<ChildServices> => ({
     read: <Identifier extends ChildServices, Service>(
       tag: Context.Tag<Identifier, Service>,
@@ -104,11 +128,12 @@ export const makeCapturedAppRuntime = <
     ): Option.Option<Service> => Context.getOption(context, tag),
     runRender,
     dispatch,
-    mountScoped,
-    mountFeature: (binding, handlers) => mountFeatureOnto(context, binding, handlers),
+    mountScoped: (activation) => mountScopedOnto(ownerScope, activation),
+    mountFeature: (binding, handlers) => mountFeatureOnto(context, ownerScope, binding, handlers),
     mountCapturedFeature: (binding, handlers) =>
-      mountCapturedFeatureOnto(context, binding, handlers),
-    mountAnyFeature: (binding, handlers) => mountAnyFeatureOnto(context, binding, handlers),
+      mountCapturedFeatureOnto(context, ownerScope, binding, handlers),
+    mountAnyFeature: (binding, handlers) =>
+      mountAnyFeatureOnto(context, ownerScope, binding, handlers),
     instrumentation,
   })
 
@@ -119,6 +144,7 @@ export const makeCapturedAppRuntime = <
     const DirectRequires extends ReadonlyArray<FeatureRequirement>,
   >(
     hostContext: Context.Context<HostServices>,
+    ownerScope: Scope.Scope,
     binding: FeatureBinding<Summary, ROut, DirectRequires>,
     handlers: FeatureMountHandlers<
       FeatureSummaryUsesInput<Summary>,
@@ -126,37 +152,35 @@ export const makeCapturedAppRuntime = <
       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 mountInto = (scope: Scope.CloseableScope) =>
+      Effect.flatMap(binding.load, (loaded) => {
+        if (
+          !hasFeatureRequirements<
+            HostServices,
+            FeatureSummaryOpenServices<Summary>,
+            DirectRequires
+          >(hostContext, loaded.requires)
+        ) {
+          return missingHostServices(binding.manifest.name)
+        }
+        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, scope)),
+          )
+        })
       })
-    })
-    return forkFeatureMount(mountHost, scope, mount, handlers.onFailed)
+    return startMount(mountHost, ownerScope, (scope) =>
+      forkFeatureMount(mountHost, scope, instrumented(mountInto(scope)), handlers.onFailed),
+    )
   }
 
   const mountCapturedFeatureOnto = <
@@ -166,6 +190,7 @@ export const makeCapturedAppRuntime = <
     const DirectRequires extends ReadonlyArray<FeatureRequirement>,
   >(
     hostContext: Context.Context<HostServices>,
+    ownerScope: Scope.Scope,
     binding: CapturedFeatureBinding<Summary, ROut, DirectRequires>,
     handlers: CapturedFeatureMountHandlers<
       FeatureSummaryMountProps<Summary>,
@@ -176,58 +201,52 @@ export const makeCapturedAppRuntime = <
       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 mountInto = (scope: Scope.CloseableScope) =>
+      Effect.flatMap(binding.load, (loaded) => {
+        if (
+          !hasFeatureRequirements<
+            HostServices,
+            FeatureSummaryOpenServices<Summary>,
+            DirectRequires
+          >(hostContext, loaded.requires)
+        ) {
+          return missingHostServices(binding.manifest.name)
+        }
+        const input = loaded.usesInput ? binding.parseInput(handlers.props) : Option.some(undefined)
+        return Option.match(input, {
+          onNone: () => invalidMountProps(binding.manifest.name),
+          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, scope)))
+            }),
+        })
       })
-    })
-    return forkFeatureMount(mountHost, scope, mount, handlers.onFailed)
+    return startMount(mountHost, ownerScope, (scope) =>
+      forkFeatureMount(mountHost, scope, instrumented(mountInto(scope)), handlers.onFailed),
+    )
   }
 
   const mountAnyFeatureOnto = <HostServices>(
     hostContext: Context.Context<HostServices>,
+    ownerScope: Scope.Scope,
     binding: AnyFeatureBinding,
     handlers: AnyFeatureMountHandlers,
   ): (() => void) =>
     binding.capture((exactBinding) =>
-      mountCapturedFeatureOnto(hostContext, exactBinding, {
+      mountCapturedFeatureOnto(hostContext, ownerScope, exactBinding, {
         props: handlers.props,
         onLive: (childRuntime) => handlers.onLive(childRuntime),
         onFailed: handlers.onFailed,
@@ -245,11 +264,13 @@ export const makeCapturedAppRuntime = <
     ): Option.Option<Service> => Context.getOption(rootContext, tag),
     runRender,
     dispatch,
-    mountScoped,
-    mountFeature: (binding, handlers) => mountFeatureOnto(rootContext, binding, handlers),
+    mountScoped: (activation) => mountScopedOnto(rootScope, activation),
+    mountFeature: (binding, handlers) =>
+      mountFeatureOnto(rootContext, rootScope, binding, handlers),
     mountCapturedFeature: (binding, handlers) =>
-      mountCapturedFeatureOnto(rootContext, binding, handlers),
-    mountAnyFeature: (binding, handlers) => mountAnyFeatureOnto(rootContext, binding, handlers),
+      mountCapturedFeatureOnto(rootContext, rootScope, binding, handlers),
+    mountAnyFeature: (binding, handlers) =>
+      mountAnyFeatureOnto(rootContext, rootScope, binding, handlers),
     boot: () => {
       if (status.disposed || status.booted) {
         return
@@ -265,6 +286,9 @@ export const makeCapturedAppRuntime = <
       }
       status.disposed = true
       activationDisposers.forEach((dispose) => dispose())
+      // On the default runtime: the managed runtime is going away underneath us and
+      // must not interrupt the finalizers of what it mounted.
+      Effect.runFork(Scope.close(rootScope, Exit.succeed(undefined)))
       void runtime.dispose()
     },
     isDisposed: () => status.disposed,

package/src/runtime/eventBudget.ts

@@ -1,6 +1,7 @@
 import { Boolean as Bool, Effect, FiberRef, GlobalValue, MutableRef, Option } from 'effect'
 import { isDev } from '../internal/env'
 import { EventLoopOverflow } from '../internal/errors'
+import { microtask } from '../internal/platform'
 
 interface EventLimitFields {
   readonly errorAt: number
@@ -20,7 +21,7 @@ export interface EventBudget {
 }
 
 const rethrowOverflow = (error: EventLoopOverflow): void =>
-  queueMicrotask(() => {
+  microtask(() => {
     // oxlint-disable-next-line reform-rules/no-throw -- only way to surface the halt to the host's global error handler
     throw error
   })