@playfast/reform 1.1.1 → 1.2.0

package/src/runtime/appRuntime.ts

@@ -1,78 +1,308 @@
 import { Cause, Context, Effect, Exit, Fiber, 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 {
+  AnyFeatureGraphSummary,
+  FeatureSummaryCompositionIdentity,
+  FeatureSummaryContract,
+  FeatureSummaryInput,
+  FeatureSummaryMountProps,
+  FeatureSummaryName,
+  FeatureSummaryOpenServices,
+  FeatureSummaryUsesInput,
+} from '../graph/closure'
 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 { 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 interface FeatureMountHandlersExternalApi {
-  readonly props?: unknown
-  readonly onLive: (runtime: RuntimeHandle) => void
+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
 }
-export type FeatureMountHandlers = FeatureMountHandlersExternalApi
 
-export interface RuntimeHandle {
-  read<Identifier, Service>(tag: Context.Tag<Identifier, Service>): Service
+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
-  mountFeature(binding: FeatureBinding, handlers: FeatureMountHandlers): () => 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 extends RuntimeHandle {
+export interface AppRuntime<Services = UnspecifiedRuntimeServices> extends RuntimeHandle<Services> {
   boot(): void
   dispose(): void
   isDisposed(): boolean
 }
 
-export const makeAppRuntime = (scene: Scene, options: ReformOptions = {}): AppRuntime => {
+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 rootContext = forceSync(() => runtime.runSync(Effect.context<MountedServices>()))
+  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)
 
-  // Inert past dispose: host may still render tearing-down trees; forked fibers outlive cleanup
+  // Hosts can still render tearing-down trees after the managed runtime is disposed.
   const status = { disposed: false, booted: false }
+  const activationDisposers = new Set<() => void>()
 
-  // Self-contained Effect runs on default runtime after dispose (never throw mid-render)
+  // 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) {
+    if (status.disposed || Option.isNone(rootBus)) {
       return
     }
-    runtime.runFork(publish(priority, event))
+    runtime.runFork(publish(priority, event).pipe(Effect.provideService(Bus, rootBus.value)))
   }
 
-  const makeChildRuntime = <R>(context: Context.Context<R>): RuntimeHandle => ({
-    read: <Identifier, Service>(tag: Context.Tag<Identifier, Service>): Service =>
-      Context.unsafeGet(context, tag),
+  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 = <R>(
-    hostContext: Context.Context<R>,
-    binding: FeatureBinding,
-    handlers: FeatureMountHandlers,
+  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(
-      mountFeature(binding, hostContext, handlers.props).pipe(
+      mount.pipe(
         Effect.provideService(Scope.Scope, scope),
         Effect.matchCause({
           onFailure: (cause) => {
-            // Disposer-cancelled mounts are not failures
+            // Disposer interruption is cancellation, not a failed feature.
             if (!Cause.isInterruptedOnly(cause)) {
               handlers.onFailed(
                 Option.getOrElse(
@@ -82,14 +312,13 @@ export const makeAppRuntime = (scene: Scene, options: ReformOptions = {}): AppRu
               )
             }
           },
-          onSuccess: (context) => handlers.onLive(makeChildRuntime(context)),
+          onSuccess: () => undefined,
         }),
       ),
     )
     return () => {
-      // Interrupt sync before scheduler: Scope.close alone does not interrupt (StrictMode)
+      // Interrupt first, then await finalizer registration before closing the scope.
       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))),
       )
@@ -101,13 +330,125 @@ export const makeAppRuntime = (scene: Scene, options: ReformOptions = {}): AppRu
     }
   }
 
-  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),
+  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
@@ -122,6 +463,7 @@ export const makeAppRuntime = (scene: Scene, options: ReformOptions = {}): AppRu
         return
       }
       status.disposed = true
+      activationDisposers.forEach((dispose) => dispose())
       void runtime.dispose()
     },
     isDisposed: () => status.disposed,
