[api] Add speed_optimized proto option for hot encode paths

Add a new (speed_optimized) message option that emits __attribute__((optimize("O2"))) on the generated encode() and calculate_size() methods. Under -Os, GCC does not inline the small ProtoEncode helpers (write_raw_byte, encode_varint, etc.) into the generated methods, causing significant overhead on hot paths. Apply to SensorStateResponse and BluetoothLERawAdvertisementsResponse which are the highest-frequency encode paths.
[api] Compile noise-c and libsodium with -O2 for speed
2026-07-01 21:12:50 +00:00 · 2026-04-12 19:12:31 -10:00 · 2026-04-12 19:03:21 -10:00 · 2026-04-12 18:37:50 -10:00 · 2026-04-12 18:32:03 -10:00
59 changed files with 301 additions and 1321 deletions
@@ -1 +1 @@
-dc8ad5472d9fb44ce1ca29a0601afd65705642799a2819704dfc8459fbaf9815
+d48687d988ae2a94a9973226df773478a7db1d52133545f07aa05e34fc678dcf
@@ -22,7 +22,7 @@ runs:
        python-version: ${{ inputs.python-version }}
    - name: Restore Python virtual environment
      id: cache-venv
-      uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+      uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
      with:
        path: venv
        # yamllint disable-line rule:line-length
@@ -27,7 +27,7 @@ jobs:

      - name: Generate a token
        id: generate-token
-        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v2
+        uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859 # v2
        with:
          app-id: ${{ secrets.ESPHOME_GITHUB_APP_ID }}
          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
@@ -47,7 +47,7 @@ jobs:
          python-version: ${{ env.DEFAULT_PYTHON }}
      - name: Restore Python virtual environment
        id: cache-venv
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: venv
          # yamllint disable-line rule:line-length
@@ -159,7 +159,7 @@ jobs:
          token: ${{ secrets.CODECOV_TOKEN }}
      - name: Save Python virtual environment cache
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: venv
          key: ${{ runner.os }}-${{ steps.restore-python.outputs.python-version }}-venv-${{ needs.common.outputs.cache-key }}
@@ -198,7 +198,7 @@ jobs:
          python-version: ${{ env.DEFAULT_PYTHON }}
          cache-key: ${{ needs.common.outputs.cache-key }}
      - name: Restore components graph cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: .temp/components_graph.json
          key: components-graph-${{ hashFiles('esphome/components/**/*.py') }}
@@ -231,7 +231,7 @@ jobs:
          echo "benchmarks=$(echo "$output" | jq -r '.benchmarks')" >> $GITHUB_OUTPUT
      - name: Save components graph cache
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: .temp/components_graph.json
          key: components-graph-${{ hashFiles('esphome/components/**/*.py') }}
@@ -253,7 +253,7 @@ jobs:
          python-version: "3.13"
      - name: Restore Python virtual environment
        id: cache-venv
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: venv
          key: ${{ runner.os }}-${{ steps.python.outputs.python-version }}-venv-${{ needs.common.outputs.cache-key }}
@@ -387,14 +387,14 @@ jobs:

      - name: Cache platformio
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: ~/.platformio
          key: platformio-${{ matrix.pio_cache_key }}-${{ hashFiles('platformio.ini') }}

      - name: Cache platformio
        if: github.ref != 'refs/heads/dev'
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: ~/.platformio
          key: platformio-${{ matrix.pio_cache_key }}-${{ hashFiles('platformio.ini') }}
@@ -466,14 +466,14 @@ jobs:

      - name: Cache platformio
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: ~/.platformio
          key: platformio-tidyesp32-${{ hashFiles('platformio.ini') }}

      - name: Cache platformio
        if: github.ref != 'refs/heads/dev'
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: ~/.platformio
          key: platformio-tidyesp32-${{ hashFiles('platformio.ini') }}
@@ -555,14 +555,14 @@ jobs:

      - name: Cache platformio
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: ~/.platformio
          key: platformio-tidyesp32-${{ hashFiles('platformio.ini') }}

      - name: Cache platformio
        if: github.ref != 'refs/heads/dev'
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: ~/.platformio
          key: platformio-tidyesp32-${{ hashFiles('platformio.ini') }}
@@ -817,7 +817,7 @@ jobs:
      - name: Restore cached memory analysis
        id: cache-memory-analysis
        if: steps.check-script.outputs.skip != 'true' && steps.check-tests.outputs.skip != 'true'
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: memory-analysis-target.json
          key: ${{ steps.cache-key.outputs.cache-key }}
@@ -841,7 +841,7 @@ jobs:

      - name: Cache platformio
        if: steps.check-script.outputs.skip != 'true' && steps.check-tests.outputs.skip != 'true' && steps.cache-memory-analysis.outputs.cache-hit != 'true'
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: ~/.platformio
          key: platformio-memory-${{ fromJSON(needs.determine-jobs.outputs.memory_impact).platform }}-${{ hashFiles('platformio.ini') }}
@@ -883,7 +883,7 @@ jobs:

      - name: Save memory analysis to cache
        if: steps.check-script.outputs.skip != 'true' && steps.check-tests.outputs.skip != 'true' && steps.cache-memory-analysis.outputs.cache-hit != 'true' && steps.build.outcome == 'success'
-        uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: memory-analysis-target.json
          key: ${{ steps.cache-key.outputs.cache-key }}
@@ -930,7 +930,7 @@ jobs:
          python-version: ${{ env.DEFAULT_PYTHON }}
          cache-key: ${{ needs.common.outputs.cache-key }}
      - name: Cache platformio
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
        with:
          path: ~/.platformio
          key: platformio-memory-${{ fromJSON(needs.determine-jobs.outputs.memory_impact).platform }}-${{ hashFiles('platformio.ini') }}
@@ -221,7 +221,7 @@ jobs:
    steps:
      - name: Generate a token
        id: generate-token
-        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1
+        uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859 # v3.0.0
        with:
          app-id: ${{ secrets.ESPHOME_GITHUB_APP_ID }}
          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
@@ -256,7 +256,7 @@ jobs:
    steps:
      - name: Generate a token
        id: generate-token
-        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1
+        uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859 # v3.0.0
        with:
          app-id: ${{ secrets.ESPHOME_GITHUB_APP_ID }}
          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
@@ -287,7 +287,7 @@ jobs:
    steps:
      - name: Generate a token
        id: generate-token
-        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1
+        uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859 # v3.0.0
        with:
          app-id: ${{ secrets.ESPHOME_GITHUB_APP_ID }}
          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
@@ -750,15 +750,8 @@ def upload_using_esptool(
            platformio_api.FlashImage(
                path=idedata.firmware_bin_path, offset=firmware_offset
            ),
+            *idedata.extra_flash_images,
        ]
-        for image in idedata.extra_flash_images:
-            if not image.path.is_file():
-                _LOGGER.warning(
-                    "Skipping missing flash image declared by platform: %s",
-                    image.path,
-                )
-                continue
-            flash_images.append(image)

    mcu = "esp8266"
    if CORE.is_esp32:
@@ -2,11 +2,7 @@ import logging

 import esphome.codegen as cg
 from esphome.components import sensor, voltage_sampler
-from esphome.components.esp32 import (
-    get_esp32_variant,
-    include_builtin_idf_component,
-    require_adc_oneshot_iram,
-)
+from esphome.components.esp32 import get_esp32_variant, include_builtin_idf_component
 from esphome.components.nrf52.const import AIN_TO_GPIO, EXTRA_ADC
 from esphome.components.zephyr import (
    zephyr_add_overlay,
@@ -28,7 +24,6 @@ from esphome.const import (
    PlatformFramework,
 )
 from esphome.core import CORE
-from esphome.types import ConfigType

 from . import (
    ATTENUATION_MODES,
@@ -70,13 +65,6 @@ def validate_config(config):
    return config


-def _require_adc_iram(config: ConfigType) -> ConfigType:
-    """Register ADC oneshot IRAM requirement during config validation."""
-    if CORE.is_esp32:
-        require_adc_oneshot_iram()
-    return config
-
-
 ADCSensor = adc_ns.class_(
    "ADCSensor", sensor.Sensor, cg.PollingComponent, voltage_sampler.VoltageSampler
 )
@@ -107,7 +95,6 @@ CONFIG_SCHEMA = cv.All(
    )
    .extend(cv.polling_component_schema("60s")),
    validate_config,
-    _require_adc_iram,
 )

 CONF_ADC_CHANNEL_ID = "adc_channel_id"
@@ -1,5 +1,6 @@
 import base64
 import logging
+import pathlib

 from esphome import automation
 from esphome.automation import Condition
@@ -458,6 +459,10 @@ async def to_code(config: ConfigType) -> None:
        # Enable optimized memzero/memcmp in libsodium instead of volatile byte loops
        cg.add_build_flag("-DHAVE_WEAK_SYMBOLS=1")
        cg.add_build_flag("-DHAVE_INLINE_ASM=1")
+        # Compile crypto libraries with -O2 for speed instead of -Os.
+        # Crypto is CPU-bound and benefits significantly from speed optimization.
+        # GCC uses the last -O flag, so appending -O2 overrides the global -Os.
+        _write_crypto_optimize_script()
    else:
        cg.add_define("USE_API_PLAINTEXT")

@@ -465,6 +470,17 @@ async def to_code(config: ConfigType) -> None:
    cg.add_global(api_ns.using)


+_CRYPTO_OPTIMIZE_SCRIPT = "crypto_optimize.py"
+
+
+def _write_crypto_optimize_script() -> None:
+    from esphome.helpers import copy_file_if_changed
+
+    script_src = pathlib.Path(__file__).parent / f"{_CRYPTO_OPTIMIZE_SCRIPT}.script"
+    copy_file_if_changed(script_src, CORE.relative_build_path(_CRYPTO_OPTIMIZE_SCRIPT))
+    cg.add_platformio_option("extra_scripts", [f"post:{_CRYPTO_OPTIMIZE_SCRIPT}"])
+
+
 KEY_VALUE_SCHEMA = cv.Schema({cv.string: cv.templatable(cv.string_strict)})


@@ -778,10 +778,9 @@ message SubscribeLogsResponse {
  option (source) = SOURCE_SERVER;
  option (log) = false;
  option (no_delay) = false;
-  option (speed_optimized) = true;

-  LogLevel level = 1 [(force) = true];
-  bytes message = 3 [(force) = true];
+  LogLevel level = 1;
+  bytes message = 3;
 }

 // ==================== NOISE ENCRYPTION ====================
@@ -745,9 +745,8 @@ uint32_t ListEntitiesSensorResponse::calculate_size() const {
 #endif
  return size;
 }
-__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *
-SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+__attribute__((optimize("O2"))) uint8_t *SensorStateResponse::encode(
+    ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
  uint8_t *__restrict__ pos = buffer.get_pos();
  ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
  ProtoEncode::encode_float(pos PROTO_ENCODE_DEBUG_ARG, 2, this->state);
@@ -757,9 +756,7 @@ SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) c
 #endif
  return pos;
 }
-__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t
-SensorStateResponse::calculate_size() const {
+__attribute__((optimize("O2"))) uint32_t SensorStateResponse::calculate_size() const {
  uint32_t size = 0;
  size += 5;
  size += ProtoSize::calc_float(1, this->state);
@@ -916,22 +913,16 @@ bool SubscribeLogsRequest::decode_varint(uint32_t field_id, proto_varint_value_t
  }
  return true;
 }
-__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *
-SubscribeLogsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+uint8_t *SubscribeLogsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
  uint8_t *__restrict__ pos = buffer.get_pos();
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(this->level), true);
-  ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 26);
-  ProtoEncode::encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, this->message_len_);
-  ProtoEncode::encode_raw(pos PROTO_ENCODE_DEBUG_ARG, this->message_ptr_, this->message_len_);
+  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(this->level));
+  ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 3, this->message_ptr_, this->message_len_);
  return pos;
 }
-__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t
-SubscribeLogsResponse::calculate_size() const {
+uint32_t SubscribeLogsResponse::calculate_size() const {
  uint32_t size = 0;
-  size += 2;
-  size += ProtoSize::calc_length_force(1, this->message_len_);
+  size += this->level ? 2 : 0;
+  size += ProtoSize::calc_length(1, this->message_len_);
  return size;
 }
 #ifdef USE_API_NOISE
@@ -2338,9 +2329,8 @@ bool SubscribeBluetoothLEAdvertisementsRequest::decode_varint(uint32_t field_id,
  }
  return true;
 }
-__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *
-BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+__attribute__((optimize("O2"))) uint8_t *BluetoothLERawAdvertisementsResponse::encode(
+    ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
  uint8_t *__restrict__ pos = buffer.get_pos();
  for (uint16_t i = 0; i < this->advertisements_len; i++) {
    auto &sub_msg = this->advertisements[i];
@@ -2362,9 +2352,7 @@ BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCO
  }
  return pos;
 }
