react-native-ble-mesh 2.0.0 → 2.1.2

package/src/service/HandshakeManager.js

@@ -21,15 +21,27 @@ const STATE = Object.freeze({
  * @extends EventEmitter
  */
 class HandshakeManager extends EventEmitter {
+  /**
+   * @param {any} keyManager
+   * @param {any} sessionManager
+   */
   constructor(keyManager, sessionManager) {
     super();
     if (!keyManager || !sessionManager) { throw new Error('keyManager and sessionManager required'); }
+    /** @type {any} */
     this._keyManager = keyManager;
+    /** @type {any} */
     this._sessionManager = sessionManager;
+    /** @type {Map<string, any>} */
     this._pending = new Map();
+    /** @type {number} */
     this._timeout = MESH_CONFIG.HANDSHAKE_TIMEOUT_MS;
   }
 
+  /**
+   * @param {string} peerId
+   * @param {any} transport
+   */
   async initiateHandshake(peerId, transport) {
     if (this._pending.has(peerId)) { throw HandshakeError.alreadyInProgress(peerId); }
 
@@ -44,12 +56,18 @@ class HandshakeManager extends EventEmitter {
       hs.step = 1;
       this.emit(EVENTS.HANDSHAKE_PROGRESS, { peerId, step: 1, role: 'initiator' });
       return await this._waitForCompletion(peerId);
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       this._fail(peerId, err);
       throw err;
     }
   }
 
+  /**
+   * @param {string} peerId
+   * @param {number} type
+   * @param {Uint8Array} payload
+   * @param {any} transport
+   */
   async handleIncomingHandshake(peerId, type, payload, transport) {
     try {
       if (type === MESSAGE_TYPE.HANDSHAKE_INIT) {
@@ -62,12 +80,15 @@ class HandshakeManager extends EventEmitter {
         return await this._onFinal(peerId, payload);
       }
       throw HandshakeError.handshakeFailed(peerId, null, { reason: 'Unknown type' });
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       this._fail(peerId, err);
       throw err;
     }
   }
 
+  /**
+   * @param {string} peerId
+   */
   cancelHandshake(peerId) {
     const hs = this._pending.get(peerId);
     if (!hs) { return; }
@@ -77,9 +98,20 @@ class HandshakeManager extends EventEmitter {
     this.emit(EVENTS.HANDSHAKE_FAILED, { peerId, reason: 'cancelled' });
   }
 
+  /**
+   * @param {string} peerId
+   * @returns {boolean}
+   */
   isHandshakePending(peerId) { return this._pending.has(peerId); }
+  /** @returns {number} */
   getPendingCount() { return this._pending.size; }
 
+  /**
+   * @param {string} peerId
+   * @param {boolean} isInitiator
+   * @returns {any}
+   * @private
+   */
   _createState(peerId, isInitiator) {
     const kp = this._keyManager.getStaticKeyPair();
     return {
@@ -88,11 +120,18 @@ class HandshakeManager extends EventEmitter {
     };
   }
 
+  /**
+   * @param {any} keyPair
+   * @param {boolean} isInitiator
+   * @returns {any}
+   * @private
+   */
   _createNoise(keyPair, isInitiator) {
     // Get crypto provider from keyManager if available
     const provider = this._keyManager.provider;
 
     // Generate ephemeral key pair for this handshake
+    /** @type {any} */
     let ephemeralKeyPair;
     if (provider && typeof provider.generateKeyPair === 'function') {
       ephemeralKeyPair = provider.generateKeyPair();
@@ -101,11 +140,18 @@ class HandshakeManager extends EventEmitter {
       ephemeralKeyPair = { publicKey: randomBytes(32), secretKey: randomBytes(32) };
     }
 
+    /** @type {Uint8Array | null} */
     let remoteEphemeralPublic = null;
+    /** @type {Uint8Array | null} */
     let sharedSecret = null;
+    /** @type {any} */
     let sessionKeys = null;
     let complete = false;
 
+    /**
+     * @param {Uint8Array} secret
+     * @returns {any}
+     */
     const deriveSessionKeys = (secret) => {
       // Derive send/receive keys from shared secret
       // Use hash to derive two different keys from the secret
@@ -125,6 +171,7 @@ class HandshakeManager extends EventEmitter {
         return ephemeralKeyPair.publicKey;
       },
 
+      /** @param {Uint8Array} msg */
       readMessage1: (msg) => {
         // Responder receives initiator's ephemeral public key
         remoteEphemeralPublic = new Uint8Array(msg);
@@ -137,10 +184,12 @@ class HandshakeManager extends EventEmitter {
         } else {
           throw new Error('Crypto provider required for secure handshake. Install tweetnacl: npm install tweetnacl');
         }
+        // @ts-ignore
         sessionKeys = deriveSessionKeys(sharedSecret);
         return ephemeralKeyPair.publicKey;
       },
 
+      /** @param {Uint8Array} msg */
       readMessage2: (msg) => {
         // Initiator receives responder's ephemeral public key and derives shared secret
         remoteEphemeralPublic = new Uint8Array(msg);
@@ -149,6 +198,7 @@ class HandshakeManager extends EventEmitter {
         } else {
           throw new Error('Crypto provider required for secure handshake. Install tweetnacl: npm install tweetnacl');
         }
+        // @ts-ignore
         sessionKeys = deriveSessionKeys(sharedSecret);
       },
 
@@ -158,6 +208,7 @@ class HandshakeManager extends EventEmitter {
         return ephemeralKeyPair.publicKey;
       },
 
+      /** @param {any} _msg */
       readMessage3: (_msg) => {
         // Responder confirms handshake completion
         complete = true;
@@ -177,32 +228,30 @@ class HandshakeManager extends EventEmitter {
         let sendNonce = 0;
         let recvNonce = 0;
 
+        // Pre-allocate nonce buffers per direction to avoid per-call allocation
+        const sendNonceBuf = new Uint8Array(24);
+        const sendNonceView = new DataView(sendNonceBuf.buffer);
+        const recvNonceBuf = new Uint8Array(24);
+        const recvNonceView = new DataView(recvNonceBuf.buffer);
+
         return {
+          /** @param {Uint8Array} plaintext */
           encrypt: (plaintext) => {
             if (provider && typeof provider.encrypt === 'function') {
-              // Use proper AEAD encryption with nonce
-              const nonce = new Uint8Array(24); // tweetnacl uses 24-byte nonces
-              const view = new DataView(nonce.buffer);
               // Store counter in last 8 bytes of nonce
-              if (nonce.byteLength >= 8) {
-                view.setUint32(nonce.byteLength - 8, 0, true);
-                view.setUint32(nonce.byteLength - 4, sendNonce++, true);
-              }
-              return provider.encrypt(sendKey, nonce, plaintext);
+              sendNonceView.setUint32(16, 0, true);
+              sendNonceView.setUint32(20, sendNonce++, true);
+              return provider.encrypt(sendKey, sendNonceBuf, plaintext);
             }
             throw new Error('Crypto provider required for encryption');
           },
 
+          /** @param {Uint8Array} ciphertext */
           decrypt: (ciphertext) => {
             if (provider && typeof provider.decrypt === 'function') {
-              // Use proper AEAD decryption with nonce
-              const nonce = new Uint8Array(24);
-              const view = new DataView(nonce.buffer);
-              if (nonce.byteLength >= 8) {
-                view.setUint32(nonce.byteLength - 8, 0, true);
-                view.setUint32(nonce.byteLength - 4, recvNonce++, true);
-              }
-              return provider.decrypt(recvKey, nonce, ciphertext);
+              recvNonceView.setUint32(16, 0, true);
+              recvNonceView.setUint32(20, recvNonce++, true);
+              return provider.decrypt(recvKey, recvNonceBuf, ciphertext);
             }
             throw new Error('Crypto provider required for encryption');
           },
@@ -219,6 +268,12 @@ class HandshakeManager extends EventEmitter {
     };
   }
 
+  /**
+   * @param {string} peerId
+   * @param {Uint8Array} payload
+   * @param {any} transport
+   * @private
+   */
   async _onInit(peerId, payload, transport) {
     const existing = this._pending.get(peerId);
 
@@ -249,6 +304,12 @@ class HandshakeManager extends EventEmitter {
     return null;
   }
 
+  /**
+   * @param {string} peerId
+   * @param {Uint8Array} payload
+   * @param {any} transport
+   * @private
+   */
   async _onResponse(peerId, payload, transport) {
     const hs = this._pending.get(peerId);
     if (!hs || !hs.isInitiator) {
@@ -262,6 +323,11 @@ class HandshakeManager extends EventEmitter {
     return this._complete(peerId, hs);
   }
 
+  /**
+   * @param {string} peerId
+   * @param {Uint8Array} payload
+   * @private
+   */
   async _onFinal(peerId, payload) {
     const hs = this._pending.get(peerId);
     if (!hs || hs.isInitiator) { throw HandshakeError.invalidState(peerId, 3); }
@@ -270,6 +336,11 @@ class HandshakeManager extends EventEmitter {
     return this._complete(peerId, hs);
   }
 
+  /**
+   * @param {string} peerId
+   * @param {any} hs
+   * @private
+   */
   _complete(peerId, hs) {
     if (hs.timer) { clearTimeout(hs.timer); }
     const session = hs.noise.getSession();
@@ -283,6 +354,11 @@ class HandshakeManager extends EventEmitter {
     return session;
   }
 
+  /**
+   * @param {string} peerId
+   * @param {any} error
+   * @private
+   */
   _fail(peerId, error) {
     const hs = this._pending.get(peerId);
     if (hs) {
@@ -293,6 +369,10 @@ class HandshakeManager extends EventEmitter {
     this.emit(EVENTS.HANDSHAKE_FAILED, { peerId, error: error.message, step: hs?.step });
   }
 
+  /**
+   * @param {string} peerId
+   * @private
+   */
   _setTimeout(peerId) {
     const hs = this._pending.get(peerId);
     if (!hs) { return; }
@@ -303,6 +383,10 @@ class HandshakeManager extends EventEmitter {
     }, this._timeout);
   }
 
+  /**
+   * @param {string} peerId
+   * @private
+   */
   _waitForCompletion(peerId) {
     return new Promise((resolve, reject) => {
       const hs = this._pending.get(peerId);
@@ -313,6 +397,11 @@ class HandshakeManager extends EventEmitter {
     });
   }
 
+  /**
+   * @param {any} localKey
+   * @param {any} remoteId
+   * @private
+   */
   _compareKeys(localKey, remoteId) {
     // Simple string/byte comparison for deterministic tie-breaking
     const localStr = typeof localKey === 'string' ? localKey : Array.from(localKey).join(',');
@@ -320,6 +409,11 @@ class HandshakeManager extends EventEmitter {
     return localStr < remoteStr ? -1 : localStr > remoteStr ? 1 : 0;
   }
 
+  /**
+   * @param {number} type
+   * @param {Uint8Array} payload
+   * @private
+   */
   _wrap(type, payload) {
     const w = new Uint8Array(1 + payload.length);
     w[0] = type;

package/src/service/MeshService.js

@@ -19,21 +19,38 @@ const { TextManager, ChannelManager } = require('./text');
  * @extends EventEmitter
  */
 class MeshService extends EventEmitter {
+  /**
+   * @param {any} [config]
+   */
   constructor(config = {}) {
     super();
+    /** @type {any} */
     this._config = { displayName: 'Anonymous', ...config };
+    /** @type {string} */
     this._state = SERVICE_STATE.UNINITIALIZED;
+    /** @type {any} */
     this._transport = null;
+    /** @type {any} */
     this._keyManager = null;
+    /** @type {SessionManager | null} */
     this._sessionManager = null;
+    /** @type {HandshakeManager | null} */
     this._handshakeManager = null;
+    /** @type {any} */
     this._channelManager = null;
+    /** @type {any} */
     this._peerManager = null;
+    /** @type {any} */
     this._audioManager = null;
+    /** @type {any} */
     this._textManager = null;
+    /** @type {number} */
     this._messageCounter = 0;
   }
 
+  /**
+   * @param {any} [options]
+   */
   async initialize(options = {}) {
     if (this._state !== SERVICE_STATE.UNINITIALIZED) {
       throw new MeshError('Service already initialized', ERROR_CODE.E002);
@@ -47,12 +64,15 @@ class MeshService extends EventEmitter {
       this._setupEventForwarding();
       this._setState(SERVICE_STATE.READY);
       this.emit(EVENTS.INITIALIZED);
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       this._setState(SERVICE_STATE.ERROR);
       throw new MeshError(`Initialization failed: ${err.message}`, ERROR_CODE.E001);
     }
   }
 
+  /**
+   * @param {any} transport
+   */
   async start(transport) {
     this._validateState([SERVICE_STATE.READY, SERVICE_STATE.SUSPENDED]);
     if (!transport) { throw new ValidationError('Transport is required', ERROR_CODE.E802); }
@@ -87,31 +107,52 @@ class MeshService extends EventEmitter {
     };
   }
 
+  /**
+   * @param {string} name
+   */
   setDisplayName(name) { this._config.displayName = name; }
   exportIdentity() { return this._keyManager?.exportIdentity() || null; }
+  /**
+   * @param {any} identity
+   */
   importIdentity(identity) { this._keyManager?.importIdentity(identity); }
 
   getPeers() { return this._peerManager?.getAllPeers() || []; }
+  /**
+   * @param {string} id
+   */
   getPeer(id) { return this._peerManager?.getPeer(id); }
   getConnectedPeers() { return this._peerManager?.getConnectedPeers() || []; }
   getSecuredPeers() { return this._sessionManager?.getAllSessionPeerIds() || []; }
 
+  /**
+   * @param {string} peerId
+   */
   async initiateHandshake(peerId) {
     this._validateState([SERVICE_STATE.ACTIVE]);
-    return this._handshakeManager.initiateHandshake(peerId, this._transport);
+    return this._handshakeManager?.initiateHandshake(peerId, this._transport);
   }
 
+  /**
+   * @param {string} id
+   */
   blockPeer(id) {
     this._peerManager?.blockPeer(id);
     this.emit(EVENTS.PEER_BLOCKED, { peerId: id });
   }
 
+  /**
+   * @param {string} id
+   */
   unblockPeer(id) {
     this._peerManager?.unblockPeer(id);
     this.emit(EVENTS.PEER_UNBLOCKED, { peerId: id });
   }
 
   // Text messaging methods
+  /**
+   * @param {string} content
+   */
   sendBroadcast(content) {
     this._validateState([SERVICE_STATE.ACTIVE]);
     if (this._textManager) {
@@ -130,26 +171,34 @@ class MeshService extends EventEmitter {
     return messageId;
   }
 
+  /**
+   * @param {string} peerId
+   * @param {string} content
+   */
   async sendPrivateMessage(peerId, content) {
     this._validateState([SERVICE_STATE.ACTIVE]);
     if (this._textManager) {
       return this._textManager.sendPrivateMessage(peerId, content);
     }
-    if (!this._sessionManager.hasSession(peerId)) { await this.initiateHandshake(peerId); }
+    if (!this._sessionManager?.hasSession(peerId)) { await this.initiateHandshake(peerId); }
     const messageId = this._generateMessageId();
     const plaintext = new TextEncoder().encode(content);
-    const ciphertext = this._sessionManager.encryptFor(peerId, plaintext);
+    const ciphertext = this._sessionManager?.encryptFor(peerId, plaintext);
     await this._transport.send(peerId, ciphertext);
     this.emit(EVENTS.PRIVATE_MESSAGE_SENT, { messageId, peerId });
     return messageId;
   }
 
+  /**
+   * @param {string} channelId
+   * @param {string} content
+   */
   sendChannelMessage(channelId, content) {
     this._validateState([SERVICE_STATE.ACTIVE]);
     if (this._textManager) {
       return this._textManager.sendChannelMessage(channelId, content);
     }
-    if (!this._channelManager.isInChannel(channelId)) {
+    if (!this._channelManager?.isInChannel(channelId)) {
       throw new MeshError('Not in channel', ERROR_CODE.E602);
     }
     const messageId = this._generateMessageId();
@@ -157,28 +206,38 @@ class MeshService extends EventEmitter {
     return messageId;
   }
 
+  /**
+   * @param {string} channelId
+   * @param {string} [password]
+   */
   joinChannel(channelId, password) {
     if (this._textManager) {
       return this._textManager.joinChannel(channelId, password);
     }
-    this._channelManager.joinChannel(channelId, password);
+    this._channelManager?.joinChannel(channelId, password);
   }
 
+  /**
+   * @param {string} channelId
+   */
   leaveChannel(channelId) {
     if (this._textManager) {
       return this._textManager.leaveChannel(channelId);
     }
-    this._channelManager.leaveChannel(channelId);
+    this._channelManager?.leaveChannel(channelId);
   }
 
   getChannels() {
     if (this._textManager) {
       return this._textManager.getChannels();
     }
-    return this._channelManager.getChannels();
+    return this._channelManager?.getChannels() || [];
   }
 
   // Text manager methods
+  /**
+   * @param {any} [options]
+   */
   async initializeText(options = {}) {
     this._validateState([SERVICE_STATE.READY, SERVICE_STATE.ACTIVE]);
     if (this._textManager) {
@@ -192,6 +251,9 @@ class MeshService extends EventEmitter {
   getTextManager() { return this._textManager; }
 
   // Audio methods
+  /**
+   * @param {any} [options]
+   */
   async initializeAudio(options = {}) {
     this._validateState([SERVICE_STATE.READY, SERVICE_STATE.ACTIVE]);
     if (this._audioManager) {
@@ -204,6 +266,10 @@ class MeshService extends EventEmitter {
 
   getAudioManager() { return this._audioManager; }
 
+  /**
+   * @param {string} peerId
+   * @param {any} voiceMessage
+   */
   async sendVoiceMessage(peerId, voiceMessage) {
     this._validateState([SERVICE_STATE.ACTIVE]);
     if (!this._audioManager) {
@@ -212,6 +278,9 @@ class MeshService extends EventEmitter {
     return this._audioManager.sendVoiceMessage(peerId, voiceMessage);
   }
 
+  /**
+   * @param {string} peerId
+   */
   async requestAudioStream(peerId) {
     this._validateState([SERVICE_STATE.ACTIVE]);
     if (!this._audioManager) {
@@ -228,7 +297,7 @@ class MeshService extends EventEmitter {
       EVENTS.CHANNEL_JOINED, EVENTS.CHANNEL_LEFT, EVENTS.CHANNEL_MESSAGE,
       EVENTS.CHANNEL_MEMBER_JOINED, EVENTS.CHANNEL_MEMBER_LEFT
     ];
-    textEvents.forEach(e => this._textManager.on(e, d => this.emit(e, d)));
+    textEvents.forEach((/** @type {string} */ e) => this._textManager.on(e, (/** @type {any} */ d) => this.emit(e, d)));
   }
 
   _setupAudioEventForwarding() {
@@ -237,9 +306,13 @@ class MeshService extends EventEmitter {
       EVENTS.AUDIO_STREAM_REQUEST, EVENTS.AUDIO_STREAM_STARTED, EVENTS.AUDIO_STREAM_ENDED,
       EVENTS.VOICE_MESSAGE_RECEIVED, EVENTS.VOICE_MESSAGE_SENT, EVENTS.VOICE_MESSAGE_PROGRESS
     ];
-    audioEvents.forEach(e => this._audioManager.on(e, d => this.emit(e, d)));
+    audioEvents.forEach((/** @type {string} */ e) => this._audioManager.on(e, (/** @type {any} */ d) => this.emit(e, d)));
   }
 
+  /**
+   * @param {string} peerId
+   * @param {Uint8Array} data
+   */
   async _sendRaw(peerId, data) {
     if (this._state === SERVICE_STATE.DESTROYED || !this._transport) {
       return; // Silently ignore sends after destroy
@@ -251,8 +324,8 @@ class MeshService extends EventEmitter {
     return {
       state: this._state, identity: this.getIdentity(),
       peerCount: this.getConnectedPeers().length, securedPeerCount: this.getSecuredPeers().length,
-      channelCount: this._channelManager?.getChannels().length || 0,
-      sessionCount: this._sessionManager?.getAllSessionPeerIds().length || 0,
+      channelCount: this._channelManager?.getChannels()?.length || 0,
+      sessionCount: this._sessionManager?.getAllSessionPeerIds()?.length || 0,
       hasTextManager: !!this._textManager,
       hasAudioManager: !!this._audioManager
     };
@@ -260,12 +333,18 @@ class MeshService extends EventEmitter {
 
   getState() { return this._state; }
 
+  /**
+   * @param {string} newState
+   */
   _setState(newState) {
     const oldState = this._state;
     this._state = newState;
     this.emit(EVENTS.STATE_CHANGED, { oldState, newState });
   }
 
+  /**
+   * @param {string[]} allowed
+   */
   _validateState(allowed) {
     if (!allowed.includes(this._state)) {
       throw new MeshError(`Invalid state: ${this._state}`, ERROR_CODE.E003);
@@ -276,13 +355,15 @@ class MeshService extends EventEmitter {
 
   _createKeyManager() {
     const { createProvider } = require('../crypto/AutoCrypto');
+    /** @type {any} */
     let provider;
+    /** @type {any} */
     let keyPair;
 
     try {
       provider = createProvider('auto');
       keyPair = provider.generateKeyPair();
-    } catch (e) {
+    } catch (/** @type {any} */ e) {
       // If no crypto provider is available, return a minimal fallback
       // that generates random keys using basic randomBytes
       const { randomBytes } = require('../utils/bytes');
@@ -291,7 +372,7 @@ class MeshService extends EventEmitter {
         getStaticKeyPair: () => keyPair,
         getPublicKey: () => keyPair.publicKey,
         exportIdentity: () => ({ publicKey: Array.from(keyPair.publicKey) }),
-        importIdentity: (id) => {
+        importIdentity: (/** @type {any} */ id) => {
           if (id && id.publicKey) {
             keyPair.publicKey = new Uint8Array(id.publicKey);
           }
@@ -310,7 +391,7 @@ class MeshService extends EventEmitter {
         publicKey: Array.from(keyPair.publicKey),
         secretKey: Array.from(keyPair.secretKey)
       }),
-      importIdentity: (id) => {
+      importIdentity: (/** @type {any} */ id) => {
         if (id && id.publicKey) {
           keyPair.publicKey = new Uint8Array(id.publicKey);
         }
@@ -322,7 +403,7 @@ class MeshService extends EventEmitter {
   }
 
   _setupEventForwarding() {
-    const fwd = (em, evts) => evts.forEach(e => em.on(e, d => this.emit(e, d)));
+    const fwd = (/** @type {any} */ em, /** @type {string[]} */ evts) => evts.forEach((/** @type {string} */ e) => em.on(e, (/** @type {any} */ d) => this.emit(e, d)));
     fwd(this._handshakeManager, [EVENTS.HANDSHAKE_STARTED, EVENTS.HANDSHAKE_PROGRESS,
       EVENTS.HANDSHAKE_COMPLETE, EVENTS.HANDSHAKE_FAILED]);
     fwd(this._channelManager, [EVENTS.CHANNEL_JOINED, EVENTS.CHANNEL_LEFT,
@@ -330,15 +411,18 @@ class MeshService extends EventEmitter {
   }
 
   _setupTransportListeners() {
-    this._transport.on('message', d => this._handleIncoming(d));
-    this._transport.on('peerConnected', d => this.emit(EVENTS.PEER_CONNECTED, d));
-    this._transport.on('peerDisconnected', d => this.emit(EVENTS.PEER_DISCONNECTED, d));
+    this._transport.on('message', (/** @type {any} */ d) => this._handleIncoming(d));
+    this._transport.on('peerConnected', (/** @type {any} */ d) => this.emit(EVENTS.PEER_CONNECTED, d));
+    this._transport.on('peerDisconnected', (/** @type {any} */ d) => this.emit(EVENTS.PEER_DISCONNECTED, d));
   }
 
+  /**
+   * @param {any} param0
+   */
   _handleIncoming({ peerId, data }) {
     const type = data[0], payload = data.subarray(1);
     if (type >= MESSAGE_TYPE.HANDSHAKE_INIT && type <= MESSAGE_TYPE.HANDSHAKE_FINAL) {
-      this._handshakeManager.handleIncomingHandshake(peerId, type, payload, this._transport);
+      this._handshakeManager?.handleIncomingHandshake(peerId, type, payload, this._transport);
     } else if (type === MESSAGE_TYPE.CHANNEL_MESSAGE) {
       if (this._textManager) {
         this._textManager.handleIncomingMessage(peerId, type, payload);
@@ -351,7 +435,7 @@ class MeshService extends EventEmitter {
           const parsed = JSON.parse(decoded);
           channelId = parsed.channelId || '';
           content = parsed.content ? new TextEncoder().encode(parsed.content) : payload;
-        } catch (e) {
+        } catch (/** @type {any} */ e) {
           // If not JSON, try to extract channelId as length-prefixed string
           if (payload.length > 1) {
             const channelIdLen = payload[0];
@@ -361,7 +445,7 @@ class MeshService extends EventEmitter {
             }
           }
         }
-        this._channelManager.handleChannelMessage({ channelId, senderId: peerId, content });
+        this._channelManager?.handleChannelMessage({ channelId, senderId: peerId, content });
       }
     } else if (type >= MESSAGE_TYPE.VOICE_MESSAGE_START && type <= MESSAGE_TYPE.AUDIO_STREAM_END) {
       if (this._audioManager) {