-      const isErrorCode = error !== NGHTTP2_NO_ERROR && error !== NGHTTP2_CANCEL;
-      if (!isErrorCode || stream.listenerCount("error") > 0) {
-        stream.rstCode = error;
-        if (isErrorCode) {
-          error_instance = streamErrorFromCode(error);
-        }
-      }
+      const isErrorCode = error !== NGHTTP2_NO_ERROR && error !== NGHTTP2_CANCEL;
+      const hasErrorListener = stream.listenerCount("error") > 0;
+      stream.rstCode = error;
+      if (isErrorCode && hasErrorListener) {
+        error_instance = streamErrorFromCode(error);
+      }

Http2Stream._destroy() then needs the matching suppression check so it does not synthesize ERR_HTTP2_STREAM_ERROR when hasErrorListener is false.

What the bug is

In emitStreamErrorNT (line 2670), error_instance is declared as Error | number | undefined. After the PR's refactoring, the number type in this union is dead code — error_instance can never actually hold a number value.

The specific code paths

There are exactly two places where error_instance is assigned after the refactor:

1. error_instance = streamErrorFromCode(error) — inside the if (typeof error === "number") branch. streamErrorFromCode returns an Error object, never a number.
2. error_instance = error — inside the else if (stream.listenerCount("error") > 0) branch. This branch is only reached when typeof error \!== "number", so error is already narrowed by TypeScript to Error (not a number).

Neither path can assign a number to error_instance.

Why existing code doesn't prevent it

This is purely a TypeScript type annotation issue. The stale | number in the union declaration is not guarded by any runtime check because it is never reachable — TypeScript would not raise an error at the assignment sites (they're all compatible), but the declared type is wider than necessary.

Historical context / pre-existing nature

One verifier notes this was technically stale even before the PR: in the old code, the else branch also only executed when typeof error \!== "number". The PR refactored the surrounding logic but did not clean up the annotation. However, since this PR directly modifies this exact line and restructures the relevant control flow, it is the natural place to fix the annotation.

Impact

No runtime impact — TypeScript type annotations are erased at runtime. However, the overly-wide type could mislead future readers or inhibit TypeScript's ability to narrow error_instance in downstream code (e.g., forcing unnecessary typeof guards).

How to fix it

Change line 2670 from:

let error_instance: Error | number | undefined = undefined;

to:

let error_instance: Error | undefined = undefined;

Step-by-step proof

1. emitStreamErrorNT is called with error = 5 (NGHTTP2_STREAM_CLOSED, a number).
2. The typeof error === "number" branch is entered.
3. isErrorCode = 5 \!== 0 && 5 \!== 8 → true.
4. stream.rstCode = 5 is set; error_instance = streamErrorFromCode(5) → assigns an Error.
5. error_instance is now an Error, never a number.

Alternatively, with error as an Error object:

1. The else if (stream.listenerCount("error") > 0) branch fires.
2. error_instance = error — error here has type Error (TypeScript narrowed it to non-number).
3. Again, never a number.