Preserve cap-gap episode; minor test/style nits

A cluster of small review follow-ups; only the first changes behavior.

- The orphan-tail-retire re-anchor caught a CatchUpSendException and
  passed fail(e.getCause()), unwrapping the cap-gap marker so
  connectLoop's isCatchUpCapGap reset the orphan settle episode instead
  of preserving it. Route unwrap-aware: fail(isCatchUpCapGap(e) ? e :
  e.getCause()) keeps the attempt count and dwell anchor across the
  re-anchor recycle for a genuine cap gap, and unwraps to the raw cause
  otherwise, exactly as a normal send failure does. This only ever errs
  safe today -- more retries before an orphan drainer quarantines -- but
  the wrapper exists precisely to carry that signal.
- Drop @testonly from BackgroundDrainer.connectWithDurableAckRetry:
  run() calls it in production, so the annotation was inaccurate.
- Rename CatchUpSendException.capGap to isCapGap (boolean naming).
- Restore the CursorWebSocketSendLoop final-field group and a
  QwpWebSocketSender import to alphabetical order.
- DeltaDictCatchUpTest: fix a comment naming a test that does not exist.
- DeltaDictRecoveryTest: delete the never-instantiated CountingHandler
  and the orphaned javadoc stacked above FullDiskDictFacade.
- CursorSendEngineTest: rename the legacy-guard test to describe what it
  asserts (the guards force an FSN gap; current recovery adopts the v2
  slot) -- it never drives a legacy reader to throw.
- PoisonFrameTest: the two catch-up-only "does not strike" tests now
  assert poisonStrikes() == 0 explicitly instead of relying only on
  checkError() not throwing.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: glasstiger

core/src/main/java/io/questdb/client/cutlass/qwp/client/QwpWebSocketSender.java

@@ -47,10 +47,10 @@
 import io.questdb.client.cutlass.qwp.client.sf.cursor.DefaultSenderErrorHandler;
 import io.questdb.client.cutlass.qwp.client.sf.cursor.DefaultSenderProgressHandler;
 import io.questdb.client.cutlass.qwp.client.sf.cursor.PersistedSymbolDict;
-import io.questdb.client.cutlass.qwp.client.sf.cursor.UnreplayableSlotException;
 import io.questdb.client.cutlass.qwp.client.sf.cursor.SenderConnectionDispatcher;
 import io.questdb.client.cutlass.qwp.client.sf.cursor.SenderErrorDispatcher;
 import io.questdb.client.cutlass.qwp.client.sf.cursor.SenderProgressDispatcher;
+import io.questdb.client.cutlass.qwp.client.sf.cursor.UnreplayableSlotException;
 import io.questdb.client.cutlass.qwp.protocol.QwpConstants;
 import io.questdb.client.cutlass.qwp.protocol.QwpTableBuffer;
 import io.questdb.client.std.CharSequenceObjHashMap;

core/src/main/java/io/questdb/client/cutlass/qwp/client/sf/cursor/BackgroundDrainer.java

