@annadata/capacitor-mqtt-quic 0.2.2 → 0.2.4

package/dist/esm/web.js

@@ -1,11 +1,47 @@
 import { WebPlugin } from '@capacitor/core';
 import mqtt from 'mqtt';
-import * as mqttPacket from 'mqtt-packet';
+import { MqttParser, buildConnect, buildDisconnect, buildPingreq, buildPublish, buildSubscribe, buildUnsubscribe, } from './webMqttCodec';
+const TAG = '[mqtt-quic-web]';
+/**
+ * Verbose WebTransport tracing (numbered connect steps, CONNECT hex dump,
+ * READ byte counts, parser packet types, publish/subscribe ops). Default: ON.
+ *
+ * To silence the trace while keeping error logs:
+ *   `globalThis.MQTT_QUIC_WT_DEBUG = false;`
+ *
+ * Errors are always logged regardless of this flag.
+ */
+function isWtDebugEnabled() {
+    try {
+        return globalThis.MQTT_QUIC_WT_DEBUG !== false;
+    }
+    catch (_a) {
+        return true;
+    }
+}
+function dlog(...args) {
+    if (!isWtDebugEnabled())
+        return;
+    // eslint-disable-next-line no-console
+    console.log(TAG, ...args);
+}
+function elog(...args) {
+    // eslint-disable-next-line no-console
+    console.error(TAG, ...args);
+}
+function hexHead(u, n = 32) {
+    return Array.from(u.subarray(0, Math.min(n, u.length)))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join(' ');
+}
 /**
  * Web / browser implementation: MQTT over WebSocket (WSS) or over WebTransport (QUIC).
  * Browsers cannot run ngtcp2/WolfSSL (no UDP). Same API as iOS/Android.
  * - Default: WSS via mqtt.js.
  * - Optional: pass webTransportUrl to use the browser's QUIC (HTTP/3) via WebTransport.
+ *
+ * The WebTransport path uses an internal hand-rolled MQTT 3.1.1/5.0 codec
+ * (`./webMqttCodec`) so it has zero Node `Buffer` / `mqtt-packet` dependency.
  */
 export class MqttQuicWeb extends WebPlugin {
     constructor() {
@@ -14,24 +50,43 @@ export class MqttQuicWeb extends WebPlugin {
         this.protocol = 'wss';
         this.wt = null;
         this.wtWriter = null;
-        this.wtReadAbort = null;
         this.wtParser = null;
-        this.wtReadBuffer = [];
+        this.wtLevel = 5;
         this.wtNextMessageId = 1;
         this.wtConnackResolve = null;
+        this.wtConnackReject = null;
         this.wtPendingSuback = new Map();
         this.wtPendingUnsuback = new Map();
         this.wtConnected = false;
+        /**
+         * Single in-flight PINGREQ. MQTT mandates at most one outstanding PINGREQ;
+         * concurrent `sendKeepalive` calls share this promise.
+         */
+        this.wtPendingPing = null;
+        /** Background auto-keepalive timer chain (recursive setTimeout). */
+        this.wtKeepaliveTimer = null;
+        this.wtKeepaliveSeconds = 0;
     }
     /** Web: no UDP; resolves ok if host looks valid. Native uses UDP reachability check. */
     async ping(_options) {
         return Promise.resolve({ ok: true });
     }
-    /** Web: mqtt.js/WT handle keepalive; return ok if connected. */
-    async sendKeepalive(_options) {
-        var _a, _b;
-        const connected = (_b = (_a = this.client) === null || _a === void 0 ? void 0 : _a.connected) !== null && _b !== void 0 ? _b : this.wtConnected;
-        return Promise.resolve({ ok: !!connected });
+    /**
+     * Send a real PINGREQ and wait for PINGRESP.
+     * - WebTransport: writes a PINGREQ packet via the codec and resolves when the
+     *   broker's PINGRESP arrives, or `{ ok: false }` after `timeoutMs`.
+     * - WSS (`mqtt.js`): the underlying client runs its own keepalive timer, so
+     *   we just report whether the socket is currently connected.
+     */
+    async sendKeepalive(options) {
+        var _a;
+        if (this.wtConnected && this.wtWriter) {
+            const t = options === null || options === void 0 ? void 0 : options.timeoutMs;
+            const timeoutMs = Math.min(15000, Math.max(1000, t !== null && t !== void 0 ? t : 5000));
+            const ok = await this.wtSendPingreq(timeoutMs);
+            return { ok };
+        }
+        return { ok: !!((_a = this.client) === null || _a === void 0 ? void 0 : _a.connected) };
     }
     async connect(options) {
         if (options.webTransportUrl && typeof WebTransport !== 'undefined') {
@@ -55,113 +110,318 @@ export class MqttQuicWeb extends WebPlugin {
         }
         return base;
     }
+    resolveLevel(options) {
+        var _a;
+        const pv = (_a = options.protocolVersion) !== null && _a !== void 0 ? _a : 'auto';
+        if (pv === '3.1.1')
+            return 4;
+        return 5; // '5.0' or 'auto'
+    }
     async connectWebTransport(options) {
-        var _a, _b, _c;
-        if (this.wtConnected && this.wt) {
-            return { connected: true };
-        }
-        const url = this.getWebTransportUrl(options);
-        const transport = new WebTransport(url);
-        await transport.ready;
-        const stream = await transport.createBidirectionalStream();
-        this.wt = transport;
-        this.wtWriter = stream.writable.getWriter();
-        this.wtReadAbort = new AbortController();
-        this.wtParser = mqttPacket.parser();
-        this.wtReadBuffer = [];
-        this.wtNextMessageId = 1;
-        this.wtPendingSuback.clear();
-        this.wtPendingUnsuback.clear();
-        let connackTimer = null;
-        const connackPromise = new Promise((resolve, reject) => {
-            this.wtConnackResolve = () => {
-                if (connackTimer)
-                    clearTimeout(connackTimer);
-                resolve();
-            };
-            connackTimer = setTimeout(() => {
-                connackTimer = null;
-                this.wtConnackResolve = null;
-                reject(new Error('WebTransport CONNACK timeout'));
-            }, 15000);
-        });
-        this.wtParser.on('packet', (packet) => {
-            if (packet.cmd === 'connack') {
-                this.wtConnected = true;
-                if (this.wtConnackResolve) {
-                    const r = this.wtConnackResolve;
+        var _a, _b, _c, _d, _e, _f, _g;
+        try {
+            if (this.wtConnected && this.wt) {
+                dlog('already connected');
+                return { connected: true };
+            }
+            const url = this.getWebTransportUrl(options);
+            dlog('1. new WebTransport', url);
+            const transport = new WebTransport(url);
+            dlog('2. awaiting transport.ready');
+            await transport.ready;
+            dlog('3. transport.ready OK');
+            const stream = await transport.createBidirectionalStream();
+            dlog('4. bidi stream opened');
+            this.wt = transport;
+            this.wtWriter = stream.writable.getWriter();
+            dlog('5. writer acquired');
+            this.wtLevel = this.resolveLevel(options);
+            this.wtParser = new MqttParser(this.wtLevel);
+            this.wtNextMessageId = 1;
+            this.wtPendingSuback.clear();
+            this.wtPendingUnsuback.clear();
+            let connackTimer = null;
+            const connackPromise = new Promise((resolve, reject) => {
+                this.wtConnackResolve = () => {
+                    if (connackTimer)
+                        clearTimeout(connackTimer);
+                    connackTimer = null;
                     this.wtConnackResolve = null;
-                    r();
+                    this.wtConnackReject = null;
+                    resolve();
+                };
+                this.wtConnackReject = (err) => {
+                    if (connackTimer)
+                        clearTimeout(connackTimer);
+                    connackTimer = null;
+                    this.wtConnackResolve = null;
+                    this.wtConnackReject = null;
+                    reject(err);
+                };
+                connackTimer = setTimeout(() => {
+                    connackTimer = null;
+                    const rej = this.wtConnackReject;
+                    this.wtConnackResolve = null;
+                    this.wtConnackReject = null;
+                    elog('CONNACK timeout after 15s');
+                    if (rej)
+                        rej(new Error('WebTransport CONNACK timeout'));
+                }, 15000);
+            });
+            this.wtParser.on((pkt) => {
+                dlog('parser ->', pkt.cmd, pkt.cmd === 'connack' ? `rc=${pkt.reasonCode}` : '');
+                if (pkt.cmd === 'connack') {
+                    if (pkt.reasonCode === 0) {
+                        this.wtConnected = true;
+                        const r = this.wtConnackResolve;
+                        this.wtConnackResolve = null;
+                        this.wtConnackReject = null;
+                        if (r)
+                            r();
+                        this.notifyListeners('connected', { connected: true });
+                    }
+                    else {
+                        const rj = this.wtConnackReject;
+                        this.wtConnackResolve = null;
+                        this.wtConnackReject = null;
+                        if (rj)
+                            rj(new Error(`CONNACK rc=${pkt.reasonCode}`));
+                    }
+                    return;
                 }
-                this.notifyListeners('connected', { connected: true });
-                return;
+                if (pkt.cmd === 'publish') {
+                    const payload = new TextDecoder().decode(pkt.payload);
+                    this.notifyListeners('message', { topic: pkt.topic, payload });
+                    return;
+                }
+                if (pkt.cmd === 'suback') {
+                    const cb = this.wtPendingSuback.get(pkt.messageId);
+                    if (cb) {
+                        this.wtPendingSuback.delete(pkt.messageId);
+                        const failed = pkt.reasonCodes.find((rc) => rc >= 0x80);
+                        if (failed != null) {
+                            cb.reject(new Error(`SUBACK failure rc=${failed} for ${cb.topic}`));
+                        }
+                        else {
+                            this.notifyListeners('subscribed', { topic: cb.topic });
+                            cb.resolve();
+                        }
+                    }
+                    return;
+                }
+                if (pkt.cmd === 'unsuback') {
+                    const cb = this.wtPendingUnsuback.get(pkt.messageId);
+                    if (cb) {
+                        this.wtPendingUnsuback.delete(pkt.messageId);
+                        const failed = pkt.reasonCodes.find((rc) => rc >= 0x80);
+                        if (failed != null)
+                            cb.reject(new Error(`UNSUBACK failure rc=${failed}`));
+                        else
+                            cb.resolve();
+                    }
+                    return;
+                }
+                if (pkt.cmd === 'pingresp') {
+                    const p = this.wtPendingPing;
+                    if (p) {
+                        if (p.timer)
+                            clearTimeout(p.timer);
+                        this.wtPendingPing = null;
+                        p.resolve(true);
+                    }
+                    return;
+                }
+                if (pkt.cmd === 'disconnect') {
+                    elog('server DISCONNECT rc=', pkt.reasonCode);
+                    this.failPendingWtOps(new Error(`server DISCONNECT rc=${pkt.reasonCode}`));
+                }
+            });
+            dlog('6. starting read loop');
+            void this.wtReadLoop(stream.readable);
+            const connectPacket = buildConnect({
+                level: this.wtLevel,
+                clientId: options.clientId,
+                keepalive: (_a = options.keepalive) !== null && _a !== void 0 ? _a : 60,
+                cleanSession: (_b = options.cleanSession) !== null && _b !== void 0 ? _b : true,
+                username: options.username || undefined,
+                password: options.password || undefined,
+                sessionExpiryInterval: this.wtLevel === 5 ? options.sessionExpiryInterval : undefined,
+                receiveMaximum: this.wtLevel === 5 ? options.receiveMaximum : undefined,
+                maximumPacketSize: this.wtLevel === 5 ? options.maximumPacketSize : undefined,
+                topicAliasMaximum: this.wtLevel === 5 ? options.topicAliasMaximum : undefined,
+            });
+            dlog('7. built CONNECT', connectPacket.length, 'bytes, first32:', hexHead(connectPacket));
+            dlog('8. writing CONNECT');
+            try {
+                await this.wtWriter.write(connectPacket);
             }
-            if (packet.cmd === 'publish') {
-                const p = packet;
-                const payload = typeof p.payload === 'string' ? p.payload : (p.payload && Buffer.isBuffer(p.payload) ? p.payload.toString('utf8') : String(p.payload));
-                this.notifyListeners('message', { topic: p.topic, payload });
-                return;
+            catch (e) {
+                elog('writer.write failed:', (_c = e === null || e === void 0 ? void 0 : e.stack) !== null && _c !== void 0 ? _c : e);
+                throw e;
             }
-            if (packet.cmd === 'suback' && packet.messageId !== undefined) {
-                const cb = this.wtPendingSuback.get(packet.messageId);
-                if (cb) {
-                    this.wtPendingSuback.delete(packet.messageId);
-                    this.notifyListeners('subscribed', { topic: cb.topic });
-                    cb.resolve();
-                }
-                return;
+            dlog('9. CONNECT written, awaiting CONNACK');
+            await connackPromise;
+            dlog('10. CONNACK OK');
+            this.wtKeepaliveSeconds = (_d = options.keepalive) !== null && _d !== void 0 ? _d : 60;
+            this.startWtAutoKeepalive();
+            return { connected: true };
+        }
+        catch (e) {
+            elog('connectWebTransport failed:', (_e = e === null || e === void 0 ? void 0 : e.stack) !== null && _e !== void 0 ? _e : e);
+            // best-effort cleanup so a future connect attempt starts clean
+            this.stopWtAutoKeepalive();
+            this.failPendingWtOps(e instanceof Error ? e : new Error(String(e)));
+            try {
+                await ((_f = this.wtWriter) === null || _f === void 0 ? void 0 : _f.close());
             }
-            if (packet.cmd === 'unsuback' && packet.messageId !== undefined) {
-                const cb = this.wtPendingUnsuback.get(packet.messageId);
-                if (cb) {
-                    this.wtPendingUnsuback.delete(packet.messageId);
-                    cb.resolve();
-                }
+            catch (_h) {
+                /* ignore */
             }
-        });
-        this.wtReadLoop(stream.readable);
-        const pv = (_a = options.protocolVersion) !== null && _a !== void 0 ? _a : 'auto';
-        const ver = pv === '3.1.1' ? 4 : 5;
-        const connectPacket = {
-            cmd: 'connect',
-            clientId: options.clientId,
-            protocolVersion: ver,
-            protocolId: 'MQTT',
-            clean: (_b = options.cleanSession) !== null && _b !== void 0 ? _b : true,
-            keepalive: (_c = options.keepalive) !== null && _c !== void 0 ? _c : 20,
-            username: options.username,
-            password: options.password ? Buffer.from(options.password, 'utf8') : undefined,
-            properties: ver === 5 && options.sessionExpiryInterval != null ? { sessionExpiryInterval: options.sessionExpiryInterval } : undefined,
-        };
-        const buf = mqttPacket.generate(connectPacket);
-        await this.wtWrite(buf);
-        await connackPromise;
-        return { connected: true };
+            try {
+                (_g = this.wt) === null || _g === void 0 ? void 0 : _g.close();
+            }
+            catch (_j) {
+                /* ignore */
+            }
+            this.wt = null;
+            this.wtWriter = null;
+            this.wtParser = null;
+            this.wtConnected = false;
+            throw e;
+        }
+    }
+    failPendingWtOps(err) {
+        if (this.wtConnackReject) {
+            const rj = this.wtConnackReject;
+            this.wtConnackResolve = null;
+            this.wtConnackReject = null;
+            rj(err);
+        }
+        for (const [, cb] of this.wtPendingSuback)
+            cb.reject(err);
+        this.wtPendingSuback.clear();
+        for (const [, cb] of this.wtPendingUnsuback)
+            cb.reject(err);
+        this.wtPendingUnsuback.clear();
+        if (this.wtPendingPing) {
+            const p = this.wtPendingPing;
+            this.wtPendingPing = null;
+            if (p.timer)
+                clearTimeout(p.timer);
+            p.resolve(false);
+        }
     }
-    async wtWrite(data) {
-        if (!this.wtWriter)
+    /**
+     * Start an internal interval that sends PINGREQ at ~75% of the negotiated
+     * keepalive. This guarantees the broker idle-timeout never fires even if the
+     * consumer forgets to call `sendKeepalive`. Also matches the WSS path, where
+     * `mqtt.js` runs its own internal keepalive timer for free.
+     */
+    startWtAutoKeepalive() {
+        this.stopWtAutoKeepalive();
+        const ka = this.wtKeepaliveSeconds;
+        if (!ka || ka <= 0) {
+            dlog('auto-keepalive: disabled (keepalive=0)');
             return;
-        const chunk = data instanceof Buffer ? new Uint8Array(data) : data;
-        await this.wtWriter.write(chunk);
+        }
+        // Steady-state interval at 50% of the negotiated keepalive (vs. spec
+        // recommendation of 75-100%) so we beat strict brokers that close at
+        // exactly `keepalive` seconds.
+        const intervalMs = Math.max(1000, Math.floor(ka * 1000 * 0.5));
+        const pingTimeoutMs = Math.max(2000, Math.floor(ka * 1000 * 0.4));
+        // First ping fires within ~3s of CONNACK. This catches WebTransport
+        // servers with idle timeouts much shorter than the MQTT keepalive
+        // (we have observed `WebTransportError: Connection lost` at <10s idle
+        // on some HTTP/3 proxies).
+        const firstPingMs = Math.min(intervalMs, 3000);
+        dlog(`auto-keepalive: armed, first=${firstPingMs}ms, interval=${intervalMs}ms, timeout=${pingTimeoutMs}ms`);
+        const tick = () => {
+            this.wtKeepaliveTimer = null;
+            if (!this.wtConnected || !this.wtWriter)
+                return;
+            void this.wtSendPingreq(pingTimeoutMs).then((ok) => {
+                if (!ok)
+                    elog('auto-keepalive: PINGRESP timeout');
+            });
+            if (this.wtConnected) {
+                this.wtKeepaliveTimer = setTimeout(tick, intervalMs);
+            }
+        };
+        this.wtKeepaliveTimer = setTimeout(tick, firstPingMs);
+    }
+    stopWtAutoKeepalive() {
+        if (this.wtKeepaliveTimer) {
+            clearTimeout(this.wtKeepaliveTimer);
+            this.wtKeepaliveTimer = null;
+        }
+    }
+    /**
+     * Write a PINGREQ and wait up to `timeoutMs` for the matching PINGRESP.
+     * Concurrent callers share the in-flight request (only one PINGREQ may be
+     * outstanding per the MQTT spec).
+     */
+    async wtSendPingreq(timeoutMs) {
+        var _a;
+        if (!this.wtConnected || !this.wtWriter)
+            return false;
+        if (this.wtPendingPing)
+            return this.wtPendingPing.promise;
+        let resolveFn;
+        const promise = new Promise((resolve) => {
+            resolveFn = resolve;
+        });
+        const timer = setTimeout(() => {
+            if (this.wtPendingPing && this.wtPendingPing.promise === promise) {
+                this.wtPendingPing = null;
+            }
+            resolveFn(false);
+        }, timeoutMs);
+        this.wtPendingPing = { promise, resolve: resolveFn, timer };
+        try {
+            dlog('pingreq');
+            await this.wtWriter.write(buildPingreq());
+        }
+        catch (e) {
+            elog('pingreq write failed:', (_a = e === null || e === void 0 ? void 0 : e.stack) !== null && _a !== void 0 ? _a : e);
+            if (this.wtPendingPing && this.wtPendingPing.promise === promise) {
+                clearTimeout(timer);
+                this.wtPendingPing = null;
+            }
+            return false;
+        }
+        return promise;
     }
     async wtReadLoop(readable) {
+        var _a, _b;
         const reader = readable.getReader();
         try {
             while (true) {
                 const { value, done } = await reader.read();
                 if (done)
                     break;
-                if (this.wtParser && value.length > 0) {
-                    this.wtParser.parse(Buffer.from(value));
+                if (value && value.length > 0) {
+                    dlog('read', value.length, 'bytes');
+                    (_a = this.wtParser) === null || _a === void 0 ? void 0 : _a.feed(value);
                 }
             }
+            dlog('read loop ended (stream closed)');
         }
         catch (e) {
-            if (e.name !== 'AbortError')
-                this.wtConnected = false;
+            const err = e;
+            if (err.name !== 'AbortError') {
+                elog('read loop err:', (_b = err.stack) !== null && _b !== void 0 ? _b : err);
+            }
         }
         finally {
-            reader.releaseLock();
+            try {
+                reader.releaseLock();
+            }
+            catch (_c) {
+                /* ignore */
+            }
+            this.wtConnected = false;
+            this.stopWtAutoKeepalive();
+            this.failPendingWtOps(new Error('WebTransport stream closed'));
         }
     }
     async connectWSS(options) {
@@ -213,7 +473,7 @@ export class MqttQuicWeb extends WebPlugin {
             const onConnect = () => {
                 this.client.removeListener('error', onError);
                 this.client.on('message', (topic, payload) => {
-                    const str = payload.toString('utf8');
+                    const str = new TextDecoder().decode(payload);
                     this.notifyListeners('message', { topic, payload: str });
                 });
                 this.notifyListeners('connected', { connected: true });
@@ -229,20 +489,34 @@ export class MqttQuicWeb extends WebPlugin {
         });
     }
     async disconnect() {
-        var _a, _b;
+        var _a;
         if (this.wt) {
-            (_a = this.wtReadAbort) === null || _a === void 0 ? void 0 : _a.abort();
+            this.stopWtAutoKeepalive();
+            try {
+                if (this.wtWriter) {
+                    await this.wtWriter.write(buildDisconnect(this.wtLevel));
+                }
+            }
+            catch (_b) {
+                /* best-effort */
+            }
+            try {
+                await ((_a = this.wtWriter) === null || _a === void 0 ? void 0 : _a.close());
+            }
+            catch (_c) {
+                /* ignore */
+            }
             try {
-                await ((_b = this.wtWriter) === null || _b === void 0 ? void 0 : _b.close());
-                await this.wt.close();
+                this.wt.close();
+            }
+            catch (_d) {
+                /* ignore */
             }
-            catch (_) { }
             this.wt = null;
             this.wtWriter = null;
             this.wtParser = null;
             this.wtConnected = false;
-            this.wtPendingSuback.clear();
-            this.wtPendingUnsuback.clear();
+            this.failPendingWtOps(new Error('disconnected'));
             return;
         }
         return new Promise((resolve) => {
@@ -257,29 +531,35 @@ export class MqttQuicWeb extends WebPlugin {
         });
     }
     async publish(options) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b;
         if (this.wtConnected && this.wtWriter) {
-            const payload = typeof options.payload === 'string' ? Buffer.from(options.payload, 'utf8') : Buffer.from(options.payload);
-            const packet = {
-                cmd: 'publish',
+            const qos = ((_a = options.qos) !== null && _a !== void 0 ? _a : 0);
+            const payload = typeof options.payload === 'string'
+                ? new TextEncoder().encode(options.payload)
+                : options.payload instanceof Uint8Array
+                    ? options.payload
+                    : new Uint8Array(options.payload);
+            const correlationData = options.correlationData == null
+                ? undefined
+                : typeof options.correlationData === 'string'
+                    ? new TextEncoder().encode(options.correlationData)
+                    : options.correlationData;
+            const messageId = qos > 0 ? this.nextWtMessageId() : undefined;
+            const pkt = buildPublish({
+                level: this.wtLevel,
                 topic: options.topic,
                 payload,
-                qos: ((_a = options.qos) !== null && _a !== void 0 ? _a : 0),
-                dup: false,
+                qos,
                 retain: (_b = options.retain) !== null && _b !== void 0 ? _b : false,
-                messageId: ((_c = options.qos) !== null && _c !== void 0 ? _c : 0) > 0 ? this.wtNextMessageId++ : undefined,
-                properties: options.contentType || options.responseTopic || ((_d = options.userProperties) === null || _d === void 0 ? void 0 : _d.length)
-                    ? {
-                        contentType: options.contentType,
-                        responseTopic: options.responseTopic,
-                        correlationData: options.correlationData != null ? Buffer.from(options.correlationData) : undefined,
-                        userProperties: ((_e = options.userProperties) === null || _e === void 0 ? void 0 : _e.length) ? Object.fromEntries(options.userProperties.map((p) => [p.name, p.value])) : undefined,
-                        messageExpiryInterval: options.messageExpiryInterval,
-                    }
-                    : undefined,
-            };
-            const buf = mqttPacket.generate(packet);
-            await this.wtWrite(buf);
+                messageId,
+                messageExpiryInterval: options.messageExpiryInterval,
+                contentType: options.contentType,
+                responseTopic: options.responseTopic,
+                correlationData,
+                userProperties: options.userProperties,
+            });
+            dlog('publish', options.topic, payload.length, 'B');
+            await this.wtWriter.write(pkt);
             return { success: true };
         }
         return new Promise((resolve, reject) => {
@@ -288,9 +568,6 @@ export class MqttQuicWeb extends WebPlugin {
                 reject(new Error('Not connected'));
                 return;
             }
-            const payload = typeof options.payload === 'string'
-                ? options.payload
-                : Buffer.from(options.payload);
             const opts = {
                 qos: ((_b = options.qos) !== null && _b !== void 0 ? _b : 0),
                 retain: (_c = options.retain) !== null && _c !== void 0 ? _c : false,
@@ -305,14 +582,20 @@ export class MqttQuicWeb extends WebPlugin {
             if (options.correlationData != null) {
                 props.correlationData =
                     typeof options.correlationData === 'string'
-                        ? Buffer.from(options.correlationData, 'utf8')
-                        : Buffer.from(options.correlationData);
+                        ? new TextEncoder().encode(options.correlationData)
+                        : options.correlationData;
             }
             if ((_d = options.userProperties) === null || _d === void 0 ? void 0 : _d.length) {
                 props.userProperties = Object.fromEntries(options.userProperties.map((p) => [p.name, p.value]));
             }
             if (Object.keys(props).length)
                 opts.properties = props;
+            // mqtt.js types declare the payload as `string | Buffer`, but its browser
+            // build accepts Uint8Array at runtime (Buffer extends Uint8Array). Cast
+            // through `unknown` to avoid forcing a Node Buffer polyfill on consumers.
+            const payload = typeof options.payload === 'string'
+                ? options.payload
+                : options.payload;
             this.client.publish(options.topic, payload, opts, (err) => {
                 if (err)
                     reject(err);
@@ -324,17 +607,18 @@ export class MqttQuicWeb extends WebPlugin {
     async subscribe(options) {
         var _a;
         if (this.wtConnected && this.wtWriter) {
-            const messageId = this.wtNextMessageId++;
-            const subackPromise = new Promise((resolve) => {
-                this.wtPendingSuback.set(messageId, { resolve, topic: options.topic });
+            const messageId = this.nextWtMessageId();
+            const subackPromise = new Promise((resolve, reject) => {
+                this.wtPendingSuback.set(messageId, { resolve, reject, topic: options.topic });
             });
-            const packet = {
-                cmd: 'subscribe',
+            const pkt = buildSubscribe({
+                level: this.wtLevel,
                 messageId,
-                subscriptions: [{ topic: options.topic, qos: ((_a = options.qos) !== null && _a !== void 0 ? _a : 0) }],
-                properties: options.subscriptionIdentifier != null ? { subscriptionIdentifier: options.subscriptionIdentifier } : undefined,
-            };
-            await this.wtWrite(mqttPacket.generate(packet));
+                topics: [{ topic: options.topic, qos: ((_a = options.qos) !== null && _a !== void 0 ? _a : 0) }],
+                subscriptionIdentifier: this.wtLevel === 5 ? options.subscriptionIdentifier : undefined,
+            });
+            dlog('subscribe', options.topic);
+            await this.wtWriter.write(pkt);
             await subackPromise;
             return { success: true };
         }
@@ -362,16 +646,12 @@ export class MqttQuicWeb extends WebPlugin {
     }
     async unsubscribe(options) {
         if (this.wtConnected && this.wtWriter) {
-            const messageId = this.wtNextMessageId++;
-            const unsubackPromise = new Promise((resolve) => {
-                this.wtPendingUnsuback.set(messageId, { resolve });
+            const messageId = this.nextWtMessageId();
+            const unsubackPromise = new Promise((resolve, reject) => {
+                this.wtPendingUnsuback.set(messageId, { resolve, reject });
             });
-            const packet = {
-                cmd: 'unsubscribe',
-                messageId,
-                unsubscriptions: [options.topic],
-            };
-            await this.wtWrite(mqttPacket.generate(packet));
+            const pkt = buildUnsubscribe({ level: this.wtLevel, messageId, topics: [options.topic] });
+            await this.wtWriter.write(pkt);
             await unsubackPromise;
             return { success: true };
         }
@@ -409,5 +689,11 @@ export class MqttQuicWeb extends WebPlugin {
             throw error instanceof Error ? error : new Error(String(error));
         }
     }
+    /** Wraps message ID at the MQTT uint16 boundary (1..65535). */
+    nextWtMessageId() {
+        const id = this.wtNextMessageId;
+        this.wtNextMessageId = id >= 0xffff ? 1 : id + 1;
+        return id;
+    }
 }
 //# sourceMappingURL=web.js.map