Prioritize HTTP status in raced connection retry decisions

Author: purpshell

README.md

@@ -130,9 +130,10 @@ The first successful upgrade wins. Pending upgrades are canceled, and opened
 losers close asynchronously with status 1000 and reason `loser socket`.
 The winner proceeds without waiting for those close handshakes. If every
 endpoint fails, the returned error joins the failures in configured URL order.
-When failures carry HTTP status codes, initial background reconnect classification
-uses the first matching status in that order, preserving the existing
-single-endpoint retry rules.
+Initial background reconnect classification uses the first matching HTTP status
+in configured URL order, ahead of network errors from other endpoints. When no
+HTTP status is present, network and dial failures remain retryable. The existing
+single-endpoint retry rules remain unchanged.
 
 With zero or one race URL, the client uses `SocketConfig.URL`, or the default
 endpoint if `URL` is empty. With racing enabled, the list supplies the endpoints

client.go

@@ -577,10 +577,8 @@ func (cli *Client) Connect() error {
 }
 
 func isRetryableConnectError(err error) bool {
-	if exhttp.IsNetworkError(err) {
-		return true
-	}
-
+	// HTTP upgrade rejections take precedence over network failures from
+	// other racers. Joined errors preserve the configured endpoint order.
 	var statusErr socket.ErrWithStatusCode
 	if errors.As(err, &statusErr) {
 		switch statusErr.StatusCode {
@@ -591,6 +589,9 @@ func isRetryableConnectError(err error) bool {
 		}
 	}
 
+	if exhttp.IsNetworkError(err) {
+		return true
+	}
 	return errors.Is(err, socket.ErrDialFailed)
 }
 

socket_race_test.go

@@ -0,0 +1,61 @@
+// Copyright (c) 2026 Rajeh Taher
+// Licensed under the MIT License. See LICENSE-MIT for details.
+
+package whatsmeow
+
+import (
+	"context"
+	"errors"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"syscall"
+	"testing"
+	"time"
+
+	"github.com/polymorfa/hypermeow/socket"
+	waLog "github.com/polymorfa/hypermeow/util/log"
+)
+
+func connectStatusError(t *testing.T, status int) error {
+	t.Helper()
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(status)
+	}))
+	defer server.Close()
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	_, err := socket.ConnectRace(ctx, waLog.Noop, http.DefaultClient, []string{"ws" + server.URL[4:]}, nil)
+	var statusErr socket.ErrWithStatusCode
+	if !errors.As(err, &statusErr) || statusErr.StatusCode != status {
+		t.Fatalf("connect error = %v, want HTTP %d", err, status)
+	}
+	return err
+}
+
+func TestConnectRetryClassificationPreservesHTTPStatusPrecedence(t *testing.T) {
+	forbidden := connectStatusError(t, http.StatusForbidden)
+	unavailable := connectStatusError(t, http.StatusServiceUnavailable)
+	network := &net.OpError{Op: "dial", Net: "tcp", Err: syscall.ECONNREFUSED}
+	for _, tc := range []struct {
+		name string
+		err  error
+		want bool
+	}{
+		{"single rejection", forbidden, false},
+		{"single server error", unavailable, true},
+		{"single network error", network, true},
+		{"rejection before network", errors.Join(forbidden, network), false},
+		{"network before rejection", errors.Join(network, forbidden), false},
+		{"rejection before server error", errors.Join(forbidden, unavailable), false},
+		{"server error before rejection", errors.Join(unavailable, forbidden), true},
+		{"all rejected", errors.Join(forbidden, forbidden), false},
+		{"no error", nil, false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := isRetryableConnectError(tc.err); got != tc.want {
+				t.Fatalf("retryable = %v, want %v: %v", got, tc.want, tc.err)
+			}
+		})
+	}
+}