@@ -265,7 +265,6 @@ public BackgroundDrainer() {
      * @return a fresh durable-ack-capable client, or {@code null} if
      *         {@link #outcome} has been set to FAILED or STOPPED
      */
-    @TestOnly
     public WebSocketClient connectWithDurableAckRetry() {
         // run() already set runnerThread; setting it again here is a no-op
         // on that path but wires up direct @TestOnly calls so requestStop()

core/src/main/java/io/questdb/client/cutlass/qwp/client/sf/cursor/CursorWebSocketSendLoop.java

@@ -229,9 +229,9 @@ public final class CursorWebSocketSendLoop implements QuietCloseable {
     // user-facing 5-minute default is applied at the config layer.
     private final long catchUpCapGapMinEscalationWindowNanos;
     private final CatchUpCapGapPolicy catchUpCapGapPolicy;
-    private final ReconnectPolicy reconnectPolicy;
     private final CursorSendEngine engine;
     private final long parkNanos;
+    private final ReconnectPolicy reconnectPolicy;
     // FIFO of OK-acked batches awaiting durable-upload confirmation. Used only
     // when durableAckMode is true. Each entry binds a wireSeq to the per-table
     // (name, seqTxn) pairs the server reported on the OK frame. The queue is
@@ -1548,7 +1548,7 @@ private void clearDurableAckTracking() {
     }
 
     private static boolean isCatchUpCapGap(Throwable t) {
-        return t instanceof CatchUpSendException && ((CatchUpSendException) t).capGap;
+        return t instanceof CatchUpSendException && ((CatchUpSendException) t).isCapGap;
     }
 
     private void resetCatchUpCapGapEpisode() {
@@ -3103,7 +3103,12 @@ private boolean trySendOne() {
                     // Re-anchor's catch-up send failed. fail() here is a fresh,
                     // non-re-entrant connectLoop entry from the I/O loop body --
                     // the same recovery a normal trySendOne send failure takes.
-                    fail(e.getCause());
+                    // Preserve the wrapper on a cap gap so connectLoop's
+                    // isCatchUpCapGap keeps the orphan settle episode (attempt count
+                    // + dwell anchor) alive across the re-anchor recycle; an ordinary
+                    // failure unwraps to the raw cause and restarts the episode, like
+                    // any normal send failure.
+                    fail(isCatchUpCapGap(e) ? e : e.getCause());
                     return false;
                 }
                 return true;
@@ -3325,15 +3330,15 @@ public interface ReconnectFactory {
      * send failures restart the orphan settle episode.
      */
     private static final class CatchUpSendException extends RuntimeException {
-        private final boolean capGap;
+        private final boolean isCapGap;
 
         CatchUpSendException(Throwable cause) {
             this(cause, false);
         }
 
-        CatchUpSendException(Throwable cause, boolean capGap) {
+        CatchUpSendException(Throwable cause, boolean isCapGap) {
             super(cause);
-            this.capGap = capGap;
+            this.isCapGap = isCapGap;
         }
     }
 

core/src/test/java/io/questdb/client/test/cutlass/qwp/client/DeltaDictCatchUpTest.java

@@ -164,7 +164,7 @@ public void testFixedCapNearBoundarySymbolCatchesUpWithoutTerminal() throws Exce
         // table("t").symbol("s", <173 chars>).atNow() encodes to 198 bytes (<=200,
         // accepted), its dict entry is 2+173=175 bytes (> old budget 172 -> old
         // terminal), while the real solo catch-up frame is 12+1+1+175=189 (<=200 ->
-        // fits). Unlike testCatchUpEntryTooLargeForCapFailsTerminally (a genuinely
+        // fits). Unlike testCatchUpCapGapRetriesUntilBudgetThenLatches (a genuinely
         // oversized entry on a shrunk cap, which MUST still terminate), this entry
         // is legally shippable and must NOT terminate.
         final int cap = 200;

core/src/test/java/io/questdb/client/test/cutlass/qwp/client/DeltaDictRecoveryTest.java

@@ -1636,26 +1636,6 @@ public void onBinaryMessage(TestWebSocketServer.ClientHandler client, byte[] dat
         }
     }
 
-    /** Counts every binary frame it receives and acks it. */
-    private static class CountingHandler implements TestWebSocketServer.WebSocketServerHandler {
-        final AtomicInteger frames = new AtomicInteger();
-        private final AtomicLong nextSeq = new AtomicLong(0);
-
-        @Override
-        public void onBinaryMessage(TestWebSocketServer.ClientHandler client, byte[] data) {
-            frames.incrementAndGet();
-            try {
-                client.sendBinary(QwpWireTestUtils.buildAck(nextSeq.getAndIncrement()));
-            } catch (IOException e) {
-                throw new RuntimeException(e);
-            }
-        }
-    }
-    /**
-     * Short-writes the FIRST dictionary append after it is armed, modelling a disk that
-     * fills mid-flush. Offset 0 is left alone so the file header still writes -- only the
-     * entry append fails, which is the path under test.
-     */
     /**
      * Refuses to grow the symbol dictionary's mmap append window -- the production
      * shape of a full disk, since PersistedSymbolDict reserves that window through

core/src/test/java/io/questdb/client/test/cutlass/qwp/client/sf/cursor/CursorSendEngineTest.java

@@ -356,7 +356,7 @@ public void testLegacyReaderGuardsSurviveReopenAndAreRepairedWhenDamaged() throw
     }
 
     @Test
-    public void testV2DiskSlotForcesLegacyReaderToFailClosed() throws Exception {
+    public void testLegacyGuardsForceFsnGapAndCurrentRecoveryAdoptsV2Slot() throws Exception {
         TestUtils.assertMemoryLeak(() -> {
             long buf = Unsafe.malloc(16, MemoryTag.NATIVE_DEFAULT);
             try {

core/src/test/java/io/questdb/client/test/cutlass/qwp/client/sf/cursor/CursorWebSocketSendLoopPoisonFrameTest.java

@@ -270,6 +270,8 @@ public void testNonOrderlyCloseAfterOnlyCatchUpDoesNotStrike() throws Exception
                 }
                 // No strike was ever charged, so nothing escalated: the loop stays
                 // retriable and the producer-facing error latch is clear.
+                assertEquals("a catch-up-only non-orderly close must charge no poison strike",
+                        0, loop.poisonStrikes());
                 loop.checkError();
             } finally {
                 closeAll(clients);
@@ -306,6 +308,8 @@ public void testNonOrderlyRejectionAfterOnlyCatchUpDoesNotStrike() throws Except
                 }
                 // No strike was ever charged, so nothing escalated: the loop stays
                 // retriable and the producer-facing error latch is clear.
+                assertEquals("a catch-up-only NACK must charge no poison strike",
+                        0, loop.poisonStrikes());
                 loop.checkError();
             } finally {
                 closeAll(clients);