fix(relay-eager): wake a parked read by cancelling the reader, not by racing

The eager producer raced every read against one never-settled abort promise.
Each completed read leaves a reaction attached to that pending promise, so a
long stream retained one callback per chunk until abort — the exact retention
class relay.ts documents avoiding at its own drain ("Deliberately NOT a shared
Promise.race companion"), reintroduced in the relay this campaign added.

Abort now cancels the reader instead, which settles the parked read on a silent
upstream the same way relay.ts's stopDrain does, and the loop checks the signal
once per iteration. The 31 eager-relay tests — cancel-drain expiry, shutdown
while paused, synthetic tails, teardown, and rewrite framing — stay green, which
is what proves the wake-up path is unchanged.

Author: lidge-jun

src/server/relay-eager.ts

@@ -194,17 +194,19 @@ export function relaySseEagerBounded(
     let syntheticKind: "incomplete" | "failed" | null = null;
     // reader.read() is not intrinsically tied to the upstream AbortController
     // (a fetch body usually rejects on abort, but that coupling is the fetch
-    // implementation's, not the stream's). Race every read against the abort
-    // signal so cancel-drain expiry and shutdown teardown ALWAYS break the
-    // loop even on a silent upstream.
-    const aborted: Promise<"aborted"> = new Promise(resolve => {
-      if (upstream.signal.aborted) resolve("aborted");
-      else upstream.signal.addEventListener("abort", () => resolve("aborted"), { once: true });
-    });
+    // implementation's, not the stream's), so abort must break a parked read on
+    // a silent upstream. Cancelling the reader does that: the pending read
+    // settles and the loop observes the abort. This is deliberately NOT a
+    // shared `Promise.race([reader.read(), aborted])` companion — racing every
+    // read against one never-settled promise retains a reaction per chunk, and
+    // that is the exact retention class relay.ts avoids at its own drain.
+    const wakeParkedRead = () => { reader.cancel(upstream.signal.reason).catch(() => {}); };
+    if (upstream.signal.aborted) wakeParkedRead();
+    else upstream.signal.addEventListener("abort", wakeParkedRead, { once: true });
     try {
       for (;;) {
-        const result = await Promise.race([reader.read(), aborted]);
-        if (result === "aborted") break;
+        const result = await reader.read();
+        if (upstream.signal.aborted) break;
         const { done: upstreamDone, value } = result;
         if (upstreamDone) {
           hooks.finishInspection();