anchor.diff:  %%
   
   -spec call(Instance::server_instance(), Module::atom(), Function::atom(),
  -        Args::list(),
  -        Options::[{timeout, Timeout::pos_integer() | infinity}]) ->
  -    Result::term().
  +    Args::list(), Options::call_options()) -> Result::term().
   
   call(Pid, Module, Function, Args, Options) when is_atom(Module)
           andalso is_atom(Function) andalso is_list(Args)
           andalso is_list(Options) ->
       Request = {call, Module, Function, Args, Options},
  -    case gen_fsm:sync_send_event(Pid, Request, infinity) of
  -        {ok, Result} ->
  -            Result;
  -        {error, Error} ->
  -            % TODO: Unpack Error if needed
  -            erlang:error(Error)
  -    end.
  +    call(Pid, Request).
   
   %%
   %% @doc Pass control to remote side by calling the function with arguments
   %%
   
   -spec switch(Instance::server_instance(), Module::atom(), Function::atom(),
  -        Args::list(), Options::[{timeout, Timeout::pos_integer() | infinity}
  -            | wait_for_result]) ->
  -    Result::ok | term() | {error, Reason::term()}.
  +        Args::list(), Options::switch_options()) ->
  +    Result::ok | term().
   
   switch(Pid, Module, Function, Args, Options) when is_atom(Module)
           andalso is_atom(Function) andalso is_list(Args)
  
positive.code:                     {stop, {switch_failed, Error}, State}
              end;
          {'P', StdoutData} ->
              ok = io:put_chars(StdoutData),
              {next_state, StateName, State};
          Request ->
              {stop, {invalid_request, Request}, State}
      catch
  
negative.code:         {empty, Queue} ->
              ok
      end.
  
  call(Pid, Request) ->
      case gen_fsm:sync_send_event(Pid, Request, infinity) of
          {ok, Result} ->
              Result;
          {error, Error} ->
              erlang:error(Error)
      end.
  
  print(Data, StateName, State) ->
      ok = io:put_chars(Data),
      {next_state, StateName, State}.
  
  spawn_call(Module, Function, Args) ->
      proc_lib:spawn_link(fun () ->
          exit(try {ok, apply(Module, Function, Args)}
              catch
                  Type:Reason ->
                      Trace = erlang:get_stacktrace(),
                      {error, {erlang, Type, Reason, Trace}}
              end)
          end).
  