xstate 5.0.0-beta.28 → 5.0.0-beta.30

package/dist/declarations/src/actions/send.d.ts

@@ -1,6 +1,6 @@
 import { ActionArgs, ActorRef, AnyActorRef, AnyEventObject, Cast, EventFrom, EventObject, InferEvent, MachineContext, SendExpr, SendToActionOptions, SendToActionParams, UnifiedArg, ParameterizedObject, NoInfer } from "../types.js";
-export interface SendToAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TDelay extends string> {
-    (_: ActionArgs<TContext, TExpressionEvent, TExpressionAction>): void;
+export interface SendToAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TDelay extends string> {
+    (_: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>): void;
     _out_TDelay?: TDelay;
 }
 /**
@@ -12,22 +12,22 @@ export interface SendToAction<TContext extends MachineContext, TExpressionEvent
  *  - `id` - The unique send event identifier (used with `cancel()`).
  *  - `delay` - The number of milliseconds to delay the sending of the event.
  */
-export declare function sendTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TActor extends AnyActorRef, TDelay extends string>(to: TActor | string | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction>) => TActor | string), eventOrExpr: EventFrom<TActor> | SendExpr<TContext, TExpressionEvent, TExpressionAction, InferEvent<Cast<EventFrom<TActor>, EventObject>>>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, NoInfer<TDelay>>): SendToAction<TContext, TExpressionEvent, TExpressionAction, TDelay>;
+export declare function sendTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TTargetActor extends AnyActorRef, TEvent extends EventObject, TDelay extends string>(to: TTargetActor | string | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => TTargetActor | string), eventOrExpr: EventFrom<TTargetActor> | SendExpr<TContext, TExpressionEvent, TExpressionAction, InferEvent<Cast<EventFrom<TTargetActor>, EventObject>>, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, NoInfer<TEvent>, NoInfer<TDelay>>): SendToAction<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>;
 /**
  * Sends an event to this machine's parent.
  *
  * @param event The event to send to the parent machine.
  * @param options Options to pass into the send event.
  */
-export declare function sendParent<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TSentEvent extends EventObject = AnyEventObject, TDelay extends string = string>(event: TSentEvent | SendExpr<TContext, TExpressionEvent, TExpressionAction, TSentEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, TDelay>): SendToAction<TContext, TExpressionEvent, TExpressionAction, TDelay>;
-type Target<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined> = string | ActorRef<any, any> | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction>) => string | ActorRef<any, any>);
+export declare function sendParent<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TSentEvent extends EventObject = AnyEventObject, TEvent extends EventObject = AnyEventObject, TDelay extends string = string>(event: TSentEvent | SendExpr<TContext, TExpressionEvent, TExpressionAction, TSentEvent, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>): SendToAction<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>;
+type Target<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> = string | ActorRef<any, any> | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => string | ActorRef<any, any>);
 /**
  * Forwards (sends) an event to a specified service.
  *
  * @param target The target service to forward the event to.
  * @param options Options to pass into the send action creator.
  */
-export declare function forwardTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TDelay extends string>(target: Target<TContext, TExpressionEvent, TExpressionAction>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, TDelay>): (args: ActionArgs<TContext, TExpressionEvent, TExpressionAction>) => void;
+export declare function forwardTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TDelay extends string>(target: Target<TContext, TExpressionEvent, TExpressionAction, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>): SendToAction<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay>;
 /**
  * Escalates an error by sending it as an event to this machine's parent.
  *
@@ -35,5 +35,5 @@ export declare function forwardTo<TContext extends MachineContext, TExpressionEv
  * takes in the `context`, `event`, and `meta`, and returns the error data to send.
  * @param options Options to pass into the send action creator.
  */
-export declare function escalate<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TErrorData = any>(errorData: TErrorData | ((args: UnifiedArg<TContext, TExpressionEvent>) => TErrorData), options?: SendToActionParams<TContext, TExpressionEvent, TExpressionAction, EventObject, string>): SendToAction<TContext, TExpressionEvent, TExpressionAction, string>;
+export declare function escalate<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TErrorData = any, TEvent extends EventObject = AnyEventObject>(errorData: TErrorData | ((args: UnifiedArg<TContext, TExpressionEvent, TEvent>) => TErrorData), options?: SendToActionParams<TContext, TExpressionEvent, TExpressionAction, EventObject, TEvent, string>): SendToAction<TContext, TExpressionEvent, TExpressionAction, TEvent, string>;
 export {};

package/dist/declarations/src/actions/stop.d.ts

@@ -1,12 +1,12 @@
 import { ActionArgs, ActorRef, EventObject, MachineContext, ParameterizedObject } from "../types.js";
