@typeonce/effect-machine 0.11.0 → 0.12.0

package/README.md

@@ -10,6 +10,27 @@ cluster adapter.
 > This is early-release software. Its API may change, and each release targets
 > one exact Effect beta.
 
+## Design principles
+
+- **Type-safe by construction:** reject invalid protocols, compositions, and
+  capabilities at compile time where possible, and preserve typed Effect
+  failures at runtime.
+- **Explicit and opinionated:** give different semantics different names and
+  contracts. Builders and inference remove ceremony without making behavior
+  depend on ambiguous omissions.
+- **Readable models:** keep schemas, topology, behavior, and effects concise
+  enough that a human can understand the complete model from its definition.
+- **Effect-native:** design toward eventual inclusion in Effect core and follow
+  its API shape, module boundaries, ownership, and failure conventions.
+
+The package is pre-1.0: a clearer or safer long-term API takes priority over
+backward compatibility. Breaking changes use minor releases, compatible fixes
+use patch releases, and compatibility aliases are not added by default.
+
+The core machine model remains local. Distributed identity, placement,
+transport, routing, delivery, and remote lifecycle semantics belong to Effect
+Cluster and are exposed only through explicit integration boundaries.
+
 ## Install
 
 ```sh
@@ -136,7 +157,7 @@ data, put it on their compound parent.
 
 ### Separate inputs, raised events, and emissions
 
-`events` is the public actor-input protocol. Events raised to the same machine
+`events` is the public machine-input protocol. Events raised to the same machine
 belong in `internalEvents`. Ephemeral outward notifications have their own
 `emittedEvents` protocol:
 
@@ -186,7 +207,7 @@ protocols but cannot expose a finite constructor set; pass a complete event
 object to `send` or `Machine.plan` for those events.
 
 `ref.emissions` is a hot `Stream`: it publishes only notifications produced
-after subscription, replays nothing, and completes when the actor terminates.
+after subscription, replays nothing, and completes when the machine terminates.
 Snapshots remain separate and stateful: `ref.changes` begins with the current
 lifecycle snapshot and then follows later changes. Use `Machine.prepare` when
 an observer must be installed before initial-entry actions run:
@@ -209,10 +230,10 @@ emission: the observer is simply subscribed before initialization begins.
 Invalid event and emission constructions fail the machine with a typed
 `MachineSchemaDecodeError`; they do not throw from the constructor call.
 
-### Send explicitly between actors
+### Send explicitly between machines
 
-`raise` targets the current machine in the same macrostep. `sendTo` targets an
-actor mailbox and is processed later. A child declares the subset of parent
+`raise` targets the current machine in the same macrostep. `sendTo` targets a
+machine mailbox and is processed later. A child declares the subset of parent
 inputs it may send with `parentEvents`:
 
 ```ts
@@ -244,15 +265,18 @@ const ParentInputs = Machine.events(Start, ParentEvents)
 The same child remains isolated and may be started as a root, where `parent` is
 `undefined`. When `Child` is invoked, the parent definition must accept every
 event in `parentEvents`; otherwise `.handle(...)` is a compile-time error.
-Inside the child, the parent reference accepts only those declared events.
-`emit` never sends to the parent: it only publishes on the emitting actor's
+Inside the child, the parent target accepts only those declared events.
+`emit` never sends to the parent: it only publishes on the emitting machine's
 `emissions` stream.
 
 Every handler also receives `self`, which can be targeted with `sendTo` when a
 later mailbox turn is required. Use `raise` instead for same-macrostep work.
+Both `self` and `parent` are minimal `Machine.MachineTarget<Event>` values. The
+shared `Machine.MachineReferences<InputEvents, ParentEvents>` context keeps
+their input protocols separate without exposing snapshot or lifecycle APIs.
 Structural state values use distinct names: `containingState` is the immediate
 valued state in the same statechart, while `ancestors` maps valued ancestor
-paths. `parent` always means the owning actor reference.
+paths. `parent` always means the owning machine target.
 
 ### Choose the target by scope
 
