@playfast/reform 0.0.2 → 0.0.3

package/src/compose/composition.ts

@@ -0,0 +1,112 @@
+import { Context, Effect, Layer, type Schema } from 'effect'
+import type { YieldWrap } from 'effect/Utils'
+import { type Manifest, definitionClass } from '../definition/definition'
+import { type Ctx } from '../internal/ctx'
+import type { Tracker } from '../internal/track'
+import { CurrentTracker } from '../internal/track'
+import { CurrentSlots, type SlotHost } from './host'
+import type { Node, SlotClass } from './slot'
+import type { UiClass, UiContract } from './ui'
+import { Props } from './props'
+
+/** Everything the host injects per render: the instance props, the dependency tracker, and slot bindings. */
+export interface RenderEnv {
+  readonly props: unknown
+  readonly tracker: Tracker
+  readonly slots: SlotHost
+}
+
+/** A mounted composition: given a render environment, produces the current frame's node. */
+export interface CompositionService {
+  readonly render: (env: RenderEnv) => Effect.Effect<Node, never, never>
+}
+
+export interface CompositionConfig {
+  readonly title: string
+  readonly description?: string
+  // `any` in the encoded/context slots is required by Schema's variance for
+  // branded/Class schemas (e.g. `Todo`); only the decoded type `P` is used.
+  readonly props?: Schema.Schema<any, any>
+  readonly states?: ReadonlyArray<unknown>
+  readonly calcs?: ReadonlyArray<unknown>
+  readonly events?: ReadonlyArray<unknown>
+  readonly slots?: Record<string, SlotClass>
+  // The UI contract this composition resolves. Typed as a manifest carrier (not
+  // the full `UiClass`, whose invariant `impl` tag would force the contract type
+  // to leak here) so reflection — the dev tool, proofs — can read `ui.manifest`.
+  readonly ui: { readonly manifest: Manifest & { readonly kind: 'Ui' } }
+}
+
+type PropsOf<Config> = Config extends { props: Schema.Schema<infer P, any> } ? P : unknown
+
+export interface CompositionClass<out P, out C extends UiContract = UiContract> {
+  new (): {}
+  readonly manifest: Manifest & { readonly kind: 'Composition' } & CompositionConfig
+  /** Phantom carrying the props type for `provide(slot, composition)` checks. */
+  readonly Props: P
+  /**
+   * Phantom carrying the resolved UI contract (props + events + slots). It lets
+   * reflection consumers — proofs, the dev tool — recover the full contract from
+   * a composition value and stay fully typed. Covariant (output only); the
+   * invariant `impl` tag is never stored here, so no variance regression.
+   */
+  readonly Contract: C
+  readonly tag: Context.Tag<CompositionService, CompositionService>
+}
+
+/**
+ * A component's logic. The *definition* (`Composition.make`) is a reflectable
+ * manifest that doubles as a requirement/tag; the *implementation*
+ * (`Composition.live`) is the synchronous body, provided separately and
+ * checked against it.
+ */
+export const make = <const Config extends CompositionConfig, C extends UiContract>(
+  name: string,
+  // Constrain `ui` to the full `UiClass<C>` so `C` is inferred here; the stored
+  // manifest still sees only the erased `{ manifest }` carrier (CompositionConfig),
+  // so the manifest type — and its variance — is unchanged.
+  config: Config & { readonly ui: UiClass<C> },
+): CompositionClass<PropsOf<Config>, C> => {
+  const tag = Context.GenericTag<CompositionService, CompositionService>(
+    `reform/composition/${name}`,
+  )
+  const manifest = { kind: 'Composition' as const, name, ...config }
+  return definitionClass<CompositionClass<PropsOf<Config>, C>>({ manifest, tag })
+}
+
+/**
+ * Wire a composition's synchronous logic (D2): read state, acquire triggers,
+ * resolve the UI, return the view. Its requirements (minus `Props`, which the
+ * host injects per render) surface as the Layer's `RIn`; the runtime runs the
+ * body per render within the captured context.
+ */
+export const live = <P, Eff extends YieldWrap<Effect.Effect<unknown, never, unknown>>>(
+  // `live` doesn't use the contract type; accept any composition.
+  composition: CompositionClass<P, any>,
+  body: () => Generator<Eff, Node, never>,
+): Layer.Layer<CompositionService, never, Exclude<Ctx<Eff>, Props>> => {
+  const logic = Effect.gen(body)
+  return Layer.effect(
+    composition.tag,
+    Effect.gen(function* () {
+      // Capture the build-time context (state stores, calc, ui, bus). `Props`,
+      // the tracker, and slots are injected per render below.
+      const context = yield* Effect.context<Exclude<Ctx<Eff>, Props>>()
+      const render = (env: RenderEnv): Effect.Effect<Node, never, never> =>
+        // Total once fully provided: the body is synchronous, reads can't fail,
+        // and every requirement is now satisfied (D2). `Effect.gen` widens the
+        // error channel to `unknown` for a generic body, so we restate it.
+        logic.pipe(
+          Effect.provideService(Props, env.props),
+          Effect.provideService(CurrentTracker, env.tracker),
+          Effect.provideService(CurrentSlots, env.slots),
+          Effect.provide(context),
+        ) as Effect.Effect<Node, never, never>
+      return { render }
+    }),
+  )
+}
+
+/** Run a mounted composition for one frame, producing its node. */
+export const render = (service: CompositionService, env: RenderEnv): Effect.Effect<Node, never, never> =>
+  service.render(env)

