xstate 5.0.0-beta.13 → 5.0.0-beta.14

package/dist/declarations/src/State.d.ts

@@ -1,6 +1,6 @@
 import type { StateNode } from "./StateNode.js";
 import { TypegenDisabled, TypegenEnabled } from "./typegenTypes.js";
-import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, StateConfig, StateValue, TransitionDefinition } from "./types.js";
+import type { ActorRef, AnyState, AnyStateMachine, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, StateConfig, StateValue } from "./types.js";
 export declare function isStateConfig<TContext extends MachineContext, TEvent extends EventObject>(state: any): state is StateConfig<TContext, TEvent>;
 /**
  * @deprecated Use `isStateConfig(object)` or `state instanceof State` instead.
@@ -20,8 +20,6 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
     output: any;
     context: TContext;
     historyValue: Readonly<HistoryValue<TContext, TEvent>>;
-    actions: BaseActionObject[];
-    event: TEvent;
     _internalQueue: Array<TEvent>;
     _initial: boolean;
     /**
@@ -37,10 +35,6 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
      * The enabled state nodes representative of the state value.
      */
     configuration: Array<StateNode<TContext, TEvent>>;
-    /**
-     * The transition definitions that resulted in this state.
-     */
-    transitions: Array<TransitionDefinition<TContext, TEvent>>;
     /**
      * An object mapping actor names to spawned/invoked actors.
      */
@@ -63,7 +57,7 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
      * @param delimiter The character(s) that separate each subpath in the string state node path.
      */
     toStrings(stateValue?: StateValue, delimiter?: string): string[];
