anchor.diff:      State = #state{bucket=Bucket,
                      caller=CallerRef,
                      key=Key},
  -    %% purposely have the timeout happen
  -    %% so that we get called in the prepare
  -    %% state
       {ok, prepare, State, 0};
   init([test, Bucket, Key, ContentLength, BlockSize]) ->
       {ok, prepare, State1, 0} = init([Bucket, Key, self()]),
  +
       %% purposely have the timeout happen
       %% so that we get called in the prepare
       %% state
  
positive.code:     %%    terminations, so this process would still
      %%    live.
      CallerRef = erlang:monitor(process, Caller),
  
      %% we want to trap exits because
      %% `erlang:link` isn't atomic, and
      %% since we're starting the reader
  
negative.code:                                      manifest=Manifest,
                                       test=true}}.
  
  prepare(timeout, State) ->
      NewState = prepare(State),
      {next_state, waiting_value, NewState}.
  
  prepare(get_manifest, _From, State) ->
      PreparedState = prepare(State),
      case PreparedState#state.manifest of
          undefined ->
              {stop, normal, notfound, State};
          Mfst ->
              NextStateTimeout = 60000,
              NewState = PreparedState#state{manifest_uuid=Mfst#lfs_manifest_v2.uuid,
                                             from=undefined},
              {reply, Mfst, waiting_continue_or_stop, NewState, NextStateTimeout}
      end.
  
  waiting_value(get_manifest, _From, State=#state{manifest=undefined}) ->
      {stop, normal, notfound, State};
  waiting_value(get_manifest, _From, State=#state{manifest=Mfst}) ->
      NextStateTimeout = 60000,
      NewState = State#state{manifest_uuid=Mfst#lfs_manifest_v2.uuid,
                             from=undefined},
      {reply, Mfst, waiting_continue_or_stop, NewState, NextStateTimeout}.
  
  waiting_continue_or_stop(timeout, State) ->
      {stop, normal, State};
  