react-native-real-time-nitro 1.7.0 → 1.8.0

package/3rdparty/output/ios/libwebsockets.xcframework/ios-arm64_x86_64-simulator/Headers/psa/crypto_values.h

@@ -279,6 +279,11 @@
  * to read from a resource. */
 #define PSA_ERROR_INSUFFICIENT_DATA     ((psa_status_t)-143)
 
+/** This can be returned if a function can no longer operate correctly.
+ * For example, if an essential initialization operation failed or
+ * a mutex operation failed. */
+#define PSA_ERROR_SERVICE_FAILURE       ((psa_status_t)-144)
+
 /** The key identifier is not valid. See also :ref:\`key-handles\`.
  */
 #define PSA_ERROR_INVALID_HANDLE        ((psa_status_t)-136)
@@ -408,7 +413,7 @@
     ((type) | PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)
 /** The public key type corresponding to a key pair type.
  *
- * You may also pass a key pair type as \p type, it will be left unchanged.
+ * You may also pass a public key type as \p type, it will be left unchanged.
  *
  * \param type      A public key type or key pair type.
  *
@@ -594,19 +599,23 @@
  * They are defined in _Standards for Efficient Cryptography_,
  * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
  * https://www.secg.org/sec2-v2.pdf
+ *
+ * \note For secp224k1, the bit-size is 225 (size of a private value).
+ *
+ * \note Mbed TLS only supports secp192k1 and secp256k1.
  */
 #define PSA_ECC_FAMILY_SECP_K1           ((psa_ecc_family_t) 0x17)
 
 /** SEC random curves over prime fields.
  *
  * This family comprises the following curves:
- * secp192k1, secp224r1, secp256r1, secp384r1, secp521r1.
+ * secp192r1, secp224r1, secp256r1, secp384r1, secp521r1.
  * They are defined in _Standards for Efficient Cryptography_,
  * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
  * https://www.secg.org/sec2-v2.pdf
  */
 #define PSA_ECC_FAMILY_SECP_R1           ((psa_ecc_family_t) 0x12)
-/* SECP160R2 (SEC2 v1, obsolete) */
+/* SECP160R2 (SEC2 v1, obsolete, not supported in Mbed TLS) */
 #define PSA_ECC_FAMILY_SECP_R2           ((psa_ecc_family_t) 0x1b)
 
 /** SEC Koblitz curves over binary fields.
@@ -616,6 +625,8 @@
  * They are defined in _Standards for Efficient Cryptography_,
  * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
  * https://www.secg.org/sec2-v2.pdf
+ *
+ * \note Mbed TLS does not support any curve in this family.
  */
 #define PSA_ECC_FAMILY_SECT_K1           ((psa_ecc_family_t) 0x27)
 
@@ -626,6 +637,8 @@
  * They are defined in _Standards for Efficient Cryptography_,
  * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
  * https://www.secg.org/sec2-v2.pdf
+ *
+ * \note Mbed TLS does not support any curve in this family.
  */
 #define PSA_ECC_FAMILY_SECT_R1           ((psa_ecc_family_t) 0x22)
 
@@ -636,6 +649,8 @@
  * It is defined in _Standards for Efficient Cryptography_,
  * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
  * https://www.secg.org/sec2-v2.pdf
+ *
+ * \note Mbed TLS does not support any curve in this family.
  */
 #define PSA_ECC_FAMILY_SECT_R2           ((psa_ecc_family_t) 0x2b)
 
@@ -645,6 +660,9 @@
  * brainpoolP160r1, brainpoolP192r1, brainpoolP224r1, brainpoolP256r1,
  * brainpoolP320r1, brainpoolP384r1, brainpoolP512r1.
  * It is defined in RFC 5639.
+ *
+ * \note Mbed TLS only supports the 256-bit, 384-bit and 512-bit curves
+ *       in this family.
  */
 #define PSA_ECC_FAMILY_BRAINPOOL_P_R1    ((psa_ecc_family_t) 0x30)
 
@@ -673,6 +691,8 @@
  * - 448-bit: Edwards448, the twisted Edwards curve birationally equivalent
  *   to Curve448.
  *   Hamburg, _Ed448-Goldilocks, a new elliptic curve_, NIST ECC Workshop, 2015.
+ *
+ * \note Mbed TLS does not support Edwards curves yet.
  */
 #define PSA_ECC_FAMILY_TWISTED_EDWARDS   ((psa_ecc_family_t) 0x42)
 

