xstate 5.0.0-beta.34 → 5.0.0-beta.36

package/dist/{raise-38b707c0.development.cjs.js → raise-106ea558.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var interpreter = require('./interpreter-70ed62f2.development.cjs.js');
+var interpreter = require('./interpreter-d3567419.development.cjs.js');
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -299,20 +299,6 @@ function evaluateGuard(guard, context, event, state) {
   );
 }
 
-function getOutput(configuration, context, event, self) {
-  const {
-    machine
-  } = configuration[0];
-  const {
-    root
-  } = machine;
-  if (!root.output) {
-    return undefined;
-  }
-  const finalChildStateNode = configuration.find(stateNode => stateNode.type === 'final' && stateNode.parent === machine.root);
-  const doneStateEvent = interpreter.createDoneStateEvent(finalChildStateNode.id, finalChildStateNode.output ? interpreter.resolveOutput(finalChildStateNode.output, context, event, self) : undefined);
-  return interpreter.resolveOutput(root.output, context, doneStateEvent, self);
-}
 const isAtomicStateNode = stateNode => stateNode.type === 'atomic' || stateNode.type === 'final';
 function getChildren(stateNode) {
   return Object.values(stateNode.states).filter(sn => sn.type !== 'history');
@@ -337,7 +323,7 @@ function getConfiguration(stateNodes) {
   for (const s of configuration) {
     // if previously active, add existing child nodes
     if (s.type === 'compound' && (!adjList.get(s) || !adjList.get(s).length)) {
-      getInitialStateNodes(s).forEach(sn => configurationSet.add(sn));
+      getInitialStateNodesWithTheirAncestors(s).forEach(sn => configurationSet.add(sn));
     } else {
       if (s.type === 'parallel') {
         for (const child of getChildren(s)) {
@@ -345,7 +331,8 @@ function getConfiguration(stateNodes) {
             continue;
           }
           if (!configurationSet.has(child)) {
-            for (const initialStateNode of getInitialStateNodes(child)) {
+            const initialStates = getInitialStateNodesWithTheirAncestors(child);
+            for (const initialStateNode of initialStates) {
               configurationSet.add(initialStateNode);
             }
           }
@@ -405,14 +392,14 @@ function getStateValue(rootNode, configuration) {
   const config = getConfiguration(configuration);
   return getValueFromAdj(rootNode, getAdjList(config));
 }
-function isInFinalState(configuration, stateNode = configuration[0].machine.root) {
+function isInFinalState(configuration, stateNode) {
   if (stateNode.type === 'compound') {
-    return getChildren(stateNode).some(s => s.type === 'final' && configuration.includes(s));
+    return getChildren(stateNode).some(s => s.type === 'final' && configuration.has(s));
   }
   if (stateNode.type === 'parallel') {
     return getChildren(stateNode).every(sn => isInFinalState(configuration, sn));
   }
-  return false;
+  return stateNode.type === 'final';
 }
 const isStateId = str => str[0] === interpreter.STATE_IDENTIFIER;
 function getCandidates(stateNode, receivedEventType) {
@@ -468,13 +455,7 @@ function getDelayedTransitions(stateNode) {
     stateNode.exit.push(cancel(eventType));
     return eventType;
   };
-  const delayedTransitions = interpreter.isArray(afterConfig) ? afterConfig.map((transition, i) => {
-    const eventType = mutateEntryExit(transition.delay, i);
-    return {
-      ...transition,
-      event: eventType
-    };
-  }) : Object.keys(afterConfig).flatMap((delay, i) => {
+  const delayedTransitions = Object.keys(afterConfig).flatMap((delay, i) => {
     const configTransition = afterConfig[delay];
     const resolvedTransition = typeof configTransition === 'string' ? {
       target: configTransition
@@ -562,43 +543,23 @@ function formatTransitions(stateNode) {
   return transitions;
 }
 function formatInitialTransition(stateNode, _target) {
-  if (typeof _target === 'string' || interpreter.isArray(_target)) {
-    const targets = interpreter.toArray(_target).map(t => {
-      // Resolve state string keys (which represent children)
-      // to their state node
-      const descStateNode = typeof t === 'string' ? isStateId(t) ? stateNode.machine.getStateNodeById(t) : stateNode.states[t] : t;
-      if (!descStateNode) {
-        throw new Error(`Initial state node "${t}" not found on parent state node #${stateNode.id}`);
-      }
-      if (!isDescendant(descStateNode, stateNode)) {
-        throw new Error(`Invalid initial target: state node #${descStateNode.id} is not a descendant of #${stateNode.id}`);
-      }
-      return descStateNode;
-    });
-    const resolvedTarget = resolveTarget(stateNode, targets);
-    const transition = {
-      source: stateNode,
-      actions: [],
-      eventType: null,
-      reenter: false,
-      target: resolvedTarget,
-      toJSON: () => ({
-        ...transition,
-        source: `#${stateNode.id}`,
-        target: resolvedTarget ? resolvedTarget.map(t => `#${t.id}`) : undefined
-      })
-    };
-    return transition;
+  const resolvedTarget = typeof _target === 'string' ? stateNode.states[_target] : _target ? stateNode.states[_target.target] : undefined;
+  if (!resolvedTarget && _target) {
+    throw new Error(`Initial state node "${_target}" not found on parent state node #${stateNode.id}`);
   }
-  return formatTransition(stateNode, '__INITIAL__', {
-    target: interpreter.toArray(_target.target).map(t => {
-      if (typeof t === 'string') {
-        return isStateId(t) ? t : `${interpreter.STATE_DELIMITER}${t}`;
-      }
-      return t;
-    }),
-    actions: _target.actions
-  });
+  const transition = {
+    source: stateNode,
+    actions: !_target || typeof _target === 'string' ? [] : interpreter.toArray(_target.actions),
+    eventType: null,
+    reenter: false,
+    target: resolvedTarget ? [resolvedTarget] : [],
+    toJSON: () => ({
+      ...transition,
+      source: `#${stateNode.id}`,
+      target: resolvedTarget ? [`#${resolvedTarget.id}`] : []
+    })
+  };
+  return transition;
 }
 function resolveTarget(stateNode, targets) {
   if (targets === undefined) {
@@ -641,6 +602,15 @@ function resolveHistoryTarget(stateNode) {
 function isHistoryNode(stateNode) {
   return stateNode.type === 'history';
 }
+function getInitialStateNodesWithTheirAncestors(stateNode) {
+  const states = getInitialStateNodes(stateNode);
+  for (const initialState of states) {
+    for (const ancestor of getProperAncestors(initialState, stateNode)) {
+      states.add(ancestor);
+    }
+  }
+  return states;
+}
 function getInitialStateNodes(stateNode) {
   const set = new Set();
   function iter(descStateNode) {
@@ -649,12 +619,7 @@ function getInitialStateNodes(stateNode) {
     }
     set.add(descStateNode);
     if (descStateNode.type === 'compound') {
-      for (const targetStateNode of descStateNode.initial.target) {
-        for (const a of getProperAncestors(targetStateNode, stateNode)) {
-          set.add(a);
-        }
-        iter(targetStateNode);
-      }
+      iter(descStateNode.initial.target[0]);
     } else if (descStateNode.type === 'parallel') {
       for (const child of getChildren(descStateNode)) {
         iter(child);
@@ -662,7 +627,7 @@ function getInitialStateNodes(stateNode) {
     }
   }
   iter(stateNode);
-  return [...set];
+  return set;
 }
 /**
  * Returns the child state node from its relative `stateKey`, or throws.
@@ -896,6 +861,17 @@ function computeExitSet(transitions, configuration, historyValue) {
   }
   return [...statesToExit];
 }
+function areConfigurationsEqual(previousConfiguration, nextConfigurationSet) {
+  if (previousConfiguration.length !== nextConfigurationSet.size) {
+    return false;
+  }
+  for (const node of previousConfiguration) {
+    if (!nextConfigurationSet.has(node)) {
+      return false;
+    }
+  }
+  return true;
+}
 
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
@@ -905,56 +881,36 @@ function computeExitSet(transitions, configuration, historyValue) {
  * @param currentState
  * @param mutConfiguration
  */
-
-function microstep(transitions, currentState, actorCtx, event, isInitial) {
-  const mutConfiguration = new Set(currentState.configuration);
+function microstep(transitions, currentState, actorCtx, event, isInitial, internalQueue) {
   if (!transitions.length) {
     return currentState;
   }
-  const microstate = microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial);
-  return cloneState(microstate, {
-    value: {} // TODO: make optional
-  });
-}
-
-function microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial) {
-  const historyValue = {
-    ...currentState.historyValue
-  };
+  const mutConfiguration = new Set(currentState.configuration);
+  let historyValue = currentState.historyValue;
   const filteredTransitions = removeConflictingTransitions(transitions, mutConfiguration, historyValue);
-  const internalQueue = [...currentState._internalQueue];
-  // TODO: this `cloneState` is really just a hack to prevent infinite loops
-  // we need to take another look at how internal queue is managed
-  let nextState = cloneState(currentState, {
-    _internalQueue: []
-  });
+  let nextState = currentState;
 
   // Exit states
   if (!isInitial) {
-    nextState = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue);
+    [nextState, historyValue] = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue, internalQueue);
   }
 
   // Execute transition content
-  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions));
+  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions), internalQueue);
 
   // Enter states
   nextState = enterStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial);
   const nextConfiguration = [...mutConfiguration];
-  const done = isInFinalState(nextConfiguration);
-  if (done) {
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit));
+  if (nextState.status === 'done') {
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit), internalQueue);
   }
   try {
-    const output = done ? getOutput(nextConfiguration, nextState.context, event, actorCtx.self) : undefined;
-    internalQueue.push(...nextState._internalQueue);
-    return cloneState(currentState, {
+    if (historyValue === currentState.historyValue && areConfigurationsEqual(currentState.configuration, mutConfiguration)) {
+      return nextState;
+    }
+    return cloneState(nextState, {
       configuration: nextConfiguration,
-      historyValue,
-      _internalQueue: internalQueue,
-      context: nextState.context,
-      status: done ? 'done' : currentState.status,
-      output,
-      children: nextState.children
+      historyValue
     });
   } catch (e) {
     // TODO: Refactor this once proper error handling is implemented.
@@ -962,6 +918,13 @@ function microstepProcedure(transitions, currentState, mutConfiguration, event,
     throw e;
   }
 }
+function getMachineOutput(state, event, actorCtx, rootNode, rootCompletionNode) {
+  if (!rootNode.output) {
+    return;
+  }
+  const doneStateEvent = interpreter.createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output && rootCompletionNode.parent ? interpreter.resolveOutput(rootCompletionNode.output, state.context, event, actorCtx.self) : undefined);
+  return interpreter.resolveOutput(rootNode.output, state.context, doneStateEvent, actorCtx.self);
+}
 function enterStates(currentState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial) {
   let nextState = currentState;
   const statesToEnter = new Set();
@@ -972,6 +935,7 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
   if (isInitial) {
     statesForDefaultEntry.add(currentState.machine.root);
   }
+  const completedNodes = new Set();
   for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
     mutConfiguration.add(stateNodeToEnter);
     const actions = [];
@@ -982,26 +946,34 @@ function enterStates(currentState, event, actorCtx, filteredTransitions, mutConf
       actions.push(invoke(invokeDef));
     }
     if (statesForDefaultEntry.has(stateNodeToEnter)) {
-      for (const stateNode of statesForDefaultEntry) {
-        const initialActions = stateNode.initial.actions;
-        actions.push(...initialActions);
-      }
+      const initialActions = stateNodeToEnter.initial.actions;
+      actions.push(...initialActions);
     }
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, internalQueue, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
     if (stateNodeToEnter.type === 'final') {
       const parent = stateNodeToEnter.parent;
-      if (!parent.parent) {
+      if (completedNodes.has(parent)) {
         continue;
       }
-      internalQueue.push(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, nextState.context, event, actorCtx.self) : undefined));
-      if (parent.parent) {
-        const grandparent = parent.parent;
-        if (grandparent.type === 'parallel') {
-          if (getChildren(grandparent).every(parentNode => isInFinalState([...mutConfiguration], parentNode))) {
-            internalQueue.push(interpreter.createDoneStateEvent(grandparent.id));
-          }
+      completedNodes.add(parent);
+      let rootCompletionNode = parent?.type === 'parallel' ? parent : stateNodeToEnter;
+      let ancestorMarker = parent?.parent;
+      if (ancestorMarker) {
+        internalQueue.push(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, nextState.context, event, actorCtx.self) : undefined));
+        while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutConfiguration, ancestorMarker)) {
+          completedNodes.add(ancestorMarker);
+          internalQueue.push(interpreter.createDoneStateEvent(ancestorMarker.id));
+          rootCompletionNode = ancestorMarker;
+          ancestorMarker = ancestorMarker.parent;
         }
       }
+      if (ancestorMarker) {
+        continue;
+      }
+      nextState = cloneState(nextState, {
+        status: 'done',
+        output: getMachineOutput(nextState, event, actorCtx, currentState.configuration[0].machine.root, rootCompletionNode)
+      });
     }
   }
   return nextState;
@@ -1047,13 +1019,9 @@ function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEnt
     statesToEnter.add(stateNode);
     if (stateNode.type === 'compound') {
       statesForDefaultEntry.add(stateNode);
-      const initialStates = stateNode.initial.target;
-      for (const initialState of initialStates) {
-        addDescendantStatesToEnter(initialState, historyValue, statesForDefaultEntry, statesToEnter);
-      }
-      for (const initialState of initialStates) {
-        addAncestorStatesToEnter(initialState, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
-      }
+      const [initialState] = stateNode.initial.target;
+      addDescendantStatesToEnter(initialState, historyValue, statesForDefaultEntry, statesToEnter);
+      addAncestorStatesToEnter(initialState, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
     } else {
       if (stateNode.type === 'parallel') {
         for (const child of getChildren(stateNode).filter(sn => !isHistoryNode(sn))) {
@@ -1078,10 +1046,11 @@ function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, history
     }
   }
 }
-function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue) {
+function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue, internalQueue) {
   let nextState = currentState;
   const statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
+  let changedHistory;
 
   // From SCXML algorithm: https://www.w3.org/TR/scxml/#exitStates
   for (const exitStateNode of statesToExit) {
@@ -1094,14 +1063,17 @@ function exitStates(currentState, event, actorCtx, transitions, mutConfiguration
           return sn.parent === exitStateNode;
         };
       }
-      historyValue[historyNode.id] = Array.from(mutConfiguration).filter(predicate);
+      changedHistory ??= {
+        ...historyValue
+      };
+      changedHistory[historyNode.id] = Array.from(mutConfiguration).filter(predicate);
     }
   }
   for (const s of statesToExit) {
-    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))]);
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))], internalQueue);
     mutConfiguration.delete(s);
   }
