anchor.diff:      ?CORE:wait_needed(Id, Threshold, Store, From, ReplyFun, ?BLOCKING);
   
   %% Attempt to read a value.
  -handle_call({read, Id, Threshold}, From, #state{store=Store, actor=Actor}=State) ->
  +handle_call({read, Id, Threshold}, From, #state{store=Store}=State) ->
       ReplyFun = fun({_Id, Type, Metadata, Value}) ->
                       {reply, {ok, {_Id, Type, Metadata, Value}}, State};
                     ({error, Error}) ->
  
positive.code: %% broadcast the result.
  handle_call({bind, Id, Value}, _From,
              #state{store=Store, actor=Actor, counter=Counter}=State) ->
      {_Time, Result} = timer:tc(?CORE,
                                 bind,
                                 [Id, Value, ?CLOCK_INCR, Store]),
      Result1 = case Result of
                    {error, not_found} ->
                        case Id of
                            {StorageId, TypeId} ->
                                {ok, {Id, _, _, _}} = ?CORE:declare(StorageId,
                                                                    TypeId,
                                                                    ?CLOCK_INIT,
                                                                    Store),
                                {_Time0, Result0} = timer:tc(?CORE,
                                                             bind,
                                                             [Id, Value,
                                                              ?CLOCK_INCR, Store]),
                                Result0;
                            _ ->
                                {error, not_found}
                        end;
                    X ->
                        X
                end,
      {reply, Result1, State#state{counter=increment_counter(Counter)}};
  
  %% Incoming bind operation; merge incoming clock with the remote clock.
  %%
  
negative.code:                           end, lasp_type:new(Type), SmallDeltaMap),
      {delta, Deltas}.
  
  %% @private
  not_found_handling({error, not_found}, Id, #state{store=Store, actor=Actor}=_State,
                     Module, Function, Args) ->
      case Id of
          {StorageId, TypeId} ->
              {ok, {Id, _, _, _}} = ?CORE:declare(StorageId, TypeId,
                                                  ?CLOCK_INIT, Store),
              erlang:apply(Module, Function, Args);
          _ ->
              {error, not_found}
      end;
  not_found_handling(Result, _Id, _State, _Module, _Function, _Args) ->
      {found, Result}.
  
  -ifdef(TEST).
  
  do(Function, Args) ->
  