package/{dist/dts/compose/host.d.ts → src/compose/host.ts}

@@ -1,5 +1,6 @@
-import { Context } from 'effect';
-import type { Node } from './slot.js';
+import { Context } from 'effect'
+import type { Node } from './slot'
+
 /**
  * Binds a parent's slots to concrete child renderers. The host package
  * (`@reform/react`) builds one per composition instance from the manifest's
@@ -7,11 +8,8 @@ import type { Node } from './slot.js';
  * child. Core stays renderer-neutral — it only defines this hole.
  */
 export interface SlotHost {
-    slot(name: string): (props: unknown) => Node;
+  slot(name: string): (props: unknown) => Node
 }
-declare const CurrentSlots_base: Context.TagClass<CurrentSlots, "reform/Slots", SlotHost>;
+
 /** The active composition's slot bindings, provided per render by the host. */
-export declare class CurrentSlots extends CurrentSlots_base {
-}
-export {};
-//# sourceMappingURL=host.d.ts.map
+export class CurrentSlots extends Context.Tag('reform/Slots')<CurrentSlots, SlotHost>() {}

package/{dist/esm/compose/props.js → src/compose/props.ts}

@@ -1,4 +1,5 @@
-import { Context } from 'effect';
+import { Context } from 'effect'
+
 /**
  * The current composition instance's props. Bound per render by the runtime; a
  * composition body reads them with `const { todo } = yield* Props`.
@@ -6,6 +7,4 @@ import { Context } from 'effect';
  * (Per-instance typing of Props is DESIGN #26 — for now the value is opaque and
  * narrowed at the use site against the composition's declared props schema.)
  */
-export class Props extends Context.Tag('reform/Props')() {
-}
-//# sourceMappingURL=props.js.map
+export class Props extends Context.Tag('reform/Props')<Props, any>() {}

package/src/compose/provide.ts

