anchor.diff:  %% 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({Name, Function}, Mode) ->
  +    Context = wf_context:context(),
  +    SeriesID = wf_context:series_id(),
  +    Key = {SeriesID, Name},
  +    {ok, Pid} = process_registry_handler:get_pid(Key, fun() ->
  +        wf_context:context(Context),
  +        wf_context:clear_actions(),
  +        case erlang:fun_info(Function, arity) of
  +        {arity, 1} -> Function(Mode);
  +        {arity, 0} -> Function()
  +        end,
  +        flush() 
  +    end),
  +    start_accumulator_check_timer(Mode, Pid),
  +    Pid;
   spawn_with_context(Function,Mode) ->
       Context = wf_context:context(),
       Pid = erlang:spawn(fun() -> 
  
positive.code:         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}.
  
negative.code: 
      % Create a process for the AsyncFunction...
      FunctionPid = case Record#comet.function of
          {Name, F} when is_function(F) ->
              P = spawn_with_context({Name, F}, postback),
              notify_accumulator_checker(P),
              P;
          F when is_function(F) ->
              spawn_with_context(F, postback);
          P when is_pid(P) -> 
              notify_accumulator_checker(P),
              P
      end,
  
  