@@ -401,7 +425,7 @@ const childEmissions = AtomMachine.childEmissions(counterAtom.child(Worker))
 ```
 
 These streams require the same `AtomRegistry`, follow the currently mounted
-actor instance, and do not replay notifications from an earlier subscription
+machine instance, and do not replay notifications from an earlier subscription
 or child instance.
 
 ## Persistence

package/dist/Machine.d.ts

@@ -119,17 +119,17 @@ export interface Machine<States extends Machine.StateSchemas, Events extends Rea
      */
     readonly internalEvents: Machine.EventProtocol<"internal", Machine.InternalEventSchemas<Events, InputEvents>>;
     /**
-     * Ephemeral outward notifications published to this actor's observers.
-     * Emissions are never delivered implicitly to an owning actor.
+     * Ephemeral outward notifications published to this machine's observers.
+     * Emissions are never delivered implicitly to an owning machine.
      *
      * @since 0.4.0
      */
     readonly emittedEvents: Machine.EventProtocol<"emitted", Emits>;
     /**
-     * Public input events accepted by an owning actor when this machine is
+     * Public input events accepted by an owning machine when this machine is
      * running as a child.
      *
-     * The protocol types the optional `parent` actor reference exposed to
+     * The protocol types the optional `parent` machine target exposed to
      * handlers and is checked against a concrete parent's public events at
      * composition boundaries.
      *
@@ -292,38 +292,38 @@ export interface Runtime<in Events, in Emits> {
      */
     readonly raise: (event: Machine.EventInput<Events>) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError>;
     /**
-     * Publishes an ephemeral notification to the running actor's observers.
+     * Publishes an ephemeral notification to the running machine's observers.
      *
      * @since 0.4.0
      */
     readonly emit: (event: Machine.EmittedEventInput<Emits>) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError>;
 }
 /**
- * Minimal typed reference accepted by targeted actor commands.
+ * Minimal typed target accepted by inter-machine send commands.
  *
  * @category models
- * @since 0.10.0
+ * @since 0.12.0
  */
-export interface ActorRef<in Event> {
+export interface MachineTarget<in Event> {
     readonly id: string;
     readonly sessionId: string;
     readonly send: (event: Event) => Effect.Effect<void, StoppedError>;
 }
 /**
- * Actor references available while evaluating machine behavior.
+ * Machine targets available while evaluating machine behavior.
  *
  * @category models
- * @since 0.10.0
+ * @since 0.12.0
  */
-export interface ActorContext<InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> {
-    /** Reference to the current actor. Sending queues a later mailbox event. */
-    readonly self: ActorRef<Machine.EventInputOf<InputEvents>>;
-    /** Reference to the owning actor, or `undefined` when running as a root. */
-    readonly parent: ActorRef<Machine.EventInputOf<ParentEvents>> | undefined;
+export interface MachineReferences<InputEvents extends ReadonlyArray<Machine.TaggedSchema>, ParentEvents extends ReadonlyArray<Machine.TaggedSchema>> {
+    /** Target for the current machine. Sending queues a later mailbox event. */
+    readonly self: MachineTarget<Machine.EventInputOf<InputEvents>>;
+    /** Target for the owning machine, or `undefined` when running as a root. */
+    readonly parent: MachineTarget<Machine.EventInputOf<ParentEvents>> | undefined;
 }
 /**
  * Synchronous commands available while a machine transition is being
- * selected. Enqueuing only records statechart and actor operations; it never
+ * selected. Enqueuing only records statechart and machine operations; it never
  * executes an Effect.
  *
  * @category models
@@ -332,11 +332,11 @@ export interface ActorContext<InputEvents extends ReadonlyArray<Machine.TaggedSc
 export interface Enqueue<in Events, in Emits> {
     /** Raises an event inside the current macrostep. */
     readonly raise: (event: Machine.EventInput<Events>) => void;
-    /** Publishes an ephemeral notification to this actor's observers. */
+    /** Publishes an ephemeral notification to this machine's observers. */
     readonly emit: (event: Machine.EmittedEventInput<Emits>) => void;
     /** Sends an event to an invoked child after the transition is selected. */
     readonly sendTo: {
-        <Event>(target: ActorRef<Event>, event: Event): void;
+        <Event>(target: MachineTarget<Event>, event: Event): void;
         <Child extends ChildMachine.Any>(child: Child, event: ChildMachine.Event<Child>): void;
         <Address extends ChildAddress<never>>(child: Address, event: ChildAddress.Event<Address>): void;
     };
@@ -347,14 +347,14 @@ export interface Enqueue<in Events, in Emits> {
     };
 }
 /**
- * A closed actor command recorded by a synchronous machine transition.
+ * A closed machine command recorded by a synchronous transition.
  *
  * @category models
  * @since 0.4.0
  */
 export type Command = {
     readonly _tag: "SendTo";
-    readonly target: ActorRef<unknown> | ChildMachine.Any | ChildAddress<never>;
+    readonly target: MachineTarget<unknown> | ChildMachine.Any | ChildAddress<never>;
     readonly event: unknown;
 } | {
     readonly _tag: "Stop";
@@ -895,7 +895,7 @@ export interface Prepared<out State, in Event, out Error, out Output, out Emitte
  * @category models
  * @since 0.4.0
  */
-export interface MachineRef<out State, in Event, out Error = never, out Output = never, out Emitted = never> extends ActorRef<Event> {
+export interface MachineRef<out State, in Event, out Error = never, out Output = never, out Emitted = never> extends MachineTarget<Event> {
     /** Stable machine definition id, or a generated fallback when none was declared. */
     readonly id: string;
     /** Unique identity for this running machine instance. */
@@ -908,7 +908,7 @@ export interface MachineRef<out State, in Event, out Error = never, out Output =
     readonly changes: Stream.Stream<RuntimeSnapshot<State, Error, Output>>;
     /**
      * Streams ephemeral notifications published after subscription. Emissions
-     * are not retained or replayed; the stream completes when the actor stops.
+     * are not retained or replayed; the stream completes when the machine stops.
      */
     readonly emissions: Stream.Stream<Emitted>;
     /** Waits for machine output or fails when execution fails or is stopped. */
@@ -988,9 +988,9 @@ export declare namespace Logic {
         readonly parent: Address<unknown> | undefined;
         /** Starts a child process owned by this scope. */
         readonly spawn: Spawn;
-        /** Sends an event to an actor reference or typed parent-local child address. */
+        /** Sends an event to a machine target or typed parent-local child address. */
         readonly sendTo: {
-            <TargetEvent>(target: ActorRef<TargetEvent>, event: TargetEvent): Effect.Effect<void, StoppedError>;
+            <TargetEvent>(target: MachineTarget<TargetEvent>, event: TargetEvent): Effect.Effect<void, StoppedError>;
             <Address extends ChildAddress<never>>(id: Address, event: ChildAddress.Event<Address>): Effect.Effect<void, StoppedError>;
         };
         /** Stops a child process selected by its parent-local address. */
@@ -1303,7 +1303,7 @@ export declare namespace Machine {
      * @since 0.4.0
      */
     type InputEvents<M extends Any> = M[typeof MachineTypeId]["inputEvents"];
-    /** Extracts the public input protocol required from an owning actor. */
+    /** Extracts the public input protocol required from an owning machine. */
     type ParentEvents<M extends Any> = M[typeof MachineTypeId]["parentEvents"];
     /** Extracts an internal event schema tuple from the complete and public protocols. */
     type InternalEventSchemas<Events extends ReadonlyArray<TaggedSchema>, InputEvents extends ReadonlyArray<TaggedSchema>> = Events extends readonly [
@@ -2543,7 +2543,7 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface HandlerContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends ActorContext<InputEvents, ParentEvents> {
+    interface HandlerContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, EventTag extends TagOf<Events[number]>, E, R, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
         readonly ancestors: ParentStateValues<States, StateId>;
@@ -2564,7 +2564,7 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface StateActionContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends ActorContext<InputEvents, ParentEvents> {
+    interface StateActionContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
         readonly ancestors: ParentStateValues<States, StateId>;
@@ -2576,7 +2576,7 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface InvokeContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends ActorContext<InputEvents, ParentEvents> {
+    interface InvokeContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
         readonly ancestors: ParentStateValues<States, StateId>;
@@ -2588,7 +2588,7 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface InvokeSnapshotContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, State, Error, Output, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends ActorContext<InputEvents, ParentEvents> {
+    interface InvokeSnapshotContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, State, Error, Output, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
         readonly id: string;
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
@@ -2604,7 +2604,7 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface InvokeDoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Output, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends ActorContext<InputEvents, ParentEvents> {
+    interface InvokeDoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Output, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
         readonly id: string;
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
@@ -2614,7 +2614,7 @@ export declare namespace Machine {
         readonly output: Output;
     }
     /** Context passed to an invocation typed-failure transition. */
-    interface InvokeFailureContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Error, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends ActorContext<InputEvents, ParentEvents> {
+    interface InvokeFailureContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, Error, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
         readonly id: string;
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
@@ -2629,7 +2629,7 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface AlwaysContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends ActorContext<InputEvents, ParentEvents> {
+    interface AlwaysContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
         readonly ancestors: ParentStateValues<States, StateId>;
@@ -2651,7 +2651,7 @@ export declare namespace Machine {
      * @category models
      * @since 0.4.0
      */
-    interface DoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends ActorContext<InputEvents, ParentEvents> {
+    interface DoneContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, StateId extends StateIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
         readonly state: StateByIdentifier<States, StateId>;
         readonly containingState: ParentStateValue<States, StateId>;
         readonly ancestors: ParentStateValues<States, StateId>;
@@ -2669,7 +2669,7 @@ export declare namespace Machine {
         readonly target: TargetBuilder<States, StateId>;
     }
     /** Context passed to a transient choice resolver. There is no `state` value. */
-    interface ChoiceContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends ActorContext<InputEvents, ParentEvents> {
+    interface ChoiceContext<States extends StateSchemas, Events extends ReadonlyArray<TaggedSchema>, Emits extends ReadonlyArray<TaggedSchema>, ChoiceId extends ChoiceIdentifier<States>, InputEvents extends ReadonlyArray<TaggedSchema> = Events, ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []> extends MachineReferences<InputEvents, ParentEvents> {
         readonly containingState: StateByIdentifier<States, Extract<ImmediateParentStateIdentifier<ChoiceId>, StateIdentifier<States>>>;
         readonly ancestors: {
             readonly [Parent in Extract<ParentStateIdentifier<ChoiceId>, ValuedStateIdentifier<States>>]: StateByIdentifier<States, Parent>;
@@ -3557,7 +3557,7 @@ interface Make {
  * adds raised events and other machine-local deliveries.
  * `Machine.emittedEvents` defines outward ephemeral notifications, while
  * `parentEvents` declares the inputs a child may explicitly send to its owning
- * actor. All descriptors expose deferred constructors while retaining their
+ * machine. All descriptors expose deferred constructors while retaining their
  * schemas opaquely for runtime validation. Public and internal tags must be
  * disjoint.
  *
@@ -3655,8 +3655,8 @@ export declare const internalEvents: {
 };
 /**
  * Defines the ephemeral notifications a machine may publish to external
- * observers. Emitted events are separate from actor input and are never sent
- * implicitly to a parent actor. Observe them through `MachineRef.emissions` or
+ * observers. Emitted events are separate from machine input and are never sent
+ * implicitly to a parent machine. Observe them through `MachineRef.emissions` or
  * the AtomMachine emission stream adapters.
  *
  * @category constructors
@@ -3891,11 +3891,11 @@ export declare const invoke: {
     <const States extends Machine.StateSchemas, const Events extends ReadonlyArray<Machine.TaggedSchema>, const Emits extends ReadonlyArray<Machine.TaggedSchema>, StateId extends Machine.StateIdentifier<States>, const Child extends ChildMachine.Any, const Config extends object>(config: Config & Machine.ChildInvokeArgs<States, Events, Emits, StateId, Child["machine"], Child, readonly [], readonly []>): Config & Machine.InvokeOwned<States, Events, Emits, StateId> & Machine.InvokeTyped<Machine.Output<Child["machine"]>, Machine.Error<Child["machine"]> | ActionError<Machine.Services<Child["machine"]>>, Machine.Services<Child["machine"]>, Machine.InitialError<Child["machine"]>, Machine.Emit<Child["machine"]>, Machine.EventOf<Machine.ParentEvents<Child["machine"]>>>;
 };
 /**
- * Plans the initial state for a machine without executing actor commands.
+ * Plans the initial state for a machine without executing machine commands.
  *
  * **Details**
  *
- * The returned plan contains the settled initial snapshot, actor commands,
+ * The returned plan contains the settled initial snapshot, machine commands,
  * emitted events, optional final output, and every startup microstep. Planning
  * may evaluate transition logic and follow completion, eventless, and
  * raised-event steps. Transition callbacks are evaluated synchronously.
@@ -3904,8 +3904,8 @@ export declare const invoke: {
  *
  * **Gotchas**
  *
- * `start` executes the closed command list as part of the managed actor commit
- * protocol. Manual planners may inspect commands but need a running actor scope
+ * `start` executes the closed command list as part of the managed machine commit
+ * protocol. Manual planners may inspect commands but need running machine targets
  * to execute child-addressed operations.
  *
  * **Example**
@@ -4029,7 +4029,7 @@ export declare const enabled: <const States extends Machine.StateSchemas, const
  *
  * **Gotchas**
  *
- * `plan` returns data; it does not implement the actor commit protocol.
+ * `plan` returns data; it does not implement the managed machine commit protocol.
  * `start` executes child commands, publishes `next`, and then delivers
  * `emittedEvents`. Events with no enabled transition are ignored and produce
  * an unchanged plan.
@@ -4250,7 +4250,7 @@ export declare const prepare: <const States extends Machine.StateSchemas, const
  * **Details**
  *
  * For each accepted event the runtime plans the complete synchronous
- * macrostep, executes closed actor commands, stops invokes for exited states,
+ * macrostep, executes closed machine commands, stops invokes for exited states,
  * publishes the new state, delivers emitted events, and then starts invokes
  * for entered states.
  *