@@ -0,0 +1,70 @@
+import { type Context, Layer } from 'effect'
+import { InvalidProvideTarget } from '../internal/errors'
+import type { CompositionClass } from './composition'
+import {
+  type EngineServices,
+  type FeatureClass,
+  isFeature,
+  type ProvidedBy,
+  type RequireCarrier,
+} from '../feature/feature'
+import { isSlot, type SlotChild, type SlotClass } from './slot'
+import { isUi, type UiClass, type UiContract, type ViewImpl } from './ui'
+
+/**
+ * Wire an implementation to a contract. Provides a `.make` presentation to a UI
+ * contract, a child composition into a parent's slot, or a `Feature` into a slot.
+ * The compose code never imports its implementations — they meet here.
+ */
+export function provide<C extends UiContract>(
+  contract: UiClass<C>,
+  view: ViewImpl<C>,
+): Layer.Layer<ViewImpl<C>>
+export function provide<Comp extends CompositionClass<any, any>>(
+  hole: SlotClass<Comp>,
+  composition: Comp,
+): Layer.Layer<CompositionClass<unknown>>
+/**
+ * Fill a slot with a feature. The slot's child composition type
+ * (`CompositionClass<P, C>`) must match the feature's mounted composition, so the
+ * facade/contract stays typed. The returned layer surfaces the feature's shared
+ * requirement (`EngineServices | ProvidedBy<Requires>`) as an open `RIn`, so the
+ * scene that wires it won't compile unless it provides the matching `Core` — even
+ * for a lazy feature whose own `.live` layer isn't built until mount.
+ */
+export function provide<
+  Comp extends CompositionClass<any, any>,
+  ROut,
+  Requires extends ReadonlyArray<RequireCarrier>,
+>(
+  hole: SlotClass<Comp>,
+  feature: FeatureClass<
+    Comp extends CompositionClass<infer P, any> ? P : never,
+    Comp extends CompositionClass<any, infer C> ? C : never,
+    ROut,
+    Requires
+  >,
+): Layer.Layer<SlotChild, never, EngineServices | ProvidedBy<Requires>>
+export function provide(target: unknown, impl: unknown): Layer.Layer<never, never, unknown> {
+  // Discriminate the target by its nominal brand, not by which DI-hole property
+  // happens to exist: a UI contract provides under its `impl` tag, a slot under
+  // its `tag`. Anything else is a wiring mistake. The overloads above pair
+  // `impl` with the chosen tag; this implementation sees both erased, so view
+  // the tag loosely (the one documented cast) to provide the service under it.
+  const tag = (isUi(target) ? target.impl : isSlot(target) ? target.tag : undefined) as
+    | Context.Tag<unknown, unknown>
+    | undefined
+  if (tag === undefined) throw new InvalidProvideTarget()
+  if (isFeature(impl)) {
+    const eager = impl.eagerModule
+    // Lazy: bind the `FeatureBinding`; the host drives load → mount, painting the
+    // placeholders. Default: bind the composition (so the existing `Compose` path
+    // renders it, no host, no flash) and merge the eager `.live` layer, whose `RIn`
+    // surfaces to the scene. Either way the overload's return type carries the
+    // shared `RIn`, so the scene still type-demands `Core`.
+    return eager === undefined
+      ? Layer.succeed(tag, impl.binding)
+      : Layer.merge(Layer.succeed(tag, impl.binding.composition), eager.layer)
+  }
+  return Layer.succeed(tag, impl)
+}

package/{dist/dts/compose/slot.d.ts → src/compose/slot.ts}

@@ -1,17 +1,22 @@
-import { Context } from 'effect';
-import type { CompositionClass } from './composition.js';
-import type { FeatureBinding } from '../feature/feature.js';
-import type { Node } from '../ui/node.js';
-export type { Node };
+import { Context } from 'effect'
+import { definitionClass } from '../definition/definition'
+import type { CompositionClass } from './composition'
+import type { FeatureBinding } from '../feature/feature'
+import type { Node } from '../ui/node'
+
+export type { Node }
+
 /** Any composition, used where only the slot's structural role matters. */
-type AnyComposition = CompositionClass<any, any>;
+type AnyComposition = CompositionClass<any, any>
+
 /**
  * What a slot can be filled with: a plain child composition (the host renders it
  * directly), or a `FeatureBinding` from `provide(slot, Feature)` (the host drives
  * its lazy/eager mount lifecycle). The slot's DI tag holds one of these; the host
  * discriminates by the `FeatureBinding` brand.
  */
-export type SlotChild = CompositionClass<unknown> | FeatureBinding;
+export type SlotChild = CompositionClass<unknown> | FeatureBinding
+
 /**
  * Phantom instance shape: `ItemSlot` used as a *type* denotes this. It carries
  * the child *composition* type `Comp`, so the slot knows both the external props
@@ -20,8 +25,9 @@ export type SlotChild = CompositionClass<unknown> | FeatureBinding;
  * proof facade, drive.
  */
 export interface SlotInstance<Comp extends AnyComposition> {
-    readonly _slot: Comp;
+  readonly _slot: Comp
 }
+
 /**
  * A DI hole for a child composition. The parent declares
  * `slot('Item')<typeof TodoItem>()` and renders through it; the concrete child
@@ -32,18 +38,29 @@ export interface SlotInstance<Comp extends AnyComposition> {
  * by `provide`'s signature, not the (invariant) tag.
  */
 /** Nominal brand identifying a slot at runtime (Effect's `TypeId` idiom). */
