Update esphome/core/string_ref.h

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

esphome/__main__.py

@@ -795,13 +795,6 @@ def command_vscode(args: ArgsProtocol) -> int | None:
 
 
 def command_compile(args: ArgsProtocol, config: ConfigType) -> int | None:
-    # Set memory analysis options in config
-    if args.analyze_memory:
-        config.setdefault(CONF_ESPHOME, {})["analyze_memory"] = True
-
-    if args.memory_report:
-        config.setdefault(CONF_ESPHOME, {})["memory_report_file"] = args.memory_report
-
     exit_code = write_cpp(config)
     if exit_code != 0:
         return exit_code
@@ -1286,17 +1279,6 @@ def parse_args(argv):
         help="Only generate source code, do not compile.",
         action="store_true",
     )
-    parser_compile.add_argument(
-        "--analyze-memory",
-        help="Analyze and display memory usage by component after compilation.",
-        action="store_true",
-    )
-    parser_compile.add_argument(
-        "--memory-report",
-        help="Save memory analysis report to a file (supports .json or .txt).",
-        type=str,
-        metavar="FILE",
-    )
 
     parser_upload = subparsers.add_parser(
         "upload",

esphome/analyze_memory/cli.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from collections import defaultdict
 from collections.abc import Callable
-import json
 import sys
 from typing import TYPE_CHECKING
 
@@ -439,28 +438,6 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
 
         return "\n".join(lines)
 
-    def to_json(self) -> str:
-        """Export analysis results as JSON."""
-        data = {
-            "components": {
-                name: {
-                    "text": mem.text_size,
-                    "rodata": mem.rodata_size,
-                    "data": mem.data_size,
-                    "bss": mem.bss_size,
-                    "flash_total": mem.flash_total,
-                    "ram_total": mem.ram_total,
-                    "symbol_count": mem.symbol_count,
-                }
-                for name, mem in self.components.items()
-            },
-            "totals": {
-                "flash": sum(c.flash_total for c in self.components.values()),
-                "ram": sum(c.ram_total for c in self.components.values()),
-            },
-        }
-        return json.dumps(data, indent=2)
-
     def dump_uncategorized_symbols(self, output_file: str | None = None) -> None:
         """Dump uncategorized symbols for analysis."""
         # Sort by size descending

esphome/components/api/api_server.cpp

@@ -645,18 +645,18 @@ uint32_t APIServer::register_active_action_call(uint32_t client_call_id, APIConn
   this->active_action_calls_.push_back({action_call_id, client_call_id, conn});
 
   // Schedule automatic cleanup after timeout (client will have given up by then)
-  // Uses numeric ID overload to avoid heap allocation from str_sprintf
-  this->set_timeout(action_call_id, USE_API_ACTION_CALL_TIMEOUT_MS, [this, action_call_id]() {
-    ESP_LOGD(TAG, "Action call %u timed out", action_call_id);
-    this->unregister_active_action_call(action_call_id);
-  });
+  this->set_timeout(str_sprintf("action_call_%u", action_call_id), USE_API_ACTION_CALL_TIMEOUT_MS,
+                    [this, action_call_id]() {
+                      ESP_LOGD(TAG, "Action call %u timed out", action_call_id);
+                      this->unregister_active_action_call(action_call_id);
+                    });
 
   return action_call_id;
 }
 
 void APIServer::unregister_active_action_call(uint32_t action_call_id) {
-  // Cancel the timeout for this action call (uses numeric ID overload)
-  this->cancel_timeout(action_call_id);
+  // Cancel the timeout for this action call
+  this->cancel_timeout(str_sprintf("action_call_%u", action_call_id));
 
   // Swap-and-pop is more efficient than remove_if for unordered vectors
   for (size_t i = 0; i < this->active_action_calls_.size(); i++) {
@@ -672,8 +672,8 @@ void APIServer::unregister_active_action_calls_for_connection(APIConnection *con
   // Remove all active action calls for disconnected connection using swap-and-pop
   for (size_t i = 0; i < this->active_action_calls_.size();) {
     if (this->active_action_calls_[i].connection == conn) {
-      // Cancel the timeout for this action call (uses numeric ID overload)
-      this->cancel_timeout(this->active_action_calls_[i].action_call_id);
+      // Cancel the timeout for this action call
+      this->cancel_timeout(str_sprintf("action_call_%u", this->active_action_calls_[i].action_call_id));
 
       std::swap(this->active_action_calls_[i], this->active_action_calls_.back());
       this->active_action_calls_.pop_back();

esphome/components/bedjet/bedjet_hub.cpp

@@ -3,7 +3,6 @@
 #include "bedjet_hub.h"
 #include "bedjet_child.h"
 #include "bedjet_const.h"
-#include "esphome/components/esp32_ble/ble_uuid.h"
 #include "esphome/core/application.h"
 #include <cinttypes>
 

esphome/components/display/__init__.py

@@ -63,13 +63,11 @@ def validate_auto_clear(value):
     return cv.boolean(value)
 
 
-def basic_display_schema(default_update_interval: str = "1s") -> cv.Schema:
-    """Create a basic display schema with configurable default update interval."""
-    return cv.Schema(
-        {
-            cv.Exclusive(CONF_LAMBDA, CONF_LAMBDA): cv.lambda_,
-        }
-    ).extend(cv.polling_component_schema(default_update_interval))
+BASIC_DISPLAY_SCHEMA = cv.Schema(
+    {
+        cv.Exclusive(CONF_LAMBDA, CONF_LAMBDA): cv.lambda_,
+    }
+).extend(cv.polling_component_schema("1s"))
 
 
 def _validate_test_card(config):
@@ -83,41 +81,34 @@ def _validate_test_card(config):
     return config
 
 
-def full_display_schema(default_update_interval: str = "1s") -> cv.Schema:
-    """Create a full display schema with configurable default update interval."""
-    schema = basic_display_schema(default_update_interval).extend(
-        {
-            cv.Optional(CONF_ROTATION): validate_rotation,
-            cv.Exclusive(CONF_PAGES, CONF_LAMBDA): cv.All(
-                cv.ensure_list(
-                    {
-                        cv.GenerateID(): cv.declare_id(DisplayPage),
-                        cv.Required(CONF_LAMBDA): cv.lambda_,
-                    }
-                ),
-                cv.Length(min=1),
-            ),
-            cv.Optional(CONF_ON_PAGE_CHANGE): automation.validate_automation(
+FULL_DISPLAY_SCHEMA = BASIC_DISPLAY_SCHEMA.extend(
+    {
+        cv.Optional(CONF_ROTATION): validate_rotation,
+        cv.Exclusive(CONF_PAGES, CONF_LAMBDA): cv.All(
+            cv.ensure_list(
                 {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        DisplayOnPageChangeTrigger
-                    ),
-                    cv.Optional(CONF_FROM): cv.use_id(DisplayPage),
-                    cv.Optional(CONF_TO): cv.use_id(DisplayPage),
+                    cv.GenerateID(): cv.declare_id(DisplayPage),
+                    cv.Required(CONF_LAMBDA): cv.lambda_,
                 }
             ),
-            cv.Optional(
-                CONF_AUTO_CLEAR_ENABLED, default=CONF_UNSPECIFIED
-            ): validate_auto_clear,
-            cv.Optional(CONF_SHOW_TEST_CARD): cv.boolean,
-        }
-    )
-    schema.add_extra(_validate_test_card)
-    return schema
-
-
-BASIC_DISPLAY_SCHEMA = basic_display_schema("1s")
-FULL_DISPLAY_SCHEMA = full_display_schema("1s")
+            cv.Length(min=1),
+        ),
+        cv.Optional(CONF_ON_PAGE_CHANGE): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                    DisplayOnPageChangeTrigger
+                ),
+                cv.Optional(CONF_FROM): cv.use_id(DisplayPage),
+                cv.Optional(CONF_TO): cv.use_id(DisplayPage),
+            }
+        ),
+        cv.Optional(
+            CONF_AUTO_CLEAR_ENABLED, default=CONF_UNSPECIFIED
+        ): validate_auto_clear,
+        cv.Optional(CONF_SHOW_TEST_CARD): cv.boolean,
+    }
+)
+FULL_DISPLAY_SCHEMA.add_extra(_validate_test_card)
 
 
 async def setup_display_core_(var, config):

esphome/components/epaper_spi/display.py

@@ -31,7 +31,6 @@ from esphome.const import (
     CONF_TRANSFORM,
     CONF_UPDATE_INTERVAL,
     CONF_WIDTH,
-    SCHEDULER_DONT_RUN,
 )
 from esphome.cpp_generator import RawExpression
 from esphome.final_validate import full_config
@@ -73,10 +72,12 @@ TRANSFORM_OPTIONS = {CONF_MIRROR_X, CONF_MIRROR_Y, CONF_SWAP_XY}
 def model_schema(config):
     model = MODELS[config[CONF_MODEL]]
     class_name = epaper_spi_ns.class_(model.class_name, EPaperBase)
+    minimum_update_interval = update_interval(
+        model.get_default(CONF_MINIMUM_UPDATE_INTERVAL, "1s")
+    )
     cv_dimensions = cv.Optional if model.get_default(CONF_WIDTH) else cv.Required
     return (
-        display.full_display_schema("60s")
-        .extend(
+        display.FULL_DISPLAY_SCHEMA.extend(
             spi.spi_device_schema(
                 cs_pin_required=False,
                 default_mode="MODE0",
@@ -93,6 +94,9 @@ def model_schema(config):
             {
                 cv.Optional(CONF_ROTATION, default=0): validate_rotation,
                 cv.Required(CONF_MODEL): cv.one_of(model.name, upper=True),
+                cv.Optional(CONF_UPDATE_INTERVAL, default=cv.UNDEFINED): cv.All(
+                    update_interval, cv.Range(min=minimum_update_interval)
+                ),
                 cv.Optional(CONF_TRANSFORM): cv.Schema(
                     {
                         cv.Required(CONF_MIRROR_X): cv.boolean,
@@ -146,22 +150,15 @@ def _final_validate(config):
     global_config = full_config.get()
     from esphome.components.lvgl import DOMAIN as LVGL_DOMAIN
 
-    # If no drawing methods are configured, and LVGL is not enabled, show a test card
-    if (
-        CONF_LAMBDA not in config
-        and CONF_PAGES not in config
-        and LVGL_DOMAIN not in global_config
-    ):
-        config[CONF_SHOW_TEST_CARD] = True
-
-    interval = config[CONF_UPDATE_INTERVAL]
-    if interval != SCHEDULER_DONT_RUN:
-        model = MODELS[config[CONF_MODEL]]
-        minimum = update_interval(model.get_default(CONF_MINIMUM_UPDATE_INTERVAL, "1s"))
-        if interval < minimum:
-            raise cv.Invalid(
-                f"update_interval must be at least {minimum} for {model.name}, got {interval}"
-            )
+    if CONF_LAMBDA not in config and CONF_PAGES not in config:
+        if LVGL_DOMAIN in global_config:
+            if CONF_UPDATE_INTERVAL not in config:
+                config[CONF_UPDATE_INTERVAL] = update_interval("never")
+        else:
+            # If no drawing methods are configured, and LVGL is not enabled, show a test card
+            config[CONF_SHOW_TEST_CARD] = True
+    elif CONF_UPDATE_INTERVAL not in config:
+        config[CONF_UPDATE_INTERVAL] = update_interval("1min")
     return config
 
 

esphome/components/esp32/__init__.py

@@ -660,9 +660,6 @@ CONF_LOOP_TASK_STACK_SIZE = "loop_task_stack_size"
 KEY_VFS_SELECT_REQUIRED = "vfs_select_required"
 KEY_VFS_DIR_REQUIRED = "vfs_dir_required"
 
-# Ring buffer IRAM requirement tracking
-KEY_RINGBUF_IN_IRAM = "ringbuf_in_iram"
-
 
 def require_vfs_select() -> None:
     """Mark that VFS select support is required by a component.
@@ -682,17 +679,6 @@ def require_vfs_dir() -> None:
     CORE.data[KEY_VFS_DIR_REQUIRED] = True
 
 
-def enable_ringbuf_in_iram() -> None:
-    """Keep ring buffer functions in IRAM instead of moving them to flash.
-
-    Call this from components that use esphome/core/ring_buffer.cpp and need
-    the ring buffer functions to remain in IRAM for performance reasons
-    (e.g., voice assistants, audio components).
-    This prevents CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH from being enabled.
-    """
-    CORE.data[KEY_RINGBUF_IN_IRAM] = True
-
-
 def _parse_idf_component(value: str) -> ConfigType:
     """Parse IDF component shorthand syntax like 'owner/component^version'"""
     # Match operator followed by version-like string (digit or *)
@@ -1104,18 +1090,14 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH", True)
 
     # Place ring buffer functions into flash instead of IRAM by default
-    # This saves IRAM but may impact performance for audio/voice components.
-    # Components that need ring buffer in IRAM call enable_ringbuf_in_iram().
-    # Users can also set ringbuf_in_iram: true to force IRAM placement.
-    # In ESP-IDF 6.0 flash placement becomes the default.
-    if conf[CONF_ADVANCED][CONF_RINGBUF_IN_IRAM] or CORE.data.get(
-        KEY_RINGBUF_IN_IRAM, False
-    ):
-        # User config or component requires ring buffer in IRAM for performance
+    # This saves IRAM. In ESP-IDF 6.0 flash placement becomes the default.
+    # Users can set ringbuf_in_iram: true as an escape hatch if they encounter issues.
+    if conf[CONF_ADVANCED][CONF_RINGBUF_IN_IRAM]:
+        # User requests ring buffer in IRAM
         # IDF 6.0+: will need CONFIG_RINGBUF_PLACE_ISR_FUNCTIONS_INTO_FLASH=n
         add_idf_sdkconfig_option("CONFIG_RINGBUF_PLACE_ISR_FUNCTIONS_INTO_FLASH", False)
     else:
-        # No component needs it - place in flash to save IRAM
+        # Place in flash to save IRAM (default)
         add_idf_sdkconfig_option("CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH", True)
 
     # Place heap functions into flash to save IRAM (~4-6KB savings)

esphome/components/esp32/gpio.cpp

@@ -85,6 +85,7 @@ void ESP32InternalGPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpi
       break;
   }
   gpio_set_intr_type(this->get_pin_num(), idf_type);
+  gpio_intr_enable(this->get_pin_num());
   if (!isr_service_installed) {
     auto res = gpio_install_isr_service(ESP_INTR_FLAG_LEVEL3);
     if (res != ESP_OK) {
@@ -94,7 +95,6 @@ void ESP32InternalGPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpi
     isr_service_installed = true;
   }
   gpio_isr_handler_add(this->get_pin_num(), func, arg);
-  gpio_intr_enable(this->get_pin_num());
 }
 
 size_t ESP32InternalGPIOPin::dump_summary(char *buffer, size_t len) const {

esphome/components/esp32_ble/ble.cpp

@@ -98,10 +98,6 @@ void ESP32BLE::advertising_set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void ESP32BLE::advertising_set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->advertising_set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void ESP32BLE::advertising_set_manufacturer_data(std::span<const uint8_t> data) {
   this->advertising_init_();
   this->advertising_->set_manufacturer_data(data);
   this->advertising_start();

esphome/components/esp32_ble/ble.h

@@ -118,7 +118,6 @@ class ESP32BLE : public Component {
   void advertising_start();
   void advertising_set_service_data(const std::vector<uint8_t> &data);
   void advertising_set_manufacturer_data(const std::vector<uint8_t> &data);
-  void advertising_set_manufacturer_data(std::span<const uint8_t> data);
   void advertising_set_appearance(uint16_t appearance) { this->appearance_ = appearance; }
   void advertising_set_service_data_and_name(std::span<const uint8_t> data, bool include_name);
   void advertising_add_service_uuid(ESPBTUUID uuid);

esphome/components/esp32_ble/ble_advertising.cpp

@@ -59,10 +59,6 @@ void BLEAdvertising::set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void BLEAdvertising::set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void BLEAdvertising::set_manufacturer_data(std::span<const uint8_t> data) {
   delete[] this->advertising_data_.p_manufacturer_data;
   this->advertising_data_.p_manufacturer_data = nullptr;
   this->advertising_data_.manufacturer_len = data.size();

esphome/components/esp32_ble/ble_advertising.h

@@ -37,7 +37,6 @@ class BLEAdvertising {
   void set_scan_response(bool scan_response) { this->scan_response_ = scan_response; }
   void set_min_preferred_interval(uint16_t interval) { this->advertising_data_.min_interval = interval; }
   void set_manufacturer_data(const std::vector<uint8_t> &data);
-  void set_manufacturer_data(std::span<const uint8_t> data);
   void set_appearance(uint16_t appearance) { this->advertising_data_.appearance = appearance; }
   void set_service_data(const std::vector<uint8_t> &data);
   void set_service_data(std::span<const uint8_t> data);

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

@@ -1,6 +1,5 @@
 #include "esp32_ble_beacon.h"
 #include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
 
 #ifdef USE_ESP32
 

esphome/components/esp32_ble_server/ble_server_automations.cpp

@@ -15,10 +15,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_characteristic_on_w
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   characteristic->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger - copy is necessary because:
-    // 1. Trigger stores the data for use in automation actions that execute later
-    // 2. The span is only valid during this callback (points to temporary BLE stack data)
-    // 3. User lambdas in automations need persistent data they can access asynchronously
+    // Convert span to vector for trigger
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;
@@ -30,10 +27,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_descriptor_on_write
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   descriptor->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger - copy is necessary because:
-    // 1. Trigger stores the data for use in automation actions that execute later
-    // 2. The span is only valid during this callback (points to temporary BLE stack data)
-    // 3. User lambdas in automations need persistent data they can access asynchronously
+    // Convert span to vector for trigger
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;

esphome/components/ethernet/ethernet_component.cpp

@@ -779,8 +779,8 @@ void EthernetComponent::ksz8081_set_clock_reference_(esp_eth_mac_t *mac) {
   ESPHL_ERROR_CHECK(err, "Read PHY Control 2 failed");
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
   char hex_buf[format_hex_pretty_size(PHY_REG_SIZE)];
-  ESP_LOGVV(TAG, "KSZ8081 PHY Control 2: %s", format_hex_pretty_to(hex_buf, (uint8_t *) &phy_control_2, PHY_REG_SIZE));
 #endif
+  ESP_LOGVV(TAG, "KSZ8081 PHY Control 2: %s", format_hex_pretty_to(hex_buf, (uint8_t *) &phy_control_2, PHY_REG_SIZE));
 
   /*
    * Bit 7 is `RMII Reference Clock Select`. Default is `0`.
@@ -797,10 +797,8 @@ void EthernetComponent::ksz8081_set_clock_reference_(esp_eth_mac_t *mac) {
     ESPHL_ERROR_CHECK(err, "Write PHY Control 2 failed");
     err = mac->read_phy_reg(mac, this->phy_addr_, KSZ80XX_PC2R_REG_ADDR, &(phy_control_2));
     ESPHL_ERROR_CHECK(err, "Read PHY Control 2 failed");
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
     ESP_LOGVV(TAG, "KSZ8081 PHY Control 2: %s",
               format_hex_pretty_to(hex_buf, (uint8_t *) &phy_control_2, PHY_REG_SIZE));
-#endif
   }
 }
 #endif  // USE_ETHERNET_KSZ8081

esphome/components/fan/fan.cpp

@@ -71,7 +71,7 @@ void FanCall::validate_() {
   auto traits = this->parent_.get_traits();
 
   if (this->speed_.has_value()) {
-    this->speed_ = clamp(*this->speed_, 1, static_cast<int>(traits.supported_speed_count()));
+    this->speed_ = clamp(*this->speed_, 1, traits.supported_speed_count());
 
     // https://developers.home-assistant.io/docs/core/entity/fan/#preset-modes
     // "Manually setting a speed must disable any set preset mode"

esphome/components/fan/fan_traits.h

@@ -11,7 +11,7 @@ namespace fan {
 class FanTraits {
  public:
   FanTraits() = default;
-  FanTraits(bool oscillation, bool speed, bool direction, uint8_t speed_count)
+  FanTraits(bool oscillation, bool speed, bool direction, int speed_count)
       : oscillation_(oscillation), speed_(speed), direction_(direction), speed_count_(speed_count) {}
 
   /// Return if this fan supports oscillation.
@@ -23,9 +23,9 @@ class FanTraits {
   /// Set whether this fan supports speed levels.
   void set_speed(bool speed) { this->speed_ = speed; }
   /// Return how many speed levels the fan has
-  uint8_t supported_speed_count() const { return this->speed_count_; }
+  int supported_speed_count() const { return this->speed_count_; }
   /// Set how many speed levels this fan has.
-  void set_supported_speed_count(uint8_t speed_count) { this->speed_count_ = speed_count; }
+  void set_supported_speed_count(int speed_count) { this->speed_count_ = speed_count; }
   /// Return if this fan supports changing direction
   bool supports_direction() const { return this->direction_; }
   /// Set whether this fan supports changing direction
@@ -64,7 +64,7 @@ class FanTraits {
   bool oscillation_{false};
   bool speed_{false};
   bool direction_{false};
-  uint8_t speed_count_{};
+  int speed_count_{};
   std::vector<const char *> preset_modes_{};
 };
 

esphome/components/hbridge/fan/__init__.py

@@ -39,7 +39,7 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_DECAY_MODE, default="SLOW"): cv.enum(
                 DECAY_MODE_OPTIONS, upper=True
             ),
-            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1, max=255),
+            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1),
             cv.Optional(CONF_ENABLE_PIN): cv.use_id(output.FloatOutput),
             cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
         }

esphome/components/hbridge/fan/hbridge_fan.h

@@ -15,7 +15,7 @@ enum DecayMode {
 
 class HBridgeFan : public Component, public fan::Fan {
  public:
-  HBridgeFan(uint8_t speed_count, DecayMode decay_mode) : speed_count_(speed_count), decay_mode_(decay_mode) {}
+  HBridgeFan(int speed_count, DecayMode decay_mode) : speed_count_(speed_count), decay_mode_(decay_mode) {}
 
   void set_pin_a(output::FloatOutput *pin_a) { pin_a_ = pin_a; }
   void set_pin_b(output::FloatOutput *pin_b) { pin_b_ = pin_b; }
@@ -33,7 +33,7 @@ class HBridgeFan : public Component, public fan::Fan {
   output::FloatOutput *pin_b_;
   output::FloatOutput *enable_{nullptr};
   output::BinaryOutput *oscillating_{nullptr};
-  uint8_t speed_count_{};
+  int speed_count_{};
   DecayMode decay_mode_{DECAY_MODE_SLOW};
   fan::FanTraits traits_;
   std::vector<const char *> preset_modes_{};

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -119,7 +119,7 @@ void IDFI2CBus::dump_config() {
         if (s.second) {
           ESP_LOGCONFIG(TAG, "Found device at address 0x%02X", s.first);
         } else {
-          ESP_LOGCONFIG(TAG, "Unknown error at address 0x%02X", s.first);
+          ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
         }
       }
     }

esphome/components/i2s_audio/__init__.py

@@ -1,11 +1,6 @@
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components.esp32 import (
-    add_idf_sdkconfig_option,
-    enable_ringbuf_in_iram,
-    get_esp32_variant,
-)
-from esphome.components.esp32.const import (
     VARIANT_ESP32,
     VARIANT_ESP32C3,
     VARIANT_ESP32C5,
@@ -15,6 +10,8 @@ from esphome.components.esp32.const import (
     VARIANT_ESP32P4,
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
+    add_idf_sdkconfig_option,
+    get_esp32_variant,
 )
 import esphome.config_validation as cv
 from esphome.const import CONF_BITS_PER_SAMPLE, CONF_CHANNEL, CONF_ID, CONF_SAMPLE_RATE
@@ -281,9 +278,6 @@ async def to_code(config):
     # Helps avoid callbacks being skipped due to processor load
     add_idf_sdkconfig_option("CONFIG_I2S_ISR_IRAM_SAFE", True)
 
-    # Keep ring buffer functions in IRAM for audio performance
-    enable_ringbuf_in_iram()
-
     cg.add(var.set_lrclk_pin(config[CONF_I2S_LRCLK_PIN]))
     if CONF_I2S_BCLK_PIN in config:
         cg.add(var.set_bclk_pin(config[CONF_I2S_BCLK_PIN]))

esphome/components/kuntze/kuntze.cpp

@@ -11,7 +11,7 @@ static const char *const TAG = "kuntze";
 static const uint8_t CMD_READ_REG = 0x03;
 static const uint16_t REGISTER[] = {4136, 4160, 4680, 6000, 4688, 4728, 5832};
 
-// Maximum bytes to log for Modbus responses (2 registers = 4 bytes, plus byte count = 5 bytes)
+// Maximum bytes to log for Modbus responses (2 registers = 4, plus count = 5)
 static constexpr size_t KUNTZE_MAX_LOG_BYTES = 8;
 
 void Kuntze::on_modbus_data(const std::vector<uint8_t> &data) {

esphome/components/logger/logger_esp8266.cpp.bak

@@ -1,51 +0,0 @@
-#ifdef USE_ESP8266
-#include "logger.h"
-#include "esphome/core/log.h"
-
-namespace esphome::logger {
-
-static const char *const TAG = "logger";
-
-void Logger::pre_setup() {
-  if (this->baud_rate_ > 0) {
-    switch (this->uart_) {
-      case UART_SELECTION_UART0:
-      case UART_SELECTION_UART0_SWAP:
-        this->hw_serial_ = &Serial;
-        Serial.begin(this->baud_rate_);
-        if (this->uart_ == UART_SELECTION_UART0_SWAP) {
-          Serial.swap();
-        }
-        Serial.setDebugOutput(ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE);
-        break;
-      case UART_SELECTION_UART1:
-        this->hw_serial_ = &Serial1;
-        Serial1.begin(this->baud_rate_);
-        Serial1.setDebugOutput(ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE);
-        break;
-    }
-  } else {
-    uart_set_debug(UART_NO);
-  }
-
-  global_logger = this;
-
-  ESP_LOGI(TAG, "Log initialized");
-}
-
-void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
-
-const LogString *Logger::get_uart_selection_() {
-  switch (this->uart_) {
-    case UART_SELECTION_UART0:
-      return LOG_STR("UART0");
-    case UART_SELECTION_UART1:
-      return LOG_STR("UART1");
-    case UART_SELECTION_UART0_SWAP:
-    default:
-      return LOG_STR("UART0_SWAP");
-  }
-}
-
-}  // namespace esphome::logger
-#endif

esphome/components/logger/logger_host.cpp.bak

@@ -1,22 +0,0 @@
-#if defined(USE_HOST)
-#include "logger.h"
-
-namespace esphome::logger {
-
-void HOT Logger::write_msg_(const char *msg) {
-  time_t rawtime;
-  struct tm *timeinfo;
-  char buffer[80];
-
-  time(&rawtime);
-  timeinfo = localtime(&rawtime);
-  strftime(buffer, sizeof buffer, "[%H:%M:%S]", timeinfo);
-  fputs(buffer, stdout);
-  puts(msg);
-}
-
-void Logger::pre_setup() { global_logger = this; }
-
-}  // namespace esphome::logger
-
-#endif

esphome/components/logger/logger_libretiny.cpp.bak

@@ -1,70 +0,0 @@
-#ifdef USE_LIBRETINY
-#include "logger.h"
-
-namespace esphome::logger {
-
-static const char *const TAG = "logger";
-
-void Logger::pre_setup() {
-  if (this->baud_rate_ > 0) {
-    switch (this->uart_) {
-#if LT_HW_UART0
-      case UART_SELECTION_UART0:
-        this->hw_serial_ = &Serial0;
-        Serial0.begin(this->baud_rate_);
-        break;
-#endif
-#if LT_HW_UART1
-      case UART_SELECTION_UART1:
-        this->hw_serial_ = &Serial1;
-        Serial1.begin(this->baud_rate_);
-        break;
-#endif
-#if LT_HW_UART2
-      case UART_SELECTION_UART2:
-        this->hw_serial_ = &Serial2;
-        Serial2.begin(this->baud_rate_);
-        break;
-#endif
-      default:
-        this->hw_serial_ = &Serial;
-        Serial.begin(this->baud_rate_);
-        if (this->uart_ != UART_SELECTION_DEFAULT) {
-          ESP_LOGW(TAG, "  The chosen logger UART port is not available on this board."
-                        "The default port was used instead.");
-        }
-        break;
-    }
-
-    // change lt_log() port to match default Serial
-    if (this->uart_ == UART_SELECTION_DEFAULT) {
-      this->uart_ = (UARTSelection) (LT_UART_DEFAULT_SERIAL + 1);
-      lt_log_set_port(LT_UART_DEFAULT_SERIAL);
-    } else {
-      lt_log_set_port(this->uart_ - 1);
-    }
-  }
-
-  global_logger = this;
-  ESP_LOGI(TAG, "Log initialized");
-}
-
-void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
-
-const LogString *Logger::get_uart_selection_() {
-  switch (this->uart_) {
-    case UART_SELECTION_DEFAULT:
-      return LOG_STR("DEFAULT");
-    case UART_SELECTION_UART0:
-      return LOG_STR("UART0");
-    case UART_SELECTION_UART1:
-      return LOG_STR("UART1");
-    case UART_SELECTION_UART2:
-    default:
-      return LOG_STR("UART2");
-  }
-}
-
-}  // namespace esphome::logger
-
-#endif  // USE_LIBRETINY

esphome/components/logger/logger_rp2040.cpp.bak

@@ -1,48 +0,0 @@
-#ifdef USE_RP2040
-#include "logger.h"
-#include "esphome/core/log.h"
-
-namespace esphome::logger {
-
-static const char *const TAG = "logger";
-
-void Logger::pre_setup() {
-  if (this->baud_rate_ > 0) {
-    switch (this->uart_) {
-      case UART_SELECTION_UART0:
-        this->hw_serial_ = &Serial1;
-        Serial1.begin(this->baud_rate_);
-        break;
-      case UART_SELECTION_UART1:
-        this->hw_serial_ = &Serial2;
-        Serial2.begin(this->baud_rate_);
-        break;
-      case UART_SELECTION_USB_CDC:
-        this->hw_serial_ = &Serial;
-        Serial.begin(this->baud_rate_);
-        break;
-    }
-  }
-  global_logger = this;
-  ESP_LOGI(TAG, "Log initialized");
-}
-
-void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
-
-const LogString *Logger::get_uart_selection_() {
-  switch (this->uart_) {
-    case UART_SELECTION_UART0:
-      return LOG_STR("UART0");
-    case UART_SELECTION_UART1:
-      return LOG_STR("UART1");
-#ifdef USE_LOGGER_USB_CDC
-    case UART_SELECTION_USB_CDC:
-      return LOG_STR("USB_CDC");
-#endif
-    default:
-      return LOG_STR("UNKNOWN");
-  }
-}
-
-}  // namespace esphome::logger
-#endif  // USE_RP2040

esphome/components/logger/logger_zephyr.cpp.bak

@@ -1,96 +0,0 @@
-#ifdef USE_ZEPHYR
-
-#include "esphome/core/application.h"
-#include "esphome/core/log.h"
-#include "logger.h"
-
-#include <zephyr/device.h>
-#include <zephyr/drivers/uart.h>
-#include <zephyr/usb/usb_device.h>
-
-namespace esphome::logger {
-
-static const char *const TAG = "logger";
-
-#ifdef USE_LOGGER_USB_CDC
-void Logger::loop() {
-  if (this->uart_ != UART_SELECTION_USB_CDC || nullptr == this->uart_dev_) {
-    return;
-  }
-  static bool opened = false;
-  uint32_t dtr = 0;
-  uart_line_ctrl_get(this->uart_dev_, UART_LINE_CTRL_DTR, &dtr);
-
-  /* Poll if the DTR flag was set, optional */
-  if (opened == dtr) {
-    return;
-  }
-
-  if (!opened) {
-    App.schedule_dump_config();
-  }
-  opened = !opened;
-}
-#endif
-
-void Logger::pre_setup() {
-  if (this->baud_rate_ > 0) {
-    static const struct device *uart_dev = nullptr;
-    switch (this->uart_) {
-      case UART_SELECTION_UART0:
-        uart_dev = DEVICE_DT_GET_OR_NULL(DT_NODELABEL(uart0));
-        break;
-      case UART_SELECTION_UART1:
-        uart_dev = DEVICE_DT_GET_OR_NULL(DT_NODELABEL(uart1));
-        break;
-#ifdef USE_LOGGER_USB_CDC
-      case UART_SELECTION_USB_CDC:
-        uart_dev = DEVICE_DT_GET_OR_NULL(DT_NODELABEL(cdc_acm_uart0));
-        if (device_is_ready(uart_dev)) {
-          usb_enable(nullptr);
-        }
-        break;
-#endif
-    }
-    if (!device_is_ready(uart_dev)) {
-      ESP_LOGE(TAG, "%s is not ready.", LOG_STR_ARG(get_uart_selection_()));
-    } else {
-      this->uart_dev_ = uart_dev;
-    }
-  }
-  global_logger = this;
-  ESP_LOGI(TAG, "Log initialized");
-}
-
-void HOT Logger::write_msg_(const char *msg) {
-#ifdef CONFIG_PRINTK
-  printk("%s\n", msg);
-#endif
-  if (nullptr == this->uart_dev_) {
-    return;
-  }
-  while (*msg) {
-    uart_poll_out(this->uart_dev_, *msg);
-    ++msg;
-  }
-  uart_poll_out(this->uart_dev_, '\n');
-}
-
-const LogString *Logger::get_uart_selection_() {
-  switch (this->uart_) {
-    case UART_SELECTION_UART0:
-      return LOG_STR("UART0");
-    case UART_SELECTION_UART1:
-      return LOG_STR("UART1");
-#ifdef USE_LOGGER_USB_CDC
-    case UART_SELECTION_USB_CDC:
-      return LOG_STR("USB_CDC");
-#endif
-    default:
-      return LOG_STR("UNKNOWN");
-  }
-}
-
-}  // namespace esphome::logger
-
-#endif

esphome/components/mcp23016/mcp23016.cpp

@@ -56,7 +56,7 @@ void MCP23016::pin_mode(uint8_t pin, gpio::Flags flags) {
     this->update_reg_(pin, false, iodir);
   }
 }
-float MCP23016::get_setup_priority() const { return setup_priority::IO; }
+float MCP23016::get_setup_priority() const { return setup_priority::HARDWARE; }
 bool MCP23016::read_reg_(uint8_t reg, uint8_t *value) {
   if (this->is_failed())
     return false;

esphome/components/micro_wake_word/__init__.py

@@ -448,9 +448,6 @@ async def to_code(config):
     # The inference task queues detection events that need immediate processing
     socket.require_wake_loop_threadsafe()
 
-    # Keep ring buffer functions in IRAM for audio performance
-    esp32.enable_ringbuf_in_iram()
-
     mic_source = await microphone.microphone_source_to_code(config[CONF_MICROPHONE])
     cg.add(var.set_microphone_source(mic_source))
 

esphome/components/select/select.h

@@ -80,21 +80,23 @@ class Select : public EntityBase {
 
   void add_on_state_callback(std::function<void(size_t)> &&callback);
 
-  /** Set the value of the select by index, this is an optional virtual method.
-   *
-   * This method is called by the SelectCall when the index is already known.
-   * Default implementation converts to string and calls control().
-   * Override this to work directly with indices and avoid string conversions.
-   *
-   * @param index The index as validated by the SelectCall.
-   */
-  virtual void control(size_t index) { this->control(this->option_at(index)); }
-
  protected:
   friend class SelectCall;
 
   size_t active_index_{0};
 
+  /** Set the value of the select by index, this is an optional virtual method.
+   *
+   * IMPORTANT: At least ONE of the two control() methods must be overridden by derived classes.
+   * Overriding this index-based version is PREFERRED as it avoids string conversions.
+   *
+   * This method is called by the SelectCall when the index is already known.
+   * Default implementation converts to string and calls control(const std::string&).
+   *
+   * @param index The index as validated by the SelectCall.
+   */
+  virtual void control(size_t index) { this->control(this->option_at(index)); }
+
   /** Set the value of the select, this is a virtual method that each select integration can implement.
    *
    * IMPORTANT: At least ONE of the two control() methods must be overridden by derived classes.

esphome/components/speed/fan/__init__.py

@@ -25,7 +25,7 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_SPEED): cv.invalid(
                 "Configuring individual speeds is deprecated."
             ),
-            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1, max=255),
+            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1),
             cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
         }
     )

esphome/components/speed/fan/speed_fan.h

@@ -10,7 +10,7 @@ namespace speed {
 
 class SpeedFan : public Component, public fan::Fan {
  public:
-  SpeedFan(uint8_t speed_count) : speed_count_(speed_count) {}
+  SpeedFan(int speed_count) : speed_count_(speed_count) {}
   void setup() override;
   void dump_config() override;
   void set_output(output::FloatOutput *output) { this->output_ = output; }
@@ -26,7 +26,7 @@ class SpeedFan : public Component, public fan::Fan {
   output::FloatOutput *output_;
   output::BinaryOutput *oscillating_{nullptr};
   output::BinaryOutput *direction_{nullptr};
-  uint8_t speed_count_{};
+  int speed_count_{};
   fan::FanTraits traits_;
   std::vector<const char *> preset_modes_{};
 };

esphome/components/template/fan/__init__.py

@@ -19,7 +19,7 @@ CONFIG_SCHEMA = (
         {
             cv.Optional(CONF_HAS_DIRECTION, default=False): cv.boolean,
             cv.Optional(CONF_HAS_OSCILLATING, default=False): cv.boolean,
-            cv.Optional(CONF_SPEED_COUNT): cv.int_range(min=1, max=255),
+            cv.Optional(CONF_SPEED_COUNT): cv.int_range(min=1),
             cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
         }
     )

esphome/components/template/fan/template_fan.h

@@ -12,7 +12,7 @@ class TemplateFan final : public Component, public fan::Fan {
   void dump_config() override;
   void set_has_direction(bool has_direction) { this->has_direction_ = has_direction; }
   void set_has_oscillating(bool has_oscillating) { this->has_oscillating_ = has_oscillating; }
-  void set_speed_count(uint8_t count) { this->speed_count_ = count; }
+  void set_speed_count(int count) { this->speed_count_ = count; }
   void set_preset_modes(std::initializer_list<const char *> presets) { this->preset_modes_ = presets; }
   fan::FanTraits get_traits() override { return this->traits_; }
 
@@ -21,7 +21,7 @@ class TemplateFan final : public Component, public fan::Fan {
 
   bool has_oscillating_{false};
   bool has_direction_{false};
-  uint8_t speed_count_{0};
+  int speed_count_{0};
   fan::FanTraits traits_;
   std::vector<const char *> preset_modes_{};
 };

esphome/components/tuya/fan/__init__.py

@@ -22,7 +22,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_SPEED_DATAPOINT): cv.uint8_t,
             cv.Optional(CONF_SWITCH_DATAPOINT): cv.uint8_t,
             cv.Optional(CONF_DIRECTION_DATAPOINT): cv.uint8_t,
-            cv.Optional(CONF_SPEED_COUNT, default=3): cv.int_range(min=1, max=255),
+            cv.Optional(CONF_SPEED_COUNT, default=3): cv.int_range(min=1, max=256),
         }
     )
     .extend(cv.COMPONENT_SCHEMA),

esphome/components/tuya/fan/tuya_fan.h

@@ -9,7 +9,7 @@ namespace tuya {
 
 class TuyaFan : public Component, public fan::Fan {
  public:
-  TuyaFan(Tuya *parent, uint8_t speed_count) : parent_(parent), speed_count_(speed_count) {}
+  TuyaFan(Tuya *parent, int speed_count) : parent_(parent), speed_count_(speed_count) {}
   void setup() override;
   void dump_config() override;
   void set_speed_id(uint8_t speed_id) { this->speed_id_ = speed_id; }
@@ -27,7 +27,7 @@ class TuyaFan : public Component, public fan::Fan {
   optional<uint8_t> switch_id_{};
   optional<uint8_t> oscillation_id_{};
   optional<uint8_t> direction_id_{};
-  uint8_t speed_count_{};
+  int speed_count_{};
   TuyaDatapointType speed_type_{};
   TuyaDatapointType oscillation_type_{};
 };

esphome/components/web_server_idf/web_server_idf.cpp

@@ -406,9 +406,8 @@ void AsyncWebServerResponse::addHeader(const char *name, const char *value) {
 void AsyncResponseStream::print(float value) {
   // Use stack buffer to avoid temporary string allocation
   // Size: sign (1) + digits (10) + decimal (1) + precision (6) + exponent (5) + null (1) = 24, use 32 for safety
-  constexpr size_t float_buf_size = 32;
-  char buf[float_buf_size];
-  int len = snprintf(buf, float_buf_size, "%f", value);
+  char buf[32];
+  int len = snprintf(buf, sizeof(buf), "%f", value);
   this->content_.append(buf, len);
 }
 

esphome/components/wifi/wifi_component.cpp

@@ -1735,7 +1735,6 @@ void WiFiComponent::log_and_adjust_priority_for_failed_connect_() {
         (old_priority > std::numeric_limits<int8_t>::min()) ? (old_priority - 1) : std::numeric_limits<int8_t>::min();
     this->set_sta_priority(failed_bssid.value(), new_priority);
   }
-
   char bssid_s[18];
   format_mac_addr_upper(failed_bssid.value().data(), bssid_s);
   ESP_LOGD(TAG, "Failed " LOG_SECRET("'%s'") " " LOG_SECRET("(%s)") ", priority %d → %d",

esphome/core/__init__.py

@@ -761,15 +761,6 @@ class EsphomeCore:
     def relative_piolibdeps_path(self, *path: str | Path) -> Path:
         return self.relative_build_path(".piolibdeps", *path)
 
-    @property
-    def platformio_cache_dir(self) -> str:
-        """Get the PlatformIO cache directory path."""
-        # Check if running in Docker/HA addon with custom cache dir
-        if (cache_dir := os.environ.get("PLATFORMIO_CACHE_DIR")) and cache_dir.strip():
-            return cache_dir
-        # Default PlatformIO cache location
-        return os.path.expanduser("~/.platformio/.cache")
-
     @property
     def firmware_bin(self) -> Path:
         if self.is_libretiny:

esphome/core/base_automation.h

@@ -191,15 +191,15 @@ template<typename... Ts> class DelayAction : public Action<Ts...>, public Compon
     // instead of std::bind to avoid bind overhead (~16 bytes heap + faster execution)
     if constexpr (sizeof...(Ts) == 0) {
       App.scheduler.set_timer_common_(
-          this, Scheduler::SchedulerItem::TIMEOUT, Scheduler::NameType::STATIC_STRING, "delay", 0, this->delay_.value(),
-          [this]() { this->play_next_(); },
+          this, Scheduler::SchedulerItem::TIMEOUT,
+          /* is_static_string= */ true, "delay", this->delay_.value(), [this]() { this->play_next_(); },
           /* is_retry= */ false, /* skip_cancel= */ this->num_running_ > 1);
     } else {
       // For delays with arguments, use std::bind to preserve argument values
       // Arguments must be copied because original references may be invalid after delay
       auto f = std::bind(&DelayAction<Ts...>::play_next_, this, x...);
-      App.scheduler.set_timer_common_(this, Scheduler::SchedulerItem::TIMEOUT, Scheduler::NameType::STATIC_STRING,
-                                      "delay", 0, this->delay_.value(x...), std::move(f),
+      App.scheduler.set_timer_common_(this, Scheduler::SchedulerItem::TIMEOUT,
+                                      /* is_static_string= */ true, "delay", this->delay_.value(x...), std::move(f),
                                       /* is_retry= */ false, /* skip_cancel= */ this->num_running_ > 1);
     }
   }

esphome/core/component.cpp

@@ -118,10 +118,7 @@ void Component::setup() {}
 void Component::loop() {}
 
 void Component::set_interval(const std::string &name, uint32_t interval, std::function<void()> &&f) {  // NOLINT
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   App.scheduler.set_interval(this, name, interval, std::move(f));
-#pragma GCC diagnostic pop
 }
 
 void Component::set_interval(const char *name, uint32_t interval, std::function<void()> &&f) {  // NOLINT
@@ -129,10 +126,7 @@ void Component::set_interval(const char *name, uint32_t interval, std::function<
 }
 
 bool Component::cancel_interval(const std::string &name) {  // NOLINT
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   return App.scheduler.cancel_interval(this, name);
-#pragma GCC diagnostic pop
 }
 
 bool Component::cancel_interval(const char *name) {  // NOLINT
@@ -141,10 +135,7 @@ bool Component::cancel_interval(const char *name) {  // NOLINT
 
 void Component::set_retry(const std::string &name, uint32_t initial_wait_time, uint8_t max_attempts,
                           std::function<RetryResult(uint8_t)> &&f, float backoff_increase_factor) {  // NOLINT
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   App.scheduler.set_retry(this, name, initial_wait_time, max_attempts, std::move(f), backoff_increase_factor);
-#pragma GCC diagnostic pop
 }
 
 void Component::set_retry(const char *name, uint32_t initial_wait_time, uint8_t max_attempts,
@@ -153,10 +144,7 @@ void Component::set_retry(const char *name, uint32_t initial_wait_time, uint8_t
 }
 
 bool Component::cancel_retry(const std::string &name) {  // NOLINT
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   return App.scheduler.cancel_retry(this, name);
-#pragma GCC diagnostic pop
 }
 
 bool Component::cancel_retry(const char *name) {  // NOLINT
@@ -164,10 +152,7 @@ bool Component::cancel_retry(const char *name) {  // NOLINT
 }
 
 void Component::set_timeout(const std::string &name, uint32_t timeout, std::function<void()> &&f) {  // NOLINT
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   App.scheduler.set_timeout(this, name, timeout, std::move(f));
-#pragma GCC diagnostic pop
 }
 
 void Component::set_timeout(const char *name, uint32_t timeout, std::function<void()> &&f) {  // NOLINT
@@ -175,36 +160,13 @@ void Component::set_timeout(const char *name, uint32_t timeout, std::function<vo
 }
 
 bool Component::cancel_timeout(const std::string &name) {  // NOLINT
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   return App.scheduler.cancel_timeout(this, name);
-#pragma GCC diagnostic pop
 }
 
 bool Component::cancel_timeout(const char *name) {  // NOLINT
   return App.scheduler.cancel_timeout(this, name);
 }
 
-// uint32_t (numeric ID) overloads - zero heap allocation
-void Component::set_timeout(uint32_t id, uint32_t timeout, std::function<void()> &&f) {  // NOLINT
-  App.scheduler.set_timeout(this, id, timeout, std::move(f));
-}
-
-bool Component::cancel_timeout(uint32_t id) { return App.scheduler.cancel_timeout(this, id); }
-
-void Component::set_interval(uint32_t id, uint32_t interval, std::function<void()> &&f) {  // NOLINT
-  App.scheduler.set_interval(this, id, interval, std::move(f));
-}
-
-bool Component::cancel_interval(uint32_t id) { return App.scheduler.cancel_interval(this, id); }
-
-void Component::set_retry(uint32_t id, uint32_t initial_wait_time, uint8_t max_attempts,
-                          std::function<RetryResult(uint8_t)> &&f, float backoff_increase_factor) {  // NOLINT
-  App.scheduler.set_retry(this, id, initial_wait_time, max_attempts, std::move(f), backoff_increase_factor);
-}
-
-bool Component::cancel_retry(uint32_t id) { return App.scheduler.cancel_retry(this, id); }
-
 void Component::call_loop() { this->loop(); }
 void Component::call_setup() { this->setup(); }
 void Component::call_dump_config() {
@@ -339,19 +301,10 @@ void Component::defer(std::function<void()> &&f) {  // NOLINT
   App.scheduler.set_timeout(this, static_cast<const char *>(nullptr), 0, std::move(f));
 }
 bool Component::cancel_defer(const std::string &name) {  // NOLINT
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-  return App.scheduler.cancel_timeout(this, name);
-#pragma GCC diagnostic pop
-}
-bool Component::cancel_defer(const char *name) {  // NOLINT
   return App.scheduler.cancel_timeout(this, name);
 }
 void Component::defer(const std::string &name, std::function<void()> &&f) {  // NOLINT
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   App.scheduler.set_timeout(this, name, 0, std::move(f));
-#pragma GCC diagnostic pop
 }
 void Component::defer(const char *name, std::function<void()> &&f) {  // NOLINT
   App.scheduler.set_timeout(this, name, 0, std::move(f));

esphome/core/component.h

@@ -306,8 +306,6 @@ class Component {
    *
    * @see cancel_interval()
    */
-  // Remove before 2026.7.0
-  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   void set_interval(const std::string &name, uint32_t interval, std::function<void()> &&f);  // NOLINT
 
   /** Set an interval function with a const char* name.
@@ -326,14 +324,6 @@ class Component {
    */
   void set_interval(const char *name, uint32_t interval, std::function<void()> &&f);  // NOLINT
 
-  /** Set an interval function with a numeric ID (zero heap allocation).
-   *
-   * @param id The numeric identifier for this interval function
-   * @param interval The interval in ms
-   * @param f The function to call
-   */
-  void set_interval(uint32_t id, uint32_t interval, std::function<void()> &&f);  // NOLINT
-
   void set_interval(uint32_t interval, std::function<void()> &&f);  // NOLINT
 
   /** Cancel an interval function.
@@ -341,11 +331,8 @@ class Component {
    * @param name The identifier for this interval function.
    * @return Whether an interval functions was deleted.
    */
-  // Remove before 2026.7.0
-  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   bool cancel_interval(const std::string &name);  // NOLINT
   bool cancel_interval(const char *name);         // NOLINT
-  bool cancel_interval(uint32_t id);              // NOLINT
 
   /** Set an retry function with a unique name. Empty name means no cancelling possible.
    *
@@ -377,25 +364,12 @@ class Component {
    * @param backoff_increase_factor time between retries is multiplied by this factor on every retry after the first
    * @see cancel_retry()
    */
-  // Remove before 2026.7.0
-  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   void set_retry(const std::string &name, uint32_t initial_wait_time, uint8_t max_attempts,       // NOLINT
                  std::function<RetryResult(uint8_t)> &&f, float backoff_increase_factor = 1.0f);  // NOLINT
 
   void set_retry(const char *name, uint32_t initial_wait_time, uint8_t max_attempts,              // NOLINT
                  std::function<RetryResult(uint8_t)> &&f, float backoff_increase_factor = 1.0f);  // NOLINT
 
-  /** Set a retry function with a numeric ID (zero heap allocation).
-   *
-   * @param id The numeric identifier for this retry function
-   * @param initial_wait_time The wait time after the first execution
-   * @param max_attempts The max number of attempts
-   * @param f The function to call
-   * @param backoff_increase_factor The factor to increase the retry interval by
-   */
-  void set_retry(uint32_t id, uint32_t initial_wait_time, uint8_t max_attempts,                   // NOLINT
-                 std::function<RetryResult(uint8_t)> &&f, float backoff_increase_factor = 1.0f);  // NOLINT
-
   void set_retry(uint32_t initial_wait_time, uint8_t max_attempts, std::function<RetryResult(uint8_t)> &&f,  // NOLINT
                  float backoff_increase_factor = 1.0f);                                                      // NOLINT
 
@@ -404,11 +378,8 @@ class Component {
    * @param name The identifier for this retry function.
    * @return Whether a retry function was deleted.
    */
-  // Remove before 2026.7.0
-  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   bool cancel_retry(const std::string &name);  // NOLINT
   bool cancel_retry(const char *name);         // NOLINT
-  bool cancel_retry(uint32_t id);              // NOLINT
 
   /** Set a timeout function with a unique name.
    *
@@ -424,8 +395,6 @@ class Component {
    *
    * @see cancel_timeout()
    */
-  // Remove before 2026.7.0
-  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   void set_timeout(const std::string &name, uint32_t timeout, std::function<void()> &&f);  // NOLINT
 
   /** Set a timeout function with a const char* name.
@@ -444,14 +413,6 @@ class Component {
    */
   void set_timeout(const char *name, uint32_t timeout, std::function<void()> &&f);  // NOLINT
 
-  /** Set a timeout function with a numeric ID (zero heap allocation).
-   *
-   * @param id The numeric identifier for this timeout function
-   * @param timeout The timeout in ms
-   * @param f The function to call
-   */
-  void set_timeout(uint32_t id, uint32_t timeout, std::function<void()> &&f);  // NOLINT
-
   void set_timeout(uint32_t timeout, std::function<void()> &&f);  // NOLINT
 
   /** Cancel a timeout function.
@@ -459,11 +420,8 @@ class Component {
    * @param name The identifier for this timeout function.
    * @return Whether a timeout functions was deleted.
    */
-  // Remove before 2026.7.0
-  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   bool cancel_timeout(const std::string &name);  // NOLINT
   bool cancel_timeout(const char *name);         // NOLINT
-  bool cancel_timeout(uint32_t id);              // NOLINT
 
   /** Defer a callback to the next loop() call.
    *
@@ -472,8 +430,6 @@ class Component {
    * @param name The name of the defer function.
    * @param f The callback.
    */
-  // Remove before 2026.7.0
-  ESPDEPRECATED("Use const char* overload instead. Removed in 2026.7.0", "2026.1.0")
   void defer(const std::string &name, std::function<void()> &&f);  // NOLINT
 
   /** Defer a callback to the next loop() call with a const char* name.
@@ -495,10 +451,7 @@ class Component {
   void defer(std::function<void()> &&f);  // NOLINT
 
   /// Cancel a defer callback using the specified name, name must not be empty.
-  // Remove before 2026.7.0
-  ESPDEPRECATED("Use const char* overload instead. Removed in 2026.7.0", "2026.1.0")
   bool cancel_defer(const std::string &name);  // NOLINT
-  bool cancel_defer(const char *name);         // NOLINT
 
   // Ordered for optimal packing on 32-bit systems
   const LogString *component_source_{nullptr};

esphome/core/helpers.cpp

@@ -329,10 +329,7 @@ std::string format_hex(const uint8_t *data, size_t length) {
   format_hex_to(&ret[0], length * 2 + 1, data, length);
   return ret;
 }
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 std::string format_hex(const std::vector<uint8_t> &data) { return format_hex(data.data(), data.size()); }
-#pragma GCC diagnostic pop
 
 char *format_hex_pretty_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length, char separator) {
   return format_hex_internal(buffer, buffer_size, data, length, separator, 'A');
@@ -485,8 +482,10 @@ int8_t step_to_accuracy_decimals(float step) {
   return str.length() - dot_pos - 1;
 }
 
-// Store BASE64 characters as array - automatically placed in flash/ROM on embedded platforms
-static const char BASE64_CHARS[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+// Use C-style string constant to store in ROM instead of RAM (saves 24 bytes)
+static constexpr const char *BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                            "abcdefghijklmnopqrstuvwxyz"
+                                            "0123456789+/";
 
 // Helper function to find the index of a base64 character in the lookup table.
 // Returns the character's position (0-63) if found, or 0 if not found.
@@ -496,8 +495,8 @@ static const char BASE64_CHARS[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqr
 // stops processing at the first invalid character due to the is_base64() check in its
 // while loop condition, making this edge case harmless in practice.
 static inline uint8_t base64_find_char(char c) {
-  const void *ptr = memchr(BASE64_CHARS, c, sizeof(BASE64_CHARS));
-  return ptr ? (static_cast<const char *>(ptr) - BASE64_CHARS) : 0;
+  const char *pos = strchr(BASE64_CHARS, c);
+  return pos ? (pos - BASE64_CHARS) : 0;
 }
 
 static inline bool is_base64(char c) { return (isalnum(c) || (c == '+') || (c == '/')); }

esphome/core/helpers.h

@@ -162,9 +162,6 @@ template<typename T, size_t N> class StaticVector {
   size_t size() const { return count_; }
   bool empty() const { return count_ == 0; }
 
-  // Direct access to size counter for efficient in-place construction
-  size_t &count() { return count_; }
-
   // Direct access to underlying data
   T *data() { return data_.data(); }
   const T *data() const { return data_.data(); }
@@ -394,15 +391,6 @@ constexpr uint32_t FNV1_OFFSET_BASIS = 2166136261UL;
 /// FNV-1 32-bit prime
 constexpr uint32_t FNV1_PRIME = 16777619UL;
 
-/// Extend a FNV-1 hash with an integer (hashes each byte).
-template<std::integral T> constexpr uint32_t fnv1_hash_extend(uint32_t hash, T value) {
-  for (size_t i = 0; i < sizeof(T); i++) {
-    hash *= FNV1_PRIME;
-    hash ^= (value >> (i * 8)) & 0xFF;
-  }
-  return hash;
-}
-
 /// Extend a FNV-1a hash with additional string data.
 constexpr uint32_t fnv1a_hash_extend(uint32_t hash, const char *str) {
   if (str) {
@@ -903,17 +891,13 @@ std::string format_hex(const std::vector<uint8_t> &data);
 /// Causes heap fragmentation on long-running devices.
 template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> std::string format_hex(T val) {
   val = convert_big_endian(val);
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   return format_hex(reinterpret_cast<uint8_t *>(&val), sizeof(T));
-#pragma GCC diagnostic pop
 }
 /// Format the std::array \p data in lowercased hex.
 /// @warning Allocates heap memory. Use format_hex_to() with a stack buffer instead.
 /// Causes heap fragmentation on long-running devices.
 template<std::size_t N> std::string format_hex(const std::array<uint8_t, N> &data) {
   return format_hex(data.data(), data.size());
-#pragma GCC diagnostic pop
 }
 
 /** Format a byte array in pretty-printed, human-readable hex format.

esphome/core/progmem.h

@@ -8,15 +8,11 @@
 // ESP8266 uses Arduino macros
 #define ESPHOME_F(string_literal) F(string_literal)
 #define ESPHOME_PGM_P PGM_P
-#define ESPHOME_PSTR(s) PSTR(s)
 #define ESPHOME_strncpy_P strncpy_P
 #define ESPHOME_strncat_P strncat_P
-#define ESPHOME_snprintf_P snprintf_P
 #else
 #define ESPHOME_F(string_literal) (string_literal)
 #define ESPHOME_PGM_P const char *
-#define ESPHOME_PSTR(s) (s)
 #define ESPHOME_strncpy_P strncpy
 #define ESPHOME_strncat_P strncat
-#define ESPHOME_snprintf_P snprintf
 #endif

esphome/core/scheduler.cpp

@@ -5,7 +5,6 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 #include <algorithm>
 #include <cinttypes>
 #include <cstring>
@@ -33,34 +32,6 @@ static constexpr uint32_t HALF_MAX_UINT32 = std::numeric_limits<uint32_t>::max()
 // max delay to start an interval sequence
 static constexpr uint32_t MAX_INTERVAL_DELAY = 5000;
 
-#if defined(ESPHOME_LOG_HAS_VERBOSE) || defined(ESPHOME_DEBUG_SCHEDULER)
-// Helper struct for formatting scheduler item names consistently in logs
-// Uses a stack buffer to avoid heap allocation
-// Uses ESPHOME_snprintf_P/ESPHOME_PSTR for ESP8266 to keep format strings in flash
-struct SchedulerNameLog {
-  char buffer[20];  // Enough for "id:4294967295" or "hash:0xFFFFFFFF" or "(null)"
-
-  // Format a scheduler item name for logging
-  // Returns pointer to formatted string (either static_name or internal buffer)
-  const char *format(Scheduler::NameType name_type, const char *static_name, uint32_t hash_or_id) {
-    using NameType = Scheduler::NameType;
-    if (name_type == NameType::STATIC_STRING) {
-      if (static_name)
-        return static_name;
-      // Copy "(null)" to buffer to keep it in flash on ESP8266
-      ESPHOME_strncpy_P(buffer, ESPHOME_PSTR("(null)"), sizeof(buffer));
-      return buffer;
-    } else if (name_type == NameType::HASHED_STRING) {
-      ESPHOME_snprintf_P(buffer, sizeof(buffer), ESPHOME_PSTR("hash:0x%08" PRIX32), hash_or_id);
-      return buffer;
-    } else {  // NUMERIC_ID
-      ESPHOME_snprintf_P(buffer, sizeof(buffer), ESPHOME_PSTR("id:%" PRIu32), hash_or_id);
-      return buffer;
-    }
-  }
-};
-#endif
-
 // Uncomment to debug scheduler
 // #define ESPHOME_DEBUG_SCHEDULER
 
@@ -105,15 +76,17 @@ static void validate_static_string(const char *name) {
 // avoid the main thread modifying the list while it is being accessed.
 
 // Common implementation for both timeout and interval
-// name_type determines storage type: STATIC_STRING uses static_name, others use hash_or_id
-void HOT Scheduler::set_timer_common_(Component *component, SchedulerItem::Type type, NameType name_type,
-                                      const char *static_name, uint32_t hash_or_id, uint32_t delay,
-                                      std::function<void()> func, bool is_retry, bool skip_cancel) {
+void HOT Scheduler::set_timer_common_(Component *component, SchedulerItem::Type type, bool is_static_string,
+                                      const void *name_ptr, uint32_t delay, std::function<void()> func, bool is_retry,
+                                      bool skip_cancel) {
+  // Get the name as const char*
+  const char *name_cstr = this->get_name_cstr_(is_static_string, name_ptr);
+
   if (delay == SCHEDULER_DONT_RUN) {
-    // Still need to cancel existing timer if we have a name/id
+    // Still need to cancel existing timer if name is not empty
     if (!skip_cancel) {
       LockGuard guard{this->lock_};
-      this->cancel_item_locked_(component, name_type, static_name, hash_or_id, type);
+      this->cancel_item_locked_(component, name_cstr, type);
     }
     return;
   }
@@ -125,19 +98,23 @@ void HOT Scheduler::set_timer_common_(Component *component, SchedulerItem::Type
   LockGuard guard{this->lock_};
 
   // Create and populate the scheduler item
-  auto item = this->get_item_from_pool_locked_();
-  item->component = component;
-  switch (name_type) {
-    case NameType::STATIC_STRING:
-      item->set_static_name(static_name);
-      break;
-    case NameType::HASHED_STRING:
-      item->set_hashed_name(hash_or_id);
-      break;
-    case NameType::NUMERIC_ID:
-      item->set_numeric_id(hash_or_id);
-      break;
+  std::unique_ptr<SchedulerItem> item;
+  if (!this->scheduler_item_pool_.empty()) {
+    // Reuse from pool
+    item = std::move(this->scheduler_item_pool_.back());
+    this->scheduler_item_pool_.pop_back();
+#ifdef ESPHOME_DEBUG_SCHEDULER
+    ESP_LOGD(TAG, "Reused item from pool (pool size now: %zu)", this->scheduler_item_pool_.size());
+#endif
+  } else {
+    // Allocate new if pool is empty
+    item = make_unique<SchedulerItem>();
+#ifdef ESPHOME_DEBUG_SCHEDULER
+    ESP_LOGD(TAG, "Allocated new item (pool empty)");
+#endif
   }
+  item->component = component;
+  item->set_name(name_cstr, !is_static_string);
   item->type = type;
   item->callback = std::move(func);
   // Reset remove flag - recycled items may have been cancelled (remove=true) in previous use
@@ -150,7 +127,7 @@ void HOT Scheduler::set_timer_common_(Component *component, SchedulerItem::Type
   if (delay == 0 && type == SchedulerItem::TIMEOUT) {
     // Put in defer queue for guaranteed FIFO execution
     if (!skip_cancel) {
-      this->cancel_item_locked_(component, name_type, static_name, hash_or_id, type);
+      this->cancel_item_locked_(component, name_cstr, type);
     }
     this->defer_queue_.push_back(std::move(item));
     return;
@@ -164,32 +141,24 @@ void HOT Scheduler::set_timer_common_(Component *component, SchedulerItem::Type
     // Calculate random offset (0 to min(interval/2, 5s))
     uint32_t offset = (uint32_t) (std::min(delay / 2, MAX_INTERVAL_DELAY) * random_float());
     item->set_next_execution(now + offset);
-#ifdef ESPHOME_LOG_HAS_VERBOSE
-    SchedulerNameLog name_log;
-    ESP_LOGV(TAG, "Scheduler interval for %s is %" PRIu32 "ms, offset %" PRIu32 "ms",
-             name_log.format(name_type, static_name, hash_or_id), delay, offset);
-#endif
+    ESP_LOGV(TAG, "Scheduler interval for %s is %" PRIu32 "ms, offset %" PRIu32 "ms", name_cstr ? name_cstr : "", delay,
+             offset);
   } else {
     item->interval = 0;
     item->set_next_execution(now + delay);
   }
 
 #ifdef ESPHOME_DEBUG_SCHEDULER
-  this->debug_log_timer_(item.get(), name_type, static_name, hash_or_id, type, delay, now);
+  this->debug_log_timer_(item.get(), is_static_string, name_cstr, type, delay, now);
 #endif /* ESPHOME_DEBUG_SCHEDULER */
 
   // For retries, check if there's a cancelled timeout first
-  // Skip check for anonymous retries (STATIC_STRING with nullptr) - they can't be cancelled by name
-  if (is_retry && (name_type != NameType::STATIC_STRING || static_name != nullptr) && type == SchedulerItem::TIMEOUT &&
-      (has_cancelled_timeout_in_container_locked_(this->items_, component, name_type, static_name, hash_or_id,
-                                                  /* match_retry= */ true) ||
-       has_cancelled_timeout_in_container_locked_(this->to_add_, component, name_type, static_name, hash_or_id,
-                                                  /* match_retry= */ true))) {
+  if (is_retry && name_cstr != nullptr && type == SchedulerItem::TIMEOUT &&
+      (has_cancelled_timeout_in_container_locked_(this->items_, component, name_cstr, /* match_retry= */ true) ||
+       has_cancelled_timeout_in_container_locked_(this->to_add_, component, name_cstr, /* match_retry= */ true))) {
     // Skip scheduling - the retry was cancelled
 #ifdef ESPHOME_DEBUG_SCHEDULER
-    SchedulerNameLog skip_name_log;
-    ESP_LOGD(TAG, "Skipping retry '%s' - found cancelled item",
-             skip_name_log.format(name_type, static_name, hash_or_id));
+    ESP_LOGD(TAG, "Skipping retry '%s' - found cancelled item", name_cstr);
 #endif
     return;
   }
@@ -197,7 +166,7 @@ void HOT Scheduler::set_timer_common_(Component *component, SchedulerItem::Type
   // If name is provided, do atomic cancel-and-add (unless skip_cancel is true)
   // Cancel existing items
   if (!skip_cancel) {
-    this->cancel_item_locked_(component, name_type, static_name, hash_or_id, type);
+    this->cancel_item_locked_(component, name_cstr, type);
   }
   // Add new item directly to to_add_
   // since we have the lock held
@@ -205,51 +174,33 @@ void HOT Scheduler::set_timer_common_(Component *component, SchedulerItem::Type
 }
 
 void HOT Scheduler::set_timeout(Component *component, const char *name, uint32_t timeout, std::function<void()> func) {
-  this->set_timer_common_(component, SchedulerItem::TIMEOUT, NameType::STATIC_STRING, name, 0, timeout,
-                          std::move(func));
+  this->set_timer_common_(component, SchedulerItem::TIMEOUT, true, name, timeout, std::move(func));
 }
 
 void HOT Scheduler::set_timeout(Component *component, const std::string &name, uint32_t timeout,
                                 std::function<void()> func) {
-  this->set_timer_common_(component, SchedulerItem::TIMEOUT, NameType::HASHED_STRING, nullptr, fnv1a_hash(name),
-                          timeout, std::move(func));
-}
-void HOT Scheduler::set_timeout(Component *component, uint32_t id, uint32_t timeout, std::function<void()> func) {
-  this->set_timer_common_(component, SchedulerItem::TIMEOUT, NameType::NUMERIC_ID, nullptr, id, timeout,
-                          std::move(func));
+  this->set_timer_common_(component, SchedulerItem::TIMEOUT, false, &name, timeout, std::move(func));
 }
 bool HOT Scheduler::cancel_timeout(Component *component, const std::string &name) {
-  return this->cancel_item_(component, NameType::HASHED_STRING, nullptr, fnv1a_hash(name), SchedulerItem::TIMEOUT);
+  return this->cancel_item_(component, false, &name, SchedulerItem::TIMEOUT);
 }
 bool HOT Scheduler::cancel_timeout(Component *component, const char *name) {
-  return this->cancel_item_(component, NameType::STATIC_STRING, name, 0, SchedulerItem::TIMEOUT);
-}
-bool HOT Scheduler::cancel_timeout(Component *component, uint32_t id) {
-  return this->cancel_item_(component, NameType::NUMERIC_ID, nullptr, id, SchedulerItem::TIMEOUT);
+  return this->cancel_item_(component, true, name, SchedulerItem::TIMEOUT);
 }
 void HOT Scheduler::set_interval(Component *component, const std::string &name, uint32_t interval,
                                  std::function<void()> func) {
-  this->set_timer_common_(component, SchedulerItem::INTERVAL, NameType::HASHED_STRING, nullptr, fnv1a_hash(name),
-                          interval, std::move(func));
+  this->set_timer_common_(component, SchedulerItem::INTERVAL, false, &name, interval, std::move(func));
 }
 
 void HOT Scheduler::set_interval(Component *component, const char *name, uint32_t interval,
                                  std::function<void()> func) {
-  this->set_timer_common_(component, SchedulerItem::INTERVAL, NameType::STATIC_STRING, name, 0, interval,
-                          std::move(func));
-}
-void HOT Scheduler::set_interval(Component *component, uint32_t id, uint32_t interval, std::function<void()> func) {
-  this->set_timer_common_(component, SchedulerItem::INTERVAL, NameType::NUMERIC_ID, nullptr, id, interval,
-                          std::move(func));
+  this->set_timer_common_(component, SchedulerItem::INTERVAL, true, name, interval, std::move(func));
 }
 bool HOT Scheduler::cancel_interval(Component *component, const std::string &name) {
-  return this->cancel_item_(component, NameType::HASHED_STRING, nullptr, fnv1a_hash(name), SchedulerItem::INTERVAL);
+  return this->cancel_item_(component, false, &name, SchedulerItem::INTERVAL);
 }
 bool HOT Scheduler::cancel_interval(Component *component, const char *name) {
-  return this->cancel_item_(component, NameType::STATIC_STRING, name, 0, SchedulerItem::INTERVAL);
-}
-bool HOT Scheduler::cancel_interval(Component *component, uint32_t id) {
-  return this->cancel_item_(component, NameType::NUMERIC_ID, nullptr, id, SchedulerItem::INTERVAL);
+  return this->cancel_item_(component, true, name, SchedulerItem::INTERVAL);
 }
 
 struct RetryArgs {
@@ -257,15 +208,17 @@ struct RetryArgs {
   std::function<RetryResult(uint8_t)> func;
   Component *component;
   Scheduler *scheduler;
-  // Union for name storage - only one is used based on name_type
-  union {
-    const char *static_name;  // For STATIC_STRING
-    uint32_t hash_or_id;      // For HASHED_STRING or NUMERIC_ID
-  } name_;
+  const char *name;  // Points to static string or owned copy
   uint32_t current_interval;
   float backoff_increase_factor;
-  Scheduler::NameType name_type;  // Discriminator for name_ union
   uint8_t retry_countdown;
+  bool name_is_dynamic;  // True if name needs delete[]
+
+  ~RetryArgs() {
+    if (this->name_is_dynamic && this->name) {
+      delete[] this->name;
+    }
+  }
 };
 
 void retry_handler(const std::shared_ptr<RetryArgs> &args) {
@@ -273,38 +226,31 @@ void retry_handler(const std::shared_ptr<RetryArgs> &args) {
   if (retry_result == RetryResult::DONE || args->retry_countdown <= 0)
     return;
   // second execution of `func` happens after `initial_wait_time`
-  // args->name_ is owned by the shared_ptr<RetryArgs>
+  // Pass is_static_string=true because args->name is owned by the shared_ptr<RetryArgs>
   // which is captured in the lambda and outlives the SchedulerItem
-  const char *static_name = (args->name_type == Scheduler::NameType::STATIC_STRING) ? args->name_.static_name : nullptr;
-  uint32_t hash_or_id = (args->name_type != Scheduler::NameType::STATIC_STRING) ? args->name_.hash_or_id : 0;
   args->scheduler->set_timer_common_(
-      args->component, Scheduler::SchedulerItem::TIMEOUT, args->name_type, static_name, hash_or_id,
-      args->current_interval, [args]() { retry_handler(args); },
-      /* is_retry= */ true);
+      args->component, Scheduler::SchedulerItem::TIMEOUT, true, args->name, args->current_interval,
+      [args]() { retry_handler(args); }, /* is_retry= */ true);
   // backoff_increase_factor applied to third & later executions
   args->current_interval *= args->backoff_increase_factor;
 }
 
-void HOT Scheduler::set_retry_common_(Component *component, NameType name_type, const char *static_name,
-                                      uint32_t hash_or_id, uint32_t initial_wait_time, uint8_t max_attempts,
+void HOT Scheduler::set_retry_common_(Component *component, bool is_static_string, const void *name_ptr,
+                                      uint32_t initial_wait_time, uint8_t max_attempts,
                                       std::function<RetryResult(uint8_t)> func, float backoff_increase_factor) {
-  this->cancel_retry_(component, name_type, static_name, hash_or_id);
+  const char *name_cstr = this->get_name_cstr_(is_static_string, name_ptr);
+
+  if (name_cstr != nullptr)
+    this->cancel_retry(component, name_cstr);
 
   if (initial_wait_time == SCHEDULER_DONT_RUN)
     return;
 
-#ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
-  {
-    SchedulerNameLog name_log;
-    ESP_LOGVV(TAG, "set_retry(name='%s', initial_wait_time=%" PRIu32 ", max_attempts=%u, backoff_factor=%0.1f)",
-              name_log.format(name_type, static_name, hash_or_id), initial_wait_time, max_attempts,
-              backoff_increase_factor);
-  }
-#endif
+  ESP_LOGVV(TAG, "set_retry(name='%s', initial_wait_time=%" PRIu32 ", max_attempts=%u, backoff_factor=%0.1f)",
+            name_cstr ? name_cstr : "", initial_wait_time, max_attempts, backoff_increase_factor);
 
   if (backoff_increase_factor < 0.0001) {
-    ESP_LOGE(TAG, "set_retry: backoff_factor %0.1f too small, using 1.0: %s", backoff_increase_factor,
-             (name_type == NameType::STATIC_STRING && static_name) ? static_name : "");
+    ESP_LOGE(TAG, "backoff_factor %0.1f too small, using 1.0: %s", backoff_increase_factor, name_cstr ? name_cstr : "");
     backoff_increase_factor = 1;
   }
 
@@ -312,56 +258,56 @@ void HOT Scheduler::set_retry_common_(Component *component, NameType name_type,
   args->func = std::move(func);
   args->component = component;
   args->scheduler = this;
-  args->name_type = name_type;
-  if (name_type == NameType::STATIC_STRING) {
-    args->name_.static_name = static_name;
-  } else {
-    args->name_.hash_or_id = hash_or_id;
-  }
   args->current_interval = initial_wait_time;
   args->backoff_increase_factor = backoff_increase_factor;
   args->retry_countdown = max_attempts;
 
+  // Store name - either as static pointer or owned copy
+  if (name_cstr == nullptr || name_cstr[0] == '\0') {
+    // Empty or null name - use empty string literal
+    args->name = "";
+    args->name_is_dynamic = false;
+  } else if (is_static_string) {
+    // Static string - just store the pointer
+    args->name = name_cstr;
+    args->name_is_dynamic = false;
+  } else {
+    // Dynamic string - make a copy
+    size_t len = strlen(name_cstr);
+    char *copy = new char[len + 1];
+    memcpy(copy, name_cstr, len + 1);
+    args->name = copy;
+    args->name_is_dynamic = true;
+  }
+
   // First execution of `func` immediately - use set_timer_common_ with is_retry=true
+  // Pass is_static_string=true because args->name is owned by the shared_ptr<RetryArgs>
+  // which is captured in the lambda and outlives the SchedulerItem
   this->set_timer_common_(
-      component, SchedulerItem::TIMEOUT, name_type, static_name, hash_or_id, 0, [args]() { retry_handler(args); },
+      component, SchedulerItem::TIMEOUT, true, args->name, 0, [args]() { retry_handler(args); },
       /* is_retry= */ true);
 }
 
-void HOT Scheduler::set_retry(Component *component, const char *name, uint32_t initial_wait_time, uint8_t max_attempts,
-                              std::function<RetryResult(uint8_t)> func, float backoff_increase_factor) {
-  this->set_retry_common_(component, NameType::STATIC_STRING, name, 0, initial_wait_time, max_attempts, std::move(func),
-                          backoff_increase_factor);
-}
-
-bool HOT Scheduler::cancel_retry_(Component *component, NameType name_type, const char *static_name,
-                                  uint32_t hash_or_id) {
-  return this->cancel_item_(component, name_type, static_name, hash_or_id, SchedulerItem::TIMEOUT,
-                            /* match_retry= */ true);
-}
-bool HOT Scheduler::cancel_retry(Component *component, const char *name) {
-  return this->cancel_retry_(component, NameType::STATIC_STRING, name, 0);
-}
-
 void HOT Scheduler::set_retry(Component *component, const std::string &name, uint32_t initial_wait_time,
                               uint8_t max_attempts, std::function<RetryResult(uint8_t)> func,
                               float backoff_increase_factor) {
-  this->set_retry_common_(component, NameType::HASHED_STRING, nullptr, fnv1a_hash(name), initial_wait_time,
-                          max_attempts, std::move(func), backoff_increase_factor);
+  this->set_retry_common_(component, false, &name, initial_wait_time, max_attempts, std::move(func),
+                          backoff_increase_factor);
 }
 
-bool HOT Scheduler::cancel_retry(Component *component, const std::string &name) {
-  return this->cancel_retry_(component, NameType::HASHED_STRING, nullptr, fnv1a_hash(name));
-}
-
-void HOT Scheduler::set_retry(Component *component, uint32_t id, uint32_t initial_wait_time, uint8_t max_attempts,
+void HOT Scheduler::set_retry(Component *component, const char *name, uint32_t initial_wait_time, uint8_t max_attempts,
                               std::function<RetryResult(uint8_t)> func, float backoff_increase_factor) {
-  this->set_retry_common_(component, NameType::NUMERIC_ID, nullptr, id, initial_wait_time, max_attempts,
-                          std::move(func), backoff_increase_factor);
+  this->set_retry_common_(component, true, name, initial_wait_time, max_attempts, std::move(func),
+                          backoff_increase_factor);
+}
+bool HOT Scheduler::cancel_retry(Component *component, const std::string &name) {
+  return this->cancel_retry(component, name.c_str());
 }
 
-bool HOT Scheduler::cancel_retry(Component *component, uint32_t id) {
-  return this->cancel_retry_(component, NameType::NUMERIC_ID, nullptr, id);
+bool HOT Scheduler::cancel_retry(Component *component, const char *name) {
+  // Cancel timeouts that have is_retry flag set
+  LockGuard guard{this->lock_};
+  return this->cancel_item_locked_(component, name, SchedulerItem::TIMEOUT, /* match_retry= */ true);
 }
 
 optional<uint32_t> HOT Scheduler::next_schedule_in(uint32_t now) {
@@ -445,11 +391,10 @@ void HOT Scheduler::call(uint32_t now) {
         item = this->pop_raw_locked_();
       }
 
-      SchedulerNameLog name_log;
+      const char *name = item->get_name();
       bool is_cancelled = is_item_removed_(item.get());
       ESP_LOGD(TAG, "  %s '%s/%s' interval=%" PRIu32 " next_execution in %" PRIu64 "ms at %" PRIu64 "%s",
-               item->get_type_str(), LOG_STR_ARG(item->get_source()),
-               name_log.format(item->get_name_type(), item->get_name(), item->get_name_hash_or_id()), item->interval,
+               item->get_type_str(), LOG_STR_ARG(item->get_source()), name ? name : "(null)", item->interval,
                item->get_next_execution() - now_64, item->get_next_execution(), is_cancelled ? " [CANCELLED]" : "");
 
       old_items.push_back(std::move(item));
@@ -513,13 +458,10 @@ void HOT Scheduler::call(uint32_t now) {
 #endif
 
 #ifdef ESPHOME_DEBUG_SCHEDULER
-    {
-      SchedulerNameLog name_log;
-      ESP_LOGV(TAG, "Running %s '%s/%s' with interval=%" PRIu32 " next_execution=%" PRIu64 " (now=%" PRIu64 ")",
-               item->get_type_str(), LOG_STR_ARG(item->get_source()),
-               name_log.format(item->get_name_type(), item->get_name(), item->get_name_hash_or_id()), item->interval,
-               item->get_next_execution(), now_64);
-    }
+    const char *item_name = item->get_name();
+    ESP_LOGV(TAG, "Running %s '%s/%s' with interval=%" PRIu32 " next_execution=%" PRIu64 " (now=%" PRIu64 ")",
+             item->get_type_str(), LOG_STR_ARG(item->get_source()), item_name ? item_name : "(null)", item->interval,
+             item->get_next_execution(), now_64);
 #endif /* ESPHOME_DEBUG_SCHEDULER */
 
     // Warning: During callback(), a lot of stuff can happen, including:
@@ -618,29 +560,33 @@ uint32_t HOT Scheduler::execute_item_(SchedulerItem *item, uint32_t now) {
   return guard.finish();
 }
 
-// Common implementation for cancel operations - handles locking
-bool HOT Scheduler::cancel_item_(Component *component, NameType name_type, const char *static_name, uint32_t hash_or_id,
-                                 SchedulerItem::Type type, bool match_retry) {
+// Common implementation for cancel operations
+bool HOT Scheduler::cancel_item_(Component *component, bool is_static_string, const void *name_ptr,
+                                 SchedulerItem::Type type) {
+  // Get the name as const char*
+  const char *name_cstr = this->get_name_cstr_(is_static_string, name_ptr);
+
+  // obtain lock because this function iterates and can be called from non-loop task context
   LockGuard guard{this->lock_};
-  return this->cancel_item_locked_(component, name_type, static_name, hash_or_id, type, match_retry);
+  return this->cancel_item_locked_(component, name_cstr, type);
 }
 
-// Helper to cancel items - must be called with lock held
-// name_type determines matching: STATIC_STRING uses static_name, others use hash_or_id
-bool HOT Scheduler::cancel_item_locked_(Component *component, NameType name_type, const char *static_name,
-                                        uint32_t hash_or_id, SchedulerItem::Type type, bool match_retry) {
-  // Early return if static string name is invalid
-  if (name_type == NameType::STATIC_STRING && static_name == nullptr) {
+// Helper to cancel items by name - must be called with lock held
+bool HOT Scheduler::cancel_item_locked_(Component *component, const char *name_cstr, SchedulerItem::Type type,
+                                        bool match_retry) {
+  // Early return if name is invalid - no items to cancel
+  if (name_cstr == nullptr) {
     return false;
   }
 
   size_t total_cancelled = 0;
 
+  // Check all containers for matching items
 #ifndef ESPHOME_THREAD_SINGLE
   // Mark items in defer queue as cancelled (they'll be skipped when processed)
   if (type == SchedulerItem::TIMEOUT) {
-    total_cancelled += this->mark_matching_items_removed_locked_(this->defer_queue_, component, name_type, static_name,
-                                                                 hash_or_id, type, match_retry);
+    total_cancelled +=
+        this->mark_matching_items_removed_locked_(this->defer_queue_, component, name_cstr, type, match_retry);
   }
 #endif /* not ESPHOME_THREAD_SINGLE */
 
@@ -650,15 +596,14 @@ bool HOT Scheduler::cancel_item_locked_(Component *component, NameType name_type
   // would destroy the callback while it's running (use-after-free).
   // Only the main loop in call() should recycle items after execution completes.
   if (!this->items_.empty()) {
-    size_t heap_cancelled = this->mark_matching_items_removed_locked_(this->items_, component, name_type, static_name,
-                                                                      hash_or_id, type, match_retry);
+    size_t heap_cancelled =
+        this->mark_matching_items_removed_locked_(this->items_, component, name_cstr, type, match_retry);
     total_cancelled += heap_cancelled;
     this->to_remove_ += heap_cancelled;
   }
 
   // Cancel items in to_add_
-  total_cancelled += this->mark_matching_items_removed_locked_(this->to_add_, component, name_type, static_name,
-                                                               hash_or_id, type, match_retry);
+  total_cancelled += this->mark_matching_items_removed_locked_(this->to_add_, component, name_cstr, type, match_retry);
 
   return total_cancelled > 0;
 }
@@ -840,6 +785,8 @@ void Scheduler::recycle_item_main_loop_(std::unique_ptr<SchedulerItem> item) {
   if (this->scheduler_item_pool_.size() < MAX_POOL_SIZE) {
     // Clear callback to release captured resources
     item->callback = nullptr;
+    // Clear dynamic name if any
+    item->clear_dynamic_name();
     this->scheduler_item_pool_.push_back(std::move(item));
 #ifdef ESPHOME_DEBUG_SCHEDULER
     ESP_LOGD(TAG, "Recycled item to pool (pool size now: %zu)", this->scheduler_item_pool_.size());
@@ -853,44 +800,24 @@ void Scheduler::recycle_item_main_loop_(std::unique_ptr<SchedulerItem> item) {
 }
 
 #ifdef ESPHOME_DEBUG_SCHEDULER
-void Scheduler::debug_log_timer_(const SchedulerItem *item, NameType name_type, const char *static_name,
-                                 uint32_t hash_or_id, SchedulerItem::Type type, uint32_t delay, uint64_t now) {
+void Scheduler::debug_log_timer_(const SchedulerItem *item, bool is_static_string, const char *name_cstr,
+                                 SchedulerItem::Type type, uint32_t delay, uint64_t now) {
   // Validate static strings in debug mode
-  if (name_type == NameType::STATIC_STRING && static_name != nullptr) {
-    validate_static_string(static_name);
+  if (is_static_string && name_cstr != nullptr) {
+    validate_static_string(name_cstr);
   }
 
   // Debug logging
-  SchedulerNameLog name_log;
   const char *type_str = (type == SchedulerItem::TIMEOUT) ? "timeout" : "interval";
   if (type == SchedulerItem::TIMEOUT) {
     ESP_LOGD(TAG, "set_%s(name='%s/%s', %s=%" PRIu32 ")", type_str, LOG_STR_ARG(item->get_source()),
-             name_log.format(name_type, static_name, hash_or_id), type_str, delay);
+             name_cstr ? name_cstr : "(null)", type_str, delay);
   } else {
     ESP_LOGD(TAG, "set_%s(name='%s/%s', %s=%" PRIu32 ", offset=%" PRIu32 ")", type_str, LOG_STR_ARG(item->get_source()),
-             name_log.format(name_type, static_name, hash_or_id), type_str, delay,
+             name_cstr ? name_cstr : "(null)", type_str, delay,
              static_cast<uint32_t>(item->get_next_execution() - now));
   }
 }
 #endif /* ESPHOME_DEBUG_SCHEDULER */
 
-// Helper to get or create a scheduler item from the pool
-// IMPORTANT: Caller must hold the scheduler lock before calling this function.
-std::unique_ptr<Scheduler::SchedulerItem> Scheduler::get_item_from_pool_locked_() {
-  std::unique_ptr<SchedulerItem> item;
-  if (!this->scheduler_item_pool_.empty()) {
-    item = std::move(this->scheduler_item_pool_.back());
-    this->scheduler_item_pool_.pop_back();
-#ifdef ESPHOME_DEBUG_SCHEDULER
-    ESP_LOGD(TAG, "Reused item from pool (pool size now: %zu)", this->scheduler_item_pool_.size());
-#endif
-  } else {
-    item = make_unique<SchedulerItem>();
-#ifdef ESPHOME_DEBUG_SCHEDULER
-    ESP_LOGD(TAG, "Allocated new item (pool empty)");
-#endif
-  }
-  return item;
-}
-
 }  // namespace esphome

esphome/core/scheduler.h

@@ -1,10 +1,9 @@
 #pragma once
 
 #include "esphome/core/defines.h"
-#include <cstring>
-#include <memory>
-#include <string>
 #include <vector>
+#include <memory>
+#include <cstring>
 #ifdef ESPHOME_THREAD_MULTI_ATOMICS
 #include <atomic>
 #endif
@@ -30,9 +29,7 @@ class Scheduler {
   template<typename... Ts> friend class DelayAction;
 
  public:
-  // std::string overload - deprecated, use const char* or uint32_t instead
-  // Remove before 2026.7.0
-  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
+  // Public API - accepts std::string for backward compatibility
   void set_timeout(Component *component, const std::string &name, uint32_t timeout, std::function<void()> func);
 
   /** Set a timeout with a const char* name.
@@ -42,17 +39,14 @@ class Scheduler {
    *   - A string literal (e.g., "update")
    *   - A static const char* variable
    *   - A pointer with lifetime >= the scheduled task
+   *
+   * For dynamic strings, use the std::string overload instead.
    */
   void set_timeout(Component *component, const char *name, uint32_t timeout, std::function<void()> func);
-  /// Set a timeout with a numeric ID (zero heap allocation)
-  void set_timeout(Component *component, uint32_t id, uint32_t timeout, std::function<void()> func);
 
-  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   bool cancel_timeout(Component *component, const std::string &name);
   bool cancel_timeout(Component *component, const char *name);
-  bool cancel_timeout(Component *component, uint32_t id);
 
-  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   void set_interval(Component *component, const std::string &name, uint32_t interval, std::function<void()> func);
 
   /** Set an interval with a const char* name.
@@ -62,29 +56,19 @@ class Scheduler {
    *   - A string literal (e.g., "update")
    *   - A static const char* variable
    *   - A pointer with lifetime >= the scheduled task
+   *
+   * For dynamic strings, use the std::string overload instead.
    */
   void set_interval(Component *component, const char *name, uint32_t interval, std::function<void()> func);
-  /// Set an interval with a numeric ID (zero heap allocation)
-  void set_interval(Component *component, uint32_t id, uint32_t interval, std::function<void()> func);
 
-  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   bool cancel_interval(Component *component, const std::string &name);
   bool cancel_interval(Component *component, const char *name);
-  bool cancel_interval(Component *component, uint32_t id);
-
-  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   void set_retry(Component *component, const std::string &name, uint32_t initial_wait_time, uint8_t max_attempts,
                  std::function<RetryResult(uint8_t)> func, float backoff_increase_factor = 1.0f);
   void set_retry(Component *component, const char *name, uint32_t initial_wait_time, uint8_t max_attempts,
                  std::function<RetryResult(uint8_t)> func, float backoff_increase_factor = 1.0f);
-  /// Set a retry with a numeric ID (zero heap allocation)
-  void set_retry(Component *component, uint32_t id, uint32_t initial_wait_time, uint8_t max_attempts,
-                 std::function<RetryResult(uint8_t)> func, float backoff_increase_factor = 1.0f);
-
-  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   bool cancel_retry(Component *component, const std::string &name);
   bool cancel_retry(Component *component, const char *name);
-  bool cancel_retry(Component *component, uint32_t id);
 
   // Calculate when the next scheduled item should run
   // @param now Fresh timestamp from millis() - must not be stale/cached
@@ -99,28 +83,21 @@ class Scheduler {
 
   void process_to_add();
 
-  // Name storage type discriminator for SchedulerItem
-  // Used to distinguish between static strings, hashed strings, and numeric IDs
-  enum class NameType : uint8_t {
-    STATIC_STRING = 0,  // const char* pointer to static/flash storage
-    HASHED_STRING = 1,  // uint32_t FNV-1a hash of a runtime string
-    NUMERIC_ID = 2      // uint32_t numeric identifier
-  };
-
  protected:
   struct SchedulerItem {
     // Ordered by size to minimize padding
     Component *component;
-    // Optimized name storage using tagged union - zero heap allocation
+    // Optimized name storage using tagged union
     union {
-      const char *static_name;  // For STATIC_STRING (string literals, no allocation)
-      uint32_t hash_or_id;      // For HASHED_STRING or NUMERIC_ID
+      const char *static_name;  // For string literals (no allocation)
+      char *dynamic_name;       // For allocated strings
     } name_;
     uint32_t interval;
     // Split time to handle millis() rollover. The scheduler combines the 32-bit millis()
-    // with a 16-bit rollover counter to create a 48-bit time space (stored as 64-bit
-    // for compatibility). With 49.7 days per 32-bit rollover, the 16-bit counter
-    // supports 49.7 days × 65536 = ~8900 years. This ensures correct scheduling
+    // with a 16-bit rollover counter to create a 48-bit time space (using 32+16 bits).
+    // This is intentionally limited to 48 bits, not stored as a full 64-bit value.
+    // With 49.7 days per 32-bit rollover, the 16-bit counter supports
+    // 49.7 days × 65536 = ~8900 years. This ensures correct scheduling
     // even when devices run for months. Split into two fields for better memory
     // alignment on 32-bit systems.
     uint32_t next_execution_low_;  // Lower 32 bits of execution time (millis value)
@@ -132,19 +109,19 @@ class Scheduler {
     // Place atomic<bool> separately since it can't be packed with bit fields
     std::atomic<bool> remove{false};
 
-    // Bit-packed fields (4 bits used, 4 bits padding in 1 byte)
+    // Bit-packed fields (3 bits used, 5 bits padding in 1 byte)
     enum Type : uint8_t { TIMEOUT, INTERVAL } type : 1;
-    NameType name_type_ : 2;  // Discriminator for name_ union (STATIC_STRING, HASHED_STRING, NUMERIC_ID)
-    bool is_retry : 1;        // True if this is a retry timeout
-                              // 4 bits padding
+    bool name_is_dynamic : 1;  // True if name was dynamically allocated (needs delete[])
+    bool is_retry : 1;         // True if this is a retry timeout
+                               // 5 bits padding
 #else
     // Single-threaded or multi-threaded without atomics: can pack all fields together
-    // Bit-packed fields (5 bits used, 3 bits padding in 1 byte)
+    // Bit-packed fields (4 bits used, 4 bits padding in 1 byte)
     enum Type : uint8_t { TIMEOUT, INTERVAL } type : 1;
     bool remove : 1;
-    NameType name_type_ : 2;  // Discriminator for name_ union (STATIC_STRING, HASHED_STRING, NUMERIC_ID)
-    bool is_retry : 1;        // True if this is a retry timeout
-                              // 3 bits padding
+    bool name_is_dynamic : 1;  // True if name was dynamically allocated (needs delete[])
+    bool is_retry : 1;         // True if this is a retry timeout
+                               // 4 bits padding
 #endif
 
     // Constructor
@@ -156,19 +133,19 @@ class Scheduler {
 #ifdef ESPHOME_THREAD_MULTI_ATOMICS
           // remove is initialized in the member declaration as std::atomic<bool>{false}
           type(TIMEOUT),
-          name_type_(NameType::STATIC_STRING),
+          name_is_dynamic(false),
           is_retry(false) {
 #else
           type(TIMEOUT),
           remove(false),
-          name_type_(NameType::STATIC_STRING),
+          name_is_dynamic(false),
           is_retry(false) {
 #endif
       name_.static_name = nullptr;
     }
 
-    // Destructor - no dynamic memory to clean up
-    ~SchedulerItem() = default;
+    // Destructor to clean up dynamic names
+    ~SchedulerItem() { clear_dynamic_name(); }
 
     // Delete copy operations to prevent accidental copies
     SchedulerItem(const SchedulerItem &) = delete;
@@ -178,31 +155,36 @@ class Scheduler {
     SchedulerItem(SchedulerItem &&) = delete;
     SchedulerItem &operator=(SchedulerItem &&) = delete;
 
-    // Helper to get the static name (only valid for STATIC_STRING type)
-    const char *get_name() const { return (name_type_ == NameType::STATIC_STRING) ? name_.static_name : nullptr; }
+    // Helper to get the name regardless of storage type
+    const char *get_name() const { return name_is_dynamic ? name_.dynamic_name : name_.static_name; }
 
-    // Helper to get the hash or numeric ID (only valid for HASHED_STRING or NUMERIC_ID types)
-    uint32_t get_name_hash_or_id() const { return (name_type_ != NameType::STATIC_STRING) ? name_.hash_or_id : 0; }
-
-    // Helper to get the name type
-    NameType get_name_type() const { return name_type_; }
-
-    // Helper to set a static string name (no allocation)
-    void set_static_name(const char *name) {
-      name_.static_name = name;
-      name_type_ = NameType::STATIC_STRING;
+    // Helper to clear dynamic name if allocated
+    void clear_dynamic_name() {
+      if (name_is_dynamic && name_.dynamic_name) {
+        delete[] name_.dynamic_name;
+        name_.dynamic_name = nullptr;
+        name_is_dynamic = false;
+      }
     }
 
-    // Helper to set a hashed string name (hash computed from std::string)
-    void set_hashed_name(uint32_t hash) {
-      name_.hash_or_id = hash;
-      name_type_ = NameType::HASHED_STRING;
-    }
+    // Helper to set name with proper ownership
+    void set_name(const char *name, bool make_copy = false) {
+      // Clean up old dynamic name if any
+      clear_dynamic_name();
 
-    // Helper to set a numeric ID name
-    void set_numeric_id(uint32_t id) {
-      name_.hash_or_id = id;
-      name_type_ = NameType::NUMERIC_ID;
+      if (!name) {
+        // nullptr case - no name provided
+        name_.static_name = nullptr;
+      } else if (make_copy) {
+        // Make a copy for dynamic strings (including empty strings)
+        size_t len = strlen(name);
+        name_.dynamic_name = new char[len + 1];
+        memcpy(name_.dynamic_name, name, len + 1);
+        name_is_dynamic = true;
+      } else {
+        // Use static string directly (including empty strings)
+        name_.static_name = name;
+      }
     }
 
     static bool cmp(const std::unique_ptr<SchedulerItem> &a, const std::unique_ptr<SchedulerItem> &b);
@@ -225,18 +207,12 @@ class Scheduler {
   };
 
   // Common implementation for both timeout and interval
-  // name_type determines storage type: STATIC_STRING uses static_name, others use hash_or_id
-  void set_timer_common_(Component *component, SchedulerItem::Type type, NameType name_type, const char *static_name,
-                         uint32_t hash_or_id, uint32_t delay, std::function<void()> func, bool is_retry = false,
-                         bool skip_cancel = false);
+  void set_timer_common_(Component *component, SchedulerItem::Type type, bool is_static_string, const void *name_ptr,
+                         uint32_t delay, std::function<void()> func, bool is_retry = false, bool skip_cancel = false);
 
   // Common implementation for retry
-  // name_type determines storage type: STATIC_STRING uses static_name, others use hash_or_id
-  void set_retry_common_(Component *component, NameType name_type, const char *static_name, uint32_t hash_or_id,
-                         uint32_t initial_wait_time, uint8_t max_attempts, std::function<RetryResult(uint8_t)> func,
-                         float backoff_increase_factor);
-  // Common implementation for cancel_retry
-  bool cancel_retry_(Component *component, NameType name_type, const char *static_name, uint32_t hash_or_id);
+  void set_retry_common_(Component *component, bool is_static_string, const void *name_ptr, uint32_t initial_wait_time,
+                         uint8_t max_attempts, std::function<RetryResult(uint8_t)> func, float backoff_increase_factor);
 
   uint64_t millis_64_(uint32_t now);
   // Cleanup logically deleted items from the scheduler
@@ -246,22 +222,21 @@ class Scheduler {
   // Remove and return the front item from the heap
   // IMPORTANT: Caller must hold the scheduler lock before calling this function.
   std::unique_ptr<SchedulerItem> pop_raw_locked_();
-  // Get or create a scheduler item from the pool
-  // IMPORTANT: Caller must hold the scheduler lock before calling this function.
-  std::unique_ptr<SchedulerItem> get_item_from_pool_locked_();
 
  private:
-  // Helper to cancel items - must be called with lock held
-  // name_type determines matching: STATIC_STRING uses static_name, others use hash_or_id
-  bool cancel_item_locked_(Component *component, NameType name_type, const char *static_name, uint32_t hash_or_id,
-                           SchedulerItem::Type type, bool match_retry = false);
+  // Helper to cancel items by name - must be called with lock held
+  bool cancel_item_locked_(Component *component, const char *name, SchedulerItem::Type type, bool match_retry = false);
 
-  // Common implementation for cancel operations - handles locking
-  bool cancel_item_(Component *component, NameType name_type, const char *static_name, uint32_t hash_or_id,
-                    SchedulerItem::Type type, bool match_retry = false);
+  // Helper to extract name as const char* from either static string or std::string
+  inline const char *get_name_cstr_(bool is_static_string, const void *name_ptr) {
+    return is_static_string ? static_cast<const char *>(name_ptr) : static_cast<const std::string *>(name_ptr)->c_str();
+  }
 
-  // Helper to check if two static string names match
-  inline bool HOT names_match_static_(const char *name1, const char *name2) const {
+  // Common implementation for cancel operations
+  bool cancel_item_(Component *component, bool is_static_string, const void *name_ptr, SchedulerItem::Type type);
+
+  // Helper to check if two scheduler item names match
+  inline bool HOT names_match_(const char *name1, const char *name2) const {
     // Check pointer equality first (common for static strings), then string contents
     // The core ESPHome codebase uses static strings (const char*) for component names,
     // making pointer comparison effective. The std::string overloads exist only for
@@ -270,11 +245,10 @@ class Scheduler {
   }
 
   // Helper function to check if item matches criteria for cancellation
-  // name_type determines matching: STATIC_STRING uses static_name, others use hash_or_id
   // IMPORTANT: Must be called with scheduler lock held
   inline bool HOT matches_item_locked_(const std::unique_ptr<SchedulerItem> &item, Component *component,
-                                       NameType name_type, const char *static_name, uint32_t hash_or_id,
-                                       SchedulerItem::Type type, bool match_retry, bool skip_removed = true) const {
+                                       const char *name_cstr, SchedulerItem::Type type, bool match_retry,
+                                       bool skip_removed = true) const {
     // THREAD SAFETY: Check for nullptr first to prevent LoadProhibited crashes. On multi-threaded
     // platforms, items can be moved out of defer_queue_ during processing, leaving nullptr entries.
     // PR #11305 added nullptr checks in callers (mark_matching_items_removed_locked_() and
@@ -287,14 +261,7 @@ class Scheduler {
         (match_retry && !item->is_retry)) {
       return false;
     }
-    // Name type must match
-    if (item->get_name_type() != name_type)
-      return false;
-    // For static strings, compare the string content; for hash/ID, compare the value
-    if (name_type == NameType::STATIC_STRING) {
-      return this->names_match_static_(item->get_name(), static_name);
-    }
-    return item->get_name_hash_or_id() == hash_or_id;
+    return this->names_match_(item->get_name(), name_cstr);
   }
 
   // Helper to execute a scheduler item
@@ -316,7 +283,7 @@ class Scheduler {
 
 #ifdef ESPHOME_DEBUG_SCHEDULER
   // Helper for debug logging in set_timer_common_ - extracted to reduce code size
-  void debug_log_timer_(const SchedulerItem *item, NameType name_type, const char *static_name, uint32_t hash_or_id,
+  void debug_log_timer_(const SchedulerItem *item, bool is_static_string, const char *name_cstr,
                         SchedulerItem::Type type, uint32_t delay, uint64_t now);
 #endif /* ESPHOME_DEBUG_SCHEDULER */
 
@@ -443,13 +410,11 @@ class Scheduler {
   }
 
   // Helper to mark matching items in a container as removed
-  // name_type determines matching: STATIC_STRING uses static_name, others use hash_or_id
   // Returns the number of items marked for removal
   // IMPORTANT: Must be called with scheduler lock held
   template<typename Container>
-  size_t mark_matching_items_removed_locked_(Container &container, Component *component, NameType name_type,
-                                             const char *static_name, uint32_t hash_or_id, SchedulerItem::Type type,
-                                             bool match_retry) {
+  size_t mark_matching_items_removed_locked_(Container &container, Component *component, const char *name_cstr,
+                                             SchedulerItem::Type type, bool match_retry) {
     size_t count = 0;
     for (auto &item : container) {
       // Skip nullptr items (can happen in defer_queue_ when items are being processed)
@@ -458,7 +423,8 @@ class Scheduler {
       // the vector can still contain nullptr items from the processing loop. This check prevents crashes.
       if (!item)
         continue;
-      if (this->matches_item_locked_(item, component, name_type, static_name, hash_or_id, type, match_retry)) {
+      if (this->matches_item_locked_(item, component, name_cstr, type, match_retry)) {
+        // Mark item for removal (platform-specific)
         this->set_item_removed_(item.get(), true);
         count++;
       }
@@ -467,12 +433,10 @@ class Scheduler {
   }
 
   // Template helper to check if any item in a container matches our criteria
-  // name_type determines matching: STATIC_STRING uses static_name, others use hash_or_id
   // IMPORTANT: Must be called with scheduler lock held
   template<typename Container>
-  bool has_cancelled_timeout_in_container_locked_(const Container &container, Component *component, NameType name_type,
-                                                  const char *static_name, uint32_t hash_or_id,
-                                                  bool match_retry) const {
+  bool has_cancelled_timeout_in_container_locked_(const Container &container, Component *component,
+                                                  const char *name_cstr, bool match_retry) const {
     for (const auto &item : container) {
       // Skip nullptr items (can happen in defer_queue_ when items are being processed)
       // The defer_queue_ uses index-based processing: items are std::moved out but left in the
@@ -481,8 +445,8 @@ class Scheduler {
       if (!item)
         continue;
       if (is_item_removed_(item.get()) &&
-          this->matches_item_locked_(item, component, name_type, static_name, hash_or_id, SchedulerItem::TIMEOUT,
-                                     match_retry, /* skip_removed= */ false)) {
+          this->matches_item_locked_(item, component, name_cstr, SchedulerItem::TIMEOUT, match_retry,
+                                     /* skip_removed= */ false)) {
         return true;
       }
     }

esphome/core/string_ref.h

@@ -115,8 +115,9 @@ inline bool operator!=(const char *lhs, const StringRef &rhs) { return !(rhs ==
 inline bool operator==(const StringRef &lhs, const __FlashStringHelper *rhs) {
   PGM_P p = reinterpret_cast<PGM_P>(rhs);
   size_t rhs_len = strlen_P(p);
-  if (lhs.size() != rhs_len)
+  if (lhs.size() != rhs_len) {
     return false;
+  }
   return memcmp_P(lhs.c_str(), p, rhs_len) == 0;
 }
 

esphome/platformio_api.py

@@ -171,16 +171,7 @@ def run_compile(config, verbose):
     args = []
     if CONF_COMPILE_PROCESS_LIMIT in config[CONF_ESPHOME]:
         args += [f"-j{config[CONF_ESPHOME][CONF_COMPILE_PROCESS_LIMIT]}"]
-    result = run_platformio_cli_run(config, verbose, *args)
-
-    # Run memory analysis if enabled
-    if config.get(CONF_ESPHOME, {}).get("analyze_memory", False):
-        try:
-            analyze_memory_usage(config)
-        except Exception as e:
-            _LOGGER.warning("Failed to analyze memory usage: %s", e)
-
-    return result
+    return run_platformio_cli_run(config, verbose, *args)
 
 
 def _run_idedata(config):
@@ -434,74 +425,3 @@ class IDEData:
     def defines(self) -> list[str]:
         """Return the list of preprocessor defines from idedata."""
         return self.raw.get("defines", [])
-
-
-def analyze_memory_usage(config: dict[str, Any]) -> None:
-    """Analyze memory usage by component after compilation."""
-    # Lazy import to avoid overhead when not needed
-    from esphome.analyze_memory.cli import MemoryAnalyzerCLI
-    from esphome.analyze_memory.helpers import get_esphome_components
-
-    idedata = get_idedata(config)
-
-    # Get paths to tools
-    elf_path = idedata.firmware_elf_path
-    objdump_path = idedata.objdump_path
-    readelf_path = idedata.readelf_path
-
-    # Debug logging
-    _LOGGER.debug("ELF path from idedata: %s", elf_path)
-
-    # Check if file exists
-    if not Path(elf_path).exists():
-        # Try alternate path
-        alt_path = Path(CORE.relative_build_path(".pioenvs", CORE.name, "firmware.elf"))
-        if alt_path.exists():
-            elf_path = str(alt_path)
-            _LOGGER.debug("Using alternate ELF path: %s", elf_path)
-        else:
-            _LOGGER.warning("ELF file not found at %s or %s", elf_path, alt_path)
-            return
-
-    # Extract external components from config
-    external_components = set()
-
-    # Get the list of built-in ESPHome components
-    builtin_components = get_esphome_components()
-
-    # Special non-component keys that appear in configs
-    NON_COMPONENT_KEYS = {
-        CONF_ESPHOME,
-        "substitutions",
-        "packages",
-        "globals",
-        "<<",
-    }
-
-    # Check all top-level keys in config
-    for key in config:
-        if key not in builtin_components and key not in NON_COMPONENT_KEYS:
-            # This is an external component
-            external_components.add(key)
-
-    _LOGGER.debug("Detected external components: %s", external_components)
-
-    # Create analyzer and run analysis
-    analyzer = MemoryAnalyzerCLI(
-        elf_path, objdump_path, readelf_path, external_components
-    )
-    analyzer.analyze()
-
-    # Generate and print report
-    report = analyzer.generate_report()
-    _LOGGER.info("\n%s", report)
-
-    # Optionally save to file
-    if config.get(CONF_ESPHOME, {}).get("memory_report_file"):
-        report_file = Path(config[CONF_ESPHOME]["memory_report_file"])
-        if report_file.suffix == ".json":
-            report_file.write_text(analyzer.to_json())
-            _LOGGER.info("Memory report saved to %s", report_file)
-        else:
-            report_file.write_text(report)
-            _LOGGER.info("Memory report saved to %s", report_file)

tests/integration/fixtures/api_user_services_union.yaml

@@ -1,59 +0,0 @@
-esphome:
-  name: test-user-services-union
-  friendly_name: Test User Services Union Storage
-
-esp32:
-  board: esp32dev
-  framework:
-    type: esp-idf
-
-logger:
-  level: DEBUG
-
-wifi:
-  ssid: "test"
-  password: "password"
-
-api:
-  actions:
-    # Test service with no arguments
-    - action: test_no_args
-      then:
-        - logger.log: "No args service called"
-
-    # Test service with one argument
-    - action: test_one_arg
-      variables:
-        value: int
-      then:
-        - logger.log:
-            format: "One arg service: %d"
-            args: [value]
-
-    # Test service with multiple arguments of different types
-    - action: test_multi_args
-      variables:
-        int_val: int
-        float_val: float
-        str_val: string
-        bool_val: bool
-      then:
-        - logger.log:
-            format: "Multi args: %d, %.2f, %s, %d"
-            args: [int_val, float_val, str_val.c_str(), bool_val]
-
-    # Test service with max typical arguments
-    - action: test_many_args
-      variables:
-        arg1: int
-        arg2: int
-        arg3: int
-        arg4: string
-        arg5: float
-      then:
-        - logger.log: "Many args service called"
-
-binary_sensor:
-  - platform: template
-    name: "Test Binary Sensor"
-    id: test_sensor

tests/integration/fixtures/scheduler_numeric_id_test.yaml

@@ -1,173 +0,0 @@
-esphome:
-  name: scheduler-numeric-id-test
-  on_boot:
-    priority: -100
-    then:
-      - logger.log: "Starting scheduler numeric ID tests"
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-globals:
-  - id: timeout_counter
-    type: int
-    initial_value: '0'
-  - id: interval_counter
-    type: int
-    initial_value: '0'
-  - id: retry_counter
-    type: int
-    initial_value: '0'
-  - id: tests_done
-    type: bool
-    initial_value: 'false'
-  - id: results_reported
-    type: bool
-    initial_value: 'false'
-
-script:
-  - id: test_numeric_ids
-    then:
-      - logger.log: "Testing numeric ID timeouts and intervals"
-      - lambda: |-
-          auto *component1 = id(test_sensor1);
-
-          // Test 1: Numeric ID with set_timeout (uint32_t)
-          App.scheduler.set_timeout(component1, 1001U, 50, []() {
-            ESP_LOGI("test", "Numeric timeout 1001 fired");
-            id(timeout_counter) += 1;
-          });
-
-          // Test 2: Another numeric ID timeout
-          App.scheduler.set_timeout(component1, 1002U, 100, []() {
-            ESP_LOGI("test", "Numeric timeout 1002 fired");
-            id(timeout_counter) += 1;
-          });
-
-          // Test 3: Numeric ID with set_interval
-          App.scheduler.set_interval(component1, 2001U, 200, []() {
-            ESP_LOGI("test", "Numeric interval 2001 fired, count: %d", id(interval_counter));
-            id(interval_counter) += 1;
-            if (id(interval_counter) >= 3) {
-              App.scheduler.cancel_interval(id(test_sensor1), 2001U);
-              ESP_LOGI("test", "Cancelled numeric interval 2001");
-            }
-          });
-
-          // Test 4: Cancel timeout with numeric ID
-          App.scheduler.set_timeout(component1, 3001U, 5000, []() {
-            ESP_LOGE("test", "ERROR: Timeout 3001 should have been cancelled");
-          });
-          App.scheduler.cancel_timeout(component1, 3001U);
-          ESP_LOGI("test", "Cancelled numeric timeout 3001");
-
-          // Test 5: Multiple timeouts with same numeric ID - only last should execute
-          for (int i = 0; i < 5; i++) {
-            App.scheduler.set_timeout(component1, 4001U, 300 + i*10, [i]() {
-              ESP_LOGI("test", "Duplicate numeric timeout %d fired", i);
-              id(timeout_counter) += 1;
-            });
-          }
-          ESP_LOGI("test", "Created 5 timeouts with same numeric ID 4001");
-
-          // Test 6: Cancel non-existent numeric ID
-          bool cancelled_nonexistent = App.scheduler.cancel_timeout(component1, 9999U);
-          ESP_LOGI("test", "Cancel non-existent numeric ID result: %s",
-                   cancelled_nonexistent ? "true (unexpected!)" : "false (expected)");
-
-          // Test 7: Component method uint32_t overloads
-          class TestNumericComponent : public Component {
-          public:
-            void test_numeric_methods() {
-              // Test set_timeout with uint32_t ID
-              this->set_timeout(5001U, 150, []() {
-                ESP_LOGI("test", "Component numeric timeout 5001 fired");
-                id(timeout_counter) += 1;
-              });
-
-              // Test set_interval with uint32_t ID
-              // Capture 'this' pointer so we can cancel with correct component
-              auto *self = this;
-              this->set_interval(5002U, 400, [self]() {
-                ESP_LOGI("test", "Component numeric interval 5002 fired");
-                id(interval_counter) += 1;
-                // Cancel after first fire - must use same component pointer
-                App.scheduler.cancel_interval(self, 5002U);
-              });
-            }
-          };
-
-          static TestNumericComponent test_component;
-          test_component.test_numeric_methods();
-
-          // Test 8: Zero ID (edge case)
-          App.scheduler.set_timeout(component1, 0U, 200, []() {
-            ESP_LOGI("test", "Numeric timeout with ID 0 fired");
-            id(timeout_counter) += 1;
-          });
-
-          // Test 9: Max uint32_t ID (edge case)
-          App.scheduler.set_timeout(component1, 0xFFFFFFFFU, 250, []() {
-            ESP_LOGI("test", "Numeric timeout with max ID fired");
-            id(timeout_counter) += 1;
-          });
-
-          // Test 10: set_retry with numeric ID
-          App.scheduler.set_retry(component1, 6001U, 50, 3,
-            [](uint8_t retry_countdown) {
-              id(retry_counter)++;
-              ESP_LOGI("test", "Numeric retry 6001 attempt %d (countdown=%d)",
-                       id(retry_counter), retry_countdown);
-              if (id(retry_counter) >= 2) {
-                ESP_LOGI("test", "Numeric retry 6001 done");
-                return RetryResult::DONE;
-              }
-              return RetryResult::RETRY;
-            });
-
-          // Test 11: cancel_retry with numeric ID
-          App.scheduler.set_retry(component1, 6002U, 100, 5,
-            [](uint8_t retry_countdown) {
-              ESP_LOGE("test", "ERROR: Numeric retry 6002 should have been cancelled");
-              return RetryResult::RETRY;
-            });
-          App.scheduler.cancel_retry(component1, 6002U);
-          ESP_LOGI("test", "Cancelled numeric retry 6002");
-
-  - id: report_results
-    then:
-      - lambda: |-
-          ESP_LOGI("test", "Final results - Timeouts: %d, Intervals: %d, Retries: %d",
-                   id(timeout_counter), id(interval_counter), id(retry_counter));
-
-sensor:
-  - platform: template
-    name: Test Sensor 1
-    id: test_sensor1
-    lambda: return 1.0;
-    update_interval: never
-
-interval:
-  # Run numeric ID tests after boot
-  - interval: 0.1s
-    then:
-      - if:
-          condition:
-            lambda: 'return id(tests_done) == false;'
-          then:
-            - lambda: 'id(tests_done) = true;'
-            - script.execute: test_numeric_ids
-            - logger.log: "Started numeric ID tests"
-
-  # Report results after tests complete
-  - interval: 0.2s
-    then:
-      - if:
-          condition:
-            lambda: 'return id(tests_done) && !id(results_reported);'
-          then:
-            - lambda: 'id(results_reported) = true;'
-            - delay: 1.5s
-            - script.execute: report_results

tests/integration/fixtures/scheduler_retry_test.yaml

@@ -43,6 +43,9 @@ globals:
   - id: static_char_retry_counter
     type: int
     initial_value: '0'
+  - id: mixed_cancel_result
+    type: bool
+    initial_value: 'false'
 
 # Using different component types for each test to ensure isolation
 sensor:
@@ -268,6 +271,23 @@ script:
             ESP_LOGI("test", "Static cancel result: %s", result ? "true" : "false");
           });
 
+      # Test 10: Mix string and const char* cancel
+      - logger.log: "=== Test 10: Mixed string/const char* ==="
+      - lambda: |-
+          auto *component = id(immediate_done_sensor);
+
+          // Set with std::string
+          std::string str_name = "mixed_retry";
+          App.scheduler.set_retry(component, str_name, 40, 3,
+            [](uint8_t retry_countdown) {
+              ESP_LOGI("test", "Mixed retry - should be cancelled");
+              return RetryResult::RETRY;
+            });
+
+          // Cancel with const char*
+          id(mixed_cancel_result) = App.scheduler.cancel_retry(component, "mixed_retry");
+          ESP_LOGI("test", "Mixed cancel result: %s", id(mixed_cancel_result) ? "true" : "false");
+
       # Wait for all tests to complete before reporting
       - delay: 500ms
 
@@ -283,4 +303,5 @@ script:
           ESP_LOGI("test", "Multiple same name counter: %d (expected 20+)", id(multiple_same_name_counter));
           ESP_LOGI("test", "Const char retry counter: %d (expected 1)", id(const_char_retry_counter));
           ESP_LOGI("test", "Static char retry counter: %d (expected 1)", id(static_char_retry_counter));
+          ESP_LOGI("test", "Mixed cancel result: %s (expected true)", id(mixed_cancel_result) ? "true" : "false");
           ESP_LOGI("test", "All retry tests completed");

tests/integration/test_scheduler_numeric_id_test.py

@@ -1,217 +0,0 @@
-"""Test scheduler numeric ID (uint32_t) overloads."""
-
-import asyncio
-import re
-
-import pytest
-
-from .types import APIClientConnectedFactory, RunCompiledFunction
-
-
-@pytest.mark.asyncio
-async def test_scheduler_numeric_id_test(
-    yaml_config: str,
-    run_compiled: RunCompiledFunction,
-    api_client_connected: APIClientConnectedFactory,
-) -> None:
-    """Test that scheduler handles numeric IDs (uint32_t) correctly."""
-    # Track counts
-    timeout_count = 0
-    interval_count = 0
-    retry_count = 0
-
-    # Events for each test completion
-    numeric_timeout_1001_fired = asyncio.Event()
-    numeric_timeout_1002_fired = asyncio.Event()
-    numeric_interval_2001_fired = asyncio.Event()
-    numeric_interval_cancelled = asyncio.Event()
-    numeric_timeout_cancelled = asyncio.Event()
-    duplicate_timeout_fired = asyncio.Event()
-    component_timeout_fired = asyncio.Event()
-    component_interval_fired = asyncio.Event()
-    zero_id_timeout_fired = asyncio.Event()
-    max_id_timeout_fired = asyncio.Event()
-    numeric_retry_done = asyncio.Event()
-    numeric_retry_cancelled = asyncio.Event()
-    final_results_logged = asyncio.Event()
-
-    # Track interval counts
-    numeric_interval_count = 0
-    numeric_retry_count = 0
-
-    def on_log_line(line: str) -> None:
-        nonlocal timeout_count, interval_count, retry_count
-        nonlocal numeric_interval_count, numeric_retry_count
-
-        # Strip ANSI color codes
-        clean_line = re.sub(r"\x1b\[[0-9;]*m", "", line)
-
-        # Check for numeric timeout completions
-        if "Numeric timeout 1001 fired" in clean_line:
-            numeric_timeout_1001_fired.set()
-            timeout_count += 1
-
-        elif "Numeric timeout 1002 fired" in clean_line:
-            numeric_timeout_1002_fired.set()
-            timeout_count += 1
-
-        # Check for numeric interval
-        elif "Numeric interval 2001 fired" in clean_line:
-            match = re.search(r"count: (\d+)", clean_line)
-            if match:
-                numeric_interval_count = int(match.group(1))
-                numeric_interval_2001_fired.set()
-
-        elif "Cancelled numeric interval 2001" in clean_line:
-            numeric_interval_cancelled.set()
-
-        elif "Cancelled numeric timeout 3001" in clean_line:
-            numeric_timeout_cancelled.set()
-
-        # Check for duplicate timeout (only last should fire)
-        elif "Duplicate numeric timeout" in clean_line:
-            match = re.search(r"timeout (\d+) fired", clean_line)
-            if match and match.group(1) == "4":
-                duplicate_timeout_fired.set()
-                timeout_count += 1
-
-        # Check for component method tests
-        elif "Component numeric timeout 5001 fired" in clean_line:
-            component_timeout_fired.set()
-            timeout_count += 1
-
-        elif "Component numeric interval 5002 fired" in clean_line:
-            component_interval_fired.set()
-            interval_count += 1
-
-        # Check for edge case tests
-        elif "Numeric timeout with ID 0 fired" in clean_line:
-            zero_id_timeout_fired.set()
-            timeout_count += 1
-
-        elif "Numeric timeout with max ID fired" in clean_line:
-            max_id_timeout_fired.set()
-            timeout_count += 1
-
-        # Check for numeric retry tests
-        elif "Numeric retry 6001 attempt" in clean_line:
-            match = re.search(r"attempt (\d+)", clean_line)
-            if match:
-                numeric_retry_count = int(match.group(1))
-
-        elif "Numeric retry 6001 done" in clean_line:
-            numeric_retry_done.set()
-
-        elif "Cancelled numeric retry 6002" in clean_line:
-            numeric_retry_cancelled.set()
-
-        # Check for final results
-        elif "Final results" in clean_line:
-            match = re.search(
-                r"Timeouts: (\d+), Intervals: (\d+), Retries: (\d+)", clean_line
-            )
-            if match:
-                timeout_count = int(match.group(1))
-                interval_count = int(match.group(2))
-                retry_count = int(match.group(3))
-                final_results_logged.set()
-
-    async with (
-        run_compiled(yaml_config, line_callback=on_log_line),
-        api_client_connected() as client,
-    ):
-        # Verify we can connect
-        device_info = await client.device_info()
-        assert device_info is not None
-        assert device_info.name == "scheduler-numeric-id-test"
-
-        # Wait for numeric timeout tests
-        try:
-            await asyncio.wait_for(numeric_timeout_1001_fired.wait(), timeout=0.5)
-        except TimeoutError:
-            pytest.fail("Numeric timeout 1001 did not fire within 0.5 seconds")
-
-        try:
-            await asyncio.wait_for(numeric_timeout_1002_fired.wait(), timeout=0.5)
-        except TimeoutError:
-            pytest.fail("Numeric timeout 1002 did not fire within 0.5 seconds")
-
-        try:
-            await asyncio.wait_for(numeric_interval_2001_fired.wait(), timeout=1.0)
-        except TimeoutError:
-            pytest.fail("Numeric interval 2001 did not fire within 1 second")
-
-        try:
-            await asyncio.wait_for(numeric_interval_cancelled.wait(), timeout=2.0)
-        except TimeoutError:
-            pytest.fail("Numeric interval 2001 was not cancelled within 2 seconds")
-
-        # Verify numeric interval ran at least twice
-        assert numeric_interval_count >= 2, (
-            f"Expected numeric interval to run at least 2 times, got {numeric_interval_count}"
-        )
-
-        # Verify numeric timeout was cancelled
-        assert numeric_timeout_cancelled.is_set(), (
-            "Numeric timeout 3001 should have been cancelled"
-        )
-
-        # Wait for duplicate timeout (only last one should fire)
-        try:
-            await asyncio.wait_for(duplicate_timeout_fired.wait(), timeout=1.0)
-        except TimeoutError:
-            pytest.fail("Duplicate numeric timeout did not fire within 1 second")
-
-        # Wait for component method tests
-        try:
-            await asyncio.wait_for(component_timeout_fired.wait(), timeout=0.5)
-        except TimeoutError:
-            pytest.fail("Component numeric timeout did not fire within 0.5 seconds")
-
-        try:
-            await asyncio.wait_for(component_interval_fired.wait(), timeout=1.0)
-        except TimeoutError:
-            pytest.fail("Component numeric interval did not fire within 1 second")
-
-        # Wait for edge case tests
-        try:
-            await asyncio.wait_for(zero_id_timeout_fired.wait(), timeout=0.5)
-        except TimeoutError:
-            pytest.fail("Zero ID timeout did not fire within 0.5 seconds")
-
-        try:
-            await asyncio.wait_for(max_id_timeout_fired.wait(), timeout=0.5)
-        except TimeoutError:
-            pytest.fail("Max ID timeout did not fire within 0.5 seconds")
-
-        # Wait for numeric retry tests
-        try:
-            await asyncio.wait_for(numeric_retry_done.wait(), timeout=1.0)
-        except TimeoutError:
-            pytest.fail(
-                f"Numeric retry 6001 did not complete. Count: {numeric_retry_count}"
-            )
-
-        assert numeric_retry_count >= 2, (
-            f"Expected at least 2 numeric retry attempts, got {numeric_retry_count}"
-        )
-
-        # Verify numeric retry was cancelled
-        assert numeric_retry_cancelled.is_set(), (
-            "Numeric retry 6002 should have been cancelled"
-        )
-
-        # Wait for final results
-        try:
-            await asyncio.wait_for(final_results_logged.wait(), timeout=3.0)
-        except TimeoutError:
-            pytest.fail("Final results were not logged within 3 seconds")
-
-        # Verify results
-        assert timeout_count >= 6, f"Expected at least 6 timeouts, got {timeout_count}"
-        assert interval_count >= 3, (
-            f"Expected at least 3 interval fires, got {interval_count}"
-        )
-        assert retry_count >= 2, (
-            f"Expected at least 2 retry attempts, got {retry_count}"
-        )

tests/integration/test_scheduler_retry_test.py

@@ -25,6 +25,7 @@ async def test_scheduler_retry_test(
     multiple_name_done = asyncio.Event()
     const_char_done = asyncio.Event()
     static_char_done = asyncio.Event()
+    mixed_cancel_done = asyncio.Event()
     test_complete = asyncio.Event()
 
     # Track retry counts
@@ -41,13 +42,14 @@ async def test_scheduler_retry_test(
     # Track specific test results
     cancel_result = None
     empty_cancel_result = None
+    mixed_cancel_result = None
     backoff_intervals = []
 
     def on_log_line(line: str) -> None:
         nonlocal simple_retry_count, backoff_retry_count, immediate_done_count
         nonlocal cancel_retry_count, empty_name_retry_count, component_retry_count
         nonlocal multiple_name_count, const_char_retry_count, static_char_retry_count
-        nonlocal cancel_result, empty_cancel_result
+        nonlocal cancel_result, empty_cancel_result, mixed_cancel_result
 
         # Strip ANSI color codes
         clean_line = re.sub(r"\x1b\[[0-9;]*m", "", line)
@@ -127,6 +129,11 @@ async def test_scheduler_retry_test(
             # This is part of test 9, but we don't track it separately
             pass
 
+        # Mixed cancel test
+        elif "Mixed cancel result:" in clean_line:
+            mixed_cancel_result = "true" in clean_line
+            mixed_cancel_done.set()
+
         # Test completion
         elif "All retry tests completed" in clean_line:
             test_complete.set()
@@ -272,6 +279,16 @@ async def test_scheduler_retry_test(
             f"Expected 1 static char retry call, got {static_char_retry_count}"
         )
 
+        # Wait for mixed cancel test
+        try:
+            await asyncio.wait_for(mixed_cancel_done.wait(), timeout=1.0)
+        except TimeoutError:
+            pytest.fail("Mixed cancel test did not complete")
+
+        assert mixed_cancel_result is True, (
+            "Mixed string/const char cancel should have succeeded"
+        )
+
         # Wait for test completion
         try:
             await asyncio.wait_for(test_complete.wait(), timeout=1.0)

tests/unit_tests/test_writer.py

@@ -453,7 +453,6 @@ def test_clean_build(
     mock_core.relative_pioenvs_path.return_value = pioenvs_dir
     mock_core.relative_piolibdeps_path.return_value = piolibdeps_dir
     mock_core.relative_build_path.return_value = dependencies_lock
-    mock_core.platformio_cache_dir = str(platformio_cache_dir)
 
     # Verify all exist before
     assert pioenvs_dir.exists()