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:     | {global, GlobalName::term()}
      | {via, Module::atom(), ViaName::term()}.
  
  -type call_option() :: {timeout, pos_integer() | infinity}.
  -type call_options() :: [call_option()].
  -type switch_option() :: {timeout, pos_integer() | infinity}
      | wait_for_result.
  -type switch_options() :: [switch_option()].
  
  -export_type([server_instance/0]).
  
  %%
  