Merge remote-tracking branch 'origin/shelly_dimmer-tables-progmem' into shelly_dimmer-drop-unused-dev-fields

# Conflicts: # esphome/components/shelly_dimmer/dev_table.h # esphome/components/shelly_dimmer/stm32flash.h
Merge remote-tracking branch 'origin/dev' into shelly_dimmer-tables-progmem
2026-10-15 02:32:49 +00:00 · 2026-10-14 08:14:42 -10:00 · 2026-10-14 08:13:27 -10:00 · 2026-10-14 08:09:53 -10:00 · 2026-10-14 13:24:36 -04:00 · 2026-10-14 10:05:02 -04:00
159 changed files with 3280 additions and 482 deletions
@@ -32,7 +32,7 @@ runs:
      # detects the activated venv via ``VIRTUAL_ENV`` so the venv layout
      # downstream jobs rely on is preserved.
      if: steps.cache-venv.outputs.cache-hit != 'true'
-      uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+      uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
      with:
        enable-cache: true
        # Pull request saves land in per-PR scopes nothing else can
@@ -29,7 +29,7 @@ jobs:
      - name: Set up uv
        # ``--system`` (below) installs into the setup-python interpreter;
        # no venv is created or restored by this workflow.
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
        with:
          enable-cache: true
          # Pull-request-only workflow: a save could never be shared and
@@ -97,7 +97,7 @@ jobs:
        run: git diff
      - if: failure()
        name: Archive artifacts
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
        with:
          name: generated-proto-files
          path: |
@@ -128,7 +128,7 @@ jobs:

      - name: Upload compile-test image artifact
        if: matrix.os == 'ubuntu-24.04' && matrix.build_type == 'docker'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
        with:
          # The tar is already compressed, so upload it as-is. archive: false
          # skips the redundant zip and makes the file name the artifact name
@@ -210,7 +210,7 @@ jobs:
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
      - name: Download image artifact
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
        with:
          name: compile-test-image.tar.zst
      - name: Load image
@@ -49,7 +49,7 @@ jobs:
        # detects the activated venv via ``VIRTUAL_ENV`` so downstream jobs
        # that ``. venv/bin/activate`` see an identical layout.
        if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -81,8 +81,8 @@ jobs:
      - name: Install apt packages (cached)
        uses: awalsh128/cache-apt-pkgs-action@553a35bb8ebd9fcabcb1c9451aa4c98e1b4ca8a9 # v1.6.3
        with:
-          packages: libsdl2-dev ccache
-          version: 1.1
+          packages: libsdl2-dev libmbedtls-dev ccache
+          version: 1.2

  determine-jobs:
    name: Determine which jobs to run
@@ -415,8 +415,8 @@ jobs:
        timeout-minutes: 10
        uses: awalsh128/cache-apt-pkgs-action@553a35bb8ebd9fcabcb1c9451aa4c98e1b4ca8a9 # v1.6.3
        with:
-          packages: libsdl2-dev ccache
-          version: 1.1
+          packages: libsdl2-dev libmbedtls-dev ccache
+          version: 1.2
      - name: Set up Python 3.13
        id: python
        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
@@ -438,7 +438,7 @@ jobs:
      - name: Set up uv
        # Only needed on cache miss to populate the venv.
        if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -477,7 +477,7 @@ jobs:
        # Tests that compare rendered output write the image they actually got here, so a
        # failure can be looked at without reproducing the whole build locally.
        if: failure()
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
        with:
          name: integration-test-artifacts-${{ matrix.bucket.name }}
          path: test_artifacts/
@@ -488,7 +488,7 @@ jobs:
        # script/update_integration_test_durations.py; only full matrix dev
        # runs produce usable data.
        if: github.ref == 'refs/heads/dev' && needs.determine-jobs.outputs.integration-run-all == 'true'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
        with:
          name: junit-integration-${{ strategy.job-index }}
          path: junit-integration.xml
@@ -528,7 +528,7 @@ jobs:
          script/check_import_time.py --check --har importtime.har
      - name: Upload waterfall HAR
        if: always()
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
        with:
          name: import-time-waterfall
          path: importtime.har
@@ -626,7 +626,7 @@ jobs:
            apt-get install -y libc6-dbg

      - name: Run CodSpeed benchmarks
-        uses: CodSpeedHQ/action@c4fd08a3a159bd0cc208da1e0edf32b8c47d75e5 # v5.4.0
+        uses: CodSpeedHQ/action@f842b9a3ffe213dbb81768fd7f7eeb4dfcf1c369 # v5.4.2
        with:
          run: |
            . venv/bin/activate
@@ -695,6 +695,10 @@ jobs:
            name: Run script/clang-tidy for RP2
            options: --environment rp2-tidy --grep USE_RP2
            pio_cache_key: tidyrp2
+          - id: clang-tidy
+            name: Run script/clang-tidy for host
+            options: --environment host-tidy --grep USE_HOST
+            pio_cache_key: tidyhost
          - id: clang-tidy
            name: Run script/clang-tidy for LibreTiny
            environments: bk72xx-tidy ln882h-tidy rtl87xxb-tidy rtl87xxc-tidy
@@ -707,6 +711,16 @@ jobs:
        with:
          # Need history for HEAD~1 to work for checking changed files
          fetch-depth: 2
+      - name: Install apt packages (cached)
+        if: matrix.pio_cache_key == 'tidyhost'
+        # libsdl2-dev is needed by the sdl component on the host, libmbedtls-dev
+        # by dsmr and dlms_meter. Packages and version must match seed-apt-cache
+        # exactly.
+        timeout-minutes: 10
+        uses: awalsh128/cache-apt-pkgs-action@553a35bb8ebd9fcabcb1c9451aa4c98e1b4ca8a9 # v1.6.3
+        with:
+          packages: libsdl2-dev libmbedtls-dev ccache
+          version: 1.2

      - name: Restore Python
        id: restore-python
@@ -1102,8 +1116,8 @@ jobs:
        timeout-minutes: 10
        uses: awalsh128/cache-apt-pkgs-action@553a35bb8ebd9fcabcb1c9451aa4c98e1b4ca8a9 # v1.6.3
        with:
-          packages: libsdl2-dev ccache
-          version: 1.1
+          packages: libsdl2-dev libmbedtls-dev ccache
+          version: 1.2

      - name: Check out code from GitHub
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -1448,7 +1462,7 @@ jobs:
        # install step (order-of-magnitude faster on cold boots,
        # with its own wheel cache). actions/setup-python still
        # provides the interpreter.
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -1647,7 +1661,7 @@ jobs:
          fi

      - name: Upload memory analysis JSON
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
        with:
          name: memory-analysis-target
          path: memory-analysis-target.json
@@ -1710,7 +1724,7 @@ jobs:
            --platform "$platform"

      - name: Upload memory analysis JSON
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
        with:
          name: memory-analysis-pr
          path: memory-analysis-pr.json
@@ -1740,13 +1754,13 @@ jobs:
          python-version: ${{ env.DEFAULT_PYTHON }}
          cache-key: ${{ needs.common.outputs.cache-key }}
      - name: Download target analysis JSON
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
        with:
          name: memory-analysis-target
          path: ./memory-analysis
        continue-on-error: true
      - name: Download PR analysis JSON
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
        with:
          name: memory-analysis-pr
          path: ./memory-analysis
@@ -56,7 +56,7 @@ jobs:

      # Initializes the CodeQL tools for scanning.
      - name: Initialize CodeQL
-        uses: github/codeql-action/init@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
+        uses: github/codeql-action/init@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
        with:
          languages: ${{ matrix.language }}
          build-mode: ${{ matrix.build-mode }}
@@ -84,6 +84,6 @@ jobs:
          exit 1

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
+        uses: github/codeql-action/analyze@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
        with:
          category: "/language:${{matrix.language}}"
@@ -162,7 +162,7 @@ jobs:
      #     version: ${{ needs.init.outputs.tag }}

      - name: Upload digests
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
        with:
          name: digests-${{ matrix.platform.arch }}
          path: /tmp/digests
@@ -195,7 +195,7 @@ jobs:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1

      - name: Download digests
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
        with:
          pattern: digests-*
          path: /tmp/digests
@@ -47,7 +47,7 @@ jobs:
        # setup-python interpreter so subsequent ``prek`` /
        # ``script/run-in-env.py`` steps find the deps without a
        # ``uv run`` prefix.
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
        with:
          enable-cache: true
          # Pin uv version so the action does not have to fetch the
@@ -10,7 +10,7 @@ ci:
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    # Ruff version.
-    rev: v0.16.10
+    rev: v0.17.0
    hooks:
      # Run the linter.
      - id: ruff
@@ -36,7 +36,7 @@ repos:
      - id: end-of-file-fixer
      - id: trailing-whitespace
  - repo: https://github.com/asottile/pyupgrade
-    rev: v3.21.2
+    rev: v3.22.0
    hooks:
      - id: pyupgrade
        args: [--py312-plus]
@@ -240,6 +240,7 @@ esphome/components/gt911/* @clydebarrow @jesserockz
 esphome/components/haier/* @paveldn
 esphome/components/haier/binary_sensor/* @paveldn
 esphome/components/haier/button/* @paveldn
+esphome/components/haier/select/* @paveldn
 esphome/components/haier/sensor/* @paveldn
 esphome/components/haier/switch/* @paveldn
 esphome/components/haier/text_sensor/* @paveldn
@@ -338,7 +338,7 @@ async def to_code(config: ConfigType) -> None:
    # HTTPS streams verify the server against the root certificate bundle
    require_certificate_bundle()

-    add_idf_component(name="esphome/esp-audio-libs", ref="4.0.1")
+    add_idf_component(name="esphome/esp-audio-libs", ref="4.1.0")

    data = _get_data()

@@ -250,6 +250,42 @@ def add_metadata(
    )


+KEY_EXTERNAL_WRITERS = "external_writers"
+
+
+def _get_external_writer_list() -> list[tuple[ID, str]]:
+    """Get the raw external writer list. Each entry is (display id, owner)."""
+    return CORE.data.setdefault(DOMAIN, {}).setdefault(KEY_EXTERNAL_WRITERS, [])
+
+
+def register_external_writer(display_id: ID, owner: str) -> None:
+    """Declare that ``owner`` draws into the display from outside its lambda or pages.
+
+    Call from the owner's CONFIG_SCHEMA. The ID may still be unresolved; the ID pass
+    resolves it in place before final validation.
+    """
+    _get_external_writer_list().append((display_id, owner))
+
+
+def get_external_writers(display_id: ID) -> list[str]:
+    """Get the owners registered for a display. Only valid once IDs are resolved."""
+    return [
+        owner
+        for id_, owner in _get_external_writer_list()
+        if id_.id is not None and id_.id == display_id.id
+    ]
+
+
+def has_external_writer(display_id: ID) -> bool:
+    """Tell a driver's final validation that something else draws into the display.
+
+    LVGL anywhere in the config also counts, as the drivers assumed before.
+    """
+    from esphome.components.lvgl import DOMAIN as LVGL_DOMAIN
+
+    return LVGL_DOMAIN in full_config.get() or bool(get_external_writers(display_id))
+
+
 async def register_display(var, config):
    await cg.register_component(var, config)
    await setup_display_core_(var, config)
@@ -5,6 +5,7 @@
 #include "display_color_utils.h"
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"

 namespace esphome::display {
@@ -52,40 +53,65 @@ void Display::line_at_angle(int x, int y, int angle, int start_radius, int stop_
  this->line(x1, y1, x2, y2, color);
 }

-void Display::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
-                             ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
-  size_t line_stride = x_offset + w + x_pad;  // length of each source line in pixels
-  uint32_t color_value;
+// flatten keeps to_color() inlined in the pixel loop; in PSRAM builds GCC at
+// -Os stops inlining it once there are two call sites, which costs a call and
+// spills per pixel. Without PSRAM there is one call site and it changes
+// nothing, and draw_pixel_at() stays a virtual call either way.
+template<ColorBitness BITNESS>
+static void __attribute__((flatten))
+draw_packed_pixels(Display *display, int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
+                   bool big_endian, int x_offset, int y_offset, int x_pad) {
+  const size_t line_stride = x_offset + w + x_pad;  // length of each source line in pixels
+  // BITNESS is a constant here, so to_color()'s three per pixel divisions
+  // become a multiply and shift and its bitness switch folds.
+  const auto draw_source_pixel = [&](int x, int y, size_t source_idx) ESPHOME_ALWAYS_INLINE {
+    display->draw_pixel_at(
+        x + x_start, y + y_start,
+        ColorUtil::to_color(ColorUtil::read_packed<BITNESS>(ptr, source_idx, big_endian), order, BITNESS));
+  };
+  // The source and frame buffers are row-major, so walking rows keeps the read
+  // and the write sequential. When the display swaps the axes before writing,
+  // walking columns keeps the write sequential instead; with the frame buffer
+  // in PSRAM a strided write costs more than a strided read.
+#ifdef USE_PSRAM
+  if (display->pixel_axes_swapped()) {
+    size_t column_idx = y_offset * line_stride + x_offset;
+    for (int x = 0; x != w; x++, column_idx++) {
+      size_t source_idx = column_idx;
+      for (int y = 0; y != h; y++, source_idx += line_stride) {
+        draw_source_pixel(x, y, source_idx);
+      }
+    }
+    return;
+  }
+#endif
+  // Row walk: builds without PSRAM, and PSRAM builds whose axes are not swapped.
  for (int y = 0; y != h; y++) {
    size_t source_idx = (y_offset + y) * line_stride + x_offset;
-    size_t source_idx_mod;
    for (int x = 0; x != w; x++, source_idx++) {
-      switch (bitness) {
-        default:
-          color_value = ptr[source_idx];
-          break;
-        case COLOR_BITNESS_565:
-          source_idx_mod = source_idx * 2;
-          if (big_endian) {
-            color_value = (ptr[source_idx_mod] << 8) + ptr[source_idx_mod + 1];
-          } else {
-            color_value = ptr[source_idx_mod] + (ptr[source_idx_mod + 1] << 8);
-          }
-          break;
-        case COLOR_BITNESS_888:
-          source_idx_mod = source_idx * 3;
-          if (big_endian) {
-            color_value = (ptr[source_idx_mod + 0] << 16) + (ptr[source_idx_mod + 1] << 8) + ptr[source_idx_mod + 2];
-          } else {
-            color_value = ptr[source_idx_mod + 0] + (ptr[source_idx_mod + 1] << 8) + (ptr[source_idx_mod + 2] << 16);
-          }
-          break;
-      }
-      this->draw_pixel_at(x + x_start, y + y_start, ColorUtil::to_color(color_value, order, bitness));
+      draw_source_pixel(x, y, source_idx);
    }
  }
 }

+void Display::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
+                             ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
+  switch (bitness) {
+    case COLOR_BITNESS_565:
+      draw_packed_pixels<COLOR_BITNESS_565>(this, x_start, y_start, w, h, ptr, order, big_endian, x_offset, y_offset,
+                                            x_pad);
+      break;
+    case COLOR_BITNESS_888:
+      draw_packed_pixels<COLOR_BITNESS_888>(this, x_start, y_start, w, h, ptr, order, big_endian, x_offset, y_offset,
+                                            x_pad);
+      break;
+    default:
+      draw_packed_pixels<COLOR_BITNESS_332>(this, x_start, y_start, w, h, ptr, order, big_endian, x_offset, y_offset,
+                                            x_pad);
+      break;
+  }
+}
+
 void HOT Display::horizontal_line(int x, int y, int width, Color color) {
  // Future: Could be made more efficient by manipulating buffer directly in certain rotations.
  for (int i = x; i < x + width; i++)
@@ -139,6 +139,11 @@ enum DisplayRotation {
  DISPLAY_ROTATION_270_DEGREES = 270,
 };

+/// Whether a rotation swaps the x and y axes.
+constexpr bool rotation_swaps_axes(DisplayRotation rotation) {
+  return rotation == DISPLAY_ROTATION_90_DEGREES || rotation == DISPLAY_ROTATION_270_DEGREES;
+}
+
 const int EDGES_TRIGON = 3;
 const int EDGES_TRIANGLE = 3;
 const int EDGES_TETRAGON = 4;
@@ -717,6 +722,12 @@ class Display : public PollingComponent {

  virtual DisplayRotation get_rotation() const { return this->rotation_; }

+  /// True when draw_pixel_at() swaps x and y before writing, so pixels that are
+  /// neighbours along x land a row apart in the frame buffer. Not the same as
+  /// get_width()/get_height() swapping: a display that rotates in hardware
+  /// reports swapped dimensions but writes unswapped pixels.
+  virtual bool pixel_axes_swapped() const { return rotation_swaps_axes(this->rotation_); }
+
  /** Get the type of display that the buffer corresponds to. In case of dynamically configurable displays,
   * returns the type the display is currently configured to.
   */
@@ -2,6 +2,7 @@
 #include <array>
 #include <cstdint>
 #include "esphome/core/color.h"
