@alteriom/painlessmesh 1.9.7 → 1.9.9

package/BRIDGE_TO_INTERNET.md

@@ -4,7 +4,20 @@ You can bridge your mesh network to the Internet by creating a **gateway node**
 
 ## Quick Start (Recommended: Auto Channel Detection)
 
-The **new bridge-centric approach** automatically detects your router's channel and configures the mesh accordingly. No manual channel configuration required!
+The **bridge-centric approach** automatically detects your router's channel and configures the mesh accordingly. No manual channel configuration required!
+
+### Resilient Initialization (v1.9.7+)
+
+**Power-up order no longer matters!** The bridge will initialize successfully even if:
+- Router is not yet powered on
+- Internet connection is unavailable
+- Router is temporarily offline
+
+The bridge will:
+- Establish the mesh network immediately
+- Accept connections from mesh nodes right away
+- Retry router connection automatically in the background
+- Update status when router/Internet becomes available
 
 ```cpp
 #include "painlessMesh.h"
@@ -25,10 +38,10 @@ void setup() {
   mesh.setDebugMsgTypes(ERROR | STARTUP | CONNECTION);
   
   // Single call does everything:
-  // 1. Connects to router and detects its channel
-  // 2. Initializes mesh on detected channel
+  // 1. Attempts to connect to router and detect its channel
+  // 2. Initializes mesh on detected channel (or default if router unavailable)
   // 3. Sets node as root/bridge
-  // 4. Maintains router connection
+  // 4. Maintains/retries router connection automatically
   mesh.initAsBridge(MESH_PREFIX, MESH_PASSWORD,
                     ROUTER_SSID, ROUTER_PASSWORD,
                     &userScheduler, MESH_PORT);
@@ -46,10 +59,10 @@ void receivedCallback(uint32_t from, String& msg) {
 }
 ```
 
-**Expected Output:**
+**Expected Output (Router Available):**
 ```
 === Bridge Mode Initialization ===
-Step 1: Connecting to router YourRouterSSID...
+Step 1: Attempting to connect to router YourRouterSSID...
 ✓ Router connected on channel 6
 ✓ Router IP: 192.168.1.100
 Step 2: Initializing mesh on channel 6...
@@ -58,10 +71,35 @@ Step 3: Establishing bridge connection...
 === Bridge Mode Active ===
   Mesh SSID: MyMeshNetwork
   Mesh Channel: 6 (matches router)
-  Router: YourRouterSSID
+  Router: YourRouterSSID (connected)
+  Port: 5555
+```
+
+**Expected Output (Router Unavailable but Visible):**
+```
+=== Bridge Mode Initialization ===
+Step 1: Attempting to connect to router YourRouterSSID...
+⚠ Router connection unavailable during initialization
+⚠ Scanning for router 'YourRouterSSID' to detect channel...
+✓ Router found on channel 6 (not connected, will retry)
+⚠ Proceeding with bridge setup on channel 6
+⚠ Bridge will retry router connection in background
+Step 2: Initializing mesh on channel 6...
+STARTUP: init(): Mesh channel set to 6
+Step 3: Establishing bridge connection...
+=== Bridge Mode Active ===
+  Mesh SSID: MyMeshNetwork
+  Mesh Channel: 6 (default, router pending)
+  Router: YourRouterSSID (will retry)
   Port: 5555
+
+INFO: Bridge initialized without router connection
+INFO: Mesh network is active and accepting node connections
+INFO: Router connection will be established automatically when available
 ```
 
+**Note:** If the router cannot connect but is visible in a WiFi scan, the bridge detects its channel and uses it for the mesh. This minimizes channel switching when the router becomes connectable. If the router is completely invisible (powered off), channel 1 is used as default.
+
 ### Regular Nodes with Auto-Detection
 
 Regular mesh nodes can also auto-detect the mesh channel:

package/CHANGELOG.md

@@ -19,6 +19,51 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - TBD
 
