react-native-ble-mesh 2.0.0 → 2.1.2

package/README.md

@@ -558,7 +558,7 @@ react-native-ble-mesh/
 │   └── hooks/                # React hooks
 ├── docs/                     # Guides & specs
 ├── app.plugin.js             # Expo plugin entry
-└── __tests__/                # 432 tests, 0 failures ✅
+└── __tests__/                # 433 tests, 0 failures ✅
 ```
 
 ---
@@ -579,7 +579,7 @@ react-native-ble-mesh/
 ## Testing
 
 ```bash
-npm test             # Run all 432 tests
+npm test             # Run all 433 tests
 npm run test:coverage  # With coverage report
 ```
 

package/docs/OPTIMIZATION.md

@@ -1,70 +1,183 @@
-# Optimization & Technical Improvements
+# Performance Optimization Guide
 
-## Summary of Changes
+## v2.1.0 Performance Overhaul
 
-### 🔴 Breaking: Crypto Module Removed
-The pure JavaScript cryptographic implementations (`src/crypto/`) have been **removed entirely**. This includes:
-- X25519 key exchange (pure JS BigInt — extremely slow)
-- ChaCha20-Poly1305 AEAD encryption
-- SHA-256 hashing
-- HMAC-SHA256
-- HKDF key derivation
-- Noise Protocol XX handshake
+Version 2.1.0 is a comprehensive performance optimization release targeting React Native speed, reduced GC pressure, and elimination of memory leaks. All changes are non-breaking.
 
-**Why:** Pure JS BigInt field arithmetic for X25519 is orders of magnitude slower than native implementations. On mobile devices, this caused:
-- ~100ms+ per key exchange (vs ~1ms with native)
-- Battery drain from CPU-intensive crypto
-- UI thread blocking on Hermes/JSC
+### Key Principles Applied
+
+1. **Zero-copy where possible** — Use `Uint8Array.subarray()` instead of `slice()` for read-only views
+2. **Cache singletons** — `TextEncoder`, `TextDecoder`, crypto providers, hex lookup tables
+3. **Avoid allocation in hot paths** — Inline computations, reuse buffers, pre-compute constants
+4. **O(1) over O(n)** — Circular buffers, running sums, pre-computed Sets
+5. **Clean up resources** — Clear timers, remove event listeners, bound map growth
+
+---
+
+## Hot Path Optimizations
+
+### Message Processing Pipeline
+
+Every message flows through: transport → deserialize → dedup → route → serialize → transport. Each stage was optimized:
+
+| Stage | Before | After | Improvement |
+|-------|--------|-------|-------------|
+| Deserialize header | 3x `slice()` copies | 0 copies (`subarray()`) | ~3x fewer allocations |
+| Deserialize payload | 1x `slice()` copy | 0 copies (`subarray()`) | Zero-copy payload |
+| CRC32 checksum | `slice(0, 44)` copy | `subarray(0, 44)` view | Zero-copy |
+| BloomFilter check | `new TextEncoder()` + array alloc | Cached encoder, inlined positions | 3 fewer allocations/msg |
+| BloomFilter fill ratio | O(n) bit scan | O(1) running counter | Constant time |
+| Serialize header | `slice(0, 44)` for CRC | `subarray(0, 44)` view | Zero-copy |
+| Hex conversion | `Array.from().map().join()` | Pre-computed lookup table | ~5x faster |
+| UUID generation | 16 temp strings + join | Hex table + concatenation | ~3x faster |
+| Encrypt/Decrypt nonce | `new Uint8Array(24)` per call | Pre-allocated per session | 0 allocations |
+
+### TextEncoder/TextDecoder Caching
+
+Before v2.1.0, `new TextEncoder()` was called on every:
+- Message validation (byte length check)
+- Message encoding (broadcast, private, channel)
+- BloomFilter dedup check (string → bytes)
+- File chunk encoding (per-chunk in loop!)
+- Protocol serialization (string payloads)
+- Read receipt handling (per-receipt in loop)
+
+Now: **One singleton per module**, created once at import time.
+
+### Crypto Provider Caching
+
+- `AutoCrypto.detectProvider()` — Now caches the singleton result
+- `QuickCryptoProvider` — Caches `require('tweetnacl')` result instead of calling per encrypt/decrypt
+- DER header buffers for X25519 — Hoisted to module level (were re-created from hex per handshake)
+
+---
+
+## Memory Leak Fixes
+
+### Timer Leaks
+
+| Location | Issue | Fix |
+|----------|-------|-----|
+| `MeshNetwork.sendFile()` | Per-chunk timeout timers never cleared on success | `clearTimeout()` in both success/error paths |
+| `DedupManager._resetBloomFilter()` | Grace period timer leaked on repeated resets | Store timer ID, clear on reset/destroy |
+
+### Event Listener Leaks
+
+| Location | Issue | Fix |
+|----------|-------|-----|
+| `MultiTransport._wireTransport()` | Handlers never removed across start/stop | Store references, remove in `stop()` |
+| `useMesh.js` initialize | Listeners stacked on re-init | Store in refs, remove old before adding new |
+| `AppStateManager` | `.bind()` per initialize, old subscription not removed | Bind once in constructor, remove old sub |
+
+### Unbounded Growth
+
+| Location | Issue | Fix |
+|----------|-------|-----|
+| `NetworkMonitor._pendingMessages` | Undelivered messages never removed | Cleanup entries older than `nodeTimeoutMs` |
+| `ConnectionQuality._peers` | Timer runs with 0 peers | Stop timer when last peer removed |
+| `BLETransport.disconnectFromPeer()` | Write queue/writing maps not cleaned | Added cleanup in disconnect |
+
+---
+
+## Data Structure Improvements
+
+### Circular Buffers (O(n) → O(1))
+
+`Array.shift()` is O(n) because it re-indexes all elements. For sliding windows that shift on every sample, this was a significant cost.
+
+**Replaced with circular buffers:**
+- `NetworkMonitor._latencies` → `Float64Array` ring buffer with running sum
+- `ConnectionQuality._rssiSamples` → `Float64Array` ring buffer with running sum
+- `ConnectionQuality._latencySamples` → `Float64Array` ring buffer with running sum
 
-**What to use instead:**
-- [`tweetnacl`](https://www.npmjs.com/package/tweetnacl) — Lightweight, audited, works everywhere (recommended)
-- [`libsodium-wrappers`](https://www.npmjs.com/package/libsodium-wrappers) — Full-featured, WASM-based
-- [`react-native-quick-crypto`](https://www.npmjs.com/package/react-native-quick-crypto) — Native crypto for RN (fastest)
+Average computation is now O(1) via running sum instead of O(n) `reduce()`.
 
-Consumers should implement their own encryption layer using these established libraries.
+### Pre-Computed Sets (O(n) → O(1))
 
-### 🟢 Bug Fixes
+`Object.values(ENUM).includes(value)` creates an array and does linear scan on every call.
 
-1. **MeshNetwork restart** — Fixed crash when calling `start()` after `stop()`. The service was trying to re-initialize (state check failed). Now skips initialization if already initialized.
+**Replaced with module-level `Set`s:**
+- `Peer.setConnectionState()` — `CONNECTION_STATE_SET.has(state)`
+- `BatteryOptimizer.setMode()` — `BATTERY_MODE_SET.has(mode)`
 
-2. **MockTransport auto-ID** — `MockTransport` now auto-generates a `localPeerId` if none provided, preventing "localPeerId required" errors when linking transports.
+### Direct Map Iteration
 
-3. **Error message clarity** — All error classes (MeshError, ValidationError, ConnectionError, etc.) now prefix messages with the error class name (e.g., `"ValidationError: Invalid type"`), making error identification easier in catch blocks and logs.
+`Array.from(map.values()).filter(...)` creates two arrays. Direct iteration creates one:
 
-### 🟡 Performance Optimizations
+```js
+// Before (2 arrays)
+getConnectedPeers() { return this.getAllPeers().filter(p => p.isConnected()); }
 
