anchor.diff:                  %% Destructure message.
                   {TracingNode, OriginNode, InterpositionType, MessagePayload, RewrittenMessagePayload} = Message,
   
  -                case is_protocol_message(MessagePayload) andalso not protocol_tracing() of 
  +                case is_protocol_message(InterpositionType, MessagePayload) andalso not protocol_tracing() of 
                       true ->
                           %% Protocol message and we're not tracing protocol messages.
                           ok;
  
positive.code:         case Type of 
              pre_interposition_fun ->
                  %% Trace all entry points if protocol message, unless tracing enabled.
                  {_TracingNode, _InterpositionType, _OriginNode, MessagePayload} = Message,
  
                  case is_protocol_message(MessagePayload) of 
                      true ->
                          %% Trace protocol messages only if protocol tracing is enabled.
                          protocol_tracing();
                      false ->
                          %% Always trace non-protocol messages.
                          true
                  end;
  
negative.code: handle_call({replay, Type, Message}, From, #state{previous_trace=PreviousTrace0, replay=Replay, shrinking=Shrinking, blocked_processes=BlockedProcesses0}=State) ->
      case Replay of 
          true ->
              %% Should we enforce trace order during replay?
              ShouldEnforce = case Type of 
                  pre_interposition_fun ->
                      %% Destructure pre-interposition trace message.
                      {_TracingNode, InterpositionType, _OriginNode, MessagePayload} = Message,
  
                      case is_protocol_message(InterpositionType, MessagePayload) of
                          true ->
                              protocol_tracing();
                          false ->
                              true
                      end;
                  _ ->
                      true
              end,
  
              case ShouldEnforce of 
                  false ->
                      {reply, ok, State};
                  true ->
                      %% Find next message that should arrive based on the trace.
                      %% Can we process immediately?
                      case can_deliver_based_on_trace(Shrinking, {Type, Message}, PreviousTrace0, BlockedProcesses0) of 
                          true ->
                              %% Deliver as much as we can.
                              {PreviousTrace, BlockedProcesses} = trace_deliver(Shrinking, {Type, Message}, PreviousTrace0, BlockedProcesses0),
  
                              %% Record new trace position and new list of blocked processes.
                              {reply, ok, State#state{blocked_processes=BlockedProcesses, previous_trace=PreviousTrace}};
                          false ->
                              %% If not, store message, block caller until processed.
                              BlockedProcesses = [{{Type, Message}, From} | BlockedProcesses0],
  
                              %% Block the process.
                              {noreply, State#state{blocked_processes=BlockedProcesses}}
                      end
              end;
          false ->
              {reply, ok, State}
  