-type ResolvableActorRef<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined> = string | ActorRef<any> | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction>) => ActorRef<any> | string);
-export interface StopAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined> {
-    (_: ActionArgs<TContext, TExpressionEvent, TExpressionAction>): void;
+type ResolvableActorRef<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> = string | ActorRef<any, any> | ((args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => ActorRef<any, any> | string);
+export interface StopAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> {
+    (_: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>): void;
 }
 /**
  * Stops an actor.
  *
  * @param actorRef The actor to stop.
  */
-export declare function stop<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined>(actorRef: ResolvableActorRef<TContext, TExpressionEvent, TExpressionAction>): StopAction<TContext, TExpressionEvent, TExpressionAction>;
+export declare function stop<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject>(actorRef: ResolvableActorRef<TContext, TExpressionEvent, TExpressionAction, TEvent>): StopAction<TContext, TExpressionEvent, TExpressionAction, TEvent>;
 export {};

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

@@ -1,11 +1,10 @@
-import { ActorLogic, EventObject, AnyActorSystem, AnyEventObject, ActorSystem, ActorRefFrom } from "../types.js";
-export interface CallbackInternalState<TEvent extends EventObject, TInput = unknown> {
-    canceled: boolean;
-    receivers: Set<(e: TEvent) => void>;
-    dispose: void | (() => void) | Promise<any>;
+import { ActorLogic, EventObject, AnyActorSystem, AnyEventObject, ActorSystem, ActorRefFrom, Snapshot, HomomorphicOmit } from "../types.js";
+type CallbackSnapshot<TInput, TEvent> = Snapshot<undefined> & {
     input: TInput;
-}
-export type CallbackActorLogic<TEvent extends EventObject, TInput = unknown> = ActorLogic<TEvent, undefined, CallbackInternalState<TEvent, TInput>, Pick<CallbackInternalState<TEvent, TInput>, 'input' | 'canceled'>, ActorSystem<any>, TInput, any>;
+    _receivers: Set<(e: TEvent) => void>;
+    _dispose: (() => void) | void;
+};
+export type CallbackActorLogic<TEvent extends EventObject, TInput = unknown> = ActorLogic<CallbackSnapshot<TInput, TEvent>, TEvent, TInput, HomomorphicOmit<CallbackSnapshot<TInput, TEvent>, '_receivers' | '_dispose'>, ActorSystem<any>>;
 export type CallbackActorRef<TEvent extends EventObject, TInput = unknown> = ActorRefFrom<CallbackActorLogic<TEvent, TInput>>;
 export type Receiver<TEvent extends EventObject> = (listener: {
     bivarianceHack(event: TEvent): void;
@@ -16,5 +15,6 @@ export type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEve
     self: CallbackActorRef<TEvent>;
     sendBack: (event: TSentEvent) => void;
     receive: Receiver<TEvent>;
-}) => (() => void) | Promise<any> | void;
+}) => (() => void) | void;
 export declare function fromCallback<TEvent extends EventObject, TInput>(invokeCallback: InvokeCallback<TEvent, AnyEventObject, TInput>): CallbackActorLogic<TEvent, TInput>;
+export {};

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

@@ -1,8 +1,6 @@
-import type { ActorRef, AnyEventObject, BaseActorRef, EventObject } from "../types.js";
+import type { ActorRef, AnyEventObject, Snapshot } from "../types.js";
 export { fromCallback, type CallbackActorLogic } from "./callback.js";
 export { fromEventObservable, fromObservable, type ObservableActorLogic } from "./observable.js";
 export { fromPromise, type PromiseActorLogic } from "./promise.js";
-export { fromTransition, type TransitionActorLogic } from "./transition.js";
-export declare function isActorRef(item: any): item is ActorRef<any>;
-export declare function toActorRef<TEvent extends EventObject, TSnapshot = any, TActorRefLike extends BaseActorRef<TEvent> = BaseActorRef<TEvent>>(actorRefLike: TActorRefLike): ActorRef<TEvent, TSnapshot> & Omit<TActorRefLike, keyof ActorRef<any, any>>;
-export declare function createEmptyActor(): ActorRef<AnyEventObject, undefined>;
+export { fromTransition, type TransitionActorLogic, type TransitionSnapshot } from "./transition.js";
+export declare function createEmptyActor(): ActorRef<AnyEventObject, Snapshot<undefined>>;

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

