code: function setNodeAsEntry(name) {
      const previousState = state;
  
      if (!isNodeDefined(state, name)) {
        state = addNode(state, name);
      }
  
      state = defineEntryNode(state, name);
  
      return Diff({
        from: previousState,
        to: state
      });
    }
docs: Dependency graphs emerge from one or more entry nodes. The ability to
  distinguish an entry node from a normal dependency node allows us to
  aggressively prune a node and all of its dependencies.
  
  As a basic example of why the concept is important, if `a -> b -> c`
  and we want to prune `b`, we know that we can safely prune `c` as well.
  
  But if `a -> b -> c -> a` and we want to prune `b`, then we need to know
  that `a` is an entry node, so that we don't traverse the cyclic graph
  and prune every node.
  
  This concept becomes increasingly important once we start dealing with
  more complicated cyclic graphs, as pruning can result in disconnected
  sub-graphs. For example, if we have `a -> b -> c -> d -> b` and we want
  to prune `a`, we can't safely prune `b -> c -> d -> b` as well, as `b`
  has a dependent `d`. However, if we don't prune them, then they are
  left disconnected from the other nodes.
  
  Hence we need to know a graph's entry points so that we can traverse it
  from the entries and find the nodes which are disconnected
  
  @param {String} name
  @returns {Diff}