anchor.diff:      iolist_size(Chunk);
   chunk_wrapper_size(Chunk) ->
       iolist_size(Chunk).
  +
  +%% The intra-gen_server-timeout is approximate.  We'll add some 30
  +%% seconds of fudge to the user-specified time to accomodate the
  +%% imprecision.  Using 'infinity' would definitely handle the case of
  +%% horrible time consumption by the gen_server proc, but I'm slightly
  +%% leery of really waiting forever: better to have an
  +%% {'EXIT',{timeout,_}} to raise awareness of a serious problem.
  +
  +timeout(infinity) ->
  +    timeout(15*60*1000);                        % close enough to infinity
  +timeout(Timeout0) ->
  +    {Timeout0, Timeout0 + 30*1000}.
  
positive.code:             exit({todo_should_never_happen,?MODULE,?LINE,File,Offset})
      end.
  
  witnesses_use_our_epoch(#state{proj=P, epoch_id=EpochID}=S) ->
      Witnesses = witness_flus(P#projection_v1.upi, P),
      witnesses_use_our_epoch(Witnesses, S).
  
  
negative.code:                                     {error, partition};
                                 true ->
                                      do_append_head2(Prefix, Chunk, ChunkExtra,
                                                      Depth, STime, TO, S2)
                              end;
                          RestFLUs3 ->
                              do_append_midtail2(RestFLUs3, Prefix, File, Offset,
                                                 Chunk, ChunkExtra,
                                                 Ws, Depth + 1, STime, TO, S2)
                      end
              end
      end.            
  
  do_append_midtail2([], _Prefix, File, Offset, Chunk,
                     _ChunkExtra, _Ws, _Depth, _STime, _TO, S) ->
      %% io:format(user, "ok!\n", []),
      {reply, {ok, {Offset, chunk_wrapper_size(Chunk), File}}, S};
  do_append_midtail2([FLU|RestFLUs]=FLUs, Prefix, File, Offset, Chunk,
                     ChunkExtra, Ws, Depth, STime, TO,
                     #state{epoch_id=EpochID, proxies_dict=PD}=S) ->
      Proxy = orddict:fetch(FLU, PD),
      case ?FLU_PC:write_chunk(Proxy, EpochID, File, Offset, Chunk, ?TIMEOUT) of
          ok ->
              %% io:format(user, "write ~w,", [FLU]),
              do_append_midtail2(RestFLUs, Prefix, File, Offset, Chunk,
                                 ChunkExtra, [FLU|Ws], Depth, STime, TO, S);
          {error, bad_checksum}=BadCS ->
              %% TODO: alternate strategy?
              {reply, BadCS, S};
          {error, Retry}
            when Retry == partition; Retry == bad_epoch; Retry == wedged ->
              do_append_midtail(FLUs, Prefix, File, Offset, Chunk,
                                ChunkExtra, Ws, Depth, STime, TO, S);
          {error, written} ->
              %% We know what the chunk ought to be, so jump to the
              %% middle of read-repair.
  