xstate 5.25.0 → 5.26.0

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

@@ -1,4 +1,4 @@
-import { AnyActorLogic, EventFromLogic, InputFrom, SnapshotFrom, ExecutableActionsFrom } from "./types.js";
+import { AnyActorLogic, EventFromLogic, InputFrom, SnapshotFrom, ExecutableActionsFrom, AnyTransitionDefinition, AnyMachineSnapshot } from "./types.js";
 /**
  * Given actor `logic`, a `snapshot`, and an `event`, returns a tuple of the
  * `nextSnapshot` and `actions` to execute.
@@ -14,3 +14,28 @@ export declare function transition<T extends AnyActorLogic>(logic: T, snapshot:
  * This is a pure function that does not execute `actions`.
  */
 export declare function initialTransition<T extends AnyActorLogic>(logic: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): [SnapshotFrom<T>, ExecutableActionsFrom<T>[]];
+/**
+ * Gets all potential next transitions from the current state.
+ *
+ * Returns all transitions that are available from the current state, including:
+ *
+ * - All transitions from atomic states (leaf states in the current state
+ *   configuration)
+ * - All transitions from ancestor states (parent states that may handle events)
+ * - All guarded transitions (regardless of whether their guards would pass)
+ * - Always (eventless) transitions
+ * - After (delayed) transitions
+ *
+ * The order of transitions is deterministic:
+ *
+ * 1. Atomic states are processed in document order
+ * 2. For each atomic state, transitions are collected from the state itself first,
+ *    then its ancestors
+ * 3. Within each state node, transitions are in the order they appear in the state
+ *    definition
+ *
+ * @param state - The current machine snapshot
+ * @returns Array of transition definitions from the current state, in
+ *   deterministic order
+ */
+export declare function getNextTransitions(state: AnyMachineSnapshot): AnyTransitionDefinition[];

package/dist/{log-fbb00743.esm.js → log-46a8697a.esm.js}

