anchor.diff:              CatalogProcessPid ! {fold_stream, done, StreamRef};
           {stream, StreamRef, Value, Props}=_Msg2 ->
               case Props of
  -                <<"">> ->
  +                <<>> ->
                       Props2 = [];
                   _ ->
                       Props2 = binary_to_term(Props)
               end,
  -            IndexBin = riak_search_utils:to_binary(Index),
  -            FieldTermBin = riak_search_utils:to_binary([Field, ".", Term]),
  -            BObj = term_to_binary({Field, Term, Value, Props2}),
  -            FoldResultPid ! {fold_result, Fun0({IndexBin, FieldTermBin}, BObj, Acc)},
  -            fold_stream_process(CatalogProcessPid, FoldResultPid, StreamRef, Fun0, Acc, Index, Field, Term);
  +            FieldTermBin = <<FieldBin/binary, ".", TermBin/binary>>,
  +            BObj = term_to_binary({FieldBin, TermBin, Value, Props2}),
  +            FoldResultPid ! {fold_result, IndexBin, FieldTermBin, BObj},
  +            fold_stream_process(CatalogProcessPid, FoldResultPid, StreamRef, 
  +                                IndexBin, FieldBin, TermBin);
           _Msg ->
               %% io:format("fold_stream_process: unknown message: ~p~n", [_Msg]),
  -            fold_stream_process(CatalogProcessPid, FoldResultPid, StreamRef, Fun0, Acc, Index, Field, Term)
  +            fold_stream_process(CatalogProcessPid, FoldResultPid, StreamRef, 
  +                                IndexBin, FieldBin, TermBin)
           after ?FOLD_TIMEOUT ->
               CatalogProcessPid ! {fold_stream, done, StreamRef},
               error_logger:warning_msg("fold_stream_process: table timed out: ~p.~p.~p~n",
  -                                      [Index, Field, Term])
  +                                      [IndexBin, FieldBin, TermBin])
       end.
   
   %% receive the Fun0(processed) objects from all the "buckets" on this partition, accumulate them
   %%   and return them
  -receive_fold_results(Acc, Count) ->
  +receive_fold_results(Fun, Acc) ->
       receive
           {fold_result, done} ->
               %% io:format("receive_fold_results: fold complete [~p objects].~n",
               %%           [Count]),
               Acc;
  -        {fold_result, _Obj} ->
  -            receive_fold_results(Acc, Count+1)
  +        {fold_result, IndexBin, FieldTermBin, BObj} ->
  +            receive_fold_results(Fun, Fun({IndexBin,FieldTermBin},BObj,Acc))
  +    after ?FOLD_TIMEOUT ->
  +            throw({timeout,Acc})
       end.
   
   %%%
  
positive.code:     Me = self(),
      FoldCatRef = {fold_catalog, erlang:make_ref()},
      CatalogResultsPid = spawn_link(fun() ->
                                             fold_catalog_process(FoldCatRef, Me, Folder, Acc, 
                                                                  false, 0, 0, false) end),
      spawn_link(fun() ->
                         try
  
negative.code: %% for each result of a stream process, package the entry in the
  %%   form of an infamously shady put-embedded command and forward
  %%   to receive_fold_results process
  fold_stream_process(CatalogProcessPid, FoldResultPid, StreamRef, IndexBin, FieldBin, TermBin) ->
      receive
          {stream, StreamRef, timeout} ->
              CatalogProcessPid ! {fold_stream, done, StreamRef};
  