release(v4.2.1): fix concurrent-ratchet desync via OutboundQueue waiter cursor

Pull-mode httpClient + drainer + parallel RPCs against the same peer
deteriorated after ~10s with `DecryptionError`. Two bugs combined:

- `OutboundQueue.enqueue` woke `drain` waiters with a `since=0`
  snapshot, replaying already-processed events into
  `Shade.acceptTransferEnvelope` → `manager.decrypt` twice. The
  duplicate consumed an already-used skipped key and corrupted the
  Double Ratchet receive chain.

- `ratchetDecrypt` then propagated the corruption: a same-DH
  message behind the chain with no cached skipped key fell through
  to `kdfChainKey` on the ahead state and rewound `chain.counter`,
  permanently desyncing the chain.

Fix `OutboundQueue` to honor each waiter's `since`, and harden
`ratchetDecrypt` so any future duplicate fails cleanly without
mutating state. Adds regression coverage at all three layers.

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

packages/shade-transfer/src/transport/queue-transport.ts

@@ -81,6 +81,14 @@ const DEFAULT_IDLE_EVICTION_MS = 10 * 60 * 1000;
 interface PendingWaiter {
   resolve(events: QueuedEvent[]): void;
   reject(err: Error): void;
+  /**
+   * The waiter's `since` cursor — only events with `id > since` should
+   * be delivered when this waiter is resolved. Without this, an
+   * enqueue that arrives while a poller is waiting would replay
+   * already-processed events, causing the receiver to double-decrypt
+   * (and corrupt ratchet state).
+   */
+  since: number;
   timer: ReturnType<typeof setTimeout>;
   abortHandler?: () => void;
   signal?: AbortSignal;
@@ -140,16 +148,21 @@ export class OutboundQueue {
     // last polled id; the @shade/transfer engine handles missing seqs
     // by re-sending on resume.
     while (state.events.length > this.maxEvents) state.events.shift();
-    // Wake all waiters with whatever has accumulated.
-    const drained = this.collect(state, 0);
-    if (drained.length > 0) {
+    // Wake each waiter with events newer than ITS OWN `since`. Using a
+    // shared snapshot from `since=0` would replay events the waiter has
+    // already processed once a fresh enqueue arrived mid-poll, which on
+    // the receiver side double-dispatches an envelope into shade.receive
+    // → manager.decrypt and consumes the same skipped-key twice (the
+    // second dispatch corrupts the ratchet chain).
+    if (state.waiters.length > 0) {
       const waiters = state.waiters.splice(0);
       for (const w of waiters) {
         clearTimeout(w.timer);
         if (w.abortHandler !== undefined && w.signal !== undefined) {
           w.signal.removeEventListener('abort', w.abortHandler);
         }
-        w.resolve(drained);
+        const wDrained = this.collect(state, w.since);
+        w.resolve(wDrained);
       }
     }
     return event;
@@ -181,7 +194,7 @@ export class OutboundQueue {
         // Empty drain on timeout — that's the "no new events" signal.
         resolve([]);
       }, blockMs);
-      const waiter: PendingWaiter = { resolve, reject, timer };
+      const waiter: PendingWaiter = { resolve, reject, since, timer };
       if (signal !== undefined) {
         const handler = () => {
           const idx = state.waiters.indexOf(waiter);