@@ -1,21 +1,20 @@
-import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem, ActorRefFrom } from "../types.js";
-export interface ObservableInternalState<T, TInput = unknown> {
-    subscription: Subscription | undefined;
-    status: 'active' | 'done' | 'error' | 'canceled';
-    data: T | undefined;
+import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem, ActorRefFrom, Snapshot, HomomorphicOmit } from "../types.js";
+export type ObservableSnapshot<TContext, TInput> = Snapshot<undefined> & {
+    context: TContext | undefined;
     input: TInput | undefined;
-}
-export type ObservablePersistedState<T, TInput = unknown> = Omit<ObservableInternalState<T, TInput>, 'subscription'>;
-export type ObservableActorLogic<T, TInput> = ActorLogic<{
+    _subscription: Subscription | undefined;
+};
+export type ObservablePersistedState<TContext, TInput> = HomomorphicOmit<ObservableSnapshot<TContext, TInput>, '_subscription'>;
+export type ObservableActorLogic<TContext, TInput> = ActorLogic<ObservableSnapshot<TContext, TInput>, {
     type: string;
     [k: string]: unknown;
-}, T | undefined, ObservableInternalState<T, TInput>, ObservablePersistedState<T, TInput>, AnyActorSystem, TInput>;
-export type ObservableActorRef<T> = ActorRefFrom<ObservableActorLogic<T, any>>;
-export declare function fromObservable<T, TInput>(observableCreator: ({ input, system }: {
+}, TInput, ObservablePersistedState<TContext, TInput>, AnyActorSystem>;
+export type ObservableActorRef<TContext> = ActorRefFrom<ObservableActorLogic<TContext, any>>;
+export declare function fromObservable<TContext, TInput>(observableCreator: ({ input, system }: {
     input: TInput;
     system: AnyActorSystem;
-    self: ObservableActorRef<T>;
-}) => Subscribable<T>): ObservableActorLogic<T, TInput>;
+    self: ObservableActorRef<TContext>;
+}) => Subscribable<TContext>): ObservableActorLogic<TContext, TInput>;
 /**
  * Creates event observable logic that listens to an observable
  * that delivers event objects.

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

@@ -1,10 +1,8 @@
-import { ActorLogic, ActorRefFrom, ActorSystem, AnyActorSystem } from "../types.js";
+import { ActorLogic, ActorRefFrom, ActorSystem, AnyActorSystem, Snapshot } from "../types.js";
 import { XSTATE_STOP } from "../constants.js";
-export interface PromiseInternalState<T, TInput = unknown> {
-    status: 'active' | 'error' | 'done' | 'canceled';
-    data: T | undefined;
+export type PromiseSnapshot<TOutput, TInput> = Snapshot<TOutput> & {
     input: TInput | undefined;
-}
+};
 declare const resolveEventType = "$$xstate.resolve";
 declare const rejectEventType = "$$xstate.reject";
 export type PromiseActorEvents<T> = {
@@ -16,17 +14,16 @@ export type PromiseActorEvents<T> = {
 } | {
     type: typeof XSTATE_STOP;
 };
-export type PromiseActorLogic<T, TInput = unknown> = ActorLogic<{
+export type PromiseActorLogic<TOutput, TInput = unknown> = ActorLogic<PromiseSnapshot<TOutput, TInput>, {
     type: string;
     [k: string]: unknown;
-}, T | undefined, PromiseInternalState<T, TInput>, // internal state
-PromiseInternalState<T, TInput>, // persisted state
-ActorSystem<any>, TInput, // input
-T>;
-export type PromiseActorRef<T> = ActorRefFrom<PromiseActorLogic<T>>;
-export declare function fromPromise<T, TInput>(promiseCreator: ({ input, system }: {
+}, TInput, // input
+PromiseSnapshot<TOutput, TInput>, // persisted state
+ActorSystem<any>>;
+export type PromiseActorRef<TOutput> = ActorRefFrom<PromiseActorLogic<TOutput, unknown>>;
+export declare function fromPromise<TOutput, TInput = unknown>(promiseCreator: ({ input, system }: {
     input: TInput;
     system: AnyActorSystem;
-    self: PromiseActorRef<T>;
-}) => PromiseLike<T>): PromiseActorLogic<T, TInput>;
+    self: PromiseActorRef<TOutput>;
+}) => PromiseLike<TOutput>): PromiseActorLogic<TOutput, TInput>;
 export {};

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

@@ -1,16 +1,19 @@
-import { ActorLogic, ActorContext, ActorSystem, EventObject, ActorRefFrom, AnyActorSystem } from "../types.js";
-export type TransitionActorLogic<TState, TEvent extends EventObject, TInput> = ActorLogic<TEvent, TState, TState, TState, AnyActorSystem, TInput>;
-export type TransitionActorRef<TState, TEvent extends EventObject> = ActorRefFrom<TransitionActorLogic<TState, TEvent, unknown>>;
+import { ActorLogic, ActorContext, ActorSystem, EventObject, ActorRefFrom, AnyActorSystem, Snapshot } from "../types.js";
+export type TransitionSnapshot<TContext> = Snapshot<undefined> & {
+    context: TContext;
+};
+export type TransitionActorLogic<TContext, TEvent extends EventObject, TInput> = ActorLogic<TransitionSnapshot<TContext>, TEvent, TInput, TransitionSnapshot<TContext>, AnyActorSystem>;
+export type TransitionActorRef<TContext, TEvent extends EventObject> = ActorRefFrom<TransitionActorLogic<TransitionSnapshot<TContext>, TEvent, unknown>>;
 /**
  * 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.
+ * @param initialContext The initial state of the transition function.
  * @returns Actor logic
  */
