anchor.diff:                                                                 transform=TransFun,
                                                                  write=WriteFun}),
   
  -        %% Determine depth.
  -        Depth = depth(Dag, Dst, 0),
  -
  -        %% Re-create destination vertex with new depth.
  -        case digraph:vertex(Dag, Dst) of
  -            {_, Label} ->
  -                case Label of
  -                    Depth ->
  -                        %% Already correct depth; ignore.
  -                        ok;
  -                    Depth0 ->
  -                        VertexResult = digraph:add_vertex(Dag, Dst, Depth),
  -                        lager:info("Vertex: ~p re-created with depth ~p => ~p; result: ~p",
  -                                   [Dst, Depth0, Depth, VertexResult]),
  -                        lager:info("Vertex: ~p edges: ~p",
  -                                   [Dst, digraph:edges(Dag, Dst)])
  +        %% Determine depth; but ignore nodes that are transient,
  +        %% single-fire processes.
  +        case Dst of
  +            {_Id, _Type} ->
  +                Depth = depth(Dag, Dst, ?BASE_DEPTH),
  +
  +                %% Re-create destination vertex with new depth.
  +                case digraph:vertex(Dag, Dst) of
  +                    {_, Label} ->
  +                        case Label of
  +                            Depth ->
  +                                %% Already correct depth; ignore.
  +                                ok;
  +                            Depth0 ->
  +                                VertexResult = digraph:add_vertex(Dag, Dst, Depth),
  +                                lager:info("Vertex: ~p re-created with depth ~p => ~p; result: ~p",
  +                                           [Dst, Depth0, Depth, VertexResult]),
  +                                lager:info("Vertex: ~p edges: ~p",
  +                                           [Dst, digraph:edges(Dag, Dst)])
  +                        end;
  +                    _ ->
  +                        ok
                   end;
               _ ->
                   ok
  
positive.code:     {reply, {ok, Edges}, State};
  
  handle_call({add_vertices, Vs}, _From, #state{dag=Dag}=State) ->
      [digraph:add_vertex(Dag, V, 0) || V <- Vs],
      {reply, ok, State};
  
  handle_call(to_dot, _From, #state{dag=Dag}=State) ->
  
negative.code: v_str(V) when is_pid(V)->
      pid_to_list(V).
  
  %% @private
  depth(G, V, Max) ->
      InNeighbors = digraph:in_neighbours(G, V),
  
      %% Filter out single-fire nodes that are identified by process
      %% identifier only.
      FilterFun = fun({_Id, _Type}) ->
                          true;
                     (_) ->
                          false
                  end,
      Neighbors = lists:filter(FilterFun, InNeighbors),
  
      case Neighbors of
          [] ->
              Max;
          _ ->
              lists:foldl(fun(V1, MaxAcc) ->
                                  max(MaxAcc, depth(G, V1, Max + 1)) end, 
                          ?BASE_DEPTH, Neighbors)
      end.
  