src/utils/internal/event-stream.ts (1)

24-28: LGTM — fix is correct and consistent with existing pattern.

Attaching .catch(_noop) to the writer.closed chain correctly prevents the unhandled rejection that occurs when the underlying TransformStream's readable side is cancelled (which rejects writer.closed per WHATWG Streams). The pattern mirrors the existing onClosed implementation at line 164 (this._writer.closed.then(cb).catch(_noop)) and the per-write .catch(...) handlers throughout the class, so the intent to swallow these errors is consistent.

One minor note for consideration: the .then(...) callback sets _writerIsClosed = true only on resolution, but on rejection (the cancel case) _writerIsClosed is left as false. In practice the per-write .catch handlers also flip the flag and close() guards on _disposed, so this is unlikely to cause issues — but if you want the flag to reflect "writer is no longer usable" in both outcomes, you could set it in the catch as well:

Optional refinement

     this._writer.closed
       .then(() => {
         this._writerIsClosed = true;
       })
-      .catch(_noop);
+      .catch(() => {
+        this._writerIsClosed = true;
+      });

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/utils/internal/event-stream.ts` around lines 24 - 28, The writer.closed
promise only sets this._writerIsClosed = true on resolution, leaving the flag
false on rejection; update the writer.closed handling (the
this._writer.closed.then(...).catch(_noop) block) so that this._writerIsClosed
is set when the promise rejects as well (either by setting the flag in the catch
or using a finally-equivalent) to reflect that the writer is no longer usable;
refer to this._writer.closed, this._writerIsClosed, _noop and mirror the pattern
used by onClosed and the per-write .catch handlers.

src/utils/internal/event-stream.ts (1)

24-30: LGTM — correctly handles the rejection of writer.closed.

This addresses the unhandled rejection cleanly and is consistent with the existing .catch(() => { this._writerIsClosed = true }) pattern used on per-write calls (lines 78, 95, 114, 137). On Deno specifically, an unhandled rejection from the closed promise (e.g., "resource closed" after the readable side is cancelled) would terminate the process, so handling it here is the right fix.

♻️ Optional: collapse the duplicated body into a single handler

Both branches do the same thing, so you can equivalently write it as:

-    this._writer.closed
-      .then(() => {
-        this._writerIsClosed = true;
-      })
-      .catch(() => {
-        this._writerIsClosed = true;
-      });
+    this._writer.closed.finally(() => {
+      this._writerIsClosed = true;
+    });

Note: .finally() still propagates the rejection, so chain a .catch(_noop) if you adopt this — or keep the current explicit two-handler form, which is already clear and correct.

-    this._writer.closed
-      .then(() => {
-        this._writerIsClosed = true;
-      })
-      .catch(() => {
-        this._writerIsClosed = true;
-      });
+    this._writer.closed
+      .finally(() => {
+        this._writerIsClosed = true;
+      })
+      .catch(_noop);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/utils/internal/event-stream.ts` around lines 24 - 30, The current
.then(...).catch(...) on this._writer.closed sets this._writerIsClosed in both
branches; simplify by replacing the two-branch pattern with a single finally
handler followed by a swallow-catch to avoid propagating rejections: call
this._writer.closed.finally(() => set this._writerIsClosed = true) and then
chain a .catch(_) noop to swallow any error; reference this._writer.closed and
the this._writerIsClosed flag when making the change.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

src/utils/internal/event-stream.ts (1)

24-27: ⚠️ Potential issue | 🔴 Critical

.finally() alone does not prevent the unhandled rejection — the bug from #1375 is still present.

Promise.prototype.finally(onFinally) returns a promise that adopts the original promise's settled state. If this._writer.closed rejects (which is exactly what happens when the TransformStream is cancelled, per WHATWG Streams), the promise returned by .finally(...) rejects with the same reason. Since nothing catches it, the unhandled rejection still escapes and Deno will still terminate the process — defeating the stated purpose of this PR.

The PR description even says "adds a noop .catch", but the implementation uses .finally() without one. The file already exposes _noop (line 4) and the correct pattern is used in onClosed() at line 163 (.then(cb).catch(_noop)).

🔧 Suggested fix

     this._writer.closed
       .finally(() => {
         this._writerIsClosed = true;
-      });
+      })
+      .catch(_noop);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/utils/internal/event-stream.ts` around lines 24 - 27, The current use of
this._writer.closed.finally(() => { this._writerIsClosed = true; }) still allows
rejections to escape; update the chain to swallow rejections by appending a
catch that uses the existing _noop (e.g., this._writer.closed.finally(() => {
this._writerIsClosed = true; }).catch(_noop)) so the rejection from the
TransformStream cancellation is handled (mirror the pattern used in onClosed()).