anchor.diff:      NewStateData = manage_chunk(IsFin, StreamRef, Data, StateData),
       case IsFin of
           fin ->
  -            {next_state, at_rest, NewStateData, 0};
  +            {next_state, at_rest, NewStateData, [{timeout, 0, 0}]};
           nofin ->
               {next_state, receive_chunk, NewStateData}
       end;
   receive_chunk(cast, {gun_error, _Pid, _StreamRef, _Reason}, StateData) ->
  -    {next_state, at_rest, StateData, 0};
  +    {next_state, at_rest, StateData, [{timeout, 0, 0}]};
   receive_chunk(info, Event, StateData) ->
       handle_info(Event, receive_chunk, StateData).
   
  
positive.code:     {next_state, at_rest, StateData, [{reply, From, Result}]};
  receive_data(cast, {gun_error, _Pid, StreamRef, _Reason},
               #{stream := StreamRef} = StateData) ->
      {next_state, at_rest, StateData, 0};
  receive_data(info, Event, StateData) ->
      handle_info(Event, receive_data, StateData).
  
  %% @private
  %% @doc Chunked data response
  -spec receive_chunk({call, gen_statem:from()} | cast | info, term(), statedata()) ->
      {stop, {error, any()}, atom(), statedata()} |
      {next_state, atom(), statedata()} |
      {next_state, atom(), statedata(), timeout()}.
  receive_chunk({call, From}, Event, StateData) ->
      enqueue_work_or_stop(receive_chunk, Event, From, StateData);
  receive_chunk(cast, {'DOWN', _, _, _, _Reason}, _StateData) ->
  
negative.code: %% @private
  %% @doc Regular response
  -spec receive_data({call, gen_statem:from()} | cast | info, term(), statedata()) ->
      {keep_state_and_data, [{reply, gen_statem:from(), {error, {unexpected, atom()}}}]} |
      {keep_state, statedata(), [{reply, gen_statem:from(), list()}]} |
      {keep_state, statedata(), [{timeout, timeout(), get_work}]} |
      {next_state, atom(), statedata()}.
  receive_data({call, From}, Event, StateData) ->
      enqueue_work_or_stop(receive_data, Event, From, StateData);
  receive_data(cast, {'DOWN', _, _, _, _Reason}, _StateData) ->
  