anchor.diff:  guardian_process(FunctionPid, AccumulatorPid, PoolPid, DyingMessage) ->
       erlang:monitor(process, FunctionPid),
       erlang:monitor(process, AccumulatorPid),
  -    erlang:monitor(process, PoolPid),	
  +    erlang:monitor(process, PoolPid),   
       receive
           {'DOWN', _, process, FunctionPid, _} ->
               % The AsyncFunction process has died. 
  
positive.code: 
  %%% INTERFACE %%%
  
  %% @doc Convenience method to start a comet process.
  comet(F) -> 
      comet(F, default).
  
  %% @doc Convenience method to start a comet process.
  comet(F, Pool) ->
      Pid = spawn_with_context(F),
      wf:wire(page, page, #comet { function=Pid, pool=Pool, scope=local }),
      {ok, Pid}.
  
  %% @doc Convenience method to start a comet process with global pool.
  comet_global(F, Pool) ->
      Pid = spawn_with_context(F),
      wf:wire(page, page, #comet { function=Pid, pool=Pool, scope=global }),
      {ok, Pid}.
  
  
negative.code: 
  %%% PRIVATE FUNCTIONS %%%
  
  %% @doc Mode can be either atoms 'page' or 'postback'.
  %% page means it's spawned from wf:comet(), meaning that the accumulator and whatnot
  %% is not started until after the comet postback. So we have to run a checker to fix it
  %% postbak means it's spawned from the postback event already along with the accumulator
  %% and everything. So no need to check for it.
  spawn_with_context(Function,Mode) ->
      Context = wf_context:context(),
      Pid = erlang:spawn(fun() -> 
          wf_context:context(Context),
          wf_context:clear_actions(),
          Function(),
          flush() 
      end),
  
      case Mode of
          postback -> do_nothing;
          page ->
              %% This function gets called before we've verified that the browser
              %% is even doing JS, and without JS, this will never get assigned 
              %% an accumulator.  So here's a hack to make sure that the accumulator
              %% exists after 20 seconds, and if not, it simply kills the pid
              start_accumulator_check_timer(Pid)
      end,
      Pid.
  
  get_accumulator_checker_pid(Pid) ->
      Key = get_accumulator_checker_key(Pid),
      {ok, _CheckPid} = process_registry_handler:get_pid(Key).
  
  get_accumulator_checker_key(Pid) ->
      _Key = {accumulator_check_timer,Pid}.
  
  start_accumulator_check_timer(Pid) ->
      Key = get_accumulator_checker_key(Pid),
      CheckFunction = fun() ->
          receive
              accumulator_started -> ok
          after ?TWENTY_SECONDS + ?TEN_SECONDS ->
              %% The page never posted back at all (Hey, we gave it 30 seconds), and so the accumulator
              %% loop doesn't exist for this pid, and so we have nothing
              %% to check for it. So let's just kill the pid
              exit(Pid,accumulator_never_started)
          end
      end,
  
      {ok, _CheckPid} = process_registry_handler:get_pid(Key,CheckFunction).
  
  
  inner_send(Pool, Scope, Message) ->
  