node:http/https/http2: raise Node v26.3.0 compat to ~94%, sync the upstream suites, and fix the Windows/macOS transport-layer teardown bugs they exposed

packages/bun-usockets/src/context.c

@@ -346,6 +346,7 @@ static void us_internal_init_listen_socket(struct us_listen_socket_t *ls,
     s->flags.is_closed = 0;
     s->flags.adopted = 0;
     s->flags.allow_half_open = (options & LIBUS_SOCKET_ALLOW_HALF_OPEN);
+    s->unclassified_send_failures = 0;
     s->next = 0;
     s->prev = 0;
     s->connect_state = NULL;
@@ -489,6 +490,7 @@ static inline void us_internal_init_connect_socket(struct us_socket_t *s,
     s->flags.is_closed = 0;
     s->flags.adopted = 0;
     s->flags.last_write_failed = 0;
+    s->unclassified_send_failures = 0;
     s->connect_state = NULL;
     s->connect_next = NULL;
 }
@@ -825,3 +827,10 @@ struct us_bun_verify_error_t us_socket_verify_error(struct us_socket_t *s) {
     }
     return (struct us_bun_verify_error_t) { .error = 0, .code = NULL, .reason = NULL };
 }
+
+const char *us_socket_sni_servername(struct us_socket_t *s) {
+    if (s->ssl) {
+        return us_internal_ssl_sni_servername(s);
+    }
+    return NULL;
+}

packages/bun-usockets/src/crypto/openssl.c

@@ -173,6 +173,7 @@ static int us_ssl_listener_ex_idx = -1;
 static int us_ssl_is_socket_ex_idx = -1;
 /* Defined in Rust (src/uws_sys/SocketKind.rs) so the ordinal tracks the enum. */
 extern const unsigned char BUN_SOCKET_KIND_BUN_SOCKET_TLS;
+extern const unsigned char BUN_SOCKET_KIND_UWS_HTTP_TLS;
 /* Serialized resumable session parked by the new-session callback until the
  * SSL stack unwinds; freed with the SSL if never delivered. */
 static int us_ssl_pending_session_idx = -1;
