anchor.diff:  
   handle_call({info, Index, Field, Term}, _From, State) ->
       %% Calculate the IFT...
  -    #state { indexes=Indexes, fields=Fields, terms=Terms, buffers=Buffers, segments=Segments } = State,
  -    IndexID = mi_incdex:lookup_nocreate(Index, Indexes),
  -    FieldID = mi_incdex:lookup_nocreate(Field, Fields),
  -    TermID = mi_incdex:lookup_nocreate(Term, Terms),
  -    IFT = mi_utils:ift_pack(IndexID, FieldID, TermID),
  -
  -    %% Look up the counts in buffers and segments...
  -    BufferCount = lists:sum([mi_buffer:info(IFT, X) || X <- Buffers]),
  -    SegmentCount = lists:sum([mi_segment:info(IFT, X) || X <- Segments]),
  -    Counts = [{Term, BufferCount + SegmentCount}],
  -
  -    %% Return...
  +    #state { buffers=Buffers, segments=Segments } = State,
  +    case mi_ift_server:find_ift(Index, Field, Term) of
  +        undefined ->
  +            {reply, {ok, 0}, State};
  +
  +        IFT ->
  +            %% Look up the counts in buffers and segments...
  +            BufferCount = lists:sum([mi_buffer:info(IFT, X) || X <- Buffers]),
  +            SegmentCount = lists:sum([mi_segment:info(IFT, X) || X <- Segments]),
  +            Counts = [{Term, BufferCount + SegmentCount}],
  +
  +            %% Return...
  +            {reply, {ok, Counts}, State}
  +    end;
  +
  +handle_call({info_range, Index, Field, StartTerm, EndTerm, _Size}, _From, State) ->
  +    %% TODO: Why do we need size here?
  +    %% Get the IDs...
  +    #state { buffers=Buffers, segments=Segments } = State,
  +
  +    %% For each term, determine the number of entries
  +    F = fun({Term, IFT}, Acc) ->
  +                Total = lists:sum([mi_buffer:info(IFT, X) || X <- Buffers]) +
  +                    lists:sum([mi_segment:info(IFT, X) || X <- Segments]),
  +                case Total > 0 of
  +                    true ->
  +                        [{Term, Total} | Acc];
  +                    false ->
  +                        Acc
  +                end
  +        end,
  +    Counts = lists:reverse(mi_ift_server:fold_ifts(Index, Field, StartTerm, EndTerm, F, [])),
       {reply, {ok, Counts}, State};
  -
  -handle_call({info_range, Index, Field, StartTerm, EndTerm, Size}, _From, State) ->
  -    %% Get the IDs...
  -    #state { indexes=Indexes, fields=Fields, terms=Terms, buffers=Buffers, segments=Segments } = State,
  -    IndexID = mi_incdex:lookup_nocreate(Index, Indexes),
  -    FieldID = mi_incdex:lookup_nocreate(Field, Fields),
  -    TermIDs = mi_incdex:select(StartTerm, EndTerm, Size, Terms),
  -
  -    F = fun({Term, TermID}) ->
  -        StartIFT = mi_utils:ift_pack(IndexID, FieldID, TermID),
  -        EndIFT = mi_utils:ift_pack(IndexID, FieldID, TermID),
  -        BufferCount = lists:sum([mi_buffer:info(StartIFT, EndIFT, X) || X <- Buffers]),
  -        SegmentCount = lists:sum([mi_segment:info(StartIFT, EndIFT, X) || X <- Segments]),
  -        {Term, BufferCount + SegmentCount}
  -    end,
  -    Counts1 = [F(X) || X <- TermIDs],
  -    Counts2 = [{Term, Count} || {Term, Count} <- Counts1, Count > 0],
  -    {reply, {ok, Counts2}, State};
   
   handle_call({stream, Index, Field, Term, Pid, Ref, FilterFun}, _From, State) ->
       %% Get the IDs...
  -    #state { locks=Locks, indexes=Indexes, fields=Fields, terms=Terms, buffers=Buffers, segments=Segments } = State,
  -    IndexID = mi_incdex:lookup_nocreate(Index, Indexes),
  -    FieldID = mi_incdex:lookup_nocreate(Field, Fields),
  -    TermID = mi_incdex:lookup_nocreate(Term, Terms),
  -
  -    %% TODO - These next two lines are indicitive of vestigal code
  -    %% from when merge_index used the fated subtype/subterm
  -    %% structure. We no longer need a StartIFT and EndIFT, we just
  -    %% need the IFT to stream. As a result, there are simplifications
  -    %% we could make in mi_buffer and mi_segment. Not making them now
  -    %% due to time pressure. - RTK
  -    StartIFT = mi_utils:ift_pack(IndexID, FieldID, TermID),
  -    EndIFT = mi_utils:ift_pack(IndexID, FieldID, TermID),
  -
  -    %% Add locks to all buffers...
  -    F1 = fun(Buffer, Acc) ->
  -        mi_locks:claim(mi_buffer:filename(Buffer), Acc)
  -    end,
  -    NewLocks = lists:foldl(F1, Locks, Buffers),
  -
  -    %% Add locks to all segments...
  -    F2 = fun(Segment, Acc) ->
  -        mi_locks:claim(mi_segment:filename(Segment), Acc)
  -    end,
  -    NewLocks1 = lists:foldl(F2, NewLocks, Segments),
  -
  -    %% Spawn a streaming function...
  -    Self = self(),
  -    spawn_link(fun() -> 
  -        F = fun(_IFT, Value, Props, _TS) ->
  -            case FilterFun(Value, Props) of
  -                true -> 
  -                    Pid!{result, {Value, Props}, Ref};
  -                _ -> 
  -                    skip
  -            end
  -        end,
  -        stream(StartIFT, EndIFT, F, Buffers, Segments),
  -        Pid!{result, '$end_of_table', Ref},
  -        gen_server:call(Self, {stream_finished, Buffers, Segments}, infinity)
  -    end),
  -
  -    %% Reply...
  -    {reply, ok, State#state { locks=NewLocks1 }};
  +    #state { locks=Locks, buffers=Buffers, segments=Segments } = State,
  +
  +    case mi_ift_server:find_ift(Index, Field, Term) of
  +        undefined ->
  +            %% Nothing to do, the IFT doesn't exist!
  +            Pid ! {result, '$end_of_table', Ref},
  +            {reply, ok, State};
  +
  +        IFT ->
  +            %% Add locks to all buffers...
  +            F1 = fun(Buffer, Acc) ->
  +                         mi_locks:claim(mi_buffer:filename(Buffer), Acc)
  +                 end,
  +            NewLocks = lists:foldl(F1, Locks, Buffers),
  +
  +            %% Add locks to all segments...
  +            F2 = fun(Segment, Acc) ->
  +                         mi_locks:claim(mi_segment:filename(Segment), Acc)
  +                 end,
  +            NewLocks1 = lists:foldl(F2, NewLocks, Segments),
  +
  +            %% Spawn a streaming function...
  +            Self = self(),
  +            spawn_link(fun() ->
  +                               F = fun(_IFT, Value, Props, _TS) ->
  +                                           case FilterFun(Value, Props) of
  +                                               true ->
  +                                                   Pid ! {result, {Value, Props}, Ref};
  +                                               _ ->
  +                                                   skip
  +                                           end
  +                                   end,
  +                               %% TODO: Stream really doesn't need to take a start/end IFT!!
  +                               stream(IFT, IFT, F, Buffers, Segments),
  +                               Pid ! {result, '$end_of_table', Ref},
  +                               gen_server:call(Self, {stream_finished, Buffers, Segments}, infinity)
  +                       end),
  +            {reply, ok, State#state { locks=NewLocks1 }}
  +    end;
   
   handle_call({stream_finished, Buffers, Segments}, _From, State) ->
       #state { locks=Locks } = State,
  
positive.code:     %% Get incdex and buffer options...
      TempState = #state { config=Config },
      SyncInterval = ?SYNC_INTERVAL(TempState),
      IncdexOptions = [{write_interval, SyncInterval}],
      BufferOptions = [{write_interval, SyncInterval}],
      
      %% Load from disk...
  
negative.code:     {reply, ok, State#state { locks=NewLocks1 }};
  
  handle_call({fold, Fun, Acc}, _From, State) ->
      #state { buffers=Buffers, segments=Segments } = State,
  
      %% Create the fold function.
      WrappedFun = fun({IFT, Value, Props, TS}, AccIn) ->
                           %% Look up the Index, Field, and Term...
                           {Index, Field, Term} = mi_ift_server:reverse_ift(IFT),
  
                           %% Call the fold function...
                           Fun(Index, Field, Term, Value, Props, TS, AccIn)
                   end,
  
      %% Fold over each buffer...
      F1 = fun(Buffer, AccIn) ->
  