@alteriom/painlessmesh 1.9.19 → 1.10.0

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");
@@ -816,8 +817,9 @@ class Mesh : public painlessmesh::Mesh<Connection> {
    * TCP Connection Retry:
    * The TCP connection now includes automatic retry with exponential backoff.
    * If the initial connection fails (error -14 ERR_CONN or other errors),
-   * the system will retry up to TCP_CONNECT_MAX_RETRIES times before
-   * triggering a full WiFi reconnection cycle. This helps handle:
+   * the system will retry up to the configured maxRetries times before
+   * triggering a full WiFi reconnection cycle (see setTcpRetryConfig()).
+   * This helps handle:
    * - Timing issues where TCP server is not ready immediately
    * - Network stack stabilization after IP acquisition
    * - Transient network conditions
@@ -841,8 +843,11 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       // This helps prevent error -14 (ERR_CONN) by allowing the network stack
       // and TCP server to be fully ready. The delay is added via task scheduler
       // to avoid blocking the event loop.
+      // The delay is read at schedule time, so calling setTcpRetryConfig()
+      // while a connect is already pending affects the next attempt, not the
+      // in-flight one.
       this->addTask(
-          painlessmesh::tcp::TCP_CONNECT_STABILIZATION_DELAY_MS, TASK_ONCE,
+          this->getTcpRetryConfig().stabilizationDelayMs, TASK_ONCE,
           [this, targetIP, targetPort]() {
             // Verify WiFi is still connected after the delay
             if (WiFi.status() != WL_CONNECTED || !WiFi.localIP()) {
@@ -998,6 +1003,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 +1297,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 +1543,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 +1555,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 +1901,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,60 +1962,57 @@ 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);
-
-    // Save current mesh configuration to restore if bridge init fails
+    // 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.
+    // The copies below are captured by value into the deferred lambda so the
+    // stop() call inside it cannot clear/mutate these members before the
+    // reinit reads them. (The Mesh object itself outlives the lambda; this
+    // protects against member mutation, not object lifetime.)
+    // TODO(#373 follow-up): if the mesh owns its scheduler
+    // (!isExternalScheduler), stop() deletes mScheduler and savedScheduler
+    // dangles before initAsBridge() uses it. Pre-existing limitation —
+    // bridge promotion requires a user-supplied scheduler.
     uint8_t savedChannel = _meshChannel;
+    TSTRING savedMeshSSID = _meshSSID;
+    TSTRING savedMeshPassword = _meshPassword;
+    TSTRING savedRouterSSID = routerSSID;
+    TSTRING savedRouterPassword = routerPassword;
+    Scheduler *savedScheduler = mScheduler;
+    auto savedBridgeRoleChangedCallback = bridgeRoleChangedCallback;
 
     // 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]() {
+    this->addTask(ASYNC_PROMOTION_DELAY_MS, TASK_ONCE,
+                  [this, savedChannel, savedMeshSSID, savedMeshPassword,
+                   savedRouterSSID, savedRouterPassword, savedScheduler,
+                   savedBridgeRoleChangedCallback]() {
       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);
-
-      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(savedMeshSSID, savedMeshPassword, savedRouterSSID,
+                         savedRouterPassword, savedScheduler, _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
-      if (bridgeRoleChangedCallback) {
+      if (savedBridgeRoleChangedCallback) {
         static const TSTRING reason = "Election winner - best router signal";
-        bridgeRoleChangedCallback(true, reason);
+        savedBridgeRoleChangedCallback(true, reason);
       }
 
       // Note: The initial takeover announcement was already sent earlier
@@ -1944,64 +2085,52 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     Log(CONNECTION,
         "Scheduling stop/reinit (async to avoid task corruption)\n");
 
-    // Save current mesh configuration
+    // Save current mesh configuration. Captured by value into the deferred
+    // lambda so stop() cannot clear/mutate these members before the reinit
+    // reads them (see the matching comment in promoteToBridge(); same
+    // TODO(#373 follow-up) about savedScheduler and internal schedulers
+    // applies here).
     uint8_t savedChannel = _meshChannel;
+    TSTRING savedMeshSSID = _meshSSID;
+    TSTRING savedMeshPassword = _meshPassword;
+    TSTRING savedRouterSSID = routerSSID;
+    TSTRING savedRouterPassword = routerPassword;
+    Scheduler *savedScheduler = mScheduler;
+    auto savedBridgeRoleChangedCallback = bridgeRoleChangedCallback;
 
     // 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]() {
+    this->addTask(ASYNC_PROMOTION_DELAY_MS, TASK_ONCE,
+                  [this, savedChannel, savedMeshSSID, savedMeshPassword,
+                   savedRouterSSID, savedRouterPassword, savedScheduler,
+                   savedBridgeRoleChangedCallback]() {
       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);
-
-      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-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");
-        }
+      // Allow event loop processing during hardware settling
+      for (int i = 0; i < 100; i++) { delay(10); yield(); }
 
-        return;
-      }
+      // initAsBridge always returns true: bridge mesh functionality is active
+      // regardless of router connection status (router connection is opportunistic)
+      this->initAsBridge(savedMeshSSID, savedMeshPassword, savedRouterSSID,
+                         savedRouterPassword, savedScheduler, _meshPort);
 
-      // 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
-      // Use explicit TSTRING construction to ensure string lifetime safety
-      if (bridgeRoleChangedCallback) {
+      if (savedBridgeRoleChangedCallback) {
         static const TSTRING reason = "Isolated node promoted to bridge";
-        bridgeRoleChangedCallback(true, reason);
+        savedBridgeRoleChangedCallback(true, reason);
       }
 
       // Note: Bridge status announcement will be sent automatically by
@@ -2131,50 +2260,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 +2483,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 +2765,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;