anchor.diff:              Pieceset = etorrent_monitorset:fetch(Pid, Monitors),
               NewNumpeers = decrement(Pieceset, Numpeers),
               NewMonitors = etorrent_monitorset:delete(Pid, Monitors),
  -            send_updates(Pieceset, Watchers, NewNumpeers),
  +            NewWatchers = send_updates(Pieceset, Watchers, NewNumpeers),
               INewState = State#state{
                   peer_monitors=NewMonitors,
  -                num_peers=NewNumpeers},
  +                num_peers=NewNumpeers,
  +                watchers=NewWatchers},
               INewState;
           false ->
  -            NewWatchers = lists:keydelete(Ref, #watcher.ref, Watchers),
  +            Watcher = lists:keyfind(MRef, #watcher.ref, Watchers),
  +            #watcher{timer_ref=TRef} = Watcher,
  +            case TRef of none -> ok; _ -> erlang:cancel_timer(TRef) end,
  +            NewWatchers = lists:keydelete(MRef, #watcher.ref, Watchers),
               State#state{watchers=NewWatchers}
       end,
  +    {noreply, NewState};
  +
  +handle_info({timeout, _, MRef}, State) ->
  +    #state{num_peers=Numpeers, watchers=Watchers} = State,
  +    Watcher = lists:keyfind(MRef, #watcher.ref, Watchers),
  +    #watcher{changed=Changed} = Watcher,
  +    NewWatcher = case Changed of
  +        %% If the watcher is still in the 'limited' state no update
  +        %% should be sent and the watcher should enter 'waiting'.
  +        false ->
  +            Watcher#watcher{timer_ref=none};
  +        %% If the watcher is in the 'updated' state an update should
  +        %% be sent and the watcher should enter 'limited'.
  +        true ->
  +            NewTRef = send_update(Watcher, Numpeers),
  +            Watcher#watcher{changed=false, timer_ref=NewTRef}
  +    end,
  +    NewWatchers = lists:keyreplace(MRef, #watcher.ref, Watchers, NewWatcher),
  +    NewState = State#state{watchers=NewWatchers},
       {noreply, NewState}.
   
   
  
positive.code:     ref :: reference(),
      tag :: term(),
      pieceset :: pieceset(),
      changed :: boolean(),
      timer_ref :: reference()}).
  
  -record(state, {
      torrent_id :: torrent_id(),
  
negative.code:         watchers=Watchers} = State,
      NewNumpeers = increment(Pieceset, Numpeers),
      NewMonitors = etorrent_monitorset:insert(PeerPid, Pieceset, Monitors),
      NewWatchers = send_updates(Pieceset, Watchers, NewNumpeers),
      NewState = State#state{
          peer_monitors=NewMonitors,
          num_peers=NewNumpeers,
          watchers=NewWatchers},
      {reply, ok, NewState};
  
  handle_call({add_piece, Pid, PieceIndex, Pieceset}, _, State) ->
  