anchor.diff:      {noreply, State};
   
   handle_call({receive_message, Peer, OriginalMessage}, 
  -            _From, 
  +            From, 
  +            #state{pre_interposition_funs=PreInterpositionFuns}=State) ->
  +    %% Run all interposition functions.
  +    DeliveryFun = fun() ->
  +        %% Fire pre-interposition functions.
  +        PreFoldFun = fun(_Name, PreInterpositionFun, ok) ->
  +            lager:info("firing preinterposition fun for original message: ~p", [OriginalMessage]),
  +            PreInterpositionFun({receive_message, Peer, OriginalMessage}),
  +            ok
  +        end,
  +        dict:fold(PreFoldFun, ok, PreInterpositionFuns),
  +
  +        %% Once pre-interposition returns, then schedule for delivery.
  +        gen_server:cast(?MODULE, {receive_message, From, Peer, OriginalMessage})
  +    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,
  +
  +    {noreply, State};
  +
  +handle_call({receive_message, Message}, From, State) ->
  +    handle_message(Message, From, State);
  +
  +handle_call(members_for_orchestration, _From, #state{membership=Membership}=State) ->
  +    {reply, {ok, Membership}, State};
  +
  +handle_call(members, _From, #state{membership=Membership}=State) ->
  +    Members = [P || #{name := P} <- Membership],
  +    {reply, {ok, Members}, State};
  +
  +handle_call(connections, _From, #state{connections=Connections}=State) ->
  +    {reply, {ok, Connections}, State};
  +
  +handle_call(get_local_state, _From, #state{membership_strategy_state=MembershipStrategyState}=State) ->
  +    {reply, {ok, MembershipStrategyState}, State};
  +
  +handle_call(Msg, _From, State) ->
  +    lager:warning("Unhandled call messages at module ~p: ~p", [?MODULE, Msg]),
  +    {reply, ok, State}.
  +
  +%% @private
  +-spec handle_cast(term(), state_t()) -> {noreply, state_t()}.
  +handle_cast({receive_message, From, Peer, OriginalMessage}, 
               #state{pre_interposition_funs=PreInterpositionFuns,
                      interposition_funs=InterpositionFuns,
                      post_interposition_funs=PostInterpositionFuns} = State) ->
       lager:info("~p: Inside the receive interposition, message from ~p at node ~p", [node(), Peer, node()]),
       lager:info("~p: Count of interposition funs: ~p", [node(), dict:size(InterpositionFuns)]),
   
  -    %% Fire pre-interposition functions.
  -    PreFoldFun = fun(_Name, PreInterpositionFun, ok) ->
  -        PreInterpositionFun({receive_message, Peer, OriginalMessage}),
  -        ok
  -    end,
  -    dict:fold(PreFoldFun, ok, PreInterpositionFuns),
  -
       %% Filter messages using interposition functions.
       FoldFun = fun(_Name, InterpositionFun, M) ->
           InterpositionFun({receive_message, Peer, M})
  
positive.code:                     Connections),
  
      partisan_util:process_forward(ServerRef, Message),
      {reply, ok, State};
  
  %% Causal messages.
  handle_message({forward_message, ServerRef, {causal, Label, _, _, _, _, _} = Message}, State) ->
      case partisan_causality_backend:is_causal_message(Message) of
          true ->
              partisan_causality_backend:receive_message(Label, Message);
  
negative.code: 
  %% @private
  handle_message({ping, SourceNode, DestinationNode, SourceTime},
                 From,
                 #state{pending=Pending,
                        connections=Connections0,
                        membership=Membership}=State) ->
  