anchor.diff:                                      Channel,
                                       PartitionKey,
                                       WrappedMessage,
  -                                    Connections);
  +                                    Connections,
  +                                    ForwardOptions,
  +                                    PreInterpositionFuns);
                   true ->
                       %% Tracing.
                       WrappedOriginalMessage = {forward_message, mynode(), MessageClock, ServerRef, OriginalMessage},
  
positive.code:     end;
  
  handle_call({send_message, Name, Channel, Message}, _From,
              #state{connections=Connections}=State) ->
      Result = do_send_message(Name, 
                               Channel, 
                               ?DEFAULT_PARTITION_KEY, 
                               Message, 
                               Connections),
      {reply, Result, State};
  
  handle_call({forward_message, Name, Channel, Clock, PartitionKey, ServerRef, OriginalMessage, Options}, 
              From, 
  
negative.code:             erlang:send_after(Period, ?MODULE, tree_refresh);
          false ->
              ok
      end.
  
  %% @private
  schedule_message_delivery(Name, Message, Channel, PartitionKey, PreInterpositionFuns) ->
      schedule_message_delivery(Name, Message, Channel, PartitionKey, [], PreInterpositionFuns).
  
  %% @private
  schedule_message_delivery(Name, Message, Channel, PartitionKey, Options, PreInterpositionFuns) ->
      %% Run all interposition functions.
      DeliveryFun = fun() ->
          %% Fire pre-interposition functions.
          PreFoldFun = fun(_Name, PreInterpositionFun, ok) ->
              lager:info("firing forward_message preinterposition fun for message: ~p", [Message]),
              PreInterpositionFun({forward_message, Name, Message}),
              ok
          end,
          dict:fold(PreFoldFun, ok, PreInterpositionFuns),
  
          %% Once pre-interposition returns, then schedule for delivery.
          gen_server:cast(?MODULE, {forward_message, undefined, Name, Channel, undefined, PartitionKey, undefined, Message, Options})
      end,
  
      case partisan_config:get(replaying, false) of 
          false ->
              %% Fire all pre-interposition functions, and then deliver, preserving serial order of messages.
              DeliveryFun();
          true ->
              %% Allow the system to proceed, and the message will be delivered once pre-interposition is done.
              spawn_link(DeliveryFun)
      end,
  
      ok.
  
  %% @private
  send_acknowledgement(Name, MessageClock, PreInterpositionFuns) ->
      %% Generate message.
      Message = {ack, MessageClock},
  
      %% Send on the default channel.
      schedule_message_delivery(Name, Message, ?DEFAULT_CHANNEL, ?DEFAULT_PARTITION_KEY, PreInterpositionFuns).