anchor.diff:                                          erlang:get_stacktrace()}}
                         end,
   
  -                  Async ! {Reply, R}
  +                  Controller ! {Reply, R}
             end),
   
       Type = proplists:get_value(type, Opts, wait),
       async_loop_wait_result(Type, MRef, Child, Reply, []).
   
  -maybe_register_with_parent_async(PDict) ->
  -    case lists:keyfind('$async', 1, PDict) of
  -        false ->
  -            ok;
  -        {_, Pid} ->
  -            register_with_parent_async(Pid)
  -    end.
  +maybe_register_with_parent_async(undefined) ->
  +    ok;
  +maybe_register_with_parent_async(Pid) ->
  +    register_with_parent_async(Pid).
   
   register_with_parent_async(Pid) ->
  +    controller = get_role(),
       ok = call(Pid, {register_child_async, self()}).
   
   async_loop_wait_result(Type, ParentMRef, Child, Reply, ChildAsyncs) ->
  
positive.code:       fun (Msg) ->
                self() ! Msg
        end, lists:reverse(PendingMsgs)).
  
negative.code:     end.
  
  %% internal
  async_init(Parent, ParentController, Opts, Fun) ->
      process_flag(trap_exit, true),
      MRef = erlang:monitor(process, Parent),
  
      set_role(controller),
      maybe_register_with_parent_async(ParentController),
  
      Reply      = make_ref(),
      Controller = self(),
  
      Child =
          spawn_link(
            fun () ->
                    set_role(executor),
                    set_controller(Controller),
  
                    R = try
                            {ok, Fun()}
  