package/cpp/HybridWebSocket.cpp

@@ -164,13 +164,14 @@ std::shared_ptr<Promise<void>> HybridWebSocket::connect(
 
     // Enable per-message-deflate compression extension
     // This can reduce bandwidth by 60-80% for text messages
+    // Optimized for mobile: smaller window size (12 instead of 15) saves 28KB per connection
     static const struct lws_extension extensions[] = {
       {
         "permessage-deflate",
         lws_extension_callback_pm_deflate,
         "permessage-deflate"
         "; client_no_context_takeover"
-        "; client_max_window_bits"
+        "; client_max_window_bits=12"  // Smaller window for mobile (saves memory)
       },
       { nullptr, nullptr, nullptr }
     };
@@ -214,6 +215,9 @@ std::shared_ptr<Promise<void>> HybridWebSocket::connect(
     // SSL configuration
     if (_useSsl) {
       ccinfo.ssl_connection = LCCSCF_USE_SSL;
+#ifdef LCCSCF_USE_TLS13
+      ccinfo.ssl_connection |= LCCSCF_USE_TLS13;
+#endif
 
       if (_caPath.empty()) {
         // No CA certificate - disable verification (insecure, for development only)
@@ -275,31 +279,17 @@ std::shared_ptr<Promise<void>> HybridWebSocket::connect(
 // ============================================================
 
 void HybridWebSocket::serviceLoop() {
-  // Adaptive polling: start aggressive, back off when idle
-  int pollTimeout = 1; // Start with 1ms for low latency
-  int idleCount = 0;
-  const int MAX_IDLE_COUNT = 10;
-  const int MAX_TIMEOUT = 50; // Max 50ms when idle
-
+  // Let libwebsockets automatically determine the optimal timeout
+  // based on internal timers, pending writes, and connection state
+  // (more efficient than manual adaptive polling)
   while (_running && _context) {
-    // Service the connection with adaptive timeout
-    int result = lws_service(_context, pollTimeout);
+    // Service with auto timeout (0 = libwebsockets decides)
+    int result = lws_service(_context, 0);
 
     if (result < 0) {
       break; // Service error
     }
 
-    // Adaptive polling: increase timeout when idle to save CPU
-    if (result == 0) {
-      idleCount++;
-      if (idleCount > MAX_IDLE_COUNT && pollTimeout < MAX_TIMEOUT) {
-        pollTimeout = std::min(pollTimeout * 2, MAX_TIMEOUT);
-      }
-    } else {
-      idleCount = 0;
-      pollTimeout = 1; // Reset to low latency when active
-    }
-
     // Process send queue - BATCH PROCESS multiple messages
     if (_wsi && _state == State::OPEN) {
       // Try lock first to avoid blocking if queue is being modified
@@ -308,11 +298,15 @@ void HybridWebSocket::serviceLoop() {
         continue; // Skip this iteration if locked
       }
 
-      // Process up to 64 messages per iteration (increased batch size)
+      // Adaptive batching: process many small messages or fewer large messages
       int batchCount = 0;
+      size_t batchBytes = 0;
       const int MAX_BATCH_SIZE = 64;
+      const size_t MAX_BATCH_BYTES = 256 * 1024; // 256KB per batch
 
-      while (!_sendQueue.empty() && batchCount < MAX_BATCH_SIZE) {
+      while (!_sendQueue.empty() &&
+             batchCount < MAX_BATCH_SIZE &&
+             batchBytes < MAX_BATCH_BYTES) {
         auto& msg = _sendQueue.front();
 
         // Prepare buffer with LWS_PRE padding
@@ -336,8 +330,15 @@ void HybridWebSocket::serviceLoop() {
         lock.lock();
 
         if (written == static_cast<int>(msg.data.size())) {
-          _sendQueue.pop();
+          // Decrement queue bytes counter
+          _queueBytes.fetch_sub(msg.data.size());
+
+          // Track batch progress
+          batchBytes += msg.data.size();
           batchCount++;
+
+          _sendQueue.pop();
+
           // Track performance metrics
           _messagesSent.fetch_add(1, std::memory_order_relaxed);
           _bytesSent.fetch_add(msg.data.size(), std::memory_order_relaxed);
@@ -366,7 +367,15 @@ void HybridWebSocket::send(const std::string& message) {
 
   {
     std::lock_guard<std::mutex> lock(_sendMutex);
+
+    // Backpressure: check queue limits
+    if (_sendQueue.size() >= MAX_QUEUE_SIZE ||
+        _queueBytes.load() >= MAX_QUEUE_BYTES) {
+      throw std::runtime_error("Send queue full - connection too slow");
+    }
+
     _sendQueue.push(std::move(msg));
+    _queueBytes.fetch_add(msg.data.size());
   }
 
   // Wake up service thread only if needed (when idle)
@@ -391,7 +400,15 @@ void HybridWebSocket::sendBinary(const std::shared_ptr<ArrayBuffer>& data) {
 
   {
     std::lock_guard<std::mutex> lock(_sendMutex);
+
+    // Backpressure: check queue limits
+    if (_sendQueue.size() >= MAX_QUEUE_SIZE ||
+        _queueBytes.load() >= MAX_QUEUE_BYTES) {
+      throw std::runtime_error("Send queue full - connection too slow");
+    }
+
     _sendQueue.push(std::move(msg));
+    _queueBytes.fetch_add(msg.data.size());
   }
 
   // Wake up service thread
@@ -451,10 +468,18 @@ void HybridWebSocket::cleanup() {
   
   _wsi = nullptr;
   _state = State::CLOSED;
-  
-  std::lock_guard<std::mutex> lock(_sendMutex);
-  while (!_sendQueue.empty()) {
-    _sendQueue.pop();
+
+  {
+    std::lock_guard<std::mutex> lock(_sendMutex);
+    while (!_sendQueue.empty()) {
+      _sendQueue.pop();
+    }
+    _queueBytes.store(0);
+  }
+
+  {
+    std::lock_guard<std::mutex> lock(_fragmentMutex);
+    _fragmentBuffer.clear();
   }
 }
 
@@ -510,6 +535,28 @@ void HybridWebSocket::setOnClose(
   _onClose = value;
 }
 
+double HybridWebSocket::getPingLatency() {
+  return static_cast<double>(_pingLatencyMs.load(std::memory_order_relaxed));
+}
+
+ConnectionMetrics HybridWebSocket::getConnectionMetrics() {
+  double queueSize;
+  {
+    std::lock_guard<std::mutex> lock(_sendMutex);
+    queueSize = static_cast<double>(_sendQueue.size());
+  }
+
+  return ConnectionMetrics(
+    static_cast<double>(_messagesSent.load(std::memory_order_relaxed)),
+    static_cast<double>(_messagesReceived.load(std::memory_order_relaxed)),
+    static_cast<double>(_bytesSent.load(std::memory_order_relaxed)),
+    static_cast<double>(_bytesReceived.load(std::memory_order_relaxed)),
+    static_cast<double>(_pingLatencyMs.load(std::memory_order_relaxed)),
+    queueSize,
+    static_cast<double>(_queueBytes.load(std::memory_order_relaxed))
+  );
+}
+
 // ============================================================
 // LibWebSockets Callback Handler
 // ============================================================
@@ -557,45 +604,107 @@ int HybridWebSocket::websocketCallback(
       
     case LWS_CALLBACK_CLIENT_RECEIVE: {
       bool isBinary = lws_frame_is_binary(wsi);
+      bool isFirstFragment = lws_is_first_fragment(wsi);
+      bool isFinalFragment = lws_is_final_fragment(wsi);
 
       // Track performance metrics
-      ws->_messagesReceived.fetch_add(1, std::memory_order_relaxed);
       ws->_bytesReceived.fetch_add(len, std::memory_order_relaxed);
 
-      if (isBinary) {
-        // Binary message - use static factory method
-        auto buffer = ArrayBuffer::copy(static_cast<const uint8_t*>(in), len);
-
-        // Optimize: check if callback exists before locking
-        std::unique_lock<std::mutex> lock(ws->_callbackMutex, std::defer_lock);
-        if (lock.try_lock() && ws->_onBinaryMessage.has_value()) {
-          try {
-            // Copy callback to minimize critical section
-            auto callback = ws->_onBinaryMessage.value();
-            lock.unlock();
-            // Execute outside of lock
-            callback(buffer);
-          } catch (...) {
-            // Catch exceptions from JS callback
+      // Handle fragmented messages (better memory usage for large messages >64KB)
+      if (!isFirstFragment || !isFinalFragment) {
+        std::lock_guard<std::mutex> fragLock(ws->_fragmentMutex);
+
+        if (isFirstFragment) {
+          // First fragment - reset buffer and pre-allocate intelligently
+          ws->_fragmentBuffer.clear();
+
+          // Smart pre-allocation: assume average fragmented message is 128KB
+          // (most fragmented messages are large images/files)
+          // This reduces reallocation overhead
+          size_t estimatedSize = std::max(len * 4, static_cast<size_t>(128 * 1024));
+          ws->_fragmentBuffer.reserve(estimatedSize);
+          ws->_fragmentIsBinary = isBinary;
+
+          #ifdef DEBUG
+          printf("[WebSocket] First fragment received, pre-allocated %zu bytes\n", estimatedSize);
+          #endif
+        }
+
+        // Accumulate fragment
+        const uint8_t* data = static_cast<const uint8_t*>(in);
+        ws->_fragmentBuffer.insert(ws->_fragmentBuffer.end(), data, data + len);
+
+        if (isFinalFragment) {
+          // Final fragment - deliver complete message
+          ws->_messagesReceived.fetch_add(1, std::memory_order_relaxed);
+
+          if (ws->_fragmentIsBinary) {
+            auto buffer = ArrayBuffer::copy(ws->_fragmentBuffer.data(), ws->_fragmentBuffer.size());
+
+            std::unique_lock<std::mutex> lock(ws->_callbackMutex, std::defer_lock);
+            if (lock.try_lock() && ws->_onBinaryMessage.has_value()) {
+              try {
+                auto callback = ws->_onBinaryMessage.value();
+                lock.unlock();
+                callback(buffer);
+              } catch (...) {}
+            }
+          } else {
+            std::string message(ws->_fragmentBuffer.begin(), ws->_fragmentBuffer.end());
+
+            std::unique_lock<std::mutex> lock(ws->_callbackMutex, std::defer_lock);
+            if (lock.try_lock() && ws->_onMessage.has_value()) {
+              try {
+                auto callback = ws->_onMessage.value();
+                lock.unlock();
+                callback(message);
+              } catch (...) {}
+            }
           }
+
+          // Clear buffer after delivery and free memory
+          // Using swap trick to force deallocation
+          std::vector<uint8_t>().swap(ws->_fragmentBuffer);
         }
       } else {
-        // Text message - reserve space for better performance
-        std::string message;
-        message.reserve(len);
-        message.assign(static_cast<char*>(in), len);
-
-        // Optimize: check if callback exists before locking
-        std::unique_lock<std::mutex> lock(ws->_callbackMutex, std::defer_lock);
-        if (lock.try_lock() && ws->_onMessage.has_value()) {
-          try {
-            // Copy callback to minimize critical section
-            auto callback = ws->_onMessage.value();
-            lock.unlock();
-            // Execute outside of lock
-            callback(message);
-          } catch (...) {
-            // Catch exceptions from JS callback
+        // Complete message in single frame (most common case)
+        ws->_messagesReceived.fetch_add(1, std::memory_order_relaxed);
+
+        if (isBinary) {
+          // Binary message - use static factory method
+          auto buffer = ArrayBuffer::copy(static_cast<const uint8_t*>(in), len);
+
+          // Optimize: check if callback exists before locking
+          std::unique_lock<std::mutex> lock(ws->_callbackMutex, std::defer_lock);
+          if (lock.try_lock() && ws->_onBinaryMessage.has_value()) {
+            try {
+              // Copy callback to minimize critical section
+              auto callback = ws->_onBinaryMessage.value();
+              lock.unlock();
+              // Execute outside of lock
+              callback(buffer);
+            } catch (...) {
+              // Catch exceptions from JS callback
+            }
+          }
+        } else {
+          // Text message - reserve space for better performance
+          std::string message;
+          message.reserve(len);
+          message.assign(static_cast<char*>(in), len);
+
+          // Optimize: check if callback exists before locking
+          std::unique_lock<std::mutex> lock(ws->_callbackMutex, std::defer_lock);
+          if (lock.try_lock() && ws->_onMessage.has_value()) {
+            try {
+              // Copy callback to minimize critical section
+              auto callback = ws->_onMessage.value();
+              lock.unlock();
+              // Execute outside of lock
+              callback(message);
+            } catch (...) {
+              // Catch exceptions from JS callback
+            }
           }
         }
       }
@@ -610,14 +719,47 @@ int HybridWebSocket::websocketCallback(
         std::string(static_cast<char*>(in)) :
         "Connection error";
 
+      // Enhanced error diagnostics - categorize common error types
+      std::string detailedError = error;
+      std::string errorCategory;
+
+      if (error.find("SSL") != std::string::npos ||
+          error.find("TLS") != std::string::npos ||
+          error.find("certificate") != std::string::npos) {
+        errorCategory = "SSL/TLS Error";
+        detailedError += " (SSL/TLS handshake failed - check certificate validity and CA path)";
+      } else if (error.find("timeout") != std::string::npos ||
+                 error.find("Timeout") != std::string::npos) {
+        errorCategory = "Timeout Error";
+        detailedError += " (Connection timeout - check network connectivity and server availability)";
+      } else if (error.find("DNS") != std::string::npos ||
+                 error.find("resolve") != std::string::npos ||
+                 error.find("getaddrinfo") != std::string::npos) {
+        errorCategory = "DNS Error";
+        detailedError += " (DNS resolution failed - check hostname and network)";
+      } else if (error.find("refused") != std::string::npos ||
+                 error.find("Refused") != std::string::npos) {
+        errorCategory = "Connection Refused";
+        detailedError += " (Server refused connection - check server is running and port is correct)";
+      } else if (error.find("unreachable") != std::string::npos) {
+        errorCategory = "Network Unreachable";
+        detailedError += " (Network unreachable - check network connectivity)";
+      } else {
+        errorCategory = "Connection Error";
+      }
+
       // Always log connection errors to help debugging
-      printf("[WebSocket] CONNECTION ERROR: %s\n", error.c_str());
-      printf("[WebSocket] URL was: %s\n", ws->_url.c_str());
+      printf("[WebSocket] ========================================\n");
+      printf("[WebSocket] CONNECTION ERROR\n");
+      printf("[WebSocket] Category: %s\n", errorCategory.c_str());
+      printf("[WebSocket] Details: %s\n", detailedError.c_str());
+      printf("[WebSocket] URL: %s\n", ws->_url.c_str());
+      printf("[WebSocket] ========================================\n");
 
       std::lock_guard<std::mutex> lock(ws->_callbackMutex);
       if (ws->_onError.has_value()) {
         try {
-          ws->_onError.value()(error);
+          ws->_onError.value()(detailedError);
         } catch (...) {}
       }
       break;
@@ -639,6 +781,9 @@ int HybridWebSocket::websocketCallback(
     case LWS_CALLBACK_CLIENT_WRITEABLE: {
       // Send ping only if timer triggered it (atomic exchange clears flag)
       if (ws->_pingPending.exchange(false, std::memory_order_relaxed)) {
+        // Record ping send time for latency tracking
+        ws->_lastPingTime = std::chrono::steady_clock::now();
+
         // Send ping frame with empty payload
         unsigned char ping_payload[LWS_PRE];
         lws_write(wsi, &ping_payload[LWS_PRE], 0, LWS_WRITE_PING);
@@ -660,9 +805,17 @@ int HybridWebSocket::websocketCallback(
     }
 
     case LWS_CALLBACK_CLIENT_RECEIVE_PONG: {
-      // Received pong response (libwebsockets handles this automatically)
+      // Received pong response - calculate latency for connection health monitoring
+      auto now = std::chrono::steady_clock::now();
+      auto latency = std::chrono::duration_cast<std::chrono::milliseconds>(
+        now - ws->_lastPingTime
+      ).count();
+
+      // Store latency metric
+      ws->_pingLatencyMs.store(latency, std::memory_order_relaxed);
+
       #ifdef DEBUG
-      printf("[WebSocket] Received pong\n");
+      printf("[WebSocket] Received pong (latency: %lldms)\n", latency);
       #endif
       break;
     }

package/cpp/HybridWebSocket.hpp

@@ -11,6 +11,8 @@
 #include <mutex>
 #include <atomic>
 #include <queue>
+#include <unordered_map>
+#include <chrono>
 
 #include <libwebsockets.h>
 
@@ -102,6 +104,16 @@ public:
    */
   void setCAPath(const std::string& path) override;
 
+  /**
+   * Get current ping latency in milliseconds
+   */
+  double getPingLatency() override;
+
+  /**
+   * Get comprehensive connection metrics
+   */
+  ConnectionMetrics getConnectionMetrics() override;
+
   // Getters
   double getState() override;
   std::string getUrl() override;
@@ -159,7 +171,20 @@ private:
 
   std::queue<QueuedMessage> _sendQueue;
   std::mutex _sendMutex;
-  
+
+  // Backpressure limits
+  static constexpr size_t MAX_QUEUE_SIZE = 1000;
+  static constexpr size_t MAX_QUEUE_BYTES = 10 * 1024 * 1024; // 10MB
+  std::atomic<size_t> _queueBytes{0};
+
+  // ============================================================
+  // Fragmentation handling (for large messages)
+  // ============================================================
+
+  std::vector<uint8_t> _fragmentBuffer;
+  bool _fragmentIsBinary = false;
+  std::mutex _fragmentMutex;
+
   // ============================================================
   // Service thread for I/O
   // ============================================================
@@ -186,10 +211,12 @@ private:
   std::string _caPath;  // CA certificate path (empty = disable verification)
 
   // ============================================================
-  // Ping/Pong tracking
+  // Ping/Pong tracking & Connection Health Monitoring
   // ============================================================
 
   std::atomic<bool> _pingPending{false};
+  std::chrono::steady_clock::time_point _lastPingTime;
+  std::atomic<int64_t> _pingLatencyMs{0};
 
   // ============================================================
   // Performance metrics (atomic for lock-free reads)

package/lib/index.d.ts

@@ -2,6 +2,9 @@ import type { WebSocket } from './specs/WebSocket.nitro';
 /**
  * Create a new WebSocket instance
  *
+ * SSL/TLS works automatically without certificate verification
+ * For production, use ws.setCAPath('/path/to/cacert.pem') to enable verification
+ *
  * @returns WebSocket hybrid object
  *
  * @example
@@ -16,6 +19,5 @@ import type { WebSocket } from './specs/WebSocket.nitro';
  * ```
  */
 export declare function createWebSocket(): WebSocket;
-export type { WebSocket } from './specs/WebSocket.nitro';
+export type { WebSocket, ConnectionMetrics } from './specs/WebSocket.nitro';
 export { WebSocketState } from './specs/WebSocket.nitro';
-export type { WebSocketOptions } from './specs/WebSocket.nitro';

package/lib/index.js

@@ -2,6 +2,9 @@ import { NitroModules } from 'react-native-nitro-modules';
 /**
  * Create a new WebSocket instance
  *
+ * SSL/TLS works automatically without certificate verification
+ * For production, use ws.setCAPath('/path/to/cacert.pem') to enable verification
+ *
  * @returns WebSocket hybrid object
  *
  * @example

package/lib/specs/WebSocket.nitro.d.ts

@@ -8,23 +8,6 @@ export declare enum WebSocketState {
     CLOSING = 2,
     CLOSED = 3
 }
-/**
- * WebSocket connection options
- */
-export interface WebSocketOptions {
-    /**
-     * Sub-protocols to use
-     */
-    protocols?: string[];
-    /**
-     * Headers to send with handshake
-     */
-    headers?: Record<string, string>;
-    /**
-     * Timeout for connection in milliseconds
-     */
-    timeout?: number;
-}
 /**
  * High-performance WebSocket client
  *
@@ -116,4 +99,56 @@ export interface WebSocket extends HybridObject<{
      * @param intervalMs - Ping interval in milliseconds (0 to disable)
      */
     setPingInterval(intervalMs: number): void;
+    /**
+     * Set CA certificate file path for SSL/TLS verification
+     *
+     * @param path - Absolute path to CA certificate file (PEM format)
+     *              Pass empty string to disable certificate verification
+     */
+    setCAPath(path: string): void;
+    /**
+     * Get current ping/pong latency in milliseconds
+     *
+     * @returns Latency in milliseconds (0 if no ping/pong completed yet)
+     */
+    getPingLatency(): number;
+    /**
+     * Get comprehensive connection metrics
+     *
+     * @returns Object containing performance metrics
+     */
+    getConnectionMetrics(): ConnectionMetrics;
+}
+/**
+ * Connection performance metrics
+ */
+export interface ConnectionMetrics {
+    /**
+     * Total messages sent
+     */
+    messagesSent: number;
+    /**
+     * Total messages received
+     */
+    messagesReceived: number;
+    /**
+     * Total bytes sent
+     */
+    bytesSent: number;
+    /**
+     * Total bytes received
+     */
+    bytesReceived: number;
+    /**
+     * Current ping latency in milliseconds (0 if unavailable)
+     */
+    pingLatencyMs: number;
+    /**
+     * Current send queue size
+     */
+    queueSize: number;
+    /**
+     * Current send queue bytes
+     */
+    queueBytes: number;
 }