-  return nextState;
+  return [nextState, changedHistory || historyValue];
 }
 function resolveActionsAndContextWorker(currentState, event, actorCtx, actions, extra, retries) {
   const {
@@ -1166,9 +1138,10 @@ function resolveActionsAndContextWorker(currentState, event, actorCtx, actions,
   }
   return intermediateState;
 }
-function resolveActionsAndContext(currentState, event, actorCtx, actions, deferredActorIds) {
+function resolveActionsAndContext(currentState, event, actorCtx, actions, internalQueue, deferredActorIds) {
   const retries = deferredActorIds ? [] : undefined;
-  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, deferredActorIds && {
+  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, {
+    internalQueue,
     deferredActorIds
   }, retries);
   retries?.forEach(([builtinAction, params]) => {
@@ -1176,7 +1149,7 @@ function resolveActionsAndContext(currentState, event, actorCtx, actions, deferr
   });
   return nextState;
 }
-function macrostep(state, event, actorCtx) {
+function macrostep(state, event, actorCtx, internalQueue = []) {
   if (event.type === interpreter.WILDCARD) {
     throw new Error(`An event cannot have the wildcard type ('${interpreter.WILDCARD}')`);
   }
@@ -1185,7 +1158,7 @@ function macrostep(state, event, actorCtx) {
 
   // Handle stop event
   if (event.type === interpreter.XSTATE_STOP) {
-    nextState = stopStep(event, nextState, actorCtx);
+    nextState = stopChildren(nextState, event, actorCtx);
     states.push(nextState);
     return {
       state: nextState,
@@ -1198,44 +1171,37 @@ function macrostep(state, event, actorCtx) {
   // Determine the next state based on the next microstep
   if (nextEvent.type !== interpreter.XSTATE_INIT) {
     const transitions = selectTransitions(nextEvent, nextState);
-    nextState = microstep(transitions, state, actorCtx, nextEvent, false);
+    nextState = microstep(transitions, state, actorCtx, nextEvent, false, internalQueue);
     states.push(nextState);
   }
+  let shouldSelectEventlessTransitions = true;
   while (nextState.status === 'active') {
-    let enabledTransitions = selectEventlessTransitions(nextState, nextEvent);
+    let enabledTransitions = shouldSelectEventlessTransitions ? selectEventlessTransitions(nextState, nextEvent) : [];
+
+    // eventless transitions should always be selected after selecting *regular* transitions
+    // by assigning `undefined` to `previousState` we ensure that `shouldSelectEventlessTransitions` gets always computed to true in such a case
+    const previousState = enabledTransitions.length ? nextState : undefined;
     if (!enabledTransitions.length) {
-      if (!nextState._internalQueue.length) {
+      if (!internalQueue.length) {
         break;
-      } else {
-        nextEvent = nextState._internalQueue[0];
-        const transitions = selectTransitions(nextEvent, nextState);
-        nextState = microstep(transitions, nextState, actorCtx, nextEvent, false);
-        nextState._internalQueue.shift();
-        states.push(nextState);
       }
-    } else {
-      nextState = microstep(enabledTransitions, nextState, actorCtx, nextEvent, false);
-      states.push(nextState);
+      nextEvent = internalQueue.shift();
+      enabledTransitions = selectTransitions(nextEvent, nextState);
     }
+    nextState = microstep(enabledTransitions, nextState, actorCtx, nextEvent, false, internalQueue);
+    shouldSelectEventlessTransitions = nextState !== previousState;
+    states.push(nextState);
   }
   if (nextState.status !== 'active') {
-    // Perform the stop step to ensure that child actors are stopped
-    stopStep(nextEvent, nextState, actorCtx);
+    stopChildren(nextState, nextEvent, actorCtx);
   }
   return {
     state: nextState,
     microstates: states
   };
 }
-function stopStep(event, nextState, actorCtx) {
-  const actions = [];
-  for (const stateNode of nextState.configuration.sort((a, b) => b.order - a.order)) {
-    actions.push(...stateNode.exit);
-  }
-  for (const child of Object.values(nextState.children)) {
-    actions.push(stop(child));
-  }
-  return resolveActionsAndContext(nextState, event, actorCtx, actions);
+function stopChildren(nextState, event, actorCtx) {
+  return resolveActionsAndContext(nextState, event, actorCtx, Object.values(nextState.children).map(child => stop(child)), []);
 }
 function selectTransitions(event, nextState) {
   return nextState.machine.getTransitionData(nextState, event);
@@ -1341,11 +1307,9 @@ class State {
     this.error = void 0;
     this.context = void 0;
     this.historyValue = {};
-    this._internalQueue = void 0;
     this.configuration = void 0;
     this.children = void 0;
     this.context = config.context;
-    this._internalQueue = config._internalQueue ?? [];
     this.historyValue = config.historyValue || {};
     this.matches = this.matches.bind(this);
     this.toStrings = this.toStrings.bind(this);
@@ -1447,11 +1411,15 @@ function getPersistedState(state) {
     tags,
     machine,
     children,
+    context,
     ...jsonValues
   } = state;
   const childrenJson = {};
   for (const id in children) {
     const child = children[id];
+    if (typeof child.src !== 'string') {
+      throw new Error('An inline child actor cannot be persisted.');
+    }
     childrenJson[id] = {
       state: child.getPersistedState?.(),
       src: child.src
@@ -1459,14 +1427,45 @@ function getPersistedState(state) {
   }
   return {
     ...jsonValues,
+    // TODO: this makes `PersistedMachineState`'s type kind of a lie
+    // it doesn't truly use `TContext` but rather some kind of a derived form of it
+    context: persistContext(context),
     children: childrenJson
   };
 }
+function persistContext(contextPart) {
+  let copy;
+  for (const key in contextPart) {
+    const value = contextPart[key];
+    if (value && typeof value === 'object') {
+      if ('sessionId' in value && 'send' in value && 'ref' in value) {
+        copy ??= Array.isArray(contextPart) ? contextPart.slice() : {
+          ...contextPart
+        };
+        copy[key] = {
+          xstate$$type: interpreter.$$ACTOR_TYPE,
+          id: value.id
+        };
+      } else {
+        const result = persistContext(value);
+        if (result !== value) {
+          copy ??= Array.isArray(contextPart) ? contextPart.slice() : {
+            ...contextPart
+          };
+          copy[key] = result;
+        }
+      }
+    }
+  }
+  return copy ?? contextPart;
+}
 
 function resolveRaise(_, state, args, {
   event: eventOrExpr,
   id,
   delay
+}, {
+  internalQueue
 }) {
   const delaysMap = state.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
@@ -1480,9 +1479,10 @@ function resolveRaise(_, state, args, {
   } else {
     resolvedDelay = typeof delay === 'function' ? delay(args) : delay;
   }
-  return [typeof resolvedDelay !== 'number' ? cloneState(state, {
-    _internalQueue: state._internalQueue.concat(resolvedEvent)
-  }) : state, {
+  if (typeof resolvedDelay !== 'number') {
+    internalQueue.push(resolvedEvent);
+  }
+  return [state, {
     event: resolvedEvent,
     id,
     delay: resolvedDelay
@@ -1527,10 +1527,10 @@ exports.getCandidates = getCandidates;
 exports.getConfiguration = getConfiguration;
 exports.getDelayedTransitions = getDelayedTransitions;
 exports.getInitialConfiguration = getInitialConfiguration;
+exports.getInitialStateNodes = getInitialStateNodes;
 exports.getPersistedState = getPersistedState;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
-exports.isAtomicStateNode = isAtomicStateNode;
 exports.isInFinalState = isInFinalState;
 exports.isStateId = isStateId;
 exports.macrostep = macrostep;