-    toJSON(): Omit<this, "meta" | "toJSON" | "configuration" | "transitions" | "tags" | "machine" | "toStrings" | "matches" | "hasTag" | "can" | "nextEvents"> & {
+    toJSON(): Omit<this, "meta" | "toJSON" | "configuration" | "tags" | "machine" | "toStrings" | "matches" | "hasTag" | "can" | "nextEvents"> & {
         tags: string[];
         meta: Record<string, any>;
     };

package/dist/declarations/src/StateMachine.d.ts

@@ -1,11 +1,11 @@
 import { State } from "./State.js";
 import { StateNode } from "./StateNode.js";
 import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
-import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from "./types.js";
+import type { ActorContext, ActorLogic, ActorMap, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from "./types.js";
 export declare const NULL_EVENT = "";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";
-export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject = EventObject, TAction extends ParameterizedObject = ParameterizedObject, TActorMap extends ActorMap = ActorMap, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TActorMap>> implements ActorBehavior<TEvent, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>> {
+export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject = EventObject, TAction extends ParameterizedObject = ParameterizedObject, TActorMap extends ActorMap = ActorMap, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TActorMap>> implements ActorLogic<TEvent, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>> {
     /**
      * The raw config used to create the machine.
      */
@@ -59,7 +59,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param state The current State instance or state value
      * @param event The received event
      */
-    transition(state: StateValue | State<TContext, TEvent, TResolvedTypesMeta> | undefined, event: TEvent, actorCtx?: ActorContext<TEvent, State<TContext, TEvent, any>>): State<TContext, TEvent, TResolvedTypesMeta>;
+    transition(state: State<TContext, TEvent, TResolvedTypesMeta>, event: TEvent, actorCtx: ActorContext<TEvent, State<TContext, TEvent, any>>): State<TContext, TEvent, TResolvedTypesMeta>;
     /**
      * Determines the next state given the current `state` and `event`.
      * Calculates a microstep.
@@ -67,22 +67,17 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param state The current state
      * @param event The received event
      */
-    microstep(state: State<TContext, TEvent, TResolvedTypesMeta> | undefined, event: TEvent, actorCtx?: AnyActorContext | undefined): Array<State<TContext, TEvent, TResolvedTypesMeta>>;
+    microstep(state: State<TContext, TEvent, TResolvedTypesMeta>, event: TEvent, actorCtx: AnyActorContext): Array<State<TContext, TEvent, TResolvedTypesMeta>>;
     getTransitionData(state: State<TContext, TEvent, TResolvedTypesMeta>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>>;
     /**
      * The initial state _before_ evaluating any microsteps.
      * This "pre-initial" state is provided to initial actions executed in the initial state.
      */
     private getPreInitialState;
-    /**
-     * The initial State instance, which includes all actions to be executed from
-     * entering the initial state.
-     */
-    get initialState(): State<TContext, TEvent, TResolvedTypesMeta>;
     /**
      * Returns the initial `State` instance, with reference to `self` as an `ActorRef`.
      */
-    getInitialState(actorCtx?: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>, input?: any): State<TContext, TEvent, TResolvedTypesMeta>;
+    getInitialState(actorCtx: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>, input?: any): State<TContext, TEvent, TResolvedTypesMeta>;
     start(state: State<TContext, TEvent, TResolvedTypesMeta>, actorCtx: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>): void;
     getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
     get definition(): StateMachineDefinition<TContext, TEvent>;

package/dist/declarations/src/StateNode.d.ts

@@ -88,7 +88,7 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     get definition(): StateNodeDefinition<TContext, TEvent>;
     toJSON(): StateNodeDefinition<TContext, TEvent>;
     /**
-     * The behaviors invoked as actors by this state node.
+     * The logic invoked as actors by this state node.
      */
     get invoke(): Array<InvokeDefinition<TContext, TEvent>>;
     /**

package/dist/declarations/src/actors/callback.d.ts

@@ -1,8 +1,8 @@
-import { InvokeCallback, ActorBehavior, EventObject } from "../types.js";
+import { InvokeCallback, ActorLogic, EventObject } from "../types.js";
 export interface CallbackInternalState {
     canceled: boolean;
     receivers: Set<(e: EventObject) => void>;
     dispose: void | (() => void) | Promise<any>;
     input?: any;
 }
-export declare function fromCallback<TEvent extends EventObject>(invokeCallback: InvokeCallback): ActorBehavior<TEvent, undefined>;
+export declare function fromCallback<TEvent extends EventObject>(invokeCallback: InvokeCallback): ActorLogic<TEvent, undefined, CallbackInternalState>;

package/dist/declarations/src/actors/index.d.ts

@@ -16,7 +16,7 @@ export interface StopSignal {
 export type LifecycleSignal = StartSignal | StopSignal;
 export type LifecycleSignalType = typeof startSignalType | typeof stopSignalType;
 /**
- * An object that expresses the behavior of an actor in reaction to received events,
+ * An object that expresses the actor logic in reaction to received events,
  * as well as an optionally emitted stream of values.
  *
  * @template TReceived The received event

package/dist/declarations/src/actors/observable.d.ts

@@ -1,4 +1,4 @@
-import { Subscribable, ActorBehavior, EventObject, Subscription } from "../types.js";
+import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem } from "../types.js";
 export interface ObservableInternalState<T> {
     subscription: Subscription | undefined;
     status: 'active' | 'done' | 'error' | 'canceled';
@@ -6,17 +6,19 @@ export interface ObservableInternalState<T> {
     input?: any;
 }
 export type ObservablePersistedState<T> = Omit<ObservableInternalState<T>, 'subscription'>;
-export declare function fromObservable<T, TEvent extends EventObject>(observableCreator: ({ input }: {
+export declare function fromObservable<T, TEvent extends EventObject>(observableCreator: ({ input, system }: {
     input: any;
-}) => Subscribable<T>): ActorBehavior<TEvent, T | undefined, ObservableInternalState<T>, ObservablePersistedState<T>>;
+    system: AnyActorSystem;
+}) => Subscribable<T>): ActorLogic<TEvent, T | undefined, ObservableInternalState<T>, ObservablePersistedState<T>>;
 /**
- * Creates an event observable behavior that listens to an observable
+ * Creates event observable logic that listens to an observable
  * that delivers event objects.
  *
  *
  * @param lazyObservable A function that creates an observable
- * @returns An event observable behavior
+ * @returns Event observable logic
  */
 export declare function fromEventObservable<T extends EventObject>(lazyObservable: ({ input }: {
     input: any;
-}) => Subscribable<T>): ActorBehavior<EventObject, T | undefined>;
+    system: AnyActorSystem;
+}) => Subscribable<T>): ActorLogic<EventObject, T | undefined, ObservableInternalState<T>, ObservablePersistedState<T>>;

package/dist/declarations/src/actors/promise.d.ts

@@ -1,11 +1,12 @@
-import { ActorBehavior } from "../types.js";
+import { ActorLogic, AnyActorSystem } from "../types.js";
 export interface PromiseInternalState<T> {
     status: 'active' | 'error' | 'done' | 'canceled';
     data: T | undefined;
     input?: any;
 }
-export declare function fromPromise<T>(promiseCreator: ({ input }: {
+export declare function fromPromise<T>(promiseCreator: ({ input, system }: {
     input: any;
-}) => PromiseLike<T>): ActorBehavior<{
+    system: AnyActorSystem;
+}) => PromiseLike<T>): ActorLogic<{
     type: string;
 }, T | undefined, PromiseInternalState<T>>;

package/dist/declarations/src/actors/transition.d.ts

@@ -1,13 +1,13 @@
-import { ActorBehavior, ActorContext, ActorSystem, EventObject } from "../types.js";
+import { ActorLogic, ActorContext, ActorSystem, EventObject } from "../types.js";
 /**
- * Returns an actor behavior from a transition function and its initial state.
+ * Returns actor logic from a transition function and its initial state.
  *
  * A transition function is a function that takes the current state and an event and returns the next state.
  *
  * @param transition The transition function that returns the next state given the current state and event.
  * @param initialState The initial state of the transition function.
- * @returns An actor behavior
+ * @returns Actor logic
  */
 export declare function fromTransition<TState, TEvent extends EventObject, TSystem extends ActorSystem<any>>(transition: (state: TState, event: TEvent, actorContext: ActorContext<TEvent, TState, TSystem>) => TState, initialState: TState | (({ input }: {
     input: any;
-}) => TState)): ActorBehavior<TEvent, TState, TState>;
+}) => TState)): ActorLogic<TEvent, TState, TState>;