-4. **BLE connection timeout cleanup** — Fixed timer leak in `BLETransport.connectToPeer()`. The timeout timer was never cleared on successful connection, leaking memory. Now properly clears the timer when connection succeeds.
+// After (1 array)
+getConnectedPeers() {
+  const result = [];
+  for (const peer of this._peers.values()) {
+    if (peer.isConnected()) result.push(peer);
+  }
+  return result;
+}
+```
 
-### 🧪 Test Improvements
+Applied to: `PeerManager.getConnectedPeers()`, `getSecuredPeers()`, `getDirectPeers()`
 
-- **Fixed all 10 previously failing tests** (was 396 total, 10 failing → 344 total, 0 failing)
-- **Added new test suites:**
-  - `__tests__/transport/BLETransport.test.js` — Lifecycle, scanning, connections, broadcast, timeout handling
-  - `__tests__/transport/MockTransport.test.js` — Linking, message passing, peer simulation
-  - `__tests__/mesh/MeshNetwork.unit.test.js` — Config merging, validation, lifecycle, restart
-  - `__tests__/service/BatteryOptimizer.test.js` — Mode switching, battery levels, cleanup
-  - `__tests__/service/MeshService.test.js` — Full lifecycle, identity, peers, messaging
-  - `__tests__/platform/ios.test.js` — Background mode, MTU fragmentation, state restoration
-  - `__tests__/platform/android.test.js` — Permissions, MTU (23/512), Doze mode, memory pressure, BloomFilter FP rate
+---
 
-### 📱 Platform Compatibility Verified
+## React Native Hook Optimizations
 
-**iOS:**
-- BLE background mode behavior tested
-- MTU 185 (BLE 4.2+) fragmentation verified
-- Battery optimizer integration tested
-- Store-and-forward for state restoration
+### usePeers — Eliminated Double Re-render
 
-**Android:**
-- BLE permission denial handled gracefully
-- MTU 23 (BLE 4.0) and 512 (BLE 5.0) fragmentation tested
-- Doze mode with low-power settings verified
-- LRU cache respects size limits under memory pressure
-- BloomFilter false positive rate verified (<20% at reasonable capacity)
+Before: Every peer event called both `setPeers()` and `setLastUpdate(Date.now())`, causing two re-renders (React may batch, but not always across async boundaries).
 
-## Remaining Recommendations
+After: `lastUpdate` is a `useRef` (no re-render). Added shallow comparison to skip `setPeers()` when peers haven't actually changed.
+
+Also: `getPeer()` now uses a `useMemo` Map for O(1) lookup instead of O(n) `Array.find()`.
+
+### useMessages — Reduced Array Copies
+
+Before: 3 array copies per incoming message when over `maxMessages` (`[msg, ...prev]` + `slice(maxMessages)` + `slice(0, maxMessages)`).
+
+After: 1 array copy + in-place truncation via `updated.length = maxMessages`.
+
+---
+
+## Storage Optimization
+
+### MessageStore Payload Encoding
+
+Before: `Array.from(Uint8Array)` converted each byte to a boxed JS Number — **8x memory bloat** (1 byte → 8 bytes for Number object + array overhead).
+
+After: Base64 encoding. A 10KB payload uses ~13.3KB as base64 string (1.33x) instead of ~80KB as Number array (8x).
+
+---
+
+## Compression Optimization
+
+### LZ4 Hash Table Reuse
+
+Before: `new Int32Array(4096)` (16KB allocation) on every `_lz4Compress()` call.
+
+After: Pre-allocated in constructor, reused with `.fill(-1)` reset per call.
+
+---
+
+## WiFi Direct Base64 Fix
+
+### O(n^2) → O(n) String Building
+
+Before: Character-by-character `binary += String.fromCharCode(bytes[i])` — O(n^2) due to string immutability.
+
+After: Chunk-based `String.fromCharCode.apply(null, bytes.subarray(i, i+8192))` with final `join()` — O(n).
+
+For a 1MB file transfer, this eliminates ~1 million intermediate string allocations.
+
+---
+
+## Historical Changes (v2.0.0)
+
+### Crypto Module Removed
+The pure JavaScript cryptographic implementations (`src/crypto/`) were removed in v2.0.0. Pure JS BigInt field arithmetic for X25519 was orders of magnitude slower than native:
+- ~100ms+ per key exchange (vs ~1ms with native)
+- Battery drain from CPU-intensive crypto
+- UI thread blocking on Hermes/JSC
 
-1. **Add `tweetnacl` as peer dependency** for consumers who need encryption
-2. **Consider TypeScript migration** — current JS codebase with JSDoc is good but TS would catch more errors
-3. **Add integration tests with real BLE** — current tests use MockTransport; consider Detox/Appium for device testing
-4. **Publish to npm** with proper semver (this is a breaking change → v2.0.0)
+Replaced by the pluggable provider system: `tweetnacl`, `react-native-quick-crypto`, or `expo-crypto`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ble-mesh",
-  "version": "2.0.0",
+  "version": "2.1.2",
   "description": "React Native Bluetooth Low Energy (BLE) mesh networking library with end-to-end encryption, offline messaging, peer-to-peer communication, and Noise Protocol security for iOS and Android",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/MeshNetwork.js

@@ -23,9 +23,14 @@ const { ValidationError, MeshError } = require('./errors');
 const { FileManager } = require('./service/file');
 const { SERVICE_STATE, EVENTS } = require('./constants');
 
+/** @private Cached TextEncoder singleton – avoids per-call allocation */
+const _encoder = new TextEncoder();
+/** @private Cached TextDecoder singleton – avoids per-call allocation */
+const _decoder = new TextDecoder();
+
 /**
  * Default MeshNetwork configuration
- * @constant {Object}
+ * @constant {any}
  */
 const DEFAULT_CONFIG = Object.freeze({
   /** Display name for this node */
@@ -83,21 +88,21 @@ class MeshNetwork extends EventEmitter {
      * @param {Object} [config.encryption] - Encryption settings
      * @param {Object} [config.routing] - Routing settings
      * @param {Object} [config.compression] - Compression settings
-     * @param {Object} [config.storeAndForward] - Store and forward settings
+     * @param {any} [config.storeAndForward] - Store and forward settings
      */
   constructor(config = {}) {
     super();
 
     /**
          * Configuration
-         * @type {Object}
+         * @type {any}
          * @private
          */
     this._config = this._mergeConfig(DEFAULT_CONFIG, config);
 
     /**
          * Underlying MeshService
-         * @type {MeshService}
+         * @type {InstanceType<typeof MeshService>}
          * @private
          */
     this._service = new MeshService({
@@ -106,7 +111,7 @@ class MeshNetwork extends EventEmitter {
 
     /**
          * Transport layer
-         * @type {Transport|null}
+         * @type {any}
          * @private
          */
     this._transport = null;
@@ -175,7 +180,7 @@ class MeshNetwork extends EventEmitter {
 
     /**
          * Channel manager reference
-         * @type {Object|null}
+         * @type {any}
          * @private
          */
     this._channels = null;
@@ -197,7 +202,7 @@ class MeshNetwork extends EventEmitter {
 
   /**
      * Starts the mesh network.
-     * @param {Object} [transport] - Optional custom transport
+     * @param {any} [transport] - Optional custom transport
      * @returns {Promise<void>}
      */
   async start(transport) {
@@ -211,7 +216,7 @@ class MeshNetwork extends EventEmitter {
         const { RNBLEAdapter } = require('./transport/adapters');
         const adapter = new RNBLEAdapter();
         this._transport = new BLETransport(adapter);
-      } catch (e) {
+      } catch (/** @type {any} */ e) {
         throw new MeshError(
           'No transport provided and BLE adapter not available. ' +
           'Either pass a transport to start(), install react-native-ble-plx for BLE, ' +
@@ -247,15 +252,15 @@ class MeshNetwork extends EventEmitter {
     }
 
     // Setup file transfer events
-    this._fileManager.on('sendProgress', (info) => this.emit('fileSendProgress', info));
-    this._fileManager.on('receiveProgress', (info) => this.emit('fileReceiveProgress', info));
-    this._fileManager.on('fileReceived', (info) => this.emit('fileReceived', info));
-    this._fileManager.on('transferFailed', (info) => this.emit('fileTransferFailed', info));
-    this._fileManager.on('transferCancelled', (info) => this.emit('fileTransferCancelled', info));
+    this._fileManager.on('sendProgress', (/** @type {any} */ info) => this.emit('fileSendProgress', info));
+    this._fileManager.on('receiveProgress', (/** @type {any} */ info) => this.emit('fileReceiveProgress', info));
+    this._fileManager.on('fileReceived', (/** @type {any} */ info) => this.emit('fileReceived', info));
+    this._fileManager.on('transferFailed', (/** @type {any} */ info) => this.emit('fileTransferFailed', info));
+    this._fileManager.on('transferCancelled', (/** @type {any} */ info) => this.emit('fileTransferCancelled', info));
 
     // Start connection quality monitoring
     this._connectionQuality.start();
-    this._connectionQuality.on('qualityChanged', (quality) => {
+    this._connectionQuality.on('qualityChanged', (/** @type {any} */ quality) => {
       this.emit('connectionQualityChanged', quality);
     });
 
@@ -347,9 +352,9 @@ class MeshNetwork extends EventEmitter {
       // If peer is offline and store-forward is enabled, cache the message
       if (this._storeForward && this._isPeerOffline(peerId)) {
         const payload = this._encodeMessage(text);
-        await this._storeForward.cacheForOfflinePeer(peerId, payload, {
+        await this._storeForward.cacheForOfflinePeer(peerId, payload, /** @type {any} */ ({
           needsEncryption: true
-        });
+        }));
         this.emit('messageCached', { peerId, text });
         return 'cached';
       }
@@ -405,7 +410,7 @@ class MeshNetwork extends EventEmitter {
 
   /**
      * Gets list of joined channels.
-     * @returns {Object[]} Channels
+     * @returns {any[]} Channels
      */
   getChannels() {
     return this._service.getChannels();
@@ -417,7 +422,7 @@ class MeshNetwork extends EventEmitter {
 
   /**
      * Gets all known peers.
-     * @returns {Object[]} Array of peers
+     * @returns {any[]} Array of peers
      */
   getPeers() {
     return this._service.getPeers();
@@ -425,7 +430,7 @@ class MeshNetwork extends EventEmitter {
 
   /**
      * Gets connected peers.
-     * @returns {Object[]} Connected peers
+     * @returns {any[]} Connected peers
      */
   getConnectedPeers() {
     return this._service.getConnectedPeers();
@@ -433,7 +438,7 @@ class MeshNetwork extends EventEmitter {
 
   /**
      * Gets peers with secure sessions.
-     * @returns {Object[]} Secured peers
+     * @returns {any[]} Secured peers
      */
   getSecuredPeers() {
     return this._service.getSecuredPeers();
@@ -463,7 +468,7 @@ class MeshNetwork extends EventEmitter {
 
   /**
      * Gets network health metrics.
-     * @returns {Object} Health report
+     * @returns {any} Health report
      */
   getNetworkHealth() {
     return this._monitor.generateHealthReport();
@@ -472,7 +477,7 @@ class MeshNetwork extends EventEmitter {
   /**
      * Gets detailed health for a specific peer.
      * @param {string} peerId - Peer ID
-     * @returns {Object|null} Node health
+     * @returns {any} Node health
      */
   getPeerHealth(peerId) {
     return this._monitor.getNodeHealth(peerId);
@@ -557,7 +562,7 @@ class MeshNetwork extends EventEmitter {
      * @param {Uint8Array} fileInfo.data - File data
      * @param {string} fileInfo.name - File name
      * @param {string} [fileInfo.mimeType] - MIME type
-     * @returns {Object} Transfer info with id and event emitter
+     * @returns {Promise<any>} Transfer info with id and event emitter
      */
   async sendFile(peerId, fileInfo) {
     this._validateRunning();
@@ -567,17 +572,19 @@ class MeshNetwork extends EventEmitter {
       throw new ValidationError('File must have data and name', 'E800');
     }
 
+    /** @type {any} */
     const transfer = this._fileManager.prepareSend(peerId, fileInfo);
 
     // Send offer (JSON is OK for metadata, but use binary type marker)
     const offerJson = JSON.stringify(transfer.offer);
-    const offerBytes = new TextEncoder().encode(offerJson);
+    const offerBytes = _encoder.encode(offerJson);
     const offerPayload = new Uint8Array(1 + offerBytes.length);
     offerPayload[0] = 0x01; // Binary type marker for OFFER
     offerPayload.set(offerBytes, 1);
     await this._service._sendRaw(peerId, offerPayload);
 
     // Send chunks sequentially using binary protocol
+    const transferIdBytes = _encoder.encode(transfer.id);
     for (let i = 0; i < transfer.chunks.length; i++) {
       // Check if still running (handles app backgrounding)
       if (this._state !== 'running') {
@@ -588,7 +595,6 @@ class MeshNetwork extends EventEmitter {
       const chunk = transfer.chunks[i];
 
       // Binary format: [type(1)] [transferIdLen(1)] [transferId(N)] [index(2)] [data(M)]
-      const transferIdBytes = new TextEncoder().encode(transfer.id);
       const header = new Uint8Array(1 + 1 + transferIdBytes.length + 2);
       let offset = 0;
       header[offset++] = 0x02; // Binary type marker for CHUNK
@@ -605,13 +611,16 @@ class MeshNetwork extends EventEmitter {
 
       // Add per-chunk timeout (10 seconds)
       const sendPromise = this._service._sendRaw(peerId, payload);
-      const timeoutPromise = new Promise((_, reject) =>
-        setTimeout(() => reject(new Error('Chunk send timeout')), 10000)
-      );
+      let timeoutId;
+      const timeoutPromise = new Promise((/** @type {any} */ _, /** @type {any} */ reject) => {
+        timeoutId = setTimeout(() => reject(new Error('Chunk send timeout')), 10000);
+      });
 
       try {
         await Promise.race([sendPromise, timeoutPromise]);
-      } catch (err) {
+        clearTimeout(timeoutId);
+      } catch (/** @type {any} */ err) {
+        clearTimeout(timeoutId);
         this._fileManager.cancelTransfer(transfer.id);
         this.emit('fileTransferFailed', {
           id: transfer.id, name: fileInfo.name, error: err.message
@@ -627,7 +636,7 @@ class MeshNetwork extends EventEmitter {
 
   /**
      * Gets active file transfers
-     * @returns {Object} { outgoing: [], incoming: [] }
+     * @returns {any} { outgoing: [], incoming: [] }
      */
   getActiveTransfers() {
     return this._fileManager.getActiveTransfers();
@@ -648,7 +657,7 @@ class MeshNetwork extends EventEmitter {
   /**
      * Gets connection quality for a specific peer.
      * @param {string} peerId - Peer ID
-     * @returns {Object|null} Quality report
+     * @returns {any} Quality report
      */
   getConnectionQuality(peerId) {
     return this._connectionQuality.getQuality(peerId);
@@ -656,7 +665,7 @@ class MeshNetwork extends EventEmitter {
 
   /**
      * Gets connection quality for all peers.
-     * @returns {Object[]} Array of quality reports
+     * @returns {any[]} Array of quality reports
      */
   getAllConnectionQuality() {
     return this._connectionQuality.getAllQuality();
@@ -668,7 +677,7 @@ class MeshNetwork extends EventEmitter {
 
   /**
      * Gets the network status.
-     * @returns {Object} Status
+     * @returns {any} Status
      */
   getStatus() {
     const identity = this._state === 'running' ? this._service.getIdentity() : null;
@@ -685,7 +694,7 @@ class MeshNetwork extends EventEmitter {
 
   /**
      * Gets the identity information.
-     * @returns {Object} Identity
+     * @returns {any} Identity
      */
   getIdentity() {
     return this._service.getIdentity();
@@ -706,9 +715,9 @@ class MeshNetwork extends EventEmitter {
 
   /**
      * Merges configuration with defaults.
-     * @param {Object} defaults - Default config
-     * @param {Object} custom - Custom config
-     * @returns {Object} Merged config
+     * @param {any} defaults - Default config
+     * @param {any} custom - Custom config
+     * @returns {any} Merged config
      * @private
      */
   _mergeConfig(defaults, custom) {
@@ -730,12 +739,12 @@ class MeshNetwork extends EventEmitter {
      */
   _setupEventForwarding() {
     // Forward service events with PRD-style naming
-    this._service.on(EVENTS.PEER_DISCOVERED, (peer) => {
+    this._service.on(EVENTS.PEER_DISCOVERED, (/** @type {any} */ peer) => {
       this._monitor.trackPeerDiscovered(peer.id);
       this.emit('peerDiscovered', peer);
     });
 
-    this._service.on(EVENTS.PEER_CONNECTED, (peer) => {
+    this._service.on(EVENTS.PEER_CONNECTED, (/** @type {any} */ peer) => {
       if (peer.rssi) {
         this._connectionQuality.recordRssi(peer.id, peer.rssi);
       }
@@ -746,13 +755,13 @@ class MeshNetwork extends EventEmitter {
       }
     });
 
-    this._service.on(EVENTS.PEER_DISCONNECTED, (peer) => {
+    this._service.on(EVENTS.PEER_DISCONNECTED, (/** @type {any} */ peer) => {
       this._monitor.trackPeerDisconnected(peer.id);
       this._connectionQuality.removePeer(peer.id);
       this.emit('peerDisconnected', peer);
     });
 
-    this._service.on('message', (message) => {
+    this._service.on('message', (/** @type {any} */ message) => {
       this._monitor.trackMessageReceived(message.senderId);
       this.emit('messageReceived', {
         from: message.senderId,
@@ -762,7 +771,7 @@ class MeshNetwork extends EventEmitter {
       });
     });
 
-    this._service.on('private-message', (message) => {
+    this._service.on('private-message', (/** @type {any} */ message) => {
       this.emit('directMessage', {
         from: message.senderId,
         text: message.content,
@@ -770,7 +779,7 @@ class MeshNetwork extends EventEmitter {
       });
     });
 
-    this._service.on('channel-message', (message) => {
+    this._service.on('channel-message', (/** @type {any} */ message) => {
       this.emit('channelMessage', {
         channel: message.channelId,
         from: message.senderId,
@@ -779,22 +788,22 @@ class MeshNetwork extends EventEmitter {
       });
     });
 
-    this._service.on('message-delivered', (info) => {
+    this._service.on('message-delivered', (/** @type {any} */ info) => {
       this._monitor.trackMessageDelivered(info.messageId);
       this.emit('messageDelivered', info);
     });
 
-    this._service.on('error', (error) => {
+    this._service.on('error', (/** @type {any} */ error) => {
       this.emit('error', error);
     });
 
     // Forward monitor events
-    this._monitor.on('health-changed', (info) => {
+    this._monitor.on('health-changed', (/** @type {any} */ info) => {
       this.emit('networkHealthChanged', info);
     });
 
     // Forward emergency events
-    this._emergencyManager.on('panic-wipe-completed', (result) => {
+    this._emergencyManager.on('panic-wipe-completed', (/** @type {any} */ result) => {
       this.emit('dataWiped', result);
     });
   }
@@ -815,17 +824,18 @@ class MeshNetwork extends EventEmitter {
   async _deliverCachedMessages(peerId) {
     if (!this._storeForward) { return; }
 
-    const sendFn = async (payload) => {
+    const sendFn = async (/** @type {any} */ payload) => {
       // Re-encrypt and send via the proper encrypted channel
       try {
-        const text = new TextDecoder().decode(payload);
+        const text = _decoder.decode(payload);
         await this._service.sendPrivateMessage(peerId, text);
-      } catch (e) {
+      } catch (/** @type {any} */ e) {
         // Fallback to raw send if encryption fails
         await this._service._sendRaw(peerId, payload);
       }
     };
 
+    /** @type {any} */
     const result = await this._storeForward.deliverCachedMessages(peerId, sendFn);
 
     if (result.delivered > 0) {
@@ -849,7 +859,7 @@ class MeshNetwork extends EventEmitter {
     // Clear store and forward cache
     if (this._storeForward) {
       this._emergencyManager.registerClearer(async () => {
-        this._storeForward.clear();
+        this._storeForward?.clear();
       });
     }
 
@@ -892,7 +902,7 @@ class MeshNetwork extends EventEmitter {
      * @private
      */
   _encodeMessage(text) {
-    return new TextEncoder().encode(text);
+    return _encoder.encode(text);
   }
 
   /**
@@ -936,7 +946,7 @@ class MeshNetwork extends EventEmitter {
     }
 
     // Check size limit (UTF-8 encoded)
-    const byteLength = new TextEncoder().encode(text).length;
+    const byteLength = _encoder.encode(text).length;
     if (byteLength > MeshNetwork.MAX_MESSAGE_SIZE) {
       throw ValidationError.outOfRange('text', byteLength, {
         min: 1,