xstate 5.0.0-alpha.6 → 5.0.0-beta.11

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

@@ -1,6 +1,6 @@
 import type { StateNode } from './StateNode.ts';
 import { TypegenDisabled, TypegenEnabled } from './typegenTypes.ts';
-import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, SCXML, StateConfig, StateValue, TransitionDefinition } from './types.ts';
+import type { ActorRef, AnyState, AnyStateMachine, BaseActionObject, EventObject, HistoryValue, MachineContext, PersistedMachineState, Prop, StateConfig, StateValue, TransitionDefinition } from './types.ts';
 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.
@@ -22,8 +22,7 @@ export declare class State<TContext extends MachineContext, TEvent extends Event
     historyValue: Readonly<HistoryValue<TContext, TEvent>>;
     actions: BaseActionObject[];
     event: TEvent;
-    _internalQueue: Array<SCXML.Event<TEvent>>;
-    _event: SCXML.Event<TEvent>;
+    _internalQueue: Array<TEvent>;
     _initial: boolean;
     /**
      * Indicates whether the state has changed from the previous state. A state is considered "changed" if:

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

@@ -1,11 +1,11 @@
 import { State } from './State.ts';
 import { StateNode } from './StateNode.ts';
 import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from './typegenTypes.ts';
-import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineSchema, NoInfer, SCXML, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from './types.ts';
+import type { ActorContext, ActorMap, ActorBehavior, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateConfig, StateMachineDefinition, StateValue, TransitionDefinition, PersistedMachineState, ParameterizedObject, AnyActorContext } from './types.ts';
 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 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>>> {
+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, State<TContext, TEvent, TResolvedTypesMeta>, State<TContext, TEvent, TResolvedTypesMeta>, PersistedMachineState<State<TContext, TEvent, TResolvedTypesMeta>>> {
     /**
      * The raw config used to create the machine.
      */
@@ -21,7 +21,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      */
     delimiter: string;
     options: MachineImplementationsSimplified<TContext, TEvent>;
-    schema: MachineSchema<TContext, TEvent>;
+    types: MachineTypes<TContext, TEvent>;
     __xstatenode: true;
     idMap: Map<string, StateNode<TContext, TEvent>>;
     root: StateNode<TContext, TEvent>;
@@ -59,7 +59,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: StateValue | State<TContext, TEvent, TResolvedTypesMeta> | undefined, event: TEvent | SCXML.Event<TEvent>, actorCtx?: ActorContext<TEvent, State<TContext, TEvent, any>>): State<TContext, TEvent, TResolvedTypesMeta>;
+    transition(state: StateValue | State<TContext, TEvent, TResolvedTypesMeta> | undefined, event: TEvent, actorCtx?: ActorContext<TEvent, State<TContext, TEvent, any>>): State<TContext, TEvent, TResolvedTypesMeta>;
     /**
      * Determines the next state given the current `state` and `event`.
      * Calculates a microstep.
@@ -67,8 +67,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> | 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>>;
+    microstep(state: State<TContext, TEvent, TResolvedTypesMeta> | undefined, event: TEvent, actorCtx?: AnyActorContext | undefined): Array<State<TContext, TEvent, TResolvedTypesMeta>>;
+    getTransitionData(state: State<TContext, TEvent, 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.

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

@@ -1,4 +1,4 @@
-import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, SCXML, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from './types.ts';
+import type { EventObject, StateNodeDefinition, TransitionDefinition, DelayedTransitionDefinition, StateNodeConfig, StateNodesConfig, InvokeDefinition, Mapper, PropertyMapper, TransitionDefinitionMap, InitialTransitionDefinition, MachineContext, BaseActionObject } from './types.ts';
 import type { State } from './State.ts';
 import type { StateMachine } from './StateMachine.ts';
 interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
@@ -69,7 +69,7 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
      */
     output?: Mapper<TContext, TEvent, any> | PropertyMapper<TContext, TEvent, any>;
     /**
-     * The order this state node appears. Corresponds to the implicit SCXML document order.
+     * The order this state node appears. Corresponds to the implicit document order.
      */
     order: number;
     description?: string;