@@ -1,5 +1,5 @@
-import { U as XSTATE_ERROR, V as createErrorActorEvent, x as evaluateGuard, a as cancel, r as raise, b as spawnChild, s as stopChild } from './raise-da2ff7ca.esm.js';
-import { a as assign } from './assign-fd69c737.esm.js';
+import { W as XSTATE_ERROR, Y as createErrorActorEvent, z as evaluateGuard, a as cancel, r as raise, b as spawnChild, s as stopChild } from './raise-f11495d1.esm.js';
+import { a as assign } from './assign-5d7df46f.esm.js';
 
 function resolveEmit(_, snapshot, args, actionParams, {
   event: eventOrExpr

package/dist/{log-bf2198dc.development.cjs.js → log-661c5df8.development.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-723edf2d.development.cjs.js');
-var assign = require('./assign-97062f30.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-e47e3273.development.cjs.js');
+var assign = require('./assign-6a45790f.development.cjs.js');
 
 function resolveEmit(_, snapshot, args, actionParams, {
   event: eventOrExpr

package/dist/{log-3eec9346.development.esm.js → log-d09f274f.development.esm.js}

@@ -1,5 +1,5 @@
-import { U as executingCustomAction, V as XSTATE_ERROR, W as createErrorActorEvent, x as evaluateGuard, a as cancel, r as raise, b as spawnChild, s as stopChild } from './raise-235fa0c7.development.esm.js';
-import { a as assign } from './assign-ef1b62f6.development.esm.js';
+import { W as executingCustomAction, Y as XSTATE_ERROR, Z as createErrorActorEvent, z as evaluateGuard, a as cancel, r as raise, b as spawnChild, s as stopChild } from './raise-13e2f823.development.esm.js';
+import { a as assign } from './assign-382e15e2.development.esm.js';
 
 function resolveEmit(_, snapshot, args, actionParams, {
   event: eventOrExpr

package/dist/{log-ec818628.cjs.js → log-fe39762e.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-ad4f12ad.cjs.js');
-var assign = require('./assign-ae103a72.cjs.js');
+var guards_dist_xstateGuards = require('./raise-df325116.cjs.js');
+var assign = require('./assign-9271e302.cjs.js');
 
 function resolveEmit(_, snapshot, args, actionParams, {
   event: eventOrExpr

package/dist/{raise-235fa0c7.development.esm.js → raise-13e2f823.development.esm.js}

@@ -968,12 +968,14 @@ class Actor {
       }
     }
     this.observers.clear();
+    this.eventListeners.clear();
   }
   _reportError(err) {
     if (!this.observers.size) {
       if (!this._parent) {
         reportUnhandledError(err);
       }
+      this.eventListeners.clear();
       return;
     }
     let reportError = false;
@@ -987,6 +989,7 @@ class Actor {
       }
     }
     this.observers.clear();
+    this.eventListeners.clear();
     if (reportError) {
       reportUnhandledError(err);
     }
@@ -1315,6 +1318,16 @@ function resolveStop(_, snapshot, args, actionParams, {
     children
   }), resolvedActorRef, undefined];
 }
+function unregisterRecursively(actorScope, actorRef) {
+  // unregister children first (depth-first)
+  const snapshot = actorRef.getSnapshot();
+  if (snapshot && 'children' in snapshot) {
+    for (const child of Object.values(snapshot.children)) {
+      unregisterRecursively(actorScope, child);
+    }
+  }
+  actorScope.system._unregister(actorRef);
+}
 function executeStop(actorScope, actorRef) {
   if (!actorRef) {
     return;
@@ -1323,7 +1336,8 @@ function executeStop(actorScope, actorRef) {
   // we need to eagerly unregister it here so a new actor with the same systemId can be registered immediately
   // since we defer actual stopping of the actor but we don't defer actor creations (and we can't do that)
   // this could throw on `systemId` collision, for example, when dealing with reentering transitions
-  actorScope.system._unregister(actorRef);
+  // we also need to recursively unregister all nested children's systemIds
+  unregisterRecursively(actorScope, actorRef);
 
   // this allows us to prevent an actor from being started if it gets stopped within the same macrostep
   // this can happen, for example, when the invoking state is being exited immediately by an always transition
@@ -1561,7 +1575,9 @@ function evaluateGuard(guard, context, event, snapshot) {
   );
 }
 
-const isAtomicStateNode = stateNode => stateNode.type === 'atomic' || stateNode.type === 'final';
+function isAtomicStateNode(stateNode) {
+  return stateNode.type === 'atomic' || stateNode.type === 'final';
+}
 function getChildren(stateNode) {
   return Object.values(stateNode.states).filter(sn => sn.type !== 'history');
 }
@@ -2727,4 +2743,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-export { $$ACTOR_TYPE as $, Actor as A, formatInitialTransition as B, getCandidates as C, resolveStateValue as D, getAllStateNodes as E, createMachineSnapshot as F, isInFinalState as G, macrostep as H, transitionNode as I, resolveActionsAndContext as J, createInitEvent as K, microstep as L, getInitialStateNodes as M, NULL_EVENT as N, toStatePath as O, isStateId as P, getStateNodeByPath as Q, getPersistedSnapshot as R, STATE_DELIMITER as S, resolveReferencedActor as T, executingCustomAction as U, XSTATE_ERROR as V, createErrorActorEvent as W, XSTATE_STOP as X, ProcessingStatus as Y, cloneMachineSnapshot as Z, cancel as a, spawnChild as b, createActor as c, and as d, stateIn as e, isMachineSnapshot as f, getStateNodes as g, getAllOwnEventDescriptors as h, interpret as i, matchesState as j, toObserver as k, stop as l, matchesEventDescriptor as m, not as n, or as o, pathToStateValue as p, mapValues as q, raise as r, stopChild as s, toArray as t, formatTransitions as u, toTransitionConfigArray as v, formatTransition as w, evaluateGuard as x, createInvokeId as y, getDelayedTransitions as z };
+export { $$ACTOR_TYPE as $, Actor as A, createInvokeId as B, getDelayedTransitions as C, formatInitialTransition as D, getCandidates as E, resolveStateValue as F, getAllStateNodes as G, createMachineSnapshot as H, isInFinalState as I, macrostep as J, transitionNode as K, resolveActionsAndContext as L, createInitEvent as M, NULL_EVENT as N, microstep as O, getInitialStateNodes as P, toStatePath as Q, isStateId as R, STATE_DELIMITER as S, getStateNodeByPath as T, getPersistedSnapshot as U, resolveReferencedActor as V, executingCustomAction as W, XSTATE_STOP as X, XSTATE_ERROR as Y, createErrorActorEvent as Z, ProcessingStatus as _, cancel as a, cloneMachineSnapshot as a0, spawnChild as b, createActor as c, interpret as d, and as e, stateIn as f, getProperAncestors as g, isMachineSnapshot as h, isAtomicStateNode as i, getStateNodes as j, getAllOwnEventDescriptors as k, matchesState as l, matchesEventDescriptor as m, not as n, or as o, pathToStateValue as p, toObserver as q, raise as r, stopChild as s, toArray as t, stop as u, mapValues as v, formatTransitions as w, toTransitionConfigArray as x, formatTransition as y, evaluateGuard as z };

package/dist/{raise-ad4f12ad.cjs.js → raise-df325116.cjs.js}

@@ -961,12 +961,14 @@ class Actor {
       }
     }
     this.observers.clear();
+    this.eventListeners.clear();
   }
   _reportError(err) {
     if (!this.observers.size) {
       if (!this._parent) {
         reportUnhandledError(err);
       }
+      this.eventListeners.clear();
       return;
     }
     let reportError = false;
@@ -980,6 +982,7 @@ class Actor {
       }
     }
     this.observers.clear();
+    this.eventListeners.clear();
     if (reportError) {
       reportUnhandledError(err);
     }
@@ -1286,6 +1289,16 @@ function resolveStop(_, snapshot, args, actionParams, {
     children
   }), resolvedActorRef, undefined];
 }
+function unregisterRecursively(actorScope, actorRef) {
+  // unregister children first (depth-first)
+  const snapshot = actorRef.getSnapshot();
+  if (snapshot && 'children' in snapshot) {
+    for (const child of Object.values(snapshot.children)) {
+      unregisterRecursively(actorScope, child);
+    }
+  }
+  actorScope.system._unregister(actorRef);
+}
 function executeStop(actorScope, actorRef) {
   if (!actorRef) {
     return;
@@ -1294,7 +1307,8 @@ function executeStop(actorScope, actorRef) {
   // we need to eagerly unregister it here so a new actor with the same systemId can be registered immediately
   // since we defer actual stopping of the actor but we don't defer actor creations (and we can't do that)
   // this could throw on `systemId` collision, for example, when dealing with reentering transitions
-  actorScope.system._unregister(actorRef);
+  // we also need to recursively unregister all nested children's systemIds
+  unregisterRecursively(actorScope, actorRef);
 
   // this allows us to prevent an actor from being started if it gets stopped within the same macrostep
   // this can happen, for example, when the invoking state is being exited immediately by an always transition
@@ -1521,7 +1535,9 @@ function evaluateGuard(guard, context, event, snapshot) {
   );
 }
 
-const isAtomicStateNode = stateNode => stateNode.type === 'atomic' || stateNode.type === 'final';
+function isAtomicStateNode(stateNode) {
+  return stateNode.type === 'atomic' || stateNode.type === 'final';
+}
 function getChildren(stateNode) {
   return Object.values(stateNode.states).filter(sn => sn.type !== 'history');
 }
@@ -2692,9 +2708,11 @@ exports.getCandidates = getCandidates;
 exports.getDelayedTransitions = getDelayedTransitions;
 exports.getInitialStateNodes = getInitialStateNodes;
 exports.getPersistedSnapshot = getPersistedSnapshot;
+exports.getProperAncestors = getProperAncestors;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
 exports.interpret = interpret;
+exports.isAtomicStateNode = isAtomicStateNode;
 exports.isInFinalState = isInFinalState;
 exports.isMachineSnapshot = isMachineSnapshot;
 exports.isStateId = isStateId;

package/dist/{raise-723edf2d.development.cjs.js → raise-e47e3273.development.cjs.js}

@@ -970,12 +970,14 @@ class Actor {
       }
     }
     this.observers.clear();
+    this.eventListeners.clear();
   }
   _reportError(err) {
     if (!this.observers.size) {
       if (!this._parent) {
         reportUnhandledError(err);
       }
+      this.eventListeners.clear();
       return;
     }
     let reportError = false;
@@ -989,6 +991,7 @@ class Actor {
       }
     }
     this.observers.clear();
+    this.eventListeners.clear();
     if (reportError) {
       reportUnhandledError(err);
     }
@@ -1317,6 +1320,16 @@ function resolveStop(_, snapshot, args, actionParams, {
     children
   }), resolvedActorRef, undefined];
 }
+function unregisterRecursively(actorScope, actorRef) {
+  // unregister children first (depth-first)
+  const snapshot = actorRef.getSnapshot();
+  if (snapshot && 'children' in snapshot) {
+    for (const child of Object.values(snapshot.children)) {
+      unregisterRecursively(actorScope, child);
+    }
+  }
+  actorScope.system._unregister(actorRef);
+}
 function executeStop(actorScope, actorRef) {
   if (!actorRef) {
     return;
@@ -1325,7 +1338,8 @@ function executeStop(actorScope, actorRef) {
   // we need to eagerly unregister it here so a new actor with the same systemId can be registered immediately
   // since we defer actual stopping of the actor but we don't defer actor creations (and we can't do that)
   // this could throw on `systemId` collision, for example, when dealing with reentering transitions
-  actorScope.system._unregister(actorRef);
+  // we also need to recursively unregister all nested children's systemIds
+  unregisterRecursively(actorScope, actorRef);
 
   // this allows us to prevent an actor from being started if it gets stopped within the same macrostep
   // this can happen, for example, when the invoking state is being exited immediately by an always transition
@@ -1563,7 +1577,9 @@ function evaluateGuard(guard, context, event, snapshot) {
   );
 }
 
-const isAtomicStateNode = stateNode => stateNode.type === 'atomic' || stateNode.type === 'final';
+function isAtomicStateNode(stateNode) {
+  return stateNode.type === 'atomic' || stateNode.type === 'final';
+}
 function getChildren(stateNode) {
   return Object.values(stateNode.states).filter(sn => sn.type !== 'history');
 }
@@ -2754,9 +2770,11 @@ exports.getCandidates = getCandidates;
 exports.getDelayedTransitions = getDelayedTransitions;
 exports.getInitialStateNodes = getInitialStateNodes;
 exports.getPersistedSnapshot = getPersistedSnapshot;
+exports.getProperAncestors = getProperAncestors;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
 exports.interpret = interpret;
+exports.isAtomicStateNode = isAtomicStateNode;
 exports.isInFinalState = isInFinalState;
 exports.isMachineSnapshot = isMachineSnapshot;
 exports.isStateId = isStateId;

package/dist/{raise-da2ff7ca.esm.js → raise-f11495d1.esm.js}

@@ -959,12 +959,14 @@ class Actor {
       }
     }
     this.observers.clear();
+    this.eventListeners.clear();
   }
   _reportError(err) {
     if (!this.observers.size) {
       if (!this._parent) {
         reportUnhandledError(err);
       }
+      this.eventListeners.clear();
       return;
     }
     let reportError = false;
@@ -978,6 +980,7 @@ class Actor {
       }
     }
     this.observers.clear();
+    this.eventListeners.clear();
     if (reportError) {
       reportUnhandledError(err);
     }
@@ -1284,6 +1287,16 @@ function resolveStop(_, snapshot, args, actionParams, {
     children
   }), resolvedActorRef, undefined];
 }
