xstate 5.32.0 → 6.0.0-alpha.1

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

@@ -1,15 +1,15 @@
 import type { MachineSnapshot } from "./State.js";
 import type { StateMachine } from "./StateMachine.js";
 import type { StateNode } from "./StateNode.js";
-import { AssignArgs } from "./actions/assign.js";
-import { ExecutableRaiseAction } from "./actions/raise.js";
-import { ExecutableSendToAction } from "./actions/send.js";
-import { PromiseActorLogic } from "./actors/promise.js";
+import { AsyncActorLogic } from "./actors/promise.js";
+import type { BaseAtom } from "./atom.js";
 import type { Actor } from "./createActor.js";
-import { Guard, GuardPredicate, UnknownGuard } from "./guards.js";
 import { InspectionEvent } from "./inspection.js";
 import { Spawner } from "./spawn.js";
 import { AnyActorSystem, Clock } from "./system.js";
+import { Implementations, Next_StateNodeConfig } from "./types.v6.js";
+import { StandardSchemaV1 } from "./schema.types.js";
+import { builtInActions } from "./actions.js";
 export type Identity<T> = {
     [K in keyof T]: T[K];
 };
@@ -57,6 +57,7 @@ export type IndexByProp<T extends Record<P, string>, P extends keyof T> = {
 export type IndexByType<T extends {
     type: string;
 }> = IndexByProp<T, 'type'>;
+export type IsEmptyObject<T> = keyof T extends never ? true : false;
 export type Equals<A1, A2> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1 ? true : false ? true : false;
 export type IsAny<T> = Equals<T, any>;
 export type Cast<A, B> = A extends B ? A : B;
@@ -82,29 +83,21 @@ export interface ParameterizedObject {
 export interface UnifiedArg<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> {
     context: TContext;
     event: TExpressionEvent;
-    self: ActorRef<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef | undefined>, // TODO: this should be replaced with `TChildren`
+    self: ActorSelf<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef | undefined>, // TODO: this should be replaced with `TChildren`
     StateValue, string, unknown, TODO, // TMeta
     TODO>, TEvent, AnyEventObject>;
     system: AnyActorSystem;
 }
 export type MachineContext = Record<string, any>;
 export interface ActionArgs<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> extends UnifiedArg<TContext, TExpressionEvent, TEvent> {
+    children: Record<string, AnyActor>;
 }
-export type InputFrom<T> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TStateSchema> ? TInput : T extends ActorLogic<infer _TSnapshot, infer _TEvent, infer TInput, infer _TSystem, infer _TEmitted> ? TInput : never;
+export type InputFrom<T> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TStateSchema, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TInput : T extends ActorLogic<infer _TSnapshot, infer _TEvent, infer TInput, infer _TSystem, infer _TEmitted> ? TInput : never;
 export type OutputFrom<T> = T extends ActorLogic<infer TSnapshot, infer _TEvent, infer _TInput, infer _TSystem, infer _TEmitted> ? (TSnapshot & {
     status: 'done';
 })['output'] : T extends ActorRef<infer TSnapshot, infer _TEvent, infer _TEmitted> ? (TSnapshot & {
     status: 'done';
 })['output'] : never;
-export type ActionFunction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject> = {
-    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
-    _out_TEvent?: TEvent;
-    _out_TActor?: TActor;
-    _out_TAction?: TAction;
-    _out_TGuard?: TGuard;
-    _out_TDelay?: TDelay;
-    _out_TEmitted?: TEmitted;
-};
 export type NoRequiredParams<T extends ParameterizedObject> = T extends any ? undefined extends T['params'] ? T['type'] : never : never;
 export type ConditionalRequired<T, Condition extends boolean> = Condition extends true ? Required<T> : T;
 export type WithDynamicParams<TContext extends MachineContext, TExpressionEvent extends EventObject, T extends ParameterizedObject> = T extends any ? ConditionalRequired<{
@@ -114,9 +107,6 @@ export type WithDynamicParams<TContext extends MachineContext, TExpressionEvent
         event: TExpressionEvent;
     }) => T['params']);
 }, undefined extends T['params'] ? false : true> : never;
