anchor.diff:                     Reconcile = Initiator andalso (Stage =:= reconciliation),
                      if RMethod =:= bloom -> 
                             ForkState = State#rr_recon_state{dest_interval = SubSyncI,
  -                                                           struct = Params},
  +                                                           params = Params},
                             {ok, Pid} = fork_recon(ForkState),
                             send_chunk_req(DhtNodePid, Pid, MySubSyncI, SubSyncI,
                                            get_max_items(RMethod), Reconcile);
  
positive.code:          dest_recon_pid     = undefined                                 :: comm:mypid() | undefined, %dest recon process pid
           method             = undefined                                 :: method() | undefined,
           dest_interval      = intervals:empty()                         :: intervals:interval(),
           struct             = {}                                        :: parameters() | {},
           stage              = req_shared_interval                       :: stage(),
           initiator          = false                                     :: boolean(),
           stats              = rr_recon_stats:new()                      :: rr_recon_stats:stats()
  
negative.code:                                            none =/= (Key = map_key_to_interval(KeyX, DestI))],
      build_struct(DBList, DestI, RestI, State);
  
  on({start_recon, RMethod, Params} = _Msg, State) ->
      ?TRACE1(_Msg, State),
      % initiator got other node's sync struct or parameters over sync interval
      % (mapped to the initiator's range)
      % -> create own recon structure based on sync interval and reconcile
      % note: sync interval may be an outdated sub-interval of this node's range
      %       -> pay attention when saving values to DB!
      %       (it could be outdated then even if we retrieved the current range now!)
      case RMethod of
          bloom ->
              MySyncI = Params#bloom_recon_struct.interval,
              DestReconPid = undefined;
          merkle_tree ->
              #merkle_params{interval = MySyncI, reconPid = DestReconPid} = Params,
              fd:subscribe(DestReconPid);
          art ->
              MySyncI = art:get_interval(Params),
              DestReconPid = undefined
      end,
      % client only sends non-empty sync intervals or exits
  