-export declare function fromTransition<TState, TEvent extends EventObject, TSystem extends ActorSystem<any>, TInput>(transition: (state: TState, event: TEvent, actorContext: ActorContext<TEvent, TState, TSystem>) => TState, initialState: TState | (({ input, self }: {
+export declare function fromTransition<TContext, TEvent extends EventObject, TSystem extends ActorSystem<any>, TInput>(transition: (state: TContext, event: TEvent, actorContext: ActorContext<TransitionSnapshot<TContext>, TEvent, TSystem>) => TContext, initialContext: TContext | (({ input, self }: {
     input: TInput;
-    self: TransitionActorRef<TState, TEvent>;
-}) => TState)): TransitionActorLogic<TState, TEvent, TInput>;
+    self: TransitionActorRef<TContext, TEvent>;
+}) => TContext)): TransitionActorLogic<TContext, TEvent, TInput>;

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

@@ -2,7 +2,7 @@ export * from "./actions.js";
 export * from "./actors/index.js";
 export { SimulatedClock } from "./SimulatedClock.js";
 export { type Spawner } from "./spawn.js";
-export { StateMachine } from "./StateMachine.js";
+export { StateMachine, type MachineSnapshot } from "./StateMachine.js";
 export { getStateNodes } from "./stateUtils.js";
 export * from "./typegenTypes.js";
 export * from "./types.js";

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

