Merge branch 'dev' into mqtt_reduce_heap_alloc

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

.clang-tidy.hash

@@ -1 +1 @@
-c0335c9688ce9defb4a7d4446b93460547e22df055668bacd7d963c770f0c65f
+d272a88e8ca28ae9340a9a03295a566432a52cb696501908f57764475bf7ca65

.github/workflows/sync-device-classes.yml

@@ -41,7 +41,7 @@ jobs:
           python script/run-in-env.py pre-commit run --all-files
 
       - name: Commit changes
-        uses: peter-evans/create-pull-request@c0f553fe549906ede9cf27b5156039d195d2ece0 # v8.1.0
+        uses: peter-evans/create-pull-request@98357b18bf14b5342f975ff684046ec3b2a07725 # v8.0.0
         with:
           commit-message: "Synchronise Device Classes from Home Assistant"
           committer: esphomebot <esphome@openhomefoundation.org>

esphome/__main__.py

@@ -1,6 +1,5 @@
 # PYTHON_ARGCOMPLETE_OK
 import argparse
-from collections.abc import Callable
 from datetime import datetime
 import functools
 import getpass
@@ -43,7 +42,6 @@ from esphome.const import (
     CONF_SUBSTITUTIONS,
     CONF_TOPIC,
     ENV_NOGITIGNORE,
-    KEY_NATIVE_IDF,
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
     PLATFORM_RP2040,
@@ -117,7 +115,6 @@ class ArgsProtocol(Protocol):
     configuration: str
     name: str
     upload_speed: str | None
-    native_idf: bool
 
 
 def choose_prompt(options, purpose: str = None):
@@ -502,15 +499,12 @@ def wrap_to_code(name, comp):
     return wrapped
 
 
-def write_cpp(config: ConfigType, native_idf: bool = False) -> int:
+def write_cpp(config: ConfigType) -> int:
     if not get_bool_env(ENV_NOGITIGNORE):
         writer.write_gitignore()
 
-    # Store native_idf flag so esp32 component can check it
-    CORE.data[KEY_NATIVE_IDF] = native_idf
-
     generate_cpp_contents(config)
-    return write_cpp_file(native_idf=native_idf)
+    return write_cpp_file()
 
 
 def generate_cpp_contents(config: ConfigType) -> None:
@@ -524,54 +518,32 @@ def generate_cpp_contents(config: ConfigType) -> None:
     CORE.flush_tasks()
 
 
-def write_cpp_file(native_idf: bool = False) -> int:
+def write_cpp_file() -> int:
     code_s = indent(CORE.cpp_main_section)
     writer.write_cpp(code_s)
 
-    if native_idf and CORE.is_esp32 and CORE.target_framework == "esp-idf":
-        from esphome.build_gen import espidf
+    from esphome.build_gen import platformio
 
-        espidf.write_project()
-    else:
-        from esphome.build_gen import platformio
-
-        platformio.write_project()
+    platformio.write_project()
 
     return 0
 
 
 def compile_program(args: ArgsProtocol, config: ConfigType) -> int:
-    native_idf = getattr(args, "native_idf", False)
+    from esphome import platformio_api
 
     # NOTE: "Build path:" format is parsed by script/ci_memory_impact_extract.py
     # If you change this format, update the regex in that script as well
     _LOGGER.info("Compiling app... Build path: %s", CORE.build_path)
-
-    if native_idf and CORE.is_esp32 and CORE.target_framework == "esp-idf":
-        from esphome import espidf_api
-
-        rc = espidf_api.run_compile(config, CORE.verbose)
-        if rc != 0:
-            return rc
-
-        # Create factory.bin and ota.bin
-        espidf_api.create_factory_bin()
-        espidf_api.create_ota_bin()
-    else:
-        from esphome import platformio_api
-
-        rc = platformio_api.run_compile(config, CORE.verbose)
-        if rc != 0:
-            return rc
-
-        idedata = platformio_api.get_idedata(config)
-        if idedata is None:
-            return 1
+    rc = platformio_api.run_compile(config, CORE.verbose)
+    if rc != 0:
+        return rc
 
     # Check if firmware was rebuilt and emit build_info + create manifest
     _check_and_emit_build_info()
 
-    return 0
+    idedata = platformio_api.get_idedata(config)
+    return 0 if idedata is not None else 1
 
 
 def _check_and_emit_build_info() -> None:
@@ -828,8 +800,7 @@ def command_vscode(args: ArgsProtocol) -> int | None:
 
 
 def command_compile(args: ArgsProtocol, config: ConfigType) -> int | None:
-    native_idf = getattr(args, "native_idf", False)
-    exit_code = write_cpp(config, native_idf=native_idf)
+    exit_code = write_cpp(config)
     if exit_code != 0:
         return exit_code
     if args.only_generate:
@@ -884,8 +855,7 @@ def command_logs(args: ArgsProtocol, config: ConfigType) -> int | None:
 
 
 def command_run(args: ArgsProtocol, config: ConfigType) -> int | None:
-    native_idf = getattr(args, "native_idf", False)
-    exit_code = write_cpp(config, native_idf=native_idf)
+    exit_code = write_cpp(config)
     if exit_code != 0:
         return exit_code
     exit_code = compile_program(args, config)
@@ -966,21 +936,11 @@ def command_dashboard(args: ArgsProtocol) -> int | None:
     return dashboard.start_dashboard(args)
 
 
-def run_multiple_configs(
-    files: list, command_builder: Callable[[str], list[str]]
-) -> int:
-    """Run a command for each configuration file in a subprocess.
-
-    Args:
-        files: List of configuration files to process.
-        command_builder: Callable that takes a file path and returns a command list.
-
-    Returns:
-        Number of failed files.
-    """
+def command_update_all(args: ArgsProtocol) -> int | None:
     import click
 
     success = {}
+    files = list_yaml_files(args.configuration)
     twidth = 60
 
     def print_bar(middle_text):
@@ -990,19 +950,17 @@ def run_multiple_configs(
         safe_print(f"{half_line}{middle_text}{half_line}")
 
     for f in files:
-        f_path = Path(f) if not isinstance(f, Path) else f
-
-        if any(f_path.name == x for x in SECRETS_FILES):
-            _LOGGER.warning("Skipping secrets file %s", f_path)
-            continue
-
-        safe_print(f"Processing {color(AnsiFore.CYAN, str(f))}")
+        safe_print(f"Updating {color(AnsiFore.CYAN, str(f))}")
         safe_print("-" * twidth)
         safe_print()
-
-        cmd = command_builder(f)
-        rc = run_external_process(*cmd)
-
+        if CORE.dashboard:
+            rc = run_external_process(
+                "esphome", "--dashboard", "run", f, "--no-logs", "--device", "OTA"
+            )
+        else:
+            rc = run_external_process(
+                "esphome", "run", f, "--no-logs", "--device", "OTA"
+            )
         if rc == 0:
             print_bar(f"[{color(AnsiFore.BOLD_GREEN, 'SUCCESS')}] {str(f)}")
             success[f] = True
@@ -1017,8 +975,6 @@ def run_multiple_configs(
     print_bar(f"[{color(AnsiFore.BOLD_WHITE, 'SUMMARY')}]")
     failed = 0
     for f in files:
-        if f not in success:
-            continue  # Skipped file
         if success[f]:
             safe_print(f"  - {str(f)}: {color(AnsiFore.GREEN, 'SUCCESS')}")
         else:
@@ -1027,17 +983,6 @@ def run_multiple_configs(
     return failed
 
 
-def command_update_all(args: ArgsProtocol) -> int | None:
-    files = list_yaml_files(args.configuration)
-
-    def build_command(f):
-        if CORE.dashboard:
-            return ["esphome", "--dashboard", "run", f, "--no-logs", "--device", "OTA"]
-        return ["esphome", "run", f, "--no-logs", "--device", "OTA"]
-
-    return run_multiple_configs(files, build_command)
-
-
 def command_idedata(args: ArgsProtocol, config: ConfigType) -> int:
     import json
 
@@ -1339,11 +1284,6 @@ def parse_args(argv):
         help="Only generate source code, do not compile.",
         action="store_true",
     )
-    parser_compile.add_argument(
-        "--native-idf",
-        help="Build with native ESP-IDF instead of PlatformIO (ESP32 esp-idf framework only).",
-        action="store_true",
-    )
 
     parser_upload = subparsers.add_parser(
         "upload",
@@ -1425,11 +1365,6 @@ def parse_args(argv):
         help="Reset the device before starting serial logs.",
         default=os.getenv("ESPHOME_SERIAL_LOGGING_RESET"),
     )
-    parser_run.add_argument(
-        "--native-idf",
-        help="Build with native ESP-IDF instead of PlatformIO (ESP32 esp-idf framework only).",
-        action="store_true",
-    )
 
     parser_clean = subparsers.add_parser(
         "clean-mqtt",
@@ -1598,48 +1533,38 @@ def run_esphome(argv):
 
     _LOGGER.info("ESPHome %s", const.__version__)
 
-    # Multiple configurations: use subprocesses to avoid state leakage
-    # between compilations (e.g., LVGL touchscreen state in module globals)
-    if len(args.configuration) > 1:
-        # Build command by reusing argv, replacing all configs with single file
-        # argv[0] is the program path, skip it since we prefix with "esphome"
-        def build_command(f):
-            return (
-                ["esphome"]
-                + [arg for arg in argv[1:] if arg not in args.configuration]
-                + [str(f)]
-            )
+    for conf_path in args.configuration:
+        conf_path = Path(conf_path)
+        if any(conf_path.name == x for x in SECRETS_FILES):
+            _LOGGER.warning("Skipping secrets file %s", conf_path)
+            continue
 
-        return run_multiple_configs(args.configuration, build_command)
+        CORE.config_path = conf_path
+        CORE.dashboard = args.dashboard
 
-    # Single configuration
-    conf_path = Path(args.configuration[0])
-    if any(conf_path.name == x for x in SECRETS_FILES):
-        _LOGGER.warning("Skipping secrets file %s", conf_path)
-        return 0
+        # For logs command, skip updating external components
+        skip_external = args.command == "logs"
+        config = read_config(
+            dict(args.substitution) if args.substitution else {},
+            skip_external_update=skip_external,
+        )
+        if config is None:
+            return 2
+        CORE.config = config
 
-    CORE.config_path = conf_path
-    CORE.dashboard = args.dashboard
+        if args.command not in POST_CONFIG_ACTIONS:
+            safe_print(f"Unknown command {args.command}")
 
-    # For logs command, skip updating external components
-    skip_external = args.command == "logs"
-    config = read_config(
-        dict(args.substitution) if args.substitution else {},
-        skip_external_update=skip_external,
-    )
-    if config is None:
-        return 2
-    CORE.config = config
+        try:
+            rc = POST_CONFIG_ACTIONS[args.command](args, config)
+        except EsphomeError as e:
+            _LOGGER.error(e, exc_info=args.verbose)
+            return 1
+        if rc != 0:
+            return rc
 
-    if args.command not in POST_CONFIG_ACTIONS:
-        safe_print(f"Unknown command {args.command}")
-        return 1
-
-    try:
-        return POST_CONFIG_ACTIONS[args.command](args, config)
-    except EsphomeError as e:
-        _LOGGER.error(e, exc_info=args.verbose)
-        return 1
+        CORE.reset()
+    return 0
 
 
 def main():

esphome/build_gen/espidf.py

@@ -1,139 +0,0 @@
-"""ESP-IDF direct build generator for ESPHome."""
-
-import json
-from pathlib import Path
-
-from esphome.components.esp32 import get_esp32_variant
-from esphome.core import CORE
-from esphome.helpers import mkdir_p, write_file_if_changed
-
-
-def get_available_components() -> list[str] | None:
-    """Get list of available ESP-IDF components from project_description.json.
-
-    Returns only internal ESP-IDF components, excluding external/managed
-    components (from idf_component.yml).
-    """
-    project_desc = Path(CORE.build_path) / "build" / "project_description.json"
-    if not project_desc.exists():
-        return None
-
-    try:
-        with open(project_desc, encoding="utf-8") as f:
-            data = json.load(f)
-
-        component_info = data.get("build_component_info", {})
-
-        result = []
-        for name, info in component_info.items():
-            # Exclude our own src component
-            if name == "src":
-                continue
-
-            # Exclude managed/external components
-            comp_dir = info.get("dir", "")
-            if "managed_components" in comp_dir:
-                continue
-
-            result.append(name)
-
-        return result
-    except (json.JSONDecodeError, OSError):
-        return None
-
-
-def has_discovered_components() -> bool:
-    """Check if we have discovered components from a previous configure."""
-    return get_available_components() is not None
-
-
-def get_project_cmakelists() -> str:
-    """Generate the top-level CMakeLists.txt for ESP-IDF project."""
-    # Get IDF target from ESP32 variant (e.g., ESP32S3 -> esp32s3)
-    variant = get_esp32_variant()
-    idf_target = variant.lower().replace("-", "")
-
-    return f"""\
-# Auto-generated by ESPHome
-cmake_minimum_required(VERSION 3.16)
-
-set(IDF_TARGET {idf_target})
-set(EXTRA_COMPONENT_DIRS ${{CMAKE_SOURCE_DIR}}/src)
-
-include($ENV{{IDF_PATH}}/tools/cmake/project.cmake)
-project({CORE.name})
-"""
-
-
-def get_component_cmakelists(minimal: bool = False) -> str:
-    """Generate the main component CMakeLists.txt."""
-    idf_requires = [] if minimal else (get_available_components() or [])
-    requires_str = " ".join(idf_requires)
-
-    # Extract compile definitions from build flags (-DXXX -> XXX)
-    compile_defs = [flag[2:] for flag in CORE.build_flags if flag.startswith("-D")]
-    compile_defs_str = "\n    ".join(compile_defs) if compile_defs else ""
-
-    # Extract compile options (-W flags, excluding linker flags)
-    compile_opts = [
-        flag
-        for flag in CORE.build_flags
-        if flag.startswith("-W") and not flag.startswith("-Wl,")
-    ]
-    compile_opts_str = "\n    ".join(compile_opts) if compile_opts else ""
-
-    # Extract linker options (-Wl, flags)
-    link_opts = [flag for flag in CORE.build_flags if flag.startswith("-Wl,")]
-    link_opts_str = "\n    ".join(link_opts) if link_opts else ""
-
-    return f"""\
-# Auto-generated by ESPHome
-file(GLOB_RECURSE app_sources
-    "${{CMAKE_CURRENT_SOURCE_DIR}}/*.cpp"
-    "${{CMAKE_CURRENT_SOURCE_DIR}}/*.c"
-    "${{CMAKE_CURRENT_SOURCE_DIR}}/esphome/*.cpp"
-    "${{CMAKE_CURRENT_SOURCE_DIR}}/esphome/*.c"
-)
-
-idf_component_register(
-    SRCS ${{app_sources}}
-    INCLUDE_DIRS "." "esphome"
-    REQUIRES {requires_str}
-)
-
-# Apply C++ standard
-target_compile_features(${{COMPONENT_LIB}} PUBLIC cxx_std_20)
-
-# ESPHome compile definitions
-target_compile_definitions(${{COMPONENT_LIB}} PUBLIC
-    {compile_defs_str}
-)
-
-# ESPHome compile options
-target_compile_options(${{COMPONENT_LIB}} PUBLIC
-    {compile_opts_str}
-)
-
-# ESPHome linker options
-target_link_options(${{COMPONENT_LIB}} PUBLIC
-    {link_opts_str}
-)
-"""
-
-
-def write_project(minimal: bool = False) -> None:
-    """Write ESP-IDF project files."""
-    mkdir_p(CORE.build_path)
-    mkdir_p(CORE.relative_src_path())
-
-    # Write top-level CMakeLists.txt
-    write_file_if_changed(
-        CORE.relative_build_path("CMakeLists.txt"),
-        get_project_cmakelists(),
-    )
-
-    # Write component CMakeLists.txt in src/
-    write_file_if_changed(
-        CORE.relative_src_path("CMakeLists.txt"),
-        get_component_cmakelists(minimal=minimal),
-    )

esphome/components/adc/sensor.py

@@ -160,21 +160,21 @@ async def to_code(config):
         zephyr_add_user("io-channels", f"<&adc {channel_id}>")
         zephyr_add_overlay(
             f"""
-                &adc {{
-                    #address-cells = <1>;
-                    #size-cells = <0>;
+&adc {{
+    #address-cells = <1>;
+    #size-cells = <0>;
 
-                    channel@{channel_id} {{
-                        reg = <{channel_id}>;
-                        zephyr,gain = "{gain}";
-                        zephyr,reference = "ADC_REF_INTERNAL";
-                        zephyr,acquisition-time = <ADC_ACQ_TIME_DEFAULT>;
-                        zephyr,input-positive = <NRF_SAADC_{pin_number}>;
-                        zephyr,resolution = <14>;
-                        zephyr,oversampling = <8>;
-                    }};
-                }};
-            """
+    channel@{channel_id} {{
+        reg = <{channel_id}>;
+        zephyr,gain = "{gain}";
+        zephyr,reference = "ADC_REF_INTERNAL";
+        zephyr,acquisition-time = <ADC_ACQ_TIME_DEFAULT>;
+        zephyr,input-positive = <NRF_SAADC_{pin_number}>;
+        zephyr,resolution = <14>;
+        zephyr,oversampling = <8>;
+    }};
+}};
+"""
         )
 
 

esphome/components/am43/am43_base.cpp

@@ -1,12 +1,21 @@
 #include "am43_base.h"
-#include "esphome/core/helpers.h"
 #include <cstring>
+#include <cstdio>
 
 namespace esphome {
 namespace am43 {
 
 const uint8_t START_PACKET[5] = {0x00, 0xff, 0x00, 0x00, 0x9a};
 
+std::string pkt_to_hex(const uint8_t *data, uint16_t len) {
+  char buf[64];
+  memset(buf, 0, 64);
+  for (int i = 0; i < len; i++)
+    sprintf(&buf[i * 2], "%02x", data[i]);
+  std::string ret = buf;
+  return ret;
+}
+
 Am43Packet *Am43Encoder::get_battery_level_request() {
   uint8_t data = 0x1;
   return this->encode_(0xA2, &data, 1);
@@ -64,9 +73,7 @@ Am43Packet *Am43Encoder::encode_(uint8_t command, uint8_t *data, uint8_t length)
   memcpy(&this->packet_.data[7], data, length);
   this->packet_.length = length + 7;
   this->checksum_();
-  char hex_buf[format_hex_size(sizeof(this->packet_.data))];
-  ESP_LOGV("am43", "ENC(%d): 0x%s", this->packet_.length,
-           format_hex_to(hex_buf, this->packet_.data, this->packet_.length));
+  ESP_LOGV("am43", "ENC(%d): 0x%s", packet_.length, pkt_to_hex(packet_.data, packet_.length).c_str());
   return &this->packet_;
 }
 
@@ -81,8 +88,7 @@ void Am43Decoder::decode(const uint8_t *data, uint16_t length) {
   this->has_set_state_response_ = false;
   this->has_position_ = false;
   this->has_pin_response_ = false;
-  char hex_buf[format_hex_size(24)];  // Max expected packet size
-  ESP_LOGV("am43", "DEC(%d): 0x%s", length, format_hex_to(hex_buf, data, length));
+  ESP_LOGV("am43", "DEC(%d): 0x%s", length, pkt_to_hex(data, length).c_str());
 
   if (length < 2 || data[0] != 0x9a)
     return;

esphome/components/anova/anova_base.cpp

@@ -18,31 +18,31 @@ AnovaPacket *AnovaCodec::clean_packet_() {
 
 AnovaPacket *AnovaCodec::get_read_device_status_request() {
   this->current_query_ = READ_DEVICE_STATUS;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), "%s", CMD_READ_DEVICE_STATUS);
+  sprintf((char *) this->packet_.data, "%s", CMD_READ_DEVICE_STATUS);
   return this->clean_packet_();
 }
 
 AnovaPacket *AnovaCodec::get_read_target_temp_request() {
   this->current_query_ = READ_TARGET_TEMPERATURE;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), "%s", CMD_READ_TARGET_TEMP);
+  sprintf((char *) this->packet_.data, "%s", CMD_READ_TARGET_TEMP);
   return this->clean_packet_();
 }
 
 AnovaPacket *AnovaCodec::get_read_current_temp_request() {
   this->current_query_ = READ_CURRENT_TEMPERATURE;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), "%s", CMD_READ_CURRENT_TEMP);
+  sprintf((char *) this->packet_.data, "%s", CMD_READ_CURRENT_TEMP);
   return this->clean_packet_();
 }
 
 AnovaPacket *AnovaCodec::get_read_unit_request() {
   this->current_query_ = READ_UNIT;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), "%s", CMD_READ_UNIT);
+  sprintf((char *) this->packet_.data, "%s", CMD_READ_UNIT);
   return this->clean_packet_();
 }
 
 AnovaPacket *AnovaCodec::get_read_data_request() {
   this->current_query_ = READ_DATA;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), "%s", CMD_READ_DATA);
+  sprintf((char *) this->packet_.data, "%s", CMD_READ_DATA);
   return this->clean_packet_();
 }
 
@@ -50,25 +50,25 @@ AnovaPacket *AnovaCodec::get_set_target_temp_request(float temperature) {
   this->current_query_ = SET_TARGET_TEMPERATURE;
   if (this->fahrenheit_)
     temperature = ctof(temperature);
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), CMD_SET_TARGET_TEMP, temperature);
+  sprintf((char *) this->packet_.data, CMD_SET_TARGET_TEMP, temperature);
   return this->clean_packet_();
 }
 
 AnovaPacket *AnovaCodec::get_set_unit_request(char unit) {
   this->current_query_ = SET_UNIT;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), CMD_SET_TEMP_UNIT, unit);
+  sprintf((char *) this->packet_.data, CMD_SET_TEMP_UNIT, unit);
   return this->clean_packet_();
 }
 
 AnovaPacket *AnovaCodec::get_start_request() {
   this->current_query_ = START;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), "%s", CMD_START);
+  sprintf((char *) this->packet_.data, CMD_START);
   return this->clean_packet_();
 }
 
 AnovaPacket *AnovaCodec::get_stop_request() {
   this->current_query_ = STOP;
-  snprintf((char *) this->packet_.data, sizeof(this->packet_.data), "%s", CMD_STOP);
+  sprintf((char *) this->packet_.data, CMD_STOP);
   return this->clean_packet_();
 }
 

esphome/components/api/api_connection.cpp

@@ -1715,7 +1715,7 @@ void APIConnection::on_home_assistant_state_response(const HomeAssistantStateRes
     // HA state max length is 255 characters, but attributes can be much longer
     // Use stack buffer for common case (states), heap fallback for large attributes
     size_t state_len = msg.state.size();
-    SmallBufferWithHeapFallback<MAX_STATE_LEN + 1> state_buf_alloc(state_len + 1);
+    SmallBufferWithHeapFallback<256> state_buf_alloc(state_len + 1);
     char *state_buf = reinterpret_cast<char *>(state_buf_alloc.get());
     if (state_len > 0) {
       memcpy(state_buf, msg.state.c_str(), state_len);

esphome/components/api/api_frame_helper_noise.cpp

@@ -3,7 +3,6 @@
 #ifdef USE_API_NOISE
 #include "api_connection.h"  // For ClientInfo struct
 #include "esphome/core/application.h"
-#include "esphome/core/entity_base.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
@@ -257,30 +256,28 @@ APIError APINoiseFrameHelper::state_action_() {
   }
   if (state_ == State::SERVER_HELLO) {
     // send server hello
+    constexpr size_t mac_len = 13;  // 12 hex chars + null terminator
     const std::string &name = App.get_name();
-    char mac[MAC_ADDRESS_BUFFER_SIZE];
+    char mac[mac_len];
     get_mac_address_into_buffer(mac);
 
     // Calculate positions and sizes
     size_t name_len = name.size() + 1;  // including null terminator
     size_t name_offset = 1;
     size_t mac_offset = name_offset + name_len;
-    size_t total_size = 1 + name_len + MAC_ADDRESS_BUFFER_SIZE;
+    size_t total_size = 1 + name_len + mac_len;
 
-    // 1 (proto) + name (max ESPHOME_DEVICE_NAME_MAX_LEN) + 1 (name null)
-    // + mac (MAC_ADDRESS_BUFFER_SIZE - 1) + 1 (mac null)
-    constexpr size_t max_msg_size = 1 + ESPHOME_DEVICE_NAME_MAX_LEN + 1 + MAC_ADDRESS_BUFFER_SIZE;
-    uint8_t msg[max_msg_size];
+    auto msg = std::make_unique<uint8_t[]>(total_size);
 
     // chosen proto
     msg[0] = 0x01;
 
     // node name, terminated by null byte
-    std::memcpy(msg + name_offset, name.c_str(), name_len);
+    std::memcpy(msg.get() + name_offset, name.c_str(), name_len);
     // node mac, terminated by null byte
-    std::memcpy(msg + mac_offset, mac, MAC_ADDRESS_BUFFER_SIZE);
+    std::memcpy(msg.get() + mac_offset, mac, mac_len);
 
-    aerr = write_frame_(msg, total_size);
+    aerr = write_frame_(msg.get(), total_size);
     if (aerr != APIError::OK)
       return aerr;
 
@@ -356,32 +353,35 @@ APIError APINoiseFrameHelper::state_action_() {
   return APIError::OK;
 }
 void APINoiseFrameHelper::send_explicit_handshake_reject_(const LogString *reason) {
-  // Max reject message: "Bad handshake packet len" (24) + 1 (failure byte) = 25 bytes
-  uint8_t data[32];
-  data[0] = 0x01;  // failure
-
 #ifdef USE_STORE_LOG_STR_IN_FLASH
   // On ESP8266 with flash strings, we need to use PROGMEM-aware functions
   size_t reason_len = strlen_P(reinterpret_cast<PGM_P>(reason));
+  size_t data_size = reason_len + 1;
+  auto data = std::make_unique<uint8_t[]>(data_size);
+  data[0] = 0x01;  // failure
+
+  // Copy error message from PROGMEM
   if (reason_len > 0) {
-    memcpy_P(data + 1, reinterpret_cast<PGM_P>(reason), reason_len);
+    memcpy_P(data.get() + 1, reinterpret_cast<PGM_P>(reason), reason_len);
   }
 #else
   // Normal memory access
   const char *reason_str = LOG_STR_ARG(reason);
   size_t reason_len = strlen(reason_str);
+  size_t data_size = reason_len + 1;
+  auto data = std::make_unique<uint8_t[]>(data_size);
+  data[0] = 0x01;  // failure
+
+  // Copy error message in bulk
   if (reason_len > 0) {
-    // NOLINTNEXTLINE(bugprone-not-null-terminated-result) - binary protocol, not a C string
-    std::memcpy(data + 1, reason_str, reason_len);
+    std::memcpy(data.get() + 1, reason_str, reason_len);
   }
 #endif
 
-  size_t data_size = reason_len + 1;
-
   // temporarily remove failed state
   auto orig_state = state_;
   state_ = State::EXPLICIT_REJECT;
-  write_frame_(data, data_size);
+  write_frame_(data.get(), data_size);
   state_ = orig_state;
 }
 APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {

esphome/components/audio/__init__.py

@@ -1,5 +1,4 @@
 import esphome.codegen as cg
-from esphome.components.esp32 import add_idf_component
 import esphome.config_validation as cv
 from esphome.const import CONF_BITS_PER_SAMPLE, CONF_NUM_CHANNELS, CONF_SAMPLE_RATE
 import esphome.final_validate as fv
@@ -166,7 +165,4 @@ def final_validate_audio_schema(
 
 
 async def to_code(config):
-    add_idf_component(
-        name="esphome/esp-audio-libs",
-        ref="2.0.3",
-    )
+    cg.add_library("esphome/esp-audio-libs", "2.0.1")

esphome/components/audio/audio_decoder.cpp

@@ -300,7 +300,7 @@ FileDecoderState AudioDecoder::decode_mp3_() {
 
   // Advance read pointer to match the offset for the syncword
   this->input_transfer_buffer_->decrease_buffer_length(offset);
-  const uint8_t *buffer_start = this->input_transfer_buffer_->get_buffer_start();
+  uint8_t *buffer_start = this->input_transfer_buffer_->get_buffer_start();
 
   buffer_length = (int) this->input_transfer_buffer_->available();
   int err = esp_audio_libs::helix_decoder::MP3Decode(this->mp3_decoder_, &buffer_start, &buffer_length,

esphome/components/bluetooth_proxy/bluetooth_connection.cpp

@@ -135,8 +135,8 @@ void BluetoothConnection::loop() {
   // - For V3_WITH_CACHE: Services are never sent, disable after INIT state
   // - For V3_WITHOUT_CACHE: Disable only after service discovery is complete
   //   (send_service_ == DONE_SENDING_SERVICES, which is only set after services are sent)
-  if (this->state() != espbt::ClientState::INIT && (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE ||
-                                                    this->send_service_ == DONE_SENDING_SERVICES)) {
+  if (this->state_ != espbt::ClientState::INIT && (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE ||
+                                                   this->send_service_ == DONE_SENDING_SERVICES)) {
     this->disable_loop();
   }
 }

esphome/components/cc1101/cc1101.cpp

@@ -152,13 +152,6 @@ void CC1101Component::setup() {
   }
 }
 
-void CC1101Component::call_listeners_(const std::vector<uint8_t> &packet, float freq_offset, float rssi, uint8_t lqi) {
-  for (auto &listener : this->listeners_) {
-    listener->on_packet(packet, freq_offset, rssi, lqi);
-  }
-  this->packet_trigger_->trigger(packet, freq_offset, rssi, lqi);
-}
-
 void CC1101Component::loop() {
   if (this->state_.PKT_FORMAT != static_cast<uint8_t>(PacketFormat::PACKET_FORMAT_FIFO) || this->gdo0_pin_ == nullptr ||
       !this->gdo0_pin_->digital_read()) {
@@ -205,7 +198,7 @@ void CC1101Component::loop() {
   bool crc_ok = (this->state_.LQI & STATUS_CRC_OK_MASK) != 0;
   uint8_t lqi = this->state_.LQI & STATUS_LQI_MASK;
   if (this->state_.CRC_EN == 0 || crc_ok) {
-    this->call_listeners_(this->packet_, freq_offset, rssi, lqi);
+    this->packet_trigger_->trigger(this->packet_, freq_offset, rssi, lqi);
   }
 
   // Return to rx

esphome/components/cc1101/cc1101.h

@@ -11,11 +11,6 @@ namespace esphome::cc1101 {
 
 enum class CC1101Error { NONE = 0, TIMEOUT, PARAMS, CRC_ERROR, FIFO_OVERFLOW, PLL_LOCK };
 
-class CC1101Listener {
- public:
-  virtual void on_packet(const std::vector<uint8_t> &packet, float freq_offset, float rssi, uint8_t lqi) = 0;
-};
-
 class CC1101Component : public Component,
                         public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW,
                                               spi::CLOCK_PHASE_LEADING, spi::DATA_RATE_1MHZ> {
@@ -78,7 +73,6 @@ class CC1101Component : public Component,
 
   // Packet mode operations
   CC1101Error transmit_packet(const std::vector<uint8_t> &packet);
-  void register_listener(CC1101Listener *listener) { this->listeners_.push_back(listener); }
   Trigger<std::vector<uint8_t>, float, float, uint8_t> *get_packet_trigger() const { return this->packet_trigger_; }
 
  protected:
@@ -95,11 +89,9 @@ class CC1101Component : public Component,
   InternalGPIOPin *gdo0_pin_{nullptr};
 
   // Packet handling
-  void call_listeners_(const std::vector<uint8_t> &packet, float freq_offset, float rssi, uint8_t lqi);
   Trigger<std::vector<uint8_t>, float, float, uint8_t> *packet_trigger_{
       new Trigger<std::vector<uint8_t>, float, float, uint8_t>()};
   std::vector<uint8_t> packet_;
-  std::vector<CC1101Listener *> listeners_;
 
   // Low-level Helpers
   uint8_t strobe_(Command cmd);

esphome/components/cs5460a/cs5460a.h

@@ -76,6 +76,7 @@ class CS5460AComponent : public Component,
   void restart() { restart_(); }
 
   void setup() override;
+  void loop() override {}
   void dump_config() override;
 
  protected:

esphome/components/datetime/date_entity.cpp

@@ -106,9 +106,9 @@ DateCall &DateCall::set_date(uint16_t year, uint8_t month, uint8_t day) {
 
 DateCall &DateCall::set_date(ESPTime time) { return this->set_date(time.year, time.month, time.day_of_month); };
 
-DateCall &DateCall::set_date(const char *date, size_t len) {
+DateCall &DateCall::set_date(const std::string &date) {
   ESPTime val{};
-  if (!ESPTime::strptime(date, len, val)) {
+  if (!ESPTime::strptime(date, val)) {
     ESP_LOGE(TAG, "Could not convert the date string to an ESPTime object");
     return *this;
   }

esphome/components/datetime/date_entity.h

@@ -67,9 +67,7 @@ class DateCall {
   void perform();
   DateCall &set_date(uint16_t year, uint8_t month, uint8_t day);
   DateCall &set_date(ESPTime time);
-  DateCall &set_date(const char *date, size_t len);
-  DateCall &set_date(const char *date) { return this->set_date(date, strlen(date)); }
-  DateCall &set_date(const std::string &date) { return this->set_date(date.c_str(), date.size()); }
+  DateCall &set_date(const std::string &date);
 
   DateCall &set_year(uint16_t year) {
     this->year_ = year;

esphome/components/datetime/datetime_entity.cpp

@@ -163,9 +163,9 @@ DateTimeCall &DateTimeCall::set_datetime(ESPTime datetime) {
                             datetime.second);
 };
 
-DateTimeCall &DateTimeCall::set_datetime(const char *datetime, size_t len) {
+DateTimeCall &DateTimeCall::set_datetime(const std::string &datetime) {
   ESPTime val{};
-  if (!ESPTime::strptime(datetime, len, val)) {
+  if (!ESPTime::strptime(datetime, val)) {
     ESP_LOGE(TAG, "Could not convert the time string to an ESPTime object");
     return *this;
   }

esphome/components/datetime/datetime_entity.h

@@ -71,11 +71,7 @@ class DateTimeCall {
   void perform();
   DateTimeCall &set_datetime(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second);
   DateTimeCall &set_datetime(ESPTime datetime);
-  DateTimeCall &set_datetime(const char *datetime, size_t len);
-  DateTimeCall &set_datetime(const char *datetime) { return this->set_datetime(datetime, strlen(datetime)); }
-  DateTimeCall &set_datetime(const std::string &datetime) {
-    return this->set_datetime(datetime.c_str(), datetime.size());
-  }
+  DateTimeCall &set_datetime(const std::string &datetime);
   DateTimeCall &set_datetime(time_t epoch_seconds);
 
   DateTimeCall &set_year(uint16_t year) {

esphome/components/datetime/time_entity.cpp

@@ -74,9 +74,9 @@ TimeCall &TimeCall::set_time(uint8_t hour, uint8_t minute, uint8_t second) {
 
 TimeCall &TimeCall::set_time(ESPTime time) { return this->set_time(time.hour, time.minute, time.second); };
 
-TimeCall &TimeCall::set_time(const char *time, size_t len) {
+TimeCall &TimeCall::set_time(const std::string &time) {
   ESPTime val{};
-  if (!ESPTime::strptime(time, len, val)) {
+  if (!ESPTime::strptime(time, val)) {
     ESP_LOGE(TAG, "Could not convert the time string to an ESPTime object");
     return *this;
   }

esphome/components/datetime/time_entity.h

@@ -69,9 +69,7 @@ class TimeCall {
   void perform();
   TimeCall &set_time(uint8_t hour, uint8_t minute, uint8_t second);
   TimeCall &set_time(ESPTime time);
-  TimeCall &set_time(const char *time, size_t len);
-  TimeCall &set_time(const char *time) { return this->set_time(time, strlen(time)); }
-  TimeCall &set_time(const std::string &time) { return this->set_time(time.c_str(), time.size()); }
+  TimeCall &set_time(const std::string &time);
 
   TimeCall &set_hour(uint8_t hour) {
     this->hour_ = hour;

esphome/components/debug/debug_component.cpp

@@ -30,7 +30,7 @@ void DebugComponent::dump_config() {
 
   char device_info_buffer[DEVICE_INFO_BUFFER_SIZE];
   ESP_LOGD(TAG, "ESPHome version %s", ESPHOME_VERSION);
-  size_t pos = buf_append_printf(device_info_buffer, DEVICE_INFO_BUFFER_SIZE, 0, "%s", ESPHOME_VERSION);
+  size_t pos = buf_append(device_info_buffer, DEVICE_INFO_BUFFER_SIZE, 0, "%s", ESPHOME_VERSION);
 
   this->free_heap_ = get_free_heap_();
   ESP_LOGD(TAG, "Free Heap Size: %" PRIu32 " bytes", this->free_heap_);

esphome/components/debug/debug_component.h

@@ -5,6 +5,12 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/macros.h"
 #include <span>
+#include <cstdarg>
+#include <cstdio>
+#include <algorithm>
+#ifdef USE_ESP8266
+#include <pgmspace.h>
+#endif
 
 #ifdef USE_SENSOR
 #include "esphome/components/sensor/sensor.h"
@@ -19,7 +25,40 @@ namespace debug {
 static constexpr size_t DEVICE_INFO_BUFFER_SIZE = 256;
 static constexpr size_t RESET_REASON_BUFFER_SIZE = 128;
 
-// buf_append_printf is now provided by esphome/core/helpers.h
+#ifdef USE_ESP8266
+// ESP8266: Use vsnprintf_P to keep format strings in flash (PROGMEM)
+// Format strings must be wrapped with PSTR() macro
+inline size_t buf_append_p(char *buf, size_t size, size_t pos, PGM_P fmt, ...) {
+  if (pos >= size) {
+    return size;
+  }
+  va_list args;
+  va_start(args, fmt);
+  int written = vsnprintf_P(buf + pos, size - pos, fmt, args);
+  va_end(args);
+  if (written < 0) {
+    return pos;  // encoding error
+  }
+  return std::min(pos + static_cast<size_t>(written), size);
+}
+#define buf_append(buf, size, pos, fmt, ...) buf_append_p(buf, size, pos, PSTR(fmt), ##__VA_ARGS__)
+#else
+/// Safely append formatted string to buffer, returning new position (capped at size)
+__attribute__((format(printf, 4, 5))) inline size_t buf_append(char *buf, size_t size, size_t pos, const char *fmt,
+                                                               ...) {
+  if (pos >= size) {
+    return size;
+  }
+  va_list args;
+  va_start(args, fmt);
+  int written = vsnprintf(buf + pos, size - pos, fmt, args);
+  va_end(args);
+  if (written < 0) {
+    return pos;  // encoding error
+  }
+  return std::min(pos + static_cast<size_t>(written), size);
+}
+#endif
 
 class DebugComponent : public PollingComponent {
  public:

esphome/components/debug/debug_esp32.cpp

@@ -173,8 +173,8 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
   uint32_t flash_size = ESP.getFlashChipSize() / 1024;       // NOLINT
   uint32_t flash_speed = ESP.getFlashChipSpeed() / 1000000;  // NOLINT
   ESP_LOGD(TAG, "Flash Chip: Size=%" PRIu32 "kB Speed=%" PRIu32 "MHz Mode=%s", flash_size, flash_speed, flash_mode);
-  pos = buf_append_printf(buf, size, pos, "|Flash: %" PRIu32 "kB Speed:%" PRIu32 "MHz Mode:%s", flash_size, flash_speed,
-                          flash_mode);
+  pos = buf_append(buf, size, pos, "|Flash: %" PRIu32 "kB Speed:%" PRIu32 "MHz Mode:%s", flash_size, flash_speed,
+                   flash_mode);
 #endif
 
   esp_chip_info_t info;
@@ -182,52 +182,52 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
   const char *model = ESPHOME_VARIANT;
 
   // Build features string
-  pos = buf_append_printf(buf, size, pos, "|Chip: %s Features:", model);
+  pos = buf_append(buf, size, pos, "|Chip: %s Features:", model);
   bool first_feature = true;
   for (const auto &feature : CHIP_FEATURES) {
     if (info.features & feature.bit) {
-      pos = buf_append_printf(buf, size, pos, "%s%s", first_feature ? "" : ", ", feature.name);
+      pos = buf_append(buf, size, pos, "%s%s", first_feature ? "" : ", ", feature.name);
       first_feature = false;
       info.features &= ~feature.bit;
     }
   }
   if (info.features != 0) {
-    pos = buf_append_printf(buf, size, pos, "%sOther:0x%" PRIx32, first_feature ? "" : ", ", info.features);
+    pos = buf_append(buf, size, pos, "%sOther:0x%" PRIx32, first_feature ? "" : ", ", info.features);
   }
   ESP_LOGD(TAG, "Chip: Model=%s, Cores=%u, Revision=%u", model, info.cores, info.revision);
-  pos = buf_append_printf(buf, size, pos, " Cores:%u Revision:%u", info.cores, info.revision);
+  pos = buf_append(buf, size, pos, " Cores:%u Revision:%u", info.cores, info.revision);
 
   uint32_t cpu_freq_mhz = arch_get_cpu_freq_hz() / 1000000;
   ESP_LOGD(TAG, "CPU Frequency: %" PRIu32 " MHz", cpu_freq_mhz);
-  pos = buf_append_printf(buf, size, pos, "|CPU Frequency: %" PRIu32 " MHz", cpu_freq_mhz);
+  pos = buf_append(buf, size, pos, "|CPU Frequency: %" PRIu32 " MHz", cpu_freq_mhz);
 
   // Framework detection
 #ifdef USE_ARDUINO
   ESP_LOGD(TAG, "Framework: Arduino");
-  pos = buf_append_printf(buf, size, pos, "|Framework: Arduino");
+  pos = buf_append(buf, size, pos, "|Framework: Arduino");
 #elif defined(USE_ESP32)
   ESP_LOGD(TAG, "Framework: ESP-IDF");
-  pos = buf_append_printf(buf, size, pos, "|Framework: ESP-IDF");
+  pos = buf_append(buf, size, pos, "|Framework: ESP-IDF");
 #else
   ESP_LOGW(TAG, "Framework: UNKNOWN");
-  pos = buf_append_printf(buf, size, pos, "|Framework: UNKNOWN");
+  pos = buf_append(buf, size, pos, "|Framework: UNKNOWN");
 #endif
 
   ESP_LOGD(TAG, "ESP-IDF Version: %s", esp_get_idf_version());
-  pos = buf_append_printf(buf, size, pos, "|ESP-IDF: %s", esp_get_idf_version());
+  pos = buf_append(buf, size, pos, "|ESP-IDF: %s", esp_get_idf_version());
 
   uint8_t mac[6];
   get_mac_address_raw(mac);
   ESP_LOGD(TAG, "EFuse MAC: %02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
-  pos = buf_append_printf(buf, size, pos, "|EFuse MAC: %02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3],
-                          mac[4], mac[5]);
+  pos = buf_append(buf, size, pos, "|EFuse MAC: %02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4],
+                   mac[5]);
 
   char reason_buffer[RESET_REASON_BUFFER_SIZE];
   const char *reset_reason = get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE>(reason_buffer));
-  pos = buf_append_printf(buf, size, pos, "|Reset: %s", reset_reason);
+  pos = buf_append(buf, size, pos, "|Reset: %s", reset_reason);
 
   const char *wakeup_cause = get_wakeup_cause_(std::span<char, RESET_REASON_BUFFER_SIZE>(reason_buffer));
-  pos = buf_append_printf(buf, size, pos, "|Wakeup: %s", wakeup_cause);
+  pos = buf_append(buf, size, pos, "|Wakeup: %s", wakeup_cause);
 
   return pos;
 }

esphome/components/debug/debug_esp8266.cpp

@@ -3,80 +3,21 @@
 #include "esphome/core/log.h"
 #include <Esp.h>
 
-extern "C" {
-#include <user_interface.h>
-
-// Global reset info struct populated by SDK at boot
-extern struct rst_info resetInfo;
-
-// Core version - either a string pointer or a version number to format as hex
-extern uint32_t core_version;
-extern const char *core_release;
-}
-
 namespace esphome {
 namespace debug {
 
 static const char *const TAG = "debug";
 
-// Get reset reason string from reason code (no heap allocation)
-// Returns LogString* pointing to flash (PROGMEM) on ESP8266
-static const LogString *get_reset_reason_str(uint32_t reason) {
-  switch (reason) {
-    case REASON_DEFAULT_RST:
-      return LOG_STR("Power On");
-    case REASON_WDT_RST:
-      return LOG_STR("Hardware Watchdog");
-    case REASON_EXCEPTION_RST:
-      return LOG_STR("Exception");
-    case REASON_SOFT_WDT_RST:
-      return LOG_STR("Software Watchdog");
-    case REASON_SOFT_RESTART:
-      return LOG_STR("Software/System restart");
-    case REASON_DEEP_SLEEP_AWAKE:
-      return LOG_STR("Deep-Sleep Wake");
-    case REASON_EXT_SYS_RST:
-      return LOG_STR("External System");
-    default:
-      return LOG_STR("Unknown");
-  }
-}
-
-// Size for core version hex buffer
-static constexpr size_t CORE_VERSION_BUFFER_SIZE = 12;
-
-// Get core version string (no heap allocation)
-// Returns either core_release directly or formats core_version as hex into provided buffer
-static const char *get_core_version_str(std::span<char, CORE_VERSION_BUFFER_SIZE> buffer) {
-  if (core_release != nullptr) {
-    return core_release;
-  }
-  snprintf_P(buffer.data(), CORE_VERSION_BUFFER_SIZE, PSTR("%08x"), core_version);
-  return buffer.data();
-}
-
-// Size for reset info buffer
-static constexpr size_t RESET_INFO_BUFFER_SIZE = 200;
-
-// Get detailed reset info string (no heap allocation)
-// For watchdog/exception resets, includes detailed exception info
-static const char *get_reset_info_str(std::span<char, RESET_INFO_BUFFER_SIZE> buffer, uint32_t reason) {
-  if (reason >= REASON_WDT_RST && reason <= REASON_SOFT_WDT_RST) {
-    snprintf_P(buffer.data(), RESET_INFO_BUFFER_SIZE,
-               PSTR("Fatal exception:%d flag:%d (%s) epc1:0x%08x epc2:0x%08x epc3:0x%08x excvaddr:0x%08x depc:0x%08x"),
-               static_cast<int>(resetInfo.exccause), static_cast<int>(reason),
-               LOG_STR_ARG(get_reset_reason_str(reason)), resetInfo.epc1, resetInfo.epc2, resetInfo.epc3,
-               resetInfo.excvaddr, resetInfo.depc);
-    return buffer.data();
-  }
-  return LOG_STR_ARG(get_reset_reason_str(reason));
-}
-
 const char *DebugComponent::get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) {
-  // Copy from flash to provided buffer
-  strncpy_P(buffer.data(), (PGM_P) get_reset_reason_str(resetInfo.reason), RESET_REASON_BUFFER_SIZE - 1);
-  buffer[RESET_REASON_BUFFER_SIZE - 1] = '\0';
-  return buffer.data();
+  char *buf = buffer.data();
+#if !defined(CLANG_TIDY)
+  String reason = ESP.getResetReason();  // NOLINT
+  snprintf_P(buf, RESET_REASON_BUFFER_SIZE, PSTR("%s"), reason.c_str());
+  return buf;
+#else
+  buf[0] = '\0';
+  return buf;
+#endif
 }
 
 const char *DebugComponent::get_wakeup_cause_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) {
@@ -92,42 +33,37 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
   constexpr size_t size = DEVICE_INFO_BUFFER_SIZE;
   char *buf = buffer.data();
 
-  const LogString *flash_mode;
+  const char *flash_mode;
   switch (ESP.getFlashChipMode()) {  // NOLINT(readability-static-accessed-through-instance)
     case FM_QIO:
-      flash_mode = LOG_STR("QIO");
+      flash_mode = "QIO";
       break;
     case FM_QOUT:
-      flash_mode = LOG_STR("QOUT");
+      flash_mode = "QOUT";
       break;
     case FM_DIO:
-      flash_mode = LOG_STR("DIO");
+      flash_mode = "DIO";
       break;
     case FM_DOUT:
-      flash_mode = LOG_STR("DOUT");
+      flash_mode = "DOUT";
       break;
     default:
-      flash_mode = LOG_STR("UNKNOWN");
+      flash_mode = "UNKNOWN";
   }
-  uint32_t flash_size = ESP.getFlashChipSize() / 1024;       // NOLINT(readability-static-accessed-through-instance)
-  uint32_t flash_speed = ESP.getFlashChipSpeed() / 1000000;  // NOLINT(readability-static-accessed-through-instance)
-  ESP_LOGD(TAG, "Flash Chip: Size=%" PRIu32 "kB Speed=%" PRIu32 "MHz Mode=%s", flash_size, flash_speed,
-           LOG_STR_ARG(flash_mode));
-  pos = buf_append_printf(buf, size, pos, "|Flash: %" PRIu32 "kB Speed:%" PRIu32 "MHz Mode:%s", flash_size, flash_speed,
-                          LOG_STR_ARG(flash_mode));
+  uint32_t flash_size = ESP.getFlashChipSize() / 1024;       // NOLINT
+  uint32_t flash_speed = ESP.getFlashChipSpeed() / 1000000;  // NOLINT
+  ESP_LOGD(TAG, "Flash Chip: Size=%" PRIu32 "kB Speed=%" PRIu32 "MHz Mode=%s", flash_size, flash_speed, flash_mode);
+  pos = buf_append(buf, size, pos, "|Flash: %" PRIu32 "kB Speed:%" PRIu32 "MHz Mode:%s", flash_size, flash_speed,
+                   flash_mode);
 
+#if !defined(CLANG_TIDY)
   char reason_buffer[RESET_REASON_BUFFER_SIZE];
-  const char *reset_reason = get_reset_reason_(reason_buffer);
-  char core_version_buffer[CORE_VERSION_BUFFER_SIZE];
-  char reset_info_buffer[RESET_INFO_BUFFER_SIZE];
-  // NOLINTBEGIN(readability-static-accessed-through-instance)
+  const char *reset_reason = get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE>(reason_buffer));
   uint32_t chip_id = ESP.getChipId();
   uint8_t boot_version = ESP.getBootVersion();
   uint8_t boot_mode = ESP.getBootMode();
   uint8_t cpu_freq = ESP.getCpuFreqMHz();
   uint32_t flash_chip_id = ESP.getFlashChipId();
-  const char *sdk_version = ESP.getSdkVersion();
-  // NOLINTEND(readability-static-accessed-through-instance)
 
   ESP_LOGD(TAG,
            "Chip ID: 0x%08" PRIX32 "\n"
@@ -138,18 +74,19 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
            "Flash Chip ID=0x%08" PRIX32 "\n"
            "Reset Reason: %s\n"
            "Reset Info: %s",
-           chip_id, sdk_version, get_core_version_str(core_version_buffer), boot_version, boot_mode, cpu_freq,
-           flash_chip_id, reset_reason, get_reset_info_str(reset_info_buffer, resetInfo.reason));
+           chip_id, ESP.getSdkVersion(), ESP.getCoreVersion().c_str(), boot_version, boot_mode, cpu_freq, flash_chip_id,
+           reset_reason, ESP.getResetInfo().c_str());
 
-  pos = buf_append_printf(buf, size, pos, "|Chip: 0x%08" PRIX32, chip_id);
-  pos = buf_append_printf(buf, size, pos, "|SDK: %s", sdk_version);
-  pos = buf_append_printf(buf, size, pos, "|Core: %s", get_core_version_str(core_version_buffer));
-  pos = buf_append_printf(buf, size, pos, "|Boot: %u", boot_version);
-  pos = buf_append_printf(buf, size, pos, "|Mode: %u", boot_mode);
-  pos = buf_append_printf(buf, size, pos, "|CPU: %u", cpu_freq);
-  pos = buf_append_printf(buf, size, pos, "|Flash: 0x%08" PRIX32, flash_chip_id);
-  pos = buf_append_printf(buf, size, pos, "|Reset: %s", reset_reason);
-  pos = buf_append_printf(buf, size, pos, "|%s", get_reset_info_str(reset_info_buffer, resetInfo.reason));
+  pos = buf_append(buf, size, pos, "|Chip: 0x%08" PRIX32, chip_id);
+  pos = buf_append(buf, size, pos, "|SDK: %s", ESP.getSdkVersion());
+  pos = buf_append(buf, size, pos, "|Core: %s", ESP.getCoreVersion().c_str());
+  pos = buf_append(buf, size, pos, "|Boot: %u", boot_version);
+  pos = buf_append(buf, size, pos, "|Mode: %u", boot_mode);
+  pos = buf_append(buf, size, pos, "|CPU: %u", cpu_freq);
+  pos = buf_append(buf, size, pos, "|Flash: 0x%08" PRIX32, flash_chip_id);
+  pos = buf_append(buf, size, pos, "|Reset: %s", reset_reason);
+  pos = buf_append(buf, size, pos, "|%s", ESP.getResetInfo().c_str());
+#endif
 
   return pos;
 }

esphome/components/debug/debug_libretiny.cpp

@@ -36,12 +36,12 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
            lt_get_version(), lt_cpu_get_model_name(), lt_cpu_get_model(), lt_cpu_get_freq_mhz(), mac_id,
            lt_get_board_code(), flash_kib, ram_kib, reset_reason);
 
-  pos = buf_append_printf(buf, size, pos, "|Version: %s", LT_BANNER_STR + 10);
-  pos = buf_append_printf(buf, size, pos, "|Reset Reason: %s", reset_reason);
-  pos = buf_append_printf(buf, size, pos, "|Chip Name: %s", lt_cpu_get_model_name());
-  pos = buf_append_printf(buf, size, pos, "|Chip ID: 0x%06" PRIX32, mac_id);
-  pos = buf_append_printf(buf, size, pos, "|Flash: %" PRIu32 " KiB", flash_kib);
-  pos = buf_append_printf(buf, size, pos, "|RAM: %" PRIu32 " KiB", ram_kib);
+  pos = buf_append(buf, size, pos, "|Version: %s", LT_BANNER_STR + 10);
+  pos = buf_append(buf, size, pos, "|Reset Reason: %s", reset_reason);
+  pos = buf_append(buf, size, pos, "|Chip Name: %s", lt_cpu_get_model_name());
+  pos = buf_append(buf, size, pos, "|Chip ID: 0x%06" PRIX32, mac_id);
+  pos = buf_append(buf, size, pos, "|Flash: %" PRIu32 " KiB", flash_kib);
+  pos = buf_append(buf, size, pos, "|RAM: %" PRIu32 " KiB", ram_kib);
 
   return pos;
 }

esphome/components/debug/debug_rp2040.cpp

@@ -19,7 +19,7 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
 
   uint32_t cpu_freq = rp2040.f_cpu();
   ESP_LOGD(TAG, "CPU Frequency: %" PRIu32, cpu_freq);
-  pos = buf_append_printf(buf, size, pos, "|CPU Frequency: %" PRIu32, cpu_freq);
+  pos = buf_append(buf, size, pos, "|CPU Frequency: %" PRIu32, cpu_freq);
 
   return pos;
 }

esphome/components/debug/debug_zephyr.cpp

@@ -20,9 +20,9 @@ static size_t append_reset_reason(char *buf, size_t size, size_t pos, bool set,
     return pos;
   }
   if (pos > 0) {
-    pos = buf_append_printf(buf, size, pos, ", ");
+    pos = buf_append(buf, size, pos, ", ");
   }
-  return buf_append_printf(buf, size, pos, "%s", reason);
+  return buf_append(buf, size, pos, "%s", reason);
 }
 
 static inline uint32_t read_mem_u32(uintptr_t addr) {
@@ -132,26 +132,6 @@ void DebugComponent::log_partition_info_() {
   flash_area_foreach(fa_cb, nullptr);
 }
 
-static const char *regout0_to_str(uint32_t value) {
-  switch (value) {
-    case (UICR_REGOUT0_VOUT_DEFAULT):
-      return "1.8V (default)";
-    case (UICR_REGOUT0_VOUT_1V8):
-      return "1.8V";
-    case (UICR_REGOUT0_VOUT_2V1):
-      return "2.1V";
-    case (UICR_REGOUT0_VOUT_2V4):
-      return "2.4V";
-    case (UICR_REGOUT0_VOUT_2V7):
-      return "2.7V";
-    case (UICR_REGOUT0_VOUT_3V0):
-      return "3.0V";
-    case (UICR_REGOUT0_VOUT_3V3):
-      return "3.3V";
-  }
-  return "???V";
-}
-
 size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE> buffer, size_t pos) {
   constexpr size_t size = DEVICE_INFO_BUFFER_SIZE;
   char *buf = buffer.data();
@@ -160,28 +140,48 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
   const char *supply_status =
       (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_NORMAL) ? "Normal voltage." : "High voltage.";
   ESP_LOGD(TAG, "Main supply status: %s", supply_status);
-  pos = buf_append_printf(buf, size, pos, "|Main supply status: %s", supply_status);
+  pos = buf_append(buf, size, pos, "|Main supply status: %s", supply_status);
 
   // Regulator stage 0
   if (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_HIGH) {
     const char *reg0_type = nrf_power_dcdcen_vddh_get(NRF_POWER) ? "DC/DC" : "LDO";
-    const char *reg0_voltage = regout0_to_str((NRF_UICR->REGOUT0 & UICR_REGOUT0_VOUT_Msk) >> UICR_REGOUT0_VOUT_Pos);
-    ESP_LOGD(TAG, "Regulator stage 0: %s, %s", reg0_type, reg0_voltage);
-    pos = buf_append_printf(buf, size, pos, "|Regulator stage 0: %s, %s", reg0_type, reg0_voltage);
-#ifdef USE_NRF52_REG0_VOUT
-    if ((NRF_UICR->REGOUT0 & UICR_REGOUT0_VOUT_Msk) >> UICR_REGOUT0_VOUT_Pos != USE_NRF52_REG0_VOUT) {
-      ESP_LOGE(TAG, "Regulator stage 0: expected %s", regout0_to_str(USE_NRF52_REG0_VOUT));
+    const char *reg0_voltage;
+    switch (NRF_UICR->REGOUT0 & UICR_REGOUT0_VOUT_Msk) {
+      case (UICR_REGOUT0_VOUT_DEFAULT << UICR_REGOUT0_VOUT_Pos):
+        reg0_voltage = "1.8V (default)";
+        break;
+      case (UICR_REGOUT0_VOUT_1V8 << UICR_REGOUT0_VOUT_Pos):
+        reg0_voltage = "1.8V";
+        break;
+      case (UICR_REGOUT0_VOUT_2V1 << UICR_REGOUT0_VOUT_Pos):
+        reg0_voltage = "2.1V";
+        break;
+      case (UICR_REGOUT0_VOUT_2V4 << UICR_REGOUT0_VOUT_Pos):
+        reg0_voltage = "2.4V";
+        break;
+      case (UICR_REGOUT0_VOUT_2V7 << UICR_REGOUT0_VOUT_Pos):
+        reg0_voltage = "2.7V";
+        break;
+      case (UICR_REGOUT0_VOUT_3V0 << UICR_REGOUT0_VOUT_Pos):
+        reg0_voltage = "3.0V";
+        break;
+      case (UICR_REGOUT0_VOUT_3V3 << UICR_REGOUT0_VOUT_Pos):
+        reg0_voltage = "3.3V";
+        break;
+      default:
+        reg0_voltage = "???V";
     }
-#endif
+    ESP_LOGD(TAG, "Regulator stage 0: %s, %s", reg0_type, reg0_voltage);
+    pos = buf_append(buf, size, pos, "|Regulator stage 0: %s, %s", reg0_type, reg0_voltage);
   } else {
     ESP_LOGD(TAG, "Regulator stage 0: disabled");
-    pos = buf_append_printf(buf, size, pos, "|Regulator stage 0: disabled");
+    pos = buf_append(buf, size, pos, "|Regulator stage 0: disabled");
   }
 
   // Regulator stage 1
   const char *reg1_type = nrf_power_dcdcen_get(NRF_POWER) ? "DC/DC" : "LDO";
   ESP_LOGD(TAG, "Regulator stage 1: %s", reg1_type);
-  pos = buf_append_printf(buf, size, pos, "|Regulator stage 1: %s", reg1_type);
+  pos = buf_append(buf, size, pos, "|Regulator stage 1: %s", reg1_type);
 
   // USB power state
   const char *usb_state;
@@ -195,7 +195,7 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
     usb_state = "disconnected";
   }
   ESP_LOGD(TAG, "USB power state: %s", usb_state);
-  pos = buf_append_printf(buf, size, pos, "|USB power state: %s", usb_state);
+  pos = buf_append(buf, size, pos, "|USB power state: %s", usb_state);
 
   // Power-fail comparator
   bool enabled;
@@ -300,14 +300,14 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
           break;
       }
       ESP_LOGD(TAG, "Power-fail comparator: %s, VDDH: %s", pof_voltage, vddh_voltage);
-      pos = buf_append_printf(buf, size, pos, "|Power-fail comparator: %s, VDDH: %s", pof_voltage, vddh_voltage);
+      pos = buf_append(buf, size, pos, "|Power-fail comparator: %s, VDDH: %s", pof_voltage, vddh_voltage);
     } else {
       ESP_LOGD(TAG, "Power-fail comparator: %s", pof_voltage);
-      pos = buf_append_printf(buf, size, pos, "|Power-fail comparator: %s", pof_voltage);
+      pos = buf_append(buf, size, pos, "|Power-fail comparator: %s", pof_voltage);
     }
   } else {
     ESP_LOGD(TAG, "Power-fail comparator: disabled");
-    pos = buf_append_printf(buf, size, pos, "|Power-fail comparator: disabled");
+    pos = buf_append(buf, size, pos, "|Power-fail comparator: disabled");
   }
 
   auto package = [](uint32_t value) {

esphome/components/dsmr/__init__.py

@@ -25,13 +25,29 @@ dsmr_ns = cg.esphome_ns.namespace("esphome::dsmr")
 Dsmr = dsmr_ns.class_("Dsmr", cg.Component, uart.UARTDevice)
 
 
+def _validate_key(value):
+    value = cv.string_strict(value)
+    parts = [value[i : i + 2] for i in range(0, len(value), 2)]
+    if len(parts) != 16:
+        raise cv.Invalid("Decryption key must consist of 16 hexadecimal numbers")
+    parts_int = []
+    if any(len(part) != 2 for part in parts):
+        raise cv.Invalid("Decryption key must be format XX")
+    for part in parts:
+        try:
+            parts_int.append(int(part, 16))
+        except ValueError:
+            # pylint: disable=raise-missing-from
+            raise cv.Invalid("Decryption key must be hex values from 00 to FF")
+
+    return "".join(f"{part:02X}" for part in parts_int)
+
+
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(Dsmr),
-            cv.Optional(CONF_DECRYPTION_KEY): lambda value: cv.bind_key(
-                value, name="Decryption key"
-            ),
+            cv.Optional(CONF_DECRYPTION_KEY): _validate_key,
             cv.Optional(CONF_CRC_CHECK, default=True): cv.boolean,
             cv.Optional(CONF_GAS_MBUS_ID, default=1): cv.int_,
             cv.Optional(CONF_WATER_MBUS_ID, default=2): cv.int_,

esphome/components/dsmr/dsmr.cpp

@@ -1,5 +1,4 @@
 #include "dsmr.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 #include <AES.h>
@@ -295,8 +294,8 @@ void Dsmr::dump_config() {
   DSMR_TEXT_SENSOR_LIST(DSMR_LOG_TEXT_SENSOR, )
 }
 
-void Dsmr::set_decryption_key(const char *decryption_key) {
-  if (decryption_key == nullptr || decryption_key[0] == '\0') {
+void Dsmr::set_decryption_key(const std::string &decryption_key) {
+  if (decryption_key.empty()) {
     ESP_LOGI(TAG, "Disabling decryption");
     this->decryption_key_.clear();
     if (this->crypt_telegram_ != nullptr) {
@@ -306,15 +305,21 @@ void Dsmr::set_decryption_key(const char *decryption_key) {
     return;
   }
 
-  if (!parse_hex(decryption_key, this->decryption_key_, 16)) {
-    ESP_LOGE(TAG, "Error, decryption key must be 32 hex characters");
-    this->decryption_key_.clear();
+  if (decryption_key.length() != 32) {
+    ESP_LOGE(TAG, "Error, decryption key must be 32 character long");
     return;
   }
+  this->decryption_key_.clear();
 
   ESP_LOGI(TAG, "Decryption key is set");
   // Verbose level prints decryption key
-  ESP_LOGV(TAG, "Using decryption key: %s", decryption_key);
+  ESP_LOGV(TAG, "Using decryption key: %s", decryption_key.c_str());
+
+  char temp[3] = {0};
+  for (int i = 0; i < 16; i++) {
+    strncpy(temp, &(decryption_key.c_str()[i * 2]), 2);
+    this->decryption_key_.push_back(std::strtoul(temp, nullptr, 16));
+  }
 
   if (this->crypt_telegram_ == nullptr) {
     this->crypt_telegram_ = new uint8_t[this->max_telegram_len_];  // NOLINT

esphome/components/dsmr/dsmr.h

@@ -63,7 +63,7 @@ class Dsmr : public Component, public uart::UARTDevice {
 
   void dump_config() override;
 
-  void set_decryption_key(const char *decryption_key);
+  void set_decryption_key(const std::string &decryption_key);
   void set_max_telegram_length(size_t length) { this->max_telegram_len_ = length; }
   void set_request_pin(GPIOPin *request_pin) { this->request_pin_ = request_pin; }
   void set_request_interval(uint32_t interval) { this->request_interval_ = interval; }

esphome/components/esp32/__init__.py

@@ -34,7 +34,6 @@ from esphome.const import (
     KEY_CORE,
     KEY_FRAMEWORK_VERSION,
     KEY_NAME,
-    KEY_NATIVE_IDF,
     KEY_TARGET_FRAMEWORK,
     KEY_TARGET_PLATFORM,
     PLATFORM_ESP32,
@@ -54,7 +53,6 @@ from .const import (  # noqa
     KEY_COMPONENTS,
     KEY_ESP32,
     KEY_EXTRA_BUILD_FILES,
-    KEY_FLASH_SIZE,
     KEY_PATH,
     KEY_REF,
     KEY_REPO,
@@ -201,7 +199,6 @@ def set_core_data(config):
     )
 
     CORE.data[KEY_ESP32][KEY_BOARD] = config[CONF_BOARD]
-    CORE.data[KEY_ESP32][KEY_FLASH_SIZE] = config[CONF_FLASH_SIZE]
     CORE.data[KEY_ESP32][KEY_VARIANT] = variant
     CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES] = {}
 
@@ -965,54 +962,12 @@ async def _add_yaml_idf_components(components: list[ConfigType]):
 
 
 async def to_code(config):
-    framework_ver: cv.Version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
-    conf = config[CONF_FRAMEWORK]
-
-    # Check if using native ESP-IDF build (--native-idf)
-    use_platformio = not CORE.data.get(KEY_NATIVE_IDF, False)
-    if use_platformio:
-        # Clear IDF environment variables to avoid conflicts with PlatformIO's ESP-IDF
-        # but keep them when using --native-idf for native ESP-IDF builds
-        for clean_var in ("IDF_PATH", "IDF_TOOLS_PATH"):
-            os.environ.pop(clean_var, None)
-
-        cg.add_platformio_option("lib_ldf_mode", "off")
-        cg.add_platformio_option("lib_compat_mode", "strict")
-        cg.add_platformio_option("platform", conf[CONF_PLATFORM_VERSION])
-        cg.add_platformio_option("board", config[CONF_BOARD])
-        cg.add_platformio_option("board_upload.flash_size", config[CONF_FLASH_SIZE])
-        cg.add_platformio_option(
-            "board_upload.maximum_size",
-            int(config[CONF_FLASH_SIZE].removesuffix("MB")) * 1024 * 1024,
-        )
-
-        if CONF_SOURCE in conf:
-            cg.add_platformio_option("platform_packages", [conf[CONF_SOURCE]])
-
-        add_extra_script(
-            "pre",
-            "pre_build.py",
-            Path(__file__).parent / "pre_build.py.script",
-        )
-
-        add_extra_script(
-            "post",
-            "post_build.py",
-            Path(__file__).parent / "post_build.py.script",
-        )
-
-        # In testing mode, add IRAM fix script to allow linking grouped component tests
-        # Similar to ESP8266's approach but for ESP-IDF
-        if CORE.testing_mode:
-            cg.add_build_flag("-DESPHOME_TESTING_MODE")
-            add_extra_script(
-                "pre",
-                "iram_fix.py",
-                Path(__file__).parent / "iram_fix.py.script",
-            )
-    else:
-        cg.add_build_flag("-Wno-error=format")
-
+    cg.add_platformio_option("board", config[CONF_BOARD])
+    cg.add_platformio_option("board_upload.flash_size", config[CONF_FLASH_SIZE])
+    cg.add_platformio_option(
+        "board_upload.maximum_size",
+        int(config[CONF_FLASH_SIZE].removesuffix("MB")) * 1024 * 1024,
+    )
     cg.set_cpp_standard("gnu++20")
     cg.add_build_flag("-DUSE_ESP32")
     cg.add_build_flag("-Wl,-z,noexecstack")
@@ -1022,49 +977,79 @@ async def to_code(config):
     cg.add_define("ESPHOME_VARIANT", VARIANT_FRIENDLY[variant])
     cg.add_define(ThreadModel.MULTI_ATOMICS)
 
+    cg.add_platformio_option("lib_ldf_mode", "off")
+    cg.add_platformio_option("lib_compat_mode", "strict")
+
+    framework_ver: cv.Version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
+
+    conf = config[CONF_FRAMEWORK]
+    cg.add_platformio_option("platform", conf[CONF_PLATFORM_VERSION])
+    if CONF_SOURCE in conf:
+        cg.add_platformio_option("platform_packages", [conf[CONF_SOURCE]])
+
     if conf[CONF_ADVANCED][CONF_IGNORE_EFUSE_CUSTOM_MAC]:
         cg.add_define("USE_ESP32_IGNORE_EFUSE_CUSTOM_MAC")
 
+    for clean_var in ("IDF_PATH", "IDF_TOOLS_PATH"):
+        os.environ.pop(clean_var, None)
+
     # Set the location of the IDF component manager cache
     os.environ["IDF_COMPONENT_CACHE_PATH"] = str(
         CORE.relative_internal_path(".espressif")
     )
 
+    add_extra_script(
+        "pre",
+        "pre_build.py",
+        Path(__file__).parent / "pre_build.py.script",
+    )
+
+    add_extra_script(
+        "post",
+        "post_build.py",
+        Path(__file__).parent / "post_build.py.script",
+    )
+
+    # In testing mode, add IRAM fix script to allow linking grouped component tests
+    # Similar to ESP8266's approach but for ESP-IDF
+    if CORE.testing_mode:
+        cg.add_build_flag("-DESPHOME_TESTING_MODE")
+        add_extra_script(
+            "pre",
+            "iram_fix.py",
+            Path(__file__).parent / "iram_fix.py.script",
+        )
+
     if conf[CONF_TYPE] == FRAMEWORK_ESP_IDF:
+        cg.add_platformio_option("framework", "espidf")
         cg.add_build_flag("-DUSE_ESP_IDF")
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ESP_IDF")
-        if use_platformio:
-            cg.add_platformio_option("framework", "espidf")
     else:
+        cg.add_platformio_option("framework", "arduino, espidf")
         cg.add_build_flag("-DUSE_ARDUINO")
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ARDUINO")
-        if use_platformio:
-            cg.add_platformio_option("framework", "arduino, espidf")
-
-            # Add IDF framework source for Arduino builds to ensure it uses the same version as
-            # the ESP-IDF framework
-            if (idf_ver := ARDUINO_IDF_VERSION_LOOKUP.get(framework_ver)) is not None:
-                cg.add_platformio_option(
-                    "platform_packages",
-                    [_format_framework_espidf_version(idf_ver, None)],
-                )
-
-            # ESP32-S2 Arduino: Disable USB Serial on boot to avoid TinyUSB dependency
-            if get_esp32_variant() == VARIANT_ESP32S2:
-                cg.add_build_unflag("-DARDUINO_USB_CDC_ON_BOOT=1")
-                cg.add_build_unflag("-DARDUINO_USB_CDC_ON_BOOT=0")
-                cg.add_build_flag("-DARDUINO_USB_CDC_ON_BOOT=0")
-
         cg.add_define(
             "USE_ARDUINO_VERSION_CODE",
             cg.RawExpression(
                 f"VERSION_CODE({framework_ver.major}, {framework_ver.minor}, {framework_ver.patch})"
             ),
         )
-
         add_idf_sdkconfig_option("CONFIG_MBEDTLS_PSK_MODES", True)
         add_idf_sdkconfig_option("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", True)
 
+        # Add IDF framework source for Arduino builds to ensure it uses the same version as
+        # the ESP-IDF framework
+        if (idf_ver := ARDUINO_IDF_VERSION_LOOKUP.get(framework_ver)) is not None:
+            cg.add_platformio_option(
+                "platform_packages", [_format_framework_espidf_version(idf_ver, None)]
+            )
+
+        # ESP32-S2 Arduino: Disable USB Serial on boot to avoid TinyUSB dependency
+        if get_esp32_variant() == VARIANT_ESP32S2:
+            cg.add_build_unflag("-DARDUINO_USB_CDC_ON_BOOT=1")
+            cg.add_build_unflag("-DARDUINO_USB_CDC_ON_BOOT=0")
+            cg.add_build_flag("-DARDUINO_USB_CDC_ON_BOOT=0")
+
     cg.add_build_flag("-Wno-nonnull-compare")
 
     add_idf_sdkconfig_option(f"CONFIG_IDF_TARGET_{variant}", True)
@@ -1211,8 +1196,7 @@ async def to_code(config):
             "CONFIG_VFS_SUPPORT_DIR", not advanced[CONF_DISABLE_VFS_SUPPORT_DIR]
         )
 
-    if use_platformio:
-        cg.add_platformio_option("board_build.partitions", "partitions.csv")
+    cg.add_platformio_option("board_build.partitions", "partitions.csv")
     if CONF_PARTITIONS in config:
         add_extra_build_file(
             "partitions.csv", CORE.relative_config_path(config[CONF_PARTITIONS])
@@ -1377,16 +1361,19 @@ def copy_files():
     _write_idf_component_yml()
 
     if "partitions.csv" not in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES]:
-        flash_size = CORE.data[KEY_ESP32][KEY_FLASH_SIZE]
         if CORE.using_arduino:
             write_file_if_changed(
                 CORE.relative_build_path("partitions.csv"),
-                get_arduino_partition_csv(flash_size),
+                get_arduino_partition_csv(
+                    CORE.platformio_options.get("board_upload.flash_size")
+                ),
             )
         else:
             write_file_if_changed(
                 CORE.relative_build_path("partitions.csv"),
-                get_idf_partition_csv(flash_size),
+                get_idf_partition_csv(
+                    CORE.platformio_options.get("board_upload.flash_size")
+                ),
             )
     # IDF build scripts look for version string to put in the build.
     # However, if the build path does not have an initialized git repo,

esphome/components/esp32/const.py

@@ -2,7 +2,6 @@ import esphome.codegen as cg
 
 KEY_ESP32 = "esp32"
 KEY_BOARD = "board"
-KEY_FLASH_SIZE = "flash_size"
 KEY_VARIANT = "variant"
 KEY_SDKCONFIG_OPTIONS = "sdkconfig_options"
 KEY_COMPONENTS = "components"

esphome/components/esp32/preferences.cpp

@@ -181,8 +181,7 @@ class ESP32Preferences : public ESPPreferences {
     if (actual_len != to_save.len) {
       return true;
     }
-    // Most preferences are small, use stack buffer with heap fallback for large ones
-    SmallBufferWithHeapFallback<256> stored_data(actual_len);
+    auto stored_data = std::make_unique<uint8_t[]>(actual_len);
     err = nvs_get_blob(nvs_handle, key_str, stored_data.get(), &actual_len);
     if (err != 0) {
       ESP_LOGV(TAG, "nvs_get_blob('%s') failed: %s", key_str, esp_err_to_name(err));

esphome/components/esp32_ble/ble_uuid.h

@@ -46,8 +46,6 @@ class ESPBTUUID {
 
   esp_bt_uuid_t get_uuid() const;
 
-  // Remove before 2026.8.0
-  ESPDEPRECATED("Use to_str() instead. Removed in 2026.8.0", "2026.2.0")
   std::string to_string() const;
   const char *to_str(std::span<char, UUID_STR_LEN> output) const;
 

esphome/components/esp32_ble_client/ble_client_base.cpp

@@ -50,7 +50,7 @@ void BLEClientBase::loop() {
     this->set_state(espbt::ClientState::INIT);
     return;
   }
-  if (this->state() == espbt::ClientState::INIT) {
+  if (this->state_ == espbt::ClientState::INIT) {
     auto ret = esp_ble_gattc_app_register(this->app_id);
     if (ret) {
       ESP_LOGE(TAG, "gattc app register failed. app_id=%d code=%d", this->app_id, ret);
@@ -60,7 +60,7 @@ void BLEClientBase::loop() {
   }
   // If idle, we can disable the loop as connect()
   // will enable it again when a connection is needed.
-  else if (this->state() == espbt::ClientState::IDLE) {
+  else if (this->state_ == espbt::ClientState::IDLE) {
     this->disable_loop();
   }
 }
@@ -86,7 +86,7 @@ bool BLEClientBase::parse_device(const espbt::ESPBTDevice &device) {
     return false;
   if (this->address_ == 0 || device.address_uint64() != this->address_)
     return false;
-  if (this->state() != espbt::ClientState::IDLE)
+  if (this->state_ != espbt::ClientState::IDLE)
     return false;
 
   this->log_event_("Found device");
@@ -102,10 +102,10 @@ bool BLEClientBase::parse_device(const espbt::ESPBTDevice &device) {
 
 void BLEClientBase::connect() {
   // Prevent duplicate connection attempts
-  if (this->state() == espbt::ClientState::CONNECTING || this->state() == espbt::ClientState::CONNECTED ||
-      this->state() == espbt::ClientState::ESTABLISHED) {
+  if (this->state_ == espbt::ClientState::CONNECTING || this->state_ == espbt::ClientState::CONNECTED ||
+      this->state_ == espbt::ClientState::ESTABLISHED) {
     ESP_LOGW(TAG, "[%d] [%s] Connection already in progress, state=%s", this->connection_index_, this->address_str_,
-             espbt::client_state_to_string(this->state()));
+             espbt::client_state_to_string(this->state_));
     return;
   }
   ESP_LOGI(TAG, "[%d] [%s] 0x%02x Connecting", this->connection_index_, this->address_str_, this->remote_addr_type_);
@@ -133,12 +133,12 @@ void BLEClientBase::connect() {
 esp_err_t BLEClientBase::pair() { return esp_ble_set_encryption(this->remote_bda_, ESP_BLE_SEC_ENCRYPT); }
 
 void BLEClientBase::disconnect() {
-  if (this->state() == espbt::ClientState::IDLE || this->state() == espbt::ClientState::DISCONNECTING) {
+  if (this->state_ == espbt::ClientState::IDLE || this->state_ == espbt::ClientState::DISCONNECTING) {
     ESP_LOGI(TAG, "[%d] [%s] Disconnect requested, but already %s", this->connection_index_, this->address_str_,
-             espbt::client_state_to_string(this->state()));
+             espbt::client_state_to_string(this->state_));
     return;
   }
-  if (this->state() == espbt::ClientState::CONNECTING || this->conn_id_ == UNSET_CONN_ID) {
+  if (this->state_ == espbt::ClientState::CONNECTING || this->conn_id_ == UNSET_CONN_ID) {
     ESP_LOGD(TAG, "[%d] [%s] Disconnect before connected, disconnect scheduled", this->connection_index_,
              this->address_str_);
     this->want_disconnect_ = true;
@@ -150,7 +150,7 @@ void BLEClientBase::disconnect() {
 void BLEClientBase::unconditional_disconnect() {
   // Disconnect without checking the state.
   ESP_LOGI(TAG, "[%d] [%s] Disconnecting (conn_id: %d).", this->connection_index_, this->address_str_, this->conn_id_);
-  if (this->state() == espbt::ClientState::DISCONNECTING) {
+  if (this->state_ == espbt::ClientState::DISCONNECTING) {
     this->log_error_("Already disconnecting");
     return;
   }
@@ -170,7 +170,7 @@ void BLEClientBase::unconditional_disconnect() {
     this->log_gattc_warning_("esp_ble_gattc_close", err);
   }
 
-  if (this->state() == espbt::ClientState::DISCOVERED) {
+  if (this->state_ == espbt::ClientState::DISCOVERED) {
     this->set_address(0);
     this->set_state(espbt::ClientState::IDLE);
   } else {
@@ -295,18 +295,18 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       // ESP-IDF's BLE stack may send ESP_GATTC_OPEN_EVT after esp_ble_gattc_open() returns an
       // error, if the error occurred at the BTA/GATT layer. This can result in the event
       // arriving after we've already transitioned to IDLE state.
-      if (this->state() == espbt::ClientState::IDLE) {
+      if (this->state_ == espbt::ClientState::IDLE) {
         ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_OPEN_EVT in IDLE state (status=%d), ignoring", this->connection_index_,
                  this->address_str_, param->open.status);
         break;
       }
 
-      if (this->state() != espbt::ClientState::CONNECTING) {
+      if (this->state_ != espbt::ClientState::CONNECTING) {
         // This should not happen but lets log it in case it does
         // because it means we have a bad assumption about how the
         // ESP BT stack works.
         ESP_LOGE(TAG, "[%d] [%s] ESP_GATTC_OPEN_EVT in %s state (status=%d)", this->connection_index_,
-                 this->address_str_, espbt::client_state_to_string(this->state()), param->open.status);
+                 this->address_str_, espbt::client_state_to_string(this->state_), param->open.status);
       }
       if (param->open.status != ESP_GATT_OK && param->open.status != ESP_GATT_ALREADY_OPEN) {
         this->log_gattc_warning_("Connection open", param->open.status);
@@ -327,7 +327,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       if (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE) {
         // Cached connections already connected with medium parameters, no update needed
         // only set our state, subclients might have more stuff to do yet.
-        this->set_state_internal_(espbt::ClientState::ESTABLISHED);
+        this->state_ = espbt::ClientState::ESTABLISHED;
         break;
       }
       // For V3_WITHOUT_CACHE, we already set fast params before connecting
@@ -356,7 +356,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         return false;
       // Check if we were disconnected while waiting for service discovery
       if (param->disconnect.reason == ESP_GATT_CONN_TERMINATE_PEER_USER &&
-          this->state() == espbt::ClientState::CONNECTED) {
+          this->state_ == espbt::ClientState::CONNECTED) {
         this->log_warning_("Remote closed during discovery");
       } else {
         ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_DISCONNECT_EVT, reason 0x%02x", this->connection_index_, this->address_str_,
@@ -433,7 +433,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
 #endif
       }
       ESP_LOGI(TAG, "[%d] [%s] Service discovery complete", this->connection_index_, this->address_str_);
-      this->set_state_internal_(espbt::ClientState::ESTABLISHED);
+      this->state_ = espbt::ClientState::ESTABLISHED;
       break;
     }
     case ESP_GATTC_READ_DESCR_EVT: {

esphome/components/esp32_ble_client/ble_client_base.h

@@ -44,7 +44,7 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
   void unconditional_disconnect();
   void release_services();
 
-  bool connected() { return this->state() == espbt::ClientState::ESTABLISHED; }
+  bool connected() { return this->state_ == espbt::ClientState::ESTABLISHED; }
 
   void set_auto_connect(bool auto_connect) { this->auto_connect_ = auto_connect; }
 

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -105,13 +105,15 @@ void ESP32BLETracker::loop() {
   }
 
   // Check for scan timeout - moved here from scheduler to avoid false reboots
-  // when the loop is blocked. This must run every iteration for safety.
+  // when the loop is blocked
   if (this->scanner_state_ == ScannerState::RUNNING) {
     switch (this->scan_timeout_state_) {
       case ScanTimeoutState::MONITORING: {
+        uint32_t now = App.get_loop_component_start_time();
+        uint32_t timeout_ms = this->scan_duration_ * 2000;
         // Robust time comparison that handles rollover correctly
         // This works because unsigned arithmetic wraps around predictably
-        if ((App.get_loop_component_start_time() - this->scan_start_time_) > this->scan_timeout_ms_) {
+        if ((now - this->scan_start_time_) > timeout_ms) {
           // First time we've seen the timeout exceeded - wait one more loop iteration
           // This ensures all components have had a chance to process pending events
           // This is because esp32_ble may not have run yet and called
@@ -126,31 +128,13 @@ void ESP32BLETracker::loop() {
         ESP_LOGE(TAG, "Scan never terminated, rebooting");
         App.reboot();
         break;
+
       case ScanTimeoutState::INACTIVE:
+        // This case should be unreachable - scanner and timeout states are always synchronized
         break;
     }
   }
 
-  // Fast path: skip expensive client state counting and processing
-  // if no state has changed since last loop iteration.
-  //
-  // How state changes ensure we reach the code below:
-  // - handle_scanner_failure_(): scanner_state_ becomes FAILED via set_scanner_state_(), or
-  //   scan_set_param_failed_ requires scanner_state_==RUNNING which can only be reached via
-  //   set_scanner_state_(RUNNING) in gap_scan_start_complete_() (scan params are set during
-  //   STARTING, not RUNNING, so version is always incremented before this condition is true)
-  // - start_scan_(): scanner_state_ becomes IDLE via set_scanner_state_() in cleanup_scan_state_()
-  // - try_promote_discovered_clients_(): client enters DISCOVERED via set_state(), or
-  //   connecting client finishes (state change), or scanner reaches RUNNING/IDLE
-  //
-  // All conditions that affect the logic below are tied to state changes that increment
-  // state_version_, so the fast path is safe.
-  if (this->state_version_ == this->last_processed_version_) {
-    return;
-  }
-  this->last_processed_version_ = this->state_version_;
-
-  // State changed - do full processing
   ClientStateCounts counts = this->count_client_states_();
   if (counts != this->client_state_counts_) {
     this->client_state_counts_ = counts;
@@ -158,7 +142,6 @@ void ESP32BLETracker::loop() {
              this->client_state_counts_.discovered, this->client_state_counts_.disconnecting);
   }
 
-  // Scanner failure: reached when set_scanner_state_(FAILED) or scan_set_param_failed_ set
   if (this->scanner_state_ == ScannerState::FAILED ||
       (this->scan_set_param_failed_ && this->scanner_state_ == ScannerState::RUNNING)) {
     this->handle_scanner_failure_();
@@ -177,8 +160,6 @@ void ESP32BLETracker::loop() {
 
   */
 
-  // Start scan: reached when scanner_state_ becomes IDLE (via set_scanner_state_()) and
-  // all clients are idle (their state changes increment version when they finish)
   if (this->scanner_state_ == ScannerState::IDLE && !counts.connecting && !counts.disconnecting && !counts.discovered) {
 #ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
     this->update_coex_preference_(false);
@@ -187,9 +168,8 @@ void ESP32BLETracker::loop() {
       this->start_scan_(false);  // first = false
     }
   }
-  // Promote discovered clients: reached when a client's state becomes DISCOVERED (via set_state()),
-  // or when a blocking condition clears (connecting client finishes, scanner reaches RUNNING/IDLE).
-  // All these trigger state_version_ increment, so we'll process and check promotion eligibility.
+  // If there is a discovered client and no connecting
+  // clients, then promote the discovered client to ready to connect.
   // We check both RUNNING and IDLE states because:
   // - RUNNING: gap_scan_event_handler initiates stop_scan_() but promotion can happen immediately
   // - IDLE: Scanner has already stopped (naturally or by gap_scan_event_handler)
@@ -256,7 +236,6 @@ void ESP32BLETracker::start_scan_(bool first) {
   // Start timeout monitoring in loop() instead of using scheduler
   // This prevents false reboots when the loop is blocked
   this->scan_start_time_ = App.get_loop_component_start_time();
-  this->scan_timeout_ms_ = this->scan_duration_ * 2000;
   this->scan_timeout_state_ = ScanTimeoutState::MONITORING;
 
   esp_err_t err = esp_ble_gap_set_scan_params(&this->scan_params_);
@@ -274,10 +253,6 @@ void ESP32BLETracker::start_scan_(bool first) {
 void ESP32BLETracker::register_client(ESPBTClient *client) {
 #ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
   client->app_id = ++this->app_id_;
-  // Give client a pointer to our state_version_ so it can notify us of state changes.
-  // This enables loop() fast-path optimization - we skip expensive work when no state changed.
-  // Safe because ESP32BLETracker (singleton) outlives all registered clients.
-  client->set_tracker_state_version(&this->state_version_);
   this->clients_.push_back(client);
   this->recalculate_advertisement_parser_types();
 #endif
@@ -407,7 +382,6 @@ void ESP32BLETracker::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_i
 
 void ESP32BLETracker::set_scanner_state_(ScannerState state) {
   this->scanner_state_ = state;
-  this->state_version_++;
   for (auto *listener : this->scanner_state_listeners_) {
     listener->on_scanner_state(state);
   }

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -216,19 +216,6 @@ enum class ConnectionType : uint8_t {
   V3_WITHOUT_CACHE
 };
 
-/// Base class for BLE GATT clients that connect to remote devices.
-///
-/// State Change Tracking Design:
-/// -----------------------------
-/// ESP32BLETracker::loop() needs to know when client states change to avoid
-/// expensive polling. Rather than checking all clients every iteration (~7000/min),
-/// we use a version counter owned by ESP32BLETracker that clients increment on
-/// state changes. The tracker compares versions to skip work when nothing changed.
-///
-/// Ownership: ESP32BLETracker owns state_version_. Clients hold a non-owning
-/// pointer (tracker_state_version_) set during register_client(). Clients
-/// increment the counter through this pointer when their state changes.
-/// The pointer may be null if the client is not registered with a tracker.
 class ESPBTClient : public ESPBTDeviceListener {
  public:
   virtual bool gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
@@ -238,49 +225,26 @@ class ESPBTClient : public ESPBTDeviceListener {
   virtual void disconnect() = 0;
   bool disconnect_pending() const { return this->want_disconnect_; }
   void cancel_pending_disconnect() { this->want_disconnect_ = false; }
-
-  /// Set the client state with IDLE handling (clears want_disconnect_).
-  /// Notifies the tracker of state change for loop optimization.
   virtual void set_state(ClientState st) {
-    this->set_state_internal_(st);
+    this->state_ = st;
     if (st == ClientState::IDLE) {
       this->want_disconnect_ = false;
     }
   }
-  ClientState state() const { return this->state_; }
-
-  /// Called by ESP32BLETracker::register_client() to enable state change notifications.
-  /// The pointer must remain valid for the lifetime of the client (guaranteed since
-  /// ESP32BLETracker is a singleton that outlives all clients).
-  void set_tracker_state_version(uint8_t *version) { this->tracker_state_version_ = version; }
+  ClientState state() const { return state_; }
 
   // Memory optimized layout
   uint8_t app_id;  // App IDs are small integers assigned sequentially
 
  protected:
-  /// Set state without IDLE handling - use for direct state transitions.
-  /// Increments the tracker's state version counter to signal that loop()
-  /// should do full processing on the next iteration.
-  void set_state_internal_(ClientState st) {
-    this->state_ = st;
-    // Notify tracker that state changed (tracker_state_version_ is owned by ESP32BLETracker)
-    if (this->tracker_state_version_ != nullptr) {
-      (*this->tracker_state_version_)++;
-    }
-  }
-
+  // Group 1: 1-byte types
+  ClientState state_{ClientState::INIT};
   // want_disconnect_ is set to true when a disconnect is requested
   // while the client is connecting. This is used to disconnect the
   // client as soon as we get the connection id (conn_id_) from the
   // ESP_GATTC_OPEN_EVT event.
   bool want_disconnect_{false};
-
- private:
-  ClientState state_{ClientState::INIT};
-  /// Non-owning pointer to ESP32BLETracker::state_version_. When this client's
-  /// state changes, we increment the tracker's counter to signal that loop()
-  /// should perform full processing. Null if client not registered with tracker.
-  uint8_t *tracker_state_version_{nullptr};
+  // 2 bytes used, 2 bytes padding
 };
 
 class ESP32BLETracker : public Component,
@@ -416,16 +380,6 @@ class ESP32BLETracker : public Component,
   // Group 4: 1-byte types (enums, uint8_t, bool)
   uint8_t app_id_{0};
   uint8_t scan_start_fail_count_{0};
-  /// Version counter for loop() fast-path optimization. Incremented when:
-  /// - Scanner state changes (via set_scanner_state_())
-  /// - Any registered client's state changes (clients hold pointer to this counter)
-  /// Owned by this class; clients receive non-owning pointer via register_client().
-  /// When loop() sees state_version_ == last_processed_version_, it skips expensive
-  /// client state counting and takes the fast path (just timeout check + return).
-  uint8_t state_version_{0};
-  /// Last state_version_ value when loop() did full processing. Compared against
-  /// state_version_ to detect if any state changed since last iteration.
-  uint8_t last_processed_version_{0};
   ScannerState scanner_state_{ScannerState::IDLE};
   bool scan_continuous_;
   bool scan_active_;
@@ -442,8 +396,6 @@ class ESP32BLETracker : public Component,
     EXCEEDED_WAIT,  // Timeout exceeded, waiting one loop before reboot
   };
   uint32_t scan_start_time_{0};
-  /// Precomputed timeout value: scan_duration_ * 2000
-  uint32_t scan_timeout_ms_{0};
   ScanTimeoutState scan_timeout_state_{ScanTimeoutState::INACTIVE};
 };
 

esphome/components/ezo_pmp/ezo_pmp.cpp

@@ -318,93 +318,90 @@ void EzoPMP::send_next_command_() {
   switch (this->next_command_) {
     // Read Commands
     case EZO_PMP_COMMAND_READ_DOSING:  // Page 54
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "D,?");
+      command_buffer_length = sprintf((char *) command_buffer, "D,?");
       break;
 
     case EZO_PMP_COMMAND_READ_SINGLE_REPORT:  // Single Report (page 53)
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "R");
+      command_buffer_length = sprintf((char *) command_buffer, "R");
       break;
 
     case EZO_PMP_COMMAND_READ_MAX_FLOW_RATE:
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "DC,?");
+      command_buffer_length = sprintf((char *) command_buffer, "DC,?");
       break;
 
     case EZO_PMP_COMMAND_READ_PAUSE_STATUS:
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "P,?");
+      command_buffer_length = sprintf((char *) command_buffer, "P,?");
       break;
 
     case EZO_PMP_COMMAND_READ_TOTAL_VOLUME_DOSED:
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "TV,?");
+      command_buffer_length = sprintf((char *) command_buffer, "TV,?");
       break;
 
     case EZO_PMP_COMMAND_READ_ABSOLUTE_TOTAL_VOLUME_DOSED:
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "ATV,?");
+      command_buffer_length = sprintf((char *) command_buffer, "ATV,?");
       break;
 
     case EZO_PMP_COMMAND_READ_CALIBRATION_STATUS:
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "Cal,?");
+      command_buffer_length = sprintf((char *) command_buffer, "Cal,?");
       break;
 
     case EZO_PMP_COMMAND_READ_PUMP_VOLTAGE:
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "PV,?");
+      command_buffer_length = sprintf((char *) command_buffer, "PV,?");
       break;
 
       // Non-Read Commands
 
     case EZO_PMP_COMMAND_FIND:  // Find (page 52)
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "Find");
+      command_buffer_length = sprintf((char *) command_buffer, "Find");
       wait_time_for_command = 60000;  // This command will block all updates for a minute
       break;
 
     case EZO_PMP_COMMAND_DOSE_CONTINUOUSLY:  // Continuous Dispensing (page 54)
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "D,*");
+      command_buffer_length = sprintf((char *) command_buffer, "D,*");
       break;
 
     case EZO_PMP_COMMAND_CLEAR_TOTAL_VOLUME_DOSED:  // Clear Total Volume Dosed (page 64)
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "Clear");
+      command_buffer_length = sprintf((char *) command_buffer, "Clear");
       break;
 
     case EZO_PMP_COMMAND_CLEAR_CALIBRATION:  // Clear Calibration (page 65)
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "Cal,clear");
+      command_buffer_length = sprintf((char *) command_buffer, "Cal,clear");
       break;
 
     case EZO_PMP_COMMAND_PAUSE_DOSING:  // Pause (page 61)
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "P");
+      command_buffer_length = sprintf((char *) command_buffer, "P");
       break;
 
     case EZO_PMP_COMMAND_STOP_DOSING:  // Stop (page 62)
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "X");
+      command_buffer_length = sprintf((char *) command_buffer, "X");
       break;
 
       // Non-Read commands with parameters
 
     case EZO_PMP_COMMAND_DOSE_VOLUME:  // Volume Dispensing (page 55)
-      command_buffer_length =
-          snprintf((char *) command_buffer, sizeof(command_buffer), "D,%0.1f", this->next_command_volume_);
+      command_buffer_length = sprintf((char *) command_buffer, "D,%0.1f", this->next_command_volume_);
       break;
 
     case EZO_PMP_COMMAND_DOSE_VOLUME_OVER_TIME:  // Dose over time (page 56)
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "D,%0.1f,%i",
-                                       this->next_command_volume_, this->next_command_duration_);
+      command_buffer_length =
+          sprintf((char *) command_buffer, "D,%0.1f,%i", this->next_command_volume_, this->next_command_duration_);
       break;
 
     case EZO_PMP_COMMAND_DOSE_WITH_CONSTANT_FLOW_RATE:  // Constant Flow Rate (page 57)
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "DC,%0.1f,%i",
-                                       this->next_command_volume_, this->next_command_duration_);
+      command_buffer_length =
+          sprintf((char *) command_buffer, "DC,%0.1f,%i", this->next_command_volume_, this->next_command_duration_);
       break;
 
     case EZO_PMP_COMMAND_SET_CALIBRATION_VOLUME:  // Set Calibration Volume (page 65)
-      command_buffer_length =
-          snprintf((char *) command_buffer, sizeof(command_buffer), "Cal,%0.2f", this->next_command_volume_);
+      command_buffer_length = sprintf((char *) command_buffer, "Cal,%0.2f", this->next_command_volume_);
       break;
 
     case EZO_PMP_COMMAND_CHANGE_I2C_ADDRESS:  // Change I2C Address (page 73)
-      command_buffer_length =
-          snprintf((char *) command_buffer, sizeof(command_buffer), "I2C,%i", this->next_command_duration_);
+      command_buffer_length = sprintf((char *) command_buffer, "I2C,%i", this->next_command_duration_);
       break;
 
     case EZO_PMP_COMMAND_EXEC_ARBITRARY_COMMAND_ADDRESS:  // Run an arbitrary command
-      command_buffer_length = snprintf((char *) command_buffer, sizeof(command_buffer), "%s", this->arbitrary_command_);
+      command_buffer_length = sprintf((char *) command_buffer, this->arbitrary_command_, this->next_command_duration_);
       ESP_LOGI(TAG, "Sending arbitrary command: %s", (char *) command_buffer);
       break;
 

esphome/components/hc8/sensor.py

@@ -6,7 +6,6 @@ from esphome.const import (
     CONF_BASELINE,
     CONF_CO2,
     CONF_ID,
-    CONF_WARMUP_TIME,
     DEVICE_CLASS_CARBON_DIOXIDE,
     ICON_MOLECULE_CO2,
     STATE_CLASS_MEASUREMENT,
@@ -15,6 +14,8 @@ from esphome.const import (
 
 DEPENDENCIES = ["uart"]
 
+CONF_WARMUP_TIME = "warmup_time"
+
 hc8_ns = cg.esphome_ns.namespace("hc8")
 HC8Component = hc8_ns.class_("HC8Component", cg.PollingComponent, uart.UARTDevice)
 HC8CalibrateAction = hc8_ns.class_("HC8CalibrateAction", automation.Action)

esphome/components/heatpumpir/climate.py

@@ -107,7 +107,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Required(CONF_MAX_TEMPERATURE): cv.temperature,
         }
     ),
-    cv.Any(cv.only_with_arduino, cv.only_on_esp32),
+    cv.only_with_arduino,
 )
 
 
@@ -126,6 +126,6 @@ async def to_code(config):
     cg.add(var.set_max_temperature(config[CONF_MAX_TEMPERATURE]))
     cg.add(var.set_min_temperature(config[CONF_MIN_TEMPERATURE]))
 
-    cg.add_library("tonia/HeatpumpIR", "1.0.40")
+    cg.add_library("tonia/HeatpumpIR", "1.0.37")
     if CORE.is_libretiny or CORE.is_esp32:
         CORE.add_platformio_option("lib_ignore", ["IRremoteESP8266"])

esphome/components/heatpumpir/heatpumpir.cpp

@@ -1,6 +1,6 @@
 #include "heatpumpir.h"
 
-#if defined(USE_ARDUINO) || defined(USE_ESP32)
+#ifdef USE_ARDUINO
 
 #include <map>
 #include "ir_sender_esphome.h"

esphome/components/heatpumpir/heatpumpir.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#if defined(USE_ARDUINO) || defined(USE_ESP32)
+#ifdef USE_ARDUINO
 
 #include "esphome/components/climate_ir/climate_ir.h"
 

esphome/components/heatpumpir/ir_sender_esphome.cpp

@@ -1,6 +1,6 @@
 #include "ir_sender_esphome.h"
 
-#if defined(USE_ARDUINO) || defined(USE_ESP32)
+#ifdef USE_ARDUINO
 
 namespace esphome {
 namespace heatpumpir {

esphome/components/heatpumpir/ir_sender_esphome.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#if defined(USE_ARDUINO) || defined(USE_ESP32)
+#ifdef USE_ARDUINO
 
 #include "esphome/components/remote_base/remote_base.h"
 #include <IRSender.h>  // arduino-heatpump library

esphome/components/http_request/__init__.py

@@ -157,7 +157,6 @@ async def to_code(config):
     if CORE.is_esp32:
         cg.add(var.set_buffer_size_rx(config[CONF_BUFFER_SIZE_RX]))
         cg.add(var.set_buffer_size_tx(config[CONF_BUFFER_SIZE_TX]))
-        cg.add(var.set_verify_ssl(config[CONF_VERIFY_SSL]))
 
         if config.get(CONF_VERIFY_SSL):
             esp32.add_idf_sdkconfig_option("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", True)

esphome/components/http_request/http_request_idf.cpp

@@ -89,7 +89,7 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
   config.max_redirection_count = this->redirect_limit_;
   config.auth_type = HTTP_AUTH_TYPE_BASIC;
 #if CONFIG_MBEDTLS_CERTIFICATE_BUNDLE
-  if (secure && this->verify_ssl_) {
+  if (secure) {
     config.crt_bundle_attach = esp_crt_bundle_attach;
   }
 #endif

esphome/components/http_request/http_request_idf.h

@@ -34,7 +34,6 @@ class HttpRequestIDF : public HttpRequestComponent {
 
   void set_buffer_size_rx(uint16_t buffer_size_rx) { this->buffer_size_rx_ = buffer_size_rx; }
   void set_buffer_size_tx(uint16_t buffer_size_tx) { this->buffer_size_tx_ = buffer_size_tx; }
-  void set_verify_ssl(bool verify_ssl) { this->verify_ssl_ = verify_ssl; }
 
  protected:
   std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method, const std::string &body,
@@ -43,7 +42,6 @@ class HttpRequestIDF : public HttpRequestComponent {
   // if zero ESP-IDF will use DEFAULT_HTTP_BUF_SIZE
   uint16_t buffer_size_rx_{};
   uint16_t buffer_size_tx_{};
-  bool verify_ssl_{true};
 
   /// @brief Monitors the http client events to gather response headers
   static esp_err_t http_event_handler(esp_http_client_event_t *evt);

esphome/components/json/__init__.py

@@ -1,6 +1,6 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CoroPriority, coroutine_with_priority
 
 CODEOWNERS = ["@esphome/core"]
 json_ns = cg.esphome_ns.namespace("json")
@@ -12,11 +12,6 @@ CONFIG_SCHEMA = cv.All(
 
 @coroutine_with_priority(CoroPriority.BUS)
 async def to_code(config):
-    if CORE.is_esp32:
-        from esphome.components.esp32 import add_idf_component
-
-        add_idf_component(name="bblanchon/arduinojson", ref="7.4.2")
-    else:
-        cg.add_library("bblanchon/ArduinoJson", "7.4.2")
+    cg.add_library("bblanchon/ArduinoJson", "7.4.2")
     cg.add_define("USE_JSON")
     cg.add_global(json_ns.using)

esphome/components/libretiny/__init__.py

@@ -382,11 +382,4 @@ async def component_to_code(config):
             "custom_options.sys_config#h", _BK7231N_SYS_CONFIG_OPTIONS
         )
 
-    # Disable LWIP statistics to save RAM - not needed in production
-    # Must explicitly disable all sub-stats to avoid redefinition warnings
-    cg.add_platformio_option(
-        "custom_options.lwip",
-        ["LWIP_STATS=0", "MEM_STATS=0", "MEMP_STATS=0"],
-    )
-
     await cg.register_component(var, config)

esphome/components/libretiny/preferences.cpp

@@ -166,8 +166,8 @@ class LibreTinyPreferences : public ESPPreferences {
       return true;
     }
 
-    // Most preferences are small, use stack buffer with heap fallback for large ones
-    SmallBufferWithHeapFallback<256> stored_data(kv.value_len);
+    // Allocate buffer on heap to avoid stack allocation for large data
+    auto stored_data = std::make_unique<uint8_t[]>(kv.value_len);
     fdb_blob_make(&this->blob, stored_data.get(), kv.value_len);
     size_t actual_len = fdb_kv_get_blob(db, key_str, &this->blob);
     if (actual_len != kv.value_len) {

esphome/components/lightwaverf/lightwaverf.cpp

@@ -1,4 +1,3 @@
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 #ifdef USE_ESP8266
@@ -45,16 +44,13 @@ void LightWaveRF::send_rx(const std::vector<uint8_t> &msg, uint8_t repeats, bool
 }
 
 void LightWaveRF::print_msg_(uint8_t *msg, uint8_t len) {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG
-  char buffer[65];  // max 10 entries * 6 chars + null
+  char buffer[65];
   ESP_LOGD(TAG, " Received code (len:%i): ", len);
 
-  size_t pos = 0;
   for (int i = 0; i < len; i++) {
-    pos = buf_append_printf(buffer, sizeof(buffer), pos, "0x%02x, ", msg[i]);
+    sprintf(&buffer[i * 6], "0x%02x, ", msg[i]);
   }
   ESP_LOGD(TAG, "[%s]", buffer);
-#endif
 }
 
 void LightWaveRF::dump_config() {

esphome/components/lock/lock.cpp

@@ -28,14 +28,16 @@ const LogString *lock_state_to_string(LockState state) {
 Lock::Lock() : state(LOCK_STATE_NONE) {}
 LockCall Lock::make_call() { return LockCall(this); }
 
-void Lock::set_state_(LockState state) {
+void Lock::lock() {
   auto call = this->make_call();
-  call.set_state(state);
+  call.set_state(LOCK_STATE_LOCKED);
+  this->control(call);
+}
+void Lock::unlock() {
+  auto call = this->make_call();
+  call.set_state(LOCK_STATE_UNLOCKED);
   this->control(call);
 }
-
-void Lock::lock() { this->set_state_(LOCK_STATE_LOCKED); }
-void Lock::unlock() { this->set_state_(LOCK_STATE_UNLOCKED); }
 void Lock::open() {
   if (traits.get_supports_open()) {
     ESP_LOGD(TAG, "'%s' Opening.", this->get_name().c_str());

esphome/components/lock/lock.h

@@ -156,9 +156,6 @@ class Lock : public EntityBase {
  protected:
   friend LockCall;
 
-  /// Helper for lock/unlock convenience methods
-  void set_state_(LockState state);
-
   /** Perform the open latch action with hardware. This method is optional to implement
    * when creating a new lock.
    *

esphome/components/logger/logger.cpp

@@ -1,5 +1,8 @@
 #include "logger.h"
 #include <cinttypes>
+#ifdef USE_ESPHOME_TASK_LOG_BUFFER
+#include <memory>  // For unique_ptr
+#endif
 
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
@@ -196,8 +199,7 @@ inline uint8_t Logger::level_for(const char *tag) {
 
 Logger::Logger(uint32_t baud_rate, size_t tx_buffer_size) : baud_rate_(baud_rate), tx_buffer_size_(tx_buffer_size) {
   // add 1 to buffer size for null terminator
-  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) - allocated once, never freed
-  this->tx_buffer_ = new char[this->tx_buffer_size_ + 1];
+  this->tx_buffer_ = new char[this->tx_buffer_size_ + 1];  // NOLINT
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
   this->main_task_ = xTaskGetCurrentTaskHandle();
 #elif defined(USE_ZEPHYR)
@@ -210,14 +212,11 @@ Logger::Logger(uint32_t baud_rate, size_t tx_buffer_size) : baud_rate_(baud_rate
 void Logger::init_log_buffer(size_t total_buffer_size) {
 #ifdef USE_HOST
   // Host uses slot count instead of byte size
-  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) - allocated once, never freed
-  this->log_buffer_ = new logger::TaskLogBufferHost(total_buffer_size);
+  this->log_buffer_ = esphome::make_unique<logger::TaskLogBufferHost>(total_buffer_size);
 #elif defined(USE_ESP32)
-  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) - allocated once, never freed
-  this->log_buffer_ = new logger::TaskLogBuffer(total_buffer_size);
+  this->log_buffer_ = esphome::make_unique<logger::TaskLogBuffer>(total_buffer_size);
 #elif defined(USE_LIBRETINY)
-  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) - allocated once, never freed
-  this->log_buffer_ = new logger::TaskLogBufferLibreTiny(total_buffer_size);
+  this->log_buffer_ = esphome::make_unique<logger::TaskLogBufferLibreTiny>(total_buffer_size);
 #endif
 
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)

esphome/components/logger/logger.h

@@ -412,11 +412,11 @@ class Logger : public Component {
 #endif
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
 #ifdef USE_HOST
-  logger::TaskLogBufferHost *log_buffer_{nullptr};  // Allocated once, never freed
+  std::unique_ptr<logger::TaskLogBufferHost> log_buffer_;  // Will be initialized with init_log_buffer
 #elif defined(USE_ESP32)
-  logger::TaskLogBuffer *log_buffer_{nullptr};  // Allocated once, never freed
+  std::unique_ptr<logger::TaskLogBuffer> log_buffer_;  // Will be initialized with init_log_buffer
 #elif defined(USE_LIBRETINY)
-  logger::TaskLogBufferLibreTiny *log_buffer_{nullptr};  // Allocated once, never freed
+  std::unique_ptr<logger::TaskLogBufferLibreTiny> log_buffer_;  // Will be initialized with init_log_buffer
 #endif
 #endif
 

esphome/components/lvgl/widgets/dropdown.py

@@ -1,4 +1,3 @@
-from esphome import codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_OPTIONS
 
@@ -25,34 +24,6 @@ from .label import CONF_LABEL
 CONF_DROPDOWN = "dropdown"
 CONF_DROPDOWN_LIST = "dropdown_list"
 
-# Example valid dropdown symbol (left arrow) for error messages
-EXAMPLE_DROPDOWN_SYMBOL = "\U00002190"  # ←
-
-
-def dropdown_symbol_validator(value):
-    """
-    Validate that the dropdown symbol is a single Unicode character
-    with a codepoint of 0x100 (256) or greater.
-    This is required because LVGL uses codepoints below 0x100 for internal symbols.
-    """
-    value = cv.string(value)
-    # len(value) counts Unicode code points, not grapheme clusters or bytes
-    if len(value) != 1:
-        raise cv.Invalid(
-            f"Dropdown symbol must be a single character, got '{value}' with length {len(value)}"
-        )
-    codepoint = ord(value)
-    if codepoint < 0x100:
-        # Format the example symbol as a Unicode escape for the error message
-        example_escape = f"\\U{ord(EXAMPLE_DROPDOWN_SYMBOL):08X}"
-        raise cv.Invalid(
-            f"Dropdown symbol must have a Unicode codepoint of 0x100 (256) or greater. "
-            f"'{value}' has codepoint {codepoint} (0x{codepoint:X}). "
-            f"Use a character like '{example_escape}' ({EXAMPLE_DROPDOWN_SYMBOL}) or other Unicode symbols with codepoint >= 0x100."
-        )
-    return value
-
-
 lv_dropdown_t = LvSelect("LvDropdownType", parents=(LvCompound,))
 
 lv_dropdown_list_t = LvType("lv_dropdown_list_t")
@@ -62,7 +33,7 @@ dropdown_list_spec = WidgetType(
 
 DROPDOWN_BASE_SCHEMA = cv.Schema(
     {
-        cv.Optional(CONF_SYMBOL): dropdown_symbol_validator,
+        cv.Optional(CONF_SYMBOL): lv_text,
         cv.Exclusive(CONF_SELECTED_INDEX, CONF_SELECTED_TEXT): lv_int,
         cv.Exclusive(CONF_SELECTED_TEXT, CONF_SELECTED_TEXT): lv_text,
         cv.Optional(CONF_DROPDOWN_LIST): part_schema(dropdown_list_spec.parts),
@@ -99,7 +70,7 @@ class DropdownType(WidgetType):
         if options := config.get(CONF_OPTIONS):
             lv_add(w.var.set_options(options))
         if symbol := config.get(CONF_SYMBOL):
-            lv.dropdown_set_symbol(w.var.obj, cg.safe_exp(symbol))
+            lv.dropdown_set_symbol(w.var.obj, await lv_text.process(symbol))
         if (selected := config.get(CONF_SELECTED_INDEX)) is not None:
             value = await lv_int.process(selected)
             lv_add(w.var.set_selected_index(value, literal("LV_ANIM_OFF")))

esphome/components/mapping/mapping.h

@@ -2,7 +2,6 @@
 
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include <cinttypes>
 #include <map>
 #include <string>
 
@@ -44,17 +43,8 @@ template<typename K, typename V> class Mapping {
       esph_log_e(TAG, "Key '%p' not found in mapping", key);
     } else if constexpr (std::is_same_v<K, std::string>) {
       esph_log_e(TAG, "Key '%s' not found in mapping", key.c_str());
-    } else if constexpr (std::is_integral_v<K>) {
-      char buf[24];  // enough for 64-bit integer
-      if constexpr (std::is_unsigned_v<K>) {
-        buf_append_printf(buf, sizeof(buf), 0, "%" PRIu64, static_cast<uint64_t>(key));
-      } else {
-        buf_append_printf(buf, sizeof(buf), 0, "%" PRId64, static_cast<int64_t>(key));
-      }
-      esph_log_e(TAG, "Key '%s' not found in mapping", buf);
     } else {
-      // All supported key types are handled above - this should never be reached
-      static_assert(sizeof(K) == 0, "Unsupported key type for Mapping error logging");
+      esph_log_e(TAG, "Key '%s' not found in mapping", to_string(key).c_str());
     }
     return {};
   }

esphome/components/mdns/mdns_esp32.cpp

@@ -24,14 +24,13 @@ static void register_esp32(MDNSComponent *comp, StaticVector<MDNSService, MDNS_S
   mdns_instance_name_set(hostname);
 
   for (const auto &service : services) {
-    // Stack buffer for up to 16 txt records, heap fallback for more
-    SmallBufferWithHeapFallback<16, mdns_txt_item_t> txt_records(service.txt_records.size());
+    auto txt_records = std::make_unique<mdns_txt_item_t[]>(service.txt_records.size());
     for (size_t i = 0; i < service.txt_records.size(); i++) {
       const auto &record = service.txt_records[i];
       // key and value are either compile-time string literals in flash or pointers to dynamic_txt_values_
       // Both remain valid for the lifetime of this function, and ESP-IDF makes internal copies
-      txt_records.get()[i].key = MDNS_STR_ARG(record.key);
-      txt_records.get()[i].value = MDNS_STR_ARG(record.value);
+      txt_records[i].key = MDNS_STR_ARG(record.key);
+      txt_records[i].value = MDNS_STR_ARG(record.value);
     }
     uint16_t port = const_cast<TemplatableValue<uint16_t> &>(service.port).value();
     err = mdns_service_add(nullptr, MDNS_STR_ARG(service.service_type), MDNS_STR_ARG(service.proto), port,

esphome/components/mhz19/sensor.py

@@ -7,7 +7,6 @@ from esphome.const import (
     CONF_CO2,
     CONF_ID,
     CONF_TEMPERATURE,
-    CONF_WARMUP_TIME,
     DEVICE_CLASS_CARBON_DIOXIDE,
     DEVICE_CLASS_TEMPERATURE,
     ICON_MOLECULE_CO2,
@@ -19,6 +18,7 @@ from esphome.const import (
 DEPENDENCIES = ["uart"]
 
 CONF_AUTOMATIC_BASELINE_CALIBRATION = "automatic_baseline_calibration"
+CONF_WARMUP_TIME = "warmup_time"
 CONF_DETECTION_RANGE = "detection_range"
 
 mhz19_ns = cg.esphome_ns.namespace("mhz19")

esphome/components/mipi_spi/mipi_spi.h

@@ -224,9 +224,12 @@ class MipiSpi : public display::Display,
                     this->madctl_ & MADCTL_BGR ? "BGR" : "RGB", DISPLAYPIXEL * 8, IS_BIG_ENDIAN ? "Big" : "Little");
     if (this->brightness_.has_value())
       esph_log_config(TAG, "  Brightness: %u", this->brightness_.value());
-    log_pin(TAG, "  CS Pin: ", this->cs_);
-    log_pin(TAG, "  Reset Pin: ", this->reset_pin_);
-    log_pin(TAG, "  DC Pin: ", this->dc_pin_);
+    if (this->cs_ != nullptr)
+      esph_log_config(TAG, "  CS Pin: %s", this->cs_->dump_summary().c_str());
+    if (this->reset_pin_ != nullptr)
+      esph_log_config(TAG, "  Reset Pin: %s", this->reset_pin_->dump_summary().c_str());
+    if (this->dc_pin_ != nullptr)
+      esph_log_config(TAG, "  DC Pin: %s", this->dc_pin_->dump_summary().c_str());
     esph_log_config(TAG,
                     "  SPI Mode: %d\n"
                     "  SPI Data rate: %dMHz\n"

esphome/components/mipi_spi/models/adafruit.py

@@ -26,3 +26,5 @@ ST7789V.extend(
     reset_pin=40,
     invert_colors=True,
 )
+
+models = {}

esphome/components/mipi_spi/models/amoled.py

@@ -105,3 +105,6 @@ CO5300 = DriverChip(
         (WCE, 0x00),
     ),
 )
+
+
+models = {}

esphome/components/mipi_spi/models/cyd.py

@@ -1,45 +1,10 @@
-from .ili import ILI9341, ILI9342, ST7789V
+from .ili import ILI9341
 
 ILI9341.extend(
-    # ESP32-2432S028 CYD board with Micro USB, has ILI9341 controller
     "ESP32-2432S028",
     data_rate="40MHz",
-    cs_pin={"number": 15, "ignore_strapping_warning": True},
-    dc_pin={"number": 2, "ignore_strapping_warning": True},
+    cs_pin=15,
+    dc_pin=2,
 )
 
-ST7789V.extend(
-    # ESP32-2432S028 CYD board with USB C + Micro USB, has ST7789V controller
-    "ESP32-2432S028-7789",
-    data_rate="40MHz",
-    cs_pin={"number": 15, "ignore_strapping_warning": True},
-    dc_pin={"number": 2, "ignore_strapping_warning": True},
-)
-
-# fmt: off
-
-ILI9342.extend(
-    # ESP32-2432S028 CYD board with USB C + Micro USB, has ILI9342 controller
-    "ESP32-2432S028-9342",
-    data_rate="40MHz",
-    cs_pin={"number": 15, "ignore_strapping_warning": True},
-    dc_pin={"number": 2, "ignore_strapping_warning": True},
-    initsequence=(
-        (0xCB, 0x39, 0x2C, 0x00, 0x34, 0x02),  # Power Control A
-        (0xCF, 0x00, 0xC1, 0x30),  # Power Control B
-        (0xE8, 0x85, 0x00, 0x78),  # Driver timing control A
-        (0xEA, 0x00, 0x00),  # Driver timing control B
-        (0xED, 0x64, 0x03, 0x12, 0x81),  # Power on sequence control
-        (0xF7, 0x20),  # Pump ratio control
-        (0xC0, 0x23),  # Power Control 1
-        (0xC1, 0x10),  # Power Control 2
-        (0xC5, 0x3E, 0x28),  # VCOM Control 1
-        (0xC7, 0x86),  # VCOM Control 2
-        (0xB1, 0x00, 0x1B),  # Frame Rate Control
-        (0xB6, 0x0A, 0xA2, 0x27, 0x00),  # Display Function Control
-        (0xF2, 0x00),  # Enable 3G
-        (0x26, 0x01),  # Gamma Set
-        (0xE0, 0x00, 0x0C, 0x11, 0x04, 0x11, 0x08, 0x37, 0x89, 0x4C, 0x06, 0x0C, 0x0A, 0x2E, 0x34, 0x0F),  # Positive Gamma Correction
-        (0xE1, 0x00, 0x0B, 0x11, 0x05, 0x13, 0x09, 0x33, 0x67, 0x48, 0x07, 0x0E, 0x0B, 0x23, 0x33, 0x0F),  # Negative Gamma Correction
-    )
-)
+models = {}

esphome/components/mipi_spi/models/ili.py

@@ -148,34 +148,6 @@ ILI9341 = DriverChip(
         ),
     ),
 )
-
-# fmt: off
-
-ILI9342 = DriverChip(
-    "ILI9342",
-    width=320,
-    height=240,
-    mirror_x=True,
-    initsequence=(
-        (0xCB, 0x39, 0x2C, 0x00, 0x34, 0x02),  # Power Control A
-        (0xCF, 0x00, 0xC1, 0x30),  # Power Control B
-        (0xE8, 0x85, 0x00, 0x78),  # Driver timing control A
-        (0xEA, 0x00, 0x00),  # Driver timing control B
-        (0xED, 0x64, 0x03, 0x12, 0x81),  # Power on sequence control
-        (0xF7, 0x20),  # Pump ratio control
-        (0xC0, 0x23),  # Power Control 1
-        (0xC1, 0x10),  # Power Control 2
-        (0xC5, 0x3E, 0x28),  # VCOM Control 1
-        (0xC7, 0x86),  # VCOM Control 2
-        (0xB1, 0x00, 0x1B),  # Frame Rate Control
-        (0xB6, 0x0A, 0xA2, 0x27, 0x00),  # Display Function Control
-        (0xF2, 0x00),  # Enable 3G
-        (0x26, 0x01),  # Gamma Set
-        (0xE0, 0x0F, 0x1F, 0x1C, 0x0C, 0x0F, 0x08, 0x48, 0x98, 0x37, 0x0A, 0x13, 0x04, 0x11, 0x0D, 0x00),  # Positive Gamma
-        (0xE1, 0x0F, 0x32, 0x2E, 0x0B, 0x0D, 0x05, 0x47, 0x75, 0x37, 0x06, 0x10, 0x03, 0x24, 0x20, 0x00),  # Negative Gamma
-    ),
-)
-
 # M5Stack Core2 uses ILI9341 chip - mirror_x disabled for correct orientation
 ILI9341.extend(
     "M5CORE2",
@@ -786,3 +758,5 @@ ST7796.extend(
     dc_pin=0,
     invert_colors=True,
 )
+
+models = {}

esphome/components/mipi_spi/models/jc.py

@@ -588,3 +588,5 @@ DriverChip(
         (0x29, 0x00),
     ),
 )
+
+models = {}

esphome/components/mipi_spi/models/lanbon.py

@@ -11,3 +11,5 @@ ST7789V.extend(
     dc_pin=21,
     reset_pin=18,
 )
+
+models = {}

esphome/components/mipi_spi/models/lilygo.py

@@ -56,3 +56,5 @@ ST7796.extend(
     backlight_pin=48,
     invert_colors=True,
 )
+
+models = {}

esphome/components/mqtt/custom_mqtt_device.cpp

@@ -18,7 +18,7 @@ bool CustomMQTTDevice::publish(const std::string &topic, float value, int8_t num
 }
 bool CustomMQTTDevice::publish(const std::string &topic, int value) {
   char buffer[24];
-  size_t len = buf_append_printf(buffer, sizeof(buffer), 0, "%d", value);
+  int len = snprintf(buffer, sizeof(buffer), "%d", value);
   return global_mqtt_client->publish(topic, buffer, len);
 }
 bool CustomMQTTDevice::publish_json(const std::string &topic, const json::json_build_t &f, uint8_t qos, bool retain) {

esphome/components/mqtt/mqtt_alarm_control_panel.cpp

@@ -43,7 +43,7 @@ void MQTTAlarmControlPanelComponent::setup() {
 
 void MQTTAlarmControlPanelComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT alarm_control_panel '%s':", this->alarm_control_panel_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, true)
+  LOG_MQTT_COMPONENT(true, true);
   ESP_LOGCONFIG(TAG,
                 "  Supported Features: %" PRIu32 "\n"
                 "  Requires Code to Disarm: %s\n"
@@ -119,8 +119,7 @@ bool MQTTAlarmControlPanelComponent::publish_state() {
     default:
       state_s = "unknown";
   }
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish(this->get_state_topic_to_(topic_buf), state_s);
+  return this->publish(this->get_state_topic_(), state_s);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_binary_sensor.cpp

@@ -19,7 +19,7 @@ void MQTTBinarySensorComponent::setup() {
 
 void MQTTBinarySensorComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT Binary Sensor '%s':", this->binary_sensor_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, false)
+  LOG_MQTT_COMPONENT(true, false);
 }
 MQTTBinarySensorComponent::MQTTBinarySensorComponent(binary_sensor::BinarySensor *binary_sensor)
     : binary_sensor_(binary_sensor) {
@@ -52,9 +52,8 @@ bool MQTTBinarySensorComponent::publish_state(bool state) {
   if (this->binary_sensor_->is_status_binary_sensor())
     return true;
 
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   const char *state_s = state ? "ON" : "OFF";
-  return this->publish(this->get_state_topic_to_(topic_buf), state_s);
+  return this->publish(this->get_state_topic_(), state_s);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_client.cpp

@@ -5,7 +5,6 @@
 #include <utility>
 #include "esphome/components/network/util.h"
 #include "esphome/core/application.h"
-#include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/version.h"
@@ -67,13 +66,10 @@ void MQTTClientComponent::setup() {
         "esphome/discover", [this](const std::string &topic, const std::string &payload) { this->send_device_info_(); },
         2);
 
-    // Format topic on stack - subscribe() copies it
-    // "esphome/ping/" (13) + name (ESPHOME_DEVICE_NAME_MAX_LEN) + null (1)
-    constexpr size_t ping_topic_buffer_size = 13 + ESPHOME_DEVICE_NAME_MAX_LEN + 1;
-    char ping_topic[ping_topic_buffer_size];
-    buf_append_printf(ping_topic, sizeof(ping_topic), 0, "esphome/ping/%s", App.get_name().c_str());
+    std::string topic = "esphome/ping/";
+    topic.append(App.get_name());
     this->subscribe(
-        ping_topic, [this](const std::string &topic, const std::string &payload) { this->send_device_info_(); }, 2);
+        topic, [this](const std::string &topic, const std::string &payload) { this->send_device_info_(); }, 2);
   }
 
   if (this->enable_on_boot_) {
@@ -85,11 +81,8 @@ void MQTTClientComponent::send_device_info_() {
   if (!this->is_connected() or !this->is_discovery_ip_enabled()) {
     return;
   }
-  // Format topic on stack to avoid heap allocation
-  // "esphome/discover/" (17) + name (ESPHOME_DEVICE_NAME_MAX_LEN) + null (1)
-  constexpr size_t topic_buffer_size = 17 + ESPHOME_DEVICE_NAME_MAX_LEN + 1;
-  char topic[topic_buffer_size];
-  buf_append_printf(topic, sizeof(topic), 0, "esphome/discover/%s", App.get_name().c_str());
+  std::string topic = "esphome/discover/";
+  topic.append(App.get_name());
 
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   this->publish_json(
@@ -98,17 +91,7 @@ void MQTTClientComponent::send_device_info_() {
         uint8_t index = 0;
         for (auto &ip : network::get_ip_addresses()) {
           if (ip.is_set()) {
-            char key[8];  // "ip" + up to 3 digits + null
-            char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
-            if (index == 0) {
-              key[0] = 'i';
-              key[1] = 'p';
-              key[2] = '\0';
-            } else {
-              buf_append_printf(key, sizeof(key), 0, "ip%u", index);
-            }
-            ip.str_to(ip_buf);
-            root[key] = ip_buf;
+            root["ip" + (index == 0 ? "" : esphome::to_string(index))] = ip.str();
             index++;
           }
         }
@@ -413,12 +396,6 @@ void MQTTClientComponent::loop() {
 
         this->last_connected_ = now;
         this->resubscribe_subscriptions_();
-
-        // Process pending resends for all MQTT components centrally
-        // This is more efficient than each component polling in its own loop
-        for (MQTTComponent *component : this->children_) {
-          component->process_resend();
-        }
       }
       break;
   }
@@ -523,49 +500,39 @@ bool MQTTClientComponent::publish(const std::string &topic, const std::string &p
 
 bool MQTTClientComponent::publish(const std::string &topic, const char *payload, size_t payload_length, uint8_t qos,
                                   bool retain) {
-  return this->publish(topic.c_str(), payload, payload_length, qos, retain);
+  return publish({.topic = topic, .payload = std::string(payload, payload_length), .qos = qos, .retain = retain});
 }
 
 bool MQTTClientComponent::publish(const MQTTMessage &message) {
-  return this->publish(message.topic.c_str(), message.payload.c_str(), message.payload.length(), message.qos,
-                       message.retain);
-}
-bool MQTTClientComponent::publish_json(const std::string &topic, const json::json_build_t &f, uint8_t qos,
-                                       bool retain) {
-  return this->publish_json(topic.c_str(), f, qos, retain);
-}
-
-bool MQTTClientComponent::publish(const char *topic, const char *payload, size_t payload_length, uint8_t qos,
-                                  bool retain) {
   if (!this->is_connected()) {
+    // critical components will re-transmit their messages
     return false;
   }
-  size_t topic_len = strlen(topic);
-  bool logging_topic = (topic_len == this->log_message_.topic.size()) &&
-                       (memcmp(this->log_message_.topic.c_str(), topic, topic_len) == 0);
-  bool ret = this->mqtt_backend_.publish(topic, payload, payload_length, qos, retain);
+  bool logging_topic = this->log_message_.topic == message.topic;
+  bool ret = this->mqtt_backend_.publish(message);
   delay(0);
   if (!ret && !logging_topic && this->is_connected()) {
     delay(0);
-    ret = this->mqtt_backend_.publish(topic, payload, payload_length, qos, retain);
+    ret = this->mqtt_backend_.publish(message);
     delay(0);
   }
 
   if (!logging_topic) {
     if (ret) {
-      ESP_LOGV(TAG, "Publish(topic='%s' retain=%d qos=%d)", topic, retain, qos);
-      ESP_LOGVV(TAG, "Publish payload (len=%u): '%.*s'", payload_length, static_cast<int>(payload_length), payload);
+      ESP_LOGV(TAG, "Publish(topic='%s' payload='%s' retain=%d qos=%d)", message.topic.c_str(), message.payload.c_str(),
+               message.retain, message.qos);
     } else {
-      ESP_LOGV(TAG, "Publish failed for topic='%s' (len=%u). Will retry", topic, payload_length);
+      ESP_LOGV(TAG, "Publish failed for topic='%s' (len=%u). Will retry", message.topic.c_str(),
+               message.payload.length());
       this->status_momentary_warning("publish", 1000);
     }
   }
   return ret != 0;
 }
-
-bool MQTTClientComponent::publish_json(const char *topic, const json::json_build_t &f, uint8_t qos, bool retain) {
+bool MQTTClientComponent::publish_json(const std::string &topic, const json::json_build_t &f, uint8_t qos,
+                                       bool retain) {
   std::string message = json::build_json(f);
-  return this->publish(topic, message.c_str(), message.length(), qos, retain);
+  return this->publish(topic, message, qos, retain);
 }
 
 void MQTTClientComponent::enable() {
@@ -643,10 +610,18 @@ static bool topic_match(const char *message, const char *subscription) {
 }
 
 void MQTTClientComponent::on_message(const std::string &topic, const std::string &payload) {
-  for (auto &subscription : this->subscriptions_) {
-    if (topic_match(topic.c_str(), subscription.topic.c_str()))
-      subscription.callback(topic, payload);
-  }
+#ifdef USE_ESP8266
+  // on ESP8266, this is called in lwIP/AsyncTCP task; some components do not like running
+  // from a different task.
+  this->defer([this, topic, payload]() {
+#endif
+    for (auto &subscription : this->subscriptions_) {
+      if (topic_match(topic.c_str(), subscription.topic.c_str()))
+        subscription.callback(topic, payload);
+    }
+#ifdef USE_ESP8266
+  });
+#endif
 }
 
 // Setters

esphome/components/mqtt/mqtt_client.h

@@ -229,9 +229,6 @@ class MQTTClientComponent : public Component
   bool publish(const std::string &topic, const char *payload, size_t payload_length, uint8_t qos = 0,
                bool retain = false);
 
-  /// Publish directly without creating MQTTMessage (avoids heap allocation for topic)
-  bool publish(const char *topic, const char *payload, size_t payload_length, uint8_t qos = 0, bool retain = false);
-
   /** Construct and send a JSON MQTT message.
    *
    * @param topic The topic.
@@ -240,9 +237,6 @@ class MQTTClientComponent : public Component
    */
   bool publish_json(const std::string &topic, const json::json_build_t &f, uint8_t qos = 0, bool retain = false);
 
-  /// Publish JSON directly without heap allocation for topic
-  bool publish_json(const char *topic, const json::json_build_t &f, uint8_t qos = 0, bool retain = false);
-
   /// Setup the MQTT client, registering a bunch of callbacks and attempting to connect.
   void setup() override;
   void dump_config() override;

esphome/components/mqtt/mqtt_component.cpp

@@ -27,20 +27,23 @@ inline char *append_char(char *p, char c) {
 // Max lengths for stack-based topic building.
 // These limits are enforced at Python config validation time in mqtt/__init__.py
 // using cv.Length() validators for topic_prefix and discovery_prefix.
-// MQTT_COMPONENT_TYPE_MAX_LEN and MQTT_SUFFIX_MAX_LEN are defined in mqtt_component.h.
+// MQTT_COMPONENT_TYPE_MAX_LEN, MQTT_SUFFIX_MAX_LEN, and MQTT_DEFAULT_TOPIC_MAX_LEN are in mqtt_component.h.
 // ESPHOME_DEVICE_NAME_MAX_LEN and OBJECT_ID_MAX_LEN are defined in entity_base.h.
 // This ensures the stack buffers below are always large enough.
-static constexpr size_t TOPIC_PREFIX_MAX_LEN = 64;      // Validated in Python: cv.Length(max=64)
 static constexpr size_t DISCOVERY_PREFIX_MAX_LEN = 64;  // Validated in Python: cv.Length(max=64)
-
-// Stack buffer sizes - safe because all inputs are length-validated at config time
-// Format: prefix + "/" + type + "/" + object_id + "/" + suffix + null
-static constexpr size_t DEFAULT_TOPIC_MAX_LEN =
-    TOPIC_PREFIX_MAX_LEN + 1 + MQTT_COMPONENT_TYPE_MAX_LEN + 1 + OBJECT_ID_MAX_LEN + 1 + MQTT_SUFFIX_MAX_LEN + 1;
 // Format: prefix + "/" + type + "/" + name + "/" + object_id + "/config" + null
 static constexpr size_t DISCOVERY_TOPIC_MAX_LEN = DISCOVERY_PREFIX_MAX_LEN + 1 + MQTT_COMPONENT_TYPE_MAX_LEN + 1 +
                                                   ESPHOME_DEVICE_NAME_MAX_LEN + 1 + OBJECT_ID_MAX_LEN + 7 + 1;
 
+// Function implementation of LOG_MQTT_COMPONENT macro to reduce code size
+void log_mqtt_component(const char *tag, MQTTComponent *obj, bool state_topic, bool command_topic) {
+  char buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
+  if (state_topic)
+    ESP_LOGCONFIG(tag, "  State Topic: '%s'", obj->get_state_topic_to_(buf).c_str());
+  if (command_topic)
+    ESP_LOGCONFIG(tag, "  Command Topic: '%s'", obj->get_command_topic_to_(buf).c_str());
+}
+
 void MQTTComponent::set_qos(uint8_t qos) { this->qos_ = qos; }
 
 void MQTTComponent::set_subscribe_qos(uint8_t qos) { this->subscribe_qos_ = qos; }
@@ -69,19 +72,18 @@ std::string MQTTComponent::get_discovery_topic_(const MQTTDiscoveryInfo &discove
   return std::string(buf, p - buf);
 }
 
-std::string MQTTComponent::get_default_topic_for_(const std::string &suffix) const {
+StringRef MQTTComponent::get_default_topic_for_to_(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf, const char *suffix,
+                                                   size_t suffix_len) const {
   const std::string &topic_prefix = global_mqtt_client->get_topic_prefix();
   if (topic_prefix.empty()) {
-    // If the topic_prefix is null, the default topic should be null
-    return "";
+    return StringRef();  // Empty topic_prefix means no default topic
   }
 
   const char *comp_type = this->component_type();
   char object_id_buf[OBJECT_ID_MAX_LEN];
   StringRef object_id = this->get_default_object_id_to_(object_id_buf);
 
-  char buf[DEFAULT_TOPIC_MAX_LEN];
-  char *p = buf;
+  char *p = buf.data();
 
   p = append_str(p, topic_prefix.data(), topic_prefix.size());
   p = append_char(p, '/');
@@ -89,47 +91,58 @@ std::string MQTTComponent::get_default_topic_for_(const std::string &suffix) con
   p = append_char(p, '/');
   p = append_str(p, object_id.c_str(), object_id.size());
   p = append_char(p, '/');
-  p = append_str(p, suffix.data(), suffix.size());
+  p = append_str(p, suffix, suffix_len);
+  *p = '\0';
 
-  return std::string(buf, p - buf);
+  return StringRef(buf.data(), p - buf.data());
+}
+
+std::string MQTTComponent::get_default_topic_for_(const std::string &suffix) const {
+  char buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
+  StringRef ref = this->get_default_topic_for_to_(buf, suffix.data(), suffix.size());
+  return std::string(ref.c_str(), ref.size());
+}
+
+StringRef MQTTComponent::get_state_topic_to_(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf) const {
+  if (this->custom_state_topic_.has_value()) {
+    // Returns ref to existing data for static/value, uses buf only for lambda case
+    return this->custom_state_topic_.ref_or_copy_to(buf.data(), buf.size());
+  }
+  return this->get_default_topic_for_to_(buf, "state", 5);
+}
+
+StringRef MQTTComponent::get_command_topic_to_(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf) const {
+  if (this->custom_command_topic_.has_value()) {
+    // Returns ref to existing data for static/value, uses buf only for lambda case
+    return this->custom_command_topic_.ref_or_copy_to(buf.data(), buf.size());
+  }
+  return this->get_default_topic_for_to_(buf, "command", 7);
 }
 
 std::string MQTTComponent::get_state_topic_() const {
-  if (this->custom_state_topic_.has_value())
-    return this->custom_state_topic_.value();
-  return this->get_default_topic_for_("state");
+  char buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
+  StringRef ref = this->get_state_topic_to_(buf);
+  return std::string(ref.c_str(), ref.size());
 }
 
 std::string MQTTComponent::get_command_topic_() const {
-  if (this->custom_command_topic_.has_value())
-    return this->custom_command_topic_.value();
-  return this->get_default_topic_for_("command");
+  char buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
+  StringRef ref = this->get_command_topic_to_(buf);
+  return std::string(ref.c_str(), ref.size());
 }
 
 bool MQTTComponent::publish(const std::string &topic, const std::string &payload) {
-  return this->publish(topic.c_str(), payload.data(), payload.size());
+  return this->publish(topic, payload.data(), payload.size());
 }
 
 bool MQTTComponent::publish(const std::string &topic, const char *payload, size_t payload_length) {
-  return this->publish(topic.c_str(), payload, payload_length);
-}
-
-bool MQTTComponent::publish(const char *topic, const char *payload, size_t payload_length) {
-  if (topic[0] == '\0')
+  if (topic.empty())
     return false;
   return global_mqtt_client->publish(topic, payload, payload_length, this->qos_, this->retain_);
 }
 
-bool MQTTComponent::publish(const char *topic, const char *payload) {
-  return this->publish(topic, payload, strlen(payload));
-}
-
 bool MQTTComponent::publish_json(const std::string &topic, const json::json_build_t &f) {
-  return this->publish_json(topic.c_str(), f);
-}
-
-bool MQTTComponent::publish_json(const char *topic, const json::json_build_t &f) {
-  if (topic[0] == '\0')
+  if (topic.empty())
     return false;
   return global_mqtt_client->publish_json(topic, f, this->qos_, this->retain_);
 }
@@ -180,10 +193,14 @@ bool MQTTComponent::send_discovery_() {
             break;
         }
 
-        if (config.state_topic)
-          root[MQTT_STATE_TOPIC] = this->get_state_topic_();
-        if (config.command_topic)
-          root[MQTT_COMMAND_TOPIC] = this->get_command_topic_();
+        if (config.state_topic) {
+          char state_topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
+          root[MQTT_STATE_TOPIC] = this->get_state_topic_to_(state_topic_buf);
+        }
+        if (config.command_topic) {
+          char command_topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
+          root[MQTT_COMMAND_TOPIC] = this->get_command_topic_to_(command_topic_buf);
+        }
         if (this->command_retain_)
           root[MQTT_COMMAND_RETAIN] = true;
 
@@ -202,37 +219,27 @@ bool MQTTComponent::send_discovery_() {
         StringRef object_id = this->get_default_object_id_to_(object_id_buf);
         if (discovery_info.unique_id_generator == MQTT_MAC_ADDRESS_UNIQUE_ID_GENERATOR) {
           char friendly_name_hash[9];
-          buf_append_printf(friendly_name_hash, sizeof(friendly_name_hash), 0, "%08" PRIx32,
-                            fnv1_hash(this->friendly_name_()));
+          snprintf(friendly_name_hash, sizeof(friendly_name_hash), "%08" PRIx32, fnv1_hash(this->friendly_name_()));
           // Format: mac-component_type-hash (e.g. "aabbccddeeff-sensor-12345678")
           // MAC (12) + "-" (1) + domain (max 20) + "-" (1) + hash (8) + null (1) = 43
           char unique_id[MAC_ADDRESS_BUFFER_SIZE + ESPHOME_DOMAIN_MAX_LEN + 11];
           char mac_buf[MAC_ADDRESS_BUFFER_SIZE];
           get_mac_address_into_buffer(mac_buf);
-          buf_append_printf(unique_id, sizeof(unique_id), 0, "%s-%s-%s", mac_buf, this->component_type(),
-                            friendly_name_hash);
+          snprintf(unique_id, sizeof(unique_id), "%s-%s-%s", mac_buf, this->component_type(), friendly_name_hash);
           root[MQTT_UNIQUE_ID] = unique_id;
         } else {
           // default to almost-unique ID. It's a hack but the only way to get that
           // gorgeous device registry view.
-          // "ESP" (3) + component_type (max 20) + object_id (max 128) + null
-          char unique_id_buf[3 + MQTT_COMPONENT_TYPE_MAX_LEN + OBJECT_ID_MAX_LEN + 1];
-          buf_append_printf(unique_id_buf, sizeof(unique_id_buf), 0, "ESP%s%s", this->component_type(),
-                            object_id.c_str());
-          root[MQTT_UNIQUE_ID] = unique_id_buf;
+          root[MQTT_UNIQUE_ID] = "ESP" + std::string(this->component_type()) + object_id.c_str();
         }
 
         const std::string &node_name = App.get_name();
-        if (discovery_info.object_id_generator == MQTT_DEVICE_NAME_OBJECT_ID_GENERATOR) {
-          // node_name (max 31) + "_" (1) + object_id (max 128) + null
-          char object_id_full[ESPHOME_DEVICE_NAME_MAX_LEN + 1 + OBJECT_ID_MAX_LEN + 1];
-          buf_append_printf(object_id_full, sizeof(object_id_full), 0, "%s_%s", node_name.c_str(), object_id.c_str());
-          root[MQTT_OBJECT_ID] = object_id_full;
-        }
+        if (discovery_info.object_id_generator == MQTT_DEVICE_NAME_OBJECT_ID_GENERATOR)
+          root[MQTT_OBJECT_ID] = node_name + "_" + object_id.c_str();
 
         const std::string &friendly_name_ref = App.get_friendly_name();
         const std::string &node_friendly_name = friendly_name_ref.empty() ? node_name : friendly_name_ref;
-        const char *node_area = App.get_area();
+        std::string node_area = App.get_area();
 
         JsonObject device_info = root[MQTT_DEVICE].to<JsonObject>();
         char mac[MAC_ADDRESS_BUFFER_SIZE];
@@ -243,29 +250,18 @@ bool MQTTComponent::send_discovery_() {
         device_info[MQTT_DEVICE_SW_VERSION] = ESPHOME_PROJECT_VERSION " (ESPHome " ESPHOME_VERSION ")";
         const char *model = std::strchr(ESPHOME_PROJECT_NAME, '.');
         device_info[MQTT_DEVICE_MODEL] = model == nullptr ? ESPHOME_BOARD : model + 1;
-        if (model == nullptr) {
-          device_info[MQTT_DEVICE_MANUFACTURER] = ESPHOME_PROJECT_NAME;
-        } else {
-          // Extract manufacturer (part before '.') using stack buffer to avoid heap allocation
-          // memcpy is used instead of strncpy since we know the exact length and strncpy
-          // would still require manual null-termination
-          char manufacturer[sizeof(ESPHOME_PROJECT_NAME)];
-          size_t len = model - ESPHOME_PROJECT_NAME;
-          memcpy(manufacturer, ESPHOME_PROJECT_NAME, len);
-          manufacturer[len] = '\0';
-          device_info[MQTT_DEVICE_MANUFACTURER] = manufacturer;
-        }
+        device_info[MQTT_DEVICE_MANUFACTURER] =
+            model == nullptr ? ESPHOME_PROJECT_NAME : std::string(ESPHOME_PROJECT_NAME, model - ESPHOME_PROJECT_NAME);
 #else
         static const char ver_fmt[] PROGMEM = ESPHOME_VERSION " (config hash 0x%08" PRIx32 ")";
-        // Buffer sized for format string expansion: ~4 bytes net growth from format specifier to 8 hex digits, plus
-        // safety margin
-        char version_buf[sizeof(ver_fmt) + 8];
 #ifdef USE_ESP8266
-        snprintf_P(version_buf, sizeof(version_buf), ver_fmt, App.get_config_hash());
+        char fmt_buf[sizeof(ver_fmt)];
+        strcpy_P(fmt_buf, ver_fmt);
+        const char *fmt = fmt_buf;
 #else
-        snprintf(version_buf, sizeof(version_buf), ver_fmt, App.get_config_hash());
+        const char *fmt = ver_fmt;
 #endif
-        device_info[MQTT_DEVICE_SW_VERSION] = version_buf;
+        device_info[MQTT_DEVICE_SW_VERSION] = str_sprintf(fmt, App.get_config_hash());
         device_info[MQTT_DEVICE_MODEL] = ESPHOME_BOARD;
 #if defined(USE_ESP8266) || defined(USE_ESP32)
         device_info[MQTT_DEVICE_MANUFACTURER] = "Espressif";
@@ -279,7 +275,7 @@ bool MQTTComponent::send_discovery_() {
         device_info[MQTT_DEVICE_MANUFACTURER] = "Host";
 #endif
 #endif
-        if (node_area[0] != '\0') {
+        if (!node_area.empty()) {
           device_info[MQTT_DEVICE_SUGGESTED_AREA] = node_area;
         }
 
@@ -321,7 +317,9 @@ void MQTTComponent::set_availability(std::string topic, std::string payload_avai
 }
 void MQTTComponent::disable_availability() { this->set_availability("", "", ""); }
 void MQTTComponent::call_setup() {
-  if (this->is_internal())
+  // Cache is_internal result once during setup - topics don't change after this
+  this->is_internal_ = this->compute_is_internal_();
+  if (this->is_internal_)
     return;
 
   this->setup();
@@ -341,12 +339,16 @@ void MQTTComponent::call_setup() {
   }
 }
 
-void MQTTComponent::process_resend() {
-  // Called by MQTTClientComponent when connected to process pending resends
-  // Note: is_internal() check not needed - internal components are never registered
-  if (!this->resend_state_)
+void MQTTComponent::call_loop() {
+  if (this->is_internal())
     return;
 
+  this->loop();
+
+  if (!this->resend_state_ || !this->is_connected_()) {
+    return;
+  }
+
   this->resend_state_ = false;
   if (this->is_discovery_enabled()) {
     if (!this->send_discovery_()) {
@@ -373,26 +375,28 @@ StringRef MQTTComponent::get_default_object_id_to_(std::span<char, OBJECT_ID_MAX
 }
 StringRef MQTTComponent::get_icon_ref_() const { return this->get_entity()->get_icon_ref(); }
 bool MQTTComponent::is_disabled_by_default_() const { return this->get_entity()->is_disabled_by_default(); }
-bool MQTTComponent::is_internal() {
+bool MQTTComponent::compute_is_internal_() {
   if (this->custom_state_topic_.has_value()) {
-    // If the custom state_topic is null, return true as it is internal and should not publish
+    // If the custom state_topic is empty, return true as it is internal and should not publish
     // else, return false, as it is explicitly set to a topic, so it is not internal and should publish
-    return this->get_state_topic_().empty();
+    // Using is_empty() avoids heap allocation for non-lambda cases
+    return this->custom_state_topic_.is_empty();
   }
 
   if (this->custom_command_topic_.has_value()) {
-    // If the custom command_topic is null, return true as it is internal and should not publish
+    // If the custom command_topic is empty, return true as it is internal and should not publish
     // else, return false, as it is explicitly set to a topic, so it is not internal and should publish
-    return this->get_command_topic_().empty();
+    // Using is_empty() avoids heap allocation for non-lambda cases
+    return this->custom_command_topic_.is_empty();
   }
 
-  // No custom topics have been set
-  if (this->get_default_topic_for_("").empty()) {
-    // If the default topic prefix is null, then the component, by default, is internal and should not publish
+  // No custom topics have been set - check topic_prefix directly to avoid allocation
+  if (global_mqtt_client->get_topic_prefix().empty()) {
+    // If the default topic prefix is empty, then the component, by default, is internal and should not publish
     return true;
   }
 
-  // Use ESPHome's component internal state if topic_prefix is not null with no custom state_topic or command_topic
+  // Use ESPHome's component internal state if topic_prefix is not empty with no custom state_topic or command_topic
   return this->get_entity()->is_internal();
 }
 

esphome/components/mqtt/mqtt_component.h

@@ -20,17 +20,22 @@ struct SendDiscoveryConfig {
   bool command_topic{true};  ///< If the command topic should be included. Default to true.
 };
 
-// Max lengths for stack-based topic building (must match mqtt_component.cpp)
+// Max lengths for stack-based topic building.
+// These limits are enforced at Python config validation time in mqtt/__init__.py
+// using cv.Length() validators for topic_prefix and discovery_prefix.
+// This ensures the stack buffers are always large enough.
 static constexpr size_t MQTT_COMPONENT_TYPE_MAX_LEN = 20;
 static constexpr size_t MQTT_SUFFIX_MAX_LEN = 32;
+static constexpr size_t MQTT_TOPIC_PREFIX_MAX_LEN = 64;  // Validated in Python: cv.Length(max=64)
+// Stack buffer size - safe because all inputs are length-validated at config time
+// Format: prefix + "/" + type + "/" + object_id + "/" + suffix + null
+static constexpr size_t MQTT_DEFAULT_TOPIC_MAX_LEN =
+    MQTT_TOPIC_PREFIX_MAX_LEN + 1 + MQTT_COMPONENT_TYPE_MAX_LEN + 1 + OBJECT_ID_MAX_LEN + 1 + MQTT_SUFFIX_MAX_LEN + 1;
 
-#define LOG_MQTT_COMPONENT(state_topic, command_topic) \
-  if (state_topic) { \
-    ESP_LOGCONFIG(TAG, "  State Topic: '%s'", this->get_state_topic_().c_str()); \
-  } \
-  if (command_topic) { \
-    ESP_LOGCONFIG(TAG, "  Command Topic: '%s'", this->get_command_topic_().c_str()); \
-  }
+class MQTTComponent;  // Forward declaration
+void log_mqtt_component(const char *tag, MQTTComponent *obj, bool state_topic, bool command_topic);
+
+#define LOG_MQTT_COMPONENT(state_topic, command_topic) log_mqtt_component(TAG, this, state_topic, command_topic)
 
 // Macro to define component_type() with compile-time length verification
 // Usage: MQTT_COMPONENT_TYPE(MQTTSensorComponent, "sensor")
@@ -74,6 +79,8 @@ static constexpr size_t MQTT_SUFFIX_MAX_LEN = 32;
  * a clean separation.
  */
 class MQTTComponent : public Component {
+  friend void log_mqtt_component(const char *tag, MQTTComponent *obj, bool state_topic, bool command_topic);
+
  public:
   /// Constructs a MQTTComponent.
   explicit MQTTComponent();
@@ -81,6 +88,8 @@ class MQTTComponent : public Component {
   /// Override setup_ so that we can call send_discovery() when needed.
   void call_setup() override;
 
+  void call_loop() override;
+
   void call_dump_config() override;
 
   /// Send discovery info the Home Assistant, override this.
@@ -88,7 +97,8 @@ class MQTTComponent : public Component {
 
   virtual bool send_initial_state() = 0;
 
-  virtual bool is_internal();
+  /// Returns cached is_internal result (computed once during setup).
+  bool is_internal() const { return this->is_internal_; }
 
   /// Set QOS for state messages.
   void set_qos(uint8_t qos);
@@ -131,9 +141,6 @@ class MQTTComponent : public Component {
   /// Internal method for the MQTT client base to schedule a resend of the state on reconnect.
   void schedule_resend_state();
 
-  /// Process pending resend if needed (called by MQTTClientComponent)
-  void process_resend();
-
   /** Send a MQTT message.
    *
    * @param topic The topic.
@@ -149,38 +156,6 @@ class MQTTComponent : public Component {
    */
   bool publish(const std::string &topic, const char *payload, size_t payload_length);
 
-  /** Send a MQTT message (no heap allocation for topic).
-   *
-   * @param topic The topic as C string.
-   * @param payload The payload buffer.
-   * @param payload_length The length of the payload.
-   */
-  bool publish(const char *topic, const char *payload, size_t payload_length);
-
-  /** Send a MQTT message (no heap allocation for topic).
-   *
-   * @param topic The topic as StringRef (for use with get_state_topic_to_()).
-   * @param payload The payload buffer.
-   * @param payload_length The length of the payload.
-   */
-  bool publish(StringRef topic, const char *payload, size_t payload_length) {
-    return this->publish(topic.c_str(), payload, payload_length);
-  }
-
-  /** Send a MQTT message (no heap allocation for topic).
-   *
-   * @param topic The topic as C string.
-   * @param payload The null-terminated payload.
-   */
-  bool publish(const char *topic, const char *payload);
-
-  /** Send a MQTT message (no heap allocation for topic).
-   *
-   * @param topic The topic as StringRef (for use with get_state_topic_to_()).
-   * @param payload The null-terminated payload.
-   */
-  bool publish(StringRef topic, const char *payload) { return this->publish(topic.c_str(), payload); }
-
   /** Construct and send a JSON MQTT message.
    *
    * @param topic The topic.
@@ -188,20 +163,6 @@ class MQTTComponent : public Component {
    */
   bool publish_json(const std::string &topic, const json::json_build_t &f);
 
-  /** Construct and send a JSON MQTT message (no heap allocation for topic).
-   *
-   * @param topic The topic as C string.
-   * @param f The Json Message builder.
-   */
-  bool publish_json(const char *topic, const json::json_build_t &f);
-
-  /** Construct and send a JSON MQTT message (no heap allocation for topic).
-   *
-   * @param topic The topic as StringRef (for use with get_state_topic_to_()).
-   * @param f The Json Message builder.
-   */
-  bool publish_json(StringRef topic, const json::json_build_t &f) { return this->publish_json(topic.c_str(), f); }
-
   /** Subscribe to a MQTT topic.
    *
    * @param topic The topic. Wildcards are currently not supported.
@@ -225,7 +186,16 @@ class MQTTComponent : public Component {
   /// Helper method to get the discovery topic for this component.
   std::string get_discovery_topic_(const MQTTDiscoveryInfo &discovery_info) const;
 
-  /** Get this components state/command/... topic.
+  /** Get this components state/command/... topic into a buffer.
+   *
+   * @param buf The buffer to write to (must be exactly MQTT_DEFAULT_TOPIC_MAX_LEN).
+   * @param suffix The suffix/key such as "state" or "command".
+   * @return StringRef pointing to the buffer with the topic.
+   */
+  StringRef get_default_topic_for_to_(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf, const char *suffix,
+                                      size_t suffix_len) const;
+
+  /** Get this components state/command/... topic (allocates std::string).
    *
    * @param suffix The suffix/key such as "state" or "command".
    * @return The full topic.
@@ -246,10 +216,20 @@ class MQTTComponent : public Component {
   /// Get whether the underlying Entity is disabled by default
   bool is_disabled_by_default_() const;
 
-  /// Get the MQTT topic that new states will be shared to.
+  /// Get the MQTT state topic into a buffer (no heap allocation for non-lambda custom topics).
+  /// @param buf Buffer of exactly MQTT_DEFAULT_TOPIC_MAX_LEN bytes.
+  /// @return StringRef pointing to the topic in the buffer.
+  StringRef get_state_topic_to_(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf) const;
+
+  /// Get the MQTT command topic into a buffer (no heap allocation for non-lambda custom topics).
+  /// @param buf Buffer of exactly MQTT_DEFAULT_TOPIC_MAX_LEN bytes.
+  /// @return StringRef pointing to the topic in the buffer.
+  StringRef get_command_topic_to_(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf) const;
+
+  /// Get the MQTT topic that new states will be shared to (allocates std::string).
   std::string get_state_topic_() const;
 
-  /// Get the MQTT topic for listening to commands.
+  /// Get the MQTT topic for listening to commands (allocates std::string).
   std::string get_command_topic_() const;
 
   bool is_connected_() const;
@@ -267,12 +247,18 @@ class MQTTComponent : public Component {
 
   std::unique_ptr<Availability> availability_;
 
-  bool command_retain_{false};
-  bool retain_{true};
-  uint8_t qos_{0};
-  uint8_t subscribe_qos_{0};
-  bool discovery_enabled_{true};
-  bool resend_state_{false};
+  // Packed bitfields - QoS values are 0-2, bools are flags
+  uint8_t qos_ : 2 {0};
+  uint8_t subscribe_qos_ : 2 {0};
+  bool command_retain_ : 1 {false};
+  bool retain_ : 1 {true};
+  bool discovery_enabled_ : 1 {true};
+  bool resend_state_ : 1 {false};
+  bool is_internal_ : 1 {false};  ///< Cached result of compute_is_internal_(), set during setup
+
+  /// Compute is_internal status based on topics and entity state.
+  /// Called once during setup to cache the result.
+  bool compute_is_internal_();
 };
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_cover.cpp

@@ -51,7 +51,7 @@ void MQTTCoverComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT cover '%s':", this->cover_->get_name().c_str());
   auto traits = this->cover_->get_traits();
   bool has_command_topic = traits.get_supports_position() || !traits.get_supports_tilt();
-  LOG_MQTT_COMPONENT(true, has_command_topic)
+  LOG_MQTT_COMPONENT(true, has_command_topic);
   if (traits.get_supports_position()) {
     ESP_LOGCONFIG(TAG,
                   "  Position State Topic: '%s'\n"
@@ -115,8 +115,7 @@ bool MQTTCoverComponent::publish_state() {
                         : this->cover_->position == COVER_OPEN                       ? "open"
                         : traits.get_supports_position()                             ? "open"
                                                                                      : "unknown";
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  if (!this->publish(this->get_state_topic_to_(topic_buf), state_s))
+  if (!this->publish(this->get_state_topic_(), state_s))
     success = false;
   return success;
 }

esphome/components/mqtt/mqtt_date.cpp

@@ -36,7 +36,7 @@ void MQTTDateComponent::setup() {
 
 void MQTTDateComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT Date '%s':", this->date_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, true)
+  LOG_MQTT_COMPONENT(true, true);
 }
 
 MQTT_COMPONENT_TYPE(MQTTDateComponent, "date")
@@ -53,8 +53,7 @@ bool MQTTDateComponent::send_initial_state() {
   }
 }
 bool MQTTDateComponent::publish_state(uint16_t year, uint8_t month, uint8_t day) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish_json(this->get_state_topic_to_(topic_buf), [year, month, day](JsonObject root) {
+  return this->publish_json(this->get_state_topic_(), [year, month, day](JsonObject root) {
     // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
     root[ESPHOME_F("year")] = year;
     root[ESPHOME_F("month")] = month;

esphome/components/mqtt/mqtt_datetime.cpp

@@ -47,7 +47,7 @@ void MQTTDateTimeComponent::setup() {
 
 void MQTTDateTimeComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT DateTime '%s':", this->datetime_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, true)
+  LOG_MQTT_COMPONENT(true, true);
 }
 
 MQTT_COMPONENT_TYPE(MQTTDateTimeComponent, "datetime")
@@ -66,17 +66,15 @@ bool MQTTDateTimeComponent::send_initial_state() {
 }
 bool MQTTDateTimeComponent::publish_state(uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute,
                                           uint8_t second) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish_json(this->get_state_topic_to_(topic_buf),
-                            [year, month, day, hour, minute, second](JsonObject root) {
-                              // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-                              root[ESPHOME_F("year")] = year;
-                              root[ESPHOME_F("month")] = month;
-                              root[ESPHOME_F("day")] = day;
-                              root[ESPHOME_F("hour")] = hour;
-                              root[ESPHOME_F("minute")] = minute;
-                              root[ESPHOME_F("second")] = second;
-                            });
+  return this->publish_json(this->get_state_topic_(), [year, month, day, hour, minute, second](JsonObject root) {
+    // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
+    root[ESPHOME_F("year")] = year;
+    root[ESPHOME_F("month")] = month;
+    root[ESPHOME_F("day")] = day;
+    root[ESPHOME_F("hour")] = hour;
+    root[ESPHOME_F("minute")] = minute;
+    root[ESPHOME_F("second")] = second;
+  });
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_event.cpp

@@ -44,8 +44,7 @@ void MQTTEventComponent::dump_config() {
 }
 
 bool MQTTEventComponent::publish_event_(const std::string &event_type) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish_json(this->get_state_topic_to_(topic_buf), [event_type](JsonObject root) {
+  return this->publish_json(this->get_state_topic_(), [event_type](JsonObject root) {
     // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
     root[MQTT_EVENT_TYPE] = event_type;
   });

esphome/components/mqtt/mqtt_fan.cpp

@@ -158,10 +158,9 @@ void MQTTFanComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig
   }
 }
 bool MQTTFanComponent::publish_state() {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   const char *state_s = this->state_->state ? "ON" : "OFF";
   ESP_LOGD(TAG, "'%s' Sending state %s.", this->state_->get_name().c_str(), state_s);
-  this->publish(this->get_state_topic_to_(topic_buf), state_s);
+  this->publish(this->get_state_topic_(), state_s);
   bool failed = false;
   if (this->state_->get_traits().supports_direction()) {
     bool success = this->publish(this->get_direction_state_topic(),
@@ -176,7 +175,7 @@ bool MQTTFanComponent::publish_state() {
   auto traits = this->state_->get_traits();
   if (traits.supports_speed()) {
     char buf[12];
-    size_t len = buf_append_printf(buf, sizeof(buf), 0, "%d", this->state_->speed);
+    int len = snprintf(buf, sizeof(buf), "%d", this->state_->speed);
     bool success = this->publish(this->get_speed_level_state_topic(), buf, len);
     failed = failed || !success;
   }

esphome/components/mqtt/mqtt_light.cpp

@@ -34,8 +34,7 @@ void MQTTJSONLightComponent::on_light_remote_values_update() {
 MQTTJSONLightComponent::MQTTJSONLightComponent(LightState *state) : state_(state) {}
 
 bool MQTTJSONLightComponent::publish_state_() {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish_json(this->get_state_topic_to_(topic_buf), [this](JsonObject root) {
+  return this->publish_json(this->get_state_topic_(), [this](JsonObject root) {
     // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
     LightJSONSchema::dump_json(*this->state_, root);
   });
@@ -91,7 +90,7 @@ void MQTTJSONLightComponent::send_discovery(JsonObject root, mqtt::SendDiscovery
 bool MQTTJSONLightComponent::send_initial_state() { return this->publish_state_(); }
 void MQTTJSONLightComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT Light '%s':", this->state_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, true)
+  LOG_MQTT_COMPONENT(true, true);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_lock.cpp

@@ -47,14 +47,13 @@ void MQTTLockComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfi
 bool MQTTLockComponent::send_initial_state() { return this->publish_state(); }
 
 bool MQTTLockComponent::publish_state() {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
 #ifdef USE_STORE_LOG_STR_IN_FLASH
   char buf[LOCK_STATE_STR_SIZE];
   strncpy_P(buf, (PGM_P) lock_state_to_string(this->lock_->state), sizeof(buf) - 1);
   buf[sizeof(buf) - 1] = '\0';
-  return this->publish(this->get_state_topic_to_(topic_buf), buf);
+  return this->publish(this->get_state_topic_(), buf);
 #else
-  return this->publish(this->get_state_topic_to_(topic_buf), LOG_STR_ARG(lock_state_to_string(this->lock_->state)));
+  return this->publish(this->get_state_topic_(), LOG_STR_ARG(lock_state_to_string(this->lock_->state)));
 #endif
 }
 

esphome/components/mqtt/mqtt_number.cpp

@@ -30,7 +30,7 @@ void MQTTNumberComponent::setup() {
 
 void MQTTNumberComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT Number '%s':", this->number_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, false)
+  LOG_MQTT_COMPONENT(true, false);
 }
 
 MQTT_COMPONENT_TYPE(MQTTNumberComponent, "number")
@@ -74,10 +74,9 @@ bool MQTTNumberComponent::send_initial_state() {
   }
 }
 bool MQTTNumberComponent::publish_state(float value) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   char buffer[64];
-  size_t len = buf_append_printf(buffer, sizeof(buffer), 0, "%f", value);
-  return this->publish(this->get_state_topic_to_(topic_buf), buffer, len);
+  snprintf(buffer, sizeof(buffer), "%f", value);
+  return this->publish(this->get_state_topic_(), buffer);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_select.cpp

@@ -25,7 +25,7 @@ void MQTTSelectComponent::setup() {
 
 void MQTTSelectComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT Select '%s':", this->select_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, false)
+  LOG_MQTT_COMPONENT(true, false);
 }
 
 MQTT_COMPONENT_TYPE(MQTTSelectComponent, "select")
@@ -50,8 +50,7 @@ bool MQTTSelectComponent::send_initial_state() {
   }
 }
 bool MQTTSelectComponent::publish_state(const std::string &value) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish(this->get_state_topic_to_(topic_buf), value.data(), value.size());
+  return this->publish(this->get_state_topic_(), value);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_sensor.cpp

@@ -28,7 +28,7 @@ void MQTTSensorComponent::dump_config() {
   if (this->get_expire_after() > 0) {
     ESP_LOGCONFIG(TAG, "  Expire After: %" PRIu32 "s", this->get_expire_after() / 1000);
   }
-  LOG_MQTT_COMPONENT(true, false)
+  LOG_MQTT_COMPONENT(true, false);
 }
 
 MQTT_COMPONENT_TYPE(MQTTSensorComponent, "sensor")
@@ -79,13 +79,12 @@ bool MQTTSensorComponent::send_initial_state() {
   }
 }
 bool MQTTSensorComponent::publish_state(float value) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   if (mqtt::global_mqtt_client->is_publish_nan_as_none() && std::isnan(value))
-    return this->publish(this->get_state_topic_to_(topic_buf), "None", 4);
+    return this->publish(this->get_state_topic_(), "None", 4);
   int8_t accuracy = this->sensor_->get_accuracy_decimals();
   char buf[VALUE_ACCURACY_MAX_LEN];
   size_t len = value_accuracy_to_buf(buf, value, accuracy);
-  return this->publish(this->get_state_topic_to_(topic_buf), buf, len);
+  return this->publish(this->get_state_topic_(), buf, len);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_switch.cpp

@@ -52,9 +52,8 @@ void MQTTSwitchComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryCon
 bool MQTTSwitchComponent::send_initial_state() { return this->publish_state(this->switch_->state); }
 
 bool MQTTSwitchComponent::publish_state(bool state) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   const char *state_s = state ? "ON" : "OFF";
-  return this->publish(this->get_state_topic_to_(topic_buf), state_s);
+  return this->publish(this->get_state_topic_(), state_s);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_text.cpp

@@ -26,7 +26,7 @@ void MQTTTextComponent::setup() {
 
 void MQTTTextComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT text '%s':", this->text_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, true)
+  LOG_MQTT_COMPONENT(true, true);
 }
 
 MQTT_COMPONENT_TYPE(MQTTTextComponent, "text")
@@ -53,8 +53,7 @@ bool MQTTTextComponent::send_initial_state() {
   }
 }
 bool MQTTTextComponent::publish_state(const std::string &value) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish(this->get_state_topic_to_(topic_buf), value.data(), value.size());
+  return this->publish(this->get_state_topic_(), value);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_text_sensor.cpp

@@ -31,10 +31,7 @@ void MQTTTextSensor::dump_config() {
   LOG_MQTT_COMPONENT(true, false);
 }
 
-bool MQTTTextSensor::publish_state(const std::string &value) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish(this->get_state_topic_to_(topic_buf), value.data(), value.size());
-}
+bool MQTTTextSensor::publish_state(const std::string &value) { return this->publish(this->get_state_topic_(), value); }
 bool MQTTTextSensor::send_initial_state() {
   if (this->sensor_->has_state()) {
     return this->publish_state(this->sensor_->state);

esphome/components/mqtt/mqtt_time.cpp

@@ -36,7 +36,7 @@ void MQTTTimeComponent::setup() {
 
 void MQTTTimeComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT Time '%s':", this->time_->get_name().c_str());
-  LOG_MQTT_COMPONENT(true, true)
+  LOG_MQTT_COMPONENT(true, true);
 }
 
 MQTT_COMPONENT_TYPE(MQTTTimeComponent, "time")
@@ -53,8 +53,7 @@ bool MQTTTimeComponent::send_initial_state() {
   }
 }
 bool MQTTTimeComponent::publish_state(uint8_t hour, uint8_t minute, uint8_t second) {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish_json(this->get_state_topic_to_(topic_buf), [hour, minute, second](JsonObject root) {
+  return this->publish_json(this->get_state_topic_(), [hour, minute, second](JsonObject root) {
     // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
     root[ESPHOME_F("hour")] = hour;
     root[ESPHOME_F("minute")] = minute;

esphome/components/mqtt/mqtt_update.cpp

@@ -28,8 +28,7 @@ void MQTTUpdateComponent::setup() {
 }
 
 bool MQTTUpdateComponent::publish_state() {
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish_json(this->get_state_topic_to_(topic_buf), [this](JsonObject root) {
+  return this->publish_json(this->get_state_topic_(), [this](JsonObject root) {
     root[ESPHOME_F("installed_version")] = this->update_->update_info.current_version;
     root[ESPHOME_F("latest_version")] = this->update_->update_info.latest_version;
     root[ESPHOME_F("title")] = this->update_->update_info.title;

esphome/components/mqtt/mqtt_valve.cpp

@@ -39,7 +39,7 @@ void MQTTValveComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "MQTT valve '%s':", this->valve_->get_name().c_str());
   auto traits = this->valve_->get_traits();
   bool has_command_topic = traits.get_supports_position();
-  LOG_MQTT_COMPONENT(true, has_command_topic)
+  LOG_MQTT_COMPONENT(true, has_command_topic);
   if (traits.get_supports_position()) {
     ESP_LOGCONFIG(TAG,
                   "  Position State Topic: '%s'\n"
@@ -84,8 +84,7 @@ bool MQTTValveComponent::publish_state() {
                         : this->valve_->position == VALVE_OPEN                       ? "open"
                         : traits.get_supports_position()                             ? "open"
                                                                                      : "unknown";
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  if (!this->publish(this->get_state_topic_to_(topic_buf), state_s))
+  if (!this->publish(this->get_state_topic_(), state_s))
     success = false;
   return success;
 }

esphome/components/network/ip_address.h

@@ -60,8 +60,6 @@ struct IPAddress {
   }
   IPAddress(const std::string &in_address) { inet_aton(in_address.c_str(), &ip_addr_); }
   IPAddress(const ip_addr_t *other_ip) { ip_addr_ = *other_ip; }
-  // Remove before 2026.8.0
-  ESPDEPRECATED("Use str_to() instead. Removed in 2026.8.0", "2026.2.0")
   std::string str() const {
     char buf[IP_ADDRESS_BUFFER_SIZE];
     this->str_to(buf);
@@ -149,8 +147,6 @@ struct IPAddress {
   bool is_ip4() const { return IP_IS_V4(&ip_addr_); }
   bool is_ip6() const { return IP_IS_V6(&ip_addr_); }
   bool is_multicast() const { return ip_addr_ismulticast(&ip_addr_); }
-  // Remove before 2026.8.0
-  ESPDEPRECATED("Use str_to() instead. Removed in 2026.8.0", "2026.2.0")
   std::string str() const {
     char buf[IP_ADDRESS_BUFFER_SIZE];
     this->str_to(buf);

esphome/components/rf_bridge/rf_bridge.cpp

@@ -1,7 +1,6 @@
 #include "rf_bridge.h"
-#include "esphome/core/application.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/application.h"
 #include <cinttypes>
 #include <cstring>
 
@@ -73,9 +72,9 @@ bool RFBridgeComponent::parse_bridge_byte_(uint8_t byte) {
 
       data.length = raw[2];
       data.protocol = raw[3];
-      char next_byte[3];  // 2 hex chars + null
+      char next_byte[3];
       for (uint8_t i = 0; i < data.length - 1; i++) {
-        buf_append_printf(next_byte, sizeof(next_byte), 0, "%02X", raw[4 + i]);
+        sprintf(next_byte, "%02X", raw[4 + i]);
         data.code += next_byte;
       }
 
@@ -91,10 +90,10 @@ bool RFBridgeComponent::parse_bridge_byte_(uint8_t byte) {
 
       uint8_t buckets = raw[2] << 1;
       std::string str;
-      char next_byte[3];  // 2 hex chars + null
+      char next_byte[3];
 
       for (uint32_t i = 0; i <= at; i++) {
-        buf_append_printf(next_byte, sizeof(next_byte), 0, "%02X", raw[i]);
+        sprintf(next_byte, "%02X", raw[i]);
         str += next_byte;
         if ((i > 3) && buckets) {
           buckets--;

esphome/components/sensor/__init__.py

@@ -9,7 +9,6 @@ from esphome.const import (
     CONF_ABOVE,
     CONF_ACCURACY_DECIMALS,
     CONF_ALPHA,
-    CONF_BASELINE,
     CONF_BELOW,
     CONF_CALIBRATION,
     CONF_DEVICE_CLASS,
@@ -39,6 +38,7 @@ from esphome.const import (
     CONF_TIMEOUT,
     CONF_TO,
     CONF_TRIGGER_ID,
+    CONF_TYPE,
     CONF_UNIT_OF_MEASUREMENT,
     CONF_VALUE,
     CONF_WEB_SERVER,
@@ -107,7 +107,7 @@ from esphome.const import (
 )
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
-from esphome.cpp_generator import MockObj, MockObjClass
+from esphome.cpp_generator import MockObjClass
 from esphome.util import Registry
 
 CODEOWNERS = ["@esphome/core"]
@@ -574,56 +574,38 @@ async def lambda_filter_to_code(config, filter_id):
     return automation.new_lambda_pvariable(filter_id, lambda_, StatelessLambdaFilter)
 
 
-def validate_delta_value(value):
-    if isinstance(value, str) and value.endswith("%"):
-        # Check it's a well-formed percentage, but return the string as-is
-        try:
-            cv.positive_float(value[:-1])
-            return value
-        except cv.Invalid as exc:
-            raise cv.Invalid("Malformed delta % value") from exc
-    return cv.positive_float(value)
-
-
-# This ideally would be done with `cv.maybe_simple_value` but it doesn't seem to respect the default for min_value.
-DELTA_SCHEMA = cv.Any(
-    cv.All(
-        {
-            # Ideally this would be 'default=float("inf")' but it doesn't translate well to C++
-            cv.Optional(CONF_MAX_VALUE): validate_delta_value,
-            cv.Optional(CONF_MIN_VALUE, default="0.0"): validate_delta_value,
-            cv.Optional(CONF_BASELINE): cv.templatable(cv.float_),
-        },
-        cv.has_at_least_one_key(CONF_MAX_VALUE, CONF_MIN_VALUE),
-    ),
-    validate_delta_value,
+DELTA_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_VALUE): cv.positive_float,
+        cv.Optional(CONF_TYPE, default="absolute"): cv.one_of(
+            "absolute", "percentage", lower=True
+        ),
+    }
 )
 
 
-def _get_delta(value):
-    if isinstance(value, str):
-        assert value.endswith("%")
-        return 0.0, float(value[:-1])
-    return value, 0.0
+def validate_delta(config):
+    try:
+        value = cv.positive_float(config)
+        return DELTA_SCHEMA({CONF_VALUE: value, CONF_TYPE: "absolute"})
+    except cv.Invalid:
+        pass
+    try:
+        value = cv.percentage(config)
+        return DELTA_SCHEMA({CONF_VALUE: value, CONF_TYPE: "percentage"})
+    except cv.Invalid:
+        pass
+    raise cv.Invalid("Delta filter requires a positive number or percentage value.")
 
 
-@FILTER_REGISTRY.register("delta", DeltaFilter, DELTA_SCHEMA)
+@FILTER_REGISTRY.register("delta", DeltaFilter, cv.Any(DELTA_SCHEMA, validate_delta))
 async def delta_filter_to_code(config, filter_id):
-    # The config could be just the min_value, or it could be a dict.
-    max = MockObj("std::numeric_limits<float>::infinity()"), 0
-    if isinstance(config, dict):
-        min = _get_delta(config[CONF_MIN_VALUE])
-        if CONF_MAX_VALUE in config:
-            max = _get_delta(config[CONF_MAX_VALUE])
-    else:
-        min = _get_delta(config)
-    var = cg.new_Pvariable(filter_id, *min, *max)
-    if isinstance(config, dict) and (baseline_lambda := config.get(CONF_BASELINE)):
-        baseline = await cg.process_lambda(
-            baseline_lambda, [(float, "x")], return_type=float
-        )
-        cg.add(var.set_baseline(baseline))
-    return var
+    percentage = config[CONF_TYPE] == "percentage"
+    return cg.new_Pvariable(
+        filter_id,
+        config[CONF_VALUE],
+        percentage,
+    )
 
 
 @FILTER_REGISTRY.register("or", OrFilter, validate_filters)

esphome/components/sensor/filter.cpp

@@ -291,27 +291,22 @@ optional<float> ThrottleWithPriorityFilter::new_value(float value) {
 }
 
 // DeltaFilter
-DeltaFilter::DeltaFilter(float min_a0, float min_a1, float max_a0, float max_a1)
-    : min_a0_(min_a0), min_a1_(min_a1), max_a0_(max_a0), max_a1_(max_a1) {}
-
-void DeltaFilter::set_baseline(float (*fn)(float)) { this->baseline_ = fn; }
-
+DeltaFilter::DeltaFilter(float delta, bool percentage_mode)
+    : delta_(delta), current_delta_(delta), last_value_(NAN), percentage_mode_(percentage_mode) {}
 optional<float> DeltaFilter::new_value(float value) {
-  // Always yield the first value.
-  if (std::isnan(this->last_value_)) {
-    this->last_value_ = value;
-    return value;
+  if (std::isnan(value)) {
+    if (std::isnan(this->last_value_)) {
+      return {};
+    } else {
+      return this->last_value_ = value;
+    }
   }
-  // calculate min and max using the linear equation
-  float ref = this->baseline_(this->last_value_);
-  float min = fabsf(this->min_a0_ + ref * this->min_a1_);
-  float max = fabsf(this->max_a0_ + ref * this->max_a1_);
-  float delta = fabsf(value - ref);
-  // if there is no reference, e.g. for the first value, just accept this one,
-  // otherwise accept only if within range.
-  if (delta > min && delta <= max) {
-    this->last_value_ = value;
-    return value;
+  float diff = fabsf(value - this->last_value_);
+  if (std::isnan(this->last_value_) || (diff > 0.0f && diff >= this->current_delta_)) {
+    if (this->percentage_mode_) {
+      this->current_delta_ = fabsf(value * this->delta_);
+    }
+    return this->last_value_ = value;
   }
   return {};
 }

esphome/components/sensor/filter.h

@@ -452,21 +452,15 @@ class HeartbeatFilter : public Filter, public Component {
 
 class DeltaFilter : public Filter {
  public:
-  explicit DeltaFilter(float min_a0, float min_a1, float max_a0, float max_a1);
-
-  void set_baseline(float (*fn)(float));
+  explicit DeltaFilter(float delta, bool percentage_mode);
 
   optional<float> new_value(float value) override;
 
  protected:
-  // These values represent linear equations for the min and max values but in practice only one of a0 and a1 will be
-  // non-zero Each limit is calculated as fabs(a0 + value * a1)
-
-  float min_a0_, min_a1_, max_a0_, max_a1_;
-  // default baseline is the previous value
-  float (*baseline_)(float) = [](float last_value) { return last_value; };
-
+  float delta_;
+  float current_delta_;
   float last_value_{NAN};
+  bool percentage_mode_;
 };
 
 class OrFilter : public Filter {

esphome/components/shtcx/shtcx.cpp

@@ -13,14 +13,14 @@ static const uint16_t SHTCX_COMMAND_READ_ID_REGISTER = 0xEFC8;
 static const uint16_t SHTCX_COMMAND_SOFT_RESET = 0x805D;
 static const uint16_t SHTCX_COMMAND_POLLING_H = 0x7866;
 
-static const LogString *shtcx_type_to_string(SHTCXType type) {
+inline const char *to_string(SHTCXType type) {
   switch (type) {
     case SHTCX_TYPE_SHTC3:
-      return LOG_STR("SHTC3");
+      return "SHTC3";
     case SHTCX_TYPE_SHTC1:
-      return LOG_STR("SHTC1");
+      return "SHTC1";
     default:
-      return LOG_STR("UNKNOWN");
+      return "UNKNOWN";
   }
 }
 
@@ -52,7 +52,7 @@ void SHTCXComponent::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "SHTCx:\n"
                 "  Model: %s (%04x)",
-                LOG_STR_ARG(shtcx_type_to_string(this->type_)), this->sensor_id_);
+                to_string(this->type_), this->sensor_id_);
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);

esphome/components/socket/socket.cpp

@@ -46,15 +46,15 @@ static inline const char *esphome_inet_ntop6(const void *addr, char *buf, size_t
 #endif
 
 // Format sockaddr into caller-provided buffer, returns length written (excluding null)
-size_t format_sockaddr_to(const struct sockaddr *addr_ptr, socklen_t len, std::span<char, SOCKADDR_STR_LEN> buf) {
-  if (addr_ptr->sa_family == AF_INET && len >= sizeof(const struct sockaddr_in)) {
-    const auto *addr = reinterpret_cast<const struct sockaddr_in *>(addr_ptr);
+static size_t format_sockaddr_to(const struct sockaddr_storage &storage, std::span<char, SOCKADDR_STR_LEN> buf) {
+  if (storage.ss_family == AF_INET) {
+    const auto *addr = reinterpret_cast<const struct sockaddr_in *>(&storage);
     if (esphome_inet_ntop4(&addr->sin_addr, buf.data(), buf.size()) != nullptr)
       return strlen(buf.data());
   }
 #if USE_NETWORK_IPV6
-  else if (addr_ptr->sa_family == AF_INET6 && len >= sizeof(sockaddr_in6)) {
-    const auto *addr = reinterpret_cast<const struct sockaddr_in6 *>(addr_ptr);
+  else if (storage.ss_family == AF_INET6) {
+    const auto *addr = reinterpret_cast<const struct sockaddr_in6 *>(&storage);
 #ifndef USE_SOCKET_IMPL_LWIP_TCP
     // Format IPv4-mapped IPv6 addresses as regular IPv4 (not supported on ESP8266 raw TCP)
     if (addr->sin6_addr.un.u32_addr[0] == 0 && addr->sin6_addr.un.u32_addr[1] == 0 &&
@@ -78,7 +78,7 @@ size_t Socket::getpeername_to(std::span<char, SOCKADDR_STR_LEN> buf) {
     buf[0] = '\0';
     return 0;
   }
-  return format_sockaddr_to(reinterpret_cast<struct sockaddr *>(&storage), len, buf);
+  return format_sockaddr_to(storage, buf);
 }
 
 size_t Socket::getsockname_to(std::span<char, SOCKADDR_STR_LEN> buf) {
@@ -88,7 +88,7 @@ size_t Socket::getsockname_to(std::span<char, SOCKADDR_STR_LEN> buf) {
     buf[0] = '\0';
     return 0;
   }
-  return format_sockaddr_to(reinterpret_cast<struct sockaddr *>(&storage), len, buf);
+  return format_sockaddr_to(storage, buf);
 }
 
 std::unique_ptr<Socket> socket_ip(int type, int protocol) {

esphome/components/socket/socket.h

@@ -102,9 +102,6 @@ inline socklen_t set_sockaddr(struct sockaddr *addr, socklen_t addrlen, const st
 /// Set a sockaddr to the any address and specified port for the IP version used by socket_ip().
 socklen_t set_sockaddr_any(struct sockaddr *addr, socklen_t addrlen, uint16_t port);
 
-/// Format sockaddr into caller-provided buffer, returns length written (excluding null)
-size_t format_sockaddr_to(const struct sockaddr *addr_ptr, socklen_t len, std::span<char, SOCKADDR_STR_LEN> buf);
-
 #if defined(USE_ESP8266) && defined(USE_SOCKET_IMPL_LWIP_TCP)
 /// Delay that can be woken early by socket activity.
 /// On ESP8266, lwip callbacks set a flag and call esp_schedule() to wake the delay.