xstate 6.0.0-alpha.2 → 6.0.0-alpha.21

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

@@ -2,7 +2,6 @@ import type { MachineSnapshot } from "./State.js";
 import type { StateMachine } from "./StateMachine.js";
 import type { StateNode } from "./StateNode.js";
 import { AsyncActorLogic } from "./actors/promise.js";
-import type { BaseAtom } from "./atom.js";
 import type { Actor } from "./createActor.js";
 import { InspectionEvent } from "./inspection.js";
 import { Spawner } from "./spawn.js";
@@ -80,18 +79,27 @@ export interface ParameterizedObject {
     type: string;
     params?: NonReducibleUnknown;
 }
-export interface UnifiedArg<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> {
+export type UnifiedArg<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> = {
     context: TContext;
     event: TExpressionEvent;
     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;
-}
+} & OutputArg<TExpressionEvent>;
 export type MachineContext = Record<string, any>;
-export interface ActionArgs<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> extends UnifiedArg<TContext, TExpressionEvent, TEvent> {
+type DoneEventType = `xstate.done.actor.${string}` | `xstate.done.state.${string}`;
+export type OutputArg<TEvent extends EventObject> = TEvent extends {
+    type: DoneEventType;
+    output: infer TOutput;
+} ? {
+    output: TOutput;
+} : {
+    output: undefined;
+};
+export type ActionArgs<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> = UnifiedArg<TContext, TExpressionEvent, TEvent> & {
     children: Record<string, AnyActor>;
-}
+};
 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';