-__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t
-BluetoothLERawAdvertisementsResponse::calculate_size() const {
+__attribute__((optimize("O2"))) uint32_t BluetoothLERawAdvertisementsResponse::calculate_size() const {
  uint32_t size = 0;
  for (uint16_t i = 0; i < this->advertisements_len; i++) {
    auto &sub_msg = this->advertisements[i];
@@ -0,0 +1,9 @@
+# Compile crypto libraries with -O2 for speed instead of the default -Os.
+# Crypto is CPU-bound and benefits significantly from speed optimization.
+# GCC uses the last -O flag, so appending -O2 overrides the global -Os
+# for these libraries only.
+Import("env")
+
+for lb in env.GetLibBuilders():
+    if lb.name in ("noise-c", "libsodium"):
+        lb.env.Append(CCFLAGS=["-O2"])
@@ -111,14 +111,14 @@ class ATM90E32Component : public PollingComponent,
 #endif
  float get_reference_voltage(uint8_t phase) {
 #ifdef USE_NUMBER
-    return (phase < 3 && ref_voltages_[phase]) ? ref_voltages_[phase]->state : 120.0;  // Default voltage
+    return (phase >= 0 && phase < 3 && ref_voltages_[phase]) ? ref_voltages_[phase]->state : 120.0;  // Default voltage
 #else
    return 120.0;  // Default voltage
 #endif
  }
  float get_reference_current(uint8_t phase) {
 #ifdef USE_NUMBER
-    return (phase < 3 && ref_currents_[phase]) ? ref_currents_[phase]->state : 5.0f;  // Default current
+    return (phase >= 0 && phase < 3 && ref_currents_[phase]) ? ref_currents_[phase]->state : 5.0f;  // Default current
 #else
    return 5.0f;   // Default current
 #endif
@@ -1,11 +1,7 @@
 from dataclasses import dataclass

 import esphome.codegen as cg
-from esphome.components.esp32 import (
-    add_idf_component,
-    add_idf_sdkconfig_option,
-    include_builtin_idf_component,
-)
+from esphome.components.esp32 import add_idf_component, include_builtin_idf_component
 import esphome.config_validation as cv
 from esphome.const import CONF_BITS_PER_SAMPLE, CONF_NUM_CHANNELS, CONF_SAMPLE_RATE
 from esphome.core import CORE
@@ -31,7 +27,6 @@ class AudioData:
    flac_support: bool = False
    mp3_support: bool = False
    opus_support: bool = False
-    micro_decoder_support: bool = False


 def _get_data() -> AudioData:
@@ -55,11 +50,6 @@ def request_opus_support() -> None:
    _get_data().opus_support = True


-def request_micro_decoder_support() -> None:
-    """Request micro-decoder library support for audio decoding."""
-    _get_data().micro_decoder_support = True
-
-
 CONF_MIN_BITS_PER_SAMPLE = "min_bits_per_sample"
 CONF_MAX_BITS_PER_SAMPLE = "max_bits_per_sample"
 CONF_MIN_CHANNELS = "min_channels"
@@ -218,19 +208,6 @@ async def to_code(config):
    )

    data = _get_data()
-
-    if data.micro_decoder_support:
-        add_idf_component(name="esphome/micro-decoder", ref="0.1.1")
-
-        # All codecs are enabled by default in micro-decoder, so disable the ones that aren't requested to save flash
-        if not data.flac_support:
-            add_idf_sdkconfig_option("CONFIG_MICRO_DECODER_CODEC_FLAC", False)
-        if not data.mp3_support:
-            add_idf_sdkconfig_option("CONFIG_MICRO_DECODER_CODEC_MP3", False)
-        if not data.opus_support:
-            add_idf_sdkconfig_option("CONFIG_MICRO_DECODER_CODEC_OPUS", False)
-
-    # Legacy audio_decoder.cpp support defines and components
    if data.flac_support:
        cg.add_define("USE_AUDIO_FLAC_SUPPORT")
        add_idf_component(name="esphome/micro-flac", ref="0.1.1")
@@ -17,7 +17,6 @@ CODEOWNERS = ["@neffs", "@kbx81"]
 DOMAIN = "bme68x_bsec2"

 BSEC2_LIBRARY_VERSION = "1.10.2610"
-BME68x_LIBRARY_VERSION = "v1.3.40408"

 CONF_ALGORITHM_OUTPUT = "algorithm_output"
 CONF_BME68X_BSEC2_ID = "bme68x_bsec2_id"
@@ -185,31 +184,16 @@ async def to_code_base(config):
    if core.CORE.using_arduino:
        cg.add_library("Wire", None)
        cg.add_library("SPI", None)
-
-    if core.CORE.is_esp32:
-        from esphome.components.esp32 import add_idf_component
-
-        add_idf_component(
-            name="boschsensortec/Bosch-BME68x-Library",
-            repo="https://github.com/esphome-libs/Bosch-BME68x-Library",
-            ref=BME68x_LIBRARY_VERSION,
-        )
-        add_idf_component(
-            name="boschsensortec/Bosch-BSEC2-Library",
-            repo="https://github.com/esphome-libs/Bosch-BSEC2-Library",
-            ref=BSEC2_LIBRARY_VERSION,
-        )
-    else:
-        cg.add_library(
-            "BME68x Sensor library",
-            None,
-            f"https://github.com/boschsensortec/Bosch-BME68x-Library#{BME68x_LIBRARY_VERSION}",
-        )
-        cg.add_library(
-            "BSEC2 Software Library",
-            None,
-            f"https://github.com/boschsensortec/Bosch-BSEC2-Library.git#{BSEC2_LIBRARY_VERSION}",
-        )
+    cg.add_library(
+        "BME68x Sensor library",
+        None,
+        "https://github.com/boschsensortec/Bosch-BME68x-Library#v1.3.40408",
+    )
+    cg.add_library(
+        "BSEC2 Software Library",
+        None,
+        f"https://github.com/boschsensortec/Bosch-BSEC2-Library.git#{BSEC2_LIBRARY_VERSION}",
+    )

    cg.add_define("USE_BSEC2")

@@ -676,7 +676,7 @@ ARDUINO_FRAMEWORK_VERSION_LOOKUP = {
    "dev": cv.Version(3, 3, 8),
 }
 ARDUINO_PLATFORM_VERSION_LOOKUP = {
-    cv.Version(3, 3, 8): cv.Version(55, 3, 38, "1"),
+    cv.Version(3, 3, 8): cv.Version(55, 3, 38),
    cv.Version(3, 3, 7): cv.Version(55, 3, 37),
    cv.Version(3, 3, 6): cv.Version(55, 3, 36),
    cv.Version(3, 3, 5): cv.Version(55, 3, 35),
@@ -724,7 +724,7 @@ ESP_IDF_PLATFORM_VERSION_LOOKUP = {
    cv.Version(
        6, 0, 0
    ): "https://github.com/pioarduino/platform-espressif32.git#prep_IDF6",
-    cv.Version(5, 5, 4): cv.Version(55, 3, 38, "1"),
+    cv.Version(5, 5, 4): cv.Version(55, 3, 38),
    cv.Version(5, 5, 3, "1"): cv.Version(55, 3, 37),
    cv.Version(5, 5, 3): cv.Version(55, 3, 37),
    cv.Version(5, 5, 2): cv.Version(55, 3, 37),
@@ -744,8 +744,8 @@ ESP_IDF_PLATFORM_VERSION_LOOKUP = {
 # The platform-espressif32 version
 #  - https://github.com/pioarduino/platform-espressif32/releases
 PLATFORM_VERSION_LOOKUP = {
-    "recommended": cv.Version(55, 3, 38, "1"),
-    "latest": cv.Version(55, 3, 38, "1"),
+    "recommended": cv.Version(55, 3, 38),
+    "latest": cv.Version(55, 3, 38),
    "dev": "https://github.com/pioarduino/platform-espressif32.git#develop",
 }

@@ -1058,7 +1058,6 @@ CONF_DISABLE_MBEDTLS_PEER_CERT = "disable_mbedtls_peer_cert"
 CONF_DISABLE_MBEDTLS_PKCS7 = "disable_mbedtls_pkcs7"
 CONF_DISABLE_REGI2C_IN_IRAM = "disable_regi2c_in_iram"
 CONF_DISABLE_FATFS = "disable_fatfs"
-CONF_ADC_ONESHOT_IN_IRAM = "adc_oneshot_in_iram"

 # VFS requirement tracking
 # Components that need VFS features can call require_vfs_*() functions
@@ -1072,7 +1071,6 @@ KEY_MBEDTLS_PEER_CERT_REQUIRED = "mbedtls_peer_cert_required"
 KEY_MBEDTLS_PKCS7_REQUIRED = "mbedtls_pkcs7_required"
 KEY_FATFS_REQUIRED = "fatfs_required"
 KEY_MBEDTLS_SHA512_REQUIRED = "mbedtls_sha512_required"
-KEY_ADC_ONESHOT_IRAM_REQUIRED = "adc_oneshot_iram_required"


 def require_vfs_select() -> None:
@@ -1170,17 +1168,6 @@ def require_fatfs() -> None:
    CORE.data[KEY_ESP32][KEY_FATFS_REQUIRED] = True


-def require_adc_oneshot_iram() -> None:
-    """Mark that ADC oneshot IRAM safety is required by a component.
-
-    Call this from components that use the ADC oneshot driver. When flash cache is
-    disabled (e.g., during NVS writes by WiFi, BLE, Zigbee, or power management),
-    the ADC oneshot read function must be in IRAM to avoid crashes.
-    This sets CONFIG_ADC_ONESHOT_CTRL_FUNC_IN_IRAM.
-    """
-    CORE.data[KEY_ESP32][KEY_ADC_ONESHOT_IRAM_REQUIRED] = True
-
-
 def _parse_idf_component(value: str) -> ConfigType:
    """Parse IDF component shorthand syntax like 'owner/component^version'"""
    # Match operator followed by version-like string (digit or *)
@@ -1281,7 +1268,6 @@ FRAMEWORK_SCHEMA = cv.Schema(
                cv.Optional(CONF_DISABLE_MBEDTLS_PEER_CERT, default=True): cv.boolean,
                cv.Optional(CONF_DISABLE_MBEDTLS_PKCS7, default=True): cv.boolean,
                cv.Optional(CONF_DISABLE_REGI2C_IN_IRAM, default=True): cv.boolean,
-                cv.Optional(CONF_ADC_ONESHOT_IN_IRAM, default=False): cv.boolean,
                cv.Optional(CONF_DISABLE_FATFS, default=True): cv.boolean,
            }
        ),
@@ -2082,16 +2068,6 @@ async def to_code(config):
    if advanced[CONF_DISABLE_REGI2C_IN_IRAM]:
        add_idf_sdkconfig_option("CONFIG_ESP_REGI2C_CTRL_FUNC_IN_IRAM", False)

-    # Place ADC oneshot control functions in IRAM for cache safety
-    # When flash cache is disabled (during NVS writes by WiFi, BLE, Zigbee, Thread,
-    # power management, etc.), ADC reads will crash if these functions are in flash.
-    # Components using ADC call require_adc_oneshot_iram() to force this.
-    if (
-        CORE.data[KEY_ESP32].get(KEY_ADC_ONESHOT_IRAM_REQUIRED, False)
-        or advanced[CONF_ADC_ONESHOT_IN_IRAM]
-    ):
-        add_idf_sdkconfig_option("CONFIG_ADC_ONESHOT_CTRL_FUNC_IN_IRAM", True)
-
    # Disable FATFS support
    # Components that need FATFS (SD card, etc.) can call require_fatfs()
    if CORE.data[KEY_ESP32].get(KEY_FATFS_REQUIRED, False):
@@ -61,9 +61,6 @@ uint32_t arch_get_cpu_freq_hz() {
 }

 TaskHandle_t loop_task_handle = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-static StaticTask_t loop_task_tcb;        // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-static StackType_t
-    loop_task_stack[ESPHOME_LOOP_TASK_STACK_SIZE];  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

 void loop_task(void *pv_params) {
  setup();
@@ -76,11 +73,9 @@ extern "C" void app_main() {
  initArduino();
  esp32::setup_preferences();
 #if CONFIG_FREERTOS_UNICORE
-  loop_task_handle = xTaskCreateStatic(loop_task, "loopTask", ESPHOME_LOOP_TASK_STACK_SIZE, nullptr, 1, loop_task_stack,
-                                       &loop_task_tcb);
+  xTaskCreate(loop_task, "loopTask", ESPHOME_LOOP_TASK_STACK_SIZE, nullptr, 1, &loop_task_handle);
 #else
-  loop_task_handle = xTaskCreateStaticPinnedToCore(loop_task, "loopTask", ESPHOME_LOOP_TASK_STACK_SIZE, nullptr, 1,
-                                                   loop_task_stack, &loop_task_tcb, 1);
+  xTaskCreatePinnedToCore(loop_task, "loopTask", ESPHOME_LOOP_TASK_STACK_SIZE, nullptr, 1, &loop_task_handle, 1);
 #endif
 }

@@ -4,6 +4,7 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include <nvs_flash.h>
+#include <cinttypes>
 #include <cstring>
 #include <vector>

@@ -11,6 +12,9 @@ namespace esphome::esp32 {

 static const char *const TAG = "preferences";

+// Buffer size for converting uint32_t to string: max "4294967295" (10 chars) + null terminator + 1 padding
+static constexpr size_t KEY_BUFFER_SIZE = 12;
+
 struct NVSData {
  uint32_t key;
  SmallInlineBuffer<8> data;  // Most prefs fit in 8 bytes (covers fan, cover, select, etc.)
@@ -47,8 +51,8 @@ bool ESP32PreferenceBackend::load(uint8_t *data, size_t len) {
    }
  }

-  char key_str[UINT32_MAX_STR_SIZE];
-  uint32_to_str(key_str, this->key);
+  char key_str[KEY_BUFFER_SIZE];
+  snprintf(key_str, sizeof(key_str), "%" PRIu32, this->key);
  size_t actual_len;
  esp_err_t err = nvs_get_blob(this->nvs_handle, key_str, nullptr, &actual_len);
  if (err != 0) {
@@ -104,8 +108,8 @@ bool ESP32Preferences::sync() {
  uint32_t last_key = 0;

  for (const auto &save : s_pending_save) {
-    char key_str[UINT32_MAX_STR_SIZE];
-    uint32_to_str(key_str, save.key);
+    char key_str[KEY_BUFFER_SIZE];
+    snprintf(key_str, sizeof(key_str), "%" PRIu32, save.key);
    ESP_LOGVV(TAG, "Checking if NVS data %s has changed", key_str);
    if (this->is_changed_(this->nvs_handle, save, key_str)) {
      esp_err_t err = nvs_set_blob(this->nvs_handle, key_str, save.data.data(), save.data.size());
@@ -108,13 +108,8 @@ async def globals_set_to_code(config, action_id, template_arg, args):
    full_id, paren = await cg.get_variable_with_full_id(config[CONF_ID])
    template_arg = cg.TemplateArguments(full_id.type, *template_arg)
    var = cg.new_Pvariable(action_id, template_arg, paren)
-    # Use the global's value_type alias as the lambda return type so
-    # TemplatableFn stores a direct function pointer instead of going through
-    # the deprecated converting trampoline when the value expression deduces
-    # to a different type (e.g. int literal assigned to a float global).
-    value_type = cg.RawExpression(f"{full_id.type}::value_type")
    templ = await cg.templatable(
-        config[CONF_VALUE], args, value_type, to_exp=cg.RawExpression
+        config[CONF_VALUE], args, None, to_exp=cg.RawExpression, wrap_constant=True
    )
    cg.add(var.set_value(templ))
    return var
@@ -127,6 +127,6 @@ async def to_code(config):
    cg.add(var.set_min_temperature(config[CONF_MIN_TEMPERATURE]))
    cg.add_build_flag("-Wno-error=overloaded-virtual")

-    cg.add_library("tonia/HeatpumpIR", "1.0.41")
+    cg.add_library("tonia/HeatpumpIR", "1.0.40")
    if CORE.is_libretiny or CORE.is_esp32:
        CORE.add_platformio_option("lib_ignore", ["IRremoteESP8266"])
@@ -360,8 +360,8 @@ void LD2410Component::handle_periodic_data_() {
  */
 #ifdef USE_SENSOR
  SAFE_PUBLISH_SENSOR(this->moving_target_distance_sensor_,
-                      encode_uint16(this->buffer_data_[MOVING_TARGET_HIGH], this->buffer_data_[MOVING_TARGET_LOW]));
-  SAFE_PUBLISH_SENSOR(this->moving_target_energy_sensor_, this->buffer_data_[MOVING_ENERGY]);
+                      encode_uint16(this->buffer_data_[MOVING_TARGET_HIGH], this->buffer_data_[MOVING_TARGET_LOW]))
+  SAFE_PUBLISH_SENSOR(this->moving_target_energy_sensor_, this->buffer_data_[MOVING_ENERGY])
  SAFE_PUBLISH_SENSOR(this->still_target_distance_sensor_,
                      encode_uint16(this->buffer_data_[STILL_TARGET_HIGH], this->buffer_data_[STILL_TARGET_LOW]));
  SAFE_PUBLISH_SENSOR(this->still_target_energy_sensor_, this->buffer_data_[STILL_ENERGY]);
@@ -375,26 +375,26 @@ void LD2410Component::handle_periodic_data_() {
      Moving energy: 20~28th bytes
    */
    for (uint8_t i = 0; i < TOTAL_GATES; i++) {
-      SAFE_PUBLISH_SENSOR(this->gate_move_sensors_[i], this->buffer_data_[MOVING_SENSOR_START + i]);
+      SAFE_PUBLISH_SENSOR(this->gate_move_sensors_[i], this->buffer_data_[MOVING_SENSOR_START + i])
    }
    /*
      Still energy: 29~37th bytes
    */
    for (uint8_t i = 0; i < TOTAL_GATES; i++) {
-      SAFE_PUBLISH_SENSOR(this->gate_still_sensors_[i], this->buffer_data_[STILL_SENSOR_START + i]);
+      SAFE_PUBLISH_SENSOR(this->gate_still_sensors_[i], this->buffer_data_[STILL_SENSOR_START + i])
    }
    /*
      Light sensor: 38th bytes
    */
-    SAFE_PUBLISH_SENSOR(this->light_sensor_, this->buffer_data_[LIGHT_SENSOR]);
+    SAFE_PUBLISH_SENSOR(this->light_sensor_, this->buffer_data_[LIGHT_SENSOR])
  } else {
    for (auto &gate_move_sensor : this->gate_move_sensors_) {
-      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_move_sensor);
+      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_move_sensor)
    }
    for (auto &gate_still_sensor : this->gate_still_sensors_) {
-      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_still_sensor);
+      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_still_sensor)
    }
-    SAFE_PUBLISH_SENSOR_UNKNOWN(this->light_sensor_);
+    SAFE_PUBLISH_SENSOR_UNKNOWN(this->light_sensor_)
  }
 #endif
 #ifdef USE_BINARY_SENSOR
@@ -786,12 +786,13 @@ void LD2410Component::set_light_out_control() {
 }

 #ifdef USE_SENSOR
+// These could leak memory, but they are only set once prior to 'setup()' and should never be used again.
 void LD2410Component::set_gate_move_sensor(uint8_t gate, sensor::Sensor *s) {
-  this->gate_move_sensors_[gate].set_sensor(s);
+  this->gate_move_sensors_[gate] = new SensorWithDedup<uint8_t>(s);
 }

 void LD2410Component::set_gate_still_sensor(uint8_t gate, sensor::Sensor *s) {
-  this->gate_still_sensors_[gate].set_sensor(s);
+  this->gate_still_sensors_[gate] = new SensorWithDedup<uint8_t>(s);
 }
 #endif

@@ -129,8 +129,8 @@ class LD2410Component : public Component, public uart::UARTDevice {
  std::array<number::Number *, TOTAL_GATES> gate_still_threshold_numbers_{};
 #endif
 #ifdef USE_SENSOR
-  std::array<SensorWithDedup<uint8_t>, TOTAL_GATES> gate_move_sensors_{};
-  std::array<SensorWithDedup<uint8_t>, TOTAL_GATES> gate_still_sensors_{};
+  std::array<SensorWithDedup<uint8_t> *, TOTAL_GATES> gate_move_sensors_{};
+  std::array<SensorWithDedup<uint8_t> *, TOTAL_GATES> gate_still_sensors_{};
 #endif
 };

@@ -397,12 +397,12 @@ void LD2412Component::handle_periodic_data_() {
  */
 #ifdef USE_SENSOR
  SAFE_PUBLISH_SENSOR(this->moving_target_distance_sensor_,
-                      encode_uint16(this->buffer_data_[MOVING_TARGET_HIGH], this->buffer_data_[MOVING_TARGET_LOW]));
-  SAFE_PUBLISH_SENSOR(this->moving_target_energy_sensor_, this->buffer_data_[MOVING_ENERGY]);
+                      encode_uint16(this->buffer_data_[MOVING_TARGET_HIGH], this->buffer_data_[MOVING_TARGET_LOW]))
+  SAFE_PUBLISH_SENSOR(this->moving_target_energy_sensor_, this->buffer_data_[MOVING_ENERGY])
  SAFE_PUBLISH_SENSOR(this->still_target_distance_sensor_,
-                      encode_uint16(this->buffer_data_[STILL_TARGET_HIGH], this->buffer_data_[STILL_TARGET_LOW]));
-  SAFE_PUBLISH_SENSOR(this->still_target_energy_sensor_, this->buffer_data_[STILL_ENERGY]);
-  if (this->detection_distance_sensor_.has_sensor()) {
+                      encode_uint16(this->buffer_data_[STILL_TARGET_HIGH], this->buffer_data_[STILL_TARGET_LOW]))
+  SAFE_PUBLISH_SENSOR(this->still_target_energy_sensor_, this->buffer_data_[STILL_ENERGY])
+  if (this->detection_distance_sensor_ != nullptr) {
    int new_detect_distance = 0;
    if (target_state != 0x00 && (target_state & MOVE_BITMASK)) {
      new_detect_distance =
@@ -410,7 +410,7 @@ void LD2412Component::handle_periodic_data_() {
    } else if (target_state != 0x00) {
      new_detect_distance = encode_uint16(this->buffer_data_[STILL_TARGET_HIGH], this->buffer_data_[STILL_TARGET_LOW]);
    }
-    this->detection_distance_sensor_.publish_state_if_not_dup(new_detect_distance);
+    this->detection_distance_sensor_->publish_state_if_not_dup(new_detect_distance);
  }
  if (engineering_mode) {
    // Engineering mode needs at least LIGHT_SENSOR + 1 bytes
@@ -423,27 +423,27 @@ void LD2412Component::handle_periodic_data_() {
        Moving energy: 20~28th bytes
      */
      for (uint8_t i = 0; i < TOTAL_GATES; i++) {
-        SAFE_PUBLISH_SENSOR(this->gate_move_sensors_[i], this->buffer_data_[MOVING_SENSOR_START + i]);
+        SAFE_PUBLISH_SENSOR(this->gate_move_sensors_[i], this->buffer_data_[MOVING_SENSOR_START + i])
      }
      /*
        Still energy: 29~37th bytes
      */
      for (uint8_t i = 0; i < TOTAL_GATES; i++) {
-        SAFE_PUBLISH_SENSOR(this->gate_still_sensors_[i], this->buffer_data_[STILL_SENSOR_START + i]);
+        SAFE_PUBLISH_SENSOR(this->gate_still_sensors_[i], this->buffer_data_[STILL_SENSOR_START + i])
      }
      /*
        Light sensor value
      */
-      SAFE_PUBLISH_SENSOR(this->light_sensor_, this->buffer_data_[LIGHT_SENSOR]);
+      SAFE_PUBLISH_SENSOR(this->light_sensor_, this->buffer_data_[LIGHT_SENSOR])
    }
  } else {
    for (auto &gate_move_sensor : this->gate_move_sensors_) {
-      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_move_sensor);
+      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_move_sensor)
    }
    for (auto &gate_still_sensor : this->gate_still_sensors_) {
-      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_still_sensor);
+      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_still_sensor)
    }
-    SAFE_PUBLISH_SENSOR_UNKNOWN(this->light_sensor_);
+    SAFE_PUBLISH_SENSOR_UNKNOWN(this->light_sensor_)
  }
 #endif
  // the radar module won't tell us when it's done, so we just have to keep polling...
@@ -846,11 +846,12 @@ void LD2412Component::set_light_out_control() {
 }

 #ifdef USE_SENSOR
+// These could leak memory, but they are only set once prior to 'setup()' and should never be used again.
 void LD2412Component::set_gate_move_sensor(uint8_t gate, sensor::Sensor *s) {
-  this->gate_move_sensors_[gate].set_sensor(s);
+  this->gate_move_sensors_[gate] = new SensorWithDedup<uint8_t>(s);
 }
 void LD2412Component::set_gate_still_sensor(uint8_t gate, sensor::Sensor *s) {
-  this->gate_still_sensors_[gate].set_sensor(s);
+  this->gate_still_sensors_[gate] = new SensorWithDedup<uint8_t>(s);
 }
 #endif

@@ -133,8 +133,8 @@ class LD2412Component : public Component, public uart::UARTDevice {
  std::array<number::Number *, TOTAL_GATES> gate_still_threshold_numbers_{};
 #endif
 #ifdef USE_SENSOR
-  std::array<SensorWithDedup<uint8_t>, TOTAL_GATES> gate_move_sensors_{};
-  std::array<SensorWithDedup<uint8_t>, TOTAL_GATES> gate_still_sensors_{};
+  std::array<SensorWithDedup<uint8_t> *, TOTAL_GATES> gate_move_sensors_{};
+  std::array<SensorWithDedup<uint8_t> *, TOTAL_GATES> gate_still_sensors_{};
 #endif
 };

@@ -565,7 +565,6 @@ void LD2450Component::handle_periodic_data_() {
  SAFE_PUBLISH_SENSOR(this->still_target_count_sensor_, still_target_count);
  // Moving Target Count
  SAFE_PUBLISH_SENSOR(this->moving_target_count_sensor_, moving_target_count);
-
 #endif

 #ifdef USE_BINARY_SENSOR
@@ -873,32 +872,33 @@ void LD2450Component::query_target_tracking_mode_() { this->send_command_(CMD_QU
 void LD2450Component::query_zone_() { this->send_command_(CMD_QUERY_ZONE, nullptr, 0); }

 #ifdef USE_SENSOR
+// These could leak memory, but they are only set once prior to 'setup()' and should never be used again.
 void LD2450Component::set_move_x_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_x_sensors_[target].set_sensor(s);
+  this->move_x_sensors_[target] = new SensorWithDedup<int16_t>(s);
 }
 void LD2450Component::set_move_y_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_y_sensors_[target].set_sensor(s);
+  this->move_y_sensors_[target] = new SensorWithDedup<int16_t>(s);
 }
 void LD2450Component::set_move_speed_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_speed_sensors_[target].set_sensor(s);
+  this->move_speed_sensors_[target] = new SensorWithDedup<int16_t>(s);
 }
 void LD2450Component::set_move_angle_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_angle_sensors_[target].set_sensor(s);
+  this->move_angle_sensors_[target] = new SensorWithDedup<float>(s);
 }
 void LD2450Component::set_move_distance_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_distance_sensors_[target].set_sensor(s);
+  this->move_distance_sensors_[target] = new SensorWithDedup<uint16_t>(s);
 }
 void LD2450Component::set_move_resolution_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_resolution_sensors_[target].set_sensor(s);
+  this->move_resolution_sensors_[target] = new SensorWithDedup<uint16_t>(s);
 }
 void LD2450Component::set_zone_target_count_sensor(uint8_t zone, sensor::Sensor *s) {
-  this->zone_target_count_sensors_[zone].set_sensor(s);
+  this->zone_target_count_sensors_[zone] = new SensorWithDedup<uint8_t>(s);
 }
 void LD2450Component::set_zone_still_target_count_sensor(uint8_t zone, sensor::Sensor *s) {
-  this->zone_still_target_count_sensors_[zone].set_sensor(s);
+  this->zone_still_target_count_sensors_[zone] = new SensorWithDedup<uint8_t>(s);
 }
 void LD2450Component::set_zone_moving_target_count_sensor(uint8_t zone, sensor::Sensor *s) {
-  this->zone_moving_target_count_sensors_[zone].set_sensor(s);
+  this->zone_moving_target_count_sensors_[zone] = new SensorWithDedup<uint8_t>(s);
 }
 #endif
 #ifdef USE_TEXT_SENSOR
@@ -182,15 +182,15 @@ class LD2450Component : public Component, public uart::UARTDevice {
  ZoneOfNumbers zone_numbers_[MAX_ZONES];
 #endif
 #ifdef USE_SENSOR
-  std::array<SensorWithDedup<int16_t>, MAX_TARGETS> move_x_sensors_{};
-  std::array<SensorWithDedup<int16_t>, MAX_TARGETS> move_y_sensors_{};
-  std::array<SensorWithDedup<int16_t>, MAX_TARGETS> move_speed_sensors_{};
-  std::array<SensorWithDedup<float>, MAX_TARGETS> move_angle_sensors_{};
-  std::array<SensorWithDedup<uint16_t>, MAX_TARGETS> move_distance_sensors_{};
-  std::array<SensorWithDedup<uint16_t>, MAX_TARGETS> move_resolution_sensors_{};
-  std::array<SensorWithDedup<uint8_t>, MAX_ZONES> zone_target_count_sensors_{};
-  std::array<SensorWithDedup<uint8_t>, MAX_ZONES> zone_still_target_count_sensors_{};
-  std::array<SensorWithDedup<uint8_t>, MAX_ZONES> zone_moving_target_count_sensors_{};
+  std::array<SensorWithDedup<int16_t> *, MAX_TARGETS> move_x_sensors_{};
+  std::array<SensorWithDedup<int16_t> *, MAX_TARGETS> move_y_sensors_{};
+  std::array<SensorWithDedup<int16_t> *, MAX_TARGETS> move_speed_sensors_{};
+  std::array<SensorWithDedup<float> *, MAX_TARGETS> move_angle_sensors_{};
+  std::array<SensorWithDedup<uint16_t> *, MAX_TARGETS> move_distance_sensors_{};
+  std::array<SensorWithDedup<uint16_t> *, MAX_TARGETS> move_resolution_sensors_{};
+  std::array<SensorWithDedup<uint8_t> *, MAX_ZONES> zone_target_count_sensors_{};
+  std::array<SensorWithDedup<uint8_t> *, MAX_ZONES> zone_still_target_count_sensors_{};
+  std::array<SensorWithDedup<uint8_t> *, MAX_ZONES> zone_moving_target_count_sensors_{};
 #endif
 #ifdef USE_TEXT_SENSOR
  std::array<text_sensor::TextSensor *, MAX_TARGETS> direction_text_sensors_{};
@@ -11,20 +11,28 @@

 #define SUB_SENSOR_WITH_DEDUP(name, dedup_type) \
 protected: \
-  ld24xx::SensorWithDedup<dedup_type> name##_sensor_{}; \
+  ld24xx::SensorWithDedup<dedup_type> *name##_sensor_{nullptr}; \
 \
 public: \
-  void set_##name##_sensor(sensor::Sensor *sensor) { this->name##_sensor_.set_sensor(sensor); }
+  void set_##name##_sensor(sensor::Sensor *sensor) { \
+    this->name##_sensor_ = new ld24xx::SensorWithDedup<dedup_type>(sensor); \
+  }
 #endif

 #define LOG_SENSOR_WITH_DEDUP_SAFE(tag, name, sensor) \
-  if ((sensor).has_sensor()) { \
-    LOG_SENSOR(tag, name, (sensor).get_sensor()); \
+  if ((sensor) != nullptr) { \
+    LOG_SENSOR(tag, name, (sensor)->sens); \
  }

-#define SAFE_PUBLISH_SENSOR(sensor, value) (sensor).publish_state_if_not_dup(value)
+#define SAFE_PUBLISH_SENSOR(sensor, value) \
+  if ((sensor) != nullptr) { \
+    (sensor)->publish_state_if_not_dup(value); \
+  }

-#define SAFE_PUBLISH_SENSOR_UNKNOWN(sensor) (sensor).publish_state_unknown()
+#define SAFE_PUBLISH_SENSOR_UNKNOWN(sensor) \
+  if ((sensor) != nullptr) { \
+    (sensor)->publish_state_unknown(); \
+  }

 #define highbyte(val) (uint8_t)((val) >> 8)
 #define lowbyte(val) (uint8_t)((val) &0xff)
@@ -62,33 +70,25 @@ inline void format_version_str(const uint8_t *version, std::span<char, 20> buffe
 }

 #ifdef USE_SENSOR
-/// Sensor with deduplication — sensor may be null, null check is internal.
-/// Stored inline, no heap allocation. Does nothing when no sensor is set.
+// Helper class to store a sensor with a deduplicator & publish state only when the value changes
 template<typename T> class SensorWithDedup {
 public:
-  void set_sensor(sensor::Sensor *sens) {
-    this->sens_ = sens;
-    this->dedup_ = {};
-  }
+  SensorWithDedup(sensor::Sensor *sens) : sens(sens) {}

  void publish_state_if_not_dup(T state) {
-    if (this->sens_ != nullptr && this->dedup_.next(state)) {
-      this->sens_->publish_state(static_cast<float>(state));
+    if (this->publish_dedup.next(state)) {
+      this->sens->publish_state(static_cast<float>(state));
    }
  }

  void publish_state_unknown() {
-    if (this->sens_ != nullptr && this->dedup_.next_unknown()) {
-      this->sens_->publish_state(NAN);
+    if (this->publish_dedup.next_unknown()) {
+      this->sens->publish_state(NAN);
    }
  }

-  bool has_sensor() const { return this->sens_ != nullptr; }
-  sensor::Sensor *get_sensor() const { return this->sens_; }
-
- protected:
-  sensor::Sensor *sens_{nullptr};
-  Deduplicator<T> dedup_;
+  sensor::Sensor *sens;
+  Deduplicator<T> publish_dedup;
 };
 #endif
 }  // namespace esphome::ld24xx
@@ -3,6 +3,7 @@
 #include "preferences.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include <cinttypes>
 #include <cstring>
 #include <vector>

@@ -10,6 +11,9 @@ namespace esphome::libretiny {

 static const char *const TAG = "preferences";

+// Buffer size for converting uint32_t to string: max "4294967295" (10 chars) + null terminator + 1 padding
+static constexpr size_t KEY_BUFFER_SIZE = 12;
+
 struct NVSData {
  uint32_t key;
  SmallInlineBuffer<8> data;  // Most prefs fit in 8 bytes (covers fan, cover, select, etc.)
@@ -46,8 +50,8 @@ bool LibreTinyPreferenceBackend::load(uint8_t *data, size_t len) {
    }
  }

-  char key_str[UINT32_MAX_STR_SIZE];
-  uint32_to_str(key_str, this->key);
+  char key_str[KEY_BUFFER_SIZE];
+  snprintf(key_str, sizeof(key_str), "%" PRIu32, this->key);
  fdb_blob_make(this->blob, data, len);
  size_t actual_len = fdb_kv_get_blob(this->db, key_str, this->blob);
  if (actual_len != len) {
@@ -88,8 +92,8 @@ bool LibreTinyPreferences::sync() {
  uint32_t last_key = 0;

  for (const auto &save : s_pending_save) {
-    char key_str[UINT32_MAX_STR_SIZE];
-    uint32_to_str(key_str, save.key);
+    char key_str[KEY_BUFFER_SIZE];
+    snprintf(key_str, sizeof(key_str), "%" PRIu32, save.key);
    ESP_LOGVV(TAG, "Checking if FDB data %s has changed", key_str);
    if (this->is_changed_(&this->db, save, key_str)) {
      ESP_LOGV(TAG, "sync: key: %s, len: %zu", key_str, save.data.size());
@@ -22,20 +22,4 @@ uint8_t ESPColorCorrection::gamma_uncorrect_(uint8_t value) const {
  return (target - a <= b - target) ? lo : lo + 1;
 }

-Color ESPColorCorrection::color_uncorrect(Color color) const {
-  // uncorrected = corrected^(1/gamma) / (max_brightness * local_brightness)
-  return Color(this->color_uncorrect_red(color.red), this->color_uncorrect_green(color.green),
-               this->color_uncorrect_blue(color.blue), this->color_uncorrect_white(color.white));
-}
-
-uint8_t ESPColorCorrection::color_uncorrect_channel_(uint8_t value, uint8_t max_brightness) const {
-  if (max_brightness == 0 || this->local_brightness_ == 0)
-    return 0;
-  // Use 32-bit intermediates: when max_brightness and local_brightness_ are small but non-zero,
-  // (uncorrected / max_brightness) * 255 can exceed 65535 before the std::min(255) clamp runs.
-  uint32_t uncorrected = this->gamma_uncorrect_(value) * 255UL;
-  uint32_t res = ((uncorrected / max_brightness) * 255UL) / this->local_brightness_;
-  return static_cast<uint8_t>(std::min(res, uint32_t(255)));
-}
-
 }  // namespace esphome::light
@@ -46,18 +46,38 @@ class ESPColorCorrection {
    uint8_t res = esp_scale8_twice(white, this->max_brightness_.white, this->local_brightness_);
    return this->gamma_correct_(res);
  }
-  Color color_uncorrect(Color color) const;
+  inline Color color_uncorrect(Color color) const ESPHOME_ALWAYS_INLINE {
+    // uncorrected = corrected^(1/gamma) / (max_brightness * local_brightness)
+    return Color(this->color_uncorrect_red(color.red), this->color_uncorrect_green(color.green),
+                 this->color_uncorrect_blue(color.blue), this->color_uncorrect_white(color.white));
+  }
  inline uint8_t color_uncorrect_red(uint8_t red) const ESPHOME_ALWAYS_INLINE {
-    return this->color_uncorrect_channel_(red, this->max_brightness_.red);
+    if (this->max_brightness_.red == 0 || this->local_brightness_ == 0)
+      return 0;
+    uint16_t uncorrected = this->gamma_uncorrect_(red) * 255UL;
+    uint16_t res = ((uncorrected / this->max_brightness_.red) * 255UL) / this->local_brightness_;
+    return (uint8_t) std::min(res, uint16_t(255));
  }
  inline uint8_t color_uncorrect_green(uint8_t green) const ESPHOME_ALWAYS_INLINE {
-    return this->color_uncorrect_channel_(green, this->max_brightness_.green);
+    if (this->max_brightness_.green == 0 || this->local_brightness_ == 0)
+      return 0;
+    uint16_t uncorrected = this->gamma_uncorrect_(green) * 255UL;
+    uint16_t res = ((uncorrected / this->max_brightness_.green) * 255UL) / this->local_brightness_;
+    return (uint8_t) std::min(res, uint16_t(255));
  }
  inline uint8_t color_uncorrect_blue(uint8_t blue) const ESPHOME_ALWAYS_INLINE {
-    return this->color_uncorrect_channel_(blue, this->max_brightness_.blue);
+    if (this->max_brightness_.blue == 0 || this->local_brightness_ == 0)
+      return 0;
+    uint16_t uncorrected = this->gamma_uncorrect_(blue) * 255UL;
+    uint16_t res = ((uncorrected / this->max_brightness_.blue) * 255UL) / this->local_brightness_;
+    return (uint8_t) std::min(res, uint16_t(255));
  }
  inline uint8_t color_uncorrect_white(uint8_t white) const ESPHOME_ALWAYS_INLINE {
-    return this->color_uncorrect_channel_(white, this->max_brightness_.white);
+    if (this->max_brightness_.white == 0 || this->local_brightness_ == 0)
+      return 0;
+    uint16_t uncorrected = this->gamma_uncorrect_(white) * 255UL;
+    uint16_t res = ((uncorrected / this->max_brightness_.white) * 255UL) / this->local_brightness_;
+    return (uint8_t) std::min(res, uint16_t(255));
  }

 protected:
@@ -65,9 +85,6 @@ class ESPColorCorrection {
  uint8_t gamma_correct_(uint8_t value) const;
  /// Reverse gamma: binary search the forward PROGMEM table
  uint8_t gamma_uncorrect_(uint8_t value) const;
-  /// Shared body of color_uncorrect_{red,green,blue,white}. Kept out-of-line
-  /// to avoid duplicating two 16-bit divides at every call site.
-  uint8_t color_uncorrect_channel_(uint8_t value, uint8_t max_brightness) const;

  const uint16_t *gamma_table_{nullptr};
  Color max_brightness_{255, 255, 255, 255};
@@ -452,7 +452,7 @@ async def to_code(config):

    esp32.add_idf_component(name="espressif/esp-tflite-micro", ref="1.3.3~1")
    # Pin esp-nn for stable future builds (esp-tflite-micro depends on esp-nn)
-    esp32.add_idf_component(name="espressif/esp-nn", ref="1.1.2")
+    esp32.add_idf_component(name="espressif/esp-nn", ref="1.2.1")

    cg.add_build_flag("-DTF_LITE_STATIC_MEMORY")
    cg.add_build_flag("-DTF_LITE_DISABLE_X86_NEON")
@@ -28,8 +28,7 @@ void AirConditioner::on_status_change() {
  if (this->base_.getAutoconfStatus() == dudanov::midea::AUTOCONF_OK &&
      this->base_.getCapabilities().supportFrostProtectionPreset() && !this->frost_protection_set_) {
    // Read existing presets (set by codegen), append frost protection, write back
-    auto traits = this->get_traits();
-    const auto &existing = traits.get_supported_custom_presets();
+    const auto &existing = this->get_traits().get_supported_custom_presets();
    bool found = false;
    for (const char *p : existing) {
      if (strcmp(p, Constants::FREEZE_PROTECTION) == 0) {
@@ -234,9 +234,9 @@ class MipiSpi : public display::Display,
  }

  void dump_config() override {
-    internal_dump_config(this->model_, this->get_width(), this->get_height(), OFFSET_WIDTH, OFFSET_HEIGHT,
-                         (uint8_t) MADCTL, this->invert_colors_, DISPLAYPIXEL * 8, IS_BIG_ENDIAN, this->brightness_,
-                         this->cs_, this->reset_pin_, this->dc_pin_, this->mode_, this->data_rate_, BUS_TYPE,
+    internal_dump_config(this->model_, this->get_width(), this->get_height(), OFFSET_WIDTH, OFFSET_HEIGHT, MADCTL,
+                         this->invert_colors_, DISPLAYPIXEL * 8, IS_BIG_ENDIAN, this->brightness_, this->cs_,
+                         this->reset_pin_, this->dc_pin_, this->mode_, this->data_rate_, BUS_TYPE,
                         HAS_HARDWARE_ROTATION);
  }

@@ -305,7 +305,7 @@ class MipiSpi : public display::Display,
      this->write_command_(BRIGHTNESS, this->brightness_.value());

    // calculate new madctl value from base value adjusted for rotation
-    uint8_t madctl = (uint8_t) MADCTL;  // lower 8 bits only
+    uint8_t madctl = MADCTL;  // lower 8 bits only
    constexpr bool use_flips = (MADCTL & MADCTL_FLIP_FLAG) != 0;
    constexpr uint8_t x_mask = use_flips ? MADCTL_XFLIP : MADCTL_MX;
    constexpr uint8_t y_mask = use_flips ? MADCTL_YFLIP : MADCTL_MY;
@@ -315,7 +315,7 @@ void TCS34725Component::set_integration_time(TCS34725IntegrationTime integration
    my_integration_time_regval = integration_time;
    this->integration_time_auto_ = false;
  }
-  this->integration_time_ = (256.f - (float) my_integration_time_regval) * 2.4f;
+  this->integration_time_ = (256.f - my_integration_time_regval) * 2.4f;
  ESP_LOGI(TAG, "TCS34725I Integration time set to: %.1fms", this->integration_time_);
 }
 void TCS34725Component::set_gain(TCS34725Gain gain) {
@@ -114,25 +114,7 @@ void OTARequestHandler::handleUpload(AsyncWebServerRequest *request, const Platf
                                     uint8_t *data, size_t len, bool final) {
  ota::OTAResponseTypes error_code = ota::OTA_RESPONSE_OK;

-  // First byte of a new upload: index==0 with actual data. (web_server_idf
-  // fires a separate start-marker call with data==nullptr/len==0 before the
-  // first real chunk; gate on len>0 so we only trigger once per upload.)
-  if (index == 0 && len > 0) {
-    // If a previous upload was interrupted (e.g. client closed the tab, TCP
-    // reset) the backend from that session may still be open. Tear it down
-    // so flash state doesn't get concatenated with the new image (which can
-    // produce a technically-valid-sized but corrupted firmware that bricks
-    // the device once it reboots).
-    if (this->ota_backend_) {
-      ESP_LOGW(TAG, "New OTA upload received while previous session was still open; aborting previous session");
-      this->ota_backend_->abort();
-#ifdef USE_OTA_STATE_LISTENER
-      // Notify listeners that the previous session was aborted before the new one starts.
-      this->parent_->notify_state_deferred_(ota::OTA_ABORT, 0.0f, 0);
-#endif
-      this->ota_backend_.reset();
-    }
-
+  if (index == 0 && !this->ota_backend_) {
    // Initialize OTA on first call
    this->ota_init_(filename.c_str());

@@ -99,6 +99,7 @@ int main() {
  setup();
  while (true) {
    loop();
+    esphome::yield();
  }
  return 0;
 }
@@ -85,12 +85,8 @@ void Application::setup() {
    if (component->can_proceed())
      continue;

-    // Force the status LED to blink WARNING while we wait for a slow
-    // component to come up. Cleared after setup() finishes if no real
-    // component has warning set.
-    this->app_state_ |= STATUS_LED_WARNING;
-
    do {
+      uint8_t new_app_state = STATUS_LED_WARNING;
      uint32_t now = millis();

      // Process pending loop enables to handle GPIO interrupts during setup
@@ -100,26 +96,17 @@ void Application::setup() {
        // Update loop_component_start_time_ right before calling each component
        this->loop_component_start_time_ = millis();
        this->components_[j]->call();
+        new_app_state |= this->components_[j]->get_component_state();
+        this->app_state_ |= new_app_state;
        this->feed_wdt();
      }

      this->after_loop_tasks_();
+      this->app_state_ = new_app_state;
      yield();
    } while (!component->can_proceed() && !component->is_failed());
  }

-  // Setup is complete. Reconcile STATUS_LED_WARNING: the slow-setup path
-  // above may have forced it on, and any status_clear_warning() calls
-  // from components during setup were intentional no-ops (gated by
-  // APP_STATE_SETUP_COMPLETE). Walk components once here to pick up the
-  // real state. STATUS_LED_ERROR is never artificially forced, so its
-  // clear path always works and needs no reconciliation. Finally, set
-  // APP_STATE_SETUP_COMPLETE so subsequent warning clears go through
-  // the normal walk-and-clear path.
-  if (!this->any_component_has_status_flag_(STATUS_LED_WARNING))
-    this->app_state_ &= ~STATUS_LED_WARNING;
-  this->app_state_ |= APP_STATE_SETUP_COMPLETE;
-
  ESP_LOGI(TAG, "setup() finished successfully!");

 #ifdef USE_SETUP_PRIORITY_OVERRIDE
@@ -209,40 +196,21 @@ void Application::process_dump_config_() {
  this->dump_config_at_++;
 }

-void Application::feed_wdt() {
-  // Cold entry: callers without a millis() timestamp in hand. Fetches the
-  // time and takes the same rate-limit path as feed_wdt_with_time().
-  uint32_t now = millis();
-  if (now - this->last_wdt_feed_ > WDT_FEED_INTERVAL_MS) {
-    this->feed_wdt_slow_(now);
-  }
-}
-
-void HOT Application::feed_wdt_slow_(uint32_t time) {
-  // Callers (both feed_wdt() and feed_wdt_with_time()) have already
-  // confirmed the WDT_FEED_INTERVAL_MS rate limit was exceeded.
-  arch_feed_wdt();
-  this->last_wdt_feed_ = time;
+void HOT Application::feed_wdt(uint32_t time) {
+  static uint32_t last_feed = 0;
+  // Use provided time if available, otherwise get current time
+  uint32_t now = time ? time : millis();
+  // Compare in milliseconds (3ms threshold)
+  if (now - last_feed > 3) {
+    arch_feed_wdt();
+    last_feed = now;
 #ifdef USE_STATUS_LED
-  if (status_led::global_status_led != nullptr) {
-    status_led::global_status_led->call();
-  }
+    if (status_led::global_status_led != nullptr) {
+      status_led::global_status_led->call();
+    }
 #endif
-}
-
-bool Application::any_component_has_status_flag_(uint8_t flag) const {
-  // Walk all components (not just looping ones) so non-looping components'
-  // status bits are respected. Only called from the slow-path clear helpers
-  // (status_clear_warning_slow_path_ / status_clear_error_slow_path_) on an
-  // actual set→clear transition, so walking O(N) here is paid once per
-  // transition — not once per loop iteration.
-  for (auto *component : this->components_) {
-    if ((component->get_component_state() & flag) != 0)
-      return true;
  }
-  return false;
 }
-
 void Application::reboot() {
  ESP_LOGI(TAG, "Forcing a reboot");
  for (auto &component : std::ranges::reverse_view(this->components_)) {
@@ -331,7 +299,7 @@ void Application::teardown_components(uint32_t timeout_ms) {

  while (pending_count > 0 && (now - start_time) < timeout_ms) {
    // Feed watchdog during teardown to prevent triggering
-    this->feed_wdt_with_time(now);
+    this->feed_wdt(now);

    // Process components and compact the array, keeping only those still pending
    size_t still_pending = 0;
@@ -385,24 +385,7 @@ class Application {

  void schedule_dump_config() { this->dump_config_at_ = 0; }

-  /// Minimum interval between real arch_feed_wdt() calls. Chosen to keep the
-  /// rate of HAL pokes low while still being small enough that any plausible
-  /// watchdog timeout (seconds) has orders of magnitude of safety margin.
-  static constexpr uint32_t WDT_FEED_INTERVAL_MS = 3;
-
-  /// Feed the task watchdog. Cold entry — callers without a millis()
-  /// timestamp in hand. Out of line to keep call sites tiny.
-  void feed_wdt();
-
-  /// Feed the task watchdog, hot entry. Callers that already have a
-  /// millis() timestamp pay only a load + sub + branch on the common
-  /// (no-op) path. The actual arch feed + status LED update live in
-  /// feed_wdt_slow_.
-  void ESPHOME_ALWAYS_INLINE feed_wdt_with_time(uint32_t time) {
-    if (static_cast<uint32_t>(time - this->last_wdt_feed_) > WDT_FEED_INTERVAL_MS) [[unlikely]] {
-      this->feed_wdt_slow_(time);
-    }
-  }
+  void feed_wdt(uint32_t time = 0);

  void reboot();

@@ -418,18 +401,7 @@ class Application {
   */
  void teardown_components(uint32_t timeout_ms);

-  /// Return the public app state status bits (STATUS_LED_* only).
-  /// Internal bookkeeping bits like APP_STATE_SETUP_COMPLETE are masked
-  /// out so external readers (status_led components, etc.) never see them.
-  uint8_t get_app_state() const { return this->app_state_ & ~APP_STATE_SETUP_COMPLETE; }
-
-  /// True once Application::setup() has finished walking all components
-  /// and finalized the initial status flags. Before this point, the
-  /// slow-setup busy-wait may be forcing STATUS_LED_WARNING on, and
-  /// status_clear_* intentionally skips its walk-and-clear step so the
-  /// forced bit doesn't get wiped. Stored as a free bit on app_state_
-  /// (bit 6) to avoid costing additional RAM.
-  bool is_setup_complete() const { return (this->app_state_ & APP_STATE_SETUP_COMPLETE) != 0; }
+  uint8_t get_app_state() const { return this->app_state_; }

 // Helper macro for entity getter method declarations
 #ifdef USE_DEVICES
@@ -605,12 +577,6 @@ class Application {
  bool is_socket_ready_(int fd) const { return FD_ISSET(fd, &this->read_fds_); }
 #endif

-  /// Walk all registered components looking for any whose component_state_
-  /// has the given flag set. Used by Component::status_clear_*_slow_path_()
-  /// (which is a friend) to decide whether to clear the corresponding bit on
-  /// this->app_state_ (the app-wide "any component has this status" indicator).
-  bool any_component_has_status_flag_(uint8_t flag) const;
-
  /// Register a component, detecting loop() override at compile time.
  /// Uses HasLoopOverride<T> which handles ambiguous &T::loop from multiple inheritance.
  template<typename T> void register_component_(T *comp) {
@@ -649,10 +615,7 @@ class Application {
  /// Caller must ensure dump_config_at_ < components_.size().
  void __attribute__((noinline)) process_dump_config_();

-  /// Slow path for feed_wdt(): actually calls arch_feed_wdt(), updates
-  /// last_wdt_feed_, and re-dispatches the status LED. Out of line so the
-  /// inline wrapper stays tiny.
-  void feed_wdt_slow_(uint32_t time);
+  void feed_wdt_arch_();

  /// Perform a delay while also monitoring socket file descriptors for readiness
 #ifdef USE_HOST
@@ -706,7 +669,6 @@ class Application {
  // 4-byte members
  uint32_t last_loop_{0};
  uint32_t loop_component_start_time_{0};
-  uint32_t last_wdt_feed_{0};  // millis() of most recent arch_feed_wdt(); rate-limits feed_wdt() hot path

 #ifdef USE_HOST
  int max_fd_{-1};  // Highest file descriptor number for select()
@@ -851,13 +813,12 @@ inline void ESPHOME_ALWAYS_INLINE Application::before_loop_tasks_(uint32_t loop_
  this->drain_wake_notifications_();
 #endif

-  // Process scheduled tasks. Scheduler::call now feeds the watchdog itself
-  // after each scheduled item that actually runs, so we no longer need an
-  // unconditional feed here — when Scheduler::call has no work to do, the
-  // only elapsed time is a sleep wake + a few instructions, and when it does
-  // have work, it fed the wdt as it went.
+  // Process scheduled tasks
  this->scheduler.call(loop_start_time);

+  // Feed the watchdog timer
+  this->feed_wdt(loop_start_time);
+
  // Process any pending enable_loop requests from ISRs
  // This must be done before marking in_loop_ = true to avoid race conditions
  if (this->has_pending_enable_loop_requests_) {
@@ -877,6 +838,8 @@ inline void ESPHOME_ALWAYS_INLINE Application::before_loop_tasks_(uint32_t loop_
 }

 inline void ESPHOME_ALWAYS_INLINE Application::loop() {
+  uint8_t new_app_state = 0;
+
  // Get the initial loop time at the start
  uint32_t last_op_end_time = millis();

@@ -896,10 +859,13 @@ inline void ESPHOME_ALWAYS_INLINE Application::loop() {
      // Use the finish method to get the current time as the end time
      last_op_end_time = guard.finish();
    }
-    this->feed_wdt_with_time(last_op_end_time);
+    new_app_state |= component->get_component_state();
+    this->app_state_ |= new_app_state;
+    this->feed_wdt(last_op_end_time);
  }

  this->after_loop_tasks_();
+  this->app_state_ = new_app_state;

 #ifdef USE_RUNTIME_STATS
  // Process any pending runtime stats printing after all components have run
@@ -411,23 +411,10 @@ void Component::status_set_error(const LogString *message) {
 }
 void Component::status_clear_warning_slow_path_() {
  this->component_state_ &= ~STATUS_LED_WARNING;
-  // Clear the app-wide STATUS_LED_WARNING bit only if setup has finished
-  // AND no other component still has it set. During setup the forced
-  // STATUS_LED_WARNING (from the slow-setup busy-wait) must not be wiped
-  // by a transient component clear — Application::setup() reconciles
-  // the warning bit once at the end before setting APP_STATE_SETUP_COMPLETE.
-  // The set path is unchanged (set_status_flag_ still writes directly).
-  if (App.is_setup_complete() && !App.any_component_has_status_flag_(STATUS_LED_WARNING))
-    App.app_state_ &= ~STATUS_LED_WARNING;
  ESP_LOGW(TAG, "%s cleared Warning flag", LOG_STR_ARG(this->get_component_log_str()));
 }
 void Component::status_clear_error_slow_path_() {
  this->component_state_ &= ~STATUS_LED_ERROR;
-  // STATUS_LED_ERROR is never artificially forced — it only ever lands
-  // in app_state_ via a real set_status_flag_ call. So the walk-and-clear
-  // path is always safe, including during setup.
-  if (!App.any_component_has_status_flag_(STATUS_LED_ERROR))
-    App.app_state_ &= ~STATUS_LED_ERROR;
  ESP_LOGE(TAG, "%s cleared Error flag", LOG_STR_ARG(this->get_component_log_str()));
 }
 void Component::status_momentary_warning(const char *name, uint32_t length) {
@@ -89,11 +89,6 @@ inline constexpr uint8_t STATUS_LED_WARNING = 0x08;
 inline constexpr uint8_t STATUS_LED_ERROR = 0x10;
 // Component loop override flag uses bit 5 (set at registration time)
 inline constexpr uint8_t COMPONENT_HAS_LOOP = 0x20;
-// Bit 6 on Application::app_state_ (ONLY) — set at the end of
-// Application::setup(). Component::status_clear_*_slow_path_() uses this to
-// decide whether to propagate clears to App.app_state_. Never set on a
-// Component's component_state_.
-inline constexpr uint8_t APP_STATE_SETUP_COMPLETE = 0x40;
 // Remove before 2026.8.0
 enum class RetryResult { DONE, RETRY };

@@ -347,18 +347,17 @@ std::string format_mac_address_pretty(const uint8_t *mac) {
  return std::string(buf);
 }

-// Internal helper for hex formatting - base is 'a' for lowercase or 'A' for uppercase.
-// When separator is set, it is written unconditionally after each byte and the last
-// one is overwritten with '\0', eliminating the per-byte `i < length - 1` check.
+// Internal helper for hex formatting - base is 'a' for lowercase or 'A' for uppercase
 static char *format_hex_internal(char *buffer, size_t buffer_size, const uint8_t *data, size_t length, char separator,
                                 char base) {
-  if (length == 0 || buffer_size == 0) {
-    if (buffer_size > 0)
-      buffer[0] = '\0';
+  if (length == 0) {
+    buffer[0] = '\0';
    return buffer;
  }
+  // With separator: total length is 3*length (2*length hex chars, (length-1) separators, 1 null terminator)
+  // Without separator: total length is 2*length + 1 (2*length hex chars, 1 null terminator)
  uint8_t stride = separator ? 3 : 2;
-  size_t max_bytes = separator ? (buffer_size / 3) : ((buffer_size - 1) / 2);
+  size_t max_bytes = separator ? (buffer_size / stride) : ((buffer_size - 1) / stride);
  if (max_bytes == 0) {
    buffer[0] = '\0';
    return buffer;
@@ -370,30 +369,14 @@ static char *format_hex_internal(char *buffer, size_t buffer_size, const uint8_t
    size_t pos = i * stride;
    buffer[pos] = format_hex_char(data[i] >> 4, base);
    buffer[pos + 1] = format_hex_char(data[i] & 0x0F, base);
-    if (separator) {
+    if (separator && i < length - 1) {
      buffer[pos + 2] = separator;
    }
  }
-  // With separator: overwrite last separator with '\0'
-  // Without: write '\0' after last hex char
  buffer[length * stride - (separator ? 1 : 0)] = '\0';
  return buffer;
 }

-char *uint32_to_str_unchecked(char *buf, uint32_t val) {
-  if (val == 0) {
-    *buf++ = '0';
-    return buf;
-  }
-  char *start = buf;
-  while (val > 0) {
-    *buf++ = '0' + (val % 10);
-    val /= 10;
-  }
-  std::reverse(start, buf);
-  return buf;
-}
-
 char *format_hex_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length) {
  return format_hex_internal(buffer, buffer_size, data, length, 0, 'a');
 }
@@ -1263,13 +1263,13 @@ constexpr uint8_t parse_hex_char(char c) {
 }

 /// Convert a nibble (0-15) to hex char with specified base ('a' for lowercase, 'A' for uppercase)
-ESPHOME_ALWAYS_INLINE inline char format_hex_char(uint8_t v, char base) { return v >= 10 ? base + (v - 10) : '0' + v; }
+inline char format_hex_char(uint8_t v, char base) { return v >= 10 ? base + (v - 10) : '0' + v; }

 /// Convert a nibble (0-15) to lowercase hex char
-ESPHOME_ALWAYS_INLINE inline char format_hex_char(uint8_t v) { return format_hex_char(v, 'a'); }
+inline char format_hex_char(uint8_t v) { return format_hex_char(v, 'a'); }

 /// Convert a nibble (0-15) to uppercase hex char (used for pretty printing)
-ESPHOME_ALWAYS_INLINE inline char format_hex_pretty_char(uint8_t v) { return format_hex_char(v, 'A'); }
+inline char format_hex_pretty_char(uint8_t v) { return format_hex_char(v, 'A'); }

 /// Write int8 value to buffer without modulo operations.
 /// Buffer must have at least 4 bytes free. Returns pointer past last char written.
@@ -1295,21 +1295,6 @@ inline char *int8_to_str(char *buf, int8_t val) {
  return buf;
 }

-/// Minimum buffer size for uint32_to_str: 10 digits + null terminator.
-static constexpr size_t UINT32_MAX_STR_SIZE = 11;
-
-/// Write unsigned 32-bit integer to buffer (internal, no size check).
-/// Buffer must have at least 10 bytes free. Returns pointer past last char written.
-char *uint32_to_str_unchecked(char *buf, uint32_t val);
-
-/// Write unsigned 32-bit integer to buffer with compile-time size check.
-/// Null-terminates the output. Returns number of chars written (excluding null).
-inline size_t uint32_to_str(std::span<char, UINT32_MAX_STR_SIZE> buf, uint32_t val) {
-  char *end = uint32_to_str_unchecked(buf.data(), val);
-  *end = '\0';
-  return static_cast<size_t>(end - buf.data());
-}
-
 /// Format byte array as lowercase hex to buffer (base implementation).
 char *format_hex_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length);

@@ -739,13 +739,7 @@ uint32_t HOT Scheduler::execute_item_(SchedulerItem *item, uint32_t now) {
  App.set_current_component(item->component);
  WarnIfComponentBlockingGuard guard{item->component, now};
  item->callback();
-  uint32_t end = guard.finish();
-  // Feed the watchdog after each scheduled item (both main heap and defer
-  // queue paths go through here). A run of back-to-back callbacks cannot
-  // starve the wdt. The inline fast path is a load + sub + branch — nearly
-  // free when the 3 ms rate limit hasn't elapsed.
-  App.feed_wdt_with_time(end);
-  return end;
+  return guard.finish();
 }

 // Common implementation for cancel operations - handles locking
@@ -138,7 +138,7 @@ class Scheduler {
  // (single-threaded). This is safe because the main loop is the only thread
  // that reads to_add_ without holding lock_; other threads may read it only
  // while holding the mutex (e.g. cancel_item_locked_).
-  inline void ESPHOME_ALWAYS_INLINE HOT process_to_add() {
+  inline void HOT process_to_add() {
    if (this->to_add_empty_())
      return;
    this->process_to_add_slow_path_();
@@ -302,7 +302,7 @@ class Scheduler {
  // loop thread structurally modifies items_ (push/pop/erase). Other threads may
  // iterate items_ and mark items removed under lock_, but never change the
  // vector's size or data pointer.
-  inline bool ESPHOME_ALWAYS_INLINE HOT cleanup_() {
+  inline bool HOT cleanup_() {
    if (this->to_remove_empty_())
      return !this->items_.empty();
    return this->cleanup_slow_path_();
@@ -407,7 +407,7 @@ class Scheduler {
  // Process defer queue for FIFO execution of deferred items.
  // IMPORTANT: This method should only be called from the main thread (loop task).
  // Inlined: the fast path (nothing deferred) is just an atomic load check.
-  inline void ESPHOME_ALWAYS_INLINE HOT process_defer_queue_(uint32_t &now) {
+  inline void HOT process_defer_queue_(uint32_t &now) {
    // Fast path: nothing to process, avoid lock entirely.
    // Worst case is a one-loop-iteration delay before newly deferred items are processed.
    if (this->defer_empty_())
@@ -113,8 +113,7 @@ def _generate_source_table_code(
    entries = ", ".join(var_names)
    lines.append(f"static const char *const {table_var}[] PROGMEM = {{{entries}}};")
    lines.append(f"const LogString *{lookup_fn}(uint8_t index) {{")
-    cond = "index == 0" if count >= 255 else f"index == 0 || index > {count}"
-    lines.append(f'  if ({cond}) return LOG_STR("<unknown>");')
+    lines.append(f'  if (index == 0 || index > {count}) return LOG_STR("<unknown>");')
    lines.append("  return reinterpret_cast<const LogString *>(")
    lines.append(f"    progmem_read_ptr(&{table_var}[index - 1]));")
    lines.append("}")
@@ -3,8 +3,6 @@ dependencies:
    version: "7.4.2"
  esphome/esp-audio-libs:
    version: 2.0.4
-  esphome/micro-decoder:
-    version: 0.1.1
  esphome/micro-flac:
    version: 0.1.1
  esphome/micro-opus:
@@ -14,6 +14,45 @@ from esphome.util import run_external_process
 _LOGGER = logging.getLogger(__name__)


+IGNORE_LIB_WARNINGS = f"(?:{'|'.join(['Hash', 'Update'])})"
+FILTER_PLATFORMIO_LINES = [
+    r"Verbose mode can be enabled via `-v, --verbose` option.*",
+    r"CONFIGURATION: https://docs.platformio.org/.*",
+    r"DEBUG: Current.*",
+    r"LDF Modes:.*",
+    r"LDF: Library Dependency Finder -> https://bit.ly/configure-pio-ldf.*",
+    f"Looking for {IGNORE_LIB_WARNINGS} library in registry",
+    f"Warning! Library `.*'{IGNORE_LIB_WARNINGS}.*` has not been found in PlatformIO Registry.",
+    f"You can ignore this message, if `.*{IGNORE_LIB_WARNINGS}.*` is a built-in library.*",
+    r"Scanning dependencies...",
+    r"Found \d+ compatible libraries",
+    r"Memory Usage -> https://bit.ly/pio-memory-usage",
+    r"Found: https://platformio.org/lib/show/.*",
+    r"Using cache: .*",
+    r"Installing dependencies",
+    r"Library Manager: Already installed, built-in library",
+    r"Building in .* mode",
+    r"Advanced Memory Usage is available via .*",
+    r"Merged .* ELF section",
+    r"esptool.py v.*",
+    r"esptool v.*",
+    r"Checking size .*",
+    r"Retrieving maximum program size .*",
+    r"PLATFORM: .*",
+    r"PACKAGES:.*",
+    r" - framework-arduinoespressif.* \(.*\)",
+    r" - tool-esptool.* \(.*\)",
+    r" - toolchain-.* \(.*\)",
+    r"Creating BIN file .*",
+    r"Warning! Could not find file \".*.crt\"",
+    r"Warning! Arduino framework as an ESP-IDF component doesn't handle the `variant` field! The default `esp32` variant will be used.",
+    r"Warning: DEPRECATED: 'esptool.py' is deprecated. Please use 'esptool' instead. The '.py' suffix will be removed in a future major release.",
+    r"Warning: esp-idf-size exited with code 2",
+    r"esp_idf_size: error: unrecognized arguments: --ng",
+    r"Package configuration completed successfully",
+]
+
+
 def run_platformio_cli(*args, **kwargs) -> str | int:
    os.environ["PLATFORMIO_FORCE_COLOR"] = "true"
    os.environ["PLATFORMIO_BUILD_DIR"] = str(CORE.relative_pioenvs_path().absolute())
@@ -26,6 +65,9 @@ def run_platformio_cli(*args, **kwargs) -> str | int:
    os.environ.setdefault("UV_HTTP_RETRIES", "10")
    cmd = [sys.executable, "-m", "esphome.platformio_runner"] + list(args)

+    if not CORE.verbose:
+        kwargs["filter_lines"] = FILTER_PLATFORMIO_LINES
+
    return run_external_process(*cmd, **kwargs)


@@ -101,83 +101,10 @@ def patch_file_downloader() -> None:
    FileDownloader.__init__ = patched_init


-_IGNORE_LIB_WARNINGS = f"(?:{'|'.join(['Hash', 'Update'])})"
-# Regex patterns matched against each line of PlatformIO output. Lines that
-# match are dropped by RedirectText before they reach the parent process.
-# Patterns are anchored at the start of the line (RedirectText uses
-# ``re.match``). Disabled when the user passes ``-v`` / ``--verbose`` to
-# ``esphome compile``.
-FILTER_PLATFORMIO_LINES = [
-    r"Verbose mode can be enabled via `-v, --verbose` option.*",
-    r"CONFIGURATION: https://docs.platformio.org/.*",
-    r"DEBUG: Current.*",
-    r"LDF Modes:.*",
-    r"LDF: Library Dependency Finder -> https://bit.ly/configure-pio-ldf.*",
-    f"Looking for {_IGNORE_LIB_WARNINGS} library in registry",
-    f"Warning! Library `.*'{_IGNORE_LIB_WARNINGS}.*` has not been found in PlatformIO Registry.",
-    f"You can ignore this message, if `.*{_IGNORE_LIB_WARNINGS}.*` is a built-in library.*",
-    r"Scanning dependencies...",
-    r"Found \d+ compatible libraries",
-    r"Memory Usage -> https://bit.ly/pio-memory-usage",
-    r"Found: https://platformio.org/lib/show/.*",
-    r"Using cache: .*",
-    r"Installing dependencies",
-    r"Library Manager: Already installed, built-in library",
-    r"Building in .* mode",
-    r"Advanced Memory Usage is available via .*",
-    r"Merged .* ELF section",
-    r"esptool.py v.*",
-    r"esptool v.*",
-    r"Checking size .*",
-    r"Retrieving maximum program size .*",
-    r"PLATFORM: .*",
-    r"PACKAGES:.*",
-    r" - framework-arduinoespressif.* \(.*\)",
-    r" - tool-esptool.* \(.*\)",
-    r" - toolchain-.* \(.*\)",
-    r"Creating BIN file .*",
-    r"Warning! Could not find file \".*.crt\"",
-    r"Warning! Arduino framework as an ESP-IDF component doesn't handle the `variant` field! The default `esp32` variant will be used.",
-    r"Warning: DEPRECATED: 'esptool.py' is deprecated. Please use 'esptool' instead. The '.py' suffix will be removed in a future major release.",
-    r"Warning: esp-idf-size exited with code 2",
-    r"esp_idf_size: error: unrecognized arguments: --ng",
-    r"Package configuration completed successfully",
-]
-
-
 def main() -> int:
    patch_structhash()
    patch_file_downloader()

-    # Wrap stdout/stderr with RedirectText before PlatformIO runs:
-    #
-    # 1. RedirectText.isatty() unconditionally returns True. Click, tqdm, and
-    #    PlatformIO's own progress-bar code check ``stream.isatty()`` to
-    #    decide whether to emit TTY-format output (``\r`` cursor moves, ANSI
-    #    colors, fancy progress bars). With the wrapper in place they always
-    #    emit TTY format, even when our real stdout is a pipe to the parent
-    #    process. Downstream consumers (local terminals and the Home
-    #    Assistant dashboard log viewer) render the TTY control sequences
-    #    correctly, so the user sees real progress bars.
-    #
-    # 2. FILTER_PLATFORMIO_LINES is applied inside RedirectText.write() in
-    #    this subprocess, so noisy PlatformIO output is dropped before it
-    #    ever leaves the runner. This replaces the parent-side filtering
-    #    that was lost when we switched from in-process to subprocess — the
-    #    parent's ``subprocess.run`` uses ``.fileno()`` on RedirectText and
-    #    bypasses its ``write()`` path entirely.
-    #
-    # Filtering is disabled when the user passed -v / --verbose to
-    # ``esphome compile``, preserving the previous in-process behavior where
-    # verbose mode let all PlatformIO output through unfiltered.
-    from esphome.util import RedirectText
-
-    is_verbose = any(arg in ("-v", "--verbose") for arg in sys.argv[1:])
-    filter_lines = None if is_verbose else FILTER_PLATFORMIO_LINES
-
-    sys.stdout = RedirectText(sys.stdout, filter_lines=filter_lines)
-    sys.stderr = RedirectText(sys.stderr, filter_lines=filter_lines)
-
    import platformio.__main__

    return platformio.__main__.main() or 0
@@ -83,7 +83,7 @@ lib_deps =
    fastled/FastLED@3.9.16                                ; fastled_base
    freekode/TM1651@1.0.1                                 ; tm1651
    dudanov/MideaUART@1.1.9                               ; midea
-    tonia/HeatpumpIR@1.0.41                               ; heatpumpir
+    tonia/HeatpumpIR@1.0.40                               ; heatpumpir
 build_flags =
    ${common.build_flags}
    -DUSE_ARDUINO
@@ -133,7 +133,7 @@ extra_scripts = post:esphome/components/esp8266/post_build.py.script
 ; This are common settings for the ESP32 (all variants) using Arduino.
 [common:esp32-arduino]
 extends = common:arduino
-platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.38-1/platform-espressif32.zip
+platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.38/platform-espressif32.zip
 platform_packages =
    pioarduino/framework-arduinoespressif32@https://github.com/espressif/arduino-esp32/releases/download/3.3.8/esp32-core-3.3.8.tar.xz
    pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v5.5.4/esp-idf-v5.5.4.tar.xz
@@ -169,7 +169,7 @@ extra_scripts = post:esphome/components/esp32/post_build.py.script
 ; This are common settings for the ESP32 (all variants) using IDF.
 [common:esp32-idf]
 extends = common:idf
-platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.38-1/platform-espressif32.zip
+platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.38/platform-espressif32.zip
 platform_packages =
    pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v5.5.4/esp-idf-v5.5.4.tar.xz

@@ -178,7 +178,7 @@ lib_deps =
    ${common:idf.lib_deps}
    droscy/esp_wireguard@0.4.4              ; wireguard
    kahrendt/ESPMicroSpeechFeatures@1.1.0   ; micro_wake_word
-    tonia/HeatpumpIR@1.0.41                 ; heatpumpir
+    tonia/HeatpumpIR@1.0.40                 ; heatpumpir
 build_flags =
    ${common:idf.build_flags}
    -Wno-nonnull-compare
@@ -12,7 +12,7 @@ platformio==6.1.19
 esptool==5.2.0
 click==8.3.2
 esphome-dashboard==20260408.1
-aioesphomeapi==44.15.0
+aioesphomeapi==44.13.3
 zeroconf==0.148.0
 puremagic==1.30
 ruamel.yaml==0.19.1 # dashboard_import
@@ -1028,8 +1028,7 @@ class BytesType(TypeInfo):
        )

    def get_size_calculation(self, name: str, force: bool = False) -> str:
-        calc_fn = "calc_length_force" if force else "calc_length"
-        return f"size += ProtoSize::{calc_fn}({self.calculate_field_id_size()}, this->{self.field_name}_len_);"
+        return f"size += ProtoSize::calc_length({self.calculate_field_id_size()}, this->{self.field_name}_len_);"

    def get_estimated_size(self) -> int:
        return self.calculate_field_id_size() + 8  # field ID + 8 bytes typical bytes
@@ -1110,8 +1109,7 @@ class PointerToBytesBufferType(PointerToBufferTypeBase):
        )

    def get_size_calculation(self, name: str, force: bool = False) -> str:
-        calc_fn = "calc_length_force" if force else "calc_length"
-        return f"size += ProtoSize::{calc_fn}({self.calculate_field_id_size()}, this->{self.field_name}_len);"
+        return f"size += ProtoSize::calc_length({self.calculate_field_id_size()}, this->{self.field_name}_len);"


 class PointerToStringBufferType(PointerToBufferTypeBase):
@@ -2684,12 +2682,9 @@ def build_message_type(
    # Check if this message wants speed-optimized encode/calculate_size.
    # When set, __attribute__((optimize("O2"))) is added to the definitions
    # so GCC inlines the small ProtoEncode helpers even under -Os.
-    is_speed_optimized = get_opt(desc, pb.speed_optimized, False)
-    speed_attr = (
-        '__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)\n'
-        if is_speed_optimized
-        else ""
-    )
+    speed_opt = getattr(pb, "speed_optimized", None)
+    is_speed_optimized = speed_opt is not None and get_opt(desc, speed_opt, False)
+    speed_attr = '__attribute__((optimize("O2"))) ' if is_speed_optimized else ""

    # Only generate encode method if this message needs encoding and has fields
    if needs_encode and encode and not is_inline_only:
@@ -1,118 +0,0 @@
-#include <benchmark/benchmark.h>
-
-#include "esphome/components/api/api_pb2.h"
-#include "esphome/components/api/api_buffer.h"
-
-namespace esphome::api::benchmarks {
-
-// Inner iteration count to amortize CodSpeed instrumentation overhead.
-static constexpr int kInnerIterations = 2000;
-
-// Typical log line: "[12:34:56][D][sensor:094]: 'Temperature': Sending state 23.50000 with 1 decimals of accuracy"
-static constexpr const char *kTypicalLogLine =
-    "[12:34:56][D][sensor:094]: 'Temperature': Sending state 23.50000 with 1 decimals of accuracy";
-
-// Short log line: "[12:34:56][I][app:029]: Running..."
-static constexpr const char *kShortLogLine = "[12:34:56][I][app:029]: Running...";
-
-// --- Encode ---
-
-static void Encode_LogResponse_Typical(benchmark::State &state) {
-  APIBuffer buffer;
-  SubscribeLogsResponse msg;
-  msg.level = enums::LOG_LEVEL_DEBUG;
-  msg.set_message(reinterpret_cast<const uint8_t *>(kTypicalLogLine), strlen(kTypicalLogLine));
-  uint32_t size = msg.calculate_size();
-  buffer.resize(size);
-
-  for (auto _ : state) {
-    for (int i = 0; i < kInnerIterations; i++) {
-      ProtoWriteBuffer writer(&buffer, 0);
-      msg.encode(writer);
-    }
-    benchmark::DoNotOptimize(buffer.data());
-  }
-  state.SetItemsProcessed(state.iterations() * kInnerIterations);
-}
-BENCHMARK(Encode_LogResponse_Typical);
-
-static void Encode_LogResponse_Short(benchmark::State &state) {
-  APIBuffer buffer;
-  SubscribeLogsResponse msg;
-  msg.level = enums::LOG_LEVEL_INFO;
-  msg.set_message(reinterpret_cast<const uint8_t *>(kShortLogLine), strlen(kShortLogLine));
-  uint32_t size = msg.calculate_size();
-  buffer.resize(size);
-
-  for (auto _ : state) {
-    for (int i = 0; i < kInnerIterations; i++) {
-      ProtoWriteBuffer writer(&buffer, 0);
-      msg.encode(writer);
-    }
-    benchmark::DoNotOptimize(buffer.data());
-  }
-  state.SetItemsProcessed(state.iterations() * kInnerIterations);
-}
-BENCHMARK(Encode_LogResponse_Short);
-
-// --- Calculate Size ---
-
-static void CalculateSize_LogResponse_Typical(benchmark::State &state) {
-  SubscribeLogsResponse msg;
-  msg.level = enums::LOG_LEVEL_DEBUG;
-  msg.set_message(reinterpret_cast<const uint8_t *>(kTypicalLogLine), strlen(kTypicalLogLine));
-
-  for (auto _ : state) {
-    uint32_t result = 0;
-    for (int i = 0; i < kInnerIterations; i++) {
-      result += msg.calculate_size();
-    }
-    benchmark::DoNotOptimize(result);
-  }
-  state.SetItemsProcessed(state.iterations() * kInnerIterations);
-}
-BENCHMARK(CalculateSize_LogResponse_Typical);
-
-// --- Calc + Encode (steady state) ---
-
-static void CalcAndEncode_LogResponse_Typical(benchmark::State &state) {
-  APIBuffer buffer;
-  SubscribeLogsResponse msg;
-  msg.level = enums::LOG_LEVEL_DEBUG;
-  msg.set_message(reinterpret_cast<const uint8_t *>(kTypicalLogLine), strlen(kTypicalLogLine));
-
-  for (auto _ : state) {
-    for (int i = 0; i < kInnerIterations; i++) {
-      uint32_t size = msg.calculate_size();
-      buffer.resize(size);
-      ProtoWriteBuffer writer(&buffer, 0);
-      msg.encode(writer);
-    }
-    benchmark::DoNotOptimize(buffer.data());
-  }
-  state.SetItemsProcessed(state.iterations() * kInnerIterations);
-}
-BENCHMARK(CalcAndEncode_LogResponse_Typical);
-
-// --- Calc + Encode (fresh allocation each time) ---
-
-static void CalcAndEncode_LogResponse_Typical_Fresh(benchmark::State &state) {
-  SubscribeLogsResponse msg;
-  msg.level = enums::LOG_LEVEL_DEBUG;
-  msg.set_message(reinterpret_cast<const uint8_t *>(kTypicalLogLine), strlen(kTypicalLogLine));
-
-  for (auto _ : state) {
-    for (int i = 0; i < kInnerIterations; i++) {
-      APIBuffer buffer;
-      uint32_t size = msg.calculate_size();
-      buffer.resize(size);
-      ProtoWriteBuffer writer(&buffer, 0);
-      msg.encode(writer);
-      benchmark::DoNotOptimize(buffer.data());
-    }
-  }
-  state.SetItemsProcessed(state.iterations() * kInnerIterations);
-}
-BENCHMARK(CalcAndEncode_LogResponse_Typical_Fresh);
-
-}  // namespace esphome::api::benchmarks
@@ -1,6 +1,4 @@
 #include <benchmark/benchmark.h>
-#include <cinttypes>
-#include <cstdio>

 #include "esphome/core/helpers.h"

@@ -309,58 +307,4 @@ static void Base64Decode_32Bytes(benchmark::State &state) {
 }
 BENCHMARK(Base64Decode_32Bytes);

-// --- uint32_to_str() vs snprintf ---
-
-static void Uint32ToStr_Small(benchmark::State &state) {
-  char buf[UINT32_MAX_STR_SIZE];
-  for (auto _ : state) {
-    for (int i = 0; i < kInnerIterations; i++) {
-      uint32_to_str(buf, 12345);
-      benchmark::DoNotOptimize(buf);
-      benchmark::ClobberMemory();
-    }
-  }
-  state.SetItemsProcessed(state.iterations() * kInnerIterations);
-}
-BENCHMARK(Uint32ToStr_Small);
-
-static void Snprintf_Uint32_Small(benchmark::State &state) {
-  char buf[UINT32_MAX_STR_SIZE];
-  for (auto _ : state) {
-    for (int i = 0; i < kInnerIterations; i++) {
-      snprintf(buf, sizeof(buf), "%" PRIu32, static_cast<uint32_t>(12345));
-      benchmark::DoNotOptimize(buf);
-      benchmark::ClobberMemory();
-    }
-  }
-  state.SetItemsProcessed(state.iterations() * kInnerIterations);
-}
-BENCHMARK(Snprintf_Uint32_Small);
-
-static void Uint32ToStr_Large(benchmark::State &state) {
-  char buf[UINT32_MAX_STR_SIZE];
-  for (auto _ : state) {
-    for (int i = 0; i < kInnerIterations; i++) {
-      uint32_to_str(buf, 4294967295u);
-      benchmark::DoNotOptimize(buf);
-      benchmark::ClobberMemory();
-    }
-  }
-  state.SetItemsProcessed(state.iterations() * kInnerIterations);
-}
-BENCHMARK(Uint32ToStr_Large);
-
-static void Snprintf_Uint32_Large(benchmark::State &state) {
-  char buf[UINT32_MAX_STR_SIZE];
-  for (auto _ : state) {
-    for (int i = 0; i < kInnerIterations; i++) {
-      snprintf(buf, sizeof(buf), "%" PRIu32, static_cast<uint32_t>(4294967295u));
-      benchmark::DoNotOptimize(buf);
-      benchmark::ClobberMemory();
-    }
-  }
-  state.SetItemsProcessed(state.iterations() * kInnerIterations);
-}
-BENCHMARK(Snprintf_Uint32_Large);
-
 }  // namespace esphome::benchmarks
@@ -1,120 +0,0 @@
-#include <gtest/gtest.h>
-#include <cstring>
-
-#include "esphome/core/helpers.h"
-
-namespace esphome::core::testing {
-
-// --- format_hex_to() ---
-
-TEST(FormatHexTo, Basic) {
-  const uint8_t data[] = {0xAB, 0xCD, 0xEF};
-  char buffer[7];  // 3 * 2 + 1
-  format_hex_to(buffer, data, 3);
-  EXPECT_STREQ(buffer, "abcdef");
-}
-
-TEST(FormatHexTo, SingleByte) {
-  const uint8_t data[] = {0x0F};
-  char buffer[3];
-  format_hex_to(buffer, data, 1);
-  EXPECT_STREQ(buffer, "0f");
-}
-
-TEST(FormatHexTo, ZeroLength) {
-  char buffer[4] = "xxx";
-  format_hex_to(buffer, static_cast<size_t>(sizeof(buffer)), static_cast<const uint8_t *>(nullptr), 0);
-  EXPECT_STREQ(buffer, "");
-}
-
-TEST(FormatHexTo, ZeroBufferSize) {
-  char buffer[4] = "xxx";
-  const uint8_t data[] = {0xAB};
-  format_hex_to(buffer, static_cast<size_t>(0), data, 1);
-  // Should not crash, buffer unchanged
-  EXPECT_EQ(buffer[0], 'x');
-}
-
-TEST(FormatHexTo, BufferTooSmall) {
-  const uint8_t data[] = {0xAB, 0xCD, 0xEF};
-  char buffer[5];  // only room for 2 bytes
-  format_hex_to(buffer, data, 3);
-  EXPECT_STREQ(buffer, "abcd");
-}
-
-TEST(FormatHexTo, MacAddress) {
-  const uint8_t mac[] = {0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF};
-  char buffer[13];
-  format_hex_to(buffer, mac, 6);
-  EXPECT_STREQ(buffer, "aabbccddeeff");
-}
-
-// --- format_hex_pretty_to() ---
-
-TEST(FormatHexPrettyTo, BasicColon) {
-  const uint8_t data[] = {0xAB, 0xCD, 0xEF};
-  char buffer[9];  // 3 * 3
-  format_hex_pretty_to(buffer, data, 3);
-  EXPECT_STREQ(buffer, "AB:CD:EF");
-}
-
-TEST(FormatHexPrettyTo, SingleByte) {
-  const uint8_t data[] = {0x0F};
-  char buffer[3];
-  format_hex_pretty_to(buffer, data, 1);
-  EXPECT_STREQ(buffer, "0F");
-}
-
-TEST(FormatHexPrettyTo, ZeroLength) {
-  char buffer[4] = "xxx";
-  format_hex_pretty_to(buffer, static_cast<size_t>(sizeof(buffer)), static_cast<const uint8_t *>(nullptr), 0);
-  EXPECT_STREQ(buffer, "");
-}
-
-TEST(FormatHexPrettyTo, ZeroBufferSize) {
-  char buffer[4] = "xxx";
-  const uint8_t data[] = {0xAB};
-  format_hex_pretty_to(buffer, static_cast<size_t>(0), data, 1);
-  EXPECT_EQ(buffer[0], 'x');
-}
-
-TEST(FormatHexPrettyTo, CustomSeparator) {
-  const uint8_t data[] = {0xAA, 0xBB, 0xCC};
-  char buffer[9];
-  format_hex_pretty_to(buffer, data, 3, '-');
-  EXPECT_STREQ(buffer, "AA-BB-CC");
-}
-
-// --- format_mac_addr_upper() ---
-
-TEST(FormatMacAddrUpper, Basic) {
-  const uint8_t mac[] = {0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF};
-  char buffer[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-  format_mac_addr_upper(mac, buffer);
-  EXPECT_STREQ(buffer, "AA:BB:CC:DD:EE:FF");
-}
-
-TEST(FormatMacAddrUpper, AllZeros) {
-  const uint8_t mac[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-  char buffer[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-  format_mac_addr_upper(mac, buffer);
-  EXPECT_STREQ(buffer, "00:00:00:00:00:00");
-}
-
-// --- format_hex_char() ---
-
-TEST(FormatHexChar, LowercaseDigits) {
-  EXPECT_EQ(format_hex_char(0), '0');
-  EXPECT_EQ(format_hex_char(9), '9');
-  EXPECT_EQ(format_hex_char(10), 'a');
-  EXPECT_EQ(format_hex_char(15), 'f');
-}
-
-TEST(FormatHexChar, UppercaseDigits) {
-  EXPECT_EQ(format_hex_pretty_char(0), '0');
-  EXPECT_EQ(format_hex_pretty_char(9), '9');
-  EXPECT_EQ(format_hex_pretty_char(10), 'A');
-  EXPECT_EQ(format_hex_pretty_char(15), 'F');
-}
-
-}  // namespace esphome::core::testing
@@ -1,77 +0,0 @@
-#include <gtest/gtest.h>
-
-#include "esphome/core/helpers.h"
-
-namespace esphome::core::testing {
-
-// --- uint32_to_str_unchecked() (internal, raw pointer) ---
-
-TEST(Uint32ToStr, InternalZero) {
-  char buf[UINT32_MAX_STR_SIZE];
-  char *end = uint32_to_str_unchecked(buf, 0);
-  *end = '\0';
-  EXPECT_STREQ(buf, "0");
-  EXPECT_EQ(end - buf, 1);
-}
-
-TEST(Uint32ToStr, InternalSingleDigit) {
-  char buf[UINT32_MAX_STR_SIZE];
-  char *end = uint32_to_str_unchecked(buf, 7);
-  *end = '\0';
-  EXPECT_STREQ(buf, "7");
-}
-
-TEST(Uint32ToStr, InternalMultiDigit) {
-  char buf[UINT32_MAX_STR_SIZE];
-  char *end = uint32_to_str_unchecked(buf, 12345);
-  *end = '\0';
-  EXPECT_STREQ(buf, "12345");
-  EXPECT_EQ(end - buf, 5);
-}
-
-TEST(Uint32ToStr, InternalMaxValue) {
-  char buf[UINT32_MAX_STR_SIZE];
-  char *end = uint32_to_str_unchecked(buf, 4294967295u);
-  *end = '\0';
-  EXPECT_STREQ(buf, "4294967295");
-  EXPECT_EQ(end - buf, 10);
-}
-
-TEST(Uint32ToStr, InternalPowersOfTen) {
-  char buf[UINT32_MAX_STR_SIZE];
-  char *end;
-
-  end = uint32_to_str_unchecked(buf, 10);
-  *end = '\0';
-  EXPECT_STREQ(buf, "10");
-
-  end = uint32_to_str_unchecked(buf, 100);
-  *end = '\0';
-  EXPECT_STREQ(buf, "100");
-
-  end = uint32_to_str_unchecked(buf, 1000000);
-  *end = '\0';
-  EXPECT_STREQ(buf, "1000000");
-}
-
-// --- uint32_to_str() (public, span API) ---
-
-TEST(Uint32ToStr, SpanZero) {
-  char buf[UINT32_MAX_STR_SIZE];
-  EXPECT_EQ(uint32_to_str(buf, 0), 1u);
-  EXPECT_STREQ(buf, "0");
-}
-
-TEST(Uint32ToStr, SpanMultiDigit) {
-  char buf[UINT32_MAX_STR_SIZE];
-  EXPECT_EQ(uint32_to_str(buf, 12345), 5u);
-  EXPECT_STREQ(buf, "12345");
-}
-
-TEST(Uint32ToStr, SpanMaxValue) {
-  char buf[UINT32_MAX_STR_SIZE];
-  EXPECT_EQ(uint32_to_str(buf, 4294967295u), 10u);
-  EXPECT_STREQ(buf, "4294967295");
-}
-
-}  // namespace esphome::core::testing
@@ -4,14 +4,6 @@ esphome:
      - globals.set:
          id: glob_int
          value: "10"
-      # Set a float global with an integer literal - must emit the correct
-      # return type so TemplatableFn stores a direct function pointer.
-      - globals.set:
-          id: glob_float
-          value: "102"
-      - globals.set:
-          id: glob_float
-          value: !lambda "return 42;"

 globals:
  - id: glob_int
@@ -1,141 +0,0 @@
-esphome:
-  name: status-flags-test
-
-host:
-api:
-  actions:
-    # Warning flag services for sensor_a
-    - action: set_warning_a
-      then:
-        - lambda: "id(sensor_a)->status_set_warning();"
-        - component.update: app_warning_bit
-        - component.update: app_error_bit
-    - action: clear_warning_a
-      then:
-        - lambda: "id(sensor_a)->status_clear_warning();"
-        - component.update: app_warning_bit
-        - component.update: app_error_bit
-
-    # Warning flag services for sensor_b
-    - action: set_warning_b
-      then:
-        - lambda: "id(sensor_b)->status_set_warning();"
-        - component.update: app_warning_bit
-        - component.update: app_error_bit
-    - action: clear_warning_b
-      then:
-        - lambda: "id(sensor_b)->status_clear_warning();"
-        - component.update: app_warning_bit
-        - component.update: app_error_bit
-
-    # Error flag services for sensor_a
-    - action: set_error_a
-      then:
-        - lambda: "id(sensor_a)->status_set_error();"
-        - component.update: app_warning_bit
-        - component.update: app_error_bit
-    - action: clear_error_a
-      then:
-        - lambda: "id(sensor_a)->status_clear_error();"
-        - component.update: app_warning_bit
-        - component.update: app_error_bit
-
-    # Error flag services for sensor_b
-    - action: set_error_b
-      then:
-        - lambda: "id(sensor_b)->status_set_error();"
-        - component.update: app_warning_bit
-        - component.update: app_error_bit
-    - action: clear_error_b
-      then:
-        - lambda: "id(sensor_b)->status_clear_error();"
-        - component.update: app_warning_bit
-        - component.update: app_error_bit
-
-    # Snapshot of the status_led_light's output state for observation.
-    - action: snapshot_led
-      then:
-        - component.update: status_led_writes
-        - component.update: status_led_last_state
-
-logger:
-
-# Tracks each write to the fake status_led output.
-globals:
-  - id: status_led_write_count
-    type: uint32_t
-    restore_value: no
-    initial_value: "0"
-  - id: status_led_last_write
-    type: bool
-    restore_value: no
-    initial_value: "false"
-
-# Fake binary output — status_led_light writes to this instead of a pin.
-# Every write bumps a counter and records the last value, both of which
-# are exposed below so the test can verify status_led_light's loop is
-# actually reading App.get_app_state() and responding.
-output:
-  - platform: template
-    id: fake_status_led
-    type: binary
-    write_action:
-      - globals.set:
-          id: status_led_write_count
-          value: !lambda "return id(status_led_write_count) + 1;"
-      - globals.set:
-          id: status_led_last_write
-          value: !lambda "return state;"
-
-# Actual status_led_light component under test.
-light:
-  - platform: status_led
-    name: Status LED
-    id: status_led_light_id
-    output: fake_status_led
-
-sensor:
-  # Two components that the test will toggle warning/error flags on.
-  - platform: template
-    name: Sensor A
-    id: sensor_a
-    update_interval: 24h
-    lambda: return 1.0;
-  - platform: template
-    name: Sensor B
-    id: sensor_b
-    update_interval: 24h
-    lambda: return 2.0;
-
-  # Expose App.app_state_'s STATUS_LED_WARNING / STATUS_LED_ERROR bits
-  # as 0.0 / 1.0. force_update ensures every manual component.update
-  # publishes even if the value is unchanged.
-  - platform: template
-    name: App Warning Bit
-    id: app_warning_bit
-    update_interval: 24h
-    force_update: true
-    lambda: |-
-      return (App.get_app_state() & STATUS_LED_WARNING) != 0 ? 1.0 : 0.0;
-  - platform: template
-    name: App Error Bit
-    id: app_error_bit
-    update_interval: 24h
-    force_update: true
-    lambda: |-
-      return (App.get_app_state() & STATUS_LED_ERROR) != 0 ? 1.0 : 0.0;
-
-  # Observables for the fake status_led output.
-  - platform: template
-    name: Status LED Writes
-    id: status_led_writes
-    update_interval: 24h
-    force_update: true
-    lambda: return id(status_led_write_count);
-  - platform: template
-    name: Status LED Last State
-    id: status_led_last_state
-    update_interval: 24h
-    force_update: true
-    lambda: |-
-      return id(status_led_last_write) ? 1.0 : 0.0;
@@ -1,209 +0,0 @@
-"""Integration tests for Component::status_set/clear_warning/error propagation.
-
-Verifies that toggling STATUS_LED_WARNING / STATUS_LED_ERROR on individual
-components correctly updates the app-wide bits on Application::app_state_,
-AND that the status_led_light component actually responds to those bits
-by writing to its output (the full chain from component.status_set_warning
-→ App.app_state_ → status_led_light.loop() reading get_app_state()).
-
-Exercises the multi-component OR semantics (the app bit stays set while
-any component still has the flag, and only clears when the last component
-clears its bit), the independence of warning and error, and the actual
-status_led_light read of the bits via a fake template output that counts
-writes.
-"""
-
-from __future__ import annotations
-
-import asyncio
-
-import pytest
-
-from .state_utils import InitialStateHelper, SensorTracker, build_key_to_entity_mapping
-from .types import APIClientConnectedFactory, RunCompiledFunction
-
-# Time to let the host-mode main loop run so status_led_light.loop() can
-# execute enough iterations to produce measurable write-count changes on
-# the fake template output. 300 ms is well above the minimum needed.
-STATUS_LED_SETTLE_S = 0.3
-
-
-@pytest.mark.asyncio
-async def test_status_flags(
-    yaml_config: str,
-    run_compiled: RunCompiledFunction,
-    api_client_connected: APIClientConnectedFactory,
-) -> None:
-    async with run_compiled(yaml_config), api_client_connected() as client:
-        entities, services = await client.list_entities_services()
-
-        # Map every custom API service by name for the test to execute.
-        svc = {s.name: s for s in services}
-        for name in (
-            "set_warning_a",
-            "clear_warning_a",
-            "set_warning_b",
-            "clear_warning_b",
-            "set_error_a",
-            "clear_error_a",
-            "set_error_b",
-            "clear_error_b",
-            "snapshot_led",
-        ):
-            assert name in svc, f"service {name} not registered"
-
-        # Track every sensor we care about. SensorTracker gives us
-        # expect(value) / expect_any() futures that resolve when a
-        # matching state arrives; much simpler than manual bookkeeping.
-        tracker = SensorTracker(
-            [
-                "app_warning_bit",
-                "app_error_bit",
-                "status_led_writes",
-                "status_led_last_state",
-            ]
-        )
-        tracker.key_to_sensor.update(
-            build_key_to_entity_mapping(entities, list(tracker.sensor_states.keys()))
-        )
-
-        # Swallow initial state broadcasts so the test only reacts to
-        # state changes triggered by our service calls.
-        initial_state_helper = InitialStateHelper(entities)
-        client.subscribe_states(initial_state_helper.on_state_wrapper(tracker.on_state))
-        try:
-            await initial_state_helper.wait_for_initial_states()
-        except TimeoutError:
-            pytest.fail("Timeout waiting for initial states")
-
-        async def call(name: str) -> None:
-            await client.execute_service(svc[name], {})
-
-        async def call_and_expect_bits(
-            service_name: str, *, warning: float, error: float
-        ) -> None:
-            """Execute a service and wait for both app bit sensors to match.
-
-            Each bit-toggling service calls component.update on both
-            app_warning_bit and app_error_bit, so both sensors publish.
-            """
-            futures = tracker.expect_all(
-                {"app_warning_bit": warning, "app_error_bit": error}
-            )
-            await call(service_name)
-            await tracker.await_all(futures)
-
-        async def snapshot_led_writes() -> int:
-            """Trigger a publish of the fake status_led output counter and return it."""
-            future = tracker.expect_any("status_led_writes")
-            await call("snapshot_led")
-            await tracker.await_change(future, "status_led_writes")
-            return int(tracker.sensor_states["status_led_writes"][-1])
-
-        # ---- Baseline: everything clean ----
-        await call_and_expect_bits("clear_warning_a", warning=0.0, error=0.0)
-
-        # ================================================================
-        # Part 1 — STATUS_LED_WARNING propagation to App.app_state_
-        # ================================================================
-
-        # Single component set/clear
-        await call_and_expect_bits("set_warning_a", warning=1.0, error=0.0)
-        await call_and_expect_bits("clear_warning_a", warning=0.0, error=0.0)
-
-        # Multi-component OR: both set, clear A, bit stays (B still has it), clear B, gone
-        await call_and_expect_bits("set_warning_a", warning=1.0, error=0.0)
-        await call_and_expect_bits("set_warning_b", warning=1.0, error=0.0)
-        await call_and_expect_bits("clear_warning_a", warning=1.0, error=0.0)
-        await call_and_expect_bits("clear_warning_b", warning=0.0, error=0.0)
-
-        # Opposite clear order
-        await call_and_expect_bits("set_warning_a", warning=1.0, error=0.0)
-        await call_and_expect_bits("set_warning_b", warning=1.0, error=0.0)
-        await call_and_expect_bits("clear_warning_b", warning=1.0, error=0.0)
-        await call_and_expect_bits("clear_warning_a", warning=0.0, error=0.0)
-
-        # ================================================================
-        # Part 2 — STATUS_LED_ERROR propagation (same scenarios)
-        # ================================================================
-
-        await call_and_expect_bits("set_error_a", warning=0.0, error=1.0)
-        await call_and_expect_bits("clear_error_a", warning=0.0, error=0.0)
-
-        await call_and_expect_bits("set_error_a", warning=0.0, error=1.0)
-        await call_and_expect_bits("set_error_b", warning=0.0, error=1.0)
-        await call_and_expect_bits("clear_error_a", warning=0.0, error=1.0)
-        await call_and_expect_bits("clear_error_b", warning=0.0, error=0.0)
-
-        # ================================================================
-        # Part 3 — warning and error are independent
-        # ================================================================
-
-        await call_and_expect_bits("set_warning_a", warning=1.0, error=0.0)
-        await call_and_expect_bits("set_error_b", warning=1.0, error=1.0)
-        await call_and_expect_bits("clear_warning_a", warning=0.0, error=1.0)
-        await call_and_expect_bits("clear_error_b", warning=0.0, error=0.0)
-
-        # ================================================================
-        # Part 4 — status_led_light actually reads App.app_state_
-        # ================================================================
-        # The fake status_led_light output increments status_led_write_count
-        # on every write. status_led_light::loop() writes its output on every
-        # iteration while an error/warning bit is set, so after holding a
-        # warning for ~300 ms we should see the counter move significantly.
-        # This is the end-to-end proof that the bits we set above actually
-        # reach status_led_light and drive its behavior.
-
-        count_before_warning = await snapshot_led_writes()
-        await call_and_expect_bits("set_warning_a", warning=1.0, error=0.0)
-        # Let status_led_light's loop run long enough to toggle the pin
-        # several times (it reads get_app_state() every main loop iteration).
-        await asyncio.sleep(STATUS_LED_SETTLE_S)
-        count_after_warning = await snapshot_led_writes()
-        assert count_after_warning > count_before_warning, (
-            "status_led_light did not respond to STATUS_LED_WARNING being set: "
-            f"write count stayed at {count_before_warning} → {count_after_warning}. "
-            "The full chain Component::status_set_warning → App.app_state_ → "
-            "status_led_light::loop reading get_app_state() is broken."
-        )
-        await call_and_expect_bits("clear_warning_a", warning=0.0, error=0.0)
-
-        # Same check for ERROR
-        count_before_error = await snapshot_led_writes()
-        await call_and_expect_bits("set_error_a", warning=0.0, error=1.0)
-        await asyncio.sleep(STATUS_LED_SETTLE_S)
-        count_after_error = await snapshot_led_writes()
-        assert count_after_error > count_before_error, (
-            "status_led_light did not respond to STATUS_LED_ERROR being set: "
-            f"write count stayed at {count_before_error} → {count_after_error}. "
-        )
-        await call_and_expect_bits("clear_error_a", warning=0.0, error=0.0)
-
-        # ---- Set → clear → re-set round-trip ----
-        # After clearing, status_led_light stops writing (steady state).
-        # Re-setting the flag must make it resume. This guards against a
-        # future idle optimization (e.g. #15642) where status_led disables
-        # its own loop when idle: if the re-enable path were broken, the
-        # second set would not produce writes.
-        #
-        # Snapshot AFTER the clear to avoid counting writes that were still
-        # in-flight from the error-set phase.
-        count_after_clear = await snapshot_led_writes()
-        await asyncio.sleep(STATUS_LED_SETTLE_S)
-        count_after_idle = await snapshot_led_writes()
-        assert count_after_idle - count_after_clear <= 5, (
-            "status_led_light kept writing after warning/error was cleared: "
-            f"count grew from {count_after_clear} to {count_after_idle}. "
-            "Expected it to stop writing once all status bits were clear."
-        )
-        # Re-set warning — writes must resume.
-        await call_and_expect_bits("set_warning_a", warning=1.0, error=0.0)
-        await asyncio.sleep(STATUS_LED_SETTLE_S)
-        count_after_reset = await snapshot_led_writes()
-        assert count_after_reset > count_after_idle + 5, (
-            "status_led_light did not resume writing after re-setting "
-            f"STATUS_LED_WARNING: count went from {count_after_idle} to "
-            f"{count_after_reset}. If an idle optimization disabled the "
-            "loop, the re-enable path may be broken."
-        )
-        await call_and_expect_bits("clear_warning_a", warning=0.0, error=0.0)
@@ -1231,48 +1231,6 @@ def test_upload_using_esptool_path_conversion(
    assert partitions_path.endswith("partitions.bin")


-def test_upload_using_esptool_skips_missing_extra_flash_images(
-    tmp_path: Path,
-    mock_run_external_command_main: Mock,
-    mock_get_idedata: Mock,
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    """A non-existent path in extra_flash_images must be filtered out with a
-    warning, and must not appear in the esptool command line. Only the valid
-    images are flashed. Regression test for
-    https://github.com/esphome/esphome/issues/15634.
-    """
-    setup_core(platform=PLATFORM_ESP32, tmp_path=tmp_path, name="test")
-    CORE.data[KEY_ESP32] = {KEY_VARIANT: VARIANT_ESP32}
-
-    missing_path = tmp_path / "variants" / "tasmota" / "tinyuf2.bin"
-
-    mock_idedata = MagicMock(spec=platformio_api.IDEData)
-    mock_idedata.firmware_bin_path = tmp_path / "firmware.bin"
-    mock_idedata.extra_flash_images = [
-        platformio_api.FlashImage(path=tmp_path / "bootloader.bin", offset="0x1000"),
-        platformio_api.FlashImage(path=missing_path, offset="0x2d0000"),
-    ]
-    mock_get_idedata.return_value = mock_idedata
-
-    (tmp_path / "firmware.bin").touch()
-    (tmp_path / "bootloader.bin").touch()
-    # Intentionally do NOT create missing_path
-
-    config = {CONF_ESPHOME: {"platformio_options": {}}}
-
-    with caplog.at_level(logging.WARNING, logger="esphome.__main__"):
-        result = upload_using_esptool(config, "/dev/ttyUSB0", None, None)
-
-    assert result == 0
-    assert "Skipping missing flash image" in caplog.text
-    assert str(missing_path) in caplog.text
-
-    cmd_list = list(mock_run_external_command_main.call_args[0][1:])
-    assert str(missing_path) not in cmd_list
-    assert "0x2d0000" not in cmd_list
-
-
 def test_upload_using_esptool_with_file_path(
    tmp_path: Path,
    mock_run_external_command_main: Mock,
@@ -906,7 +906,7 @@ def _filter_through_redirect(line: str) -> str:

    captured = io.StringIO()
    redirect = RedirectText(
-        captured, filter_lines=platformio_runner.FILTER_PLATFORMIO_LINES
+        captured, filter_lines=platformio_api.FILTER_PLATFORMIO_LINES
    )
    redirect.write(line + "\n")
    return captured.getvalue()
Author	SHA1	Message	Date
J. Nick Koston	5e881738da	[api] Add speed_optimized proto option for hot encode paths Add a new (speed_optimized) message option that emits __attribute__((optimize("O2"))) on the generated encode() and calculate_size() methods. Under -Os, GCC does not inline the small ProtoEncode helpers (write_raw_byte, encode_varint, etc.) into the generated methods, causing significant overhead on hot paths. Apply to SensorStateResponse and BluetoothLERawAdvertisementsResponse which are the highest-frequency encode paths.	2026-04-12 19:12:31 -10:00
J. Nick Koston	5a250cc74f	[api] Compile noise-c and libsodium with -O2 for speed Crypto libraries are CPU-bound and benefit significantly from speed optimization over the default -Os. Add a post: extra_script that appends -O2 to noise-c and libsodium build flags when API noise encryption is enabled. GCC uses the last -O flag, so this overrides the global -Os for these libraries only.	2026-04-12 19:03:21 -10:00
J. Nick Koston	02f828fcbf	[benchmark] Use -Os to match firmware optimization level CodSpeed benchmarks were building with -O2, while all firmware targets (ESP8266, ESP32, LibreTiny) use -Os. This mismatch means the benchmarks cannot detect inlining regressions that affect real devices — GCC under -O2 inlines functions that -Os outlines due to its size-conscious cost model. Switch to -Os with -ffunction-sections/-fdata-sections for proper dead-code stripping (needed because -Os preserves references that -O2 optimizes away at compile time).	2026-04-12 18:37:50 -10:00
J. Nick Koston	ab64916c37	[benchmark] Use -Os to match firmware optimization level CodSpeed benchmarks were building with -O2, while all firmware targets (ESP8266, ESP32, LibreTiny) use -Os. This mismatch means the benchmarks cannot detect inlining regressions that affect real devices — GCC under -O2 inlines functions that -Os outlines due to its size-conscious cost model. Remove the -Os unflag and -O2 override so benchmarks use the platform default -Os, matching what actually runs on devices.	2026-04-12 18:32:03 -10:00