anchor.diff:  handle_call({update, Id, Operation, Actor}, _From, #state{store=Store, counter=Counter}=State) ->
       {ok, Result} = ?CORE:update(Id, Operation, Actor, Store),
       {reply, {ok, Result}, State#state{counter=increment_counter(Counter)}};
  +
  +%% Spawn a function.
   handle_call({thread, Module, Function, Args}, _From, #state{store=Store}=State) ->
       ok = ?CORE:thread(Module, Function, Args, Store),
       {reply, ok, State};
  +
  +%% Block, enforcing lazy evaluation of the provided function.
   handle_call({wait_needed, Id, Threshold}, From, #state{store=Store}=State) ->
       ReplyFun = fun(ReadThreshold) -> {reply, {ok, ReadThreshold}, State} end,
       ?CORE:wait_needed(Id, Threshold, Store, From, ReplyFun, ?BLOCKING);
  
positive.code:     end,
      Result = ?CORE:declare(Id, Type, ?CLOCK_MERG, Metadata0, Store),
      {reply, Result, State#state{counter=increment_counter(Counter)}};
  handle_call({declare_dynamic, Id, Type}, _From,
              #state{store=Store, actor=Actor, counter=Counter}=State) ->
      Result = ?CORE:declare_dynamic(Id, Type, ?CLOCK_INIT, Store),
      {reply, Result, State#state{counter=increment_counter(Counter)}};
  handle_call({query, Id}, _From, #state{store=Store}=State) ->
      {ok, Value} = ?CORE:query(Id, Store),
      {reply, {ok, Value}, State};
  
negative.code:     {{Id, Clock}, {Id, Type, Metadata, Value}}.
  
  %% @doc Perform a merge of an incoming object with an object in the
  %%      local datastore, as long as we haven't seen a more recent clock
  %%      for the same object.
  -spec merge({broadcast_id(), broadcast_clock()}, broadcast_payload()) -> boolean().
  merge({Id, Clock}, {Id, Type, Metadata, Value}) ->
  