xstate 5.0.0-alpha.1 → 5.0.0-alpha.3

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

@@ -1,5 +1,5 @@
 import type { BaseActionObject, BaseDynamicActionObject, BuiltInActionObject, EventObject, MachineContext } from '../src/types';
-export declare function createDynamicAction<TContext extends MachineContext, TEvent extends EventObject, TAction extends BaseActionObject, TDynamicParams extends Record<string, any>>(action: BuiltInActionObject & {
+export declare function createDynamicAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TAction extends BaseActionObject, TDynamicParams extends Record<string, any>>(action: BuiltInActionObject & {
     params: TDynamicParams;
-}, resolve: BaseDynamicActionObject<TContext, TEvent, TAction, TDynamicParams>['resolve']): BaseDynamicActionObject<TContext, TEvent, TAction, TDynamicParams>;
-export declare function isDynamicAction(action: any): action is BaseDynamicActionObject<any, any, any, any>;
+}, resolve: BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, TAction, TDynamicParams>['resolve']): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, TAction, TDynamicParams>;
+export declare function isDynamicAction(action: any): action is BaseDynamicActionObject<any, any, any, any, any>;

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

@@ -1,4 +1,4 @@
-import { MachineConfig, EventObject, AnyEventObject, MachineContext, ActorMap, InternalMachineImplementations, BaseActionObject } from './types';
-import { TypegenConstraint, TypegenDisabled, ResolveTypegenMeta } from './typegenTypes';
-import { StateMachine } from './StateMachine';
-export declare function createMachine<TContext extends MachineContext, TEvent extends EventObject = AnyEventObject, TActorMap extends ActorMap = ActorMap, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, BaseActionObject, TActorMap, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, BaseActionObject, TActorMap>>): StateMachine<TContext, TEvent, BaseActionObject, TActorMap, ResolveTypegenMeta<TTypesMeta, TEvent, BaseActionObject, TActorMap>>;
+import { MachineConfig, EventObject, AnyEventObject, MachineContext, ActorMap, InternalMachineImplementations, ParameterizedObject } 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, TActorMap extends ActorMap = ActorMap, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, ParameterizedObject, TActorMap, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, TEvent, ResolveTypegenMeta<TTypesMeta, TEvent, ParameterizedObject, TActorMap>>): StateMachine<TContext, TEvent, ParameterizedObject, TActorMap, ResolveTypegenMeta<TTypesMeta, TEvent, ParameterizedObject, TActorMap>>;

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

@@ -1,4 +1,4 @@
-import { Clock } from './interpreter';
+import { Clock } from './interpreter.js';
 export interface SimulatedClock extends Clock {
     start(speed: number): void;
     increment(ms: number): void;

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

@@ -1,6 +1,6 @@
-import type { StateNode } from './StateNode';
-import { TypegenDisabled, TypegenEnabled } from './typegenTypes';
-import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, Prop, SCXML, StateConfig, StateValue, TransitionDefinition } from './types';
+import type { StateNode } from './StateNode.js';
+import { TypegenDisabled, TypegenEnabled } from './typegenTypes.js';
+import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, SCXML, StateConfig, StateValue, TransitionDefinition } from './types.js';
 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.
