anchor.diff:           bloom    = ?required(bloom_recon_struct, bloom)    :: ?REP_BLOOM:bloom_filter()         
           }).
   
  --type internal_params() :: {reconPid, comm:mypid()} |
  -                           {art, art:art()}.
  +-type internal_param() :: {reconPid, comm:mypid()}.
   
   -type sync_struct() :: #bloom_recon_struct{} |
                          merkle_tree:merkle_tree() |
                          art:art().
   -type parameters() :: sync_struct() |
  -                      [internal_params()] |
  +                      [internal_param()] |
                         [merkle_tree:mt_node()].
   -type recon_dest() :: ?RT:key() | random.
   
  
positive.code:     end;
  
  on({rr_recon, data, DestI, {get_chunk_response, {RestI, DBList0}}} = _Msg,
     State = #rr_recon_state{stage = build_struct,       initiator = Initiator,
                             method = RMethod,           dhtNodePid = DhtNodePid,
                             struct = Params,            stats = Stats}) ->
      ?TRACE1(_Msg, State),
      % create recon structure based on all elements in sync interval
      DBList = [encodeBlob(Key, VersionX) || {KeyX, VersionX} <- DBList0,
                                             none =/= (Key = map_key_to_interval(KeyX, DestI))],
      {BuildTime, SyncStruct} =
          case merkle_tree:is_merkle_tree(Params) of
              true ->
                  {BTime, NTree} = util:tc(merkle_tree, insert_list, [DBList, Params]),
                  {rr_recon_stats:get(build_time, Stats) + BTime, merkle_tree:gen_hash(NTree) };
              false ->
                  ToBuild = ?IIF(RMethod =:= art, ?IIF(Initiator, merkle_tree, art), RMethod),
                  util:tc(fun() -> build_recon_struct(ToBuild, {DestI, DBList}) end)
          end,
      EmptyRest = intervals:is_empty(RestI),
      % bloom may fork more recon processes if un-synced elements remain
      if not EmptyRest ->
             SubSyncI = find_intersection(DestI, RestI),
             case intervals:is_empty(SubSyncI) of
                 false ->
                     Pid = if RMethod =:= bloom -> 
                                  erlang:element(2, fork_recon(State#rr_recon_state{dest_interval = SubSyncI,
                                                                                    struct = Params}));
                              true -> self()
                           end,
                     send_chunk_req(DhtNodePid, Pid, find_intersection(RestI, DestI), SubSyncI,
                                    get_max_items(RMethod));
                 true -> ok
             end;
          true -> ok
      end,
      {NStage, NStats} =
          if EmptyRest orelse RMethod =:= bloom -> {reconciliation, begin_sync(SyncStruct, State)};
             not EmptyRest andalso RMethod =:= merkle_tree -> {build_struct, Stats};
             true -> {reconciliation, Stats}
          end,
      State#rr_recon_state{ stage = NStage,
                            struct = SyncStruct,
                            stats = rr_recon_stats:set([{build_time, BuildTime}], NStats) };
  
  on({start_recon, bloom = Method, SyncStruct = #bloom_recon_struct{interval = MySyncI},
      true = Initiator} = _Msg, State) ->
      ?TRACE1(_Msg, State),
      % initiator got client's bloom recon structure over sync interval (mapped to own range)
      % -> reconcile own DB with received bloom filter
      % note: BloomI 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 retrieve the current range!)
      NewState = State#rr_recon_state{stage = reconciliation, struct = SyncStruct,
                                      method = Method, initiator = Initiator},
      case intervals:is_empty(MySyncI) of
          false ->
              DhtNodePid = State#rr_recon_state.dhtNodePid,
              Self = comm:reply_as(self(), 2, {reconcile, '_'}),
              send_local(DhtNodePid,
                         {get_chunk, Self, MySyncI, fun get_chunk_filter/1,
                          fun get_chunk_value/1, get_max_items(bloom)}),
              NewState;
          true ->
              shutdown(empty_interval, NewState)
      end;
  
  on({reconcile, {get_chunk_response, {RestI, DBList0}}} = _Msg,
     State = #rr_recon_state{stage = reconciliation,     ownerPid = OwnerL,
  
negative.code:             end,
              rr_recon_stats:set(
                [{tree_compareLeft, ?IIF(Initiator, 1, 0)},
                 {tree_size, merkle_tree:size_detail(MySyncStruct)}], Stats);
          bloom when Initiator =:= false ->
              send(DestRRPid, {continue_recon, comm:make_global(OwnerL), SID,
                               {start_recon, Method, MySyncStruct, true}}),
              send_local(self(), {shutdown, {ok, build_struct}}),
              Stats;
          art ->
              {AOk, ARStats} = 
                  case Initiator of
                      true -> art_recon(MySyncStruct, Params, State);
                      false ->
                          send(DestRRPid, {continue_recon, comm:make_global(OwnerL), SID,
                                           {start_recon, Method, MySyncStruct, true}}),
                          {no, Stats}
                  end,
              send_local(self(), {shutdown, ?IIF(AOk =:= ok, sync_finished, build_struct)}),
  