anchor.diff:  
   %%% PRIVATE FUNCTIONS %%%
   
  -spawn_with_context(Function) ->
  +%% @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(),
  -    erlang:spawn(fun() -> wf_context:context(Context), wf_context:clear_actions(), Function(), flush() end).
  +    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) ->
  
positive.code: guardian_process(FunctionPid, AccumulatorPid, PoolPid, DyingMessage) ->
      erlang:monitor(process, FunctionPid),
      erlang:monitor(process, AccumulatorPid),
      erlang:monitor(process, PoolPid),	
      receive
          {'DOWN', _, process, FunctionPid, _} ->
              % The AsyncFunction process has died. 
  
negative.code:     #event { type=system, delay=Interval, delegate=?MODULE, postback=start_async }.
  
  
  % Return true if the process is alive, accounting for processes on other nodes. 
  is_remote_process_alive(Pid) ->
      is_pid(Pid) andalso
      pong == net_adm:ping(node(Pid)) andalso
  