Merge branch 'dev' into compact_string_wifi

# Conflicts:
#	esphome/components/wifi/wifi_component_esp_idf.cpp

.clang-tidy.hash

@@ -1 +1 @@
-37ec8d5a343c8d0a485fd2118cbdabcbccd7b9bca197e4a392be75087974dced
+069fa9526c52f7c580a9ec17c7678d12f142221387e9b561c18f95394d4629a3

.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@45cbd0c69e560cd9e7cd7f8c32362050c9b7ded2 # v4.32.2
+        uses: github/codeql-action/init@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4.32.0
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@45cbd0c69e560cd9e7cd7f8c32362050c9b7ded2 # v4.32.2
+        uses: github/codeql-action/analyze@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4.32.0
         with:
           category: "/language:${{matrix.language}}"

.pre-commit-config.yaml

@@ -11,7 +11,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.15.0
+    rev: v0.14.14
     hooks:
       # Run the linter.
       - id: ruff

CODEOWNERS

@@ -532,7 +532,7 @@ esphome/components/uart/packet_transport/* @clydebarrow
 esphome/components/udp/* @clydebarrow
 esphome/components/ufire_ec/* @pvizeli
 esphome/components/ufire_ise/* @pvizeli
-esphome/components/ultrasonic/* @ssieb @swoboda1337
+esphome/components/ultrasonic/* @OttoWinter
 esphome/components/update/* @jesserockz
 esphome/components/uponor_smatrix/* @kroimon
 esphome/components/usb_cdc_acm/* @kbx81

esphome/__main__.py

@@ -294,13 +294,8 @@ def has_api() -> bool:
 
 
 def has_ota() -> bool:
-    """Check if OTA upload is available (requires platform: esphome)."""
-    if CONF_OTA not in CORE.config:
-        return False
-    return any(
-        ota_item.get(CONF_PLATFORM) == CONF_ESPHOME
-        for ota_item in CORE.config[CONF_OTA]
-    )
+    """Check if OTA is available."""
+    return CONF_OTA in CORE.config
 
 
 def has_mqtt_ip_lookup() -> bool:

esphome/analyze_memory/__init__.py

@@ -12,6 +12,7 @@ from .const import (
     CORE_SUBCATEGORY_PATTERNS,
     DEMANGLED_PATTERNS,
     ESPHOME_COMPONENT_PATTERN,
+    SECTION_TO_ATTR,
     SYMBOL_PATTERNS,
 )
 from .demangle import batch_demangle
@@ -90,17 +91,6 @@ class ComponentMemory:
     bss_size: int = 0  # Uninitialized data (ram only)
     symbol_count: int = 0
 
-    def add_section_size(self, section_name: str, size: int) -> None:
-        """Add size to the appropriate attribute for a section."""
-        if section_name == ".text":
-            self.text_size += size
-        elif section_name == ".rodata":
-            self.rodata_size += size
-        elif section_name == ".data":
-            self.data_size += size
-        elif section_name == ".bss":
-            self.bss_size += size
-
     @property
     def flash_total(self) -> int:
         """Total flash usage (text + rodata + data)."""
@@ -177,15 +167,12 @@ class MemoryAnalyzer:
         self._elf_symbol_names: set[str] = set()
         # SDK symbols not in ELF (static/local symbols from closed-source libs)
         self._sdk_symbols: list[SDKSymbol] = []
-        # CSWTCH symbols: list of (name, size, source_file, component)
-        self._cswtch_symbols: list[tuple[str, int, str, str]] = []
 
     def analyze(self) -> dict[str, ComponentMemory]:
         """Analyze the ELF file and return component memory usage."""
         self._parse_sections()
         self._parse_symbols()
         self._categorize_symbols()
-        self._analyze_cswtch_symbols()
         self._analyze_sdk_libraries()
         return dict(self.components)
 
@@ -268,7 +255,8 @@ class MemoryAnalyzer:
                 comp_mem.symbol_count += 1
 
                 # Update the appropriate size attribute based on section
-                comp_mem.add_section_size(section_name, size)
+                if attr_name := SECTION_TO_ATTR.get(section_name):
+                    setattr(comp_mem, attr_name, getattr(comp_mem, attr_name) + size)
 
                 # Track uncategorized symbols
                 if component == "other" and size > 0:
@@ -384,205 +372,6 @@ class MemoryAnalyzer:
 
         return "Other Core"
 
-    def _find_object_files_dir(self) -> Path | None:
-        """Find the directory containing object files for this build.
-
-        Returns:
-            Path to the directory containing .o files, or None if not found.
-        """
-        # The ELF is typically at .pioenvs/<env>/firmware.elf
-        # Object files are in .pioenvs/<env>/src/ and .pioenvs/<env>/lib*/
-        pioenvs_dir = self.elf_path.parent
-        if pioenvs_dir.exists() and any(pioenvs_dir.glob("src/*.o")):
-            return pioenvs_dir
-        return None
-
-    def _scan_cswtch_in_objects(
-        self, obj_dir: Path
-    ) -> dict[str, list[tuple[str, int]]]:
-        """Scan object files for CSWTCH symbols using a single nm invocation.
-
-        Uses ``nm --print-file-name -S`` on all ``.o`` files at once.
-        Output format: ``/path/to/file.o:address size type name``
-
-        Args:
-            obj_dir: Directory containing object files (.pioenvs/<env>/)
-
-        Returns:
-            Dict mapping "CSWTCH$NNN:size" to list of (source_file, size) tuples.
-        """
-        cswtch_map: dict[str, list[tuple[str, int]]] = defaultdict(list)
-
-        if not self.nm_path:
-            return cswtch_map
-
-        # Find all .o files recursively, sorted for deterministic output
-        obj_files = sorted(obj_dir.rglob("*.o"))
-        if not obj_files:
-            return cswtch_map
-
-        _LOGGER.debug("Scanning %d object files for CSWTCH symbols", len(obj_files))
-
-        # Single nm call with --print-file-name for all object files
-        result = run_tool(
-            [self.nm_path, "--print-file-name", "-S"] + [str(f) for f in obj_files],
-            timeout=30,
-        )
-        if result is None or result.returncode != 0:
-            return cswtch_map
-
-        for line in result.stdout.splitlines():
-            if "CSWTCH$" not in line:
-                continue
-
-            # Split on last ":" that precedes a hex address.
-            # nm --print-file-name format: filepath:hex_addr hex_size type name
-            # We split from the right: find the last colon followed by hex digits.
-            parts_after_colon = line.rsplit(":", 1)
-            if len(parts_after_colon) != 2:
-                continue
-
-            file_path = parts_after_colon[0]
-            fields = parts_after_colon[1].split()
-            # fields: [address, size, type, name]
-            if len(fields) < 4:
-                continue
-
-            sym_name = fields[3]
-            if not sym_name.startswith("CSWTCH$"):
-                continue
-
-            try:
-                size = int(fields[1], 16)
-            except ValueError:
-                continue
-
-            # Get relative path from obj_dir for readability
-            try:
-                rel_path = str(Path(file_path).relative_to(obj_dir))
-            except ValueError:
-                rel_path = file_path
-
-            key = f"{sym_name}:{size}"
-            cswtch_map[key].append((rel_path, size))
-
-        return cswtch_map
-
-    def _source_file_to_component(self, source_file: str) -> str:
-        """Map a source object file path to its component name.
-
-        Args:
-            source_file: Relative path like 'src/esphome/components/wifi/wifi_component.cpp.o'
-
-        Returns:
-            Component name like '[esphome]wifi' or the source file if unknown.
-        """
-        parts = Path(source_file).parts
-
-        # ESPHome component: src/esphome/components/<name>/...
-        if "components" in parts:
-            idx = parts.index("components")
-            if idx + 1 < len(parts):
-                component_name = parts[idx + 1]
-                if component_name in get_esphome_components():
-                    return f"{_COMPONENT_PREFIX_ESPHOME}{component_name}"
-                if component_name in self.external_components:
-                    return f"{_COMPONENT_PREFIX_EXTERNAL}{component_name}"
-
-        # ESPHome core: src/esphome/core/... or src/esphome/...
-        if "core" in parts and "esphome" in parts:
-            return _COMPONENT_CORE
-        if "esphome" in parts and "components" not in parts:
-            return _COMPONENT_CORE
-
-        # Framework/library files - return the first path component
-        # e.g., lib65b/ESPAsyncTCP/... -> lib65b
-        #        FrameworkArduino/... -> FrameworkArduino
-        return parts[0] if parts else source_file
-
-    def _analyze_cswtch_symbols(self) -> None:
-        """Analyze CSWTCH (GCC switch table) symbols by tracing to source objects.
-
-        CSWTCH symbols are compiler-generated lookup tables for switch statements.
-        They are local symbols, so the same name can appear in different object files.
-        This method scans .o files to attribute them to their source components.
-        """
-        obj_dir = self._find_object_files_dir()
-        if obj_dir is None:
-            _LOGGER.debug("No object files directory found, skipping CSWTCH analysis")
-            return
-
-        # Scan object files for CSWTCH symbols
-        cswtch_map = self._scan_cswtch_in_objects(obj_dir)
-        if not cswtch_map:
-            _LOGGER.debug("No CSWTCH symbols found in object files")
-            return
-
-        # Collect CSWTCH symbols from the ELF (already parsed in sections)
-        # Include section_name for re-attribution of component totals
-        elf_cswtch = [
-            (symbol_name, size, section_name)
-            for section_name, section in self.sections.items()
-            for symbol_name, size, _ in section.symbols
-            if symbol_name.startswith("CSWTCH$")
-        ]
-
-        _LOGGER.debug(
-            "Found %d CSWTCH symbols in ELF, %d unique in object files",
-            len(elf_cswtch),
-            len(cswtch_map),
-        )
-
-        # Match ELF CSWTCH symbols to source files and re-attribute component totals.
-        # _categorize_symbols() already ran and put these into "other" since CSWTCH$
-        # names don't match any component pattern. We move the bytes to the correct
-        # component based on the object file mapping.
-        other_mem = self.components.get("other")
-
-        for sym_name, size, section_name in elf_cswtch:
-            key = f"{sym_name}:{size}"
-            sources = cswtch_map.get(key, [])
-
-            if len(sources) == 1:
-                source_file = sources[0][0]
-                component = self._source_file_to_component(source_file)
-            elif len(sources) > 1:
-                # Ambiguous - multiple object files have same CSWTCH name+size
-                source_file = "ambiguous"
-                component = "ambiguous"
-                _LOGGER.debug(
-                    "Ambiguous CSWTCH %s (%d B) found in %d files: %s",
-                    sym_name,
-                    size,
-                    len(sources),
-                    ", ".join(src for src, _ in sources),
-                )
-            else:
-                source_file = "unknown"
-                component = "unknown"
-
-            self._cswtch_symbols.append((sym_name, size, source_file, component))
-
-            # Re-attribute from "other" to the correct component
-            if (
-                component not in ("other", "unknown", "ambiguous")
-                and other_mem is not None
-            ):
-                other_mem.add_section_size(section_name, -size)
-                if component not in self.components:
-                    self.components[component] = ComponentMemory(component)
-                self.components[component].add_section_size(section_name, size)
-
-        # Sort by size descending
-        self._cswtch_symbols.sort(key=lambda x: x[1], reverse=True)
-
-        total_size = sum(size for _, size, _, _ in self._cswtch_symbols)
-        _LOGGER.debug(
-            "CSWTCH analysis: %d symbols, %d bytes total",
-            len(self._cswtch_symbols),
-            total_size,
-        )
-
     def get_unattributed_ram(self) -> tuple[int, int, int]:
         """Get unattributed RAM sizes (SDK/framework overhead).
 

esphome/analyze_memory/cli.py

@@ -184,52 +184,6 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                 f"{i + 1:>2}. {size:>7,} B {section_label:<8} {demangled_display:<{self.COL_TOP_SYMBOL_NAME}} {component}"
             )
 
-    def _add_cswtch_analysis(self, lines: list[str]) -> None:
-        """Add CSWTCH (GCC switch table lookup) analysis section."""
-        self._add_section_header(lines, "CSWTCH Analysis (GCC Switch Table Lookups)")
-
-        total_size = sum(size for _, size, _, _ in self._cswtch_symbols)
-        lines.append(
-            f"Total: {len(self._cswtch_symbols)} switch table(s), {total_size:,} B"
-        )
-        lines.append("")
-
-        # Group by component
-        by_component: dict[str, list[tuple[str, int, str]]] = defaultdict(list)
-        for sym_name, size, source_file, component in self._cswtch_symbols:
-            by_component[component].append((sym_name, size, source_file))
-
-        # Sort components by total size descending
-        sorted_components = sorted(
-            by_component.items(),
-            key=lambda x: sum(s[1] for s in x[1]),
-            reverse=True,
-        )
-
-        for component, symbols in sorted_components:
-            comp_total = sum(s[1] for s in symbols)
-            lines.append(f"{component} ({comp_total:,} B, {len(symbols)} tables):")
-
-            # Group by source file within component
-            by_file: dict[str, list[tuple[str, int]]] = defaultdict(list)
-            for sym_name, size, source_file in symbols:
-                by_file[source_file].append((sym_name, size))
-
-            for source_file, file_symbols in sorted(
-                by_file.items(),
-                key=lambda x: sum(s[1] for s in x[1]),
-                reverse=True,
-            ):
-                file_total = sum(s[1] for s in file_symbols)
-                lines.append(
-                    f"  {source_file} ({file_total:,} B, {len(file_symbols)} tables)"
-                )
-                for sym_name, size in sorted(
-                    file_symbols, key=lambda x: x[1], reverse=True
-                ):
-                    lines.append(f"    {size:>6,} B  {sym_name}")
-            lines.append("")
-
     def generate_report(self, detailed: bool = False) -> str:
         """Generate a formatted memory report."""
         components = sorted(
@@ -517,10 +471,6 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                     lines.append(f"    ... and {len(large_ram_syms) - 10} more")
             lines.append("")
 
-        # CSWTCH (GCC switch table) analysis
-        if self._cswtch_symbols:
-            self._add_cswtch_analysis(lines)
-
         lines.append(
             "Note: This analysis covers symbols in the ELF file. Some runtime allocations may not be included."
         )

esphome/analyze_memory/const.py

@@ -66,6 +66,15 @@ SECTION_MAPPING = {
     ),
 }
 
+# Section to ComponentMemory attribute mapping
+# Maps section names to the attribute name in ComponentMemory dataclass
+SECTION_TO_ATTR = {
+    ".text": "text_size",
+    ".rodata": "rodata_size",
+    ".data": "data_size",
+    ".bss": "bss_size",
+}
+
 # Component identification rules
 # Symbol patterns: patterns found in raw symbol names
 SYMBOL_PATTERNS = {
@@ -504,9 +513,7 @@ SYMBOL_PATTERNS = {
         "__FUNCTION__$",
         "DAYS_IN_MONTH",
         "_DAYS_BEFORE_MONTH",
-        # Note: CSWTCH$ symbols are GCC switch table lookup tables.
-        # They are attributed to their source object files via _analyze_cswtch_symbols()
-        # rather than being lumped into libc.
+        "CSWTCH$",
         "dst$",
         "sulp",
         "_strtol_l",  # String to long with locale

esphome/codegen.py

@@ -87,7 +87,6 @@ from esphome.cpp_types import (  # noqa: F401
     size_t,
     std_ns,
     std_shared_ptr,
-    std_span,
     std_string,
     std_string_ref,
     std_vector,

esphome/components/absolute_humidity/absolute_humidity.cpp

@@ -45,6 +45,8 @@ void AbsoluteHumidityComponent::dump_config() {
                 this->temperature_sensor_->get_name().c_str(), this->humidity_sensor_->get_name().c_str());
 }
 
+float AbsoluteHumidityComponent::get_setup_priority() const { return setup_priority::DATA; }
+
 void AbsoluteHumidityComponent::loop() {
   if (!this->next_update_) {
     return;

esphome/components/absolute_humidity/absolute_humidity.h

@@ -24,6 +24,7 @@ class AbsoluteHumidityComponent : public sensor::Sensor, public Component {
 
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void loop() override;
 
  protected:

esphome/components/adc/adc_sensor.h

@@ -68,6 +68,11 @@ class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage
   /// This method is called during the ESPHome setup process to log the configuration.
   void dump_config() override;
 
+  /// Return the setup priority for this component.
+  /// Components with higher priority are initialized earlier during setup.
+  /// @return A float representing the setup priority.
+  float get_setup_priority() const override;
+
 #ifdef USE_ZEPHYR
   /// Set the ADC channel to be used by the ADC sensor.
   /// @param channel Pointer to an adc_dt_spec structure representing the ADC channel.

esphome/components/adc/adc_sensor_common.cpp

@@ -79,5 +79,7 @@ void ADCSensor::set_sample_count(uint8_t sample_count) {
 
 void ADCSensor::set_sampling_mode(SamplingMode sampling_mode) { this->sampling_mode_ = sampling_mode; }
 
+float ADCSensor::get_setup_priority() const { return setup_priority::DATA; }
+
 }  // namespace adc
 }  // namespace esphome

esphome/components/adc/adc_sensor_esp32.cpp

@@ -42,11 +42,11 @@ void ADCSensor::setup() {
     adc_oneshot_unit_init_cfg_t init_config = {};  // Zero initialize
     init_config.unit_id = this->adc_unit_;
     init_config.ulp_mode = ADC_ULP_MODE_DISABLE;
-#if USE_ESP32_VARIANT_ESP32C2 || USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || \
-    USE_ESP32_VARIANT_ESP32C6 || USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2
+#if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \
+    USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2
     init_config.clk_src = ADC_DIGI_CLK_SRC_DEFAULT;
-#endif  // USE_ESP32_VARIANT_ESP32C2 || USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 ||
-        // USE_ESP32_VARIANT_ESP32C6 || USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2
+#endif  // USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 ||
+        // USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2
     esp_err_t err = adc_oneshot_new_unit(&init_config, &ADCSensor::shared_adc_handles[this->adc_unit_]);
     if (err != ESP_OK) {
       ESP_LOGE(TAG, "Error initializing %s: %d", LOG_STR_ARG(adc_unit_to_str(this->adc_unit_)), err);
@@ -76,7 +76,7 @@ void ADCSensor::setup() {
 
 #if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \
     USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2 || USE_ESP32_VARIANT_ESP32P4 || USE_ESP32_VARIANT_ESP32S3
-    // RISC-V variants (except C2) and S3 use curve fitting calibration
+    // RISC-V variants and S3 use curve fitting calibration
     adc_cali_curve_fitting_config_t cali_config = {};  // Zero initialize first
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
     cali_config.chan = this->channel_;
@@ -94,14 +94,14 @@ void ADCSensor::setup() {
       ESP_LOGW(TAG, "Curve fitting calibration failed with error %d, will use uncalibrated readings", err);
       this->setup_flags_.calibration_complete = false;
     }
-#else  // ESP32, ESP32-S2, and ESP32-C2 use line fitting calibration
+#else  // Other ESP32 variants use line fitting calibration
     adc_cali_line_fitting_config_t cali_config = {
       .unit_id = this->adc_unit_,
       .atten = this->attenuation_,
       .bitwidth = ADC_BITWIDTH_DEFAULT,
-#if !defined(USE_ESP32_VARIANT_ESP32S2) && !defined(USE_ESP32_VARIANT_ESP32C2)
+#if !defined(USE_ESP32_VARIANT_ESP32S2)
       .default_vref = 1100,  // Default reference voltage in mV
-#endif  // !defined(USE_ESP32_VARIANT_ESP32S2) && !defined(USE_ESP32_VARIANT_ESP32C2)
+#endif  // !defined(USE_ESP32_VARIANT_ESP32S2)
     };
     err = adc_cali_create_scheme_line_fitting(&cali_config, &handle);
     if (err == ESP_OK) {
@@ -112,7 +112,7 @@ void ADCSensor::setup() {
       ESP_LOGW(TAG, "Line fitting calibration failed with error %d, will use uncalibrated readings", err);
       this->setup_flags_.calibration_complete = false;
     }
-#endif  // ESP32C3 || ESP32C5 || ESP32C6 || ESP32C61 || ESP32H2 || ESP32P4 || ESP32S3
+#endif  // USE_ESP32_VARIANT_ESP32C3 || ESP32C5 || ESP32C6 || ESP32C61 || ESP32H2 || ESP32P4 || ESP32S3
   }
 
   this->setup_flags_.init_complete = true;
@@ -189,7 +189,7 @@ float ADCSensor::sample_fixed_attenuation_() {
         adc_cali_delete_scheme_curve_fitting(this->calibration_handle_);
 #else   // Other ESP32 variants use line fitting calibration
         adc_cali_delete_scheme_line_fitting(this->calibration_handle_);
-#endif  // ESP32C3 || ESP32C5 || ESP32C6 || ESP32C61 || ESP32H2 || ESP32P4 || ESP32S3
+#endif  // USE_ESP32_VARIANT_ESP32C3 || ESP32C5 || ESP32C6 || ESP32C61 || ESP32H2 || ESP32P4 || ESP32S3
         this->calibration_handle_ = nullptr;
       }
     }
@@ -247,7 +247,7 @@ float ADCSensor::sample_autorange_() {
       .unit_id = this->adc_unit_,
       .atten = atten,
       .bitwidth = ADC_BITWIDTH_DEFAULT,
-#if !defined(USE_ESP32_VARIANT_ESP32S2) && !defined(USE_ESP32_VARIANT_ESP32C2)
+#if !defined(USE_ESP32_VARIANT_ESP32S2)
       .default_vref = 1100,
 #endif
     };

esphome/components/adc128s102/sensor/adc128s102_sensor.cpp

@@ -9,6 +9,8 @@ static const char *const TAG = "adc128s102.sensor";
 
 ADC128S102Sensor::ADC128S102Sensor(uint8_t channel) : channel_(channel) {}
 
+float ADC128S102Sensor::get_setup_priority() const { return setup_priority::DATA; }
+
 void ADC128S102Sensor::dump_config() {
   LOG_SENSOR("", "ADC128S102 Sensor", this);
   ESP_LOGCONFIG(TAG, "  Pin: %u", this->channel_);

esphome/components/adc128s102/sensor/adc128s102_sensor.h

@@ -19,6 +19,7 @@ class ADC128S102Sensor : public PollingComponent,
 
   void update() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   float sample() override;
 
  protected:

esphome/components/aht10/aht10.cpp

@@ -150,6 +150,8 @@ void AHT10Component::update() {
   this->restart_read_();
 }
 
+float AHT10Component::get_setup_priority() const { return setup_priority::DATA; }
+
 void AHT10Component::dump_config() {
   ESP_LOGCONFIG(TAG, "AHT10:");
   LOG_I2C_DEVICE(this);

esphome/components/aht10/aht10.h

@@ -16,6 +16,7 @@ class AHT10Component : public PollingComponent, public i2c::I2CDevice {
   void setup() override;
   void update() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void set_variant(AHT10Variant variant) { this->variant_ = variant; }
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }

esphome/components/alarm_control_panel/alarm_control_panel_state.cpp

@@ -1,15 +1,32 @@
 #include "alarm_control_panel_state.h"
-#include "esphome/core/progmem.h"
 
 namespace esphome::alarm_control_panel {
 
-// Alarm control panel state strings indexed by AlarmControlPanelState enum (0-9)
-PROGMEM_STRING_TABLE(AlarmControlPanelStateStrings, "DISARMED", "ARMED_HOME", "ARMED_AWAY", "ARMED_NIGHT",
-                     "ARMED_VACATION", "ARMED_CUSTOM_BYPASS", "PENDING", "ARMING", "DISARMING", "TRIGGERED", "UNKNOWN");
-
 const LogString *alarm_control_panel_state_to_string(AlarmControlPanelState state) {
-  return AlarmControlPanelStateStrings::get_log_str(static_cast<uint8_t>(state),
-                                                    AlarmControlPanelStateStrings::LAST_INDEX);
+  switch (state) {
+    case ACP_STATE_DISARMED:
+      return LOG_STR("DISARMED");
+    case ACP_STATE_ARMED_HOME:
+      return LOG_STR("ARMED_HOME");
+    case ACP_STATE_ARMED_AWAY:
+      return LOG_STR("ARMED_AWAY");
+    case ACP_STATE_ARMED_NIGHT:
+      return LOG_STR("ARMED_NIGHT");
+    case ACP_STATE_ARMED_VACATION:
+      return LOG_STR("ARMED_VACATION");
+    case ACP_STATE_ARMED_CUSTOM_BYPASS:
+      return LOG_STR("ARMED_CUSTOM_BYPASS");
+    case ACP_STATE_PENDING:
+      return LOG_STR("PENDING");
+    case ACP_STATE_ARMING:
+      return LOG_STR("ARMING");
+    case ACP_STATE_DISARMING:
+      return LOG_STR("DISARMING");
+    case ACP_STATE_TRIGGERED:
+      return LOG_STR("TRIGGERED");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
 
 }  // namespace esphome::alarm_control_panel

esphome/components/am2315c/am2315c.cpp

@@ -176,5 +176,7 @@ void AM2315C::dump_config() {
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
 
+float AM2315C::get_setup_priority() const { return setup_priority::DATA; }
+
 }  // namespace am2315c
 }  // namespace esphome

esphome/components/am2315c/am2315c.h

@@ -33,6 +33,7 @@ class AM2315C : public PollingComponent, public i2c::I2CDevice {
   void dump_config() override;
   void update() override;
   void setup() override;
+  float get_setup_priority() const override;
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { this->temperature_sensor_ = temperature_sensor; }
   void set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }

esphome/components/am2320/am2320.cpp

@@ -51,6 +51,7 @@ void AM2320Component::dump_config() {
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
+float AM2320Component::get_setup_priority() const { return setup_priority::DATA; }
 
 bool AM2320Component::read_bytes_(uint8_t a_register, uint8_t *data, uint8_t len, uint32_t conversion) {
   if (!this->write_bytes(a_register, data, 2)) {

esphome/components/am2320/am2320.h

@@ -11,6 +11,7 @@ class AM2320Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void update() override;
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }

esphome/components/apds9960/apds9960.cpp

@@ -384,6 +384,7 @@ void APDS9960::process_dataset_(int up, int down, int left, int right) {
     }
   }
 }
+float APDS9960::get_setup_priority() const { return setup_priority::DATA; }
 bool APDS9960::is_proximity_enabled_() const {
   return
 #ifdef USE_SENSOR

esphome/components/apds9960/apds9960.h

@@ -32,6 +32,7 @@ class APDS9960 : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void update() override;
   void loop() override;
 

esphome/components/api/api_connection.h

@@ -47,72 +47,72 @@ class APIConnection final : public APIServerConnection {
 #endif
 #ifdef USE_COVER
   bool send_cover_state(cover::Cover *cover);
-  void on_cover_command_request(const CoverCommandRequest &msg) override;
+  void cover_command(const CoverCommandRequest &msg) override;
 #endif
 #ifdef USE_FAN
   bool send_fan_state(fan::Fan *fan);
-  void on_fan_command_request(const FanCommandRequest &msg) override;
+  void fan_command(const FanCommandRequest &msg) override;
 #endif
 #ifdef USE_LIGHT
   bool send_light_state(light::LightState *light);
-  void on_light_command_request(const LightCommandRequest &msg) override;
+  void light_command(const LightCommandRequest &msg) override;
 #endif
 #ifdef USE_SENSOR
   bool send_sensor_state(sensor::Sensor *sensor);
 #endif
 #ifdef USE_SWITCH
   bool send_switch_state(switch_::Switch *a_switch);
-  void on_switch_command_request(const SwitchCommandRequest &msg) override;
+  void switch_command(const SwitchCommandRequest &msg) override;
 #endif
 #ifdef USE_TEXT_SENSOR
   bool send_text_sensor_state(text_sensor::TextSensor *text_sensor);
 #endif
 #ifdef USE_CAMERA
   void set_camera_state(std::shared_ptr<camera::CameraImage> image);
-  void on_camera_image_request(const CameraImageRequest &msg) override;
+  void camera_image(const CameraImageRequest &msg) override;
 #endif
 #ifdef USE_CLIMATE
   bool send_climate_state(climate::Climate *climate);
-  void on_climate_command_request(const ClimateCommandRequest &msg) override;
+  void climate_command(const ClimateCommandRequest &msg) override;
 #endif
 #ifdef USE_NUMBER
   bool send_number_state(number::Number *number);
-  void on_number_command_request(const NumberCommandRequest &msg) override;
+  void number_command(const NumberCommandRequest &msg) override;
 #endif
 #ifdef USE_DATETIME_DATE
   bool send_date_state(datetime::DateEntity *date);
-  void on_date_command_request(const DateCommandRequest &msg) override;
+  void date_command(const DateCommandRequest &msg) override;
 #endif
 #ifdef USE_DATETIME_TIME
   bool send_time_state(datetime::TimeEntity *time);
-  void on_time_command_request(const TimeCommandRequest &msg) override;
+  void time_command(const TimeCommandRequest &msg) override;
 #endif
 #ifdef USE_DATETIME_DATETIME
   bool send_datetime_state(datetime::DateTimeEntity *datetime);
-  void on_date_time_command_request(const DateTimeCommandRequest &msg) override;
+  void datetime_command(const DateTimeCommandRequest &msg) override;
 #endif
 #ifdef USE_TEXT
   bool send_text_state(text::Text *text);
-  void on_text_command_request(const TextCommandRequest &msg) override;
+  void text_command(const TextCommandRequest &msg) override;
 #endif
 #ifdef USE_SELECT
   bool send_select_state(select::Select *select);
-  void on_select_command_request(const SelectCommandRequest &msg) override;
+  void select_command(const SelectCommandRequest &msg) override;
 #endif
 #ifdef USE_BUTTON
-  void on_button_command_request(const ButtonCommandRequest &msg) override;
+  void button_command(const ButtonCommandRequest &msg) override;
 #endif
 #ifdef USE_LOCK
   bool send_lock_state(lock::Lock *a_lock);
-  void on_lock_command_request(const LockCommandRequest &msg) override;
+  void lock_command(const LockCommandRequest &msg) override;
 #endif
 #ifdef USE_VALVE
   bool send_valve_state(valve::Valve *valve);
-  void on_valve_command_request(const ValveCommandRequest &msg) override;
+  void valve_command(const ValveCommandRequest &msg) override;
 #endif
 #ifdef USE_MEDIA_PLAYER
   bool send_media_player_state(media_player::MediaPlayer *media_player);
-  void on_media_player_command_request(const MediaPlayerCommandRequest &msg) override;
+  void media_player_command(const MediaPlayerCommandRequest &msg) override;
 #endif
   bool try_send_log_message(int level, const char *tag, const char *line, size_t message_len);
 #ifdef USE_API_HOMEASSISTANT_SERVICES
@@ -126,18 +126,18 @@ class APIConnection final : public APIServerConnection {
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
 #endif  // USE_API_HOMEASSISTANT_SERVICES
 #ifdef USE_BLUETOOTH_PROXY
-  void on_subscribe_bluetooth_le_advertisements_request(const SubscribeBluetoothLEAdvertisementsRequest &msg) override;
-  void on_unsubscribe_bluetooth_le_advertisements_request() override;
+  void subscribe_bluetooth_le_advertisements(const SubscribeBluetoothLEAdvertisementsRequest &msg) override;
+  void unsubscribe_bluetooth_le_advertisements(const UnsubscribeBluetoothLEAdvertisementsRequest &msg) override;
 
-  void on_bluetooth_device_request(const BluetoothDeviceRequest &msg) override;
-  void on_bluetooth_gatt_read_request(const BluetoothGATTReadRequest &msg) override;
-  void on_bluetooth_gatt_write_request(const BluetoothGATTWriteRequest &msg) override;
-  void on_bluetooth_gatt_read_descriptor_request(const BluetoothGATTReadDescriptorRequest &msg) override;
-  void on_bluetooth_gatt_write_descriptor_request(const BluetoothGATTWriteDescriptorRequest &msg) override;
-  void on_bluetooth_gatt_get_services_request(const BluetoothGATTGetServicesRequest &msg) override;
-  void on_bluetooth_gatt_notify_request(const BluetoothGATTNotifyRequest &msg) override;
-  void on_subscribe_bluetooth_connections_free_request() override;
-  void on_bluetooth_scanner_set_mode_request(const BluetoothScannerSetModeRequest &msg) override;
+  void bluetooth_device_request(const BluetoothDeviceRequest &msg) override;
+  void bluetooth_gatt_read(const BluetoothGATTReadRequest &msg) override;
+  void bluetooth_gatt_write(const BluetoothGATTWriteRequest &msg) override;
+  void bluetooth_gatt_read_descriptor(const BluetoothGATTReadDescriptorRequest &msg) override;
+  void bluetooth_gatt_write_descriptor(const BluetoothGATTWriteDescriptorRequest &msg) override;
+  void bluetooth_gatt_get_services(const BluetoothGATTGetServicesRequest &msg) override;
+  void bluetooth_gatt_notify(const BluetoothGATTNotifyRequest &msg) override;
+  bool send_subscribe_bluetooth_connections_free_response(const SubscribeBluetoothConnectionsFreeRequest &msg) override;
+  void bluetooth_scanner_set_mode(const BluetoothScannerSetModeRequest &msg) override;
 
 #endif
 #ifdef USE_HOMEASSISTANT_TIME
@@ -148,33 +148,33 @@ class APIConnection final : public APIServerConnection {
 #endif
 
 #ifdef USE_VOICE_ASSISTANT
-  void on_subscribe_voice_assistant_request(const SubscribeVoiceAssistantRequest &msg) override;
+  void subscribe_voice_assistant(const SubscribeVoiceAssistantRequest &msg) override;
   void on_voice_assistant_response(const VoiceAssistantResponse &msg) override;
   void on_voice_assistant_event_response(const VoiceAssistantEventResponse &msg) override;
   void on_voice_assistant_audio(const VoiceAssistantAudio &msg) override;
   void on_voice_assistant_timer_event_response(const VoiceAssistantTimerEventResponse &msg) override;
   void on_voice_assistant_announce_request(const VoiceAssistantAnnounceRequest &msg) override;
-  void on_voice_assistant_configuration_request(const VoiceAssistantConfigurationRequest &msg) override;
-  void on_voice_assistant_set_configuration(const VoiceAssistantSetConfiguration &msg) override;
+  bool send_voice_assistant_get_configuration_response(const VoiceAssistantConfigurationRequest &msg) override;
+  void voice_assistant_set_configuration(const VoiceAssistantSetConfiguration &msg) override;
 #endif
 
 #ifdef USE_ZWAVE_PROXY
-  void on_z_wave_proxy_frame(const ZWaveProxyFrame &msg) override;
-  void on_z_wave_proxy_request(const ZWaveProxyRequest &msg) override;
+  void zwave_proxy_frame(const ZWaveProxyFrame &msg) override;
+  void zwave_proxy_request(const ZWaveProxyRequest &msg) override;
 #endif
 
 #ifdef USE_ALARM_CONTROL_PANEL
   bool send_alarm_control_panel_state(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel);
-  void on_alarm_control_panel_command_request(const AlarmControlPanelCommandRequest &msg) override;
+  void alarm_control_panel_command(const AlarmControlPanelCommandRequest &msg) override;
 #endif
 
 #ifdef USE_WATER_HEATER
   bool send_water_heater_state(water_heater::WaterHeater *water_heater);
-  void on_water_heater_command_request(const WaterHeaterCommandRequest &msg) override;
+  void water_heater_command(const WaterHeaterCommandRequest &msg) override;
 #endif
 
 #ifdef USE_IR_RF
-  void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &msg) override;
+  void infrared_rf_transmit_raw_timings(const InfraredRFTransmitRawTimingsRequest &msg) override;
   void send_infrared_rf_receive_event(const InfraredRFReceiveEvent &msg);
 #endif
 
@@ -184,11 +184,11 @@ class APIConnection final : public APIServerConnection {
 
 #ifdef USE_UPDATE
   bool send_update_state(update::UpdateEntity *update);
-  void on_update_command_request(const UpdateCommandRequest &msg) override;
+  void update_command(const UpdateCommandRequest &msg) override;
 #endif
 
-  void on_disconnect_response() override;
-  void on_ping_response() override {
+  void on_disconnect_response(const DisconnectResponse &value) override;
+  void on_ping_response(const PingResponse &value) override {
     // we initiated ping
     this->flags_.sent_ping = false;
   }
@@ -198,12 +198,12 @@ class APIConnection final : public APIServerConnection {
 #ifdef USE_HOMEASSISTANT_TIME
   void on_get_time_response(const GetTimeResponse &value) override;
 #endif
-  void on_hello_request(const HelloRequest &msg) override;
-  void on_disconnect_request() override;
-  void on_ping_request() override;
-  void on_device_info_request() override;
-  void on_list_entities_request() override { this->begin_iterator_(ActiveIterator::LIST_ENTITIES); }
-  void on_subscribe_states_request() override {
+  bool send_hello_response(const HelloRequest &msg) override;
+  bool send_disconnect_response(const DisconnectRequest &msg) override;
+  bool send_ping_response(const PingRequest &msg) override;
+  bool send_device_info_response(const DeviceInfoRequest &msg) override;
+  void list_entities(const ListEntitiesRequest &msg) override { this->begin_iterator_(ActiveIterator::LIST_ENTITIES); }
+  void subscribe_states(const SubscribeStatesRequest &msg) override {
     this->flags_.state_subscription = true;
     // Start initial state iterator only if no iterator is active
     // If list_entities is running, we'll start initial_state when it completes
@@ -211,19 +211,21 @@ class APIConnection final : public APIServerConnection {
       this->begin_iterator_(ActiveIterator::INITIAL_STATE);
     }
   }
-  void on_subscribe_logs_request(const SubscribeLogsRequest &msg) override {
+  void subscribe_logs(const SubscribeLogsRequest &msg) override {
     this->flags_.log_subscription = msg.level;
     if (msg.dump_config)
       App.schedule_dump_config();
   }
 #ifdef USE_API_HOMEASSISTANT_SERVICES
-  void on_subscribe_homeassistant_services_request() override { this->flags_.service_call_subscription = true; }
+  void subscribe_homeassistant_services(const SubscribeHomeassistantServicesRequest &msg) override {
+    this->flags_.service_call_subscription = true;
+  }
 #endif
 #ifdef USE_API_HOMEASSISTANT_STATES
-  void on_subscribe_home_assistant_states_request() override;
+  void subscribe_home_assistant_states(const SubscribeHomeAssistantStatesRequest &msg) override;
 #endif
 #ifdef USE_API_USER_DEFINED_ACTIONS
-  void on_execute_service_request(const ExecuteServiceRequest &msg) override;
+  void execute_service(const ExecuteServiceRequest &msg) override;
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
   void send_execute_service_response(uint32_t call_id, bool success, StringRef error_message);
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
@@ -233,7 +235,7 @@ class APIConnection final : public APIServerConnection {
 #endif  // USE_API_USER_DEFINED_ACTION_RESPONSES
 #endif
 #ifdef USE_API_NOISE
-  void on_noise_encryption_set_key_request(const NoiseEncryptionSetKeyRequest &msg) override;
+  bool send_noise_encryption_set_key_response(const NoiseEncryptionSetKeyRequest &msg) override;
 #endif
 
   bool is_authenticated() override {
@@ -253,7 +255,17 @@ class APIConnection final : public APIServerConnection {
 
   void on_fatal_error() override;
   void on_no_setup_connection() override;
-  bool send_message_impl(const ProtoMessage &msg, uint8_t message_type) override;
+  ProtoWriteBuffer create_buffer(uint32_t reserve_size) override {
+    // FIXME: ensure no recursive writes can happen
+
+    // Get header padding size - used for both reserve and insert
+    uint8_t header_padding = this->helper_->frame_header_padding();
+    // Get shared buffer from parent server
+    std::vector<uint8_t> &shared_buf = this->parent_->get_shared_buffer_ref();
+    this->prepare_first_message_buffer(shared_buf, header_padding,
+                                       reserve_size + header_padding + this->helper_->frame_footer_size());
+    return {&shared_buf};
+  }
 
   void prepare_first_message_buffer(std::vector<uint8_t> &shared_buf, size_t header_padding, size_t total_size) {
     shared_buf.clear();
@@ -265,13 +277,6 @@ class APIConnection final : public APIServerConnection {
     shared_buf.resize(header_padding);
   }
 
-  // Convenience overload - computes frame overhead internally
-  void prepare_first_message_buffer(std::vector<uint8_t> &shared_buf, size_t payload_size) {
-    const uint8_t header_padding = this->helper_->frame_header_padding();
-    const uint8_t footer_size = this->helper_->frame_footer_size();
-    this->prepare_first_message_buffer(shared_buf, header_padding, payload_size + header_padding + footer_size);
-  }
-
   bool try_to_clear_buffer(bool log_out_of_space);
   bool send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) override;
 
@@ -283,21 +288,6 @@ class APIConnection final : public APIServerConnection {
   // Helper function to handle authentication completion
   void complete_authentication_();
 
-  // Pattern B helpers: send response and return success/failure
-  bool send_hello_response_(const HelloRequest &msg);
-  bool send_disconnect_response_();
-  bool send_ping_response_();
-  bool send_device_info_response_();
-#ifdef USE_API_NOISE
-  bool send_noise_encryption_set_key_response_(const NoiseEncryptionSetKeyRequest &msg);
-#endif
-#ifdef USE_BLUETOOTH_PROXY
-  bool send_subscribe_bluetooth_connections_free_response_();
-#endif
-#ifdef USE_VOICE_ASSISTANT
-  bool send_voice_assistant_get_configuration_response_(const VoiceAssistantConfigurationRequest &msg);
-#endif
-
 #ifdef USE_CAMERA
   void try_send_camera_image_();
 #endif
@@ -308,21 +298,21 @@ class APIConnection final : public APIServerConnection {
 
   // Non-template helper to encode any ProtoMessage
   static uint16_t encode_message_to_buffer(ProtoMessage &msg, uint8_t message_type, APIConnection *conn,
-                                           uint32_t remaining_size);
+                                           uint32_t remaining_size, bool is_single);
 
   // Helper to fill entity state base and encode message
   static uint16_t fill_and_encode_entity_state(EntityBase *entity, StateResponseProtoMessage &msg, uint8_t message_type,
-                                               APIConnection *conn, uint32_t remaining_size) {
+                                               APIConnection *conn, uint32_t remaining_size, bool is_single) {
     msg.key = entity->get_object_id_hash();
 #ifdef USE_DEVICES
     msg.device_id = entity->get_device_id();
 #endif
-    return encode_message_to_buffer(msg, message_type, conn, remaining_size);
+    return encode_message_to_buffer(msg, message_type, conn, remaining_size, is_single);
   }
 
   // Helper to fill entity info base and encode message
   static uint16_t fill_and_encode_entity_info(EntityBase *entity, InfoResponseProtoMessage &msg, uint8_t message_type,
-                                              APIConnection *conn, uint32_t remaining_size) {
+                                              APIConnection *conn, uint32_t remaining_size, bool is_single) {
     // Set common fields that are shared by all entity types
     msg.key = entity->get_object_id_hash();
 
@@ -349,7 +339,7 @@ class APIConnection final : public APIServerConnection {
 #ifdef USE_DEVICES
     msg.device_id = entity->get_device_id();
 #endif
-    return encode_message_to_buffer(msg, message_type, conn, remaining_size);
+    return encode_message_to_buffer(msg, message_type, conn, remaining_size, is_single);
   }
 
 #ifdef USE_VOICE_ASSISTANT
@@ -380,108 +370,141 @@ class APIConnection final : public APIServerConnection {
   }
 
 #ifdef USE_BINARY_SENSOR
-  static uint16_t try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_binary_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                               bool is_single);
+  static uint16_t try_send_binary_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                              bool is_single);
 #endif
 #ifdef USE_COVER
-  static uint16_t try_send_cover_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_cover_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_cover_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
+  static uint16_t try_send_cover_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
 #ifdef USE_FAN
-  static uint16_t try_send_fan_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_fan_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_fan_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_fan_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
 #ifdef USE_LIGHT
-  static uint16_t try_send_light_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_light_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_light_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
+  static uint16_t try_send_light_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
 #ifdef USE_SENSOR
-  static uint16_t try_send_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                        bool is_single);
+  static uint16_t try_send_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
 #endif
 #ifdef USE_SWITCH
-  static uint16_t try_send_switch_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_switch_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_switch_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                        bool is_single);
+  static uint16_t try_send_switch_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
 #endif
 #ifdef USE_TEXT_SENSOR
-  static uint16_t try_send_text_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_text_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_text_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                             bool is_single);
+  static uint16_t try_send_text_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                            bool is_single);
 #endif
 #ifdef USE_CLIMATE
-  static uint16_t try_send_climate_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_climate_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_climate_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                         bool is_single);
+  static uint16_t try_send_climate_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                        bool is_single);
 #endif
 #ifdef USE_NUMBER
-  static uint16_t try_send_number_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_number_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_number_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                        bool is_single);
+  static uint16_t try_send_number_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
 #endif
 #ifdef USE_DATETIME_DATE
-  static uint16_t try_send_date_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_date_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_date_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_date_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
 #ifdef USE_DATETIME_TIME
-  static uint16_t try_send_time_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_time_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_time_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_time_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
 #ifdef USE_DATETIME_DATETIME
-  static uint16_t try_send_datetime_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_datetime_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_datetime_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                          bool is_single);
+  static uint16_t try_send_datetime_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                         bool is_single);
 #endif
 #ifdef USE_TEXT
-  static uint16_t try_send_text_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_text_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_text_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_text_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
 #ifdef USE_SELECT
-  static uint16_t try_send_select_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_select_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_select_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                        bool is_single);
+  static uint16_t try_send_select_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
 #endif
 #ifdef USE_BUTTON
-  static uint16_t try_send_button_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_button_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
 #endif
 #ifdef USE_LOCK
-  static uint16_t try_send_lock_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_lock_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_lock_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_lock_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
 #ifdef USE_VALVE
-  static uint16_t try_send_valve_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_valve_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_valve_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
+  static uint16_t try_send_valve_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
 #ifdef USE_MEDIA_PLAYER
-  static uint16_t try_send_media_player_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_media_player_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_media_player_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                              bool is_single);
+  static uint16_t try_send_media_player_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                             bool is_single);
 #endif
 #ifdef USE_ALARM_CONTROL_PANEL
-  static uint16_t try_send_alarm_control_panel_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_alarm_control_panel_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_alarm_control_panel_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                                     bool is_single);
+  static uint16_t try_send_alarm_control_panel_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                                    bool is_single);
 #endif
 #ifdef USE_WATER_HEATER
-  static uint16_t try_send_water_heater_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_water_heater_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_water_heater_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                              bool is_single);
+  static uint16_t try_send_water_heater_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                             bool is_single);
 #endif
 #ifdef USE_INFRARED
-  static uint16_t try_send_infrared_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_infrared_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                         bool is_single);
 #endif
 #ifdef USE_EVENT
   static uint16_t try_send_event_response(event::Event *event, StringRef event_type, APIConnection *conn,
-                                          uint32_t remaining_size);
-  static uint16_t try_send_event_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+                                          uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_event_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
 #ifdef USE_UPDATE
-  static uint16_t try_send_update_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-  static uint16_t try_send_update_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_update_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                        bool is_single);
+  static uint16_t try_send_update_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
 #endif
 #ifdef USE_CAMERA
-  static uint16_t try_send_camera_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_camera_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
 #endif
 
   // Method for ListEntitiesDone batching
-  static uint16_t try_send_list_info_done(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_list_info_done(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                          bool is_single);
 
   // Method for DisconnectRequest batching
-  static uint16_t try_send_disconnect_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_disconnect_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                              bool is_single);
 
   // Batch message method for ping requests
-  static uint16_t try_send_ping_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_ping_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                        bool is_single);
 
   // === Optimal member ordering for 32-bit systems ===
 
@@ -516,7 +539,7 @@ class APIConnection final : public APIServerConnection {
 #endif
 
   // Function pointer type for message encoding
-  using MessageCreatorPtr = uint16_t (*)(EntityBase *, APIConnection *, uint32_t remaining_size);
+  using MessageCreatorPtr = uint16_t (*)(EntityBase *, APIConnection *, uint32_t remaining_size, bool is_single);
 
   // Generic batching mechanism for both state updates and entity info
   struct DeferredBatch {
@@ -629,7 +652,7 @@ class APIConnection final : public APIServerConnection {
 
   // Dispatch message encoding based on message_type - replaces function pointer storage
   // Switch assigns pointer, single call site for smaller code size
-  uint16_t dispatch_message_(const DeferredBatch::BatchItem &item, uint32_t remaining_size, bool batch_first);
+  uint16_t dispatch_message_(const DeferredBatch::BatchItem &item, uint32_t remaining_size, bool is_single);
 
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void log_batch_item_(const DeferredBatch::BatchItem &item) {
@@ -661,7 +684,19 @@ class APIConnection final : public APIServerConnection {
   // Tries immediate send if should_send_immediately_() returns true and buffer has space
   // Falls back to batching if immediate send fails or isn't applicable
   bool send_message_smart_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
-                           uint8_t aux_data_index = DeferredBatch::AUX_DATA_UNUSED);
+                           uint8_t aux_data_index = DeferredBatch::AUX_DATA_UNUSED) {
+    if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
+      DeferredBatch::BatchItem item{entity, message_type, estimated_size, aux_data_index};
+      if (this->dispatch_message_(item, MAX_BATCH_PACKET_SIZE, true) &&
+          this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+        this->log_batch_item_(item);
+#endif
+        return true;
+      }
+    }
+    return this->schedule_message_(entity, message_type, estimated_size, aux_data_index);
+  }
 
   // Helper function to schedule a deferred message with known message type
   bool schedule_message_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,

esphome/components/api/api_pb2_dump.cpp

@@ -23,8 +23,15 @@ static inline void append_field_prefix(DumpBuffer &out, const char *field_name,
   out.append(indent, ' ').append(field_name).append(": ");
 }
 
+static inline void append_with_newline(DumpBuffer &out, const char *str) {
+  out.append(str);
+  out.append("\n");
+}
+
 static inline void append_uint(DumpBuffer &out, uint32_t value) {
-  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%" PRIu32, value));
+  char buf[16];
+  snprintf(buf, sizeof(buf), "%" PRIu32, value);
+  out.append(buf);
 }
 
 // RAII helper for message dump formatting
@@ -42,23 +49,31 @@ class MessageDumpHelper {
 
 // Helper functions to reduce code duplication in dump methods
 static void dump_field(DumpBuffer &out, const char *field_name, int32_t value, int indent = 2) {
+  char buffer[64];
   append_field_prefix(out, field_name, indent);
-  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%" PRId32 "\n", value));
+  snprintf(buffer, 64, "%" PRId32, value);
+  append_with_newline(out, buffer);
 }
 
 static void dump_field(DumpBuffer &out, const char *field_name, uint32_t value, int indent = 2) {
+  char buffer[64];
   append_field_prefix(out, field_name, indent);
-  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%" PRIu32 "\n", value));
+  snprintf(buffer, 64, "%" PRIu32, value);
+  append_with_newline(out, buffer);
 }
 
 static void dump_field(DumpBuffer &out, const char *field_name, float value, int indent = 2) {
+  char buffer[64];
   append_field_prefix(out, field_name, indent);
-  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%g\n", value));
+  snprintf(buffer, 64, "%g", value);
+  append_with_newline(out, buffer);
 }
 
 static void dump_field(DumpBuffer &out, const char *field_name, uint64_t value, int indent = 2) {
+  char buffer[64];
   append_field_prefix(out, field_name, indent);
-  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%" PRIu64 "\n", value));
+  snprintf(buffer, 64, "%" PRIu64, value);
+  append_with_newline(out, buffer);
 }
 
 static void dump_field(DumpBuffer &out, const char *field_name, bool value, int indent = 2) {
@@ -97,7 +112,7 @@ static void dump_bytes_field(DumpBuffer &out, const char *field_name, const uint
   char hex_buf[format_hex_pretty_size(160)];
   append_field_prefix(out, field_name, indent);
   format_hex_pretty_to(hex_buf, data, len);
-  out.append(hex_buf).append("\n");
+  append_with_newline(out, hex_buf);
 }
 
 template<> const char *proto_enum_to_string<enums::EntityCategory>(enums::EntityCategory value) {

esphome/components/api/api_pb2_service.cpp

@@ -15,9 +15,6 @@ void APIServerConnectionBase::log_receive_message_(const LogString *name, const
   DumpBuffer dump_buf;
   ESP_LOGVV(TAG, "%s: %s", LOG_STR_ARG(name), msg.dump_to(dump_buf));
 }
-void APIServerConnectionBase::log_receive_message_(const LogString *name) {
-  ESP_LOGVV(TAG, "%s: {}", LOG_STR_ARG(name));
-}
 #endif
 
 void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) {
@@ -32,52 +29,66 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       break;
     }
     case DisconnectRequest::MESSAGE_TYPE: {
+      DisconnectRequest msg;
+      // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_disconnect_request"));
+      this->log_receive_message_(LOG_STR("on_disconnect_request"), msg);
 #endif
-      this->on_disconnect_request();
+      this->on_disconnect_request(msg);
       break;
     }
     case DisconnectResponse::MESSAGE_TYPE: {
+      DisconnectResponse msg;
+      // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_disconnect_response"));
+      this->log_receive_message_(LOG_STR("on_disconnect_response"), msg);
 #endif
-      this->on_disconnect_response();
+      this->on_disconnect_response(msg);
       break;
     }
     case PingRequest::MESSAGE_TYPE: {
+      PingRequest msg;
+      // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_ping_request"));
+      this->log_receive_message_(LOG_STR("on_ping_request"), msg);
 #endif
-      this->on_ping_request();
+      this->on_ping_request(msg);
       break;
     }
     case PingResponse::MESSAGE_TYPE: {
+      PingResponse msg;
+      // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_ping_response"));
+      this->log_receive_message_(LOG_STR("on_ping_response"), msg);
 #endif
-      this->on_ping_response();
+      this->on_ping_response(msg);
       break;
     }
     case DeviceInfoRequest::MESSAGE_TYPE: {
+      DeviceInfoRequest msg;
+      // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_device_info_request"));
+      this->log_receive_message_(LOG_STR("on_device_info_request"), msg);
 #endif
-      this->on_device_info_request();
+      this->on_device_info_request(msg);
       break;
     }
     case ListEntitiesRequest::MESSAGE_TYPE: {
+      ListEntitiesRequest msg;
+      // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_list_entities_request"));
+      this->log_receive_message_(LOG_STR("on_list_entities_request"), msg);
 #endif
-      this->on_list_entities_request();
+      this->on_list_entities_request(msg);
       break;
     }
     case SubscribeStatesRequest::MESSAGE_TYPE: {
+      SubscribeStatesRequest msg;
+      // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_states_request"));
+      this->log_receive_message_(LOG_STR("on_subscribe_states_request"), msg);
 #endif
-      this->on_subscribe_states_request();
+      this->on_subscribe_states_request(msg);
       break;
     }
     case SubscribeLogsRequest::MESSAGE_TYPE: {
@@ -135,10 +146,12 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
 #endif
 #ifdef USE_API_HOMEASSISTANT_SERVICES
     case SubscribeHomeassistantServicesRequest::MESSAGE_TYPE: {
+      SubscribeHomeassistantServicesRequest msg;
+      // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_homeassistant_services_request"));
+      this->log_receive_message_(LOG_STR("on_subscribe_homeassistant_services_request"), msg);
 #endif
-      this->on_subscribe_homeassistant_services_request();
+      this->on_subscribe_homeassistant_services_request(msg);
       break;
     }
 #endif
@@ -153,10 +166,12 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
     }
 #ifdef USE_API_HOMEASSISTANT_STATES
     case SubscribeHomeAssistantStatesRequest::MESSAGE_TYPE: {
+      SubscribeHomeAssistantStatesRequest msg;
+      // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_home_assistant_states_request"));
+      this->log_receive_message_(LOG_STR("on_subscribe_home_assistant_states_request"), msg);
 #endif
-      this->on_subscribe_home_assistant_states_request();
+      this->on_subscribe_home_assistant_states_request(msg);
       break;
     }
 #endif
@@ -360,19 +375,23 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
 #endif
 #ifdef USE_BLUETOOTH_PROXY
     case SubscribeBluetoothConnectionsFreeRequest::MESSAGE_TYPE: {
+      SubscribeBluetoothConnectionsFreeRequest msg;
+      // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_bluetooth_connections_free_request"));
+      this->log_receive_message_(LOG_STR("on_subscribe_bluetooth_connections_free_request"), msg);
 #endif
-      this->on_subscribe_bluetooth_connections_free_request();
+      this->on_subscribe_bluetooth_connections_free_request(msg);
       break;
     }
 #endif
 #ifdef USE_BLUETOOTH_PROXY
     case UnsubscribeBluetoothLEAdvertisementsRequest::MESSAGE_TYPE: {
+      UnsubscribeBluetoothLEAdvertisementsRequest msg;
+      // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_unsubscribe_bluetooth_le_advertisements_request"));
+      this->log_receive_message_(LOG_STR("on_unsubscribe_bluetooth_le_advertisements_request"), msg);
 #endif
-      this->on_unsubscribe_bluetooth_le_advertisements_request();
+      this->on_unsubscribe_bluetooth_le_advertisements_request(msg);
       break;
     }
 #endif
@@ -623,6 +642,209 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
   }
 }
 
+void APIServerConnection::on_hello_request(const HelloRequest &msg) {
+  if (!this->send_hello_response(msg)) {
+    this->on_fatal_error();
+  }
+}
+void APIServerConnection::on_disconnect_request(const DisconnectRequest &msg) {
+  if (!this->send_disconnect_response(msg)) {
+    this->on_fatal_error();
+  }
+}
+void APIServerConnection::on_ping_request(const PingRequest &msg) {
+  if (!this->send_ping_response(msg)) {
+    this->on_fatal_error();
+  }
+}
+void APIServerConnection::on_device_info_request(const DeviceInfoRequest &msg) {
+  if (!this->send_device_info_response(msg)) {
+    this->on_fatal_error();
+  }
+}
+void APIServerConnection::on_list_entities_request(const ListEntitiesRequest &msg) { this->list_entities(msg); }
+void APIServerConnection::on_subscribe_states_request(const SubscribeStatesRequest &msg) {
+  this->subscribe_states(msg);
+}
+void APIServerConnection::on_subscribe_logs_request(const SubscribeLogsRequest &msg) { this->subscribe_logs(msg); }
+#ifdef USE_API_HOMEASSISTANT_SERVICES
+void APIServerConnection::on_subscribe_homeassistant_services_request(
+    const SubscribeHomeassistantServicesRequest &msg) {
+  this->subscribe_homeassistant_services(msg);
+}
+#endif
+#ifdef USE_API_HOMEASSISTANT_STATES
+void APIServerConnection::on_subscribe_home_assistant_states_request(const SubscribeHomeAssistantStatesRequest &msg) {
+  this->subscribe_home_assistant_states(msg);
+}
+#endif
+#ifdef USE_API_USER_DEFINED_ACTIONS
+void APIServerConnection::on_execute_service_request(const ExecuteServiceRequest &msg) { this->execute_service(msg); }
+#endif
+#ifdef USE_API_NOISE
+void APIServerConnection::on_noise_encryption_set_key_request(const NoiseEncryptionSetKeyRequest &msg) {
+  if (!this->send_noise_encryption_set_key_response(msg)) {
+    this->on_fatal_error();
+  }
+}
+#endif
+#ifdef USE_BUTTON
+void APIServerConnection::on_button_command_request(const ButtonCommandRequest &msg) { this->button_command(msg); }
+#endif
+#ifdef USE_CAMERA
+void APIServerConnection::on_camera_image_request(const CameraImageRequest &msg) { this->camera_image(msg); }
+#endif
+#ifdef USE_CLIMATE
+void APIServerConnection::on_climate_command_request(const ClimateCommandRequest &msg) { this->climate_command(msg); }
+#endif
+#ifdef USE_COVER
+void APIServerConnection::on_cover_command_request(const CoverCommandRequest &msg) { this->cover_command(msg); }
+#endif
+#ifdef USE_DATETIME_DATE
+void APIServerConnection::on_date_command_request(const DateCommandRequest &msg) { this->date_command(msg); }
+#endif
+#ifdef USE_DATETIME_DATETIME
+void APIServerConnection::on_date_time_command_request(const DateTimeCommandRequest &msg) {
+  this->datetime_command(msg);
+}
+#endif
+#ifdef USE_FAN
+void APIServerConnection::on_fan_command_request(const FanCommandRequest &msg) { this->fan_command(msg); }
+#endif
+#ifdef USE_LIGHT
+void APIServerConnection::on_light_command_request(const LightCommandRequest &msg) { this->light_command(msg); }
+#endif
+#ifdef USE_LOCK
+void APIServerConnection::on_lock_command_request(const LockCommandRequest &msg) { this->lock_command(msg); }
+#endif
+#ifdef USE_MEDIA_PLAYER
+void APIServerConnection::on_media_player_command_request(const MediaPlayerCommandRequest &msg) {
+  this->media_player_command(msg);
+}
+#endif
+#ifdef USE_NUMBER
+void APIServerConnection::on_number_command_request(const NumberCommandRequest &msg) { this->number_command(msg); }
+#endif
+#ifdef USE_SELECT
+void APIServerConnection::on_select_command_request(const SelectCommandRequest &msg) { this->select_command(msg); }
+#endif
+#ifdef USE_SIREN
+void APIServerConnection::on_siren_command_request(const SirenCommandRequest &msg) { this->siren_command(msg); }
+#endif
+#ifdef USE_SWITCH
+void APIServerConnection::on_switch_command_request(const SwitchCommandRequest &msg) { this->switch_command(msg); }
+#endif
+#ifdef USE_TEXT
+void APIServerConnection::on_text_command_request(const TextCommandRequest &msg) { this->text_command(msg); }
+#endif
+#ifdef USE_DATETIME_TIME
+void APIServerConnection::on_time_command_request(const TimeCommandRequest &msg) { this->time_command(msg); }
+#endif
+#ifdef USE_UPDATE
+void APIServerConnection::on_update_command_request(const UpdateCommandRequest &msg) { this->update_command(msg); }
+#endif
+#ifdef USE_VALVE
+void APIServerConnection::on_valve_command_request(const ValveCommandRequest &msg) { this->valve_command(msg); }
+#endif
+#ifdef USE_WATER_HEATER
+void APIServerConnection::on_water_heater_command_request(const WaterHeaterCommandRequest &msg) {
+  this->water_heater_command(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_subscribe_bluetooth_le_advertisements_request(
+    const SubscribeBluetoothLEAdvertisementsRequest &msg) {
+  this->subscribe_bluetooth_le_advertisements(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_device_request(const BluetoothDeviceRequest &msg) {
+  this->bluetooth_device_request(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_gatt_get_services_request(const BluetoothGATTGetServicesRequest &msg) {
+  this->bluetooth_gatt_get_services(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_gatt_read_request(const BluetoothGATTReadRequest &msg) {
+  this->bluetooth_gatt_read(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_gatt_write_request(const BluetoothGATTWriteRequest &msg) {
+  this->bluetooth_gatt_write(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_gatt_read_descriptor_request(const BluetoothGATTReadDescriptorRequest &msg) {
+  this->bluetooth_gatt_read_descriptor(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_gatt_write_descriptor_request(const BluetoothGATTWriteDescriptorRequest &msg) {
+  this->bluetooth_gatt_write_descriptor(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_gatt_notify_request(const BluetoothGATTNotifyRequest &msg) {
+  this->bluetooth_gatt_notify(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_subscribe_bluetooth_connections_free_request(
+    const SubscribeBluetoothConnectionsFreeRequest &msg) {
+  if (!this->send_subscribe_bluetooth_connections_free_response(msg)) {
+    this->on_fatal_error();
+  }
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_unsubscribe_bluetooth_le_advertisements_request(
+    const UnsubscribeBluetoothLEAdvertisementsRequest &msg) {
+  this->unsubscribe_bluetooth_le_advertisements(msg);
+}
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+void APIServerConnection::on_bluetooth_scanner_set_mode_request(const BluetoothScannerSetModeRequest &msg) {
+  this->bluetooth_scanner_set_mode(msg);
+}
+#endif
+#ifdef USE_VOICE_ASSISTANT
+void APIServerConnection::on_subscribe_voice_assistant_request(const SubscribeVoiceAssistantRequest &msg) {
+  this->subscribe_voice_assistant(msg);
+}
+#endif
+#ifdef USE_VOICE_ASSISTANT
+void APIServerConnection::on_voice_assistant_configuration_request(const VoiceAssistantConfigurationRequest &msg) {
+  if (!this->send_voice_assistant_get_configuration_response(msg)) {
+    this->on_fatal_error();
+  }
+}
+#endif
+#ifdef USE_VOICE_ASSISTANT
+void APIServerConnection::on_voice_assistant_set_configuration(const VoiceAssistantSetConfiguration &msg) {
+  this->voice_assistant_set_configuration(msg);
+}
+#endif
+#ifdef USE_ALARM_CONTROL_PANEL
+void APIServerConnection::on_alarm_control_panel_command_request(const AlarmControlPanelCommandRequest &msg) {
+  this->alarm_control_panel_command(msg);
+}
+#endif
+#ifdef USE_ZWAVE_PROXY
+void APIServerConnection::on_z_wave_proxy_frame(const ZWaveProxyFrame &msg) { this->zwave_proxy_frame(msg); }
+#endif
+#ifdef USE_ZWAVE_PROXY
+void APIServerConnection::on_z_wave_proxy_request(const ZWaveProxyRequest &msg) { this->zwave_proxy_request(msg); }
+#endif
+#ifdef USE_IR_RF
+void APIServerConnection::on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &msg) {
+  this->infrared_rf_transmit_raw_timings(msg);
+}
+#endif
+
 void APIServerConnection::read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) {
   // Check authentication/connection requirements for messages
   switch (msg_type) {

esphome/components/api/api_pb2_service.h

@@ -14,7 +14,6 @@ class APIServerConnectionBase : public ProtoService {
  protected:
   void log_send_message_(const char *name, const char *dump);
   void log_receive_message_(const LogString *name, const ProtoMessage &msg);
-  void log_receive_message_(const LogString *name);
 
  public:
 #endif
@@ -24,20 +23,20 @@ class APIServerConnectionBase : public ProtoService {
     DumpBuffer dump_buf;
     this->log_send_message_(msg.message_name(), msg.dump_to(dump_buf));
 #endif
-    return this->send_message_impl(msg, message_type);
+    return this->send_message_(msg, message_type);
   }
 
   virtual void on_hello_request(const HelloRequest &value){};
 
-  virtual void on_disconnect_request(){};
-  virtual void on_disconnect_response(){};
-  virtual void on_ping_request(){};
-  virtual void on_ping_response(){};
-  virtual void on_device_info_request(){};
+  virtual void on_disconnect_request(const DisconnectRequest &value){};
+  virtual void on_disconnect_response(const DisconnectResponse &value){};
+  virtual void on_ping_request(const PingRequest &value){};
+  virtual void on_ping_response(const PingResponse &value){};
+  virtual void on_device_info_request(const DeviceInfoRequest &value){};
 
-  virtual void on_list_entities_request(){};
+  virtual void on_list_entities_request(const ListEntitiesRequest &value){};
 
-  virtual void on_subscribe_states_request(){};
+  virtual void on_subscribe_states_request(const SubscribeStatesRequest &value){};
 
 #ifdef USE_COVER
   virtual void on_cover_command_request(const CoverCommandRequest &value){};
@@ -62,14 +61,14 @@ class APIServerConnectionBase : public ProtoService {
 #endif
 
 #ifdef USE_API_HOMEASSISTANT_SERVICES
-  virtual void on_subscribe_homeassistant_services_request(){};
+  virtual void on_subscribe_homeassistant_services_request(const SubscribeHomeassistantServicesRequest &value){};
 #endif
 
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
   virtual void on_homeassistant_action_response(const HomeassistantActionResponse &value){};
 #endif
 #ifdef USE_API_HOMEASSISTANT_STATES
-  virtual void on_subscribe_home_assistant_states_request(){};
+  virtual void on_subscribe_home_assistant_states_request(const SubscribeHomeAssistantStatesRequest &value){};
 #endif
 
 #ifdef USE_API_HOMEASSISTANT_STATES
@@ -148,11 +147,12 @@ class APIServerConnectionBase : public ProtoService {
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY
-  virtual void on_subscribe_bluetooth_connections_free_request(){};
+  virtual void on_subscribe_bluetooth_connections_free_request(const SubscribeBluetoothConnectionsFreeRequest &value){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY
-  virtual void on_unsubscribe_bluetooth_le_advertisements_request(){};
+  virtual void on_unsubscribe_bluetooth_le_advertisements_request(
+      const UnsubscribeBluetoothLEAdvertisementsRequest &value){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY
@@ -229,7 +229,270 @@ class APIServerConnectionBase : public ProtoService {
 };
 
 class APIServerConnection : public APIServerConnectionBase {
+ public:
+  virtual bool send_hello_response(const HelloRequest &msg) = 0;
+  virtual bool send_disconnect_response(const DisconnectRequest &msg) = 0;
+  virtual bool send_ping_response(const PingRequest &msg) = 0;
+  virtual bool send_device_info_response(const DeviceInfoRequest &msg) = 0;
+  virtual void list_entities(const ListEntitiesRequest &msg) = 0;
+  virtual void subscribe_states(const SubscribeStatesRequest &msg) = 0;
+  virtual void subscribe_logs(const SubscribeLogsRequest &msg) = 0;
+#ifdef USE_API_HOMEASSISTANT_SERVICES
+  virtual void subscribe_homeassistant_services(const SubscribeHomeassistantServicesRequest &msg) = 0;
+#endif
+#ifdef USE_API_HOMEASSISTANT_STATES
+  virtual void subscribe_home_assistant_states(const SubscribeHomeAssistantStatesRequest &msg) = 0;
+#endif
+#ifdef USE_API_USER_DEFINED_ACTIONS
+  virtual void execute_service(const ExecuteServiceRequest &msg) = 0;
+#endif
+#ifdef USE_API_NOISE
+  virtual bool send_noise_encryption_set_key_response(const NoiseEncryptionSetKeyRequest &msg) = 0;
+#endif
+#ifdef USE_BUTTON
+  virtual void button_command(const ButtonCommandRequest &msg) = 0;
+#endif
+#ifdef USE_CAMERA
+  virtual void camera_image(const CameraImageRequest &msg) = 0;
+#endif
+#ifdef USE_CLIMATE
+  virtual void climate_command(const ClimateCommandRequest &msg) = 0;
+#endif
+#ifdef USE_COVER
+  virtual void cover_command(const CoverCommandRequest &msg) = 0;
+#endif
+#ifdef USE_DATETIME_DATE
+  virtual void date_command(const DateCommandRequest &msg) = 0;
+#endif
+#ifdef USE_DATETIME_DATETIME
+  virtual void datetime_command(const DateTimeCommandRequest &msg) = 0;
+#endif
+#ifdef USE_FAN
+  virtual void fan_command(const FanCommandRequest &msg) = 0;
+#endif
+#ifdef USE_LIGHT
+  virtual void light_command(const LightCommandRequest &msg) = 0;
+#endif
+#ifdef USE_LOCK
+  virtual void lock_command(const LockCommandRequest &msg) = 0;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  virtual void media_player_command(const MediaPlayerCommandRequest &msg) = 0;
+#endif
+#ifdef USE_NUMBER
+  virtual void number_command(const NumberCommandRequest &msg) = 0;
+#endif
+#ifdef USE_SELECT
+  virtual void select_command(const SelectCommandRequest &msg) = 0;
+#endif
+#ifdef USE_SIREN
+  virtual void siren_command(const SirenCommandRequest &msg) = 0;
+#endif
+#ifdef USE_SWITCH
+  virtual void switch_command(const SwitchCommandRequest &msg) = 0;
+#endif
+#ifdef USE_TEXT
+  virtual void text_command(const TextCommandRequest &msg) = 0;
+#endif
+#ifdef USE_DATETIME_TIME
+  virtual void time_command(const TimeCommandRequest &msg) = 0;
+#endif
+#ifdef USE_UPDATE
+  virtual void update_command(const UpdateCommandRequest &msg) = 0;
+#endif
+#ifdef USE_VALVE
+  virtual void valve_command(const ValveCommandRequest &msg) = 0;
+#endif
+#ifdef USE_WATER_HEATER
+  virtual void water_heater_command(const WaterHeaterCommandRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void subscribe_bluetooth_le_advertisements(const SubscribeBluetoothLEAdvertisementsRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_device_request(const BluetoothDeviceRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_gatt_get_services(const BluetoothGATTGetServicesRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_gatt_read(const BluetoothGATTReadRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_gatt_write(const BluetoothGATTWriteRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_gatt_read_descriptor(const BluetoothGATTReadDescriptorRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_gatt_write_descriptor(const BluetoothGATTWriteDescriptorRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_gatt_notify(const BluetoothGATTNotifyRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual bool send_subscribe_bluetooth_connections_free_response(
+      const SubscribeBluetoothConnectionsFreeRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void unsubscribe_bluetooth_le_advertisements(const UnsubscribeBluetoothLEAdvertisementsRequest &msg) = 0;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  virtual void bluetooth_scanner_set_mode(const BluetoothScannerSetModeRequest &msg) = 0;
+#endif
+#ifdef USE_VOICE_ASSISTANT
+  virtual void subscribe_voice_assistant(const SubscribeVoiceAssistantRequest &msg) = 0;
+#endif
+#ifdef USE_VOICE_ASSISTANT
+  virtual bool send_voice_assistant_get_configuration_response(const VoiceAssistantConfigurationRequest &msg) = 0;
+#endif
+#ifdef USE_VOICE_ASSISTANT
+  virtual void voice_assistant_set_configuration(const VoiceAssistantSetConfiguration &msg) = 0;
+#endif
+#ifdef USE_ALARM_CONTROL_PANEL
+  virtual void alarm_control_panel_command(const AlarmControlPanelCommandRequest &msg) = 0;
+#endif
+#ifdef USE_ZWAVE_PROXY
+  virtual void zwave_proxy_frame(const ZWaveProxyFrame &msg) = 0;
+#endif
+#ifdef USE_ZWAVE_PROXY
+  virtual void zwave_proxy_request(const ZWaveProxyRequest &msg) = 0;
+#endif
+#ifdef USE_IR_RF
+  virtual void infrared_rf_transmit_raw_timings(const InfraredRFTransmitRawTimingsRequest &msg) = 0;
+#endif
  protected:
+  void on_hello_request(const HelloRequest &msg) override;
+  void on_disconnect_request(const DisconnectRequest &msg) override;
+  void on_ping_request(const PingRequest &msg) override;
+  void on_device_info_request(const DeviceInfoRequest &msg) override;
+  void on_list_entities_request(const ListEntitiesRequest &msg) override;
+  void on_subscribe_states_request(const SubscribeStatesRequest &msg) override;
+  void on_subscribe_logs_request(const SubscribeLogsRequest &msg) override;
+#ifdef USE_API_HOMEASSISTANT_SERVICES
+  void on_subscribe_homeassistant_services_request(const SubscribeHomeassistantServicesRequest &msg) override;
+#endif
+#ifdef USE_API_HOMEASSISTANT_STATES
+  void on_subscribe_home_assistant_states_request(const SubscribeHomeAssistantStatesRequest &msg) override;
+#endif
+#ifdef USE_API_USER_DEFINED_ACTIONS
+  void on_execute_service_request(const ExecuteServiceRequest &msg) override;
+#endif
+#ifdef USE_API_NOISE
+  void on_noise_encryption_set_key_request(const NoiseEncryptionSetKeyRequest &msg) override;
+#endif
+#ifdef USE_BUTTON
+  void on_button_command_request(const ButtonCommandRequest &msg) override;
+#endif
+#ifdef USE_CAMERA
+  void on_camera_image_request(const CameraImageRequest &msg) override;
+#endif
+#ifdef USE_CLIMATE
+  void on_climate_command_request(const ClimateCommandRequest &msg) override;
+#endif
+#ifdef USE_COVER
+  void on_cover_command_request(const CoverCommandRequest &msg) override;
+#endif
+#ifdef USE_DATETIME_DATE
+  void on_date_command_request(const DateCommandRequest &msg) override;
+#endif
+#ifdef USE_DATETIME_DATETIME
+  void on_date_time_command_request(const DateTimeCommandRequest &msg) override;
+#endif
+#ifdef USE_FAN
+  void on_fan_command_request(const FanCommandRequest &msg) override;
+#endif
+#ifdef USE_LIGHT
+  void on_light_command_request(const LightCommandRequest &msg) override;
+#endif
+#ifdef USE_LOCK
+  void on_lock_command_request(const LockCommandRequest &msg) override;
+#endif
+#ifdef USE_MEDIA_PLAYER
+  void on_media_player_command_request(const MediaPlayerCommandRequest &msg) override;
+#endif
+#ifdef USE_NUMBER
+  void on_number_command_request(const NumberCommandRequest &msg) override;
+#endif
+#ifdef USE_SELECT
+  void on_select_command_request(const SelectCommandRequest &msg) override;
+#endif
+#ifdef USE_SIREN
+  void on_siren_command_request(const SirenCommandRequest &msg) override;
+#endif
+#ifdef USE_SWITCH
+  void on_switch_command_request(const SwitchCommandRequest &msg) override;
+#endif
+#ifdef USE_TEXT
+  void on_text_command_request(const TextCommandRequest &msg) override;
+#endif
+#ifdef USE_DATETIME_TIME
+  void on_time_command_request(const TimeCommandRequest &msg) override;
+#endif
+#ifdef USE_UPDATE
+  void on_update_command_request(const UpdateCommandRequest &msg) override;
+#endif
+#ifdef USE_VALVE
+  void on_valve_command_request(const ValveCommandRequest &msg) override;
+#endif
+#ifdef USE_WATER_HEATER
+  void on_water_heater_command_request(const WaterHeaterCommandRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_subscribe_bluetooth_le_advertisements_request(const SubscribeBluetoothLEAdvertisementsRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_device_request(const BluetoothDeviceRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_gatt_get_services_request(const BluetoothGATTGetServicesRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_gatt_read_request(const BluetoothGATTReadRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_gatt_write_request(const BluetoothGATTWriteRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_gatt_read_descriptor_request(const BluetoothGATTReadDescriptorRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_gatt_write_descriptor_request(const BluetoothGATTWriteDescriptorRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_gatt_notify_request(const BluetoothGATTNotifyRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_subscribe_bluetooth_connections_free_request(const SubscribeBluetoothConnectionsFreeRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_unsubscribe_bluetooth_le_advertisements_request(
+      const UnsubscribeBluetoothLEAdvertisementsRequest &msg) override;
+#endif
+#ifdef USE_BLUETOOTH_PROXY
+  void on_bluetooth_scanner_set_mode_request(const BluetoothScannerSetModeRequest &msg) override;
+#endif
+#ifdef USE_VOICE_ASSISTANT
+  void on_subscribe_voice_assistant_request(const SubscribeVoiceAssistantRequest &msg) override;
+#endif
+#ifdef USE_VOICE_ASSISTANT
+  void on_voice_assistant_configuration_request(const VoiceAssistantConfigurationRequest &msg) override;
+#endif
+#ifdef USE_VOICE_ASSISTANT
+  void on_voice_assistant_set_configuration(const VoiceAssistantSetConfiguration &msg) override;
+#endif
+#ifdef USE_ALARM_CONTROL_PANEL
+  void on_alarm_control_panel_command_request(const AlarmControlPanelCommandRequest &msg) override;
+#endif
+#ifdef USE_ZWAVE_PROXY
+  void on_z_wave_proxy_frame(const ZWaveProxyFrame &msg) override;
+#endif
+#ifdef USE_ZWAVE_PROXY
+  void on_z_wave_proxy_request(const ZWaveProxyRequest &msg) override;
+#endif
+#ifdef USE_IR_RF
+  void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &msg) override;
+#endif
   void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) override;
 };
 

esphome/components/api/proto.h

@@ -402,20 +402,6 @@ class DumpBuffer {
   const char *c_str() const { return buf_; }
   size_t size() const { return pos_; }
 
-  /// Get writable buffer pointer for use with buf_append_printf
-  char *data() { return buf_; }
-  /// Get current position for use with buf_append_printf
-  size_t pos() const { return pos_; }
-  /// Update position after buf_append_printf call
-  void set_pos(size_t pos) {
-    if (pos >= CAPACITY) {
-      pos_ = CAPACITY - 1;
-    } else {
-      pos_ = pos;
-    }
-    buf_[pos_] = '\0';
-  }
-
  private:
   void append_impl_(const char *str, size_t len) {
     size_t space = CAPACITY - 1 - pos_;
@@ -957,16 +943,32 @@ class ProtoService {
   virtual bool is_connection_setup() = 0;
   virtual void on_fatal_error() = 0;
   virtual void on_no_setup_connection() = 0;
+  /**
+   * Create a buffer with a reserved size.
+   * @param reserve_size The number of bytes to pre-allocate in the buffer. This is a hint
+   *                     to optimize memory usage and avoid reallocations during encoding.
+   *                     Implementations should aim to allocate at least this size.
+   * @return A ProtoWriteBuffer object with the reserved size.
+   */
+  virtual ProtoWriteBuffer create_buffer(uint32_t reserve_size) = 0;
   virtual bool send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) = 0;
   virtual void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) = 0;
-  /**
-   * Send a protobuf message by calculating its size, allocating a buffer, encoding, and sending.
-   * This is the implementation method - callers should use send_message() which adds logging.
-   * @param msg The protobuf message to send.
-   * @param message_type The message type identifier.
-   * @return True if the message was sent successfully, false otherwise.
-   */
-  virtual bool send_message_impl(const ProtoMessage &msg, uint8_t message_type) = 0;
+
+  // Optimized method that pre-allocates buffer based on message size
+  bool send_message_(const ProtoMessage &msg, uint8_t message_type) {
+    ProtoSize size;
+    msg.calculate_size(size);
+    uint32_t msg_size = size.get_size();
+
+    // Create a pre-sized buffer
+    auto buffer = this->create_buffer(msg_size);
+
+    // Encode message into the buffer
+    msg.encode(buffer);
+
+    // Send the buffer
+    return this->send_buffer(buffer, message_type);
+  }
 
   // Authentication helper methods
   inline bool check_connection_setup_() {

esphome/components/aqi/aqi_sensor.h

@@ -10,6 +10,7 @@ class AQISensor : public sensor::Sensor, public Component {
  public:
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::DATA; }
 
   void set_pm_2_5_sensor(sensor::Sensor *sensor) { this->pm_2_5_sensor_ = sensor; }
   void set_pm_10_0_sensor(sensor::Sensor *sensor) { this->pm_10_0_sensor_ = sensor; }

esphome/components/as3935/as3935.cpp

@@ -41,6 +41,8 @@ void AS3935Component::dump_config() {
 #endif
 }
 
+float AS3935Component::get_setup_priority() const { return setup_priority::DATA; }
+
 void AS3935Component::loop() {
   if (!this->irq_pin_->digital_read())
     return;

esphome/components/as3935/as3935.h

@@ -74,6 +74,7 @@ class AS3935Component : public Component {
  public:
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void loop() override;
 
   void set_irq_pin(GPIOPin *irq_pin) { irq_pin_ = irq_pin; }

esphome/components/as5600/sensor/as5600_sensor.cpp

@@ -22,6 +22,8 @@ static const uint8_t REGISTER_STATUS = 0x0B;     // 8 bytes  / R
 static const uint8_t REGISTER_AGC = 0x1A;        // 8 bytes  / R
 static const uint8_t REGISTER_MAGNITUDE = 0x1B;  // 16 bytes / R
 
+float AS5600Sensor::get_setup_priority() const { return setup_priority::DATA; }
+
 void AS5600Sensor::dump_config() {
   LOG_SENSOR("", "AS5600 Sensor", this);
   ESP_LOGCONFIG(TAG, "  Out of Range Mode: %u", this->out_of_range_mode_);

esphome/components/as5600/sensor/as5600_sensor.h

@@ -14,6 +14,7 @@ class AS5600Sensor : public PollingComponent, public Parented<AS5600Component>,
  public:
   void update() override;
   void dump_config() override;
+  float get_setup_priority() const override;
 
   void set_angle_sensor(sensor::Sensor *angle_sensor) { this->angle_sensor_ = angle_sensor; }
   void set_raw_angle_sensor(sensor::Sensor *raw_angle_sensor) { this->raw_angle_sensor_ = raw_angle_sensor; }

esphome/components/as7341/as7341.cpp

@@ -58,6 +58,8 @@ void AS7341Component::dump_config() {
   LOG_SENSOR("  ", "NIR", this->nir_);
 }
 
+float AS7341Component::get_setup_priority() const { return setup_priority::DATA; }
+
 void AS7341Component::update() {
   this->read_channels(this->channel_readings_);
 

esphome/components/as7341/as7341.h

@@ -78,6 +78,7 @@ class AS7341Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void update() override;
 
   void set_f1_sensor(sensor::Sensor *f1_sensor) { this->f1_ = f1_sensor; }

esphome/components/atm90e26/atm90e26.cpp

@@ -146,6 +146,7 @@ void ATM90E26Component::dump_config() {
   LOG_SENSOR("  ", "Active Reverse Energy A", this->reverse_active_energy_sensor_);
   LOG_SENSOR("  ", "Frequency", this->freq_sensor_);
 }
+float ATM90E26Component::get_setup_priority() const { return setup_priority::DATA; }
 
 uint16_t ATM90E26Component::read16_(uint8_t a_register) {
   uint8_t data[2];

esphome/components/atm90e26/atm90e26.h

@@ -13,6 +13,7 @@ class ATM90E26Component : public PollingComponent,
  public:
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void update() override;
 
   void set_voltage_sensor(sensor::Sensor *obj) { this->voltage_sensor_ = obj; }

esphome/components/bh1750/bh1750.cpp

@@ -265,4 +265,6 @@ void BH1750Sensor::fail_and_reset_() {
   this->state_ = IDLE;
 }
 
+float BH1750Sensor::get_setup_priority() const { return setup_priority::DATA; }
+
 }  // namespace esphome::bh1750

esphome/components/bh1750/bh1750.h

@@ -21,6 +21,7 @@ class BH1750Sensor : public sensor::Sensor, public PollingComponent, public i2c:
   void dump_config() override;
   void update() override;
   void loop() override;
+  float get_setup_priority() const override;
 
  protected:
   // State machine states

esphome/components/bme280_base/bme280_base.cpp

@@ -199,6 +199,7 @@ void BME280Component::dump_config() {
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
   ESP_LOGCONFIG(TAG, "    Oversampling: %s", oversampling_to_str(this->humidity_oversampling_));
 }
+float BME280Component::get_setup_priority() const { return setup_priority::DATA; }
 
 inline uint8_t oversampling_to_time(BME280Oversampling over_sampling) { return (1 << uint8_t(over_sampling)) >> 1; }
 

esphome/components/bme280_base/bme280_base.h

@@ -76,6 +76,7 @@ class BME280Component : public PollingComponent {
   // (In most use cases you won't need these)
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void update() override;
 
  protected:

esphome/components/bme680/bme680.cpp

@@ -233,6 +233,8 @@ void BME680Component::dump_config() {
   }
 }
 
+float BME680Component::get_setup_priority() const { return setup_priority::DATA; }
+
 void BME680Component::update() {
   uint8_t meas_control = 0;  // No need to fetch, we're setting all fields
   meas_control |= (this->temperature_oversampling_ & 0b111) << 5;

esphome/components/bme680/bme680.h

@@ -99,6 +99,7 @@ class BME680Component : public PollingComponent, public i2c::I2CDevice {
   // (In most use cases you won't need these)
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void update() override;
 
  protected:

esphome/components/bme680_bsec/__init__.py

@@ -89,9 +89,8 @@ async def to_code(config):
         var.set_state_save_interval(config[CONF_STATE_SAVE_INTERVAL].total_milliseconds)
     )
 
-    # Although this component does not use SPI/Wire directly, the BSEC library requires them
+    # Although this component does not use SPI, the BSEC library requires the SPI library
     cg.add_library("SPI", None)
-    cg.add_library("Wire", None)
 
     cg.add_define("USE_BSEC")
     cg.add_library("boschsensortec/BSEC Software Library", "1.6.1480")

esphome/components/bme680_bsec/bme680_bsec.cpp

@@ -181,6 +181,8 @@ void BME680BSECComponent::dump_config() {
   LOG_SENSOR("  ", "Breath VOC Equivalent", this->breath_voc_equivalent_sensor_);
 }
 
+float BME680BSECComponent::get_setup_priority() const { return setup_priority::DATA; }
+
 void BME680BSECComponent::loop() {
   this->run_();
 

esphome/components/bme680_bsec/bme680_bsec.h

@@ -64,6 +64,7 @@ class BME680BSECComponent : public Component, public i2c::I2CDevice {
 
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void loop() override;
 
  protected:

esphome/components/bme68x_bsec2/bme68x_bsec2.cpp

@@ -106,6 +106,8 @@ void BME68xBSEC2Component::dump_config() {
 #endif
 }
 
+float BME68xBSEC2Component::get_setup_priority() const { return setup_priority::DATA; }
+
 void BME68xBSEC2Component::loop() {
   this->run_();
 

esphome/components/bme68x_bsec2/bme68x_bsec2.h

@@ -48,6 +48,7 @@ class BME68xBSEC2Component : public Component {
  public:
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void loop() override;
 
   void set_algorithm_output(AlgorithmOutput algorithm_output) { this->algorithm_output_ = algorithm_output; }

esphome/components/bmi160/bmi160.cpp

@@ -263,6 +263,7 @@ void BMI160Component::update() {
 
   this->status_clear_warning();
 }
+float BMI160Component::get_setup_priority() const { return setup_priority::DATA; }
 
 }  // namespace bmi160
 }  // namespace esphome

esphome/components/bmi160/bmi160.h

@@ -14,6 +14,8 @@ class BMI160Component : public PollingComponent, public i2c::I2CDevice {
 
   void update() override;
 
+  float get_setup_priority() const override;
+
   void set_accel_x_sensor(sensor::Sensor *accel_x_sensor) { accel_x_sensor_ = accel_x_sensor; }
   void set_accel_y_sensor(sensor::Sensor *accel_y_sensor) { accel_y_sensor_ = accel_y_sensor; }
   void set_accel_z_sensor(sensor::Sensor *accel_z_sensor) { accel_z_sensor_ = accel_z_sensor; }

esphome/components/bmp085/bmp085.cpp

@@ -131,6 +131,7 @@ bool BMP085Component::set_mode_(uint8_t mode) {
   ESP_LOGV(TAG, "Setting mode to 0x%02X", mode);
   return this->write_byte(BMP085_REGISTER_CONTROL, mode);
 }
+float BMP085Component::get_setup_priority() const { return setup_priority::DATA; }
 
 }  // namespace bmp085
 }  // namespace esphome

esphome/components/bmp085/bmp085.h

@@ -18,6 +18,8 @@ class BMP085Component : public PollingComponent, public i2c::I2CDevice {
   void setup() override;
   void dump_config() override;
 
+  float get_setup_priority() const override;
+
  protected:
   struct CalibrationData {
     int16_t ac1, ac2, ac3;

esphome/components/bmp280_base/bmp280_base.cpp

@@ -148,6 +148,7 @@ void BMP280Component::dump_config() {
   LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
   ESP_LOGCONFIG(TAG, "    Oversampling: %s", oversampling_to_str(this->pressure_oversampling_));
 }
+float BMP280Component::get_setup_priority() const { return setup_priority::DATA; }
 
 inline uint8_t oversampling_to_time(BMP280Oversampling over_sampling) { return (1 << uint8_t(over_sampling)) >> 1; }
 

esphome/components/bmp280_base/bmp280_base.h

@@ -64,6 +64,7 @@ class BMP280Component : public PollingComponent {
 
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void update() override;
 
  protected:

esphome/components/bmp3xx_base/bmp3xx_base.cpp

@@ -179,6 +179,7 @@ void BMP3XXComponent::dump_config() {
     ESP_LOGCONFIG(TAG, "    Oversampling: %s", LOG_STR_ARG(oversampling_to_str(this->pressure_oversampling_)));
   }
 }
+float BMP3XXComponent::get_setup_priority() const { return setup_priority::DATA; }
 
 inline uint8_t oversampling_to_time(Oversampling over_sampling) { return (1 << uint8_t(over_sampling)); }
 

esphome/components/bmp3xx_base/bmp3xx_base.h

@@ -73,6 +73,7 @@ class BMP3XXComponent : public PollingComponent {
  public:
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void update() override;
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }

esphome/components/cd74hc4067/cd74hc4067.cpp

@@ -7,6 +7,8 @@ namespace cd74hc4067 {
 
 static const char *const TAG = "cd74hc4067";
 
+float CD74HC4067Component::get_setup_priority() const { return setup_priority::DATA; }
+
 void CD74HC4067Component::setup() {
   this->pin_s0_->setup();
   this->pin_s1_->setup();

esphome/components/cd74hc4067/cd74hc4067.h

@@ -13,6 +13,7 @@ class CD74HC4067Component : public Component {
   /// Set up the internal sensor array.
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
 
   /// setting pin active by setting the right combination of the four multiplexer input pins
   void activate_pin(uint8_t pin);

esphome/components/climate/climate_mode.cpp

@@ -1,44 +1,109 @@
 #include "climate_mode.h"
-#include "esphome/core/progmem.h"
 
 namespace esphome::climate {
 
-// Climate mode strings indexed by ClimateMode enum (0-6): OFF, HEAT_COOL, COOL, HEAT, FAN_ONLY, DRY, AUTO
-PROGMEM_STRING_TABLE(ClimateModeStrings, "OFF", "HEAT_COOL", "COOL", "HEAT", "FAN_ONLY", "DRY", "AUTO", "UNKNOWN");
-
 const LogString *climate_mode_to_string(ClimateMode mode) {
-  return ClimateModeStrings::get_log_str(static_cast<uint8_t>(mode), ClimateModeStrings::LAST_INDEX);
+  switch (mode) {
+    case CLIMATE_MODE_OFF:
+      return LOG_STR("OFF");
+    case CLIMATE_MODE_HEAT_COOL:
+      return LOG_STR("HEAT_COOL");
+    case CLIMATE_MODE_AUTO:
+      return LOG_STR("AUTO");
+    case CLIMATE_MODE_COOL:
+      return LOG_STR("COOL");
+    case CLIMATE_MODE_HEAT:
+      return LOG_STR("HEAT");
+    case CLIMATE_MODE_FAN_ONLY:
+      return LOG_STR("FAN_ONLY");
+    case CLIMATE_MODE_DRY:
+      return LOG_STR("DRY");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
-
-// Climate action strings indexed by ClimateAction enum (0,2-6): OFF, (gap), COOLING, HEATING, IDLE, DRYING, FAN
-PROGMEM_STRING_TABLE(ClimateActionStrings, "OFF", "UNKNOWN", "COOLING", "HEATING", "IDLE", "DRYING", "FAN", "UNKNOWN");
-
 const LogString *climate_action_to_string(ClimateAction action) {
-  return ClimateActionStrings::get_log_str(static_cast<uint8_t>(action), ClimateActionStrings::LAST_INDEX);
+  switch (action) {
+    case CLIMATE_ACTION_OFF:
+      return LOG_STR("OFF");
+    case CLIMATE_ACTION_COOLING:
+      return LOG_STR("COOLING");
+    case CLIMATE_ACTION_HEATING:
+      return LOG_STR("HEATING");
+    case CLIMATE_ACTION_IDLE:
+      return LOG_STR("IDLE");
+    case CLIMATE_ACTION_DRYING:
+      return LOG_STR("DRYING");
+    case CLIMATE_ACTION_FAN:
+      return LOG_STR("FAN");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
 
-// Climate fan mode strings indexed by ClimateFanMode enum (0-9): ON, OFF, AUTO, LOW, MEDIUM, HIGH, MIDDLE, FOCUS,
-// DIFFUSE, QUIET
-PROGMEM_STRING_TABLE(ClimateFanModeStrings, "ON", "OFF", "AUTO", "LOW", "MEDIUM", "HIGH", "MIDDLE", "FOCUS", "DIFFUSE",
-                     "QUIET", "UNKNOWN");
-
 const LogString *climate_fan_mode_to_string(ClimateFanMode fan_mode) {
-  return ClimateFanModeStrings::get_log_str(static_cast<uint8_t>(fan_mode), ClimateFanModeStrings::LAST_INDEX);
+  switch (fan_mode) {
+    case climate::CLIMATE_FAN_ON:
+      return LOG_STR("ON");
+    case climate::CLIMATE_FAN_OFF:
+      return LOG_STR("OFF");
+    case climate::CLIMATE_FAN_AUTO:
+      return LOG_STR("AUTO");
+    case climate::CLIMATE_FAN_LOW:
+      return LOG_STR("LOW");
+    case climate::CLIMATE_FAN_MEDIUM:
+      return LOG_STR("MEDIUM");
+    case climate::CLIMATE_FAN_HIGH:
+      return LOG_STR("HIGH");
+    case climate::CLIMATE_FAN_MIDDLE:
+      return LOG_STR("MIDDLE");
+    case climate::CLIMATE_FAN_FOCUS:
+      return LOG_STR("FOCUS");
+    case climate::CLIMATE_FAN_DIFFUSE:
+      return LOG_STR("DIFFUSE");
+    case climate::CLIMATE_FAN_QUIET:
+      return LOG_STR("QUIET");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
 
-// Climate swing mode strings indexed by ClimateSwingMode enum (0-3): OFF, BOTH, VERTICAL, HORIZONTAL
-PROGMEM_STRING_TABLE(ClimateSwingModeStrings, "OFF", "BOTH", "VERTICAL", "HORIZONTAL", "UNKNOWN");
-
 const LogString *climate_swing_mode_to_string(ClimateSwingMode swing_mode) {
-  return ClimateSwingModeStrings::get_log_str(static_cast<uint8_t>(swing_mode), ClimateSwingModeStrings::LAST_INDEX);
+  switch (swing_mode) {
+    case climate::CLIMATE_SWING_OFF:
+      return LOG_STR("OFF");
+    case climate::CLIMATE_SWING_BOTH:
+      return LOG_STR("BOTH");
+    case climate::CLIMATE_SWING_VERTICAL:
+      return LOG_STR("VERTICAL");
+    case climate::CLIMATE_SWING_HORIZONTAL:
+      return LOG_STR("HORIZONTAL");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
 
-// Climate preset strings indexed by ClimatePreset enum (0-7): NONE, HOME, AWAY, BOOST, COMFORT, ECO, SLEEP, ACTIVITY
-PROGMEM_STRING_TABLE(ClimatePresetStrings, "NONE", "HOME", "AWAY", "BOOST", "COMFORT", "ECO", "SLEEP", "ACTIVITY",
-                     "UNKNOWN");
-
 const LogString *climate_preset_to_string(ClimatePreset preset) {
-  return ClimatePresetStrings::get_log_str(static_cast<uint8_t>(preset), ClimatePresetStrings::LAST_INDEX);
+  switch (preset) {
+    case climate::CLIMATE_PRESET_NONE:
+      return LOG_STR("NONE");
+    case climate::CLIMATE_PRESET_HOME:
+      return LOG_STR("HOME");
+    case climate::CLIMATE_PRESET_ECO:
+      return LOG_STR("ECO");
+    case climate::CLIMATE_PRESET_AWAY:
+      return LOG_STR("AWAY");
+    case climate::CLIMATE_PRESET_BOOST:
+      return LOG_STR("BOOST");
+    case climate::CLIMATE_PRESET_COMFORT:
+      return LOG_STR("COMFORT");
+    case climate::CLIMATE_PRESET_SLEEP:
+      return LOG_STR("SLEEP");
+    case climate::CLIMATE_PRESET_ACTIVITY:
+      return LOG_STR("ACTIVITY");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
 
 }  // namespace esphome::climate

esphome/components/cm1106/cm1106.h

@@ -10,6 +10,8 @@ namespace cm1106 {
 
 class CM1106Component : public PollingComponent, public uart::UARTDevice {
  public:
+  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
+
   void setup() override;
   void update() override;
   void dump_config() override;

esphome/components/combination/combination.h

@@ -10,6 +10,8 @@ namespace combination {
 
 class CombinationComponent : public Component, public sensor::Sensor {
  public:
+  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
+
   /// @brief Logs all source sensor's names
   virtual void log_source_sensors() = 0;
 

esphome/components/const/__init__.py

@@ -17,9 +17,3 @@ CONF_ON_STATE_CHANGE = "on_state_change"
 CONF_REQUEST_HEADERS = "request_headers"
 CONF_ROWS = "rows"
 CONF_USE_PSRAM = "use_psram"
-
-ICON_CURRENT_DC = "mdi:current-dc"
-ICON_SOLAR_PANEL = "mdi:solar-panel"
-ICON_SOLAR_POWER = "mdi:solar-power"
-
-UNIT_AMPERE_HOUR = "Ah"

esphome/components/cover/__init__.py

@@ -1,5 +1,3 @@
-import logging
-
 from esphome import automation
 from esphome.automation import Condition, maybe_simple_id
 import esphome.codegen as cg
@@ -11,7 +9,6 @@ from esphome.const import (
     CONF_ICON,
     CONF_ID,
     CONF_MQTT_ID,
-    CONF_ON_IDLE,
     CONF_ON_OPEN,
     CONF_POSITION,
     CONF_POSITION_COMMAND_TOPIC,
@@ -35,10 +32,9 @@ from esphome.const import (
     DEVICE_CLASS_SHUTTER,
     DEVICE_CLASS_WINDOW,
 )
-from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
+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.types import ConfigType, TemplateArgsType
+from esphome.cpp_generator import MockObjClass
 
 IS_PLATFORM_COMPONENT = True
 
@@ -57,8 +53,6 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_WINDOW,
 ]
 
-_LOGGER = logging.getLogger(__name__)
-
 cover_ns = cg.esphome_ns.namespace("cover")
 
 Cover = cover_ns.class_("Cover", cg.EntityBase)
@@ -89,29 +83,14 @@ ControlAction = cover_ns.class_("ControlAction", automation.Action)
 CoverPublishAction = cover_ns.class_("CoverPublishAction", automation.Action)
 CoverIsOpenCondition = cover_ns.class_("CoverIsOpenCondition", Condition)
 CoverIsClosedCondition = cover_ns.class_("CoverIsClosedCondition", Condition)
-CoverOpenedTrigger = cover_ns.class_(
-    "CoverOpenedTrigger", automation.Trigger.template()
-)
+
+# Triggers
+CoverOpenTrigger = cover_ns.class_("CoverOpenTrigger", automation.Trigger.template())
 CoverClosedTrigger = cover_ns.class_(
     "CoverClosedTrigger", automation.Trigger.template()
 )
-CoverTrigger = cover_ns.class_("CoverTrigger", automation.Trigger.template())
 
-# Cover-specific constants
 CONF_ON_CLOSED = "on_closed"
-CONF_ON_OPENED = "on_opened"
-CONF_ON_OPENING = "on_opening"
-CONF_ON_CLOSING = "on_closing"
-
-TRIGGERS = {
-    CONF_ON_OPEN: CoverOpenedTrigger,  # Deprecated, use on_opened
-    CONF_ON_OPENED: CoverOpenedTrigger,
-    CONF_ON_CLOSED: CoverClosedTrigger,
-    CONF_ON_CLOSING: CoverTrigger.template(CoverOperation.COVER_OPERATION_CLOSING),
-    CONF_ON_OPENING: CoverTrigger.template(CoverOperation.COVER_OPERATION_OPENING),
-    CONF_ON_IDLE: CoverTrigger.template(CoverOperation.COVER_OPERATION_IDLE),
-}
-
 
 _COVER_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
@@ -132,14 +111,16 @@ _COVER_SCHEMA = (
             cv.Optional(CONF_TILT_STATE_TOPIC): cv.All(
                 cv.requires_component("mqtt"), cv.subscribe_topic
             ),
-            **{
-                cv.Optional(conf): automation.validate_automation(
-                    {
-                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(trigger_class),
-                    }
-                )
-                for conf, trigger_class in TRIGGERS.items()
-            },
+            cv.Optional(CONF_ON_OPEN): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(CoverOpenTrigger),
+                }
+            ),
+            cv.Optional(CONF_ON_CLOSED): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(CoverClosedTrigger),
+                }
+            ),
         }
     )
 )
@@ -176,14 +157,12 @@ async def setup_cover_core_(var, config):
     if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
         cg.add(var.set_device_class(device_class))
 
-    if CONF_ON_OPEN in config:
-        _LOGGER.warning(
-            "'on_open' is deprecated, use 'on_opened'. Will be removed in 2026.8.0"
-        )
-    for trigger_conf in TRIGGERS:
-        for conf in config.get(trigger_conf, []):
-            trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-            await automation.build_automation(trigger, [], conf)
+    for conf in config.get(CONF_ON_OPEN, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+    for conf in config.get(CONF_ON_CLOSED, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
 
     if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
         mqtt_ = cg.new_Pvariable(mqtt_id, var)
@@ -279,26 +258,6 @@ async def cover_control_to_code(config, action_id, template_arg, args):
     return var
 
 
-COVER_CONDITION_SCHEMA = cv.maybe_simple_value(
-    {cv.Required(CONF_ID): cv.use_id(Cover)}, key=CONF_ID
-)
-
-
-async def cover_condition_to_code(
-    config: ConfigType, condition_id: ID, template_arg: MockObj, args: TemplateArgsType
-) -> MockObj:
-    paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(condition_id, template_arg, paren)
-
-
-automation.register_condition(
-    "cover.is_open", CoverIsOpenCondition, COVER_CONDITION_SCHEMA
-)(cover_condition_to_code)
-automation.register_condition(
-    "cover.is_closed", CoverIsClosedCondition, COVER_CONDITION_SCHEMA
-)(cover_condition_to_code)
-
-
 @coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(cover_ns.using)

esphome/components/cover/automation.h

@@ -90,53 +90,44 @@ template<typename... Ts> class CoverPublishAction : public Action<Ts...> {
   Cover *cover_;
 };
 
-template<bool OPEN, typename... Ts> class CoverPositionCondition : public Condition<Ts...> {
+template<typename... Ts> class CoverIsOpenCondition : public Condition<Ts...> {
  public:
-  CoverPositionCondition(Cover *cover) : cover_(cover) {}
-
-  bool check(const Ts &...x) override { return this->cover_->position == (OPEN ? COVER_OPEN : COVER_CLOSED); }
+  CoverIsOpenCondition(Cover *cover) : cover_(cover) {}
+  bool check(const Ts &...x) override { return this->cover_->is_fully_open(); }
 
  protected:
   Cover *cover_;
 };
 
-template<typename... Ts> using CoverIsOpenCondition = CoverPositionCondition<true, Ts...>;
-template<typename... Ts> using CoverIsClosedCondition = CoverPositionCondition<false, Ts...>;
-
-template<bool OPEN> class CoverPositionTrigger : public Trigger<> {
+template<typename... Ts> class CoverIsClosedCondition : public Condition<Ts...> {
  public:
-  CoverPositionTrigger(Cover *a_cover) {
+  CoverIsClosedCondition(Cover *cover) : cover_(cover) {}
+  bool check(const Ts &...x) override { return this->cover_->is_fully_closed(); }
+
+ protected:
+  Cover *cover_;
+};
+
+class CoverOpenTrigger : public Trigger<> {
+ public:
+  CoverOpenTrigger(Cover *a_cover) {
     a_cover->add_on_state_callback([this, a_cover]() {
-      if (a_cover->position != this->last_position_) {
-        this->last_position_ = a_cover->position;
-        if (a_cover->position == (OPEN ? COVER_OPEN : COVER_CLOSED))
-          this->trigger();
+      if (a_cover->is_fully_open()) {
+        this->trigger();
       }
     });
   }
-
- protected:
-  float last_position_{NAN};
 };
 
-using CoverOpenedTrigger = CoverPositionTrigger<true>;
-using CoverClosedTrigger = CoverPositionTrigger<false>;
-
-template<CoverOperation OP> class CoverTrigger : public Trigger<> {
+class CoverClosedTrigger : public Trigger<> {
  public:
-  CoverTrigger(Cover *a_cover) {
+  CoverClosedTrigger(Cover *a_cover) {
     a_cover->add_on_state_callback([this, a_cover]() {
-      auto current_op = a_cover->current_operation;
-      if (current_op == OP) {
-        if (!this->last_operation_.has_value() || this->last_operation_.value() != OP) {
-          this->trigger();
-        }
+      if (a_cover->is_fully_closed()) {
+        this->trigger();
       }
-      this->last_operation_ = current_op;
     });
   }
-
- protected:
-  optional<CoverOperation> last_operation_{};
 };
+
 }  // namespace esphome::cover

esphome/components/cover/cover.cpp

@@ -10,6 +10,9 @@ namespace esphome::cover {
 
 static const char *const TAG = "cover";
 
+const float COVER_OPEN = 1.0f;
+const float COVER_CLOSED = 0.0f;
+
 const LogString *cover_command_to_str(float pos) {
   if (pos == COVER_OPEN) {
     return LOG_STR("OPEN");
@@ -19,11 +22,17 @@ const LogString *cover_command_to_str(float pos) {
     return LOG_STR("UNKNOWN");
   }
 }
-// Cover operation strings indexed by CoverOperation enum (0-2): IDLE, OPENING, CLOSING, plus UNKNOWN
-PROGMEM_STRING_TABLE(CoverOperationStrings, "IDLE", "OPENING", "CLOSING", "UNKNOWN");
-
 const LogString *cover_operation_to_str(CoverOperation op) {
-  return CoverOperationStrings::get_log_str(static_cast<uint8_t>(op), CoverOperationStrings::LAST_INDEX);
+  switch (op) {
+    case COVER_OPERATION_IDLE:
+      return LOG_STR("IDLE");
+    case COVER_OPERATION_OPENING:
+      return LOG_STR("OPENING");
+    case COVER_OPERATION_CLOSING:
+      return LOG_STR("CLOSING");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
 
 Cover::Cover() : position{COVER_OPEN} {}

esphome/components/cover/cover.h

@@ -10,8 +10,8 @@
 
 namespace esphome::cover {
 
-static constexpr float COVER_OPEN = 1.0f;
-static constexpr float COVER_CLOSED = 0.0f;
+const extern float COVER_OPEN;
+const extern float COVER_CLOSED;
 
 #define LOG_COVER(prefix, type, obj) \
   if ((obj) != nullptr) { \

esphome/components/cse7761/cse7761.cpp

@@ -62,6 +62,8 @@ void CSE7761Component::dump_config() {
   this->check_uart_settings(38400, 1, uart::UART_CONFIG_PARITY_EVEN, 8);
 }
 
+float CSE7761Component::get_setup_priority() const { return setup_priority::DATA; }
+
 void CSE7761Component::update() {
   if (this->data_.ready) {
     this->get_data_();

esphome/components/cse7761/cse7761.h

@@ -28,6 +28,7 @@ class CSE7761Component : public PollingComponent, public uart::UARTDevice {
   void set_current_2_sensor(sensor::Sensor *current_sensor_2) { current_sensor_2_ = current_sensor_2; }
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void update() override;
 
  protected:

esphome/components/cse7766/cse7766.cpp

@@ -37,6 +37,7 @@ void CSE7766Component::loop() {
     this->raw_data_index_ = (this->raw_data_index_ + 1) % 24;
   }
 }
+float CSE7766Component::get_setup_priority() const { return setup_priority::DATA; }
 
 bool CSE7766Component::check_byte_() {
   uint8_t index = this->raw_data_index_;
@@ -151,10 +152,6 @@ void CSE7766Component::parse_data_() {
     if (this->power_sensor_ != nullptr) {
       this->power_sensor_->publish_state(power);
     }
-  } else if (this->power_sensor_ != nullptr) {
-    // No valid power measurement from chip - publish 0W to avoid stale readings
-    // This typically happens when current is below the measurable threshold (~50mA)
-    this->power_sensor_->publish_state(0.0f);
   }
 
   float current = 0.0f;

esphome/components/cse7766/cse7766.h

@@ -23,6 +23,7 @@ class CSE7766Component : public Component, public uart::UARTDevice {
   void set_power_factor_sensor(sensor::Sensor *power_factor_sensor) { power_factor_sensor_ = power_factor_sensor; }
 
   void loop() override;
+  float get_setup_priority() const override;
   void dump_config() override;
 
  protected:

esphome/components/current_based/current_based_cover.cpp

@@ -159,6 +159,7 @@ void CurrentBasedCover::dump_config() {
                 this->start_sensing_delay_ / 1e3f, YESNO(this->malfunction_detection_));
 }
 
+float CurrentBasedCover::get_setup_priority() const { return setup_priority::DATA; }
 void CurrentBasedCover::stop_prev_trigger_() {
   if (this->prev_command_trigger_ != nullptr) {
     this->prev_command_trigger_->stop_action();

esphome/components/current_based/current_based_cover.h

@@ -14,6 +14,7 @@ class CurrentBasedCover : public cover::Cover, public Component {
   void setup() override;
   void loop() override;
   void dump_config() override;
+  float get_setup_priority() const override;
 
   Trigger<> *get_stop_trigger() { return &this->stop_trigger_; }
 

esphome/components/daly_bms/daly_bms.cpp

@@ -104,6 +104,8 @@ void DalyBmsComponent::loop() {
   }
 }
 
+float DalyBmsComponent::get_setup_priority() const { return setup_priority::DATA; }
+
 void DalyBmsComponent::request_data_(uint8_t data_id) {
   uint8_t request_message[DALY_FRAME_SIZE];
 

esphome/components/daly_bms/daly_bms.h

@@ -72,6 +72,7 @@ class DalyBmsComponent : public PollingComponent, public uart::UARTDevice {
   void update() override;
   void loop() override;
 
+  float get_setup_priority() const override;
   void set_address(uint8_t address) { this->addr_ = address; }
 
  protected:

esphome/components/daly_bms/sensor.py

@@ -1,6 +1,5 @@
 import esphome.codegen as cg
 from esphome.components import sensor
-from esphome.components.const import ICON_CURRENT_DC, UNIT_AMPERE_HOUR
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BATTERY_LEVEL,
@@ -56,11 +55,14 @@ CONF_CELL_15_VOLTAGE = "cell_15_voltage"
 CONF_CELL_16_VOLTAGE = "cell_16_voltage"
 CONF_CELL_17_VOLTAGE = "cell_17_voltage"
 CONF_CELL_18_VOLTAGE = "cell_18_voltage"
+ICON_CURRENT_DC = "mdi:current-dc"
 ICON_BATTERY_OUTLINE = "mdi:battery-outline"
 ICON_THERMOMETER_CHEVRON_UP = "mdi:thermometer-chevron-up"
 ICON_THERMOMETER_CHEVRON_DOWN = "mdi:thermometer-chevron-down"
 ICON_CAR_BATTERY = "mdi:car-battery"
 
+UNIT_AMPERE_HOUR = "Ah"
+
 TYPES = [
     CONF_VOLTAGE,
     CONF_CURRENT,

esphome/components/dht/dht.cpp

@@ -63,6 +63,8 @@ void DHT::update() {
   }
 }
 
+float DHT::get_setup_priority() const { return setup_priority::DATA; }
+
 void DHT::set_dht_model(DHTModel model) {
   this->model_ = model;
   this->is_auto_detect_ = model == DHT_MODEL_AUTO_DETECT;

esphome/components/dht/dht.h

@@ -51,6 +51,8 @@ class DHT : public PollingComponent {
   void dump_config() override;
   /// Update sensor values and push them to the frontend.
   void update() override;
+  /// HARDWARE_LATE setup priority.
+  float get_setup_priority() const override;
 
  protected:
   bool read_sensor_(float *temperature, float *humidity, bool report_errors);

esphome/components/dht12/dht12.cpp

@@ -49,7 +49,7 @@ void DHT12Component::dump_config() {
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
-
+float DHT12Component::get_setup_priority() const { return setup_priority::DATA; }
 bool DHT12Component::read_data_(uint8_t *data) {
   if (!this->read_bytes(0, data, 5)) {
     ESP_LOGW(TAG, "Updating DHT12 failed!");

esphome/components/dht12/dht12.h

@@ -11,6 +11,7 @@ class DHT12Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void update() override;
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }

esphome/components/dps310/dps310.cpp

@@ -98,6 +98,8 @@ void DPS310Component::dump_config() {
   LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
 }
 
+float DPS310Component::get_setup_priority() const { return setup_priority::DATA; }
+
 void DPS310Component::update() {
   if (!this->update_in_progress_) {
     this->update_in_progress_ = true;

esphome/components/dps310/dps310.h

@@ -40,6 +40,7 @@ class DPS310Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void update() override;
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }

esphome/components/ds1307/ds1307.cpp

@@ -26,6 +26,8 @@ void DS1307Component::dump_config() {
   RealTimeClock::dump_config();
 }
 
+float DS1307Component::get_setup_priority() const { return setup_priority::DATA; }
+
 void DS1307Component::read_time() {
   if (!this->read_rtc_()) {
     return;

esphome/components/ds1307/ds1307.h

@@ -12,6 +12,7 @@ class DS1307Component : public time::RealTimeClock, public i2c::I2CDevice {
   void setup() override;
   void update() override;
   void dump_config() override;
+  float get_setup_priority() const override;
   void read_time();
   void write_time();
 

esphome/components/dsmr/__init__.py

@@ -66,7 +66,7 @@ async def to_code(config):
     cg.add_build_flag("-DDSMR_WATER_MBUS_ID=" + str(config[CONF_WATER_MBUS_ID]))
 
     # DSMR Parser
-    cg.add_library("esphome/dsmr_parser", "1.1.0")
+    cg.add_library("esphome/dsmr_parser", "1.0.0")
 
     # Crypto
     cg.add_library("polargoose/Crypto-no-arduino", "0.4.0")

esphome/components/dsmr/sensor.py

@@ -718,6 +718,14 @@ CONFIG_SCHEMA = cv.Schema(
             device_class=DEVICE_CLASS_POWER,
             state_class=STATE_CLASS_MEASUREMENT,
         ),
+        cv.Optional("fw_core_version"): sensor.sensor_schema(
+            accuracy_decimals=3,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("fw_module_version"): sensor.sensor_schema(
+            accuracy_decimals=3,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 

esphome/components/dsmr/text_sensor.py

@@ -26,9 +26,7 @@ CONFIG_SCHEMA = cv.Schema(
         cv.Optional("sub_equipment_id"): text_sensor.text_sensor_schema(),
         cv.Optional("gas_delivered_text"): text_sensor.text_sensor_schema(),
         cv.Optional("fw_core_checksum"): text_sensor.text_sensor_schema(),
-        cv.Optional("fw_core_version"): text_sensor.text_sensor_schema(),
         cv.Optional("fw_module_checksum"): text_sensor.text_sensor_schema(),
-        cv.Optional("fw_module_version"): text_sensor.text_sensor_schema(),
         cv.Optional("telegram"): text_sensor.text_sensor_schema().extend(
             {cv.Optional(CONF_INTERNAL, default=True): cv.boolean}
         ),

esphome/components/duty_cycle/duty_cycle_sensor.cpp

@@ -43,6 +43,8 @@ void DutyCycleSensor::update() {
   this->last_update_ = now;
 }
 
+float DutyCycleSensor::get_setup_priority() const { return setup_priority::DATA; }
+
 void IRAM_ATTR DutyCycleSensorStore::gpio_intr(DutyCycleSensorStore *arg) {
   const bool new_level = arg->pin.digital_read();
   if (new_level == arg->last_level)

esphome/components/duty_cycle/duty_cycle_sensor.h

@@ -22,6 +22,7 @@ class DutyCycleSensor : public sensor::Sensor, public PollingComponent {
   void set_pin(InternalGPIOPin *pin) { pin_ = pin; }
 
   void setup() override;
+  float get_setup_priority() const override;
   void dump_config() override;
   void update() override;
 

esphome/components/ee895/ee895.cpp

@@ -55,6 +55,8 @@ void EE895Component::dump_config() {
   LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
 }
 
+float EE895Component::get_setup_priority() const { return setup_priority::DATA; }
+
 void EE895Component::update() {
   write_command_(TEMPERATURE_ADDRESS, 2);
   this->set_timeout(50, [this]() {

esphome/components/ee895/ee895.h

@@ -14,6 +14,7 @@ class EE895Component : public PollingComponent, public i2c::I2CDevice {
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
   void set_pressure_sensor(sensor::Sensor *pressure_sensor) { pressure_sensor_ = pressure_sensor; }
 
+  float get_setup_priority() const override;
   void setup() override;
   void dump_config() override;
   void update() override;

esphome/components/emc2101/sensor/emc2101_sensor.cpp

@@ -7,6 +7,8 @@ namespace emc2101 {
 
 static const char *const TAG = "EMC2101.sensor";
 
+float EMC2101Sensor::get_setup_priority() const { return setup_priority::DATA; }
+
 void EMC2101Sensor::dump_config() {
   ESP_LOGCONFIG(TAG, "Emc2101 sensor:");
   LOG_SENSOR("  ", "Internal temperature", this->internal_temperature_sensor_);

esphome/components/emc2101/sensor/emc2101_sensor.h

@@ -15,6 +15,8 @@ class EMC2101Sensor : public PollingComponent {
   void dump_config() override;
   /** Used by ESPHome framework. */
   void update() override;
+  /** Used by ESPHome framework. */
+  float get_setup_priority() const override;
 
   /** Used by ESPHome framework. */
   void set_internal_temperature_sensor(sensor::Sensor *sensor) { this->internal_temperature_sensor_ = sensor; }

esphome/components/endstop/endstop_cover.cpp

@@ -111,7 +111,7 @@ void EndstopCover::dump_config() {
   LOG_BINARY_SENSOR("  ", "Open Endstop", this->open_endstop_);
   LOG_BINARY_SENSOR("  ", "Close Endstop", this->close_endstop_);
 }
-
+float EndstopCover::get_setup_priority() const { return setup_priority::DATA; }
 void EndstopCover::stop_prev_trigger_() {
   if (this->prev_command_trigger_ != nullptr) {
     this->prev_command_trigger_->stop_action();

esphome/components/endstop/endstop_cover.h

@@ -13,6 +13,7 @@ class EndstopCover : public cover::Cover, public Component {
   void setup() override;
   void loop() override;
   void dump_config() override;
+  float get_setup_priority() const override;
 
   Trigger<> *get_open_trigger() { return &this->open_trigger_; }
   Trigger<> *get_close_trigger() { return &this->close_trigger_; }

esphome/components/ens210/ens210.cpp

@@ -136,6 +136,8 @@ void ENS210Component::dump_config() {
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
 
+float ENS210Component::get_setup_priority() const { return setup_priority::DATA; }
+
 void ENS210Component::update() {
   // Execute a single measurement
   if (!this->write_byte(ENS210_REGISTER_SENS_RUN, 0x00)) {

esphome/components/ens210/ens210.h

@@ -10,6 +10,7 @@ namespace ens210 {
 /// This class implements support for the ENS210 relative humidity and temperature i2c sensor.
 class ENS210Component : public PollingComponent, public i2c::I2CDevice {
  public:
+  float get_setup_priority() const override;
   void dump_config() override;
   void setup() override;
   void update() override;

esphome/components/epaper_spi/colorconv.h

@@ -1,67 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <algorithm>
-#include "esphome/core/color.h"
-
-/* Utility for converting internal \a Color RGB representation to supported IC hardware color keys
- *
- * Focus in driver layer is on efficiency.
- * For optimum output quality on RGB inputs consider offline color keying/dithering.
- * Also see e.g. Image component.
- */
-
-namespace esphome::epaper_spi {
-
-/** Delta for when to regard as gray */
-static constexpr uint8_t COLORCONV_GRAY_THRESHOLD = 50;
-
-/** Map RGB color to discrete BWYR hex 4 color key
- *
- * @tparam NATIVE_COLOR  Type of native hardware color values
- * @param color     RGB color to convert from
- * @param hw_black  Native value for black
- * @param hw_white  Native value for white
- * @param hw_yellow Native value for yellow
- * @param hw_red    Native value for red
- * @return          Converted native hardware color value
- * @internal Constexpr. Does not depend on side effects ("pure").
- */
-template<typename NATIVE_COLOR>
-constexpr NATIVE_COLOR color_to_bwyr(Color color, NATIVE_COLOR hw_black, NATIVE_COLOR hw_white, NATIVE_COLOR hw_yellow,
-                                     NATIVE_COLOR hw_red) {
-  // --- Step 1: Check for Grayscale (Black or White) ---
-  // We define "grayscale" as a color where the min and max components
-  // are close to each other.
-
-  const auto [min_rgb, max_rgb] = std::minmax({color.r, color.g, color.b});
-
-  if ((max_rgb - min_rgb) < COLORCONV_GRAY_THRESHOLD) {
-    // It's a shade of gray. Map to BLACK or WHITE.
-    // We split the luminance at the halfway point (382 = (255*3)/2)
-    if ((static_cast<int>(color.r) + color.g + color.b) > 382) {
-      return hw_white;
-    }
-    return hw_black;
-  }
-
-  // --- Step 2: Check for Primary/Secondary Colors ---
-  // If it's not gray, it's a color. We check which components are
-  // "on" (over 128) vs "off". This divides the RGB cube into 8 corners.
-  const bool r_on = (color.r > 128);
-  const bool g_on = (color.g > 128);
-  const bool b_on = (color.b > 128);
-
-  if (r_on) {
-    if (!b_on) {
-      return g_on ? hw_yellow : hw_red;
-    }
-
-    // At least red+blue high (but not gray) -> White
-    return hw_white;
-  } else {
-    return (b_on && g_on) ? hw_white : hw_black;
-  }
-}
-
-}  // namespace esphome::epaper_spi