@@ -19,7 +19,7 @@ export declare enum ActorStatus {
  * @deprecated Use `ActorStatus` instead.
  */
 export declare const InterpreterStatus: typeof ActorStatus;
-export declare class Actor<TLogic extends AnyActorLogic, TEvent extends EventObject = EventFromLogic<TLogic>> implements ActorRef<TEvent, SnapshotFrom<TLogic>> {
+export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<EventFromLogic<TLogic>, SnapshotFrom<TLogic>> {
     logic: TLogic;
     /**
      * The current internal state of the actor.
@@ -42,8 +42,8 @@ export declare class Actor<TLogic extends AnyActorLogic, TEvent extends EventObj
      * Whether the service is started.
      */
     status: ActorStatus;
-    _parent?: ActorRef<any>;
-    ref: ActorRef<TEvent>;
+    _parent?: ActorRef<any, any>;
+    ref: ActorRef<EventFromLogic<TLogic>, SnapshotFrom<TLogic>>;
     private _actorContext;
     private _systemId;
     /**
@@ -83,7 +83,7 @@ export declare class Actor<TLogic extends AnyActorLogic, TEvent extends EventObj
      *
      * @param event The event to send
      */
-    send(event: TEvent): void;
+    send(event: EventFromLogic<TLogic>): void;
     delaySend({ event, id, delay, to }: {
         event: EventObject;
         id: string | undefined;

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

@@ -35,12 +35,11 @@ export declare function getStateNodeByPath(stateNode: AnyStateNode, statePath: s
  *
  * @param state The state value or State instance
  */
-export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, state: StateValue | State<TContext, TEvent, TODO, TODO, TODO, TODO>): Array<AnyStateNode>;
-export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, state: State<TContext, TEvent, TODO, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent, TODO, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent, TODO, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, state: State<TContext, TEvent, TODO, TODO, TODO, // output
-TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, state: StateValue | State<TContext, TEvent, TODO, TODO, TODO>): Array<AnyStateNode>;
+export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, state: State<TContext, TEvent, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, state: State<TContext, TEvent, TODO, TODO, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, configuration: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure

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

@@ -1,12 +1,18 @@
 import type { StateNode } from "./StateNode.js";
 import type { State } from "./State.js";
 import type { ActorStatus, Clock, Actor } from "./interpreter.js";
-import type { StateMachine } from "./StateMachine.js";
+import type { MachineSnapshot, StateMachine } from "./StateMachine.js";
 import { TypegenDisabled, ResolveTypegenMeta, TypegenConstraint, MarkAllImplementationsAsProvided, AreAllImplementationsAssumedToBeProvided } from "./typegenTypes.js";
 import { PromiseActorLogic } from "./actors/promise.js";
 import { Guard, GuardPredicate, UnknownGuard } from "./guards.js";
 import { Spawner } from "./spawn.js";
 import { AssignArgs } from "./actions/assign.js";
+export type HomomorphicPick<T, K extends keyof any> = {
+    [P in keyof T as P & K]: T[P];
+};
+export type HomomorphicOmit<T, K extends keyof any> = {
+    [P in keyof T as Exclude<P, K>]: T[P];
+};
 /**
  * `T | unknown` reduces to `unknown` and that can be problematic when it comes to contextual typing.
  * It especially is a problem when the union has a function member, like here:
@@ -58,20 +64,22 @@ export interface ParameterizedObject {
     type: string;
     params?: Record<string, unknown>;
 }
-export interface UnifiedArg<TContext extends MachineContext, TExpressionEvent extends EventObject> {
+export interface UnifiedArg<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> {
     context: TContext;
     event: TExpressionEvent;
-    self: ActorRef<TExpressionEvent>;
+    self: ActorRef<TEvent, MachineSnapshot<TContext, TEvent, ProvidedActor, string, unknown>>;
     system: ActorSystem<any>;
 }
 export type MachineContext = Record<string, any>;
-export interface ActionArgs<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject | undefined> extends UnifiedArg<TContext, TEvent> {
-    action: TAction;
+export interface ActionArgs<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> extends UnifiedArg<TContext, TExpressionEvent, TEvent> {
+    action: TExpressionAction;
 }
-export type InputFrom<T extends AnyActorLogic> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TInput : T extends ActorLogic<infer _TEvent, infer _TSnapshot, infer _TInternalState, infer _TPersisted, infer _TSystem, infer TInput> ? TInput : never;
-export type OutputFrom<T extends AnyActorLogic> = T extends ActorLogic<infer _TEvent, infer _TSnapshot, infer _TInternalState, infer _TPersisted, infer _TSystem, infer _TInput, infer TOutput> ? TOutput : never;
+export type InputFrom<T extends AnyActorLogic> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TInput : T extends ActorLogic<infer _TSnapshot, infer _TEvent, infer TInput, infer _TPersisted, infer _TSystem> ? TInput : never;
+export type OutputFrom<T extends AnyActorLogic> = T extends ActorLogic<infer TSnapshot, infer _TEvent, infer _TInput, infer _TPersisted, infer _TSystem> ? (TSnapshot & {
+    status: 'done';
+})['output'] : never;
 export type ActionFunction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = {
-    (args: ActionArgs<TContext, TExpressionEvent, TExpressionAction>): void;
+    (args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>): void;
     _out_TEvent?: TEvent;
     _out_TActor?: TActor;
     _out_TAction?: TAction;
@@ -143,7 +151,7 @@ type Delay<TDelay extends string> = TDelay | number;
 export type DelayedTransitions<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = {
     [K in Delay<TDelay>]?: string | SingleOrArray<TransitionConfig<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay>>;
 } | Array<TransitionConfig<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay> & {
-    delay: Delay<TDelay> | ((args: UnifiedArg<TContext, TEvent>) => Delay<TDelay>);
+    delay: Delay<TDelay> | ((args: UnifiedArg<TContext, TEvent, TEvent>) => Delay<TDelay>);
 }>;
 export type StateTypes = 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | string;
 export type SingleOrArray<T> = readonly T[] | T;
@@ -338,7 +346,10 @@ export interface StateMachineDefinition<TContext extends MachineContext, TEvent
 }
 export type AnyStateNode = StateNode<any, any>;
 export type AnyStateNodeDefinition = StateNodeDefinition<any, any>;
-export type AnyState = State<any, any, any, any, any, // delays
+export type AnyState = State<any, // context
+any, // event
+any, // actor
+any, // tags
 any>;
 export type AnyStateMachine = StateMachine<any, any, any, any, any, any, any, any, any, // delays
 any>;
@@ -372,8 +383,8 @@ type GuardMap<TContext extends MachineContext, TEvent extends EventObject, TGuar
         type: K;
     } ? TGuard : never, TGuard>;
 };
-export type DelayFunctionMap<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject> = Record<string, DelayConfig<TContext, TEvent, TAction>>;
-export type DelayConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined> = number | DelayExpr<TContext, TExpressionEvent, TExpressionAction>;
+export type DelayFunctionMap<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject> = Record<string, DelayConfig<TContext, TEvent, TAction, TEvent>>;
+export type DelayConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> = number | DelayExpr<TContext, TExpressionEvent, TExpressionAction, TEvent>;
 export interface MachineImplementationsSimplified<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject> {
     guards: GuardMap<TContext, TEvent, TGuard>;
     actions: ActionFunctionMap<TContext, TEvent, TActor, TAction>;
@@ -394,7 +405,7 @@ type MachineImplementationsActors<TContext extends MachineContext, TResolvedType
     };
 };
 type MachineImplementationsDelays<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingDelays'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TIndexedActions = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedActions'>, TIndexedDelays = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedDelays'>> = {
-    [K in keyof TIndexedDelays]?: DelayConfig<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingDelays, K>, Cast<Prop<TIndexedActions, keyof TIndexedActions>, ParameterizedObject> | undefined>;
+    [K in keyof TIndexedDelays]?: DelayConfig<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingDelays, K>, Cast<Prop<TIndexedActions, keyof TIndexedActions>, ParameterizedObject> | undefined, Cast<Prop<TIndexedEvents, keyof TIndexedEvents>, EventObject>>;
 };
 type MachineImplementationsGuards<TContext extends MachineContext, TResolvedTypesMeta, TEventsCausingGuards = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'eventsCausingGuards'>, TIndexedEvents = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedEvents'>, TIndexedGuards = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'indexedGuards'>> = {
     [K in keyof TIndexedGuards]?: Guard<TContext, MaybeNarrowedEvent<TIndexedEvents, TEventsCausingGuards, K>, Cast<TIndexedGuards[K], ParameterizedObject>, Cast<Prop<TIndexedGuards, keyof TIndexedGuards>, ParameterizedObject>>;
@@ -482,34 +493,34 @@ export interface DoneStateEvent<TOutput = unknown> extends EventObject {
     type: `xstate.done.state.${string}`;
     output: TOutput;
 }
-export type DelayExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined> = (args: ActionArgs<TContext, TExpressionEvent, TExpressionAction>) => number;
-export type LogExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined> = (args: ActionArgs<TContext, TExpressionEvent, TExpressionAction>) => unknown;
-export type SendExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TSentEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TExpressionAction>) => TSentEvent;
+export type DelayExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => number;
+export type LogExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => unknown;
+export type SendExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TSentEvent extends EventObject, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TExpressionAction, TEvent>) => TSentEvent;
 export declare enum SpecialTargets {
     Parent = "#_parent",
     Internal = "#_internal"
 }
-export interface SendToActionOptions<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TDelay extends string> extends RaiseActionOptions<TContext, TExpressionEvent, TExpressionAction, TDelay> {
+export interface SendToActionOptions<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TDelay extends string> extends RaiseActionOptions<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay> {
 }
-export interface RaiseActionOptions<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TDelay extends string> {
+export interface RaiseActionOptions<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TDelay extends string> {
     id?: string;
-    delay?: Delay<TDelay> | DelayExpr<TContext, TExpressionEvent, TExpressionAction>;
+    delay?: Delay<TDelay> | DelayExpr<TContext, TExpressionEvent, TExpressionAction, TEvent>;
 }
-export interface RaiseActionParams<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TDelay extends string> extends RaiseActionOptions<TContext, TExpressionEvent, TExpressionAction, TDelay> {
-    event: TEvent | SendExpr<TContext, TExpressionEvent, TExpressionAction, TEvent>;
+export interface RaiseActionParams<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TDelay extends string> extends RaiseActionOptions<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay> {
+    event: TEvent | SendExpr<TContext, TExpressionEvent, TExpressionAction, TEvent, TEvent>;
 }
-export interface SendToActionParams<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TSentEvent extends EventObject, TDelay extends string> extends SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, TDelay> {
-    event: TSentEvent | SendExpr<TContext, TExpressionEvent, TExpressionAction, TSentEvent>;
+export interface SendToActionParams<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TSentEvent extends EventObject, TEvent extends EventObject, TDelay extends string> extends SendToActionOptions<TContext, TExpressionEvent, TExpressionAction, TEvent, TDelay> {
+    event: TSentEvent | SendExpr<TContext, TExpressionEvent, TExpressionAction, TSentEvent, TEvent>;
 }
-export type Assigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TActor extends ProvidedActor> = (args: AssignArgs<TContext, TExpressionEvent, TExpressionAction, TActor>) => Partial<TContext>;
-export type PartialAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TActor extends ProvidedActor, TKey extends keyof TContext> = (args: AssignArgs<TContext, TExpressionEvent, TExpressionAction, TActor>) => TContext[TKey];
-export type PropertyAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TActor extends ProvidedActor> = {
-    [K in keyof TContext]?: PartialAssigner<TContext, TExpressionEvent, TExpressionAction, TActor, K> | TContext[K];
+export type Assigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TActor extends ProvidedActor> = (args: AssignArgs<TContext, TExpressionEvent, TExpressionAction, TEvent, TActor>) => Partial<TContext>;
+export type PartialAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TActor extends ProvidedActor, TKey extends keyof TContext> = (args: AssignArgs<TContext, TExpressionEvent, TExpressionAction, TEvent, TActor>) => TContext[TKey];
+export type PropertyAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TExpressionAction extends ParameterizedObject | undefined, TEvent extends EventObject, TActor extends ProvidedActor> = {
+    [K in keyof TContext]?: PartialAssigner<TContext, TExpressionEvent, TExpressionAction, TEvent, TActor, K> | TContext[K];
 };
 export type Mapper<TContext extends MachineContext, TEvent extends EventObject, TResult> = (args: {
     context: TContext;
     event: TEvent;
-    self: ActorRef<TEvent>;
+    self: ActorRef<TEvent, any>;
 }) => TResult;
 export type PropertyMapper<TContext extends MachineContext, TEvent extends EventObject, TParams extends {}> = {
     [K in keyof TParams]?: Mapper<TContext, TEvent, TParams[K]> | TParams[K];
@@ -539,7 +550,7 @@ export type TransitionDefinitionMap<TContext extends MachineContext, TEvent exte
     [K in EventDescriptor<TEvent>]: Array<TransitionDefinition<TContext, ExtractEvent<TEvent, K>>>;
 };
 export interface DelayedTransitionDefinition<TContext extends MachineContext, TEvent extends EventObject> extends TransitionDefinition<TContext, TEvent> {
-    delay: number | string | DelayExpr<TContext, TEvent, undefined>;
+    delay: number | string | DelayExpr<TContext, TEvent, undefined, TEvent>;
 }
 export interface StateLike<TContext extends MachineContext> {
     value: StateValue;
@@ -552,8 +563,8 @@ export interface StateConfig<TContext extends MachineContext, TEvent extends Eve
     historyValue?: HistoryValue<TContext, TEvent>;
     meta?: any;
     configuration?: Array<StateNode<TContext, TEvent>>;
-    children: Record<string, ActorRef<any>>;
-    done?: boolean;
+    children: Record<string, ActorRef<any, any>>;
+    status: 'active' | 'done' | 'error' | 'stopped';
     output?: any;
     error?: unknown;
     tags?: Set<string>;
@@ -567,15 +578,7 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
     execute?: boolean;
     clock?: Clock;
     logger?: (...args: any[]) => void;
-    parent?: ActorRef<any>;
-    /**
-     * If `true`, defers processing of sent events until the service
-     * is initialized (`.start()`). Otherwise, an error will be thrown
-     * for events sent to an uninitialized service.
-     *
-     * Default: `true`
-     */
-    deferEvents?: boolean;
+    parent?: ActorRef<any, any>;
     /**
      * The custom `id` for referencing this service.
      */
@@ -601,14 +604,14 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      */
     src?: string;
 }
-export type AnyActor = Actor<any, any>;
+export type AnyActor = Actor<any>;
 /**
  * @deprecated Use `AnyActor` instead.
  */
 export type AnyInterpreter = AnyActor;
 export type Observer<T> = {
     next?: (value: T) => void;
-    error?: (err: any) => void;
+    error?: (err: unknown) => void;
     complete?: () => void;
 };
 export interface Subscription {
@@ -631,7 +634,7 @@ export interface BaseActorRef<TEvent extends EventObject> {
 export interface ActorLike<TCurrent, TEvent extends EventObject> extends Subscribable<TCurrent> {
     send: (event: TEvent) => void;
 }
-export interface ActorRef<TEvent extends EventObject, TSnapshot = any> extends Subscribable<TSnapshot>, InteropObservable<TSnapshot> {
+export interface ActorRef<TEvent extends EventObject, TSnapshot extends Snapshot<unknown>> extends Subscribable<TSnapshot>, InteropObservable<TSnapshot> {
     /**
      * The unique identifier for this actor relative to its parent.
      */
@@ -650,12 +653,12 @@ export interface ActorRef<TEvent extends EventObject, TSnapshot = any> extends S
 }
 export type AnyActorRef = ActorRef<any, any>;
 export type ActorLogicFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<any, any, any, any, any, any, any, any, any> ? R : R extends Promise<infer U> ? PromiseActorLogic<U> : never : never;
-export type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer TEvent, infer TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TTag, infer _TInput, infer TOutput, infer TResolvedTypesMeta> ? ActorRef<TEvent, State<TContext, TEvent, TActor, TTag, TOutput, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>> : R extends Promise<infer U> ? ActorRefFrom<PromiseActorLogic<U>> : R extends ActorLogic<infer TEvent, infer TSnapshot, infer _, infer __, infer ___, infer ____, infer _____> ? ActorRef<TEvent, TSnapshot> : never : never;
+export type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer TEvent, infer TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TTag, infer _TInput, infer TOutput, infer TResolvedTypesMeta> ? ActorRef<TEvent, MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>> : R extends Promise<infer U> ? ActorRefFrom<PromiseActorLogic<U>> : R extends ActorLogic<infer TSnapshot, infer TEvent, infer _TInput, infer _TPersisted, infer _TSystem> ? ActorRef<TEvent, TSnapshot> : never : never;
 export type DevToolsAdapter = (service: AnyActor) => void;
 /**
  * @deprecated Use `Actor<T>` instead.
  */
-export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TTag, infer TInput, infer TOutput, infer TResolvedTypesMeta> ? Actor<ActorLogic<TEvent, State<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, State<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>>, ActorSystem<any>, TInput>> : never;
+export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TTag, infer TInput, infer TOutput, infer TResolvedTypesMeta> ? Actor<ActorLogic<MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, TEvent, TInput, PersistedMachineState<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, ActorSystem<any>>> : never;
 export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TActor, infer TAction, infer _TGuard, infer TDelay, infer _TTag, infer _TInput, infer _TOutput, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TEvent, TActor, TAction, TDelay, TResolvedTypesMeta, TRequireMissingImplementations> : never;
 export type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, // context
 any, // event
@@ -667,7 +670,7 @@ any, // tag
 any, // input
 any, // output
 infer TResolvedTypesMeta> ? TResolvedTypesMeta : never;
-export interface ActorContext<TEvent extends EventObject, TSnapshot, TSystem extends ActorSystem<any> = ActorSystem<any>> {
+export interface ActorContext<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TSystem extends ActorSystem<any> = ActorSystem<any>> {
     self: ActorRef<TEvent, TSnapshot>;
     id: string;
     sessionId: string;
@@ -677,38 +680,57 @@ export interface ActorContext<TEvent extends EventObject, TSnapshot, TSystem ext
     stopChild: (child: AnyActorRef) => void;
 }
 export type AnyActorContext = ActorContext<any, any, any>;
-export interface ActorLogic<TEvent extends EventObject, TSnapshot = any, TInternalState = TSnapshot, 
+export type ActorStatusObject<TOutput> = {
+    status: 'done';
+    output: TOutput;
+} | {
+    status: 'error';
+    error: unknown;
+} | {
+    status: 'stopped';
+} | {
+    status: 'active';
+};
+export type Snapshot<TOutput> = {
+    status: 'active';
+    output: undefined;
+    error: undefined;
+} | {
+    status: 'done';
+    output: TOutput;
+    error: undefined;
+} | {
+    status: 'error';
+    output: undefined;
+    error: unknown;
+} | {
+    status: 'stopped';
+    output: undefined;
+    error: undefined;
+};
+export interface ActorLogic<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TInput = unknown, 
 /**
  * Serialized internal state used for persistence & restoration
  */
-TPersisted = TInternalState, TSystem extends ActorSystem<any> = ActorSystem<any>, TInput = any, TOutput = unknown> {
+TPersisted = TSnapshot, TSystem extends ActorSystem<any> = ActorSystem<any>> {
     config?: unknown;
-    transition: (state: TInternalState, message: TEvent, ctx: ActorContext<TEvent, TSnapshot, TSystem>) => TInternalState;
-    getInitialState: (actorCtx: ActorContext<TEvent, TSnapshot, TSystem>, input: TInput) => TInternalState;
-    restoreState?: (persistedState: TPersisted, actorCtx: ActorContext<TEvent, TSnapshot>) => TInternalState;
-    getSnapshot?: (state: TInternalState) => TSnapshot;
-    getStatus?: (state: TInternalState) => {
-        status: string;
-        data?: any;
-    };
-    start?: (state: TInternalState, actorCtx: ActorContext<TEvent, TSnapshot>) => void;
+    transition: (state: TSnapshot, message: TEvent, ctx: ActorContext<TSnapshot, TEvent, TSystem>) => TSnapshot;
+    getInitialState: (actorCtx: ActorContext<TSnapshot, TEvent, TSystem>, input: TInput) => TSnapshot;
+    restoreState?: (persistedState: TPersisted, actorCtx: ActorContext<TSnapshot, TEvent>) => TSnapshot;
+    start?: (state: TSnapshot, actorCtx: ActorContext<TSnapshot, TEvent>) => void;
     /**
      * @returns Persisted state
      */
-    getPersistedState?: (state: TInternalState) => TPersisted;
-    _out_TOutput?: TOutput;
+    getPersistedState?: (state: TSnapshot) => TPersisted;
 }
-export type AnyActorLogic = ActorLogic<any, // event
-any, // snapshot
-any, // internal state
-any, // persisted state
-any, // system
+export type AnyActorLogic = ActorLogic<any, // snapshot
+any, // event
 any, // input
+any, // persisted state
 any>;
-export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TSnapshot> ? TSnapshot : R extends Actor<infer TLogic> ? SnapshotFrom<TLogic> : R extends StateMachine<infer _TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? 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;
+export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TSnapshot> ? TSnapshot : R extends Actor<infer TLogic> ? SnapshotFrom<TLogic> : R extends StateMachine<infer _TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? StateFrom<R> : R extends ActorLogic<any, any, any, any, any> ? ReturnType<R['transition']> : R extends ActorContext<infer TSnapshot, infer _, infer __> ? TSnapshot : never : never;
+export type EventFromLogic<TLogic extends ActorLogic<any, any, any, any, any>> = TLogic extends ActorLogic<infer _, infer TEvent, infer __, infer _____, infer ______> ? TEvent : never;
+export type PersistedStateFrom<TLogic extends ActorLogic<any, any, any, any, any>> = TLogic extends ActorLogic<infer _TSnapshot, infer _TEvent, infer _TInput, infer TPersisted, infer _TSystem> ? TPersisted : never;
 type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _TContext, infer TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TResolvedTypesMeta> ? TEvent : R extends State<infer _TContext, infer TEvent, infer _TActor, infer _TOutput, infer _TResolvedTypesMeta> ? 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 _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : R extends State<infer TContext, infer _TEvent, infer _TActor, infer _TOutput, infer _TResolvedTypesMeta> ? TContext : R extends Actor<infer TActorLogic> ? TActorLogic extends StateMachine<infer TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer _TTypesMeta> ? TContext : never : never : never;
@@ -733,9 +755,9 @@ export interface ActorSystem<T extends ActorSystemInfo> {
     get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;
 }
 export type AnyActorSystem = ActorSystem<any>;
-export type PersistedMachineState<TState extends AnyState> = Pick<TState, 'value' | 'output' | 'error' | 'context' | 'done' | 'historyValue'> & {
+export type PersistedMachineState<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TTag extends string, TOutput, TResolvedTypesMeta = TypegenDisabled> = HomomorphicPick<MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, 'value' | 'output' | 'error' | 'context' | 'status' | 'historyValue'> & {
     children: {
-        [K in keyof TState['children']]: {
+        [K in keyof MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>['children']]: {
             state: any;
             src?: string;
         };