anchor.diff:  handle_check_return({up, Check}, ServiceId, State) ->
       #health_check{service_pid = Pid} = Check,
       Healths = orddict:store(ServiceId, Check, State#state.health_checks),
  -
  -    %% Update the set of active services locally
  -    Services = ordsets:add_element(ServiceId, State#state.services),
  -    S2 = State#state { services = Services },
  -
  -    %% Remove any existing mrefs for this service
  -    delete_service_mref(ServiceId),
  -
  -    %% Setup a monitor for the Pid representing this service
  -    Mref = erlang:monitor(process, Pid),
  -    erlang:put(Mref, ServiceId),
  -    erlang:put(ServiceId, Mref),
  -
  -    %% Update our local ETS table and broadcast
  -    S3 = local_update(S2),
  -    update_avsn(S3#state{health_checks = Healths});
  +    S2 = State#state{health_checks = Healths},
  +    add_service(ServiceId, Pid, S2);
   handle_check_return({down, Check}, ServiceId, State) ->
       Healths = orddict:store(ServiceId, Check, State#state.health_checks),
  -
  -    %% Update the set of active services locally
  -    Services = ordsets:del_element(ServiceId, State#state.services),
  -    S2 = State#state { services = Services },
  -
  -    %% Remove any existing mrefs for this service
  -    delete_service_mref(ServiceId),
  -
  -    %% Update local ETS table and broadcast
  -    S3 = local_update(S2),
  -
  -    update_avsn(S3#state{health_checks = Healths}).
  +    S2 = State#state{health_checks = Healths},
  +    drop_service(ServiceId, S2).
  +
  +remove_health_check(ServiceId, State) ->
  +    #state{health_checks = Healths} = State,
  +    Healths2 = case orddict:find(ServiceId, Healths) of
  +        error ->
  +            Healths;
  +        {ok, Check} ->
  +            health_fsm(remove, ServiceId, Check),
  +            orddict:erase(ServiceId, Healths)
  +    end,
  +    State#state{health_checks = Healths2}.
   
   %% health checks are an fsm to make mental modeling easier.
   %% There are X states:
  
positive.code:         max_callback_failures = proplists:get_value(max_callback_failures, Options, 3),
          interval_tref = IntervalTref
      },
      Healths = orddict:store(Id, CheckRec, State1#state.health_checks),
      {reply, ok, State1#state{health_checks = Healths}};
  
  handle_call({service_down, Id}, _From, State) ->
      %% Update the set of active services locally
      Services = ordsets:del_element(Id, State#state.services),
      S2 = State#state { services = Services },
  
      %% Remove any existing mrefs for this service
      delete_service_mref(Id),
  
      %% Update local ETS table and broadcast
      S3 = local_update(S2),
  
      %% Remove health check if any
      case orddict:find(Id, State#state.health_checks) of
          error ->
              ok;
          {ok, Check} ->
              health_fsm(remove, Id, Check)
      end,
  
      Healths = orddict:erase(Id, S3#state.health_checks),
      {reply, ok, update_avsn(S3#state{health_checks = Healths})};
  
  handle_call({node_status, Status}, _From, State) ->
      Transition = {State#state.status, Status},
  
negative.code:     {reply, State#state.avsn, State};
  
  handle_call({service_up, Id, Pid}, _From, State) ->
      %% remove any existing health checks
      S2 = remove_health_check(Id, State),
  
      S3 = add_service(Id, Pid, S2),
  
      {reply, ok, S3};
  
  handle_call({service_up, Id, Pid, MFA, Options}, From, State) ->
      %% update the active set of services if needed.
      {reply, _, State1} = handle_call({service_up, Id, Pid}, From, State),
  
      State2 = remove_health_check(Id, State1),
  
      %% install the health check
      CheckInterval = proplists:get_value(check_interval, Options, 60),
  