anchor.diff:      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}) ->
  +   State = #rr_recon_state{stage = build_struct}) ->
       ?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
  +    build_struct(DBList, DestI, RestI, State);
  +
  +on({start_recon, RMethod, SyncStruct, true = Initiator} = _Msg, State) ->
  +    ?TRACE1(_Msg, State),
  +    % initiator got other node's sync struct over sync interval (mapped to own 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 = SyncStruct#bloom_recon_struct.interval,
  +            DestReconPid = undefined,
  +            ok;
  +%%         merkle_tree -> % TODO
  +%%             MySyncI = merkle_tree:get_interval(SyncStruct),
  +%%             DestReconPid = proplists:get_value(reconPid, Params, undefined),
  +%%             fd:subscribe(DestReconPid),
  +%%             ok;
  +        art ->
  +            MySyncI = art:get_interval(SyncStruct),
  +            DestReconPid = undefined,
  +            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;
  +    % client only sends non-empty sync intervals or exits
  +    ?ASSERT(not intervals:is_empty(MySyncI)),
  +    
  +    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(RMethod)}),
  +    State#rr_recon_state{stage = reconciliation, struct = SyncStruct,
  +                         method = RMethod, initiator = Initiator,
  +                         dest_recon_pid = DestReconPid};
   
   on({reconcile, {get_chunk_response, {RestI, DBList0}}} = _Msg,
      State = #rr_recon_state{stage = reconciliation,     ownerPid = OwnerL,
  
positive.code: 
  -type request() :: 
      {start, method(), DestKey::recon_dest()} |
      {create_struct, method(), SenderI::intervals:interval(), [], RcvInitiator::boolean()} |
      {start_recon, bloom, #bloom_recon_struct{}, RcvInitiator::boolean()} |
      {continue, method(), stage(), parameters(), Initiator::boolean()}.
  
  -type message() ::          
  
negative.code: 
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  -spec build_struct(DBList::db_chunk_enc(), DestI::I, RestI::I, state()) -> state()
            when is_subtype(I, intervals:interval()).
  build_struct(DBList, DestI, RestI,
               State = #rr_recon_state{method = RMethod, struct = Params,
                                       initiator = Initiator, stats = Stats,
                                       dhtNodePid = DhtNodePid}) ->
      {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) }.
  
  -spec begin_sync(sync_struct(), state()) -> rr_recon_stats:stats().
  begin_sync(MySyncStruct, State = #rr_recon_state{method = Method,
                                                   struct = Params,
                                                   ownerPid = OwnerL,
                                                   dest_recon_pid = DestReconPid,
                                                   dest_rr_pid = DestRRPid,
                                                   initiator = Initiator,
                                                   stats = Stats }) ->
      ?TRACE("BEGIN SYNC", []),
      SID = rr_recon_stats:get(session_id, Stats),
      case Method of
          merkle_tree -> 
              case Initiator of
                  true -> send(DestReconPid,
                               {check_nodes, comm:this(), [merkle_tree:get_hash(MySyncStruct)]});
                  false ->
                      SyncI = merkle_tree:get_interval(MySyncStruct),
                      SyncParams = [{reconPid, comm:this()}],
                      send(DestRRPid,
                           {continue_recon, comm:make_global(OwnerL), SID,
  