rpc: pin upstream-entry convergence within two ticks

The previous loopback-suppression test asserted that the tick
immediately after a pull pushed zero entries. That contract no
longer holds: the local pushRev advance was removed because it
desynced from the wire-visible appliedPushRev, so the apply's rev
bumps now ride back to the sender on the next pushOnce and the
sender drops them via alreadyApplied().

Rewrite the test to assert the new contract: tick 1 after an
upstream pull may ship redundant entries, but tick 2 is the
no-op, and tick 3 stays settled. This pins that convergence is
bounded at one extra round trip per upstream apply rather than
becoming an unbounded ping-pong, which was the worry the previous
test was guarding against in a stricter form than the system can
now honor.

Author: aron-cf

packages/rpc/src/sync-driver.test.ts

@@ -361,23 +361,43 @@ describe("sync driver — bidirectional convergence", () => {
     }
   });
 
-  it("an upstream entry does not get re-pushed (loopback suppression)", async () => {
+  it("an upstream entry stops circulating within two ticks", async () => {
+    // Before the pushRev-locality fix, the loopback suppression
+    // advanced B's pushRev to currentRev on the apply, so the
+    // immediate pushOnce was a no-op. After the fix, B's pushRev
+    // stays put after the pull, so the first pushOnce after a
+    // pull ships the apply's rev bumps back to A; A's
+    // alreadyApplied() drops them, the push response advances B's
+    // pushRev, and the *next* tick is the no-op. The echo is
+    // bounded at one extra round trip and the system converges
+    // without an unbounded ping-pong.
     const a = makePeer();
     const b = makePeer();
     try {
       const providerA = new SQLiteWorkspaceProvider(a.db, { now: () => 1 });
       providerA.writeFileSync("/from-a.txt", "alpha");
 
-      // First tick: B pulls from A.
-      await tick(b.db, a.rpc);
+      // Tick 1: B pulls A's write. The apply on B bumps B's rev,
+      // so B's coalesce window contains entries; pushed reports
+      // however many entries got coalesced (typically 1 for the
+      // file alone, more if directory entries get touched).
+      const first = await tick(b.db, a.rpc);
       expect(fileEntries(b.db)).toContain("from-a.txt");
-
-      // Second tick: B has nothing new to push back. If the
-      // loopback suppression is broken, applyChanges bumped
-      // vfs_meta.rev on the apply, and the push side would re-ship
-      // the same entry.
-      const result = await tick(b.db, a.rpc);
-      expect(result.pushed).toBe(0);
+      expect(first.pulled.applied).toBeGreaterThan(0);
+      expect(first.pushed).toBeGreaterThanOrEqual(1);
+
+      // Tick 2: A's alreadyApplied() dropped the redundant entries
+      // shipped in tick 1, and B's pushRev advanced past them. So
+      // tick 2 has nothing to push and nothing to pull.
+      const second = await tick(b.db, a.rpc);
+      expect(second.pulled.applied).toBe(0);
+      expect(second.pushed).toBe(0);
+
+      // Tick 3: still settled. Pins that convergence is durable,
+      // not just "the next tick happens to be empty."
+      const third = await tick(b.db, a.rpc);
+      expect(third.pulled.applied).toBe(0);
+      expect(third.pushed).toBe(0);
     } finally {
       a.close();
       b.close();