Reword comment to avoid ci-custom scanf lint false positive

The regex matches `scanf (` in comments too since `\s*\(` matches the
space before the parenthesized size note.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

esphome/analyze_memory/const.py

@@ -256,7 +256,7 @@ SYMBOL_PATTERNS = {
     "ipv6_stack": ["nd6_", "ip6_", "mld6_", "icmp6_", "icmp6_input"],
     # Order matters! More specific categories must come before general ones.
     # mdns must come before bluetooth to avoid "_mdns_disable_pcb" matching "ble_" pattern
-    "mdns_lib": ["mdns", "packet$"],
+    "mdns_lib": ["mdns"],
     # memory_mgmt must come before wifi_stack to catch mmu_hal_* symbols
     "memory_mgmt": [
         "mem_",
@@ -794,6 +794,7 @@ SYMBOL_PATTERNS = {
         "s_dp",
         "s_ni",
         "s_reg_dump",
+        "packet$",
         "d_mult_table",
         "K",
         "fcstab",

esphome/components/api/api_server.cpp

@@ -117,7 +117,37 @@ void APIServer::setup() {
 void APIServer::loop() {
   // Accept new clients only if the socket exists and has incoming connections
   if (this->socket_ && this->socket_->ready()) {
-    this->accept_new_connections_();
+    while (true) {
+      struct sockaddr_storage source_addr;
+      socklen_t addr_len = sizeof(source_addr);
+
+      auto sock = this->socket_->accept_loop_monitored((struct sockaddr *) &source_addr, &addr_len);
+      if (!sock)
+        break;
+
+      char peername[socket::SOCKADDR_STR_LEN];
+      sock->getpeername_to(peername);
+
+      // Check if we're at the connection limit
+      if (this->clients_.size() >= this->max_connections_) {
+        ESP_LOGW(TAG, "Max connections (%d), rejecting %s", this->max_connections_, peername);
+        // Immediately close - socket destructor will handle cleanup
+        sock.reset();
+        continue;
+      }
+
+      ESP_LOGD(TAG, "Accept %s", peername);
+
+      auto *conn = new APIConnection(std::move(sock), this);
+      this->clients_.emplace_back(conn);
+      conn->start();
+
+      // First client connected - clear warning and update timestamp
+      if (this->clients_.size() == 1 && this->reboot_timeout_ != 0) {
+        this->status_clear_warning();
+        this->last_connected_ = App.get_loop_component_start_time();
+      }
+    }
   }
 
   if (this->clients_.empty()) {
@@ -148,84 +178,46 @@ void APIServer::loop() {
   while (client_index < this->clients_.size()) {
     auto &client = this->clients_[client_index];
 
-    if (client->flags_.remove) {
-      // Rare case: handle disconnection (don't increment - swapped element needs processing)
-      this->remove_client_(client_index);
-    } else {
+    if (!client->flags_.remove) {
       // Common case: process active client
       client->loop();
       client_index++;
-    }
-  }
-}
-
-void APIServer::remove_client_(size_t client_index) {
-  auto &client = this->clients_[client_index];
-
-#ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
-  this->unregister_active_action_calls_for_connection(client.get());
-#endif
-  ESP_LOGV(TAG, "Remove connection %s", client->get_name());
-
-#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-  // Save client info before closing socket and removal for the trigger
-  char peername_buf[socket::SOCKADDR_STR_LEN];
-  std::string client_name(client->get_name());
-  std::string client_peername(client->get_peername_to(peername_buf));
-#endif
-
-  // Close socket now (was deferred from on_fatal_error to allow getpeername)
-  client->helper_->close();
-
-  // Swap with the last element and pop (avoids expensive vector shifts)
-  if (client_index < this->clients_.size() - 1) {
-    std::swap(this->clients_[client_index], this->clients_.back());
-  }
-  this->clients_.pop_back();
-
-  // Last client disconnected - set warning and start tracking for reboot timeout
-  if (this->clients_.empty() && this->reboot_timeout_ != 0) {
-    this->status_set_warning();
-    this->last_connected_ = App.get_loop_component_start_time();
-  }
-
-#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-  // Fire trigger after client is removed so api.connected reflects the true state
-  this->client_disconnected_trigger_.trigger(client_name, client_peername);
-#endif
-}
-
-void APIServer::accept_new_connections_() {
-  while (true) {
-    struct sockaddr_storage source_addr;
-    socklen_t addr_len = sizeof(source_addr);
-
-    auto sock = this->socket_->accept_loop_monitored((struct sockaddr *) &source_addr, &addr_len);
-    if (!sock)
-      break;
-
-    char peername[socket::SOCKADDR_STR_LEN];
-    sock->getpeername_to(peername);
-
-    // Check if we're at the connection limit
-    if (this->clients_.size() >= this->max_connections_) {
-      ESP_LOGW(TAG, "Max connections (%d), rejecting %s", this->max_connections_, peername);
-      // Immediately close - socket destructor will handle cleanup
-      sock.reset();
       continue;
     }
 
-    ESP_LOGD(TAG, "Accept %s", peername);
+    // Rare case: handle disconnection
+#ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
+    this->unregister_active_action_calls_for_connection(client.get());
+#endif
+    ESP_LOGV(TAG, "Remove connection %s", client->get_name());
 
-    auto *conn = new APIConnection(std::move(sock), this);
-    this->clients_.emplace_back(conn);
-    conn->start();
+#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
+    // Save client info before closing socket and removal for the trigger
+    char peername_buf[socket::SOCKADDR_STR_LEN];
+    std::string client_name(client->get_name());
+    std::string client_peername(client->get_peername_to(peername_buf));
+#endif
 
-    // First client connected - clear warning and update timestamp
-    if (this->clients_.size() == 1 && this->reboot_timeout_ != 0) {
-      this->status_clear_warning();
+    // Close socket now (was deferred from on_fatal_error to allow getpeername)
+    client->helper_->close();
+
+    // Swap with the last element and pop (avoids expensive vector shifts)
+    if (client_index < this->clients_.size() - 1) {
+      std::swap(this->clients_[client_index], this->clients_.back());
+    }
+    this->clients_.pop_back();
+
+    // Last client disconnected - set warning and start tracking for reboot timeout
+    if (this->clients_.empty() && this->reboot_timeout_ != 0) {
+      this->status_set_warning();
       this->last_connected_ = App.get_loop_component_start_time();
     }
+
+#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
+    // Fire trigger after client is removed so api.connected reflects the true state
+    this->client_disconnected_trigger_.trigger(client_name, client_peername);
+#endif
+    // Don't increment client_index since we need to process the swapped element
   }
 }
 

esphome/components/api/api_server.h

@@ -234,11 +234,6 @@ class APIServer : public Component,
 #endif
 
  protected:
-  // Accept incoming socket connections. Only called when socket has pending connections.
-  void __attribute__((noinline)) accept_new_connections_();
-  // Remove a disconnected client by index. Swaps with last element and pops.
-  void __attribute__((noinline)) remove_client_(size_t client_index);
-
 #ifdef USE_API_NOISE
   bool update_noise_psk_(const SavedNoisePsk &new_psk, const LogString *save_log_msg, const LogString *fail_log_msg,
                          const psk_t &active_psk, bool make_active);

esphome/components/captive_portal/captive_portal.cpp

@@ -47,8 +47,8 @@ void CaptivePortal::handle_config(AsyncWebServerRequest *request) {
   request->send(stream);
 }
 void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
-  const auto &ssid = request->arg("ssid");
-  const auto &psk = request->arg("psk");
+  std::string ssid = request->arg("ssid").c_str();  // NOLINT(readability-redundant-string-cstr)
+  std::string psk = request->arg("psk").c_str();    // NOLINT(readability-redundant-string-cstr)
   ESP_LOGI(TAG,
            "Requested WiFi Settings Change:\n"
            "  SSID='%s'\n"
@@ -56,10 +56,10 @@ void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
            ssid.c_str(), psk.c_str());
 #ifdef USE_ESP8266
   // ESP8266 is single-threaded, call directly
-  wifi::global_wifi_component->save_wifi_sta(ssid.c_str(), psk.c_str());
+  wifi::global_wifi_component->save_wifi_sta(ssid, psk);
 #else
   // Defer save to main loop thread to avoid NVS operations from HTTP thread
-  this->defer([ssid, psk]() { wifi::global_wifi_component->save_wifi_sta(ssid.c_str(), psk.c_str()); });
+  this->defer([ssid, psk]() { wifi::global_wifi_component->save_wifi_sta(ssid, psk); });
 #endif
   request->redirect(ESPHOME_F("/?save"));
 }

esphome/components/ethernet/ethernet_component.h

@@ -110,8 +110,6 @@ class EthernetComponent : public Component {
   const char *get_use_address() const;
   void set_use_address(const char *use_address);
   void get_eth_mac_address_raw(uint8_t *mac);
-  // Remove before 2026.9.0
-  ESPDEPRECATED("Use get_eth_mac_address_pretty_into_buffer() instead. Removed in 2026.9.0", "2026.3.0")
   std::string get_eth_mac_address_pretty();
   const char *get_eth_mac_address_pretty_into_buffer(std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf);
   eth_duplex_t get_duplex_mode();

esphome/components/mipi_spi/models/waveshare.py

@@ -1,17 +1,4 @@
-from esphome.components.mipi import (
-    ETMOD,
-    FRMCTR2,
-    GMCTRN1,
-    GMCTRP1,
-    IFCTR,
-    MODE_RGB,
-    PWCTR1,
-    PWCTR3,
-    PWCTR4,
-    PWCTR5,
-    PWSET,
-    DriverChip,
-)
+from esphome.components.mipi import DriverChip
 import esphome.config_validation as cv
 
 from .amoled import CO5300
@@ -142,16 +129,6 @@ DriverChip(
         ),
     ),
 )
-ST7789P = DriverChip(
-    "ST7789P",
-    # Max supported dimensions
-    width=240,
-    height=320,
-    # SPI: RGB layout
-    color_order=MODE_RGB,
-    invert_colors=True,
-    draw_rounding=1,
-)
 
 ILI9488_A.extend(
     "PICO-RESTOUCH-LCD-3.5",
@@ -185,61 +162,3 @@ AXS15231.extend(
     cs_pin=9,
     reset_pin=21,
 )
-
-# Waveshare 1.83-v2
-#
-# Do not use on 1.83-v1: Vendor warning on different chip!
-ST7789P.extend(
-    "WAVESHARE-1.83-V2",
-    # Panel size smaller than ST7789 max allowed
-    width=240,
-    height=284,
-    # Vendor specific init derived from vendor sample code
-    # "LCD_1.83_Code_Rev2/ESP32/LCD_1in83/LCD_Driver.cpp"
-    # Compatible MIT license, see esphome/LICENSE file.
-    initsequence=(
-        (FRMCTR2, 0x0C, 0x0C, 0x00, 0x33, 0x33),
-        (ETMOD, 0x35),
-        (0xBB, 0x19),
-        (PWCTR1, 0x2C),
-        (PWCTR3, 0x01),
-        (PWCTR4, 0x12),
-        (PWCTR5, 0x20),
-        (IFCTR, 0x0F),
-        (PWSET, 0xA4, 0xA1),
-        (
-            GMCTRP1,
-            0xD0,
-            0x04,
-            0x0D,
-            0x11,
-            0x13,
-            0x2B,
-            0x3F,
-            0x54,
-            0x4C,
-            0x18,
-            0x0D,
-            0x0B,
-            0x1F,
-            0x23,
-        ),
-        (
-            GMCTRN1,
-            0xD0,
-            0x04,
-            0x0C,
-            0x11,
-            0x13,
-            0x2C,
-            0x3F,
-            0x44,
-            0x51,
-            0x2F,
-            0x1F,
-            0x1F,
-            0x20,
-            0x23,
-        ),
-    ),
-)

esphome/components/pulse_meter/pulse_meter_sensor.cpp

@@ -38,7 +38,8 @@ void PulseMeterSensor::setup() {
 }
 
 void PulseMeterSensor::loop() {
-  State state;
+  // Reset the count in get before we pass it back to the ISR as set
+  this->get_->count_ = 0;
 
   {
     // Lock the interrupt so the interrupt code doesn't interfere with itself
@@ -57,35 +58,31 @@ void PulseMeterSensor::loop() {
     }
     this->last_pin_val_ = current;
 
-    // Get the latest state from the ISR and reset the count in the ISR
-    state.last_detected_edge_us_ = this->state_.last_detected_edge_us_;
-    state.last_rising_edge_us_ = this->state_.last_rising_edge_us_;
-    state.count_ = this->state_.count_;
-    this->state_.count_ = 0;
+    // Swap out set and get to get the latest state from the ISR
+    std::swap(this->set_, this->get_);
   }
 
   const uint32_t now = micros();
 
   // If an edge was peeked, repay the debt
-  if (this->peeked_edge_ && state.count_ > 0) {
+  if (this->peeked_edge_ && this->get_->count_ > 0) {
     this->peeked_edge_ = false;
-    state.count_--;
+    this->get_->count_--;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
-  // If there is an unprocessed edge, and filter_us_ has passed since, count this edge early.
-  // Wait for the debt to be repaid before counting another unprocessed edge early.
-  if (!this->peeked_edge_ && state.last_rising_edge_us_ != state.last_detected_edge_us_ &&
-      now - state.last_rising_edge_us_ >= this->filter_us_) {
+  // If there is an unprocessed edge, and filter_us_ has passed since, count this edge early
+  if (this->get_->last_rising_edge_us_ != this->get_->last_detected_edge_us_ &&
+      now - this->get_->last_rising_edge_us_ >= this->filter_us_) {
     this->peeked_edge_ = true;
-    state.last_detected_edge_us_ = state.last_rising_edge_us_;
-    state.count_++;
+    this->get_->last_detected_edge_us_ = this->get_->last_rising_edge_us_;
+    this->get_->count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
   // Check if we detected a pulse this loop
-  if (state.count_ > 0) {
+  if (this->get_->count_ > 0) {
     // Keep a running total of pulses if a total sensor is configured
     if (this->total_sensor_ != nullptr) {
-      this->total_pulses_ += state.count_;
+      this->total_pulses_ += this->get_->count_;
       const uint32_t total = this->total_pulses_;
       this->total_sensor_->publish_state(total);
     }
@@ -97,15 +94,15 @@ void PulseMeterSensor::loop() {
         this->meter_state_ = MeterState::RUNNING;
       } break;
       case MeterState::RUNNING: {
-        uint32_t delta_us = state.last_detected_edge_us_ - this->last_processed_edge_us_;
-        float pulse_width_us = delta_us / float(state.count_);
-        ESP_LOGV(TAG, "New pulse, delta: %" PRIu32 " µs, count: %" PRIu32 ", width: %.5f µs", delta_us, state.count_,
-                 pulse_width_us);
+        uint32_t delta_us = this->get_->last_detected_edge_us_ - this->last_processed_edge_us_;
+        float pulse_width_us = delta_us / float(this->get_->count_);
+        ESP_LOGV(TAG, "New pulse, delta: %" PRIu32 " µs, count: %" PRIu32 ", width: %.5f µs", delta_us,
+                 this->get_->count_, pulse_width_us);
         this->publish_state((60.0f * 1000000.0f) / pulse_width_us);
       } break;
     }
 
-    this->last_processed_edge_us_ = state.last_detected_edge_us_;
+    this->last_processed_edge_us_ = this->get_->last_detected_edge_us_;
   }
   // No detected edges this loop
   else {
@@ -144,14 +141,14 @@ void IRAM_ATTR PulseMeterSensor::edge_intr(PulseMeterSensor *sensor) {
   // This is an interrupt handler - we can't call any virtual method from this method
   // Get the current time before we do anything else so the measurements are consistent
   const uint32_t now = micros();
-  auto &edge_state = sensor->edge_state_;
-  auto &state = sensor->state_;
+  auto &state = sensor->edge_state_;
+  auto &set = *sensor->set_;
 
-  if ((now - edge_state.last_sent_edge_us_) >= sensor->filter_us_) {
-    edge_state.last_sent_edge_us_ = now;
-    state.last_detected_edge_us_ = now;
-    state.last_rising_edge_us_ = now;
-    state.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
+  if ((now - state.last_sent_edge_us_) >= sensor->filter_us_) {
+    state.last_sent_edge_us_ = now;
+    set.last_detected_edge_us_ = now;
+    set.last_rising_edge_us_ = now;
+    set.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
   // This ISR is bound to rising edges, so the pin is high
@@ -163,26 +160,26 @@ void IRAM_ATTR PulseMeterSensor::pulse_intr(PulseMeterSensor *sensor) {
   // Get the current time before we do anything else so the measurements are consistent
   const uint32_t now = micros();
   const bool pin_val = sensor->isr_pin_.digital_read();
-  auto &pulse_state = sensor->pulse_state_;
-  auto &state = sensor->state_;
+  auto &state = sensor->pulse_state_;
+  auto &set = *sensor->set_;
 
   // Filter length has passed since the last interrupt
-  const bool length = now - pulse_state.last_intr_ >= sensor->filter_us_;
+  const bool length = now - state.last_intr_ >= sensor->filter_us_;
 
-  if (length && pulse_state.latched_ && !sensor->last_pin_val_) {  // Long enough low edge
-    pulse_state.latched_ = false;
-  } else if (length && !pulse_state.latched_ && sensor->last_pin_val_) {  // Long enough high edge
-    pulse_state.latched_ = true;
-    state.last_detected_edge_us_ = pulse_state.last_intr_;
-    state.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
+  if (length && state.latched_ && !sensor->last_pin_val_) {  // Long enough low edge
+    state.latched_ = false;
+  } else if (length && !state.latched_ && sensor->last_pin_val_) {  // Long enough high edge
+    state.latched_ = true;
+    set.last_detected_edge_us_ = state.last_intr_;
+    set.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
   // Due to order of operations this includes
   //    length && latched && rising   (just reset from a long low edge)
   //    !latched && (rising || high)  (noise on the line resetting the potential rising edge)
-  state.last_rising_edge_us_ = !pulse_state.latched_ && pin_val ? now : state.last_detected_edge_us_;
+  set.last_rising_edge_us_ = !state.latched_ && pin_val ? now : set.last_detected_edge_us_;
 
-  pulse_state.last_intr_ = now;
+  state.last_intr_ = now;
   sensor->last_pin_val_ = pin_val;
 }
 

esphome/components/pulse_meter/pulse_meter_sensor.h

@@ -46,16 +46,17 @@ class PulseMeterSensor : public sensor::Sensor, public Component {
   uint32_t total_pulses_ = 0;
   uint32_t last_processed_edge_us_ = 0;
 
-  // This struct and variable are used to pass data between the ISR and loop.
-  // The data from state_ is read and then count_ in state_ is reset in each loop.
-  // This must be done while guarded by an InterruptLock. Use this variable to send data
-  // from the ISR to the loop not the other way around (except for resetting count_).
+  // This struct (and the two pointers) are used to pass data between the ISR and loop.
+  // These two pointers are exchanged each loop.
+  // Use these to send data from the ISR to the loop not the other way around (except for resetting the values).
   struct State {
     uint32_t last_detected_edge_us_ = 0;
     uint32_t last_rising_edge_us_ = 0;
     uint32_t count_ = 0;
   };
-  volatile State state_{};
+  State state_[2];
+  volatile State *set_ = state_;
+  volatile State *get_ = state_ + 1;
 
   // Only use the following variables in the ISR or while guarded by an InterruptLock
   ISRInternalGPIOPin isr_pin_;

esphome/components/time/posix_tz.cpp

@@ -0,0 +1,481 @@
+#include "esphome/core/defines.h"
+
+#ifdef USE_TIME_TIMEZONE
+
+#include "posix_tz.h"
+#include <cctype>
+
+namespace esphome::time {
+
+// Global timezone - set once at startup, rarely changes
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) - intentional mutable state
+static ParsedTimezone global_tz_{};
+
+void set_global_tz(const ParsedTimezone &tz) { global_tz_ = tz; }
+
+const ParsedTimezone &get_global_tz() { return global_tz_; }
+
+namespace internal {
+
+// Helper to parse an unsigned integer from string, updating pointer
+static uint32_t parse_uint(const char *&p) {
+  uint32_t value = 0;
+  while (std::isdigit(static_cast<unsigned char>(*p))) {
+    value = value * 10 + (*p - '0');
+    p++;
+  }
+  return value;
+}
+
+bool is_leap_year(int year) { return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0); }
+
+// Get days in year (avoids duplicate is_leap_year calls)
+static inline int days_in_year(int year) { return is_leap_year(year) ? 366 : 365; }
+
+// Convert days since epoch to year, updating days to remainder
+static int __attribute__((noinline)) days_to_year(int64_t &days) {
+  int year = 1970;
+  int diy;
+  while (days >= (diy = days_in_year(year))) {
+    days -= diy;
+    year++;
+  }
+  while (days < 0) {
+    year--;
+    days += days_in_year(year);
+  }
+  return year;
+}
+
+// Extract just the year from a UTC epoch
+static int epoch_to_year(time_t epoch) {
+  int64_t days = epoch / 86400;
+  if (epoch < 0 && epoch % 86400 != 0)
+    days--;
+  return days_to_year(days);
+}
+
+int days_in_month(int year, int month) {
+  switch (month) {
+    case 2:
+      return is_leap_year(year) ? 29 : 28;
+    case 4:
+    case 6:
+    case 9:
+    case 11:
+      return 30;
+    default:
+      return 31;
+  }
+}
+
+// Zeller-like algorithm for day of week (0 = Sunday)
+int __attribute__((noinline)) day_of_week(int year, int month, int day) {
+  // Adjust for January/February
+  if (month < 3) {
+    month += 12;
+    year--;
+  }
+  int k = year % 100;
+  int j = year / 100;
+  int h = (day + (13 * (month + 1)) / 5 + k + k / 4 + j / 4 - 2 * j) % 7;
+  // Convert from Zeller (0=Sat) to standard (0=Sun)
+  return ((h + 6) % 7);
+}
+
+void __attribute__((noinline)) epoch_to_tm_utc(time_t epoch, struct tm *out_tm) {
+  // Days since epoch
+  int64_t days = epoch / 86400;
+  int32_t remaining_secs = epoch % 86400;
+  if (remaining_secs < 0) {
+    days--;
+    remaining_secs += 86400;
+  }
+
+  out_tm->tm_sec = remaining_secs % 60;
+  remaining_secs /= 60;
+  out_tm->tm_min = remaining_secs % 60;
+  out_tm->tm_hour = remaining_secs / 60;
+
+  // Day of week (Jan 1, 1970 was Thursday = 4)
+  out_tm->tm_wday = static_cast<int>((days + 4) % 7);
+  if (out_tm->tm_wday < 0)
+    out_tm->tm_wday += 7;
+
+  // Calculate year (updates days to day-of-year)
+  int year = days_to_year(days);
+  out_tm->tm_year = year - 1900;
+  out_tm->tm_yday = static_cast<int>(days);
+
+  // Calculate month and day
+  int month = 1;
+  int dim;
+  while (days >= (dim = days_in_month(year, month))) {
+    days -= dim;
+    month++;
+  }
+
+  out_tm->tm_mon = month - 1;
+  out_tm->tm_mday = static_cast<int>(days) + 1;
+  out_tm->tm_isdst = 0;
+}
+
+bool skip_tz_name(const char *&p) {
+  if (*p == '<') {
+    // Angle-bracket quoted name: <+07>, <-03>, <AEST>
+    p++;  // skip '<'
+    while (*p && *p != '>') {
+      p++;
+    }
+    if (*p == '>') {
+      p++;  // skip '>'
+      return true;
+    }
+    return false;  // Unterminated
+  }
+
+  // Standard name: 3+ letters
+  const char *start = p;
+  while (*p && std::isalpha(static_cast<unsigned char>(*p))) {
+    p++;
+  }
+  return (p - start) >= 3;
+}
+
+int32_t __attribute__((noinline)) parse_offset(const char *&p) {
+  int sign = 1;
+  if (*p == '-') {
+    sign = -1;
+    p++;
+  } else if (*p == '+') {
+    p++;
+  }
+
+  int hours = parse_uint(p);
+  int minutes = 0;
+  int seconds = 0;
+
+  if (*p == ':') {
+    p++;
+    minutes = parse_uint(p);
+    if (*p == ':') {
+      p++;
+      seconds = parse_uint(p);
+    }
+  }
+
+  return sign * (hours * 3600 + minutes * 60 + seconds);
+}
+
+// Helper to parse the optional /time suffix (reuses parse_offset logic)
+static void parse_transition_time(const char *&p, DSTRule &rule) {
+  rule.time_seconds = 2 * 3600;  // Default 02:00
+  if (*p == '/') {
+    p++;
+    rule.time_seconds = parse_offset(p);
+  }
+}
+
+void __attribute__((noinline)) julian_to_month_day(int julian_day, int &out_month, int &out_day) {
+  // J format: day 1-365, Feb 29 is NOT counted even in leap years
+  // So day 60 is always March 1
+  // Iterate forward through months (no array needed)
+  int remaining = julian_day;
+  out_month = 1;
+  while (out_month <= 12) {
+    // Days in month for non-leap year (J format ignores leap years)
+    int dim = days_in_month(2001, out_month);  // 2001 is non-leap year
+    if (remaining <= dim) {
+      out_day = remaining;
+      return;
+    }
+    remaining -= dim;
+    out_month++;
+  }
+  out_day = remaining;
+}
+
+void __attribute__((noinline)) day_of_year_to_month_day(int day_of_year, int year, int &out_month, int &out_day) {
+  // Plain format: day 0-365, Feb 29 IS counted in leap years
+  // Day 0 = Jan 1
+  int remaining = day_of_year;
+  out_month = 1;
+
+  while (out_month <= 12) {
+    int days_this_month = days_in_month(year, out_month);
+    if (remaining < days_this_month) {
+      out_day = remaining + 1;
+      return;
+    }
+    remaining -= days_this_month;
+    out_month++;
+  }
+
+  // Shouldn't reach here with valid input
+  out_month = 12;
+  out_day = 31;
+}
+
+bool parse_dst_rule(const char *&p, DSTRule &rule) {
+  rule = {};  // Zero initialize
+
+  if (*p == 'M' || *p == 'm') {
+    // M format: Mm.w.d (month.week.day)
+    rule.type = DSTRuleType::MONTH_WEEK_DAY;
+    p++;
+
+    rule.month = parse_uint(p);
+    if (rule.month < 1 || rule.month > 12)
+      return false;
+
+    if (*p++ != '.')
+      return false;
+
+    rule.week = parse_uint(p);
+    if (rule.week < 1 || rule.week > 5)
+      return false;
+
+    if (*p++ != '.')
+      return false;
+
+    rule.day_of_week = parse_uint(p);
+    if (rule.day_of_week > 6)
+      return false;
+
+  } else if (*p == 'J' || *p == 'j') {
+    // J format: Jn (Julian day 1-365, not counting Feb 29)
+    rule.type = DSTRuleType::JULIAN_NO_LEAP;
+    p++;
+
+    rule.day = parse_uint(p);
+    if (rule.day < 1 || rule.day > 365)
+      return false;
+
+  } else if (std::isdigit(static_cast<unsigned char>(*p))) {
+    // Plain number format: n (day 0-365, counting Feb 29)
+    rule.type = DSTRuleType::DAY_OF_YEAR;
+
+    rule.day = parse_uint(p);
+    if (rule.day > 365)
+      return false;
+
+  } else {
+    return false;
+  }
+
+  // Parse optional /time suffix
+  parse_transition_time(p, rule);
+
+  return true;
+}
+
+// Calculate days from Jan 1 of given year to given month/day
+static int __attribute__((noinline)) days_from_year_start(int year, int month, int day) {
+  int days = day - 1;
+  for (int m = 1; m < month; m++) {
+    days += days_in_month(year, m);
+  }
+  return days;
+}
+
+// Calculate days from epoch to Jan 1 of given year (for DST transition calculations)
+// Only supports years >= 1970. Timezone is either compiled in from YAML or set by
+// Home Assistant, so pre-1970 dates are not a concern.
+static int64_t __attribute__((noinline)) days_to_year_start(int year) {
+  int64_t days = 0;
+  for (int y = 1970; y < year; y++) {
+    days += days_in_year(y);
+  }
+  return days;
+}
+
+time_t __attribute__((noinline)) calculate_dst_transition(int year, const DSTRule &rule, int32_t base_offset_seconds) {
+  int month, day;
+
+  switch (rule.type) {
+    case DSTRuleType::MONTH_WEEK_DAY: {
+      // Find the nth occurrence of day_of_week in the given month
+      int first_dow = day_of_week(year, rule.month, 1);
+
+      // Days until first occurrence of target day
+      int days_until_first = (rule.day_of_week - first_dow + 7) % 7;
+      int first_occurrence = 1 + days_until_first;
+
+      if (rule.week == 5) {
+        // "Last" occurrence - find the last one in the month
+        int dim = days_in_month(year, rule.month);
+        day = first_occurrence;
+        while (day + 7 <= dim) {
+          day += 7;
+        }
+      } else {
+        // nth occurrence
+        day = first_occurrence + (rule.week - 1) * 7;
+      }
+      month = rule.month;
+      break;
+    }
+
+    case DSTRuleType::JULIAN_NO_LEAP:
+      // J format: day 1-365, Feb 29 not counted
+      julian_to_month_day(rule.day, month, day);
+      break;
+
+    case DSTRuleType::DAY_OF_YEAR:
+      // Plain format: day 0-365, Feb 29 counted
+      day_of_year_to_month_day(rule.day, year, month, day);
+      break;
+
+    case DSTRuleType::NONE:
+      // Should never be called with NONE, but handle it gracefully
+      month = 1;
+      day = 1;
+      break;
+  }
+
+  // Calculate days from epoch to this date
+  int64_t days = days_to_year_start(year) + days_from_year_start(year, month, day);
+
+  // Convert to epoch and add transition time and base offset
+  return days * 86400 + rule.time_seconds + base_offset_seconds;
+}
+
+}  // namespace internal
+
+bool __attribute__((noinline)) is_in_dst(time_t utc_epoch, const ParsedTimezone &tz) {
+  if (!tz.has_dst()) {
+    return false;
+  }
+
+  int year = internal::epoch_to_year(utc_epoch);
+
+  // Calculate DST start and end for this year
+  // DST start transition happens in standard time
+  time_t dst_start = internal::calculate_dst_transition(year, tz.dst_start, tz.std_offset_seconds);
+  // DST end transition happens in daylight time
+  time_t dst_end = internal::calculate_dst_transition(year, tz.dst_end, tz.dst_offset_seconds);
+
+  if (dst_start < dst_end) {
+    // Northern hemisphere: DST is between start and end
+    return (utc_epoch >= dst_start && utc_epoch < dst_end);
+  } else {
+    // Southern hemisphere: DST is outside the range (wraps around year)
+    return (utc_epoch >= dst_start || utc_epoch < dst_end);
+  }
+}
+
+bool parse_posix_tz(const char *tz_string, ParsedTimezone &result) {
+  if (!tz_string || !*tz_string) {
+    return false;
+  }
+
+  const char *p = tz_string;
+
+  // Initialize result (dst_start/dst_end default to type=NONE, so has_dst() returns false)
+  result.std_offset_seconds = 0;
+  result.dst_offset_seconds = 0;
+  result.dst_start = {};
+  result.dst_end = {};
+
+  // Skip standard timezone name
+  if (!internal::skip_tz_name(p)) {
+    return false;
+  }
+
+  // Parse standard offset (required)
+  if (!*p || (!std::isdigit(static_cast<unsigned char>(*p)) && *p != '+' && *p != '-')) {
+    return false;
+  }
+  result.std_offset_seconds = internal::parse_offset(p);
+
+  // Check for DST name
+  if (!*p) {
+    return true;  // No DST
+  }
+
+  // If next char is comma, there's no DST name but there are rules (invalid)
+  if (*p == ',') {
+    return false;
+  }
+
+  // Check if there's something that looks like a DST name start
+  // (letter or angle bracket). If not, treat as trailing garbage and return success.
+  if (!std::isalpha(static_cast<unsigned char>(*p)) && *p != '<') {
+    return true;  // No DST, trailing characters ignored
+  }
+
+  if (!internal::skip_tz_name(p)) {
+    return false;  // Invalid DST name (started but malformed)
+  }
+
+  // Optional DST offset (default is std - 1 hour)
+  if (*p && *p != ',' && (std::isdigit(static_cast<unsigned char>(*p)) || *p == '+' || *p == '-')) {
+    result.dst_offset_seconds = internal::parse_offset(p);
+  } else {
+    result.dst_offset_seconds = result.std_offset_seconds - 3600;
+  }
+
+  // Parse DST rules (required when DST name is present)
+  if (*p != ',') {
+    // DST name without rules - treat as no DST since we can't determine transitions
+    return true;
+  }
+
+  p++;
+  if (!internal::parse_dst_rule(p, result.dst_start)) {
+    return false;
+  }
+
+  // Second rule is required per POSIX
+  if (*p != ',') {
+    return false;
+  }
+  p++;
+  // has_dst() now returns true since dst_start.type was set by parse_dst_rule
+  return internal::parse_dst_rule(p, result.dst_end);
+}
+
+bool epoch_to_local_tm(time_t utc_epoch, const ParsedTimezone &tz, struct tm *out_tm) {
+  if (!out_tm) {
+    return false;
+  }
+
+  // Determine DST status once (avoids duplicate is_in_dst calculation)
+  bool in_dst = is_in_dst(utc_epoch, tz);
+  int32_t offset = in_dst ? tz.dst_offset_seconds : tz.std_offset_seconds;
+
+  // Apply offset (POSIX offset is positive west, so subtract to get local)
+  time_t local_epoch = utc_epoch - offset;
+
+  internal::epoch_to_tm_utc(local_epoch, out_tm);
+  out_tm->tm_isdst = in_dst ? 1 : 0;
+
+  return true;
+}
+
+}  // namespace esphome::time
+
+#ifndef USE_HOST
+// Override libc's localtime functions to use our timezone on embedded platforms.
+// This allows user lambdas calling ::localtime() to get correct local time
+// without needing the TZ environment variable (which pulls in scanf bloat).
+// On host, we use the normal TZ mechanism since there's no memory constraint.
+
+// Thread-safe version
+extern "C" struct tm *localtime_r(const time_t *timer, struct tm *result) {
+  if (timer == nullptr || result == nullptr) {
+    return nullptr;
+  }
+  esphome::time::epoch_to_local_tm(*timer, esphome::time::get_global_tz(), result);
+  return result;
+}
+
+// Non-thread-safe version (uses static buffer, standard libc behavior)
+extern "C" struct tm *localtime(const time_t *timer) {
+  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+  static struct tm localtime_buf;
+  return localtime_r(timer, &localtime_buf);
+}
+#endif  // !USE_HOST
+
+#endif  // USE_TIME_TIMEZONE

esphome/components/time/posix_tz.h

@@ -0,0 +1,132 @@
+#pragma once
+
+#ifdef USE_TIME_TIMEZONE
+
+#include <cstdint>
+#include <ctime>
+
+namespace esphome::time {
+
+/// Type of DST transition rule
+enum class DSTRuleType : uint8_t {
+  NONE = 0,        ///< No DST rule (used to indicate no DST)
+  MONTH_WEEK_DAY,  ///< M format: Mm.w.d (e.g., M3.2.0 = 2nd Sunday of March)
+  JULIAN_NO_LEAP,  ///< J format: Jn (day 1-365, Feb 29 not counted)
+  DAY_OF_YEAR,     ///< Plain number: n (day 0-365, Feb 29 counted in leap years)
+};
+
+/// Rule for DST transition (packed for 32-bit: 12 bytes)
+struct DSTRule {
+  int32_t time_seconds;  ///< Seconds after midnight (default 7200 = 2:00 AM)
+  uint16_t day;          ///< Day of year (for JULIAN_NO_LEAP and DAY_OF_YEAR)
+  DSTRuleType type;      ///< Type of rule
+  uint8_t month;         ///< Month 1-12 (for MONTH_WEEK_DAY)
+  uint8_t week;          ///< Week 1-5, 5 = last (for MONTH_WEEK_DAY)
+  uint8_t day_of_week;   ///< Day 0-6, 0 = Sunday (for MONTH_WEEK_DAY)
+};
+
+/// Parsed POSIX timezone information (packed for 32-bit: 32 bytes)
+struct ParsedTimezone {
+  int32_t std_offset_seconds;  ///< Standard time offset from UTC in seconds (positive = west)
+  int32_t dst_offset_seconds;  ///< DST offset from UTC in seconds
+  DSTRule dst_start;           ///< When DST starts
+  DSTRule dst_end;             ///< When DST ends
+
+  /// Check if this timezone has DST rules
+  bool has_dst() const { return this->dst_start.type != DSTRuleType::NONE; }
+};
+
+/// Parse a POSIX TZ string into a ParsedTimezone struct.
+/// Supports formats like:
+///   - "EST5" (simple offset, no DST)
+///   - "EST5EDT,M3.2.0,M11.1.0" (with DST, M-format rules)
+///   - "CST6CDT,M3.2.0/2,M11.1.0/2" (with transition times)
+///   - "<+07>-7" (angle-bracket notation for special names)
+///   - "IST-5:30" (half-hour offsets)
+///   - "EST5EDT,J60,J300" (J-format: Julian day without leap day)
+///   - "EST5EDT,60,300" (plain day number: day of year with leap day)
+/// @param tz_string The POSIX TZ string to parse
+/// @param result Output: the parsed timezone data
+/// @return true if parsing succeeded, false on error
+bool parse_posix_tz(const char *tz_string, ParsedTimezone &result);
+
+/// Convert a UTC epoch to local time using the parsed timezone.
+/// This replaces libc's localtime() to avoid scanf dependency.
+/// @param utc_epoch Unix timestamp in UTC
+/// @param tz The parsed timezone
+/// @param[out] out_tm Output tm struct with local time
+/// @return true on success
+bool epoch_to_local_tm(time_t utc_epoch, const ParsedTimezone &tz, struct tm *out_tm);
+
+/// Set the global timezone used by epoch_to_local_tm() when called without a timezone.
+/// This is called by RealTimeClock::apply_timezone_() to enable ESPTime::from_epoch_local()
+/// to work without libc's localtime().
+void set_global_tz(const ParsedTimezone &tz);
+
+/// Get the global timezone.
+const ParsedTimezone &get_global_tz();
+
+/// Check if a given UTC epoch falls within DST for the parsed timezone.
+/// @param utc_epoch Unix timestamp in UTC
+/// @param tz The parsed timezone
+/// @return true if DST is in effect at the given time
+bool is_in_dst(time_t utc_epoch, const ParsedTimezone &tz);
+
+// Internal helper functions exposed for testing
+
+namespace internal {
+
+/// Skip a timezone name (letters or <...> quoted format)
+/// @param p Pointer to current position, updated on return
+/// @return true if a valid name was found
+bool skip_tz_name(const char *&p);
+
+/// Parse an offset in format [-]hh[:mm[:ss]]
+/// @param p Pointer to current position, updated on return
+/// @return Offset in seconds
+int32_t parse_offset(const char *&p);
+
+/// Parse a DST rule in format Mm.w.d[/time], Jn[/time], or n[/time]
+/// @param p Pointer to current position, updated on return
+/// @param rule Output: the parsed rule
+/// @return true if parsing succeeded
+bool parse_dst_rule(const char *&p, DSTRule &rule);
+
+/// Convert Julian day (J format, 1-365 not counting Feb 29) to month/day
+/// @param julian_day Day number 1-365
+/// @param[out] month Output: month 1-12
+/// @param[out] day Output: day of month
+void julian_to_month_day(int julian_day, int &month, int &day);
+
+/// Convert day of year (plain format, 0-365 counting Feb 29) to month/day
+/// @param day_of_year Day number 0-365
+/// @param year The year (for leap year calculation)
+/// @param[out] month Output: month 1-12
+/// @param[out] day Output: day of month
+void day_of_year_to_month_day(int day_of_year, int year, int &month, int &day);
+
+/// Calculate day of week for any date (0 = Sunday)
+/// Uses a simplified algorithm that works for years 1970-2099
+int day_of_week(int year, int month, int day);
+
+/// Get the number of days in a month
+int days_in_month(int year, int month);
+
+/// Check if a year is a leap year
+bool is_leap_year(int year);
+
+/// Convert epoch to year/month/day/hour/min/sec (UTC)
+void epoch_to_tm_utc(time_t epoch, struct tm *out_tm);
+
+/// Calculate the epoch timestamp for a DST transition in a given year.
+/// @param year The year (e.g., 2026)
+/// @param rule The DST rule (month, week, day_of_week, time)
+/// @param base_offset_seconds The timezone offset to apply (std or dst depending on context)
+/// @return Unix epoch timestamp of the transition
+time_t calculate_dst_transition(int year, const DSTRule &rule, int32_t base_offset_seconds);
+
+}  // namespace internal
+
+}  // namespace esphome::time
+
+#endif  // USE_TIME_TIMEZONE

esphome/components/time/real_time_clock.cpp

@@ -14,8 +14,8 @@
 #include <sys/time.h>
 #endif
 #include <cerrno>
-
 #include <cinttypes>
+#include <cstdlib>
 
 namespace esphome::time {
 
@@ -23,9 +23,33 @@ static const char *const TAG = "time";
 
 RealTimeClock::RealTimeClock() = default;
 
+ESPTime __attribute__((noinline)) RealTimeClock::now() {
+#ifdef USE_TIME_TIMEZONE
+  time_t epoch = this->timestamp_now();
+  struct tm local_tm;
+  if (epoch_to_local_tm(epoch, get_global_tz(), &local_tm)) {
+    return ESPTime::from_c_tm(&local_tm, epoch);
+  }
+  // Fallback to UTC if parsing failed
+  return ESPTime::from_epoch_utc(epoch);
+#else
+  return ESPTime::from_epoch_local(this->timestamp_now());
+#endif
+}
+
 void RealTimeClock::dump_config() {
 #ifdef USE_TIME_TIMEZONE
-  ESP_LOGCONFIG(TAG, "Timezone: '%s'", this->timezone_.c_str());
+  const auto &tz = get_global_tz();
+  // POSIX offset is positive west, negate for conventional UTC+X display
+  int std_h = -tz.std_offset_seconds / 3600;
+  int std_m = (std::abs(tz.std_offset_seconds) % 3600) / 60;
+  if (tz.has_dst()) {
+    int dst_h = -tz.dst_offset_seconds / 3600;
+    int dst_m = (std::abs(tz.dst_offset_seconds) % 3600) / 60;
+    ESP_LOGCONFIG(TAG, "Timezone: UTC%+d:%02d (DST UTC%+d:%02d)", std_h, std_m, dst_h, dst_m);
+  } else {
+    ESP_LOGCONFIG(TAG, "Timezone: UTC%+d:%02d", std_h, std_m);
+  }
 #endif
   auto time = this->now();
   ESP_LOGCONFIG(TAG, "Current time: %04d-%02d-%02d %02d:%02d:%02d", time.year, time.month, time.day_of_month, time.hour,
@@ -72,11 +96,6 @@ void RealTimeClock::synchronize_epoch_(uint32_t epoch) {
     ret = settimeofday(&timev, nullptr);
   }
 
-#ifdef USE_TIME_TIMEZONE
-  // Move timezone back to local timezone.
-  this->apply_timezone_();
-#endif
-
   if (ret != 0) {
     ESP_LOGW(TAG, "setimeofday() failed with code %d", ret);
   }
@@ -89,9 +108,29 @@ void RealTimeClock::synchronize_epoch_(uint32_t epoch) {
 }
 
 #ifdef USE_TIME_TIMEZONE
-void RealTimeClock::apply_timezone_() {
-  setenv("TZ", this->timezone_.c_str(), 1);
+void RealTimeClock::apply_timezone_(const char *tz) {
+  ParsedTimezone parsed{};
+
+  // Handle null or empty input - use UTC
+  if (tz == nullptr || *tz == '\0') {
+    set_global_tz(parsed);
+    return;
+  }
+
+#ifdef USE_HOST
+  // On host platform, also set TZ environment variable for libc compatibility
+  setenv("TZ", tz, 1);
   tzset();
+#endif
+
+  // Parse the POSIX TZ string using our custom parser
+  if (!parse_posix_tz(tz, parsed)) {
+    ESP_LOGW(TAG, "Failed to parse timezone: %s", tz);
+    // parsed stays as default (UTC) on failure
+  }
+
+  // Set global timezone for all time conversions
+  set_global_tz(parsed);
 }
 #endif
 

esphome/components/time/real_time_clock.h

@@ -6,6 +6,9 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/time.h"
+#ifdef USE_TIME_TIMEZONE
+#include "posix_tz.h"
+#endif
 
 namespace esphome::time {
 
@@ -20,26 +23,31 @@ class RealTimeClock : public PollingComponent {
   explicit RealTimeClock();
 
 #ifdef USE_TIME_TIMEZONE
-  /// Set the time zone.
-  void set_timezone(const std::string &tz) {
-    this->timezone_ = tz;
-    this->apply_timezone_();
-  }
+  /// Set the time zone from a POSIX TZ string.
+  void set_timezone(const char *tz) { this->apply_timezone_(tz); }
 
-  /// Set the time zone from raw buffer, only if it differs from the current one.
+  /// Set the time zone from a character buffer with known length.
+  /// The buffer does not need to be null-terminated.
   void set_timezone(const char *tz, size_t len) {
-    if (this->timezone_.length() != len || memcmp(this->timezone_.c_str(), tz, len) != 0) {
-      this->timezone_.assign(tz, len);
-      this->apply_timezone_();
+    if (tz == nullptr) {
+      this->apply_timezone_(nullptr);
+      return;
     }
+    // Stack buffer - TZ strings from tzdata are typically short (< 50 chars)
+    char buf[128];
+    if (len >= sizeof(buf))
+      len = sizeof(buf) - 1;
+    memcpy(buf, tz, len);
+    buf[len] = '\0';
+    this->apply_timezone_(buf);
   }
 
-  /// Get the time zone currently in use.
-  std::string get_timezone() { return this->timezone_; }
+  /// Set the time zone from a std::string.
+  void set_timezone(const std::string &tz) { this->apply_timezone_(tz.c_str()); }
 #endif
 
   /// Get the time in the currently defined timezone.
-  ESPTime now() { return ESPTime::from_epoch_local(this->timestamp_now()); }
+  ESPTime now();
 
   /// Get the time without any time zone or DST corrections.
   ESPTime utcnow() { return ESPTime::from_epoch_utc(this->timestamp_now()); }
@@ -58,8 +66,7 @@ class RealTimeClock : public PollingComponent {
   void synchronize_epoch_(uint32_t epoch);
 
 #ifdef USE_TIME_TIMEZONE
-  std::string timezone_{};
-  void apply_timezone_();
+  void apply_timezone_(const char *tz);
 #endif
 
   LazyCallbackManager<void()> time_sync_callback_;

esphome/components/uart/uart_component_esp_idf.cpp

@@ -90,6 +90,7 @@ void IDFUARTComponent::setup() {
     return;
   }
   this->uart_num_ = static_cast<uart_port_t>(next_uart_num++);
+  this->lock_ = xSemaphoreCreateMutex();
 
 #if (SOC_UART_LP_NUM >= 1)
   size_t fifo_len = ((this->uart_num_ < SOC_UART_HP_NUM) ? SOC_UART_FIFO_LEN : SOC_LP_UART_FIFO_LEN);
@@ -101,7 +102,11 @@ void IDFUARTComponent::setup() {
     this->rx_buffer_size_ = fifo_len * 2;
   }
 
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
+
   this->load_settings(false);
+
+  xSemaphoreGive(this->lock_);
 }
 
 void IDFUARTComponent::load_settings(bool dump_config) {
@@ -121,20 +126,13 @@ void IDFUARTComponent::load_settings(bool dump_config) {
       return;
     }
   }
-#ifdef USE_UART_WAKE_LOOP_ON_RX
-  constexpr int event_queue_size = 20;
-  QueueHandle_t *event_queue_ptr = &this->uart_event_queue_;
-#else
-  constexpr int event_queue_size = 0;
-  QueueHandle_t *event_queue_ptr = nullptr;
-#endif
   err = uart_driver_install(this->uart_num_,        // UART number
                             this->rx_buffer_size_,  // RX ring buffer size
-                            0,  // TX ring buffer size. If zero, driver will not use a TX buffer and TX function will
-                                // block task until all data has been sent out
-                            event_queue_size,  // event queue size/depth
-                            event_queue_ptr,   // event queue
-                            0                  // Flags used to allocate the interrupt
+                            0,   // TX ring buffer size. If zero, driver will not use a TX buffer and TX function will
+                                 // block task until all data has been sent out
+                            20,  // event queue size/depth
+                            &this->uart_event_queue_,  // event queue
+                            0                          // Flags used to allocate the interrupt
   );
   if (err != ESP_OK) {
     ESP_LOGW(TAG, "uart_driver_install failed: %s", esp_err_to_name(err));
@@ -284,7 +282,9 @@ void IDFUARTComponent::set_rx_timeout(size_t rx_timeout) {
 }
 
 void IDFUARTComponent::write_array(const uint8_t *data, size_t len) {
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   int32_t write_len = uart_write_bytes(this->uart_num_, data, len);
+  xSemaphoreGive(this->lock_);
   if (write_len != (int32_t) len) {
     ESP_LOGW(TAG, "uart_write_bytes failed: %d != %zu", write_len, len);
     this->mark_failed();
@@ -299,6 +299,7 @@ void IDFUARTComponent::write_array(const uint8_t *data, size_t len) {
 bool IDFUARTComponent::peek_byte(uint8_t *data) {
   if (!this->check_read_timeout_())
     return false;
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   if (this->has_peek_) {
     *data = this->peek_byte_;
   } else {
@@ -310,6 +311,7 @@ bool IDFUARTComponent::peek_byte(uint8_t *data) {
       this->peek_byte_ = *data;
     }
   }
+  xSemaphoreGive(this->lock_);
   return true;
 }
 
@@ -318,6 +320,7 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
   int32_t read_len = 0;
   if (!this->check_read_timeout_(len))
     return false;
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   if (this->has_peek_) {
     length_to_read--;
     *data = this->peek_byte_;
@@ -326,6 +329,7 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
   }
   if (length_to_read > 0)
     read_len = uart_read_bytes(this->uart_num_, data, length_to_read, 20 / portTICK_PERIOD_MS);
+  xSemaphoreGive(this->lock_);
 #ifdef USE_UART_DEBUGGER
   for (size_t i = 0; i < len; i++) {
     this->debug_callback_.call(UART_DIRECTION_RX, data[i]);
@@ -338,7 +342,9 @@ size_t IDFUARTComponent::available() {
   size_t available = 0;
   esp_err_t err;
 
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   err = uart_get_buffered_data_len(this->uart_num_, &available);
+  xSemaphoreGive(this->lock_);
 
   if (err != ESP_OK) {
     ESP_LOGW(TAG, "uart_get_buffered_data_len failed: %s", esp_err_to_name(err));
@@ -352,7 +358,9 @@ size_t IDFUARTComponent::available() {
 
 void IDFUARTComponent::flush() {
   ESP_LOGVV(TAG, "    Flushing");
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   uart_wait_tx_done(this->uart_num_, portMAX_DELAY);
+  xSemaphoreGive(this->lock_);
 }
 
 void IDFUARTComponent::check_logger_conflict() {}
@@ -376,13 +384,6 @@ void IDFUARTComponent::start_rx_event_task_() {
   ESP_LOGV(TAG, "RX event task started");
 }
 
-// FreeRTOS task that relays UART ISR events to the main loop.
-// This task exists because wake_loop_threadsafe() is not ISR-safe (it uses a
-// UDP loopback socket), so we need a task as an ISR-to-main-loop trampoline.
-// IMPORTANT: This task must NOT call any UART wrapper methods (read_array,
-// write_array, peek_byte, etc.) or touch has_peek_/peek_byte_ — all reading
-// is done by the main loop. This task only reads from the event queue and
-// calls App.wake_loop_threadsafe().
 void IDFUARTComponent::rx_event_task_func(void *param) {
   auto *self = static_cast<IDFUARTComponent *>(param);
   uart_event_t event;
@@ -404,14 +405,8 @@ void IDFUARTComponent::rx_event_task_func(void *param) {
 
         case UART_FIFO_OVF:
         case UART_BUFFER_FULL:
-          // Don't call uart_flush_input() here — this task does not own the read side.
-          // ESP-IDF examples flush on overflow because the same task handles both events
-          // and reads, so flush and read are serialized. Here, reads happen on the main
-          // loop, so flushing from this task races with read_array() and can destroy data
-          // mid-read. The driver self-heals without an explicit flush: uart_read_bytes()
-          // calls uart_check_buf_full() after each chunk, which moves stashed FIFO bytes
-          // into the ring buffer and re-enables RX interrupts once space is freed.
-          ESP_LOGW(TAG, "FIFO overflow or ring buffer full");
+          ESP_LOGW(TAG, "FIFO overflow or ring buffer full - clearing");
+          uart_flush_input(self->uart_num_);
 #if defined(USE_SOCKET_SELECT_SUPPORT) && defined(USE_WAKE_LOOP_THREADSAFE)
           App.wake_loop_threadsafe();
 #endif

esphome/components/uart/uart_component_esp_idf.h

@@ -8,13 +8,6 @@
 
 namespace esphome::uart {
 
-/// ESP-IDF UART driver wrapper.
-///
-/// Thread safety: All public methods must only be called from the main loop.
-/// The ESP-IDF UART driver API does not guarantee thread safety, and ESPHome's
-/// peek byte state (has_peek_/peek_byte_) is not synchronized. The rx_event_task
-/// (when enabled) must not call any of these methods — it communicates with the
-/// main loop exclusively via App.wake_loop_threadsafe().
 class IDFUARTComponent : public UARTComponent, public Component {
  public:
   void setup() override;
@@ -33,9 +26,7 @@ class IDFUARTComponent : public UARTComponent, public Component {
   void flush() override;
 
   uint8_t get_hw_serial_number() { return this->uart_num_; }
-#ifdef USE_UART_WAKE_LOOP_ON_RX
   QueueHandle_t *get_uart_event_queue() { return &this->uart_event_queue_; }
-#endif
 
   /**
    * Load the UART with the current settings.
@@ -55,20 +46,18 @@ class IDFUARTComponent : public UARTComponent, public Component {
  protected:
   void check_logger_conflict() override;
   uart_port_t uart_num_;
+  QueueHandle_t uart_event_queue_;
   uart_config_t get_config_();
+  SemaphoreHandle_t lock_;
 
   bool has_peek_{false};
   uint8_t peek_byte_;
 
 #ifdef USE_UART_WAKE_LOOP_ON_RX
-  // RX notification support — runs on a separate FreeRTOS task.
-  // IMPORTANT: rx_event_task_func must NOT call any UART wrapper methods (read_array,
-  // write_array, etc.) or touch has_peek_/peek_byte_. It must only read from the
-  // event queue and call App.wake_loop_threadsafe().
+  // RX notification support
   void start_rx_event_task_();
   static void rx_event_task_func(void *param);
 
-  QueueHandle_t uart_event_queue_;
   TaskHandle_t rx_event_task_handle_{nullptr};
 #endif  // USE_UART_WAKE_LOOP_ON_RX
 };

esphome/components/web_server/web_server.cpp

@@ -557,9 +557,7 @@ static void set_json_id(JsonObject &root, EntityBase *obj, const char *prefix, J
       root[ESPHOME_F("device")] = device_name;
     }
 #endif
-#ifdef USE_ENTITY_ICON
     root[ESPHOME_F("icon")] = obj->get_icon_ref();
-#endif
     root[ESPHOME_F("entity_category")] = obj->get_entity_category();
     bool is_disabled = obj->is_disabled_by_default();
     if (is_disabled)
@@ -585,7 +583,8 @@ static void set_json_icon_state_value(JsonObject &root, EntityBase *obj, const c
 
 // Helper to get request detail parameter
 static JsonDetail get_request_detail(AsyncWebServerRequest *request) {
-  return request->arg(ESPHOME_F("detail")) == "all" ? DETAIL_ALL : DETAIL_STATE;
+  auto *param = request->getParam(ESPHOME_F("detail"));
+  return (param && param->value() == "all") ? DETAIL_ALL : DETAIL_STATE;
 }
 
 #ifdef USE_SENSOR
@@ -862,10 +861,10 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
       }
       auto call = is_on ? obj->turn_on() : obj->turn_off();
 
-      parse_num_param_(request, ESPHOME_F("speed_level"), call, &decltype(call)::set_speed);
+      parse_int_param_(request, ESPHOME_F("speed_level"), call, &decltype(call)::set_speed);
 
-      if (request->hasArg(ESPHOME_F("oscillation"))) {
-        auto speed = request->arg(ESPHOME_F("oscillation"));
+      if (request->hasParam(ESPHOME_F("oscillation"))) {
+        auto speed = request->getParam(ESPHOME_F("oscillation"))->value();
         auto val = parse_on_off(speed.c_str());
         switch (val) {
           case PARSE_ON:
@@ -1041,14 +1040,14 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
     }
 
     auto traits = obj->get_traits();
-    if ((request->hasArg(ESPHOME_F("position")) && !traits.get_supports_position()) ||
-        (request->hasArg(ESPHOME_F("tilt")) && !traits.get_supports_tilt())) {
+    if ((request->hasParam(ESPHOME_F("position")) && !traits.get_supports_position()) ||
+        (request->hasParam(ESPHOME_F("tilt")) && !traits.get_supports_tilt())) {
       request->send(409);
       return;
     }
 
-    parse_num_param_(request, ESPHOME_F("position"), call, &decltype(call)::set_position);
-    parse_num_param_(request, ESPHOME_F("tilt"), call, &decltype(call)::set_tilt);
+    parse_float_param_(request, ESPHOME_F("position"), call, &decltype(call)::set_position);
+    parse_float_param_(request, ESPHOME_F("tilt"), call, &decltype(call)::set_tilt);
 
     DEFER_ACTION(call, call.perform());
     request->send(200);
@@ -1107,7 +1106,7 @@ void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlM
     }
 
     auto call = obj->make_call();
-    parse_num_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_value);
+    parse_float_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_value);
 
     DEFER_ACTION(call, call.perform());
     request->send(200);
@@ -1175,13 +1174,12 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat
 
     auto call = obj->make_call();
 
-    const auto &value = request->arg(ESPHOME_F("value"));
-    // Arduino String has isEmpty() not empty(), use length() for cross-platform compatibility
-    if (value.length() == 0) {  // NOLINT(readability-container-size-empty)
+    if (!request->hasParam(ESPHOME_F("value"))) {
       request->send(409);
       return;
     }
-    call.set_date(value.c_str(), value.length());
+
+    parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_date);
 
     DEFER_ACTION(call, call.perform());
     request->send(200);
@@ -1236,13 +1234,12 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat
 
     auto call = obj->make_call();
 
-    const auto &value = request->arg(ESPHOME_F("value"));
-    // Arduino String has isEmpty() not empty(), use length() for cross-platform compatibility
-    if (value.length() == 0) {  // NOLINT(readability-container-size-empty)
+    if (!request->hasParam(ESPHOME_F("value"))) {
       request->send(409);
       return;
     }
-    call.set_time(value.c_str(), value.length());
+
+    parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_time);
 
     DEFER_ACTION(call, call.perform());
     request->send(200);
@@ -1296,13 +1293,12 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur
 
     auto call = obj->make_call();
 
-    const auto &value = request->arg(ESPHOME_F("value"));
-    // Arduino String has isEmpty() not empty(), use length() for cross-platform compatibility
-    if (value.length() == 0) {  // NOLINT(readability-container-size-empty)
+    if (!request->hasParam(ESPHOME_F("value"))) {
       request->send(409);
       return;
     }
-    call.set_datetime(value.c_str(), value.length());
+
+    parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_datetime);
 
     DEFER_ACTION(call, call.perform());
     request->send(200);
@@ -1481,14 +1477,10 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
     parse_string_param_(request, ESPHOME_F("swing_mode"), call, &decltype(call)::set_swing_mode);
 
     // Parse temperature parameters
-    // static_cast needed to disambiguate overloaded setters (float vs optional<float>)
-    using ClimateCall = decltype(call);
-    parse_num_param_(request, ESPHOME_F("target_temperature_high"), call,
-                     static_cast<ClimateCall &(ClimateCall::*) (float)>(&ClimateCall::set_target_temperature_high));
-    parse_num_param_(request, ESPHOME_F("target_temperature_low"), call,
-                     static_cast<ClimateCall &(ClimateCall::*) (float)>(&ClimateCall::set_target_temperature_low));
-    parse_num_param_(request, ESPHOME_F("target_temperature"), call,
-                     static_cast<ClimateCall &(ClimateCall::*) (float)>(&ClimateCall::set_target_temperature));
+    parse_float_param_(request, ESPHOME_F("target_temperature_high"), call,
+                       &decltype(call)::set_target_temperature_high);
+    parse_float_param_(request, ESPHOME_F("target_temperature_low"), call, &decltype(call)::set_target_temperature_low);
+    parse_float_param_(request, ESPHOME_F("target_temperature"), call, &decltype(call)::set_target_temperature);
 
     DEFER_ACTION(call, call.perform());
     request->send(200);
@@ -1729,12 +1721,12 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa
     }
 
     auto traits = obj->get_traits();
-    if (request->hasArg(ESPHOME_F("position")) && !traits.get_supports_position()) {
+    if (request->hasParam(ESPHOME_F("position")) && !traits.get_supports_position()) {
       request->send(409);
       return;
     }
 
-    parse_num_param_(request, ESPHOME_F("position"), call, &decltype(call)::set_position);
+    parse_float_param_(request, ESPHOME_F("position"), call, &decltype(call)::set_position);
 
     DEFER_ACTION(call, call.perform());
     request->send(200);
@@ -1878,12 +1870,12 @@ void WebServer::handle_water_heater_request(AsyncWebServerRequest *request, cons
     parse_string_param_(request, ESPHOME_F("mode"), base_call, &water_heater::WaterHeaterCall::set_mode);
 
     // Parse temperature parameters
-    parse_num_param_(request, ESPHOME_F("target_temperature"), base_call,
-                     &water_heater::WaterHeaterCall::set_target_temperature);
-    parse_num_param_(request, ESPHOME_F("target_temperature_low"), base_call,
-                     &water_heater::WaterHeaterCall::set_target_temperature_low);
-    parse_num_param_(request, ESPHOME_F("target_temperature_high"), base_call,
-                     &water_heater::WaterHeaterCall::set_target_temperature_high);
+    parse_float_param_(request, ESPHOME_F("target_temperature"), base_call,
+                       &water_heater::WaterHeaterCall::set_target_temperature);
+    parse_float_param_(request, ESPHOME_F("target_temperature_low"), base_call,
+                       &water_heater::WaterHeaterCall::set_target_temperature_low);
+    parse_float_param_(request, ESPHOME_F("target_temperature_high"), base_call,
+                       &water_heater::WaterHeaterCall::set_target_temperature_high);
 
     // Parse away mode parameter
     parse_bool_param_(request, ESPHOME_F("away"), base_call, &water_heater::WaterHeaterCall::set_away);
@@ -1987,16 +1979,16 @@ void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const Ur
     auto call = obj->make_call();
 
     // Parse carrier frequency (optional)
-    {
-      auto value = parse_number<uint32_t>(request->arg(ESPHOME_F("carrier_frequency")).c_str());
+    if (request->hasParam(ESPHOME_F("carrier_frequency"))) {
+      auto value = parse_number<uint32_t>(request->getParam(ESPHOME_F("carrier_frequency"))->value().c_str());
       if (value.has_value()) {
         call.set_carrier_frequency(*value);
       }
     }
 
     // Parse repeat count (optional, defaults to 1)
-    {
-      auto value = parse_number<uint32_t>(request->arg(ESPHOME_F("repeat_count")).c_str());
+    if (request->hasParam(ESPHOME_F("repeat_count"))) {
+      auto value = parse_number<uint32_t>(request->getParam(ESPHOME_F("repeat_count"))->value().c_str());
       if (value.has_value()) {
         call.set_repeat_count(*value);
       }
@@ -2004,12 +1996,18 @@ void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const Ur
 
     // Parse base64url-encoded raw timings (required)
     // Base64url is URL-safe: uses A-Za-z0-9-_ (no special characters needing escaping)
-    const auto &data_arg = request->arg(ESPHOME_F("data"));
+    if (!request->hasParam(ESPHOME_F("data"))) {
+      request->send(400, ESPHOME_F("text/plain"), ESPHOME_F("Missing 'data' parameter"));
+      return;
+    }
 
-    // Validate base64url is not empty (also catches missing parameter since arg() returns empty string)
-    // Arduino String has isEmpty() not empty(), use length() for cross-platform compatibility
-    if (data_arg.length() == 0) {  // NOLINT(readability-container-size-empty)
-      request->send(400, ESPHOME_F("text/plain"), ESPHOME_F("Missing or empty 'data' parameter"));
+    // .c_str() is required for Arduino framework where value() returns Arduino String instead of std::string
+    std::string encoded =
+        request->getParam(ESPHOME_F("data"))->value().c_str();  // NOLINT(readability-redundant-string-cstr)
+
+    // Validate base64url is not empty
+    if (encoded.empty()) {
+      request->send(400, ESPHOME_F("text/plain"), ESPHOME_F("Empty 'data' parameter"));
       return;
     }
 
@@ -2017,7 +2015,7 @@ void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const Ur
     // it outlives the call - set_raw_timings_base64url stores a pointer, so the string
     // must remain valid until perform() completes.
     // ESP8266 also needs this because ESPAsyncWebServer callbacks run in "sys" context.
-    this->defer([call, encoded = std::string(data_arg.c_str(), data_arg.length())]() mutable {
+    this->defer([call, encoded = std::move(encoded)]() mutable {
       call.set_raw_timings_base64url(encoded);
       call.perform();
     });

esphome/components/web_server/web_server.h

@@ -513,9 +513,11 @@ class WebServer : public Controller,
   template<typename T, typename Ret>
   void parse_light_param_(AsyncWebServerRequest *request, ParamNameType param_name, T &call, Ret (T::*setter)(float),
                           float scale = 1.0f) {
-    auto value = parse_number<float>(request->arg(param_name).c_str());
-    if (value.has_value()) {
-      (call.*setter)(*value / scale);
+    if (request->hasParam(param_name)) {
+      auto value = parse_number<float>(request->getParam(param_name)->value().c_str());
+      if (value.has_value()) {
+        (call.*setter)(*value / scale);
+      }
     }
   }
 
@@ -523,19 +525,34 @@ class WebServer : public Controller,
   template<typename T, typename Ret>
   void parse_light_param_uint_(AsyncWebServerRequest *request, ParamNameType param_name, T &call,
                                Ret (T::*setter)(uint32_t), uint32_t scale = 1) {
-    auto value = parse_number<uint32_t>(request->arg(param_name).c_str());
-    if (value.has_value()) {
-      (call.*setter)(*value * scale);
+    if (request->hasParam(param_name)) {
+      auto value = parse_number<uint32_t>(request->getParam(param_name)->value().c_str());
+      if (value.has_value()) {
+        (call.*setter)(*value * scale);
+      }
     }
   }
 #endif
 
-  // Generic helper to parse and apply a numeric parameter
-  template<typename NumT, typename T, typename Ret>
-  void parse_num_param_(AsyncWebServerRequest *request, ParamNameType param_name, T &call, Ret (T::*setter)(NumT)) {
-    auto value = parse_number<NumT>(request->arg(param_name).c_str());
-    if (value.has_value()) {
-      (call.*setter)(*value);
+  // Generic helper to parse and apply a float parameter
+  template<typename T, typename Ret>
+  void parse_float_param_(AsyncWebServerRequest *request, ParamNameType param_name, T &call, Ret (T::*setter)(float)) {
+    if (request->hasParam(param_name)) {
+      auto value = parse_number<float>(request->getParam(param_name)->value().c_str());
+      if (value.has_value()) {
+        (call.*setter)(*value);
+      }
+    }
+  }
+
+  // Generic helper to parse and apply an int parameter
+  template<typename T, typename Ret>
+  void parse_int_param_(AsyncWebServerRequest *request, ParamNameType param_name, T &call, Ret (T::*setter)(int)) {
+    if (request->hasParam(param_name)) {
+      auto value = parse_number<int>(request->getParam(param_name)->value().c_str());
+      if (value.has_value()) {
+        (call.*setter)(*value);
+      }
     }
   }
 
@@ -543,9 +560,10 @@ class WebServer : public Controller,
   template<typename T, typename Ret>
   void parse_string_param_(AsyncWebServerRequest *request, ParamNameType param_name, T &call,
                            Ret (T::*setter)(const std::string &)) {
-    if (request->hasArg(param_name)) {
-      const auto &value = request->arg(param_name);
-      (call.*setter)(std::string(value.c_str(), value.length()));
+    if (request->hasParam(param_name)) {
+      // .c_str() is required for Arduino framework where value() returns Arduino String instead of std::string
+      std::string value = request->getParam(param_name)->value().c_str();  // NOLINT(readability-redundant-string-cstr)
+      (call.*setter)(value);
     }
   }
 
@@ -555,9 +573,8 @@ class WebServer : public Controller,
   // Invalid values are ignored (setter not called)
   template<typename T, typename Ret>
   void parse_bool_param_(AsyncWebServerRequest *request, ParamNameType param_name, T &call, Ret (T::*setter)(bool)) {
-    const auto &param_value = request->arg(param_name);
-    // Arduino String has isEmpty() not empty(), use length() for cross-platform compatibility
-    if (param_value.length() > 0) {  // NOLINT(readability-container-size-empty)
+    if (request->hasParam(param_name)) {
+      auto param_value = request->getParam(param_name)->value();
       // First check on/off (default), then true/false (custom)
       auto val = parse_on_off(param_value.c_str());
       if (val == PARSE_NONE) {

esphome/components/web_server_idf/utils.cpp

@@ -1,13 +1,17 @@
 #ifdef USE_ESP32
+#include <memory>
 #include <cstring>
 #include <cctype>
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include "http_parser.h"
 
 #include "utils.h"
 
 namespace esphome::web_server_idf {
 
+static const char *const TAG = "web_server_idf_utils";
+
 size_t url_decode(char *str) {
   char *start = str;
   char *ptr = str, buf;
@@ -50,15 +54,32 @@ optional<std::string> request_get_header(httpd_req_t *req, const char *name) {
   return {str};
 }
 
+optional<std::string> request_get_url_query(httpd_req_t *req) {
+  auto len = httpd_req_get_url_query_len(req);
+  if (len == 0) {
+    return {};
+  }
+
+  std::string str;
+  str.resize(len);
+
+  auto res = httpd_req_get_url_query_str(req, &str[0], len + 1);
+  if (res != ESP_OK) {
+    ESP_LOGW(TAG, "Can't get query for request: %s", esp_err_to_name(res));
+    return {};
+  }
+
+  return {str};
+}
+
 optional<std::string> query_key_value(const char *query_url, size_t query_len, const char *key) {
   if (query_url == nullptr || query_len == 0) {
     return {};
   }
 
-  // Value can't exceed query_len. Use small stack buffer for typical values,
-  // heap fallback for long ones (e.g. base64 IR data) to limit stack usage
-  // since callers may also have stack buffers for the query string.
-  SmallBufferWithHeapFallback<128, char> val(query_len);
+  // Use stack buffer for typical query strings, heap fallback for large ones
+  SmallBufferWithHeapFallback<256, char> val(query_len);
+
   if (httpd_query_key_value(query_url, key, val.get(), query_len) != ESP_OK) {
     return {};
   }
@@ -67,18 +88,6 @@ optional<std::string> query_key_value(const char *query_url, size_t query_len, c
   return {val.get()};
 }
 
-bool query_has_key(const char *query_url, size_t query_len, const char *key) {
-  if (query_url == nullptr || query_len == 0) {
-    return false;
-  }
-  // Minimal buffer — we only care if the key exists, not the value
-  char buf[1];
-  // httpd_query_key_value returns ESP_OK if found, ESP_ERR_HTTPD_RESULT_TRUNC if found
-  // but value truncated (expected with 1-byte buffer), or other errors for invalid input
-  auto err = httpd_query_key_value(query_url, key, buf, sizeof(buf));
-  return err == ESP_OK || err == ESP_ERR_HTTPD_RESULT_TRUNC;
-}
-
 // Helper function for case-insensitive string region comparison
 bool str_ncmp_ci(const char *s1, const char *s2, size_t n) {
   for (size_t i = 0; i < n; i++) {

esphome/components/web_server_idf/utils.h

@@ -13,8 +13,11 @@ size_t url_decode(char *str);
 
 bool request_has_header(httpd_req_t *req, const char *name);
 optional<std::string> request_get_header(httpd_req_t *req, const char *name);
+optional<std::string> request_get_url_query(httpd_req_t *req);
 optional<std::string> query_key_value(const char *query_url, size_t query_len, const char *key);
-bool query_has_key(const char *query_url, size_t query_len, const char *key);
+inline optional<std::string> query_key_value(const std::string &query_url, const std::string &key) {
+  return query_key_value(query_url.c_str(), query_url.size(), key.c_str());
+}
 
 // Helper function for case-insensitive character comparison
 inline bool char_equals_ci(char a, char b) { return ::tolower(a) == ::tolower(b); }

esphome/components/web_server_idf/web_server_idf.cpp

@@ -393,7 +393,13 @@ AsyncWebParameter *AsyncWebServerRequest::getParam(const char *name) {
   }
 
   // Look up value from query strings
-  auto val = this->find_query_value_(name);
+  optional<std::string> val = query_key_value(this->post_query_.c_str(), this->post_query_.size(), name);
+  if (!val.has_value()) {
+    auto url_query = request_get_url_query(*this);
+    if (url_query.has_value()) {
+      val = query_key_value(url_query.value().c_str(), url_query.value().size(), name);
+    }
+  }
 
   // Don't cache misses to avoid wasting memory when handlers check for
   // optional parameters that don't exist in the request
@@ -406,50 +412,6 @@ AsyncWebParameter *AsyncWebServerRequest::getParam(const char *name) {
   return param;
 }
 
-/// Search post_query then URL query with a callback.
-/// Returns first truthy result, or value-initialized default.
-/// URL query is accessed directly from req->uri (same pattern as url_to()).
-template<typename Func>
-static auto search_query_sources(httpd_req_t *req, const std::string &post_query, const char *name, Func func)
-    -> decltype(func(nullptr, size_t{0}, name)) {
-  if (!post_query.empty()) {
-    auto result = func(post_query.c_str(), post_query.size(), name);
-    if (result) {
-      return result;
-    }
-  }
-  // Use httpd API for query length, then access string directly from URI.
-  // http_parser identifies components by offset/length without modifying the URI string.
-  // This is the same pattern used by url_to().
-  auto len = httpd_req_get_url_query_len(req);
-  if (len == 0) {
-    return {};
-  }
-  const char *query = strchr(req->uri, '?');
-  if (query == nullptr) {
-    return {};
-  }
-  query++;  // skip '?'
-  return func(query, len, name);
-}
-
-optional<std::string> AsyncWebServerRequest::find_query_value_(const char *name) const {
-  return search_query_sources(this->req_, this->post_query_, name,
-                              [](const char *q, size_t len, const char *k) { return query_key_value(q, len, k); });
-}
-
-bool AsyncWebServerRequest::hasArg(const char *name) {
-  return search_query_sources(this->req_, this->post_query_, name, query_has_key);
-}
-
-std::string AsyncWebServerRequest::arg(const char *name) {
-  auto val = this->find_query_value_(name);
-  if (val.has_value()) {
-    return std::move(val.value());
-  }
-  return {};
-}
-
 void AsyncWebServerResponse::addHeader(const char *name, const char *value) {
   httpd_resp_set_hdr(*this->req_, name, value);
 }

esphome/components/web_server_idf/web_server_idf.h

@@ -116,8 +116,7 @@ class AsyncWebServerRequest {
   /// Write URL (without query string) to buffer, returns StringRef pointing to buffer.
   /// URL is decoded (e.g., %20 -> space).
   StringRef url_to(std::span<char, URL_BUF_SIZE> buffer) const;
-  // Remove before 2026.9.0
-  ESPDEPRECATED("Use url_to() instead. Removed in 2026.9.0", "2026.3.0")
+  /// Get URL as std::string. Prefer url_to() to avoid heap allocation.
   std::string url() const {
     char buffer[URL_BUF_SIZE];
     return std::string(this->url_to(buffer));
@@ -171,8 +170,14 @@ class AsyncWebServerRequest {
   AsyncWebParameter *getParam(const std::string &name) { return this->getParam(name.c_str()); }
 
   // NOLINTNEXTLINE(readability-identifier-naming)
-  bool hasArg(const char *name);
-  std::string arg(const char *name);
+  bool hasArg(const char *name) { return this->hasParam(name); }
+  std::string arg(const char *name) {
+    auto *param = this->getParam(name);
+    if (param) {
+      return param->value();
+    }
+    return {};
+  }
   std::string arg(const std::string &name) { return this->arg(name.c_str()); }
 
   operator httpd_req_t *() const { return this->req_; }
@@ -187,7 +192,6 @@ class AsyncWebServerRequest {
   // is faster than tree/hash overhead. AsyncWebParameter stores both name and value to avoid
   // duplicate storage. Only successful lookups are cached to prevent cache pollution when
   // handlers check for optional parameters that don't exist.
-  optional<std::string> find_query_value_(const char *name) const;
   std::vector<AsyncWebParameter *> params_;
   std::string post_query_;
   AsyncWebServerRequest(httpd_req_t *req) : req_(req) {}

esphome/components/wifi/wifi_component.cpp

@@ -3,7 +3,6 @@
 #include <cassert>
 #include <cinttypes>
 #include <cmath>
-#include <type_traits>
 
 #ifdef USE_ESP32
 #if (ESP_IDF_VERSION_MAJOR >= 5 && ESP_IDF_VERSION_MINOR >= 1)
@@ -1320,61 +1319,20 @@ void WiFiComponent::start_scanning() {
 // Using insertion sort instead of std::stable_sort saves flash memory
 // by avoiding template instantiations (std::rotate, std::stable_sort, lambdas)
 // IMPORTANT: This sort is stable (preserves relative order of equal elements)
-//
-// Uses raw memcpy instead of copy assignment to avoid CompactString's
-// destructor/constructor overhead (heap delete[]/new[] for long SSIDs).
-// Copy assignment calls ~CompactString() then placement-new for every shift,
-// which means delete[]/new[] per shift for heap-allocated SSIDs. With 70+
-// networks (e.g., captive portal showing full scan results), this caused
-// event loop blocking from hundreds of heap operations in a tight loop.
-//
-// This is safe because we're permuting elements within the same array —
-// each slot is overwritten exactly once, so no ownership duplication occurs.
-// All members of WiFiScanResult are either trivially copyable (bssid, channel,
-// rssi, priority, flags) or CompactString, which stores either inline data or
-// a heap pointer — never a self-referential pointer (unlike std::string's SSO
-// on some implementations). This was not possible before PR#13472 replaced
-// std::string with CompactString, since std::string's internal layout is
-// implementation-defined and may use self-referential pointers.
-//
-// TODO: If C++ standardizes std::trivially_relocatable, add the assertion for
-// WiFiScanResult/CompactString here to formally express the memcpy safety guarantee.
 template<typename VectorType> static void insertion_sort_scan_results(VectorType &results) {
-  // memcpy-based sort requires no self-referential pointers or virtual dispatch.
-  // These static_asserts guard the assumptions. If any fire, the memcpy sort
-  // must be reviewed for safety before updating the expected values.
-  //
-  // No vtable pointers (memcpy would corrupt vptr)
-  static_assert(!std::is_polymorphic<WiFiScanResult>::value, "WiFiScanResult must not have vtable");
-  static_assert(!std::is_polymorphic<CompactString>::value, "CompactString must not have vtable");
-  // Standard layout ensures predictable memory layout with no virtual bases
-  // and no mixed-access-specifier reordering
-  static_assert(std::is_standard_layout<WiFiScanResult>::value, "WiFiScanResult must be standard layout");
-  static_assert(std::is_standard_layout<CompactString>::value, "CompactString must be standard layout");
-  // Size checks catch added/removed fields that may need safety review
-  static_assert(sizeof(WiFiScanResult) == 32, "WiFiScanResult size changed - verify memcpy sort is still safe");
-  static_assert(sizeof(CompactString) == 20, "CompactString size changed - verify memcpy sort is still safe");
-  // Alignment must match for reinterpret_cast of key_buf to be valid
-  static_assert(alignof(WiFiScanResult) <= alignof(std::max_align_t), "WiFiScanResult alignment exceeds max_align_t");
   const size_t size = results.size();
-  constexpr size_t elem_size = sizeof(WiFiScanResult);
-  // Suppress warnings for intentional memcpy on non-trivially-copyable type.
-  // Safety is guaranteed by the static_asserts above and the permutation invariant.
-  // NOLINTNEXTLINE(bugprone-undefined-memory-manipulation)
-  auto *memcpy_fn = &memcpy;
   for (size_t i = 1; i < size; i++) {
-    alignas(WiFiScanResult) uint8_t key_buf[elem_size];
-    memcpy_fn(key_buf, &results[i], elem_size);
-    const auto &key = *reinterpret_cast<const WiFiScanResult *>(key_buf);
+    // Make a copy to avoid issues with move semantics during comparison
+    WiFiScanResult key = results[i];
     int32_t j = i - 1;
 
     // Move elements that are worse than key to the right
     // For stability, we only move if key is strictly better than results[j]
     while (j >= 0 && wifi_scan_result_is_better(key, results[j])) {
-      memcpy_fn(&results[j + 1], &results[j], elem_size);
+      results[j + 1] = results[j];
       j--;
     }
-    memcpy_fn(&results[j + 1], key_buf, elem_size);
+    results[j + 1] = key;
   }
 }
 

esphome/components/wifi/wifi_component.h

@@ -10,7 +10,6 @@
 
 #include <span>
 #include <string>
-#include <type_traits>
 #include <vector>
 
 #ifdef USE_LIBRETINY
@@ -220,14 +219,6 @@ class CompactString {
 };
 
 static_assert(sizeof(CompactString) == 20, "CompactString must be exactly 20 bytes");
-// CompactString is not trivially copyable (non-trivial destructor/copy for heap case).
-// However, its layout has no self-referential pointers: storage_[] contains either inline
-// data or an external heap pointer — never a pointer to itself. This is unlike libstdc++
-// std::string SSO where _M_p points to _M_local_buf within the same object.
-// This property allows memcpy-based permutation sorting where each element ends up in
-// exactly one slot (no ownership duplication). These asserts document that layout property.
-static_assert(std::is_standard_layout<CompactString>::value, "CompactString must be standard layout");
-static_assert(!std::is_polymorphic<CompactString>::value, "CompactString must not have vtable");
 
 class WiFiAP {
   friend class WiFiComponent;
@@ -511,8 +502,6 @@ class WiFiComponent : public Component {
   }
 
   network::IPAddresses wifi_sta_ip_addresses();
-  // Remove before 2026.9.0
-  ESPDEPRECATED("Use wifi_ssid_to() instead. Removed in 2026.9.0", "2026.3.0")
   std::string wifi_ssid();
   /// Write SSID to buffer without heap allocation.
   /// Returns pointer to buffer, or empty string if not connected.

esphome/core/helpers.h

@@ -1083,9 +1083,6 @@ template<std::size_t N> std::string format_hex(const std::array<uint8_t, N> &dat
  * Each byte is displayed as a two-digit uppercase hex value, separated by the specified separator.
  * Optionally includes the total byte count in parentheses at the end.
  *
- * @warning Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.
- * Causes heap fragmentation on long-running devices.
- *
  * @param data Pointer to the byte array to format.
  * @param length Number of bytes in the array.
  * @param separator Character to use between hex bytes (default: '.').
@@ -1111,9 +1108,6 @@ std::string format_hex_pretty(const uint8_t *data, size_t length, char separator
  *
  * Similar to the byte array version, but formats 16-bit words as 4-digit hex values.
  *
- * @warning Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.
- * Causes heap fragmentation on long-running devices.
- *
  * @param data Pointer to the 16-bit word array to format.
  * @param length Number of 16-bit words in the array.
  * @param separator Character to use between hex words (default: '.').
@@ -1137,9 +1131,6 @@ std::string format_hex_pretty(const uint16_t *data, size_t length, char separato
  * Convenience overload for std::vector<uint8_t>. Formats each byte as a two-digit
  * uppercase hex value with customizable separator.
  *
- * @warning Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.
- * Causes heap fragmentation on long-running devices.
- *
  * @param data Vector of bytes to format.
  * @param separator Character to use between hex bytes (default: '.').
  * @param show_length Whether to append the byte count in parentheses (default: true).
@@ -1163,9 +1154,6 @@ std::string format_hex_pretty(const std::vector<uint8_t> &data, char separator =
  * Convenience overload for std::vector<uint16_t>. Each 16-bit word is formatted
  * as a 4-digit uppercase hex value in big-endian order.
  *
- * @warning Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.
- * Causes heap fragmentation on long-running devices.
- *
  * @param data Vector of 16-bit words to format.
  * @param separator Character to use between hex words (default: '.').
  * @param show_length Whether to append the word count in parentheses (default: true).
@@ -1188,9 +1176,6 @@ std::string format_hex_pretty(const std::vector<uint16_t> &data, char separator
  * Treats each character in the string as a byte and formats it in hex.
  * Useful for debugging binary data stored in std::string containers.
  *
- * @warning Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.
- * Causes heap fragmentation on long-running devices.
- *
  * @param data String whose bytes should be formatted as hex.
  * @param separator Character to use between hex bytes (default: '.').
  * @param show_length Whether to append the byte count in parentheses (default: true).
@@ -1213,9 +1198,6 @@ std::string format_hex_pretty(const std::string &data, char separator = '.', boo
  * Converts the integer to big-endian byte order and formats each byte as hex.
  * The most significant byte appears first in the output string.
  *
- * @warning Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.
- * Causes heap fragmentation on long-running devices.
- *
  * @tparam T Unsigned integer type (uint8_t, uint16_t, uint32_t, uint64_t, etc.).
  * @param val The unsigned integer value to format.
  * @param separator Character to use between hex bytes (default: '.').

esphome/core/time.cpp

@@ -2,7 +2,6 @@
 #include "helpers.h"
 
 #include <algorithm>
-#include <cinttypes>
 
 namespace esphome {
 
@@ -67,58 +66,123 @@ std::string ESPTime::strftime(const char *format) {
 
 std::string ESPTime::strftime(const std::string &format) { return this->strftime(format.c_str()); }
 
-bool ESPTime::strptime(const char *time_to_parse, size_t len, ESPTime &esp_time) {
-  uint16_t year;
-  uint8_t month;
-  uint8_t day;
-  uint8_t hour;
-  uint8_t minute;
-  uint8_t second;
-  int num;
-  const int ilen = static_cast<int>(len);
-
-  if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %02hhu:%02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
-             &hour,                                                                              // NOLINT
-             &minute,                                                                            // NOLINT
-             &second, &num) == 6 &&                                                              // NOLINT
-      num == ilen) {
-    esp_time.year = year;
-    esp_time.month = month;
-    esp_time.day_of_month = day;
-    esp_time.hour = hour;
-    esp_time.minute = minute;
-    esp_time.second = second;
-  } else if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
-                    &hour,                                                                       // NOLINT
-                    &minute, &num) == 5 &&                                                       // NOLINT
-             num == ilen) {
-    esp_time.year = year;
-    esp_time.month = month;
-    esp_time.day_of_month = day;
-    esp_time.hour = hour;
-    esp_time.minute = minute;
-    esp_time.second = 0;
-  } else if (sscanf(time_to_parse, "%02hhu:%02hhu:%02hhu %n", &hour, &minute, &second, &num) == 3 &&  // NOLINT
-             num == ilen) {
-    esp_time.hour = hour;
-    esp_time.minute = minute;
-    esp_time.second = second;
-  } else if (sscanf(time_to_parse, "%02hhu:%02hhu %n", &hour, &minute, &num) == 2 &&  // NOLINT
-             num == ilen) {
-    esp_time.hour = hour;
-    esp_time.minute = minute;
-    esp_time.second = 0;
-  } else if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %n", &year, &month, &day, &num) == 3 &&  // NOLINT
-             num == ilen) {
-    esp_time.year = year;
-    esp_time.month = month;
-    esp_time.day_of_month = day;
-  } else {
-    return false;
+// Helper to parse exactly N digits, returns false if not enough digits
+static bool parse_digits(const char *&p, const char *end, int count, uint16_t &value) {
+  value = 0;
+  for (int i = 0; i < count; i++) {
+    if (p >= end || *p < '0' || *p > '9')
+      return false;
+    value = value * 10 + (*p - '0');
+    p++;
   }
   return true;
 }
 
+// Helper to check for expected character
+static bool expect_char(const char *&p, const char *end, char expected) {
+  if (p >= end || *p != expected)
+    return false;
+  p++;
+  return true;
+}
+
+bool ESPTime::strptime(const char *time_to_parse, size_t len, ESPTime &esp_time) {
+  // Supported formats:
+  //   YYYY-MM-DD HH:MM:SS (19 chars)
+  //   YYYY-MM-DD HH:MM    (16 chars)
+  //   YYYY-MM-DD          (10 chars)
+  //   HH:MM:SS            (8 chars)
+  //   HH:MM               (5 chars)
+
+  if (time_to_parse == nullptr || len == 0)
+    return false;
+
+  const char *p = time_to_parse;
+  const char *end = time_to_parse + len;
+  uint16_t v1, v2, v3, v4, v5, v6;
+
+  // Try date formats first (start with 4-digit year)
+  if (len >= 10 && time_to_parse[4] == '-') {
+    // YYYY-MM-DD...
+    if (!parse_digits(p, end, 4, v1))
+      return false;
+    if (!expect_char(p, end, '-'))
+      return false;
+    if (!parse_digits(p, end, 2, v2))
+      return false;
+    if (!expect_char(p, end, '-'))
+      return false;
+    if (!parse_digits(p, end, 2, v3))
+      return false;
+
+    esp_time.year = v1;
+    esp_time.month = v2;
+    esp_time.day_of_month = v3;
+
+    if (p == end) {
+      // YYYY-MM-DD (date only)
+      return true;
+    }
+
+    if (!expect_char(p, end, ' '))
+      return false;
+
+    // Continue with time part: HH:MM[:SS]
+    if (!parse_digits(p, end, 2, v4))
+      return false;
+    if (!expect_char(p, end, ':'))
+      return false;
+    if (!parse_digits(p, end, 2, v5))
+      return false;
+
+    esp_time.hour = v4;
+    esp_time.minute = v5;
+
+    if (p == end) {
+      // YYYY-MM-DD HH:MM
+      esp_time.second = 0;
+      return true;
+    }
+
+    if (!expect_char(p, end, ':'))
+      return false;
+    if (!parse_digits(p, end, 2, v6))
+      return false;
+
+    esp_time.second = v6;
+    return p == end;  // YYYY-MM-DD HH:MM:SS
+  }
+
+  // Try time-only formats (HH:MM[:SS])
+  if (len >= 5 && time_to_parse[2] == ':') {
+    if (!parse_digits(p, end, 2, v1))
+      return false;
+    if (!expect_char(p, end, ':'))
+      return false;
+    if (!parse_digits(p, end, 2, v2))
+      return false;
+
+    esp_time.hour = v1;
+    esp_time.minute = v2;
+
+    if (p == end) {
+      // HH:MM
+      esp_time.second = 0;
+      return true;
+    }
+
+    if (!expect_char(p, end, ':'))
+      return false;
+    if (!parse_digits(p, end, 2, v3))
+      return false;
+
+    esp_time.second = v3;
+    return p == end;  // HH:MM:SS
+  }
+
+  return false;
+}
+
 void ESPTime::increment_second() {
   this->timestamp++;
   if (!increment_time_value(this->second, 0, 60))
@@ -193,27 +257,67 @@ void ESPTime::recalc_timestamp_utc(bool use_day_of_year) {
 }
 
 void ESPTime::recalc_timestamp_local() {
-  struct tm tm;
+#ifdef USE_TIME_TIMEZONE
+  // Calculate timestamp as if fields were UTC
+  this->recalc_timestamp_utc(false);
+  if (this->timestamp == -1) {
+    return;  // Invalid time
+  }
 
-  tm.tm_year = this->year - 1900;
-  tm.tm_mon = this->month - 1;
-  tm.tm_mday = this->day_of_month;
-  tm.tm_hour = this->hour;
-  tm.tm_min = this->minute;
-  tm.tm_sec = this->second;
-  tm.tm_isdst = -1;
+  // Now convert from local to UTC by adding the offset
+  // POSIX: local = utc - offset, so utc = local + offset
+  const auto &tz = time::get_global_tz();
 
-  this->timestamp = mktime(&tm);
+  if (!tz.has_dst()) {
+    // No DST - just apply standard offset
+    this->timestamp += tz.std_offset_seconds;
+    return;
+  }
+
+  // Try both interpretations to match libc mktime() with tm_isdst=-1
+  // For ambiguous times (fall-back repeated hour), prefer standard time
+  // For invalid times (spring-forward skipped hour), libc normalizes forward
+  time_t utc_if_dst = this->timestamp + tz.dst_offset_seconds;
+  time_t utc_if_std = this->timestamp + tz.std_offset_seconds;
+
+  bool dst_valid = time::is_in_dst(utc_if_dst, tz);
+  bool std_valid = !time::is_in_dst(utc_if_std, tz);
+
+  if (dst_valid && std_valid) {
+    // Ambiguous time (repeated hour during fall-back) - prefer standard time
+    this->timestamp = utc_if_std;
+  } else if (dst_valid) {
+    // Only DST interpretation is valid
+    this->timestamp = utc_if_dst;
+  } else if (std_valid) {
+    // Only standard interpretation is valid
+    this->timestamp = utc_if_std;
+  } else {
+    // Invalid time (skipped hour during spring-forward)
+    // libc normalizes forward: 02:30 CST -> 08:30 UTC -> 03:30 CDT
+    // Using std offset achieves this since the UTC result falls during DST
+    this->timestamp = utc_if_std;
+  }
+#else
+  // No timezone support - treat as UTC
+  this->recalc_timestamp_utc(false);
+#endif
 }
 
 int32_t ESPTime::timezone_offset() {
+#ifdef USE_TIME_TIMEZONE
   time_t now = ::time(nullptr);
-  struct tm local_tm = *::localtime(&now);
-  local_tm.tm_isdst = 0;  // Cause mktime to ignore daylight saving time because we want to include it in the offset.
-  time_t local_time = mktime(&local_tm);
-  struct tm utc_tm = *::gmtime(&now);
-  time_t utc_time = mktime(&utc_tm);
-  return static_cast<int32_t>(local_time - utc_time);
+  const auto &tz = time::get_global_tz();
+  // POSIX offset is positive west, but we return offset to add to UTC to get local
+  // So we negate the POSIX offset
+  if (time::is_in_dst(now, tz)) {
+    return -tz.dst_offset_seconds;
+  }
+  return -tz.std_offset_seconds;
+#else
+  // No timezone support - no offset
+  return 0;
+#endif
 }
 
 bool ESPTime::operator<(const ESPTime &other) const { return this->timestamp < other.timestamp; }

esphome/core/time.h

@@ -7,6 +7,10 @@
 #include <span>
 #include <string>
 
+#ifdef USE_TIME_TIMEZONE
+#include "esphome/components/time/posix_tz.h"
+#endif
+
 namespace esphome {
 
 template<typename T> bool increment_time_value(T &current, uint16_t begin, uint16_t end);
@@ -105,11 +109,17 @@ struct ESPTime {
    * @return The generated ESPTime
    */
   static ESPTime from_epoch_local(time_t epoch) {
-    struct tm *c_tm = ::localtime(&epoch);
-    if (c_tm == nullptr) {
-      return ESPTime{};  // Return an invalid ESPTime
+#ifdef USE_TIME_TIMEZONE
+    struct tm local_tm;
+    if (time::epoch_to_local_tm(epoch, time::get_global_tz(), &local_tm)) {
+      return ESPTime::from_c_tm(&local_tm, epoch);
     }
-    return ESPTime::from_c_tm(c_tm, epoch);
+    // Fallback to UTC if conversion failed
+    return ESPTime::from_epoch_utc(epoch);
+#else
+    // No timezone support - return UTC (no TZ configured, localtime would return UTC anyway)
+    return ESPTime::from_epoch_utc(epoch);
+#endif
   }
   /** Convert an UTC epoch timestamp to a UTC time ESPTime instance.
    *

script/build_language_schema.py

@@ -369,7 +369,7 @@ def get_logger_tags():
         "api.service",
     ]
     for file in CORE_COMPONENTS_PATH.rglob("*.cpp"):
-        data = file.read_text(encoding="utf-8")
+        data = file.read_text()
         match = pattern.search(data)
         if match:
             tags.append(match.group(1))

script/cpp_unit_test.py

@@ -66,6 +66,7 @@ def create_test_config(config_name: str, includes: list[str]) -> dict:
                 ],
                 "build_flags": [
                     "-Og",  # optimize for debug
+                    "-DUSE_TIME_TIMEZONE",  # enable timezone code paths for testing
                 ],
                 "debug_build_flags": [  # only for debug builds
                     "-g3",  # max debug info

tests/components/mipi_spi/common.yaml

@@ -3,15 +3,9 @@ display:
     spi_16: true
     pixel_mode: 18bit
     model: ili9488
-    dc_pin:
-      allow_other_uses: true
-      number: ${dc_pin}
-    cs_pin:
-      allow_other_uses: true
-      number: ${cs_pin}
-    reset_pin:
-      allow_other_uses: true
-      number: ${reset_pin}
+    dc_pin: ${dc_pin}
+    cs_pin: ${cs_pin}
+    reset_pin: ${reset_pin}
     data_rate: 20MHz
     invert_colors: true
     show_test_card: true
@@ -30,15 +24,3 @@ display:
       height: 200
     enable_pin: ${enable_pin}
     bus_mode: single
-
-  - platform: mipi_spi
-    model: WAVESHARE-1.83-V2
-    dc_pin:
-      allow_other_uses: true
-      number: ${dc_pin}
-    cs_pin:
-      allow_other_uses: true
-      number: ${cs_pin}
-    reset_pin:
-      allow_other_uses: true
-      number: ${reset_pin}