+## [1.9.9] - 2025-12-14
+
+### Fixed
+
+- **Hard Reset from Heap Corruption in Connection Destructor** - Fixed ESP32/ESP8266 hard resets caused by heap corruption when connections were closed
+  - **Root Cause**: AsyncClient objects were being deleted immediately in `~BufferedConnection()` destructor when `eraseClosedConnections()` removed closed connections. The AsyncTCP library was still referencing these objects internally, causing heap corruption and hard resets
+  - **Symptom**: Device crashes with "CORRUPT HEAP: Bad head at 0x408388a4. Expected 0xabba1234 got 0xfefefefe" and "assert failed: multi_heap_free multi_heap_poisoning.c:279" when connections are removed from the mesh
+  - **Solution**: Deferred AsyncClient deletion in destructor using task scheduler with 500ms delay
+    - Store scheduler reference in `BufferedConnection` for use in destructor
+    - Schedule AsyncClient deletion with 500ms delay to give AsyncTCP time to complete internal cleanup
+    - Use same deferred deletion pattern as error handler fixes (Issues #254, #269)
+    - Added fallback for test environments where scheduler may not be available
+  - **Impact**: Eliminates hard resets and heap corruption when mesh connections are closed, allows stable mesh network operation
+  - **Files Modified**: `src/painlessmesh/connection.hpp` (lines 42-81, 89-91, 192)
+  - **Documentation**: See `ISSUE_HARD_RESET_FIX.md` for detailed analysis
+
+- **Node Crash During TCP Connection Retries** - Fixed device crashes that occurred after 2-3 TCP connection retry attempts
+  - **Root Cause**: AsyncClient objects were being deleted too quickly (0ms delay) after connection errors. The AsyncTCP library needs 200-400ms to complete internal cleanup operations, and accessing the deleted object caused crashes
+  - **Symptom**: Device crashes or hangs after 2-3 TCP retry attempts, serial log stops abruptly during retry sequence
+  - **Solution**: Increased AsyncClient cleanup delay from 0ms to 500ms
+    - Added new constant `TCP_CLIENT_CLEANUP_DELAY_MS = 500` to give AsyncTCP library time to complete internal cleanup
+    - Updated both cleanup paths (retry and exhaustion) to use this delay
+    - Provides sufficient time for AsyncTCP to finish processing before object deletion
+  - **Impact**: Eliminates crashes during TCP connection retries, allows full retry sequence to complete
+  - **Files Modified**: `src/painlessmesh/tcp.hpp` (lines 26, 149, 170)
+  - **Documentation**: See `ASYNCCLIENT_CLEANUP_FIX.md` for detailed analysis
+
+## [1.9.8] - 2025-12-14
+
+### Fixed
+
+- **Heap Corruption on TCP Connection Errors** (#254) - Fixed ESP32 heap corruption crashes during AsyncClient deletion
+  - **Root Cause**: AsyncClient objects were being deleted synchronously from within their own error callback handlers, causing heap corruption and use-after-free crashes
+  - **Symptom**: ESP32 devices crash with "CORRUPT HEAP: Bad head at 0x4083a398. Expected 0xabba1234 got 0xfefefefe" during TCP connection error handling
+  - **Solution**: Deferred AsyncClient deletion using task scheduler to execute after error handler completes
+    - Changed from synchronous `delete client` to deferred deletion via `mesh.addTask([client]() { delete client; }, 0)`
+    - Deletion now occurs microseconds after error handler returns, preventing use-after-free
+    - Added logging for cleanup operations to aid debugging
+  - **Impact**: Eliminates heap corruption crashes on ESP32 during TCP connection retries and error conditions
+  - **Files Modified**: `src/painlessmesh/tcp.hpp` (lines 138, 149)
+
+### Changed
+
+- **README Version Reference** - Updated version banner to 1.9.7 for consistency with release history
+
 ## [1.9.7] - 2025-12-13
 
 ### Fixed

package/README.md

@@ -4,7 +4,7 @@
 
 <div align="center">
 
-**Version 1.9.6** - Latest release with TCP connection improvements and documentation updates
+**Version 1.9.9** - Latest release with AsyncClient cleanup fixes for improved stability
 
 [![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/RELEASE_GUIDE.md

@@ -2,9 +2,52 @@
 
 This document provides comprehensive instructions for releasing new versions of the Alteriom painlessMesh library across all distribution channels.
 
+## ⚠️ Important: Agent Requirements for Releases
+
+**Releases MUST be performed by Alteriom AI Agent (`@alteriom-ai-agent`) with full tool access.**
+
+### Why This Matters
+
+A release requires updating 7 files consistently:
+1. library.properties
+2. library.json  
+3. package.json
+4. src/painlessMesh.h
+5. src/AlteriomPainlessMesh.h
+6. README.md
+7. CHANGELOG.md
+
+**✅ Correct Agent:** `@alteriom-ai-agent`
+- Has file editing tools (`replace_string_in_file`, `multi_replace_string_in_file`)
+- Can run terminal commands (`run_in_terminal`)
+- Can execute git operations
+- **Use this for release preparation**
+
+**❌ Wrong Agent:** `@painlessmesh-coordinator` or specialized agents without tools
+- Lack file editing capabilities
+- Can only provide documentation/checklists
+- Cannot actually perform releases
+- Will result in manual work
+
+### Agent-Assisted Release (Recommended)
+
+```bash
+# Ask Alteriom AI Agent to prepare release
+@alteriom-ai-agent Prepare release v1.9.9 with these changes:
+- Fixed ESP8266 WiFiClientSecure scope issue  
+- Fixed TCP retry crash with AsyncClient cleanup
+
+# Agent will:
+# ✅ Update all 7 version files
+# ✅ Restructure CHANGELOG.md
+# ✅ Run validation: ./scripts/release-agent.sh
+# ✅ Commit: "release: v1.9.9 - Description"
+# ✅ Push to trigger automation
+```
+
 ## 🚀 Quick Release Process
 
-### Standard Release (Recommended)
+### Standard Release (Manual)
 
 ```bash
 # 1. Update version using the bump script
@@ -21,7 +64,7 @@ This document provides comprehensive instructions for releasing new versions of
 ./scripts/release-agent.sh
 
 # 5. If all checks pass, commit and trigger release
-git add library.properties library.json package.json CHANGELOG.md src/*.h
+git add library.properties library.json package.json CHANGELOG.md src/*.h README.md
 git commit -m "release: v1.7.9 - Brief description"
 git push origin main
 ```

package/examples/bridge/bridge.ino

@@ -1,20 +1,29 @@
 //************************************************************
-// Bridge Node Example - Automatic Channel Detection
+// Bridge Node Example - Automatic Channel Detection & Resilient Initialization
 //
-// This example demonstrates the new bridge-centric architecture that
+// This example demonstrates the bridge-centric architecture that
 // automatically detects the router's WiFi channel and configures the
 // mesh network accordingly.
 //
 // Features:
-// - Connects to router FIRST and auto-detects its channel
-// - Creates mesh network on the same channel as router
+// - Resilient initialization: Works even if router is unavailable at boot
+// - Automatically detects router channel when available
+// - Creates mesh network immediately (default channel if needed)
 // - No manual channel configuration required
 // - Automatically sets itself as root node
+// - Retries router connection in background if initially unavailable
 // - Broadcasts bridge status to mesh (Type 610 - BRIDGE_STATUS)
 //   - Reports Internet connectivity status
 //   - Updates every 30 seconds by default
 //   - Enables nodes to implement failover and queueing logic
 //
+// POWER-UP ORDER INDEPENDENCE (v1.9.7+):
+// The bridge now initializes successfully regardless of power-up order:
+// - Bridge can boot before router is ready
+// - Mesh nodes can connect immediately to bridge
+// - Router connection is established automatically when available
+// - No need to restart bridge when router becomes ready
+//
 // For more details, see BRIDGE_TO_INTERNET.md
 //
 // EXTERNAL DEVICE CONNECTIONS:
@@ -63,29 +72,27 @@ void setup() {
   // Set debug message types before init() to see startup messages
   mesh.setDebugMsgTypes(ERROR | STARTUP | CONNECTION);
 
-  // NEW: Single call to initialize as bridge with auto channel detection
+  // Single call to initialize as bridge with auto channel detection
   // This will:
-  // 1. Connect to router and detect its channel
-  // 2. Initialize mesh on the detected channel
-  // 3. Set this node as root
-  // 4. Maintain router connection
+  // 1. Attempt to connect to router and detect its channel
+  // 2. Initialize mesh on the detected channel (or default if router unavailable)
+  // 3. Set this node as root/bridge
+  // 4. Maintain/retry router connection automatically
   // 5. Start broadcasting bridge status (Type 610) every 30 seconds
-  bool bridgeSuccess = mesh.initAsBridge(MESH_PREFIX, MESH_PASSWORD,
-                                         ROUTER_SSID, ROUTER_PASSWORD,
-                                         &userScheduler, MESH_PORT);
-
-  if (!bridgeSuccess) {
-    Serial.println("✗ Failed to initialize as bridge!");
-    Serial.println("Router unreachable - falling back to regular mesh node");
-    Serial.println("The node will join the mesh without bridge functionality");
-    
-    // Fallback: Initialize as regular mesh node
-    // This allows the device to still participate in the mesh
-    mesh.init(MESH_PREFIX, MESH_PASSWORD, &userScheduler, MESH_PORT);
-    
-    Serial.println("✓ Initialized as regular mesh node");
-    Serial.println("Note: To function as a bridge, fix router connectivity and restart");
-  }
+  //
+  // RESILIENT INITIALIZATION (v1.9.7+):
+  // The bridge will successfully initialize even if the router is unavailable
+  // at boot time. It will:
+  // - Establish the mesh network immediately on a default channel
+  // - Accept connections from mesh nodes right away
+  // - Retry router connection automatically in the background
+  // - Update bridge status when router becomes available
+  //
+  // This solves the power-up order issue (Issue #268) where bridge
+  // initialization would fail if the router wasn't ready yet.
+  mesh.initAsBridge(MESH_PREFIX, MESH_PASSWORD,
+                    ROUTER_SSID, ROUTER_PASSWORD,
+                    &userScheduler, MESH_PORT);
 
   // Optional: Configure bridge status broadcasting
   // mesh.setBridgeStatusInterval(60000);  // Change to 60 seconds
@@ -98,6 +105,8 @@ void setup() {
   mesh.onReceive(&receivedCallback);
   
   Serial.println("✓ Bridge node initialized and ready!");
+  Serial.println("Mesh network active - accepting node connections");
+  Serial.println("Router connection will be established automatically when available");
   Serial.println("Broadcasting bridge status to mesh every 30 seconds");
 }
 

package/library.json

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

package/library.properties

@@ -1,5 +1,5 @@
 name=Alteriom PainlessMesh
-version=1.9.7
+version=1.9.9
 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.7",
+  "version": "1.9.9",
   "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.7"
+#define ALTERIOM_PAINLESS_MESH_VERSION "1.9.9"
 #define ALTERIOM_PAINLESS_MESH_VERSION_MAJOR 1
 #define ALTERIOM_PAINLESS_MESH_VERSION_MINOR 9
-#define ALTERIOM_PAINLESS_MESH_VERSION_PATCH 7
+#define ALTERIOM_PAINLESS_MESH_VERSION_PATCH 9
 
 /**
  * @brief Library description and usage information

package/src/arduino/wifi.hpp

@@ -386,9 +386,12 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     using namespace logger;
 
     Log(STARTUP, "=== Bridge Mode Initialization ===\n");
-    Log(STARTUP, "Step 1: Connecting to router %s...\n", routerSSID.c_str());
+    Log(STARTUP, "Step 1: Attempting to connect to router %s...\n", routerSSID.c_str());
 
-    // Step 1: Connect to router first to detect its channel
+    // Store router credentials for future connection attempts
+    setRouterCredentials(routerSSID, routerPassword);
+
+    // Step 1: Attempt to connect to router first to detect its channel
     // Shut Wifi down and start with a blank slate
     if (WiFi.status() != WL_DISCONNECTED) WiFi.disconnect();
 
@@ -413,6 +416,7 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     }
 
     uint8_t detectedChannel = 1;  // Default fallback
+    bool routerConnected = false;
 
     if (WiFi.status() == WL_CONNECTED) {
       detectedChannel = WiFi.channel();
@@ -425,18 +429,50 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       } else {
         Log(STARTUP, "\n✓ Router connected on channel %d\n", detectedChannel);
         Log(STARTUP, "✓ Router IP: %s\n", WiFi.localIP().toString().c_str());
+        routerConnected = true;
       }
     } else {
-      Log(ERROR, "\n✗ Failed to connect to router\n");
-      Log(ERROR, "Cannot become bridge without router connection\n");
-      Log(ERROR, "Bridge initialization aborted - remaining as regular node\n");
-      return false;
+      Log(STARTUP, "\n⚠ Router connection unavailable during initialization\n");
+      
+      // Scan for router to detect its channel even though we can't connect
+      // This minimizes channel mismatch when router becomes available later
+      Log(STARTUP, "⚠ Scanning for router '%s' to detect channel...\n", routerSSID.c_str());
+      
+      // ESP32 and ESP8266 have different scanNetworks signatures
+#ifdef ESP32
+      int16_t numNetworks = WiFi.scanNetworks(false, false, false, 300U, 0);
+#elif defined(ESP8266)
+      int16_t numNetworks = WiFi.scanNetworks(false, false, 0);
+#endif
+      
+      if (numNetworks > 0) {
+        for (int16_t i = 0; i < numNetworks; i++) {
+          if (WiFi.SSID(i) == routerSSID) {
+            uint8_t scannedChannel = WiFi.channel(i);
+            if (scannedChannel >= 1 && scannedChannel <= 13) {
+              detectedChannel = scannedChannel;
+              Log(STARTUP, "✓ Router found on channel %d (not connected, will retry)\n", 
+                  detectedChannel);
+              break;
+            }
+          }
+        }
+        WiFi.scanDelete();
+      }
+      
+      if (detectedChannel == 1) {
+        Log(STARTUP, "⚠ Router not found in scan, using default channel %d\n", detectedChannel);
+      }
+      
+      Log(STARTUP, "⚠ Proceeding with bridge setup on channel %d\n", detectedChannel);
+      Log(STARTUP, "⚠ Bridge will retry router connection in background\n");
     }
 
     Log(STARTUP, "Step 2: Initializing mesh on channel %d...\n",
         detectedChannel);
 
-    // Step 2: Initialize mesh on detected channel
+    // Step 2: Initialize mesh on detected/default channel
+    // This allows the bridge to establish the mesh network even without router
     init(meshSSID, meshPassword, baseScheduler, port, WIFI_AP_STA,
          detectedChannel, 0, MAX_CONN);
 
@@ -446,10 +482,13 @@ class Mesh : public painlessmesh::Mesh<Connection> {
 
     Log(STARTUP, "Step 3: Establishing bridge connection...\n");
 
-    // Step 3: Re-establish router connection using stationManual
+    // Step 3: Establish/re-establish router connection using stationManual
+    // If router wasn't available initially, this will be retried automatically
     stationManual(routerSSID, routerPassword, 0);
 
     // Step 4: Configure as root/bridge node
+    // Bridge role is established regardless of router connectivity
+    // This ensures mesh nodes can connect and the bridge can provide mesh services
     this->setRoot(true);
     this->setContainsRoot(true);
 
@@ -461,9 +500,21 @@ class Mesh : public painlessmesh::Mesh<Connection> {
 
     Log(STARTUP, "=== Bridge Mode Active ===\n");
     Log(STARTUP, "  Mesh SSID: %s\n", meshSSID.c_str());
-    Log(STARTUP, "  Mesh Channel: %d (matches router)\n", detectedChannel);
-    Log(STARTUP, "  Router: %s\n", routerSSID.c_str());
+    Log(STARTUP, "  Mesh Channel: %d%s\n", detectedChannel, 
+        routerConnected ? " (matches router)" : " (default, router pending)");
+    Log(STARTUP, "  Router: %s%s\n", routerSSID.c_str(),
+        routerConnected ? " (connected)" : " (will retry)");
     Log(STARTUP, "  Port: %d\n", port);
+    
+    if (!routerConnected) {
+      Log(STARTUP, "\nINFO: Bridge initialized without router connection\n");
+      Log(STARTUP, "INFO: Mesh network is active and accepting node connections\n");
+      Log(STARTUP, "INFO: Router connection will be established automatically when available\n");
+    }
+    
+    // Return true - bridge mesh functionality is active even without router
+    // The mesh network is operational and nodes can connect
+    // Router connection will be retried automatically via stationManual
     return true;
   }
 

package/src/painlessMesh.h

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

package/src/painlessmesh/connection.hpp

@@ -14,6 +14,11 @@ extern painlessmesh::logger::LogClass Log;
 namespace painlessmesh {
 namespace tcp {
 
+// Delay before cleaning up failed AsyncClient after connection error or close
+// This prevents crashes when AsyncTCP library is still accessing the client internally
+// The AsyncTCP library may take a few hundred milliseconds to complete its internal cleanup
+static const uint32_t TCP_CLIENT_CLEANUP_DELAY_MS = 500; // 500ms delay before deleting AsyncClient
+
 // Shared buffer for reading/writing to the buffer
 static painlessmesh::buffer::temp_buffer_t shared_buffer;
 
@@ -40,16 +45,50 @@ class BufferedConnection
   BufferedConnection(AsyncClient *client) : client(client) {}
 
   ~BufferedConnection() {
+    using namespace logger;
     Log.remote("~BufferedConnection");
     this->close();
     if (!client->freeable()) {
       client->close(true);
     }
     client->abort();
-    delete client;
+    
+    // Defer deletion of the AsyncClient to prevent heap corruption
+    // Deleting immediately can cause use-after-free issues when the AsyncTCP 
+    // library is still referencing the object internally during cleanup
+    // See ISSUE_254_HEAP_CORRUPTION_FIX.md and ASYNCCLIENT_CLEANUP_FIX.md
+    if (mScheduler) {
+      // Capture client pointer by value for safe deferred deletion
+      AsyncClient* clientToDelete = client;
+      
+      // Schedule deletion task with TCP_CLIENT_CLEANUP_DELAY_MS delay
+      // This gives AsyncTCP library time to complete its internal cleanup
+      // Note: Task object is intentionally leaked to keep implementation simple
+      // This is acceptable because:
+      // 1. Connections are long-lived, destructor calls are infrequent
+      // 2. Task object is small (~32-64 bytes) vs preventing critical heap corruption
+      // 3. In typical deployments, memory impact is negligible (few KB over months)
+      // 4. Alternative cleanup patterns would add significant complexity
+      Task* cleanupTask = new Task(TCP_CLIENT_CLEANUP_DELAY_MS * TASK_MILLISECOND, TASK_ONCE, [clientToDelete]() {
+        using namespace logger;
+        Log(CONNECTION, "~BufferedConnection: Deferred cleanup of AsyncClient\n");
+        delete clientToDelete;
+      });
+      
+      mScheduler->addTask(*cleanupTask);
+      cleanupTask->enableDelayed();
+    } else {
+      // Fallback: If scheduler not available, delete immediately
+      // This should only happen in test environments or edge cases
+      Log(CONNECTION, "~BufferedConnection: No scheduler available, deleting AsyncClient immediately (risky)\n");
+      delete client;
+    }
   }
 
   void initialize(Scheduler *scheduler) {
+    // Store scheduler reference for deferred cleanup in destructor
+    mScheduler = scheduler;
+    
     auto self = this->shared_from_this();
     sentBufferTask.set(TASK_SECOND, TASK_FOREVER, [self]() {
       if (!self->sentBuffer.empty() && self->client->canSend()) {
@@ -156,6 +195,7 @@ class BufferedConnection
   bool mConnected = true;
 
   AsyncClient *client;
+  Scheduler *mScheduler = nullptr; // Scheduler for deferred AsyncClient cleanup
 
   std::function<void(TSTRING)> receiveCallback;
   std::function<void()> disconnectCallback;

package/src/painlessmesh/mesh.hpp

@@ -622,10 +622,10 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
    * 
    * Use hasLocalInternet() to check if THIS specific node has direct Internet access.
    * 
-   * When connected to mesh, requires recent bridge status (within timeout).
-   * When disconnected from mesh, returns true if any bridge previously
-   * reported Internet connectivity - allowing operations to be queued for
-   * when mesh connectivity is restored.
+   * This method now ALWAYS requires healthy (recent) bridge status to prevent
+   * false positives when mesh connectivity is lost. Without active mesh connections,
+   * stale bridge data cannot be relied upon, as the bridge may have lost Internet
+   * connectivity or become unreachable.
    * 
    * \code
    * if (mesh.hasInternetConnection()) {
@@ -644,16 +644,10 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
    * @see initAsSharedGateway() to give all nodes direct Internet access (requires router credentials)
    */
   bool hasInternetConnection() {
-    bool hasConnections = hasActiveMeshConnections();
-    
+    // Always require healthy bridge status to prevent false positives
+    // when mesh is disconnected. Stale bridge data is unreliable.
     for (const auto& bridge : knownBridges) {
-      // When connected: require fresh status
-      // When disconnected: use last known state
-      bool isUsable = hasConnections 
-          ? (bridge.isHealthy(bridgeTimeoutMs) && bridge.internetConnected)
-          : bridge.internetConnected;
-      
-      if (isUsable) {
+      if (bridge.isHealthy(bridgeTimeoutMs) && bridge.internetConnected) {
         return true;
       }
     }
@@ -698,14 +692,17 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
    * Get the primary (best) bridge node
    * 
    * Primary bridge is selected based on:
-   * 1. Must be healthy (seen within timeout) - unless node is disconnected
+   * 1. Must be healthy (seen within timeout)
    * 2. Must have Internet connection
    * 3. Best WiFi RSSI to router
    * 
-   * When this node is disconnected from the mesh (no active connections),
-   * returns the last known bridge even if lastSeen is stale. This allows
-   * nodes to attempt routing through the last known bridge once mesh
-   * connectivity is restored.
+   * This method now ALWAYS requires healthy (recent) bridge status to prevent
+   * routing messages to unreachable or outdated bridges when mesh connectivity
+   * is lost. Without active mesh connections and fresh status, we cannot reliably
+   * route messages to any bridge.
+   * 
+   * If you need access to the last known bridge regardless of health status,
+   * use getLastKnownBridge() instead.
    * 
    * @return pointer to BridgeInfo of primary bridge, or nullptr if no suitable bridge
    */
@@ -713,17 +710,9 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     BridgeInfo* primary = nullptr;
     int8_t bestRSSI = -127;  // Worst possible RSSI
     
-    // Check if we have active mesh connections
-    bool hasConnections = hasActiveMeshConnections();
-    
+    // Always require healthy bridge status to prevent routing to stale/unreachable bridges
     for (auto& bridge : knownBridges) {
-      // When connected to mesh: require healthy (recent) bridge status
-      // When disconnected: use any bridge that reported Internet (stale info is better than none)
-      bool isUsable = hasConnections 
-          ? (bridge.isHealthy(bridgeTimeoutMs) && bridge.internetConnected)
-          : bridge.internetConnected;
-      
-      if (isUsable) {
+      if (bridge.isHealthy(bridgeTimeoutMs) && bridge.internetConnected) {
         if (bridge.routerRSSI > bestRSSI) {
           bestRSSI = bridge.routerRSSI;
           primary = &bridge;
@@ -1290,6 +1279,18 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
       Log(COMMUNICATION, "sendToInternet(): Local Internet available, using gateway protocol for consistency\n");
     }
 
+    // Validate mesh connectivity before attempting to send
+    if (!hasActiveMeshConnections()) {
+      Log(ERROR, "sendToInternet(): No active mesh connections\n");
+      if (callback) {
+        // Schedule callback to avoid blocking
+        this->addTask([callback]() {
+          callback(false, 0, "No mesh connections - cannot route to gateway");
+        });
+      }
+      return 0;
+    }
+
     // Find the best gateway to route through
     BridgeInfo* gateway = getPrimaryBridge();
     if (gateway == nullptr) {

package/src/painlessmesh/tcp.hpp

@@ -20,6 +20,11 @@ namespace tcp {
 static const uint8_t TCP_CONNECT_MAX_RETRIES = 5;       // Max retry attempts before giving up
 static const uint32_t TCP_CONNECT_RETRY_DELAY_MS = 1000; // Delay between retry attempts (1 second)
 static const uint32_t TCP_CONNECT_STABILIZATION_DELAY_MS = 500; // Delay after IP acquisition (500ms)
+// TCP_CLIENT_CLEANUP_DELAY_MS is defined in connection.hpp since it's used in the destructor
+// Delay before WiFi reconnection after all TCP retries are exhausted
+// This prevents rapid reconnection loops when TCP server is persistently unavailable
+// 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
 
 inline uint32_t encodeNodeId(const uint8_t *hwaddr) {
   using namespace painlessmesh::logger;
@@ -129,24 +134,46 @@ void connect(AsyncClient &client, IPAddress ip, uint16_t port, M &mesh,
           connect<T, M>((*pRetryConn), ip, port, mesh, retryCount + 1);
         }, retryDelay);
         
-        // Delete the current failed client to prevent memory leak
-        // The AsyncClient is no longer needed after connection failure
-        delete client;
+        // Defer deletion of the failed AsyncClient to prevent heap corruption
+        // Deleting from within the error callback can cause use-after-free issues
+        // as the AsyncTCP library may still be referencing the object
+        // Use TCP_CLIENT_CLEANUP_DELAY_MS to give AsyncTCP library time to complete
+        // its internal cleanup before we delete the object
+        // Note: client is captured by value (pointer copy) and we are the sole owner
+        mesh.addTask([client]() {
+          Log(CONNECTION, "tcp_err(): Cleaning up failed AsyncClient (retry path)\n");
+          delete client;
+        }, TCP_CLIENT_CLEANUP_DELAY_MS);
         
         mesh.semaphoreGive();
         return;
       }
       
-      // All retries exhausted - clean up the failed client and trigger full reconnection
-      Log(CONNECTION, "tcp_err(): All %d retries exhausted, triggering WiFi reconnection\n",
-          TCP_CONNECT_MAX_RETRIES + 1);
-      delete client;
+      // 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);
+      
+      // Defer deletion of the failed AsyncClient to prevent heap corruption
+      // Deleting from within the error callback can cause use-after-free issues
+      // as the AsyncTCP library may still be referencing the object
+      // Use TCP_CLIENT_CLEANUP_DELAY_MS to give AsyncTCP library time to complete
+      // its internal cleanup before we delete the object
+      // Note: client is captured by value (pointer copy) and we are the sole owner
+      mesh.addTask([client]() {
+        Log(CONNECTION, "tcp_err(): Cleaning up failed AsyncClient (exhaustion path)\n");
+        delete client;
+      }, TCP_CLIENT_CLEANUP_DELAY_MS);
 #endif
       // Defer callback execution to avoid crashes in error handler context
       // Execute callbacks after semaphore is released and error handler completes
+      // The delay helps prevent endless rapid reconnection loops by giving the TCP server
+      // more time to recover and reducing network congestion from multiple retrying nodes
       mesh.addTask([&mesh]() {
+        Log(CONNECTION, "tcp_err(): Executing delayed WiFi reconnection after retry exhaustion\n");
         mesh.droppedConnectionCallbacks.execute(0, true);
-      });
+      }, TCP_EXHAUSTION_RECONNECT_DELAY_MS);
       mesh.semaphoreGive();
     }
   });