-export declare const SlotTypeId: unique symbol;
-export type SlotTypeId = typeof SlotTypeId;
+export const SlotTypeId: unique symbol = Symbol.for('reform/Slot')
+export type SlotTypeId = typeof SlotTypeId
+
 export interface SlotClass<Comp extends AnyComposition = AnyComposition> {
-    new (): SlotInstance<Comp>;
-    readonly [SlotTypeId]: SlotTypeId;
-    readonly kind: 'Slot';
-    /** Internal DI tag the filling child (composition or feature binding) is provided under. */
-    readonly tag: Context.Tag<SlotChild, SlotChild>;
+  new (): SlotInstance<Comp>
+  readonly [SlotTypeId]: SlotTypeId
+  readonly kind: 'Slot'
+  /** Internal DI tag the filling child (composition or feature binding) is provided under. */
+  readonly tag: Context.Tag<SlotChild, SlotChild>
 }
+
 /** Whether a value is a slot — discriminates a `provide` target by brand. */
-export declare const isSlot: (u: unknown) => u is SlotClass;
+export const isSlot = (u: unknown): u is SlotClass =>
+  (typeof u === 'function' || typeof u === 'object') && u !== null && SlotTypeId in u
+
 /** The props a slot renders with — the child composition's external props. */
-export type SlotProps<S> = S extends SlotInstance<infer Comp> ? Comp['Props'] : never;
-export declare const slot: (name: string) => <Comp extends AnyComposition = AnyComposition>() => SlotClass<Comp>;
-//# sourceMappingURL=slot.d.ts.map
+export type SlotProps<S> = S extends SlotInstance<infer Comp> ? Comp['Props'] : never
+
+export const slot =
+  (name: string) =>
+  // Defaulted so a slot whose child carries no meaningful props/contract can be
+  // declared bare (`slot('Tree')()`); pass `typeof Child` to type the facade.
+  <Comp extends AnyComposition = AnyComposition>(): SlotClass<Comp> => {
+    const tag = Context.GenericTag<SlotChild, SlotChild>(`reform/slot/${name}`)
+    return definitionClass<SlotClass<Comp>>({ [SlotTypeId]: SlotTypeId, kind: 'Slot' as const, tag })
+  }

package/src/compose/ui.ts

@@ -0,0 +1,97 @@
+import { Context, Effect, Option } from 'effect'
+import { type Manifest, yieldableClass } from '../definition/definition'
+import { CaptureSink } from '../internal/capture'
+import { SlotRenderingUnavailable } from '../internal/errors'
+import type { Trigger } from '../ui/trigger'
+import { CurrentSlots } from './host'
+import { type Node, type SlotInstance, type SlotProps } from './slot'
+
+export interface UiContract {
+  props: unknown
+  slots?: Record<string, SlotInstance<any>>
+  events?: Record<string, Trigger<any>>
+}
+
+type PropsOf<C extends UiContract> = C['props']
+type EventsOf<C extends UiContract> = C extends { events: infer E } ? E : Record<never, never>
+type SlotsOf<C extends UiContract> = C extends { slots: infer S }
+  ? { readonly [K in keyof S]: (props: SlotProps<S[K]>) => Node }
+  : Record<never, never>
+
+/** What the composition logic calls: props + handlers in, a node out. Slots are bound by the renderer. */
+export type LogicView<C extends UiContract> = (props: PropsOf<C>, events?: EventsOf<C>) => Node
+
+/** What `.make` authors: the pure presentation. Slots are injected by the renderer. */
+export type ViewImpl<C extends UiContract> = (
+  props: PropsOf<C>,
+  slots: SlotsOf<C>,
+  events: EventsOf<C>,
+) => Node
+
+/** Nominal brand identifying a UI contract at runtime (Effect's `TypeId` idiom). */
+export const UiTypeId: unique symbol = Symbol.for('reform/Ui')
+export type UiTypeId = typeof UiTypeId
+
+export interface UiClass<C extends UiContract>
+  extends Effect.Effect<LogicView<C>, never, ViewImpl<C>> {
+  new (): {}
+  readonly [UiTypeId]: UiTypeId
+  readonly manifest: Manifest & { readonly kind: 'Ui' }
+  /** Internal DI tag the `Ui.make` presentation is provided under. */
+  readonly impl: Context.Tag<ViewImpl<C>, ViewImpl<C>>
+}
+
+/** Whether a value is a UI contract — discriminates a `provide` target by brand. */
+export const isUi = (u: unknown): u is UiClass<UiContract> =>
+  (typeof u === 'function' || typeof u === 'object') && u !== null && UiTypeId in u
+
+/**
+ * A renderer-neutral UI contract. The logic resolves it (`yield* TodoAppUi`) to
+ * a `(props, events) => node` view with slots already bound; `.make` authors the
+ * presentation. Core defines the contract; `@reform/react` does the rendering.
+ */
+export const ui =
+  (name: string) =>
+  <C extends UiContract>(): UiClass<C> => {
+    const impl = Context.GenericTag<ViewImpl<C>, ViewImpl<C>>(`reform/ui/${name}`)
+    const read = Effect.gen(function* () {
+      const render = yield* impl
+      // Slots are bound by the host (`@reform/react`) per composition instance.
+      // Core has no renderer, so without a host every slot access throws.
+      const host = yield* Effect.serviceOption(CurrentSlots)
+      const slots = new Proxy({} as SlotsOf<C>, {
+        get(_t, key) {
+          if (Option.isNone(host)) {
+            throw new SlotRenderingUnavailable({ slot: String(key) })
+          }
+          return host.value.slot(String(key))
+        },
+      })
+      // A capturing host (proofs, the dev tool) reports each render's observable
+      // surface without replacing the presentation. Absent in production.
+      const sink = yield* Effect.serviceOption(CaptureSink)
+      return (props: PropsOf<C>, events?: EventsOf<C>) => {
+        if (Option.isSome(sink)) {
+          sink.value.record({
+            name,
+            props,
+            events: (events ?? {}) as Record<string, Trigger<unknown>>,
+          })
+        }
+        return render(props, slots, (events ?? {}) as EventsOf<C>)
+      }
+    })
+    return yieldableClass(read, {
+      [UiTypeId]: UiTypeId,
+      manifest: { kind: 'Ui' as const, name },
+      impl,
+    })
+  }
+
+/**
+ * Author the pure presentation for a contract — `Ui.make(TodoAppUi, (props,
+ * slots, events) => node)`. The contract argument fixes the view's types; wire
+ * the result with `provide(contract, view)`.
+ */
+export const make = <C extends UiContract>(_contract: UiClass<C>, view: ViewImpl<C>): ViewImpl<C> =>
+  view

