@typeonce/effect-machine 0.8.0 → 0.10.0

package/src/internal/machine/runtime.ts

@@ -18,6 +18,7 @@ import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import * as SynchronizedRef from "effect/SynchronizedRef"
 import type * as Take from "effect/Take"
+import type { ActorRef } from "../../Machine.js"
 import { ChildAlreadyExistsError, StoppedError } from "./errors.js"
 
 type ChildDescriptor = {
@@ -284,12 +285,13 @@ export type RuntimeOutcome<State, Error = never, Output = never> =
     readonly snapshot: Extract<RuntimeSnapshot<State, Error, Output>, { readonly status: "stopped" }>
   }
 
-export interface MachineRef<out State, in Event, out Error = never, out Output = never> {
+export interface MachineRef<out State, in Event, out Error = never, out Output = never, out Emitted = never> {
   readonly id: string
   readonly sessionId: string
   readonly state: Effect.Effect<State>
   readonly snapshot: Effect.Effect<RuntimeSnapshot<State, Error, Output>>
   readonly changes: Stream.Stream<RuntimeSnapshot<State, Error, Output>>
+  readonly emissions: Stream.Stream<Emitted>
   readonly join: Effect.Effect<Output, Error | StoppedError>
   readonly stop: Effect.Effect<void>
   readonly send: (event: Event) => Effect.Effect<void, StoppedError>
@@ -307,12 +309,19 @@ interface ProcessAddress<in Event> {
   readonly send: (event: Event) => Effect.Effect<void, StoppedError>
 }
 
+const isProcessAddress = (value: unknown): value is ActorRef<unknown> =>
+  typeof value === "object" && value !== null && "send" in value && typeof value.send === "function"
+
 export interface ProcessScope<Event> {
   readonly self: ProcessAddress<Event>
   readonly parent: ProcessAddress<unknown> | undefined
   readonly spawn: ProcessSpawn
   readonly sendParent: (event: unknown) => Effect.Effect<void, StoppedError>
-  readonly sendTo: (child: ChildSelector, event: unknown) => Effect.Effect<void, StoppedError>
+  readonly emit: (event: unknown) => Effect.Effect<void>
+  readonly sendTo: {
+    <TargetEvent>(target: ActorRef<TargetEvent>, event: TargetEvent): Effect.Effect<void, StoppedError>
+    (child: ChildSelector, event: unknown): Effect.Effect<void, StoppedError>
+  }
   readonly stopChild: (child: ChildSelector) => Effect.Effect<void>
   /** @internal */
   readonly failCause: (cause: Cause.Cause<unknown>) => Effect.Effect<void>
@@ -708,6 +717,10 @@ class OwnedChildRuntimeImpl implements OwnedChildRuntime {
         ownerPath: options.path,
         ownerActive: true
       })
+      const parent: ProcessAddress<unknown> = {
+        ...this.self,
+        send: (event) => options.sendParent(isCurrent, event)
+      }
       const startOptions: StartInternalOptions = {
         detached: true,
         id: options.id,
@@ -722,7 +735,7 @@ class OwnedChildRuntimeImpl implements OwnedChildRuntime {
         },
         onStopSync: () => unregisterChild(this.registry, options.id, token),
         skipStoppedOutcome: true,
-        parent: this.self,
+        parent,
         runtime: this.runtime
       }
       const execution = logic.execution
@@ -785,6 +798,9 @@ class OwnedChildRuntimeImpl implements OwnedChildRuntime {
 
 const noChildChanges = Stream.succeed(Option.none()).pipe(Stream.concat(Stream.never))
 const noParentSend = (_event: unknown): Effect.Effect<void, StoppedError> => Effect.void
+const EmissionsClosed: unique symbol = Symbol("effect/Machine/EmissionsClosed")
+
+type LazyEmissions = PubSub.PubSub<unknown> | typeof EmissionsClosed | undefined
 
 const childlessRuntime: ChildRuntime = {
   close: () => Effect.void,
@@ -1091,6 +1107,38 @@ const startGenericInternal: <
   const sessionId = yield* runtime.nextSessionId
   const id = requestedId ?? sessionId
   const queue = yield* Queue.unbounded<ProcessMessage<Event>>()
+  let emissions: LazyEmissions
+  const getOrCreateEmissions: Effect.Effect<PubSub.PubSub<unknown> | undefined> = Effect.suspend(() => {
+    const observed = emissions
+    if (observed === EmissionsClosed) return Effect.succeed(undefined)
+    if (observed !== undefined) return Effect.succeed(observed)
+    return PubSub.unbounded<unknown>().pipe(
+      Effect.flatMap((candidate) =>
+        Effect.sync(() => {
+          const latest = emissions
+          if (latest === EmissionsClosed) return [undefined, true] as const
+          if (latest !== undefined) return [latest, true] as const
+          emissions = candidate
+          return [candidate, false] as const
+        }).pipe(
+          Effect.flatMap(([selected, discard]) =>
+            discard ? PubSub.shutdown(candidate).pipe(Effect.as(selected)) : Effect.succeed(selected)
+          )
+        )
+      )
+    )
+  })
+  const closeEmissions = (): Effect.Effect<void> => {
+    const observed = emissions
+    emissions = EmissionsClosed
+    return observed === undefined || observed === EmissionsClosed ? Effect.void : PubSub.shutdown(observed)
+  }
+  const emit = (event: unknown): Effect.Effect<void> =>
+    Effect.suspend(() =>
+      emissions === undefined || emissions === EmissionsClosed
+        ? Effect.void
+        : PubSub.publish(emissions, event).pipe(Effect.asVoid)
+    )
   const termination = yield* Deferred.make<ProcessTermination>()
   const done = yield* Deferred.make<Output, Error | StoppedError>()
   const awaitCompletion = Deferred.await(done).pipe(Effect.exit, Effect.asVoid)
@@ -1161,7 +1209,7 @@ const startGenericInternal: <
   }
   const cleanupStartupFailure = <A, E>(exit: Exit.Exit<A, E>): Effect.Effect<void> =>
     Exit.isFailure(exit)
-      ? closeChildren(exit)
+      ? closeChildren(exit).pipe(Effect.andThen(closeEmissions()))
       : Effect.void
   const cleanup = onStopSync === undefined ? onStop ?? Effect.void : Effect.sync(onStopSync)
   const sendParent = overrideSendParent ?? (parent === undefined ? noParentSend : parent.send)
@@ -1171,7 +1219,11 @@ const startGenericInternal: <
     parent,
     spawn,
     sendParent,
-    sendTo,
+    emit,
+    sendTo: ((target: unknown, event: unknown) =>
+      isProcessAddress(target) ? target.send(event) : sendTo(target as ChildSelector, event)) as ProcessScope<
+        Event
+      >["sendTo"],
     stopChild,
     failCause: (cause) =>
       Deferred.succeed(termination, {
@@ -1209,7 +1261,9 @@ const startGenericInternal: <
       const runtimeSnapshot = snapshot.snapshot
       return runtimeSnapshot.status !== "active"
         ? publish
-        : publish.pipe(Effect.tap(() => notifyActiveSnapshot(onSnapshot, runtimeSnapshot)))
+        : publish.pipe(Effect.tap(() =>
+          notifyActiveSnapshot(onSnapshot, runtimeSnapshot)
+        ))
     }
 
   const completeChanges = (
@@ -1348,6 +1402,7 @@ const startGenericInternal: <
         Effect.andThen(Queue.shutdown(queue)),
         Effect.andThen(closeChildren(exit)),
         Effect.andThen(setAndPublishSnapshot(snapshot)),
+        Effect.andThen(closeEmissions()),
         Effect.andThen(Effect.sync(() => {
           if (Exit.isFailure(exit)) {
             failAcknowledgedMessage(inFlightMessage, exit.cause)
@@ -1504,6 +1559,11 @@ const startGenericInternal: <
     state: SynchronizedRef.get(current).pipe(Effect.map((current) => current.snapshot.state)),
     snapshot: SynchronizedRef.get(current).pipe(Effect.map((current) => current.snapshot)),
     changes: changesStream,
+    emissions: Stream.unwrap(
+      getOrCreateEmissions.pipe(
+        Effect.map((emissions) => emissions === undefined ? Stream.empty : Stream.fromPubSub(emissions))
+      )
+    ) as Stream.Stream<never>,
     join: Deferred.await(done),
     stop,
     send: self.send,
@@ -1657,6 +1717,7 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
   private interruptRequested = false
   private offerRevision = 0
   private inFlightMessage: ProcessMessage<unknown> | undefined
+  private emissionsPubSub: LazyEmissions
 
   constructor(
     private readonly logic: ProcessLogic<any, any, any, any, any, any>,
@@ -1690,7 +1751,11 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
       parent,
       spawn: this.childRuntime.spawn,
       sendParent,
-      sendTo: this.childRuntime.sendTo,
+      emit: (event) => this.emitEvent(event),
+      sendTo: ((target: unknown, event: unknown) =>
+        isProcessAddress(target)
+          ? target.send(event)
+          : this.childRuntime.sendTo(target as ChildSelector, event)) as ProcessScope<unknown>["sendTo"],
       stopChild: this.childRuntime.stop,
       failCause: (cause: Cause.Cause<unknown>) => this.failCause(cause)
     }
@@ -1743,7 +1808,11 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
         parent,
         spawn: self.childRuntime.spawn,
         sendParent,
-        sendTo: self.childRuntime.sendTo,
+        emit: (event) => self.emitEvent(event),
+        sendTo: ((target: unknown, event: unknown) =>
+          isProcessAddress(target)
+            ? target.send(event)
+            : self.childRuntime.sendTo(target as ChildSelector, event)) as ProcessScope<unknown>["sendTo"],
         stopChild: self.childRuntime.stop,
         failCause: (cause: Cause.Cause<unknown>) => self.failCause(cause)
       }
@@ -1838,6 +1907,10 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
     return this.changesStream()
   }
 
+  get emissions(): Stream.Stream<never> {
+    return this.emissionsStream() as Stream.Stream<never>
+  }
+
   get join(): Effect.Effect<unknown, unknown> {
     return Effect.suspend(() => {
       if (this.lifecycle === "Completed") {
@@ -2145,6 +2218,7 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
         }).pipe(
           Effect.andThen(this.childRuntime.close(exit)),
           Effect.andThen(this.setAndPublishSnapshot(snapshot)),
+          Effect.andThen(this.closeEmissions()),
           Effect.andThen(Effect.sync(() => {
             if (requested._tag === "Failure") {
               failAcknowledgedMessage(this.inFlightMessage, requested.cause)
@@ -2193,6 +2267,55 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
       : PubSub.publish(snapshot.changes, Exit.succeed<void>(undefined)).pipe(Effect.asVoid)
   }
 
+  private emitEvent(event: unknown): Effect.Effect<void> {
+    return Effect.suspend(() =>
+      this.emissionsPubSub === undefined || this.emissionsPubSub === EmissionsClosed
+        ? Effect.void
+        : PubSub.publish(this.emissionsPubSub, event).pipe(Effect.asVoid)
+    )
+  }
+
+  shutdownEmissions(): Effect.Effect<void> {
+    return this.closeEmissions()
+  }
+
+  private closeEmissions(): Effect.Effect<void> {
+    const observed = this.emissionsPubSub
+    this.emissionsPubSub = EmissionsClosed
+    return observed === undefined || observed === EmissionsClosed ? Effect.void : PubSub.shutdown(observed)
+  }
+
+  private getOrCreateEmissions(): Effect.Effect<PubSub.PubSub<unknown> | undefined> {
+    return Effect.suspend(() => {
+      const observed = this.emissionsPubSub
+      if (observed === EmissionsClosed) return Effect.succeed(undefined)
+      if (observed !== undefined) return Effect.succeed(observed)
+      return PubSub.unbounded<unknown>().pipe(
+        Effect.flatMap((candidate) =>
+          Effect.sync(() => {
+            const latest = this.emissionsPubSub
+            if (latest === EmissionsClosed) return [undefined, true] as const
+            if (latest !== undefined) return [latest, true] as const
+            this.emissionsPubSub = candidate
+            return [candidate, false] as const
+          }).pipe(
+            Effect.flatMap(([selected, discard]) =>
+              discard ? PubSub.shutdown(candidate).pipe(Effect.as(selected)) : Effect.succeed(selected)
+            )
+          )
+        )
+      )
+    })
+  }
+
+  private emissionsStream(): Stream.Stream<unknown> {
+    return Stream.unwrap(
+      this.getOrCreateEmissions().pipe(
+        Effect.map((emissions) => emissions === undefined ? Stream.empty : Stream.fromPubSub(emissions))
+      )
+    )
+  }
+
   private setAndPublishSnapshot(snapshot: RuntimeSnapshot<unknown, unknown, unknown>): Effect.Effect<void> {
     return Effect.suspend(() => {
       this.flushPendingChanges()
@@ -2407,10 +2530,13 @@ const startCompactCompiledInternal: typeof startGenericInternal = Effect.fnUntra
   // A compiled initializer is synchronous by construction. Only startup
   // callbacks that themselves return Effects need the generic initialization
   // program; the compiled drain is still provided the complete service context.
-  return yield* execution.initialSync !== undefined &&
+  const initialize = execution.initialSync !== undefined &&
       options.onReady === undefined && options.onSnapshot === undefined
     ? process.initializeCompiledSync()
     : process.initialize()
+  return yield* initialize.pipe(
+    Effect.onExit((exit) => Exit.isFailure(exit) ? process.shutdownEmissions() : Effect.void)
+  )
 }) as typeof startGenericInternal
 
 const startLogicInternal: typeof startGenericInternal = ((

package/src/internal/machine/symbols.ts

@@ -1,2 +1,5 @@
 /** @internal */
 export const InitialEventTypeId: unique symbol = Symbol("effect/Machine/InitialEvent")
+
+/** @internal Returns process logic for a child descriptor and optional input. */
+export const ChildMachineLogicTypeId: unique symbol = Symbol("effect/Machine/ChildMachineLogic")

package/src/internal/machine/topology.ts

@@ -21,6 +21,8 @@ export const HistoryTargetTypeId: unique symbol = Symbol("effect/Machine/History
 
 export const ChoiceTargetTypeId: unique symbol = Symbol("effect/Machine/ChoiceTarget")
 
+export const NoTargetTypeId: unique symbol = Symbol("effect/Machine/NoTarget")
+
 interface StateInput {
   readonly [StateInputTypeId]: typeof StateInputTypeId
   readonly input: unknown
@@ -42,6 +44,19 @@ export interface ChoiceTarget {
   readonly values?: Readonly<Record<string, unknown>>
 }
 
+/** Internal marker returned by an explicitly targetless transition. */
+export interface NoTarget {
+  readonly [NoTargetTypeId]: typeof NoTargetTypeId
+}
+
+const noTarget = Object.freeze({
+  [NoTargetTypeId]: NoTargetTypeId
+}) as NoTarget
+
+export const makeNoTarget = (): Machine.NoTarget => noTarget
+
+export const isNoTarget = (u: unknown): u is Machine.NoTarget => hasProperty(u, NoTargetTypeId)
+
 export const makeHistoryTarget = (path: string, parent: string): HistoryTarget => ({
   [HistoryTargetTypeId]: HistoryTargetTypeId,
   path,
@@ -392,6 +407,29 @@ export const transitionDefinitions = (
         targets: transitionTargets(config.onDone)
       })
     }
+    const invokes = config.invoke === undefined
+      ? []
+      : Array.isArray(config.invoke)
+      ? config.invoke
+      : [config.invoke]
+    for (const invoke of invokes) {
+      const id = "child" in invoke ? String(invoke.child.id) : String(invoke.id)
+      for (const outcome of ["done", "failure", "snapshot"] as const) {
+        const handler = outcome === "done"
+          ? invoke.onDone
+          : outcome === "failure"
+          ? invoke.onFailure
+          : invoke.onSnapshot
+        if (handler !== undefined) {
+          definitions.push({
+            source: node.path,
+            trigger: { type: "invoke", id, outcome },
+            reenter: typeof handler === "object" && handler !== null && handler.reenter === true,
+            targets: transitionTargets(handler)
+          })
+        }
+      }
+    }
   }
   return definitions
 }

package/src/internal/testing/machine/finiteModel.ts

@@ -1487,7 +1487,7 @@ export const compileModel = (model: FiniteModel): Machine.Machine.Any => {
   const initial = byPath.get(model.initial)!
   const machine = Machine.make({
     states: defined.states as any,
-    events: eventSchemas as any,
+    events: Machine.events(...eventSchemas) as any,
     initial: () => selectSnapshot(defined.initial as any, initial.path, byPath, [initial.path], 0) as any
   })
   const transitions = new Map(model.transitions.map((transition) => [

package/src/internal/testing/machine/runtime.ts

@@ -15,6 +15,7 @@ import * as Stream from "effect/Stream"
 import { FastCheck, TestClock } from "effect/testing"
 import * as Machine from "../../../Machine.js"
 import type { CausalRuntimeEvidence, Probe, ProbeStep, RuntimeInvariant } from "../../../testing/MachineTest.js"
+import * as Protocol from "../../machine/protocol.js"
 import { type SchemaArbitraryReport, toArbitraryWithReport } from "./arbitrary.js"
 import { assertRuntimeInvariants, type RuntimeInvariantError } from "./runtimeInvariant.js"
 
@@ -1523,7 +1524,7 @@ export const runtimeCommands = <M extends AnyMachine>(
 
   const reports: Array<SchemaArbitraryReport> = []
   const eventArbitraries = options.eventArbitrary === undefined
-    ? machine.events.map((schema) => {
+    ? Protocol.inputEventSchemas(machine).map((schema) => {
       const derived = toArbitraryWithReport(schema)
       reports.push(derived.report)
       return derived.value as FastCheck.Arbitrary<Machine.Machine.InputEvent<M>>

package/src/internal/testing/machine/verification.ts

@@ -35,6 +35,7 @@ import type {
   VerificationViolation,
   VerifyOptions
 } from "../../../testing/MachineTest.js"
+import * as Protocol from "../../machine/protocol.js"
 import { toArbitraryWithReport } from "./arbitrary.js"
 import type { FiniteModel } from "./finiteModel.js"
 import * as ReferenceModel from "./referenceModel.js"
@@ -167,6 +168,7 @@ export const scenarios = <M extends AnyMachine>(
   machine: M,
   options: ScenarioOptions<M> = {} as ScenarioOptions<M>
 ): Scenarios<M> => {
+  const eventSchemas = Protocol.inputEventSchemas(machine)
   const minEvents = options.minEvents ?? 0
   const maxEvents = options.maxEvents ?? 50
   if (options.eventsArbitrary === undefined) {
@@ -175,7 +177,7 @@ export const scenarios = <M extends AnyMachine>(
     if (minEvents > maxEvents) {
       throw new Error("MachineTest.scenarios expected minEvents to be less than or equal to maxEvents")
     }
-    if (machine.events.length === 0 && minEvents > 0) {
+    if (eventSchemas.length === 0 && minEvents > 0) {
       throw new Error(
         "MachineTest.scenarios cannot generate a non-empty event sequence for a machine without public events"
       )
@@ -184,7 +186,7 @@ export const scenarios = <M extends AnyMachine>(
 
   const diagnostics: Array<SchemaArbitraryDiagnostic> = []
   const eventArbitraries = options.eventsArbitrary === undefined
-    ? machine.events.map((schema, index) => {
+    ? eventSchemas.map((schema, index) => {
       const derived = toArbitraryWithReport(schema)
       diagnostics.push({
         boundary: "event",
@@ -524,7 +526,7 @@ const publicEventTags = <M extends AnyMachine>(machine: M): {
 } => {
   const tags: Array<Machine.Machine.TagOf<Machine.Machine.InputEvents<M>[number]>> = []
   const diagnostics: Array<{ readonly schemaIndex: number; readonly message: string }> = []
-  machine.events.forEach((schema, schemaIndex) => {
+  Protocol.inputEventSchemas(machine).forEach((schema, schemaIndex) => {
     const values = finiteTagValues(SchemaAST.toType(schema.ast))
     if (values === undefined) {
       diagnostics.push({

package/src/testing/MachineTest.ts

@@ -230,7 +230,7 @@ export interface Scenarios<M extends AnyMachine> {
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [Reset],
+ *   events: Machine.events(Reset),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: { on: { Reset: () => States.initial.Idle.from() } } })
  *
@@ -479,7 +479,7 @@ export { ProbeUnavailableError } from "../internal/testing/machine/verification.
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -1089,7 +1089,7 @@ export const Invariant: {
  * const States = Machine.defineStates({ Count })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Count(new Count({ value: 0 }))
  * }).handle({ Count: {} })
  *
@@ -1407,7 +1407,7 @@ export type ExploreOptions<M extends AnyMachine, Key extends ExplorationKey = Ex
  * const States = Machine.defineStates({ Count })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [Increment],
+ *   events: Machine.events(Increment),
  *   initial: () => States.initial.Count(new Count({ value: 0 }))
  * }).handle({
  *   Count: { on: { Increment: ({ state }) =>
@@ -1591,7 +1591,7 @@ export type RunServices<M extends AnyMachine> = IsAny<
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -1818,7 +1818,7 @@ export interface Coverage<M extends AnyMachine> {
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -2034,7 +2034,7 @@ export interface VerifyOptions {
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *

package/src/unstable/cluster/ClusterMachine.ts

@@ -315,7 +315,7 @@ export const layerMemory: Layer.Layer<Storage> = internal.layerMemory
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *

package/src/unstable/reactivity/AtomMachine.ts

@@ -7,6 +7,7 @@
 import type * as Option from "effect/Option"
 import type * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
+import type * as Stream from "effect/Stream"
 import type { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity"
 import * as internal from "../../internal/machine/atom.js"
 import type { ChildNotActiveError, NotReadyError } from "../../internal/machine/atom.js"
@@ -89,14 +90,14 @@ type MachineStartError<InitialE, E, InitialR, R, RuntimeError = never> =
  * @category models
  * @since 0.4.0
  */
-export interface MachineAtom<State, Event, Error = never, Output = never, StartError = never> {
+export interface MachineAtom<State, Event, Error = never, Output = never, StartError = never, Emitted = never> {
   /**
    * Atom containing the running machine handle once startup succeeds.
    *
    * @since 0.4.0
    */
   readonly ref: Atom.Atom<
-    AsyncResult.AsyncResult<Machine.MachineRef<State, Event, Error, Output>, StartError>
+    AsyncResult.AsyncResult<Machine.MachineRef<State, Event, Error, Output, Emitted>, StartError>
   >
 
   /**
@@ -163,6 +164,32 @@ type RefState<Ref> = Ref extends Machine.MachineRef<infer State, any, any, any>
 type RefError<Ref> = Ref extends Machine.MachineRef<any, any, infer Error, any> ? Error : never
 
 type RefOutput<Ref> = Ref extends Machine.MachineRef<any, any, any, infer Output> ? Output : never
+type RefEmitted<Ref> = Ref extends Machine.MachineRef<any, any, any, any, infer Emitted> ? Emitted : never
+
+/**
+ * Observes ephemeral notifications from the actor owned by a machine atom.
+ * The stream requires an `AtomRegistry` and does not replay earlier emissions.
+ *
+ * @category getters
+ * @since 0.10.0
+ */
+export const emissions: <State, Event, Error, Output, StartError, Emitted>(
+  self: MachineAtom<State, Event, Error, Output, StartError, Emitted>
+) => Stream.Stream<Emitted, StartError, AtomRegistry.AtomRegistry> = internal.emissions
+
+/**
+ * Observes emissions from each active instance selected by a child bridge.
+ *
+ * @category getters
+ * @since 0.10.0
+ */
+export const childEmissions: <Child extends Machine.ChildMachine.Any, StartError>(
+  self: ChildMachineAtom<Child, StartError>
+) => Stream.Stream<
+  RefEmitted<Machine.ChildMachine.Ref<Child>>,
+  StartError,
+  AtomRegistry.AtomRegistry
+> = internal.childEmissions
 
 /**
  * Reactive access to one invoked child machine selected by its descriptor.
@@ -328,7 +355,7 @@ type ChildState<Child extends Machine.ChildMachine.Any> = RefState<Machine.Child
  * const States = Machine.defineStates({ Count })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Count(new Count({ value: 0 }))
  * }).handle({ Count: {} })
  * const machineAtom = AtomMachine.make(machine)
@@ -439,7 +466,7 @@ export const selectSnapshotChild: <
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  * const machineAtom = AtomMachine.make(machine)
@@ -537,7 +564,7 @@ type MachineInputArgsOf<M extends Machine.Machine.Any> = [
 
 type MachineAtomOf<M extends Machine.Machine.Any, RuntimeError> = MachineAtom<
   Machine.Machine.Snapshot<Machine.Machine.States<M>>,
-  Machine.Machine.InputEvent<M>,
+  Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>,
   MachineRuntimeError<Machine.Machine.Error<M>, Machine.Machine.Services<M>>,
   Machine.Machine.Output<M>,
   MachineStartError<
@@ -546,15 +573,17 @@ type MachineAtomOf<M extends Machine.Machine.Any, RuntimeError> = MachineAtom<
     Machine.Machine.InitialServices<M>,
     Machine.Machine.Services<M>,
     RuntimeError
-  >
+  >,
+  Machine.Machine.EmittedEvent<M>
 >
 
 type ResumedMachineAtomOf<M extends Machine.Machine.Any, RuntimeError> = MachineAtom<
   Machine.Machine.Snapshot<Machine.Machine.States<M>>,
-  Machine.Machine.InputEvent<M>,
+  Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>,
   MachineRuntimeError<Machine.Machine.Error<M>, Machine.Machine.Services<M>>,
   Machine.Machine.Output<M>,
-  Machine.MachineSchemaDecodeError | RuntimeError
+  Machine.MachineSchemaDecodeError | RuntimeError,
+  Machine.Machine.EmittedEvent<M>
 >
 
 /**
@@ -607,7 +636,7 @@ export interface Bound<Services, RuntimeError = never> {
  * const States = Machine.defineStates({ Idle })
  * const machine = Machine.make({
  *   states: States.states,
- *   events: [],
+ *   events: Machine.events(),
  *   initial: () => States.initial.Idle.from()
  * }).handle({ Idle: {} })
  *
@@ -631,7 +660,8 @@ export const make: {
     FinalStates extends Machine.Machine.StateIdentifier<States> = never,
     Output = never,
     OutputStates extends Machine.Machine.StateIdentifier<States> = never,
-    InputEvents extends ReadonlyArray<Machine.Machine.TaggedSchema> = Events
+    InputEvents extends ReadonlyArray<Machine.Machine.TaggedSchema> = Events,
+    ParentEvents extends ReadonlyArray<Machine.Machine.TaggedSchema> = readonly []
   >(
     machine:
       & Machine.Machine<
@@ -647,7 +677,8 @@ export const make: {
         Output,
         Emits,
         OutputStates,
-        InputEvents
+        InputEvents,
+        ParentEvents
       >
       & EnsureNoExternalRequirements<
         MachineRequirements<
@@ -661,10 +692,11 @@ export const make: {
     ...args: [...Machine.Machine.InputArgs<Input>]
   ): MachineAtom<
     Machine.Machine.Snapshot<States>,
-    Machine.Machine.EventOf<InputEvents>,
+    Machine.Machine.EventInputOf<InputEvents>,
     MachineRuntimeError<E, R>,
     Output,
-    MachineStartError<InitialE, E, InitialR, R>
+    MachineStartError<InitialE, E, InitialR, R>,
+    Machine.Machine.EmittedEventOf<Emits>
   >
 } = internal.make