package/dist/declarations/src/interpreter.d.ts

@@ -1,8 +1,8 @@
 import { symbolObservable } from "./symbolObservable.js";
 import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from "./typegenTypes.js";
-import type { ActorSystem, AnyActorBehavior, AnyStateMachine, EventFromBehavior, InterpreterFrom, PersistedStateFrom, RaiseActionObject, SnapshotFrom } from "./types.js";
+import type { ActorSystem, AnyActorLogic, AnyStateMachine, EventFromLogic, InterpreterFrom, PersistedStateFrom, RaiseActionObject, SnapshotFrom } from "./types.js";
 import { ActorRef, EventObject, InteropSubscribable, InterpreterOptions, Observer, SendActionObject, Subscription } from "./types.js";
-export type SnapshotListener<TBehavior extends AnyActorBehavior> = (state: SnapshotFrom<TBehavior>) => void;
+export type SnapshotListener<TLogic extends AnyActorLogic> = (state: SnapshotFrom<TLogic>) => void;
 export type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
 export type Listener = () => void;
 export type ErrorListener = (error: any) => void;
@@ -15,17 +15,17 @@ export declare enum ActorStatus {
     Running = 1,
     Stopped = 2
 }
-export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent extends EventObject = EventFromBehavior<TBehavior>> implements ActorRef<TEvent, SnapshotFrom<TBehavior>> {
-    behavior: TBehavior;
+export declare class Interpreter<TLogic extends AnyActorLogic, TEvent extends EventObject = EventFromLogic<TLogic>> implements ActorRef<TEvent, SnapshotFrom<TLogic>> {
+    logic: TLogic;
     /**
-     * The current state of the interpreted behavior.
+     * The current state of the interpreted logic.
      */
     private _state;
     /**
      * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
      */
     clock: Clock;
-    options: Readonly<InterpreterOptions<TBehavior>>;
+    options: Readonly<InterpreterOptions<TLogic>>;
     /**
      * The unique identifier for this actor relative to its parent.
      */
@@ -50,17 +50,17 @@ export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent exte
     private _doneEvent?;
     src?: string;
     /**
-     * Creates a new Interpreter instance (i.e., service) for the given behavior with the provided options, if any.
+     * Creates a new Interpreter instance (i.e., service) for the given logic with the provided options, if any.
      *
-     * @param behavior The behavior to be interpreted
+     * @param logic The logic to be interpreted
      * @param options Interpreter options
      */
-    constructor(behavior: TBehavior, options?: InterpreterOptions<TBehavior>);
+    constructor(logic: TLogic, options?: InterpreterOptions<TLogic>);
     private _initState;
     private _deferred;
     private update;
-    subscribe(observer: Observer<SnapshotFrom<TBehavior>>): Subscription;
-    subscribe(nextListener?: (state: SnapshotFrom<TBehavior>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
+    subscribe(observer: Observer<SnapshotFrom<TLogic>>): Subscription;
+    subscribe(nextListener?: (state: SnapshotFrom<TLogic>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
     /**
      * Starts the interpreter from the initial state
      */
@@ -86,9 +86,9 @@ export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent exte
     toJSON(): {
         id: string;
     };
-    getPersistedState(): PersistedStateFrom<TBehavior> | undefined;
-    [Symbol.observable](): InteropSubscribable<SnapshotFrom<TBehavior>>;
-    getSnapshot(): SnapshotFrom<TBehavior>;
+    getPersistedState(): PersistedStateFrom<TLogic> | undefined;
+    [Symbol.observable](): InteropSubscribable<SnapshotFrom<TLogic>>;
+    getSnapshot(): SnapshotFrom<TLogic>;
 }
 /**
  * Creates a new Interpreter instance for the given machine with the provided options, if any.
@@ -97,4 +97,4 @@ export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent exte
  * @param options Interpreter options
  */
 export declare function interpret<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : MissingImplementationsError<TMachine['__TResolvedTypesMeta']>, options?: InterpreterOptions<TMachine>): InterpreterFrom<TMachine>;
-export declare function interpret<TBehavior extends AnyActorBehavior>(behavior: TBehavior, options?: InterpreterOptions<TBehavior>): Interpreter<TBehavior>;
+export declare function interpret<TLogic extends AnyActorLogic>(logic: TLogic, options?: InterpreterOptions<TLogic>): Interpreter<TLogic>;

package/dist/declarations/src/stateUtils.d.ts

@@ -2,7 +2,7 @@ import { BaseActionObject, EventObject, StateValue, TransitionConfig, Transition
 import { State } from "./State.js";
 import { NULL_EVENT } from "./constants.js";
 import type { StateNode } from "./StateNode.js";
-import { AnyActorContext, AnyHistoryValue, AnyState, AnyStateMachine, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, InitialTransitionDefinition, StateFromMachine } from "./index.js";
+import { AnyActorContext, AnyHistoryValue, AnyState, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, InitialTransitionDefinition } from "./index.js";
 type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
 type AnyConfiguration = Configuration<any, any>;
 type AdjList = Map<AnyStateNode, Array<AnyStateNode>>;
@@ -52,11 +52,9 @@ export declare function removeConflictingTransitions(enabledTransitions: Array<A
  * @param currentState
  * @param mutConfiguration
  */
-export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined, event: TEvent): State<TContext, TEvent, any>;
-export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: BaseActionObject[], event: TEvent, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined): {
-    nextState: AnyState;
-};
-export declare function macrostep<TMachine extends AnyStateMachine>(state: StateFromMachine<TMachine>, event: TMachine['__TEvent'], actorCtx: AnyActorContext | undefined): {
+export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext, event: TEvent): State<TContext, TEvent, any>;
+export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: BaseActionObject[], event: TEvent, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined): [AnyState, BaseActionObject[]];
+export declare function macrostep(state: AnyState, event: EventObject, actorCtx: AnyActorContext): {
     state: typeof state;
     microstates: Array<typeof state>;
 };

package/dist/declarations/src/types.d.ts

@@ -76,12 +76,12 @@ export type MachineContext = Record<string, any>;
 export interface ActionMeta<TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> extends StateMeta<TEvent> {
     action: TAction;
 }
-export type Spawner = <T extends ActorBehavior<any, any> | string>(// TODO: read string from machine behavior keys
-behavior: T, options?: Partial<{
+export type Spawner = <T extends ActorLogic<any, any> | string>(// TODO: read string from machine logic keys
+logic: T, options?: Partial<{
     id: string;
     systemId?: string;
     input: any;
-}>) => T extends ActorBehavior<infer TActorEvent, infer TActorEmitted> ? ActorRef<TActorEvent, TActorEmitted> : ActorRef<any, any>;
+}>) => T extends ActorLogic<infer TActorEvent, infer TActorEmitted, infer _, infer __, infer ___> ? ActorRef<TActorEvent, TActorEmitted> : ActorRef<any, any>;
 export interface AssignMeta<TExpressionEvent extends EventObject, _TEvent extends EventObject> extends StateMeta<TExpressionEvent> {
     action: BaseActionObject;
     event: TExpressionEvent;
@@ -182,17 +182,10 @@ type ExtractWithSimpleSupport<T extends {
 export type Receiver<TEvent extends EventObject> = (listener: {
     bivarianceHack(event: TEvent): void;
 }['bivarianceHack']) => void;
-export type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject> = (sendBack: (event: TSentEvent) => void, onReceive: Receiver<TEvent>, { input }: {
+export type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject> = (sendBack: (event: TSentEvent) => void, onReceive: Receiver<TEvent>, { input, system }: {
     input: any;
+    system: AnyActorSystem;
 }) => (() => void) | Promise<any> | void;
-export type ActorBehaviorCreator<TContext extends MachineContext, TEvent extends EventObject, TActorBehavior extends AnyActorBehavior = AnyActorBehavior> = (context: TContext, event: TEvent, meta: {
-    id: string;
-    data?: any;
-    src: string;
-    event: TEvent;
-    meta: MetaObject | undefined;
-    input: any;
-}) => TActorBehavior;
 export interface InvokeMeta {
     src: string;
     meta: MetaObject | undefined;
@@ -201,7 +194,7 @@ export interface InvokeDefinition<TContext extends MachineContext, TEvent extend
     id: string;
     systemId: string | undefined;
     /**
-     * The source of the actor's behavior to be invoked
+     * The source of the actor logic to be invoked
      */
     src: string;
     input?: Mapper<TContext, TEvent, any> | any;
@@ -259,7 +252,7 @@ export interface InvokeConfig<TContext extends MachineContext, TEvent extends Ev
     /**
      * The source of the machine to be invoked, or the machine itself.
      */
-    src: string | ActorBehavior<any, any>;
+    src: string | ActorLogic<any, any>;
     input?: Mapper<TContext, TEvent, any> | any;
     /**
      * The transition to take upon the invoked child machine reaching its final top-level state.
@@ -428,8 +421,8 @@ export type DelayConfig<TContext extends MachineContext, TEvent extends EventObj
 export interface MachineImplementationsSimplified<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> {
     guards: Record<string, GuardPredicate<TContext, TEvent>>;
     actions: ActionFunctionMap<TContext, TEvent, TAction>;
-    actors: Record<string, AnyActorBehavior | {
-        src: AnyActorBehavior;
+    actors: Record<string, AnyActorLogic | {
+        src: AnyActorLogic;
         input: Mapper<TContext, TEvent, any> | any;
     }>;
     delays: DelayFunctionMap<TContext, TEvent>;
@@ -446,8 +439,8 @@ type MachineImplementationsGuards<TContext extends MachineContext, TResolvedType
     [K in keyof TEventsCausingGuards]?: GuardPredicate<TContext, Cast<Prop<TIndexedEvents, TEventsCausingGuards[K]>, EventObject>>;
 };
 type MachineImplementationsActors<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingActors = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingActors'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, _TInvokeSrcNameMap = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'invokeSrcNameMap'>> = {
-    [K in keyof TEventsCausingActors]?: AnyActorBehavior | {
-        src: AnyActorBehavior;
+    [K in keyof TEventsCausingActors]?: AnyActorLogic | {
+        src: AnyActorLogic;
         input: Mapper<TContext, Cast<Prop<TIndexedEvents, TEventsCausingActors[K]>, EventObject>, any> | any;
     };
 };
@@ -782,9 +775,7 @@ export interface StateLike<TContext extends MachineContext> {
 export interface StateConfig<TContext extends MachineContext, TEvent extends EventObject> {
     value: StateValue;
     context: TContext;
-    event: TEvent;
     historyValue?: HistoryValue<TContext, TEvent>;
-    actions?: BaseActionObject[];
     meta?: any;
     configuration?: Array<StateNode<TContext, TEvent>>;
     transitions?: Array<TransitionDefinition<TContext, TEvent>>;
@@ -795,7 +786,7 @@ export interface StateConfig<TContext extends MachineContext, TEvent extends Eve
     machine?: StateMachine<TContext, TEvent, any, any, any>;
     _internalQueue?: Array<TEvent>;
 }
-export interface InterpreterOptions<_TActorBehavior extends AnyActorBehavior> {
+export interface InterpreterOptions<_TActorLogic extends AnyActorLogic> {
     /**
      * Whether state actions should be executed immediately upon transition. Defaults to `true`.
      */
@@ -855,7 +846,6 @@ export interface Subscribable<T> extends InteropSubscribable<T> {
     subscribe(observer: Observer<T>): Subscription;
     subscribe(next: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
 }
-export type Spawnable = AnyStateMachine | PromiseLike<any> | InvokeCallback | InteropObservable<any> | Subscribable<any> | ActorBehavior<any, any>;
 export type ExtractEvent<TEvent extends EventObject, TEventType extends TEvent['type']> = TEvent extends any ? TEventType extends TEvent['type'] ? TEvent : never : never;
 export interface BaseActorRef<TEvent extends EventObject> {
     send: (event: TEvent) => void;
@@ -883,9 +873,9 @@ export interface ActorRef<TEvent extends EventObject, TSnapshot = any> extends S
 export type AnyActorRef = ActorRef<any, any>;
 export type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer TEvent, any, any, infer TResolvedTypesMeta> ? ActorRef<TEvent, State<TContext, TEvent, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>> : R extends Promise<infer U> ? ActorRef<{
     type: string;
-}, U | undefined> : R extends ActorBehavior<infer TEvent, infer TSnapshot> ? ActorRef<TEvent, TSnapshot> : never : never;
+}, U | undefined> : R extends ActorLogic<infer TEvent, infer TSnapshot> ? ActorRef<TEvent, TSnapshot> : never : never;
 export type DevToolsAdapter = (service: AnyInterpreter) => void;
-export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, any, any, infer TResolvedTypesMeta> ? Interpreter<ActorBehavior<TEvent, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>>> : never;
+export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, any, any, infer TResolvedTypesMeta> ? Interpreter<ActorLogic<TEvent, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>>> : never;
 export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, any, any, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TEvent, TResolvedTypesMeta, TRequireMissingImplementations> : never;
 export type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, any, any, infer TResolvedTypesMeta> ? TResolvedTypesMeta : never;
 export type EventOfMachine<TMachine extends AnyStateMachine> = TMachine extends StateMachine<any, infer E, any, any, any> ? E : never;
@@ -899,7 +889,7 @@ export interface ActorContext<TEvent extends EventObject, TSnapshot, TSystem ext
     stopChild: (child: AnyActorRef) => void;
 }
 export type AnyActorContext = ActorContext<any, any, any>;
-export interface ActorBehavior<TEvent extends EventObject, TSnapshot = any, TInternalState = any, 
+export interface ActorLogic<TEvent extends EventObject, TSnapshot = any, TInternalState = TSnapshot, 
 /**
  * Serialized internal state used for persistence & restoration
  */
@@ -919,14 +909,14 @@ TPersisted = TInternalState, TSystem extends ActorSystem<any> = ActorSystem<any>
      */
     getPersistedState?: (state: TInternalState) => TPersisted;
 }
-export type AnyActorBehavior = ActorBehavior<any, any, any, any>;
-export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TSnapshot> ? TSnapshot : R extends Interpreter<infer TBehavior> ? SnapshotFrom<TBehavior> : R extends StateMachine<infer _, infer __, infer ___, infer ____, infer _____> ? StateFrom<R> : R extends ActorBehavior<infer _, infer TSnapshot, infer __, infer ___, infer ____> ? TSnapshot : R extends ActorContext<infer _, infer TSnapshot, infer __> ? TSnapshot : never : never;
-export type EventFromBehavior<TBehavior extends ActorBehavior<any, any>> = TBehavior extends ActorBehavior<infer TEvent, infer _> ? TEvent : never;
-export type PersistedStateFrom<TBehavior extends ActorBehavior<any, any>> = TBehavior extends ActorBehavior<infer _TEvent, infer _TSnapshot, infer _TInternalState, infer TPersisted> ? TPersisted : never;
-export type InternalStateFrom<TBehavior extends ActorBehavior<any, any>> = TBehavior extends ActorBehavior<infer _TEvent, infer _TSnapshot, infer TInternalState, infer _TPersisted> ? TInternalState : never;
+export type AnyActorLogic = ActorLogic<any, any, any, any>;
+export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TSnapshot> ? TSnapshot : R extends Interpreter<infer TLogic> ? SnapshotFrom<TLogic> : R extends StateMachine<infer _, infer __, infer ___, infer ____, infer _____> ? StateFrom<R> : R extends ActorLogic<infer _, infer TSnapshot, infer __, infer ___, infer ____> ? TSnapshot : R extends ActorContext<infer _, infer TSnapshot, infer __> ? TSnapshot : never : never;
+export type EventFromLogic<TLogic extends ActorLogic<any, any>> = TLogic extends ActorLogic<infer TEvent, infer _, infer __, infer ___, infer ____> ? TEvent : never;
+export type PersistedStateFrom<TLogic extends ActorLogic<any, any>> = TLogic extends ActorLogic<infer _TEvent, infer _TSnapshot, infer _TInternalState, infer TPersisted> ? TPersisted : never;
+export type InternalStateFrom<TLogic extends ActorLogic<any, any>> = TLogic extends ActorLogic<infer _TEvent, infer _TSnapshot, infer TInternalState, infer _TPersisted> ? TInternalState : never;
 type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer TEvent, infer __, infer ___, infer ____> ? TEvent : R extends State<infer _, infer TEvent, infer __> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
 export type EventFrom<T, K extends Prop<TEvent, 'type'> = never, TEvent extends EventObject = ResolveEventType<T>> = IsNever<K> extends true ? TEvent : ExtractEvent<TEvent, K>;
-export type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _, infer __, infer ___, infer ____> ? TContext : R extends State<infer TContext, infer _, infer __> ? TContext : R extends Interpreter<infer TBehavior> ? TBehavior extends StateMachine<infer TContext, infer _> ? TContext : never : never : never;
+export type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _, infer __, infer ___, infer ____> ? TContext : R extends State<infer TContext, infer _, infer __> ? TContext : R extends Interpreter<infer TActorLogic> ? TActorLogic extends StateMachine<infer TContext, infer _> ? TContext : never : never : never;
 export type InferEvent<E extends EventObject> = {
     [T in E['type']]: {
         type: T;
@@ -937,7 +927,6 @@ export type InferEvent<E extends EventObject> = {
 export type TODO = any;
 export type StateValueFrom<TMachine extends AnyStateMachine> = Parameters<StateFrom<TMachine>['matches']>[0];
 export type TagsFrom<TMachine extends AnyStateMachine> = Parameters<StateFrom<TMachine>['hasTag']>[0];
-export type StateFromMachine<TMachine extends AnyStateMachine> = TMachine['initialState'];
 export interface ActorSystemInfo {
     actors: Record<string, AnyActorRef>;
 }
@@ -948,7 +937,8 @@ export interface ActorSystem<T extends ActorSystemInfo> {
     _set: <K extends keyof T['actors']>(key: K, actorRef: T['actors'][K]) => void;
     get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;
 }
-export type PersistedMachineState<TState extends AnyState> = Pick<TState, 'value' | 'output' | 'context' | 'event' | 'done' | 'historyValue'> & {
+export type AnyActorSystem = ActorSystem<any>;
+export type PersistedMachineState<TState extends AnyState> = Pick<TState, 'value' | 'output' | 'context' | 'done' | 'historyValue'> & {
     children: {
         [K in keyof TState['children']]: {
             state: any;

package/dist/declarations/src/utils.d.ts

@@ -1,7 +1,7 @@
-import { AnyActorBehavior, AnyState } from "./index.js";
+import { AnyActorLogic, AnyState } from "./index.js";
 import { NULL_EVENT } from "./constants.js";
 import type { StateNode } from "./StateNode.js";
-import type { ActorBehavior, AnyEventObject, EventObject, EventType, InvokeConfig, MachineContext, Mapper, Observer, PropertyMapper, ErrorEvent, SingleOrArray, StateLike, StateValue, Subscribable, TransitionConfig, TransitionConfigTarget } from "./types.js";
+import type { ActorLogic, AnyEventObject, EventObject, EventType, InvokeConfig, MachineContext, Mapper, Observer, PropertyMapper, ErrorEvent, SingleOrArray, StateLike, StateValue, Subscribable, TransitionConfig, TransitionConfigTarget } from "./types.js";
 export declare function keys<T extends object>(value: T): Array<keyof T & string>;
 export declare function matchesState(parentStateId: StateValue, childStateId: StateValue, delimiter?: string): boolean;
 export declare function toStatePath(stateId: string | string[], delimiter: string): string[];
@@ -30,7 +30,7 @@ export declare function toArray<T>(value: T[] | T | undefined): T[];
 export declare function mapContext<TContext extends MachineContext, TEvent extends EventObject>(mapper: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>, context: TContext, event: TEvent): any;
 export declare function isBuiltInEvent(eventType: EventType): boolean;
 export declare function isPromiseLike(value: any): value is PromiseLike<any>;
-export declare function isBehavior(value: any): value is ActorBehavior<any, any>;
+export declare function isActorLogic(value: any): value is ActorLogic<any, any>;
 export declare function partition<T, A extends T, B extends T>(items: T[], predicate: (item: T) => item is A): [A[], B[]];
 export declare function isArray(value: any): value is any[];
 export declare function isFunction(value: any): value is Function;
@@ -43,13 +43,13 @@ export declare function toTransitionConfigArray<TContext extends MachineContext,
 }>;
 export declare function normalizeTarget<TContext extends MachineContext, TEvent extends EventObject>(target: SingleOrArray<string | StateNode<TContext, TEvent>> | undefined): Array<string | StateNode<TContext, TEvent>> | undefined;
 export declare function reportUnhandledExceptionOnInvocation(originalError: any, currentError: any, id: string): void;
-export declare function toInvokeConfig<TContext extends MachineContext, TEvent extends EventObject>(invocable: InvokeConfig<TContext, TEvent> | string | ActorBehavior<any, any>, id: string): InvokeConfig<TContext, TEvent>;
+export declare function toInvokeConfig<TContext extends MachineContext, TEvent extends EventObject>(invocable: InvokeConfig<TContext, TEvent> | string | ActorLogic<any, any>, id: string): InvokeConfig<TContext, TEvent>;
 export declare function toObserver<T>(nextHandler?: Observer<T> | ((value: T) => void), errorHandler?: (error: any) => void, completionHandler?: () => void): Observer<T>;
 export declare function createInvokeId(stateNodeId: string, index: number): string;
-export declare function resolveReferencedActor(referenced: AnyActorBehavior | {
-    src: AnyActorBehavior;
+export declare function resolveReferencedActor(referenced: AnyActorLogic | {
+    src: AnyActorLogic;
     input: Mapper<any, any, any> | any;
 } | undefined): {
-    src: AnyActorBehavior;
+    src: AnyActorLogic;
     input: Mapper<any, any, any> | any;
 } | undefined;