package/src/definition/definition.ts

@@ -0,0 +1,74 @@
+import { Effect } from 'effect'
+import { attachInspectable } from '../internal/inspect'
+
+/** A definition's `toJSON`: its reflectable manifest, else its raw statics. */
+const describe = (statics: object): unknown => (statics as { manifest?: unknown }).manifest ?? statics
+
+/**
+ * The reflectable descriptor every primitive carries (principle #6). The editor
+ * and proof packages read these without running any logic.
+ */
+export type Kind =
+  | 'State'
+  | 'StateGroup'
+  | 'StateFamily'
+  | 'Event'
+  | 'EventGroup'
+  | 'Reducer'
+  | 'Calc'
+  | 'CalcFamily'
+  | 'AsyncCalc'
+  | 'RemoteState'
+  | 'Boundary'
+  | 'Procedure'
+  | 'Channel'
+  | 'Composition'
+  | 'Ui'
+  | 'Slot'
+  | 'Feature'
+
+export interface Manifest {
+  readonly kind: Kind
+  readonly name: string
+}
+
+/**
+ * Build a class whose *static* side is itself an Effect, so `yield* TheClass`
+ * runs `read` and returns its value (the same mechanism `Context.Tag` uses).
+ * Subclasses inherit the protocol through the prototype chain, so the user's
+ * `class FeedState extends State.make(...) {}` is yieldable too.
+ *
+ * `statics` (manifest, `.live`, tag, …) are attached as own properties
+ * and likewise inherited by the subclass.
+ */
+export const yieldableClass = <A, E, R, Statics extends object>(
+  read: Effect.Effect<A, E, R>,
+  statics: Statics,
+): { new (): {} } & Effect.Effect<A, E, R> & Statics => {
+  class Base {}
+  Object.setPrototypeOf(Base, read)
+  // `defineProperty` over `Reflect.ownKeys`, not `Object.assign` over
+  // `Object.entries`: a static can shadow a non-writable own property of the
+  // class function (notably `name`, which a `Source`-shaped definition like a
+  // Calc carries) and `assign` would throw on those; and `ownKeys` (unlike
+  // `entries`) carries symbol-keyed statics — the `TypeId` brands.
+  for (const key of Reflect.ownKeys(statics)) {
+    const value = (statics as Record<PropertyKey, unknown>)[key]
+    Object.defineProperty(Base, key, { value, writable: true, enumerable: true, configurable: true })
+  }
+  // Print like an Effect value (the manifest), not `[object Object]`.
+  attachInspectable(Base, () => describe(statics))
+  return Base as never
+}
+
+/**
+ * Build a *definition class*: an empty constructible carrying static marker data
+ * (manifest, tag, policy, members, …) that the editor and proof packages reflect
+ * on. Definition interfaces declare phantom, type-only fields — a composition's
+ * `Props`, a family instance's `Key` — that exist purely for inference and have
+ * no runtime value, so the assembled object cannot *structurally* satisfy the
+ * interface. The one assertion to `Class` lives here, documented, instead of a
+ * scattered `as never` / `as unknown as` at every `*.make`.
+ */
+export const definitionClass = <Class>(statics: object): Class =>
+  attachInspectable(Object.assign(class {}, statics), () => describe(statics)) as unknown as Class

