@typeonce/effect-machine 0.9.0 → 0.11.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>
@@ -300,6 +302,22 @@ export interface MachineRef<out State, in Event, out Error = never, out Output =
   readonly childChanges: (child: any) => Stream.Stream<Option.Option<any>>
 }
 
+export interface PreparedProcess<
+  out State,
+  in Event,
+  out Error,
+  out Output,
+  out Emitted,
+  out StartError,
+  StartRequirements
+> {
+  readonly id: string
+  readonly sessionId: string
+  readonly changes: Stream.Stream<RuntimeSnapshot<State, Error, Output>, StartError>
+  readonly emissions: Stream.Stream<Emitted>
+  readonly start: Effect.Effect<MachineRef<State, Event, Error, Output, Emitted>, StartError, StartRequirements>
+}
+
 interface ProcessAddress<in Event> {
   readonly id: string
   readonly sessionId: string
@@ -307,12 +325,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>
@@ -600,6 +625,8 @@ const makeProcessRuntime: Effect.Effect<ProcessRuntime> = Effect.sync(() => {
 interface StartInternalOptions {
   readonly detached?: boolean
   readonly id?: string
+  readonly sessionId?: string
+  readonly emissions?: EmissionRuntime
   readonly onOutcome?: (outcome: RuntimeOutcome<any, any, any>) => Effect.Effect<void>
   readonly onSnapshot?: (
     snapshot: Extract<RuntimeSnapshot<any, any, any>, { readonly status: "active" }>
@@ -708,6 +735,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 +753,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 +816,57 @@ 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
+
+interface EmissionRuntime {
+  readonly emit: (event: unknown) => Effect.Effect<void>
+  readonly close: () => Effect.Effect<void>
+  readonly stream: Stream.Stream<unknown>
+}
+
+const makeEmissionRuntime = (): EmissionRuntime => {
+  let emissions: LazyEmissions
+  const getOrCreate: 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)
+          )
+        )
+      )
+    )
+  })
+  return {
+    emit: (event) =>
+      Effect.suspend(() =>
+        emissions === undefined || emissions === EmissionsClosed
+          ? Effect.void
+          : PubSub.publish(emissions, event).pipe(Effect.asVoid)
+      ),
+    close: () => {
+      const observed = emissions
+      emissions = EmissionsClosed
+      return observed === undefined || observed === EmissionsClosed ? Effect.void : PubSub.shutdown(observed)
+    },
+    stream: Stream.unwrap(
+      getOrCreate.pipe(
+        Effect.map((emissions) => emissions === undefined ? Stream.empty : Stream.fromPubSub(emissions))
+      )
+    )
+  }
+}
 
 const childlessRuntime: ChildRuntime = {
   close: () => Effect.void,
@@ -1088,9 +1170,10 @@ const startGenericInternal: <
     | { readonly _tag: "Done"; readonly output: Output }
     | { readonly _tag: "Failure"; readonly cause: Cause.Cause<Error> }
 
-  const sessionId = yield* runtime.nextSessionId
+  const sessionId = options.sessionId ?? (yield* runtime.nextSessionId)
   const id = requestedId ?? sessionId
   const queue = yield* Queue.unbounded<ProcessMessage<Event>>()
+  const emissions = options.emissions ?? makeEmissionRuntime()
   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 +1244,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(emissions.close()))
       : Effect.void
   const cleanup = onStopSync === undefined ? onStop ?? Effect.void : Effect.sync(onStopSync)
   const sendParent = overrideSendParent ?? (parent === undefined ? noParentSend : parent.send)
@@ -1171,7 +1254,11 @@ const startGenericInternal: <
     parent,
     spawn,
     sendParent,
-    sendTo,
+    emit: emissions.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 +1296,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 +1437,7 @@ const startGenericInternal: <
         Effect.andThen(Queue.shutdown(queue)),
         Effect.andThen(closeChildren(exit)),
         Effect.andThen(setAndPublishSnapshot(snapshot)),