@@ -102,10 +110,10 @@ export type NoRequiredParams<T extends ParameterizedObject> = T extends any ? un
 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<{
     type: T['type'];
-    params?: T['params'] | (({ context, event }: {
+    params?: T['params'] | (({ context, event, output }: {
         context: TContext;
         event: TExpressionEvent;
-    }) => T['params']);
+    } & OutputArg<TExpressionEvent>) => T['params']);
 }, undefined extends T['params'] ? false : true> : never;
 export type StateKey = string | AnyMachineSnapshot;
 export interface StateValueMap {
@@ -122,16 +130,23 @@ 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, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> {
+export type TransitionContextPatch<TContext extends MachineContext> = Partial<TContext> & {
+    call?: never;
+    apply?: never;
+    bind?: never;
+};
+export type TransitionContextMapper<TContext extends MachineContext, TCurrentEvent extends EventObject, TEvent extends EventObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actorSources'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], _TCtx extends MachineContext = [TContext] extends [never] ? any : TContext> = (args: TransitionFunctionArgs<_TCtx, TCurrentEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap>) => TransitionContextPatch<_TCtx>;
+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['actorSources'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> {
     actions?: never;
     guard?: unknown;
     reenter?: boolean;
     target?: TransitionTarget | undefined;
+    context?: TransitionContextPatch<TContext> | TransitionContextMapper<TContext, TExpressionEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap>;
     to?: TransitionConfigFunction<TContext, TExpressionEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
     meta?: TMeta;
     description?: string;
 }
-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> {
+export interface InitialTransitionConfig<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actorSources'], 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
@@ -143,11 +158,11 @@ any, // TActionMap
 any, // TActorMap
 any, // TGuardMap
 any>;
-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']> {
+export interface InvokeDefinition<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actorSources'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> {
     id: string;
-    systemId: string | undefined;
-    logic: string | AnyActorLogic | (({ actors, context, event, self }: {
-        actors: TActorMap;
+    registryKey: string | undefined;
+    logic: string | AnyActorLogic | (({ actorSources, context, event, self }: {
+        actorSources: TActorMap;
         context: TContext;
         event: TEvent;
         self: AnyActorRef;
@@ -177,9 +192,9 @@ export interface InvokeDefinition<TContext extends MachineContext, TEvent extend
     /** 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']>;
+export type AnyInvokeDefinition = InvokeDefinition<MachineContext, EventObject, EventObject, MetaObject, Implementations['actions'], Implementations['actorSources'], Implementations['guards'], Implementations['delays']>;
 type Delay<TDelay extends string> = TDelay | number;
-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']> = {
+export type DelayedTransitions<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actorSources'], 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' | 'choice' | 'history' | ({} & string);
@@ -188,26 +203,31 @@ export type StateNodesConfig<TContext extends MachineContext, TEvent extends Eve
     [K in string]: StateNode<TContext, TEvent>;
 };
 export type TransitionConfigTarget = string | undefined;
-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;
+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['actorSources'], 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['actorSources'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TMeta extends MetaObject, TInput = undefined, _TCtx extends MachineContext = [TContext] extends [never] ? any : TContext> = (args: TransitionFunctionArgs<_TCtx, TCurrentEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap> & {
+    input: TInput;
+}, enq: EnqueueObject<TEvent, TEmitted>) => {
+    target?: string | string[];
+    context?: TransitionContextPatch<_TCtx>;
+    reenter?: boolean;
+    meta?: TMeta;
+    input?: Record<string, unknown>;
+} | void;
+type TransitionFunctionArgs<TContext, TCurrentEvent extends EventObject, TEvent extends EventObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actorSources'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> = {
+    context: TContext;
     event: TCurrentEvent;
-    self: ActorSelf<MachineSnapshot<_TCtx & MachineContext, TEvent, TODO, TODO, TODO, TODO, TODO, TODO>, TEvent>;
+    self: ActorSelf<MachineSnapshot<TContext & MachineContext, TEvent, TODO, TODO, TODO, TODO, TODO, TODO>, TEvent>;
     parent: UnknownActorRef | undefined;
     value: StateValue;
     children: Record<string, AnyActor>;
+    system: AnyActorSystem;
     actions: TActionMap;
-    actors: TActorMap;
+    actorSources: 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']> = {
+} & OutputArg<TCurrentEvent>;
+export type AnyTransitionConfigFunction = TransitionConfigFunction<any, 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['actorSources'], 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;
@@ -223,10 +243,10 @@ type ActorImplementationsBySrc<TActor extends ProvidedActor> = {
 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;
+    registryKey?: string;
     /** The source of the machine to be invoked, or the machine itself. */
-    src: TSrc | (({ actors, context, event, self }: {
-        actors: ActorImplementationsBySrc<TActor>;
+    src: TSrc | (({ actorSources, context, event, self }: {
+        actorSources: ActorImplementationsBySrc<TActor>;
         context: TContext;
         event: TEvent;
         self: AnyActorRef;
@@ -257,9 +277,9 @@ type DistributeActors<TContext extends MachineContext, TEvent extends EventObjec
     [K in RequiredActorOptions<TSpecificActor>]: unknown;
 }> | {
     id?: never;
-    systemId?: string;
-    src: string | AnyActorLogic | (({ actors, context, event, self }: {
-        actors: ActorImplementationsBySrc<TActor>;
+    registryKey?: string;
+    src: string | AnyActorLogic | (({ actorSources, context, event, self }: {
+        actorSources: ActorImplementationsBySrc<TActor>;
         context: TContext;
         event: TEvent;
         self: AnyActorRef;
@@ -280,10 +300,10 @@ export type InvokeConfig<TContext extends MachineContext, TEvent extends EventOb
      * will be the machine's own `id`, or the URL (from `src`).
      */
     id?: string;
-    systemId?: string;
+    registryKey?: string;
     /** The source of the machine to be invoked, or the machine itself. */
-    src: string | AnyActorLogic | (({ actors, context, event, self }: {
-        actors: ActorImplementationsBySrc<TActor>;
+    src: string | AnyActorLogic | (({ actorSources, context, event, self }: {
+        actorSources: ActorImplementationsBySrc<TActor>;
         context: TContext;
         event: TEvent;
         self: AnyActorRef;
@@ -307,29 +327,36 @@ export type InvokeConfig<TContext extends MachineContext, TEvent extends EventOb
     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 type AnyStateNodeConfig = Next_StateNodeConfig<any, any, any, any, any, any, any, any, any, any, any>;
+export type AnyStateNodeConfig = Next_StateNodeConfig<any, 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>;
-export type AnyStateMachine = StateMachine<any, // context
-any, // event
-any, // children
-any, // state value
-any, // tag
-any, // input
-any, // output
-any, // emitted
-any, // TMeta
-any, // TStateSchema,
-any, // TActionMap,
-any, // TActorMap
-any, // TGuardMap
-any>;
+type LoosenMachineSnapshot<TSnapshot> = TSnapshot extends MachineSnapshot<any, any, any, any, any, any, any, any> ? Omit<TSnapshot, 'matches' | 'can'> & {
+    matches(partialStateValue: StateValue): boolean;
+    can(event: any): boolean;
+} : never;
+export type AnyMachineSnapshot = LoosenMachineSnapshot<MachineSnapshot<any, any, any, any, any, any, any, any>>;
+export interface AnyStateMachine extends AnyActorLogic {
+    id: string;
+    root: AnyStateNode;
+    options?: {
+        maxIterations?: number;
+    };
+    states: StateNodesConfig<any, any>;
+    events: Array<EventDescriptor<any>>;
+    implementations: Implementations;
+    config: any;
+    version?: string;
+    provide(implementations: any): AnyStateMachine;
+    resolveState(config: any): any;
+    getTransitionData(snapshot: any, event: any, actor: AnyActorRef): AnyTransitionDefinition[];
+    getStateNodeById(stateId: string): AnyStateNode;
+    getPersistedSnapshot(snapshot: any, options?: unknown): Snapshot<unknown>;
+}
 export type AnyStateConfig = StateConfig<any, AnyEventObject>;
 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 }: {
+export type InitialContext<TContext extends MachineContext, TActorMap extends Implementations['actorSources'], TInput, TEvent extends EventObject> = TContext | ContextFactory<TContext, TActorMap, TInput, TEvent>;
+export type ContextFactory<TContext extends MachineContext, TActorMap extends Implementations['actorSources'], TInput, TEvent extends EventObject = EventObject> = ({ spawn, actorSources, input, self }: {
     spawn: Spawner;
-    actors: TActorMap;
+    actorSources: TActorMap;
     input: TInput;
     self: ActorSelf<MachineSnapshot<[
         TContext
@@ -353,7 +380,7 @@ export interface SetupTypes<TContext extends MachineContext, TEvent extends Even
     meta?: TMeta;
 }
 export interface MachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput, TEmitted extends EventObject, TMeta extends MetaObject> extends SetupTypes<TContext, TEvent, never, TTag, TInput, TOutput, TEmitted, TMeta> {
-    actors?: TActor;
+    actorSources?: TActor;
     actions?: TAction;
     guards?: TGuard;
     delays?: TDelay;
@@ -368,7 +395,20 @@ export type PersistedHistoryValue = Record<string, Array<{
     id: string;
 }>>;
 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 StateFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = T extends AnyStateMachine ? StateSnapshotFromMachine<T> : T extends (...args: any[]) => AnyStateMachine ? StateSnapshotFromMachine<ReturnType<T>> : never;
+type StateValueFromStateSchema<T extends StateSchema> = StateSchema extends T ? StateValue : ToStateValue<T> extends infer TStateValue ? TStateValue extends StateValue ? TStateValue : StateValue : StateValue;
+type MatchingStateValueForStateFrom<TStateValue extends StateValue, TTestStateValue extends StateValue> = TStateValue extends unknown ? TTestStateValue extends string ? TStateValue extends string ? TTestStateValue extends TStateValue ? TTestStateValue : Extract<TStateValue, TTestStateValue> : TStateValue extends StateValueMap ? TStateValue & Record<TTestStateValue, StateValue | undefined> : never : TTestStateValue extends StateValueMap ? TStateValue extends StateValueMap ? MatchingStateValueMapForStateFrom<TStateValue, TTestStateValue> : never : never : never;
+type MatchingStateValueMapForStateFrom<TStateValue extends StateValueMap, TTestStateValue extends StateValueMap> = false extends {
+    [K in keyof TTestStateValue & string]: K extends keyof TStateValue ? IsNever<MatchingStateValueForStateFrom<NonNullable<TStateValue[K]>, NonNullable<TTestStateValue[K]>>> extends true ? false : true : false;
+}[keyof TTestStateValue & string] ? never : {
+    [K in keyof TStateValue]: K extends keyof TTestStateValue ? MatchingStateValueForStateFrom<NonNullable<TStateValue[K]>, NonNullable<TTestStateValue[K]>> : TStateValue[K];
+};
+type StateSnapshotFromStateValue<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema, TAllStateValue extends StateValue = TStateValue> = TStateValue extends unknown ? Omit<MachineSnapshot<StateContextFromStateValue<TStateSchema, TContext, TStateValue>, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, 'matches'> & {
+    matches<const TTestStateValue extends string>(partialStateValue: TTestStateValue, ...args: string extends TTestStateValue ? [never] : []): this is StateSnapshotFromStateValue<StateContextFromStateValue<TStateSchema, TContext, TTestStateValue>, TEvent, TChildren, MatchingStateValueForStateFrom<TAllStateValue, TTestStateValue>, TTag, TOutput, TMeta, TStateSchema, TAllStateValue>;
+    matches<const TTestStateValue extends StateValueMap>(partialStateValue: TTestStateValue, ...args: string extends keyof TTestStateValue ? [never] : []): this is StateSnapshotFromStateValue<StateContextFromStateValue<TStateSchema, TContext, TTestStateValue>, TEvent, TChildren, MatchingStateValueForStateFrom<TAllStateValue, TTestStateValue>, TTag, TOutput, TMeta, TStateSchema, TAllStateValue>;
+    matches(partialStateValue: StateValue): boolean;
+} : never;
+type StateSnapshotFromMachine<T extends AnyStateMachine> = SnapshotFrom<T> extends MachineSnapshot<infer TContext, infer TEvent, infer TChildren, infer _TStateValue, infer TTag, infer TOutput, infer TMeta, infer TStateSchema> ? StateSnapshotFromStateValue<TContext, TEvent, TChildren, StateValueFromStateSchema<TStateSchema>, TTag, TOutput, TMeta, TStateSchema, StateValueFromStateSchema<TStateSchema>> : SnapshotFrom<T>;
 export interface DoneActorEvent<TOutput = unknown, TId extends string = string> extends EventObject {
     type: `xstate.done.actor.${TId}`;
     output: TOutput;
@@ -379,6 +419,11 @@ export interface ErrorActorEvent<TErrorData = unknown, TId extends string = stri
     error: TErrorData;
     actorId: TId;
 }
+export interface ErrorPlatformEvent<TErrorData = unknown, TKind extends string = string> extends EventObject {
+    type: `xstate.error.${TKind}`;
+    error: TErrorData;
+}
+export type ErrorEvent = ErrorActorEvent | ErrorPlatformEvent;
 export interface SnapshotEvent<TSnapshot extends Snapshot<unknown> = Snapshot<unknown>> extends EventObject {
     type: `xstate.snapshot.${string}`;
     snapshot: TSnapshot;
@@ -396,7 +441,7 @@ export type Mapper<TContext extends MachineContext, TExpressionEvent extends Eve
     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;
+} & OutputArg<TExpressionEvent>) => TResult;
 export interface TransitionDefinition<TContext extends MachineContext, TEvent extends EventObject> extends Omit<TransitionConfig<TContext, TEvent, TEvent, TODO, TODO, TODO, TODO, TODO, // TEmitted
 TODO>, 'target' | 'to'> {
     target: ReadonlyArray<AnyStateNode> | undefined;
@@ -407,6 +452,7 @@ TODO>, 'target' | 'to'> {
     input?: Record<string, unknown> | ((args: {
         context: any;
         event: any;
+        output: any;
     }) => Record<string, unknown>);
 }
 export type AnyTransitionDefinition = TransitionDefinition<any, any>;
@@ -512,8 +558,8 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
     id?: string;
     /** @deprecated Use `inspect` instead. */
     devTools?: never;
-    /** The system ID to register this actor under. */
-    systemId?: string;
+    /** The registry key to register this actor under. */
+    registryKey?: string;
     /** The input data to pass to the actor. */
     input?: InputFrom<TLogic>;
     /**
@@ -667,6 +713,10 @@ export interface ActorRef<TSnapshot extends Snapshot<unknown>, TEvent extends Ev
         type: TType;
     })) => void) => Subscription;
 }
+type EventPayload<TEvent extends EventObject, TType extends TEvent['type']> = HomomorphicOmit<ExtractEvent<TEvent, TType>, 'type'>;
+export type ActorTrigger<TEvent extends EventObject> = {
+    [K in TEvent['type']]: {} extends EventPayload<TEvent, K> ? () => void : (payload: EventPayload<TEvent, K>) => void;
+};
 /**
  * Runtime-only actor capabilities.
  *
@@ -675,7 +725,7 @@ export interface ActorRef<TSnapshot extends Snapshot<unknown>, TEvent extends Ev
  * 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> {
+export interface ActorRuntime<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, _TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> {
     /** The unique identifier for this actor relative to its parent. */
     id: string;
     /**
@@ -692,7 +742,7 @@ export interface ActorRuntime<TSnapshot extends Snapshot<unknown>, TEvent extend
     _parent?: any;
     system: any;
     src: string | AnyActorLogic;
-    trigger: any;
+    trigger: ActorTrigger<TSendEvent>;
     select<TSelected>(selector: (snapshot: TSnapshot) => TSelected, equalityFn?: (a: TSelected, b: TSelected) => boolean): Readable<TSelected>;
 }
 /**
@@ -702,7 +752,7 @@ export interface ActorRuntime<TSnapshot extends Snapshot<unknown>, TEvent extend
  * 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> {
+export interface ActorInstance<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> extends ActorRuntime<TSnapshot, TEvent, TEmitted, TSendEvent>, ActorRef<TSnapshot, TEvent, TEmitted, TSendEvent> {
 }
 /**
  * The actor's own full self handle.
@@ -711,15 +761,20 @@ export interface ActorInstance<TSnapshot extends Snapshot<unknown>, TEvent exten
  * 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 ActorSelf<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject, TEmitted extends EventObject = EventObject, TSendEvent extends EventObject = TEvent> = ActorRuntime<TSnapshot, TEvent, TEmitted, TSendEvent> & 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>;
+type OpaqueMachineSnapshot<TSnapshot extends Snapshot<unknown>> = TSnapshot extends MachineSnapshot<infer TContext, infer TEvent, infer TChildren, infer TStateValue, infer TTag, infer TOutput, infer TMeta, infer _TStateSchema> ? MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, any> : TSnapshot;
+export type ActorRefFromLogic<T extends AnyActorLogic> = ActorRef<OpaqueMachineSnapshot<SnapshotFrom<T>>, EventFromLogic<T>, EmittedFrom<T>, SendableEventFromLogic<T>>;
+export interface AnyActorRef extends Subscribable<any>, InteropObservable<any> {
+    send(event: any): void;
+    getSnapshot(): any;
+    on(type: string, handler: (emitted: any) => void): Subscription;
+}
 /** 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 {
@@ -730,7 +785,7 @@ export type UnknownActorRef = ActorRef<Snapshot<unknown>, EventObject>;
 export type DevToolsAdapter = (service: AnyActor) => void;
 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;
+    actorSources: TActorMap;
     guards: TGuardMap;
     delays: TDelayMap;
 } : never;
@@ -767,6 +822,7 @@ export type Snapshot<TOutput> = {
     output: undefined;
     error: undefined;
 };
+export type ActorLogicTransitionResult<TSnapshot extends Snapshot<unknown>, TEffect = unknown> = [nextSnapshot: TSnapshot, effects: TEffect[]];
 /**
  * Represents logic which can be used by an actor.
  *
@@ -782,14 +838,22 @@ in TInput = NonReducibleUnknown, TSystem extends AnyActorSystem = AnyActorSystem
     config?: unknown;
     /**
      * Transition function that processes the current state and an incoming event
-     * to produce a new state.
+     * to produce a new state and effects.
      *
      * @param snapshot - The current state.
      * @param event - The incoming event.
      * @param actorScope - The actor scope.
-     * @returns The new state.
+     * @returns A tuple of the next state and effects.
+     */
+    transition: (snapshot: TSnapshot, event: TEvent, actorScope: ActorScope<TSnapshot, TEvent, TSystem, TEmitted>) => ActorLogicTransitionResult<TSnapshot>;
+    /**
+     * Transition function that produces the initial state and effects.
+     *
+     * @param actorScope - The actor scope.
+     * @param input - The input for the initial state.
+     * @returns A tuple of the initial state and effects.
      */
-    transition: (snapshot: TSnapshot, event: TEvent, actorScope: ActorScope<TSnapshot, TEvent, TSystem, TEmitted>) => TSnapshot;
+    initialTransition: (input: TInput, actorScope: ActorScope<TSnapshot, TEvent, TSystem, TEmitted>) => ActorLogicTransitionResult<TSnapshot>;
     /**
      * Called to provide the initial state of the actor.
      *
@@ -823,19 +887,37 @@ in TInput = NonReducibleUnknown, TSystem extends AnyActorSystem = AnyActorSystem
      * @returns The a representation of the internal state to be persisted.
      */
     getPersistedSnapshot: (snapshot: TSnapshot, options?: unknown) => Snapshot<unknown>;
+    /**
+     * Executes the non-action effects returned from `transition` (e.g. the
+     * effects produced by `createLogic`-based actors). Actor logic that never
+     * returns such effects can omit this.
+     */
+    executeEffects?: (effects: readonly unknown[], actorScope: ActorScope<TSnapshot, TEvent, TSystem, TEmitted>) => void;
+    /**
+     * Returns an event that the actor should transition with to recover from an
+     * execution error, or `undefined` if the given snapshot cannot handle it.
+     * Actor logic without error-recovery semantics can omit this.
+     */
+    getExecutionErrorEvent?: (snapshot: TSnapshot, error: unknown) => TEvent | undefined;
+}
+export interface AnyActorLogic {
+    config?: unknown;
+    transition(snapshot: any, event: any, actorScope: any): ActorLogicTransitionResult<any>;
+    initialTransition(input: any, actorScope: any): ActorLogicTransitionResult<any>;
+    getInitialSnapshot(actorScope: any, input: any): any;
+    restoreSnapshot?(persistedState: Snapshot<unknown>, actorScope: any): any;
+    start?(snapshot: any, actorScope: any): void;
+    getPersistedSnapshot(snapshot: any, options?: unknown): Snapshot<unknown>;
+    executeEffects?(effects: readonly unknown[], actorScope: any): void;
+    getExecutionErrorEvent?(snapshot: any, error: unknown): any;
 }
-export type AnyActorLogic = ActorLogic<any, // snapshot
-any, // event
-any, // input
-any, // system
-any>;
 export type UnknownActorLogic = ActorLogic<any, // snapshot
 any, // event
 any, // input
 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;
+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 _TSystem, infer _TEmitted> ? TSnapshot : 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 _TSystem, infer _TEmitted> ? TEvent : never;
+export type EmittedFrom<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 _TStateSchema, infer _TActionMap, infer _TActorMap, infer _TGuardMap, infer _TDelayMap> ? TEmitted : [TLogic] extends [AnyStateMachine] ? AnyEventObject : TLogic extends ActorLogic<infer _TSnapshot, infer _TEvent, infer _TInput, infer _TSystem, infer TEmitted> ? TEmitted : AnyEventObject;
 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> = 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;
@@ -852,6 +934,10 @@ export type TagsFrom<TMachine extends AnyStateMachine> = Parameters<StateFrom<TM
 export interface ActorSystemInfo {
     actors: Record<string, AnyActorRef>;
 }
+export type SystemRegistry = Record<string, AnyActorLogic>;
+export type RegistryKeyForLogic<TLogic extends AnyActorLogic, TSystemRegistry extends SystemRegistry> = string extends keyof TSystemRegistry ? string : Values<{
+    [K in keyof TSystemRegistry & string]: ActorRefFromLogic<TLogic> extends ActorRefFromLogic<TSystemRegistry[K]> ? K : never;
+}>;
 export type RequiredActorOptions<TActor extends ProvidedActor> = (undefined extends TActor['id'] ? never : 'id') | (undefined extends InputFrom<TActor['logic']> ? never : 'input');
 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;
@@ -877,6 +963,9 @@ export type StateSchema = {
     entry?: unknown;
     exit?: unknown;
     onDone?: unknown;
+    onError?: unknown;
+    timeout?: unknown;
+    onTimeout?: unknown;
     after?: unknown;
     always?: unknown;
     choice?: unknown;
@@ -914,7 +1003,7 @@ export type RoutableStateId<TSchema extends StateSchema> = (TSchema extends {
 export interface StateMachineTypes {
     context: MachineContext;
     events: EventObject;
-    actors: ProvidedActor;
+    actorSources: ProvidedActor;
     actions: ParameterizedObject;
     guards: ParameterizedObject;
     delays: string;
@@ -925,7 +1014,7 @@ export interface StateMachineTypes {
 export interface ResolvedStateMachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TEmitted extends EventObject = EventObject> {
     context: TContext;
     events: TEvent;
-    actors: TActor;
+    actorSources: TActor;
     actions: TAction;
     guards: TGuard;
     delays: TDelay;
@@ -937,7 +1026,9 @@ type _GroupStateKeys<T extends StateSchema, S extends keyof T['states']> = S ext
     type: 'history';
 } ? [never, never] : T extends {
     type: 'parallel';
-} ? [S, never] : 'states' extends keyof T['states'][S] ? [S, never] : [never, S] : never;
+} ? [S, never] : T['states'][S] extends {
+    states: Record<string, StateSchema>;
+} ? [S, never] : [never, S] : never;
 type GroupStateKeys<T extends StateSchema, S extends keyof T['states']> = {
     nonLeaf: _GroupStateKeys<T, S & string>[0];
     leaf: _GroupStateKeys<T, S & string>[1];
@@ -953,19 +1044,68 @@ export type ToStateValue<T extends StateSchema> = T extends {
         [StateKey in K]: ToStateValue<T['states'][K]>;
     };
 }>> : never) : {};
-export interface ExecutableActionObject {
-    type: string & {};
+export interface BaseExecutableActionObject {
     params: NonReducibleUnknown;
     args: unknown[];
     exec: (() => void) | undefined;
 }
-export type SpecialExecutableAction = Values<{
-    [K in keyof typeof builtInActions]: {
-        type: K;
-        args: Parameters<(typeof builtInActions)[K]>;
-    };
+export interface CustomExecutableActionObject<TType extends string = string & {}> extends BaseExecutableActionObject {
+    type: TType;
+}
+export interface SpawnExecutableActionObject extends BaseExecutableActionObject {
+    type: '@xstate.spawn';
+    actor: AnyActor;
+    id: string;
+    logic: AnyActorLogic;
+    src: string | AnyActorLogic;
+    input: unknown;
+    args: Parameters<(typeof builtInActions)['@xstate.spawn']>;
+}
+export interface StartExecutableActionObject extends BaseExecutableActionObject {
+    type: '@xstate.start';
+    actor: AnyActor;
+    id: string;
+    args: Parameters<(typeof builtInActions)['@xstate.start']>;
+}
+export interface RaiseExecutableActionObject extends BaseExecutableActionObject {
+    type: '@xstate.raise';
+    event: EventObject;
+    id: string | undefined;
+    delay: number | undefined;
+    args: Parameters<(typeof builtInActions)['@xstate.raise']>;
+}
+export interface SendToExecutableActionObject extends BaseExecutableActionObject {
+    type: '@xstate.sendTo';
+    target: AnyActor;
+    event: EventObject;
+    id: string | undefined;
+    delay: number | undefined;
+    args: Parameters<(typeof builtInActions)['@xstate.sendTo']>;
+}
+export interface CancelExecutableActionObject extends BaseExecutableActionObject {
+    type: '@xstate.cancel';
+    id: string;
+    args: Parameters<(typeof builtInActions)['@xstate.cancel']>;
+}
+export interface StopExecutableActionObject extends BaseExecutableActionObject {
+    type: '@xstate.stop';
+    actor: AnyActor;
+    args: Parameters<(typeof builtInActions)['@xstate.stop']>;
+}
+export type BuiltInExecutableActionObject = Values<{
+    '@xstate.spawn': SpawnExecutableActionObject;
+    '@xstate.start': StartExecutableActionObject;
+    '@xstate.raise': RaiseExecutableActionObject;
+    '@xstate.sendTo': SendToExecutableActionObject;
+    '@xstate.cancel': CancelExecutableActionObject;
+    '@xstate.stop': StopExecutableActionObject;
 }>;
-export interface ToExecutableAction<T extends ParameterizedObject> extends ExecutableActionObject {
+export type SpecialExecutableAction = BuiltInExecutableActionObject;
+type TransitionExecutableActionObject<TType extends string = never> = BuiltInExecutableActionObject | CustomExecutableActionObject<TType | (string & {})>;
+type KnownImplementationKeys<TImplementationMap> = string extends keyof TImplementationMap ? never : Extract<keyof TImplementationMap, string>;
+export type ExecutableActionObjectFromLogic<T extends AnyActorLogic> = T extends StateMachine<any, any, any, any, any, any, any, any, any, any, infer TActionMap, any, any, any> ? TransitionExecutableActionObject<KnownImplementationKeys<TActionMap>> : ExecutableActionObject;
+export type ExecutableActionObject<TType extends string = string & {}> = BuiltInExecutableActionObject | CustomExecutableActionObject<TType>;
+export interface ToExecutableAction<T extends ParameterizedObject> extends CustomExecutableActionObject<T['type']> {
     type: T['type'];
     params: T['params'];
     exec: undefined;
@@ -977,7 +1117,7 @@ export interface SubscribeToMappers<TSnapshot extends Snapshot<unknown>, TOutput
     done?: (output: TOutput) => TMappedEvent;
     error?: (error: unknown) => TMappedEvent;
 }
-export type EnqueueObject<TEvent extends EventObject, TEmittedEvent extends EventObject> = {
+export type EnqueueObject<TEvent extends EventObject, TEmittedEvent extends EventObject, TSystemRegistry extends SystemRegistry = SystemRegistry> = {
     cancel: (id: string) => void;
     raise: (ev: TEvent, options?: {
         id?: string;
@@ -987,7 +1127,7 @@ export type EnqueueObject<TEvent extends EventObject, TEmittedEvent extends Even
         input?: InputFrom<T>;
         id?: string;
         syncSnapshot?: boolean;
-        systemId?: string;
+        registryKey?: RegistryKeyForLogic<T, TSystemRegistry>;
     }) => ActorFromLogic<T>;
     emit: (emittedEvent: TEmittedEvent) => void;
     <T extends (...args: any[]) => any>(fn: T, ...args: Parameters<T>): void;
@@ -1017,30 +1157,25 @@ export type EnqueueObject<TEvent extends EventObject, TEmittedEvent extends Even
      * @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;
-    };
+    subscribeTo: <TActor extends AnyActor, TMappedEvent extends TEvent>(actor: TActor, mappers: SubscribeToMappers<SnapshotFrom<TActor>, OutputFrom<TActor>, TMappedEvent> | ((snapshot: SnapshotFrom<TActor>) => 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> = (_: {
+export type Action<TContext extends MachineContext, TEvent extends EventObject, TEmittedEvent extends EventObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actorSources'], 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;
+    actorSources: TActorMap;
     guards: TGuardMap;
     delays: TDelayMap;
     system?: AnyActorSystem;
     params: TParams;
 }, enqueue: EnqueueObject<TEvent, TEmittedEvent>) => {
-    context?: _TCtx;
+    context?: Partial<_TCtx>;
     children?: Record<string, AnyActor | undefined>;
 } | void;
-export type AnyAction = Action<MachineContext, EventObject, EventObject, Implementations['actions'], Implementations['actors'], Implementations['guards'], Implementations['delays']> | {
+export type AnyAction = Action<MachineContext, EventObject, EventObject, Implementations['actions'], Implementations['actorSources'], Implementations['guards'], Implementations['delays']> | {
     action: (...args: any[]) => any;
     args: any[];
 } | AnyEventObject;