package/src/event/event.ts

@@ -0,0 +1,65 @@
+import { Effect, PubSub, Runtime, type Schema } from 'effect'
+import { type Manifest, definitionClass } from '../definition/definition'
+import { Bus, publish, type Tagged } from '../runtime/bus'
+import type { Trigger } from '../ui/trigger'
+
+/** The dispatched value of an event: `{ _tag, ...payload }`, matched with `Match.tags`. */
+export type EventOf<N extends string, P> = Tagged & { readonly _tag: N } & P
+
+export interface EventManifest<N extends string, P> extends Manifest {
+  readonly kind: 'Event'
+  readonly name: N
+  readonly schema: Schema.Schema<P, any>
+}
+
+export interface EventClass<out N extends string, in out P> {
+  new (): {}
+  readonly manifest: EventManifest<N, P>
+  readonly tag: N
+  /** Carrier for `Event.construct` — builds the tagged value `{ _tag, ...payload }`. */
+  readonly build: (payload: P) => EventOf<N, P>
+  /** Carrier for `Event.trigger` — the UI callback effect (High priority). */
+  readonly trigger: Effect.Effect<Trigger<P>, never, Bus>
+}
+
+export type AnyEvent = EventClass<string, any>
+export type EventType<E> = E extends EventClass<infer N, infer P> ? EventOf<N, P> : never
+
+/** A pure data fact. Events depend on nothing — only reducers tie them to state. */
+export const make = <const N extends string, P>(
+  name: N,
+  schema: Schema.Schema<P, any>,
+): EventClass<N, P> => {
+  const build = (payload: P): EventOf<N, P> => ({ _tag: name, ...payload })
+  const trigger = Effect.gen(function* () {
+    const bus = yield* Bus
+    const runtime = yield* Effect.runtime<never>()
+    // Dispatch synchronously: on the unbounded bus `publish` only enqueues and
+    // returns, so `runSync` never suspends and no fiber is forked per UI event.
+    // The drain loop still folds reducers on its own fiber — publish is pure offer.
+    return (payload: P) => {
+      Runtime.runSync(runtime)(PubSub.publish(bus, { priority: 'High', event: build(payload) }))
+    }
+  })
+  return definitionClass<EventClass<N, P>>({
+    manifest: { kind: 'Event' as const, name, schema },
+    tag: name,
+    build,
+    trigger,
+  })
+}
+
+/** Construct the tagged value for an event (used for `boot` events). */
+export const construct = <N extends string, P>(event: EventClass<N, P>, payload: P): EventOf<N, P> =>
+  event.build(payload)
+
+/** Dispatch as a follow-up (Normal priority) from a procedure/effect. */
+export const dispatch = <N extends string, P>(
+  event: EventClass<N, P>,
+  payload: P,
+): Effect.Effect<void, never, Bus> => publish('Normal', event.build(payload))
+
+/** A callback for the UI that dispatches at High priority via the runtime. */
+export const trigger = <N extends string, P>(
+  event: EventClass<N, P>,
+): Effect.Effect<Trigger<P>, never, Bus> => event.trigger

package/src/event/eventGroup.ts

@@ -0,0 +1,14 @@
+import { definitionClass } from '../definition/definition'
+import type { AnyEvent } from './event'
+
+export interface EventGroupClass<Members extends ReadonlyArray<AnyEvent>> {
+  new (): {}
+  readonly kind: 'EventGroup'
+  readonly members: Members
+}
+
+/** Compose events into a group, the same variadic shape as `StateGroup`/`RpcGroup`. */
+export const make = <const Members extends ReadonlyArray<AnyEvent>>(
+  ...members: Members
+): EventGroupClass<Members> =>
+  definitionClass<EventGroupClass<Members>>({ kind: 'EventGroup' as const, members })