xstate 5.0.0-beta.20 → 5.0.0-beta.21

package/dist/{actions-069d9805.cjs.js → actions-c619a105.cjs.js}

@@ -2,6 +2,18 @@
 
 var dev_dist_xstateDev = require('../dev/dist/xstate-dev.cjs.js');
 
+/**
+ * `T | unknown` reduces to `unknown` and that can be problematic when it comes to contextual typing.
+ * It especially is a problem when the union has a function member, like here:
+ *
+ * ```ts
+ * declare function test(cbOrVal: ((arg: number) => unknown) | unknown): void;
+ * test((arg) => {}) // oops, implicit any
+ * ```
+ *
+ * This type can be used to avoid this problem. This union represents the same value space as `unknown`.
+ */
+
 // https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
 
 /**
@@ -406,27 +418,15 @@ function toArray(value) {
   }
   return toArrayStrict(value);
 }
-function mapContext(mapper, context, event) {
+function mapContext(mapper, context, event, self) {
   if (typeof mapper === 'function') {
     return mapper({
       context,
-      event
+      event,
+      self
     });
   }
-  const result = {};
-  const args = {
-    context,
-    event
-  };
-  for (const key of Object.keys(mapper)) {
-    const subMapper = mapper[key];
-    if (typeof subMapper === 'function') {
-      result[key] = subMapper(args);
-    } else {
-      result[key] = subMapper;
-    }
-  }
-  return result;
+  return mapper;
 }
 function isPromiseLike(value) {
   if (value instanceof Promise) {
@@ -478,13 +478,12 @@ function toInvokeConfig(invocable, id) {
   };
 }
 function toObserver(nextHandler, errorHandler, completionHandler) {
-  const noop = () => {};
   const isObserver = typeof nextHandler === 'object';
-  const self = isObserver ? nextHandler : null;
+  const self = isObserver ? nextHandler : undefined;
   return {
-    next: ((isObserver ? nextHandler.next : nextHandler) || noop).bind(self),
-    error: ((isObserver ? nextHandler.error : errorHandler) || noop).bind(self),
-    complete: ((isObserver ? nextHandler.complete : completionHandler) || noop).bind(self)
+    next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
+    error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
+    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
   };
 }
 function createInvokeId(stateNodeId, index) {
@@ -498,7 +497,7 @@ function resolveReferencedActor(referenced) {
 }
 
 function fromCallback(invokeCallback) {
-  const logic = {
+  return {
     config: invokeCallback,
     start: (_state, {
       self
@@ -564,19 +563,20 @@ function fromCallback(invokeCallback) {
     },
     getSnapshot: () => undefined,
     getPersistedState: ({
-      input
-    }) => input
+      input,
+      canceled
+    }) => ({
+      input,
+      canceled
+    })
   };
-  return logic;
 }
 
 function fromObservable(observableCreator) {
   const nextEventType = '$$xstate.next';
   const errorEventType = '$$xstate.error';
   const completeEventType = '$$xstate.complete';
-
-  // TODO: add event types
-  const logic = {
+  return {
     config: observableCreator,
     transition: (state, event, {
       self,
@@ -606,6 +606,7 @@ function fromObservable(observableCreator) {
             status: 'error',
             input: undefined,
             data: event.data,
+            // TODO: if we keep this as `data` we should reflect this in the type
             subscription: undefined
           };
         case completeEventType:
@@ -683,7 +684,6 @@ function fromObservable(observableCreator) {
       subscription: undefined
     })
   };
-  return logic;
 }
 
 /**
@@ -700,7 +700,7 @@ function fromEventObservable(lazyObservable) {
   const completeEventType = '$$xstate.complete';
 
   // TODO: event types
-  const logic = {
+  return {
     config: lazyObservable,
     transition: (state, event) => {
       if (state.status !== 'active') {
@@ -713,6 +713,7 @@ function fromEventObservable(lazyObservable) {
             status: 'error',
             input: undefined,
             data: event.data,
+            // TODO: if we keep this as `data` we should reflect this in the type
             subscription: undefined
           };
         case completeEventType:
@@ -787,7 +788,6 @@ function fromEventObservable(lazyObservable) {
       subscription: undefined
     })
   };
-  return logic;
 }
 
 const resolveEventType = '$$xstate.resolve';
@@ -815,6 +815,7 @@ promiseCreator) {
             ...state,
             status: 'error',
             data: event.data,
+            // TODO: if we keep this as `data` we should reflect this in the type
             input: undefined
           };
         case stopSignalType:
@@ -924,6 +925,19 @@ function createEmptyActor() {
   return interpret(emptyLogic);
 }
 
+/**
+ * This function makes sure that unhandled errors are thrown in a separate macrotask.
+ * It allows those errors to be detected by global error handlers and reported to bug tracking services
+ * without interrupting our own stack of execution.
+ *
+ * @param err error to be thrown
+ */
+function reportUnhandledError(err) {
+  setTimeout(() => {
+    throw err;
+  });
+}
+
 function createSystem() {
   let sessionIdCounter = 0;
   const children = new Map();
@@ -1092,29 +1106,38 @@ class Interpreter {
       deferredFn();
     }
     for (const observer of this.observers) {
-      observer.next?.(snapshot);
+      // TODO: should observers be notified in case of the error?
+      try {
+        observer.next?.(snapshot);
+      } catch (err) {
+        reportUnhandledError(err);
+      }
     }
     const status = this.logic.getStatus?.(state);
     switch (status?.status) {
       case 'done':
         this._stopProcedure();
+        this._complete();
         this._doneEvent = doneInvoke(this.id, status.data);
         this._parent?.send(this._doneEvent);
-        this._complete();
         break;
       case 'error':
         this._stopProcedure();
-        this._parent?.send(error(this.id, status.data));
         this._error(status.data);
+        this._parent?.send(error(this.id, status.data));
         break;
     }
   }
   subscribe(nextListenerOrObserver, errorListener, completeListener) {
     const observer = toObserver(nextListenerOrObserver, errorListener, completeListener);
-    this.observers.add(observer);
-    if (this.status === ActorStatus.Stopped) {
-      observer.complete?.();
-      this.observers.delete(observer);
+    if (this.status !== ActorStatus.Stopped) {
+      this.observers.add(observer);
+    } else {
+      try {
+        observer.complete?.();
+      } catch (err) {
+        reportUnhandledError(err);
+      }
     }
     return {
       unsubscribe: () => {
@@ -1136,8 +1159,26 @@ class Interpreter {
       this.system._set(this._systemId, this);
     }
     this.status = ActorStatus.Running;
+    const status = this.logic.getStatus?.(this._state);
+    switch (status?.status) {
+      case 'done':
+        // a state machine can be "done" upon intialization (it could reach a final state using initial microsteps)
+        // we still need to complete observers, flush deferreds etc
+        this.update(this._state);
+      // fallthrough
+      case 'error':
+        // TODO: rethink cleanup of observers, mailbox, etc
+        return this;
+    }
     if (this.logic.start) {
-      this.logic.start(this._state, this._actorContext);
+      try {
+        this.logic.start(this._state, this._actorContext);
+      } catch (err) {
+        this._stopProcedure();
+        this._error(err);
+        this._parent?.send(error(this.id, err));
+        return this;
+      }
     }
 
     // TODO: this notifies all subscribers but usually this is redundant
@@ -1151,23 +1192,30 @@ class Interpreter {
     return this;
   }
   _process(event) {
+    // TODO: reexamine what happens when an action (or a guard or smth) throws
+    let nextState;
+    let caughtError;
     try {
-      const nextState = this.logic.transition(this._state, event, this._actorContext);
-      this.update(nextState);
-      if (event.type === stopSignalType) {
-        this._stopProcedure();
-        this._complete();
-      }
+      nextState = this.logic.transition(this._state, event, this._actorContext);
     } catch (err) {
-      // TODO: properly handle errors
-      if (this.observers.size > 0) {
-        this.observers.forEach(observer => {
-          observer.error?.(err);
-        });
-        this.stop();
-      } else {
-        throw err;
-      }
+      // we wrap it in a box so we can rethrow it later even if falsy value gets caught here
+      caughtError = {
+        err
+      };
+    }
+    if (caughtError) {
+      const {
+        err
+      } = caughtError;
+      this._stopProcedure();
+      this._error(err);
+      this._parent?.send(error(this.id, err));
+      return;
+    }
+    this.update(nextState);
+    if (event.type === stopSignalType) {
+      this._stopProcedure();
+      this._complete();
     }
   }
   _stop() {
@@ -1196,15 +1244,35 @@ class Interpreter {
   }
   _complete() {
     for (const observer of this.observers) {
-      observer.complete?.();
+      try {
+        observer.complete?.();
+      } catch (err) {
+        reportUnhandledError(err);
+      }
     }
     this.observers.clear();
   }
-  _error(data) {
+  _error(err) {
+    if (!this.observers.size) {
+      if (!this._parent) {
+        reportUnhandledError(err);
+      }
+      return;
+    }
+    let reportError = false;
     for (const observer of this.observers) {
-      observer.error?.(data);
+      const errorListener = observer.error;
+      reportError ||= !errorListener;
+      try {
+        errorListener?.(err);
+      } catch (err2) {
+        reportUnhandledError(err2);
+      }
     }
     this.observers.clear();
+    if (reportError) {
+      reportUnhandledError(err);
+    }
   }
   _stopProcedure() {
     if (this.status !== ActorStatus.Running) {
@@ -1526,10 +1594,10 @@ function toGuardDefinition(guardConfig, getPredicate) {
   }
 }
 
-function getOutput(configuration, context, event) {
+function getOutput(configuration, context, event, self) {
   const machine = configuration[0].machine;
   const finalChildStateNode = configuration.find(stateNode => stateNode.type === 'final' && stateNode.parent === machine.root);
-  return finalChildStateNode && finalChildStateNode.output ? mapContext(finalChildStateNode.output, context, event) : undefined;
+  return finalChildStateNode && finalChildStateNode.output ? mapContext(finalChildStateNode.output, context, event, self) : undefined;
 }
 const isAtomicStateNode = stateNode => stateNode.type === 'atomic' || stateNode.type === 'final';
 function getChildren(stateNode) {
@@ -2145,7 +2213,7 @@ function microstepProcedure(transitions, currentState, mutConfiguration, event,
   actions.push(...filteredTransitions.flatMap(t => t.actions));
 
   // Enter states
-  enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue, isInitial);
+  enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue, isInitial, actorCtx);
   const nextConfiguration = [...mutConfiguration];
   const done = isInFinalState(nextConfiguration);
   if (done) {
@@ -2154,7 +2222,7 @@ function microstepProcedure(transitions, currentState, mutConfiguration, event,
   }
   try {
     const nextState = resolveActionsAndContext(actions, event, currentState, actorCtx);
-    const output = done ? getOutput(nextConfiguration, nextState.context, event) : undefined;
+    const output = done ? getOutput(nextConfiguration, nextState.context, event, actorCtx.self) : undefined;
     internalQueue.push(...nextState._internalQueue);
     return cloneState(currentState, {
       configuration: nextConfiguration,
@@ -2171,7 +2239,7 @@ function microstepProcedure(transitions, currentState, mutConfiguration, event,
     throw e;
   }
 }
-function enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue, isInitial) {
+function enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue, isInitial, actorContext) {
   const statesToEnter = new Set();
   const statesForDefaultEntry = new Set();
   computeEntrySet(filteredTransitions, historyValue, statesForDefaultEntry, statesToEnter);
@@ -2199,7 +2267,7 @@ function enterStates(event, filteredTransitions, mutConfiguration, actions, inte
       if (!parent.parent) {
         continue;
       }
-      internalQueue.push(done(parent.id, stateNodeToEnter.output ? mapContext(stateNodeToEnter.output, currentState.context, event) : undefined));
+      internalQueue.push(done(parent.id, stateNodeToEnter.output ? mapContext(stateNodeToEnter.output, currentState.context, event, actorContext.self) : undefined));
       if (parent.parent) {
         const grandparent = parent.parent;
         if (grandparent.type === 'parallel') {
@@ -2519,6 +2587,7 @@ class State {
     this.value = void 0;
     this.done = void 0;
     this.output = void 0;
+    this.error = void 0;
     this.context = void 0;
     this.historyValue = {};
     this._internalQueue = void 0;
@@ -2535,6 +2604,7 @@ class State {
     this.tags = new Set(flatten(this.configuration.map(sn => sn.tags)));
     this.done = config.done ?? false;
     this.output = config.output;
+    this.error = config.error;
   }
 
   /**
@@ -2996,6 +3066,7 @@ exports.and = and;
 exports.assign = assign;
 exports.cancel = cancel;
 exports.choose = choose;
+exports.cloneState = cloneState;
 exports.constantPrefixes = constantPrefixes;
 exports.createEmptyActor = createEmptyActor;
 exports.createInitEvent = createInitEvent;

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

@@ -1,4 +1,4 @@
-import { MachineConfig, EventObject, AnyEventObject, MachineContext, InternalMachineImplementations, ParameterizedObject, ProvidedActor } from "./types.js";
+import { MachineConfig, EventObject, MachineContext, InternalMachineImplementations, ParameterizedObject, ProvidedActor, AnyEventObject } from "./types.js";
 import { TypegenConstraint, TypegenDisabled, ResolveTypegenMeta } from "./typegenTypes.js";
 import { StateMachine } from "./StateMachine.js";
-export declare function createMachine<TContext extends MachineContext, TEvent extends EventObject = AnyEventObject, TActor extends ProvidedActor = ProvidedActor, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, ParameterizedObject, TActor, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, TEvent, ParameterizedObject, TActor, ResolveTypegenMeta<TTypesMeta, TEvent, ParameterizedObject, TActor>>): StateMachine<TContext, TEvent, ParameterizedObject, TActor, ResolveTypegenMeta<TTypesMeta, TEvent, ParameterizedObject, TActor>>;
+export declare function createMachine<TContext extends MachineContext, TEvent extends EventObject = AnyEventObject, TActor extends ProvidedActor = ProvidedActor, TInput = any, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, ParameterizedObject, TActor, TInput, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, TEvent, ParameterizedObject, TActor, ResolveTypegenMeta<TTypesMeta, TEvent, ParameterizedObject, TActor>>): StateMachine<TContext, TEvent, ParameterizedObject, TActor, TInput, ResolveTypegenMeta<TTypesMeta, TEvent, ParameterizedObject, TActor>>;

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

@@ -1,14 +1,10 @@
 import type { StateNode } from "./StateNode.js";
 import { TypegenDisabled, TypegenEnabled } from "./typegenTypes.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 ComputeConcreteChildren<TActor extends ProvidedActor> = {
+    [A in TActor as 'id' extends keyof A ? A['id'] & string : never]?: ActorRefFrom<A['logic']>;
 };
-type ComputeChildren<TActor extends ProvidedActor> = string extends TActor['src'] ? Record<string, AnyActorRef> : Compute<ComputeConcreteChildren<Extract<TActor, {
-    id: string;
-}>> & (undefined extends TActor['id'] ? {
+type ComputeChildren<TActor extends ProvidedActor> = string extends TActor['src'] ? Record<string, AnyActorRef> : Compute<ComputeConcreteChildren<TActor> & (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>;
@@ -28,6 +24,7 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
      * The done data of the top-level finite state.
      */
     output: any;
+    error: unknown;
     context: TContext;
     historyValue: Readonly<HistoryValue<TContext, TEvent>>;
     _internalQueue: Array<TEvent>;

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, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext, ProvidedActor, Equals } from "./types.js";
+import type { ActorContext, ActorLogic, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext, ProvidedActor, Equals, TODO } 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, 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>>> {
+export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TAction extends ParameterizedObject, TActor extends ProvidedActor, TInput, 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>>, TODO, TInput, TODO> {
     /**
      * 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, TActor>;
+    types: MachineTypes<TContext, TEvent, TActor, TInput>;
     __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, TAction, TActor, TResolvedTypesMeta, true>): StateMachine<TContext, TEvent, TAction, TActor, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
+    provide(implementations: InternalMachineImplementations<TContext, TEvent, TAction, TActor, TResolvedTypesMeta, true>): StateMachine<TContext, TEvent, TAction, TActor, TInput, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
     /**
      * Resolves the given `state` to a new `State` instance relative to this machine.
      *
@@ -70,8 +70,8 @@ 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, 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;
+    getInitialState(actorCtx: ActorContext<TEvent, State<TContext, TEvent, TActor, TResolvedTypesMeta>>, input?: TInput): State<TContext, TEvent, TActor, TResolvedTypesMeta>;
+    start(state: State<TContext, TEvent, TActor, TResolvedTypesMeta>): void;
     getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
     get definition(): StateMachineDefinition<TContext, TEvent>;
     toJSON(): StateMachineDefinition<TContext, TEvent>;
@@ -95,4 +95,5 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
     __TActor: TActor;
     /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TResolvedTypesMeta: TResolvedTypesMeta;
+    __TInput: TInput;
 }

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, TODO } from "./types.js";
+import type { Action, DelayedTransitionDefinition, EventObject, InitialTransitionDefinition, InvokeDefinition, MachineContext, Mapper, StateNodeConfig, StateNodeDefinition, StateNodesConfig, TransitionDefinition, TransitionDefinitionMap, TODO } from "./types.js";
 interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
     _key: string;
     _parent?: StateNode<TContext, TEvent>;
@@ -59,7 +59,7 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     /**
      * The root machine node.
      */
-    machine: StateMachine<TContext, TEvent, any, any>;
+    machine: StateMachine<TContext, TEvent, any, any, TODO, TODO>;
     /**
      * The meta data associated with this state node, which will be returned in State instances.
      */
@@ -67,7 +67,7 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     /**
      * The output data sent with the "done.state._id_" event if this is a final state node.
      */
-    output?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
+    output?: Mapper<TContext, TEvent, any>;
     /**
      * The order this state node appears. Corresponds to the implicit document order.
      */

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").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>>>;
+    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 ____, 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 ____, 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>;
-}): (ActorRef<any, any> | AnyState)[];
+}): (AnyState | ActorRef<any, any>)[];
 declare function execute(actorContext: AnyActorContext, actorRef: ActorRef<any, any> | undefined): void;
 /**
  * Stops an actor.

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

@@ -36,7 +36,7 @@ export declare function done(id: string, output?: any): DoneEventObject;
  */
 export declare function doneInvoke(invokeId: string, output?: any): DoneEvent;
 export declare function error(id: string, data?: any): ErrorPlatformEvent & string;
-export declare function createInitEvent(input: any): {
+export declare function createInitEvent(input: unknown): {
     readonly type: "xstate.init";
-    readonly input: any;
+    readonly input: unknown;
 };

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

@@ -1,12 +1,12 @@
 import { ActorLogic, EventObject, AnyActorSystem, AnyEventObject, ActorSystem, ActorRefFrom } from "../types.js";
-export interface CallbackInternalState<TEvent extends EventObject> {
+export interface CallbackInternalState<TEvent extends EventObject, TInput = unknown> {
     canceled: boolean;
     receivers: Set<(e: TEvent) => void>;
     dispose: void | (() => void) | Promise<any>;
-    input?: any;
+    input: TInput;
 }
-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 type CallbackActorLogic<TEvent extends EventObject, TInput = unknown> = ActorLogic<TEvent, undefined, CallbackInternalState<TEvent, TInput>, Pick<CallbackInternalState<TEvent, TInput>, 'input' | 'canceled'>, ActorSystem<any>, TInput, any>;
+export type CallbackActorRef<TEvent extends EventObject, TInput = unknown> = ActorRefFrom<CallbackActorLogic<TEvent, TInput>>;
 export type Receiver<TEvent extends EventObject> = (listener: {
     bivarianceHack(event: TEvent): void;
 }['bivarianceHack']) => void;

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

@@ -1,12 +1,15 @@
 import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem, ActorRefFrom } from "../types.js";
-export interface ObservableInternalState<T> {
+export interface ObservableInternalState<T, TInput = unknown> {
     subscription: Subscription | undefined;
     status: 'active' | 'done' | 'error' | 'canceled';
     data: T | undefined;
-    input?: any;
+    input: TInput | undefined;
 }
-export type ObservablePersistedState<T> = Omit<ObservableInternalState<T>, 'subscription'>;
-export type ObservableActorLogic<T, TInput> = ActorLogic<EventObject, T | undefined, ObservableInternalState<T>, ObservablePersistedState<T>, AnyActorSystem, TInput>;
+export type ObservablePersistedState<T, TInput = unknown> = Omit<ObservableInternalState<T, TInput>, 'subscription'>;
+export type ObservableActorLogic<T, TInput> = ActorLogic<{
+    type: string;
+    [k: string]: unknown;
+}, T | undefined, ObservableInternalState<T, TInput>, ObservablePersistedState<T, TInput>, AnyActorSystem, TInput>;
 export type ObservableActorRef<T> = ActorRefFrom<ObservableActorLogic<T, any>>;
 export declare function fromObservable<T, TInput>(observableCreator: ({ input, system }: {
     input: TInput;

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

@@ -1,8 +1,8 @@
 import { ActorLogic, ActorRefFrom, ActorSystem, AnyActorSystem } from "../types.js";
-export interface PromiseInternalState<T> {
+export interface PromiseInternalState<T, TInput = unknown> {
     status: 'active' | 'error' | 'done' | 'canceled';
     data: T | undefined;
-    input?: any;
+    input: TInput | undefined;
 }
 declare const resolveEventType = "$$xstate.resolve";
 declare const rejectEventType = "$$xstate.reject";
@@ -18,8 +18,8 @@ export type PromiseActorEvents<T> = {
 export type PromiseActorLogic<T, TInput = unknown> = ActorLogic<{
     type: string;
     [k: string]: unknown;
-}, T | undefined, PromiseInternalState<T>, // internal state
-PromiseInternalState<T>, // persisted state
+}, T | undefined, PromiseInternalState<T, TInput>, // internal state
+PromiseInternalState<T, TInput>, // persisted state
 ActorSystem<any>, TInput, // input
 T>;
 export type PromiseActorRef<T> = ActorRefFrom<PromiseActorLogic<T>>;