anchor.diff:                  S#state{url_cache = NewDel}),
       {noreply, S1, S1#state.timeout}.
   
  +-spec handle_call(term(), from(), state()) -> {reply, ok | state(), state()}.
   handle_call(dbg_get_state, _, S) ->
       {reply, S, S};
   
   handle_call(_, _, S) -> {reply, ok, S}.
   
  +-spec handle_info(timeout, state()) -> {noreply, state(), non_neg_integer()} | {stop, normal, state()};
  +                 ({reference(), term()}, state()) -> {noreply, state()}.
   handle_info(timeout, S) ->
       handle_cast({die, none}, S);
  -
   % handle late replies to "catch gen_server:call"
   handle_info({Ref, _Msg}, S) when is_reference(Ref) ->
       {noreply, S}.
   
   % callback stubs
  -terminate(_Reason, _State) -> {}.
  -
  +-spec terminate(term(), state()) -> ok.
  +terminate(_Reason, _State) -> ok.
  +
  +-spec code_change(term(), state(), term()) -> {ok, state()}.
   code_change(_OldVsn, State, _Extra) -> {ok, State}.
   
   
  
positive.code:                 replicas :: 'false' | 'too_many_failed_nodes'
                      | [{replica(), node()}],
                  url_cache :: 'false' | gb_set()}).
  
  % THOUGHT: Eventually we want to partition tag keyspace instead
  % of using a single global keyspace. This can be done relatively
  
negative.code:                 url_cache = false,
                  timeout = Timeout}}.
  
  -type msg() :: get_msg() | put_msg() | update_msg() | delayed_update_msg()
               | delete_attrib_msg() | delete_msg()
               | has_tagname_msg() | get_tagnames_msg() | delete_tagname_msg()
               | gc_get_msg()
                 %% internal messages:
               | gc_get0.
  
  -type notify() :: notify_msg()
                    %% internal messages:
                  | {notify0, term()}.
  
  %%% Note to the reader!
  %%%
  %%% handle_casts below form a state machine. The order in which the functions
  