anchor.diff:                  false ->
                       % Guardian_process will detect that we've died and update
                       % the pool.
  +                    maybe_kill_waiting(Waiting),
                       erlang:exit({accumulator_loop, exiting_lease_expired})
               end;
  +        info ->
  +            Status = [{guardians, Guardians}, {actions, Actions}, {timer_ref, TimerRef}, {websocket_pid, WebsocketPid}, {process_tags, ProcessTags}],
  +            ?PRINT({accumulator_status, Status}),
  +            accumulator_loop(Guardians, Actions, Waiting, TimerRef, WebsocketPid, ProcessTags);
  +
           Other ->
               ?PRINT({accumulator_loop, unhandled_event, Other}),
               accumulator_loop(Guardians, Actions, Waiting, TimerRef, WebsocketPid, ProcessTags)
  
positive.code:     {ok, AccumulatorPid} = get_accumulator_pid(SeriesID),
      AccumulatorNode = node(AccumulatorPid),
      TimerRef = rpc:call(AccumulatorNode, erlang, send_after, [Timeout, AccumulatorPid, {add_actions, []}]),
  
      AccumulatorPid!{get_actions_blocking, self()},
      receive 
          {actions, X} -> erlang:cancel_timer(TimerRef), X;           
          Other -> ?PRINT({unhandled_event, Other}), []
      end.
  
  set_lease(LengthInMS) ->
  
negative.code:         %% If we have no TimerRef, then the browser never performed
          %% the callback, so kill this process after 20 seconds.
          case TimerRef == undefined of
              true  ->
                  maybe_kill_waiting(Waiting),
                  erlang:exit({accumulator_loop, timeout});
              false -> accumulator_loop(Guardians, Actions, Waiting, TimerRef, WebsocketPid, ProcessTags)
          end
      end.
  
  maybe_kill_waiting(Pid) when is_pid(Pid) ->
      Pid ! killed_when_accumulator_died;
  maybe_kill_waiting(_) ->
      ok.
  
  
  % The guardian process monitors the running AsyncFunction and
  % the running Accumulator. If either one dies, then send 
  