@annadata/capacitor-mqtt-quic 0.2.2 → 0.2.4

package/docs/diff-node_modules-vs-standalone-android-src.patch

@@ -1,1031 +0,0 @@
-diff -Naur capacitor-mqtt-quic/android/src/main/cpp/ngtcp2_jni.cpp annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/cpp/ngtcp2_jni.cpp
---- capacitor-mqtt-quic/android/src/main/cpp/ngtcp2_jni.cpp	2026-02-18 22:28:55
-+++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/cpp/ngtcp2_jni.cpp	2026-02-19 10:27:58
-@@ -24,6 +24,7 @@
- #include <algorithm>
- #include <atomic>
- #include <chrono>
-+#include <cinttypes>
- #include <cstdarg>
- #include <cstdlib>
- #include <cstdio>
-@@ -73,7 +74,11 @@
- class QuicClient {
-  public:
-   QuicClient(std::string host, uint16_t port)
--      : host_(std::move(host)),
-+      : QuicClient(std::move(host), "", port) {}
-+
-+  QuicClient(std::string host_for_tls, std::string connect_addr, uint16_t port)
-+      : host_(std::move(host_for_tls)),
-+        connect_addr_(connect_addr.empty() ? host_ : std::move(connect_addr)),
-         port_(port),
-         fd_(-1),
-         ssl_ctx_(nullptr),
-@@ -181,6 +186,9 @@
-       buffer[i] = state.recv_buf.front();
-       state.recv_buf.pop_front();
-     }
-+    if (n > 0) {
-+      LOGI("read_stream stream_id=%" PRId64 " returning %zu bytes", (int64_t)stream_id, n);
-+    }
-     return (ssize_t)n;
-   }
- 
-@@ -223,6 +231,8 @@
-     std::lock_guard<std::mutex> lock(stream_mutex_);
-     StreamState &state = streams_[stream_id];
-     state.recv_buf.insert(state.recv_buf.end(), data, data + datalen);
-+    LOGI("recv stream data stream_id=%" PRId64 " len=%zu recv_buf_total=%zu",
-+         (int64_t)stream_id, datalen, state.recv_buf.size());
-     if (flags & NGTCP2_STREAM_DATA_FLAG_FIN) {
-       state.fin_received = true;
-     }
-@@ -254,7 +264,8 @@
- 
-     char port_str[16];
-     snprintf(port_str, sizeof(port_str), "%u", port_);
--    int rv = getaddrinfo(host_.c_str(), port_str, &hints, &res);
-+    const char *resolve_host = connect_addr_.empty() ? host_.c_str() : connect_addr_.c_str();
-+    int rv = getaddrinfo(resolve_host, port_str, &hints, &res);
-     if (rv != 0) {
-       setError(gai_strerror(rv));
-       return -1;
-@@ -269,6 +280,13 @@
-       if (::connect(fd, rp->ai_addr, rp->ai_addrlen) == 0) {
-         memcpy(&remote_addr_, rp->ai_addr, rp->ai_addrlen);
-         remote_addrlen_ = (socklen_t)rp->ai_addrlen;
-+        char buf[INET6_ADDRSTRLEN];
-+        const void *src = (rp->ai_family == AF_INET)
-+            ? (void *)&((struct sockaddr_in *)rp->ai_addr)->sin_addr
-+            : (void *)&((struct sockaddr_in6 *)rp->ai_addr)->sin6_addr;
-+        if (inet_ntop(rp->ai_family, src, buf, sizeof(buf))) {
-+          resolved_address_ = buf;
-+        }
-         break;
-       }
-       ::close(fd);
-@@ -651,30 +669,44 @@
-   }
- 
-   void cleanup() {
--    if (conn_) {
--      ngtcp2_conn_del(conn_);
-+    ngtcp2_conn *conn_to_del = nullptr;
-+    void *ssl_to_free = nullptr;
-+    void *ssl_ctx_to_free = nullptr;
-+    int fd_to_close = -1;
-+    int wake0 = -1, wake1 = -1;
-+    {
-+      std::lock_guard<std::mutex> lock(cleanup_mutex_);
-+      conn_to_del = conn_;
-       conn_ = nullptr;
--    }
--    if (ssl_) {
--      wolfSSL_free(ssl_);
-+      ssl_to_free = ssl_;
-       ssl_ = nullptr;
--    }
--    if (ssl_ctx_) {
--      wolfSSL_CTX_free(ssl_ctx_);
-+      ssl_ctx_to_free = ssl_ctx_;
-       ssl_ctx_ = nullptr;
--    }
--    if (fd_ != -1) {
--      ::close(fd_);
-+      fd_to_close = fd_;
-       fd_ = -1;
--    }
--    if (wakeup_fds_[0] != -1) {
--      ::close(wakeup_fds_[0]);
-+      wake0 = wakeup_fds_[0];
-+      wake1 = wakeup_fds_[1];
-       wakeup_fds_[0] = -1;
--    }
--    if (wakeup_fds_[1] != -1) {
--      ::close(wakeup_fds_[1]);
-       wakeup_fds_[1] = -1;
-     }
-+    if (conn_to_del) {
-+      ngtcp2_conn_del(conn_to_del);
-+    }
-+    if (ssl_to_free) {
-+      wolfSSL_free(static_cast<WOLFSSL *>(ssl_to_free));
-+    }
-+    if (ssl_ctx_to_free) {
-+      wolfSSL_CTX_free(static_cast<WOLFSSL_CTX *>(ssl_ctx_to_free));
-+    }
-+    if (fd_to_close != -1) {
-+      ::close(fd_to_close);
-+    }
-+    if (wake0 != -1) {
-+      ::close(wake0);
-+    }
-+    if (wake1 != -1) {
-+      ::close(wake1);
-+    }
-   }
- 
-   void clearError() {
-@@ -766,9 +798,14 @@
-     return client->on_handshake_completed();
-   }
- 
-+ public:
-+  const std::string &resolved_address() const { return resolved_address_; }
-+
-  private:
-   std::string host_;
-+  std::string connect_addr_;
-   uint16_t port_;
-+  std::string resolved_address_;
- 
-   int fd_;
-   struct sockaddr_storage remote_addr_;
-@@ -800,6 +837,8 @@
- 
-   mutable std::mutex err_mutex_;
-   std::string last_error_str_;
-+
-+  std::mutex cleanup_mutex_;
- };
- 
- static std::map<jlong, std::unique_ptr<QuicClient>> connections;
-@@ -827,6 +866,27 @@
-   return handle;
- }
- 
-+JNIEXPORT jlong JNICALL
-+Java_ai_annadata_mqttquic_quic_NGTCP2Client_nativeCreateConnectionWithAddress(
-+    JNIEnv *env, jobject thiz, jstring hostnameForTls, jstring connectAddress, jint port) {
-+  const char *tls_str = env->GetStringUTFChars(hostnameForTls, nullptr);
-+  const char *addr_str = env->GetStringUTFChars(connectAddress, nullptr);
-+  if (!tls_str || !addr_str) {
-+    if (tls_str) env->ReleaseStringUTFChars(hostnameForTls, tls_str);
-+    return 0;
-+  }
-+  std::string host_for_tls(tls_str);
-+  std::string connect_addr(addr_str);
-+  env->ReleaseStringUTFChars(hostnameForTls, tls_str);
-+  env->ReleaseStringUTFChars(connectAddress, addr_str);
-+
-+  auto client = std::make_unique<QuicClient>(host_for_tls, connect_addr, (uint16_t)port);
-+  std::lock_guard<std::mutex> lock(connections_mutex);
-+  jlong handle = next_handle++;
-+  connections[handle] = std::move(client);
-+  return handle;
-+}
-+
- JNIEXPORT jint JNICALL
- Java_ai_annadata_mqttquic_quic_NGTCP2Client_nativeConnect(
-     JNIEnv *env, jobject thiz, jlong connHandle) {
-@@ -929,6 +989,21 @@
-     return env->NewStringUTF("invalid connection");
-   }
-   return env->NewStringUTF(it->second->last_error());
-+}
-+
-+JNIEXPORT jstring JNICALL
-+Java_ai_annadata_mqttquic_quic_NGTCP2Client_nativeGetLastResolvedAddress(
-+    JNIEnv *env, jobject thiz, jlong connHandle) {
-+  std::lock_guard<std::mutex> lock(connections_mutex);
-+  auto it = connections.find(connHandle);
-+  if (it == connections.end()) {
-+    return nullptr;
-+  }
-+  const std::string &addr = it->second->resolved_address();
-+  if (addr.empty()) {
-+    return nullptr;
-+  }
-+  return env->NewStringUTF(addr.c_str());
- }
- 
- // Debug-build alias: Kotlin/AGP can mangle the method name to include the module suffix.
-diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/MqttQuicPlugin.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/MqttQuicPlugin.kt
---- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/MqttQuicPlugin.kt	2026-02-18 22:28:55
-+++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/MqttQuicPlugin.kt	2026-02-19 10:26:46
-@@ -13,10 +13,13 @@
- import android.util.Base64
- import kotlinx.coroutines.CoroutineScope
- import kotlinx.coroutines.Dispatchers
-+import kotlinx.coroutines.delay
- import kotlinx.coroutines.launch
-+import kotlinx.coroutines.withContext
- import java.nio.charset.StandardCharsets
- import java.io.File
- import java.io.IOException
-+import java.net.InetAddress
- 
- /**
-  * Capacitor plugin bridge. Phase 3: connect/publish/subscribe call into MQTTClient.
-@@ -27,6 +30,29 @@
-     private var client = MQTTClient(MQTTClient.ProtocolVersion.AUTO)
-     private val scope = CoroutineScope(Dispatchers.Main)
- 
-+    /** Last resolved IP per host (used when DNS fails on reconnect). */
-+    @Volatile
-+    private var lastResolvedHost: String? = null
-+    @Volatile
-+    private var lastResolvedIp: String? = null
-+
-+    /** Resolve hostname to IP for socket connect (avoids "No address" on reconnect). Returns null if resolution fails. */
-+    private fun resolveHostToIp(host: String): String? {
-+        return try {
-+            InetAddress.getAllByName(host).firstOrNull()?.hostAddress?.also { ip ->
-+                lastResolvedHost = host
-+                lastResolvedIp = ip
-+            }
-+        } catch (e: Exception) {
-+            null
-+        }
-+    }
-+
-+    /** Use cached IP for this host if fresh resolve failed (e.g. on reconnect). */
-+    private fun resolveOrCachedIp(host: String): String? {
-+        return resolveHostToIp(host) ?: if (host == lastResolvedHost) lastResolvedIp else null
-+    }
-+
-     private fun bundledCaFilePath(): String? {
-         return try {
-             val assetName = "mqttquic_ca.pem"
-@@ -100,9 +126,38 @@
-                         notifyListeners("message", data)
-                     }
-                 }
--                client.connect(host, port, clientId, username, password, cleanSession ?: true, keepalive ?: 20, sessionExpiryInterval)
--                call.resolve(JSObject().put("connected", true))
--                notifyListeners("connected", JSObject().put("connected", true))
-+                // Resolve host to IP on IO so native getaddrinfo gets an IP (avoids "No address associated with hostname" on reconnect)
-+                val noAddressMsg = "No address associated with hostname"
-+                var lastException: Exception? = null
-+                for (attempt in 1..2) {
-+                    try {
-+                        withContext(Dispatchers.IO) {
-+                            val resolvedIp = resolveOrCachedIp(host)
-+                            client.connect(host, port, clientId, username, password, cleanSession ?: true, keepalive ?: 20, sessionExpiryInterval, connectAddress = resolvedIp)
-+                        }
-+                        // Cache resolved IP from native so reconnect can use it when Java DNS fails
-+                        client.getLastResolvedAddress()?.let { ip ->
-+                            lastResolvedHost = host
-+                            lastResolvedIp = ip
-+                        }
-+                        call.resolve(JSObject().put("connected", true))
-+                        notifyListeners("connected", JSObject().put("connected", true))
-+                        return@launch
-+                    } catch (e: Exception) {
-+                        // Cache resolved IP from native even on failure (e.g. CONNACK timeout) so reconnect can use it
-+                        client.getLastResolvedAddress()?.let { ip ->
-+                            lastResolvedHost = host
-+                            lastResolvedIp = ip
-+                        }
-+                        lastException = e
-+                        if (attempt == 1 && e.message?.contains(noAddressMsg, ignoreCase = true) == true) {
-+                            delay(2000L)
-+                            continue
-+                        }
-+                        break
-+                    }
-+                }
-+                call.reject(lastException?.message ?: "Connection failed")
-             } catch (e: Exception) {
-                 call.reject(e.message ?: "Connection failed")
-             }
-diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/client/MQTTClient.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/client/MQTTClient.kt
---- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/client/MQTTClient.kt	2026-02-19 13:50:48
-+++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/client/MQTTClient.kt	2026-02-19 12:34:46
-@@ -1,5 +1,6 @@
- package ai.annadata.mqttquic.client
- 
-+import android.util.Log
- import ai.annadata.mqttquic.mqtt.MQTT5PropertyType
- import ai.annadata.mqttquic.mqtt.MQTTConnAckCode
- import ai.annadata.mqttquic.mqtt.MQTTMessageType
-@@ -15,6 +16,7 @@
- import ai.annadata.mqttquic.transport.MQTTStreamWriter
- import ai.annadata.mqttquic.transport.QUICStreamReader
- import ai.annadata.mqttquic.transport.QUICStreamWriter
-+import kotlinx.coroutines.CompletableDeferred
- import kotlinx.coroutines.CoroutineScope
- import kotlinx.coroutines.Dispatchers
- import kotlinx.coroutines.delay
-@@ -24,6 +26,9 @@
- import kotlinx.coroutines.sync.Mutex
- import kotlinx.coroutines.sync.withLock
- import kotlinx.coroutines.SupervisorJob
-+import kotlinx.coroutines.CancellationException
-+import kotlinx.coroutines.TimeoutCancellationException
-+import kotlinx.coroutines.withTimeout
- 
- /**
-  * High-level MQTT client: connect, publish, subscribe, disconnect.
-@@ -62,6 +67,10 @@
-     var onPublish: ((String, ByteArray) -> Unit)? = null
-     /** Per-connection Topic Alias map (alias -> topic name) for MQTT 5.0 incoming PUBLISH. */
-     private val topicAliasMap = mutableMapOf<Int, String>()
-+    /** Pending SUBACK by packet ID. Message loop completes with (fullPacket, hdrLen). Single reader: only message loop reads stream. */
-+    private val pendingSubacks = mutableMapOf<Int, CompletableDeferred<Pair<ByteArray, Int>>>()
-+    /** Pending UNSUBACK by packet ID. Message loop completes when UNSUBACK is read. */
-+    private val pendingUnsubacks = mutableMapOf<Int, CompletableDeferred<Unit>>()
-     private val lock = Mutex()
-     private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
- 
-@@ -77,6 +86,29 @@
-     /** Assigned Client Identifier from CONNACK when client sent empty ClientID; null otherwise. */
-     fun getAssignedClientIdentifier(): String? = runBlocking { lock.withLock { assignedClientIdentifier } }
- 
-+    /** Resolved IP used for the current/last QUIC connection (from native getaddrinfo). Used by plugin to cache for reconnect when Java DNS fails. */
-+    fun getLastResolvedAddress(): String? = (quicClient as? NGTCP2Client)?.getLastResolvedAddress()
-+
-+    /** Read full MQTT fixed header (1 byte type + 1–4 bytes remaining length per MQTT v5.0 §2.1.4). Returns (msgType, remLen, fixedHeaderBytes). */
-+    private suspend fun readFixedHeader(r: MQTTStreamReader): Triple<Byte, Int, ByteArray> {
-+        Log.i("MQTTClient", "readFixedHeader: requesting first byte")
-+        var fixed = r.readexactly(1).toMutableList()
-+        val firstByte = fixed[0].toInt() and 0xFF
-+        Log.i("MQTTClient", "readFixedHeader: got type byte 0x${Integer.toHexString(firstByte)} ($firstByte)")
-+        repeat(5) { // 1 type + up to 4 remaining-length bytes (Variable Byte Integer)
-+            try {
-+                val (rem, _) = MQTTProtocol.decodeRemainingLength(fixed.toByteArray(), 1)
-+                Log.i("MQTTClient", "readFixedHeader: decoded remLen=$rem fixedSize=${fixed.size}")
-+                return Triple(fixed[0], rem, fixed.toByteArray())
-+            } catch (_: IllegalArgumentException) {
-+                if (fixed.size > 5) throw IllegalArgumentException("Invalid remaining length")
-+                fixed.addAll(r.readexactly(1).toList())
-+                Log.i("MQTTClient", "readFixedHeader: added byte, fixedSize=${fixed.size}")
-+            }
-+        }
-+        throw IllegalArgumentException("Invalid remaining length")
-+    }
-+
-     suspend fun connect(
-         host: String,
-         port: Int,
-@@ -85,7 +117,8 @@
-         password: String?,
-         cleanSession: Boolean,
-         keepalive: Int,
--        sessionExpiryInterval: Int? = null
-+        sessionExpiryInterval: Int? = null,
-+        connectAddress: String? = null
-     ) {
-         lock.withLock {
-             if (state == State.CONNECTING) {
-@@ -109,7 +142,7 @@
-             } else {
-                 QuicClientStub(connack.toList())
-             }
--            quic.connect(host, port)
-+            quic.connect(host, port, connectAddress)
-             val s = quic.openStream()
-             val r = QUICStreamReader(s)
-             val w = QUICStreamWriter(s)
-@@ -146,50 +179,118 @@
-             w.write(connectData)
-             w.drain()
- 
--            // MQTT 5.0: server may send AUTH before CONNACK; loop until CONNACK
-+            // MQTT 5.0: server may send AUTH before CONNACK; loop until CONNACK. Timeout so we don't block 30s until ERR_IDLE_CLOSE.
-+            // Efficient path: drain stream (read until empty), then parse first complete packet; repeat until CONNACK or timeout.
-             var full: ByteArray
-             var hdrLen: Int
--            if (activeProtocolVersion == MQTTProtocolLevel.V5) {
--                while (true) {
--                    val fixed = r.readexactly(2)
--                    val (msgType, remLen, hLen) = MQTTProtocol.parseFixedHeader(fixed)
--                    val rest = r.readexactly(remLen)
--                    full = fixed + rest
--                    hdrLen = hLen
--                    when (msgType) {
--                        MQTTMessageType.CONNACK -> break
--                        MQTTMessageType.AUTH -> {
--                            lock.withLock { state = State.ERROR }
--                            try {
--                                w.write(MQTT5Protocol.buildDisconnectV5(MQTT5ReasonCode.BAD_AUTHENTICATION_METHOD_DISC))
--                                w.drain()
--                                w.close()
--                            } catch (_: Exception) { /* ignore */ }
--                            throw IllegalArgumentException("Enhanced authentication not supported")
-+            val connackTimeoutMs = 15_000L
-+            try {
-+                if (activeProtocolVersion == MQTTProtocolLevel.V5) {
-+                    Log.i("MQTTClient", "reading CONNACK (MQTT5) timeout=${connackTimeoutMs}ms (drain then parse)")
-+                    withTimeout(connackTimeoutMs) {
-+                        while (true) {
-+                            if (r is QUICStreamReader) {
-+                                r.drain()
-+                                val avail = r.available()
-+                                Log.i("MQTTClient", "CONNACK loop: after drain available=$avail")
-+                                val packet = r.tryConsumeNextPacket()
-+                                if (packet != null) {
-+                                    val (msgType, _, fixedLen) = MQTTProtocol.parseFixedHeader(packet.copyOf(minOf(5, packet.size)))
-+                                    val typeByte = msgType.toInt() and 0xFF
-+                                    Log.i("MQTTClient", "CONNACK loop: packet type=0x${Integer.toHexString(typeByte)} len=${packet.size} hdrLen=$fixedLen")
-+                                    when (typeByte) {
-+                                        0x20 -> {
-+                                            full = packet
-+                                            hdrLen = fixedLen
-+                                            return@withTimeout
-+                                        }
-+                                        0xF0 -> {
-+                                            lock.withLock { state = State.ERROR }
-+                                            try {
-+                                                w.write(MQTT5Protocol.buildDisconnectV5(MQTT5ReasonCode.BAD_AUTHENTICATION_METHOD_DISC))
-+                                                w.drain()
-+                                                w.close()
-+                                            } catch (_: Exception) { /* ignore */ }
-+                                            throw IllegalArgumentException("Enhanced authentication not supported")
-+                                        }
-+                                        0xE0 -> {
-+                                            lock.withLock { state = State.ERROR }
-+                                            throw IllegalArgumentException("Server sent DISCONNECT before CONNACK")
-+                                        }
-+                                        else -> Log.i("MQTTClient", "CONNACK loop: skipping non-CONNACK packet type=0x${Integer.toHexString(typeByte)}")
-+                                    }
-+                                } else {
-+                                    // Only delay when no data; if we have data but no packet, retry soon (avoid suspend then timeout before next iteration)
-+                                    if (avail == 0) delay(50) else delay(10)
-+                                }
-+                            } else {
-+                                // Fallback for non-QUIC reader (e.g. mock)
-+                                val (msgType, remLen, fixed) = readFixedHeader(r)
-+                                val typeByte = fixed[0].toInt() and 0xFF
-+                                val rest = r.readexactly(remLen)
-+                                full = fixed + rest
-+                                hdrLen = fixed.size
-+                                when (typeByte) {
-+                                    0x20 -> return@withTimeout
-+                                    0xF0 -> {
-+                                        lock.withLock { state = State.ERROR }
-+                                        try {
-+                                            w.write(MQTT5Protocol.buildDisconnectV5(MQTT5ReasonCode.BAD_AUTHENTICATION_METHOD_DISC))
-+                                            w.drain()
-+                                            w.close()
-+                                        } catch (_: Exception) { /* ignore */ }
-+                                        throw IllegalArgumentException("Enhanced authentication not supported")
-+                                    }
-+                                    0xE0 -> {
-+                                        lock.withLock { state = State.ERROR }
-+                                        throw IllegalArgumentException("Server sent DISCONNECT before CONNACK")
-+                                    }
-+                                    else -> { /* skip; continue */ }
-+                                }
-+                            }
-                         }
--                        MQTTMessageType.DISCONNECT -> {
--                            lock.withLock { state = State.ERROR }
--                            throw IllegalArgumentException("Server sent DISCONNECT before CONNACK")
-+                    }
-+                    Log.i("MQTTClient", "got CONNACK (MQTT5) (fullLen=${full.size} hdrLen=$hdrLen)")
-+                } else {
-+                    Log.i("MQTTClient", "reading CONNACK (3.1.1) timeout=${connackTimeoutMs}ms")
-+                    withTimeout(connackTimeoutMs) {
-+                        if (r is QUICStreamReader) {
-+                            while (true) {
-+                                r.drain()
-+                                val packet = r.tryConsumeNextPacket()
-+                                if (packet != null) {
-+                                    val (msgType, _, fixedLen) = MQTTProtocol.parseFixedHeader(packet.copyOf(minOf(5, packet.size)))
-+                                    if (msgType == MQTTMessageType.CONNACK) {
-+                                        full = packet
-+                                        hdrLen = fixedLen
-+                                        break
-+                                    }
-+                                    lock.withLock { state = State.ERROR }
-+                                    throw IllegalArgumentException("expected CONNACK, got $msgType")
-+                                }
-+                                delay(50)
-+                            }
-+                        } else {
-+                            val (msgType, remLen, fixed) = readFixedHeader(r)
-+                            val rest = r.readexactly(remLen)
-+                            full = fixed + rest
-+                            hdrLen = fixed.size
-+                            if (msgType != MQTTMessageType.CONNACK) {
-+                                lock.withLock { state = State.ERROR }
-+                                throw IllegalArgumentException("expected CONNACK, got $msgType")
-+                            }
-                         }
--                        else -> {
--                            lock.withLock { state = State.ERROR }
--                            throw IllegalArgumentException("Expected CONNACK or AUTH, got $msgType")
--                        }
-+                        Log.i("MQTTClient", "got CONNACK (3.1.1)")
-                     }
-                 }
--            } else {
--                val fixed = r.readexactly(2)
--                val (msgType, remLen, hLen) = MQTTProtocol.parseFixedHeader(fixed)
--                val rest = r.readexactly(remLen)
--                full = fixed + rest
--                hdrLen = hLen
--                if (msgType != MQTTMessageType.CONNACK) {
--                    lock.withLock { state = State.ERROR }
--                    throw IllegalArgumentException("expected CONNACK, got $msgType")
--                }
-+            } catch (e: TimeoutCancellationException) {
-+                lock.withLock { state = State.ERROR }
-+                Log.w("MQTTClient", "CONNACK read timed out after ${connackTimeoutMs}ms", e)
-+                throw IllegalStateException("CONNACK read timed out. Drain+parse did not receive a complete CONNACK in time. Ask server to send full CONNACK (loop writev_stream until all bytes sent); or check network.", e)
-             }
- 
-             if (activeProtocolVersion == MQTTProtocolLevel.V5) {
-+                Log.i("MQTTClient", "parsing CONNACK v5 (offset=$hdrLen)")
-                 val (_, reasonCode, props) = MQTT5Protocol.parseConnackV5(full, hdrLen)
-                 if (reasonCode != MQTT5ReasonCode.SUCCESS) {
-                     lock.withLock { state = State.ERROR }
-@@ -210,21 +311,37 @@
-             }
- 
-             lock.withLock { state = State.CONNECTED }
-+            Log.i("MQTTClient", "state=CONNECTED, starting message and keepalive loops")
-             startMessageLoop()
-             startKeepaliveLoop()
-         } catch (e: Exception) {
--            val wr = lock.withLock {
-+            val (wr, quic) = lock.withLock {
-                 val w = writer
-+                val q = quicClient
-                 quicClient = null
-                 stream = null
-                 reader = null
-                 writer = null
-                 state = State.ERROR
--                w
-+                Pair(w, q)
-             }
-             try {
-                 wr?.close()
-             } catch (_: Exception) { /* ignore */ }
-+            // Skip quic.close() on timeout/cancellation: server may have already sent idle close, and native close() can crash. Prefer leak over crash.
-+            val isTimeoutOrCancel = e is TimeoutCancellationException ||
-+                e is CancellationException ||
-+                e.cause is TimeoutCancellationException ||
-+                (e.message?.contains("Timed out", ignoreCase = true) == true)
-+            if (!isTimeoutOrCancel) {
-+                try {
-+                    quic?.close()
-+                } catch (ex: Exception) {
-+                    Log.w("MQTTClient", "Error closing QUIC connection on connect failure", ex)
-+                }
-+            } else {
-+                Log.i("MQTTClient", "Skipping quic.close() on timeout/cancellation to avoid native crash")
-+            }
-             throw e
-         }
-     }
-@@ -260,59 +377,66 @@
- 
-     suspend fun subscribe(topic: String, qos: Int, subscriptionIdentifier: Int? = null) {
-         if (getState() != State.CONNECTED) throw IllegalStateException("not connected")
--        val (r, w, version) = lock.withLock { Triple(reader, writer, activeProtocolVersion) }
--        if (r == null || w == null) throw IllegalStateException("no reader/writer")
-+        val (w, version) = lock.withLock { writer to activeProtocolVersion }
-+        if (w == null) throw IllegalStateException("no writer")
- 
-         val pid = nextPacketIdUsed()
--        val data: ByteArray
--        if (version == MQTTProtocolLevel.V5) {
--            data = MQTT5Protocol.buildSubscribeV5(pid, topic, qos, subscriptionIdentifier)
--        } else {
--            data = MQTTProtocol.buildSubscribe(pid, topic, qos)
--        }
--        w.write(data)
--        w.drain()
-+        val deferred = CompletableDeferred<Pair<ByteArray, Int>>()
-+        lock.withLock { pendingSubacks[pid] = deferred }
-+        try {
-+            val data: ByteArray
-+            if (version == MQTTProtocolLevel.V5) {
-+                data = MQTT5Protocol.buildSubscribeV5(pid, topic, qos, subscriptionIdentifier)
-+            } else {
-+                data = MQTTProtocol.buildSubscribe(pid, topic, qos)
-+            }
-+            w.write(data)
-+            w.drain()
- 
--        val fixed = r.readexactly(2)
--        val (_, remLen, hdrLen) = MQTTProtocol.parseFixedHeader(fixed)
--        val rest = r.readexactly(remLen)
--        val full = fixed + rest
--        
--        if (version == MQTTProtocolLevel.V5) {
--            val (_, reasonCodes, _) = MQTT5Protocol.parseSubackV5(full, hdrLen)
--            if (reasonCodes.isNotEmpty()) {
--                val firstRC = reasonCodes[0]
--                if (firstRC != MQTT5ReasonCode.GRANTED_QOS_0 && firstRC != MQTT5ReasonCode.GRANTED_QOS_1 && firstRC != MQTT5ReasonCode.GRANTED_QOS_2) {
--                    throw IllegalArgumentException("SUBACK error $firstRC")
-+            val (full, hdrLen) = withTimeout(15_000L) { deferred.await() }
-+
-+            if (version == MQTTProtocolLevel.V5) {
-+                val (_, reasonCodes, _) = MQTT5Protocol.parseSubackV5(full, hdrLen)
-+                if (reasonCodes.isNotEmpty()) {
-+                    val firstRC = reasonCodes[0]
-+                    if (firstRC != MQTT5ReasonCode.GRANTED_QOS_0 && firstRC != MQTT5ReasonCode.GRANTED_QOS_1 && firstRC != MQTT5ReasonCode.GRANTED_QOS_2) {
-+                        throw IllegalArgumentException("SUBACK error $firstRC")
-+                    }
-                 }
-+            } else {
-+                val (_, rc, _) = MQTTProtocol.parseSuback(full, hdrLen)
-+                if (rc > 0x02) throw IllegalArgumentException("SUBACK error $rc")
-             }
--        } else {
--            val (_, rc, _) = MQTTProtocol.parseSuback(full, hdrLen)
--            if (rc > 0x02) throw IllegalArgumentException("SUBACK error $rc")
-+        } finally {
-+            lock.withLock { pendingSubacks.remove(pid) }
-         }
-     }
- 
-     suspend fun unsubscribe(topic: String) {
-         if (getState() != State.CONNECTED) throw IllegalStateException("not connected")
--        val (r, w, version) = lock.withLock {
-+        val (w, version) = lock.withLock {
-             subscribedTopics.remove(topic)
--            Triple(reader, writer, activeProtocolVersion)
-+            writer to activeProtocolVersion
-         }
--        if (r == null || w == null) throw IllegalStateException("no reader/writer")
-+        if (w == null) throw IllegalStateException("no writer")
- 
-         val pid = nextPacketIdUsed()
--        val data: ByteArray
--        if (version == MQTTProtocolLevel.V5) {
--            data = MQTT5Protocol.buildUnsubscribeV5(pid, listOf(topic))
--        } else {
--            data = MQTTProtocol.buildUnsubscribe(pid, listOf(topic))
--        }
--        w.write(data)
--        w.drain()
-+        val deferred = CompletableDeferred<Unit>()
-+        lock.withLock { pendingUnsubacks[pid] = deferred }
-+        try {
-+            val data: ByteArray
-+            if (version == MQTTProtocolLevel.V5) {
-+                data = MQTT5Protocol.buildUnsubscribeV5(pid, listOf(topic))
-+            } else {
-+                data = MQTTProtocol.buildUnsubscribe(pid, listOf(topic))
-+            }
-+            w.write(data)
-+            w.drain()
- 
--        val fixed = r.readexactly(2)
--        val (_, remLen, _) = MQTTProtocol.parseFixedHeader(fixed)
--        r.readexactly(remLen)
-+            withTimeout(15_000L) { deferred.await() }
-+        } finally {
-+            lock.withLock { pendingUnsubacks.remove(pid) }
-+        }
-     }
- 
-     suspend fun disconnect() {
-@@ -323,6 +447,8 @@
-         job?.cancel()
-         job?.join()
- 
-+        failPendingSubacksUnsubacks(IllegalStateException("Disconnected"))
-+
-         val (w, version) = lock.withLock {
-             val wr = writer
-             val v = activeProtocolVersion
-@@ -369,6 +495,15 @@
-         pid
-     }
- 
-+    private suspend fun failPendingSubacksUnsubacks(cause: Throwable) {
-+        lock.withLock {
-+            pendingSubacks.values.forEach { it.completeExceptionally(cause) }
-+            pendingSubacks.clear()
-+            pendingUnsubacks.values.forEach { it.completeExceptionally(cause) }
-+            pendingUnsubacks.clear()
-+        }
-+    }
-+
-     /** Send PINGREQ at effectiveKeepalive interval so server sees activity and does not close (idle/keepalive). [MQTT-3.1.2-20] */
-     private fun startKeepaliveLoop() {
-         keepaliveJob?.cancel()
-@@ -394,11 +529,24 @@
-             while (isActive) {
-                 val r = lock.withLock { reader } ?: break
-                 try {
--                    val fixed = r.readexactly(2)
--                    val (msgType, remLen, _) = MQTTProtocol.parseFixedHeader(fixed)
-+                    val (msgType, remLen, fixed) = readFixedHeader(r)
-                     val rest = r.readexactly(remLen)
-                     val type = (msgType.toInt() and 0xF0).toByte()
-                     when (type) {
-+                        MQTTMessageType.SUBACK -> {
-+                            if (rest.size >= 2) {
-+                                val pid = ((rest[0].toInt() and 0xFF) shl 8) or (rest[1].toInt() and 0xFF)
-+                                val full = fixed + rest
-+                                val hdrLen = fixed.size
-+                                lock.withLock { pendingSubacks.remove(pid)?.complete(Pair(full, hdrLen)) }
-+                            }
-+                        }
-+                        MQTTMessageType.UNSUBACK -> {
-+                            if (rest.size >= 2) {
-+                                val pid = ((rest[0].toInt() and 0xFF) shl 8) or (rest[1].toInt() and 0xFF)
-+                                lock.withLock { pendingUnsubacks.remove(pid)?.complete(Unit) }
-+                            }
-+                        }
-                         MQTTMessageType.DISCONNECT -> {
-                             val reasonCode = if (rest.isNotEmpty()) rest[0].toInt() and 0xFF else 0x00
-                             lock.withLock {
-@@ -412,6 +560,7 @@
-                                 topicAliasMap.clear()
-                                 state = if (reasonCode >= 0x80) State.ERROR else State.DISCONNECTED
-                             }
-+                            failPendingSubacksUnsubacks(IllegalStateException("Server sent DISCONNECT"))
-                             break
-                         }
-                         MQTTMessageType.PINGREQ -> {
-@@ -473,6 +622,7 @@
-                             topicAliasMap.clear()
-                             state = State.DISCONNECTED
-                         }
-+                        failPendingSubacksUnsubacks(e)
-                     }
-                     break
-                 }
-diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/mqtt/MQTTProtocol.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/mqtt/MQTTProtocol.kt
---- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/mqtt/MQTTProtocol.kt	2026-02-19 13:50:43
-+++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/mqtt/MQTTProtocol.kt	2026-02-19 13:05:52
-@@ -40,10 +40,10 @@
-             val b = data[i].toInt() and 0xFF
-             len += (b and 0x7F) * mul
-             i++
--            if ((b and 0x80) == 0) return@repeat
-+            if ((b and 0x80) == 0) return len to (i - offset)
-             mul *= 128
-         }
--        return len to (i - offset)
-+        throw IllegalArgumentException("Invalid remaining length (max 4 bytes)")
-     }
- 
-     fun encodeString(s: String): ByteArray {
-@@ -73,6 +73,37 @@
-         val msgType = data[0]
-         val (rem, consumed) = decodeRemainingLength(data, 1)
-         return Triple(msgType, rem, 1 + consumed)
-+    }
-+
-+    /**
-+     * Returns total MQTT packet length (fixed header + payload) if buffer has at least a decodable fixed header, else null.
-+     * Use when draining stream: accumulate bytes, then call this; when buffer.size >= length, you have a complete packet.
-+     */
-+    fun getNextPacketLength(buffer: ByteArray): Int? {
-+        if (buffer.size < 2) return null
-+        // CONNACK (0x20): often single-byte remaining length (e.g. 0x20 = 32 → total 34). Handle that first.
-+        if (buffer[0].toInt() and 0xFF == 0x20) {
-+            val b1 = buffer[1].toInt() and 0xFF
-+            if ((b1 and 0x80) == 0) {
-+                val rem = b1
-+                val total = 1 + 1 + rem
-+                if (total <= buffer.size) return total
-+            } else {
-+                try {
-+                    val (rem, consumed) = decodeRemainingLength(buffer, 1)
-+                    val total = 1 + consumed + rem
-+                    if (total <= buffer.size) return total
-+                } catch (_: IllegalArgumentException) { /* fall through */ }
-+            }
-+        }
-+        for (len in minOf(5, buffer.size) downTo 2) {
-+            try {
-+                val (_, rem, fixedLen) = parseFixedHeader(buffer.copyOf(len))
-+                val total = fixedLen + rem
-+                if (total in 1..buffer.size) return total
-+            } catch (_: IllegalArgumentException) { /* need more bytes for remaining length */ }
-+        }
-+        return null
-     }
- 
-     fun buildConnect(
-diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/NGTCP2Client.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/NGTCP2Client.kt
---- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/NGTCP2Client.kt	2026-02-19 13:50:50
-+++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/NGTCP2Client.kt	2026-02-19 12:10:12
-@@ -40,22 +40,28 @@
-     
-     // Native methods (implemented in ngtcp2_jni.cpp)
-     private external fun nativeCreateConnection(host: String, port: Int): Long
-+    private external fun nativeCreateConnectionWithAddress(hostnameForTls: String, connectAddress: String, port: Int): Long
-     private external fun nativeConnect(connHandle: Long): Int
-     private external fun nativeOpenStream(connHandle: Long): Long
-     private external fun nativeWriteStream(connHandle: Long, streamId: Long, data: ByteArray): Int
-     private external fun nativeReadStream(connHandle: Long, streamId: Long): ByteArray?
-     private external fun nativeClose(connHandle: Long)
-     private external fun nativeIsConnected(connHandle: Long): Boolean
--    internal external fun nativeCloseStream(connHandle: Long, streamId: Long): Int
-+    // Public to avoid Kotlin internal-name mangling (nativeCloseStream$module) which breaks JNI lookup
-+    external fun nativeCloseStream(connHandle: Long, streamId: Long): Int
-     @JvmName("nativeGetLastError")
--    internal external fun nativeGetLastError(connHandle: Long): String
--    
-+    external fun nativeGetLastError(connHandle: Long): String
-+    private external fun nativeGetLastResolvedAddress(connHandle: Long): String?
-+
-+    /** Resolved IP used for this connection (set after init_socket in native). Use for reconnect cache when Java DNS fails. */
-+    fun getLastResolvedAddress(): String? = if (connHandle != 0L) nativeGetLastResolvedAddress(connHandle) else null
-+
-     // Connection state
-     private var connHandle: Long = 0
-     private var isConnected: Boolean = false
-     private val streams = mutableMapOf<Long, NGTCP2Stream>()
-     
--    override suspend fun connect(host: String, port: Int) {
-+    override suspend fun connect(host: String, port: Int, connectAddress: String?) {
-         if (!isAvailable()) {
-             throw IllegalStateException("ngtcp2 native library is not loaded")
-         }
-@@ -63,8 +69,12 @@
-             throw IllegalStateException("Already connected")
-         }
-         
--        // Create native connection
--        connHandle = nativeCreateConnection(host, port)
-+        // Create native connection (use pre-resolved IP when given to avoid "No address" on reconnect)
-+        connHandle = if (!connectAddress.isNullOrBlank()) {
-+            nativeCreateConnectionWithAddress(host, connectAddress, port)
-+        } else {
-+            nativeCreateConnection(host, port)
-+        }
-         if (connHandle == 0L) {
-             throw IllegalStateException("Failed to create QUIC connection")
-         }
-@@ -147,19 +157,19 @@
-     
-     private var isClosed: Boolean = false
-     
-+    /**
-+     * Read up to maxBytes from the stream. Returns immediately with whatever is
-+     * currently available (possibly empty). This allows drain()-then-parse logic
-+     * to complete: first read returns CONNACK bytes, second read returns empty
-+     * so drain() breaks and tryConsumeNextPacket() can run. Never blocks waiting
-+     * for more data (native recv_buf is already populated by the event loop).
-+     */
-     override suspend fun read(maxBytes: Int): ByteArray {
-         if (isClosed) {
-             throw IllegalStateException("Stream is closed")
-         }
--
--        while (!isClosed) {
--            val data = client.readStreamData(streamId)
--            if (data != null && data.isNotEmpty()) {
--                return data
--            }
--            delay(5)
--        }
--        return ByteArray(0)
-+        val data = client.readStreamData(streamId) ?: return ByteArray(0)
-+        return data
-     }
-     
-     override suspend fun write(data: ByteArray) {
-diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicClientStub.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicClientStub.kt
---- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicClientStub.kt	2026-02-18 22:28:55
-+++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicClientStub.kt	2026-02-19 10:19:11
-@@ -36,7 +36,7 @@
-     private var buffer: MockStreamBuffer? = null
-     private var streamId = 0L
- 
--    override suspend fun connect(host: String, port: Int) {
-+    override suspend fun connect(host: String, port: Int, connectAddress: String?) {
-         buffer = MockStreamBuffer(initialReadData.toByteArray())
-         streamId = 0L
-     }
-diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicTypes.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicTypes.kt
---- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicTypes.kt	2026-02-18 22:28:55
-+++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/quic/QuicTypes.kt	2026-02-19 10:16:31
-@@ -15,7 +15,7 @@
-  * QUIC client: connect, TLS handshake, open one bidirectional stream.
-  */
- interface QuicClient {
--    suspend fun connect(host: String, port: Int)
-+    suspend fun connect(host: String, port: Int, connectAddress: String? = null)
-     suspend fun openStream(): QuicStream
-     suspend fun close()
- }
-diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/QUICStreamAdapter.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/QUICStreamAdapter.kt
---- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/QUICStreamAdapter.kt	2026-02-19 13:50:41
-+++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/QUICStreamAdapter.kt	2026-02-19 12:21:15
-@@ -1,21 +1,96 @@
- package ai.annadata.mqttquic.transport
- 
-+import android.util.Log
-+import ai.annadata.mqttquic.mqtt.MQTTProtocol
- import ai.annadata.mqttquic.quic.QuicStream
-+import kotlinx.coroutines.delay
- 
- /**
-- * MQTTStreamReader over QUIC stream. Mirrors NGTCP2StreamReader.
-+ * MQTTStreamReader over QUIC stream. Buffers excess bytes so readexactly(n)
-+ * and read(maxBytes) get exactly the requested amount; native may return
-+ * a full CONNACK (e.g. 18 bytes) in one read, so we must not lose the remainder.
-+ *
-+ * Efficient CONNACK/packet read: call [drain] to read until the stream has no more
-+ * data, then [tryConsumeNextPacket] to take the first complete MQTT packet from
-+ * the buffer. Repeat drain + tryConsumeNextPacket (with short delay) until you
-+ * get a packet or timeout.
-  */
- class QUICStreamReader(private val stream: QuicStream) : MQTTStreamReader {
- 
--    override suspend fun read(maxBytes: Int): ByteArray = stream.read(maxBytes)
-+    private val buffer = mutableListOf<Byte>()
- 
-+    override suspend fun available(): Int = buffer.size
-+
-+    /** Read from stream until no more data is available (drained). Call before tryConsumeNextPacket. */
-+    suspend fun drain() {
-+        while (true) {
-+            val chunk = stream.read(8192)
-+            if (chunk.isEmpty()) break
-+            Log.i("MQTTClient", "QUICStreamReader: drain got ${chunk.size} bytes bufferTotal=${buffer.size + chunk.size}")
-+            buffer.addAll(chunk.toList())
-+        }
-+    }
-+
-+    /** Consume the first n bytes from buffer and return them. Caller must ensure buffer.size >= n. */
-+    fun consume(n: Int): ByteArray {
-+        if (buffer.size < n) throw IllegalArgumentException("buffer has ${buffer.size} < $n")
-+        val out = buffer.take(n).toByteArray()
-+        repeat(n) { buffer.removeAt(0) }
-+        return out
-+    }
-+
-+    /**
-+     * If buffer contains at least one complete MQTT packet (fixed header + payload), consume and return it; else return null.
-+     * Call after [drain]; if null, delay and drain again (or timeout).
-+     */
-+    fun tryConsumeNextPacket(): ByteArray? {
-+        val buf = buffer.toByteArray()
-+        val totalLen = MQTTProtocol.getNextPacketLength(buf)
-+        if (totalLen == null) {
-+            if (buf.isNotEmpty()) {
-+                Log.w("MQTTClient", "QUICStreamReader: getNextPacketLength returned null bufferSize=${buf.size} firstByte=0x${Integer.toHexString(buf[0].toInt() and 0xFF)}")
-+            }
-+            return null
-+        }
-+        if (buffer.size < totalLen) {
-+            Log.i("MQTTClient", "QUICStreamReader: buffer.size=${buffer.size} < totalLen=$totalLen waiting for more")
-+            return null
-+        }
-+        val packet = consume(totalLen)
-+        Log.i("MQTTClient", "QUICStreamReader: tryConsumeNextPacket consumed $totalLen bytes type=0x${Integer.toHexString(packet[0].toInt() and 0xFF)}")
-+        return packet
-+    }
-+
-+    override suspend fun read(maxBytes: Int): ByteArray {
-+        while (buffer.size < maxBytes) {
-+            val chunk = stream.read(maxBytes - buffer.size)
-+            if (chunk.isEmpty()) break
-+            Log.i("MQTTClient", "QUICStreamReader: got chunk=${chunk.size} bufferSize=${buffer.size + chunk.size}")
-+            buffer.addAll(chunk.toList())
-+        }
-+        val n = minOf(maxBytes, buffer.size)
-+        if (n == 0) return ByteArray(0)
-+        val result = buffer.subList(0, n).toByteArray()
-+        repeat(n) { buffer.removeAt(0) }
-+        Log.i("MQTTClient", "QUICStreamReader: returning $n bytes bufferRemain=${buffer.size}")
-+        return result
-+    }
-+
-     override suspend fun readexactly(n: Int): ByteArray {
-+        Log.i("MQTTClient", "QUICStreamReader: readexactly($n) bufferHas=${buffer.size}")
-         val acc = mutableListOf<Byte>()
-         while (acc.size < n) {
--            val chunk = stream.read(n - acc.size)
--            if (chunk.isEmpty()) throw IllegalArgumentException("readexactly")
--            acc.addAll(chunk.toList())
-+            drain()
-+            val fromBuffer = minOf(n - acc.size, buffer.size)
-+            if (fromBuffer > 0) {
-+                acc.addAll(buffer.subList(0, fromBuffer).toList())
-+                repeat(fromBuffer) { buffer.removeAt(0) }
-+            } else {
-+                // No data yet (e.g. message loop waiting for SUBACK/PUBLISH). Wait and retry instead of throwing.
-+                delay(20L)
-+            }
-         }
-+        Log.i("MQTTClient", "QUICStreamReader: readexactly($n) done")
-         return acc.toByteArray()
-     }
- }
-diff -Naur capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/StreamTransport.kt annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/StreamTransport.kt
---- capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/StreamTransport.kt	2026-02-18 22:28:55
-+++ annadata-app/node_modules/@annadata/capacitor-mqtt-quic/android/src/main/kotlin/ai/annadata/mqttquic/transport/StreamTransport.kt	2026-02-19 08:09:34
-@@ -7,6 +7,8 @@
-  * Phase 2 implements over QUIC stream.
-  */
- interface MQTTStreamReader {
-+    /** Number of bytes currently buffered (without reading from stream). Used to skip unwanted packets only when safe. */
-+    suspend fun available(): Int
-     suspend fun read(maxBytes: Int): ByteArray
-     suspend fun readexactly(n: Int): ByteArray
- }
-@@ -49,6 +51,8 @@
-  * Mock reader over MockStreamBuffer.
-  */
- class MockStreamReader(private val buffer: MockStreamBuffer) : MQTTStreamReader {
-+
-+    override suspend fun available(): Int = buffer.readBuffer.size
- 
-     override suspend fun read(maxBytes: Int): ByteArray {
-         if (buffer.isClosed && buffer.readBuffer.isEmpty()) return ByteArray(0)