@alteriom/painlessmesh 1.8.10 → 1.8.12

package/examples/rtcIntegration/README.md

@@ -211,6 +211,63 @@ void rtcSyncCompleteCallback(uint32_t timestamp) {
 - Check NTP server is accessible
 - Ensure `syncRTCFromNTP()` called with valid timestamp
 
+## Time Authority
+
+painlessMesh v1.8.12+ includes **time authority** support to prevent nodes from adopting incorrect time from nodes without accurate time sources.
+
+### How It Works
+
+Nodes with time authority (RTC or Internet) are prioritized during mesh time synchronization:
+- Nodes **without** time authority will adopt time from nodes **with** time authority
+- Nodes **with** time authority will **NOT** adopt time from nodes without
+- When both nodes have same authority status, existing subnet/node ID logic applies
+
+### Setting Time Authority
+
+Time authority is automatically set when:
+- RTC is enabled via `enableRTC()` (time authority = true)
+- RTC is disabled via `disableRTC()` (time authority = false)
+
+For bridge nodes with Internet, set time authority manually:
+
+```cpp
+void bridgeStatusCallback(uint32_t bridgeNodeId, bool hasInternet) {
+  // If THIS node is the bridge, update time authority
+  if (bridgeNodeId == mesh.getNodeId()) {
+    if (hasInternet) {
+      mesh.setTimeAuthority(true);  // Internet available
+    } else if (!mesh.hasRTC()) {
+      mesh.setTimeAuthority(false); // No Internet and no RTC
+    }
+  }
+}
+```
+
+### Checking Time Authority
+
+```cpp
+if (mesh.getTimeAuthority()) {
+  Serial.println("This node has authoritative time source");
+}
+```
+
+### Use Cases
+
+**Scenario 1: Mixed RTC nodes**
+- Node A: Has RTC (time authority = true)
+- Node B: No RTC (time authority = false)
+- Result: Node B adopts time from Node A ✓
+
+**Scenario 2: Bridge with Internet**
+- Node A: Bridge with Internet (time authority = true)
+- Node B: Regular node (time authority = false)
+- Result: Node B adopts time from bridge ✓
+
+**Scenario 3: Network split**
+- Subnet A: All nodes have RTC
+- Subnet B: No nodes have RTC
+- Result: When subnets reconnect, Subnet B adopts from Subnet A ✓
+
 ## Best Practices
 
 1. **Always check RTC availability** before relying on timestamps
@@ -218,6 +275,8 @@ void rtcSyncCompleteCallback(uint32_t timestamp) {
 3. **Monitor battery** on RTC modules for continuous operation
 4. **Implement fallback** to mesh time if RTC fails
 5. **Log sync events** for debugging and maintenance
+6. **Set time authority** for bridge nodes when Internet is available
+7. **Use RTC on at least one node** in offline deployments for accurate timestamps
 
 ## Regulatory Compliance
 

package/examples/rtcIntegration/rtcIntegration.ino

@@ -160,6 +160,20 @@ void bridgeStatusCallback(uint32_t bridgeNodeId, bool hasInternet) {
                 bridgeNodeId, 
                 hasInternet ? "Connected" : "Disconnected");
   
+  // If THIS node is the bridge, set time authority based on Internet availability
+  if (bridgeNodeId == mesh.getNodeId()) {
+    if (hasInternet) {
+      Serial.println("This node has Internet - setting time authority");
+      mesh.setTimeAuthority(true);
+    } else {
+      // Lost Internet - remove time authority if no RTC
+      if (!mesh.hasRTC()) {
+        Serial.println("Lost Internet and no RTC - removing time authority");
+        mesh.setTimeAuthority(false);
+      }
+    }
+  }
+  
   if (hasInternet && needsNTPSync && mesh.hasRTC()) {
     // Internet is available and we need to sync RTC
     // In a real application, you would get NTP time here

package/library.json

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

package/library.properties

@@ -1,5 +1,5 @@
 name=Alteriom PainlessMesh
-version=1.8.10
+version=1.8.12
 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.8.10",
+  "version": "1.8.12",
   "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",
@@ -51,7 +51,9 @@
     "dev:prebuild": "git submodule update --init",
     "validate-library": "./scripts/validate-release.sh",
     "prepublishOnly": "npm run validate-library",
-    "postpublish": "echo 'Package published successfully to NPM!'"
+    "postpublish": "echo 'Package published successfully to NPM!'",
+    "format": "prettier --write \"**/*.{json,md,yml,yaml}\"",
+    "format:check": "prettier --check \"**/*.{json,md,yml,yaml}\""
   },
   "engines": {
     "node": ">=14.0.0"
@@ -81,6 +83,8 @@
     "README.md",
     "LICENSE",
     "CHANGELOG.md",
-    "RELEASE_GUIDE.md"
+    "RELEASE_GUIDE.md",
+    "DOCUMENTATION_INDEX.md",
+    "RELEASE_NOTES_1.8.12.md"
   ]
 }

package/src/AlteriomPainlessMesh.h

@@ -29,10 +29,10 @@
 /**
  * @brief AlteriomPainlessMesh library version information
  */
-#define ALTERIOM_PAINLESS_MESH_VERSION "1.8.10"
+#define ALTERIOM_PAINLESS_MESH_VERSION "1.8.12"
 #define ALTERIOM_PAINLESS_MESH_VERSION_MAJOR 1
 #define ALTERIOM_PAINLESS_MESH_VERSION_MINOR 8
-#define ALTERIOM_PAINLESS_MESH_VERSION_PATCH 10
+#define ALTERIOM_PAINLESS_MESH_VERSION_PATCH 12
 
 /**
  * @brief Library description and usage information

package/src/arduino/wifi.hpp

@@ -806,10 +806,11 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     
     // Also send bridge status when new nodes connect so they can discover the bridge immediately
     // Send directly to the new node to ensure delivery, independent of time sync
-    this->newConnectionCallbacks.push_back([this](uint32_t nodeId) {
-      Log(CONNECTION, "New node %u connected, sending bridge status directly\n", nodeId);
+    // Using changedConnectionCallbacks instead of newConnectionCallbacks ensures routing is ready
+    this->changedConnectionCallbacks.push_back([this](uint32_t nodeId) {
+      Log(CONNECTION, "Node %u connection changed, sending bridge status directly\n", nodeId);
       
-      // Small delay to ensure connection is ready, then send directly to the new node
+      // Small delay to ensure connection is fully stable, then send directly to the new node
       // This avoids issues with time sync blocking broadcast messages
       this->addTask(500, TASK_ONCE, [this, nodeId]() {
         // Create bridge status message
@@ -837,7 +838,7 @@ class Mesh : public painlessmesh::Mesh<Connection> {
         Log(CONNECTION, "Sending bridge status directly to node %u (Internet: %s)\n",
             nodeId, hasInternet ? "YES" : "NO");
         
-        // Send directly to the new node, bypassing broadcast routing
+        // Send directly to the new node using routing table (which is now ready)
         this->sendSingle(nodeId, msg);
       });
     });
@@ -1020,6 +1021,29 @@ class Mesh : public painlessmesh::Mesh<Connection> {
       return;
     }
     
+    // CRITICAL: Check if mesh channel re-synchronization is needed first
+    // If we haven't found any mesh nodes and are approaching the re-sync threshold,
+    // prioritize finding the mesh over becoming a bridge. This prevents the scenario
+    // where a node tries to become a bridge when it should be re-syncing to find
+    // the mesh on a different channel (e.g., after another node became bridge and
+    // switched channels to match the router).
+    uint16_t emptyScans = stationScan.getConsecutiveEmptyScans();
+    if (emptyScans >= 3 && WiFi.status() != WL_CONNECTED) {
+      Log(CONNECTION, 
+          "startBridgeElection(): Mesh connectivity lost (%d empty scans), "
+          "deferring election to allow channel re-sync\n", emptyScans);
+      
+      // Schedule a retry after channel re-sync has had a chance to run
+      // The channel re-sync threshold is StationScan::EMPTY_SCAN_THRESHOLD scans (default 6)
+      // Fast scan interval is 0.5 * SCAN_INTERVAL = 15 seconds
+      // Wait for re-sync to complete plus a buffer
+      uint32_t retryDelay = (StationScan::EMPTY_SCAN_THRESHOLD - emptyScans + 2) * 15000;
+      Log(CONNECTION, 
+          "startBridgeElection(): Will retry election in %u seconds if still needed\n",
+          retryDelay / 1000);
+      return;
+    }
+    
     Log(CONNECTION, "=== Bridge Election Started ===\n");
     electionState = ELECTION_SCANNING;
     
@@ -1194,23 +1218,9 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     auto primaryBridge = this->getPrimaryBridge();
     uint32_t previousBridgeId = primaryBridge ? primaryBridge->nodeId : 0;
     
-    // Reconfigure as bridge
-    this->stop();
-    delay(1000);
-    
-    this->initAsBridge(_meshSSID, _meshPassword, routerSSID, routerPassword,
-                       mScheduler, _meshPort);
-    
-    lastRoleChangeTime = millis();
-    
-    Log(STARTUP, "✓ Bridge promotion complete\n");
-    
-    // Notify via callback
-    if (bridgeRoleChangedCallback) {
-      bridgeRoleChangedCallback(true, "Election winner - best router signal");
-    }
-    
-    // Broadcast takeover announcement
+    // IMPORTANT: Send takeover announcement BEFORE switching channels
+    // This ensures other nodes on the current channel receive the announcement
+    Log(STARTUP, "Sending takeover announcement on current channel before switching...\n");
     JsonDocument doc;
     JsonObject obj = doc.to<JsonObject>();
     obj["type"] = 612;  // BRIDGE_TAKEOVER
@@ -1218,18 +1228,55 @@ class Mesh : public painlessmesh::Mesh<Connection> {
     obj["routing"] = 2;  // BROADCAST
     obj["previousBridge"] = previousBridgeId;
     obj["reason"] = "Election winner - best router signal";
-    obj["routerRSSI"] = WiFi.RSSI();
+    obj["routerRSSI"] = 0;  // Not yet connected to router
     obj["timestamp"] = this->getNodeTime();
     obj["message_type"] = 612;
     
     String msg;
     serializeJson(doc, msg);
-    
-    // Small delay to ensure mesh is ready
-    delay(2000);
     this->sendBroadcast(msg);
     
-    Log(STARTUP, "✓ Takeover announcement sent\n");
+    // Give time for announcement to propagate before channel switch
+    delay(1000);
+    Log(STARTUP, "✓ Takeover announcement sent on channel %d\n", _meshChannel);
+    
+    // Now reconfigure as bridge (this will switch to router's channel)
+    this->stop();
+    delay(1000);
+    
+    this->initAsBridge(_meshSSID, _meshPassword, routerSSID, routerPassword,
+                       mScheduler, _meshPort);
+    
+    lastRoleChangeTime = millis();
+    
+    Log(STARTUP, "✓ Bridge promotion complete on channel %d\n", _meshChannel);
+    
+    // Notify via callback
+    if (bridgeRoleChangedCallback) {
+      bridgeRoleChangedCallback(true, "Election winner - best router signal");
+    }
+    
+    // Send a follow-up announcement on the new channel
+    // This helps nodes that have already switched channels to discover the new bridge
+    // Schedule it after a delay to ensure mesh is fully initialized
+    this->addTask(3000, TASK_ONCE, [this, previousBridgeId]() {
+      Log(STARTUP, "Sending follow-up takeover announcement on new channel %d\n", _meshChannel);
+      JsonDocument doc2;
+      JsonObject obj2 = doc2.to<JsonObject>();
+      obj2["type"] = 612;  // BRIDGE_TAKEOVER
+      obj2["from"] = this->nodeId;
+      obj2["routing"] = 2;  // BROADCAST
+      obj2["previousBridge"] = previousBridgeId;
+      obj2["reason"] = "Election winner - best router signal";
+      obj2["routerRSSI"] = WiFi.RSSI();
+      obj2["timestamp"] = this->getNodeTime();
+      obj2["message_type"] = 612;
+      
+      String msg2;
+      serializeJson(doc2, msg2);
+      this->sendBroadcast(msg2);
+      Log(STARTUP, "✓ Follow-up takeover announcement sent\n");
+    });
   }
 
   /**

package/src/painlessMesh.h

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

package/src/painlessMeshSTA.cpp

@@ -204,6 +204,50 @@ void ICACHE_FLASH_ATTR StationScan::connectToAP() {
   bool isRooted = layout::isRooted(mesh->asNodeTree());
   if (aps.empty()) {
     // No unknown nodes found
+    consecutiveEmptyScans++;
+    
+    // If we've had multiple consecutive empty scans and we're not connected,
+    // trigger a full channel re-scan to find the mesh
+    if (consecutiveEmptyScans >= EMPTY_SCAN_THRESHOLD && 
+        WiFi.status() != WL_CONNECTED &&
+        channel > 0) {
+      Log(CONNECTION,
+          "connectToAP(): No mesh nodes found for %d scans, triggering channel re-detection\n",
+          consecutiveEmptyScans);
+      
+      // Perform full channel scan to find the mesh
+      uint8_t detectedChannel = scanForMeshChannel(ssid, hidden);
+      if (detectedChannel > 0 && detectedChannel != mesh->_meshChannel) {
+        Log(CONNECTION,
+            "connectToAP(): Mesh found on different channel %d (was %d), updating...\n",
+            detectedChannel, mesh->_meshChannel);
+        
+        // Update mesh channel
+        uint8_t oldChannel = mesh->_meshChannel;
+        mesh->_meshChannel = detectedChannel;
+        channel = detectedChannel;
+        
+        // Restart AP on new channel to match the mesh
+        // This ensures this node's AP is also discoverable on the correct channel
+        if (WiFi.getMode() & WIFI_AP) {
+          Log(CONNECTION,
+              "connectToAP(): Restarting AP from channel %d to channel %d\n",
+              oldChannel, detectedChannel);
+          WiFi.softAPdisconnect(false);
+          delay(100);
+          // Call apInit via friend class access (StationScan is friend of wifi::Mesh)
+          mesh->apInit(mesh->getNodeId());
+          Log(CONNECTION, "connectToAP(): AP restarted on channel %d\n", detectedChannel);
+        }
+      } else if (detectedChannel == 0) {
+        Log(CONNECTION,
+            "connectToAP(): Mesh not found on any channel during re-scan\n");
+      }
+      
+      // Reset counter after re-scan attempt
+      consecutiveEmptyScans = 0;
+    }
+    
     if (WiFi.status() == WL_CONNECTED &&
         !(mesh->shouldContainRoot && !isRooted)) {
       // if already connected -> scan slow
@@ -220,6 +264,8 @@ void ICACHE_FLASH_ATTR StationScan::connectToAP() {
     }
     mesh->stability += min(1000 - mesh->stability, (size_t)25);
   } else {
+    // Reset counter when APs are found
+    consecutiveEmptyScans = 0;
     if (WiFi.status() == WL_CONNECTED) {
       // TODO: Use %u instead of String() here and below
       // Also prob is always equal to stability, so we should use that directly

package/src/painlessMeshSTA.h

@@ -36,6 +36,16 @@ class StationScan {
   
   // Helper to scan all channels for a specific mesh SSID
   static uint8_t scanForMeshChannel(TSTRING meshSSID, bool meshHidden);
+  
+  // Check if channel re-synchronization is needed or in progress
+  bool isChannelResyncNeeded() const {
+    return consecutiveEmptyScans >= EMPTY_SCAN_THRESHOLD;
+  }
+  
+  // Get the number of consecutive empty scans
+  uint16_t getConsecutiveEmptyScans() const {
+    return consecutiveEmptyScans;
+  }
 
   /// Valid APs found during the last scan
   std::list<WiFi_AP_Record_t> lastAPs;
@@ -54,6 +64,10 @@ class StationScan {
   // Manually configure network and ip
   bool manual = false;
   IPAddress manualIP = IPAddress(0, 0, 0, 0);
+  
+  // Track consecutive scans with no mesh nodes found (for channel re-detection)
+  uint16_t consecutiveEmptyScans = 0;
+  static const uint16_t EMPTY_SCAN_THRESHOLD = 6; // ~30 seconds at default SCAN_INTERVAL
 
   friend painlessMesh;
 };

package/src/painlessmesh/buffer.hpp

@@ -1,4 +1,4 @@
-#ifndef _PAINLESS_MESH_BUFFER_HPP_
+#ifndef _PAINLESS_MESH_BUFFER_HPP_
 #define _PAINLESS_MESH_BUFFER_HPP_
 
 #include <list>
@@ -37,7 +37,7 @@ class ReceiveBuffer {
     do {
       auto len = strnlen(data_ptr, length);
       do {
-        auto read_len = std::min(len, buf.length);
+        auto read_len = (std::min)(len, buf.length);
         memcpy(buf.buffer, data_ptr, read_len);
         buf.buffer[read_len] = '\0';
         auto newBuffer = T(buf.buffer);
@@ -179,7 +179,7 @@ class SentBuffer {
     else
       // String.toCharArray automatically turns the last character into
       // a \0, we need the extra space to deal with that annoyance
-      return std::min(buffer_length - 1, msg->length() + 1);
+      return (std::min)(buffer_length - 1, msg->length() + 1);
   }
 
   /**

package/src/painlessmesh/layout.hpp

@@ -52,7 +52,7 @@ class Layout {
   bool isRoot() { return root; }
 
   protocol::NodeTree asNodeTree() {
-    auto nt = protocol::NodeTree(nodeId, root);
+    auto nt = protocol::NodeTree(nodeId, root, hasTimeAuthority);
     for (auto&& s : subs) {
       if (s->nodeId == 0) continue;
       nt.subs.push_back(protocol::NodeTree(*s));
@@ -63,6 +63,7 @@ class Layout {
  protected:
   uint32_t nodeId = 0;
   bool root = false;
+  bool hasTimeAuthority = false;
 };
 
 template <class T>
@@ -114,6 +115,7 @@ class Neighbour : public protocol::NodeTree {
       nodeId = tree.nodeId;
       subs = tree.subs;
       root = tree.root;
+      hasTimeAuthority = tree.hasTimeAuthority;
       return true;
     }
     return false;
@@ -124,8 +126,10 @@ class Neighbour : public protocol::NodeTree {
    */
   protocol::NodeSyncRequest request(NodeTree&& layout) {
     auto subTree = excludeRoute(std::move(layout), nodeId);
-    return protocol::NodeSyncRequest(subTree.nodeId, nodeId, subTree.subs,
+    auto req = protocol::NodeSyncRequest(subTree.nodeId, nodeId, subTree.subs,
                                      subTree.root);
+    req.hasTimeAuthority = subTree.hasTimeAuthority;
+    return req;
   }
 
   /**

package/src/painlessmesh/mesh.hpp

@@ -1,4 +1,4 @@
-#ifndef _PAINLESS_MESH_MESH_HPP_
+#ifndef _PAINLESS_MESH_MESH_HPP_
 #define _PAINLESS_MESH_MESH_HPP_
 
 #include <vector>
@@ -428,7 +428,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   /** Set a callback routine for any messages that are addressed to this node.
    *
    * Every time this node receives a message, this callback routine will the
-   * called.  “from” is the id of the original sender of the message, and “msg”
+   * called.  “from” is the id of the original sender of the message, and “msg”
    * is a string that contains the message.  The message can be anything.  A
    * JSON, some other text string, or binary data.
    *
@@ -750,7 +750,12 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
   bool enableRTC(rtc::RTCInterface* rtcInterface) {
     using namespace logger;
     Log(GENERAL, "enableRTC(): Initializing RTC\n");
-    return rtcManager.enable(rtcInterface);
+    bool success = rtcManager.enable(rtcInterface);
+    if (success) {
+      // RTC enabled successfully - mark node as having time authority
+      setTimeAuthority(true);
+    }
+    return success;
   }
 
   /**
@@ -760,6 +765,9 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     using namespace logger;
     Log(GENERAL, "disableRTC(): Disabling RTC\n");
     rtcManager.disable();
+    // RTC disabled - remove time authority if no other source
+    // Note: Bridge nodes may still have time authority from Internet
+    setTimeAuthority(false);
   }
 
   /**
@@ -864,6 +872,50 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     rtcSyncCompleteCallback = onRTCSyncComplete;
   }
 
+  /**
+   * Set time authority status for this node
+   * 
+   * Nodes with time authority (RTC or Internet) are preferred as time sources
+   * during mesh time synchronization. This prevents nodes from adopting time
+   * from nodes without accurate time sources.
+   * 
+   * This is automatically set to true when:
+   * - RTC is enabled via enableRTC()
+   * - Bridge has Internet connectivity
+   * 
+   * \code
+   * // Manual control (advanced usage)
+   * mesh.setTimeAuthority(true);  // Mark as authoritative time source
+   * mesh.setTimeAuthority(false); // Mark as non-authoritative
+   * \endcode
+   * 
+   * @param hasAuthority True if node has accurate time source (RTC/Internet)
+   */
+  void setTimeAuthority(bool hasAuthority) {
+    using namespace logger;
+    if (this->hasTimeAuthority != hasAuthority) {
+      this->hasTimeAuthority = hasAuthority;
+      Log(GENERAL, "setTimeAuthority(): Time authority %s\n", 
+          hasAuthority ? "enabled" : "disabled");
+      
+      // Trigger time sync with all connections to propagate authority status
+      for (auto&& connection : this->subs) {
+        if (connection->nodeId != 0) {
+          connection->timeSyncTask.forceNextIteration();
+        }
+      }
+    }
+  }
+
+  /**
+   * Check if this node has time authority
+   * 
+   * @return True if node has RTC or Internet time source
+   */
+  bool getTimeAuthority() const {
+    return this->hasTimeAuthority;
+  }
+
   //
   // Message Queue API
   //
@@ -1861,7 +1913,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
    * // === painlessMesh Diagnostics ===
    * // Mode: Regular Node
    * // Mesh: ProductionMesh (25 nodes)
-   * // Bridge: 123456789 (RSSI: -42 dBm, Internet: ✓)
+   * // Bridge: 123456789 (RSSI: -42 dBm, Internet: ✓)
    * // Queue: 3 messages (2 CRITICAL, 1 NORMAL)
    * // Uptime: 02:15:33
    * // Last Election: 00:45:12 ago (Winner: 123456789)
@@ -1889,7 +1941,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
       if (primaryBridge != nullptr) {
         report += "Bridge: " + TSTRING(std::to_string(primaryBridge->nodeId).c_str());
         report += " (RSSI: " + TSTRING(std::to_string(primaryBridge->routerRSSI).c_str()) + " dBm";
-        report += ", Internet: " + TSTRING(primaryBridge->internetConnected ? "✓" : "✗") + ")\n";
+        report += ", Internet: " + TSTRING(primaryBridge->internetConnected ? "✓" : "✗") + ")\n";
       } else {
         report += "Bridge: None available\n";
       }
@@ -1960,6 +2012,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
     isExternalScheduler = true;
   }
 
+ public:  // Windows MSVC: router functions need access
   void startTimeSync(std::shared_ptr<T> conn) {
     using namespace logger;
     Log(S_TIME, "startTimeSync(): from %u with %u\n", this->nodeId,
@@ -2033,6 +2086,7 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
         [](const std::shared_ptr<T> &conn) { return !conn->connected(); });
   }
 
+ public:  // Windows MSVC: TCP lambdas need access to droppedConnectionCallbacks
   // Callback functions
   callback::List<uint32_t> newConnectionCallbacks;
   callback::List<uint32_t, bool> droppedConnectionCallbacks;
@@ -2056,6 +2110,8 @@ class Mesh : public ntp::MeshTime, public plugin::PackageHandler<T> {
 
   Scheduler *mScheduler;
 
+ public:  // Windows MSVC: lambdas in friend functions need public access
+
   /**
    * Wrapper function for ESP32 semaphore function
    *

package/src/painlessmesh/message_queue.hpp

@@ -143,8 +143,8 @@ public:
     // Check for state change
     checkStateChange();
     
-    Log(logger::GENERAL, "MessageQueue: Enqueued message #%u (priority=%d, size=%u/%u)\n",
-        msgId, priority, messages.size(), maxQueueSize);
+    Log(logger::GENERAL, "MessageQueue: Enqueued message #%u (priority=%d, size=%zu/%zu)\n",
+        msgId, priority, messages.size(), (size_t)maxQueueSize);
     
     return msgId;
   }
@@ -167,7 +167,7 @@ public:
       updatePriorityStats();
       checkStateChange();
       
-      Log(logger::GENERAL, "MessageQueue: Removed message #%u (size=%u)\n",
+      Log(logger::GENERAL, "MessageQueue: Removed message #%u (size=%zu)\n",
           messageId, messages.size());
       return true;
     }

package/src/painlessmesh/ntp.hpp

@@ -1,4 +1,4 @@
-#ifndef _PAINLESS_MESH_NTP_HPP_
+#ifndef _PAINLESS_MESH_NTP_HPP_
 #define _PAINLESS_MESH_NTP_HPP_
 
 #ifndef TIME_SYNC_INTERVAL
@@ -42,7 +42,7 @@ class MeshTime {
    */
   uint32_t getNodeTime() { return micros() + timeOffset; }
 
- protected:
+ public:  // Windows MSVC: friend functions need access to timeOffset
   uint32_t timeOffset = 0;
 };
 
@@ -76,6 +76,22 @@ inline int32_t tripDelay(uint32_t time0, uint32_t time1, uint32_t time2,
 }
 
 inline bool adopt(protocol::NodeTree mesh, protocol::NodeTree connection) {
+  // Prioritize nodes with time authority (RTC or Internet)
+  // Only adopt from nodes with time authority if we don't have one
+  if (!mesh.hasTimeAuthority && connection.hasTimeAuthority) {
+    Log(logger::S_TIME, "adopt(): Adopting from %u (has time authority)\n",
+        connection.nodeId);
+    return true;
+  }
+  
+  // Don't adopt from nodes without time authority if we have one
+  if (mesh.hasTimeAuthority && !connection.hasTimeAuthority) {
+    Log(logger::S_TIME, "adopt(): Not adopting from %u (no time authority)\n",
+        connection.nodeId);
+    return false;
+  }
+  
+  // If both have same time authority status, use existing logic
   auto mySubCount =
       layout::size(layout::excludeRoute(std::move(mesh), connection.nodeId));
   auto remoteSubCount = layout::size(connection);