xstate 5.0.0-beta.19 → 5.0.0-beta.20

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

@@ -1,12 +1,22 @@
 import type { StateNode } from "./StateNode.js";
 import { TypegenDisabled, TypegenEnabled } from "./typegenTypes.js";
-import type { ActorRef, AnyState, AnyStateMachine, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, StateConfig, StateValue } from "./types.js";
+import type { ProvidedActor, ActorRefFrom, AnyState, AnyStateMachine, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, StateConfig, StateValue, TODO, AnyActorRef, Compute } from "./types.js";
+type ComputeConcreteChildren<TActor extends Required<ProvidedActor>> = {
+    [K in TActor['id']]?: ActorRefFrom<(TActor & {
+        id: K;
+    })['logic']>;
+};
+type ComputeChildren<TActor extends ProvidedActor> = string extends TActor['src'] ? Record<string, AnyActorRef> : Compute<ComputeConcreteChildren<Extract<TActor, {
+    id: string;
+}>> & (undefined extends TActor['id'] ? {
+    [id: string]: TActor extends any ? ActorRefFrom<TActor['logic']> | undefined : never;
+} : {})>;
 export declare function isStateConfig<TContext extends MachineContext, TEvent extends EventObject>(state: any): state is StateConfig<TContext, TEvent>;
 /**
  * @deprecated Use `isStateConfig(object)` or `state instanceof State` instead.
  */
 export declare const isState: typeof isStateConfig;