+function unregisterRecursively(actorScope, actorRef) {
+  // unregister children first (depth-first)
+  const snapshot = actorRef.getSnapshot();
+  if (snapshot && 'children' in snapshot) {
+    for (const child of Object.values(snapshot.children)) {
+      unregisterRecursively(actorScope, child);
+    }
+  }
+  actorScope.system._unregister(actorRef);
+}
 function executeStop(actorScope, actorRef) {
   if (!actorRef) {
     return;
@@ -1292,7 +1305,8 @@ function executeStop(actorScope, actorRef) {
   // we need to eagerly unregister it here so a new actor with the same systemId can be registered immediately
   // since we defer actual stopping of the actor but we don't defer actor creations (and we can't do that)
   // this could throw on `systemId` collision, for example, when dealing with reentering transitions
-  actorScope.system._unregister(actorRef);
+  // we also need to recursively unregister all nested children's systemIds
+  unregisterRecursively(actorScope, actorRef);
 
   // this allows us to prevent an actor from being started if it gets stopped within the same macrostep
   // this can happen, for example, when the invoking state is being exited immediately by an always transition
@@ -1519,7 +1533,9 @@ function evaluateGuard(guard, context, event, snapshot) {
   );
 }
 
-const isAtomicStateNode = stateNode => stateNode.type === 'atomic' || stateNode.type === 'final';
+function isAtomicStateNode(stateNode) {
+  return stateNode.type === 'atomic' || stateNode.type === 'final';
+}
 function getChildren(stateNode) {
   return Object.values(stateNode.states).filter(sn => sn.type !== 'history');
 }
@@ -2665,4 +2681,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-export { $$ACTOR_TYPE as $, Actor as A, formatInitialTransition as B, getCandidates as C, resolveStateValue as D, getAllStateNodes as E, createMachineSnapshot as F, isInFinalState as G, macrostep as H, transitionNode as I, resolveActionsAndContext as J, createInitEvent as K, microstep as L, getInitialStateNodes as M, NULL_EVENT as N, toStatePath as O, isStateId as P, getStateNodeByPath as Q, getPersistedSnapshot as R, STATE_DELIMITER as S, resolveReferencedActor as T, XSTATE_ERROR as U, createErrorActorEvent as V, ProcessingStatus as W, XSTATE_STOP as X, cloneMachineSnapshot as Y, cancel as a, spawnChild as b, createActor as c, and as d, stateIn as e, isMachineSnapshot as f, getStateNodes as g, getAllOwnEventDescriptors as h, interpret as i, matchesState as j, toObserver as k, stop as l, matchesEventDescriptor as m, not as n, or as o, pathToStateValue as p, mapValues as q, raise as r, stopChild as s, toArray as t, formatTransitions as u, toTransitionConfigArray as v, formatTransition as w, evaluateGuard as x, createInvokeId as y, getDelayedTransitions as z };
+export { $$ACTOR_TYPE as $, Actor as A, createInvokeId as B, getDelayedTransitions as C, formatInitialTransition as D, getCandidates as E, resolveStateValue as F, getAllStateNodes as G, createMachineSnapshot as H, isInFinalState as I, macrostep as J, transitionNode as K, resolveActionsAndContext as L, createInitEvent as M, NULL_EVENT as N, microstep as O, getInitialStateNodes as P, toStatePath as Q, isStateId as R, STATE_DELIMITER as S, getStateNodeByPath as T, getPersistedSnapshot as U, resolveReferencedActor as V, XSTATE_ERROR as W, XSTATE_STOP as X, createErrorActorEvent as Y, ProcessingStatus as Z, cloneMachineSnapshot as _, cancel as a, spawnChild as b, createActor as c, interpret as d, and as e, stateIn as f, getProperAncestors as g, isMachineSnapshot as h, isAtomicStateNode as i, getStateNodes as j, getAllOwnEventDescriptors as k, matchesState as l, matchesEventDescriptor as m, not as n, or as o, pathToStateValue as p, toObserver as q, raise as r, stopChild as s, toArray as t, stop as u, mapValues as v, formatTransitions as w, toTransitionConfigArray as x, formatTransition as y, evaluateGuard as z };

package/dist/xstate.cjs.js

@@ -3,10 +3,10 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var actors_dist_xstateActors = require('../actors/dist/xstate-actors.cjs.js');
-var guards_dist_xstateGuards = require('./raise-ad4f12ad.cjs.js');
-var StateMachine = require('./StateMachine-f73271f9.cjs.js');
-var assign = require('./assign-ae103a72.cjs.js');
-var log = require('./log-ec818628.cjs.js');
+var guards_dist_xstateGuards = require('./raise-df325116.cjs.js');
+var StateMachine = require('./StateMachine-29d33e13.cjs.js');
+var assign = require('./assign-9271e302.cjs.js');
+var log = require('./log-fe39762e.cjs.js');
 require('../dev/dist/xstate-dev.cjs.js');
 
 /**
@@ -338,6 +338,62 @@ function initialTransition(logic, ...[input]) {
   return [nextSnapshot, executableActions];
 }
 
+/**
+ * Gets all potential next transitions from the current state.
+ *
+ * Returns all transitions that are available from the current state, including:
+ *
+ * - All transitions from atomic states (leaf states in the current state
+ *   configuration)
+ * - All transitions from ancestor states (parent states that may handle events)
+ * - All guarded transitions (regardless of whether their guards would pass)
+ * - Always (eventless) transitions
+ * - After (delayed) transitions
+ *
+ * The order of transitions is deterministic:
+ *
+ * 1. Atomic states are processed in document order
+ * 2. For each atomic state, transitions are collected from the state itself first,
+ *    then its ancestors
+ * 3. Within each state node, transitions are in the order they appear in the state
+ *    definition
+ *
+ * @param state - The current machine snapshot
+ * @returns Array of transition definitions from the current state, in
+ *   deterministic order
+ */
+function getNextTransitions(state) {
+  const potentialTransitions = [];
+  const atomicStates = state._nodes.filter(guards_dist_xstateGuards.isAtomicStateNode);
+  const visited = new Set();
+
+  // Collect all transitions from atomic states and their ancestors
+  // Process atomic states in document order (as they appear in state._nodes)
+  for (const stateNode of atomicStates) {
+    // For each atomic state, process the state itself first, then its ancestors
+    // This ensures child state transitions come before parent state transitions
+    for (const s of [stateNode].concat(guards_dist_xstateGuards.getProperAncestors(stateNode, undefined))) {
+      if (visited.has(s.id)) {
+        continue;
+      }
+      visited.add(s.id);
+
+      // Get all transitions for each event type
+      // Include ALL transitions, even if the same event type appears in multiple state nodes
+      // This is important for guarded transitions - all are "potential" regardless of guard evaluation
+      for (const [, transitions] of s.transitions) {
+        potentialTransitions.push(...transitions);
+      }
+
+      // Also include always (eventless) transitions
+      if (s.always) {
+        potentialTransitions.push(...s.always);
+      }
+    }
+  }
+  return potentialTransitions;
+}
+
 const defaultWaitForOptions = {
   timeout: Infinity // much more than 10 seconds
 };
@@ -478,6 +534,7 @@ exports.assertEvent = assertEvent;
 exports.createMachine = createMachine;
 exports.getInitialSnapshot = getInitialSnapshot;
 exports.getNextSnapshot = getNextSnapshot;
+exports.getNextTransitions = getNextTransitions;
 exports.initialTransition = initialTransition;
 exports.setup = setup;
 exports.toPromise = toPromise;

package/dist/xstate.cjs.mjs

@@ -22,6 +22,7 @@ export {
   fromTransition,
   getInitialSnapshot,
   getNextSnapshot,
+  getNextTransitions,
   getStateNodes,
   initialTransition,
   interpret,

package/dist/xstate.development.cjs.js

@@ -3,10 +3,10 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var actors_dist_xstateActors = require('../actors/dist/xstate-actors.development.cjs.js');
-var guards_dist_xstateGuards = require('./raise-723edf2d.development.cjs.js');
-var StateMachine = require('./StateMachine-e3bf357b.development.cjs.js');
-var assign = require('./assign-97062f30.development.cjs.js');
-var log = require('./log-bf2198dc.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-e47e3273.development.cjs.js');
+var StateMachine = require('./StateMachine-3a7b3253.development.cjs.js');
+var assign = require('./assign-6a45790f.development.cjs.js');
+var log = require('./log-661c5df8.development.cjs.js');
 require('../dev/dist/xstate-dev.development.cjs.js');
 
 /**
@@ -338,6 +338,62 @@ function initialTransition(logic, ...[input]) {
   return [nextSnapshot, executableActions];
 }
 
+/**
+ * Gets all potential next transitions from the current state.
+ *
+ * Returns all transitions that are available from the current state, including:
+ *
+ * - All transitions from atomic states (leaf states in the current state
+ *   configuration)
+ * - All transitions from ancestor states (parent states that may handle events)
+ * - All guarded transitions (regardless of whether their guards would pass)
+ * - Always (eventless) transitions
+ * - After (delayed) transitions
+ *
+ * The order of transitions is deterministic:
+ *
+ * 1. Atomic states are processed in document order
+ * 2. For each atomic state, transitions are collected from the state itself first,
+ *    then its ancestors
+ * 3. Within each state node, transitions are in the order they appear in the state
+ *    definition
+ *
+ * @param state - The current machine snapshot
+ * @returns Array of transition definitions from the current state, in
+ *   deterministic order
+ */
+function getNextTransitions(state) {
+  const potentialTransitions = [];
+  const atomicStates = state._nodes.filter(guards_dist_xstateGuards.isAtomicStateNode);
+  const visited = new Set();
+
+  // Collect all transitions from atomic states and their ancestors
+  // Process atomic states in document order (as they appear in state._nodes)
+  for (const stateNode of atomicStates) {
+    // For each atomic state, process the state itself first, then its ancestors
+    // This ensures child state transitions come before parent state transitions
+    for (const s of [stateNode].concat(guards_dist_xstateGuards.getProperAncestors(stateNode, undefined))) {
+      if (visited.has(s.id)) {
+        continue;
+      }
+      visited.add(s.id);
+
+      // Get all transitions for each event type
+      // Include ALL transitions, even if the same event type appears in multiple state nodes
+      // This is important for guarded transitions - all are "potential" regardless of guard evaluation
+      for (const [, transitions] of s.transitions) {
+        potentialTransitions.push(...transitions);
+      }
+
+      // Also include always (eventless) transitions
+      if (s.always) {
+        potentialTransitions.push(...s.always);
+      }
+    }
+  }
+  return potentialTransitions;
+}
+
 const defaultWaitForOptions = {
   timeout: Infinity // much more than 10 seconds
 };
@@ -481,6 +537,7 @@ exports.assertEvent = assertEvent;
 exports.createMachine = createMachine;
 exports.getInitialSnapshot = getInitialSnapshot;
 exports.getNextSnapshot = getNextSnapshot;
+exports.getNextTransitions = getNextTransitions;
 exports.initialTransition = initialTransition;
 exports.setup = setup;
 exports.toPromise = toPromise;

package/dist/xstate.development.cjs.mjs

@@ -22,6 +22,7 @@ export {
   fromTransition,
   getInitialSnapshot,
   getNextSnapshot,
+  getNextTransitions,
   getStateNodes,
   initialTransition,
   interpret,

package/dist/xstate.development.esm.js

@@ -1,12 +1,12 @@
 export { createEmptyActor, fromCallback, fromEventObservable, fromObservable, fromPromise, fromTransition } from '../actors/dist/xstate-actors.development.esm.js';
-import { m as matchesEventDescriptor, t as toArray, c as createActor, r as raise, a as cancel, s as stopChild, b as spawnChild } from './raise-235fa0c7.development.esm.js';
-export { A as Actor, h as __unsafe_getAllOwnEventDescriptors, d as and, a as cancel, c as createActor, g as getStateNodes, i as interpret, f as isMachineSnapshot, j as matchesState, n as not, o as or, p as pathToStateValue, r as raise, b as spawnChild, e as stateIn, l as stop, s as stopChild, k as toObserver } from './raise-235fa0c7.development.esm.js';
-import { S as StateMachine } from './StateMachine-53479528.development.esm.js';
-export { S as StateMachine, a as StateNode } from './StateMachine-53479528.development.esm.js';
-import { a as assign } from './assign-ef1b62f6.development.esm.js';
-export { a as assign } from './assign-ef1b62f6.development.esm.js';
-import { s as sendTo, l as log, e as enqueueActions, a as emit } from './log-3eec9346.development.esm.js';
-export { S as SpecialTargets, a as emit, e as enqueueActions, f as forwardTo, l as log, b as sendParent, s as sendTo } from './log-3eec9346.development.esm.js';
+import { m as matchesEventDescriptor, t as toArray, c as createActor, r as raise, a as cancel, s as stopChild, b as spawnChild, i as isAtomicStateNode, g as getProperAncestors } from './raise-13e2f823.development.esm.js';
+export { A as Actor, k as __unsafe_getAllOwnEventDescriptors, e as and, a as cancel, c as createActor, j as getStateNodes, d as interpret, h as isMachineSnapshot, l as matchesState, n as not, o as or, p as pathToStateValue, r as raise, b as spawnChild, f as stateIn, u as stop, s as stopChild, q as toObserver } from './raise-13e2f823.development.esm.js';
+import { S as StateMachine } from './StateMachine-ceed8de1.development.esm.js';
+export { S as StateMachine, a as StateNode } from './StateMachine-ceed8de1.development.esm.js';
+import { a as assign } from './assign-382e15e2.development.esm.js';
+export { a as assign } from './assign-382e15e2.development.esm.js';
+import { s as sendTo, l as log, e as enqueueActions, a as emit } from './log-d09f274f.development.esm.js';
+export { S as SpecialTargets, a as emit, e as enqueueActions, f as forwardTo, l as log, b as sendParent, s as sendTo } from './log-d09f274f.development.esm.js';
 import '../dev/dist/xstate-dev.development.esm.js';
 
 /**
@@ -338,6 +338,62 @@ function initialTransition(logic, ...[input]) {
   return [nextSnapshot, executableActions];
 }
 
+/**
+ * Gets all potential next transitions from the current state.
+ *
+ * Returns all transitions that are available from the current state, including:
+ *
+ * - All transitions from atomic states (leaf states in the current state
+ *   configuration)
+ * - All transitions from ancestor states (parent states that may handle events)
+ * - All guarded transitions (regardless of whether their guards would pass)
+ * - Always (eventless) transitions
+ * - After (delayed) transitions
+ *
+ * The order of transitions is deterministic:
+ *
+ * 1. Atomic states are processed in document order
+ * 2. For each atomic state, transitions are collected from the state itself first,
+ *    then its ancestors
+ * 3. Within each state node, transitions are in the order they appear in the state
+ *    definition
+ *
+ * @param state - The current machine snapshot
+ * @returns Array of transition definitions from the current state, in
+ *   deterministic order
+ */
+function getNextTransitions(state) {
+  const potentialTransitions = [];
+  const atomicStates = state._nodes.filter(isAtomicStateNode);
+  const visited = new Set();
+
+  // Collect all transitions from atomic states and their ancestors
+  // Process atomic states in document order (as they appear in state._nodes)
+  for (const stateNode of atomicStates) {
+    // For each atomic state, process the state itself first, then its ancestors
+    // This ensures child state transitions come before parent state transitions
+    for (const s of [stateNode].concat(getProperAncestors(stateNode, undefined))) {
+      if (visited.has(s.id)) {
+        continue;
+      }
+      visited.add(s.id);
+
+      // Get all transitions for each event type
+      // Include ALL transitions, even if the same event type appears in multiple state nodes
+      // This is important for guarded transitions - all are "potential" regardless of guard evaluation
+      for (const [, transitions] of s.transitions) {
+        potentialTransitions.push(...transitions);
+      }
+
+      // Also include always (eventless) transitions
+      if (s.always) {
+        potentialTransitions.push(...s.always);
+      }
+    }
+  }
+  return potentialTransitions;
+}
+
 const defaultWaitForOptions = {
   timeout: Infinity // much more than 10 seconds
 };
@@ -442,4 +498,4 @@ function waitFor(actorRef, predicate, options) {
   });
 }
 
-export { SimulatedClock, assertEvent, createMachine, getInitialSnapshot, getNextSnapshot, initialTransition, setup, toPromise, transition, waitFor };
+export { SimulatedClock, assertEvent, createMachine, getInitialSnapshot, getNextSnapshot, getNextTransitions, initialTransition, setup, toPromise, transition, waitFor };