anchor.diff:      end,
       {reply, Result, State};
   
  +%% Naive anti-entropy mechanism; periodically re-broadcast all messages.
  +handle_call(exchange, _From, #state{store=Store}=State) ->
  +    Function = fun({Id, #dv{type=Type, metadata=Metadata, value=Value}}, Acc0) ->
  +                    case orddict:find(dynamic, Metadata) of
  +                        {ok, true} ->
  +                            %% Ignore: this is a dynamic variable.
  +                            ok;
  +                        _ ->
  +                            broadcast({Id, Type, Metadata, Value})
  +                    end,
  +                    [{ok, {Id, Type, Metadata, Value}}|Acc0]
  +               end,
  +    Pid = spawn(fun() -> do(fold, [Store, Function, []]) end),
  +    {reply, {ok, Pid}, State};
  +
  +%% @private
  +handle_call(Msg, _From, State) ->
  +    _ = lager:warning("Unhandled messages: ~p", [Msg]),
  +    {reply, ok, State}.
  +
  +-spec handle_cast(term(), #state{}) -> {noreply, #state{}}.
   %% Anti-entropy mechanism for causal consistency of delta-CRDT;
   %% periodically ship delta-interval or entire state.
  -handle_call({exchange, Peer}, _From, #state{store=Store, gc_counter=GCCounter}=State) ->
  +handle_cast({exchange, Peer}, #state{store=Store, gc_counter=GCCounter}=State) ->
  +    lager:info("Exchange starting for ~p", [Peer]),
  +
       Function = fun({Id, #dv{value=Value, type=Type, metadata=Metadata,
                               delta_counter=Counter, delta_map=DeltaMap,
                               delta_ack_map=AckMap}},
  
positive.code:                 erlang:monotonic_time(),
                  erlang:unique_integer()),
  
      {ok, Actor} = lasp_unique:unique(),
  
      Counter = 0,
  
negative.code:                                Acc0
                         end
                 end,
      spawn_link(fun() -> do(fold, [Store, Function, []]) end),
  
      lager:info("Exchange finished."),
  
      {noreply, State#state{gc_counter=increment_counter(GCCounter)}};
  
  handle_cast({delta_send, From, {Id, Type, _Metadata, Deltas}, Counter},
              #state{store=Store, actor=Actor}=State) ->
      ?CORE:receive_delta(Store, {delta_send,
                                 {Id, Type, _Metadata, Deltas},
                                 ?CLOCK_INCR(Actor),
                                 ?CLOCK_INIT(Actor)}),
      send({delta_ack, node(), Id, Counter}, From),
      {noreply, State};
  
  handle_cast({delta_ack, From, Id, Counter}, #state{store=Store}=State) ->
      ?CORE:receive_delta(Store, {delta_ack, Id, From, Counter}),
      {noreply, State};
  
  %% @private
  handle_cast(Msg, State) ->
      _ = lager:warning("Unhandled messages: ~p", [Msg]),
      {noreply, State}.
  
  %% @private
  -spec handle_info(term(), #state{}) -> {noreply, #state{}}.
  handle_info(memory_report, State) ->
      %% Log
      memory_report(),
  
      %% Schedule report.
      schedule_memory_report(),
  
      {noreply, State};
  handle_info(delta_sync, State) ->
      lager:info("Beginning delta synchronization."),
  
      %% Get the active set from the membership protocol.
      %%
      %% @todo: If full, this has to be changed to fanout; otherwise,
      %% fanout is the active set.
      %%
      {ok, Members} = lasp_peer_service:members(),
  
      %% Remove ourself.
      Peers = Members -- [node()],
  
      lager:info("Beginning sync for peers: ~p", [Peers]),
  
      %% Ship buffered updates for the fanout value.
      lists:foreach(fun(Peer) ->
                            init_delta_sync(Peer)
                    end, Peers),
  
      %% Schedule next synchronization.
      schedule_delta_synchronization(),
  
      {noreply, State};
  handle_info(delta_gc, #state{gc_counter=GCCounter0, store=Store}=State) ->
      MaxGCCounter = lasp_config:get(delta_mode_max_gc_counter, ?MAX_GC_COUNTER),
      Function =
          fun({Id, #dv{delta_map=DeltaMap0, delta_ack_map=AckMap0,
                       delta_counter=Counter}=_Object},
  