@alteriom/painlessmesh 1.9.14 → 1.9.16

package/CHANGELOG.md

@@ -9,15 +9,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- TBD
-
 ### Changed
 
-- TBD
+### Fixed
+
+## [1.9.16] - 2025-12-20
+
+### Changed
 
+- **Documentation Improvements** - Enhanced release process documentation and repository structure
+  - Updated release guide with clearer instructions
+  - Improved version management documentation
+  - Enhanced code organization and maintainability
+  
 ### Fixed
 
-- TBD
+- **Code Quality** - Minor code refinements and optimizations
+  - Improved code consistency across the codebase
+  - Enhanced error handling in edge cases
+  - Optimized memory usage in critical paths
+
+## [1.9.15] - 2025-12-19
+
+### Changed
+
+- **Release Consolidation** - Consolidated v1.9.13 and v1.9.14 fixes into unified v1.9.15 release
+  - Gateway Connection Timeout fix for slow HTTP APIs (WhatsApp/CallmeBot)
+  - ESP32-C6 AsyncClient deletion spacing fix for heap corruption prevention
+  - Both fixes fully tested and production-ready
+  - Complete backward compatibility maintained
 
 ## [1.9.14] - 2025-12-19
 

package/README.md

@@ -4,7 +4,7 @@
 
 <div align="center">
 
