WebSocket: release pending-activity ref when close()/terminate() called during CONNECTING

src/bun.js/bindings/webcore/WebSocket.cpp

@@ -920,6 +920,52 @@
     updateHasPendingActivity();
 }
 
+// Called from close()/terminate() while m_state == CONNECTING.
+//
+// The Zig-side upgrade client's cancel() clears its back-pointer to us
+// without calling didAbruptClose, so none of didConnect /
+// didFailWithErrorCode / didClose will ever fire for this socket. We
+// must therefore finish the close ourselves: cancel the upgrade, queue
+// a task that moves to CLOSED, fires the close event (code 1006 per
+// spec — connection never established), and releases the
+// pending-activity ref taken in connect(). Without this the WebSocket
+// stays in CLOSING with m_pendingActivityCount > 0 forever and is
+// never garbage-collected.
+void WebSocket::failConnectingWebSocket()
+{
+    ASSERT(m_state == CONNECTING);
+    m_state = CLOSING;
+
+    if (m_upgradeClient != nullptr) {
+        void* upgradeClient = m_upgradeClient;
+        m_upgradeClient = nullptr;
+        bool useTLSClient = (m_connectionType == ConnectionType::TLS || m_connectionType == ConnectionType::ProxyTLS);
+        if (useTLSClient) {
+            Bun__WebSocketHTTPSClient__cancel(upgradeClient);
+        } else {
+            Bun__WebSocketHTTPClient__cancel(upgradeClient);
+        }
+    }
+
+    if (auto* context = scriptExecutionContext()) {
+        context->postTask([protectedThis = Ref { *this }](ScriptExecutionContext&) {
+            if (protectedThis->m_state == CLOSED)
+                return;
+            protectedThis->m_state = CLOSED;
+            if (protectedThis->m_native.onClose) {
+                protectedThis->m_native.onClose(protectedThis->m_native.ctx, 1006);
+            } else {
+                protectedThis->dispatchEvent(CloseEvent::create(false, 1006, emptyString()));
+            }
+            protectedThis->disablePendingActivity();
+        });
+    } else {
+        m_state = CLOSED;
+        disablePendingActivity();
+    }
+    updateHasPendingActivity();
+}
+
 ExceptionOr<void> WebSocket::close(std::optional<unsigned short> optionalCode, const String& reason)
 {
     int code = optionalCode ? optionalCode.value() : static_cast<int>(1000);
@@ -938,18 +984,7 @@
     if (m_state == CLOSING || m_state == CLOSED)
         return {};
     if (m_state == CONNECTING) {
-        m_state = CLOSING;
-        if (m_upgradeClient != nullptr) {
-            void* upgradeClient = m_upgradeClient;
-            m_upgradeClient = nullptr;
-            bool useTLSClient = (m_connectionType == ConnectionType::TLS || m_connectionType == ConnectionType::ProxyTLS);
-            if (useTLSClient) {
-                Bun__WebSocketHTTPSClient__cancel(upgradeClient);
-            } else {
-                Bun__WebSocketHTTPClient__cancel(upgradeClient);
-            }
-        }
-        updateHasPendingActivity();
+        failConnectingWebSocket();
         return {};
     }
     m_state = CLOSING;
@@ -994,18 +1029,7 @@
     if (m_state == CLOSING || m_state == CLOSED)
         return {};
     if (m_state == CONNECTING) {
-        m_state = CLOSING;
-        if (m_upgradeClient != nullptr) {
-            void* upgradeClient = m_upgradeClient;
-            m_upgradeClient = nullptr;
-            bool useTLSClient = (m_connectionType == ConnectionType::TLS || m_connectionType == ConnectionType::ProxyTLS);
-            if (useTLSClient) {
-                Bun__WebSocketHTTPSClient__cancel(upgradeClient);
-            } else {
-                Bun__WebSocketHTTPClient__cancel(upgradeClient);
-            }
-        }
-        updateHasPendingActivity();
+        failConnectingWebSocket();
         return {};
     }
     m_state = CLOSING;

src/bun.js/bindings/webcore/WebSocket.h

@@ -271,6 +271,7 @@ class WebSocket final : public RefCounted<WebSocket>, public EventTargetWithInli
     void didReceiveClose(CleanStatus wasClean, unsigned short code, WTF::String reason, bool isConnectionError = false);
     void didUpdateBufferedAmount(unsigned bufferedAmount);
     void didStartClosingHandshake();
+    void failConnectingWebSocket();
 
     void sendWebSocketString(const String& message, const Opcode opcode);
     void sendWebSocketData(const char* data, size_t length, const Opcode opcode);

test/js/web/websocket/websocket.test.js

@@ -807,6 +807,91 @@
   }
 });
 
+// close()/terminate() during CONNECTING must transition to CLOSED, fire a
+// close event, and release the pending-activity ref so the WebSocket can be
+// garbage collected. Previously the upgrade client was cancelled without any
+// of the completion callbacks firing, leaving the socket stuck in CLOSING
+// with hasPendingActivity() permanently true.
+describe.each(["close", "terminate"])("%s() during CONNECTING", method => {
+  it("fires close event and transitions to CLOSED", async () => {
+    // TCP server that accepts connections but never responds — keeps the
+    // WebSocket in CONNECTING until we abort it.
+    const listening = Promise.withResolvers();
+    const server = createServer(() => {}).listen(0, "127.0.0.1", listening.resolve);
+    await listening.promise;
+    try {
+      const port = server.address().port;
+      const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+      expect(ws.readyState).toBe(WebSocket.CONNECTING);
+
+      const errors = [];
+      ws.onerror = e => errors.push(e);
+      const closed = new Promise(resolve => {
+        ws.onclose = resolve;
+      });
+
+      ws[method]();
+      expect(ws.readyState).toBe(WebSocket.CLOSING);
+
+      const ev = await closed;
+      expect({
+        readyState: ws.readyState,
+        code: ev.code,
+        wasClean: ev.wasClean,
+        errors: errors.length,
+      }).toEqual({
+        readyState: WebSocket.CLOSED,
+        code: 1006,
+        wasClean: false,
+        errors: 0,
+      });
+    } finally {
+      server.close();
+    }
+  });
+
+  it.serial(
+    "does not leak",
+    async () => {
+      function getWebSocketCount() {
+        Bun.gc(true);
+        return require("bun:jsc").heapStats().objectTypeCounts?.WebSocket || 0;
+      }
+
+      const listening = Promise.withResolvers();
+      const server = createServer(() => {}).listen(0, "127.0.0.1", listening.resolve);
+      await listening.promise;
+      try {
+        const port = server.address().port;
+        const before = getWebSocketCount();
+
+        const closes = [];
+        for (let i = 0; i < 64; i++) {
+          const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+          closes.push(new Promise(resolve => (ws.onclose = resolve)));
+          ws[method]();
+        }
+        await Promise.all(closes);
+
+        // disablePendingActivity is posted as a separate task after the close
+        // event fires; drain those plus any pending socket-close callbacks
+        // before counting. Without the fix, all 64 instances remain alive.
+        let after;
+        for (let i = 0; i < 10; i++) {
+          await new Promise(resolve => setImmediate(resolve));
+          after = getWebSocketCount();
+          if (after - before <= 5) break;
+        }
+
+        expect(after - before).toBeLessThanOrEqual(5);
+      } finally {
+        server.close();
+      }
+    },
+    20000,
+  );
+});
+
 it.serial("instances should be finalized when GC'd", async () => {
   let current_websocket_count = 0;
   let initial_websocket_count = 0;