@@ -8,6 +8,7 @@ export declare function isStateConfig<TContext extends MachineContext, TEvent ex
 export declare const isState: typeof isStateConfig;
 export declare class State<TContext extends MachineContext, TEvent extends EventObject = EventObject, TResolvedTypesMeta = TypegenDisabled> {
     machine: AnyStateMachine;
+    tags: Set<string>;
     value: StateValue;
     /**
      * Indicates whether the state is a final state.
@@ -23,7 +24,6 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
     event: TEvent;
     _internalQueue: Array<SCXML.Event<TEvent>>;
     _event: SCXML.Event<TEvent>;
-    _sessionid: string | undefined;
     _initial: boolean;
     /**
      * Indicates whether the state has changed from the previous state. A state is considered "changed" if:
@@ -64,7 +64,7 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
      * @param delimiter The character(s) that separate each subpath in the string state node path.
      */
     toStrings(stateValue?: StateValue, delimiter?: string): string[];
-    toJSON(): Omit<this, "nextEvents" | "meta" | "toJSON" | "configuration" | "transitions" | "tags" | "machine" | "toStrings" | "matches" | "hasTag" | "can"> & {
+    toJSON(): Omit<this, "meta" | "toJSON" | "configuration" | "transitions" | "tags" | "machine" | "toStrings" | "matches" | "hasTag" | "can" | "nextEvents"> & {
         tags: string[];
         meta: Record<string, any>;
     };
@@ -92,6 +92,6 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
      */
     get nextEvents(): Array<TEvent['type']>;
     get meta(): Record<string, any>;
-    get tags(): Set<string>;
 }
 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>;

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

@@ -1,17 +1,16 @@
-import { State } from './State';
-import { StateNode } from './StateNode';
-import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from './typegenTypes';
-import type { ActorContext, ActorMap, BaseActionObject, Behavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineSchema, MaybeLazy, NoInfer, SCXML, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition } from './types';
+import { State } from './State.js';
+import { StateNode } from './StateNode.js';
+import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from './typegenTypes.js';
+import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineSchema, NoInfer, SCXML, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, AnyActorContext, PersistedMachineState, ParameterizedObject } from './types.js';
 export declare const NULL_EVENT = "";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";
-export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject = EventObject, TAction extends BaseActionObject = BaseActionObject, TActorMap extends ActorMap = ActorMap, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TAction, TActorMap>> implements Behavior<TEvent | SCXML.Event<TEvent>, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>> {
+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 ActorBehavior<TEvent | SCXML.Event<TEvent>, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>> {
     /**
      * The raw config used to create the machine.
      */
     config: MachineConfig<TContext, TEvent, any, any, any>;
-    private _contextFactory;
-    get context(): TContext;
+    getContext(input?: any): TContext;
     private getContextAndActions;
     /**
      * The machine's own version.
@@ -43,17 +42,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> & {
-        context?: MaybeLazy<Partial<TContext>>;
-    }): StateMachine<TContext, TEvent, TAction, TActorMap, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
-    /**
-     * Clones this state machine with custom `context`.
-     *
-     * The `context` provided can be partial `context`, which will be combined with the original `context`.
-     *
-     * @param context Custom context (will override predefined context, not recursive)
-     */
-    withContext(context: Partial<TContext>): this;
+    provide(implementations: InternalMachineImplementations<TContext, TEvent, TResolvedTypesMeta, true>): StateMachine<TContext, TEvent, TAction, TActorMap, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
     /**
      * Resolves the given `state` to a new `State` instance relative to this machine.
      *
@@ -78,7 +67,7 @@ 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> | undefined, event: TEvent | SCXML.Event<TEvent>, actorCtx?: ActorContext<any, any> | undefined): Array<State<TContext, TEvent, TResolvedTypesMeta>>;
+    microstep(state: State<TContext, TEvent, TResolvedTypesMeta> | undefined, event: TEvent | SCXML.Event<TEvent>, actorCtx?: AnyActorContext | undefined): Array<State<TContext, TEvent, TResolvedTypesMeta>>;
     getTransitionData(state: State<TContext, TEvent, TResolvedTypesMeta>, _event: SCXML.Event<TEvent>): Array<TransitionDefinition<TContext, TEvent>>;
     /**
      * The initial state _before_ evaluating any microsteps.
@@ -93,11 +82,12 @@ 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>>): State<TContext, TEvent, TResolvedTypesMeta>;
-    start(state: State<TContext, TEvent, TResolvedTypesMeta>, actorCtx: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>): State<TContext, TEvent, TResolvedTypesMeta>;
+    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;
     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>): {
         status: string;
@@ -106,7 +96,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
         status: string;
         data?: undefined;
     };
-    restoreState(state: State<TContext, TEvent, TResolvedTypesMeta>, _actorCtx?: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>): State<TContext, TEvent, TResolvedTypesMeta>;
+    restoreState(state: PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>, _actorCtx: ActorContext<TEvent, State<TContext, TEvent, TResolvedTypesMeta>>): State<TContext, TEvent, 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 */

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

@@ -1,6 +1,6 @@
-import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, SCXML, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from './types';
-import type { State } from './State';
-import type { StateMachine } from './StateMachine';
+import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, SCXML, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from './types.js';
+import type { State } from './State.js';
+import type { StateMachine } from './StateMachine.js';
 interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
     _key: string;
     _parent?: StateNode<TContext, TEvent>;

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

@@ -1,4 +1,4 @@
-import { ActionTypes } from './types';
+import { ActionTypes } from './types.js';
 export declare const stop = ActionTypes.Stop;
 export declare const raise = ActionTypes.Raise;
 export declare const send = ActionTypes.Send;

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

@@ -1,7 +1,7 @@
-import type { EventObject, Assigner, PropertyAssigner, MachineContext, DynamicAssignAction } from '../types';
+import type { EventObject, Assigner, PropertyAssigner, MachineContext, DynamicAssignAction, LowInfer } from '../types.js';
 /**
  * Updates the current context of the machine.
  *
  * @param assignment An object that represents the partial context to update.
  */
-export declare function assign<TContext extends MachineContext, TEvent extends EventObject = EventObject, TAssignment extends Assigner<TContext, TEvent> | PropertyAssigner<TContext, TEvent> = Assigner<TContext, TEvent> | PropertyAssigner<TContext, TEvent>>(assignment: TAssignment): DynamicAssignAction<TContext, TEvent>;
+export declare function assign<TContext extends MachineContext, TExpressionEvent extends EventObject = EventObject, TEvent extends EventObject = TExpressionEvent>(assignment: Assigner<LowInfer<TContext>, TExpressionEvent, TEvent> | PropertyAssigner<LowInfer<TContext>, TExpressionEvent, TEvent>): DynamicAssignAction<TContext, TExpressionEvent, TEvent>;

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

@@ -1,5 +1,5 @@
-import { EventObject, ExprWithMeta, MachineContext } from '../types';
-import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject } from '..';
+import { EventObject, ExprWithMeta, MachineContext } from '../types.js';
+import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject } from '../index.js';
 /**
  * Cancels an in-flight `send(...)` action. A canceled sent action will not
  * be executed, nor will its event be sent, unless it has already been sent
@@ -7,4 +7,4 @@ import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject
  *
  * @param sendId The `id` of the `send(...)` action to cancel.
  */
