anchor.diff:  
       % Create a process for the AsyncFunction...
       FunctionPid = case Record#comet.function of
  -        F when is_function(F) -> spawn_with_context(F);
  -        P when is_pid(P) -> P
  +        F when is_function(F) -> spawn_with_context(F,postback);
  +        P when is_pid(P) -> 
  +            %% If P is a pid, then it was initiated on the page
  +            %% and that means we have to kill the checker pid that's
  +            %% waiting to kill it for us.  Hacky, I know. Real
  +            %% spaghetti-like. I don't particularly like it, but it
  +            %% fixes the bug.
  +            {ok,CheckerPid} = get_accumulator_checker_pid(P),
  +            CheckerPid ! accumulator_started,
  +            P
       end,
   
       % Create a process for the AsyncGuardian...
  
positive.code:     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.
  
  
negative.code: 
  %%% INTERFACE %%%
  
  %% NOTE: For comet/1, comet/2, and comet_global/2, there was a bug that would
  %% cause the process to loop forever without being killed in the event that
  %% wf:comet was called without javascript being loaded.  This bug is documented
  %% here: https://github.com/nitrogen/nitrogen/issues/37
  %%
  %% The "Easy" fix would be to change those functions to start the comet call
  %% inside the postback by changing function=Pid to function=F. Then we would
  %% be guaranteed that the accumulator would be watching the pid and can kill it
  %% on its own. But the drawback to this is that the comet function itself would
  %% not start until the postback is received, meaning the function wouldn't be started
  %% until javascript is loaded on the client and the postback received by the server.
  %% This may be too much latency, so I've introduced a couple of hacks to make sure that
  %% the pid is killed if the accumulator is never started (meaning never posted back).
  
  %% @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,page),
      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,page),
      wf:wire(page, page, #comet { function=Pid, pool=Pool, scope=global }),
      {ok, Pid}.
  
  