xstate 5.0.0-beta.48 → 5.0.0-beta.50

package/dist/{raise-0eafc1df.development.cjs.js → raise-dc9c2c58.development.cjs.js}

@@ -250,9 +250,6 @@ function mapValues(collection, iteratee) {
   }
   return result;
 }
-function flatten(array) {
-  return [].concat(...array);
-}
 function toArrayStrict(value) {
   if (isArray(value)) {
     return value;
@@ -322,7 +319,7 @@ function resolveReferencedActor(machine, src) {
   return machine.implementations.actors[src];
 }
 function getAllOwnEventDescriptors(snapshot) {
-  return [...new Set(flatten([...snapshot._nodes.map(sn => sn.ownEvents)]))];
+  return [...new Set([...snapshot._nodes.flatMap(sn => sn.ownEvents)])];
 }
 
 const $$ACTOR_TYPE = 1;
@@ -457,7 +454,18 @@ class Actor {
     }
   }
   _initState(persistedState) {
-    this._state = persistedState ? this.logic.restoreState ? this.logic.restoreState(persistedState, this._actorScope) : persistedState : this.logic.getInitialState(this._actorScope, this.options?.input);
+    try {
+      this._state = persistedState ? this.logic.restoreState ? this.logic.restoreState(persistedState, this._actorScope) : persistedState : this.logic.getInitialState(this._actorScope, this.options?.input);
+    } catch (err) {
+      // if we get here then it means that we assign a value to this._state that is not of the correct type
+      // we can't get the true `TSnapshot & { status: 'error'; }`, it's impossible
+      // so right now this is a lie of sorts
+      this._state = {
+        status: 'error',
+        output: undefined,
+        error: err
+      };
+    }
   }
   update(snapshot, event) {
     // Update state
@@ -466,17 +474,46 @@ class Actor {
     // Execute deferred effects
     let deferredFn;
     while (deferredFn = this._deferred.shift()) {
-      deferredFn();
-    }
-    for (const observer of this.observers) {
       try {
-        observer.next?.(snapshot);
+        deferredFn();
       } catch (err) {
-        reportUnhandledError(err);
+        // this error can only be caught when executing *initial* actions
+        // it's the only time when we call actions provided by the user through those deferreds
+        // when the actor is already running we always execute them synchronously while transitioning
+        // no "builtin deferred" should actually throw an error since they are either safe
+        // or the control flow is passed through the mailbox and errors should be caught by the `_process` used by the mailbox
+        this._deferred.length = 0;
+        this._state = {
+          ...snapshot,
+          status: 'error',
+          error: err
+        };
       }
     }
     switch (this._state.status) {
+      case 'active':
+        for (const observer of this.observers) {
+          try {
+            observer.next?.(snapshot);
+          } catch (err) {
+            reportUnhandledError(err);
+          }
+        }
+        break;
       case 'done':
+        // next observers are meant to be notified about done snapshots
+        // this can be seen as something that is different from how observable work
+        // but with observables `complete` callback is called without any arguments
+        // it's more ergonomic for XState to treat a done snapshot as a "next" value
+        // and the completion event as something that is separate,
+        // something that merely follows emitting that done snapshot
+        for (const observer of this.observers) {
+          try {
+            observer.next?.(snapshot);
+          } catch (err) {
+            reportUnhandledError(err);
+          }
+        }
         this._stopProcedure();
         this._complete();
         this._doneEvent = createDoneActorEvent(this.id, this._state.output);
@@ -485,11 +522,7 @@ class Actor {
         }
         break;
       case 'error':
-        this._stopProcedure();
         this._error(this._state.error);
-        if (this._parent) {
-          this.system._relay(this, this._parent, createErrorActorEvent(this.id, this._state.error));
-        }
         break;
     }
     this.system._sendInspectionEvent({
@@ -579,7 +612,7 @@ class Actor {
       this.subscribe({
         next: snapshot => {
           if (snapshot.status === 'active') {
-            this._parent.send({
+            this.system._relay(this, this._parent, {
               type: `xstate.snapshot.${this.id}`,
               snapshot
             });
@@ -608,18 +641,22 @@ class Actor {
         // a state machine can be "done" upon initialization (it could reach a final state using initial microsteps)
         // we still need to complete observers, flush deferreds etc
         this.update(this._state, initEvent);
-      // fallthrough
-      case 'error':
         // TODO: rethink cleanup of observers, mailbox, etc
         return this;
+      case 'error':
+        this._error(this._state.error);
+        return this;
     }
     if (this.logic.start) {
       try {
         this.logic.start(this._state, this._actorScope);
       } catch (err) {
-        this._stopProcedure();
+        this._state = {
+          ...this._state,
+          status: 'error',
+          error: err
+        };
         this._error(err);
-        this._parent?.send(createErrorActorEvent(this.id, err));
         return this;
       }
     }
@@ -635,7 +672,6 @@ class Actor {
     return this;
   }
   _process(event) {
-    // TODO: reexamine what happens when an action (or a guard or smth) throws
     let nextState;
     let caughtError;
     try {
@@ -650,9 +686,12 @@ class Actor {
       const {
         err
       } = caughtError;
-      this._stopProcedure();
+      this._state = {
+        ...this._state,
+        status: 'error',
+        error: err
+      };
       this._error(err);
-      this._parent?.send(createErrorActorEvent(this.id, err));
       return;
     }
     this.update(nextState, event);
@@ -695,7 +734,7 @@ class Actor {
     }
     this.observers.clear();
   }
-  _error(err) {
+  _reportError(err) {
     if (!this.observers.size) {
       if (!this._parent) {
         reportUnhandledError(err);
@@ -717,6 +756,18 @@ class Actor {
       reportUnhandledError(err);
     }
   }
+  _error(err) {
+    this._stopProcedure();
+    this._reportError(err);
+    if (this._parent) {
+      this.system._relay(this, this._parent, createErrorActorEvent(this.id, err));
+    }
+  }
+  // TODO: atm children don't belong entirely to the actor so
+  // in a way - it's not even super aware of them
+  // so we can't stop them from here but we really should!
+  // right now, they are being stopped within the machine's transition
+  // but that could throw and leave us with "orphaned" active actors
   _stopProcedure() {
     if (this._processingStatus !== ProcessingStatus.Running) {
       // Actor already stopped; do nothing
@@ -976,12 +1027,7 @@ function executeSpawn(actorScope, {
     if (actorRef._processingStatus === ProcessingStatus.Stopped) {
       return;
     }
-    try {
-      actorRef.start?.();
-    } catch (err) {
-      actorScope.self.send(createErrorActorEvent(id, err));
-      return;
-    }
+    actorRef.start();
   });
 }
 function spawnChild(...[src, {
@@ -2064,7 +2110,23 @@ function macrostep(state, event, actorScope, internalQueue = []) {
   // Assume the state is at rest (no raised events)
   // Determine the next state based on the next microstep
   if (nextEvent.type !== XSTATE_INIT) {
-    const transitions = selectTransitions(nextEvent, nextState);
+    const currentEvent = nextEvent;
+    const isErr = isErrorActorEvent(currentEvent);
+    const transitions = selectTransitions(currentEvent, nextState);
+    if (isErr && !transitions.length) {
+      // TODO: we should likely only allow transitions selected by very explicit descriptors
+      // `*` shouldn't be matched, likely `xstate.error.*` shouldnt be either
+      // similarly `xstate.error.actor.*` and `xstate.error.actor.todo.*` have to be considered too
+      nextState = cloneMachineSnapshot(state, {
+        status: 'error',
+        error: currentEvent.data
+      });
+      states.push(nextState);
+      return {
+        state: nextState,
+        microstates: states
+      };
+    }
     nextState = microstep(transitions, state, actorScope, nextEvent, false, internalQueue);
     states.push(nextState);
   }
@@ -2181,10 +2243,9 @@ function createMachineSnapshot(config, machine) {
     context: config.context,
     _nodes: config._nodes,
     value: getStateValue(machine.root, config._nodes),
-    tags: new Set(flatten(config._nodes.map(sn => sn.tags))),
+    tags: new Set(config._nodes.flatMap(sn => sn.tags)),
     children: config.children,
     historyValue: config.historyValue || {},
-    // this one is generic in the target and it's hard to create a matching non-generic source signature
     matches: machineSnapshotMatches,
     hasTag: machineSnapshotHasTag,
     can: machineSnapshotCan,
@@ -2342,7 +2403,6 @@ exports.getPersistedState = getPersistedState;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
 exports.interpret = interpret;
-exports.isErrorActorEvent = isErrorActorEvent;
 exports.isInFinalState = isInFinalState;
 exports.isMachineSnapshot = isMachineSnapshot;
 exports.isStateId = isStateId;

package/dist/{send-f0a3179c.development.esm.js → send-2b001f05.development.esm.js}

@@ -1,4 +1,4 @@
-import { U as ProcessingStatus, V as createErrorActorEvent, B as resolveReferencedActor, C as createActor, p as cloneMachineSnapshot, e as evaluateGuard, t as toArray, W as XSTATE_ERROR } from './raise-286581d5.development.esm.js';
+import { R as ProcessingStatus, y as resolveReferencedActor, z as createActor, T as cloneMachineSnapshot, e as evaluateGuard, t as toArray, U as XSTATE_ERROR, V as createErrorActorEvent } from './raise-6c05c91b.development.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -47,12 +47,7 @@ function createSpawner(actorScope, {
       if (actorRef._processingStatus === ProcessingStatus.Stopped) {
         return;
       }
-      try {
-        actorRef.start?.();
-      } catch (err) {
-        actorScope.self.send(createErrorActorEvent(actorRef.id, err));
-        return;
-      }
+      actorRef.start();
     });
     return actorRef;
   };

package/dist/{send-355ba004.cjs.js → send-7f3db830.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-cd0dde81.cjs.js');
+var guards_dist_xstateGuards = require('./raise-8176cd35.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -49,12 +49,7 @@ function createSpawner(actorScope, {
       if (actorRef._processingStatus === guards_dist_xstateGuards.ProcessingStatus.Stopped) {
         return;
       }
-      try {
-        actorRef.start?.();
-      } catch (err) {
-        actorScope.self.send(guards_dist_xstateGuards.createErrorActorEvent(actorRef.id, err));
-        return;
-      }
+      actorRef.start();
     });
     return actorRef;
   };

package/dist/{send-ae491737.esm.js → send-88351a33.esm.js}

@@ -1,4 +1,4 @@
-import { U as ProcessingStatus, V as createErrorActorEvent, B as resolveReferencedActor, C as createActor, p as cloneMachineSnapshot, e as evaluateGuard, t as toArray, W as XSTATE_ERROR } from './raise-84fd7a92.esm.js';
+import { R as ProcessingStatus, y as resolveReferencedActor, z as createActor, T as cloneMachineSnapshot, e as evaluateGuard, t as toArray, U as XSTATE_ERROR, V as createErrorActorEvent } from './raise-32ec7226.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -47,12 +47,7 @@ function createSpawner(actorScope, {
       if (actorRef._processingStatus === ProcessingStatus.Stopped) {
         return;
       }
-      try {
-        actorRef.start?.();
-      } catch (err) {
-        actorScope.self.send(createErrorActorEvent(actorRef.id, err));
-        return;
-      }
+      actorRef.start();
     });
     return actorRef;
   };

package/dist/{send-32a63473.development.cjs.js → send-df1c8ef2.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-0eafc1df.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-dc9c2c58.development.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -49,12 +49,7 @@ function createSpawner(actorScope, {
       if (actorRef._processingStatus === guards_dist_xstateGuards.ProcessingStatus.Stopped) {
         return;
       }
-      try {
-        actorRef.start?.();
-      } catch (err) {
-        actorScope.self.send(guards_dist_xstateGuards.createErrorActorEvent(actorRef.id, err));
-        return;
-      }
+      actorRef.start();
     });
     return actorRef;
   };

package/dist/xstate.cjs.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var actors_dist_xstateActors = require('../actors/dist/xstate-actors.cjs.js');
-var guards_dist_xstateGuards = require('./raise-cd0dde81.cjs.js');
-var send = require('./send-355ba004.cjs.js');
+var guards_dist_xstateGuards = require('./raise-8176cd35.cjs.js');
+var send = require('./send-7f3db830.cjs.js');
 require('../dev/dist/xstate-dev.cjs.js');
 
 class SimulatedClock {
@@ -372,7 +372,6 @@ class StateMachine {
      */
     this.version = void 0;
     this.implementations = void 0;
-    this.types = void 0;
     this.__xstatenode = true;
     this.idMap = new Map();
     this.root = void 0;
@@ -389,7 +388,6 @@ class StateMachine {
       guards: implementations?.guards ?? {}
     };
     this.version = this.config.version;
-    this.types = this.config.types ?? {};
     this.transition = this.transition.bind(this);
     this.getInitialState = this.getInitialState.bind(this);
     this.restoreState = this.restoreState.bind(this);
@@ -453,24 +451,14 @@ class StateMachine {
   }
 
   /**
-   * Determines the next state given the current `state` and received `event`.
+   * Determines the next snapshot given the current `snapshot` and received `event`.
    * Calculates a full macrostep from all microsteps.
    *
-   * @param state The current State instance or state value
+   * @param snapshot The current snapshot
    * @param event The received event
    */
-  transition(state, event, actorScope) {
-    // TODO: handle error events in a better way
-    if (guards_dist_xstateGuards.isErrorActorEvent(event) && !guards_dist_xstateGuards.getAllOwnEventDescriptors(state).some(nextEvent => nextEvent === event.type)) {
-      return guards_dist_xstateGuards.cloneMachineSnapshot(state, {
-        status: 'error',
-        error: event.data
-      });
-    }
-    const {
-      state: nextState
-    } = guards_dist_xstateGuards.macrostep(state, event, actorScope);
-    return nextState;
+  transition(snapshot, event, actorScope) {
+    return guards_dist_xstateGuards.macrostep(snapshot, event, actorScope).state;
   }
 
   /**
@@ -483,8 +471,8 @@ class StateMachine {
   microstep(state, event, actorScope) {
     return guards_dist_xstateGuards.macrostep(state, event, actorScope).microstates;
   }
-  getTransitionData(state, event) {
-    return guards_dist_xstateGuards.transitionNode(this.root, state.value, state, event) || [];
+  getTransitionData(snapshot, event) {
+    return guards_dist_xstateGuards.transitionNode(this.root, snapshot.value, snapshot, event) || [];
   }
 
   /**
@@ -679,6 +667,9 @@ function waitFor(actorRef, predicate, options) {
   });
 }
 
+// this is not 100% accurate since we can't make parallel regions required in the result
+// `TTestValue` doesn't encode this information anyhow for us to be able to do that
+// this is fine for most practical use cases anyway though
 function createMachine(config, implementations) {
   return new StateMachine(config, implementations);
 }

package/dist/xstate.development.cjs.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var actors_dist_xstateActors = require('../actors/dist/xstate-actors.development.cjs.js');
-var guards_dist_xstateGuards = require('./raise-0eafc1df.development.cjs.js');
-var send = require('./send-32a63473.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-dc9c2c58.development.cjs.js');
+var send = require('./send-df1c8ef2.development.cjs.js');
 require('../dev/dist/xstate-dev.development.cjs.js');
 
 class SimulatedClock {
@@ -372,7 +372,6 @@ class StateMachine {
      */
     this.version = void 0;
     this.implementations = void 0;
-    this.types = void 0;
     this.__xstatenode = true;
     this.idMap = new Map();
     this.root = void 0;
@@ -389,7 +388,6 @@ class StateMachine {
       guards: implementations?.guards ?? {}
     };
     this.version = this.config.version;
-    this.types = this.config.types ?? {};
     this.transition = this.transition.bind(this);
     this.getInitialState = this.getInitialState.bind(this);
     this.restoreState = this.restoreState.bind(this);
@@ -456,24 +454,14 @@ class StateMachine {
   }
 
   /**
-   * Determines the next state given the current `state` and received `event`.
+   * Determines the next snapshot given the current `snapshot` and received `event`.
    * Calculates a full macrostep from all microsteps.
    *
-   * @param state The current State instance or state value
+   * @param snapshot The current snapshot
    * @param event The received event
    */
-  transition(state, event, actorScope) {
-    // TODO: handle error events in a better way
-    if (guards_dist_xstateGuards.isErrorActorEvent(event) && !guards_dist_xstateGuards.getAllOwnEventDescriptors(state).some(nextEvent => nextEvent === event.type)) {
-      return guards_dist_xstateGuards.cloneMachineSnapshot(state, {
-        status: 'error',
-        error: event.data
-      });
-    }
-    const {
-      state: nextState
-    } = guards_dist_xstateGuards.macrostep(state, event, actorScope);
-    return nextState;
+  transition(snapshot, event, actorScope) {
+    return guards_dist_xstateGuards.macrostep(snapshot, event, actorScope).state;
   }
 
   /**
@@ -486,8 +474,8 @@ class StateMachine {
   microstep(state, event, actorScope) {
     return guards_dist_xstateGuards.macrostep(state, event, actorScope).microstates;
   }
-  getTransitionData(state, event) {
-    return guards_dist_xstateGuards.transitionNode(this.root, state.value, state, event) || [];
+  getTransitionData(snapshot, event) {
+    return guards_dist_xstateGuards.transitionNode(this.root, snapshot.value, snapshot, event) || [];
   }
 
   /**
@@ -685,6 +673,9 @@ function waitFor(actorRef, predicate, options) {
   });
 }
 
+// this is not 100% accurate since we can't make parallel regions required in the result
+// `TTestValue` doesn't encode this information anyhow for us to be able to do that
+// this is fine for most practical use cases anyway though
 function createMachine(config, implementations) {
   return new StateMachine(config, implementations);
 }

package/dist/xstate.development.esm.js

@@ -1,8 +1,8 @@
 export { createEmptyActor, fromCallback, fromEventObservable, fromObservable, fromPromise, fromTransition } from '../actors/dist/xstate-actors.development.esm.js';
-import { S as STATE_DELIMITER, m as mapValues, t as toArray, f as formatTransitions, a as toTransitionConfigArray, b as formatTransition, N as NULL_EVENT, e as evaluateGuard, c as createInvokeId, g as getDelayedTransitions, d as formatInitialTransition, h as getCandidates, r as resolveStateValue, i as getAllStateNodes, j as getStateNodes, k as createMachineSnapshot, l as isInFinalState, n as isErrorActorEvent, o as getAllOwnEventDescriptors, p as cloneMachineSnapshot, q as macrostep, s as transitionNode, u as resolveActionsAndContext, v as createInitEvent, w as microstep, x as getInitialStateNodes, y as isStateId, z as getStateNodeByPath, A as getPersistedState, B as resolveReferencedActor, C as createActor, $ as $$ACTOR_TYPE } from './raise-286581d5.development.esm.js';
-export { D as Actor, o as __unsafe_getAllOwnEventDescriptors, J as and, O as cancel, C as createActor, j as getStateNodes, E as interpret, F as isMachineSnapshot, G as matchesState, K as not, L as or, H as pathToStateValue, P as raise, T as spawnChild, M as stateIn, Q as stop, R as stopChild, I as toObserver } from './raise-286581d5.development.esm.js';
-import { a as assign } from './send-f0a3179c.development.esm.js';
-export { S as SpecialTargets, a as assign, c as choose, e as escalate, f as forwardTo, l as log, p as pure, s as sendParent, b as sendTo } from './send-f0a3179c.development.esm.js';
+import { S as STATE_DELIMITER, m as mapValues, t as toArray, f as formatTransitions, a as toTransitionConfigArray, b as formatTransition, N as NULL_EVENT, e as evaluateGuard, c as createInvokeId, g as getDelayedTransitions, d as formatInitialTransition, h as getCandidates, r as resolveStateValue, i as getAllStateNodes, j as getStateNodes, k as createMachineSnapshot, l as isInFinalState, n as macrostep, o as transitionNode, p as resolveActionsAndContext, q as createInitEvent, s as microstep, u as getInitialStateNodes, v as isStateId, w as getStateNodeByPath, x as getPersistedState, y as resolveReferencedActor, z as createActor, $ as $$ACTOR_TYPE } from './raise-6c05c91b.development.esm.js';
+export { A as Actor, G as __unsafe_getAllOwnEventDescriptors, H as and, L as cancel, z as createActor, j as getStateNodes, B as interpret, C as isMachineSnapshot, D as matchesState, I as not, J as or, E as pathToStateValue, M as raise, Q as spawnChild, K as stateIn, O as stop, P as stopChild, F as toObserver } from './raise-6c05c91b.development.esm.js';
+import { a as assign } from './send-2b001f05.development.esm.js';
+export { S as SpecialTargets, a as assign, c as choose, e as escalate, f as forwardTo, l as log, p as pure, s as sendParent, b as sendTo } from './send-2b001f05.development.esm.js';
 import '../dev/dist/xstate-dev.development.esm.js';
 
 class SimulatedClock {
@@ -370,7 +370,6 @@ class StateMachine {
      */
     this.version = void 0;
     this.implementations = void 0;
-    this.types = void 0;
     this.__xstatenode = true;
     this.idMap = new Map();
     this.root = void 0;
@@ -387,7 +386,6 @@ class StateMachine {
       guards: implementations?.guards ?? {}
     };
     this.version = this.config.version;
-    this.types = this.config.types ?? {};
     this.transition = this.transition.bind(this);
     this.getInitialState = this.getInitialState.bind(this);
     this.restoreState = this.restoreState.bind(this);
@@ -454,24 +452,14 @@ class StateMachine {
   }
 
   /**
-   * Determines the next state given the current `state` and received `event`.
+   * Determines the next snapshot given the current `snapshot` and received `event`.
    * Calculates a full macrostep from all microsteps.
    *
-   * @param state The current State instance or state value
+   * @param snapshot The current snapshot
    * @param event The received event
    */
-  transition(state, event, actorScope) {
-    // TODO: handle error events in a better way
-    if (isErrorActorEvent(event) && !getAllOwnEventDescriptors(state).some(nextEvent => nextEvent === event.type)) {
-      return cloneMachineSnapshot(state, {
-        status: 'error',
-        error: event.data
-      });
-    }
-    const {
-      state: nextState
-    } = macrostep(state, event, actorScope);
-    return nextState;
+  transition(snapshot, event, actorScope) {
+    return macrostep(snapshot, event, actorScope).state;
   }
 
   /**
@@ -484,8 +472,8 @@ class StateMachine {
   microstep(state, event, actorScope) {
     return macrostep(state, event, actorScope).microstates;
   }
-  getTransitionData(state, event) {
-    return transitionNode(this.root, state.value, state, event) || [];
+  getTransitionData(snapshot, event) {
+    return transitionNode(this.root, snapshot.value, snapshot, event) || [];
   }
 
   /**
@@ -683,6 +671,9 @@ function waitFor(actorRef, predicate, options) {
   });
 }
 
+// this is not 100% accurate since we can't make parallel regions required in the result
+// `TTestValue` doesn't encode this information anyhow for us to be able to do that
+// this is fine for most practical use cases anyway though
 function createMachine(config, implementations) {
   return new StateMachine(config, implementations);
 }

package/dist/xstate.esm.js

@@ -1,8 +1,8 @@
 export { createEmptyActor, fromCallback, fromEventObservable, fromObservable, fromPromise, fromTransition } from '../actors/dist/xstate-actors.esm.js';
-import { S as STATE_DELIMITER, m as mapValues, t as toArray, f as formatTransitions, a as toTransitionConfigArray, b as formatTransition, N as NULL_EVENT, e as evaluateGuard, c as createInvokeId, g as getDelayedTransitions, d as formatInitialTransition, h as getCandidates, r as resolveStateValue, i as getAllStateNodes, j as getStateNodes, k as createMachineSnapshot, l as isInFinalState, n as isErrorActorEvent, o as getAllOwnEventDescriptors, p as cloneMachineSnapshot, q as macrostep, s as transitionNode, u as resolveActionsAndContext, v as createInitEvent, w as microstep, x as getInitialStateNodes, y as isStateId, z as getStateNodeByPath, A as getPersistedState, B as resolveReferencedActor, C as createActor, $ as $$ACTOR_TYPE } from './raise-84fd7a92.esm.js';
-export { D as Actor, o as __unsafe_getAllOwnEventDescriptors, J as and, O as cancel, C as createActor, j as getStateNodes, E as interpret, F as isMachineSnapshot, G as matchesState, K as not, L as or, H as pathToStateValue, P as raise, T as spawnChild, M as stateIn, Q as stop, R as stopChild, I as toObserver } from './raise-84fd7a92.esm.js';
-import { a as assign } from './send-ae491737.esm.js';
-export { S as SpecialTargets, a as assign, c as choose, e as escalate, f as forwardTo, l as log, p as pure, s as sendParent, b as sendTo } from './send-ae491737.esm.js';
+import { S as STATE_DELIMITER, m as mapValues, t as toArray, f as formatTransitions, a as toTransitionConfigArray, b as formatTransition, N as NULL_EVENT, e as evaluateGuard, c as createInvokeId, g as getDelayedTransitions, d as formatInitialTransition, h as getCandidates, r as resolveStateValue, i as getAllStateNodes, j as getStateNodes, k as createMachineSnapshot, l as isInFinalState, n as macrostep, o as transitionNode, p as resolveActionsAndContext, q as createInitEvent, s as microstep, u as getInitialStateNodes, v as isStateId, w as getStateNodeByPath, x as getPersistedState, y as resolveReferencedActor, z as createActor, $ as $$ACTOR_TYPE } from './raise-32ec7226.esm.js';
+export { A as Actor, G as __unsafe_getAllOwnEventDescriptors, H as and, L as cancel, z as createActor, j as getStateNodes, B as interpret, C as isMachineSnapshot, D as matchesState, I as not, J as or, E as pathToStateValue, M as raise, Q as spawnChild, K as stateIn, O as stop, P as stopChild, F as toObserver } from './raise-32ec7226.esm.js';
+import { a as assign } from './send-88351a33.esm.js';
+export { S as SpecialTargets, a as assign, c as choose, e as escalate, f as forwardTo, l as log, p as pure, s as sendParent, b as sendTo } from './send-88351a33.esm.js';
 import '../dev/dist/xstate-dev.esm.js';
 
 class SimulatedClock {
@@ -370,7 +370,6 @@ class StateMachine {
      */
     this.version = void 0;
     this.implementations = void 0;
-    this.types = void 0;
     this.__xstatenode = true;
     this.idMap = new Map();
     this.root = void 0;
@@ -387,7 +386,6 @@ class StateMachine {
       guards: implementations?.guards ?? {}
     };
     this.version = this.config.version;
-    this.types = this.config.types ?? {};
     this.transition = this.transition.bind(this);
     this.getInitialState = this.getInitialState.bind(this);
     this.restoreState = this.restoreState.bind(this);
@@ -451,24 +449,14 @@ class StateMachine {
   }
 
   /**
-   * Determines the next state given the current `state` and received `event`.
+   * Determines the next snapshot given the current `snapshot` and received `event`.
    * Calculates a full macrostep from all microsteps.
    *
-   * @param state The current State instance or state value
+   * @param snapshot The current snapshot
    * @param event The received event
    */
-  transition(state, event, actorScope) {
-    // TODO: handle error events in a better way
-    if (isErrorActorEvent(event) && !getAllOwnEventDescriptors(state).some(nextEvent => nextEvent === event.type)) {
-      return cloneMachineSnapshot(state, {
-        status: 'error',
-        error: event.data
-      });
-    }
-    const {
-      state: nextState
-    } = macrostep(state, event, actorScope);
-    return nextState;
+  transition(snapshot, event, actorScope) {
+    return macrostep(snapshot, event, actorScope).state;
   }
 
   /**
@@ -481,8 +469,8 @@ class StateMachine {
   microstep(state, event, actorScope) {
     return macrostep(state, event, actorScope).microstates;
   }
-  getTransitionData(state, event) {
-    return transitionNode(this.root, state.value, state, event) || [];
+  getTransitionData(snapshot, event) {
+    return transitionNode(this.root, snapshot.value, snapshot, event) || [];
   }
 
   /**
@@ -677,6 +665,9 @@ function waitFor(actorRef, predicate, options) {
   });
 }
 
+// this is not 100% accurate since we can't make parallel regions required in the result
+// `TTestValue` doesn't encode this information anyhow for us to be able to do that
+// this is fine for most practical use cases anyway though
 function createMachine(config, implementations) {
   return new StateMachine(config, implementations);
 }