-export declare function cancel<TContext extends MachineContext, TEvent extends EventObject>(sendId: string | ExprWithMeta<TContext, TEvent, string>): BaseDynamicActionObject<TContext, TEvent, CancelActionObject, DynamicCancelActionObject<TContext, TEvent>['params']>;
+export declare function cancel<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(sendId: string | ExprWithMeta<TContext, TExpressionEvent, string>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, CancelActionObject, DynamicCancelActionObject<TContext, TExpressionEvent>['params']>;

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

@@ -1,3 +1,3 @@
-import { EventObject, ChooseCondition, MachineContext } from '../types';
-import { BaseDynamicActionObject, ChooseAction, ResolvedChooseAction } from '..';
-export declare function choose<TContext extends MachineContext, TEvent extends EventObject>(guards: Array<ChooseCondition<TContext, TEvent>>): BaseDynamicActionObject<TContext, TEvent, ResolvedChooseAction, ChooseAction<TContext, TEvent>['params']>;
+import { EventObject, ChooseCondition, MachineContext } from '../types.js';
+import { BaseDynamicActionObject, ChooseAction, ResolvedChooseAction } from '../index.js';
+export declare function choose<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(guards: Array<ChooseCondition<TContext, TExpressionEvent>>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, ResolvedChooseAction, ChooseAction<TContext, TExpressionEvent>['params']>;

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

@@ -1,3 +1,3 @@
-import { EventObject, InvokeDefinition, MachineContext } from '../types';
-import { BaseDynamicActionObject, DynamicInvokeActionObject, InvokeActionObject } from '..';
-export declare function invoke<TContext extends MachineContext, TEvent extends EventObject>(invokeDef: InvokeDefinition<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, InvokeActionObject, DynamicInvokeActionObject<TContext, TEvent>['params']>;
+import { EventObject, InvokeDefinition, MachineContext } from '../types.js';
+import { BaseDynamicActionObject, DynamicInvokeActionObject, InvokeActionObject } from '../index.js';
+export declare function invoke<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(invokeDef: InvokeDefinition<TContext, TEvent>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, InvokeActionObject, DynamicInvokeActionObject<TContext, TEvent>['params']>;

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

@@ -1,5 +1,5 @@
-import { EventObject, LogExpr, MachineContext, LogActionObject } from '../types';
-import { BaseDynamicActionObject, DynamicLogAction } from '..';
+import { EventObject, LogExpr, MachineContext, LogActionObject } from '../types.js';
+import { BaseDynamicActionObject, DynamicLogAction } from '../index.js';
 /**
  *
  * @param expr The expression function to evaluate which will be logged.
@@ -8,4 +8,4 @@ import { BaseDynamicActionObject, DynamicLogAction } from '..';
  *  - `event` - the event that caused this action to be executed.
  * @param label The label to give to the logged expression.
  */
-export declare function log<TContext extends MachineContext, TEvent extends EventObject>(expr?: string | LogExpr<TContext, TEvent>, label?: string): BaseDynamicActionObject<TContext, TEvent, LogActionObject, DynamicLogAction<TContext, TEvent>['params']>;
+export declare function log<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent>(expr?: string | LogExpr<TContext, TExpressionEvent>, label?: string): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, LogActionObject, DynamicLogAction<TContext, TExpressionEvent, TEvent>['params']>;

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

@@ -1,3 +1,6 @@
-import { EventObject, SingleOrArray, MachineContext } from '../types';
+import { EventObject, SingleOrArray, MachineContext } from '../types.js';
 import { BaseActionObject, BaseDynamicActionObject, DynamicPureActionObject, PureActionObject } from '..';
-export declare function pure<TContext extends MachineContext, TEvent extends EventObject>(getActions: (context: TContext, event: TEvent) => SingleOrArray<BaseActionObject> | undefined): BaseDynamicActionObject<TContext, TEvent, PureActionObject, DynamicPureActionObject<TContext, TEvent>['params']>;
+export declare function pure<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent>(getActions: ({ context, event }: {
+    context: TContext;
+    event: TExpressionEvent;
+}) => SingleOrArray<BaseActionObject | string> | undefined): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, PureActionObject, DynamicPureActionObject<TContext, TExpressionEvent>['params']>;

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

@@ -1,9 +1,8 @@
-import { EventObject, RaiseActionObject } from '../types';
-import { BaseDynamicActionObject } from '..';
+import { EventObject, MachineContext, RaiseActionObject, BaseDynamicActionObject, RaiseActionOptions, SendExpr, RaiseActionParams, NoInfer } from '../types.js';
 /**
  * Raises an event. This places the event in the internal event queue, so that
  * the event is immediately consumed by the machine in the current step.
  *
  * @param eventType The event to raise.
  */
-export declare function raise<TEvent extends EventObject>(event: TEvent): BaseDynamicActionObject<any, TEvent, RaiseActionObject<TEvent>, RaiseActionObject<TEvent>['params']>;
+export declare function raise<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent>(eventOrExpr: NoInfer<TEvent> | SendExpr<TContext, TExpressionEvent, NoInfer<TEvent>>, options?: RaiseActionOptions<TContext, TExpressionEvent>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, RaiseActionObject<TContext, TExpressionEvent, TEvent>, RaiseActionParams<TContext, TExpressionEvent, TEvent>>;

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

@@ -1,37 +1,39 @@
-import { EventObject, SendActionParams, SendExpr, AnyEventObject, MachineContext } from '../types';
-import { AnyActorRef, BaseDynamicActionObject, Cast, EventFrom, ExprWithMeta, InferEvent, SendActionObject, SendActionOptions } from '..';
+import { EventObject, SendActionParams, SendExpr, AnyEventObject, MachineContext } from '../types.js';
+import { AnyActorRef, BaseDynamicActionObject, Cast, EventFrom, ExprWithMeta, InferEvent, SendActionObject, SendActionOptions } from '../index.js';
 /**
  * Sends an event. This returns an action that will be read by an interpreter to
  * send the event in the next step, after the current step is finished executing.
  *
- * @param event The event to send.
+ * @deprecated Use the `sendTo(...)` action creator instead.
+ *
+ * @param eventOrExpr The event to send.
  * @param options Options to pass into the send event:
  *  - `id` - The unique send event identifier (used with `cancel()`).
  *  - `delay` - The number of milliseconds to delay the sending of the event.
  *  - `to` - The target of this event (by default, the machine the event was sent from).
  */
-export declare function send<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: TSentEvent | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent>>;
+export declare function send<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(eventOrExpr: TSentEvent | SendExpr<TContext, TEvent, AnyEventObject>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent>>;
 /**
  * Sends an event to this machine's parent.
  *
  * @param event The event to send to the parent machine.
  * @param options Options to pass into the send event.
  */
-export declare function sendParent<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: TSentEvent | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
+export declare function sendParent<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: TSentEvent | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
 /**
  * Sends an event back to the sender of the original event.
  *
  * @param event The event to send back to the sender
  * @param options Options to pass into the send event
  */
-export declare function respond<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: TEvent | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
+export declare function respond<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: TEvent | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
 /**
  * Forwards (sends) an event to a specified service.
  *
  * @param target The target service to forward the event to.
  * @param options Options to pass into the send action creator.
  */
-export declare function forwardTo<TContext extends MachineContext, TEvent extends EventObject>(target: Required<SendActionParams<TContext, TEvent>>['to'], options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
+export declare function forwardTo<TContext extends MachineContext, TEvent extends EventObject>(target: Required<SendActionParams<TContext, TEvent>>['to'], options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
 /**
  * Escalates an error by sending it as an event to this machine's parent.
  *
@@ -39,7 +41,7 @@ export declare function forwardTo<TContext extends MachineContext, TEvent extend
  * takes in the `context`, `event`, and `meta`, and returns the error data to send.
  * @param options Options to pass into the send action creator.
  */
-export declare function escalate<TContext extends MachineContext, TEvent extends EventObject, TErrorData = any>(errorData: TErrorData | ExprWithMeta<TContext, TEvent, TErrorData>, options?: SendActionParams<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
+export declare function escalate<TContext extends MachineContext, TEvent extends EventObject, TErrorData = any>(errorData: TErrorData | ExprWithMeta<TContext, TEvent, TErrorData>, options?: SendActionParams<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
 /**
  * Sends an event to an actor.
  *
@@ -48,4 +50,4 @@ export declare function escalate<TContext extends MachineContext, TEvent extends
  * @param options Send action options
  * @returns An XState send action object
  */
-export declare function sendTo<TContext extends MachineContext, TEvent extends EventObject, TActor extends AnyActorRef>(actor: (ctx: TContext) => TActor, event: EventFrom<TActor> | SendExpr<TContext, TEvent, InferEvent<Cast<EventFrom<TActor>, EventObject>>>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
+export declare function sendTo<TContext extends MachineContext, TEvent extends EventObject, TActor extends AnyActorRef>(actor: TActor | string | ExprWithMeta<TContext, TEvent, TActor | string>, event: EventFrom<TActor> | SendExpr<TContext, TEvent, InferEvent<Cast<EventFrom<TActor>, EventObject>>>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;

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

@@ -1,7 +1,7 @@
-import { ActorRef, BaseDynamicActionObject, DynamicStopActionObject, EventObject, Expr, MachineContext, StopActionObject } from '../types';
+import { ActorRef, BaseDynamicActionObject, DynamicStopActionObject, EventObject, Expr, MachineContext, StopActionObject } from '../types.js';
 /**
  * Stops an actor.
  *
  * @param actorRef The actor to stop.
  */
-export declare function stop<TContext extends MachineContext, TEvent extends EventObject>(actorRef: string | ActorRef<any> | Expr<TContext, TEvent, ActorRef<any> | string>): BaseDynamicActionObject<TContext, TEvent, StopActionObject, DynamicStopActionObject<TContext, TEvent>['params']>;
+export declare function stop<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(actorRef: string | ActorRef<any> | Expr<TContext, TExpressionEvent, ActorRef<any> | string>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, StopActionObject, DynamicStopActionObject<TContext, TExpressionEvent>['params']>;

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

@@ -1,19 +1,19 @@
-import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject, SCXML } from './types';
-import * as actionTypes from './actionTypes';
-export { send, sendTo, sendParent, respond, forwardTo, escalate } from './actions/send';
-export { stop } from './actions/stop';
-export { log } from './actions/log';
-export { cancel } from './actions/cancel';
-export { assign } from './actions/assign';
-export { raise } from './actions/raise';
-export { choose } from './actions/choose';
+import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject, SCXML } from './types.js';
+import * as actionTypes from './actionTypes.js';
+export { send, sendTo, sendParent, respond, forwardTo, escalate } from './actions/send.js';
+export { stop } from './actions/stop.js';
+export { log } from './actions/log.js';
+export { cancel } from './actions/cancel.js';
+export { assign } from './actions/assign.js';
+export { raise } from './actions/raise.js';
+export { choose } from './actions/choose.js';
 export { actionTypes };
 export declare const initEvent: SCXML.Event<{
     type: ActionTypes;
 }>;
 export declare function resolveActionObject(actionObject: BaseActionObject, actionFunctionMap: ActionFunctionMap<any, any>): BaseActionObject;
 export declare function toActionObject<TContext extends MachineContext, TEvent extends EventObject>(action: BaseActionObject | ActionFunction<TContext, TEvent> | string): BaseActionObject;
-export declare const toActionObjects: <TContext extends MachineContext, TEvent extends EventObject>(action?: SingleOrArray<Action<TContext, TEvent>> | undefined) => BaseActionObject[];
+export declare const toActionObjects: <TContext extends MachineContext, TEvent extends EventObject>(action?: SingleOrArray<Action<TContext, TEvent, TEvent>> | undefined) => BaseActionObject[];
 /**
  * Returns an event type that represents an implicit event that
  * is sent after the specified `delay`.
@@ -41,3 +41,7 @@ export declare function done(id: string, data?: any): DoneEventObject;
  */
 export declare function doneInvoke(invokeId: string, data?: any): DoneEvent;
 export declare function error(id: string, data?: any): ErrorPlatformEvent & string;
+export declare function createInitEvent(input: any): SCXML.Event<{
+    type: ActionTypes.Init;
+    input: any;
+}>;

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

@@ -0,0 +1,8 @@
+import { InvokeCallback, ActorBehavior, EventObject } from '../types';
+export interface CallbackInternalState {
+    canceled: boolean;
+    receivers: Set<(e: EventObject) => void>;
+    dispose: void | (() => void) | Promise<any>;
+    input?: any;
+}
+export declare function fromCallback<TEvent extends EventObject>(invokeCallback: InvokeCallback): ActorBehavior<TEvent, undefined>;

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

@@ -0,0 +1,27 @@
+import type { EventObject, ActorRef, BaseActorRef } from '../types.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;
+export declare const stopSignal: StopSignal;
+export interface StartSignal {
+    type: 'xstate.init';
+}
+export interface StopSignal {
+    type: 'xstate.stop';
+}
+export type LifecycleSignal = StartSignal | StopSignal;
+export type LifecycleSignalType = typeof startSignalType | typeof stopSignalType;
+/**
+ * An object that expresses the behavior of an actor in reaction to received events,
+ * as well as an optionally emitted stream of values.
+ *
+ * @template TReceived The received event
+ * @template TSnapshot The emitted value
+ */
+export declare function isSignal(eventType: string): eventType is LifecycleSignalType;
+export declare function isActorRef(item: any): item is ActorRef<any>;
+export declare function toActorRef<TEvent extends EventObject, TSnapshot = any, TActorRefLike extends BaseActorRef<TEvent> = BaseActorRef<TEvent>>(actorRefLike: TActorRefLike): ActorRef<TEvent, TSnapshot> & Omit<TActorRefLike, keyof ActorRef<any, any>>;

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

@@ -0,0 +1,23 @@
+import { Subscribable, ActorBehavior, EventObject, Subscription } from '../types';
+export interface ObservableInternalState<T> {
+    subscription: Subscription | undefined;
+    canceled: boolean;
+    status: 'active' | 'done' | 'error';
+    data: T | undefined;
+    input?: any;
+}
+export type ObservablePersistedState<T> = Omit<ObservableInternalState<T>, 'subscription'>;
+export declare function fromObservable<T, TEvent extends EventObject>(observableCreator: ({ input }: {
+    input: any;
+}) => Subscribable<T>): ActorBehavior<TEvent, T | undefined, ObservableInternalState<T>, ObservablePersistedState<T>>;
+/**
+ * Creates an event observable behavior that listens to an observable
+ * that delivers event objects.
+ *
+ *
+ * @param lazyObservable A function that creates an observable
+ * @returns An event observable behavior
+ */
+export declare function fromEventObservable<T extends EventObject>(lazyObservable: ({ input }: {
+    input: any;
+}) => Subscribable<T>): ActorBehavior<EventObject, T | undefined>;

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

@@ -0,0 +1,12 @@
+import { ActorBehavior } from '../types';
+export interface PromiseInternalState<T> {
+    status: 'active' | 'error' | 'done';
+    canceled: boolean;
+    data: T | undefined;
+    input?: any;
+}
+export declare function fromPromise<T>(promiseCreator: ({ input }: {
+    input: any;
+}) => PromiseLike<T>): ActorBehavior<{
+    type: string;
+}, T | undefined, PromiseInternalState<T>>;

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

@@ -0,0 +1,13 @@
+import { ActorBehavior, ActorContext, ActorSystem, EventObject } from '../types';
+/**
+ * Returns an actor behavior from a transition function and its initial state.
+ *
+ * A transition function is a function that takes the current state and an event and returns the next state.
+ *
+ * @param transition The transition function that returns the next state given the current state and event.
+ * @param initialState The initial state of the transition function.
+ * @returns An actor behavior
+ */
+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 }: {
+    input: any;
+}) => TState)): ActorBehavior<TEvent, TState, TState>;

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

@@ -1,5 +1,5 @@
-import { AnyInterpreter, DevToolsAdapter } from '../types';
-declare type ServiceListener = (service: AnyInterpreter) => void;
+import { AnyInterpreter, DevToolsAdapter } from '../types.js';
+type ServiceListener = (service: AnyInterpreter) => void;
 export interface XStateDevInterface {
     register: (service: AnyInterpreter) => void;
     unregister: (service: AnyInterpreter) => void;

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

@@ -1,5 +1,5 @@
-import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, SCXML, GuardPredicate, MachineContext } from './types';
-import type { State } from './State';
+import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, SCXML, GuardPredicate, MachineContext } 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>;

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

@@ -1,25 +1,25 @@
-import { after, done, doneInvoke, escalate, forwardTo, respond, sendParent, sendTo } from './actions';
-import { assign } from './actions/assign';
-import { cancel } from './actions/cancel';
-import { choose } from './actions/choose';
-import { log } from './actions/log';
-import { pure } from './actions/pure';
-import { raise } from './actions/raise';
-import { send } from './actions/send';
-import { stop } from './actions/stop';
-import { interpret, Interpreter, ActorStatus } from './interpreter';
-import { createMachine } from './Machine';
-import { mapState } from './mapState';
-import { State } from './State';
-import { StateNode } from './StateNode';
-export { createSchema, t } from './schema';
-export { SimulatedClock } from './SimulatedClock';
-export { StateMachine } from './StateMachine';
-export { getStateNodes } from './stateUtils';
-export * from './typegenTypes';
-export * from './types';
-export { matchesState, pathToStateValue, toObserver, toSCXMLEvent } from './utils';
-export { StateNode, State, mapState, actions, assign, send, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
+import { after, done, doneInvoke, escalate, forwardTo, respond, sendParent, sendTo } from './actions.js';
+import { assign } from './actions/assign.js';
+import { cancel } from './actions/cancel.js';
+import { choose } from './actions/choose.js';
+import { log } from './actions/log.js';
+import { pure } from './actions/pure.js';
+import { raise } from './actions/raise.js';
+import { send } from './actions/send.js';
+import { stop } from './actions/stop.js';
+import { interpret, Interpreter, ActorStatus } from './interpreter.js';
+import { createMachine } from './Machine.js';
+import { mapState } from './mapState.js';
+import { State } from './State.js';
+import { StateNode } from './StateNode.js';
+export { createSchema, t } from './schema.js';
+export { SimulatedClock } from './SimulatedClock.js';
+export { StateMachine } from './StateMachine.js';
+export { getStateNodes } from './stateUtils.js';
+export * from './typegenTypes.js';
+export * from './types.js';
+export { matchesState, pathToStateValue, toObserver, toSCXMLEvent } from './utils.js';
+export { StateNode, State, mapState, actions, assign, send, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
 declare const actions: {
     raise: typeof raise;
     send: typeof send;