@@ -97,13 +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>;
-    /**
-     * Returns `true` if this state node explicitly handles the given event.
-     *
-     * @param event The event in question
-     */
-    handles(event: TEvent): boolean;
-    next(state: State<TContext, TEvent>, _event: SCXML.Event<TEvent>): TransitionDefinition<TContext, TEvent>[] | undefined;
+    next(state: State<TContext, TEvent>, 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

@@ -20,13 +20,6 @@ export declare function send<TContext extends MachineContext, TEvent extends Eve
  * @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, 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, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
 /**
  * Forwards (sends) an event to a specified service.
  *

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

@@ -1,16 +1,17 @@
-import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject, SCXML } from './types.ts';
+import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject } from './types.ts';
 import * as actionTypes from './actionTypes.ts';
-export { send, sendTo, sendParent, respond, forwardTo, escalate } from './actions/send.ts';
+export { send, sendTo, sendParent, forwardTo, escalate } from './actions/send.ts';
 export { stop } from './actions/stop.ts';
 export { log } from './actions/log.ts';
 export { cancel } from './actions/cancel.ts';
 export { assign } from './actions/assign.ts';
 export { raise } from './actions/raise.ts';
 export { choose } from './actions/choose.ts';
+export { pure } from './actions/pure.ts';
 export { actionTypes };
-export declare const initEvent: SCXML.Event<{
+export declare const initEvent: {
     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[];
@@ -41,7 +42,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): SCXML.Event<{
-    type: ActionTypes.Init;
-    input: any;
-}>;
+export declare function createInitEvent(input: any): {
+    readonly type: ActionTypes.Init;
+    readonly input: any;
+};

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

@@ -1,4 +1,4 @@
-import type { EventObject, ActorRef, BaseActorRef } from '../types.ts';
+import type { EventObject, ActorRef, BaseActorRef, AnyEventObject } from '../types.ts';
 export { fromTransition } from './transition.ts';
 export { fromPromise } from './promise.ts';
 export { fromObservable, fromEventObservable } from './observable.ts';
@@ -25,3 +25,4 @@ export type LifecycleSignalType = typeof startSignalType | typeof stopSignalType
 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>>;
+export declare function createEmptyActor(): ActorRef<AnyEventObject, undefined>;

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

@@ -1,8 +1,7 @@
 import { Subscribable, ActorBehavior, EventObject, Subscription } from '../types';
 export interface ObservableInternalState<T> {
     subscription: Subscription | undefined;
-    canceled: boolean;
-    status: 'active' | 'done' | 'error';
+    status: 'active' | 'done' | 'error' | 'canceled';
     data: T | undefined;
     input?: any;
 }

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

@@ -1,7 +1,6 @@
 import { ActorBehavior } from '../types';
 export interface PromiseInternalState<T> {
-    status: 'active' | 'error' | 'done';
-    canceled: boolean;
+    status: 'active' | 'error' | 'done' | 'canceled';
     data: T | undefined;
     input?: any;
 }

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

@@ -1,8 +1,8 @@
-import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, SCXML, GuardPredicate, MachineContext } from './types.ts';
+import type { EventObject, StateValue, BooleanGuardDefinition, GuardConfig, GuardDefinition, GuardPredicate, MachineContext } from './types.ts';
 import type { State } from './State.ts';
 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: SCXML.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>): boolean;
 export declare function toGuardDefinition<TContext extends MachineContext, TEvent extends EventObject>(guardConfig: GuardConfig<TContext, TEvent>, getPredicate?: (guardType: string) => GuardPredicate<TContext, TEvent>): GuardDefinition<TContext, TEvent>;

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

@@ -1,42 +1,26 @@
-import { after, done, doneInvoke, escalate, forwardTo, respond, sendParent, sendTo } from './actions.ts';
-import { assign } from './actions/assign.ts';
-import { cancel } from './actions/cancel.ts';
-import { choose } from './actions/choose.ts';
-import { log } from './actions/log.ts';
-import { pure } from './actions/pure.ts';
-import { raise } from './actions/raise.ts';
-import { send } from './actions/send.ts';
-import { stop } from './actions/stop.ts';
+import { doneInvoke, forwardTo, sendParent, sendTo } from './actions.ts';
+export { assign } from './actions/assign.ts';
+export { cancel } from './actions/cancel.ts';
+export { choose } from './actions/choose.ts';
+export { log } from './actions/log.ts';
+export { pure } from './actions/pure.ts';
+export { raise } from './actions/raise.ts';
+export { stop } from './actions/stop.ts';
 import { interpret, Interpreter, ActorStatus } from './interpreter.ts';
 import { createMachine } from './Machine.ts';
 import { mapState } from './mapState.ts';
 import { State } from './State.ts';
 import { StateNode } from './StateNode.ts';
-export { createSchema, t } from './schema.ts';
 export { SimulatedClock } from './SimulatedClock.ts';
 export { StateMachine } from './StateMachine.ts';
 export { getStateNodes } from './stateUtils.ts';
+export { waitFor } from './waitFor.ts';
 export * from './typegenTypes.ts';
 export * from './types.ts';
-export { matchesState, pathToStateValue, toObserver, toSCXMLEvent } from './utils.ts';
-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;
-    sendParent: typeof sendParent;
-    sendTo: typeof sendTo;
-    log: typeof log;
-    cancel: typeof cancel;
-    stop: typeof stop;
-    assign: typeof assign;
-    after: typeof after;
-    done: typeof done;
-    respond: typeof respond;
-    forwardTo: typeof forwardTo;
-    escalate: typeof escalate;
-    choose: typeof choose;
-    pure: typeof pure;
-};
+export { matchesState, pathToStateValue, toObserver } from './utils.ts';
+export { StateNode, State, mapState, sendTo, sendParent, forwardTo, interpret, Interpreter, ActorStatus as InterpreterStatus, doneInvoke, createMachine };
+export { fromPromise, fromObservable, fromCallback, fromEventObservable, fromTransition } from './actors/index.ts';
+export { stateIn, not, and, or } from './guards.ts';
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

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

@@ -1,7 +1,7 @@
 import { symbolObservable } from './symbolObservable.ts';
-import { AreAllImplementationsAssumedToBeProvided } from './typegenTypes.ts';
+import { AreAllImplementationsAssumedToBeProvided, MissingImplementationsError } from './typegenTypes.ts';
 import type { ActorSystem, AnyActorBehavior, AnyStateMachine, EventFromBehavior, InterpreterFrom, PersistedStateFrom, RaiseActionObject, SnapshotFrom } from './types.ts';
-import { ActorRef, DoneEvent, EventObject, InteropSubscribable, InterpreterOptions, Observer, SCXML, SendActionObject, Subscription } from './types.ts';
+import { ActorRef, DoneEvent, EventObject, InteropSubscribable, InterpreterOptions, Observer, SendActionObject, Subscription } from './types.ts';
 export type SnapshotListener<TBehavior extends AnyActorBehavior> = (state: SnapshotFrom<TBehavior>) => void;
 export type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
 export type Listener = () => void;
@@ -77,13 +77,14 @@ export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent exte
      */
     stop(): this;
     private _complete;
+    private _error;
     private _stopProcedure;
     /**
      * Sends an event to the running interpreter to trigger a transition.
      *
      * @param event The event to send
      */
-    send(event: TEvent | SCXML.Event<TEvent>): void;
+    send(event: TEvent): void;
     delaySend(sendAction: SendActionObject | RaiseActionObject<any, any, any>): void;
     cancel(sendId: string | number): void;
     private attachDevTools;
@@ -100,5 +101,5 @@ export declare class Interpreter<TBehavior extends AnyActorBehavior, TEvent exte
  * @param machine The machine to interpret
  * @param options Interpreter options
  */
-export declare function interpret<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : 'Some implementations missing', options?: InterpreterOptions<TMachine>): InterpreterFrom<TMachine>;
+export declare function interpret<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : MissingImplementationsError<TMachine['__TResolvedTypesMeta']>, options?: InterpreterOptions<TMachine>): InterpreterFrom<TMachine>;
 export declare function interpret<TBehavior extends AnyActorBehavior>(behavior: TBehavior, options?: InterpreterOptions<TBehavior>): Interpreter<TBehavior>;

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

