@alteriom/painlessmesh 1.9.19 → 1.9.20

package/src/arduino/wifi.hpp

@@ -410,7 +410,8 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     // Wait for connection (with timeout)
     int timeout = 30;  // 30 seconds timeout
     while (WiFi.status() != WL_CONNECTED && timeout > 0) {
-      delay(1000);
+      // Allow event loop processing during hardware settling
+      for (int i = 0; i < 100; i++) { delay(10); yield(); }
       timeout--;
       Log(STARTUP, ".");
     }
@@ -423,20 +424,20 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       // Validate channel is in valid range (1-13 for 2.4GHz)
       if (detectedChannel < 1 || detectedChannel > 13) {
         Log(ERROR,
-            "\n✗ Invalid channel detected: %d, falling back to channel 1\n",
+            "\n[FAIL] Invalid channel detected: %d, falling back to channel 1\n",
             detectedChannel);
         detectedChannel = 1;
       } else {
-        Log(STARTUP, "\n✓ Router connected on channel %d\n", detectedChannel);
-        Log(STARTUP, "✓ Router IP: %s\n", WiFi.localIP().toString().c_str());
+        Log(STARTUP, "\n[OK] Router connected on channel %d\n", detectedChannel);
+        Log(STARTUP, "[OK] Router IP: %s\n", WiFi.localIP().toString().c_str());
         routerConnected = true;
       }
     } else {
-      Log(STARTUP, "\n⚠ Router connection unavailable during initialization\n");
+      Log(STARTUP, "\n[WARN] 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());
+      Log(STARTUP, "[WARN] Scanning for router '%s' to detect channel...\n", routerSSID.c_str());
       
       // ESP32 and ESP8266 have different scanNetworks signatures
 #ifdef ESP32
@@ -451,7 +452,7 @@ class Mesh : public painlessmesh::Mesh<Connection> {
             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", 
+              Log(STARTUP, "[OK] Router found on channel %d (not connected, will retry)\n", 
                   detectedChannel);
               break;
             }
@@ -461,11 +462,11 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       }
       
       if (detectedChannel == 1) {
-        Log(STARTUP, "⚠ Router not found in scan, using default channel %d\n", detectedChannel);
+        Log(STARTUP, "[WARN] 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, "[WARN] Proceeding with bridge setup on channel %d\n", detectedChannel);
+      Log(STARTUP, "[WARN] Bridge will retry router connection in background\n");
     }
 
     Log(STARTUP, "Step 2: Initializing mesh on channel %d...\n",
@@ -512,9 +513,8 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       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
+    // Always returns true: bridge mesh functionality is active regardless of
+    // router connection status. The router connection is opportunistic.
     return true;
   }
 
@@ -641,7 +641,8 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     // Wait for connection with timeout (using constant for configurability)
     int timeout = ROUTER_CONNECTION_TIMEOUT_SECONDS;
     while (WiFi.status() != WL_CONNECTED && timeout > 0) {
-      delay(1000);
+      // Allow event loop processing during hardware settling
+      for (int i = 0; i < 100; i++) { delay(10); yield(); }
       timeout--;
       Log(STARTUP, ".");
     }
@@ -654,15 +655,15 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       if (detectedChannel < MIN_WIFI_CHANNEL ||
           detectedChannel > MAX_WIFI_CHANNEL) {
         Log(ERROR,
-            "\n✗ Invalid channel detected: %d, falling back to channel 1\n",
+            "\n[FAIL] Invalid channel detected: %d, falling back to channel 1\n",
             detectedChannel);
         detectedChannel = 1;
       } else {
-        Log(STARTUP, "\n✓ Router connected on channel %d\n", detectedChannel);
-        Log(STARTUP, "✓ Router IP: %s\n", WiFi.localIP().toString().c_str());
+        Log(STARTUP, "\n[OK] Router connected on channel %d\n", detectedChannel);
+        Log(STARTUP, "[OK] Router IP: %s\n", WiFi.localIP().toString().c_str());
       }
     } else {
-      Log(ERROR, "\n✗ Failed to connect to router during channel detection\n");
+      Log(ERROR, "\n[FAIL] Failed to connect to router during channel detection\n");
       Log(ERROR,
           "Continuing with default channel 1, will retry router connection "
           "later\n");
@@ -998,6 +999,123 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     bridgeRoleChangedCallback = callback;
   }
 
+  /**
+   * Set callback for bridge coordination messages
+   *
+   * Called every time a coordination message (Type 613) is received from
+   * another bridge. Useful for monitoring bridge health and status.
+   *
+   * For non-bridge nodes, this also registers a Type 613 handler so that
+   * regular mesh nodes can monitor bridge coordination traffic.
+   *
+   * @param callback Function called with the coordination package and sender
+   * node ID
+   */
+  void onBridgeCoordination(
+      std::function<void(const plugin::BridgeCoordinationPackage&, uint32_t)>
+          callback) {
+    using namespace logger;
+    bridgeCoordinationCallback = callback;
+
+    // Non-bridge nodes don't run initBridgeCoordination(), so register
+    // a Type 613 handler here so they can still receive coordination traffic.
+    if (!this->isBridge()) {
+      this->callbackList.onPackage(
+          613,
+          [this](protocol::Variant& variant, std::shared_ptr<Connection>,
+                 uint32_t) {
+            JsonDocument doc;
+            TSTRING str;
+            variant.printTo(str);
+            deserializeJson(doc, str);
+            JsonObject obj = doc.as<JsonObject>();
+
+            if (obj["priority"].is<unsigned int>()) {
+              uint32_t fromNode = obj["from"];
+              plugin::BridgeCoordinationPackage pkg(obj);
+
+              if (this->bridgeCoordinationCallback) {
+                this->bridgeCoordinationCallback(pkg, fromNode);
+              }
+
+              // Change detection for non-bridge nodes
+              if (this->bridgeCoordinationChangedCallback) {
+                auto it = this->lastBridgeCoordinationState.find(fromNode);
+                if (it == this->lastBridgeCoordinationState.end()) {
+                  this->lastBridgeCoordinationState[fromNode] = {
+                      pkg.priority, pkg.role, pkg.load, (uint32_t)millis()};
+                  this->bridgeCoordinationChangedCallback(pkg, fromNode,
+                                                          "new");
+                } else {
+                  auto& prev = it->second;
+                  bool changed = (prev.priority != pkg.priority ||
+                                  prev.role != pkg.role ||
+                                  prev.load != pkg.load);
+                  prev.priority = pkg.priority;
+                  prev.role = pkg.role;
+                  prev.load = pkg.load;
+                  prev.lastSeen = (uint32_t)millis();
+                  if (changed) {
+                    this->bridgeCoordinationChangedCallback(pkg, fromNode,
+                                                            "updated");
+                  }
+                }
+              }
+            }
+            return false;
+          });
+      Log(GENERAL,
+          "onBridgeCoordination(): Registered Type 613 handler for non-bridge "
+          "node\n");
+    }
+  }
+
+  /**
+   * Set callback for bridge coordination state changes
+   *
+   * Called when a new bridge is discovered, an existing bridge changes its
+   * priority/role/load, or a bridge is lost (no coordination message for 60s).
+   *
+   * @param callback Function called with the coordination package, sender node
+   * ID, and change type ("new", "updated", or "lost")
+   */
+  void onBridgeCoordinationChanged(
+      std::function<void(const plugin::BridgeCoordinationPackage&, uint32_t,
+                         TSTRING)>
+          callback) {
+    using namespace logger;
+    bridgeCoordinationChangedCallback = callback;
+
+    // Start periodic lost-detection task (every 30 seconds, check for
+    // bridges that haven't sent a coordination message in 60 seconds)
+    bridgeLostDetectionTask = this->addTask(
+        30000, TASK_FOREVER, [this]() {
+          uint32_t now = (uint32_t)millis();
+          for (auto it = this->lastBridgeCoordinationState.begin();
+               it != this->lastBridgeCoordinationState.end();) {
+            if ((now - it->second.lastSeen) > 60000) {
+              uint32_t lostNode = it->first;
+              // Create a package with last known state for the callback
+              plugin::BridgeCoordinationPackage pkg;
+              pkg.from = lostNode;
+              pkg.priority = it->second.priority;
+              pkg.role = it->second.role;
+              pkg.load = it->second.load;
+              it = this->lastBridgeCoordinationState.erase(it);
+              if (this->bridgeCoordinationChangedCallback) {
+                this->bridgeCoordinationChangedCallback(pkg, lostNode, "lost");
+              }
+            } else {
+              ++it;
+            }
+          }
+        });
+
+    Log(GENERAL,
+        "onBridgeCoordinationChanged(): Lost detection task started "
+        "(interval: 30s, timeout: 60s)\n");
+  }
+
   /**
    * Enable or disable multi-bridge coordination mode
    *
@@ -1175,17 +1293,6 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     }
   }
 
-  /**
-   * Select a specific bridge for next transmission
-   *
-   * This overrides the automatic bridge selection for one message.
-   *
-   * @param bridgeNodeId Node ID of bridge to use
-   */
-  void selectBridge(uint32_t bridgeNodeId) {
-    selectedBridgeOverride = bridgeNodeId;
-  }
-
   /**
    * Check if multi-bridge mode is enabled
    *
@@ -1432,6 +1539,9 @@ class Mesh : public painlessmesh::Mesh<Connection> {
                 if (peerId != this->nodeId &&
                     std::find(knownBridgePeers.begin(), knownBridgePeers.end(),
                               peerId) == knownBridgePeers.end()) {
+                  if (knownBridgePeers.size() >= 32) {
+                    knownBridgePeers.erase(knownBridgePeers.begin());
+                  }
                   knownBridgePeers.push_back(peerId);
                 }
               }
@@ -1441,6 +1551,36 @@ class Mesh : public painlessmesh::Mesh<Connection> {
                 "Bridge coordination from %u: priority=%d, role=%s, "
                 "load=%d%%\n",
                 fromNode, priority, role.c_str(), load);
+
+            // Invoke bridge coordination callback if set
+            if (this->bridgeCoordinationCallback) {
+              plugin::BridgeCoordinationPackage pkg(obj);
+              this->bridgeCoordinationCallback(pkg, fromNode);
+            }
+
+            // Change detection and bridgeCoordinationChangedCallback
+            if (this->bridgeCoordinationChangedCallback) {
+              plugin::BridgeCoordinationPackage pkg(obj);
+              auto it = this->lastBridgeCoordinationState.find(fromNode);
+              if (it == this->lastBridgeCoordinationState.end()) {
+                this->lastBridgeCoordinationState[fromNode] = {
+                    priority, role, load, (uint32_t)millis()};
+                this->bridgeCoordinationChangedCallback(pkg, fromNode, "new");
+              } else {
+                auto& prev = it->second;
+                bool changed = (prev.priority != priority ||
+                                prev.role != role ||
+                                prev.load != load);
+                prev.priority = priority;
+                prev.role = role;
+                prev.load = load;
+                prev.lastSeen = (uint32_t)millis();
+                if (changed) {
+                  this->bridgeCoordinationChangedCallback(pkg, fromNode,
+                                                          "updated");
+                }
+              }
+            }
           }
           return false;  // Don't consume the package
         });
@@ -1757,7 +1897,7 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     }
 
     if (winner->nodeId == this->nodeId) {
-      Log(CONNECTION, "🎯 I WON! Promoting to bridge...\n");
+      Log(CONNECTION, "[TARGET] I WON! Promoting to bridge...\n");
       promoteToBridge();
     } else {
       Log(CONNECTION, "Winner is node %u, remaining as regular node\n",
@@ -1818,8 +1958,9 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     router::broadcast<protocol::Variant, Connection>(variant, (*this), 0);
 
     // Give time for announcement to propagate before channel switch
-    delay(1000);
-    Log(STARTUP, "✓ Takeover announcement sent on channel %d\n", _meshChannel);
+    // Allow event loop processing during hardware settling
+    for (int i = 0; i < 100; i++) { delay(10); yield(); }
+    Log(STARTUP, "[OK] Takeover announcement sent on channel %d\n", _meshChannel);
 
     // Save current mesh configuration to restore if bridge init fails
     uint8_t savedChannel = _meshChannel;
@@ -1835,37 +1976,17 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       
       // 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);
-
-      if (!bridgeInitSuccess) {
-        Log(ERROR, "✗ Bridge promotion failed - router unreachable\n");
-        Log(ERROR, "Reverting to regular node on channel %d\n", savedChannel);
+      // Allow event loop processing during hardware settling
+      for (int i = 0; i < 100; i++) { delay(10); yield(); }
 
-        // 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();
-
-        // Notify via callback
-        if (bridgeRoleChangedCallback) {
-          bridgeRoleChangedCallback(
-              false, "Bridge promotion failed - router unreachable");
-        }
-
-        return;
-      }
+      // initAsBridge always returns true: bridge mesh functionality is active
+      // regardless of router connection status (router connection is opportunistic)
+      this->initAsBridge(_meshSSID, _meshPassword, routerSSID, routerPassword,
+                         mScheduler, _meshPort);
 
       lastRoleChangeTime = millis();
 
-      Log(STARTUP, "✓ Bridge promotion complete on channel %d\n", _meshChannel);
+      Log(STARTUP, "[OK] Bridge promotion complete on channel %d\n", _meshChannel);
 
       // Notify via callback
       // Use explicit TSTRING construction to ensure string lifetime safety
@@ -1958,43 +2079,19 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       
       // Stop current mesh operations
       this->stop();
-      delay(1000);
-
-      // Attempt to initialize as bridge
-      bool bridgeInitSuccess =
-          this->initAsBridge(_meshSSID, _meshPassword, routerSSID, routerPassword,
-                             mScheduler, _meshPort);
+      // Allow event loop processing during hardware settling
+      for (int i = 0; i < 100; i++) { delay(10); yield(); }
 
-      if (!bridgeInitSuccess) {
-        Log(ERROR, "✗ Isolated bridge promotion failed - router unreachable\n");
-        Log(ERROR, "Reverting to regular node on channel %d\n", savedChannel);
+      // initAsBridge always returns true: bridge mesh functionality is active
+      // regardless of router connection status (router connection is opportunistic)
+      this->initAsBridge(_meshSSID, _meshPassword, routerSSID, routerPassword,
+                         mScheduler, _meshPort);
 
-        // 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);
-
-        // 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");
-        }
-
-        return;
-      }
-
-      // Success! Reset retry counter
+      // Reset retry counter
       _isolatedBridgeRetryAttempts = 0;
       lastRoleChangeTime = millis();
 
-      Log(STARTUP, "✓ Isolated bridge promotion complete on channel %d\n",
+      Log(STARTUP, "[OK] Isolated bridge promotion complete on channel %d\n",
           _meshChannel);
 
       // Notify via callback
@@ -2131,50 +2228,141 @@ class Mesh : public painlessmesh::Mesh<Connection> {
    */
   bool hasActualInternetAccess() {
     using namespace logger;
-    
+
+    // Cache result to avoid blocking DNS/HTTP on every call
+    static uint32_t lastCheckTime = 0;
+    static bool lastResult = false;
+    uint32_t now = millis();
+    if (lastCheckTime > 0 && (now - lastCheckTime) < 60000) {
+      return lastResult;
+    }
+
     // First check WiFi connection
     if (WiFi.status() != WL_CONNECTED) {
+      lastCheckTime = millis();
+      lastResult = false;
       return false;
     }
-    
+
     // Check if we have a valid local IP
     if (WiFi.localIP() == IPAddress(0, 0, 0, 0)) {
+      lastCheckTime = millis();
+      lastResult = false;
       return false;
     }
-    
+
     // Try to resolve a well-known DNS name
     // Using Google's servers as they have high availability globally
     IPAddress result;
-    
+
 #if defined(ESP32) || defined(ESP8266)
     // Both ESP32 and ESP8266 support WiFi.hostByName()
     int dnsResult = WiFi.hostByName("www.google.com", result);
-    
+
     // Check if DNS resolution succeeded
     if (dnsResult != 1) {
       Log(COMMUNICATION, "hasActualInternetAccess(): DNS resolution failed (code=%d)\n", dnsResult);
+      lastCheckTime = millis();
+      lastResult = false;
       return false;
     }
-    
+
     // Additional validation: Check if resolved IP is valid
     // Some ESP8266 versions may return success but set IP to 255.255.255.255 on error
     if (result == IPAddress(0, 0, 0, 0) || result == IPAddress(255, 255, 255, 255)) {
       TSTRING resultStr = result.toString();
       Log(COMMUNICATION, "hasActualInternetAccess(): Invalid DNS result IP: %s\n", resultStr.c_str());
+      lastCheckTime = millis();
+      lastResult = false;
       return false;
     }
 #else
     // Other platforms: assume internet is available if WiFi connected
     // (no reliable way to test without platform-specific APIs)
+    lastCheckTime = millis();
+    lastResult = true;
     return true;
 #endif
-    
+
     TSTRING resultStr = result.toString();
-    Log(COMMUNICATION, "hasActualInternetAccess(): Internet connectivity verified (resolved to %s)\n", 
+    Log(COMMUNICATION, "hasActualInternetAccess(): Internet connectivity verified (resolved to %s)\n",
         resultStr.c_str());
+    lastCheckTime = millis();
+    lastResult = true;
     return true;
   }
 
+  /**
+   * Detect captive portal by making a lightweight HTTP request
+   * 
+   * Captive portals often allow DNS resolution but intercept HTTP requests,
+   * returning redirects, cached responses (HTTP 203), or their own HTML.
+   * This function makes a simple HTTP GET request to a known endpoint and
+   * verifies the response to detect such interference.
+   * 
+   * Test endpoint used:
+   * - http://captive.apple.com/hotspot-detect.html - Returns "Success" (Apple standard)
+   * 
+   * @return true if no captive portal detected, false if portal found or check fails
+   */
+  bool detectCaptivePortal() {
+    using namespace logger;
+    
+#if defined(ESP32) || defined(ESP8266)
+    HTTPClient http;
+    http.setTimeout(5000);  // 5 second timeout for quick check
+    
+    WiFiClient client;
+    
+    // Use Apple's captive portal detection endpoint
+    // This is a well-maintained, reliable endpoint used by iOS devices
+    const char* testUrl = "http://captive.apple.com/hotspot-detect.html";
+    
+    Log(COMMUNICATION, "detectCaptivePortal(): Testing %s\n", testUrl);
+    
+#ifdef ESP8266
+    if (!http.begin(client, testUrl)) {
+      Log(COMMUNICATION, "detectCaptivePortal(): Failed to begin HTTP client - treating as potential network restriction\n");
+      return false;  // Conservative approach: treat initialization failure as potential captive portal or network restriction
+    }
+#else
+    // ESP32
+    if (!http.begin(testUrl)) {
+      Log(COMMUNICATION, "detectCaptivePortal(): Failed to begin HTTP client - treating as potential network restriction\n");
+      return false;
+    }
+#endif
+    
+    int httpCode = http.GET();
+    
+    if (httpCode != 200) {
+      // Any response other than HTTP 200 indicates captive portal or network issue
+      Log(COMMUNICATION, "detectCaptivePortal(): Unexpected HTTP code %d (expected 200)\n", httpCode);
+      http.end();
+      return false;
+    }
+    
+    // Check response content
+    String response = http.getString();
+    http.end();
+    
+    // Verify the response contains "Success" - this is Apple's standard response
+    // Full response: "<HTML><HEAD><TITLE>Success</TITLE></HEAD><BODY>Success</BODY></HTML>"
+    // We check for presence of "Success" to be robust against minor format variations
+    if (response.indexOf("Success") == -1) {
+      Log(COMMUNICATION, "detectCaptivePortal(): Response doesn't contain 'Success', likely captive portal\n");
+      return false;
+    }
+    
+    Log(COMMUNICATION, "detectCaptivePortal(): No captive portal detected\n");
+    return true;
+    
+#else
+    // Non-ESP platforms: can't reliably test, assume no captive portal
+    return true;
+#endif
+  }
+
   /**
    * Helper method to send gateway acknowledgment
    */
@@ -2263,6 +2451,13 @@ class Mesh : public painlessmesh::Mesh<Connection> {
             sendGatewayAck(pkg, false, 0, "Router has no internet access - check WAN connection");
             return true;  // Consume package - we handled it (with error)
           }
+          
+          // Finally, check for captive portal interference
+          // This detects when DNS works but HTTP requests are intercepted
+          if (!detectCaptivePortal()) {
+            sendGatewayAck(pkg, false, 0, "Captive portal detected - requires web authentication. Check router/WiFi settings");
+            return true;  // Consume package - we handled it (with error)
+          }
 
 #if defined(ESP32) || defined(ESP8266)
           // Make HTTP/HTTPS request
@@ -2538,9 +2733,20 @@ class Mesh : public painlessmesh::Mesh<Connection> {
   std::shared_ptr<Task> bridgeCoordinationTask;
   std::map<uint32_t, uint8_t> bridgePriorities;  // nodeId -> priority mapping
   std::vector<uint32_t> knownBridgePeers;        // List of peer bridge node IDs
-  uint32_t selectedBridgeOverride = 0;  // Manual bridge selection override
   size_t lastSelectedBridgeIndex = 0;   // For round-robin selection
 
+  // Bridge coordination monitoring callbacks and state
+  struct BridgeCoordinationState {
+    uint8_t priority;
+    TSTRING role;
+    uint8_t load;
+    uint32_t lastSeen;
+  };
+  std::map<uint32_t, BridgeCoordinationState> lastBridgeCoordinationState;
+  std::function<void(const plugin::BridgeCoordinationPackage&, uint32_t)> bridgeCoordinationCallback;
+  std::function<void(const plugin::BridgeCoordinationPackage&, uint32_t, TSTRING)> bridgeCoordinationChangedCallback;
+  std::shared_ptr<Task> bridgeLostDetectionTask;
+
   // Shared gateway mode state and configuration
   bool _sharedGatewayMode = false;
   gateway::SharedGatewayConfig _sharedGatewayConfig;

package/src/connection.cpp

@@ -0,0 +1,10 @@
+#include "painlessmesh/connection.hpp"
+
+namespace painlessmesh {
+namespace tcp {
+
+uint32_t lastScheduledDeletionTime = 0;
+painlessmesh::buffer::temp_buffer_t shared_buffer;
+
+}  // namespace tcp
+}  // namespace painlessmesh

package/src/painlessMesh.h

@@ -5,7 +5,7 @@
  * @file painlessMesh.h
  * @brief Main header file for Alteriom painlessMesh library
  * 
- * @version 1.9.19
+ * @version 1.9.20
  * @date 2025-12-21
  * 
  * painlessMesh is a user-friendly library for creating mesh networks with 
@@ -44,19 +44,6 @@
 #include "painlessmesh/ota.hpp"
 #endif
 
-// Include improvement modules when enabled
-#ifdef PAINLESSMESH_ENABLE_VALIDATION
-#include "painlessmesh/validation.hpp"
-#endif
-
-#ifdef PAINLESSMESH_ENABLE_METRICS
-#include "painlessmesh/metrics.hpp"
-#endif
-
-#ifdef PAINLESSMESH_ENABLE_MEMORY_OPTIMIZATION
-#include "painlessmesh/memory.hpp"
-#endif
-
 #include "painlessmesh/buffer.hpp"
 #include "painlessmesh/layout.hpp"
 #include "painlessmesh/logger.hpp"

package/src/painlessmesh/connection.hpp

@@ -42,10 +42,10 @@ static const uint32_t TCP_CLIENT_DELETION_SPACING_MS = 1000; // 1000ms spacing b
 // - The scheduler never runs tasks concurrently within the same mesh instance
 // - All mesh operations (including deletion callbacks) execute in the same thread
 // - Even when multiple tasks are ready, they execute one-at-a-time via scheduler->execute()
-static uint32_t lastScheduledDeletionTime = 0; // Timestamp of last deletion scheduled/executed (milliseconds)
+extern uint32_t lastScheduledDeletionTime; // Timestamp of last deletion scheduled/executed (milliseconds)
 
 // Shared buffer for reading/writing to the buffer
-static painlessmesh::buffer::temp_buffer_t shared_buffer;
+extern painlessmesh::buffer::temp_buffer_t shared_buffer;
 
 /**
  * Schedule deletion of an AsyncClient with proper spacing to prevent concurrent cleanups
@@ -116,25 +116,20 @@ inline void scheduleAsyncClientDeletion(Scheduler* scheduler, AsyncClient* clien
   Log(CONNECTION, "%s: Scheduling AsyncClient deletion in %u ms (spaced from previous deletions)\n", 
       logPrefix, actualDelay);
   
-  // Schedule the deletion task
-  // 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
+  // Schedule the deletion task with self-cleanup
   Task* cleanupTask = new Task(actualDelay * TASK_MILLISECOND, TASK_ONCE, [client, logPrefix]() {
     using namespace logger;
     Log(CONNECTION, "%s: Deferred cleanup of AsyncClient executing now\n", logPrefix);
-    
-    // Note: lastScheduledDeletionTime is updated at scheduling time (before this task runs), not here
-    // This ensures consistent spacing based on when deletions were scheduled, preventing
-    // the race condition where execution-time updates could "rewind" the timestamp
-    // and cause subsequent deletions to be scheduled too close together
-    
     delete client;
   });
-  
+
+  // Self-cleanup: after execution, remove from scheduler and delete the Task.
+  // OnDisable fires after a TASK_ONCE task completes its single iteration.
+  cleanupTask->setOnDisable([cleanupTask, scheduler]() {
+    scheduler->deleteTask(*cleanupTask);
+    delete cleanupTask;
+  });
+
   scheduler->addTask(*cleanupTask);
   cleanupTask->enableDelayed();
 }