-export type Action<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject> = NoRequiredParams<TAction> | WithDynamicParams<TContext, TExpressionEvent, TAction> | ActionFunction<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay, TEmitted>;
-export type UnknownAction = Action<MachineContext, EventObject, EventObject, ParameterizedObject['params'] | undefined, ProvidedActor, ParameterizedObject, ParameterizedObject, string, EventObject>;
-export type Actions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject> = SingleOrArray<Action<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay, TEmitted>>;
 export type StateKey = string | AnyMachineSnapshot;
 export interface StateValueMap {
     [key: string]: StateValue | undefined;
@@ -132,30 +122,36 @@ export interface StateValueMap {
  */
 export type StateValue = string | StateValueMap;
 export type TransitionTarget = SingleOrArray<string>;
-export interface TransitionConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject = EventObject, TMeta extends MetaObject = MetaObject> {
-    guard?: Guard<TContext, TExpressionEvent, undefined, TGuard>;
-    actions?: Actions<TContext, TExpressionEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay, TEmitted>;
+export interface TransitionConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> {
+    actions?: never;
+    guard?: unknown;
     reenter?: boolean;
     target?: TransitionTarget | undefined;
+    to?: TransitionConfigFunction<TContext, TExpressionEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
     meta?: TMeta;
     description?: string;
 }
-export interface InitialTransitionConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> extends TransitionConfig<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay, TODO, // TEmitted
-TODO> {
+export interface InitialTransitionConfig<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> extends TransitionConfig<TContext, TEvent, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap> {
     target: string;
 }
 export type AnyTransitionConfig = TransitionConfig<any, // TContext
 any, // TExpressionEvent
 any, // TEvent
-any, // TActor
-any, // TAction
-any, // TGuard
-any, // TDelay
 any, // TEmitted
+any, // TMeta
+any, // TActionMap
+any, // TActorMap
+any, // TGuardMap
 any>;
-export interface InvokeDefinition<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject, TMeta extends MetaObject> {
+export interface InvokeDefinition<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> {
     id: string;
     systemId: string | undefined;
+    logic: string | AnyActorLogic | (({ actors, context, event, self }: {
+        actors: TActorMap;
+        context: TContext;
+        event: TEvent;
+        self: AnyActorRef;
+    }) => string | AnyActorLogic);
     /** The source of the actor logic to be invoked */
     src: AnyActorLogic | string;
     input?: Mapper<TContext, TEvent, NonReducibleUnknown, TEvent> | NonReducibleUnknown;
@@ -163,46 +159,78 @@ export interface InvokeDefinition<TContext extends MachineContext, TEvent extend
      * The transition to take upon the invoked child machine reaching its final
      * top-level state.
      */
-    onDone?: string | SingleOrArray<TransitionConfig<TContext, DoneActorEvent<unknown>, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
+    onDone?: string | SingleOrArray<TransitionConfig<TContext, DoneActorEvent<unknown>, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>>;
     /**
      * The transition to take upon the invoked child machine sending an error
      * event.
      */
-    onError?: string | SingleOrArray<TransitionConfig<TContext, ErrorActorEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
-    onSnapshot?: string | SingleOrArray<TransitionConfig<TContext, SnapshotEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
-    toJSON: () => Omit<InvokeDefinition<TContext, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>, 'onDone' | 'onError' | 'toJSON'>;
+    onError?: string | SingleOrArray<TransitionConfig<TContext, ErrorActorEvent, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>>;
+    onSnapshot?: string | SingleOrArray<TransitionConfig<TContext, SnapshotEvent, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>>;
+    /**
+     * The duration (in ms) after which this invocation times out if it has not
+     * completed.
+     */
+    timeout?: number | ((args: {
+        context: TContext;
+        event: TEvent;
+    }) => number);
+    /** The transition to take when the invoke-level `timeout` expires. */
+    onTimeout?: string | SingleOrArray<TransitionConfig<TContext, TEvent, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>>;
 }
+export type AnyInvokeDefinition = InvokeDefinition<MachineContext, EventObject, EventObject, MetaObject, Implementations['actions'], Implementations['actors'], Implementations['guards'], Implementations['delays']>;
 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, TODO, // TEmitted
-    TODO>>;
+export type DelayedTransitions<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> = {
+    [K in Delay<keyof TDelayMap & string>]?: string | SingleOrArray<TransitionConfig<TContext, TEvent, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>> | TransitionConfigFunction<TContext, TEvent, TEvent, TODO, any, any, any, any, any>;
 };
-export type StateTypes = 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | ({} & string);
+export type StateTypes = 'atomic' | 'compound' | 'parallel' | 'final' | 'choice' | 'history' | ({} & string);
 export type SingleOrArray<T> = readonly T[] | T;
 export type StateNodesConfig<TContext extends MachineContext, TEvent extends EventObject> = {
     [K in string]: StateNode<TContext, TEvent>;
 };
-export type StatesConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TOutput, TEmitted extends EventObject, TMeta extends MetaObject> = {
-    [K in string]: StateNodeConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TOutput, TEmitted, TMeta>;
-};
-export type StatesDefinition<TContext extends MachineContext, TEvent extends EventObject> = {
-    [K in string]: StateNodeDefinition<TContext, TEvent>;
-};
 export type TransitionConfigTarget = string | undefined;
-export type TransitionConfigOrTarget<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject, TMeta extends MetaObject> = SingleOrArray<TransitionConfigTarget | TransitionConfig<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
-export type TransitionsConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject, TMeta extends MetaObject> = {
-    [K in EventDescriptor<TEvent>]?: TransitionConfigOrTarget<TContext, ExtractEvent<TEvent, K>, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>;
+export type TransitionConfigOrTarget<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> = SingleOrArray<TransitionConfigTarget | TransitionConfig<TContext, TExpressionEvent, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap> | TransitionConfigFunction<TContext, TExpressionEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>>;
+export type TransitionConfigFunction<TContext extends MachineContext, TCurrentEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TMeta extends MetaObject, _TCtx = [TContext] extends [never] ? any : TContext> = ({ context, event, self, parent, value, children, actions }: {
+    context: _TCtx;
+    event: TCurrentEvent;
+    self: ActorSelf<MachineSnapshot<_TCtx & MachineContext, TEvent, TODO, TODO, TODO, TODO, TODO, TODO>, TEvent>;
+    parent: UnknownActorRef | undefined;
+    value: StateValue;
+    children: Record<string, AnyActor>;
+    actions: TActionMap;
+    actors: TActorMap;
+    guards: TGuardMap;
+    delays: TDelayMap;
+}, enq: EnqueueObject<TEvent, TEmitted>) => {
+    target?: string | string[];
+    context?: _TCtx;
+    reenter?: boolean;
+    meta?: TMeta;
+} | void;
+export type AnyTransitionConfigFunction = TransitionConfigFunction<any, any, any, any, any, any, any, any, any>;
+export type TransitionsConfig<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> = {
+    [K in EventDescriptor<TEvent>]?: TransitionConfigOrTarget<TContext, ExtractEvent<TEvent, K>, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>;
 };
 type PartialEventDescriptor<TEventType extends string> = TEventType extends `${infer TLeading}.${infer TTail}` ? `${TLeading}.*` | `${TLeading}.${PartialEventDescriptor<TTail>}` : never;
 export type EventDescriptor<TEvent extends EventObject> = TEvent['type'] | PartialEventDescriptor<TEvent['type']> | '*';
-type NormalizeDescriptor<TDescriptor extends string> = TDescriptor extends '*' ? string : TDescriptor extends `${infer TLeading}.*` ? `${TLeading}.${string}` : TDescriptor;
+export type NormalizeDescriptor<TDescriptor extends string> = TDescriptor extends '*' ? string : TDescriptor extends `${infer TLeading}.*` ? `${TLeading}.${string}` : TDescriptor;
+type EventTypeMatchesDescriptor<TEventType extends string, TDescriptor extends string> = TEventType extends NormalizeDescriptor<TDescriptor> ? true : false;
+type IsInternalEventType<TEventType extends string, TDescriptors extends string> = true extends (TDescriptors extends any ? EventTypeMatchesDescriptor<TEventType, TDescriptors> : never) ? true : false;
+type ExcludeInternalEvents<TEvent extends EventObject, TDescriptors extends string> = TEvent extends any ? IsInternalEventType<TEvent['type'], TDescriptors> extends true ? never : TEvent : never;
 export type IsLiteralString<T extends string> = string extends T ? false : true;
-type DistributeActors<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject, TMeta extends MetaObject, TSpecificActor extends ProvidedActor> = TSpecificActor extends {
+type ActorImplementationsBySrc<TActor extends ProvidedActor> = {
+    [A in TActor as A['src']]: A['logic'];
+};
+type DistributeActors<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, _TAction extends ParameterizedObject, _TGuard extends ParameterizedObject, _TDelay extends string, TEmitted extends EventObject, TMeta extends MetaObject, TSpecificActor extends ProvidedActor> = TSpecificActor extends {
     src: infer TSrc;
 } ? Compute<{
     systemId?: string;
     /** The source of the machine to be invoked, or the machine itself. */
-    src: TSrc;
+    src: TSrc | (({ actors, context, event, self }: {
+        actors: ActorImplementationsBySrc<TActor>;
+        context: TContext;
+        event: TEvent;
+        self: AnyActorRef;
+    }) => TSrc | TSpecificActor['logic']);
     /**
      * The unique identifier for the invoked machine. If not specified,
      * this will be the machine's own `id`, or the URL (from `src`).
@@ -213,23 +241,38 @@ type DistributeActors<TContext extends MachineContext, TEvent extends EventObjec
      * The transition to take upon the invoked child machine reaching
      * its final top-level state.
      */
-    onDone?: string | SingleOrArray<TransitionConfigOrTarget<TContext, DoneActorEvent<OutputFrom<TSpecificActor['logic']>>, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
+    onDone?: string | SingleOrArray<TransitionConfigOrTarget<TContext, DoneActorEvent<OutputFrom<TSpecificActor['logic']>>, TEvent, TEmitted, TMeta, any, any, any, any>>;
     /**
      * The transition to take upon the invoked child machine sending an
      * error event.
      */
-    onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
-    onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent<SnapshotFrom<TSpecificActor['logic']>>, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
+    onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
+    onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent<SnapshotFrom<TSpecificActor['logic']>>, TEvent, TEmitted, TMeta, any, any, any, any>>;
+    timeout?: number | ((args: {
+        context: TContext;
+        event: TEvent;
+    }) => number);
+    onTimeout?: string | SingleOrArray<TransitionConfigOrTarget<TContext, TEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
 } & {
     [K in RequiredActorOptions<TSpecificActor>]: unknown;
 }> | {
     id?: never;
     systemId?: string;
-    src: AnyActorLogic;
+    src: string | AnyActorLogic | (({ actors, context, event, self }: {
+        actors: ActorImplementationsBySrc<TActor>;
+        context: TContext;
+        event: TEvent;
+        self: AnyActorRef;
+    }) => string | AnyActorLogic);
     input?: Mapper<TContext, TEvent, NonReducibleUnknown, TEvent> | NonReducibleUnknown;
-    onDone?: string | SingleOrArray<TransitionConfigOrTarget<TContext, DoneActorEvent<unknown>, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
-    onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
-    onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
+    onDone?: string | SingleOrArray<TransitionConfigOrTarget<TContext, DoneActorEvent<unknown>, TEvent, TEmitted, TMeta, any, any, any, any>>;
+    onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
+    onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
+    timeout?: number | ((args: {
+        context: TContext;
+        event: TEvent;
+    }) => number);
+    onTimeout?: string | SingleOrArray<TransitionConfigOrTarget<TContext, TEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
 } : never;
 export type InvokeConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject, TMeta extends MetaObject> = IsLiteralString<TActor['src']> extends true ? DistributeActors<TContext, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta, TActor> : {
     /**
@@ -239,260 +282,61 @@ export type InvokeConfig<TContext extends MachineContext, TEvent extends EventOb
     id?: string;
     systemId?: string;
     /** The source of the machine to be invoked, or the machine itself. */
-    src: AnyActorLogic | string;
+    src: string | AnyActorLogic | (({ actors, context, event, self }: {
+        actors: ActorImplementationsBySrc<TActor>;
+        context: TContext;
+        event: TEvent;
+        self: AnyActorRef;
+    }) => string | AnyActorLogic);
     input?: Mapper<TContext, TEvent, NonReducibleUnknown, TEvent> | NonReducibleUnknown;
     /**
      * The transition to take upon the invoked child machine reaching its
      * final top-level state.
      */
-    onDone?: string | SingleOrArray<TransitionConfigOrTarget<TContext, DoneActorEvent<any>, // TODO: consider replacing with `unknown`
-    TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
+    onDone?: string | SingleOrArray<TransitionConfigOrTarget<TContext, DoneActorEvent<unknown>, TEvent, TEmitted, TMeta, any, any, any, any>>;
     /**
      * The transition to take upon the invoked child machine sending an
      * error event.
      */
-    onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
-    onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
+    onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
+    onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
+    timeout?: number | ((args: {
+        context: TContext;
+        event: TEvent;
+    }) => number);
+    onTimeout?: string | SingleOrArray<TransitionConfigOrTarget<TContext, TEvent, TEvent, TEmitted, TMeta, any, any, any, any>>;
 };
 export type AnyInvokeConfig = InvokeConfig<any, any, any, any, any, any, any, any>;
-export interface StateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, _TOutput, TEmitted extends EventObject, TMeta extends MetaObject> {
-    /** The initial state transition. */
-    initial?: InitialTransitionConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay> | string | undefined;
-    /**
-     * The type of this state node:
-     *
-     * - `'atomic'` - no child state nodes
-     * - `'compound'` - nested child state nodes (XOR)
-     * - `'parallel'` - orthogonal nested child state nodes (AND)
-     * - `'history'` - history state node
-     * - `'final'` - final state node
-     */
-    type?: 'atomic' | 'compound' | 'parallel' | 'final' | 'history';
-    /**
-     * Indicates whether the state node is a history state node, and what type of
-     * history: shallow, deep, true (shallow), false (none), undefined (none)
-     */
-    history?: 'shallow' | 'deep' | boolean | undefined;
-    /**
-     * The mapping of state node keys to their state node configurations
-     * (recursive).
-     */
-    states?: StatesConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, NonReducibleUnknown, TEmitted, TMeta> | undefined;
-    /**
-     * The services to invoke upon entering this state node. These services will
-     * be stopped upon exiting this state node.
-     */
-    invoke?: SingleOrArray<InvokeConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>>;
-    /** The mapping of event types to their potential transition(s). */
-    on?: TransitionsConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>;
-    /** The action(s) to be executed upon entering the state node. */
-    entry?: Actions<TContext, TEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay, TEmitted>;
-    /** The action(s) to be executed upon exiting the state node. */
-    exit?: Actions<TContext, TEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay, TEmitted>;
-    /**
-     * The potential transition(s) to be taken upon reaching a final child state
-     * node.
-     *
-     * This is equivalent to defining a `[done(id)]` transition on this state
-     * node's `on` property.
-     */
-    onDone?: string | SingleOrArray<TransitionConfig<TContext, DoneStateEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>> | undefined;
-    /**
-     * The mapping (or array) of delays (in milliseconds) to their potential
-     * transition(s). The delayed transitions are taken after the specified delay
-     * in an interpreter.
-     */
-    after?: DelayedTransitions<TContext, TEvent, TActor, TAction, TGuard, TDelay>;
-    /**
-     * An eventless transition that is always taken when this state node is
-     * active.
-     */
-    always?: TransitionConfigOrTarget<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted, TMeta>;
-    parent?: StateNode<TContext, TEvent>;
-    /**
-     * The meta data associated with this state node, which will be returned in
-     * State instances.
-     */
-    meta?: TMeta;
-    /**
-     * The output data sent with the "xstate.done.state._id_" event if this is a
-     * final state node.
-     *
-     * The output data will be evaluated with the current `context` and placed on
-     * the `.data` property of the event.
-     */
-    output?: Mapper<TContext, TEvent, unknown, TEvent> | NonReducibleUnknown;
-    /**
-     * The unique ID of the state node, which can be referenced as a transition
-     * target via the `#id` syntax.
-     */
-    id?: string | undefined;
-    /**
-     * The order this state node appears. Corresponds to the implicit document
-     * order.
-     */
-    order?: number;
-    /**
-     * The tags for this state node, which are accumulated into the `state.tags`
-     * property.
-     */
-    tags?: SingleOrArray<TTag>;
-    /** A text description of the state node */
-    description?: string;
-    /** A default target for a history state */
-    target?: string | undefined;
-    route?: RouteTransitionConfig<TContext, TEvent, TEvent, TActor, TAction, TGuard, TDelay, TEmitted>;
-}
-export interface RouteTransitionConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TEmitted extends EventObject> {
-    guard?: Guard<TContext, TExpressionEvent, undefined, TGuard>;
-    actions?: Actions<TContext, TExpressionEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay, TEmitted>;
-    meta?: Record<string, any>;
-    description?: string;
-}
-export type AnyStateNodeConfig = StateNodeConfig<any, any, any, any, any, any, any, any, any, // emitted
-any>;
-export interface StateNodeDefinition<TContext extends MachineContext, TEvent extends EventObject> {
-    id: string;
-    version?: string | undefined;
-    key: string;
-    type: 'atomic' | 'compound' | 'parallel' | 'final' | 'history';
-    initial: InitialTransitionDefinition<TContext, TEvent> | undefined;
-    history: boolean | 'shallow' | 'deep' | undefined;
-    states: StatesDefinition<TContext, TEvent>;
-    on: TransitionDefinitionMap<TContext, TEvent>;
-    transitions: Array<TransitionDefinition<TContext, TEvent>>;
-    entry: UnknownAction[];
-    exit: UnknownAction[];
-    meta: any;
-    order: number;
-    output?: StateNodeConfig<TContext, TEvent, ProvidedActor, ParameterizedObject, ParameterizedObject, string, string, unknown, EventObject, // TEmitted
-    any>['output'];
-    invoke: Array<InvokeDefinition<TContext, TEvent, TODO, TODO, TODO, TODO, TODO, // TEmitted
-    TODO>>;
-    description?: string;
-    tags: string[];
-}
-export interface StateMachineDefinition<TContext extends MachineContext, TEvent extends EventObject> extends StateNodeDefinition<TContext, TEvent> {
-}
-export type AnyStateNode = StateNode<any, any>;
-export type AnyStateNodeDefinition = StateNodeDefinition<any, any>;
+export type AnyStateNodeConfig = Next_StateNodeConfig<any, any, any, any, any, any, any, any, any, any, any>;
+export type AnyStateNode = StateNode<any, any> | StateNode<never, EventObject> | StateNode<any, EventObject> | StateNode<never, any>;
 export type AnyMachineSnapshot = MachineSnapshot<any, any, any, any, any, any, any, any>;
-/** @deprecated Use `AnyMachineSnapshot` instead */
-export type AnyState = AnyMachineSnapshot;
 export type AnyStateMachine = StateMachine<any, // context
 any, // event
 any, // children
-any, // actor
-any, // action
-any, // guard
-any, // delay
 any, // state value
 any, // tag
 any, // input
 any, // output
 any, // emitted
 any, // TMeta
+any, // TStateSchema,
+any, // TActionMap,
+any, // TActorMap
+any, // TGuardMap
 any>;
 export type AnyStateConfig = StateConfig<any, AnyEventObject>;
-export interface AtomicStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject> extends StateNodeConfig<TContext, TEvent, TODO, TODO, TODO, TODO, TODO, TODO, TODO, // emitted
-TODO> {
-    initial?: undefined;
-    parallel?: false | undefined;
-    states?: undefined;
-    onDone?: undefined;
-}
-export interface HistoryStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject> extends AtomicStateNodeConfig<TContext, TEvent> {
-    history: 'shallow' | 'deep' | true;
-    target: string | undefined;
-}
-export type SimpleOrStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject> = AtomicStateNodeConfig<TContext, TEvent> | StateNodeConfig<TContext, TEvent, TODO, TODO, TODO, TODO, TODO, TODO, TODO, // emitted
-TODO>;
-export type ActionFunctionMap<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string, TEmitted extends EventObject = EventObject> = {
-    [K in TAction['type']]?: ActionFunction<TContext, TEvent, TEvent, GetParameterizedParams<TAction extends {
-        type: K;
-    } ? TAction : never>, TActor, TAction, TGuard, TDelay, TEmitted>;
-};
-type GuardMap<TContext extends MachineContext, TEvent extends EventObject, TGuard extends ParameterizedObject> = {
-    [K in TGuard['type']]?: GuardPredicate<TContext, TEvent, GetParameterizedParams<TGuard extends {
-        type: K;
-    } ? TGuard : never>, TGuard>;
-};
-export type DelayFunctionMap<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject> = Record<string, DelayConfig<TContext, TEvent, TAction['params'], TEvent>>;
-export type DelayConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = number | DelayExpr<TContext, TExpressionEvent, TParams, TEvent>;
-/** @ignore */
-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>;
-    actors: Record<string, AnyActorLogic | {
-        src: AnyActorLogic;
-        input: Mapper<TContext, TEvent, unknown, TEvent> | NonReducibleUnknown;
-    }>;
-    delays: DelayFunctionMap<TContext, TEvent, TAction>;
-}
-type MachineImplementationsActions<TTypes extends StateMachineTypes> = {
-    [K in TTypes['actions']['type']]?: ActionFunction<TTypes['context'], TTypes['events'], TTypes['events'], GetConcreteByKey<TTypes['actions'], 'type', K>['params'], TTypes['actors'], TTypes['actions'], TTypes['guards'], TTypes['delays'], TTypes['emitted']>;
-};
-type MachineImplementationsActors<TTypes extends StateMachineTypes> = {
-    [K in TTypes['actors']['src']]?: GetConcreteByKey<TTypes['actors'], 'src', K>['logic'];
-};
-type MachineImplementationsDelays<TTypes extends StateMachineTypes> = {
-    [K in TTypes['delays']]?: DelayConfig<TTypes['context'], TTypes['events'], undefined, TTypes['events']>;
-};
-type MachineImplementationsGuards<TTypes extends StateMachineTypes> = {
-    [K in TTypes['guards']['type']]?: Guard<TTypes['context'], TTypes['events'], GetConcreteByKey<TTypes['guards'], 'type', K>['params'], TTypes['guards']>;
-};
-export type InternalMachineImplementations<TTypes extends StateMachineTypes> = {
-    actions?: MachineImplementationsActions<TTypes>;
-    actors?: MachineImplementationsActors<TTypes>;
-    delays?: MachineImplementationsDelays<TTypes>;
-    guards?: MachineImplementationsGuards<TTypes>;
-};
-type InitialContext<TContext extends MachineContext, TActor extends ProvidedActor, TInput, TEvent extends EventObject> = TContext | ContextFactory<TContext, TActor, TInput, TEvent>;
-export type ContextFactory<TContext extends MachineContext, TActor extends ProvidedActor, TInput, TEvent extends EventObject = EventObject> = ({ spawn, input, self }: {
-    spawn: Spawner<TActor>;
+export type DelayConfig<TContext extends MachineContext, TExpressionEvent extends EventObject> = number | DelayExpr<TContext, TExpressionEvent>;
+export type InitialContext<TContext extends MachineContext, TActorMap extends Implementations['actors'], TInput, TEvent extends EventObject> = TContext | ContextFactory<TContext, TActorMap, TInput, TEvent>;
+export type ContextFactory<TContext extends MachineContext, TActorMap extends Implementations['actors'], TInput, TEvent extends EventObject = EventObject> = ({ spawn, actors, input, self }: {
+    spawn: Spawner;
+    actors: TActorMap;
     input: TInput;
-    self: ActorRef<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef | undefined>, // TODO: this should be replaced with `TChildren`
+    self: ActorSelf<MachineSnapshot<[
+        TContext
+    ] extends [never] ? any : TContext, TEvent, Record<string, AnyActorRef | undefined>, // TODO: this should be replaced with `TChildren`
     StateValue, string, unknown, TODO, // TMeta
     TODO>, TEvent, AnyEventObject>;
-}) => TContext;
-/**
- * Runtime options for state machine execution.
- *
- * @example
- *
- * ```ts
- * const machine = createMachine({
- *   // ... machine config
- *   options: {
- *     maxIterations: 5000
- *     // other runtime options can be added here
- *   }
- * });
- * ```
- */
-export interface MachineOptions {
-    /**
-     * Maximum number of microsteps allowed before throwing an infinite loop
-     * error. Defaults to `Infinity` (no limit). Set to a finite number to enable
-     * infinite loop detection.
-     *
-     * @default Infinity
-     */
-    maxIterations?: number;
-}
-export type MachineConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string, TTag extends string = string, TInput = any, TOutput = unknown, TEmitted extends EventObject = EventObject, TMeta extends MetaObject = MetaObject> = (Omit<StateNodeConfig<DoNotInfer<TContext>, DoNotInfer<TEvent>, DoNotInfer<TActor>, DoNotInfer<TAction>, DoNotInfer<TGuard>, DoNotInfer<TDelay>, DoNotInfer<TTag>, DoNotInfer<TOutput>, DoNotInfer<TEmitted>, DoNotInfer<TMeta>>, 'output'> & {
-    /** The initial context (extended state) */
-    /** The machine's own version. */
-    version?: string;
-    output?: Mapper<TContext, DoneStateEvent, TOutput, TEvent> | TOutput;
-    /** Runtime options for machine execution. */
-    options?: MachineOptions;
-}) & (MachineContext extends TContext ? {
-    context?: InitialContext<LowInfer<TContext>, TActor, TInput, TEvent>;
-} : {
-    context: InitialContext<LowInfer<TContext>, TActor, TInput, TEvent>;
-});
-export type UnknownMachineConfig = MachineConfig<MachineContext, EventObject>;
+}) => [TContext] extends [never] ? MachineContext : TContext;
 export interface ProvidedActor {
     src: string;
     logic: UnknownActorLogic;
@@ -519,13 +363,12 @@ export interface HistoryStateNode<TContext extends MachineContext> extends State
     history: 'shallow' | 'deep';
     target: string | undefined;
 }
-export type HistoryValue<TContext extends MachineContext, TEvent extends EventObject> = Record<string, Array<StateNode<TContext, TEvent>>>;
+export type HistoryValue = Record<string, Array<AnyStateNode>>;
 export type PersistedHistoryValue = Record<string, Array<{
     id: string;
 }>>;
-export type AnyHistoryValue = HistoryValue<any, any>;
+export type AnyHistoryValue = HistoryValue;
 export type StateFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = T extends AnyStateMachine ? ReturnType<T['transition']> : T extends (...args: any[]) => AnyStateMachine ? ReturnType<ReturnType<T>['transition']> : never;
-export type Transitions<TContext extends MachineContext, TEvent extends EventObject> = Array<TransitionDefinition<TContext, TEvent>>;
 export interface DoneActorEvent<TOutput = unknown, TId extends string = string> extends EventObject {
     type: `xstate.done.actor.${TId}`;
     output: TOutput;
@@ -544,64 +387,49 @@ export interface DoneStateEvent<TOutput = unknown> extends EventObject {
     type: `xstate.done.state.${string}`;
     output: TOutput;
 }
-export type DelayExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => number;
-export type LogExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => unknown;
-export type SendExpr<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TSentEvent extends EventObject, TEvent extends EventObject> = (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => TSentEvent;
 export declare enum SpecialTargets {
-    Parent = "#_parent",
     Internal = "#_internal"
 }
-export interface SendToActionOptions<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> extends RaiseActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay> {
-}
-export interface RaiseActionOptions<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> {
-    id?: string;
-    delay?: Delay<TDelay> | DelayExpr<TContext, TExpressionEvent, TParams, TEvent>;
-}
-export interface RaiseActionParams<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> extends RaiseActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay> {
-    event: TEvent | SendExpr<TContext, TExpressionEvent, TParams, TEvent, TEvent>;
-}
-export interface SendToActionParams<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TSentEvent extends EventObject, TEvent extends EventObject, TDelay extends string> extends SendToActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay> {
-    event: TSentEvent | SendExpr<TContext, TExpressionEvent, TParams, TSentEvent, TEvent>;
-}
-export type Assigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor> = (args: AssignArgs<TContext, TExpressionEvent, TEvent, TActor>, params: TParams) => Partial<TContext>;
-export type PartialAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor, TKey extends keyof TContext> = (args: AssignArgs<TContext, TExpressionEvent, TEvent, TActor>, params: TParams) => TContext[TKey];
-export type PropertyAssigner<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor> = {
-    [K in keyof TContext]?: PartialAssigner<TContext, TExpressionEvent, TParams, TEvent, TActor, K> | TContext[K];
-};
-export type Mapper<TContext extends MachineContext, TExpressionEvent extends EventObject, TResult, TEvent extends EventObject> = (args: {
-    context: TContext;
+export type Mapper<TContext extends MachineContext, TExpressionEvent extends EventObject, TResult, TEvent extends EventObject, _TCtx = [TContext] extends [never] ? any : TContext> = (args: {
+    context: _TCtx;
     event: TExpressionEvent;
-    self: ActorRef<MachineSnapshot<TContext, TEvent, Record<string, AnyActorRef>, // TODO: this should be replaced with `TChildren`
+    self: ActorSelf<MachineSnapshot<_TCtx & MachineContext, TEvent, Record<string, AnyActorRef>, // TODO: this should be replaced with `TChildren`
     StateValue, string, unknown, TODO, // TMeta
     TODO>, TEvent, AnyEventObject>;
 }) => TResult;
 export interface TransitionDefinition<TContext extends MachineContext, TEvent extends EventObject> extends Omit<TransitionConfig<TContext, TEvent, TEvent, TODO, TODO, TODO, TODO, TODO, // TEmitted
-TODO>, 'target' | 'guard'> {
-    target: ReadonlyArray<StateNode<TContext, TEvent>> | undefined;
-    source: StateNode<TContext, TEvent>;
-    actions: readonly UnknownAction[];
+TODO>, 'target' | 'to'> {
+    target: ReadonlyArray<AnyStateNode> | undefined;
+    source: AnyStateNode;
     reenter: boolean;
-    guard?: UnknownGuard;
     eventType: EventDescriptor<TEvent>;
-    toJSON: () => {
-        target: string[] | undefined;
-        source: string;
-        actions: readonly UnknownAction[];
-        guard?: UnknownGuard;
-        eventType: EventDescriptor<TEvent>;
-        meta?: Record<string, any>;
-    };
+    to?: ((...args: any[]) => any) | undefined;
+    input?: Record<string, unknown> | ((args: {
+        context: any;
+        event: any;
+    }) => Record<string, unknown>);
 }
 export type AnyTransitionDefinition = TransitionDefinition<any, any>;
-export interface InitialTransitionDefinition<TContext extends MachineContext, TEvent extends EventObject> extends TransitionDefinition<TContext, TEvent> {
-    target: ReadonlyArray<StateNode<TContext, TEvent>>;
-    guard?: never;
-}
+export type InitialTransitionDefinition = {
+    source: AnyStateNode;
+    target: AnyStateNode[] | undefined;
+    reenter?: boolean;
+    eventType?: EventDescriptor<any>;
+    input?: Record<string, unknown> | ((args: {
+        context: MachineContext;
+        event: EventObject;
+    }) => Record<string, unknown>);
+};
 export type TransitionDefinitionMap<TContext extends MachineContext, TEvent extends EventObject> = {
     [K in EventDescriptor<TEvent>]: Array<TransitionDefinition<TContext, ExtractEvent<TEvent, K>>>;
 };
+export type DelayExpr<TContext extends MachineContext, TEvent extends EventObject> = (args: {
+    context: [TContext] extends [never] ? any : TContext;
+    event: TEvent;
+    stateNode: AnyStateNode;
+}) => number;
 export interface DelayedTransitionDefinition<TContext extends MachineContext, TEvent extends EventObject> extends TransitionDefinition<TContext, TEvent> {
-    delay: number | string | DelayExpr<TContext, TEvent, undefined, TEvent>;
+    delay: number | string | DelayExpr<TContext, TEvent>;
 }
 export interface StateLike<TContext extends MachineContext> {
     value: StateValue;
@@ -610,15 +438,52 @@ export interface StateLike<TContext extends MachineContext> {
 }
 export interface StateConfig<TContext extends MachineContext, TEvent extends EventObject> {
     context: TContext;
-    historyValue?: HistoryValue<TContext, TEvent>;
-    children: Record<string, AnyActorRef>;
+    historyValue?: HistoryValue;
+    children: Record<string, AnyActorRef | undefined>;
     status: SnapshotStatus;
     output?: any;
     error?: unknown;
-    machine?: StateMachine<TContext, TEvent, any, any, any, any, any, any, any, any, any, any, any, // TMeta
-    any>;
+    machine?: StateMachine<TContext, TEvent, any, any, any, any, any, any, any, any, any, any, any, any>;
 }
+/**
+ * A pending effect (delayed event/transition that has not fired yet) captured
+ * in a persisted snapshot — a serialized built-in action descriptor plus its
+ * runtime progress, with enough information to restore it under any strategy.
+ */
+export interface PendingEffect {
+    /** The serialized built-in action type for this effect. */
+    type: '@xstate.raise';
+    event: EventObject;
+    id: string;
+    /** The original delay (in ms) the effect was scheduled with. */
+    delay: number;
+    /** Wall-clock timestamp (ms) when the effect was scheduled. */
+    startedAt: number;
+    /** Wall-clock time (ms) that had elapsed when the snapshot was persisted. */
+    elapsed: number;
+}
+/**
+ * How pending effects (timers) from a persisted snapshot are restored on
+ * `actor.start()`:
+ *
+ * - `'resume'` (default) — the clock was "frozen" while persisted: a 5-minute
+ *   timer persisted with 1 minute elapsed fires after 4 more minutes.
+ * - `'restart'` — timers start over with their full delay.
+ * - `'absolute'` — timers honor the original wall-clock expiry (`startedAt +
+ *   delay`); already-expired timers fire immediately.
+ * - A custom function receiving the pending effect and returning the remaining
+ *   delay in ms.
+ */
+export type TimersRestoreStrategy = 'resume' | 'restart' | 'absolute' | ((pendingEffect: PendingEffect) => number);
 export interface ActorOptions<TLogic extends AnyActorLogic> {
+    /**
+     * How pending timers (delayed events/transitions) from a persisted `snapshot`
+     * are restored when the actor starts. Applies to this actor and (when this is
+     * the root) all rehydrated child actors.
+     *
+     * @default 'resume'
+     */
+    timers?: TimersRestoreStrategy;
     /**
      * The clock that is responsible for setting and clearing timeouts, such as
      * delayed events and transitions.
@@ -642,7 +507,7 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      * native `console.log(...)` method.
      */
     logger?: (...args: any[]) => void;
-    parent?: AnyActorRef;
+    parent?: AnyActor;
     /** The custom `id` for referencing this service. */
     id?: string;
     /** @deprecated Use `inspect` instead. */
@@ -675,13 +540,14 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      *
      * @remarks
      * If a callback function is provided, it can accept an inspection event
-     * argument. The types of inspection events that can be observed include:
+     * argument. The inspection protocol has two event types:
      *
-     * - `@xstate.actor` - An actor ref has been created in the system
-     * - `@xstate.event` - An event was sent from a source actor ref to a target
-     *   actor ref in the system
-     * - `@xstate.snapshot` - An actor ref emitted a snapshot due to a received
-     *   event
+     * - `@xstate.actor` - An actor ref was created in the system (announces actor
+     *   topology: identity + parent).
+     * - `@xstate.transition` - An actor transitioned. Carries every facet of the
+     *   transition with flat, always-present fields: `event`, `snapshot`,
+     *   `sourceRef`, `microsteps`, executed `actions`, and `sent`/scheduled
+     *   events.
      *
      * @example
      *
@@ -699,19 +565,18 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      *     }
      *
      *     if (inspectionEvent.type === '@xstate.actor') {
-     *       console.log(inspectionEvent.actorRef);
+     *       console.log(inspectionEvent.actorRef, inspectionEvent.parentRef);
      *     }
      *
-     *     if (inspectionEvent.type === '@xstate.event') {
+     *     if (inspectionEvent.type === '@xstate.transition') {
      *       console.log(inspectionEvent.sourceRef);
      *       console.log(inspectionEvent.actorRef);
      *       console.log(inspectionEvent.event);
-     *     }
-     *
-     *     if (inspectionEvent.type === '@xstate.snapshot') {
-     *       console.log(inspectionEvent.actorRef);
-     *       console.log(inspectionEvent.event);
      *       console.log(inspectionEvent.snapshot);
+     *       // flat, always-present facets — no narrowing required
+     *       console.log(inspectionEvent.actions);
+     *       console.log(inspectionEvent.sent);
+     *       console.log(inspectionEvent.microsteps);
      *     }
      *   }
      * });
@@ -731,19 +596,20 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      *       }
      *
      *       if (inspectionEvent.type === '@xstate.actor') {
-     *         console.log(inspectionEvent.actorRef);
+     *         console.log(
+     *           inspectionEvent.actorRef,
+     *           inspectionEvent.parentRef
+     *         );
      *       }
      *
-     *       if (inspectionEvent.type === '@xstate.event') {
+     *       if (inspectionEvent.type === '@xstate.transition') {
      *         console.log(inspectionEvent.sourceRef);
      *         console.log(inspectionEvent.actorRef);
      *         console.log(inspectionEvent.event);
-     *       }
-     *
-     *       if (inspectionEvent.type === '@xstate.snapshot') {
-     *         console.log(inspectionEvent.actorRef);
-     *         console.log(inspectionEvent.event);
      *         console.log(inspectionEvent.snapshot);
+     *         console.log(inspectionEvent.actions);
+     *         console.log(inspectionEvent.sent);
+     *         console.log(inspectionEvent.microsteps);
      *       }
      *     }
      *   }
@@ -752,7 +618,7 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      */
     inspect?: Observer<InspectionEvent> | ((inspectionEvent: InspectionEvent) => void);
 }
-export type AnyActor = Actor<any>;
+export type AnyActor = ActorInstance<any, any, any, any>;
 /** @deprecated Use `AnyActor` instead. */
 export type AnyInterpreter = AnyActor;
 export type Observer<T> = {
@@ -784,50 +650,105 @@ export interface BaseActorRef<TEvent extends EventObject> {
 export interface ActorLike<TCurrent, TEvent extends EventObject> extends Subscribable<TCurrent> {
     send: (event: TEvent) => void;
 }
-export interface ActorRef<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TEmitted extends EventObject = EventObject> extends Subscribable<TSnapshot>, InteropObservable<TSnapshot> {
+/**
+ * A consumer-facing actor handle.
+ *
+ * `ActorRef` describes the contract a consumer needs: which events can be sent
+ * to the actor, which snapshot it publishes for observation, and which emitted
+ * events can be listened to. It intentionally does not expose lifecycle control
+ * or runtime internals. A concrete `Actor` satisfies this interface, so APIs
+ * should accept `ActorRef` whenever they only need to send events, read
+ * snapshots, or listen to emitted events.
+ */
+export interface ActorRef<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> extends Subscribable<TSnapshot>, InteropObservable<TSnapshot> {
+    send: (event: TSendEvent) => void;
+    getSnapshot: () => TSnapshot;
+    on: <TType extends TEmitted['type'] | '*'>(type: TType, handler: (emitted: TEmitted & (TType extends '*' ? unknown : {
+        type: TType;
+    })) => void) => Subscription;
+}
+/**
+ * Runtime-only actor capabilities.
+ *
+ * These members are needed by the interpreter, scheduler, inspection, and child
+ * management code. Public consumer APIs should prefer `ActorRef` unless they
+ * genuinely need lifecycle control such as starting, stopping, or accessing
+ * system-owned runtime state.
+ */
+export interface ActorRuntime<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, _TEmitted extends EventObject = EventObject> {
     /** The unique identifier for this actor relative to its parent. */
     id: string;
-    sessionId: string;
-    send: (event: TEvent) => void;
-    start: () => void;
-    getSnapshot: () => TSnapshot;
+    /**
+     * The globally unique process ID for this invocation.
+     *
+     * @remarks
+     * This is only defined once the actor is started.
+     */
+    sessionId: string | undefined;
+    start: () => this;
     getPersistedSnapshot: () => Snapshot<unknown>;
     stop: () => void;
     toJSON?: () => any;
-    _parent?: AnyActorRef;
-    system: AnyActorSystem;
+    _parent?: any;
+    system: any;
     src: string | AnyActorLogic;
-    on: <TType extends TEmitted['type'] | '*'>(type: TType, handler: (emitted: TEmitted & (TType extends '*' ? unknown : {
-        type: TType;
-    })) => void) => Subscription;
+    trigger: any;
     select<TSelected>(selector: (snapshot: TSnapshot) => TSelected, equalityFn?: (a: TSelected, b: TSelected) => boolean): Readable<TSelected>;
 }
-export type AnyActorRef = ActorRef<any, any, // TODO: shouldn't this be AnyEventObject?
-any>;
-export type ActorRefLike = Pick<AnyActorRef, 'sessionId' | 'send' | 'getSnapshot'>;
+/**
+ * A concrete actor instance type.
+ *
+ * `ActorInstance` combines the consumer `ActorRef` contract with runtime
+ * lifecycle capabilities. Values returned by `createActor(...)` and
+ * `spawn(...)` naturally satisfy narrower `ActorRef` contracts.
+ */
+export interface ActorInstance<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> extends ActorRuntime<TSnapshot, TEvent, TEmitted>, ActorRef<TSnapshot, TEvent, TEmitted, TSendEvent> {
+}
+/**
+ * The actor's own full self handle.
+ *
+ * Internals and action/guard implementations receive this shape because `self`
+ * can participate in runtime-owned behavior while still being usable wherever
+ * an `ActorRef` is expected.
+ */
+export type ActorSelf<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> = ActorRuntime<TSnapshot, TEvent, TEmitted> & ActorRef<TSnapshot, TEvent, TEmitted, TSendEvent>;
+export type ActorRefFrom<T> = T extends StateMachine<infer TContext, infer TEvent, infer TChildren, infer TStateValue, infer TTag, infer _TInput, infer TOutput, infer TEmitted, infer TMeta, infer TConfig, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TConfig extends {
+    internalEvents?: readonly EventDescriptor<TEvent>[];
+} ? ActorRef<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, any>, TEvent, TEmitted, ExcludeInternalEvents<TEvent, TConfig['internalEvents'] extends readonly EventDescriptor<TEvent>[] ? TConfig['internalEvents'] extends readonly (infer TDesc)[] ? Extract<TDesc, string> : never : never>> : ActorRef<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, any>, TEvent, TEmitted> : T extends Promise<infer U> ? ActorRefFrom<AsyncActorLogic<U>> : T extends ActorLogic<infer TSnapshot, infer TEvent, infer _TInput, infer _TSystem, infer TEmitted> ? ActorRef<TSnapshot, TEvent, TEmitted> : never;
+export type SendableEventFromLogic<TLogic extends AnyActorLogic> = TLogic extends StateMachine<infer _TContext, infer TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer TConfig, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TConfig extends {
+    internalEvents?: readonly EventDescriptor<TEvent>[];
+} ? ExcludeInternalEvents<TEvent, TConfig['internalEvents'] extends readonly EventDescriptor<TEvent>[] ? TConfig['internalEvents'] extends readonly (infer TDesc)[] ? Extract<TDesc, string> : never : never> : TEvent : EventFromLogic<TLogic>;
+export type ActorRefFromLogic<T extends AnyActorLogic> = ActorRef<SnapshotFrom<T>, EventFromLogic<T>, EmittedFrom<T>, SendableEventFromLogic<T>>;
+export type AnyActorRef = ActorRef<any, any, any, any>;
+/** The concrete actor instance type produced from actor logic. */
+export type ActorFromLogic<T extends AnyActorLogic> = ActorInstance<SnapshotFrom<T>, EventFromLogic<T>, EmittedFrom<T>, SendableEventFromLogic<T>>;
+type SendableEventFromActorRef<TActorRef, TFallback extends EventObject = AnyEventObject> = [NonNullable<TActorRef>] extends [never] ? TFallback : NonNullable<TActorRef> extends infer TNonNullableActorRef ? TNonNullableActorRef extends {
+    send: (event: infer TEvent) => void;
+} ? [TEvent] extends [never] ? TFallback : TEvent extends EventObject ? TEvent : TFallback : never : never;
+export type ActorRefLike = Pick<AnyActor, 'sessionId' | 'send' | 'getSnapshot'>;
 export type UnknownActorRef = ActorRef<Snapshot<unknown>, EventObject>;
-export type ActorLogicFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<any, any, any, any, any, any, any, any, any, any, any, any, any, // TMeta
-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 TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TStateValue, infer TTag, infer _TInput, infer TOutput, infer TEmitted, infer TMeta, infer TStateSchema> ? ActorRef<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, TEvent, TEmitted> : R extends Promise<infer U> ? ActorRefFrom<PromiseActorLogic<U>> : R extends ActorLogic<infer TSnapshot, infer TEvent, infer _TInput, infer _TSystem, infer TEmitted> ? ActorRef<TSnapshot, TEvent, TEmitted> : never : never;
-export type ActorRefFromLogic<T extends AnyActorLogic> = ActorRef<SnapshotFrom<T>, EventFromLogic<T>, EmittedFrom<T>>;
 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 TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TStateValue, infer TTag, infer TInput, infer TOutput, infer TEmitted, infer TMeta, infer TStateSchema> ? Actor<ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, TEvent, TInput, AnyActorSystem, TEmitted>> : never;
-export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer _TChildren, infer TActor, infer TAction, infer TGuard, infer TDelay, infer _TStateValue, infer TTag, infer _TInput, infer _TOutput, infer TEmitted, infer _TMeta, infer _TStateSchema> ? InternalMachineImplementations<ResolvedStateMachineTypes<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TEmitted>> : never;
-export interface ActorScope<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TSystem extends AnyActorSystem = AnyActorSystem, TEmitted extends EventObject = EventObject> {
-    self: ActorRef<TSnapshot, TEvent, TEmitted>;
+export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TConfig, infer TActionMap, infer TActorMap, infer TGuardMap, infer TDelayMap> ? {
+    actions: TActionMap;
+    actors: TActorMap;
+    guards: TGuardMap;
+    delays: TDelayMap;
+} : never;
+export interface ActorScope<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TSystem extends AnyActorSystem = AnyActorSystem, TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> {
+    self: ActorSelf<TSnapshot, TEvent, TEmitted, TSendEvent>;
     id: string;
     sessionId: string;
     logger: (...args: any[]) => void;
     defer: (fn: () => void) => void;
     emit: (event: TEmitted) => void;
     system: TSystem;
-    stopChild: (child: AnyActorRef) => void;
+    stopChild: (child: AnyActor) => void;
     actionExecutor: ActionExecutor;
 }
 export type AnyActorScope = ActorScope<any, // TSnapshot
 any, // TEvent
-AnyActorSystem, any>;
+AnyActorSystem, any, // TEmitted
+any>;
 export type SnapshotStatus = 'active' | 'done' | 'error' | 'stopped';
 export type Snapshot<TOutput> = {
     status: 'active';
@@ -915,9 +836,9 @@ AnyActorSystem, any>;
 export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer TSnapshot, infer _, infer __> ? TSnapshot : R extends Actor<infer TLogic> ? SnapshotFrom<TLogic> : R extends ActorLogic<infer _TSnapshot, infer _TEvent, infer _TInput, infer _TEmitted, infer _TSystem> ? ReturnType<R['transition']> : R extends ActorScope<infer TSnapshot, infer _TEvent, infer _TEmitted, infer _TSystem> ? TSnapshot : never : never;
 export type EventFromLogic<TLogic extends AnyActorLogic> = TLogic extends ActorLogic<infer _TSnapshot, infer TEvent, infer _TInput, infer _TEmitted, infer _TSystem> ? TEvent : never;
 export type EmittedFrom<TLogic extends AnyActorLogic> = TLogic extends ActorLogic<infer _TSnapshot, infer _TEvent, infer _TInput, infer _TSystem, infer TEmitted> ? TEmitted : never;
-type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _TContext, infer TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TStateSchema> ? TEvent : R extends MachineSnapshot<infer _TContext, infer TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TOutput, infer _TMeta, infer _TStateSchema> ? TEvent : R extends ActorRef<infer _TSnapshot, infer TEvent, infer _TEmitted> ? TEvent : never : never;
+type ResolveEventType<T> = T extends infer R ? R extends StateMachine<infer _TContext, infer TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TConfig, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TEvent : R extends MachineSnapshot<infer _TContext, infer TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TOutput, infer _TMeta, infer _TStateSchema> ? TEvent : R extends ActorRef<infer _TSnapshot, infer TEvent, infer _TEmitted> ? 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 _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TStateSchema> ? TContext : R extends MachineSnapshot<infer TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TOutput, infer _TMeta, infer _TStateSchema> ? TContext : R extends Actor<infer TActorLogic> ? TActorLogic extends StateMachine<infer TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TStateSchema> ? TContext : never : never : never;
+export type ContextFrom<T> = T extends StateMachine<infer TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TConfig, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TContext : T extends MachineSnapshot<infer TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TOutput, infer _TMeta, infer _TStateSchema> ? TContext : T extends Actor<infer TActorLogic> ? TActorLogic extends AnyStateMachine ? ContextFrom<TActorLogic> : never : never;
 export type InferEvent<E extends EventObject> = {
     [T in E['type']]: {
         type: T;
@@ -935,18 +856,21 @@ export type RequiredActorOptions<TActor extends ProvidedActor> = (undefined exte
 export type RequiredLogicInput<TLogic extends AnyActorLogic> = undefined extends InputFrom<TLogic> ? never : 'input';
 type ExtractLiteralString<T extends string | undefined> = T extends string ? string extends T ? never : T : never;
 type ToConcreteChildren<TActor extends ProvidedActor> = {
-    [A in TActor as ExtractLiteralString<A['id']>]?: ActorRefFromLogic<A['logic']>;
+    [A in TActor as ExtractLiteralString<A['id']>]?: ActorFromLogic<A['logic']>;
 };
-export type ToChildren<TActor extends ProvidedActor> = string extends TActor['src'] ? Record<string, AnyActorRef> : Compute<ToConcreteChildren<TActor> & {
+type NonConcreteActors<TActor extends ProvidedActor> = TActor extends any ? ExtractLiteralString<TActor['id']> extends never ? TActor : never : never;
+export type ToChildren<TActor extends ProvidedActor> = string extends TActor['src'] ? Record<string, AnyActor> : Compute<ToConcreteChildren<TActor> & {
     include: {
-        [id: string]: TActor extends any ? ActorRefFromLogic<TActor['logic']> | undefined : never;
+        [id: string]: NonConcreteActors<TActor> extends never ? AnyActor | undefined : NonConcreteActors<TActor> extends any ? ActorFromLogic<NonConcreteActors<TActor>['logic']> | undefined : never;
     };
     exclude: unknown;
-}[undefined extends TActor['id'] ? 'include' : string extends TActor['id'] ? 'include' : 'exclude']>;
+}[NonConcreteActors<TActor> extends never ? 'exclude' : 'include']>;
 export type StateSchema = {
     id?: string;
     route?: unknown;
     states?: Record<string, StateSchema>;
+    contextSchema?: StandardSchemaV1;
+    input?: unknown;
     type?: unknown;
     invoke?: unknown;
     on?: unknown;
@@ -955,17 +879,32 @@ export type StateSchema = {
     onDone?: unknown;
     after?: unknown;
     always?: unknown;
+    choice?: unknown;
     meta?: unknown;
     output?: unknown;
     tags?: unknown;
     description?: unknown;
 };
-export type StateSchemaFrom<T extends AnyStateMachine> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer TStateSchema> ? TStateSchema : never;
+export type StateSchemaFrom<T extends AnyStateMachine> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer TStateSchema, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TStateSchema : never;
 export type StateId<TSchema extends StateSchema, TKey extends string = '(machine)', TParentKey extends string | null = null> = (TSchema extends {
     id: string;
 } ? TSchema['id'] : TParentKey extends null ? TKey : `${TParentKey}.${TKey}`) | (TSchema['states'] extends Record<string, any> ? Values<{
     [K in keyof TSchema['states'] & string]: StateId<TSchema['states'][K], K, TParentKey extends string ? `${TParentKey}.${TKey}` : TSchema['id'] extends string ? TSchema['id'] : TKey>;
 }> : never);
+/** Maps state IDs to their input types based on the StateSchema. */
+export type StateIdInputs<TSchema extends StateSchema, TKey extends string = '(machine)', TParentKey extends string | null = null> = {
+    [K in TSchema extends {
+        id: string;
+    } ? TSchema['id'] : TParentKey extends null ? TKey : `${TParentKey}.${TKey}`]: TSchema['input'] extends undefined ? undefined : TSchema['input'];
+} & (TSchema['states'] extends Record<string, StateSchema> ? UnionToIntersection<Values<{
+    [K in keyof TSchema['states'] & string]: StateIdInputs<TSchema['states'][K], K, TParentKey extends string ? `${TParentKey}.${TKey}` : TSchema['id'] extends string ? TSchema['id'] : TKey>;
+}>> : {});
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type ContextFromStateSchema<TSchema extends StateSchema, TFallbackContext extends MachineContext> = TSchema['contextSchema'] extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema['contextSchema']> & MachineContext : TFallbackContext;
+type ContextFromChildStateValue<TChildSchema extends StateSchema, TFallbackContext extends MachineContext, TChildValue> = ContextFromStateSchema<TChildSchema, TFallbackContext> & StateContextFromStateValue<TChildSchema, ContextFromStateSchema<TChildSchema, TFallbackContext>, TChildValue>;
+export type StateContextFromStateValue<TSchema extends StateSchema, TFallbackContext extends MachineContext, TStateValue> = (TSchema['states'] extends Record<string, StateSchema> ? TStateValue extends keyof TSchema['states'] & string ? ContextFromStateSchema<TSchema['states'][TStateValue], TFallbackContext> : TStateValue extends Record<string, unknown> ? UnionToIntersection<Values<{
+    [K in keyof TStateValue & keyof TSchema['states'] & string]: ContextFromChildStateValue<TSchema['states'][K], TFallbackContext, NonNullable<TStateValue[K]>>;
+}>> : TFallbackContext : TFallbackContext) & MachineContext;
 export type RoutableStateId<TSchema extends StateSchema> = (TSchema extends {
     route: any;
     id: string;
@@ -1015,32 +954,94 @@ export type ToStateValue<T extends StateSchema> = T extends {
     };
 }>> : never) : {};
 export interface ExecutableActionObject {
-    type: string;
-    info: ActionArgs<MachineContext, EventObject, EventObject>;
+    type: string & {};
     params: NonReducibleUnknown;
-    exec: ((info: ActionArgs<any, any, any>, params: unknown) => void) | undefined;
+    args: unknown[];
+    exec: (() => void) | undefined;
 }
+export type SpecialExecutableAction = Values<{
+    [K in keyof typeof builtInActions]: {
+        type: K;
+        args: Parameters<(typeof builtInActions)[K]>;
+    };
+}>;
 export interface ToExecutableAction<T extends ParameterizedObject> extends ExecutableActionObject {
     type: T['type'];
     params: T['params'];
     exec: undefined;
 }
-export interface ExecutableSpawnAction extends ExecutableActionObject {
-    type: 'xstate.spawnChild';
-    info: ActionArgs<MachineContext, EventObject, EventObject>;
-    params: {
-        id: string;
-        actorRef: AnyActorRef | undefined;
-        src: string | AnyActorLogic;
-    };
-}
-export type SpecialExecutableAction = ExecutableSpawnAction | ExecutableRaiseAction | ExecutableSendToAction;
-export type ExecutableActionsFrom<T extends AnyActorLogic> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TActor, infer TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TStateSchema> ? SpecialExecutableAction | (string extends TAction['type'] ? never : ToExecutableAction<TAction>) : never;
 export type ActionExecutor = (actionToExecute: ExecutableActionObject) => void;
-export type BuiltinActionResolution = [
-    AnyMachineSnapshot,
-    NonReducibleUnknown,
-    // params
-    UnknownAction[] | undefined
-];
+/** Mappers for subscribeTo - maps lifecycle events to machine events */
+export interface SubscribeToMappers<TSnapshot extends Snapshot<unknown>, TOutput, TMappedEvent extends EventObject> {
+    snapshot?: (snapshot: TSnapshot) => TMappedEvent;
+    done?: (output: TOutput) => TMappedEvent;
+    error?: (error: unknown) => TMappedEvent;
+}
+export type EnqueueObject<TEvent extends EventObject, TEmittedEvent extends EventObject> = {
+    cancel: (id: string) => void;
+    raise: (ev: TEvent, options?: {
+        id?: string;
+        delay?: number;
+    }) => void;
+    spawn: <T extends AnyActorLogic>(logic: T, options?: {
+        input?: InputFrom<T>;
+        id?: string;
+        syncSnapshot?: boolean;
+        systemId?: string;
+    }) => ActorFromLogic<T>;
+    emit: (emittedEvent: TEmittedEvent) => void;
+    <T extends (...args: any[]) => any>(fn: T, ...args: Parameters<T>): void;
+    log: (...args: any[]) => void;
+    sendTo: <TActorRef extends {
+        send: (...args: any[]) => void;
+    } | undefined>(actorRef: TActorRef, event: SendableEventFromActorRef<NoInfer<TActorRef>>, options?: {
+        id?: string;
+        delay?: number;
+    }) => void;
+    stop: (actor?: AnyActor) => void;
+    /**
+     * Listen to emitted events from an actor. Returns a listener actor that can
+     * be stopped via `enq.stop()`.
+     *
+     * @param actor - The actor to listen to
+     * @param eventType - The emitted event type to listen for (supports
+     *   wildcards: 'event._', '_')
+     * @param mapper - Function to transform emitted events into machine events
+     */
+    listen: <TEmitted extends EventObject, TMappedEvent extends TEvent>(actor: AnyActor, eventType: string, mapper: (event: TEmitted) => TMappedEvent) => AnyActor;
+    /**
+     * Subscribe to lifecycle events (done/error/snapshot) from an actor. Returns
+     * a subscription actor that can be stopped via `enq.stop()`.
+     *
+     * @param actor - The actor to subscribe to
+     * @param mappers - Object with done/error/snapshot mappers, or a single
+     *   snapshot mapper function
+     */
+    subscribeTo: {
+        <TSnapshot extends Snapshot<unknown>, TOutput, TMappedEvent extends TEvent>(actor: AnyActor, mappers: SubscribeToMappers<TSnapshot, TOutput, TMappedEvent> | ((snapshot: TSnapshot) => TMappedEvent)): AnyActor;
+        <TValue, TMappedEvent extends TEvent>(atom: BaseAtom<TValue>, mappers: {
+            snapshot?: (value: TValue) => TMappedEvent;
+        } | ((value: TValue) => TMappedEvent)): AnyActor;
+    };
+};
+export type Action<TContext extends MachineContext, TEvent extends EventObject, TEmittedEvent extends EventObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TParams = Record<string, unknown> | undefined, _TCtx = [TContext] extends [never] ? any : TContext> = (_: {
+    context: _TCtx;
+    event: TEvent;
+    parent: AnyActorRef | undefined;
+    self: ActorSelf<MachineSnapshot<_TCtx & MachineContext, TEvent, TODO, TODO, TODO, TODO, TODO, TODO>, TEvent>;
+    children: Record<string, AnyActor | undefined>;
+    actions: TActionMap;
+    actors: TActorMap;
+    guards: TGuardMap;
+    delays: TDelayMap;
+    system?: AnyActorSystem;
+    params: TParams;
+}, enqueue: EnqueueObject<TEvent, TEmittedEvent>) => {
+    context?: _TCtx;
+    children?: Record<string, AnyActor | undefined>;
+} | void;
+export type AnyAction = Action<MachineContext, EventObject, EventObject, Implementations['actions'], Implementations['actors'], Implementations['guards'], Implementations['delays']> | {
+    action: (...args: any[]) => any;
+    args: any[];
+} | AnyEventObject;
 export {};