anchor.diff:  %% @private
   without_me(Members) ->
       Members -- [node()].
  +
  +%% @private
  +should_react() ->
  +    PeerServiceManager = lasp_config:get(peer_service_manager, partisan_peer_service),
  +    case PeerServiceManager of
  +        partisan_client_server_peer_service_manager ->
  +            case partisan_config:get(tag, undefined) of
  +                server ->
  +                    case lasp_config:get(reactive_server, false) of
  +                        true ->
  +                            %% I'm the server in the reactive client-server mode.
  +                            true;
  +                        _ ->
  +                            false
  +                    end;
  +                _ ->
  +                    false
  +            end;
  +        _ ->
  +            false
  +    end.
  
positive.code:                             %% Ignore: this is a dynamic variable.
                              Acc0;
                          _ ->
                              send({aae_send, node(), {Id, Type, Metadata, Value}}, Peer),
                              [{ok, {Id, Type, Metadata, Value}}|Acc0]
                      end
                 end,
      %% TODO: Should this be parallel?
  
negative.code:                                {Id, Type, _Metadata, Value},
                                 ?CLOCK_INCR(Actor),
                                 ?CLOCK_INIT(Actor)}),
  
      %% Send back just the updated state for the object received.
      case should_react() of
          true ->
              ObjectFilterFun = fun(Id1) ->
                                        Id =:= Id1
                                end,
              init_aae_sync(From, ObjectFilterFun, Store);
          false ->
              ok
      end,
  
      {noreply, State};
  
  handle_cast({delta_send, From, {Id, Type, _Metadata, Deltas}, Counter},
  