@@ -1338,6 +1339,7 @@ void us_internal_ssl_attach(struct us_socket_t *s, SSL_CTX *ctx,
   s->ssl_raw_tap = 0;
   s->ssl_shutdown_after_spill = 0;
   s->ssl_close_after_spill = 0;
+  s->ssl_end_delivered = 0;
   s->ssl_in_use = 0;
   s->ssl_pending_detach = 0;
   s->ssl_pending_close_code = 0;
@@ -1758,12 +1760,57 @@ struct us_socket_t *us_internal_ssl_on_close(struct us_socket_t *s, int code, vo
   return ret;
 }
 
+/* The EOF dispatch below is scoped to uWS HTTP server sockets: their
+ * context's onEnd owns the EOF (premature-EOF clientError
+ * HPE_INVALID_EOF_STATE, CONNECT/Upgrade half-open, pipeline drain after
+ * FIN), and closing without dispatching silently skipped all of it for
+ * node:https. Every other TLS socket kind predates the dispatch and
+ * synthesizes its JS 'end' from the close event, so they keep the
+ * historical force-close (dispatching for them strands sockets whose end
+ * handler expects the transport to close underneath it). */
+static int ssl_wants_eof_dispatch(struct us_socket_t *s) {
+  return us_socket_kind(s) == BUN_SOCKET_KIND_UWS_HTTP_TLS;
+}
+
+/* Deliver the plaintext EOF to the user layer once, like the plain-TCP path
+ * (loop.c dispatches us_dispatch_end for non-SSL sockets). Both TLS EOF
+ * paths (peer close_notify -> ZERO_RETURN, and the raw TCP FIN that usually
+ * follows it) route through here, so the bit keeps the end handler
+ * single-shot. */
+static struct us_socket_t *ssl_deliver_eof(struct us_socket_t *s) {
+  if (s->ssl_end_delivered) {
+    return s;
+  }
+  s->ssl_end_delivered = 1;
+  return us_dispatch_end(s);
+}
+
 struct us_socket_t *us_internal_ssl_on_end(struct us_socket_t *s) {
   ssl_set_loop_data(s);
-  /* TCP FIN under TLS: the peer's write side is gone, so no close_notify reply
-   * is coming. Send ours best-effort and raw-close now — deferring (the
-   * code==0 path in ssl_close) would wait forever, and with native
-   * allowHalfOpen=true the loop.c caller no longer raw-closes for us. */
+  if (ssl_wants_eof_dispatch(s)) {
+    /* Raw TCP FIN under TLS: the peer's write side is gone, so no
+     * close_notify reply is ever coming. Record the TLS-level shutdown as
+     * received so a later graceful close (an allow_half_open socket ending
+     * its side after this EOF) completes immediately in ssl_handle_shutdown
+     * instead of deferring for an alert that cannot arrive. */
+    if (!ssl_gone(s)) {
+      SSL_set_shutdown(s_ssl(s), SSL_get_shutdown(s_ssl(s)) | SSL_RECEIVED_SHUTDOWN);
+    }
+    s = ssl_deliver_eof(s);
+    if (!s || us_socket_is_closed(s)) {
+      return s;
+    }
+    if (s->flags.allow_half_open) {
+      /* Keep the write side alive like the plain-TCP half-open branch in
+       * loop.c: TCP permits writing after a received FIN, so queued
+       * responses still flush and the app's own end() completes the
+       * shutdown. */
+      return s;
+    }
+  }
+  /* TCP FIN with no half-open: send our close_notify best-effort and
+   * raw-close now — deferring (the code==0 path in ssl_close) would wait
+   * forever. */
   s = ssl_close(s, 0, NULL);
   if (s && !us_socket_is_closed(s)) {
     s = us_internal_socket_close_raw(s, LIBUS_SOCKET_CLOSE_CODE_CLEAN_SHUTDOWN, NULL);
@@ -1890,14 +1937,29 @@ struct us_socket_t *us_internal_ssl_on_data(struct us_socket_t *s, char *data, i
            * close_notify was parked by the new-session callback; deliver it
            * first (wire order - the ticket preceded these bytes, and Node's
            * NewSessionCallback runs before the data reaches JS), then the
-           * decrypted data, then close. */
+           * decrypted data, then the EOF. */
           ssl_flush_pending_session(s);
           ssl_flush_pending_keylog(s);
           if (ssl_gone(s)) return NULL;
           if (read) {
             s = us_dispatch_data(s, loop_ssl_data->ssl_read_output + LIBUS_RECV_BUFFER_PADDING, read);
             if (!s || ssl_gone(s)) return NULL;
           }
+          /* TLS-level EOF: for uWS HTTP sockets, dispatch the user layer's
+           * end handler like a TCP FIN would (see ssl_wants_eof_dispatch),
+           * then honor half-open exactly like the plain-TCP eof branch in
+           * loop.c. */
+          if (ssl_wants_eof_dispatch(s)) {
+            s = ssl_deliver_eof(s);
+            if (!s || ssl_gone(s)) return NULL;
+            if (s->flags.allow_half_open) {
+              /* close_notify only ended the peer's write side; ours may
+               * still flush queued bytes, and the app's own end() completes
+               * the shutdown (ssl_handle_shutdown sees RECEIVED_SHUTDOWN and
+               * finishes immediately). */
+              return s;
+            }
+          }
           ssl_close(s, 0, NULL);
           return NULL;
         }
@@ -2534,6 +2596,11 @@ void *us_internal_ssl_sni_userdata(struct us_socket_t *s) {
   return us_socket_server_name_userdata(s);
 }
 
+const char *us_internal_ssl_sni_servername(struct us_socket_t *s) {
+  if (!s->ssl || !s_ssl(s)) return NULL;
+  return SSL_get_servername(s_ssl(s), TLSEXT_NAMETYPE_host_name);
+}
+
 void us_internal_listen_socket_ssl_free(struct us_listen_socket_t *ls) {
   /* Accepted sockets carry `ls` in per-SSL ex_data so sni_cb can reach the
    * listener's SNI tree. Those sockets may outlive the listener (server.close()

packages/bun-usockets/src/eventing/libuv.c

@@ -21,11 +21,116 @@
 
 #ifdef LIBUS_USE_LIBUV
 
+/* The shared dispatch follows socket adoption (a tunneled/upgraded socket
+ * moves; the old allocation stays readable with flags.adopted set and prev
+ * pointing at the live one) and skips closed sockets. The paused-probe below
+ * must honor the same contract - dereferencing the raw poll cast crashed the
+ * CONNECT-tunnel tests on the aarch64 agent. */
+/* Windows does not reliably latch a received RST in SO_ERROR (POSIX does);
+ * the reset surfaces on the next I/O. A zero-byte send observes it without
+ * touching the stream: 0 on a healthy socket, SOCKET_ERROR with a fatal
+ * code once the connection died hard. */
+int us_internal_libuv_peer_reset_probe(LIBUS_SOCKET_DESCRIPTOR fd) {
+  /* Raw winsock send: this file only builds on the libuv (Windows) path and
+   * bsd_send's Windows signature has no flags parameter. */
+  if (send(fd, "", 0, 0) != SOCKET_ERROR) {
+    return 0;
+  }
+  return WSAGetLastError() != WSAEWOULDBLOCK;
+}
+
+static struct us_socket_t *us_internal_poll_cb_adopted_socket(struct us_poll_t *wp) {
+  struct us_socket_t *s = (struct us_socket_t *)wp;
+  if (s->flags.adopted && s->prev) {
+    s = s->prev;
+  }
+  return s;
+}
+
+static int us_internal_poll_cb_socket_is_probeable(struct us_poll_t *wp) {
+  struct us_socket_t *s = us_internal_poll_cb_adopted_socket(wp);
+  return !s->flags.is_closed && s->flags.is_paused;
+}
+
 /* uv_poll_t->data always (except for most times after calling us_poll_stop)
  * points to the us_poll_t */
 static void poll_cb(uv_poll_t *p, int status, int events) {
-  us_internal_dispatch_ready_poll((struct us_poll_t *)p->data, status < 0 && status != UV_EOF, status == UV_EOF,
-                                  events);
+  /* UV_DISCONNECT (Windows AFD): the peer closed its write side. A FIN
+   * arriving after this side already half-closed and stopped reading never
+   * fires another readable poll, and the socket (and server.close()) waits
+   * forever - so DISCONNECT is armed unconditionally in us_poll_start/change
+   * and surfaced as a readable dispatch: the read loop's recv() discovers
+   * the true end of stream (0) after consuming whatever is still queued.
+   * It is mapped to the eof hint ONLY for sockets whose write side we
+   * already shut down (see below): unlike kqueue's EV_EOF, which the kernel
+   * sets only alongside the final data, AFD can signal DISCONNECT while data
+   * is still in flight, and an unconditional eof mapping closed connections
+   * at a mid-stream EAGAIN (truncated bodies across the fetch/backpressure
+   * suites). One-shot: AFD keeps reporting DISCONNECT once signaled, so
+   * re-arm without it - us_poll_start/us_poll_change add it back on the next
+   * poll change.
+   * https://github.com/libuv/libuv/blob/v1.x/docs/src/poll.rst (UV_DISCONNECT
+   * is Windows-only and best-effort; readable polling stays the primary
+   * signal). */
+  int eof = status == UV_EOF;
+  int error = status < 0 && status != UV_EOF;
+  if (events & UV_DISCONNECT) {
+    struct us_poll_t *wp = (struct us_poll_t *)p->data;
+    uv_poll_start(p, us_poll_events(wp), poll_cb);
+    int kind = us_internal_poll_type(wp) & POLL_TYPE_KIND_MASK;
+    /* For a socket whose write side we already shut down, AFD delivers no
+     * readable event for the peer's FIN at all - the exact half-closed state
+     * that hung server.close() - and with our writes closed there is no
+     * data-bearing flow left that an early EOF could truncate. Only there is
+     * DISCONNECT mapped to the eof hint (like kqueue's EV_EOF); every other
+     * socket keeps recv()-owned EOF discovery so mid-stream transfers are
+     * never cut at an EAGAIN. */
+    if (kind == POLL_TYPE_SOCKET_SHUT_DOWN) {
+      eof = 1;
+      events |= UV_READABLE;
+    } else if (kind == POLL_TYPE_SOCKET && us_internal_poll_cb_socket_is_probeable(wp)) {
+      /* A paused socket polls without READABLE, so the read loop cannot
+       * discover terminal states for it - and the pause contract forbids
+       * consuming deferred bytes. MSG_PEEK discriminates without consuming:
+       * an error is an abortive reset (our libuv patch reports AFD_POLL_ABORT
+       * as DISCONNECT so it reaches write-only polls at all) and must close
+       * now like epoll's unmaskable EPOLLERR; 0 is a graceful FIN with no
+       * data, deferred by the shared dispatch's existing paused-EOF contract
+       * until resume; pending data keeps the pause honored untouched. */
+      char probe;
+      ssize_t peeked = bsd_recv(us_poll_fd(wp), &probe, 1, MSG_PEEK);
+      if (peeked == 0) {
+        eof = 1;
+        events |= UV_READABLE;
+      } else if (peeked < 0 && !bsd_would_block()) {
+        error = 1;
+        events |= UV_READABLE;
+      } else if (peeked > 0) {
+        struct us_socket_t *sock = us_internal_poll_cb_adopted_socket(wp);
+        if (us_socket_get_error(sock) != 0 || us_internal_libuv_peer_reset_probe(us_poll_fd(wp))) {
+          /* Data is buffered ahead of whatever ended the connection. If the
+           * peer ABORTED, the kernel already discarded the stream's tail and
+           * a paused socket that never resumes would otherwise never learn -
+           * node's paused sockets error immediately on a reset, buffered
+           * data included. SO_ERROR separates that from a graceful FIN
+           * behind data, which stays deferred until resume. */
+          error = 1;
+          events |= UV_READABLE;
+        } else if (!sock->fin_deferred) {
+          /* Graceful FIN deferred behind data. This one-shot DISCONNECT
+           * report is now consumed, so a LATER reset (an error-path peer
+           * ends, flushes, then destroys - FIN, then RST) has no event left
+           * to ride. Mark the socket; the sweep timer escalates via
+           * SO_ERROR. */
+          sock->fin_deferred = 1;
+          sock->group->loop->data.fin_deferred_count++;
+        }
+      }
+    } else {
+      events |= UV_READABLE;
+    }
+  }
+  us_internal_dispatch_ready_poll((struct us_poll_t *)p->data, error, eof, events);
 }
 
 static void prepare_cb(uv_prepare_t *p) {
@@ -101,7 +206,10 @@ void us_poll_start(struct us_poll_t *p, struct us_loop_t *loop, int events) {
   // a `Async.KeepAlive` associated with them, which is used instead of the
   // usockets internals. usockets doesnt have a notion of ref-counted handles.
   uv_unref((uv_handle_t *)p->uv_p);
-  uv_poll_start(p->uv_p, events, poll_cb);
+  /* Always ask for UV_DISCONNECT: a peer FIN must fire even when the poll is
+   * writable-only at that moment (a half-closed connection whose reads are
+   * paused is exactly the state that otherwise hangs; see poll_cb). */
+  uv_poll_start(p->uv_p, events | UV_DISCONNECT, poll_cb);
 }
 
 int us_poll_start_rc(struct us_poll_t *p, struct us_loop_t *loop, int events) {
@@ -116,7 +224,7 @@ void us_poll_change(struct us_poll_t *p, struct us_loop_t *loop, int events) {
         us_internal_poll_type(p) |
         ((events & LIBUS_SOCKET_READABLE) ? POLL_TYPE_POLLING_IN : 0) |
         ((events & LIBUS_SOCKET_WRITABLE) ? POLL_TYPE_POLLING_OUT : 0);
-    uv_poll_start(p->uv_p, events, poll_cb);
+    uv_poll_start(p->uv_p, events | UV_DISCONNECT, poll_cb);
   }
 }
 
@@ -200,7 +308,7 @@ void us_loop_free(struct us_loop_t *loop) {
 
   us_internal_loop_data_free(loop);
 
-  // we need to run the loop one last round to call all close callbacks
+// we need to run the loop one last round to call all close callbacks
   // we cannot do this if we do not own the loop, default
   if (!loop->is_default) {
     uv_run(loop->uv_loop, UV_RUN_NOWAIT);

packages/bun-usockets/src/internal/eventing/libuv.h

@@ -24,6 +24,9 @@
 #define LIBUS_SOCKET_READABLE UV_READABLE
 #define LIBUS_SOCKET_WRITABLE UV_WRITABLE
 
+/* Defined in eventing/libuv.c; used by the sweep escalation in loop.c. */
+int us_internal_libuv_peer_reset_probe(LIBUS_SOCKET_DESCRIPTOR fd);
+
 struct us_loop_t {
   alignas(LIBUS_EXT_ALIGNMENT) struct us_internal_loop_data_t data;
 

packages/bun-usockets/src/internal/internal.h

@@ -227,6 +227,7 @@ int us_internal_ssl_write(us_socket_r s, const char *data, int length);
 void *us_internal_ssl_get_native_handle(us_socket_r s);
 struct us_bun_verify_error_t us_internal_ssl_verify_error(us_socket_r s);
 void *us_internal_ssl_sni_userdata(us_socket_r s);
+const char *us_internal_ssl_sni_servername(us_socket_r s);
 void us_internal_ssl_handshake_abort(us_socket_r s);
 /* SSL_CTX_free(ls->ssl_ctx) + sni_free(ls->sni). Called from us_listen_socket_close. */
 void us_internal_listen_socket_ssl_free(struct us_listen_socket_t *ls);
@@ -286,6 +287,10 @@ struct us_socket_t {
   /* Same as ssl_shutdown_after_spill but for us_internal_ssl_close: the
    * close re-runs from the writable event once the spill drains. */
   unsigned char ssl_close_after_spill : 1;
+  /* The plaintext EOF (peer close_notify or the raw TCP FIN behind it) was
+   * already dispatched to the user layer; both EOF paths can fire for one
+   * connection, and the end handler must run once. */
+  unsigned char ssl_end_delivered : 1;
   /* Set while SSL_do_handshake/SSL_read is on the stack: JS run from inside
    * those calls (ALPN/SNI/keylog callbacks) may destroy the socket, and the
    * SSL must not be freed under BoringSSL's feet - the detach is deferred to
@@ -296,6 +301,15 @@ struct us_socket_t {
    * inside a handshake callback must still RST, not FIN, when it is finally
    * performed). */
   unsigned char ssl_pending_close_code;
+  /* Consecutive send() failures with an errno that is neither
+   * would-block/transient nor a known peer-gone error (see
+   * us_socket_write_check_error). Reset by any send that makes progress.
+   * Lives in the pad-to-pointer gap before `group`, so it costs nothing. */
+  /* 7 bits fit the 32-cap retry counter; the spare bit marks a paused
+   * socket whose peer FIN was deferred behind buffered data (libuv path -
+   * the sweep escalates via SO_ERROR when the peer later resets). */
+  unsigned char unclassified_send_failures : 7;
+  unsigned char fin_deferred : 1;
 
   struct us_socket_group_t *group;
   /* NULL for plain TCP. Direct BoringSSL `SSL*`; set by us_internal_ssl_attach

packages/bun-usockets/src/internal/loop_data.h

@@ -44,6 +44,13 @@ struct us_internal_loop_data_t {
     long long sweep_next_tick_ns;
 #endif
     int sweep_timer_count;
+#ifdef LIBUS_USE_LIBUV
+    /* Sockets whose peer FIN was deferred behind buffered data while paused
+     * (poll_cb's MSG_PEEK probe): the sweep escalates them via SO_ERROR when
+     * the peer later resets, since the one-shot DISCONNECT report was already
+     * consumed by the FIN. Zero cost while no socket is in that state. */
+    int fin_deferred_count;
+#endif
     struct us_internal_async *wakeup_async;
     struct us_socket_group_t *head;
     /* QUIC engines on this loop. us_quic_loop_process walks the list from

packages/bun-usockets/src/libusockets.h

@@ -410,6 +410,11 @@ unsigned char us_connecting_socket_kind(struct us_connecting_socket_t *c) nonnul
 
 struct us_bun_verify_error_t us_socket_verify_error(struct us_socket_t *s);
 
+/* SNI hostname the peer sent in its ClientHello (server-side TLS sockets), or
+ * NULL when the socket is not TLS or no SNI extension was sent. The returned
+ * pointer is owned by the SSL object and only valid while the socket lives. */
+const char *us_socket_sni_servername(struct us_socket_t *s);
+
 /* ── SSL_CTX construction ─────────────────────────────────────────────────
  * The expensive bit (cert/key/CA parse, cipher list, DH params) is decoupled
  * from sockets entirely. Build once per SecureContext / config, share across