xstate 3.2.1 → 3.3.3

package/src/StateNode.ts

@@ -6,7 +6,11 @@ import {
   path,
   toStatePaths,
   pathsToStateValue,
-  pathToStateValue
+  pathToStateValue,
+  getActionType,
+  flatMap,
+  mapFilterValues,
+  nestedPath
 } from './utils';
 import {
   Event,
@@ -17,18 +21,24 @@ import {
   StandardMachine,
   ParallelMachine,
   SimpleOrCompoundStateNodeConfig,
-  MachineConfig,
   ParallelMachineConfig,
   EventType,
-  ActionMap,
   StandardMachineConfig,
   TransitionConfig,
   ActivityMap,
-  StateNodeConfig,
   Activity,
+  ConditionalTransitionConfig,
+  EntryExitStates,
+  TargetTransitionConfig,
   StateTransition,
+  ActionObject,
+  StateValueMap,
+  MachineOptions,
+  Condition,
+  ConditionPredicate,
   EventObject,
-  ConditionalTransitionConfig
+  HistoryStateNodeConfig,
+  HistoryValue
 } from './types';
 import { matchesState } from './matchesState';
 import { State } from './State';
@@ -39,85 +49,22 @@ const HISTORY_KEY = '$history';
 const NULL_EVENT = '';
 const STATE_IDENTIFIER = '#';
 const isStateId = (str: string) => str[0] === STATE_IDENTIFIER;
-const emptyActions: ActionMap = Object.freeze({
-  onEntry: [],
-  onExit: [],
-  actions: []
-});
-
-/**
- * Given a StateNode, walk up the parent chain until we find an
- * orthogonal region of a parallel state, or the top level machine
- * itself
- */
-const regionOf = (node: StateNode): StateNode => {
-  // If we reach the top of the state machine, we're a "region".
-  // If our parent is a parallel state, we're a region.
-  while (node.parent && !node.parent.parallel) {
-    node = node.parent;
-  }
-  return node;
+const defaultOptions: MachineOptions = {
+  guards: {}
 };
 
-/**
- * Ensure that the passed in StateNode instance belongs to a region
- * that previously had not been used, or that matches the existing
- * StateNode for the orthogonal regions.  This function is used to
- * verify that a transition that has multiple targets ends doesn't try
- * to target several states in the same orthogonal region.  The passed
- * state is added to the regions data structure using the state's
- * _region_ (see regionOf), and the region's parent.  If there is
- * already an object in the structure which is not already the state
- * in question, an Error is thrown, otherwise the state is added to
- * the structure, and the _region_ is returned.
- *
- * @param sourceState the state in which the event was triggered (used
- * to report error messages)
- * @param event the event that triggered the transition (used to
- * report error messages)
- * @param regions A data structure that retains the current set of
- * orthogonal regions (their IDs), grouped by their parallel state
- * (their IDs), with the values being the chosen states
- * @param state A state to add to the structure if possible.
- * @returns The region of the state, in order for the caller to repeat the process for the parent.
- * @throws Error if the region found already exists in the regions
- */
-
-const ensureTargetStateIsInCorrectRegion = (
-  sourceState: StateNode,
-  event: Event,
-  regions: Record<string, Record<string, StateNode>>,
-  stateToCheck: StateNode
-): StateNode => {
-  const region = regionOf(stateToCheck);
-  const parent = region.parent;
-  const parentId = parent ? parent.id : ''; // '' == machine
-
-  regions[parentId] = regions[parentId] || {};
-  if (
-    regions[parentId][region.id] &&
-    regions[parentId][region.id] !== stateToCheck
-  ) {
-    throw new Error(
-      `Event '${event}' on state '${sourceState.id}' leads to an invalid configuration: ` +
-        `Two or more states in the orthogonal region '${region.id}'.`
-    );
-  }
-  // Keep track of which state was chosen in a particular region.
-  regions[parentId][region.id] = stateToCheck;
-  return region;
-};
-
-class StateNode implements StateNodeConfig {
+class StateNode {
   public key: string;
   public id: string;
   public path: string[];
   public initial?: string;
   public parallel?: boolean;
+  public transient: boolean;
   public states: Record<string, StateNode>;
+  public history: false | 'shallow' | 'deep';
   public on: Record<string, ConditionalTransitionConfig>;
-  public onEntry?: Action[];
-  public onExit?: Action[];
+  public onEntry: Action[];
+  public onExit: Action[];
   public activities?: Activity[];
   public strict: boolean;
   public parent?: StateNode;
@@ -137,7 +84,8 @@ class StateNode implements StateNodeConfig {
     public config:
       | SimpleOrCompoundStateNodeConfig
       | StandardMachineConfig
-      | ParallelMachineConfig
+      | ParallelMachineConfig,
+    public options: MachineOptions = defaultOptions
   ) {
     this.key = config.key || '(machine)';
     this.parent = config.parent;
@@ -154,35 +102,41 @@ class StateNode implements StateNodeConfig {
     this.initial = config.initial;
     this.parallel = !!config.parallel;
     this.states = (config.states
-      ? mapValues<
-          SimpleOrCompoundStateNodeConfig,
-          StateNode
-        >(config.states, (stateConfig, key) => {
-          const stateNode = new StateNode({
-            ...stateConfig,
-            key,
-            parent: this
-          });
-          Object.assign(this.idMap, {
-            [stateNode.id]: stateNode,
-            ...stateNode.idMap
-          });
-          return stateNode;
-        })
+      ? mapValues<SimpleOrCompoundStateNodeConfig, StateNode>(
+          config.states,
+          (stateConfig, key) => {
+            const stateNode = new StateNode({
+              ...stateConfig,
+              key,
+              parent: this
+            });
+            Object.assign(this.idMap, {
+              [stateNode.id]: stateNode,
+              ...stateNode.idMap
+            });
+            return stateNode;
+          }
+        )
       : {}) as Record<string, StateNode>;
 
+    // History config
+    this.history =
+      config.history === true ? 'shallow' : config.history || false;
+
     this.on = config.on ? this.formatTransitions(config.on) : {};
+    this.transient = !!this.on[NULL_EVENT];
     this.strict = !!config.strict;
     this.onEntry = config.onEntry
       ? ([] as Action[]).concat(config.onEntry)
-      : undefined;
-    this.onExit = config.onExit
-      ? ([] as Action[]).concat(config.onExit)
-      : undefined;
+      : [];
+    this.onExit = config.onExit ? ([] as Action[]).concat(config.onExit) : [];
     this.data = config.data;
     this.activities = config.activities;
   }
   public getStateNodes(state: StateValue | State): StateNode[] {
+    if (!state) {
+      return [];
+    }
     const stateValue =
       state instanceof State
         ? state.value
@@ -219,411 +173,285 @@ class StateNode implements StateNodeConfig {
 
     return this.events.indexOf(eventType) !== -1;
   }
-  public transition(
-    state: StateValue | State,
+  private _transitionLeafNode(
+    stateValue: string,
+    state: State,
     event: Event,
     extendedState?: any
-  ): State {
-    const resolvedStateValue =
-      typeof state === 'string'
-        ? this.resolve(pathToStateValue(this.getResolvedPath(state)))
-        : state instanceof State ? state : this.resolve(state);
-
-    if (this.strict) {
-      const eventType = getEventType(event);
-      if (this.events.indexOf(eventType) === -1) {
-        throw new Error(
-          `Machine '${this.id}' does not accept event '${eventType}'`
-        );
-      }
-    }
-
-    const currentState = State.from(resolvedStateValue);
-
-    const stateTransition = this.transitionStateValue(
-      currentState,
-      event,
-      currentState,
-      extendedState
-    );
-    let nextState = this.stateTransitionToState(stateTransition, currentState);
-
-    if (!nextState) {
-      return State.inert(currentState);
-    }
-
-    let maybeNextState: State | undefined = nextState;
-
-    const raisedEvents = nextState.actions.filter(
-      action => typeof action === 'object' && action.type === actionTypes.raise
-    );
-
-    if (raisedEvents.length) {
-      const raisedEvent = (raisedEvents[0] as EventObject).event!;
-
-      nextState = this.transition(nextState, raisedEvent, extendedState);
-      nextState.actions.unshift(...nextState.actions);
-      return nextState;
-    }
+  ): StateTransition {
+    const stateNode = this.getStateNode(stateValue);
+    const next = stateNode._next(state, event, extendedState);
 
-    if (stateTransition.events.length) {
-      const raised =
-        stateTransition.events[0].type === actionTypes.raise
-          ? stateTransition.events[0].event!
-          : undefined;
-      const nullEvent = stateTransition.events[0].type === actionTypes.null;
+    if (!next.value) {
+      const { value, entryExitStates, actions, paths } = this._next(
+        state,
+        event,
+        extendedState
+      );
 
-      if (raised || nullEvent) {
-        maybeNextState = this.transition(
-          nextState,
-          nullEvent ? NULL_EVENT : raised,
-          extendedState
-        );
-        maybeNextState.actions.unshift(...nextState.actions);
-        return maybeNextState;
-      }
+      return {
+        value,
+        entryExitStates: {
+          entry: entryExitStates ? entryExitStates.entry : new Set(),
+          exit: new Set<StateNode>([
+            stateNode,
+            ...(entryExitStates
+              ? Array.from(entryExitStates.exit)
+              : ([] as StateNode[]))
+          ])
+        },
+        actions,
+        paths
+      };
     }
 
-    return nextState;
+    return next;
   }
-  private stateTransitionToState(
-    stateTransition: StateTransition,
-    prevState: State
-  ): State | undefined {
-    const {
-      statePaths: nextStatePaths,
-      actions: nextActions,
-      activities: nextActivities,
-      events
-    } = stateTransition;
-
-    if (!nextStatePaths.length) {
-      return undefined;
-    }
-
-    const prevActivities =
-      prevState instanceof State ? prevState.activities : undefined;
-
-    const activities = { ...prevActivities, ...nextActivities };
-
-    const nextStateValue = this.resolve(pathsToStateValue(nextStatePaths));
-    return new State(
-      // next state value
-      nextStateValue,
-      // history
-      State.from(prevState),
-      // effects
-      nextActions
-        ? nextActions.onExit
-            .concat(nextActions.actions)
-            .concat(nextActions.onEntry)
-        : [],
-      // activities
-      activities,
-      // data
-      this.getStateNodes(nextStateValue).reduce(
-        (data, stateNode) => {
-          if (stateNode.data !== undefined) {
-            data[stateNode.id] = stateNode.data;
-          }
+  private _transitionHierarchicalNode(
+    stateValue: StateValueMap,
+    state: State,
+    event: Event,
+    extendedState?: any
+  ): StateTransition {
+    const subStateKeys = Object.keys(stateValue);
 
-          return data;
-        },
-        {} as Record<string, any>
-      ),
-      events
+    const stateNode = this.getStateNode(subStateKeys[0]);
+    const next = stateNode._transition(
+      stateValue[subStateKeys[0]],
+      state,
+      event,
+      extendedState
     );
-  }
-  public getStateNode(stateKey: string): StateNode {
-    if (isStateId(stateKey)) {
-      return this.machine.getStateNodeById(stateKey);
-    }
 
-    if (!this.states) {
-      throw new Error(
-        `Unable to retrieve child state '${stateKey}' from '${this
-          .id}'; no child states exist.`
-      );
-    }
-
-    const result = this.states[stateKey];
-    if (!result) {
-      throw new Error(
-        `Child state '${stateKey}' does not exist on '${this.id}'`
+    if (!next.value) {
+      const { value, entryExitStates, actions, paths } = this._next(
+        state,
+        event,
+        extendedState
       );
-    }
-
-    return result;
-  }
-  public getStateNodeById(stateId: string): StateNode {
-    const resolvedStateId = isStateId(stateId)
-      ? stateId.slice(STATE_IDENTIFIER.length)
-      : stateId;
-    const stateNode = this.idMap[resolvedStateId];
 
-    if (!stateNode) {
-      throw new Error(
-        `Substate '#${resolvedStateId}' does not exist on '${this.id}'`
-      );
+      return {
+        value,
+        entryExitStates: {
+          entry: entryExitStates ? entryExitStates.entry : new Set(),
+          exit: new Set<StateNode>([
+            ...(next.entryExitStates
+              ? Array.from(next.entryExitStates.exit)
+              : []),
+            stateNode,
+            ...(entryExitStates
+              ? Array.from(entryExitStates.exit)
+              : ([] as StateNode[]))
+          ])
+        },
+        actions,
+        paths
+      };
     }
 
-    return stateNode;
+    return next;
   }
-  private resolve(stateValue: StateValue): StateValue {
-    if (typeof stateValue === 'string') {
-      const subStateNode = this.getStateNode(stateValue);
-      return subStateNode.initial
-        ? { [stateValue]: subStateNode.initialStateValue! }
-        : stateValue;
-    }
-
-    if (this.parallel) {
-      return mapValues(
-        this.initialStateValue as Record<string, StateValue>,
-        (subStateValue, subStateKey) => {
-          return this.getStateNode(subStateKey).resolve(
-            stateValue[subStateKey] || subStateValue
-          );
-        }
-      );
-    }
-
-    return mapValues(stateValue, (subStateValue, subStateKey) => {
-      return this.getStateNode(subStateKey).resolve(subStateValue);
-    });
-  }
-  private transitionStateValue(
+  private _transitionOrthogonalNode(
+    stateValue: StateValueMap,
     state: State,
     event: Event,
-    fullState: State,
     extendedState?: any
   ): StateTransition {
-    const { history } = state;
-    const stateValue = state.value;
+    const noTransitionKeys: string[] = [];
+    const transitionMap: Record<string, StateTransition> = {};
 
-    if (typeof stateValue === 'string') {
-      const subStateNode = this.getStateNode(stateValue);
+    Object.keys(stateValue).forEach(subStateKey => {
+      const subStateValue = stateValue[subStateKey];
 
-      const result = subStateNode.next(
+      if (!subStateValue) {
+        return;
+      }
+
+      const next = this.getStateNode(subStateKey)._transition(
+        subStateValue,
+        state,
         event,
-        fullState,
-        history ? history.value : undefined,
         extendedState
       );
 
-      // If a machine substate returns no potential transitions,
-      // check on the machine itself.
-      if (!result.statePaths.length && !this.parent) {
-        return this.next(
-          event,
-          fullState,
-          history ? history.value : undefined,
-          extendedState
-        );
+      if (!next.value) {
+        noTransitionKeys.push(subStateKey);
       }
 
-      return result;
-    }
-
-    // Potential transition tuples from parent state nodes
-    const potentialStateTransitions: StateTransition[] = [];
-    let willTransition = false;
-
-    let nextStateTransitionMap = mapValues(
-      stateValue,
-      (subStateValue, subStateKey) => {
-        const subStateNode = this.getStateNode(subStateKey);
-        const subHistory = history ? history.value[subStateKey] : undefined;
-        const subState = new State(
-          subStateValue,
-          subHistory ? State.from(subHistory) : undefined
-        );
-        const subStateTransition = subStateNode.transitionStateValue(
-          subState,
-          event,
-          fullState,
-          extendedState
-        );
-
-        if (!subStateTransition.statePaths.length) {
-          potentialStateTransitions.push(
-            subStateNode.next(
-              event,
-              fullState,
-              history ? history.value : undefined,
-              extendedState
-            )
-          );
-        } else {
-          willTransition = true;
-        }
+      transitionMap[subStateKey] = next;
+    });
 
-        return subStateTransition;
-      }
+    const willTransition = Object.keys(transitionMap).some(
+      key => transitionMap[key].value !== undefined
     );
 
     if (!willTransition) {
-      if (this.parallel) {
-        if (potentialStateTransitions.length) {
-          // Select the first potential state transition to take
-          return potentialStateTransitions[0];
-        }
-
-        return {
-          statePaths: [],
-          actions: emptyActions,
-          activities: undefined,
-          events: []
-        };
-      }
-
-      const [subStateKey] = Object.keys(nextStateTransitionMap);
-
-      // try with parent
-      const {
-        statePaths: parentStatePaths,
-        actions: parentNextActions,
-        activities: parentActivities
-      } = this.getStateNode(subStateKey).next(
+      const { value, entryExitStates, actions, paths } = this._next(
+        state,
         event,
-        fullState,
-        history ? history.value : undefined,
         extendedState
       );
 
-      const nextActions = nextStateTransitionMap[subStateKey].actions;
-      const activities = nextStateTransitionMap[subStateKey].activities;
-
-      const allActivities = {
-        ...activities,
-        ...parentActivities
+      return {
+        value,
+        entryExitStates: {
+          entry: entryExitStates ? entryExitStates.entry : new Set(),
+          exit: new Set([
+            ...Object.keys(this.states).map(key => this.states[key]),
+            ...(entryExitStates ? Array.from(entryExitStates.exit) : [])
+          ])
+        },
+        actions,
+        paths
       };
+    }
 
-      const allActions = parentNextActions
-        ? nextActions
-          ? {
-              onEntry: [...nextActions.onEntry, ...parentNextActions.onEntry],
-              actions: [...nextActions.actions, ...parentNextActions.actions],
-              onExit: [...nextActions.onExit, ...parentNextActions.onExit]
-            }
-          : parentNextActions
-        : nextActions;
+    const allPaths = flatMap(
+      Object.keys(transitionMap).map(key => transitionMap[key].paths)
+    );
 
+    // External transition that escapes orthogonal region
+    if (
+      allPaths.length === 1 &&
+      !matchesState(pathToStateValue(this.path), pathToStateValue(allPaths[0]))
+    ) {
       return {
-        statePaths: parentStatePaths,
-        actions: allActions,
-        activities: allActivities,
-        events: []
+        value: this.machine.resolve(pathsToStateValue(allPaths)),
+        entryExitStates: Object.keys(transitionMap)
+          .map(key => transitionMap[key].entryExitStates)
+          .reduce(
+            (allEntryExitStates, entryExitStates) => {
+              const { entry, exit } = entryExitStates!;
+
+              return {
+                entry: new Set([
+                  ...Array.from(allEntryExitStates!.entry),
+                  ...Array.from(entry)
+                ]),
+                exit: new Set([
+                  ...Array.from(allEntryExitStates!.exit),
+                  ...Array.from(exit)
+                ])
+              };
+            },
+            { entry: new Set(), exit: new Set() } as EntryExitStates
+          ),
+        actions: flatMap(
+          Object.keys(transitionMap).map(key => {
+            return transitionMap[key].actions;
+          })
+        ),
+        paths: allPaths
       };
     }
 
-    if (this.parallel) {
-      nextStateTransitionMap = {
-        ...mapValues(
-          this.initialState.value as Record<string, StateValue>,
-          (subStateValue, key) => {
-            const subStateTransition = nextStateTransitionMap[key];
-            return {
-              statePaths:
-                subStateTransition && subStateTransition.statePaths.length
-                  ? subStateTransition.statePaths
-                  : toStatePaths(
-                      stateValue[key] || subStateValue
-                    ).map(subPath => [
-                      ...this.getStateNode(key).path,
-                      ...subPath
-                    ]),
-              actions:
-                subStateTransition && subStateTransition.actions
-                  ? subStateTransition.actions
-                  : {
-                      onEntry: [],
-                      onExit: [],
-                      actions: []
-                    },
-              activities: undefined,
-              events: []
-            };
-          }
-        )
-      };
-    }
+    const allResolvedPaths = flatMap(
+      Object.keys(transitionMap).map(key => {
+        const transition = transitionMap[key];
+        const value = transition.value || state.value;
 
-    const finalActions: ActionMap = {
-      onEntry: [],
-      actions: [],
-      onExit: []
-    };
-    const finalActivities: ActivityMap = {};
-    mapValues(nextStateTransitionMap, subStateTransition => {
-      const {
-        // statePaths: nextSubStatePaths,
-        actions: nextSubActions,
-        activities: nextSubActivities
-      } = subStateTransition;
-      if (nextSubActions) {
-        if (nextSubActions.onEntry) {
-          finalActions.onEntry.push(...nextSubActions.onEntry);
-        }
-        if (nextSubActions.actions) {
-          finalActions.actions.push(...nextSubActions.actions);
-        }
-        if (nextSubActions.onExit) {
-          finalActions.onExit.push(...nextSubActions.onExit);
-        }
-      }
-      if (nextSubActivities) {
-        Object.assign(finalActivities, nextSubActivities);
-      }
-    });
+        return toStatePaths(path(this.path)(value)[key]).map(statePath =>
+          this.path.concat(key, statePath)
+        );
+      })
+    );
+
+    const nextStateValue = this.machine.resolve(
+      pathsToStateValue(allResolvedPaths)
+    );
 
     return {
-      statePaths: Object.keys(nextStateTransitionMap)
-        .map(stateKey => nextStateTransitionMap[stateKey].statePaths)
-        .reduce((a, b) => a.concat(b), [] as string[][]),
-      actions: finalActions,
-      activities: finalActivities,
-      events: []
+      value: nextStateValue,
+      entryExitStates: Object.keys(transitionMap).reduce(
+        (allEntryExitStates, key) => {
+          const { value: subStateValue, entryExitStates } = transitionMap[key];
+
+          // If the event was not handled (no subStateValue),
+          // machine should still be in state without reentry/exit.
+          if (!subStateValue || !entryExitStates) {
+            return allEntryExitStates;
+          }
+
+          const { entry, exit } = entryExitStates;
+
+          return {
+            entry: new Set([
+              ...Array.from(allEntryExitStates.entry),
+              ...Array.from(entry)
+            ]),
+            exit: new Set([
+              ...Array.from(allEntryExitStates.exit),
+              ...Array.from(exit)
+            ])
+          };
+        },
+        { entry: new Set(), exit: new Set() } as EntryExitStates
+      ),
+      actions: flatMap(
+        Object.keys(transitionMap).map(key => {
+          return transitionMap[key].actions;
+        })
+      ),
+      paths: toStatePaths(nextStateValue)
     };
   }
+  public _transition(
+    stateValue: StateValue,
+    state: State,
+    event: Event,
+    extendedState?: any
+  ): StateTransition {
+    // leaf node
+    if (typeof stateValue === 'string') {
+      return this._transitionLeafNode(stateValue, state, event, extendedState);
+    }
+
+    // hierarchical node
+    if (Object.keys(stateValue).length === 1) {
+      return this._transitionHierarchicalNode(
+        stateValue,
+        state,
+        event,
+        extendedState
+      );
+    }
 
-  private next(
+    // orthogonal node
+    return this._transitionOrthogonalNode(
+      stateValue,
+      state,
+      event,
+      extendedState
+    );
+  }
+  private _next(
+    state: State,
     event: Event,
-    fullState: State,
-    history?: StateValue,
     extendedState?: any
   ): StateTransition {
     const eventType = getEventType(event);
-    const actionMap: ActionMap = { onEntry: [], onExit: [], actions: [] };
-    const activityMap: ActivityMap = {};
     const candidates = this.on[eventType];
+    const actions: Action[] = this.transient
+      ? [{ type: actionTypes.null }]
+      : [];
 
-    if (this.onExit) {
-      actionMap.onExit = this.onExit;
-    }
-    if (this.activities) {
-      this.activities.forEach(activity => {
-        activityMap[getEventType(activity)] = false;
-        actionMap.onExit = actionMap.onExit.concat(stop(activity));
-      });
-    }
-
-    if (!candidates) {
+    if (!candidates || !candidates.length) {
       return {
-        statePaths: [],
-        actions: actionMap,
-        activities: activityMap,
-        events: []
+        value: undefined,
+        entryExitStates: undefined,
+        actions,
+        paths: []
       };
     }
 
     let nextStateStrings: string[] = [];
+    let selectedTransition: TargetTransitionConfig;
 
     for (const candidate of candidates) {
       const {
         cond,
-        in: stateIn,
-        actions: transitionActions
+        in: stateIn
+        // actions: transitionActions
       } = candidate as TransitionConfig;
       const extendedStateObject = extendedState || {};
       const eventObject = toEventObject(event);
@@ -631,172 +459,450 @@ class StateNode implements StateNodeConfig {
       const isInState = stateIn
         ? matchesState(
             toStateValue(stateIn, this.delimiter),
-            path(this.path.slice(0, -2))(fullState.value)
+            path(this.path.slice(0, -2))(state.value)
           )
         : true;
 
       if (
-        (!cond || cond(extendedStateObject, eventObject)) &&
+        (!cond ||
+          this._evaluateCond(
+            cond,
+            extendedStateObject,
+            eventObject,
+            state.value
+          )) &&
         (!stateIn || isInState)
       ) {
         nextStateStrings = Array.isArray(candidate.target)
           ? candidate.target
           : [candidate.target];
-        if (transitionActions) {
-          actionMap.actions = actionMap.actions.concat(transitionActions);
-        }
+        actions.push(...(candidate.actions ? candidate.actions : [])); // TODO: fixme;
+        selectedTransition = candidate;
         break;
       }
     }
 
     if (nextStateStrings.length === 0) {
       return {
-        statePaths: [],
-        actions: actionMap,
-        activities: activityMap,
-        events: []
+        value: undefined,
+        entryExitStates: undefined,
+        actions,
+        paths: []
       };
     }
 
-    const finalPaths: string[][] = [];
-    const raisedEvents: Action[] = [];
-    const usedRegions: Record<string, Record<string, StateNode>> = {};
+    const nextStateNodes = flatMap(
+      nextStateStrings.map(str =>
+        this.getRelativeStateNodes(str, state.historyValue)
+      )
+    );
 
-    nextStateStrings.forEach(nextStateString => {
-      const nextStatePath = this.getResolvedPath(nextStateString);
-      let currentState = isStateId(nextStateString)
-        ? this.machine
-        : this.parent;
-      let currentHistory = history;
-      let currentPath = this.key;
+    const nextStatePaths = nextStateNodes.map(stateNode => stateNode.path);
 
-      nextStatePath.forEach(subPath => {
-        if (subPath === '') {
-          actionMap.onExit = [];
-          currentState = this;
-          return;
-        }
+    const entryExitStates = nextStateNodes.reduce(
+      (allEntryExitStates, nextStateNode) => {
+        const { entry, exit } = this._getEntryExitStates(
+          nextStateNode,
+          !!selectedTransition.internal
+        );
 
-        if (!currentState || !currentState.states) {
-          throw new Error(`Unable to read '${subPath}' from '${this.id}'`);
-        }
+        return {
+          entry: new Set([
+            ...Array.from(allEntryExitStates.entry),
+            ...Array.from(entry)
+          ]),
+          exit: new Set([
+            ...Array.from(allEntryExitStates.exit),
+            ...Array.from(exit)
+          ])
+        };
+      },
+      { entry: new Set(), exit: new Set() } as EntryExitStates
+    );
 
-        if (subPath === HISTORY_KEY) {
-          if (!Object.keys(currentState.states).length) {
-            subPath = '';
-          } else if (currentHistory) {
-            subPath =
-              typeof currentHistory === 'object'
-                ? Object.keys(currentHistory)[0]
-                : currentHistory;
-          } else if (currentState.initial) {
-            subPath = currentState.initial;
-          } else {
-            throw new Error(
-              `Cannot read '${HISTORY_KEY}' from state '${currentState.id}': missing 'initial'`
-            );
-          }
-        }
+    return {
+      value: this.machine.resolve(
+        pathsToStateValue(
+          flatMap(
+            nextStateStrings.map(str =>
+              this.getRelativeStateNodes(str, state.historyValue).map(
+                s => s.path
+              )
+            )
+          )
+        )
+      ),
+      entryExitStates,
+      actions,
+      paths: nextStatePaths
+    };
+  }
+  private _getEntryExitStates(
+    nextStateNode: StateNode,
+    internal: boolean
+  ): EntryExitStates {
+    const entryExitStates = {
+      entry: [] as StateNode[],
+      exit: [] as StateNode[]
+    };
 
-        try {
-          if (subPath !== '') {
-            currentState = currentState.getStateNode(subPath);
-          }
-        } catch (e) {
-          throw new Error(
-            `Event '${event}' on state '${currentPath}' leads to undefined state '${nextStatePath.join(
-              this.delimiter
-            )}'.`
-          );
-        }
+    const fromPath = this.path;
+    const toPath = nextStateNode.path;
 
-        if (currentState.onEntry) {
-          actionMap.onEntry = actionMap.onEntry.concat(currentState.onEntry);
-        }
-        if (currentState.activities) {
-          currentState.activities.forEach(activity => {
-            activityMap[getEventType(activity)] = true;
-            actionMap.onEntry = actionMap.onEntry.concat(start(activity));
-          });
-        }
+    let parent = this.machine;
 
-        currentPath = subPath;
+    for (let i = 0; i < Math.min(fromPath.length, toPath.length); i++) {
+      const fromPathSegment = fromPath[i];
+      const toPathSegment = toPath[i];
 
-        if (currentHistory) {
-          currentHistory = currentHistory[subPath];
-        }
-      });
+      if (fromPathSegment === toPathSegment) {
+        parent = parent.getStateNode(fromPathSegment);
+      } else {
+        break;
+      }
+    }
+
+    const commonAncestorPath = parent.path;
 
-      if (!currentState) {
-        throw new Error('no state');
+    let marker: StateNode = parent;
+    for (const segment of fromPath.slice(commonAncestorPath.length)) {
+      marker = marker.getStateNode(segment);
+      entryExitStates.exit.unshift(marker);
+    }
+
+    // Child node
+    if (parent === this) {
+      if (!internal) {
+        entryExitStates.exit.push(this);
+        entryExitStates.entry.push(this);
       }
+    }
 
-      let region = ensureTargetStateIsInCorrectRegion(
-        this,
-        event,
-        usedRegions,
-        currentState
-      );
+    marker = parent;
+    for (const segment of toPath.slice(commonAncestorPath.length)) {
+      marker = marker.getStateNode(segment);
+      entryExitStates.entry.push(marker);
+    }
 
-      while (region.parent) {
-        region = ensureTargetStateIsInCorrectRegion(
-          this,
-          event,
-          usedRegions,
-          region.parent
+    return {
+      entry: new Set(entryExitStates.entry),
+      exit: new Set(entryExitStates.exit)
+    };
+  }
+  private _evaluateCond(
+    condition: Condition,
+    extendedState: any,
+    eventObject: EventObject,
+    interimState: StateValue
+  ): boolean {
+    let condFn: ConditionPredicate;
+
+    if (typeof condition === 'string') {
+      if (!this.machine.options.guards[condition]) {
+        throw new Error(
+          `String condition '${condition}' is not defined on machine '${
+            this.machine.id
+          }'`
         );
       }
 
-      let paths = [currentState.path];
+      condFn = this.machine.options.guards[condition];
+    } else {
+      condFn = condition;
+    }
+
+    return condFn(extendedState, eventObject, interimState);
+  }
+  private _getActions(transition: StateTransition): Action[] {
+    const entryExitActions = {
+      entry: transition.entryExitStates
+        ? flatMap(
+            Array.from(transition.entryExitStates.entry).map(n => [
+              ...n.onEntry,
+              ...(n.activities
+                ? n.activities.map(activity => start(activity))
+                : [])
+            ])
+          )
+        : [],
+      exit: transition.entryExitStates
+        ? flatMap(
+            Array.from(transition.entryExitStates.exit).map(n => [
+              ...n.onExit,
+              ...(n.activities
+                ? n.activities.map(activity => stop(activity))
+                : [])
+            ])
+          )
+        : []
+    };
+
+    const actions = (entryExitActions.exit || [])
+      .concat(transition.actions || [])
+      .concat(entryExitActions.entry || []);
+
+    return actions;
+  }
+  private _getActivities(
+    state: State,
+    transition: StateTransition
+  ): ActivityMap {
+    if (!transition.entryExitStates) {
+      return {};
+    }
+
+    const activityMap = { ...state.activities };
+
+    Array.from(transition.entryExitStates.exit).forEach(stateNode => {
+      if (!stateNode.activities) {
+        return; // TODO: fixme
+      }
+
+      stateNode.activities.forEach(activity => {
+        activityMap[getActionType(activity)] = false;
+      });
+    });
+
+    Array.from(transition.entryExitStates.entry).forEach(stateNode => {
+      if (!stateNode.activities) {
+        return; // TODO: fixme
+      }
 
-      if (currentState.initial || currentState.parallel) {
-        const { initialState } = currentState;
-        actionMap.onEntry = actionMap.onEntry.concat(initialState.actions);
-        paths = toStatePaths(initialState.value).map(subPath =>
-          currentState!.path.concat(subPath)
+      stateNode.activities.forEach(activity => {
+        activityMap[getActionType(activity)] = true;
+      });
+    });
+
+    return activityMap;
+  }
+  public transition(
+    state: StateValue | State,
+    event: Event,
+    extendedState?: any
+  ): State {
+    const resolvedStateValue =
+      typeof state === 'string'
+        ? this.resolve(pathToStateValue(this.getResolvedPath(state)))
+        : state instanceof State
+          ? state
+          : this.resolve(state);
+
+    const eventType = getEventType(event);
+
+    if (this.strict) {
+      if (this.events.indexOf(eventType) === -1) {
+        throw new Error(
+          `Machine '${this.id}' does not accept event '${eventType}'`
         );
       }
+    }
+
+    const currentState = State.from(resolvedStateValue);
+
+    const historyValue =
+      resolvedStateValue instanceof State
+        ? resolvedStateValue.historyValue
+          ? resolvedStateValue.historyValue
+          : (this.machine.historyValue(
+              resolvedStateValue.value
+            ) as HistoryValue)
+        : (this.machine.historyValue(resolvedStateValue) as HistoryValue);
+
+    const stateTransition = this._transition(
+      currentState.value,
+      currentState,
+      event,
+      extendedState
+    );
+
+    try {
+      this.ensureValidPaths(stateTransition.paths);
+    } catch (e) {
+      throw new Error(
+        `Event '${eventType}' leads to an invalid configuration: ` + e.message
+      );
+    }
+
+    const actions = this._getActions(stateTransition);
+    const activities = this._getActivities(currentState, stateTransition);
 
-      finalPaths.push(...paths);
+    const raisedEvents = actions.filter(
+      action =>
+        typeof action === 'object' &&
+        (action.type === actionTypes.raise || action.type === actionTypes.null)
+    ) as ActionObject[];
 
-      while (currentState.initial) {
-        if (!currentState || !currentState.states) {
-          throw new Error(`Invalid initial state`);
+    const nonEventActions = actions.filter(
+      action =>
+        typeof action !== 'object' ||
+        (action.type !== actionTypes.raise && action.type !== actionTypes.null)
+    );
+    const stateNodes = stateTransition.value
+      ? this.getStateNodes(stateTransition.value)
+      : [];
+
+    const isTransient = stateNodes.some(stateNode => stateNode.transient);
+    if (isTransient) {
+      raisedEvents.push({ type: actionTypes.null });
+    }
+
+    const data = {};
+    stateNodes.forEach(stateNode => {
+      data[stateNode.id] = stateNode.data;
+    });
+
+    const nextState = stateTransition.value
+      ? new State(
+          stateTransition.value,
+          StateNode.updateHistoryValue(historyValue, stateTransition.value),
+          currentState,
+          nonEventActions,
+          activities,
+          data,
+          raisedEvents
+        )
+      : undefined;
+
+    if (!nextState) {
+      // Unchanged state should be returned with no actions
+      return State.inert(currentState);
+    }
+
+    // Dispose of previous histories to prevent memory leaks
+    delete currentState.history;
+
+    let maybeNextState = nextState;
+    while (raisedEvents.length) {
+      const currentActions = maybeNextState.actions;
+      const raisedEvent = raisedEvents.shift()!;
+      maybeNextState = this.transition(
+        maybeNextState,
+        raisedEvent.type === actionTypes.null ? NULL_EVENT : raisedEvent.event,
+        extendedState
+      );
+      maybeNextState.actions.unshift(...currentActions);
+    }
+
+    return maybeNextState;
+  }
+  private ensureValidPaths(paths: string[][]): void {
+    const visitedParents = new Map<StateNode, StateNode[]>();
+
+    const stateNodes = flatMap(
+      paths.map(_path => this.getRelativeStateNodes(_path))
+    );
+
+    outer: for (const stateNode of stateNodes) {
+      let marker = stateNode;
+
+      while (marker.parent) {
+        if (visitedParents.has(marker.parent)) {
+          if (marker.parent.parallel) {
+            continue outer;
+          }
+
+          throw new Error(
+            `State node '${stateNode.id}' shares parent '${
+              marker.parent.id
+            }' with state node '${visitedParents
+              .get(marker.parent)!
+              .map(a => a.id)}'`
+          );
         }
-        currentState = currentState.states[currentState.initial];
 
-        if (currentState.activities) {
-          currentState.activities.forEach(activity => {
-            activityMap[getEventType(activity)] = true;
-            actionMap.onEntry = actionMap.onEntry.concat(start(activity));
-          });
+        if (!visitedParents.get(marker.parent)) {
+          visitedParents.set(marker.parent, [stateNode]);
+        } else {
+          visitedParents.get(marker.parent)!.push(stateNode);
         }
+
+        marker = marker.parent;
       }
-      const myActions = (currentState.onEntry
-        ? currentState.onEntry.filter(
-            action =>
-              typeof action === 'object' && action.type === actionTypes.raise
-          )
-        : []
-      ).concat(currentState.on[NULL_EVENT] ? { type: actionTypes.null } : []);
-      myActions.forEach(action => raisedEvents.push(action));
-    });
+    }
+  }
+  public getStateNode(stateKey: string): StateNode {
+    if (isStateId(stateKey)) {
+      return this.machine.getStateNodeById(stateKey);
+    }
 
-    return {
-      statePaths: finalPaths,
-      actions: actionMap,
-      activities: activityMap,
-      events: raisedEvents as EventObject[]
-    };
+    if (!this.states) {
+      throw new Error(
+        `Unable to retrieve child state '${stateKey}' from '${
+          this.id
+        }'; no child states exist.`
+      );
+    }
+
+    const result = this.states[stateKey];
+    if (!result) {
+      throw new Error(
+        `Child state '${stateKey}' does not exist on '${this.id}'`
+      );
+    }
+
+    return result;
   }
+  public getStateNodeById(stateId: string): StateNode {
+    const resolvedStateId = isStateId(stateId)
+      ? stateId.slice(STATE_IDENTIFIER.length)
+      : stateId;
+    const stateNode = this.machine.idMap[resolvedStateId];
+
+    if (!stateNode) {
+      throw new Error(
+        `Substate '#${resolvedStateId}' does not exist on '${this.id}'`
+      );
+    }
+
+    return stateNode;
+  }
+  public getStateNodeByPath(statePath: string | string[]): StateNode {
+    const arrayStatePath = toStatePath(statePath, this.delimiter);
+    let currentStateNode: StateNode = this;
+    while (arrayStatePath.length) {
+      const key = arrayStatePath.shift()!;
+      currentStateNode = currentStateNode.getStateNode(key);
+    }
+
+    return currentStateNode;
+  }
+  private resolve(stateValue: StateValue): StateValue {
+    if (typeof stateValue === 'string') {
+      const subStateNode = this.getStateNode(stateValue);
+      return subStateNode.initial
+        ? { [stateValue]: subStateNode.initialStateValue! }
+        : stateValue;
+    }
+
+    if (this.parallel) {
+      return mapValues(
+        this.initialStateValue as Record<string, StateValue>,
+        (subStateValue, subStateKey) => {
+          return subStateValue
+            ? this.getStateNode(subStateKey).resolve(
+                stateValue[subStateKey] || subStateValue
+              )
+            : {};
+        }
+      );
+    }
+
+    return mapValues(stateValue, (subStateValue, subStateKey) => {
+      return subStateValue
+        ? this.getStateNode(subStateKey).resolve(subStateValue)
+        : {};
+    });
+  }
+
   private get resolvedStateValue(): StateValue {
     const { key } = this;
 
     if (this.parallel) {
       return {
-        [key]: mapValues(
+        [key]: mapFilterValues(
           this.states,
-          stateNode => stateNode.resolvedStateValue[stateNode.key]
+          stateNode => stateNode.resolvedStateValue[stateNode.key],
+          stateNode => !stateNode.history
         )
       };
     }
@@ -826,16 +932,19 @@ class StateNode implements StateNodeConfig {
     return toStatePath(stateIdentifier, this.delimiter);
   }
   private get initialStateValue(): StateValue | undefined {
-    const initialStateValue =
-      this.__cache.initialState ||
-      ((this.parallel
-        ? mapValues(
-            this.states as Record<string, StateNode>,
-            state => state.initialStateValue
-          )
-        : typeof this.resolvedStateValue === 'string'
-          ? undefined
-          : this.resolvedStateValue[this.key]) as StateValue);
+    if (this.__cache.initialState) {
+      return this.__cache.initialState;
+    }
+
+    const initialStateValue = (this.parallel
+      ? mapFilterValues(
+          this.states as Record<string, StateNode>,
+          state => state.initialStateValue || {},
+          stateNode => !stateNode.history
+        )
+      : typeof this.resolvedStateValue === 'string'
+        ? undefined
+        : this.resolvedStateValue[this.key]) as StateValue;
 
     this.__cache.initialState = initialStateValue;
 
@@ -865,7 +974,53 @@ class StateNode implements StateNodeConfig {
       }
     });
 
-    return new State(initialStateValue, undefined, actions, activityMap);
+    // TODO: deduplicate - DRY (from this.transition())
+    const raisedEvents = actions.filter(
+      action =>
+        typeof action === 'object' &&
+        (action.type === actionTypes.raise || action.type === actionTypes.null)
+    ) as ActionObject[];
+
+    const initialState = new State(
+      initialStateValue,
+      undefined,
+      undefined,
+      actions,
+      activityMap
+    );
+
+    let maybeNextState = initialState;
+    while (raisedEvents.length) {
+      const currentActions = maybeNextState.actions;
+      const raisedEvent = raisedEvents.shift()!;
+      maybeNextState = this.transition(
+        maybeNextState,
+        raisedEvent.type === actionTypes.null ? NULL_EVENT : raisedEvent.event,
+        undefined // TODO: consider initial state given external state
+      );
+      maybeNextState.actions.unshift(...currentActions);
+    }
+
+    return maybeNextState;
+  }
+  public get target(): StateValue | undefined {
+    let target;
+    if (this.history) {
+      const historyConfig = this.config as HistoryStateNodeConfig;
+      if (historyConfig.target && typeof historyConfig.target === 'string') {
+        target = isStateId(historyConfig.target)
+          ? pathToStateValue(
+              this.machine
+                .getStateNodeById(historyConfig.target)
+                .path.slice(this.path.length - 1)
+            )
+          : historyConfig.target;
+      } else {
+        target = historyConfig.target;
+      }
+    }
+
+    return target;
   }
   public getStates(stateValue: StateValue): StateNode[] {
     if (typeof stateValue === 'string') {
@@ -880,30 +1035,215 @@ class StateNode implements StateNodeConfig {
 
     return stateNodes;
   }
-  public getState(relativeStateId: string | string[]): StateNode | undefined {
+
+  /**
+   * Returns the leaf nodes from a state path relative to this state node.
+   *
+   * @param relativeStateId The relative state path to retrieve the state nodes
+   * @param history The previous state to retrieve history
+   * @param resolve Whether state nodes should resolve to initial child state nodes
+   */
+  public getRelativeStateNodes(
+    relativeStateId: string | string[],
+    historyValue?: HistoryValue,
+    resolve: boolean = true
+  ): StateNode[] {
     if (typeof relativeStateId === 'string' && isStateId(relativeStateId)) {
-      return this.getStateNodeById(relativeStateId);
+      const unresolvedStateNode = this.getStateNodeById(relativeStateId);
+
+      return resolve
+        ? unresolvedStateNode.history
+          ? unresolvedStateNode.resolveHistory(historyValue)
+          : unresolvedStateNode.initialStateNodes
+        : [unresolvedStateNode];
     }
 
     const statePath = toStatePath(relativeStateId, this.delimiter);
 
-    try {
-      return statePath.reduce(
-        (subState, subPath) => {
-          if (!subState.states) {
-            throw new Error(
-              `Cannot retrieve subPath '${subPath}' from node with no states`
-            );
-          }
-          return subState.states[subPath];
-        },
-        this as StateNode
-      );
-    } catch (e) {
+    const rootStateNode = this.parent || this;
+
+    const unresolvedStateNodes = rootStateNode.getFromRelativePath(
+      statePath,
+      historyValue
+    );
+
+    if (!resolve) {
+      return unresolvedStateNodes;
+    }
+    return flatMap(
+      unresolvedStateNodes.map(stateNode => stateNode.initialStateNodes)
+    );
+  }
+  public get initialStateNodes(): StateNode[] {
+    // todo - isLeafNode or something
+    if (!this.parallel && !this.initial) {
+      return [this];
+    }
+
+    const { initialState } = this;
+    const initialStateNodePaths = toStatePaths(initialState.value);
+    return flatMap(
+      initialStateNodePaths.map(initialPath =>
+        this.getFromRelativePath(initialPath)
+      )
+    );
+  }
+  /**
+   * Retrieves state nodes from a relative path to this state node.
+   *
+   * @param relativePath The relative path from this state node
+   * @param historyValue
+   */
+  public getFromRelativePath(
+    relativePath: string[],
+    historyValue?: HistoryValue
+  ): StateNode[] {
+    if (!relativePath.length) {
+      return [this];
+    }
+
+    const [x, ...xs] = relativePath;
+
+    if (!this.states) {
       throw new Error(
-        `State '${relativeStateId} does not exist on machine '${this.id}'`
+        `Cannot retrieve subPath '${x}' from node with no states`
+      );
+    }
+
+    // TODO: remove (4.0)
+    if (x === HISTORY_KEY) {
+      if (!historyValue) {
+        return [this];
+      }
+
+      const subHistoryValue = nestedPath<HistoryValue>(this.path, 'states')(
+        historyValue
+      ).current;
+
+      if (typeof subHistoryValue === 'string') {
+        return this.states[subHistoryValue].getFromRelativePath(
+          xs,
+          historyValue
+        );
+      }
+
+      return flatMap(
+        Object.keys(subHistoryValue!).map(key => {
+          return this.states[key].getFromRelativePath(xs, historyValue);
+        })
       );
     }
+
+    const childStateNode = this.getStateNode(x);
+
+    if (childStateNode.history) {
+      return childStateNode.resolveHistory(historyValue);
+    }
+
+    if (!this.states[x]) {
+      throw new Error(`Child state '${x}' does not exist on '${this.id}'`);
+    }
+
+    return this.states[x].getFromRelativePath(xs, historyValue);
+  }
+  public static updateHistoryValue(
+    hist: HistoryValue,
+    stateValue: StateValue
+  ): HistoryValue {
+    function update(
+      _hist: HistoryValue,
+      _sv: StateValue
+    ): Record<string, HistoryValue | undefined> {
+      return mapValues(_hist.states, (subHist, key) => {
+        if (!subHist) {
+          return undefined;
+        }
+        const subStateValue =
+          (typeof _sv === 'string' ? undefined : _sv[key]) ||
+          (subHist ? subHist.current : undefined);
+
+        if (!subStateValue) {
+          return undefined;
+        }
+
+        return {
+          current: subStateValue,
+          states: update(subHist, subStateValue)
+        };
+      });
+    }
+    return {
+      current: stateValue,
+      states: update(hist, stateValue)
+    };
+  }
+  public historyValue(
+    relativeStateValue?: StateValue | undefined
+  ): HistoryValue | undefined {
+    if (!Object.keys(this.states).length) {
+      return undefined;
+    }
+
+    return {
+      current: relativeStateValue || this.initialStateValue,
+      states: mapFilterValues(
+        this.states,
+        (stateNode, key) => {
+          if (!relativeStateValue) {
+            return stateNode.historyValue();
+          }
+
+          const subStateValue =
+            typeof relativeStateValue === 'string'
+              ? undefined
+              : relativeStateValue[key];
+
+          return stateNode.historyValue(
+            subStateValue || stateNode.initialStateValue
+          );
+        },
+        stateNode => !stateNode.history
+      )
+    };
+  }
+  /**
+   * Resolves to the historical value(s) of the parent state node,
+   * represented by state nodes.
+   *
+   * @param historyValue
+   */
+  private resolveHistory(historyValue?: HistoryValue): StateNode[] {
+    if (!this.history) {
+      return [this];
+    }
+
+    const parent = this.parent!;
+
+    if (!historyValue) {
+      return this.target
+        ? flatMap(
+            toStatePaths(this.target).map(relativeChildPath =>
+              parent.getFromRelativePath(relativeChildPath)
+            )
+          )
+        : this.parent!.initialStateNodes;
+    }
+
+    const subHistoryValue = nestedPath<HistoryValue>(parent.path, 'states')(
+      historyValue
+    ).current;
+
+    if (typeof subHistoryValue === 'string') {
+      return [parent.getStateNode(subHistoryValue)];
+    }
+
+    return flatMap(
+      toStatePaths(subHistoryValue!).map(subStatePath => {
+        return this.history === 'deep'
+          ? parent.getFromRelativePath(subStatePath)
+          : [parent.states[subStatePath[0]]];
+      })
+    );
   }
   get events(): EventType[] {
     if (this.__cache.events) {
@@ -925,6 +1265,33 @@ class StateNode implements StateNodeConfig {
 
     return (this.__cache.events = Array.from(events));
   }
+  private formatTransition(
+    targets: string[],
+    transitionConfig?: TransitionConfig
+  ): TargetTransitionConfig {
+    let internal = transitionConfig ? transitionConfig.internal : false;
+
+    // Format targets to their full string path
+    const formattedTargets = targets.map(target => {
+      const internalTarget =
+        typeof target === 'string' && target[0] === this.delimiter;
+      internal = internal || internalTarget;
+
+      // If internal target is defined on machine,
+      // do not include machine key on target
+      if (internalTarget && !this.parent) {
+        return target.slice(1);
+      }
+
+      return internalTarget ? this.key + target : target;
+    });
+
+    return {
+      ...transitionConfig,
+      target: formattedTargets,
+      internal
+    };
+  }
   private formatTransitions(
     onConfig: Record<string, Transition | undefined>
   ): Record<string, ConditionalTransitionConfig> {
@@ -934,27 +1301,36 @@ class StateNode implements StateNodeConfig {
       }
 
       if (Array.isArray(value)) {
-        return value;
+        return value.map(targetTransitionConfig =>
+          this.formatTransition(
+            ([] as string[]).concat(targetTransitionConfig.target),
+            targetTransitionConfig
+          )
+        );
       }
 
       if (typeof value === 'string') {
-        return [{ target: value }];
+        return [this.formatTransition([value])];
       }
 
       return Object.keys(value).map(target => {
-        return {
-          target,
-          ...value[target]
-        };
+        return this.formatTransition([target], value[target]);
       });
     });
   }
 }
 
-export function Machine(
-  config: MachineConfig | ParallelMachineConfig
-): StandardMachine | ParallelMachine {
-  return new StateNode(config) as StandardMachine | ParallelMachine;
+export function Machine<
+  T extends StandardMachineConfig | ParallelMachineConfig
+>(
+  config: T,
+  options?: MachineOptions
+): T extends ParallelMachineConfig
+  ? ParallelMachine
+  : T extends StandardMachineConfig ? StandardMachine : never {
+  return new StateNode(config, options) as T extends ParallelMachineConfig
+    ? ParallelMachine
+    : T extends StandardMachineConfig ? StandardMachine : never;
 }
 
 export { StateNode };