+#include "esphome/core/helpers.h"

 namespace esphome::display {
 enum ColorOrder : uint8_t { COLOR_ORDER_RGB = 0, COLOR_ORDER_BGR = 1, COLOR_ORDER_GRB = 2 };
@@ -10,6 +11,27 @@ inline static uint8_t esp_scale(uint8_t i, uint8_t scale, uint8_t max_value = 25

 class ColorUtil {
 public:
+  /// Reads one packed pixel of the given bitness from a source buffer into the
+  /// value to_color() takes. BITNESS is a template argument so the byte layout
+  /// folds; pass it on to to_color() as a constant too, and its channel scaling
+  /// divides by a constant, which the compiler turns into a multiply and shift.
+  template<ColorBitness BITNESS>
+  static ESPHOME_ALWAYS_INLINE uint32_t read_packed(const uint8_t *ptr, size_t index, bool big_endian) {
+    if constexpr (BITNESS == COLOR_BITNESS_565) {
+      const size_t idx = index * 2;
+      if (big_endian)
+        return (ptr[idx] << 8) + ptr[idx + 1];
+      return ptr[idx] + (ptr[idx + 1] << 8);
+    } else if constexpr (BITNESS == COLOR_BITNESS_888) {
+      const size_t idx = index * 3;
+      if (big_endian)
+        return (ptr[idx + 0] << 16) + (ptr[idx + 1] << 8) + ptr[idx + 2];
+      return ptr[idx + 0] + (ptr[idx + 1] << 8) + (ptr[idx + 2] << 16);
+    } else {
+      return ptr[index];
+    }
+  }
+
  static Color to_color(uint32_t colorcode, ColorOrder color_order,
                        ColorBitness color_bitness = ColorBitness::COLOR_BITNESS_888, bool right_bit_aligned = true) {
    uint8_t first_color, second_color, third_color;
@@ -40,7 +40,6 @@ from esphome.const import (
    CONF_WIDTH,
 )
 from esphome.cpp_generator import RawExpression
-from esphome.final_validate import full_config

 from . import models

@@ -198,15 +197,11 @@ def _final_validate(config) -> None:
        "epaper_spi", require_miso=False, require_mosi=True
    )(config)

-    global_config = full_config.get()
-    from esphome.components.lvgl import DOMAIN as LVGL_DOMAIN
-
    if CONF_LAMBDA not in config and CONF_PAGES not in config:
-        if LVGL_DOMAIN in global_config:
+        if display.has_external_writer(config[CONF_ID]):
            if CONF_UPDATE_INTERVAL not in config:
                config[CONF_UPDATE_INTERVAL] = update_interval("never")
        else:
-            # If no drawing methods are configured, and LVGL is not enabled, show a test card
            config[CONF_SHOW_TEST_CARD] = True
    elif CONF_UPDATE_INTERVAL not in config:
        config[CONF_UPDATE_INTERVAL] = update_interval("1min")
@@ -106,6 +106,7 @@ class EPaperBase : public Display,

  int get_width() override { return this->effective_transform_ & SWAP_XY ? this->height_ : this->width_; }
  int get_height() override { return this->effective_transform_ & SWAP_XY ? this->width_ : this->height_; }
+  bool pixel_axes_swapped() const override { return this->effective_transform_ & SWAP_XY; }
  void draw_pixel_at(int x, int y, Color color) override;
  void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
                      ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
@@ -87,6 +87,38 @@ jd79660.extend(
    ),
 )

+# Waveshare 2.13-G (V2 hardware/init revision, PCB marked "rev 2.1" or later)
+#
+# Vendor init derived from vendor sample code
+# <https://github.com/waveshareteam/e-Paper/blob/master/E-paper_Separate_Program/2in13_e-Paper_G/ESP32/EPD_2in13g_V2.cpp>
+# Compatible MIT license, see esphome/LICENSE file.
+#
+# Note: busy pin uses LOW=busy, HIGH=idle. Configure with inverted: true in YAML.
+# Note: panel is 122px wide, but vendor code declares the TRES register as a fixed
+# 124 on this revision. width=124 is declared here (rather than 122) purely so the
+# transferred bytes-per-row matches what the vendor init tells the IC to expect; the
+# extra 2 columns fall outside the visible glass. The model width must equal the
+# TRES value in initsequence, so overriding dimensions: in YAML brings the shear back.
+#
+# fmt: off
+jd79660.extend(
+    "Waveshare-2.13in-G",
+    width=124,
+    height=250,
+
+    initsequence=(
+        (0x61, 0x00, 0x7C, 0x00, 0xFA,),  # TRES: 124x250 fixed (124 = TRES stride value)
+        (0xE9, 0x01,),
+        # Power On (0x04): Must be early part of init seq = Disabled later!
+        (0x04,),
+    ),
+    fast_update=(
+        (0xE0, 0x02,),
+        (0xE6, 0x5A,),
+        (0xA5,),
+    ),
+)
+
 # Waveshare 7.5-H
 #
 # Vendor init derived from vendor sample code
@@ -130,7 +162,7 @@ jd79660.extend(
 # Note: busy pin uses LOW=busy, HIGH=idle.
 #
 # fmt: off
-jd79660.extend(
+gdey0213f51 = jd79660.extend(
    "goodisplay-gdey0213f51-2.13",
    width=128,
    height=250,
@@ -154,3 +186,13 @@ jd79660.extend(
        (0x04,),
    ),
 )
+
+# Waveshare 2.13-G (V1 hardware/init revision, older stock): the same panel and init as the Good
+# Display entry above, byte for byte, so it only adds the name. Vendor sample:
+# <https://github.com/waveshareteam/e-Paper/blob/master/E-paper_Separate_Program/2in13_e-Paper_G/ESP32/EPD_2in13g.cpp>
+# Compatible MIT license, see esphome/LICENSE file.
+#
+# Note: busy pin uses LOW=busy, HIGH=idle. Configure with inverted: true in YAML.
+# Note: width=128 is the TRES value the init sequence programs, not the 122 visible columns; overriding
+# dimensions: in YAML shears the image. Not tested on V1 hardware.
+gdey0213f51.extend("Waveshare-2.13in-G-V1")
@@ -24,3 +24,11 @@ WaveshareB(
    data_rate="10MHz",
    minimum_update_interval="1s",
 )
+
+WaveshareB(
+    "waveshare-2.66in-b",
+    width=152,
+    height=296,
+    data_rate="10MHz",
+    minimum_update_interval="15s",
+)
@@ -131,6 +131,7 @@ bool ESP32PreferenceBackend::load(uint8_t *data, size_t len) {
 void ESP32Preferences::open() {
  // Runs from app_main() before the logger is initialized; any logging here
  // must be deferred. See s_open_err and make_preference() below.
+  // Components that need NVS check nvs_handle instead of initializing it again.
  nvs_flash_init();
  esp_err_t err = nvs_open("esphome", NVS_READWRITE, &this->nvs_handle);
  if (err == 0)
@@ -5,6 +5,7 @@
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/preferences.h"

 #ifndef CONFIG_BT_CONTROLLER_DISABLED
 #include <esp_bt.h>
@@ -28,7 +29,6 @@ extern "C" {
 #include <freertos/FreeRTOS.h>
 #include <freertos/FreeRTOSConfig.h>
 #include <freertos/task.h>
-#include <nvs_flash.h>

 #ifdef USE_ARDUINO
 // Prevent Arduino from releasing BT memory at startup (esp32-hal-misc.c).
@@ -77,8 +77,9 @@ static constexpr uint32_t HOSTED_BT_WDT_TIMEOUT_MS = 60000;

 void ESP32BLE::setup() {
  global_ble = this;
-  if (!ble_pre_setup_()) {
-    ESP_LOGE(TAG, "BLE could not be prepared for configuration");
+  // Preferences opens NVS in app_main(); a zero handle means it could not be opened, even after an erase
+  if (global_preferences->nvs_handle == 0) {
+    ESP_LOGE(TAG, "NVS unavailable");
    this->mark_failed();
    return;
  }
@@ -185,15 +186,6 @@ void ESP32BLE::advertising_remove_service_uuid(ESPBTUUID uuid) {
 }
 #endif

-bool ESP32BLE::ble_pre_setup_() {
-  esp_err_t err = nvs_flash_init();
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "nvs_flash_init failed: %d", err);
-    return false;
-  }
-  return true;
-}
-
 #ifdef USE_ESP32_BLE_ADVERTISING
 void ESP32BLE::advertising_init_() {
  if (this->advertising_ != nullptr)
@@ -185,7 +185,6 @@ class ESP32BLE final : public Component {
    }
    this->ble_events_.get_and_reset_dropped_count();
  }
-  bool ble_pre_setup_();
 #ifdef USE_ESP32_BLE_ADVERTISING
  void advertising_init_();
 #endif
@@ -10,7 +10,6 @@
 #include <esp_gap_ble_api.h>
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
-#include <nvs_flash.h>
 #include <cstring>

 #include "esphome/core/hal.h"
@@ -7,7 +7,6 @@

 #ifdef USE_ESP32

-#include <nvs_flash.h>
 #include <freertos/FreeRTOSConfig.h>
 #include <esp_bt_main.h>
 #ifndef CONFIG_BT_CONTROLLER_DISABLED
@@ -16,7 +16,6 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/FreeRTOSConfig.h>
 #include <freertos/task.h>
-#include <nvs_flash.h>
 #include <cinttypes>

 #ifdef USE_OTA
@@ -6,6 +6,8 @@ import esphome.codegen as cg
 from esphome.components import canbus
 from esphome.components.canbus import CONF_BIT_RATE, CanbusComponent, CanSpeed
 from esphome.components.esp32 import (
+    CONF_MINIMUM_CHIP_REVISION,
+    KEY_ESP32,
    VARIANT_ESP32,
    VARIANT_ESP32C3,
    VARIANT_ESP32C5,
@@ -20,6 +22,8 @@ from esphome.components.esp32 import (
 )
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_ADVANCED,
+    CONF_FRAMEWORK,
    CONF_ID,
    CONF_MODE,
    CONF_RX_PIN,
@@ -27,6 +31,7 @@ from esphome.const import (
    CONF_TX_PIN,
    CONF_TX_QUEUE_LEN,
 )
+import esphome.final_validate as fv
 from esphome.types import ConfigType

 CODEOWNERS = ["@Sympatron"]
@@ -42,6 +47,7 @@ CanMode = esp32_can_ns.enum("CanMode")
 CAN_MODES = {
    "NORMAL": CanMode.CAN_MODE_NORMAL,
    "LISTENONLY": CanMode.CAN_MODE_LISTEN_ONLY,
+    "NO_ACK": CanMode.CAN_MODE_NO_ACK,
 }

 # Currently the driver only supports a subset of the bit rates defined in canbus
@@ -49,6 +55,7 @@ CAN_MODES = {
 # See ESP-IDF Programming Guide --> API Reference --> Two-Wire Automotive Interface (TWAI)

 CAN_SPEEDS_ESP32 = {
+    "20KBPS": CanSpeed.CAN_20KBPS,
    "25KBPS": CanSpeed.CAN_25KBPS,
    "50KBPS": CanSpeed.CAN_50KBPS,
    "100KBPS": CanSpeed.CAN_100KBPS,
@@ -114,6 +121,22 @@ CONFIG_SCHEMA = canbus.CANBUS_SCHEMA.extend(
 )


+def _final_validate(config: ConfigType) -> None:
+    if get_esp32_variant() == VARIANT_ESP32 and config[CONF_BIT_RATE] == "20KBPS":
+        esp32_config = fv.full_config.get()[KEY_ESP32]
+        min_revision = esp32_config[CONF_FRAMEWORK][CONF_ADVANCED].get(
+            CONF_MINIMUM_CHIP_REVISION
+        )
+        if min_revision is None or min_revision < "2.0":
+            raise cv.Invalid(
+                "20KBPS on ESP32 requires esp32.framework.advanced.minimum_chip_revision: '2.0' or higher",
+                path=[CONF_BIT_RATE],
+            )
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
 def get_default_tx_enqueue_timeout(bit_rate: str) -> int:
    bit_rate_numeric = canbus.get_rate(bit_rate)
    bits_per_packet = 140  # ~max CAN message length
@@ -33,6 +33,10 @@ static bool get_bitrate(canbus::CanSpeed bitrate, twai_timing_config_t *t_config
    case canbus::CAN_16KBPS:
      *t_config = (twai_timing_config_t) TWAI_TIMING_CONFIG_16KBITS();
      return true;
+#endif
+#if defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32C61) || \
+    defined(USE_ESP32_VARIANT_ESP32H2) || defined(USE_ESP32_VARIANT_ESP32P4) || defined(USE_ESP32_VARIANT_ESP32S2) || \
+    defined(USE_ESP32_VARIANT_ESP32S3) || (defined(USE_ESP32_VARIANT_ESP32) && CONFIG_ESP32_REV_MIN_FULL >= 200)
    case canbus::CAN_20KBPS:
      *t_config = (twai_timing_config_t) TWAI_TIMING_CONFIG_20KBITS();
      return true;
@@ -75,10 +79,13 @@ bool ESP32Can::setup_internal() {
  }

  // Select TWAI mode based on configuration
-  twai_mode_t twai_mode = (this->mode_ == CAN_MODE_LISTEN_ONLY) ? TWAI_MODE_LISTEN_ONLY : TWAI_MODE_NORMAL;
-
+  twai_mode_t twai_mode = TWAI_MODE_NORMAL;
  if (this->mode_ == CAN_MODE_LISTEN_ONLY) {
+    twai_mode = TWAI_MODE_LISTEN_ONLY;
    ESP_LOGI(TAG, "CAN bus configured in LISTEN_ONLY mode (passive, no ACKs)");
+  } else if (this->mode_ == CAN_MODE_NO_ACK) {
+    twai_mode = TWAI_MODE_NO_ACK;
+    ESP_LOGI(TAG, "CAN bus configured in NO_ACK mode (transmit without requiring ACK)");
  }

  twai_general_config_t g_config =
@@ -12,6 +12,7 @@ namespace esphome::esp32_can {
 enum CanMode : uint8_t {
  CAN_MODE_NORMAL = 0,
  CAN_MODE_LISTEN_ONLY = 1,
+  CAN_MODE_NO_ACK = 2,
 };

 class ESP32Can final : public canbus::Canbus {
@@ -2,7 +2,10 @@
 #include <string>
 #include "esphome/components/climate/climate.h"
 #include "esphome/components/uart/uart.h"
+#include "esphome/core/application.h"
+#include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/progmem.h"
 #include "hon_climate.h"
 #include "hon_packet.h"

@@ -11,6 +14,26 @@ using namespace esphome::uart;

 namespace esphome::haier {

+static bool vertical_axis_is_auto(climate::ClimateSwingMode swing_mode) {
+  return (swing_mode == climate::CLIMATE_SWING_VERTICAL) || (swing_mode == climate::CLIMATE_SWING_BOTH);
+}
+
+static bool horizontal_axis_is_auto(climate::ClimateSwingMode swing_mode) {
+  return (swing_mode == climate::CLIMATE_SWING_HORIZONTAL) || (swing_mode == climate::CLIMATE_SWING_BOTH);
+}
+
+static bool is_auto(hon_protocol::VerticalSwingMode mode) {
+  return (mode == hon_protocol::VerticalSwingMode::AUTO) || (mode == hon_protocol::VerticalSwingMode::AUTO_SPECIAL);
+}
+
+static bool is_auto(hon_protocol::HorizontalSwingMode mode) { return mode == hon_protocol::HorizontalSwingMode::AUTO; }
+
+// A position the user just set wins over the appliance's echo of the old one for this long
+constexpr uint32_t AIRFLOW_SELECT_DEBOUNCE_MS = 10000;
+static bool in_debounce(uint32_t set_time, uint32_t now) {
+  return set_time != 0 && now - set_time < AIRFLOW_SELECT_DEBOUNCE_MS;
+}
+
 ESPHOME_LOG_TAG(TAG, "haier.climate");
 constexpr size_t SIGNAL_LEVEL_UPDATE_INTERVAL_MS = 10000;
 constexpr int PROTOCOL_OUTDOOR_TEMPERATURE_OFFSET = -64;
@@ -20,6 +43,27 @@ constexpr size_t ALARM_STATUS_REQUEST_INTERVAL_MS = 600000;
 const uint8_t ONE_BUF[] = {0x00, 0x01};
 const uint8_t ZERO_BUF[] = {0x00, 0x00};

+// Alarm texts indexed by alarm code; the last entry is the fallback for unknown codes
+PROGMEM_STRING_TABLE(
+    HonAlarmMessages, "Outdoor module failure", "Outdoor defrost sensor failure",
+    "Outdoor compressor exhaust sensor failure", "Outdoor EEPROM abnormality", "Indoor coil sensor failure",
+    "Indoor-outdoor communication failure", "Power supply overvoltage protection",
+    "Communication failure between panel and indoor unit", "Outdoor compressor overheat protection",
+    "Outdoor environmental sensor abnormality", "Full water protection", "Indoor EEPROM failure",
+    "Outdoor out air sensor failure", "CBD and module communication failure", "Indoor DC fan failure",
+    "Outdoor DC fan failure", "Door switch failure", "Dust filter needs cleaning reminder", "Water shortage protection",
+    "Humidity sensor failure", "Indoor temperature sensor failure", "Manipulator limit failure",
+    "Indoor PM2.5 sensor failure", "Outdoor PM2.5 sensor failure", "Indoor heating overload/high load alarm",
+    "Outdoor AC current protection", "Outdoor compressor operation abnormality", "Outdoor DC current protection",
+    "Outdoor no-load failure", "CT current abnormality", "Indoor cooling freeze protection",
+    "High and low pressure protection", "Compressor out air temperature is too high",
+    "Outdoor evaporator sensor failure", "Outdoor cooling overload", "Water pump drainage failure",
+    "Three-phase power supply failure", "Four-way valve failure", "External alarm/scraper flow switch failure",
+    "Temperature cutoff protection alarm", "Different mode operation failure", "Electronic expansion valve failure",
+    "Dual heat source sensor Tw failure", "Communication failure with the wired controller",
+    "Indoor unit address duplication failure", "50Hz zero crossing failure", "Outdoor unit failure",
+    "Formaldehyde sensor failure", "VOC sensor failure", "CO2 sensor failure", "Firewall failure", "Unknown");
+
 HonClimate::HonClimate()
    : cleaning_status_(CleaningState::NO_CLEANING), got_valid_outdoor_temp_(false), active_alarms_{0x00, 0x00, 0x00,
                                                                                                   0x00, 0x00, 0x00,
@@ -67,21 +111,60 @@ bool HonClimate::get_quiet_mode_state() const {
 }

 esphome::optional<hon_protocol::VerticalSwingMode> HonClimate::get_vertical_airflow() const {
+  if (!this->current_vertical_swing_.has_value()) {
+    return this->current_vertical_swing_;
+  }
+  // While the appliance swings, or right after the user chose a position, report the chosen position
+  if (is_auto(this->current_vertical_swing_.value()) ||
+      in_debounce(this->vertical_direction_set_time_, App.get_loop_component_start_time())) {
+    return this->settings_.last_vertiacal_swing;
+  }
  return this->current_vertical_swing_;
-};
+}

 void HonClimate::set_vertical_airflow(hon_protocol::VerticalSwingMode direction) {
+  if (is_auto(direction)) {
+    ESP_LOGW(TAG, "Vertical AUTO mode is not allowed for airflow position selector");
+    return;
+  }
+  if (this->settings_.last_vertiacal_swing != direction) {
+    this->settings_.last_vertiacal_swing = direction;
+    this->hon_rtc_.save(&this->settings_);
+  }
  this->pending_vertical_direction_ = direction;
  this->force_send_control_ = true;
+  this->vertical_direction_set_time_ = App.get_loop_component_start_time();
+#ifdef USE_SELECT
+  this->publish_airflow_selects_();
+#endif
 }

 esphome::optional<hon_protocol::HorizontalSwingMode> HonClimate::get_horizontal_airflow() const {
+  if (!this->current_horizontal_swing_.has_value()) {
+    return this->current_horizontal_swing_;
+  }
+  if (is_auto(this->current_horizontal_swing_.value()) ||
+      in_debounce(this->horizontal_direction_set_time_, App.get_loop_component_start_time())) {
+    return this->settings_.last_horizontal_swing;
+  }
  return this->current_horizontal_swing_;
 }

 void HonClimate::set_horizontal_airflow(hon_protocol::HorizontalSwingMode direction) {
+  if (is_auto(direction)) {
+    ESP_LOGW(TAG, "Horizontal AUTO mode is not allowed for airflow position selector");
+    return;
+  }
+  if (this->settings_.last_horizontal_swing != direction) {
+    this->settings_.last_horizontal_swing = direction;
+    this->hon_rtc_.save(&this->settings_);
+  }
  this->pending_horizontal_direction_ = direction;
  this->force_send_control_ = true;
+  this->horizontal_direction_set_time_ = App.get_loop_component_start_time();
+#ifdef USE_SELECT
+  this->publish_airflow_selects_();
+#endif
 }

 const char *HonClimate::get_cleaning_status_text() const {
@@ -511,6 +594,18 @@ void HonClimate::initialization() {
  } else {
    this->settings_ = {hon_protocol::VerticalSwingMode::CENTER, hon_protocol::HorizontalSwingMode::CENTER, true, false};
  }
+  bool settings_fixed = false;
+  if (is_auto(this->settings_.last_vertiacal_swing)) {
+    this->settings_.last_vertiacal_swing = hon_protocol::VerticalSwingMode::CENTER;
+    settings_fixed = true;
+  }
+  if (is_auto(this->settings_.last_horizontal_swing)) {
+    this->settings_.last_horizontal_swing = hon_protocol::HorizontalSwingMode::CENTER;
+    settings_fixed = true;
+  }
+  if (settings_fixed) {
+    this->hon_rtc_.save(&this->settings_);
+  }
  this->current_vertical_swing_ = this->settings_.last_vertiacal_swing;
  this->current_horizontal_swing_ = this->settings_.last_horizontal_swing;
  this->quiet_mode_state_ = this->settings_.quiet_mode_state ? SwitchState::SWITCH_ON : SwitchState::SWITCH_OFF;
@@ -646,12 +741,21 @@ haier_protocol::HaierMessage HonClimate::get_control_message() {
      }
    }
  }
+  const ClimateSwingMode target_swing_mode = this->current_hvac_settings_.swing_mode.value_or(this->swing_mode);
  if (this->pending_vertical_direction_.has_value()) {
-    out_data->vertical_swing_mode = (uint8_t) this->pending_vertical_direction_.value();
+    if (!vertical_axis_is_auto(target_swing_mode)) {
+      out_data->vertical_swing_mode = (uint8_t) this->pending_vertical_direction_.value();
+    } else {
+      ESP_LOGD(TAG, "Vertical swing is on; the position is kept for when it is turned off");
+    }
    this->pending_vertical_direction_.reset();
  }
  if (this->pending_horizontal_direction_.has_value()) {
-    out_data->horizontal_swing_mode = (uint8_t) this->pending_horizontal_direction_.value();
+    if (!horizontal_axis_is_auto(target_swing_mode)) {
+      out_data->horizontal_swing_mode = (uint8_t) this->pending_horizontal_direction_.value();
+    } else {
+      ESP_LOGD(TAG, "Horizontal swing is on; the position is kept for when it is turned off");
+    }
    this->pending_horizontal_direction_.reset();
  }
  {
@@ -687,9 +791,17 @@ void HonClimate::process_alarm_message_(const uint8_t *packet, uint8_t size, boo
            if ((packet[2 + i] & alarm_bit) != (this->active_alarms_[i] & alarm_bit)) {
              bool alarm_status = (packet[2 + i] & alarm_bit) != 0;
              int log_level = alarm_status ? ESPHOME_LOG_LEVEL_WARN : ESPHOME_LOG_LEVEL_INFO;
-              const char *alarm_message = alarm_code < esphome::haier::hon_protocol::HON_ALARM_COUNT
-                                              ? esphome::haier::hon_protocol::HON_ALARM_MESSAGES[alarm_code].c_str()
-                                              : "Unknown";
+#ifdef USE_ESP8266
+              // Static so a delayed on_alarm automation can still read it, but only until the next
+              // alarm change, including a later one in this packet; `code` stays correct
+              static char alarm_message[HonAlarmMessages::MAX_LENGTH + 1];
+              ESPHOME_strncpy_P(alarm_message,
+                                reinterpret_cast<const char *>(
+                                    HonAlarmMessages::get_progmem_str(alarm_code, HonAlarmMessages::LAST_INDEX)),
+                                sizeof(alarm_message));
+#else
+              const char *alarm_message = HonAlarmMessages::get_progmem_str(alarm_code, HonAlarmMessages::LAST_INDEX);
+#endif
              esp_log_printf_(log_level, TAG, __LINE__, "Alarm %s (%d): %s", alarm_status ? "activated" : "deactivated",
                              alarm_code, alarm_message);
              if (alarm_status) {
@@ -810,6 +922,41 @@ void HonClimate::set_quiet_mode_switch(switch_::Switch *sw) {
 }
 #endif  // USE_SWITCH

+#ifdef USE_SELECT
+template<typename Mode, size_t N>
+static void publish_airflow_index(select::Select *sel, const std::array<Mode, N> &order, Mode mode) {
+  if (sel == nullptr) {
+    return;
+  }
+  // Saved settings never hold AUTO after initialization(); any other value outside the table shows as Center
+  size_t index = N;
+  size_t center = 0;
+  for (size_t i = 0; i < N; i++) {
+    const Mode entry = airflow_order_at(order, i);
+    if (entry == mode) {
+      index = i;
+    } else if (entry == Mode::CENTER) {
+      center = i;
+    }
+  }
+  if (index == N) {
+    index = center;
+  }
+  const auto active = sel->active_index();
+  if (active.has_value() && *active == index) {
+    return;
+  }
+  sel->publish_state(index);
+}
+
+void HonClimate::publish_airflow_selects_() {
+  publish_airflow_index(this->vertical_airflow_select_, VERTICAL_SWING_MODES_ORDER,
+                        this->settings_.last_vertiacal_swing);
+  publish_airflow_index(this->horizontal_airflow_select_, HORIZONTAL_SWING_MODES_ORDER,
+                        this->settings_.last_horizontal_swing);
+}
+#endif  // USE_SELECT
+
 haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *packet_buffer, uint8_t size) {
  size_t expected_size =
      2 + this->status_message_header_size_ + this->real_control_packet_size_ + this->real_sensors_packet_size_;
@@ -1044,16 +1191,25 @@ haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *
    // Saving last known non auto mode for vertical and horizontal swing
    this->current_vertical_swing_ = (hon_protocol::VerticalSwingMode) packet.control.vertical_swing_mode;
    this->current_horizontal_swing_ = (hon_protocol::HorizontalSwingMode) packet.control.horizontal_swing_mode;
-    bool save_settings = ((this->current_vertical_swing_.value() != hon_protocol::VerticalSwingMode::AUTO) &&
-                          (this->current_vertical_swing_.value() != hon_protocol::VerticalSwingMode::AUTO_SPECIAL) &&
-                          (this->current_vertical_swing_.value() != this->settings_.last_vertiacal_swing)) ||
-                         ((this->current_horizontal_swing_.value() != hon_protocol::HorizontalSwingMode::AUTO) &&
-                          (this->current_horizontal_swing_.value() != this->settings_.last_horizontal_swing));
-    if (save_settings) {
-      this->settings_.last_vertiacal_swing = this->current_vertical_swing_.value();
-      this->settings_.last_horizontal_swing = this->current_horizontal_swing_.value();
+    const uint32_t now_ms = App.get_loop_component_start_time();
+    bool save_vertical = !in_debounce(this->vertical_direction_set_time_, now_ms) &&
+                         !is_auto(this->current_vertical_swing_.value()) &&
+                         (this->current_vertical_swing_.value() != this->settings_.last_vertiacal_swing);
+    bool save_horizontal = !in_debounce(this->horizontal_direction_set_time_, now_ms) &&
+                           !is_auto(this->current_horizontal_swing_.value()) &&
+                           (this->current_horizontal_swing_.value() != this->settings_.last_horizontal_swing);
+    if (save_vertical || save_horizontal) {
+      if (save_vertical) {
+        this->settings_.last_vertiacal_swing = this->current_vertical_swing_.value();
+      }
+      if (save_horizontal) {
+        this->settings_.last_horizontal_swing = this->current_horizontal_swing_.value();
+      }
      this->hon_rtc_.save(&this->settings_);
    }
+#ifdef USE_SELECT
+    this->publish_airflow_selects_();
+#endif
    should_publish = should_publish || (old_swing_mode != this->swing_mode);
  }
  this->last_valid_status_timestamp_ = std::chrono::steady_clock::now();
@@ -1229,8 +1385,10 @@ void HonClimate::fill_control_messages_queue_() {
                                              (uint8_t) hon_protocol::DataParameters::SET_POINT,
                                          buffer, 2);
  }
+  ClimateSwingMode target_swing_mode = this->swing_mode;
  // Vertical swing mode
  if (climate_control.swing_mode.has_value()) {
+    target_swing_mode = climate_control.swing_mode.value();
    uint8_t vertical_swing_buf[] = {0x00, (uint8_t) hon_protocol::VerticalSwingMode::AUTO};
    uint8_t horizontal_swing_buf[] = {0x00, (uint8_t) hon_protocol::HorizontalSwingMode::AUTO};
    switch (climate_control.swing_mode.value()) {
@@ -1256,6 +1414,32 @@ void HonClimate::fill_control_messages_queue_() {
                                              (uint8_t) hon_protocol::DataParameters::VERTICAL_SWING_MODE,
                                          vertical_swing_buf, 2);
  }
+  // A swing change above already sent both axes from settings_.last_*, which set_*_airflow() updated
+  const bool swing_sent = climate_control.swing_mode.has_value();
+  if (this->pending_vertical_direction_.has_value()) {
+    if (vertical_axis_is_auto(target_swing_mode)) {
+      ESP_LOGD(TAG, "Vertical swing is on; the position is kept for when it is turned off");
+    } else if (!swing_sent) {
+      uint8_t vertical_swing_buf[] = {0x00, (uint8_t) this->pending_vertical_direction_.value()};
+      this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
+                                            (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
+                                                (uint8_t) hon_protocol::DataParameters::VERTICAL_SWING_MODE,
+                                            vertical_swing_buf, 2);
+    }
+    this->pending_vertical_direction_.reset();
+  }
+  if (this->pending_horizontal_direction_.has_value()) {
+    if (horizontal_axis_is_auto(target_swing_mode)) {
+      ESP_LOGD(TAG, "Horizontal swing is on; the position is kept for when it is turned off");
+    } else if (!swing_sent) {
+      uint8_t horizontal_swing_buf[] = {0x00, (uint8_t) this->pending_horizontal_direction_.value()};
+      this->control_messages_queue_.emplace(haier_protocol::FrameType::CONTROL,
+                                            (uint16_t) hon_protocol::SubcommandsControl::SET_SINGLE_PARAMETER +
+                                                (uint8_t) hon_protocol::DataParameters::HORIZONTAL_SWING_MODE,
+                                            horizontal_swing_buf, 2);
+    }
+    this->pending_horizontal_direction_.reset();
+  }
  // Fan mode
  if (climate_control.fan_mode.has_value()) {
    switch (climate_control.fan_mode.value()) {
@@ -1,5 +1,6 @@
 #pragma once

+#include <array>
 #include <chrono>
 #include <queue>
 #ifdef USE_SENSOR
@@ -14,12 +15,36 @@
 #ifdef USE_SWITCH
 #include "esphome/components/switch/switch.h"
 #endif
+#ifdef USE_SELECT
+#include "esphome/components/select/select.h"
+#endif
 #include "esphome/core/automation.h"
+#include "esphome/core/hal.h"
 #include "haier_base.h"
 #include "hon_packet.h"

 namespace esphome::haier {

+#ifdef USE_SELECT
+// Positions in the order the select platform lists them; in flash on ESP8266, so read with airflow_order_at()
+inline constexpr std::array<hon_protocol::VerticalSwingMode, 7> VERTICAL_SWING_MODES_ORDER PROGMEM{
+    hon_protocol::VerticalSwingMode::HEALTH_UP,   hon_protocol::VerticalSwingMode::MAX_UP,
+    hon_protocol::VerticalSwingMode::UP,          hon_protocol::VerticalSwingMode::CENTER,
+    hon_protocol::VerticalSwingMode::DOWN,        hon_protocol::VerticalSwingMode::MAX_DOWN,
+    hon_protocol::VerticalSwingMode::HEALTH_DOWN,
+};
+inline constexpr std::array<hon_protocol::HorizontalSwingMode, 5> HORIZONTAL_SWING_MODES_ORDER PROGMEM{
+    hon_protocol::HorizontalSwingMode::MAX_LEFT,  hon_protocol::HorizontalSwingMode::LEFT,
+    hon_protocol::HorizontalSwingMode::CENTER,    hon_protocol::HorizontalSwingMode::RIGHT,
+    hon_protocol::HorizontalSwingMode::MAX_RIGHT,
+};
+
+template<typename Mode, size_t N> Mode airflow_order_at(const std::array<Mode, N> &order, size_t index) {
+  static_assert(sizeof(Mode) == 1);
+  return static_cast<Mode>(progmem_read_byte(reinterpret_cast<const uint8_t *>(order.data() + index)));
+}
+#endif
+
 enum class CleaningState : uint8_t {
  NO_CLEANING = 0,
  SELF_CLEAN = 1,
@@ -100,6 +125,16 @@ class HonClimate final : public HaierClimateBase {
 protected:
  switch_::Switch *beeper_switch_{nullptr};
  switch_::Switch *quiet_mode_switch_{nullptr};
+#endif
+#ifdef USE_SELECT
+ public:
+  void set_vertical_airflow_select(select::Select *sel) { this->vertical_airflow_select_ = sel; }
+  void set_horizontal_airflow_select(select::Select *sel) { this->horizontal_airflow_select_ = sel; }
+
+ protected:
+  void publish_airflow_selects_();
+  select::Select *vertical_airflow_select_{nullptr};
+  select::Select *horizontal_airflow_select_{nullptr};
 #endif
 public:
  HonClimate();
@@ -195,6 +230,9 @@ class HonClimate final : public HaierClimateBase {
  uint8_t big_data_counter_{0};
  esphome::optional<hon_protocol::VerticalSwingMode> current_vertical_swing_{};
  esphome::optional<hon_protocol::HorizontalSwingMode> current_horizontal_swing_{};
+  // millis() of the last user-set position per axis, 0 when none
+  uint32_t vertical_direction_set_time_{0};
+  uint32_t horizontal_direction_set_time_{0};
  HonSettings settings_{};
  ESPPreferenceObject hon_rtc_;
  SwitchState quiet_mode_state_{SwitchState::SWITCH_OFF};
@@ -197,60 +197,4 @@ enum class SubcommandsControl : uint16_t {
                                  // content: all values like in status packet)
 };

-const std::string HON_ALARM_MESSAGES[] = {
-    "Outdoor module failure",
-    "Outdoor defrost sensor failure",
-    "Outdoor compressor exhaust sensor failure",
-    "Outdoor EEPROM abnormality",
-    "Indoor coil sensor failure",
-    "Indoor-outdoor communication failure",
-    "Power supply overvoltage protection",
-    "Communication failure between panel and indoor unit",
-    "Outdoor compressor overheat protection",
-    "Outdoor environmental sensor abnormality",
-    "Full water protection",
-    "Indoor EEPROM failure",
-    "Outdoor out air sensor failure",
-    "CBD and module communication failure",
-    "Indoor DC fan failure",
-    "Outdoor DC fan failure",
-    "Door switch failure",
-    "Dust filter needs cleaning reminder",
-    "Water shortage protection",
-    "Humidity sensor failure",
-    "Indoor temperature sensor failure",
-    "Manipulator limit failure",
-    "Indoor PM2.5 sensor failure",
-    "Outdoor PM2.5 sensor failure",
-    "Indoor heating overload/high load alarm",
-    "Outdoor AC current protection",
-    "Outdoor compressor operation abnormality",
-    "Outdoor DC current protection",
-    "Outdoor no-load failure",
-    "CT current abnormality",
-    "Indoor cooling freeze protection",
-    "High and low pressure protection",
-    "Compressor out air temperature is too high",
-    "Outdoor evaporator sensor failure",
-    "Outdoor cooling overload",
-    "Water pump drainage failure",
-    "Three-phase power supply failure",
-    "Four-way valve failure",
-    "External alarm/scraper flow switch failure",
-    "Temperature cutoff protection alarm",
-    "Different mode operation failure",
-    "Electronic expansion valve failure",
-    "Dual heat source sensor Tw failure",
-    "Communication failure with the wired controller",
-    "Indoor unit address duplication failure",
-    "50Hz zero crossing failure",
-    "Outdoor unit failure",
-    "Formaldehyde sensor failure",
-    "VOC sensor failure",
-    "CO2 sensor failure",
-    "Firewall failure",
-};
-
-constexpr size_t HON_ALARM_COUNT = sizeof(HON_ALARM_MESSAGES) / sizeof(HON_ALARM_MESSAGES[0]);
-
 }  // namespace esphome::haier::hon_protocol
@@ -0,0 +1,67 @@
+import esphome.codegen as cg
+from esphome.components import select
+import esphome.config_validation as cv
+from esphome.const import ENTITY_CATEGORY_CONFIG
+from esphome.types import ConfigType
+
+from ..climate import (
+    CONF_HAIER_ID,
+    CONF_HORIZONTAL_AIRFLOW,
+    CONF_VERTICAL_AIRFLOW,
+    HonClimate,
+    haier_ns,
+)
+
+CODEOWNERS = ["@paveldn"]
+VerticalAirflowSelect = haier_ns.class_("VerticalAirflowSelect", select.Select)
+HorizontalAirflowSelect = haier_ns.class_("HorizontalAirflowSelect", select.Select)
+
+# Same order as VERTICAL_SWING_MODES_ORDER and HORIZONTAL_SWING_MODES_ORDER in hon_climate.h
+AIRFLOW_VERTICAL_DIRECTION_OPTIONS = [
+    "Health Up",
+    "Max Up",
+    "Up",
+    "Center",
+    "Down",
+    "Max Down",
+    "Health Down",
+]
+
+AIRFLOW_HORIZONTAL_DIRECTION_OPTIONS = [
+    "Max Left",
+    "Left",
+    "Center",
+    "Right",
+    "Max Right",
+]
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_HAIER_ID): cv.use_id(HonClimate),
+        cv.Optional(CONF_VERTICAL_AIRFLOW): select.select_schema(
+            VerticalAirflowSelect,
+            icon="mdi:arrow-expand-vertical",
+            entity_category=ENTITY_CATEGORY_CONFIG,
+        ),
+        cv.Optional(CONF_HORIZONTAL_AIRFLOW): select.select_schema(
+            HorizontalAirflowSelect,
+            icon="mdi:arrow-expand-horizontal",
+            entity_category=ENTITY_CATEGORY_CONFIG,
+        ),
+    }
+)
+
+
+async def to_code(config: ConfigType) -> None:
+    hub = await cg.get_variable(config[CONF_HAIER_ID])
+    selects = select.sub_selects(config, parent=hub)
+    await selects(
+        CONF_VERTICAL_AIRFLOW,
+        hub.set_vertical_airflow_select,
+        options=AIRFLOW_VERTICAL_DIRECTION_OPTIONS,
+    )
+    await selects(
+        CONF_HORIZONTAL_AIRFLOW,
+        hub.set_horizontal_airflow_select,
+        options=AIRFLOW_HORIZONTAL_DIRECTION_OPTIONS,
+    )
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "esphome/components/select/select.h"
+#include "../hon_climate.h"
+
+namespace esphome::haier {
+
+class HorizontalAirflowSelect : public select::Select, public Parented<HonClimate> {
+ protected:
+  void control(size_t index) override {
+    this->parent_->set_horizontal_airflow(airflow_order_at(HORIZONTAL_SWING_MODES_ORDER, index));
+  }
+};
+
+}  // namespace esphome::haier
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "esphome/components/select/select.h"
+#include "../hon_climate.h"
+
+namespace esphome::haier {
+
+class VerticalAirflowSelect : public select::Select, public Parented<HonClimate> {
+ protected:
+  void control(size_t index) override {
+    this->parent_->set_vertical_airflow(airflow_order_at(VERTICAL_SWING_MODES_ORDER, index));
+  }
+};
+
+}  // namespace esphome::haier
@@ -126,8 +126,8 @@ CONFIG_SCHEMA = cv.All(


 async def to_code(config: ConfigType) -> None:
-    var = await climate_ir.new_climate_ir(config)
-    cg.add(var.set_protocol(config[CONF_PROTOCOL]))
+    tag = heatpumpir_ns.ProtocolTag.template(config[CONF_PROTOCOL])
+    var = await climate_ir.new_climate_ir(config, tag())
    cg.add(var.set_horizontal_default(config[CONF_HORIZONTAL_DEFAULT]))
    cg.add(var.set_vertical_default(config[CONF_VERTICAL_DEFAULT]))
    cg.add(var.set_max_temperature(config[CONF_MAX_TEMPERATURE]))
@@ -5,7 +5,6 @@
 #if defined(USE_ARDUINO) || defined(USE_ESP32)

 #include <cmath>
-#include <map>
 #include <IRSender.h>
 #include <HeatpumpIRFactory.h>
 #include "esphome/components/remote_base/remote_base.h"
@@ -45,71 +44,76 @@ class IRSenderESPHome : public IRSender {

 ESPHOME_LOG_TAG(TAG, "heatpumpir.climate");

-const std::map<Protocol, std::function<HeatpumpIR *()>> PROTOCOL_CONSTRUCTOR_MAP = {
-    {PROTOCOL_AUX, []() { return new AUXHeatpumpIR(); }},                                    // NOLINT
-    {PROTOCOL_BALLU, []() { return new BalluHeatpumpIR(); }},                                // NOLINT
-    {PROTOCOL_CARRIER_MCA, []() { return new CarrierMCAHeatpumpIR(); }},                     // NOLINT
-    {PROTOCOL_CARRIER_NQV, []() { return new CarrierNQVHeatpumpIR(); }},                     // NOLINT
-    {PROTOCOL_DAIKIN_ARC417, []() { return new DaikinHeatpumpARC417IR(); }},                 // NOLINT
-    {PROTOCOL_DAIKIN_ARC480, []() { return new DaikinHeatpumpARC480A14IR(); }},              // NOLINT
-    {PROTOCOL_DAIKIN, []() { return new DaikinHeatpumpIR(); }},                              // NOLINT
-    {PROTOCOL_ELECTROLUXYAL, []() { return new ElectroluxYALHeatpumpIR(); }},                // NOLINT
-    {PROTOCOL_FUEGO, []() { return new FuegoHeatpumpIR(); }},                                // NOLINT
-    {PROTOCOL_FUJITSU_AWYZ, []() { return new FujitsuHeatpumpIR(); }},                       // NOLINT
-    {PROTOCOL_GREE, []() { return new GreeGenericHeatpumpIR(); }},                           // NOLINT
-    {PROTOCOL_GREEYAA, []() { return new GreeYAAHeatpumpIR(); }},                            // NOLINT
-    {PROTOCOL_GREEYAN, []() { return new GreeYANHeatpumpIR(); }},                            // NOLINT
-    {PROTOCOL_GREEYAC, []() { return new GreeYACHeatpumpIR(); }},                            // NOLINT
-    {PROTOCOL_GREEYT, []() { return new GreeYTHeatpumpIR(); }},                              // NOLINT
-    {PROTOCOL_GREEYAP, []() { return new GreeYAPHeatpumpIR(); }},                            // NOLINT
-    {PROTOCOL_HISENSE_AUD, []() { return new HisenseHeatpumpIR(); }},                        // NOLINT
-    {PROTOCOL_HITACHI, []() { return new HitachiHeatpumpIR(); }},                            // NOLINT
-    {PROTOCOL_HYUNDAI, []() { return new HyundaiHeatpumpIR(); }},                            // NOLINT
-    {PROTOCOL_IVT, []() { return new IVTHeatpumpIR(); }},                                    // NOLINT
-    {PROTOCOL_MIDEA, []() { return new MideaHeatpumpIR(); }},                                // NOLINT
-    {PROTOCOL_MITSUBISHI_FA, []() { return new MitsubishiFAHeatpumpIR(); }},                 // NOLINT
-    {PROTOCOL_MITSUBISHI_FD, []() { return new MitsubishiFDHeatpumpIR(); }},                 // NOLINT
-    {PROTOCOL_MITSUBISHI_FE, []() { return new MitsubishiFEHeatpumpIR(); }},                 // NOLINT
-    {PROTOCOL_MITSUBISHI_HEAVY_FDTC, []() { return new MitsubishiHeavyFDTCHeatpumpIR(); }},  // NOLINT
-    {PROTOCOL_MITSUBISHI_HEAVY_ZJ, []() { return new MitsubishiHeavyZJHeatpumpIR(); }},      // NOLINT
-    {PROTOCOL_MITSUBISHI_HEAVY_ZM, []() { return new MitsubishiHeavyZMHeatpumpIR(); }},      // NOLINT
-    {PROTOCOL_MITSUBISHI_HEAVY_ZMP, []() { return new MitsubishiHeavyZMPHeatpumpIR(); }},    // NOLINT
-    {PROTOCOL_MITSUBISHI_KJ, []() { return new MitsubishiKJHeatpumpIR(); }},                 // NOLINT
-    {PROTOCOL_MITSUBISHI_MSC, []() { return new MitsubishiMSCHeatpumpIR(); }},               // NOLINT
-    {PROTOCOL_MITSUBISHI_MSY, []() { return new MitsubishiMSYHeatpumpIR(); }},               // NOLINT
-    {PROTOCOL_MITSUBISHI_SEZ, []() { return new MitsubishiSEZKDXXHeatpumpIR(); }},           // NOLINT
-    {PROTOCOL_PANASONIC_CKP, []() { return new PanasonicCKPHeatpumpIR(); }},                 // NOLINT
-    {PROTOCOL_PANASONIC_DKE, []() { return new PanasonicDKEHeatpumpIR(); }},                 // NOLINT
-    {PROTOCOL_PANASONIC_EKE, []() { return new PanasonicEKEHeatpumpIR(); }},                 // NOLINT
-    {PROTOCOL_PANASONIC_JKE, []() { return new PanasonicJKEHeatpumpIR(); }},                 // NOLINT
-    {PROTOCOL_PANASONIC_LKE, []() { return new PanasonicLKEHeatpumpIR(); }},                 // NOLINT
-    {PROTOCOL_PANASONIC_NKE, []() { return new PanasonicNKEHeatpumpIR(); }},                 // NOLINT
-    {PROTOCOL_SAMSUNG_AQV, []() { return new SamsungAQVHeatpumpIR(); }},                     // NOLINT
-    {PROTOCOL_SAMSUNG_FJM, []() { return new SamsungFJMHeatpumpIR(); }},                     // NOLINT
-    {PROTOCOL_SHARP, []() { return new SharpHeatpumpIR(); }},                                // NOLINT
-    {PROTOCOL_TOSHIBA_DAISEIKAI, []() { return new ToshibaDaiseikaiHeatpumpIR(); }},         // NOLINT
-    {PROTOCOL_TOSHIBA, []() { return new ToshibaHeatpumpIR(); }},                            // NOLINT
-    {PROTOCOL_ZHLT01, []() { return new ZHLT01HeatpumpIR(); }},                              // NOLINT
-    {PROTOCOL_NIBE, []() { return new NibeHeatpumpIR(); }},                                  // NOLINT
-    {PROTOCOL_QLIMA_1, []() { return new Qlima1HeatpumpIR(); }},                             // NOLINT
-    {PROTOCOL_QLIMA_2, []() { return new Qlima2HeatpumpIR(); }},                             // NOLINT
-    {PROTOCOL_SAMSUNG_AQV12MSAN, []() { return new SamsungAQV12MSANHeatpumpIR(); }},         // NOLINT
-    {PROTOCOL_ZHJG01, []() { return new ZHJG01HeatpumpIR(); }},                              // NOLINT
-    {PROTOCOL_AIRWAY, []() { return new AIRWAYHeatpumpIR(); }},                              // NOLINT
-    {PROTOCOL_BGH_AUD, []() { return new BGHHeatpumpIR(); }},                                // NOLINT
-    {PROTOCOL_PANASONIC_ALTDKE, []() { return new PanasonicAltDKEHeatpumpIR(); }},           // NOLINT
-    {PROTOCOL_PHILCO_PHS32, []() { return new PhilcoPHS32HeatpumpIR(); }},                   // NOLINT
-    {PROTOCOL_VAILLANTVAI8, []() { return new VaillantHeatpumpIR(); }},                      // NOLINT
-    {PROTOCOL_R51M, []() { return new R51MHeatpumpIR(); }},                                  // NOLINT
-};
+template<Protocol P> struct ProtocolClass;
+
+template<Protocol P> HeatpumpIR *create_heatpump_ir() {
+  return new typename ProtocolClass<P>::type();  // NOLINT
+}
+
+// Codegen calls only the configured protocols, so the linker drops the other classes
+#define HEATPUMPIR_PROTOCOL(protocol, cls) \
+  template<> struct ProtocolClass<protocol> { using type = cls; }; \
+  template HeatpumpIR *create_heatpump_ir<protocol>();
+
+HEATPUMPIR_PROTOCOL(PROTOCOL_AUX, AUXHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_BALLU, BalluHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_CARRIER_MCA, CarrierMCAHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_CARRIER_NQV, CarrierNQVHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_DAIKIN_ARC417, DaikinHeatpumpARC417IR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_DAIKIN_ARC480, DaikinHeatpumpARC480A14IR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_DAIKIN, DaikinHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_ELECTROLUXYAL, ElectroluxYALHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_FUEGO, FuegoHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_FUJITSU_AWYZ, FujitsuHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_GREE, GreeGenericHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_GREEYAA, GreeYAAHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_GREEYAN, GreeYANHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_GREEYAC, GreeYACHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_GREEYT, GreeYTHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_GREEYAP, GreeYAPHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_HISENSE_AUD, HisenseHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_HITACHI, HitachiHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_HYUNDAI, HyundaiHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_IVT, IVTHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_MIDEA, MideaHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_MITSUBISHI_FA, MitsubishiFAHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_MITSUBISHI_FD, MitsubishiFDHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_MITSUBISHI_FE, MitsubishiFEHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_MITSUBISHI_HEAVY_FDTC, MitsubishiHeavyFDTCHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_MITSUBISHI_HEAVY_ZJ, MitsubishiHeavyZJHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_MITSUBISHI_HEAVY_ZM, MitsubishiHeavyZMHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_MITSUBISHI_HEAVY_ZMP, MitsubishiHeavyZMPHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_MITSUBISHI_KJ, MitsubishiKJHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_MITSUBISHI_MSC, MitsubishiMSCHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_MITSUBISHI_MSY, MitsubishiMSYHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_MITSUBISHI_SEZ, MitsubishiSEZKDXXHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_PANASONIC_CKP, PanasonicCKPHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_PANASONIC_DKE, PanasonicDKEHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_PANASONIC_EKE, PanasonicEKEHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_PANASONIC_JKE, PanasonicJKEHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_PANASONIC_LKE, PanasonicLKEHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_PANASONIC_NKE, PanasonicNKEHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_SAMSUNG_AQV, SamsungAQVHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_SAMSUNG_FJM, SamsungFJMHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_SHARP, SharpHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_TOSHIBA_DAISEIKAI, ToshibaDaiseikaiHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_TOSHIBA, ToshibaHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_ZHLT01, ZHLT01HeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_NIBE, NibeHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_QLIMA_1, Qlima1HeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_QLIMA_2, Qlima2HeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_SAMSUNG_AQV12MSAN, SamsungAQV12MSANHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_ZHJG01, ZHJG01HeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_AIRWAY, AIRWAYHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_BGH_AUD, BGHHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_PANASONIC_ALTDKE, PanasonicAltDKEHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_PHILCO_PHS32, PhilcoPHS32HeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_VAILLANTVAI8, VaillantHeatpumpIR)
+HEATPUMPIR_PROTOCOL(PROTOCOL_R51M, R51MHeatpumpIR)
+
+#undef HEATPUMPIR_PROTOCOL

 void HeatpumpIRClimate::setup() {
-  auto protocol_constructor = PROTOCOL_CONSTRUCTOR_MAP.find(protocol_);
-  if (protocol_constructor == PROTOCOL_CONSTRUCTOR_MAP.end()) {
-    ESP_LOGE(TAG, "Invalid protocol");
-    return;
-  }
-  this->heatpump_ir_ = protocol_constructor->second();
  climate_ir::ClimateIR::setup();
  if (this->sensor_) {
    this->sensor_->add_on_state_callback([this](float state) {
@@ -89,25 +89,21 @@ enum VerticalDirection {
  VERTICAL_DIRECTION_DOWN = 5,
 };

+/// Creates the HeatpumpIR library class for a protocol; instantiated in heatpumpir.cpp.
+template<Protocol P> HeatpumpIR *create_heatpump_ir();
+
+/// Selects the protocol at compile time so the enum and the library object always match.
+template<Protocol P> struct ProtocolTag {};
+
 // Temperature
 const float TEMP_MIN = 0;    // Celsius
 const float TEMP_MAX = 100;  // Celsius

 class HeatpumpIRClimate final : public climate_ir::ClimateIR {
 public:
-  HeatpumpIRClimate()
-      : climate_ir::ClimateIR(TEMP_MIN, TEMP_MAX, 1.0f, true, true,
-                              {climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM, climate::CLIMATE_FAN_HIGH,
-                               climate::CLIMATE_FAN_AUTO},
-                              {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_HORIZONTAL,
-                               climate::CLIMATE_SWING_VERTICAL, climate::CLIMATE_SWING_BOTH}) {}
+  template<Protocol P>
+  explicit HeatpumpIRClimate(ProtocolTag<P> /*tag*/) : HeatpumpIRClimate(P, create_heatpump_ir<P>()) {}
  void setup() override;
-  void set_protocol(Protocol protocol) {
-    this->protocol_ = protocol;
-    if (this->has_fan_byte_presets_()) {
-      this->presets_ = {climate::CLIMATE_PRESET_NONE, climate::CLIMATE_PRESET_ECO, climate::CLIMATE_PRESET_BOOST};
-    }
-  }
  void set_horizontal_default(HorizontalDirection horizontal_direction) {
    this->default_horizontal_direction_ = horizontal_direction;
  }
@@ -119,6 +115,18 @@ class HeatpumpIRClimate final : public climate_ir::ClimateIR {
  void set_min_temperature(float temperature) { this->min_temperature_ = temperature; }

 protected:
+  HeatpumpIRClimate(Protocol protocol, HeatpumpIR *heatpump_ir)
+      : climate_ir::ClimateIR(TEMP_MIN, TEMP_MAX, 1.0f, true, true,
+                              {climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM, climate::CLIMATE_FAN_HIGH,
+                               climate::CLIMATE_FAN_AUTO},
+                              {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_HORIZONTAL,
+                               climate::CLIMATE_SWING_VERTICAL, climate::CLIMATE_SWING_BOTH}),
+        heatpump_ir_(heatpump_ir),
+        protocol_(protocol) {
+    if (this->has_fan_byte_presets_()) {
+      this->presets_ = {climate::CLIMATE_PRESET_NONE, climate::CLIMATE_PRESET_ECO, climate::CLIMATE_PRESET_BOOST};
+    }
+  }
  HeatpumpIR *heatpump_ir_;
  void control(const climate::ClimateCall &call) override;
  /// Transmit via IR the state of this climate controller.
@@ -59,8 +59,8 @@ namespace esphome::host {
 char **get_argv() { return s_argv; }

 const std::string &get_exe_path() {
-  static const std::string empty;
-  return s_exe_path != nullptr ? *s_exe_path : empty;
+  static const std::string EMPTY;
+  return s_exe_path != nullptr ? *s_exe_path : EMPTY;
 }

 void arm_reexec(const std::string &path) {
@@ -5,7 +5,7 @@
 #include "esphome/core/log.h"
 #include "core.h"

-#include <time.h>
+#include <ctime>
 #include <unistd.h>
 #include <cerrno>
 #include <cstdlib>
@@ -39,8 +39,8 @@ bool Mutex::try_lock() { return static_cast<std::mutex *>(handle_)->try_lock();
 void Mutex::unlock() { static_cast<std::mutex *>(handle_)->unlock(); }

 void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
-  static const uint8_t esphome_host_mac_address[MAC_ADDRESS_SIZE] = USE_ESPHOME_HOST_MAC_ADDRESS;
-  memcpy(mac, esphome_host_mac_address, sizeof(esphome_host_mac_address));
+  static constexpr uint8_t HOST_MAC_ADDRESS[MAC_ADDRESS_SIZE] = USE_ESPHOME_HOST_MAC_ADDRESS;
+  memcpy(mac, HOST_MAC_ADDRESS, sizeof(HOST_MAC_ADDRESS));
 }

 }  // namespace esphome
@@ -2,6 +2,7 @@

 #include <filesystem>
 #include <fstream>
+#include <utility>
 #include "preferences.h"
 #include "esphome/core/application.h"
 #include "esphome/core/log.h"
@@ -45,11 +46,10 @@ void HostPreferences::setup_() {
        break;
      if (fread(&len, sizeof(len), 1, fp) != 1)
        break;
-      uint8_t data[len];
-      if (fread(data, sizeof(uint8_t), len, fp) != len)
+      std::vector<uint8_t> data(len);
+      if (fread(data.data(), sizeof(uint8_t), len, fp) != len)
        break;
-      std::vector vec(data, data + len);
-      this->data_[key] = vec;
+      this->data_[key] = std::move(data);
    }
    fclose(fp);
  }
@@ -53,7 +53,7 @@ std::shared_ptr<HttpContainer> HttpRequestHost::perform(const char *url, const c
  for (const auto &[name, value] : request_headers) {
    h_headers.emplace(name, value);
  }
-  httplib::Client client(scheme_host.c_str());
+  httplib::Client client(scheme_host);
  if (!client.is_valid()) {
    ESP_LOGE(TAG, "HTTP Request failed; Invalid URL: %s", url);
    return nullptr;
@@ -114,7 +114,7 @@ std::shared_ptr<HttpContainer> HttpRequestHost::perform(const char *url, const c
  }

  container->content_length = container->response_body_.size();
-  for (auto header : response.headers) {
+  for (const auto &header : response.headers) {
    ESP_LOGD(TAG, "Header: %s: %s", header.first.c_str(), header.second.c_str());
    auto lower_name = str_lower_case(header.first);  // NOLINT
    if (should_collect_header(lower_case_collect_headers, lower_name)) {
@@ -3,4 +3,5 @@ DOMAIN = "ili9xxx"
 DEPRECATED_COMPONENT = """
 The 'ili9xxx' component is deprecated and no new models will be added to it.
 New model PRs should target the newer and more performant 'mipi_spi' component.
+It will be removed in ESPHome 2027.5.0.
 """
@@ -220,8 +220,10 @@ FINAL_VALIDATE_SCHEMA = final_validate


 async def to_code(config: ConfigType) -> None:
+    # Remove before 2027.5.0
    LOGGER.warning(
-        "The 'ili9xxx' component is deprecated, it is recommended to use 'mipi_spi' instead."
+        "The 'ili9xxx' component is deprecated and will be removed in ESPHome 2027.5.0, "
+        "migrate to 'mipi_spi' instead."
    )
    rhs = MODELS[config[CONF_MODEL]].new()
    var = cg.Pvariable(config[CONF_ID], rhs)
@@ -37,7 +37,6 @@ from esphome.const import (
    CONF_WIDTH,
 )
 from esphome.cpp_generator import RawExpression
-from esphome.final_validate import full_config
 from esphome.types import ConfigType

 AUTO_LOAD = ["split_buffer"]
@@ -348,11 +347,8 @@ def _final_validate(config: ConfigType) -> None:
        config
    )

-    global_config = full_config.get()
-    from esphome.components.lvgl import DOMAIN as LVGL_DOMAIN
-
    if CONF_LAMBDA not in config and CONF_PAGES not in config:
-        if LVGL_DOMAIN in global_config:
+        if display.has_external_writer(config[CONF_ID]):
            if CONF_UPDATE_INTERVAL not in config:
                config[CONF_UPDATE_INTERVAL] = update_interval("never")
        else:
@@ -204,6 +204,7 @@ class IT8951Display : public Display,
                      ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
  int get_width() override { return (this->effective_transform_ & TRANSFORM_SWAP_XY) ? this->height_ : this->width_; }
  int get_height() override { return (this->effective_transform_ & TRANSFORM_SWAP_XY) ? this->width_ : this->height_; }
+  bool pixel_axes_swapped() const override { return this->effective_transform_ & TRANSFORM_SWAP_XY; }

 protected:
  int get_height_internal() override { return this->height_; }
@@ -3,7 +3,9 @@ from esphome.components.esp32 import add_idf_component, add_idf_sdkconfig_option
 from esphome.config_helpers import filter_source_files_from_platform, get_logger_level
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_API,
    CONF_DISABLED,
+    CONF_ETHERNET,
    CONF_ID,
    CONF_OPENTHREAD,
    CONF_PORT,
@@ -285,6 +287,23 @@ async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)

+    # With both wifi and ethernet, the _esphomelib "network" TXT value follows the
+    # connected interface. OpenThread hands its services to the SRP client once,
+    # so it keeps the fixed value.
+    if (
+        CONF_API in CORE.config
+        and CONF_WIFI in CORE.config
+        and CONF_ETHERNET in CORE.config
+        and CONF_OPENTHREAD not in CORE.config
+    ):
+        from esphome.components import network
+
+        cg.add_define("USE_MDNS_DYNAMIC_NETWORK_TXT")
+        # Where the network component tracks the default route (ESP32), follow
+        # it; otherwise mdns checks the connected interface every second.
+        if await network.register_active_interface_listener(var):
+            cg.add_define("USE_MDNS_ACTIVE_INTERFACE_LISTENER")
+
    for service in config[CONF_SERVICES]:
        txt_records = [
            await _mdns_txt_record_templated(var, txt_key, txt_value)
@@ -62,12 +62,9 @@ const char *MDNSComponent::connected_network_() const {
  return nullptr;
 }

-void MDNSComponent::update_network_txt_() {
-  if (this->network_txt_ == nullptr)
-    return;
+void MDNSComponent::update_network_txt_(const char *network) {
  // With no interface connected, keep the last value instead of flapping to wifi
-  const char *network = this->connected_network_();
-  if (network == nullptr || network == this->network_txt_)
+  if (this->network_txt_ == nullptr || network == nullptr || network == this->network_txt_)
    return;
  if (!this->publish_network_txt_(network)) {
    // The _esphomelib service is missing, so a retry would fail too
@@ -80,6 +77,21 @@ void MDNSComponent::update_network_txt_() {
  this->network_record_->value = MDNS_STR(network);
 #endif
 }
+
+#ifdef USE_MDNS_ACTIVE_INTERFACE_LISTENER
+void MDNSComponent::on_active_interface(network::NetworkInterface interface) {
+  switch (interface) {
+    case network::NetworkInterface::NETWORK_INTERFACE_ETHERNET:
+      this->update_network_txt_(NETWORK_ETHERNET);
+      break;
+    case network::NetworkInterface::NETWORK_INTERFACE_WIFI:
+      this->update_network_txt_(NETWORK_WIFI);
+      break;
+    default:
+      break;
+  }
+}
+#endif
 #endif

 void MDNSComponent::setup_buffers_and_register_(PlatformRegisterFn platform_register) {
@@ -32,10 +32,11 @@
 #define USE_MDNS_DEVICE_INFO_TXT
 #endif

-// With both wifi and ethernet, the _esphomelib "network" TXT value follows the connected interface.
-// OpenThread hands its services to the SRP client once, so it keeps the fixed value.
-#if defined(USE_API) && defined(USE_WIFI) && defined(USE_ETHERNET) && !defined(USE_OPENTHREAD)
-#define USE_MDNS_DYNAMIC_NETWORK_TXT
+// USE_MDNS_DYNAMIC_NETWORK_TXT (wifi + ethernet + api): the _esphomelib "network" TXT value follows the
+// connected interface. With USE_MDNS_ACTIVE_INTERFACE_LISTENER (ESP32) the network component reports
+// default route changes; otherwise the value is checked every NETWORK_TXT_CHECK_INTERVAL_MS.
+#ifdef USE_MDNS_ACTIVE_INTERFACE_LISTENER
+#include "esphome/components/network/network_component.h"
 #endif

 namespace esphome::mdns {
@@ -79,6 +80,10 @@ class MDNSComponent final : public Component
    ,
                            public ethernet::EthernetIPStateListener
 #endif
+#ifdef USE_MDNS_ACTIVE_INTERFACE_LISTENER
+    ,
+                            public network::ActiveInterfaceListener
+#endif
 {
 public:
  void setup() override;
@@ -140,6 +145,10 @@ class MDNSComponent final : public Component
  }
 #endif

+#ifdef USE_MDNS_ACTIVE_INTERFACE_LISTENER
+  void on_active_interface(network::NetworkInterface interface) override;
+#endif
+
 #ifdef USE_MDNS_EVENT_DRIVEN_POLLING
  void on_ip_state(const network::IPAddresses &ips, const network::IPAddress &dns1,
                   const network::IPAddress &dns2) override;
@@ -160,8 +169,8 @@ class MDNSComponent final : public Component
  static constexpr uint32_t NETWORK_TXT_CHECK_INTERVAL_MS = 1000;
  /// The first connected interface in network: priority order ("ethernet" or "wifi"), else nullptr.
  const char *connected_network_() const;
-  /// Check the connected interface and publish a changed "network" TXT value.
-  void update_network_txt_();
+  /// Publish network as the "network" TXT value if it changed; nullptr keeps the current value.
+  void update_network_txt_(const char *network);
  /// Platform-specific: replace the "network" TXT value of the registered _esphomelib service.
  bool publish_network_txt_(const char *network);
  /// Advertised value; nullptr until the _esphomelib service is registered, and after a failed publish.
@@ -103,8 +103,9 @@ bool MDNSComponent::publish_network_txt_(const char *network) {

 void MDNSComponent::setup() {
  this->setup_buffers_and_register_(register_esp32);
-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-  this->set_interval(NETWORK_TXT_CHECK_INTERVAL_MS, [this]() { this->update_network_txt_(); });
+#if defined(USE_MDNS_DYNAMIC_NETWORK_TXT) && !defined(USE_MDNS_ACTIVE_INTERFACE_LISTENER)
+  this->set_interval(NETWORK_TXT_CHECK_INTERVAL_MS,
+                     [this]() { this->update_network_txt_(this->connected_network_()); });
 #endif
 }

@@ -64,7 +64,8 @@ bool MDNSComponent::publish_network_txt_(const char *network) {
 void MDNSComponent::setup() {
 #ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
  // No-op until the first IP-up event registers the services
-  this->set_interval(NETWORK_TXT_CHECK_INTERVAL_MS, [this]() { this->update_network_txt_(); });
+  this->set_interval(NETWORK_TXT_CHECK_INTERVAL_MS,
+                     [this]() { this->update_network_txt_(this->connected_network_()); });
 #endif
  // arduino-pico stubs out LwipIntf::stateUpCB (the netif status callback LEAmDNS uses
  // on ESP8266 for auto-restart), so we must drive begin()/notifyAPChange() from our
@@ -127,6 +127,19 @@ ClimateTraits AirConditioner::traits() {
  return traits;
 }

+#ifdef USE_REMOTE_TRANSMITTER
+static const LogString *display_control_str(DisplayControl control) {
+  switch (control) {
+    case DisplayControl::DISPLAY_CONTROL_UART:
+      return LOG_STR("UART");
+    case DisplayControl::DISPLAY_CONTROL_IR:
+      return LOG_STR("IR");
+    default:
+      return LOG_STR("AUTO");
+  }
+}
+#endif
+
 void AirConditioner::dump_config() {
  ESP_LOGCONFIG(Constants::TAG,
                "MideaDongle:\n"
@@ -135,7 +148,10 @@ void AirConditioner::dump_config() {
                "  [x] Request attempts: %d",
                this->base_.getPeriod(), this->base_.getTimeout(), this->base_.getNumAttempts());
 #ifdef USE_REMOTE_TRANSMITTER
-  ESP_LOGCONFIG(Constants::TAG, "  [x] Using RemoteTransmitter");
+  ESP_LOGCONFIG(Constants::TAG,
+                "  [x] Using RemoteTransmitter\n"
+                "  [x] Display control: %s",
+                LOG_STR_ARG(display_control_str(this->display_control_)));
 #endif
  if (this->base_.getAutoconfStatus() == dudanov::midea::AUTOCONF_OK) {
    this->base_.getCapabilities().dump();
@@ -183,16 +199,20 @@ void AirConditioner::do_swing_step() {
 }

 void AirConditioner::do_display_toggle() {
-  if (this->base_.getCapabilities().supportLightControl()) {
-    this->base_.displayToggle();
-  } else {
 #ifdef USE_REMOTE_TRANSMITTER
+  // AUTO uses IR unless the appliance reports light control over UART. Without a transmitter
+  // built in, every setting sends the UART request: Mundoclima, Rotenso and others accept it
+  // without advertising it in the 0xB5 capabilities report.
+  const bool use_ir = this->display_control_ == DisplayControl::DISPLAY_CONTROL_IR ||
+                      (this->display_control_ == DisplayControl::DISPLAY_CONTROL_AUTO &&
+                       !this->base_.getCapabilities().supportLightControl());
+  if (use_ir) {
    IrSpecialData data(0x08);
    this->transmitter_.transmit(data);
-#else
-    ESP_LOGW(Constants::TAG, "Action needs remote_transmitter component");
-#endif
+    return;
  }
+#endif
+  this->base_.displayToggle();
 }

 }  // namespace esphome::midea::ac
@@ -21,12 +21,20 @@ using climate::ClimateModeMask;
 using climate::ClimateSwingModeMask;
 using climate::ClimatePresetMask;

+// How the display toggle reaches the appliance; the AUTO rules are in do_display_toggle()
+enum class DisplayControl : uint8_t {
+  DISPLAY_CONTROL_UART,  // always the UART request
+  DISPLAY_CONTROL_AUTO,  // UART when the appliance reports it or no transmitter is built in, else IR
+  DISPLAY_CONTROL_IR,    // always the IR remote, needs a transmitter
+};
+
 class AirConditioner final : public ApplianceBase<dudanov::midea::ac::AirConditioner>, public climate::Climate {
 public:
  void dump_config() override;
  void set_outdoor_temperature_sensor(Sensor *sensor) { this->outdoor_sensor_ = sensor; }
  void set_humidity_setpoint_sensor(Sensor *sensor) { this->humidity_sensor_ = sensor; }
  void set_power_sensor(Sensor *sensor) { this->power_sensor_ = sensor; }
+  void set_display_control(DisplayControl control) { this->display_control_ = control; }
  void on_status_change() override;

  /* ############### */
@@ -54,6 +62,7 @@ class AirConditioner final : public ApplianceBase<dudanov::midea::ac::AirConditi
  ClimateSwingModeMask supported_swing_modes_{};
  ClimatePresetMask supported_presets_{};
  bool frost_protection_set_{false};
+  DisplayControl display_control_{DisplayControl::DISPLAY_CONTROL_AUTO};
  Sensor *outdoor_sensor_{nullptr};
  Sensor *humidity_sensor_{nullptr};
  Sensor *power_sensor_{nullptr};
@@ -33,15 +33,18 @@ from esphome.const import (
    UNIT_WATT,
 )
 from esphome.core import CORE
+from esphome.types import ConfigType

 CODEOWNERS = ["@dudanov"]
 DEPENDENCIES = ["climate", "uart"]
 AUTO_LOAD = ["sensor"]
 CONF_POWER_USAGE = "power_usage"
 CONF_HUMIDITY_SETPOINT = "humidity_setpoint"
+CONF_DISPLAY_CONTROL = "display_control"
 midea_ac_ns = cg.esphome_ns.namespace("midea").namespace("ac")
 AirConditioner = midea_ac_ns.class_("AirConditioner", climate.Climate, cg.Component)
 Capabilities = midea_ac_ns.namespace("Constants")
+DisplayControl = midea_ac_ns.enum("DisplayControl", is_class=True)


 def templatize(value):
@@ -82,11 +85,29 @@ CUSTOM_PRESETS = {
    "FREEZE_PROTECTION": Capabilities.FREEZE_PROTECTION,
 }

+# How midea_ac.display_toggle reaches the appliance; see do_display_toggle() for the AUTO rules
+DISPLAY_CONTROLS = {
+    "UART": DisplayControl.DISPLAY_CONTROL_UART,
+    "AUTO": DisplayControl.DISPLAY_CONTROL_AUTO,
+    "IR": DisplayControl.DISPLAY_CONTROL_IR,
+}
+
 validate_modes = cv.enum(ALLOWED_CLIMATE_MODES, upper=True)
 validate_presets = cv.enum(ALLOWED_CLIMATE_PRESETS, upper=True)
 validate_swing_modes = cv.enum(ALLOWED_CLIMATE_SWING_MODES, upper=True)
 validate_custom_fan_modes = cv.enum(CUSTOM_FAN_MODES, upper=True)
 validate_custom_presets = cv.enum(CUSTOM_PRESETS, upper=True)
+validate_display_control = cv.enum(DISPLAY_CONTROLS, upper=True)
+
+
+def validate_display_control_with_transmitter(config: ConfigType) -> ConfigType:
+    """`display_control: IR` needs a `remote_transmitter` to send through; UART and AUTO do not."""
+    if config.get(CONF_DISPLAY_CONTROL) == "IR" and CONF_TRANSMITTER_ID not in config:
+        raise cv.Invalid(
+            f"'{CONF_DISPLAY_CONTROL}: IR' requires '{CONF_TRANSMITTER_ID}' to be set"
+        )
+    return config
+

 CONFIG_SCHEMA = cv.All(
    climate.climate_schema(AirConditioner)
@@ -100,6 +121,7 @@ CONFIG_SCHEMA = cv.All(
            ),
            cv.Optional(CONF_BEEPER, default=False): cv.boolean,
            cv.Optional(CONF_AUTOCONF, default=True): cv.boolean,
+            cv.Optional(CONF_DISPLAY_CONTROL, default="AUTO"): validate_display_control,
            cv.Optional(CONF_SUPPORTED_MODES): cv.ensure_list(validate_modes),
            cv.Optional(CONF_SUPPORTED_SWING_MODES): cv.ensure_list(
                validate_swing_modes
@@ -134,6 +156,7 @@ CONFIG_SCHEMA = cv.All(
    )
    .extend(uart.UART_DEVICE_SCHEMA)
    .extend(cv.COMPONENT_SCHEMA),
+    validate_display_control_with_transmitter,
    cv.only_on(
        [
            PLATFORM_ESP32,
@@ -204,6 +227,7 @@ async def to_code(config):
        cg.add(var.set_transmitter(transmitter_))
    cg.add(var.set_beeper_feedback(config[CONF_BEEPER]))
    cg.add(var.set_autoconf(config[CONF_AUTOCONF]))
+    cg.add(var.set_display_control(config[CONF_DISPLAY_CONTROL]))
    if CONF_SUPPORTED_MODES in config:
        cg.add(var.set_supported_modes(config[CONF_SUPPORTED_MODES]))
    if CONF_SUPPORTED_SWING_MODES in config:
@@ -130,19 +130,8 @@ class MipiSpi : public display::Display,
  }
  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }

-  int get_width() override {
-    if (this->rotation_ == display::DISPLAY_ROTATION_90_DEGREES ||
-        this->rotation_ == display::DISPLAY_ROTATION_270_DEGREES)
-      return HEIGHT;
-    return WIDTH;
-  }
-
-  int get_height() override {
-    if (this->rotation_ == display::DISPLAY_ROTATION_90_DEGREES ||
-        this->rotation_ == display::DISPLAY_ROTATION_270_DEGREES)
-      return WIDTH;
-    return HEIGHT;
-  }
+  int get_width() override { return display::rotation_swaps_axes(this->rotation_) ? HEIGHT : WIDTH; }
+  int get_height() override { return display::rotation_swaps_axes(this->rotation_) ? WIDTH : HEIGHT; }

  void set_init_sequence(const uint8_t *sequence, size_t len) {
    this->init_sequence_ = sequence;
@@ -621,6 +610,9 @@ class MipiSpiBuffer
 #endif
  }

+  // With hardware rotation the buffer is written in drawn coordinates.
+  bool pixel_axes_swapped() const override { return !HAS_HARDWARE_ROTATION && display::Display::pixel_axes_swapped(); }
+
  // Draw a pixel at the given coordinates.
  void draw_pixel_at(int x, int y, Color color) override {
    if (this->is_point_clipped(x, y))
@@ -100,6 +100,37 @@ if (

 network_ns = cg.esphome_ns.namespace("network")
 NetworkComponent = network_ns.class_("NetworkComponent", cg.Component)
+
+_request_active_interface_listener_slot = cg.slot_counter(
+    "NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT"
+)
+
+
+def has_active_interface() -> bool:
+    """Return True when NetworkComponent tracks the interface holding the default route.
+
+    That is ESP32 with more than one interface in 'network: priority:', the same
+    condition that emits USE_NETWORK_DEFAULT_ROUTE.
+    """
+    return CORE.is_esp32 and len(CORE.config.get(DOMAIN, {}).get(CONF_PRIORITY, [])) > 1
+
+
+async def register_active_interface_listener(listener: cg.MockObj) -> bool:
+    """Register an ActiveInterfaceListener with the NetworkComponent.
+
+    The listener is notified from the main loop when the interface holding the
+    default route changes. Returns False, and registers nothing, when
+    has_active_interface() is False; the caller then needs another way to
+    follow interface changes.
+    """
+    if not has_active_interface():
+        return False
+    _request_active_interface_listener_slot()
+    network = await cg.get_variable(CORE.config[DOMAIN][CONF_ID])
+    cg.add(network.add_active_interface_listener(listener))
+    return True
+
+
 IPAddress = network_ns.class_("IPAddress")


@@ -402,7 +433,7 @@ async def to_code(config: ConfigType) -> None:
        # frameworks build from source.
        # The ethernet/wifi-only assumption behind the arbitration is enforced in
        # _final_validate() so a future unsupported type fails as a config error.
-        if len(priority_list) > 1 and CORE.is_esp32:
+        if has_active_interface():
            cg.add_define("USE_NETWORK_DEFAULT_ROUTE")
            # Have lwIP switch to the DNS servers of the netif that owns the
            # default route whenever the arbitration changes it.
@@ -78,16 +78,24 @@ void NetworkComponent::loop() {
  // USE_NETWORK_PRIMARY_INTERFACE_WIFI is emitted for a wifi-first priority list;
  // it selects the reported address in util.cpp and doubles as the route-order
  // pivot here — the two uses must stay in sync.
-  esp_netif_t *best;
+  esp_netif_t *wifi = connected_wifi_netif();
+  esp_netif_t *ethernet = connected_ethernet_netif();
 #ifdef USE_NETWORK_PRIMARY_INTERFACE_WIFI
-  best = connected_wifi_netif();
-  if (best == nullptr)
-    best = connected_ethernet_netif();
+  esp_netif_t *best = wifi != nullptr ? wifi : ethernet;
 #else
-  best = connected_ethernet_netif();
-  if (best == nullptr)
-    best = connected_wifi_netif();
+  esp_netif_t *best = ethernet != nullptr ? ethernet : wifi;
 #endif
+  NetworkInterface active = NetworkInterface::NETWORK_INTERFACE_NONE;
+  if (best != nullptr) {
+    active = best == ethernet ? NetworkInterface::NETWORK_INTERFACE_ETHERNET : NetworkInterface::NETWORK_INTERFACE_WIFI;
+  }
+  if (active != this->active_interface_) {
+    this->active_interface_ = active;
+#ifdef NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT
+    for (auto *listener : this->active_interface_listeners_)
+      listener->on_active_interface(active);
+#endif
+  }
  if (best == nullptr) {
    // Forget the last winner: stopping its netif cleared lwIP's default route and
    // IDF's manual override suppresses re-election, so reconnect must re-assert it.
@@ -4,12 +4,32 @@
 #include "esphome/core/component.h"

 #ifdef USE_NETWORK_DEFAULT_ROUTE
+#include "esphome/core/helpers.h"
 // Forward declaration matching esp_netif's own typedef; avoids pulling esp_netif.h
 // into this header.
 using esp_netif_t = struct esp_netif_obj;
 #endif

 namespace esphome::network {
+
+#ifdef USE_NETWORK_DEFAULT_ROUTE
+/// The interface holding the default route. Lists only the interfaces loop() arbitrates
+/// (ARBITRATED_NETWORK_TYPES in __init__.py); extend both together.
+enum class NetworkInterface : uint8_t {
+  NETWORK_INTERFACE_NONE,
+  NETWORK_INTERFACE_ETHERNET,
+  NETWORK_INTERFACE_WIFI,
+};
+
+#ifdef NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT
+/// Notified from the main loop when the interface holding the default route changes.
+class ActiveInterfaceListener {
+ public:
+  virtual void on_active_interface(NetworkInterface interface) = 0;
+};
+#endif
+#endif
+
 class NetworkComponent final : public Component {
 public:
  void setup() override;
@@ -20,6 +40,14 @@ class NetworkComponent final : public Component {
 #ifdef USE_NETWORK_DEFAULT_ROUTE
  void loop() override;

+  /// The first connected interface in network: priority order; NONE while none is connected.
+  NetworkInterface get_active_interface() const { return this->active_interface_; }
+#ifdef NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT
+  void add_active_interface_listener(ActiveInterfaceListener *listener) {
+    this->active_interface_listeners_.push_back(listener);
+  }
+#endif
+
 protected:
  // Verify-lwIP-route interval for the settled state; keeps the global lwIP core
  // mutex off the hot loop path.
@@ -27,6 +55,10 @@ class NetworkComponent final : public Component {
  // Last netif this component made the default; avoids redundant esp_netif calls.
  esp_netif_t *default_netif_{nullptr};
  uint32_t last_route_check_{0};
+#ifdef NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT
+  StaticVector<ActiveInterfaceListener *, NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT> active_interface_listeners_;
+#endif
+  NetworkInterface active_interface_{NetworkInterface::NETWORK_INTERFACE_NONE};
 #endif
 };
 }  // namespace esphome::network
@@ -32,7 +32,7 @@ ESPHOME_LOG_TAG(TAG, "ota");
 constexpr size_t MAX_OTA_SIZE = 256u * 1024u * 1024u;  // 256 MiB
 constexpr size_t HEADER_PEEK_SIZE = 64;

-ssize_t read_header_(const char *path, uint8_t *buf, size_t len) {
+ssize_t read_header(const char *path, uint8_t *buf, size_t len) {
  int fd = ::open(path, O_RDONLY);
  if (fd < 0)
    return -1;
@@ -50,7 +50,7 @@ struct ElfIdent {
  uint16_t e_type;
 };

-ElfIdent parse_elf_(const uint8_t *buf, size_t len) {
+ElfIdent parse_elf(const uint8_t *buf, size_t len) {
  ElfIdent out{};
  if (len < EI_NIDENT + 4)
    return out;
@@ -76,17 +76,17 @@ ElfIdent parse_elf_(const uint8_t *buf, size_t len) {
  return out;
 }

-bool validate_elf_(const char *staging_path, const std::string &exe_path) {
+bool validate_elf(const char *staging_path, const std::string &exe_path) {
  uint8_t new_buf[HEADER_PEEK_SIZE];
  uint8_t cur_buf[HEADER_PEEK_SIZE];
-  ssize_t new_n = read_header_(staging_path, new_buf, sizeof(new_buf));
-  ssize_t cur_n = read_header_(exe_path.c_str(), cur_buf, sizeof(cur_buf));
+  ssize_t new_n = read_header(staging_path, new_buf, sizeof(new_buf));
+  ssize_t cur_n = read_header(exe_path.c_str(), cur_buf, sizeof(cur_buf));
  if (new_n < static_cast<ssize_t>(EI_NIDENT + 4) || cur_n < static_cast<ssize_t>(EI_NIDENT + 4)) {
    ESP_LOGE(TAG, "ELF header read failed");
    return false;
  }
-  ElfIdent new_id = parse_elf_(new_buf, new_n);
-  ElfIdent cur_id = parse_elf_(cur_buf, cur_n);
+  ElfIdent new_id = parse_elf(new_buf, new_n);
+  ElfIdent cur_id = parse_elf(cur_buf, cur_n);
  if (!new_id.valid) {
    ESP_LOGE(TAG, "Uploaded payload is not a valid ELF");
    return false;
@@ -122,7 +122,7 @@ struct MachOIdent {
  uint32_t cpusubtype;
 };

-MachOIdent parse_macho_(const uint8_t *buf, size_t len) {
+MachOIdent parse_macho(const uint8_t *buf, size_t len) {
  MachOIdent out{};
  // mach_header is the common prefix of mach_header and mach_header_64;
  // cputype/cpusubtype/filetype have identical offsets in both.
@@ -153,18 +153,18 @@ MachOIdent parse_macho_(const uint8_t *buf, size_t len) {
  return out;
 }

-bool validate_macho_(const char *staging_path, const std::string &exe_path) {
+bool validate_macho(const char *staging_path, const std::string &exe_path) {
  uint8_t new_buf[HEADER_PEEK_SIZE];
  uint8_t cur_buf[HEADER_PEEK_SIZE];
-  ssize_t new_n = read_header_(staging_path, new_buf, sizeof(new_buf));
-  ssize_t cur_n = read_header_(exe_path.c_str(), cur_buf, sizeof(cur_buf));
+  ssize_t new_n = read_header(staging_path, new_buf, sizeof(new_buf));
+  ssize_t cur_n = read_header(exe_path.c_str(), cur_buf, sizeof(cur_buf));
  if (new_n < static_cast<ssize_t>(sizeof(struct mach_header)) ||
      cur_n < static_cast<ssize_t>(sizeof(struct mach_header))) {
    ESP_LOGE(TAG, "Mach-O header read failed");
    return false;
  }
-  MachOIdent new_id = parse_macho_(new_buf, new_n);
-  MachOIdent cur_id = parse_macho_(cur_buf, cur_n);
+  MachOIdent new_id = parse_macho(new_buf, new_n);
+  MachOIdent cur_id = parse_macho(cur_buf, cur_n);
  if (!new_id.valid) {
    ESP_LOGE(TAG, "Uploaded payload is not a valid thin Mach-O executable");
    return false;
@@ -182,11 +182,11 @@ bool validate_macho_(const char *staging_path, const std::string &exe_path) {
 }
 #endif  // __APPLE__

-bool validate_executable_(const char *staging_path, const std::string &exe_path) {
+bool validate_executable(const char *staging_path, const std::string &exe_path) {
 #ifdef __linux__
-  return validate_elf_(staging_path, exe_path);
+  return validate_elf(staging_path, exe_path);
 #elif defined(__APPLE__)
-  return validate_macho_(staging_path, exe_path);
+  return validate_macho(staging_path, exe_path);
 #else
  (void) staging_path;
  (void) exe_path;
@@ -298,7 +298,7 @@ OTAResponseTypes HostOTABackend::end() {
  ::close(this->fd_);
  this->fd_ = -1;

-  if (!validate_executable_(this->staging_path_.c_str(), this->final_path_)) {
+  if (!validate_executable(this->staging_path_.c_str(), this->final_path_)) {
    ::unlink(this->staging_path_.c_str());
    this->staging_path_.clear();
    return OTA_RESPONSE_ERROR_UPDATE_END;
@@ -1,5 +1,5 @@
 #include "prometheus_handler.h"
-#ifdef USE_NETWORK
+#if defined(USE_NETWORK) && !defined(USE_HOST)
 #include "esphome/core/application.h"

 namespace esphome::prometheus {
@@ -1,6 +1,6 @@
 #pragma once
 #include "esphome/core/defines.h"
-#if defined(USE_NETWORK) && !defined(USE_ZEPHYR)
+#if defined(USE_NETWORK) && !defined(USE_ZEPHYR) && !defined(USE_HOST)
 #include <map>
 #include <utility>

@@ -6,4 +6,5 @@ CONF_DRAW_FROM_ORIGIN = "draw_from_origin"
 DEPRECATED_COMPONENT = """
 The 'qspi_dbi' component is deprecated and no new models will be added to it.
 New model PRs should target the newer and more performant 'mipi_spi' component.
+It will be removed in ESPHome 2027.5.0.
 """
@@ -165,8 +165,10 @@ CONFIG_SCHEMA = cv.All(


 async def to_code(config: ConfigType) -> None:
+    # Remove before 2027.5.0
    LOGGER.warning(
-        "The 'qspi_dbi' component is deprecated, it is recommended to use 'mipi_spi' instead."
+        "The 'qspi_dbi' component is deprecated and will be removed in ESPHome 2027.5.0, "
+        "migrate to 'mipi_spi' instead."
    )
    var = cg.new_Pvariable(config[CONF_ID])
    await display.register_display(var, config)
@@ -4,4 +4,5 @@ DOMAIN = "rpi_dpi_rgb"
 DEPRECATED_COMPONENT = """
 The 'rpi_dpi_rgb' component is deprecated and no new models will be added to it.
 New model PRs should target the newer and more performant 'mipi_rgb' component.
+It will be removed in ESPHome 2027.5.0.
 """
@@ -132,8 +132,10 @@ CONFIG_SCHEMA = cv.All(


 async def to_code(config: ConfigType) -> None:
+    # Remove before 2027.5.0
    LOGGER.warning(
-        "The 'rpi_dpi_rgb' component is deprecated, it is recommended to use 'mipi_rgb' instead."
+        "The 'rpi_dpi_rgb' component is deprecated and will be removed in ESPHome 2027.5.0, "
+        "migrate to 'mipi_rgb' instead."
    )
    var = cg.new_Pvariable(config[CONF_ID])
    await display.register_display(var, config)
@@ -157,7 +157,7 @@ void Sdl::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *
    Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
  } else {
    auto stride = x_offset + w + x_pad;
-    auto data = ptr + (stride * y_offset + x_offset) * 2;
+    const auto *data = ptr + (stride * y_offset + x_offset) * 2;
    SDL_UpdateTexture(this->texture_, &rect, data, stride * 2);
  }
  this->redraw_(rect);
@@ -199,7 +199,7 @@ void Sdl::process_key(uint32_t keycode, bool down) {
    callback->second(down);
 }

-Sdl *Sdl::instance_for_window_(uint32_t window_id) {
+Sdl *Sdl::instance_for_window(uint32_t window_id) {
  SDL_Window *window = SDL_GetWindowFromID(window_id);
  if (window == nullptr)
    return nullptr;
@@ -293,7 +293,7 @@ void Sdl::loop() {
        continue;
    }

-    Sdl *target = instance_for_window_(window_id);
+    Sdl *target = instance_for_window(window_id);
    if (target == nullptr) {
      // Nothing to route this to: the window has gone, or it is not one of ours. Say so, otherwise
      // input that stops working leaves no trace at all.
@@ -42,7 +42,7 @@ class Sdl final : public display::Display, public snapshot::Snapshot {
  float get_setup_priority() const override { return setup_priority::HARDWARE; }
  void dump_config() override { LOG_DISPLAY("", "SDL", this); }
  template<typename F> void add_key_listener(int32_t keycode, F &&callback) {
-    if (!this->key_callbacks_.count(keycode)) {
+    if (!this->key_callbacks_.contains(keycode)) {
      this->key_callbacks_[keycode] = CallbackManager<void(bool)>();
    }
    this->key_callbacks_[keycode].add(std::forward<F>(callback));
@@ -66,7 +66,7 @@ class Sdl final : public display::Display, public snapshot::Snapshot {
  bool capture_bgr(uint8_t *dest, size_t row_stride) override;
  void handle_event_(const SDL_Event &event);
  /// The display owning the given window, or nullptr if it is not one of ours.
-  static Sdl *instance_for_window_(uint32_t window_id);
+  static Sdl *instance_for_window(uint32_t window_id);
  SDL_Renderer *renderer_{};
  SDL_Window *window_{};
  SDL_Texture *texture_{};
@@ -162,6 +162,7 @@ bool MR60BHA2Component::validate_message_() {
 void MR60BHA2Component::process_frame_(uint16_t frame_id, uint16_t frame_type, const uint8_t *data, size_t length) {
  switch (frame_type) {
    case BREATH_RATE_TYPE_BUFFER:
+#ifdef USE_SENSOR
      if (this->breath_rate_sensor_ != nullptr && length >= 4) {
        uint32_t current_breath_rate_int = encode_uint32(data[3], data[2], data[1], data[0]);
        if (current_breath_rate_int != 0) {
@@ -170,11 +171,14 @@ void MR60BHA2Component::process_frame_(uint16_t frame_id, uint16_t frame_type, c
          this->breath_rate_sensor_->publish_state(breath_rate_float);
        }
      }
+#endif
      break;
    case PEOPLE_EXIST_TYPE_BUFFER:
+#ifdef USE_BINARY_SENSOR
      if (this->has_target_binary_sensor_ != nullptr && length >= 2) {
        uint16_t has_target_int = encode_uint16(data[1], data[0]);
        this->has_target_binary_sensor_->publish_state(has_target_int);
+#ifdef USE_SENSOR
        if (has_target_int == 0) {
          if (this->breath_rate_sensor_ != nullptr)
            this->breath_rate_sensor_->publish_state(0.0);
@@ -185,9 +189,12 @@ void MR60BHA2Component::process_frame_(uint16_t frame_id, uint16_t frame_type, c
          if (this->num_targets_sensor_ != nullptr)
            this->num_targets_sensor_->publish_state(0);
        }
+#endif
      }
+#endif
      break;
    case HEART_RATE_TYPE_BUFFER:
+#ifdef USE_SENSOR
      if (this->heart_rate_sensor_ != nullptr && length >= 4) {
        uint32_t current_heart_rate_int = encode_uint32(data[3], data[2], data[1], data[0]);
        if (current_heart_rate_int != 0) {
@@ -196,8 +203,10 @@ void MR60BHA2Component::process_frame_(uint16_t frame_id, uint16_t frame_type, c
          this->heart_rate_sensor_->publish_state(heart_rate_float);
        }
      }
+#endif
      break;
    case DISTANCE_TYPE_BUFFER:
+#ifdef USE_SENSOR
      if (length >= 1 && data[0] != 0) {
        if (this->distance_sensor_ != nullptr && length >= 8) {
          uint32_t current_distance_int = encode_uint32(data[7], data[6], data[5], data[4]);
@@ -206,12 +215,15 @@ void MR60BHA2Component::process_frame_(uint16_t frame_id, uint16_t frame_type, c
          this->distance_sensor_->publish_state(distance_float);
        }
      }
+#endif
      break;
    case PRINT_CLOUD_BUFFER:
+#ifdef USE_SENSOR
      if (this->num_targets_sensor_ != nullptr && length >= 4) {
        uint32_t current_num_targets_int = encode_uint32(data[3], data[2], data[1], data[0]);
        this->num_targets_sensor_->publish_state(current_num_targets_int);
      }
+#endif
      break;
    default:
      break;
@@ -96,6 +96,7 @@ static bool validate_checksum(const uint8_t *data, size_t len, uint8_t expected_
  return calculate_checksum(data, len) == expected_checksum;
 }

+#ifdef USE_SELECT
 static uint8_t find_nearest_index(float value, const float *arr, int size) {
  int nearest_index = 0;
  float min_diff = std::abs(value - arr[0]);
@@ -108,6 +109,7 @@ static uint8_t find_nearest_index(float value, const float *arr, int size) {
  }
  return nearest_index;
 }
+#endif

 /**
 * @brief Convert a float value to a byte array.
@@ -250,15 +252,19 @@ void MR60FDA2Component::split_frame_(uint8_t buffer) {
 void MR60FDA2Component::process_frame_() {
  switch (this->current_frame_type_) {
    case IS_FALL_TYPE_BUFFER:
+#ifdef USE_BINARY_SENSOR
      if (this->fall_detected_binary_sensor_ != nullptr) {
        this->fall_detected_binary_sensor_->publish_state(this->current_frame_buf_[LEN_TO_HEAD_CKSUM]);
      }
+#endif
      this->current_frame_locate_ = LOCATE_FRAME_HEADER;
      break;

    case PEOPLE_EXIST_TYPE_BUFFER:
+#ifdef USE_BINARY_SENSOR
      if (this->people_exist_binary_sensor_ != nullptr)
        this->people_exist_binary_sensor_->publish_state(this->current_frame_buf_[LEN_TO_HEAD_CKSUM]);
+#endif
      this->current_frame_locate_ = LOCATE_FRAME_HEADER;
      break;

@@ -293,6 +299,7 @@ void MR60FDA2Component::process_frame_() {
      float install_height_float = 0;
      float height_threshold_float = 0;
      uint32_t current_sensitivity = 0;
+#ifdef USE_SELECT
      if (this->install_height_select_ != nullptr) {
        uint32_t current_install_height_int =
            encode_uint32(current_data_buf_[3], current_data_buf_[2], current_data_buf_[1], current_data_buf_[0]);
@@ -318,6 +325,7 @@ void MR60FDA2Component::process_frame_() {
        uint32_t select_index = find_nearest_index(current_sensitivity, SENSITIVITY, 3);
        this->sensitivity_select_->publish_state(select_index);
      }
+#endif

      ESP_LOGD(TAG, "Mounting height: %.2f, Height threshold: %.2f, Sensitivity: %" PRIu32, install_height_float,
               height_threshold_float, current_sensitivity);
@@ -14,6 +14,15 @@ static constexpr uint32_t POLL_INTERVAL = 50;   // 50 ms between poll attempts
 // Numeric timeout IDs. Each chain is sequential, so only one timeout per ID is active at a time.
 static constexpr uint32_t TIMEOUT_POLL = 1;
 static constexpr uint32_t TIMEOUT_SETUP_STEP = 2;
+static constexpr uint32_t TIMEOUT_STARTUP = 3;
+// Post-command wait times from the datasheet: start execution (4.8.1), stop execution (4.8.2),
+// fan cleaning (4.8.22), SHT heater (4.8.23), CO2 conditioning after start on SEN63C/SEN69C (4.8.1)
+static constexpr uint32_t START_MEASUREMENT_DELAY = 50;
+static constexpr uint32_t STOP_MEASUREMENT_DELAY = 1400;
+static constexpr uint32_t FAN_CLEANING_DELAY = 10000;
+static constexpr uint32_t SHT_HEATER_DELAY = 20000;
+static constexpr uint32_t CO2_CONDITIONING_DELAY = 24000;
+static constexpr uint32_t STARTUP_DELAY = 60000;  // ms before published values are considered valid
 static constexpr uint16_t SEN6X_CMD_GET_DATA_READY_STATUS = 0x0202;
 static constexpr uint16_t SEN6X_CMD_GET_FIRMWARE_VERSION = 0xD100;
 static constexpr uint16_t SEN6X_CMD_GET_PRODUCT_NAME = 0xD014;
@@ -27,6 +36,9 @@ static constexpr uint16_t SEN6X_CMD_READ_MEASUREMENT_SEN68 = 0x0467;
 static constexpr uint16_t SEN6X_CMD_READ_MEASUREMENT_SEN69C = 0x04B5;

 static constexpr uint16_t SEN6X_CMD_START_MEASUREMENTS = 0x0021;
+static constexpr uint16_t SEN6X_CMD_STOP_MEASUREMENTS = 0x0104;
+static constexpr uint16_t SEN6X_CMD_START_FAN_CLEANING = 0x5607;
+static constexpr uint16_t SEN6X_CMD_ACTIVATE_SHT_HEATER = 0x6765;
 static constexpr uint16_t SEN6X_CMD_RESET = 0xD304;
 static constexpr uint16_t SEN6X_CMD_VOC_ALGORITHM_TUNING = 0x60D0;
 static constexpr uint16_t SEN6X_CMD_NOX_ALGORITHM_TUNING = 0x60E1;
@@ -191,7 +203,7 @@ void SEN6XComponent::finish_setup_() {
    return;
  }

-  this->set_timeout(60000, [this]() { this->startup_complete_ = true; });
+  this->on_measurement_started_();
  this->initialized_ = true;
  ESP_LOGD(TAG, "Initialized");
 }
@@ -240,7 +252,7 @@ void SEN6XComponent::dump_config() {
 }

 void SEN6XComponent::update() {
-  if (!this->initialized_) {
+  if (!this->initialized_ || !this->measuring_) {
    return;
  }

@@ -442,6 +454,101 @@ void SEN6XComponent::parse_and_publish_measurements_() {
  this->status_clear_warning();
 }

+// True while the previous command's execution or settling time has not elapsed
+bool SEN6XComponent::command_blocked_() const { return millis() - this->command_started_at_ < this->command_wait_; }
+
+void SEN6XComponent::set_command_wait_(uint32_t wait_ms) {
+  this->command_started_at_ = millis();
+  this->command_wait_ = wait_ms;
+}
+
+void SEN6XComponent::on_measurement_started_() {
+  this->measuring_ = true;
+  this->set_command_wait_(START_MEASUREMENT_DELAY);
+  // SEN63C/SEN69C condition the CO2 sensor for 24 s after a start; block restarts until then
+  if (this->sen6x_type_ == SEN63C || this->sen6x_type_ == SEN69C) {
+    this->co2_started_at_ = millis();
+    this->co2_wait_ = CO2_CONDITIONING_DELAY;
+  }
+  // Values need the warm-up period again after every start
+  this->startup_complete_ = false;
+  this->set_timeout(TIMEOUT_STARTUP, STARTUP_DELAY, [this]() { this->startup_complete_ = true; });
+}
+
+void SEN6XComponent::start_measurement() {
+  if (!this->initialized_ || this->measuring_)
+    return;
+  // The CO2 conditioning window only blocks restarting, not other commands
+  if (this->command_blocked_() || millis() - this->co2_started_at_ < this->co2_wait_) {
+    ESP_LOGW(TAG, "Device busy");
+    return;
+  }
+  if (!this->write_command(SEN6X_CMD_START_MEASUREMENTS)) {
+    this->status_set_warning();
+    ESP_LOGW(TAG, "Start measurement failed (%d)", this->last_error_);
+    return;
+  }
+  this->on_measurement_started_();
+}
+
+void SEN6XComponent::stop_measurement() {
+  if (!this->initialized_ || !this->measuring_)
+    return;
+  if (this->command_blocked_()) {
+    ESP_LOGW(TAG, "Device busy");
+    return;
+  }
+  // Stop any in-flight polling before the device goes idle
+  this->cancel_timeout(TIMEOUT_POLL);
+  if (!this->write_command(SEN6X_CMD_STOP_MEASUREMENTS)) {
+    this->status_set_warning();
+    ESP_LOGW(TAG, "Stop measurement failed (%d)", this->last_error_);
+    return;
+  }
+  this->measuring_ = false;
+  this->set_command_wait_(STOP_MEASUREMENT_DELAY);
+}
+
+void SEN6XComponent::start_fan_cleaning() {
+  if (!this->initialized_)
+    return;
+  // The device only accepts this command in idle mode (datasheet section 4.8.22)
+  if (this->measuring_) {
+    ESP_LOGW(TAG, "Fan cleaning requires idle mode; stop the measurement first");
+    return;
+  }
+  if (this->command_blocked_()) {
+    ESP_LOGW(TAG, "Device busy");
+    return;
+  }
+  if (!this->write_command(SEN6X_CMD_START_FAN_CLEANING)) {
+    this->status_set_warning();
+    ESP_LOGW(TAG, "Fan cleaning failed (%d)", this->last_error_);
+    return;
+  }
+  this->set_command_wait_(FAN_CLEANING_DELAY);
+}
+
+void SEN6XComponent::activate_sht_heater() {
+  if (!this->initialized_)
+    return;
+  // The device only accepts this command in idle mode (datasheet section 4.8.23)
+  if (this->measuring_) {
+    ESP_LOGW(TAG, "SHT heater requires idle mode; stop the measurement first");
+    return;
+  }
+  if (this->command_blocked_()) {
+    ESP_LOGW(TAG, "Device busy");
+    return;
+  }
+  if (!this->write_command(SEN6X_CMD_ACTIVATE_SHT_HEATER)) {
+    this->status_set_warning();
+    ESP_LOGW(TAG, "SHT heater failed (%d)", this->last_error_);
+    return;
+  }
+  this->set_command_wait_(SHT_HEATER_DELAY);
+}
+
 SEN6XComponent::Sen6xType SEN6XComponent::infer_type_from_product_name_(const std::string &product_name) {
  if (product_name == "SEN62")
    return SEN62;
@@ -58,6 +58,10 @@ class SEN6XComponent final : public PollingComponent, public sensirion_common::S
                                         NOX_STD_INITIAL,
                                         gain_factor};
  }
+  void start_measurement();
+  void stop_measurement();
+  void start_fan_cleaning();
+  void activate_sht_heater();

 protected:
  Sen6xType infer_type_from_product_name_(const std::string &product_name);
@@ -65,6 +69,9 @@ class SEN6XComponent final : public PollingComponent, public sensirion_common::S
  void finish_setup_();
  bool write_config_words_(uint16_t i2c_command, const uint16_t *data, uint8_t len);
  bool write_tuning_parameters_(uint16_t i2c_command, const GasTuning &tuning);
+  bool command_blocked_() const;
+  void set_command_wait_(uint32_t wait_ms);
+  void on_measurement_started_();
  void poll_data_ready_();
  void read_measurements_();
  void parse_and_publish_measurements_();
@@ -74,6 +81,11 @@ class SEN6XComponent final : public PollingComponent, public sensirion_common::S
  optional<GasTuning> voc_tuning_params_;
  optional<GasTuning> nox_tuning_params_;
  Sen6xType sen6x_type_{UNKNOWN};
+  // Post-command wait windows, stored as start time plus duration so elapsed-time checks survive millis() wrap
+  uint32_t command_started_at_{0};
+  uint32_t command_wait_{0};
+  uint32_t co2_started_at_{0};
+  uint32_t co2_wait_{0};
  uint16_t read_cmd_{0};
  uint8_t setup_step_index_{0};
  uint8_t firmware_version_major_{0};
@@ -81,6 +93,7 @@ class SEN6XComponent final : public PollingComponent, public sensirion_common::S
  uint8_t poll_retries_remaining_{0};
  uint8_t read_words_{0};
  bool initialized_{false};
+  bool measuring_{false};
  bool startup_complete_{false};
 };

@@ -1,3 +1,5 @@
+from esphome import automation
+from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
 from esphome.components import i2c, sensirion_common, sensor
 from esphome.components.const import CONF_NOX_INDEX, CONF_VOC_INDEX
@@ -209,3 +211,21 @@ async def to_code(config: ConfigType) -> None:
                args.append(std_initial)
            args.append(tuning[CONF_GAIN_FACTOR])
            cg.add(getattr(var, setter)(*args))
+
+
+SEN6X_ACTION_SCHEMA = maybe_simple_id(
+    {
+        cv.Required(CONF_ID): cv.use_id(SEN6XComponent),
+    }
+)
+
+
+for _name, _call in (
+    ("sen6x.start_measurement", "start_measurement()"),
+    ("sen6x.stop_measurement", "stop_measurement()"),
+    ("sen6x.start_fan_cleaning", "start_fan_cleaning()"),
+    ("sen6x.activate_sht_heater", "activate_sht_heater()"),
+):
+    automation.register_apply_action(
+        _name, SEN6X_ACTION_SCHEMA, automation.ApplyCall(_call)
+    )
@@ -21,6 +21,7 @@

 #include "esphome/core/defines.h"
 #ifdef USE_SHD_FIRMWARE_DATA
+#include "esphome/core/hal.h"
 #include "stm32flash.h"

 namespace esphome::shelly_dimmer {
@@ -38,118 +39,118 @@ constexpr uint32_t SZ_256K = 0x00040000;
 /*
 * Page-size for page-by-page flash erase.
 * Arrays are zero terminated; last non-zero value is automatically repeated
+ * In PROGMEM and read by direct indexing: each entry is an aligned 32-bit load, which is safe from flash on ESP8266
 */

 /* fixed size pages */
-constexpr uint32_t p_128[] = {SZ_128, 0};  // NOLINT
-constexpr uint32_t p_256[] = {SZ_256, 0};  // NOLINT
-constexpr uint32_t p_1k[] = {SZ_1K, 0};    // NOLINT
-constexpr uint32_t p_2k[] = {SZ_2K, 0};    // NOLINT
+alignas(4) constexpr uint32_t p_128[] PROGMEM = {SZ_128, 0};  // NOLINT
+alignas(4) constexpr uint32_t p_256[] PROGMEM = {SZ_256, 0};  // NOLINT
+alignas(4) constexpr uint32_t p_1k[] PROGMEM = {SZ_1K, 0};    // NOLINT
+alignas(4) constexpr uint32_t p_2k[] PROGMEM = {SZ_2K, 0};    // NOLINT
 /* F2 and F4 page size */
-constexpr uint32_t f2f4[] = {SZ_16K, SZ_16K, SZ_16K, SZ_16K, SZ_64K, SZ_128K, 0};  // NOLINT
+alignas(4) constexpr uint32_t f2f4[] PROGMEM = {SZ_16K, SZ_16K, SZ_16K, SZ_16K, SZ_64K, SZ_128K, 0};  // NOLINT
 /* F4 dual bank page size */
-constexpr uint32_t f4db[] = {SZ_16K,  SZ_16K, SZ_16K, SZ_16K, SZ_64K, SZ_128K, SZ_128K,  // NOLINT
-                             SZ_128K, SZ_16K, SZ_16K, SZ_16K, SZ_16K, SZ_64K,  SZ_128K, 0};
+alignas(4) constexpr uint32_t f4db[] PROGMEM = {SZ_16K,  SZ_16K, SZ_16K, SZ_16K, SZ_64K, SZ_128K, SZ_128K,  // NOLINT
+                                                SZ_128K, SZ_16K, SZ_16K, SZ_16K, SZ_16K, SZ_64K,  SZ_128K, 0};
 /* F7 page size */
-constexpr uint32_t f7[] = {SZ_32K, SZ_32K, SZ_32K, SZ_32K, SZ_128K, SZ_256K, 0};  // NOLINT
+alignas(4) constexpr uint32_t f7[] PROGMEM = {SZ_32K, SZ_32K, SZ_32K, SZ_32K, SZ_128K, SZ_256K, 0};  // NOLINT

 /*
 * Device table, corresponds to the "Bootloader device-dependant parameters"
 * table in ST document AN2606.
- * Note that the option bytes upper range is inclusive!
+ * Only the columns the updater reads are kept.
 */
-constexpr stm32_dev_t DEVICES[] = {
-    /* ID   "name"                              SRAM-address-range      FLASH-address-range    PPS  PSize
-       Option-byte-addr-range  System-mem-addr-range   Flags */
+alignas(4) constexpr stm32_dev_t DEVICES[] PROGMEM = {
+    /* ID   SRAM-start  FLASH-address-range  PSize  Flags */
    /* F0 */
-    {0x440, "STM32F030x8/F05xxx", 0x20000800, 0x20002000, 0x08000000, 0x08010000, 4, p_1k, 0x1FFFF800, 0x1FFFF80F,
-     0x1FFFEC00, 0x1FFFF800, 0},
-    {0x442, "STM32F030xC/F09xxx", 0x20001800, 0x20008000, 0x08000000, 0x08040000, 2, p_2k, 0x1FFFF800, 0x1FFFF80F,
-     0x1FFFC800, 0x1FFFF800, F_OBLL},
-    {0x444, "STM32F03xx4/6", 0x20000800, 0x20001000, 0x08000000, 0x08008000, 4, p_1k, 0x1FFFF800, 0x1FFFF80F,
-     0x1FFFEC00, 0x1FFFF800, 0},
-    {0x445, "STM32F04xxx/F070x6", 0x20001800, 0x20001800, 0x08000000, 0x08008000, 4, p_1k, 0x1FFFF800, 0x1FFFF80F,
-     0x1FFFC400, 0x1FFFF800, 0},
-    {0x448, "STM32F070xB/F071xx/F72xx", 0x20001800, 0x20004000, 0x08000000, 0x08020000, 2, p_2k, 0x1FFFF800, 0x1FFFF80F,
-     0x1FFFC800, 0x1FFFF800, 0},
+    // STM32F030x8/F05xxx
+    {0x440, 0x20000800, 0x08000000, 0x08010000, p_1k, 0},
+    // STM32F030xC/F09xxx
+    {0x442, 0x20001800, 0x08000000, 0x08040000, p_2k, F_OBLL},
+    // STM32F03xx4/6
+    {0x444, 0x20000800, 0x08000000, 0x08008000, p_1k, 0},
+    // STM32F04xxx/F070x6
+    {0x445, 0x20001800, 0x08000000, 0x08008000, p_1k, 0},
+    // STM32F070xB/F071xx/F72xx
+    {0x448, 0x20001800, 0x08000000, 0x08020000, p_2k, 0},
    /* F1 */
-    {0x412, "STM32F10xxx Low-density", 0x20000200, 0x20002800, 0x08000000, 0x08008000, 4, p_1k, 0x1FFFF800, 0x1FFFF80F,
-     0x1FFFF000, 0x1FFFF800, 0},
-    {0x410, "STM32F10xxx Medium-density", 0x20000200, 0x20005000, 0x08000000, 0x08020000, 4, p_1k, 0x1FFFF800,
-     0x1FFFF80F, 0x1FFFF000, 0x1FFFF800, 0},
-    {0x414, "STM32F10xxx High-density", 0x20000200, 0x20010000, 0x08000000, 0x08080000, 2, p_2k, 0x1FFFF800, 0x1FFFF80F,
-     0x1FFFF000, 0x1FFFF800, 0},
-    {0x420, "STM32F10xxx Medium-density VL", 0x20000200, 0x20002000, 0x08000000, 0x08020000, 4, p_1k, 0x1FFFF800,
-     0x1FFFF80F, 0x1FFFF000, 0x1FFFF800, 0},
-    {0x428, "STM32F10xxx High-density VL", 0x20000200, 0x20008000, 0x08000000, 0x08080000, 2, p_2k, 0x1FFFF800,
-     0x1FFFF80F, 0x1FFFF000, 0x1FFFF800, 0},
-    {0x418, "STM32F105xx/F107xx", 0x20001000, 0x20010000, 0x08000000, 0x08040000, 2, p_2k, 0x1FFFF800, 0x1FFFF80F,
-     0x1FFFB000, 0x1FFFF800, 0},
-    {0x430, "STM32F10xxx XL-density", 0x20000800, 0x20018000, 0x08000000, 0x08100000, 2, p_2k, 0x1FFFF800, 0x1FFFF80F,
-     0x1FFFE000, 0x1FFFF800, 0},
+    // STM32F10xxx Low-density
+    {0x412, 0x20000200, 0x08000000, 0x08008000, p_1k, 0},
+    // STM32F10xxx Medium-density
+    {0x410, 0x20000200, 0x08000000, 0x08020000, p_1k, 0},
+    // STM32F10xxx High-density
+    {0x414, 0x20000200, 0x08000000, 0x08080000, p_2k, 0},
+    // STM32F10xxx Medium-density VL
+    {0x420, 0x20000200, 0x08000000, 0x08020000, p_1k, 0},
+    // STM32F10xxx High-density VL
+    {0x428, 0x20000200, 0x08000000, 0x08080000, p_2k, 0},
+    // STM32F105xx/F107xx
+    {0x418, 0x20001000, 0x08000000, 0x08040000, p_2k, 0},
+    // STM32F10xxx XL-density
+    {0x430, 0x20000800, 0x08000000, 0x08100000, p_2k, 0},
    /* F2 */
-    {0x411, "STM32F2xxxx", 0x20002000, 0x20020000, 0x08000000, 0x08100000, 1, f2f4, 0x1FFFC000, 0x1FFFC00F, 0x1FFF0000,
-     0x1FFF7800, 0},
+    // STM32F2xxxx
+    {0x411, 0x20002000, 0x08000000, 0x08100000, f2f4, 0},
    /* F3 */
-    {0x432, "STM32F373xx/F378xx", 0x20001400, 0x20008000, 0x08000000, 0x08040000, 2, p_2k, 0x1FFFF800, 0x1FFFF80F,
-     0x1FFFD800, 0x1FFFF800, 0},
-    {0x422, "STM32F302xB(C)/F303xB(C)/F358xx", 0x20001400, 0x2000A000, 0x08000000, 0x08040000, 2, p_2k, 0x1FFFF800,
-     0x1FFFF80F, 0x1FFFD800, 0x1FFFF800, 0},
-    {0x439, "STM32F301xx/F302x4(6/8)/F318xx", 0x20001800, 0x20004000, 0x08000000, 0x08010000, 2, p_2k, 0x1FFFF800,
-     0x1FFFF80F, 0x1FFFD800, 0x1FFFF800, 0},
-    {0x438, "STM32F303x4(6/8)/F334xx/F328xx", 0x20001800, 0x20003000, 0x08000000, 0x08010000, 2, p_2k, 0x1FFFF800,
-     0x1FFFF80F, 0x1FFFD800, 0x1FFFF800, 0},
-    {0x446, "STM32F302xD(E)/F303xD(E)/F398xx", 0x20001800, 0x20010000, 0x08000000, 0x08080000, 2, p_2k, 0x1FFFF800,
-     0x1FFFF80F, 0x1FFFD800, 0x1FFFF800, 0},
+    // STM32F373xx/F378xx
+    {0x432, 0x20001400, 0x08000000, 0x08040000, p_2k, 0},
+    // STM32F302xB(C)/F303xB(C)/F358xx
+    {0x422, 0x20001400, 0x08000000, 0x08040000, p_2k, 0},
+    // STM32F301xx/F302x4(6/8)/F318xx
+    {0x439, 0x20001800, 0x08000000, 0x08010000, p_2k, 0},
+    // STM32F303x4(6/8)/F334xx/F328xx
+    {0x438, 0x20001800, 0x08000000, 0x08010000, p_2k, 0},
+    // STM32F302xD(E)/F303xD(E)/F398xx
+    {0x446, 0x20001800, 0x08000000, 0x08080000, p_2k, 0},
    /* F4 */
-    {0x413, "STM32F40xxx/41xxx", 0x20003000, 0x20020000, 0x08000000, 0x08100000, 1, f2f4, 0x1FFFC000, 0x1FFFC00F,
-     0x1FFF0000, 0x1FFF7800, 0},
-    {0x419, "STM32F42xxx/43xxx", 0x20003000, 0x20030000, 0x08000000, 0x08200000, 1, f4db, 0x1FFEC000, 0x1FFFC00F,
-     0x1FFF0000, 0x1FFF7800, 0},
-    {0x423, "STM32F401xB(C)", 0x20003000, 0x20010000, 0x08000000, 0x08040000, 1, f2f4, 0x1FFFC000, 0x1FFFC00F,
-     0x1FFF0000, 0x1FFF7800, 0},
-    {0x433, "STM32F401xD(E)", 0x20003000, 0x20018000, 0x08000000, 0x08080000, 1, f2f4, 0x1FFFC000, 0x1FFFC00F,
-     0x1FFF0000, 0x1FFF7800, 0},
-    {0x458, "STM32F410xx", 0x20003000, 0x20008000, 0x08000000, 0x08020000, 1, f2f4, 0x1FFFC000, 0x1FFFC00F, 0x1FFF0000,
-     0x1FFF7800, 0},
-    {0x431, "STM32F411xx", 0x20003000, 0x20020000, 0x08000000, 0x08080000, 1, f2f4, 0x1FFFC000, 0x1FFFC00F, 0x1FFF0000,
-     0x1FFF7800, 0},
-    {0x421, "STM32F446xx", 0x20003000, 0x20020000, 0x08000000, 0x08080000, 1, f2f4, 0x1FFFC000, 0x1FFFC00F, 0x1FFF0000,
-     0x1FFF7800, 0},
-    {0x434, "STM32F469xx", 0x20003000, 0x20060000, 0x08000000, 0x08200000, 1, f4db, 0x1FFEC000, 0x1FFFC00F, 0x1FFF0000,
-     0x1FFF7800, 0},
+    // STM32F40xxx/41xxx
+    {0x413, 0x20003000, 0x08000000, 0x08100000, f2f4, 0},
+    // STM32F42xxx/43xxx
+    {0x419, 0x20003000, 0x08000000, 0x08200000, f4db, 0},
+    // STM32F401xB(C)
+    {0x423, 0x20003000, 0x08000000, 0x08040000, f2f4, 0},
+    // STM32F401xD(E)
+    {0x433, 0x20003000, 0x08000000, 0x08080000, f2f4, 0},
+    // STM32F410xx
+    {0x458, 0x20003000, 0x08000000, 0x08020000, f2f4, 0},
+    // STM32F411xx
+    {0x431, 0x20003000, 0x08000000, 0x08080000, f2f4, 0},
+    // STM32F446xx
+    {0x421, 0x20003000, 0x08000000, 0x08080000, f2f4, 0},
+    // STM32F469xx
+    {0x434, 0x20003000, 0x08000000, 0x08200000, f4db, 0},
    /* F7 */
-    {0x449, "STM32F74xxx/75xxx", 0x20004000, 0x20050000, 0x08000000, 0x08100000, 1, f7, 0x1FFF0000, 0x1FFF001F,
-     0x1FF00000, 0x1FF0EDC0, 0},
+    // STM32F74xxx/75xxx
+    {0x449, 0x20004000, 0x08000000, 0x08100000, f7, 0},
    /* L0 */
-    {0x425, "STM32L031xx/041xx", 0x20001000, 0x20002000, 0x08000000, 0x08008000, 32, p_128, 0x1FF80000, 0x1FF8001F,
-     0x1FF00000, 0x1FF01000, 0},
-    {0x417, "STM32L05xxx/06xxx", 0x20001000, 0x20002000, 0x08000000, 0x08010000, 32, p_128, 0x1FF80000, 0x1FF8001F,
-     0x1FF00000, 0x1FF01000, 0},
-    {0x447, "STM32L07xxx/08xxx", 0x20002000, 0x20005000, 0x08000000, 0x08030000, 32, p_128, 0x1FF80000, 0x1FF8001F,
-     0x1FF00000, 0x1FF02000, 0},
+    // STM32L031xx/041xx
+    {0x425, 0x20001000, 0x08000000, 0x08008000, p_128, 0},
+    // STM32L05xxx/06xxx
+    {0x417, 0x20001000, 0x08000000, 0x08010000, p_128, 0},
+    // STM32L07xxx/08xxx
+    {0x447, 0x20002000, 0x08000000, 0x08030000, p_128, 0},
    /* L1 */
-    {0x416, "STM32L1xxx6(8/B)", 0x20000800, 0x20004000, 0x08000000, 0x08020000, 16, p_256, 0x1FF80000, 0x1FF8001F,
-     0x1FF00000, 0x1FF01000, F_NO_ME},
-    {0x429, "STM32L1xxx6(8/B)A", 0x20001000, 0x20008000, 0x08000000, 0x08020000, 16, p_256, 0x1FF80000, 0x1FF8001F,
-     0x1FF00000, 0x1FF01000, 0},
-    {0x427, "STM32L1xxxC", 0x20001000, 0x20008000, 0x08000000, 0x08040000, 16, p_256, 0x1FF80000, 0x1FF8001F,
-     0x1FF00000, 0x1FF02000, 0},
-    {0x436, "STM32L1xxxD", 0x20001000, 0x2000C000, 0x08000000, 0x08060000, 16, p_256, 0x1FF80000, 0x1FF8009F,
-     0x1FF00000, 0x1FF02000, 0},
-    {0x437, "STM32L1xxxE", 0x20001000, 0x20014000, 0x08000000, 0x08080000, 16, p_256, 0x1FF80000, 0x1FF8009F,
-     0x1FF00000, 0x1FF02000, F_NO_ME},
+    // STM32L1xxx6(8/B)
+    {0x416, 0x20000800, 0x08000000, 0x08020000, p_256, F_NO_ME},
+    // STM32L1xxx6(8/B)A
+    {0x429, 0x20001000, 0x08000000, 0x08020000, p_256, 0},
+    // STM32L1xxxC
+    {0x427, 0x20001000, 0x08000000, 0x08040000, p_256, 0},
+    // STM32L1xxxD
+    {0x436, 0x20001000, 0x08000000, 0x08060000, p_256, 0},
+    // STM32L1xxxE
+    {0x437, 0x20001000, 0x08000000, 0x08080000, p_256, F_NO_ME},
    /* L4 */
-    {0x415, "STM32L476xx/486xx", 0x20003100, 0x20018000, 0x08000000, 0x08100000, 1, p_2k, 0x1FFF7800, 0x1FFFF80F,
-     0x1FFF0000, 0x1FFF7000, 0},
+    // STM32L476xx/486xx
+    {0x415, 0x20003100, 0x08000000, 0x08100000, p_2k, 0},
    /* These are not (yet) in AN2606: */
-    {0x641, "Medium_Density PL", 0x20000200, 0x20005000, 0x08000000, 0x08020000, 4, p_1k, 0x1FFFF800, 0x1FFFF80F,
-     0x1FFFF000, 0x1FFFF800, 0},
-    {0x9a8, "STM32W-128K", 0x20000200, 0x20002000, 0x08000000, 0x08020000, 4, p_1k, 0x08040800, 0x0804080F, 0x08040000,
-     0x08040800, 0},
-    {0x9b0, "STM32W-256K", 0x20000200, 0x20004000, 0x08000000, 0x08040000, 4, p_2k, 0x08040800, 0x0804080F, 0x08040000,
-     0x08040800, 0},
-    {0x0, "", 0x0, 0x0, 0x0, 0x0, 0x0, nullptr, 0x0, 0x0, 0x0, 0x0, 0x0},
+    // Medium_Density PL
+    {0x641, 0x20000200, 0x08000000, 0x08020000, p_1k, 0},
+    // STM32W-128K
+    {0x9a8, 0x20000200, 0x08000000, 0x08020000, p_1k, 0},
+    // STM32W-256K
+    {0x9b0, 0x20000200, 0x08000000, 0x08040000, p_2k, 0},
+    {0x0, 0x0, 0x0, 0x0, nullptr, 0x0},
 };

 }  // namespace esphome::shelly_dimmer
@@ -72,17 +72,15 @@ using stm32_cmd_t = struct Stm32Cmd {
  uint8_t crc;
 };

+// Word-only fields: the table is in PROGMEM and aligned 32-bit loads from flash are safe on ESP8266
 using stm32_dev_t = struct Stm32Dev {  // NOLINT
-  const uint16_t id;
-  const char *name;
-  const uint32_t ram_start, ram_end;
+  const uint32_t id;
+  const uint32_t ram_start;
  const uint32_t fl_start, fl_end;
-  const uint16_t fl_pps;  // pages per sector
  const uint32_t *fl_ps;  // page size
-  const uint32_t opt_start, opt_end;
-  const uint32_t mem_start, mem_end;
  const uint32_t flags;
 };
+static_assert(sizeof(stm32_dev_t) == 6 * sizeof(uint32_t), "stm32_dev_t must stay word-only for flash reads");

 using stm32_t = struct Stm32 {
  uart::UARTDevice *stream;
@@ -50,9 +50,9 @@ struct BitWriter {
  uint32_t buffer{0};
  unsigned count{0};

-  void put(uint32_t code, unsigned size) {
-    this->buffer |= code << this->count;
-    this->count += size;
+  void put(uint32_t value, unsigned bits) {
+    this->buffer |= value << this->count;
+    this->count += bits;
    while (this->count >= 8) {
      this->out.push_back(static_cast<uint8_t>(this->buffer & 0xFF));
      this->buffer >>= 8;
@@ -55,7 +55,7 @@ std::string sanitise_filename(const char *const name, const char *extension, boo
      break;
    }
    char c = *p;
-    if (!(std::isalnum(static_cast<unsigned char>(c)) || c == '.' || c == '_' || c == '-')) {
+    if (!std::isalnum(static_cast<unsigned char>(c)) && c != '.' && c != '_' && c != '-') {
      c = '_';
      changed = true;
    }
@@ -61,6 +61,8 @@ class TcpClientLink {
  void close();

  bool connected() const { return this->connected_; }
+  /// A connect attempt is in flight.
+  bool connecting() const { return this->sock_ != nullptr && !this->connected_; }
  bool ready() const { return this->sock_ != nullptr && this->sock_->ready(); }
  /// Shared retry clock, also usable for a listen socket.
  void note_attempt() { this->last_attempt_ms_ = App.get_loop_component_start_time(); }
@@ -7,4 +7,5 @@ st7735_ns = cg.esphome_ns.namespace("st7735")
 DEPRECATED_COMPONENT = """
 The 'st7735' component is deprecated and no new models will be added to it.
 New model PRs should target the newer and more performant 'mipi_spi' component.
+It will be removed in ESPHome 2027.5.0.
 """
@@ -92,8 +92,10 @@ async def setup_st7735(var: MockObj, config: ConfigType) -> None:


 async def to_code(config: ConfigType) -> None:
+    # Remove before 2027.5.0
    LOGGER.warning(
-        "The 'st7735' component is deprecated, it is recommended to use 'mipi_spi' instead."
+        "The 'st7735' component is deprecated and will be removed in ESPHome 2027.5.0, "
+        "migrate to 'mipi_spi' instead."
    )
    var = cg.new_Pvariable(
        config[CONF_ID],
@@ -7,4 +7,5 @@ st7789v_ns = cg.esphome_ns.namespace("st7789v")
 DEPRECATED_COMPONENT = """
 The 'st7789v' component is deprecated and no new functionality will be added to it.
 PRs should target the newer and more performant 'mipi_spi' component.
+It will be removed in ESPHome 2027.5.0.
 """
@@ -183,8 +183,10 @@ FINAL_VALIDATE_SCHEMA = spi.final_validate_device_schema(


 async def to_code(config: ConfigType) -> None:
+    # Remove before 2027.5.0
    LOGGER.warning(
-        "The 'st7789v' component is deprecated, it is recommended to use 'mipi_spi' instead."
+        "The 'st7789v' component is deprecated and will be removed in ESPHome 2027.5.0, "
+        "migrate to 'mipi_spi' instead."
    )
    var = cg.new_Pvariable(config[CONF_ID])
    await display.register_display(var, config)
@@ -1,4 +1,5 @@
 #include "sx126x.h"
+#include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"

@@ -313,6 +314,11 @@ void SX126x::set_packet_params_(uint8_t payload_length) {
 }

 SX126xError SX126x::transmit_packet(const uint8_t *data, size_t len) {
+  // Callers such as a template number's on_value can run before setup() or after a failed setup
+  if (!this->is_ready()) {
+    ESP_LOGW(TAG, "Radio not ready, packet dropped");
+    return SX126xError::SX126X_ERROR_NOT_READY;
+  }
  if (this->payload_length_ > 0 && this->payload_length_ != len) {
    ESP_LOGE(TAG, "Packet size does not match config");
    return SX126xError::INVALID_PARAMS;
@@ -333,6 +339,7 @@ SX126xError SX126x::transmit_packet(const uint8_t *data, size_t len) {
  // wait until transmit completes, typically the delay will be less than 100 ms
  uint32_t start = millis();
  while (!this->dio1_pin_->digital_read()) {
+    App.feed_wdt();
    if (millis() - start > TRANSMIT_TIMEOUT_MS) {
      ESP_LOGE(TAG, "Transmit packet failure");
      ret = SX126xError::TIMEOUT;
@@ -48,7 +48,7 @@ enum SX126xBw : uint8_t {
  SX126X_BW_500000,
 };

-enum class SX126xError { NONE = 0, TIMEOUT, INVALID_PARAMS };
+enum class SX126xError { NONE = 0, TIMEOUT, INVALID_PARAMS, SX126X_ERROR_NOT_READY };

 class SX126xListener {
 public:
@@ -1,4 +1,5 @@
 #include "sx127x.h"
+#include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"

@@ -256,6 +257,11 @@ size_t SX127x::get_max_packet_size() {
 }

 SX127xError SX127x::transmit_packet(const uint8_t *data, size_t len) {
+  // Callers such as a template number's on_value can run before setup() or after a failed setup
+  if (!this->is_ready()) {
+    ESP_LOGW(TAG, "Radio not ready, packet dropped");
+    return SX127xError::SX127X_ERROR_NOT_READY;
+  }
  if (this->payload_length_ > 0 && this->payload_length_ != len) {
    ESP_LOGE(TAG, "Packet size does not match config");
    return SX127xError::INVALID_PARAMS;
@@ -292,6 +298,7 @@ SX127xError SX127x::transmit_packet(const uint8_t *data, size_t len) {
  // wait until transmit completes, typically the delay will be less than 100 ms
  uint32_t start = millis();
  while (!this->dio0_pin_->digital_read()) {
+    App.feed_wdt();
    if (millis() - start > 4000) {
      ESP_LOGE(TAG, "Transmit packet failure");
      ret = SX127xError::TIMEOUT;
@@ -36,7 +36,7 @@ enum SX127xBw : uint8_t {
  SX127X_BW_500_0,
 };

-enum class SX127xError { NONE = 0, TIMEOUT, INVALID_PARAMS };
+enum class SX127xError { NONE = 0, TIMEOUT, INVALID_PARAMS, SX127X_ERROR_NOT_READY };

 class SX127xListener {
 public:
@@ -17,12 +17,22 @@ CONF_CHARGE_CURRENT = "charge_current"
 CONF_PRECHARGE_CURRENT = "precharge_current"
 CONF_CHARGE_ENABLED = "charge_enabled"
 CONF_ENABLE_ADC = "enable_adc"
+CONF_I2C_WATCHDOG_TIMEOUT = "i2c_watchdog_timeout"

 sy6970_ns = cg.esphome_ns.namespace("sy6970")
 SY6970Component = sy6970_ns.class_(
    "SY6970Component", cg.PollingComponent, i2c.I2CDevice
 )
 SY6970Listener = sy6970_ns.class_("SY6970Listener")
+I2CWatchdogTimeout = sy6970_ns.enum("I2CWatchdogTimeout")
+
+# REG07[5:4]; the component kicks the watchdog itself, so the chip's 40S default can stay on
+I2C_WATCHDOG_TIMEOUTS = {
+    "DISABLED": I2CWatchdogTimeout.I2C_WATCHDOG_DISABLED,
+    "40S": I2CWatchdogTimeout.I2C_WATCHDOG_40S,
+    "80S": I2CWatchdogTimeout.I2C_WATCHDOG_80S,
+    "160S": I2CWatchdogTimeout.I2C_WATCHDOG_160S,
+}

 CONFIG_SCHEMA = (
    cv.Schema(
@@ -43,6 +53,9 @@ CONFIG_SCHEMA = (
            ),
            cv.Optional(CONF_CHARGE_ENABLED, default=True): cv.boolean,
            cv.Optional(CONF_ENABLE_ADC, default=True): cv.boolean,
+            cv.Optional(CONF_I2C_WATCHDOG_TIMEOUT, default="40S"): cv.enum(
+                I2C_WATCHDOG_TIMEOUTS, upper=True
+            ),
        }
    )
    .extend(cv.polling_component_schema("5s"))
@@ -60,6 +73,7 @@ async def to_code(config: ConfigType) -> None:
        config[CONF_PRECHARGE_CURRENT],
        config[CONF_CHARGE_ENABLED],
        config[CONF_ENABLE_ADC],
+        config[CONF_I2C_WATCHDOG_TIMEOUT],
    )
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)
@@ -6,6 +6,25 @@ namespace esphome::sy6970 {

 ESPHOME_LOG_TAG(TAG, "sy6970");

+static const LogString *i2c_watchdog_timeout_to_string(I2CWatchdogTimeout timeout) {
+  switch (timeout) {
+    case I2C_WATCHDOG_DISABLED:
+      return LOG_STR("Disabled");
+    case I2C_WATCHDOG_40S:
+      return LOG_STR("40s");
+    case I2C_WATCHDOG_80S:
+      return LOG_STR("80s");
+    case I2C_WATCHDOG_160S:
+      return LOG_STR("160s");
+    default:
+      return LOG_STR("Unknown");
+  }
+}
+
+static constexpr uint32_t I2C_WATCHDOG_KICK_INTERVAL_ID = 0;
+// Well under the 40 s default, so a failed kick or a timeout the chip did not accept still leaves margin
+static constexpr uint32_t I2C_WATCHDOG_KICK_INTERVAL_MS = 10000;
+
 bool SY6970Component::read_all_registers_() {
  // Read all registers from 0x00 to 0x14 in one transaction (21 bytes)
  // This includes unused registers 0x0F, 0x10 for performance
@@ -51,6 +70,11 @@ void SY6970Component::setup() {
    ESP_LOGW(TAG, "Unexpected chip ID: 0x%02X (expected 0x00)", chip_id);
  }

+  // Service the watchdog first, so the settings below are not reverted while they are written
+  ESP_LOGV(TAG, "Setting I2C watchdog timeout to %s",
+           LOG_STR_ARG(i2c_watchdog_timeout_to_string(this->i2c_watchdog_timeout_)));
+  this->set_i2c_watchdog_timeout(this->i2c_watchdog_timeout_);
+
  // Apply configuration options (all have defaults now)
  ESP_LOGV(TAG, "Setting LED enabled to %s", ONOFF(this->led_enabled_));
  this->set_led_enabled(this->led_enabled_);
@@ -85,9 +109,11 @@ void SY6970Component::dump_config() {
                "  Charge Current: %u mA\n"
                "  Precharge Current: %u mA\n"
                "  Charge Enabled: %s\n"
-                "  ADC Enabled: %s",
+                "  ADC Enabled: %s\n"
+                "  I2C Watchdog Timeout: %s",
                ONOFF(this->led_enabled_), this->input_current_limit_, this->charge_voltage_, this->charge_current_,
-                this->precharge_current_, ONOFF(this->charge_enabled_), ONOFF(this->enable_adc_));
+                this->precharge_current_, ONOFF(this->charge_enabled_), ONOFF(this->enable_adc_),
+                LOG_STR_ARG(i2c_watchdog_timeout_to_string(this->i2c_watchdog_timeout_)));
  LOG_I2C_DEVICE(this);
  LOG_UPDATE_INTERVAL(this);
  if (this->is_failed()) {
@@ -198,4 +224,44 @@ void SY6970Component::set_enable_adc_measure(bool enabled) {
  this->update_register_(SY6970_REG_ADC_CONTROL, 0xC0, enabled ? 0xC0 : 0x00);
 }

+void SY6970Component::set_i2c_watchdog_timeout(I2CWatchdogTimeout timeout) {
+  if (this->is_failed())
+    return;
+
+  if (timeout != I2C_WATCHDOG_DISABLED) {
+    // Changing the timeout does not restart the chip's timer, which may be close to expiring
+    this->reset_i2c_watchdog();
+  }
+
+  // REG07 bits 5:4 (WATCHDOG[1:0])
+  bool written = this->update_register_(SY6970_REG_TIMER_CONTROL, 0x30, static_cast<uint8_t>(timeout) << 4);
+  if (!written) {
+    ESP_LOGW(TAG, "Failed to set I2C watchdog timeout to %s", LOG_STR_ARG(i2c_watchdog_timeout_to_string(timeout)));
+  }
+
+  if (timeout == I2C_WATCHDOG_DISABLED && written) {
+    this->i2c_watchdog_timeout_ = timeout;
+    this->cancel_interval(I2C_WATCHDOG_KICK_INTERVAL_ID);
+    return;
+  }
+  if (timeout != I2C_WATCHDOG_DISABLED) {
+    this->i2c_watchdog_timeout_ = timeout;
+  }
+  // Keeps kicking after a failed write too: the chip may still be on its 40 s default
+  this->set_interval(I2C_WATCHDOG_KICK_INTERVAL_ID, I2C_WATCHDOG_KICK_INTERVAL_MS,
+                     [this]() { this->reset_i2c_watchdog(); });
+}
+
+bool SY6970Component::reset_i2c_watchdog() {
+  if (this->is_failed())
+    return false;
+
+  // WD_RST, self-clearing
+  if (!this->update_register_(SY6970_REG_SYS_CONTROL, 0x40, 0x40)) {
+    ESP_LOGW(TAG, "I2C watchdog reset failed, settings may revert");
+    return false;
+  }
+  return true;
+}
+
 }  // namespace esphome::sy6970
@@ -62,6 +62,15 @@ enum ChargeStatus {
  CHARGE_STATUS_CHARGE_DONE = 3,
 };

+// REG07[5:4]. When the watchdog elapses the chip reverts CHG_CONFIG and STAT_DIS to their defaults,
+// so an enabled watchdog is kicked on its own interval.
+enum I2CWatchdogTimeout {
+  I2C_WATCHDOG_DISABLED = 0,
+  I2C_WATCHDOG_40S = 1,
+  I2C_WATCHDOG_80S = 2,
+  I2C_WATCHDOG_160S = 3,
+};
+
 // Structure to hold all register data read in one transaction
 struct SY6970Data {
  uint8_t registers[21];  // Registers 0x00-0x14 (includes unused 0x0F, 0x10)
@@ -76,14 +85,16 @@ class SY6970Listener {
 class SY6970Component final : public PollingComponent, public i2c::I2CDevice {
 public:
  SY6970Component(bool led_enabled, uint16_t input_current_limit, uint16_t charge_voltage, uint16_t charge_current,
-                  uint16_t precharge_current, bool charge_enabled, bool enable_adc)
+                  uint16_t precharge_current, bool charge_enabled, bool enable_adc,
+                  I2CWatchdogTimeout i2c_watchdog_timeout)
      : led_enabled_(led_enabled),
        input_current_limit_(input_current_limit),
        charge_voltage_(charge_voltage),
        charge_current_(charge_current),
        precharge_current_(precharge_current),
        charge_enabled_(charge_enabled),
-        enable_adc_(enable_adc) {}
+        enable_adc_(enable_adc),
+        i2c_watchdog_timeout_(i2c_watchdog_timeout) {}
  void setup() override;
  void dump_config() override;
  void update() override;
@@ -99,6 +110,10 @@ class SY6970Component final : public PollingComponent, public i2c::I2CDevice {
  void set_charge_enabled(bool enabled);
  void set_led_enabled(bool enabled);
  void set_enable_adc_measure(bool enabled = true);
+  void set_i2c_watchdog_timeout(I2CWatchdogTimeout timeout);
+
+  /// Kick the I2C watchdog (REG03 bit 6); runs on its own interval while enabled. Returns false when not written.
+  bool reset_i2c_watchdog();

 protected:
  bool read_all_registers_();
@@ -116,6 +131,7 @@ class SY6970Component final : public PollingComponent, public i2c::I2CDevice {
  uint16_t precharge_current_;
  bool charge_enabled_;
  bool enable_adc_;
+  I2CWatchdogTimeout i2c_watchdog_timeout_;
 };

 }  // namespace esphome::sy6970
@@ -0,0 +1,31 @@
+"""TMP102 threshold status entity."""
+
+import esphome.codegen as cg
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import ENTITY_CATEGORY_DIAGNOSTIC
+from esphome.types import ConfigType
+
+from . import CONF_TMP102_ID, TMP102Component, validate_unique_child
+
+CONFIG_SCHEMA = text_sensor.text_sensor_schema(
+    entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+).extend(
+    {
+        cv.GenerateID(CONF_TMP102_ID): cv.use_id(TMP102Component),
+    }
+)
+
+
+def _final_validate(config: ConfigType) -> ConfigType:
+    return validate_unique_child(config, "text_sensor")
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
+async def to_code(config: ConfigType) -> None:
+    cg.add_define("USE_TMP102_TEXT_SENSOR")
+    parent = await cg.get_variable(config[CONF_TMP102_ID])
+    var = await text_sensor.new_text_sensor(config)
+    cg.add(parent.set_threshold_status_text_sensor(var))
@@ -1,8 +1,14 @@
 #include "tmp102.h"
 #include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#ifdef USE_TMP102_TEXT_SENSOR
+#include "esphome/core/progmem.h"
+#endif

 #include <cmath>
+#ifdef USE_TMP102_TEXT_SENSOR
+#include <cstdio>
+#endif

 namespace esphome::tmp102 {

@@ -12,6 +18,30 @@ static constexpr uint32_t READ_TEMP_TIMEOUT_ID = 0;

 static constexpr uint8_t TMP102_REGISTER_TEMPERATURE = 0x00;
 static constexpr float TMP102_CONVERSION_FACTOR = 0.0625f;
+
+enum TMP102ThresholdStatus : uint8_t {
+  TMP102_THRESHOLD_STATUS_NOT_CONFIGURED,
+  TMP102_THRESHOLD_STATUS_SETUP_FAILED,
+  TMP102_THRESHOLD_STATUS_OK,
+  TMP102_THRESHOLD_STATUS_RESTORE_RESET,
+  TMP102_THRESHOLD_STATUS_RESTORE_RESET_SAVE_FAILED,
+  TMP102_THRESHOLD_STATUS_PREFERENCE_SAVE_FAILED,
+  TMP102_THRESHOLD_STATUS_RECOVERY_FAILED,
+  TMP102_THRESHOLD_STATUS_RECOVERED,
+  TMP102_THRESHOLD_STATUS_WRITE_HIGH_FAILED,
+  TMP102_THRESHOLD_STATUS_WRITE_LOW_FAILED,
+  TMP102_THRESHOLD_STATUS_SENSOR_SETUP_FAILED,
+  TMP102_THRESHOLD_STATUS_COUNT,
+};
+
+#ifdef USE_TMP102_TEXT_SENSOR
+PROGMEM_STRING_TABLE(ThresholdStatusStrings, "Not configured", "Setup failed", "OK", "Restored thresholds reset",
+                     "Restore reset; save failed", "Preference save failed", "Configuration recovery failed",
+                     "Configuration restored", "Write failed: high threshold", "Write failed: low threshold",
+                     "Rejected: sensor setup failed");
+static_assert(ThresholdStatusStrings::COUNT == TMP102_THRESHOLD_STATUS_COUNT);
+#endif
+
 #if defined(USE_TMP102_CONFIGURE) || defined(USE_TMP102_BINARY_SENSOR)
 static constexpr uint8_t TMP102_REGISTER_CONFIGURATION = 0x01;
 static constexpr uint16_t TMP102_ALERT_BIT = 0x0020;
@@ -42,15 +72,30 @@ static uint16_t encode_temperature(float temperature, bool extended) {
  return static_cast<uint16_t>(static_cast<uint32_t>(static_cast<uint16_t>(steps)) << (extended ? 3 : 4));
 }
 #endif
+#endif

+#if defined(USE_TMP102_CONFIGURE) || defined(USE_TMP102_TEXT_SENSOR)
 void TMP102Component::setup() {
-  if (!this->configure_)
+#ifdef USE_TMP102_CONFIGURE
+  if (this->configure_) {
+    this->setup_configured_();
    return;
+  }
+#endif
+  this->publish_threshold_status_(TMP102_THRESHOLD_STATUS_NOT_CONFIGURED);
+}
+#endif
+
+#ifdef USE_TMP102_CONFIGURE
+void TMP102Component::setup_configured_() {
+  bool corrected = false;
 #ifdef USE_TMP102_NUMBER
  float restored[2]{};
-  this->prepare_number_limits_(restored);
+  bool restore_corrected[2]{};
+  corrected = this->prepare_number_limits_(restored, restore_corrected);
 #endif
  if (!this->write_configuration_()) {
+    this->publish_threshold_status_(TMP102_THRESHOLD_STATUS_SETUP_FAILED);
    this->mark_failed();
    return;
  }
@@ -61,14 +106,17 @@ void TMP102Component::setup() {
    if (control == nullptr)
      continue;
    const float value = this->get_limit_temperature_(static_cast<TMP102LimitType>(limit));
-    if (value != restored[limit])
+    if (restore_corrected[limit] || value != restored[limit])
      saved &= control->save_value_(value);
    control->publish_state(value);
  }
  if (!saved) {
    ESP_LOGW(TAG, "Failed to save threshold preferences");
+    this->publish_threshold_status_(TMP102_THRESHOLD_STATUS_RESTORE_RESET_SAVE_FAILED);
+    return;
  }
 #endif
+  this->publish_threshold_status_(corrected ? TMP102_THRESHOLD_STATUS_RESTORE_RESET : TMP102_THRESHOLD_STATUS_OK);
 }
 #endif

@@ -83,6 +131,9 @@ void TMP102Component::dump_config() {
 #ifdef USE_TMP102_BINARY_SENSOR
  LOG_BINARY_SENSOR("  ", "Alert", this->alert_binary_sensor_);
 #endif
+#ifdef USE_TMP102_TEXT_SENSOR
+  LOG_TEXT_SENSOR("  ", "Threshold Status", this->threshold_status_text_sensor_);
+#endif
 #ifdef USE_TMP102_CONFIGURE
  if (!this->configure_)
    return;
@@ -203,6 +254,9 @@ bool TMP102Component::check_configuration_() {
  this->set_warning_and_invalidate_alert_();
  if (!this->write_configuration_()) {
    ESP_LOGW(TAG, "Failed to restore configuration and thresholds");
+    this->publish_threshold_status_(TMP102_THRESHOLD_STATUS_RECOVERY_FAILED);
+  } else {
+    this->publish_threshold_status_(TMP102_THRESHOLD_STATUS_RECOVERED);
  }
  return false;
 }
@@ -228,22 +282,25 @@ void TMP102Component::set_limit_control(TMP102LimitNumber *number) {
  this->limit_controls_[number->limit_type_] = number;
 }

-void TMP102Component::prepare_number_limits_(float *restored) {
+bool TMP102Component::prepare_number_limits_(float *restored, bool *restore_corrected) {
  const bool extended = this->config_ & TMP102_EXTENDED_MODE_BIT;
  uint16_t raw[2] = {this->low_limit_, this->high_limit_};
+  bool corrected = false;
  for (uint8_t limit = 0; limit < 2; ++limit) {
    TMP102LimitNumber *control = this->limit_controls_[limit];
    if (control == nullptr)
      continue;
-    restored[limit] = control->load_value_(decode_temperature(raw[limit], extended));
+    restored[limit] = control->load_value_(decode_temperature(raw[limit], extended), restore_corrected[limit]);
+    corrected |= restore_corrected[limit];
    raw[limit] = encode_temperature(restored[limit], extended);
  }
  if (static_cast<int16_t>(raw[TMP102_LIMIT_LOW]) > static_cast<int16_t>(raw[TMP102_LIMIT_HIGH])) {
    ESP_LOGW(TAG, "Restored thresholds are inverted; using configured values");
-    return;
+    return true;
  }
  this->low_limit_ = raw[TMP102_LIMIT_LOW];
  this->high_limit_ = raw[TMP102_LIMIT_HIGH];
+  return corrected;
 }

 float TMP102Component::get_limit_temperature_(TMP102LimitType limit) const {
@@ -261,10 +318,13 @@ bool TMP102Component::set_limit_temperature_(TMP102LimitType limit, float temper
    ESP_LOGW(TAG, "Rejected %s threshold %.4f°C: crosses %s threshold %.4f°C",
             high ? LOG_STR_LITERAL("high") : LOG_STR_LITERAL("low"), decode_temperature(raw, extended),
             high ? LOG_STR_LITERAL("low") : LOG_STR_LITERAL("high"), decode_temperature(other, extended));
+    this->publish_threshold_rejection_(high, decode_temperature(raw, extended), decode_temperature(other, extended));
    return false;
  }
  if (!this->write_register_(static_cast<uint8_t>(TMP102_REGISTER_LOW_LIMIT + limit), raw)) {
    this->status_set_warning();
+    this->publish_threshold_status_(high ? TMP102_THRESHOLD_STATUS_WRITE_HIGH_FAILED
+                                         : TMP102_THRESHOLD_STATUS_WRITE_LOW_FAILED);
    return false;
  }
  (high ? this->high_limit_ : this->low_limit_) = raw;
@@ -273,6 +333,32 @@ bool TMP102Component::set_limit_temperature_(TMP102LimitType limit, float temper
 #endif
 #endif

+#ifdef USE_TMP102_TEXT_SENSOR
+void TMP102Component::publish_threshold_status_(uint8_t status) {
+  if (this->threshold_status_text_sensor_ == nullptr)
+    return;
+  char text[40];
+  ESPHOME_strncpy_P(
+      text,
+      reinterpret_cast<ESPHOME_PGM_P>(ThresholdStatusStrings::get_progmem_str(status, TMP102_THRESHOLD_STATUS_OK)),
+      sizeof(text));
+  text[sizeof(text) - 1] = '\0';
+  this->threshold_status_text_sensor_->publish_state(text);
+}
+
+void TMP102Component::publish_threshold_rejection_(bool high, float value, float other) {
+  if (this->threshold_status_text_sensor_ == nullptr)
+    return;
+  char text[96];
+  if (high) {
+    ESPHOME_snprintf_P(text, sizeof(text), ESPHOME_PSTR("Rejected: high %.4f°C crosses low %.4f°C"), value, other);
+  } else {
+    ESPHOME_snprintf_P(text, sizeof(text), ESPHOME_PSTR("Rejected: low %.4f°C crosses high %.4f°C"), value, other);
+  }
+  this->threshold_status_text_sensor_->publish_state(text);
+}
+#endif
+
 #ifdef USE_TMP102_BINARY_SENSOR
 void TMP102Component::invalidate_alert_() {
  if (this->alert_binary_sensor_ != nullptr)
@@ -294,7 +380,7 @@ bool TMP102Component::read_alert_state_() {
 #endif

 #ifdef USE_TMP102_NUMBER
-float TMP102LimitNumber::load_value_(float fallback) {
+float TMP102LimitNumber::load_value_(float fallback, bool &corrected) {
  float value = fallback;
  if (this->restore_value_) {
    this->pref_ = this->make_entity_preference<float>();
@@ -303,6 +389,7 @@ float TMP102LimitNumber::load_value_(float fallback) {
  if (!std::isfinite(value) || value < this->traits.get_min_value() || value > this->traits.get_max_value()) {
    ESP_LOGW(TAG, "Invalid restored threshold; using configured value");
    value = fallback;
+    corrected = true;
  }
  return value;
 }
@@ -313,6 +400,7 @@ void TMP102LimitNumber::control(float value) {
  // A chip that failed setup holds nothing the entity could show
  if (this->parent_->is_failed()) {
    ESP_LOGW(TAG, "Rejected threshold change: sensor setup failed");
+    this->parent_->publish_threshold_status_(TMP102_THRESHOLD_STATUS_SENSOR_SETUP_FAILED);
    return;
  }
  const bool accepted = this->parent_->set_limit_temperature_(this->limit_type_, value);
@@ -320,6 +408,9 @@ void TMP102LimitNumber::control(float value) {
  this->publish_state(value);
  if (accepted && !this->save_value_(value)) {
    ESP_LOGW(TAG, "Failed to save threshold preference");
+    this->parent_->publish_threshold_status_(TMP102_THRESHOLD_STATUS_PREFERENCE_SAVE_FAILED);
+  } else if (accepted) {
+    this->parent_->publish_threshold_status_(TMP102_THRESHOLD_STATUS_OK);
  }
 }
 #endif
@@ -12,11 +12,20 @@
 #include "esphome/core/preferences.h"
 #endif
 #include "esphome/components/sensor/sensor.h"
+#ifdef USE_TMP102_TEXT_SENSOR
+#include "esphome/components/text_sensor/text_sensor.h"
+#endif

 #include <cstdint>

 namespace esphome::tmp102 {

+#ifdef USE_HOST
+namespace testing {
+class TMP102Test;
+}
+#endif
+
 #ifdef USE_TMP102_NUMBER
 enum TMP102LimitType : uint8_t {
  TMP102_LIMIT_LOW = 0,
@@ -31,8 +40,13 @@ class TMP102Component final : public PollingComponent, public i2c::I2CDevice, pu
 #ifdef USE_TMP102_BINARY_SENSOR
  SUB_BINARY_SENSOR(alert)
 #endif
-#ifdef USE_TMP102_CONFIGURE
+#ifdef USE_TMP102_TEXT_SENSOR
+  SUB_TEXT_SENSOR(threshold_status)
+#endif
+#if defined(USE_TMP102_CONFIGURE) || defined(USE_TMP102_TEXT_SENSOR)
  void setup() override;
+#endif
+#ifdef USE_TMP102_CONFIGURE
  void set_configuration(uint16_t config, uint16_t high_limit, uint16_t low_limit) {
    this->config_ = config;
    this->high_limit_ = high_limit;
@@ -47,6 +61,13 @@ class TMP102Component final : public PollingComponent, public i2c::I2CDevice, pu
  void update() override;

 protected:
+#ifdef USE_TMP102_TEXT_SENSOR
+  void publish_threshold_status_(uint8_t status);
+  void publish_threshold_rejection_(bool high, float value, float other);
+#else
+  void publish_threshold_status_(uint8_t) {}
+  void publish_threshold_rejection_(bool, float, float) {}
+#endif
  void set_warning_and_invalidate_alert_() {
    this->status_set_warning();
 #ifdef USE_TMP102_BINARY_SENSOR
@@ -58,6 +79,7 @@ class TMP102Component final : public PollingComponent, public i2c::I2CDevice, pu
  void invalidate_alert_();
 #endif
 #ifdef USE_TMP102_CONFIGURE
+  void setup_configured_();
  bool write_register_(uint8_t reg, uint16_t value);
  bool write_configuration_();
  bool check_configuration_();
@@ -67,11 +89,10 @@ class TMP102Component final : public PollingComponent, public i2c::I2CDevice, pu
  friend class TMP102LimitNumber;
  bool set_limit_temperature_(TMP102LimitType limit, float temperature);
  float get_limit_temperature_(TMP102LimitType limit) const;
-  void prepare_number_limits_(float *restored);
+  bool prepare_number_limits_(float *restored, bool *restore_corrected);

  TMP102LimitNumber *limit_controls_[2]{};
 #endif
-
  uint16_t config_{0};
  uint16_t high_limit_{0};
  uint16_t low_limit_{0};
@@ -87,7 +108,10 @@ class TMP102LimitNumber final : public number::Number, public Parented<TMP102Com

 protected:
  friend class TMP102Component;
-  float load_value_(float fallback);
+#ifdef USE_HOST
+  friend class testing::TMP102Test;
+#endif
+  float load_value_(float fallback, bool &corrected);
  bool save_value_(float value);
  void control(float value) override;

@@ -9,11 +9,11 @@
 #error This HostUartComponent implementation is not supported on this host OS
 #endif

-#include <stdio.h>
-#include <string.h>
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
 #include <unistd.h>
 #include <fcntl.h>
-#include <errno.h>
 #include <termios.h>
 #include <sys/ioctl.h>

@@ -210,7 +210,6 @@ void HostUartComponent::write_array(const uint8_t *data, size_t len) {
    this->debug_callback_.call(UART_DIRECTION_TX, data[i]);
  }
 #endif
-  return;
 }

 bool HostUartComponent::peek_byte(uint8_t *data) {
@@ -2,6 +2,8 @@

 #ifdef USE_HOST

+#include <utility>
+
 #include "esphome/core/component.h"
 #include "esphome/core/log.h"
 #include "uart_component.h"
@@ -10,7 +12,7 @@ namespace esphome::uart {

 class HostUartComponent final : public UARTComponent, public Component {
 public:
-  virtual ~HostUartComponent();
+  ~HostUartComponent();
  void setup() override;
  void dump_config() override;
  float get_setup_priority() const override { return setup_priority::BUS; }
@@ -19,7 +21,7 @@ class HostUartComponent final : public UARTComponent, public Component {
  bool read_array(uint8_t *data, size_t len) override;
  size_t available() override;
  UARTFlushResult flush() override;
-  void set_name(std::string port_name) { port_name_ = port_name; };
+  void set_name(std::string port_name) { this->port_name_ = std::move(port_name); }

 protected:
  void update_error_(const std::string &error);
@@ -1,5 +1,5 @@
 #include "web_server_base.h"
-#if defined(USE_NETWORK) && !defined(USE_ZEPHYR)
+#if defined(USE_NETWORK) && !defined(USE_ZEPHYR) && !defined(USE_HOST)

 namespace esphome::web_server_base {

@@ -1,6 +1,6 @@
 #pragma once
 #include "esphome/core/defines.h"
-#if defined(USE_NETWORK) && !defined(USE_ZEPHYR)
+#if defined(USE_NETWORK) && !defined(USE_ZEPHYR) && !defined(USE_HOST)
 #include <vector>

 #include "esphome/core/progmem.h"
@@ -959,10 +959,39 @@ void AsyncEventSourceResponse::process_close_() {
  }
 }

+void AsyncEventSourceResponse::refresh_lru_() {
+  // httpd only advances a session's LRU counter when a request arrives, and an event stream receives one
+  // request ever, so the purge that frees a socket for a new client would evict the live streams first.
+  // The HTTPD task owns the session table, so the refresh runs there.
+  // A stalled stream is the socket the purge should take, and a zeroed fd has no session left to refresh.
+  if (this->send_failure_started_ms_ != 0 || this->fd_.load() == 0)
+    return;
+  const uint32_t now = App.get_loop_component_start_time();
+  if (now - this->last_lru_refresh_ms_ < LRU_REFRESH_INTERVAL_MS ||
+      this->lru_work_queued_.load(std::memory_order_acquire)) {
+    return;
+  }
+  this->last_lru_refresh_ms_ = now;  // a full queue also waits for the next interval
+  this->lru_work_queued_.store(true, std::memory_order_release);
+  if (httpd_queue_work(this->hd_, &AsyncEventSourceResponse::refresh_lru_work, this) != ESP_OK) {
+    this->lru_work_queued_.store(false, std::memory_order_release);
+  }
+}
+
+void AsyncEventSourceResponse::refresh_lru_work(void *arg) {
+  auto *response = static_cast<AsyncEventSourceResponse *>(arg);
+  const int fd = response->fd_.load();
+  if (response->owns_session_(fd)) {
+    httpd_sess_update_lru_counter(response->hd_, fd);
+  }
+  // Release self only after the HTTPD-task callback has finished every access.
+  response->lru_work_queued_.store(false, std::memory_order_release);
+}
+
 void AsyncEventSourceResponse::close_session_work(void *arg) {
  auto *response = static_cast<AsyncEventSourceResponse *>(arg);
  const int fd = response->fd_.load();
-  if (fd != 0 && httpd_sess_get_ctx(response->hd_, fd) == response) {
+  if (response->owns_session_(fd)) {
    // The HTTPD task remains the session owner. Shutting the socket down makes
    // its next select/recv path delete the session and invoke destroy().
    shutdown(fd, SHUT_RDWR);
@@ -976,7 +1005,7 @@ ssize_t AsyncEventSourceResponse::send_(struct iovec *iov, int iovcnt) {
  // httpd frees a session before closing its socket, so the fd may already be a new client's.
  // Treated as would-block; the stall timer ends a session that never becomes ours again.
  const int fd = this->fd_.load();
-  if (httpd_sess_get_ctx(this->hd_, fd) != this) {
+  if (!this->owns_session_(fd)) {
    return 0;
  }
  struct msghdr msg {};
@@ -1085,6 +1114,7 @@ void AsyncEventSourceResponse::loop() {
    this->process_close_();
    return;
  }
+  this->refresh_lru_();
  drain_tail_();
  process_deferred_queue_();
  if (this->close_requested_)
@@ -339,10 +339,15 @@ class AsyncEventSourceResponse {
  };
  void process_close_();
  static void close_session_work(void *arg);
+  void refresh_lru_();
+  static void refresh_lru_work(void *arg);
+  // httpd frees a session before closing its socket, so the fd may already belong to a new client
+  bool owns_session_(int fd) const { return fd != 0 && httpd_sess_get_ctx(this->hd_, fd) == this; }

-  // Deletable only after destroy() zeroed fd_ and no queued HTTPD close work still references this object.
+  // Deletable only after destroy() zeroed fd_ and no queued HTTPD work still references this object.
  bool safe_to_delete_() const {
-    return this->fd_.load() == 0 && !this->close_work_queued_.load(std::memory_order_acquire);
+    return this->fd_.load() == 0 && !this->close_work_queued_.load(std::memory_order_acquire) &&
+           !this->lru_work_queued_.load(std::memory_order_acquire);
  }

  static void destroy(void *p);
@@ -357,11 +362,13 @@ class AsyncEventSourceResponse {
  RAMUniquePtr<uint8_t[]> tail_;
  uint32_t send_failure_started_ms_{0};  // Zero means no send stall in progress.
  uint32_t next_close_attempt_ms_{0};
+  uint32_t last_lru_refresh_ms_{0};
  uint16_t tail_cap_{0};
  uint16_t tail_len_{0};  // Zero means nothing pending
  uint16_t tail_sent_{0};
  // Set on the main loop before queueing close work, cleared by the HTTPD-task callback when done.
  std::atomic<bool> close_work_queued_{false};
+  std::atomic<bool> lru_work_queued_{false};
  // Main-loop only; the HTTPD task never reads or writes these flags.
  bool close_requested_{false};
  bool close_retry_warning_logged_{false};
@@ -383,6 +390,7 @@ class AsyncEventSourceResponse {
  static constexpr uint32_t SEND_STALL_TIMEOUT_MS = 20000;
  static constexpr uint32_t CLOSE_RETRY_INTERVAL_MS = 250;
  static constexpr uint32_t CLOSE_CONFIRM_INTERVAL_MS = 1000;
+  static constexpr uint32_t LRU_REFRESH_INTERVAL_MS = 1000;
 };

 using AsyncEventSourceClient = AsyncEventSourceResponse;
@@ -5,7 +5,6 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_check.h"
-#include "nvs_flash.h"
 #include "zigbee_attribute_esp32.h"
 #include "zigbee_esp32.h"
 #include "esphome/core/application.h"
@@ -1,4 +1,4 @@
-import datetime
+import datetime as dt
 import random

 import esphome.codegen as cg
@@ -176,7 +176,7 @@ async def _attr_to_code(config: ConfigType) -> None:
            basic_attrs.date_code,
            # Local build time, matching the esp32 implementation
            # (App.get_build_time() in C++).
-            datetime.datetime.now().astimezone().strftime("%Y%m%d %H%M%S"),
+            dt.datetime.now().astimezone().strftime("%Y%m%d %H%M%S"),
        ),
        zigbee_assign(
            basic_attrs.power_source,
@@ -217,6 +217,7 @@
 #define TCA8418_LISTENER_COUNT 1
 #define USE_MEDIA_PLAYER
 #define USE_MEDIA_SOURCE
+#define NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT 1
 #define USE_NETWORK
 #define USE_NETWORK_DEFAULT_ROUTE
 #define USE_NETWORK_PRIMARY_INTERFACE_WIFI
@@ -271,6 +272,7 @@
 #define USE_TMP102_BINARY_SENSOR
 #define USE_TMP102_CONFIGURE
 #define USE_TMP102_NUMBER
+#define USE_TMP102_TEXT_SENSOR
 #define USE_TOUCHSCREEN
 #define USE_UART_DEBUGGER
 #define USE_UART_WAKE_LOOP_ON_RX
@@ -329,7 +331,7 @@
 #define USE_NOISE
 #define USE_NOISE_SPARE_EPHEMERAL
 #define USE_SHA256
-#ifndef USE_RP2  // no MQTT backend or esp_wireguard library on RP2
+#if !defined(USE_RP2) && !defined(USE_HOST)  // no MQTT backend or esp_wireguard library on RP2 and host
 #define USE_MQTT
 #define USE_MQTT_COVER_JSON
 #define USE_WIREGUARD
@@ -418,7 +420,9 @@
 #define USE_ESPNOW
 #define USE_ESPNOW_MAX_PAYLOAD_SIZE 1470

+#ifndef USE_HOST  // web_server, captive_portal: no ESPAsyncWebServer on host
 #define USE_CAPTIVE_PORTAL
+#endif
 #define USE_WIFI_SCAN_RESULTS_LOCK
 #define USE_ESP32_BLE
 #define USE_ESP32_BLE_MAX_CONNECTIONS 3
@@ -476,6 +480,7 @@
 #define USE_SPI
 #define USE_SPI_PSRAM_DMA
 #define USE_VOICE_ASSISTANT
+#ifndef USE_HOST
 #define USE_WEBSERVER
 #define USE_WEBSERVER_AUTH
 #define USE_WEBSERVER_AUTH_DIGEST
@@ -487,6 +492,7 @@
 #define USE_WEBSERVER_ALLOWED_ORIGINS
 #define WEB_SERVER_DEFAULT_HEADERS_COUNT 1
 #define USE_CAPTIVE_PORTAL_GZIP
+#endif
 #define USE_WIFI_11KV_SUPPORT
 #define USE_WIFI_FAST_CONNECT
 #define USE_WIFI_FAST_CONNECT_IN_FLASH
@@ -567,6 +573,10 @@
 #endif
 #ifndef USE_OPENTHREAD
 #define USE_MDNS_SUPPORTS_ENABLE_DISABLE
+#ifdef USE_ETHERNET
+#define USE_MDNS_ACTIVE_INTERFACE_LISTENER
+#define USE_MDNS_DYNAMIC_NETWORK_TXT
+#endif
 #endif
 #endif

@@ -647,6 +657,7 @@
 #define USE_ETHERNET_SPI
 #endif
 #define USE_ETHERNET_W5500
+#define USE_MDNS_DYNAMIC_NETWORK_TXT
 #define USE_WIFI_IP_STATE_LISTENERS
 #define ESPHOME_WIFI_IP_STATE_LISTENERS 2
 #define USE_ETHERNET_IP_STATE_LISTENERS
@@ -684,6 +695,8 @@
 #endif

 #ifdef USE_HOST
+#define USE_ESPHOME_HOST_MAC_ADDRESS \
+  { 0x98, 0x35, 0x69, 0xab, 0xf6, 0x79 }
 #define USE_HTTP_REQUEST_RESPONSE
 // Host only: the uart arm would shadow the native logger UART arms in other envs
 #define USE_IMPROV_SERIAL_UART
@@ -1,5 +1,6 @@
 #pragma once

+#include <algorithm>
 #include <array>
 #include <cstddef>
 #include <cstdint>
@@ -68,6 +69,7 @@ template<size_t N> struct FixedString {
 };

 /// Compile-time string table that packs strings into a single blob with offset lookup.
+/// Blobs over 255 bytes have no offsets and are scanned, so keep those for rarely read strings.
 /// Use PROGMEM_STRING_TABLE macro to instantiate with proper flash placement on ESP8266.
 ///
 /// Example:
@@ -78,6 +80,11 @@ template<size_t N> struct FixedString {
 template<FixedString... Strs> struct ProgmemStringTable {
  static constexpr size_t COUNT = sizeof...(Strs);
  static constexpr size_t BLOB_SIZE = (0 + ... + (Strs.size() + 1));
+  /// Length of the longest string, for sizing a RAM copy on ESP8266
+  static constexpr size_t MAX_LENGTH = std::max({Strs.size()...});
+  /// One-byte offsets address up to 255 bytes; a larger blob has no offset table and is scanned instead,
+  /// which costs less flash than wider offsets for the rarely read tables that get this big.
+  static constexpr bool INDEXED = BLOB_SIZE <= UINT8_MAX;

  /// Generate packed string blob at compile time
  static constexpr auto make_blob() {
@@ -91,18 +98,28 @@ template<FixedString... Strs> struct ProgmemStringTable {
    return result;
  }

-  /// Generate offset table at compile time (uint8_t limits blob to 255 bytes)
+  /// Generate offset table at compile time
  static constexpr auto make_offsets() {
    static_assert(COUNT > 0, "PROGMEM_STRING_TABLE must contain at least one string");
    static_assert(COUNT <= 255, "PROGMEM_STRING_TABLE supports at most 255 strings with uint8_t indices");
-    static_assert(BLOB_SIZE <= 255, "PROGMEM_STRING_TABLE blob exceeds 255 bytes; use fewer/shorter strings");
-    std::array<uint8_t, COUNT> result{};
-    size_t pos = 0, idx = 0;
-    ((result[idx++] = static_cast<uint8_t>(pos), pos += Strs.size() + 1), ...);
-    return result;
+    if constexpr (INDEXED) {
+      std::array<uint8_t, COUNT> result{};
+      size_t pos = 0, idx = 0;
+      ((result[idx++] = static_cast<uint8_t>(pos), pos += Strs.size() + 1), ...);
+      return result;
+    } else {
+      return std::array<uint8_t, 0>{};
+    }
  }
 };

+/// Skip idx strings in a packed NUL-separated blob that may live in flash.
+inline const char *progmem_skip_strings(const char *blob, uint8_t idx) {
+  while (idx-- > 0)
+    blob += ESPHOME_strlen_P(blob) + 1;
+  return blob;
+}
+
 // Forward declaration for LogString (defined in log.h)
 struct LogString;

@@ -115,6 +132,7 @@ struct LogString;
    static constexpr size_t COUNT = Table::COUNT; \
    static constexpr uint8_t LAST_INDEX = COUNT - 1; \
    static constexpr size_t BLOB_SIZE = Table::BLOB_SIZE; \
+    static constexpr size_t MAX_LENGTH = Table::MAX_LENGTH; \
    static constexpr auto BLOB ESPHOME_PROGMEM_STRING_TABLE_STORAGE = Table::make_blob(); \
    static constexpr auto OFFSETS ESPHOME_PROGMEM_STRING_TABLE_STORAGE = Table::make_offsets(); \
    static const char *get_(uint8_t idx, uint8_t fallback) { \
@@ -122,7 +140,10 @@ struct LogString;
        idx = fallback; \
      /* std::launder is used here to prevent the inter-procedural analysis that */ \
      /* causes the false positive that the string is not null terminated */ \
-      return std::launder(&BLOB[::esphome::progmem_read_byte(&OFFSETS[idx])]); \
+      if constexpr (Table::INDEXED) \
+        return std::launder(&BLOB[::esphome::progmem_read_byte(&OFFSETS[idx])]); \
+      else \
+        return std::launder(::esphome::progmem_skip_strings(BLOB.data(), idx)); \
    } \
    static ::ProgmemStr get_progmem_str(uint8_t idx, uint8_t fallback) { \
      return reinterpret_cast<::ProgmemStr>(get_(idx, fallback)); \
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
J. Nick Koston	cdab2aa2cf	Merge remote-tracking branch 'origin/shelly_dimmer-tables-progmem' into shelly_dimmer-drop-unused-dev-fields # Conflicts: # esphome/components/shelly_dimmer/dev_table.h # esphome/components/shelly_dimmer/stm32flash.h	2026-10-14 08:14:42 -10:00
J. Nick Koston	f8777fb60e	Merge remote-tracking branch 'origin/dev' into shelly_dimmer-tables-progmem	2026-10-14 08:13:27 -10:00
Jonathan Swoboda	9fe75e262f	[ci] Add a host clang-tidy environment and job (#20747 )	2026-10-14 08:09:53 -10:00
Kevin Ahrendt	0132f722a3	[audio] Bump esp-audio-libs to v4.1.0 (#20754 )	2026-10-14 13:24:36 -04:00
Jonathan Swoboda	7d7a78308d	[ci] Test tinyusb_keyboard in isolation (#20749 )	2026-10-14 10:05:02 -04:00
J. Nick Koston	9c568525b0	[core] Add CodSpeed benchmarks for importing entity components (#20648 )	2026-10-14 09:08:41 -04:00
J. Nick Koston	d8cf0c6afb	Make the 4-byte alignment of the directly read flash tables explicit	2026-10-14 09:03:39 -04:00
J. Nick Koston	04216571e6	Note why the page-size tables are read directly	2026-10-14 09:03:39 -04:00
J. Nick Koston	c304871e73	Read the device table in place with word-only fields instead of copying an entry	2026-10-14 09:03:39 -04:00
J. Nick Koston	1e21b8a417	Drop the redundant static inside the anonymous namespace	2026-10-14 09:03:39 -04:00
J. Nick Koston	bd6a0c0241	[shelly_dimmer] Keep the STM32 device table in flash	2026-10-14 09:03:39 -04:00
J. Nick Koston	10f42e3e7c	[shelly_dimmer] Build the STM32 firmware update path in CI (#20677 )	2026-10-14 09:03:34 -04:00
J. Nick Koston	25d4b88605	[nfc] Add unit tests for the URI record prefix codes (#20724 )	2026-10-14 09:01:59 -04:00
J. Nick Koston	d6abf35138	[sx126x][sx127x] Stop the watchdog reset loop when a packet is sent before setup (#20727 )	2026-10-14 09:01:10 -04:00
J. Nick Koston	66ea99ce65	[seeed_mr60fda2] Compile without binary sensors or selects (#20726 )	2026-10-14 09:00:08 -04:00
J. Nick Koston	d9298cb7b9	[seeed_mr60bha2] Compile without sensors or binary sensors (#20729 )	2026-10-14 08:59:27 -04:00
J. Nick Koston	34e1cf96d5	[bmi270] Build the component on ESP8266 in CI (#20731 )	2026-10-14 08:58:56 -04:00
J. Nick Koston	008e772e08	Merge remote-tracking branch 'origin/shelly_dimmer-tables-progmem' into shelly_dimmer-drop-unused-dev-fields # Conflicts: # esphome/components/shelly_dimmer/dev_table.h	2026-10-14 00:30:54 -10:00
J. Nick Koston	160eece4fb	Make the 4-byte alignment of the directly read flash tables explicit	2026-10-14 00:29:45 -10:00
Pavlo Dudnytskyi pre-commit-ci-lite[bot]Pavlo Dudnytskyi Jonathan Swoboda J. Nick Koston	56cc03c4d4	[haier] Haier Select component added (#16148 ) Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com> Co-authored-by: Pavlo Dudnytskyi <Pavlo.Dudnytskyi@addsecure.com> Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com> Co-authored-by: J. Nick Koston <nick@home-assistant.io>	2026-10-13 23:27:18 -10:00
Anunay Kulshrestha Claude Fable 5 J. Nick Koston J. Nick Koston	35b416c6c0	[web_server_idf] Keep active SSE sessions out of the LRU purge (#17383 ) Co-authored-by: Claude Fable 5 <noreply@anthropic.com> Co-authored-by: J. Nick Koston <nick@koston.org> Co-authored-by: J. Nick Koston <nick@home-assistant.io>	2026-10-13 22:19:06 -10:00
Petar Petrov	7f2c3ba3f5	[display] Let other components draw into a display (#20622 )	2026-10-14 06:11:47 +00:00
Keith BurzinskiandClaude Opus 5.5	a97604d574	[esp32_ble] Rely on preferences for NVS init (#20708 ) Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-13 20:10:51 -10:00
J. Nick Koston	9f0c1f4abb	Run the flash table reads on an ESP8266	2026-10-13 19:43:57 -10:00
J. Nick Koston	166cb2dbf9	Merge remote-tracking branch 'origin/shelly_dimmer-tables-progmem' into shelly_dimmer-drop-unused-dev-fields	2026-10-13 19:41:54 -10:00
Petar Petrov	1146b77836	[socket] Add TcpClientLink::connecting() (#20722 )	2026-10-13 19:19:17 -10:00
J. Nick Koston	741421a244	Note why the page-size tables are read directly	2026-10-13 18:41:20 -10:00
J. Nick Koston	1338902ac5	[heatpumpir] Link only the configured protocol classes (#20707 )	2026-10-14 17:06:22 +13:00
Dmitrii Kuminov pre-commit-ci-lite[bot]J. Nick Koston J. Nick Koston	60a1d70805	[core] Move deferred include processing to parse_yaml (#16344 ) Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com> Co-authored-by: J. Nick Koston <nick@koston.org> Co-authored-by: J. Nick Koston <nick@home-assistant.io>	2026-10-13 17:46:54 -10:00
Ryan LudwigandCursor	887d4c3a83	[esp32_can] Add NO_ACK mode (#20706 ) Co-authored-by: Cursor <cursoragent@cursor.com>	2026-10-13 17:36:15 -10:00
J. Nick Koston	c1fa73470e	[display] Walk the blit fallback in frame buffer order and resolve the bitness once (#20651 )	2026-10-13 17:31:13 -10:00
J. Nick Koston	e41d16ba7e	[haier] Keep the alarm message table in flash (#20641 )	2026-10-14 03:23:28 +00:00
J. Nick Koston	5171113c87	[core] Let PROGMEM_STRING_TABLE hold more than 255 bytes (#20646 )	2026-10-13 17:17:48 -10:00
techdregsandJ. Nick Koston	5718e4b779	[tmp102] Add text sensor for diagnostics (#20629 ) Co-authored-by: J. Nick Koston <nick@koston.org>	2026-10-13 17:06:56 -10:00
J. Nick Koston	40e12cd0d8	[image] Add CodSpeed benchmarks for image, runtime image and display block draws (#20649 )	2026-10-13 17:01:47 -10:00
Brandon HarveyandJ. Nick Koston	07029d0077	[sen6x] Add measurement control and maintenance actions (#18783 ) Co-authored-by: J. Nick Koston <nick@home-assistant.io>	2026-10-14 15:47:31 +13:00
Christopher Reimer	bb1119d83f	[esp32_can] Support 20 kbit/s on ESP32 revision 2 or later (#20426 )	2026-10-13 22:34:03 -04:00
willumpie82Willem OldemansClaude Sonnet 5 J. Nick Koston J. Nick Koston	7b591b26d6	[sy6970] Service the I2C watchdog so charge/LED settings persist (#19424 ) Co-authored-by: Willem Oldemans <> Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com> Co-authored-by: J. Nick Koston <nick@koston.org> Co-authored-by: J. Nick Koston <nick@home-assistant.io>	2026-10-13 16:19:58 -10:00
Andres Signes Grimalt J. Nick Koston J. Nick Koston	f45e6f0bf4	[midea] Add display_control and send the display toggle over UART without a transmitter (#18671 ) Co-authored-by: J. Nick Koston <nick@koston.org> Co-authored-by: J. Nick Koston <nick@home-assistant.io>	2026-10-13 16:03:18 -10:00
Keith BurzinskiandClaude Opus 5.5	4b8af08155	[network] Notify listeners when the active interface changes (#20684 ) Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-13 20:57:59 -05:00
dependabot[bot]esphome[bot]Jonathan Swoboda	613973b432	Bump ruff from 0.16.10 to 0.17.0 (#20694 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: esphome[bot] <115708604+esphome[bot]@users.noreply.github.com> Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>	2026-10-13 21:53:44 -04:00
dependabot[bot]	9ee4314bc2	Bump esptool from 5.4.0 to 5.5.0 (#20693 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-10-13 15:41:30 -10:00
fredkotzeandJ. Nick Koston	59f55dbe9e	[epaper_spi] Add Waveshare 2.13in-G (JD79660) display models (#18141 ) Co-authored-by: J. Nick Koston <nick@home-assistant.io>	2026-10-13 15:40:28 -10:00
dependabot[bot]	8fce95454a	Bump github/codeql-action/init from 4.38.2 to 4.38.3 (#20701 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-10-13 15:39:49 -10:00
dependabot[bot]	16134ee993	Bump astral-sh/setup-uv from 10.2.0 to 10.3.0 (#20704 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-10-13 15:39:38 -10:00
dependabot[bot]	bc39d56bb4	Bump CodSpeedHQ/action from 5.4.0 to 5.4.2 (#20705 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-10-13 15:39:29 -10:00
dependabot[bot]	c5522abc71	Bump github/codeql-action/analyze from 4.38.2 to 4.38.3 (#20699 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-10-13 21:39:11 -04:00
dependabot[bot]	7cb5906d2a	Bump actions/upload-artifact from 7.0.1 to 7.0.2 (#20702 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-10-14 01:38:42 +00:00
dependabot[bot]	d452dbce30	Bump actions/download-artifact from 8.0.1 to 8.0.2 (#20703 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-10-14 01:38:39 +00:00
dependabot[bot]	81e5b50087	Bump backports-zstd from 1.7.0 to 1.8.0 (#20695 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-10-13 15:38:35 -10:00
dependabot[bot]	426a4a2dce	Bump filelock from 4.0.12 to 4.1.0 (#20696 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-10-13 15:38:26 -10:00
dependabot[bot]andesphome[bot]	c95c17c4e7	Bump pyupgrade from 3.21.2 to 3.22.0 (#20698 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: esphome[bot] <115708604+esphome[bot]@users.noreply.github.com>	2026-10-13 15:38:17 -10:00
dependabot[bot]	576d3325fe	Bump astral-sh/setup-uv from 10.2.0 to 10.3.0 in /.github/actions/restore-python (#20700 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-10-13 15:37:47 -10:00
dependabot[bot]	c9cf0ad92e	Bump platformdirs from 4.12.3 to 4.12.4 (#20697 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-10-13 21:37:36 -04:00
Felipe Guedes	f505212e64	[epaper_spi] Add Waveshare 2.66" e-Paper Module (B) support (#20546 )	2026-10-13 15:03:05 -10:00
J. Nick Koston	52a5e6a007	[rpi_dpi_rgb] Set removal of the deprecated component for 2027.5.0 (#20691 )	2026-10-14 13:32:18 +13:00
J. Nick Koston	3b261d2cf0	[st7789v] Set removal of the deprecated component for 2027.5.0 (#20689 )	2026-10-14 13:30:52 +13:00
J. Nick Koston	9238fcc727	[st7735] Set removal of the deprecated component for 2027.5.0 (#20688 )	2026-10-14 13:30:21 +13:00
J. Nick Koston	96902cc122	[qspi_dbi] Set removal of the deprecated component for 2027.5.0 (#20690 )	2026-10-14 13:29:52 +13:00
J. Nick Koston	95711d83d1	[ili9xxx] Set removal of the deprecated component for 2027.5.0 (#20687 )	2026-10-14 13:29:29 +13:00
J. Nick Koston	5538c30453	Merge remote-tracking branch 'origin/shelly_dimmer-tables-progmem' into shelly_dimmer-drop-unused-dev-fields	2026-10-13 12:32:02 -10:00
J. Nick Koston	fffe30c497	Merge remote-tracking branch 'origin/shelly-dimmer-update-test' into shelly_dimmer-tables-progmem	2026-10-13 12:31:53 -10:00
J. Nick Koston	7dcd608a5f	Merge remote-tracking branch 'origin/dev' into shelly-dimmer-update-test	2026-10-13 12:31:43 -10:00
J. Nick Koston	7b20ccc5b3	Merge remote-tracking branch 'origin/shelly_dimmer-tables-progmem' into shelly_dimmer-drop-unused-dev-fields	2026-10-13 11:43:10 -10:00
J. Nick Koston	0d56ae0ea9	Merge remote-tracking branch 'origin/shelly-dimmer-update-test' into shelly_dimmer-tables-progmem	2026-10-13 11:43:01 -10:00
J. Nick Koston	b1e3e70b44	[shelly_dimmer] Build the STM32 firmware update path in CI	2026-10-13 11:42:44 -10:00
J. Nick Koston	2ca4479459	Drop the stale option byte note from the table comment	2026-10-13 11:30:28 -10:00
J. Nick Koston	5a68731bbb	[shelly_dimmer] Drop the device table fields that are never read	2026-10-13 11:13:51 -10:00
J. Nick Koston	572b2635c6	Read the device table in place with word-only fields instead of copying an entry	2026-10-13 10:27:10 -10:00
J. Nick Koston	85d4511dbb	Drop the redundant static inside the anonymous namespace	2026-10-13 10:16:22 -10:00
J. Nick Koston	9d3b3b650e	[shelly_dimmer] Keep the STM32 device table in flash	2026-10-13 10:03:57 -10:00