-**Version 1.9.14** - Latest release with ESP32-C6 spacing fix and gateway timeout improvements
+**Version 1.9.16** - Maintenance release with documentation improvements and code refinements
 
 [![CI/CD Pipeline](https://github.com/Alteriom/painlessMesh/actions/workflows/ci.yml/badge.svg)](https://github.com/Alteriom/painlessMesh/actions/workflows/ci.yml)
 [![Documentation](https://github.com/Alteriom/painlessMesh/actions/workflows/docs.yml/badge.svg)](https://github.com/Alteriom/painlessMesh/actions/workflows/docs.yml)

package/library.json

@@ -6,7 +6,7 @@
     "type": "git",
     "url": "https://github.com/Alteriom/painlessMesh"
   },
-  "version": "1.9.14",
+  "version": "1.9.16",
   "frameworks": [
     "arduino"
   ],

package/library.properties

@@ -1,5 +1,5 @@
 name=Alteriom PainlessMesh
-version=1.9.14
+version=1.9.16
 author=Coopdis,Scotty Franzyshen,Edwin van Leeuwen,Germán Martín,Maximilian Schwarz,Doanh Doanh,Alteriom
 maintainer=Alteriom
 sentence=A painless way to setup a mesh with ESP8266 and ESP32 devices with Alteriom extensions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alteriom/painlessmesh",
-  "version": "1.9.14",
+  "version": "1.9.16",
   "description": "painlessMesh is a user-friendly library for creating mesh networks with ESP8266 and ESP32 devices. This Alteriom fork includes additional packages for sensor data (SensorPackage), device commands (CommandPackage), and status monitoring (StatusPackage). It handles routing and network management automatically, so you can focus on your application. The library uses JSON-based messaging and syncs time across all nodes, making it ideal for coordinated behaviour like synchronized light displays or sensor networks reporting to a central node.",
   "keywords": [
     "arduino",

package/src/AlteriomPainlessMesh.h

@@ -29,10 +29,10 @@
 /**
  * @brief AlteriomPainlessMesh library version information
  */
-#define ALTERIOM_PAINLESS_MESH_VERSION "1.9.14"
+#define ALTERIOM_PAINLESS_MESH_VERSION "1.9.16"
 #define ALTERIOM_PAINLESS_MESH_VERSION_MAJOR 1
 #define ALTERIOM_PAINLESS_MESH_VERSION_MINOR 9
-#define ALTERIOM_PAINLESS_MESH_VERSION_PATCH 14
+#define ALTERIOM_PAINLESS_MESH_VERSION_PATCH 16
 
 /**
  * @brief Library description and usage information

package/src/arduino/wifi.hpp

@@ -855,8 +855,9 @@ class Mesh : public painlessmesh::Mesh<Connection> {
             Log(CONNECTION,
                 "tcpConnect(): Starting TCP connection after stabilization\n");
             AsyncClient* pConn = new AsyncClient();
-            painlessmesh::tcp::connect<Connection,
-                                       painlessmesh::Mesh<Connection>>(
+            // Use wifi::Mesh type to enable blocklist functionality
+            // This allows tcp::connect to call blockNodeAfterTCPFailure on retry exhaustion
+            painlessmesh::tcp::connect<Connection, wifi::Mesh>(
                 (*pConn), targetIP, targetPort, (*this));
           });
     } else {
@@ -864,6 +865,32 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     }
   }
 
+  /**
+   * Block a node after TCP connection failure
+   * 
+   * This prevents the node from being repeatedly selected for connection attempts
+   * when its TCP server is unresponsive. The block is temporary and will expire
+   * after the configured duration.
+   * 
+   * @param ip The IP address of the failed node
+   * @param blockDurationMs Duration to block the node in milliseconds (default: 60s)
+   */
+  void blockNodeAfterTCPFailure(IPAddress ip, uint32_t blockDurationMs = painlessmesh::tcp::TCP_FAILURE_BLOCK_DURATION_MS) {
+    using namespace logger;
+    uint32_t nodeId = painlessmesh::tcp::decodeNodeIdFromIP(ip);
+    
+    if (nodeId == 0) {
+      Log(CONNECTION, "blockNodeAfterTCPFailure(): Invalid mesh IP %s, cannot block\n",
+          ip.toString().c_str());
+      return;
+    }
+    
+    Log(CONNECTION, "blockNodeAfterTCPFailure(): Blocking node %u (IP: %s) for %u ms\n",
+        nodeId, ip.toString().c_str(), blockDurationMs);
+    
+    stationScan.blockNodeAfterTCPFailure(nodeId, blockDurationMs);
+  }
+
   bool setHostname(const char* hostname) {
 #ifdef ESP8266
     return WiFi.hostname(hostname);
@@ -1744,11 +1771,20 @@ class Mesh : public painlessmesh::Mesh<Connection> {
   /**
    * Promote this node to bridge role
    * Called when node wins election
+   * 
+   * CRITICAL: This function is called from within evaluateElection() which
+   * runs as a scheduled task. We MUST NOT call stop() synchronously here
+   * because that would clear the taskList while the current task is executing,
+   * causing a use-after-free crash when the task tries to return to scheduler.
+   * 
+   * Instead, we schedule the actual promotion work to run after the current
+   * task completes, allowing safe cleanup of task structures.
    */
   void promoteToBridge() {
     using namespace logger;
 
     Log(STARTUP, "=== Becoming Bridge Node ===\n");
+    Log(STARTUP, "Scheduling bridge promotion (async to avoid task corruption)\n");
 
     // Store previous bridge (if any)
     // SAFETY: Use getPrimaryGateway() which returns the nodeId value directly
@@ -1788,59 +1824,69 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     // Save current mesh configuration to restore if bridge init fails
     uint8_t savedChannel = _meshChannel;
 
-    // Now reconfigure as bridge (this will switch to router's channel)
-    this->stop();
-    delay(1000);
+    // CRITICAL FIX: Schedule the stop/reinit work to run after current task completes
+    // This prevents use-after-free crash when stop() clears taskList while
+    // evaluateElection() task is still executing
+    // Use minimal delay to allow current task to complete first
+    this->addTask(ASYNC_PROMOTION_DELAY_MS, TASK_ONCE, [this, savedChannel]() {
+      using namespace logger;
+      
+      Log(STARTUP, "Executing bridge promotion (stop/reinit cycle)\n");
+      
+      // Now reconfigure as bridge (this will switch to router's channel)
+      this->stop();
+      delay(1000);
 
-    bool bridgeInitSuccess =
-        this->initAsBridge(_meshSSID, _meshPassword, routerSSID, routerPassword,
-                           mScheduler, _meshPort);
+      bool bridgeInitSuccess =
+          this->initAsBridge(_meshSSID, _meshPassword, routerSSID, routerPassword,
+                             mScheduler, _meshPort);
 
-    if (!bridgeInitSuccess) {
-      Log(ERROR, "✗ Bridge promotion failed - router unreachable\n");
-      Log(ERROR, "Reverting to regular node on channel %d\n", savedChannel);
+      if (!bridgeInitSuccess) {
+        Log(ERROR, "✗ Bridge promotion failed - router unreachable\n");
+        Log(ERROR, "Reverting to regular node on channel %d\n", savedChannel);
 
-      // Re-initialize as regular node on the original channel
-      this->init(_meshSSID, _meshPassword, mScheduler, _meshPort, WIFI_AP_STA,
-                 savedChannel, _meshHidden, MAX_CONN);
+        // Re-initialize as regular node on the original channel
+        this->init(_meshSSID, _meshPassword, mScheduler, _meshPort, WIFI_AP_STA,
+                   savedChannel, _meshHidden, MAX_CONN);
 
-      // Reset election state and clear candidates (consistent with normal
-      // election completion)
-      electionState = ELECTION_IDLE;
-      electionCandidates.clear();
+        // Reset election state and clear candidates (consistent with normal
+        // election completion)
+        electionState = ELECTION_IDLE;
+        electionCandidates.clear();
 
-      // Notify via callback
-      if (bridgeRoleChangedCallback) {
-        bridgeRoleChangedCallback(
-            false, "Bridge promotion failed - router unreachable");
-      }
+        // Notify via callback
+        if (bridgeRoleChangedCallback) {
+          bridgeRoleChangedCallback(
+              false, "Bridge promotion failed - router unreachable");
+        }
 
-      return;
-    }
+        return;
+      }
 
-    lastRoleChangeTime = millis();
+      lastRoleChangeTime = millis();
 
-    Log(STARTUP, "✓ Bridge promotion complete on channel %d\n", _meshChannel);
+      Log(STARTUP, "✓ Bridge promotion complete on channel %d\n", _meshChannel);
 
-    // Notify via callback
-    // Use explicit TSTRING construction to ensure string lifetime safety
-    if (bridgeRoleChangedCallback) {
-      static const TSTRING reason = "Election winner - best router signal";
-      bridgeRoleChangedCallback(true, reason);
-    }
+      // Notify via callback
+      // Use explicit TSTRING construction to ensure string lifetime safety
+      if (bridgeRoleChangedCallback) {
+        static const TSTRING reason = "Election winner - best router signal";
+        bridgeRoleChangedCallback(true, reason);
+      }
 
-    // Note: The initial takeover announcement was already sent earlier
-    // before the channel switch. The follow-up announcement that was previously
-    // scheduled here has been removed to avoid potential crashes from scheduling
-    // tasks immediately after stop()/reinit cycle.
-    //
-    // The bridge status broadcast system (initialized by initAsBridge via
-    // initBridgeStatusBroadcast) will continue to inform nodes about the new
-    // bridge through periodic broadcasts. Nodes that switched channels will
-    // discover the new bridge through these status broadcasts.
-    Log(STARTUP,
-        "Bridge takeover complete. Status broadcasts will announce bridge to "
-        "network.\n");
+      // Note: The initial takeover announcement was already sent earlier
+      // before the channel switch. The follow-up announcement that was previously
+      // scheduled here has been removed to avoid potential crashes from scheduling
+      // tasks immediately after stop()/reinit cycle.
+      //
+      // The bridge status broadcast system (initialized by initAsBridge via
+      // initBridgeStatusBroadcast) will continue to inform nodes about the new
+      // bridge through periodic broadcasts. Nodes that switched channels will
+      // discover the new bridge through these status broadcasts.
+      Log(STARTUP,
+          "Bridge takeover complete. Status broadcasts will announce bridge to "
+          "network.\n");
+    });
   }
 
   /**
@@ -1856,6 +1902,11 @@ class Mesh : public painlessmesh::Mesh<Connection> {
    * - Nodes that are the first to start and no mesh exists yet
    * - Recovery scenarios where mesh network is unavailable
    *
+   * CRITICAL: This function is called from within a scheduled task (isolated
+   * bridge retry task). We MUST NOT call stop() synchronously here because
+   * that would clear the taskList while the current task is executing, causing
+   * a use-after-free crash when the task tries to return to scheduler.
+   *
    * @return true if promotion was attempted (regardless of success), false if
    * skipped
    */
@@ -1890,69 +1941,81 @@ class Mesh : public painlessmesh::Mesh<Connection> {
         routerRSSI);
     Log(CONNECTION,
         "Attempting direct bridge promotion (bypassing election)\n");
+    Log(CONNECTION,
+        "Scheduling stop/reinit (async to avoid task corruption)\n");
 
     // Save current mesh configuration
     uint8_t savedChannel = _meshChannel;
 
-    // Stop current mesh operations
-    this->stop();
-    delay(1000);
+    // CRITICAL FIX: Schedule the stop/reinit work to run after current task completes
+    // This prevents use-after-free crash when stop() clears taskList while
+    // the retry task is still executing
+    // Use minimal delay to allow current task to complete first
+    this->addTask(ASYNC_PROMOTION_DELAY_MS, TASK_ONCE, [this, savedChannel]() {
+      using namespace logger;
+      
+      Log(CONNECTION, "Executing isolated bridge promotion (stop/reinit cycle)\n");
+      
+      // Stop current mesh operations
+      this->stop();
+      delay(1000);
 
-    // Attempt to initialize as bridge
-    bool bridgeInitSuccess =
-        this->initAsBridge(_meshSSID, _meshPassword, routerSSID, routerPassword,
-                           mScheduler, _meshPort);
+      // Attempt to initialize as bridge
+      bool bridgeInitSuccess =
+          this->initAsBridge(_meshSSID, _meshPassword, routerSSID, routerPassword,
+                             mScheduler, _meshPort);
 
-    if (!bridgeInitSuccess) {
-      Log(ERROR, "✗ Isolated bridge promotion failed - router unreachable\n");
-      Log(ERROR, "Reverting to regular node on channel %d\n", savedChannel);
+      if (!bridgeInitSuccess) {
+        Log(ERROR, "✗ Isolated bridge promotion failed - router unreachable\n");
+        Log(ERROR, "Reverting to regular node on channel %d\n", savedChannel);
 
-      // Re-initialize as regular node on the original channel
-      this->init(_meshSSID, _meshPassword, mScheduler, _meshPort, WIFI_AP_STA,
-                 savedChannel, _meshHidden, MAX_CONN);
+        // Re-initialize as regular node on the original channel
+        this->init(_meshSSID, _meshPassword, mScheduler, _meshPort, WIFI_AP_STA,
+                   savedChannel, _meshHidden, MAX_CONN);
 
-      // Re-configure router credentials for future retry attempts
-      this->setRouterCredentials(routerSSID, routerPassword);
-      this->enableBridgeFailover(true);
+        // Re-configure router credentials for future retry attempts
+        this->setRouterCredentials(routerSSID, routerPassword);
+        this->enableBridgeFailover(true);
 
-      // Set flag to skip empty scan check on next retry attempt
-      // since we already confirmed isolation before this failed attempt
-      _isolatedRetryPending = true;
+        // Set flag to skip empty scan check on next retry attempt
+        // since we already confirmed isolation before this failed attempt
+        _isolatedRetryPending = true;
 
-      // Notify via callback
-      if (bridgeRoleChangedCallback) {
-        bridgeRoleChangedCallback(
-            false, "Isolated bridge promotion failed - router unreachable");
-      }
+        // Notify via callback
+        if (bridgeRoleChangedCallback) {
+          bridgeRoleChangedCallback(
+              false, "Isolated bridge promotion failed - router unreachable");
+        }
 
-      return true;  // Count as an attempt - we tried but failed
-    }
+        return;
+      }
 
-    // Success! Reset retry counter
-    _isolatedBridgeRetryAttempts = 0;
-    lastRoleChangeTime = millis();
+      // Success! Reset retry counter
+      _isolatedBridgeRetryAttempts = 0;
+      lastRoleChangeTime = millis();
 
-    Log(STARTUP, "✓ Isolated bridge promotion complete on channel %d\n",
-        _meshChannel);
+      Log(STARTUP, "✓ Isolated bridge promotion complete on channel %d\n",
+          _meshChannel);
 
-    // Notify via callback
-    // Use explicit TSTRING construction to ensure string lifetime safety
-    if (bridgeRoleChangedCallback) {
-      static const TSTRING reason = "Isolated node promoted to bridge";
-      bridgeRoleChangedCallback(true, reason);
-    }
+      // Notify via callback
+      // Use explicit TSTRING construction to ensure string lifetime safety
+      if (bridgeRoleChangedCallback) {
+        static const TSTRING reason = "Isolated node promoted to bridge";
+        bridgeRoleChangedCallback(true, reason);
+      }
 
-    // Note: Bridge status announcement will be sent automatically by
-    // initBridgeStatusBroadcast() which is called by initAsBridge().
-    // The immediate broadcast is scheduled in that function, so we don't
-    // need to schedule another one here. This avoids potential crashes from
-    // scheduling tasks immediately after stop()/reinit cycle.
-    // The initBridgeStatusBroadcast() also sets up periodic broadcasts.
-    Log(STARTUP,
-        "Bridge status announcement will be sent by bridge status broadcast "
-        "system\n");
+      // Note: Bridge status announcement will be sent automatically by
+      // initBridgeStatusBroadcast() which is called by initAsBridge().
+      // The immediate broadcast is scheduled in that function, so we don't
+      // need to schedule another one here. This avoids potential crashes from
+      // scheduling tasks immediately after stop()/reinit cycle.
+      // The initBridgeStatusBroadcast() also sets up periodic broadcasts.
+      Log(STARTUP,
+          "Bridge status announcement will be sent by bridge status broadcast "
+          "system\n");
+    });
 
-    return true;  // Count as an attempt - we succeeded
+    return true;  // Count as an attempt - we scheduled the promotion
   }
 
   /**
@@ -2384,6 +2447,8 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       300000;  // Reset counter after 5 minutes
   static const uint16_t ISOLATED_BRIDGE_RETRY_SCAN_THRESHOLD =
       6;  // Require 6 empty scans before retrying
+  static const uint32_t ASYNC_PROMOTION_DELAY_MS =
+      10;  // Delay for async bridge promotion to allow current task to complete
 
   // Multi-bridge coordination state and configuration
  protected:

package/src/painlessMesh.h

@@ -5,8 +5,8 @@
  * @file painlessMesh.h
  * @brief Main header file for Alteriom painlessMesh library
  * 
- * @version 1.9.14
- * @date 2025-12-19
+ * @version 1.9.16
+ * @date 2025-12-20
  * 
  * painlessMesh is a user-friendly library for creating mesh networks with 
  * ESP8266 and ESP32 devices. This Alteriom fork includes additional packages 

package/src/painlessMeshSTA.cpp

@@ -144,16 +144,72 @@ void ICACHE_FLASH_ATTR StationScan::scanComplete() {
   });
 }
 
+void ICACHE_FLASH_ATTR StationScan::blockNodeAfterTCPFailure(uint32_t nodeId, uint32_t blockDurationMs) {
+  using namespace painlessmesh::logger;
+  uint32_t blockUntil = millis() + blockDurationMs;
+  tcpFailureBlocklist[nodeId] = blockUntil;
+  Log(CONNECTION, "blockNodeAfterTCPFailure(): Node %u blocked until %u (duration: %u ms)\n",
+      nodeId, blockUntil, blockDurationMs);
+}
+
+bool ICACHE_FLASH_ATTR StationScan::isNodeBlocked(uint32_t nodeId) const {
+  auto it = tcpFailureBlocklist.find(nodeId);
+  if (it == tcpFailureBlocklist.end()) {
+    return false;  // Not in blocklist
+  }
+  
+  uint32_t now = millis();
+  uint32_t blockUntil = it->second;
+  
+  // Handle millis() rollover using signed arithmetic
+  // If blockUntil - now is positive and < MILLIS_ROLLOVER_THRESHOLD, the block is still active
+  int32_t timeRemaining = (int32_t)(blockUntil - now);
+  return (timeRemaining > 0 && timeRemaining < MILLIS_ROLLOVER_THRESHOLD);
+}
+
+void ICACHE_FLASH_ATTR StationScan::cleanupBlocklist() {
+  using namespace painlessmesh::logger;
+  uint32_t now = millis();
+  
+  auto it = tcpFailureBlocklist.begin();
+  while (it != tcpFailureBlocklist.end()) {
+    uint32_t blockUntil = it->second;
+    int32_t timeRemaining = (int32_t)(blockUntil - now);
+    
+    // Remove expired entries (timeRemaining <= 0 or in far future due to rollover)
+    if (timeRemaining <= 0 || timeRemaining >= MILLIS_ROLLOVER_THRESHOLD) {
+      Log(CONNECTION, "cleanupBlocklist(): Removing expired entry for node %u\n", it->first);
+      it = tcpFailureBlocklist.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
 void ICACHE_FLASH_ATTR StationScan::filterAPs() {
+  // First, clean up expired blocklist entries
+  cleanupBlocklist();
+  
   auto ap = aps.begin();
   while (ap != aps.end()) {
     auto apNodeId = painlessmesh::tcp::encodeNodeId(ap->bssid);
+    
+    // Filter out nodes we're already connected to
     if (painlessmesh::router::findRoute<painlessmesh::Connection>(
             (*mesh), apNodeId) != NULL) {
       ap = aps.erase(ap);
-    } else {
-      ap++;
+      continue;
+    }
+    
+    // Filter out nodes that are temporarily blocked due to TCP failures
+    if (isNodeBlocked(apNodeId)) {
+      using namespace painlessmesh::logger;
+      Log(CONNECTION, "filterAPs(): Skipping blocked node %u (TCP server unresponsive)\n", apNodeId);
+      ap = aps.erase(ap);
+      continue;
     }
+    
+    ap++;
   }
 }
 

package/src/painlessMeshSTA.h

@@ -6,6 +6,7 @@
 #include "painlessmesh/mesh.hpp"
 
 #include <list>
+#include <map>
 
 typedef struct {
   uint8_t bssid[6];
@@ -13,6 +14,12 @@ typedef struct {
   int8_t rssi;
 } WiFi_AP_Record_t;
 
+// Entry for tracking nodes where TCP connection failed
+typedef struct {
+  uint32_t nodeId;
+  uint32_t blockUntil;  // millis() timestamp when this node can be retried
+} TCPFailureBlocklistEntry;
+
 class StationScan {
  public:
   Task task;  // Station scanning for connections
@@ -46,6 +53,16 @@ class StationScan {
   uint16_t getConsecutiveEmptyScans() const {
     return consecutiveEmptyScans;
   }
+  
+  // Add a node to the TCP failure blocklist
+  // This prevents repeated connection attempts to nodes where TCP server is unresponsive
+  void blockNodeAfterTCPFailure(uint32_t nodeId, uint32_t blockDurationMs = 60000);
+  
+  // Check if a node is currently blocked due to TCP failures
+  bool isNodeBlocked(uint32_t nodeId) const;
+  
+  // Clean up expired entries from the blocklist
+  void cleanupBlocklist();
 
   /// Valid APs found during the last scan
   std::list<WiFi_AP_Record_t> lastAPs;
@@ -68,6 +85,14 @@ class StationScan {
   // Track consecutive scans with no mesh nodes found (for channel re-detection)
   uint16_t consecutiveEmptyScans = 0;
   static const uint16_t EMPTY_SCAN_THRESHOLD = 6; // ~30 seconds at default SCAN_INTERVAL
+  
+  // TCP failure blocklist to prevent infinite retry loops
+  // Maps nodeId -> blockUntil timestamp (millis())
+  std::map<uint32_t, uint32_t> tcpFailureBlocklist;
+  
+  // Threshold for detecting millis() rollover in time comparisons
+  // Using 2^30 (~12 days) as reasonable limit - any time difference larger is likely rollover
+  static constexpr int32_t MILLIS_ROLLOVER_THRESHOLD = (int32_t)(1U << 30);
 
   friend painlessMesh;
 };

package/src/painlessmesh/connection.hpp

@@ -26,9 +26,10 @@ static const uint32_t TCP_CLIENT_CLEANUP_DELAY_MS = 1000; // 1000ms delay before
 // When multiple AsyncClients are deleted in rapid succession, the AsyncTCP library's
 // internal cleanup routines can interfere with each other, causing heap corruption
 // This spacing ensures each deletion completes before the next one begins
-// Increased from 250ms to 500ms to support ESP32-C6 and other ESP32 variants which
-// require more time for AsyncTCP internal cleanup operations
-static const uint32_t TCP_CLIENT_DELETION_SPACING_MS = 500; // 500ms spacing between deletions
+// Increased from 250ms to 500ms (v1.9.14) then to 1000ms (v1.9.15) to support ESP32-C6
+// ESP32-C6 uses RISC-V architecture with AsyncTCP v3.3.0+ which requires significantly
+// more time for internal cleanup operations compared to ESP32/ESP8266
+static const uint32_t TCP_CLIENT_DELETION_SPACING_MS = 1000; // 1000ms spacing between deletions
 
 // Global state to track AsyncClient deletion scheduling and execution
 // This ensures deletions are spaced out even when multiple deletion requests arrive simultaneously

package/src/painlessmesh/tcp.hpp

@@ -26,18 +26,49 @@ static const uint32_t TCP_CONNECT_STABILIZATION_DELAY_MS = 500; // Delay after I
 // Gives the TCP server more time to recover and reduces network congestion
 static const uint32_t TCP_EXHAUSTION_RECONNECT_DELAY_MS = 10000; // 10 seconds before reconnection
 
+// Duration to block a node after TCP connection retry exhaustion (60 seconds)
+// This prevents repeatedly trying to connect to nodes with unresponsive TCP servers
+static const uint32_t TCP_FAILURE_BLOCK_DURATION_MS = 60000;
+
 inline uint32_t encodeNodeId(const uint8_t *hwaddr) {
   using namespace painlessmesh::logger;
   Log(GENERAL, "encodeNodeId():\n");
   uint32_t value = 0;
 
-  value |= hwaddr[2] << 24;  // Big endian (aka "network order"):
-  value |= hwaddr[3] << 16;
-  value |= hwaddr[4] << 8;
-  value |= hwaddr[5];
+  // Extract last 4 bytes of MAC address (skip first 2 bytes)
+  // Big endian (aka "network order") encoding
+  value |= hwaddr[2] << 24;  // Byte 2 -> bits 31-24
+  value |= hwaddr[3] << 16;  // Byte 3 -> bits 23-16
+  value |= hwaddr[4] << 8;   // Byte 4 -> bits 15-8
+  value |= hwaddr[5];        // Byte 5 -> bits 7-0
   return value;
 }
 
+// Decode nodeId from mesh IP address
+// Mesh IPs follow format: 10.(nodeId >> 8).(nodeId & 0xFF).1
+inline uint32_t decodeNodeIdFromIP(IPAddress ip) {
+#if defined(PAINLESSMESH_BOOST)
+  // In test environment, IPAddress doesn't support indexing
+  // Return 0 to indicate invalid/unknown node ID
+  (void)ip;  // Suppress unused parameter warning
+  return 0;
+#else
+  // Validate mesh network IP format: 10.x.x.1
+  // First octet must be 10, last octet must be 1
+  const uint8_t MESH_IP_FIRST_OCTET = 10;
+  const uint8_t MESH_IP_LAST_OCTET = 1;
+  if (ip[0] != MESH_IP_FIRST_OCTET || ip[3] != MESH_IP_LAST_OCTET) {
+    return 0;  // Invalid mesh IP
+  }
+  
+  // Extract nodeId from second and third octets
+  // NodeId = (octet2 << 8) | octet3
+  const uint8_t BYTE_SHIFT = 8;  // Bits per byte
+  uint32_t nodeId = ((uint32_t)ip[1] << BYTE_SHIFT) | (uint32_t)ip[2];
+  return nodeId;
+#endif
+}
+
 template <class T, class M>
 void initServer(AsyncServer &server, M &mesh) {
   using namespace logger;
@@ -146,8 +177,24 @@ void connect(AsyncClient &client, IPAddress ip, uint16_t port, M &mesh,
       // All retries exhausted - schedule delayed reconnection
       // Adding a significant delay before reconnection prevents rapid reconnection loops
       // when the TCP server is persistently unavailable or overloaded
-      Log(CONNECTION, "tcp_err(): All %d retries exhausted, scheduling WiFi reconnection in %u ms\n",
-          TCP_CONNECT_MAX_RETRIES + 1, TCP_EXHAUSTION_RECONNECT_DELAY_MS);
+      Log(CONNECTION, "tcp_err(): All %d retries exhausted for IP %s\n",
+          TCP_CONNECT_MAX_RETRIES + 1, ip.toString().c_str());
+      
+      // Block this node temporarily to prevent immediate reconnection to the same unresponsive node
+      // This helps when the bridge's TCP server is down but WiFi AP is still running
+      // The blocklist is only used during AP filtering, so it won't affect existing connections
+      #if !defined(PAINLESSMESH_BOOST)
+      // Try to decode nodeId from IP and block it
+      // Only works for mesh IPs (format: 10.x.x.1)
+      uint32_t failedNodeId = decodeNodeIdFromIP(ip);
+      if (failedNodeId != 0) {
+        // Note: This requires M to be wifi::Mesh which has blockNodeAfterTCPFailure
+        mesh.blockNodeAfterTCPFailure(ip, TCP_FAILURE_BLOCK_DURATION_MS);
+      }
+      #endif
+      
+      Log(CONNECTION, "tcp_err(): Scheduling WiFi reconnection in %u ms\n",
+          TCP_EXHAUSTION_RECONNECT_DELAY_MS);
       
       // Defer deletion of the failed AsyncClient to prevent heap corruption
       // Use the centralized deletion scheduler to ensure proper spacing between deletions