anchor.diff:          [{LPN1,Pg1}, {LPN2,Pg2}, {LPN3,Pg3}, {LPN4,Pg4}, {LPN5,Pg5}] = LPN_Pgs,
           {ok, 4, true, [{LPN2,Pg2}, {LPN3,Pg3}]} = scan_forward(P1, 2, 2),
           {ok, 6, false, [{LPN3,Pg3}, {LPN4,Pg4}, {LPN5,Pg5}]} = scan_forward(P1, 3, 10),
  +
  +        %% Let's smoke read-repair: regular write failure
  +        Epoch = P1#proj.epoch,
  +        Pg6 = <<424242:(PageSize*8)>>,
  +
  +        %% Simulate a failed write to the chain.
  +        [F6a, F6b, F6c] = Chain6 = project_to_chain(6, P1),
  +        NotHead6 = [F6b, F6c],
  +        ok = write_single_page_to_chain([F6a], Epoch, 6, Pg6, 1),
  +
  +        %% Does the chain look as expected?
  +        {ok, Pg6} = corfurl_flu:read(flu_pid(F6a), Epoch, 6),
  +        [error_unwritten = corfurl_flu:read(flu_pid(X), Epoch, 6) ||
  +            X <- NotHead6],
  +
  +        %% Read repair should fix it.
  +        {ok, Pg6} = read_page(P1, 6),
  +        [{ok, Pg6} = corfurl_flu:read(flu_pid(X), Epoch, 6) || X <- Chain6],
  +
  +        %% Let's smoke read-repair: failed fill
  +        [F7a, F7b, F7c] = Chain7 = project_to_chain(7, P1),
  +        NotHead7 = [F7b, F7c],
  +        ok = corfurl_flu:fill(flu_pid(F7a), Epoch, 7),
  +
  +        %% Does the chain look as expected?
  +        error_trimmed = corfurl_flu:read(flu_pid(F7a), Epoch, 7),
  +        [error_unwritten = corfurl_flu:read(flu_pid(X), Epoch, 7) ||
  +            X <- NotHead7],
  +
  +        %% Read repair should fix it.
  +        error_trimmed = read_page(P1, 7),
  +        [error_trimmed = corfurl_flu:read(flu_pid(X), Epoch, 7) || X <- Chain7],
  +
   
           ok
       after
  
positive.code:      end || X <- lists:seq(1, NumFLUs)].
  
  smoke1_test() ->
      NumFLUs = 4,
      PageSize = 8,
      NumPages = 10,
      FLUs = [F1, F2, F3, F4] = setup_basic_flus(NumFLUs, PageSize, NumPages),
      {ok, Seq} = corfurl_sequencer:start_link(FLUs),
  
      %% We know that the first LSN will be 1.
      LPN_Pgs = [{X, list_to_binary(
                       lists:flatten(io_lib:format("~8..0w", [X])))} ||
                    X <- lists:seq(1, 5)],
      try
          P1 = new_simple_projection(1, 1, 1*100, [[F1, F2], [F3, F4]]),
          [begin {ok, LPN} = append_page(Seq, P1, Pg) end || {LPN, Pg} <- LPN_Pgs],
  
          [begin {ok, Pg} = read_page(P1, LPN) end || {LPN, Pg} <- LPN_Pgs],
  
negative.code:             %%       in the Acc?  Or should the client assume that if
              %%       scan_forward() doesn't mention a page that
              scan_forward(P, LPN + 1, MaxPages - 1, ok, true, Acc);
          error_unwritten ->
              %% Halt, allow recursion to create our return value.
              %% TODO: It's possible that we're stuck here because a client
              %%       crashed and that we see an unwritten page at LPN.
              %%       We ought to ask the sequencer always/sometime?? what
              %%       tail LPN is, and if there's a hole, start a timer to
              %%       allow us to fill the hole.
              scan_forward(P, LPN, 0, ok, false, Acc)
          %% Let it crash: error_overwritten
      end.
  
  flu_pid(X) when is_pid(X) ->
  