@@ -1,4 +1,4 @@
-import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, SCXML, StateValueMap, InitialTransitionConfig, MachineContext } from './types.ts';
+import { BaseActionObject, EventObject, StateValue, TransitionConfig, TransitionDefinition, SingleOrArray, StateValueMap, InitialTransitionConfig, MachineContext } from './types.ts';
 import { State } from './State.ts';
 import { NULL_EVENT } from './constants.ts';
 import type { StateNode } from './StateNode.ts';
@@ -11,12 +11,7 @@ export declare function getAdjList<TContext extends MachineContext, TE extends E
 export declare function getStateValue(rootNode: AnyStateNode, configuration: AnyConfiguration): StateValue;
 export declare function isInFinalState(configuration: Array<AnyStateNode>, stateNode?: AnyStateNode): boolean;
 export declare const isStateId: (str: string) => boolean;
-export declare function getCandidates<TEvent extends EventObject>(stateNode: StateNode<any, TEvent>, receivedEventType: TEvent['type'], 
-/**
- * If `true`, will use SCXML event partial token matching semantics
- * without the need for the ".*" suffix
- */
-partialMatch?: boolean): Array<TransitionDefinition<any, TEvent>>;
+export declare function getCandidates<TEvent extends EventObject>(stateNode: StateNode<any, TEvent>, receivedEventType: TEvent['type']): Array<TransitionDefinition<any, TEvent>>;
 /**
  * All delayed transitions from the config.
  */
