anchor.diff:        end,
       { next_state
       , StateName
  -    , State#{status_code := StatusCode, headers := Headers}
  +    , StateData#{status_code := StatusCode, headers := Headers}
       };
   wait_response(cast, {gun_error, _Pid, _StreamRef, Error},
  -              #{from := From} = State) ->
  +              #{from := From} = StateData) ->
       gen_statem:reply(From, {error, Error}),
  -    {next_state, at_rest, State, 0};
  +    {next_state, at_rest, StateData, 0};
   wait_response(cast, body_chunked,
  -              #{stream := StreamRef, from := From} = State) ->
  +              #{stream := StreamRef, from := From} = StateData) ->
       gen_statem:reply(From, {ok, StreamRef}),
  -    {next_state, wait_response, State};
  -wait_response(cast, Event, State) ->
  -    {stop, {unexpected, Event}, State};
  -wait_response(info, Event, State) ->
  -    handle_info(Event, wait_response, State).
  +    {next_state, wait_response, StateData};
  +wait_response(cast, Event, StateData) ->
  +    {stop, {unexpected, Event}, StateData};
  +wait_response(info, Event, StateData) ->
  +    handle_info(Event, wait_response, StateData).
   
   %% @private
   -spec receive_data({call, pid()} | cast | info, term(), state()) ->
  
positive.code:     {keep_state, state()} |
      {next_state, atom(), state()} |
      {next_state, atom(), state(), timeout()}.
  receive_data({call, From}, Event, State) ->
      enqueue_work_or_stop(receive_data, Event, From, State);
  receive_data(cast, {'DOWN', _, _, _, _Reason}, _State) ->
      error(incomplete);
  receive_data(cast, {gun_data, _Pid, StreamRef, nofin, Data},
               #{stream := StreamRef, data := DataAcc} = State) ->
      NewData = <<DataAcc/binary, Data/binary>>,
      {next_state, receive_data, State#{data => NewData}};
  receive_data(cast, {gun_data, _Pid, _StreamRef, fin, Data},
               #{data := DataAcc, from := From, status_code
                 := StatusCode, headers := Headers} = State) ->
      NewData = <<DataAcc/binary, Data/binary>>,
      Result = {ok, #{status_code => StatusCode,
                      headers => Headers,
                      body => NewData
                     }},
      gen_statem:reply(From, Result),
      {next_state, at_rest, State, 0};
  receive_data(cast, {gun_error, _Pid, StreamRef, _Reason},
               #{stream := StreamRef} = State) ->
      {next_state, at_rest, State, 0};
  receive_data(info, Event, State) ->
      handle_info(Event, receive_data, State).
  
  %% @private
  %% @doc Chunked data response
  
negative.code: handle_info(
      {gun_down, Pid, Protocol, {error, Reason},
       KilledStreams, UnprocessedStreams}, StateName,
       StateData = #{pid := Pid}) ->
      error_logger:warning_msg(
          "~p connection down on ~p: ~p (Killed: ~p, Unprocessed: ~p)",
          [Protocol, Pid, Reason, KilledStreams, UnprocessedStreams]),
  