@@ -129,3 +471,22 @@ export const makeAppRuntime = (scene: Scene, options: ReformOptions = {}): AppRu
   }
   return app
 }
+
+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))
+}

package/src/runtime/eventBudget.test.ts

@@ -112,10 +112,7 @@ it.live('crossing the hard limit halts the runtime with EventLoopOverflow', () =
     yield* publish('Normal', Event.construct(Bumped, { to: 9_999 }))
     yield* Effect.sleep(Duration.millis(20))
     expect(store.get()).toBe(before)
-  }).pipe(
-    Effect.provide(TestLayer),
-    Logger.withMinimumLogLevel(LogLevel.None),
-  )
+  }).pipe(Effect.provide(TestLayer), Logger.withMinimumLogLevel(LogLevel.None))
 })
 
 it.live('the window resets when the event loop yields — bursty traffic never trips', () => {

package/src/runtime/eventBudget.ts

@@ -2,16 +2,17 @@ import { Boolean as Bool, Effect, FiberRef, GlobalValue, MutableRef, Option } fr
 import { isDev } from '../internal/env'
 import { EventLoopOverflow } from '../internal/errors'
 
-export interface ReformOptions {
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- presence-optional public config; absent fields fall back to the built-in defaults
-  readonly maxEventsPerJsTick?: {
-    // oxlint-disable-next-line reform-rules/no-optional-fields -- presence-optional public config; absent fields fall back to the built-in defaults
-    readonly errorAt?: number
-    // oxlint-disable-next-line reform-rules/no-optional-fields -- presence-optional public config; absent fields fall back to the built-in defaults
-    readonly warningAt?: number
-  }
+interface EventLimitFields {
+  readonly errorAt: number
+  readonly warningAt: number
 }
 
+interface ReformOptionFields {
+  readonly maxEventsPerJsTick: Partial<EventLimitFields>
+}
+
+export interface ReformOptions extends Partial<ReformOptionFields> {}
+
 export interface EventBudget {
   readonly errorAt: number
   readonly warningAt: Option.Option<number>

package/src/runtime/hardening.test.ts

@@ -1,6 +1,7 @@
 import { expect, it } from '@effect/vitest'
 import { Cause, Duration, Effect, Exit, Layer, LogLevel, Logger, Schema as S, Scope } from 'effect'
-import { Channel, Channels, Engine, Event, Procedure, publish, Reducer, State } from '../index'
+import { Channel, Engine, Event, Procedure, publish, Reducer, State } from '../index'
+import { Channels } from '../channel/channel'
 
 it.live('a reducer that throws is isolated; the loop keeps draining', () => {
   class Counter extends State.make('counter', S.Number) {}
@@ -27,10 +28,7 @@ it.live('a reducer that throws is isolated; the loop keeps draining', () => {
     yield* publish('Normal', Event.construct(Good, {}))
     yield* Effect.sleep(Duration.millis(10))
     expect(store.get()).toBe(1)
-  }).pipe(
-    Effect.provide(TestLayer),
-    Logger.withMinimumLogLevel(LogLevel.None),
-  )
+  }).pipe(Effect.provide(TestLayer), Logger.withMinimumLogLevel(LogLevel.None))
 })
 
 it.effect('two different channels registered under one name are rejected', () => {
@@ -91,10 +89,7 @@ it.live('remount overlap keeps the channel alive', () => {
     const secondScope = yield* Scope.make()
 
     yield* Layer.buildWithScope(Channel.live(FirstLane), firstScope)
-    yield* Layer.buildWithScope(
-      Layer.mergeAll(Channel.live(SecondLane), WorkLive),
-      secondScope,
-    )
+    yield* Layer.buildWithScope(Layer.mergeAll(Channel.live(SecondLane), WorkLive), secondScope)
     yield* Scope.close(firstScope, Exit.void)
 
     yield* publish('Normal', Event.construct(Fired, {}))