@@ -44,10 +39,10 @@ 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: SCXML.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: SCXML.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: SCXML.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: SCXML.Event<TEvent>): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+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 removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, configuration: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
@@ -57,11 +52,11 @@ 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 | undefined, scxmlEvent: SCXML.Event<TEvent>): State<TContext, TEvent, any>;
-export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: BaseActionObject[], scxmlEvent: SCXML.Event<TEvent>, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined): {
+export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<TransitionDefinition<TContext, TEvent>>, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined, event: TEvent): State<TContext, TEvent, any>;
+export declare function resolveActionsAndContext<TContext extends MachineContext, TEvent extends EventObject>(actions: BaseActionObject[], event: TEvent, currentState: State<TContext, TEvent, any>, actorCtx: AnyActorContext | undefined): {
     nextState: AnyState;
 };
-export declare function macrostep<TMachine extends AnyStateMachine>(state: StateFromMachine<TMachine>, scxmlEvent: SCXML.Event<TMachine['__TEvent']>, actorCtx: AnyActorContext | undefined): {
+export declare function macrostep<TMachine extends AnyStateMachine>(state: StateFromMachine<TMachine>, event: TMachine['__TEvent'], actorCtx: AnyActorContext | undefined): {
     state: typeof state;
     microstates: Array<typeof state>;
 };

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

@@ -1,4 +1,4 @@
-import { EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast, ParameterizedObject } from './types.ts';
+import { Compute, EventObject, IndexByType, IsNever, Prop, Values, IsAny, ActorMap, Cast, ParameterizedObject } from './types.ts';
 export interface TypegenDisabled {
     '@@xstate/typegen': false;
 }
@@ -86,6 +86,12 @@ export type TypegenConstraint = TypegenEnabled | TypegenDisabled;
 export type AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = IsAny<TResolvedTypesMeta> extends true ? true : TResolvedTypesMeta extends TypegenEnabled ? IsNever<Values<{
     [K in keyof TMissingImplementations]: TMissingImplementations[K];
 }>> extends true ? true : false : true;
+export type MissingImplementationsError<TResolvedTypesMeta, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = Compute<[
+    'Some implementations missing',
+    Values<{
+        [K in keyof TMissingImplementations]: TMissingImplementations[K];
+    }>
+]>;
 interface AllImplementationsProvided {
     missingImplementations: {
         actions: never;

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

@@ -58,7 +58,7 @@ export interface UnifiedArg<TContext extends MachineContext, TEvent extends Even
 export interface BaseDynamicActionObject<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TResolvedAction extends BaseActionObject, TDynamicParams extends Record<string, any>> {
     type: `xstate.${string}`;
     params: TDynamicParams;
-    resolve: (_event: SCXML.Event<TExpressionEvent>, extra: {
+    resolve: (event: TExpressionEvent, extra: {
         state: State<TContext, TEvent>;
         /**
          * The original action object
@@ -75,7 +75,6 @@ export interface BaseDynamicActionObject<TContext extends MachineContext, TExpre
 export type MachineContext = Record<string, any>;
 export interface ActionMeta<TEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject> extends StateMeta<TEvent> {
     action: TAction;
-    _event: SCXML.Event<TEvent>;
 }
 export type Spawner = <T extends ActorBehavior<any, any> | string>(// TODO: read string from machine behavior keys
 behavior: T, options?: Partial<{
@@ -84,7 +83,7 @@ behavior: T, options?: Partial<{
 }>) => T extends ActorBehavior<infer TActorEvent, infer TActorEmitted> ? ActorRef<TActorEvent, TActorEmitted> : ActorRef<any, any>;
 export interface AssignMeta<TExpressionEvent extends EventObject, _TEvent extends EventObject> extends StateMeta<TExpressionEvent> {
     action: BaseActionObject;
-    _event: SCXML.Event<TExpressionEvent>;
+    event: TExpressionEvent;
     spawn: Spawner;
 }
 export type ActionFunction<TContext extends MachineContext, TExpressionEvent extends EventObject, TAction extends ParameterizedObject = ParameterizedObject, TEvent extends EventObject = TExpressionEvent> = (args: {
@@ -92,7 +91,7 @@ export type ActionFunction<TContext extends MachineContext, TExpressionEvent ext
     event: TExpressionEvent;
 } & ActionMeta<TEvent, TAction>) => void;
 export interface ChooseCondition<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> {
-    guard?: GuardConfig<TContext, TEvent>;
+    guard?: GuardConfig<TContext, TExpressionEvent>;
     actions: Actions<TContext, TExpressionEvent, TEvent>;
 }
 export type Action<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent> = ActionType | ParameterizedObject | ActionFunction<TContext, TExpressionEvent, ParameterizedObject, TEvent> | BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, any, any>;
@@ -126,10 +125,9 @@ export interface DefaultGuardObject<TContext extends MachineContext, TEvent exte
     children?: Array<GuardObject<TContext, TEvent>>;
     predicate?: GuardPredicate<TContext, TEvent>;
 }
-export type GuardEvaluator<TContext extends MachineContext, TEvent extends EventObject> = (guard: GuardDefinition<TContext, TEvent>, context: TContext, _event: SCXML.Event<TEvent>, state: State<TContext, TEvent>) => boolean;
+export type GuardEvaluator<TContext extends MachineContext, TEvent extends EventObject> = (guard: GuardDefinition<TContext, TEvent>, context: TContext, event: TEvent, state: State<TContext, TEvent>) => boolean;
 export interface GuardMeta<TContext extends MachineContext, TEvent extends EventObject> {
     state: State<TContext, TEvent, any>;
-    _event: SCXML.Event<TEvent>;
     guard: GuardDefinition<TContext, TEvent>;
     evaluate: GuardEvaluator<TContext, TEvent>;
 }
@@ -161,7 +159,7 @@ export type TransitionTarget = SingleOrArray<string>;
 export interface TransitionConfig<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent, TAction extends ParameterizedObject = ParameterizedObject> {
     guard?: GuardConfig<TContext, TExpressionEvent>;
     actions?: BaseActions<TContext, TExpressionEvent, TEvent, TAction>;
-    external?: boolean;
+    reenter?: boolean;
     target?: TransitionTarget | undefined;
     meta?: Record<string, any>;
     description?: string;
@@ -190,7 +188,7 @@ export type ActorBehaviorCreator<TContext extends MachineContext, TEvent extends
     id: string;
     data?: any;
     src: string;
-    _event: SCXML.Event<TEvent>;
+    event: TEvent;
     meta: MetaObject | undefined;
     input: any;
 }) => TActorBehavior;
@@ -357,7 +355,7 @@ export interface StateNodeConfig<TContext extends MachineContext, TEvent extends
      */
     delimiter?: string;
     /**
-     * The order this state node appears. Corresponds to the implicit SCXML document order.
+     * The order this state node appears. Corresponds to the implicit document order.
      */
     order?: number;
     /**
@@ -486,17 +484,12 @@ export interface MachineConfig<TContext extends MachineContext, TEvent extends E
      * The machine's own version.
      */
     version?: string;
-    /**
-     * If `true`, will use SCXML semantics, such as event token matching.
-     */
-    scxml?: boolean;
-    schema?: MachineSchema<TContext, TEvent, TActorMap>;
-    tsTypes?: TTypesMeta;
+    types?: MachineTypes<TContext, TEvent, TActorMap, TTypesMeta>;
 }
 export type ActorMap = Record<string, {
     output: any;
 }>;
-export interface MachineSchema<TContext extends MachineContext, TEvent extends EventObject, TActorMap extends ActorMap = ActorMap> {
+export interface MachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActorMap extends ActorMap = ActorMap, TTypesMeta = TypegenDisabled> {
     context?: TContext;
     actions?: {
         type: string;
@@ -508,6 +501,7 @@ export interface MachineSchema<TContext extends MachineContext, TEvent extends E
         type: string;
         [key: string]: any;
     };
+    typegen?: TTypesMeta;
 }
 export interface HistoryStateNode<TContext extends MachineContext> extends StateNode<TContext> {
     history: 'shallow' | 'deep';
@@ -540,7 +534,6 @@ export interface RaiseActionObject<TContext extends MachineContext, TExpressionE
     type: ActionTypes.Raise;
     params: {
         event: TEvent;
-        _event: SCXML.Event<TEvent>;
         delay: RaiseActionOptions<TContext, TExpressionEvent>['delay'];
         id: string | number;
     };
@@ -565,10 +558,6 @@ export interface ErrorExecutionEvent extends EventObject {
 export interface ErrorPlatformEvent extends EventObject {
     data: any;
 }
-export interface SCXMLErrorEvent extends SCXML.Event<any> {
-    name: ActionTypes.ErrorExecution | ActionTypes.ErrorPlatform | ActionTypes.ErrorCommunication;
-    data: any;
-}
 export interface DoneEventObject extends EventObject {
     output?: any;
     toString(): string;
@@ -626,7 +615,6 @@ export interface SendActionObject<TSentEvent extends EventObject = AnyEventObjec
     type: 'xstate.send';
     params: {
         to: ActorRef<TSentEvent> | undefined;
-        _event: SCXML.Event<TSentEvent>;
         event: TSentEvent;
         delay?: number;
         id: string | number;
@@ -731,7 +719,7 @@ export interface TransitionDefinition<TContext extends MachineContext, TEvent ex
     target: Array<StateNode<TContext, TEvent>> | undefined;
     source: StateNode<TContext, TEvent>;
     actions: BaseActionObject[];
-    external: boolean;
+    reenter: boolean;
     guard?: GuardDefinition<TContext, TEvent>;
     eventType: TEvent['type'] | '*';
     toJSON: () => {
@@ -782,7 +770,6 @@ export interface Segment<TContext extends MachineContext, TEvent extends EventOb
     event: TEvent;
 }
 export interface StateMeta<TEvent extends EventObject> {
-    _event: SCXML.Event<TEvent>;
     self: ActorRef<TEvent>;
     system: ActorSystem<any>;
 }
@@ -790,12 +777,11 @@ export interface StateLike<TContext extends MachineContext> {
     value: StateValue;
     context: TContext;
     event: EventObject;
-    _event: SCXML.Event<EventObject>;
 }
 export interface StateConfig<TContext extends MachineContext, TEvent extends EventObject> {
     value: StateValue;
     context: TContext;
-    _event: SCXML.Event<TEvent>;
+    event: TEvent;
     historyValue?: HistoryValue<TContext, TEvent>;
     actions?: BaseActionObject[];
     meta?: any;
@@ -806,7 +792,7 @@ export interface StateConfig<TContext extends MachineContext, TEvent extends Eve
     output?: any;
     tags?: Set<string>;
     machine?: StateMachine<TContext, TEvent, any, any, any>;
-    _internalQueue?: Array<SCXML.Event<TEvent>>;
+    _internalQueue?: Array<TEvent>;
 }
 export interface InterpreterOptions<_TActorBehavior extends AnyActorBehavior> {
     /**
@@ -850,68 +836,6 @@ export interface InterpreterOptions<_TActorBehavior extends AnyActorBehavior> {
     src?: string;
 }
 export type AnyInterpreter = Interpreter<any>;
-export declare namespace SCXML {
-    interface Event<TEvent extends EventObject> {
-        /**
-         * This is a character string giving the name of the event.
-         * The SCXML Processor must set the name field to the name of this event.
-         * It is what is matched against the 'event' attribute of <transition>.
-         * Note that transitions can do additional tests by using the value of this field
-         * inside boolean expressions in the 'cond' attribute.
-         */
-        name: string;
-        /**
-         * This field describes the event type.
-         * The SCXML Processor must set it to: "platform" (for events raised by the platform itself, such as error events),
-         * "internal" (for events raised by <raise> and <send> with target '_internal')
-         * or "external" (for all other events).
-         */
-        type: 'platform' | 'internal' | 'external';
-        /**
-         * If the sending entity has specified a value for this, the Processor must set this field to that value
-         * (see C Event I/O Processors for details).
-         * Otherwise, in the case of error events triggered by a failed attempt to send an event,
-         * the Processor must set this field to the send id of the triggering <send> element.
-         * Otherwise it must leave it blank.
-         */
-        sendid?: string;
-        /**
-         * This is a URI, equivalent to the 'target' attribute on the <send> element.
-         * For external events, the SCXML Processor should set this field to a value which,
-         * when used as the value of 'target', will allow the receiver of the event to <send>
-         * a response back to the originating entity via the Event I/O Processor specified in 'origintype'.
-         * For internal and platform events, the Processor must leave this field blank.
-         */
-        origin?: ActorRef<any>;
-        /**
-         * This is equivalent to the 'type' field on the <send> element.
-         * For external events, the SCXML Processor should set this field to a value which,
-         * when used as the value of 'type', will allow the receiver of the event to <send>
-         * a response back to the originating entity at the URI specified by 'origin'.
-         * For internal and platform events, the Processor must leave this field blank.
-         */
-        origintype?: string;
-        /**
-         * If this event is generated from an invoked child process, the SCXML Processor
-         * must set this field to the invoke id of the invocation that triggered the child process.
-         * Otherwise it must leave it blank.
-         */
-        invokeid?: string;
-        /**
-         * This field contains whatever data the sending entity chose to include in this event.
-         * The receiving SCXML Processor should reformat this data to match its data model,
-         * but must not otherwise modify it.
-         *
-         * If the conversion is not possible, the Processor must leave the field blank
-         * and must place an error 'error.execution' in the internal event queue.
-         */
-        data: TEvent;
-        /**
-         * @private
-         */
-        $$type: 'scxml';
-    }
-}
 export type Observer<T> = {
     next?: (value: T) => void;
     error?: (err: any) => void;
@@ -979,6 +903,7 @@ export interface ActorBehavior<TEvent extends EventObject, TSnapshot = any, TInt
  * Serialized internal state used for persistence & restoration
  */
 TPersisted = TInternalState, TSystem extends ActorSystem<any> = ActorSystem<any>> {
+    config?: unknown;
     transition: (state: TInternalState, message: TEvent | LifecycleSignal, ctx: ActorContext<TEvent, TSnapshot, TSystem>) => TInternalState;
     getInitialState: (actorCtx: ActorContext<TEvent, TSnapshot, any>, input: any) => TInternalState;
     restoreState?: (persistedState: TPersisted, actorCtx: ActorContext<TEvent, TSnapshot>) => TInternalState;
@@ -994,11 +919,11 @@ TPersisted = TInternalState, TSystem extends ActorSystem<any> = ActorSystem<any>
     getPersistedState?: (state: TInternalState) => TPersisted;
 }
 export type AnyActorBehavior = ActorBehavior<any, any, any, any>;
-export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TSnapshot> ? TSnapshot : R extends Interpreter<infer TBehavior> ? SnapshotFrom<TBehavior> : R extends ActorBehavior<infer _, infer TSnapshot> ? TSnapshot : R extends ActorContext<infer _, infer TSnapshot, infer __> ? TSnapshot : never : never;
+export type SnapshotFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends ActorRef<infer _, infer TSnapshot> ? TSnapshot : R extends Interpreter<infer TBehavior> ? SnapshotFrom<TBehavior> : R extends StateMachine<infer _, infer __, infer ___, infer ____, infer _____> ? StateFrom<R> : R extends ActorBehavior<infer _, infer TSnapshot, infer __, infer ___, infer ____> ? TSnapshot : R extends ActorContext<infer _, infer TSnapshot, infer __> ? TSnapshot : never : never;
 export type EventFromBehavior<TBehavior extends ActorBehavior<any, any>> = TBehavior extends ActorBehavior<infer TEvent, infer _> ? TEvent : never;
 export type PersistedStateFrom<TBehavior extends ActorBehavior<any, any>> = TBehavior extends ActorBehavior<infer _TEvent, infer _TSnapshot, infer _TInternalState, infer TPersisted> ? TPersisted : never;
 export type InternalStateFrom<TBehavior extends ActorBehavior<any, any>> = TBehavior extends ActorBehavior<infer _TEvent, infer _TSnapshot, infer TInternalState, infer _TPersisted> ? TInternalState : never;
-type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer TEvent, infer __, infer ___, infer ____> ? TEvent : R extends State<infer _, infer TEvent, infer __> ? TEvent : R extends Interpreter<infer _, infer TEvent> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
+type ResolveEventType<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer _, infer TEvent, infer __, infer ___, infer ____> ? TEvent : R extends State<infer _, infer TEvent, infer __> ? TEvent : R extends ActorRef<infer TEvent, infer _> ? TEvent : never : never;
 export type EventFrom<T, K extends Prop<TEvent, 'type'> = never, TEvent extends EventObject = ResolveEventType<T>> = IsNever<K> extends true ? TEvent : ExtractEvent<TEvent, K>;
 export type ContextFrom<T> = ReturnTypeOrValue<T> extends infer R ? R extends StateMachine<infer TContext, infer _, infer __, infer ___, infer ____> ? TContext : R extends State<infer TContext, infer _, infer __> ? TContext : R extends Interpreter<infer TBehavior> ? TBehavior extends StateMachine<infer TContext, infer _> ? TContext : never : never : never;
 export type InferEvent<E extends EventObject> = {
@@ -1010,6 +935,7 @@ export type InferEvent<E extends EventObject> = {
 }[E['type']];
 export type TODO = any;
 export type StateValueFrom<TMachine extends AnyStateMachine> = Parameters<StateFrom<TMachine>['matches']>[0];
+export type TagsFrom<TMachine extends AnyStateMachine> = Parameters<StateFrom<TMachine>['hasTag']>[0];
 export type StateFromMachine<TMachine extends AnyStateMachine> = TMachine['initialState'];
 export interface ActorSystemInfo {
     actors: Record<string, AnyActorRef>;
@@ -1021,7 +947,7 @@ export interface ActorSystem<T extends ActorSystemInfo> {
     _set: <K extends keyof T['actors']>(key: K, actorRef: T['actors'][K]) => void;
     get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;
 }
-export type PersistedMachineState<TState extends AnyState> = Pick<TState, 'value' | 'output' | 'context' | '_event' | 'done' | 'historyValue'> & {
+export type PersistedMachineState<TState extends AnyState> = Pick<TState, 'value' | 'output' | 'context' | 'event' | 'done' | 'historyValue'> & {
     children: {
         [K in keyof TState['children']]: {
             state: any;