-export declare class State<TContext extends MachineContext, TEvent extends EventObject = EventObject, TResolvedTypesMeta = TypegenDisabled> {
+export declare class State<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TResolvedTypesMeta = TypegenDisabled> {
     machine: AnyStateMachine;
     tags: Set<string>;
     value: StateValue;
@@ -28,13 +38,13 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
     /**
      * An object mapping actor names to spawned/invoked actors.
      */
-    children: Record<string, ActorRef<any>>;
+    children: ComputeChildren<TActor>;
     /**
      * Creates a new State instance for the given `stateValue` and `context`.
      * @param stateValue
      * @param context
      */
-    static from<TContext extends MachineContext, TEvent extends EventObject = EventObject>(stateValue: State<TContext, TEvent, any> | StateValue, context: TContext | undefined, machine: AnyStateMachine): State<TContext, TEvent, any>;
+    static from<TContext extends MachineContext, TEvent extends EventObject = EventObject>(stateValue: State<TContext, TEvent, TODO, any> | StateValue, context: TContext | undefined, machine: AnyStateMachine): State<TContext, TEvent, TODO, any>;
     /**
      * Creates a new `State` instance that represents the current state of a running machine.
      *
@@ -78,3 +88,4 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
 }
 export declare function cloneState<TState extends AnyState>(state: TState, config?: Partial<StateConfig<any, any>>): TState;
 export declare function getPersistedState<TState extends AnyState>(state: TState): PersistedMachineState<TState>;
+export {};

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

@@ -1,10 +1,10 @@
 import { State } from "./State.js";
 import { StateNode } from "./StateNode.js";
 import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
-import type { ActorContext, ActorLogic, ActorMap, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext, Equals } from "./types.js";
+import type { ActorContext, ActorLogic, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext, ProvidedActor, Equals } from "./types.js";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";
-export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject = EventObject, TAction extends ParameterizedObject = ParameterizedObject, TActorMap extends ActorMap = ActorMap, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TActorMap>> implements ActorLogic<TEvent, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>> {
+export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject = EventObject, TAction extends ParameterizedObject = ParameterizedObject, TActor extends ProvidedActor = ProvidedActor, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TActor>> implements ActorLogic<TEvent, State<TContext, TEvent, TActor, TResolvedTypesMeta>, State<TContext, TEvent, TActor, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TActor, TResolvedTypesMeta>>> {
     /**
      * The raw config used to create the machine.
      */
@@ -14,7 +14,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      */
     version?: string;
     implementations: MachineImplementationsSimplified<TContext, TEvent>;
-    types: MachineTypes<TContext, TEvent>;
+    types: MachineTypes<TContext, TEvent, TActor>;
     __xstatenode: true;
     idMap: Map<string, StateNode<TContext, TEvent>>;
     root: StateNode<TContext, TEvent>;
@@ -35,7 +35,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      *
      * @returns A new `StateMachine` instance with the provided implementations.
      */
-    provide(implementations: InternalMachineImplementations<TContext, TEvent, TResolvedTypesMeta, true>): StateMachine<TContext, TEvent, TAction, TActorMap, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
+    provide(implementations: InternalMachineImplementations<TContext, TEvent, TAction, TActor, TResolvedTypesMeta, true>): StateMachine<TContext, TEvent, TAction, TActor, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
     /**
      * Resolves the given `state` to a new `State` instance relative to this machine.
      *
@@ -43,8 +43,8 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      *
      * @param state The state to resolve
      */
-    resolveState(state: State<TContext, TEvent, TResolvedTypesMeta>): typeof state;
-    resolveStateValue(stateValue: StateValue, ...[context]: Equals<TContext, MachineContext> extends true ? [] : [TContext]): State<TContext, TEvent, TResolvedTypesMeta>;
+    resolveState(state: State<TContext, TEvent, TActor, TResolvedTypesMeta>): typeof state;
+    resolveStateValue(stateValue: StateValue, ...[context]: Equals<TContext, MachineContext> extends true ? [] : [TContext]): State<TContext, TEvent, TActor, TResolvedTypesMeta>;
     /**
      * Determines the next state given the current `state` and received `event`.
      * Calculates a full macrostep from all microsteps.
@@ -52,7 +52,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param state The current State instance or state value
      * @param event The received event
      */
-    transition(state: State<TContext, TEvent, TResolvedTypesMeta>, event: TEvent, actorCtx: ActorContext<TEvent, State<TContext, TEvent, any>>): State<TContext, TEvent, TResolvedTypesMeta>;
+    transition(state: State<TContext, TEvent, TActor, TResolvedTypesMeta>, event: TEvent, actorCtx: ActorContext<TEvent, State<TContext, TEvent, TActor, any>>): State<TContext, TEvent, TActor, TResolvedTypesMeta>;
     /**
      * Determines the next state given the current `state` and `event`.
      * Calculates a microstep.
@@ -60,8 +60,8 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param state The current state
      * @param event The received event
      */
-    microstep(state: State<TContext, TEvent, TResolvedTypesMeta>, event: TEvent, actorCtx: AnyActorContext): Array<State<TContext, TEvent, TResolvedTypesMeta>>;
-    getTransitionData(state: State<TContext, TEvent, TResolvedTypesMeta>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>>;
+    microstep(state: State<TContext, TEvent, TActor, TResolvedTypesMeta>, event: TEvent, actorCtx: AnyActorContext): Array<State<TContext, TEvent, TActor, TResolvedTypesMeta>>;
+    getTransitionData(state: State<TContext, TEvent, TActor, TResolvedTypesMeta>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>>;
     /**
      * The initial state _before_ evaluating any microsteps.
      * This "pre-initial" state is provided to initial actions executed in the initial state.
@@ -70,21 +70,21 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
     /**
      * Returns the initial `State` instance, with reference to `self` as an `ActorRef`.
      */
-    getInitialState(actorCtx: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>, input?: any): State<TContext, TEvent, TResolvedTypesMeta>;
-    start(state: State<TContext, TEvent, TResolvedTypesMeta>, actorCtx: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>): void;
+    getInitialState(actorCtx: ActorContext<TEvent, State<TContext, TEvent, TActor, TResolvedTypesMeta>>, input?: any): State<TContext, TEvent, TActor, TResolvedTypesMeta>;
+    start(state: State<TContext, TEvent, TActor, TResolvedTypesMeta>, actorCtx: ActorContext<TEvent, State<TContext, TEvent, TActor, TResolvedTypesMeta>>): void;
     getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
     get definition(): StateMachineDefinition<TContext, TEvent>;
     toJSON(): StateMachineDefinition<TContext, TEvent>;
-    getPersistedState(state: State<TContext, TEvent, TResolvedTypesMeta>): PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>;
-    createState(stateConfig: State<TContext, TEvent, TResolvedTypesMeta> | StateConfig<TContext, TEvent>): State<TContext, TEvent, TResolvedTypesMeta>;
-    getStatus(state: State<TContext, TEvent, TResolvedTypesMeta>): {
+    getPersistedState(state: State<TContext, TEvent, TActor, TResolvedTypesMeta>): PersistedMachineState<State<TContext, TEvent, TActor, TResolvedTypesMeta>>;
+    createState(stateConfig: State<TContext, TEvent, TActor, TResolvedTypesMeta> | StateConfig<TContext, TEvent>): State<TContext, TEvent, TActor, TResolvedTypesMeta>;
+    getStatus(state: State<TContext, TEvent, TActor, TResolvedTypesMeta>): {
         status: string;
         data: any;
     } | {
         status: string;
         data?: undefined;
     };
-    restoreState(state: PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>, _actorCtx: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>): State<TContext, TEvent, TResolvedTypesMeta>;
+    restoreState(state: PersistedMachineState<State<TContext, TEvent, TActor, TResolvedTypesMeta>>, _actorCtx: ActorContext<TEvent, State<TContext, TEvent, TActor, TResolvedTypesMeta>>): State<TContext, TEvent, TActor, TResolvedTypesMeta>;
     /**@deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TContext: TContext;
     /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
@@ -92,7 +92,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
     /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TAction: TAction;
     /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
-    __TActorMap: TActorMap;
+    __TActor: TActor;
     /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TResolvedTypesMeta: TResolvedTypesMeta;
 }

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

@@ -1,6 +1,6 @@
 import type { State } from "./State.js";
 import type { StateMachine } from "./StateMachine.js";
-import type { Action, DelayedTransitionDefinition, EventObject, InitialTransitionDefinition, InvokeDefinition, MachineContext, Mapper, PropertyMapper, StateNodeConfig, StateNodeDefinition, StateNodesConfig, TransitionDefinition, TransitionDefinitionMap } from "./types.js";
+import type { Action, DelayedTransitionDefinition, EventObject, InitialTransitionDefinition, InvokeDefinition, MachineContext, Mapper, PropertyMapper, StateNodeConfig, StateNodeDefinition, StateNodesConfig, TransitionDefinition, TransitionDefinitionMap, TODO } from "./types.js";
 interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
     _key: string;
     _parent?: StateNode<TContext, TEvent>;
@@ -10,7 +10,7 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     /**
      * The raw config used to create the machine.
      */
-    config: StateNodeConfig<TContext, TEvent>;
+    config: StateNodeConfig<TContext, TEvent, TODO, TODO>;
     /**
      * The relative key of the state node, which represents its location in the overall state value.
      */
@@ -80,7 +80,7 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     /**
      * The raw config used to create the machine.
      */
-    config: StateNodeConfig<TContext, TEvent>, options: StateNodeOptions<TContext, TEvent>);
+    config: StateNodeConfig<TContext, TEvent, TODO, TODO>, options: StateNodeOptions<TContext, TEvent>);
     _initialize(): void;
     /**
      * The well-structured state node definition.
@@ -97,7 +97,7 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     get on(): TransitionDefinitionMap<TContext, TEvent>;
     get after(): Array<DelayedTransitionDefinition<TContext, TEvent>>;
     get initial(): InitialTransitionDefinition<TContext, TEvent>;
-    next(state: State<TContext, TEvent>, event: TEvent): TransitionDefinition<TContext, TEvent>[] | undefined;
+    next(state: State<TContext, TEvent, TODO>, event: TEvent): TransitionDefinition<TContext, TEvent>[] | undefined;
     /**
      * The target state value of the history state node, if it exists. This represents the
      * default state value to transition to if no history value exists yet.

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

@@ -29,7 +29,7 @@ export declare function sendTo<TContext extends MachineContext, TExpressionEvent
     (_: ActionArgs<TContext, TExpressionEvent>): void;
     type: string;
     to: string | TActor | ((args: UnifiedArg<TContext, TExpressionEvent>) => TActor | string);
-    event: ((TActor extends import("../types.js").AnyFunction ? ReturnType<TActor> : TActor) extends infer R ? R extends import("../StateMachine.js").StateMachine<infer _ extends MachineContext, infer TEvent_1 extends EventObject, infer __ extends import("../types.js").ParameterizedObject, infer ___ extends import("../types.js").ActorMap, infer ____> ? TEvent_1 : R extends import("../State.js").State<infer __1 extends MachineContext, infer TEvent_2 extends EventObject, infer ____1> ? TEvent_2 : R extends ActorRef<infer TEvent_3 extends EventObject, infer __2> ? TEvent_3 : never : never) | SendExpr<TContext, TExpressionEvent, InferEvent<Cast<(TActor extends import("../types.js").AnyFunction ? ReturnType<TActor> : TActor) extends infer R ? R extends import("../StateMachine.js").StateMachine<infer _ extends MachineContext, infer TEvent_1 extends EventObject, infer __ extends import("../types.js").ParameterizedObject, infer ___ extends import("../types.js").ActorMap, infer ____> ? TEvent_1 : R extends import("../State.js").State<infer __1 extends MachineContext, infer TEvent_2 extends EventObject, infer ____1> ? TEvent_2 : R extends ActorRef<infer TEvent_3 extends EventObject, infer __2> ? TEvent_3 : never : never, EventObject>>>;
+    event: ((TActor extends import("../types.js").AnyFunction ? ReturnType<TActor> : TActor) extends infer R ? R extends import("../StateMachine.js").StateMachine<infer _ extends MachineContext, infer TEvent_1 extends EventObject, infer __ extends import("../types.js").ParameterizedObject, infer ___ extends import("../types.js").ProvidedActor, infer ____> ? TEvent_1 : R extends import("../State.js").State<infer _TContext extends MachineContext, infer TEvent_2 extends EventObject, infer _TAction extends import("../types.js").ProvidedActor, infer _TActor> ? TEvent_2 : R extends ActorRef<infer TEvent_3 extends EventObject, infer __1> ? TEvent_3 : never : never) | SendExpr<TContext, TExpressionEvent, InferEvent<Cast<(TActor extends import("../types.js").AnyFunction ? ReturnType<TActor> : TActor) extends infer R ? R extends import("../StateMachine.js").StateMachine<infer _ extends MachineContext, infer TEvent_1 extends EventObject, infer __ extends import("../types.js").ParameterizedObject, infer ___ extends import("../types.js").ProvidedActor, infer ____> ? TEvent_1 : R extends import("../State.js").State<infer _TContext extends MachineContext, infer TEvent_2 extends EventObject, infer _TAction extends import("../types.js").ProvidedActor, infer _TActor> ? TEvent_2 : R extends ActorRef<infer TEvent_3 extends EventObject, infer __1> ? TEvent_3 : never : never, EventObject>>>;
     id: string | undefined;
     delay: string | number | DelayExpr<TContext, TExpressionEvent> | undefined;
     resolve: typeof resolve;

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

@@ -2,7 +2,7 @@ import { ActionArgs, ActorRef, AnyActorContext, AnyState, EventObject, MachineCo
 type ResolvableActorRef<TContext extends MachineContext, TExpressionEvent extends EventObject> = string | ActorRef<any> | ((args: UnifiedArg<TContext, TExpressionEvent>) => ActorRef<any> | string);
 declare function resolve(_: AnyActorContext, state: AnyState, args: ActionArgs<any, any>, { actorRef }: {
     actorRef: ResolvableActorRef<any, any>;
-}): (AnyState | ActorRef<any, any>)[];
+}): (ActorRef<any, any> | AnyState)[];
 declare function execute(actorContext: AnyActorContext, actorRef: ActorRef<any, any> | undefined): void;
 /**
  * Stops an actor.

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

@@ -1,10 +1,20 @@
-import { InvokeCallback, ActorLogic, EventObject, ActorRefFrom } from "../types.js";
+import { ActorLogic, EventObject, AnyActorSystem, AnyEventObject, ActorSystem, ActorRefFrom } from "../types.js";
 export interface CallbackInternalState<TEvent extends EventObject> {
     canceled: boolean;
     receivers: Set<(e: TEvent) => void>;
     dispose: void | (() => void) | Promise<any>;
     input?: any;
 }
-export type CallbackActorLogic<TEvent extends EventObject> = ActorLogic<TEvent, undefined, CallbackInternalState<TEvent>>;
+export type CallbackActorLogic<TEvent extends EventObject, TInput = any> = ActorLogic<TEvent, undefined, CallbackInternalState<TEvent>, CallbackInternalState<TEvent>, ActorSystem<any>, TInput, any>;
 export type CallbackActorRef<TEvent extends EventObject> = ActorRefFrom<CallbackActorLogic<TEvent>>;
-export declare function fromCallback<TEvent extends EventObject>(invokeCallback: InvokeCallback): CallbackActorLogic<TEvent>;
+export type Receiver<TEvent extends EventObject> = (listener: {
+    bivarianceHack(event: TEvent): void;
+}['bivarianceHack']) => void;
+export type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject, TInput = unknown> = ({ input, system, self, sendBack, receive }: {
+    input: TInput;
+    system: AnyActorSystem;
+    self: CallbackActorRef<TEvent>;
+    sendBack: (event: TSentEvent) => void;
+    receive: Receiver<TEvent>;
+}) => (() => void) | Promise<any> | void;
+export declare function fromCallback<TEvent extends EventObject, TInput>(invokeCallback: InvokeCallback<TEvent, AnyEventObject, TInput>): CallbackActorLogic<TEvent, TInput>;

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

@@ -1,8 +1,8 @@
-import type { EventObject, ActorRef, BaseActorRef, AnyEventObject } from "../types.js";
+import type { ActorRef, AnyEventObject, BaseActorRef, EventObject } from "../types.js";
+export { fromCallback, type CallbackActorLogic } from "./callback.js";
+export { fromEventObservable, fromObservable } from "./observable.js";
+export { fromPromise, type PromiseActorLogic } from "./promise.js";
 export { fromTransition } from "./transition.js";
-export { fromPromise } from "./promise.js";
-export { fromObservable, fromEventObservable } from "./observable.js";
-export { fromCallback } from "./callback.js";
 export declare const startSignalType = "xstate.init";
 export declare const stopSignalType = "xstate.stop";
 export declare const startSignal: StartSignal;

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

@@ -6,13 +6,13 @@ export interface ObservableInternalState<T> {
     input?: any;
 }
 export type ObservablePersistedState<T> = Omit<ObservableInternalState<T>, 'subscription'>;
-export type ObservableActorLogic<T> = ActorLogic<EventObject, T | undefined, ObservableInternalState<T>, ObservablePersistedState<T>>;
-export type ObservableActorRef<T> = ActorRefFrom<ObservableActorLogic<T>>;
-export declare function fromObservable<T>(observableCreator: ({ input, system }: {
-    input: any;
+export type ObservableActorLogic<T, TInput> = ActorLogic<EventObject, T | undefined, ObservableInternalState<T>, ObservablePersistedState<T>, AnyActorSystem, TInput>;
+export type ObservableActorRef<T> = ActorRefFrom<ObservableActorLogic<T, any>>;
+export declare function fromObservable<T, TInput>(observableCreator: ({ input, system }: {
+    input: TInput;
     system: AnyActorSystem;
     self: ObservableActorRef<T>;
-}) => Subscribable<T>): ObservableActorLogic<T>;
+}) => Subscribable<T>): ObservableActorLogic<T, TInput>;
 /**
  * Creates event observable logic that listens to an observable
  * that delivers event objects.
@@ -21,8 +21,8 @@ export declare function fromObservable<T>(observableCreator: ({ input, system }:
  * @param lazyObservable A function that creates an observable
  * @returns Event observable logic
  */
-export declare function fromEventObservable<T extends EventObject>(lazyObservable: ({ input }: {
-    input: any;
+export declare function fromEventObservable<T extends EventObject, TInput>(lazyObservable: ({ input, system }: {
+    input: TInput;
     system: AnyActorSystem;
     self: ObservableActorRef<T>;
-}) => Subscribable<T>): ObservableActorLogic<T>;
+}) => Subscribable<T>): ObservableActorLogic<T, TInput>;

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

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

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

@@ -1,6 +1,6 @@
-import { ActorLogic, ActorContext, ActorSystem, EventObject, ActorRefFrom } from "../types.js";
-export type TransitionActorLogic<TState, TEvent extends EventObject> = ActorLogic<TEvent, TState, TState>;
-export type TransitionActorRef<TState, TEvent extends EventObject> = ActorRefFrom<TransitionActorLogic<TState, TEvent>>;
+import { ActorLogic, ActorContext, ActorSystem, EventObject, ActorRefFrom, AnyActorSystem } from "../types.js";
+export type TransitionActorLogic<TState, TEvent extends EventObject, TInput> = ActorLogic<TEvent, TState, TState, TState, AnyActorSystem, TInput>;
+export type TransitionActorRef<TState, TEvent extends EventObject> = ActorRefFrom<TransitionActorLogic<TState, TEvent, unknown>>;
 /**
  * Returns actor logic from a transition function and its initial state.
  *
@@ -10,7 +10,7 @@ export type TransitionActorRef<TState, TEvent extends EventObject> = ActorRefFro
  * @param initialState The initial state of the transition function.
  * @returns Actor logic
  */
-export declare function fromTransition<TState, TEvent extends EventObject, TSystem extends ActorSystem<any>>(transition: (state: TState, event: TEvent, actorContext: ActorContext<TEvent, TState, TSystem>) => TState, initialState: TState | (({ input, self }: {
-    input: any;
+export declare function fromTransition<TState, TEvent extends EventObject, TSystem extends ActorSystem<any>, TInput>(transition: (state: TState, event: TEvent, actorContext: ActorContext<TEvent, TState, TSystem>) => TState, initialState: TState | (({ input, self }: {
+    input: TInput;
     self: TransitionActorRef<TState, TEvent>;
-}) => TState)): TransitionActorLogic<TState, TEvent>;
+}) => TState)): TransitionActorLogic<TState, TEvent, TInput>;

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

@@ -1,8 +1,8 @@
-import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, GuardPredicate, MachineContext } from "./types.js";
+import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, GuardPredicate, MachineContext, TODO } from "./types.js";
 import type { State } from "./State.js";
 export declare function stateIn<TContext extends MachineContext, TEvent extends EventObject>(stateValue: StateValue): GuardDefinition<TContext, TEvent>;
 export declare function not<TContext extends MachineContext, TEvent extends EventObject>(guard: GuardConfig<TContext, TEvent>): BooleanGuardDefinition<TContext, TEvent>;
 export declare function and<TContext extends MachineContext, TEvent extends EventObject>(guards: Array<GuardConfig<TContext, TEvent>>): BooleanGuardDefinition<TContext, TEvent>;
 export declare function or<TContext extends MachineContext, TEvent extends EventObject>(guards: Array<GuardConfig<TContext, TEvent>>): BooleanGuardDefinition<TContext, TEvent>;
-export declare function evaluateGuard<TContext extends MachineContext, TEvent extends EventObject>(guard: GuardDefinition<TContext, TEvent>, context: TContext, event: TEvent, state: State<TContext, TEvent>): boolean;
+export declare function evaluateGuard<TContext extends MachineContext, TEvent extends EventObject>(guard: GuardDefinition<TContext, TEvent>, context: TContext, event: TEvent, state: State<TContext, TEvent, TODO, TODO>): boolean;
 export declare function toGuardDefinition<TContext extends MachineContext, TEvent extends EventObject>(guardConfig: GuardConfig<TContext, TEvent>, getPredicate?: (guardType: string) => GuardPredicate<TContext, TEvent> | GuardDefinition<TContext, TEvent>): GuardDefinition<TContext, TEvent>;

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

@@ -1,6 +1,6 @@
 import { State } from "./State.js";
 import type { StateNode } from "./StateNode.js";
-import { Action, AnyActorContext, AnyHistoryValue, AnyState, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, SingleOrArray, StateValue, StateValueMap, TransitionConfig, TransitionDefinition } from "./types.js";
+import { Action, AnyActorContext, AnyHistoryValue, AnyState, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, SingleOrArray, StateValue, StateValueMap, TransitionConfig, TransitionDefinition, TODO } from "./types.js";
 type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
 type AnyConfiguration = Configuration<any, any>;
 type AdjList = Map<AnyStateNode, Array<AnyStateNode>>;
@@ -35,11 +35,11 @@ export declare function getStateNodeByPath(stateNode: AnyStateNode, statePath: s
  *
  * @param state The state value or State instance
  */
-export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, state: StateValue | State<TContext, TEvent>): Array<AnyStateNode>;
-export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, state: State<TContext, TEvent>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, state: State<TContext, TEvent, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function getStateNodes<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, state: StateValue | State<TContext, TEvent, TODO>): Array<AnyStateNode>;
+export declare function transitionAtomicNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: string, state: State<TContext, TEvent, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: State<TContext, TEvent, TODO>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, state: State<TContext, TEvent, TODO, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, configuration: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
@@ -49,8 +49,8 @@ export declare function removeConflictingTransitions(enabledTransitions: Array<A
  * @param currentState
  * @param mutConfiguration
  */
-export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext, event: TEvent, isInitial: boolean): State<TContext, TEvent, any>;
-export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: Action<any, any, any>[], event: TEvent, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext): AnyState;
+export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent, TODO, any>, actorCtx: AnyActorContext, event: TEvent, isInitial: boolean): State<TContext, TEvent, TODO, any>;
+export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: Action<any, any, any>[], event: TEvent, currentState: State<TContext, TEvent, TODO, any>, actorCtx: AnyActorContext): AnyState;
 export declare function macrostep(state: AnyState, event: EventObject, actorCtx: AnyActorContext): {
     state: typeof state;
     microstates: Array<typeof state>;

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

@@ -1,4 +1,4 @@
-import { Compute, EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast, ParameterizedObject } from "./types.js";
+import { Compute, EventObject, IndexByType, IsNever, Prop, Values, IsAny, ParameterizedObject, ProvidedActor, OutputFrom, AnyActorLogic, IndexByProp } from "./types.js";
 export interface TypegenDisabled {
     '@@xstate/typegen': false;
 }
@@ -36,8 +36,7 @@ export interface TypegenMeta extends TypegenEnabled {
      */
     internalEvents: {};
     /**
-     * Maps the name of the actor to the event type
-     * of the done.invoke action
+     * Maps the src of the invoked actor to the event type that includes its known id
      *
      * key: 'invokeSrc'
      * value: 'done.invoke.invokeName'
@@ -78,6 +77,7 @@ export interface TypegenMeta extends TypegenEnabled {
 }
 export interface ResolvedTypegenMeta extends TypegenMeta {
     resolved: TypegenMeta & {
+        indexedActors: Record<string, ProvidedActor>;
         indexedActions: Record<string, ParameterizedObject>;
         indexedEvents: Record<string, EventObject>;
     };
@@ -104,12 +104,10 @@ export interface MarkAllImplementationsAsProvided<TResolvedTypesMeta> {
     '@@xstate/typegen': Prop<TResolvedTypesMeta, '@@xstate/typegen'>;
     resolved: Prop<TResolvedTypesMeta, 'resolved'> & AllImplementationsProvided;
 }
-type GenerateActorEvent<TActorName, TEventType, TActorMap extends ActorMap> = TEventType extends any ? {
-    type: TEventType;
-} & Prop<TActorMap, TActorName> : never;
-type GenerateActorEvents<TActorMap extends ActorMap, TInvokeSrcNameMap> = string extends keyof TActorMap ? never : Cast<{
-    [K in keyof TInvokeSrcNameMap]: GenerateActorEvent<K, TInvokeSrcNameMap[K], TActorMap>;
-}[keyof TInvokeSrcNameMap], EventObject>;
+type GenerateActorEvents<TActor extends ProvidedActor, TInvokeSrcNameMap> = string extends TActor['src'] ? never : TActor extends any ? {
+    type: TActor['id'] extends string ? `done.invoke.${TActor['id']}` : TActor['src'] extends keyof TInvokeSrcNameMap ? `done.invoke.${TInvokeSrcNameMap[TActor['src']] & string}` : `done.invoke.${string}`;
+    output: OutputFrom<TActor['logic']>;
+} : never;
 type MergeWithInternalEvents<TIndexedEvents, TInternalEvents> = TIndexedEvents & Pick<TInternalEvents, Exclude<keyof TInternalEvents, keyof TIndexedEvents>>;
 type AllowAllEvents = {
     eventsCausingActions: Record<string, string>;
@@ -117,21 +115,21 @@ type AllowAllEvents = {
     eventsCausingDelays: Record<string, string>;
     eventsCausingGuards: Record<string, string>;
 };
-export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends ParameterizedObject, TActorMap extends ActorMap> {
+export interface ResolveTypegenMeta<TTypesMeta extends TypegenConstraint, TEvent extends EventObject, TAction extends ParameterizedObject, TActor extends ProvidedActor> {
     '@@xstate/typegen': TTypesMeta['@@xstate/typegen'];
     resolved: {
         enabled: TTypesMeta & {
             indexedActions: IndexByType<TAction>;
-            indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateActorEvents<TActorMap, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
+            indexedActors: string extends TActor['src'] ? Record<keyof Prop<TTypesMeta, 'eventsCausingActors'>, {
+                logic: AnyActorLogic;
+            }> : IndexByProp<TActor, 'src'>;
+            indexedEvents: MergeWithInternalEvents<IndexByType<(string extends TEvent['type'] ? never : TEvent) | GenerateActorEvents<TActor, Prop<TTypesMeta, 'invokeSrcNameMap'>>>, Prop<TTypesMeta, 'internalEvents'>>;
         };
         disabled: TypegenDisabled & AllImplementationsProvided & AllowAllEvents & {
             indexedActions: IndexByType<TAction>;
-            indexedEvents: Record<string, TEvent> & {
-                __XSTATE_ALLOW_ANY_INVOKE_OUTPUT_HACK__: {
-                    output: any;
-                };
-            };
-            invokeSrcNameMap: Record<string, '__XSTATE_ALLOW_ANY_INVOKE_OUTPUT_HACK__'>;
+            indexedActors: IndexByProp<TActor, 'src'>;
+            indexedEvents: Record<string, TEvent>;
+            invokeSrcNameMap: Record<string, string>;
         };
     }[IsNever<TTypesMeta> extends true ? 'disabled' : TTypesMeta extends TypegenEnabled ? 'enabled' : 'disabled'];
 }