+        Effect.andThen(emissions.close()),
         Effect.andThen(Effect.sync(() => {
           if (Exit.isFailure(exit)) {
             failAcknowledgedMessage(inFlightMessage, exit.cause)
@@ -1504,6 +1594,7 @@ 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: emissions.stream as Stream.Stream<never>,
     join: Deferred.await(done),
     stop,
     send: self.send,
@@ -1657,6 +1748,8 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
   private interruptRequested = false
   private offerRevision = 0
   private inFlightMessage: ProcessMessage<unknown> | undefined
+  private readonly externalEmissions: EmissionRuntime | undefined
+  private emissionsPubSub: LazyEmissions
 
   constructor(
     private readonly logic: ProcessLogic<any, any, any, any, any, any>,
@@ -1666,6 +1759,7 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
   ) {
     this.sessionId = sessionId
     this.id = options.id ?? sessionId
+    this.externalEmissions = options.emissions
     this.send = (event) => this.offerMessage(event)
     this.address = {
       id: this.id,
@@ -1690,7 +1784,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 +1841,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 +1940,10 @@ class CompiledProcess implements MachineRef<any, any, any, any> {
     return this.changesStream()
   }
 
+  get emissions(): Stream.Stream<never> {
+    return (this.externalEmissions?.stream ?? this.emissionsStream()) as Stream.Stream<never>
+  }
+
   get join(): Effect.Effect<unknown, unknown> {
     return Effect.suspend(() => {
       if (this.lifecycle === "Completed") {
@@ -2145,6 +2251,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 +2300,57 @@ 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> {
+    if (this.externalEmissions !== undefined) return this.externalEmissions.emit(event)
+    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> {
+    if (this.externalEmissions !== undefined) return this.externalEmissions.close()
+    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()
@@ -2400,17 +2558,20 @@ const startCompactCompiledInternal: typeof startGenericInternal = Effect.fnUntra
   logic: ProcessLogic<any, any, any, any, any, any>,
   options: StartInternalOptions
 ) {
-  const sessionId = yield* options.runtime.nextSessionId
+  const sessionId = options.sessionId ?? (yield* options.runtime.nextSessionId)
   const services = yield* Effect.context<any>()
   const execution = logic.execution as CompiledProcessExecution<any, any, any, any, any, any>
   const process = new CompiledProcess(logic, options, services, sessionId)
   // 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 = ((
@@ -2510,3 +2671,97 @@ export const startProcess: <
       }
   )
 })
+
+const prepareProcessWithStrategy = Effect.fnUntraced(function*<
+  State,
+  Event,
+  Error,
+  Requirements,
+  Output,
+  InitialError,
+  Emitted
+>(
+  logic: ProcessLogic<State, Event, Error, Requirements, Output, InitialError>,
+  strategy: ProcessRuntimeStrategy,
+  options?: {
+    readonly id?: string
+  }
+) {
+  const runtime = yield* makeProcessRuntime
+  const sessionId = yield* runtime.nextSessionId
+  const emissions = makeEmissionRuntime()
+  const started = yield* Deferred.make<MachineRef<State, Event, Error, Output, Emitted>, InitialError>()
+  const internalOptions: StartInternalOptions = options === undefined
+    ? {
+      detached: true,
+      emissions,
+      runtime,
+      sessionId
+    }
+    : {
+      ...options,
+      detached: true,
+      emissions,
+      runtime,
+      sessionId
+    }
+  const initialize = strategy === "generic"
+    ? startGenericInternal(logic, internalOptions)
+    : strategy === "compiled"
+    ? logic.execution?._tag === "Compiled"
+      ? startCompactCompiledInternal(logic, internalOptions)
+      : Effect.die(new Error("Machine cannot force the compiled runtime for generic process logic"))
+    : startLogicInternal(logic, internalOptions)
+  const start = yield* Effect.cached(
+    initialize.pipe(
+      Effect.onExit((exit) => Deferred.done(started, exit))
+    ) as Effect.Effect<MachineRef<State, Event, Error, Output, Emitted>, InitialError, Requirements>
+  )
+  return {
+    id: options?.id ?? sessionId,
+    sessionId,
+    changes: Stream.unwrap(
+      Deferred.await(started).pipe(Effect.map((ref) => ref.changes))
+    ),
+    emissions: emissions.stream as Stream.Stream<Emitted>,
+    start
+  }
+})
+
+export const prepareProcess: <
+  State,
+  Event,
+  Error = never,
+  Requirements = never,
+  Output = never,
+  InitialError = never,
+  Emitted = never
+>(
+  logic: ProcessLogic<State, Event, Error, Requirements, Output, InitialError>,
+  options?: {
+    readonly id?: string
+  }
+) => Effect.Effect<
+  PreparedProcess<State, Event, Error, Output, Emitted, InitialError, Requirements>
+> =
+  ((logic: ProcessLogic<any, any, any, any, any, any>, options?: { readonly id?: string }) =>
+    prepareProcessWithStrategy(logic, "auto", options)) as any
+
+/** @internal Test-only prepared startup strategy selection. */
+export const prepareProcessWithStrategyForTesting = <
+  State,
+  Event,
+  Error = never,
+  Requirements = never,
+  Output = never,
+  InitialError = never,
+  Emitted = never
+>(
+  logic: ProcessLogic<State, Event, Error, Requirements, Output, InitialError>,
+  strategy: ProcessRuntimeStrategy,
+  options?: {
+    readonly id?: string
+  }
+): Effect.Effect<
+  PreparedProcess<State, Event, Error, Output, Emitted, InitialError, Requirements>
+> => prepareProcessWithStrategy(logic, strategy, options) as any

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,

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: {} })
  *