anchor.diff:  get_metadata(Pid) ->
       gen_fsm:sync_send_event(Pid, get_metadata).
   
  +get_next_chunk(Pid) ->
  +    gen_fsm:sync_send_event(Pid, get_next_chunk).
  +
   %% ====================================================================
   %% gen_fsm callbacks
   %% ====================================================================
   
  -init([From, Bucket, Key]) ->
  -    State = #state{from=From, bucket=Bucket, key=Key,
  -                   get_module=riak_moss_riakc},
  +init([_From, Bucket, Key]) ->
  +    Queue = queue:new(),
  +    State = #state{bucket=Bucket, key=Key,
  +                   get_module=riak_moss_riakc,
  +                   chunk_queue=Queue},
       %% purposely have the timeout happen
       %% so that we get called in the prepare
       %% state
       {ok, prepare, State, 0};
   init([test, From, Bucket, Key]) ->
  -    State = #state{from=From, bucket=Bucket, key=Key,
  -                   get_module=riak_moss_dummy_gets},
  +    {ok, prepare, State1, 0} = init([From, Bucket, Key]),
  +    State2 = State1#state{get_module=riak_moss_dummy_gets},
       %% purposely have the timeout happen
       %% so that we get called in the prepare
       %% state
  -    {ok, prepare, State, 0}.
  +    {ok, prepare, State2, 0}.
   
   %% TODO:
   %% could this func use
  
positive.code:             %% we don't actually have to start
              %% retrieving chunks, as we already
              %% have the value cached in our State
              From ! {done, CachedValue},
              {stop, normal, State}
      end.
  
  waiting_chunks({chunk, {ChunkSeq, ChunkRiakObject}}, #state{from=From, blocks_left=Remaining}=State) ->
      %% we're assuming that we're receiving the
      %% chunks synchronously, and that we can
      %% send them back to WM as we get them
  
      %% we currently only care about the binary
      %% data in the object
      ChunkValue = riakc_obj:get_value(ChunkRiakObject),
  
      NewRemaining = sets:del_element(ChunkSeq, Remaining),
      NewState = State#state{blocks_left=NewRemaining},
      case sets:size(NewRemaining) of
          0 ->
              From ! {done, ChunkValue},
              {stop, normal, NewState};
          _ ->
              From ! {chunk, ChunkValue},
              {next_state, waiting_chunks, NewState}
      end.
  
  %% @private
  
negative.code:     {next_state, waiting_metadata_request, NextState, NextStateTimeout}.
  
  waiting_metadata_request(get_metadata, _From, #state{metadata_cache=Metadata}=State) ->
      {reply, Metadata, waiting_continue_or_stop, State#state{metadata_cache=undefined}}.
  
  waiting_continue_or_stop(timeout, State) ->
      {stop, normal, State};
  waiting_continue_or_stop(stop, State) ->
      {stop, normal, State};
  waiting_continue_or_stop(continue, #state{value_cache=CachedValue,
                                         manifest=Manifest,
                                         bucket=BucketName,
                                         get_module=GetModule}=State) ->
      case CachedValue of
          undefined ->
              %% TODO:
  