anchor.diff:  
   handle_call({index, Index, Field, Term, Value, Props, TS}, _From, State) ->
       %% Calculate the IFT...
  -    #state { indexes=Indexes, fields=Fields, terms=Terms, buffers=[CurrentBuffer0|Buffers] } = State,
  -    {IndexID, NewIndexes} = mi_incdex:lookup(Index, Indexes),
  -    {FieldID, NewFields} = mi_incdex:lookup(Field, Fields),
  -    {TermID, NewTerms} = mi_incdex:lookup(Term, Terms),
  -    IFT = mi_utils:ift_pack(IndexID, FieldID, TermID),
  +    #state { buffers=[CurrentBuffer0|Buffers] } = State,
  +    IFT = mi_ift_server:create_ift(Index, Field, Term),
   
       %% Write to the buffer...
       CurrentBuffer = mi_buffer:write(IFT, Value, Props, TS, CurrentBuffer0),
   
       %% Update the state...
  -    NewState = State#state {
  -        indexes=NewIndexes,
  -        fields=NewFields,
  -        terms=NewTerms,
  -        buffers=[CurrentBuffer|Buffers]
  -    },
  -
  -    %% Add a small delay if we are sitting on too many segments. This
  -    %% provides a sort of automated throttling, giving the compactor
  -    %% time to merge segments.
  -    %% TODO - Make this configurable. It would be useful to
  -    %% turn this off for bulk loading.
  -    %% TODO - Reevaluate whether sleeping here is a good idea.
  +    NewState = State#state {buffers = [CurrentBuffer | Buffers]},
   
       %% Possibly dump buffer to a new segment...
       case mi_buffer:filesize(CurrentBuffer) > ?ROLLOVER_SIZE(NewState) of
  
positive.code:     State = #state {
          root     = Root,
          locks    = mi_locks:new(),
          indexes  = mi_incdex:open(join(Root, "indexes"), IncdexOptions),
          fields   = mi_incdex:open(join(Root, "fields"), IncdexOptions),
          terms    = mi_incdex:open(join(Root, "terms"), IncdexOptions),
          buffers  = [Buffer],
          segments = Segments,
          config   = Config,
  
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) ->
  