Merge branch 'dev' into uart-debug-event-flash

Merge remote-tracking branch 'origin/dev' into HEAD
Merge remote-tracking branch 'origin/dev' into uart-debug-event-flash
2026-10-24 23:15:34 +00:00 · 2026-10-12 17:33:23 -10:00 · 2026-10-09 18:27:50 -10:00 · 2026-10-04 18:06:45 -05:00 · 2026-10-03 16:06:49 -05:00 · 2026-10-03 15:38:41 -05:00
564 changed files with 2023 additions and 22964 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@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+      uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.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@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.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@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        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@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        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@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
        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@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.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 libmbedtls-dev ccache
-          version: 1.2
+          packages: libsdl2-dev ccache
+          version: 1.1

  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 libmbedtls-dev ccache
-          version: 1.2
+          packages: libsdl2-dev ccache
+          version: 1.1
      - 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@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.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@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        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@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        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@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        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@f842b9a3ffe213dbb81768fd7f7eeb4dfcf1c369 # v5.4.2
+        uses: CodSpeedHQ/action@c4fd08a3a159bd0cc208da1e0edf32b8c47d75e5 # v5.4.0
        with:
          run: |
            . venv/bin/activate
@@ -680,7 +680,7 @@ jobs:
        include:
          - id: clang-tidy
            name: Run script/clang-tidy for ESP8266
-            options: --environment esp8266-arduino-tidy --grep USE_ESP8266 --grep USE_SOCKET_IMPL_LWIP_TCP --grep USE_SHD_FIRMWARE_DATA
+            options: --environment esp8266-arduino-tidy --grep USE_ESP8266
            pio_cache_key: tidyesp8266
          - id: clang-tidy
            name: Run script/clang-tidy for ESP32 Arduino
@@ -693,16 +693,12 @@ jobs:
            ignore_errors: false
          - id: clang-tidy
            name: Run script/clang-tidy for RP2
-            options: --environment rp2-tidy --grep USE_RP2 --grep USE_BLE_SCAN_RESPONSE_MERGER
+            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
-            options: --grep USE_LIBRETINY --grep USE_BK72XX --grep USE_RTL87XX --grep USE_LN882X --grep USE_LN882H_BLE --grep USE_SOCKET_IMPL_LWIP_SOCKETS
+            options: --grep USE_LIBRETINY --grep USE_BK72XX --grep USE_RTL87XX --grep USE_LN882X
            pio_cache_key: tidylibretiny

    steps:
@@ -711,16 +707,6 @@ 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
@@ -1003,14 +989,14 @@ jobs:
          - id: clang-tidy
            name: Run script/clang-tidy for ESP32 S3
            # yamllint disable-line rule:line-length
-            options: --environment esp32s3-idf-tidy --grep SOC_TEMP_SENSOR_SUPPORTED --grep USE_ESP32_VARIANT_ESP32S3 --grep USE_LOGGER_USB_CDC --grep SOC_I2S_SUPPORTS_TDM
+            options: --environment esp32s3-idf-tidy --grep SOC_TEMP_SENSOR_SUPPORTED --grep USE_ESP32_VARIANT_ESP32S3 --grep USE_LOGGER_USB_CDC
            tidy_environment: esp32s3-idf-tidy
          - id: clang-tidy
            name: Run script/clang-tidy for ESP32 P4
            # P4 has no native Wi-Fi/BLE; those run over the hosted co-processor,
            # so their code paths differ -- lint them under the P4 build too.
            # yamllint disable-line rule:line-length
-            options: --environment esp32p4-idf-tidy --grep USE_ESP32_VARIANT_ESP32P4 --grep CONFIG_IDF_TARGET_ESP32P4 --grep USE_ESP32_HOSTED --grep USE_WIFI --grep USE_BLE
+            options: --environment esp32p4-idf-tidy --grep USE_ESP32_VARIANT_ESP32P4 --grep USE_ESP32_HOSTED --grep USE_WIFI --grep USE_BLE
            tidy_environment: esp32p4-idf-tidy
          - id: clang-tidy
            name: Run script/clang-tidy for ESP32 C6
@@ -1116,8 +1102,8 @@ jobs:
        timeout-minutes: 10
        uses: awalsh128/cache-apt-pkgs-action@553a35bb8ebd9fcabcb1c9451aa4c98e1b4ca8a9 # v1.6.3
        with:
-          packages: libsdl2-dev libmbedtls-dev ccache
-          version: 1.2
+          packages: libsdl2-dev ccache
+          version: 1.1

      - name: Check out code from GitHub
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -1462,7 +1448,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@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -1661,7 +1647,7 @@ jobs:
          fi

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

      - name: Upload memory analysis JSON
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: memory-analysis-pr
          path: memory-analysis-pr.json
@@ -1754,13 +1740,13 @@ jobs:
          python-version: ${{ env.DEFAULT_PYTHON }}
          cache-key: ${{ needs.common.outputs.cache-key }}
      - name: Download target analysis JSON
-        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
        with:
          name: memory-analysis-target
          path: ./memory-analysis
        continue-on-error: true
      - name: Download PR analysis JSON
-        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
        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@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
+        uses: github/codeql-action/init@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
        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@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
+        uses: github/codeql-action/analyze@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
        with:
          category: "/language:${{matrix.language}}"
@@ -162,7 +162,7 @@ jobs:
      #     version: ${{ needs.init.outputs.tag }}

      - name: Upload digests
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        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@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
        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@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.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.17.0
+    rev: v0.16.10
    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.22.0
+    rev: v3.21.2
    hooks:
      - id: pyupgrade
        args: [--py312-plus]
@@ -144,9 +144,6 @@ file does, and it is the authority when they disagree. The most useful starting

 *   **C++ Preprocessor Directives:**
    *   **Avoid `#define` for constants:** Using `#define` for constants is discouraged and should be replaced with `const` variables or enums.
-    *   **A constant with a compile-time initializer is `static constexpr`,** not `static const`, at namespace scope
-        and inside functions; `static const` is only for a value computed at run time. A function-local
-        `static constexpr` table is a static constant to clang-tidy, so it is `UPPER_SNAKE_CASE` too.
    *   **Use `#define` only for:**
        - Conditional compilation (`#ifdef`, `#ifndef`)
        - Compile-time sizes calculated during Python code generation (e.g., configuring `std::array` or `StaticVector` dimensions via `cg.add_define()`)
@@ -220,9 +217,6 @@ file does, and it is the authority when they disagree. The most useful starting
        listener base (a second vptr per entity).
    *   **A global feature define** says the code is compiled in, not that this instance uses it: keep the
        per-instance check (`if (this->aux_device_ == ...)`) inside the `#ifdef`.
-    *   **Model-specific code** sits behind a define the Python side emits only for configs that use that model
-        (`cg.add_define("USE_SELEC_METER_EM4M")`), so the other models' builds leave it out; the runtime model check
-        stays inside the `#ifdef`.
    *   **Failures after `setup()`:** `mark_failed()` is for `setup()` only. A runtime read or write failure
        sets `status_set_warning()` and the next success clears it; writes skip work when `is_failed()`.
    *   **Fixed platform facts compile to nothing:** gate on `#ifdef USE_ESP8266` and friends, not on a
@@ -573,9 +567,6 @@ file does, and it is the authority when they disagree. The most useful starting
    An intentionally empty body (an unused `register_dumper` builder, for example) gets a one-line docstring, not `pass`.

 *   **Configuration Validation:**
-    *   **One schema per model:** when a component's options depend on a `model` key, use `cv.typed_schema({...},
-        key=CONF_MODEL, default_type=...)` with each model's own keys and defaults, not one schema plus a validator
-        that rejects keys and fills defaults afterwards.
    *   **Reuse existing validators:** Before writing a custom validator, check for an existing one in `config_validation.py` and compose it in `cv.All(...)` rather than duplicating logic across components. For example, rename a config key with `cv.rename_key(CONF_OLD, CONF_NEW, removed_in="2026.6.0")`, and reject mutually-exclusive keys with `cv.has_at_most_one_key(...)` / `cv.has_exactly_one_key(...)`. See how `api` composes `cv.has_exactly_one_key` + `cv.rename_key`.
    *   **Common Validators:** `cv.int_`, `cv.float_`, `cv.string`, `cv.boolean`, `cv.int_range(min=0, max=100)`, `cv.positive_int`, `cv.percentage`.
    *   **Complex Validation:** `cv.All(cv.string, cv.Length(min=1, max=50))`, `cv.Any(cv.int_, cv.string)`.
@@ -618,9 +609,6 @@ file does, and it is the authority when they disagree. The most useful starting
        `on_tx` lambda with a static counter and `inject_to_rx_buffer` (see `uart_mock_ld2412_requery_after_giveup.yaml`).
    *   **Keep build-test variants few:** one `test.<platform>.yaml` per platform the code actually differs
        on. A variant per board for platform-identical code only adds CI time.
-    *   **A test that needs a shared component in a particular state** (`esp32_ble` security settings, an option
-        that PSRAM rejects) cannot be grouped: the merged block wins and the whole batch fails. Add the component to
-        `ISOLATED_COMPONENTS` in `script/analyze_component_buses.py`, or move the option to a `test-<variant>` file.
    *   **Component Tests:** YAML-based compilation tests are located in `tests/`. The structure is as follows:
        ```
        tests/
@@ -183,7 +183,6 @@ esphome/components/es7243e/* @kbx81
 esphome/components/es8156/* @kbx81
 esphome/components/es8311/* @kahrendt @kroimon
 esphome/components/es8388/* @P4uLT
-esphome/components/es9038q2m_katana/* @GioMez
 esphome/components/esp32/* @esphome/core
 esphome/components/esp32_ble/* @bdraco @jesserockz @Rapsssito
 esphome/components/esp32_ble_client/* @bdraco @jesserockz
@@ -213,14 +212,12 @@ esphome/components/factory_reset/* @anatoly-savchenkov
 esphome/components/fastled_base/* @OttoWinter
 esphome/components/feedback/* @ianchi
 esphome/components/file/* @esphome/core
-esphome/components/filter_lifetime/* @tuct
 esphome/components/fingerprint_grow/* @alexborro @loongyh @OnFreund
 esphome/components/font/* @clydebarrow @esphome/core
 esphome/components/friedrich/* @rwrozelle
 esphome/components/fs3000/* @kahrendt
 esphome/components/ft5x06/* @clydebarrow
 esphome/components/ft63x6/* @gpambrozio
-esphome/components/fusb302b/* @remcom
 esphome/components/gcja5/* @gcormier
 esphome/components/gdk101/* @Szewcson
 esphome/components/gl_r01_i2c/* @pkejval
@@ -242,13 +239,9 @@ 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
-esphome/components/haier_tundra/* @fauxpark
-esphome/components/haier_tundra/button/* @fauxpark
-esphome/components/haier_tundra/switch/* @fauxpark
 esphome/components/havells_solar/* @sourabhjaiswal
 esphome/components/hbridge/fan/* @WeekendWarrior
 esphome/components/hbridge/light/* @DotNetDann
@@ -257,7 +250,6 @@ esphome/components/hc8/* @omartijn
 esphome/components/hdc2010/* @optimusprimespace @ssieb
 esphome/components/hdc2080/* @G-Pereira @jesserockz
 esphome/components/hdc302x/* @joshuasing
-esphome/components/hdmi_cec/* @JosVanEijndhoven
 esphome/components/he60r/* @clydebarrow
 esphome/components/heatpumpir/* @rob-deutsch
 esphome/components/hitachi_ac424/* @sourabhjaiswal
@@ -294,7 +286,6 @@ esphome/components/i2s_audio/microphone/* @jesserockz
 esphome/components/i2s_audio/speaker/* @jesserockz @kahrendt
 esphome/components/i2s_clockless_led_strip/* @j9brown
 esphome/components/iaqcore/* @yozik04
-esphome/components/icm20689/* @lboue
 esphome/components/icnt86/* @danepowell
 esphome/components/ili9xxx/* @clydebarrow @nielsnl68
 esphome/components/improv_base/* @esphome/core
@@ -389,7 +380,6 @@ esphome/components/microphone/* @jesserockz @kahrendt
 esphome/components/mics_4514/* @jesserockz
 esphome/components/midea/* @dudanov
 esphome/components/midea_ir/* @dudanov
-esphome/components/midea_portasplit/* @Fexiven
 esphome/components/mipi_dsi/* @clydebarrow
 esphome/components/mipi_rgb/* @clydebarrow
 esphome/components/mipi_spi/* @clydebarrow
@@ -444,7 +434,6 @@ esphome/components/ota/* @esphome/core
 esphome/components/output/* @esphome/core
 esphome/components/packet_transport/* @clydebarrow
 esphome/components/pca6416a/* @Mat931
-esphome/components/pca9505/* @ajfriesen @ssieb
 esphome/components/pca9554/* @bdraco @clydebarrow @hwstar
 esphome/components/pcf85063/* @brogon
 esphome/components/pcf8563/* @KoenBreeman
@@ -483,9 +483,12 @@ def has_ota() -> bool:

 def has_native_ota() -> bool:
    """Check if native API OTA upload is available (``platform: esphome``)."""
-    from esphome.espota2 import esphome_ota_items
-
-    return bool(esphome_ota_items(CORE.config))
+    if CONF_OTA not in CORE.config:
+        return False
+    return any(
+        ota_item.get(CONF_PLATFORM) == CONF_ESPHOME
+        for ota_item in CORE.config[CONF_OTA]
+    )


 def has_web_server_ota() -> bool:
@@ -1356,17 +1359,14 @@ def _choose_ota_platform(config: ConfigType, requested: str | None) -> str:
    return CONF_WEB_SERVER


-def _esphome_ota_conf(config: ConfigType) -> ConfigType | None:
-    """The validated esphome OTA platform block, if configured."""
-    from esphome.espota2 import esphome_ota_items
-
-    return next(iter(esphome_ota_items(config)), None)
-
-
 def _upload_via_native_api(
    config: ConfigType, network_devices: list[str], args: ArgsProtocol
 ) -> tuple[int, str | None]:
-    ota_conf = _esphome_ota_conf(config) or {}
+    ota_conf: ConfigType = {}
+    for ota_item in config.get(CONF_OTA, []):
+        if ota_item.get(CONF_PLATFORM) == CONF_ESPHOME:
+            ota_conf = ota_item
+            break

    from esphome import espota2
    from esphome.components.noise import static_encryption_key
@@ -1457,8 +1457,10 @@ def _old_key_notice(config: ConfigType) -> None:
    `upload` may send a stale image that still carries the previous key."""
    from esphome import espota2

-    for item in espota2.esphome_ota_items(config):
-        if (item.get(CONF_ENCRYPTION) or {}).get(espota2.CONF_OLD_KEY):
+    for item in config.get(CONF_OTA, []):
+        if item.get(CONF_PLATFORM) == CONF_ESPHOME and (
+            item.get(CONF_ENCRYPTION) or {}
+        ).get(espota2.CONF_OLD_KEY):
            _LOGGER.warning(espota2.OLD_KEY_REMOVE_NOTICE)


@@ -1466,12 +1468,12 @@ def _upload_via_web_server(
    config: ConfigType, network_devices: list[str], binary: Path
 ) -> tuple[int, str | None]:
    from esphome import web_server_ota
-    from esphome.espota2 import esphome_ota_items
    from esphome.web_server_helpers import get_web_server_connection

    if any(
-        ota_item.get(CONF_ENCRYPTION) is not None
-        for ota_item in esphome_ota_items(config)
+        ota_item.get(CONF_PLATFORM) == CONF_ESPHOME
+        and ota_item.get(CONF_ENCRYPTION) is not None
+        for ota_item in config.get(CONF_OTA, [])
    ):
        _LOGGER.warning(
            "This config has OTA encryption, but the web_server OTA path sends "
@@ -906,21 +906,6 @@ async def while_action_to_code(
    return var


-def _shadow_iteration(args: TemplateArgsType) -> TemplateArgsType:
-    """Rename an inherited `iteration` so the inner repeat's own counter can shadow it."""
-    names = {name for _, name in args}
-    renamed: TemplateArgsType = []
-    for type_, name in args:
-        if name == "iteration":
-            depth = 1
-            while f"iteration_{depth}" in names:
-                depth += 1
-            name = f"iteration_{depth}"
-            names.add(name)
-        renamed.append((type_, name))
-    return renamed
-
-
@register_action(
    "repeat",
    RepeatAction,
@@ -944,7 +929,7 @@ async def repeat_action_to_code(
    actions = await build_action_list(
        config[CONF_THEN],
        cg.TemplateArguments(cg.uint32, *template_arg.args),
-        [(cg.uint32, "iteration"), *_shadow_iteration(args)],
+        [(cg.uint32, "iteration"), *args],
    )
    for action in actions:
        cg.add(var.add_then_action(action))
@@ -251,6 +251,9 @@ def _validate_supports_response(value: Any) -> str:
    return cv.enum(SUPPORTS_RESPONSE_OPTIONS, lower=True)(value)


+# ESP8266 copies every string of an action into a stack buffer sized by codegen; keep it small
+ESP8266_ACTION_STRINGS_MAX_TOTAL = 384
+
 VARIABLE_SCHEMA = cv.Schema(
    {
        cv.Required(CONF_TYPE): cv.one_of(*SERVICE_ARG_NATIVE_TYPES, lower=True),
@@ -481,6 +484,29 @@ def _action_strings(conf: ConfigType, has_metadata: bool) -> list[str | None]:
    return strings


+def _action_strings_size(strings: list[str | None]) -> int:
+    """Bytes needed to copy every string out of flash, each with its terminator."""
+    return sum(
+        len(string.encode("utf-8")) + 1 for string in strings if string is not None
+    )
+
+
+def _validate_esp8266_action_strings(config: ConfigType) -> ConfigType:
+    if not CORE.is_esp8266:
+        return config
+    actions = config.get(CONF_ACTIONS, [])
+    has_metadata = _has_action_metadata(actions)
+    for conf in actions:
+        size = _action_strings_size(_action_strings(conf, has_metadata))
+        if size > ESP8266_ACTION_STRINGS_MAX_TOTAL:
+            raise cv.Invalid(
+                f"Action '{conf[CONF_ACTION]}' has {size} bytes of name, variable name, "
+                f"description and example text; ESP8266 allows at most "
+                f"{ESP8266_ACTION_STRINGS_MAX_TOTAL} bytes per action"
+            )
+    return config
+
+
 def _validate_outgoing_host_ipv6(config: ConfigType) -> ConfigType:
    """An IPv6 host can never be parsed, so never dialed, without IPv6."""
    if (
@@ -505,6 +531,7 @@ def _validate_wizard(config: ConfigType) -> ConfigType:


 FINAL_VALIDATE_SCHEMA = cv.All(
+    _validate_esp8266_action_strings,
    _validate_outgoing_host_ipv6,
    _validate_wizard,
 )
@@ -560,6 +587,7 @@ async def to_code(config: ConfigType) -> None:
    if config[CONF_HOMEASSISTANT_STATES]:
        cg.add_define("USE_API_HOMEASSISTANT_STATES")

+    scratch_size = 0
    if actions:
        # Metadata is compiled in for every action once any action declares it, because the
        # string table layout is fixed by the define rather than per action
@@ -611,6 +639,8 @@ async def to_code(config: ConfigType) -> None:
                func_args.append((native, name))
            strings = _action_strings(conf, has_metadata)
            table = _add_action_strings(index, strings)
+            if CORE.is_esp8266:
+                scratch_size = max(scratch_size, _action_strings_size(strings))
            # Template args: supports_response mode, then user service arg types
            templ = cg.TemplateArguments(supports_response, *service_template_args)
            # Key is hashed here because the name is not readable at runtime on ESP8266
@@ -637,6 +667,9 @@ async def to_code(config: ConfigType) -> None:
                cg.add(auto.add_action(unregister_action))
        # Register all services at once - single allocation, no reallocations
        cg.add(var.initialize_user_services(triggers))
+    if CORE.is_esp8266 and has_user_actions:
+        # Stack buffer that list-entities copies PROGMEM strings into, sized for the largest action
+        cg.add_define("API_USER_ACTION_STRINGS_SCRATCH_SIZE", max(scratch_size, 1))

    if (wizard_config := config.get(wizard.CONF_WIZARD)) is not None:
        await wizard.to_code(wizard_config)
@@ -403,9 +403,6 @@ message WizardCapabilities {
 message SendspinCapabilities {
  // Bitmask of the Sendspin features this device supports
  uint32 feature_flags = 1;
-  // The Sendspin client_id: base64url of the client's static public key, 43 characters.
-  // Empty until the Sendspin client has started once since boot.
-  string client_id = 2 [(max_data_length) = 43];
 }

 message DeviceCapabilitiesResponse {
@@ -1029,8 +1026,8 @@ message SubscribeHomeassistantServicesRequest {
 }

 message HomeassistantServiceMap {
-  string key = 1 [(progmem) = true];
-  string value = 2 [(progmem) = true];
+  string key = 1;
+  string value = 2;
 }

 message HomeassistantActionRequest {
@@ -1039,7 +1036,7 @@ message HomeassistantActionRequest {
  option (no_delay) = true;
  option (ifdef) = "USE_API_HOMEASSISTANT_SERVICES";

-  string service = 1 [(progmem) = true];
+  string service = 1;
  repeated HomeassistantServiceMap data = 2 [(fixed_vector) = true];
  repeated HomeassistantServiceMap data_template = 3 [(fixed_vector) = true];
  repeated HomeassistantServiceMap variables = 4 [(fixed_vector) = true];
@@ -1160,21 +1157,21 @@ enum SupportsResponseType {
 }
 message ListEntitiesServicesArgument {
  option (ifdef) = "USE_API_USER_DEFINED_ACTIONS";
-  string name = 1 [(progmem) = true];
+  string name = 1;
  ServiceArgType type = 2;
-  string description = 3 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA", (progmem) = true];
-  string example = 4 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA", (progmem) = true];
+  string description = 3 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA"];
+  string example = 4 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA"];
 }
 message ListEntitiesServicesResponse {
  option (id) = 41;
  option (source) = SOURCE_SERVER;
  option (ifdef) = "USE_API_USER_DEFINED_ACTIONS";

-  string name = 1 [(progmem) = true];
+  string name = 1;
  fixed32 key = 2 [(force) = true];
  repeated ListEntitiesServicesArgument args = 3 [(fixed_vector) = true];
  SupportsResponseType supports_response = 4;
-  string description = 5 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA", (progmem) = true];
+  string description = 5 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA"];
 }
 message ExecuteServiceArgument {
  option (ifdef) = "USE_API_USER_DEFINED_ACTIONS";
@@ -3046,15 +3043,12 @@ enum SerialProxyIdentityFlag {
                                             // IDs below are empty
 }

-// The descriptor fields of a USB device as seen by the host stack, and the port's index
-// among those a vendor driver exposes on the interface
+// The descriptor fields of a USB device as seen by the host stack
 message UsbDeviceDescriptor {
  uint32 vendor_id = 1;
  uint32 product_id = 2;
  uint32 bcd_device = 3;
-  uint32 interface_number = 4;  // bInterfaceNumber the port is bound through
-  uint32 interface_class = 5;   // bInterfaceClass of that interface
-  uint32 port_number = 6;
+  uint32 interface_number = 4;   // bInterfaceNumber the host driver binds to
 }

 // The identity of the device behind a port. Identifies one physical device among others of
@@ -1,7 +1,4 @@
 #include "api_connection.h"
-#if defined(USE_LOGGER) && defined(USE_CRASH_HANDLER)
-#include "esphome/components/logger/logger.h"
-#endif
 #ifdef USE_API
 #include "api_connection_buffer.h"  // for the APIServer-dependent APIConnection inlines
 #ifdef USE_API_NOISE
@@ -454,15 +451,6 @@ bool APIConnection::send_disconnect_response_() {
  DisconnectResponse resp;
  return this->send_message(resp);
 }
-void APIConnection::on_subscribe_logs_request(const SubscribeLogsRequest &msg) {
-  this->flags_.log_subscription = msg.level;
-  if (msg.dump_config)
-    App.schedule_dump_config();
-#if defined(USE_LOGGER) && defined(USE_CRASH_HANDLER)
-  logger::log_crash_to_client();
-#endif
-}
-
 void APIConnection::on_disconnect_response() {
  // Don't close socket here, let APIServer::loop() do it
  // so getpeername() still works for the disconnect trigger
@@ -2131,7 +2119,6 @@ bool APIConnection::send_device_capabilities_response_() {
 #endif
 #if defined(USE_SENDSPIN) && defined(USE_ESP_IDF)
  resp.sendspin.feature_flags = sendspin_::global_sendspin_hub->get_feature_flags();
-  resp.sendspin.client_id = sendspin_::global_sendspin_hub->get_client_id();
 #endif
  return this->send_message(resp);
 }
@@ -15,6 +15,15 @@
 #include "subscribe_state.h"
 #include "esphome/core/application.h"
 #include "esphome/core/component.h"
+#ifdef USE_ESP32_CRASH_HANDLER
+#include "esphome/components/esp32/crash_handler.h"
+#endif
+#ifdef USE_RP2_CRASH_HANDLER
+#include "esphome/components/rp2/crash_handler.h"
+#endif
+#ifdef USE_ESP8266_CRASH_HANDLER
+#include "esphome/components/esp8266/crash_handler.h"
+#endif
 #include "esphome/core/entity_base.h"
 #include "esphome/core/log.h"
 #include "esphome/core/string_ref.h"
@@ -289,7 +298,21 @@ class APIConnection final : public APIServerConnectionBase {
      this->begin_iterator_(ActiveIterator::INITIAL_STATE);
    }
  }
-  void on_subscribe_logs_request(const SubscribeLogsRequest &msg);
+  void on_subscribe_logs_request(const SubscribeLogsRequest &msg) {
+    this->flags_.log_subscription = msg.level;
+    if (msg.dump_config)
+      App.schedule_dump_config();
+#ifdef USE_ESP32_CRASH_HANDLER
+    esp32::crash_handler_log();
+    esp32::crash_handler_clear();
+#endif
+#ifdef USE_RP2_CRASH_HANDLER
+    rp2::crash_handler_log();
+#endif
+#ifdef USE_ESP8266_CRASH_HANDLER
+    esp8266::crash_handler_log();
+#endif
+  }
 #ifdef USE_API_HOMEASSISTANT_SERVICES
  void on_subscribe_homeassistant_services_request() { this->flags_.service_call_subscription = true; }
 #endif
@@ -123,7 +123,7 @@ extend google.protobuf.FieldOptions {
    // from an absent one (e.g. a UTC ParsedTimezone, which is all zeros).
    optional bool track_presence = 50020 [default=false];

-    // progmem: The string field, or pointer_to_buffer bytes field, points into flash (PROGMEM).
+    // progmem: The pointer_to_buffer bytes field points into flash (PROGMEM).
    // The generated encode and dump copy it with progmem_memcpy, as ESP8266
    // cannot read flash with ordinary loads.
    optional bool progmem = 50021 [default=false];
@@ -310,14 +310,12 @@ uint32_t WizardCapabilities::calc_size_msg(const void *self) {
 uint8_t *SendspinCapabilities::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
  const auto &msg = *static_cast<const SendspinCapabilities *>(self);
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.feature_flags);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.client_id);
  return pos;
 }
 uint32_t SendspinCapabilities::calc_size_msg(const void *self) {
  const auto &msg = *static_cast<const SendspinCapabilities *>(self);
  uint32_t size = 0;
  size += ProtoSize::calc_uint32(1, msg.feature_flags);
-  size += !msg.client_id.empty() ? 2 + msg.client_id.size() : 0;
  return size;
 }
 #endif
@@ -1142,8 +1140,8 @@ uint32_t NoiseEncryptionSetKeyResponse::calc_size_msg(const void *self) {
 #ifdef USE_API_HOMEASSISTANT_SERVICES
 uint8_t *HomeassistantServiceMap::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
  const auto &msg = *static_cast<const HomeassistantServiceMap *>(self);
-  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.key);
-  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.value);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.key);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.value);
  return pos;
 }
 uint32_t HomeassistantServiceMap::calc_size_msg(const void *self) {
@@ -1155,7 +1153,7 @@ uint32_t HomeassistantServiceMap::calc_size_msg(const void *self) {
 }
 uint8_t *HomeassistantActionRequest::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
  const auto &msg = *static_cast<const HomeassistantActionRequest *>(self);
-  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.service);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.service);
  for (auto &it : msg.data) {
    pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, 2, it);
  }
@@ -1326,13 +1324,13 @@ void GetTimeResponse::decode_field(void *self, uint32_t tag, const uint8_t *data
 uint8_t *ListEntitiesServicesArgument::encode_msg(const void *self,
                                                  uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
  const auto &msg = *static_cast<const ListEntitiesServicesArgument *>(self);
-  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.name);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.name);
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(msg.type));
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.description);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.description);
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.example);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.example);
 #endif
  return pos;
 }
@@ -1352,14 +1350,14 @@ uint32_t ListEntitiesServicesArgument::calc_size_msg(const void *self) {
 uint8_t *ListEntitiesServicesResponse::encode_msg(const void *self,
                                                  uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
  const auto &msg = *static_cast<const ListEntitiesServicesResponse *>(self);
-  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.name);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.name);
  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
  for (auto &it : msg.args) {
    pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, 3, it);
  }
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, static_cast<uint32_t>(msg.supports_response));
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.description);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.description);
 #endif
  return pos;
 }
@@ -4177,8 +4175,6 @@ uint8_t *UsbDeviceDescriptor::encode_msg(const void *self, uint8_t *__restrict__
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.product_id);
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.bcd_device);
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.interface_number);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.interface_class);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.port_number);
  return pos;
 }
 uint32_t UsbDeviceDescriptor::calc_size_msg(const void *self) {
@@ -4188,8 +4184,6 @@ uint32_t UsbDeviceDescriptor::calc_size_msg(const void *self) {
  size += ProtoSize::calc_uint32(1, msg.product_id);
  size += ProtoSize::calc_uint32(1, msg.bcd_device);
  size += ProtoSize::calc_uint32(1, msg.interface_number);
-  size += ProtoSize::calc_uint32(1, msg.interface_class);
-  size += ProtoSize::calc_uint32(1, msg.port_number);
  return size;
 }
 uint8_t *SerialProxyIdentity::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
@@ -750,7 +750,6 @@ class WizardCapabilities final : public ProtoMessage {
 class SendspinCapabilities final : public ProtoMessage {
 public:
  uint32_t feature_flags{0};
-  StringRef client_id{nullptr, 0};  // null until set, encode only
  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
    return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -1389,8 +1388,8 @@ class NoiseEncryptionSetKeyResponse final : public ProtoMessage {
 #ifdef USE_API_HOMEASSISTANT_SERVICES
 class HomeassistantServiceMap final : public ProtoMessage {
 public:
-  ProgmemStringRef key{};
-  ProgmemStringRef value{};
+  StringRef key{nullptr, 0};    // null until set, encode only
+  StringRef value{nullptr, 0};  // null until set, encode only
  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
    return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -1410,7 +1409,7 @@ class HomeassistantActionRequest final : public ProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
  const LogString *message_name() const override { return LOG_STR("homeassistant_action_request"); }
 #endif
-  ProgmemStringRef service{};
+  StringRef service{nullptr, 0};  // null until set, encode only
  FixedVector<HomeassistantServiceMap> data{};
  FixedVector<HomeassistantServiceMap> data_template{};
  FixedVector<HomeassistantServiceMap> variables{};
@@ -1577,13 +1576,13 @@ class GetTimeResponse final : public ProtoDecodableMessage {
 #ifdef USE_API_USER_DEFINED_ACTIONS
 class ListEntitiesServicesArgument final : public ProtoMessage {
 public:
-  ProgmemStringRef name{};
+  StringRef name{nullptr, 0};  // null until set, encode only
  enums::ServiceArgType type{};
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  ProgmemStringRef description{};
+  StringRef description{nullptr, 0};  // null until set, encode only
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  ProgmemStringRef example{};
+  StringRef example{nullptr, 0};  // null until set, encode only
 #endif
  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -1604,12 +1603,12 @@ class ListEntitiesServicesResponse final : public ProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
  const LogString *message_name() const override { return LOG_STR("list_entities_services_response"); }
 #endif
-  ProgmemStringRef name{};
+  StringRef name{nullptr, 0};  // null until set, encode only
  uint32_t key{0};
  FixedVector<ListEntitiesServicesArgument> args{};
  enums::SupportsResponseType supports_response{};
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  ProgmemStringRef description{};
+  StringRef description{nullptr, 0};  // null until set, encode only
 #endif
  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -4084,8 +4083,6 @@ class UsbDeviceDescriptor final : public ProtoMessage {
  uint32_t product_id{0};
  uint32_t bcd_device{0};
  uint32_t interface_number{0};
-  uint32_t interface_class{0};
-  uint32_t port_number{0};
  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
    return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -12,9 +12,8 @@ namespace esphome::api {

 #ifdef USE_ESP8266
 // Out-of-line to avoid inlining strlen_P/memcpy_P at every call site
-void DumpBuffer::append_p_esp8266(const char *str) { this->append_p_esp8266(str, strlen_P(str)); }
-
-void DumpBuffer::append_p_esp8266(const char *str, size_t len) {
+void DumpBuffer::append_p_esp8266(const char *str) {
+  size_t len = strlen_P(str);
  size_t space = CAPACITY - 1 - pos_;
  if (len > space)
    len = space;
@@ -135,13 +134,6 @@ static void dump_progmem_bytes_field(DumpBuffer &out, const char *field_name, co
  progmem_memcpy(data_buf, data, len);
  dump_bytes_field(out, field_name, data_buf, len, indent);
 }
-
-// Helper for string fields in flash
-static void dump_progmem_string_field(DumpBuffer &out, const char *field_name, const ProgmemStringRef &value,
-                                      int indent = 2) {
-  append_field_prefix(out, field_name, indent);
-  out.append("'").append_p(value.progmem_ptr(), value.size()).append("'\n");
-}
 #pragma GCC diagnostic pop

 template<> const char *proto_enum_to_string<enums::DisconnectReason>(enums::DisconnectReason value) {
@@ -1127,7 +1119,6 @@ const char *WizardCapabilities::dump_to(DumpBuffer &out) const {
 const char *SendspinCapabilities::dump_to(DumpBuffer &out) const {
  MessageDumpHelper helper(out, ESPHOME_PSTR("SendspinCapabilities"));
  dump_field(out, ESPHOME_PSTR("feature_flags"), this->feature_flags);
-  dump_field(out, ESPHOME_PSTR("client_id"), this->client_id);
  return out.c_str();
 }
 #endif
@@ -1520,13 +1511,13 @@ const char *NoiseEncryptionSetKeyResponse::dump_to(DumpBuffer &out) const {
 #ifdef USE_API_HOMEASSISTANT_SERVICES
 const char *HomeassistantServiceMap::dump_to(DumpBuffer &out) const {
  MessageDumpHelper helper(out, ESPHOME_PSTR("HomeassistantServiceMap"));
-  dump_progmem_string_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("value"), this->value);
+  dump_field(out, ESPHOME_PSTR("key"), this->key);
+  dump_field(out, ESPHOME_PSTR("value"), this->value);
  return out.c_str();
 }
 const char *HomeassistantActionRequest::dump_to(DumpBuffer &out) const {
  MessageDumpHelper helper(out, ESPHOME_PSTR("HomeassistantActionRequest"));
-  dump_progmem_string_field(out, ESPHOME_PSTR("service"), this->service);
+  dump_field(out, ESPHOME_PSTR("service"), this->service);
  for (const auto &it : this->data) {
    out.append(4, ' ').append_p(ESPHOME_PSTR("data")).append(": ");
    it.dump_to(out);
@@ -1621,19 +1612,19 @@ const char *GetTimeResponse::dump_to(DumpBuffer &out) const {
 #ifdef USE_API_USER_DEFINED_ACTIONS
 const char *ListEntitiesServicesArgument::dump_to(DumpBuffer &out) const {
  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesServicesArgument"));
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
  dump_field(out, ESPHOME_PSTR("type"), static_cast<enums::ServiceArgType>(this->type));
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  dump_progmem_string_field(out, ESPHOME_PSTR("description"), this->description);
+  dump_field(out, ESPHOME_PSTR("description"), this->description);
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  dump_progmem_string_field(out, ESPHOME_PSTR("example"), this->example);
+  dump_field(out, ESPHOME_PSTR("example"), this->example);
 #endif
  return out.c_str();
 }
 const char *ListEntitiesServicesResponse::dump_to(DumpBuffer &out) const {
  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesServicesResponse"));
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
  dump_field(out, ESPHOME_PSTR("key"), this->key);
  for (const auto &it : this->args) {
    out.append(4, ' ').append_p(ESPHOME_PSTR("args")).append(": ");
@@ -1642,7 +1633,7 @@ const char *ListEntitiesServicesResponse::dump_to(DumpBuffer &out) const {
  }
  dump_field(out, ESPHOME_PSTR("supports_response"), static_cast<enums::SupportsResponseType>(this->supports_response));
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  dump_progmem_string_field(out, ESPHOME_PSTR("description"), this->description);
+  dump_field(out, ESPHOME_PSTR("description"), this->description);
 #endif
  return out.c_str();
 }
@@ -2951,8 +2942,6 @@ const char *UsbDeviceDescriptor::dump_to(DumpBuffer &out) const {
  dump_field(out, ESPHOME_PSTR("product_id"), this->product_id);
  dump_field(out, ESPHOME_PSTR("bcd_device"), this->bcd_device);
  dump_field(out, ESPHOME_PSTR("interface_number"), this->interface_number);
-  dump_field(out, ESPHOME_PSTR("interface_class"), this->interface_class);
-  dump_field(out, ESPHOME_PSTR("port_number"), this->port_number);
  return out.c_str();
 }
 const char *SerialProxyIdentity::dump_to(DumpBuffer &out) const {
@@ -547,7 +547,7 @@ void APIServer::send_homeassistant_action(const HomeassistantActionRequest &call
    // arrive before the subscription and are lost - warn instead of failing silently.
    ESP_LOGW(TAG, "Home Assistant %s '%.*s' dropped; %s",
             call.is_event ? LOG_STR_LITERAL("event") : LOG_STR_LITERAL("action"),
-             static_cast<int>(call.service.size()), call.service.empty() ? "" : call.service.progmem_ptr(),
+             static_cast<int>(call.service.size()), call.service.empty() ? "" : call.service.c_str(),
             this->is_connected() ? LOG_STR_LITERAL("client has not subscribed to actions (yet)")
                                  : LOG_STR_LITERAL("no client connected"));
  }
@@ -247,7 +247,7 @@ class CustomAPIDevice {
   */
  void call_homeassistant_service(const std::string &service_name) {
    HomeassistantActionRequest resp;
-    resp.service = ProgmemStringRef(StringRef(service_name));
+    resp.service = StringRef(service_name);
    global_api_server->send_homeassistant_action(resp);
  }

@@ -267,12 +267,12 @@ class CustomAPIDevice {
   */
  void call_homeassistant_service(const std::string &service_name, const std::map<std::string, std::string> &data) {
    HomeassistantActionRequest resp;
-    resp.service = ProgmemStringRef(StringRef(service_name));
+    resp.service = StringRef(service_name);
    resp.data.init(data.size());
    for (auto &it : data) {
      auto &kv = resp.data.emplace_back();
-      kv.key = ProgmemStringRef(StringRef(it.first));
-      kv.value = ProgmemStringRef(StringRef(it.second));  // data map lives until send completes
+      kv.key = StringRef(it.first);
+      kv.value = StringRef(it.second);  // data map lives until send completes
    }
    global_api_server->send_homeassistant_action(resp);
  }
@@ -289,7 +289,7 @@ class CustomAPIDevice {
   */
  void fire_homeassistant_event(const std::string &event_name) {
    HomeassistantActionRequest resp;
-    resp.service = ProgmemStringRef(StringRef(event_name));
+    resp.service = StringRef(event_name);
    resp.is_event = true;
    global_api_server->send_homeassistant_action(resp);
  }
@@ -309,13 +309,13 @@ class CustomAPIDevice {
   */
  void fire_homeassistant_event(const std::string &service_name, const std::map<std::string, std::string> &data) {
    HomeassistantActionRequest resp;
-    resp.service = ProgmemStringRef(StringRef(service_name));
+    resp.service = StringRef(service_name);
    resp.is_event = true;
    resp.data.init(data.size());
    for (auto &it : data) {
      auto &kv = resp.data.emplace_back();
-      kv.key = ProgmemStringRef(StringRef(it.first));
-      kv.value = ProgmemStringRef(StringRef(it.second));  // data map lives until send completes
+      kv.key = StringRef(it.first);
+      kv.value = StringRef(it.second);  // data map lives until send completes
    }
    global_api_server->send_homeassistant_action(resp);
  }
@@ -116,18 +116,42 @@ template<typename... Ts> class HomeAssistantServiceCallAction final : public Act
    const Field *fields = this->fields_;
    const size_t total = 1 + this->data_count_ + this->data_template_count_ + this->variables_count_;

-    // Lambda results must live until the send; the constant strings are encoded from flash where they are
+    // Lambda results, and on ESP8266 the RAM copies of the flash strings, must live until the send
    size_t lambda_count = 0;
-    for (size_t i = 0; i < total; i++)
+#ifdef USE_ESP8266
+    size_t flash_len = 0;
+#endif
+    for (size_t i = 0; i < total; i++) {
      lambda_count += fields[i].fn != nullptr;
+#ifdef USE_ESP8266
+      if (fields[i].fn == nullptr)
+        flash_len += ESPHOME_strlen_P(fields[i].value);
+      if (fields[i].key != nullptr)
+        flash_len += ESPHOME_strlen_P(fields[i].key);
+#endif
+    }
    FixedVector<std::string> results;
    results.init(lambda_count);
-    auto string_ref = [](const char *str) { return ProgmemStringRef(str, ESPHOME_strlen_P(str)); };
+#ifdef USE_ESP8266
+    SmallBufferWithHeapFallback<128, char> flash_copy(flash_len);
+    char *cursor = flash_copy.get();
+#endif
+    auto string_ref = [&](const char *str) {
+#ifdef USE_ESP8266
+      size_t len = ESPHOME_strlen_P(str);
+      memcpy_P(cursor, str, len);
+      StringRef ref(cursor, len);
+      cursor += len;
+      return ref;
+#else
+      return StringRef(str);
+#endif
+    };
    auto value_ref = [&](const Field &field) {
      if (field.fn == nullptr)
        return string_ref(field.value);
      results.push_back(field.fn(x...));
-      return ProgmemStringRef(StringRef(results.back()));
+      return StringRef(results.back());
    };
    auto fill = [&](FixedVector<HomeassistantServiceMap> &dest, uint8_t count) {
      dest.init(count);
@@ -99,7 +99,8 @@ ListEntitiesIterator::ListEntitiesIterator(APIConnection *client) : client_(clie
 static constexpr uint8_t SERVICE_YIELD_INTERVAL = 3;

 bool ListEntitiesIterator::on_service(UserServiceDescriptor *service) {
-  auto resp = service->encode_list_service_response();
+  UserActionScratch scratch;
+  auto resp = service->encode_list_service_response(scratch);
  if (!this->client_->send_message(resp))
    return false;
  // at_ is this service's index
@@ -418,18 +418,6 @@ class ProtoEncode {
    std::memcpy(pos + 2, ref.c_str(), ref.size());
    return pos + 2 + ref.size();
  }
-  /// encode_short_string_force for a string that may be in flash (PROGMEM).
-  [[nodiscard]] static inline uint8_t *encode_short_progmem_string_force(
-      uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint8_t tag, const ProgmemStringRef &ref) {
-#ifdef ESPHOME_DEBUG_API
-    assert(ref.size() < 128 && "encode_short_progmem_string_force: string exceeds max_data_length < 128");
-#endif
-    PROTO_ENCODE_CHECK_BOUNDS(pos, 2 + ref.size());
-    pos[0] = tag;
-    pos[1] = static_cast<uint8_t>(ref.size());
-    progmem_memcpy(pos + 2, ref.progmem_ptr(), ref.size());
-    return pos + 2 + ref.size();
-  }
  /// Write a precomputed tag byte + 32-bit value. Outlined on embedded: one copy beats inline stores per field.
  [[nodiscard]] static PROTO_OUTLINE_FOR_SIZE uint8_t *write_tag_and_fixed32(
      uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint8_t tag, uint32_t value) {
@@ -493,17 +481,6 @@ class ProtoEncode {
    progmem_memcpy(pos, data, len);
    return pos + len;
  }
-  /// encode_progmem_bytes for a string field that may be in flash.
-  [[nodiscard]] static inline uint8_t *encode_progmem_string(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                             uint32_t field_id, const ProgmemStringRef &ref) {
-    return encode_progmem_bytes(pos PROTO_ENCODE_DEBUG_ARG, field_id,
-                                reinterpret_cast<const uint8_t *>(ref.progmem_ptr()), ref.size());
-  }
-  [[nodiscard]] static inline uint8_t *encode_progmem_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                                   uint32_t field_id, const ProgmemStringRef &ref) {
-    return encode_progmem_bytes_force(pos PROTO_ENCODE_DEBUG_ARG, field_id,
-                                      reinterpret_cast<const uint8_t *>(ref.progmem_ptr()), ref.size());
-  }
  [[nodiscard]] static inline uint8_t *encode_uint32_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
                                                           uint32_t field_id, uint32_t value) {
    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
@@ -703,20 +680,9 @@ class DumpBuffer {
    return *this;
  }

-  /// Append len bytes of a PROGMEM string
-  DumpBuffer &append_p(const char *str, size_t len) {
-#ifdef USE_ESP8266
-    append_p_esp8266(str, len);
-#else
-    append_impl_(str, len);
-#endif
-    return *this;
-  }
-
 #ifdef USE_ESP8266
  /// Out-of-line ESP8266 PROGMEM append to avoid inlining strlen_P/memcpy_P at every call site
  void append_p_esp8266(const char *str);
-  void append_p_esp8266(const char *str, size_t len);
 #endif

  const char *c_str() const { return buf_; }
@@ -1,36 +1,47 @@
 #include "user_services.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 #include "esphome/core/string_ref.h"

 namespace esphome::api {

-ProgmemStringRef UserServiceStatic::str_(size_t idx) const {
+StringRef UserServiceStatic::str_(size_t idx, std::span<char> &scratch) const {
  const char *s = progmem_read_ptr(&this->strings_[idx]);
  if (s == nullptr)
    return {};
-  return ProgmemStringRef(s, ESPHOME_strlen_P(s));
+#ifdef USE_ESP8266
+  // Codegen sizes the scratch buffer for the largest service; the bound only guards other callers
+  if (scratch.empty())
+    return {};
+  size_t len = strnlen_P(s, scratch.size() - 1);
+  progmem_memcpy(scratch.data(), s, len);
+  scratch[len] = '\0';
+  StringRef ref(scratch.data(), len);
+  scratch = scratch.subspan(len + 1);
+  return ref;
+#else
+  return StringRef(s);
+#endif
 }

 ListEntitiesServicesResponse UserServiceStatic::encode_list_service_response_(
-    std::span<const enums::ServiceArgType> arg_types) const {
+    std::span<const enums::ServiceArgType> arg_types, std::span<char> scratch) const {
  ListEntitiesServicesResponse msg;
-  msg.name = this->str_(0);
+  msg.name = this->str_(0, scratch);
  msg.key = this->key_;
  msg.supports_response = this->supports_response_;
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  msg.description = this->str_(1);
+  msg.description = this->str_(1, scratch);
 #endif
  msg.args.init(arg_types.size());
  for (size_t i = 0; i < arg_types.size(); i++) {
    size_t base = USER_ACTION_HEADER_STRINGS + i * USER_ACTION_ARG_STRINGS;
    auto &arg = msg.args.emplace_back();
    arg.type = arg_types[i];
-    arg.name = this->str_(base);
+    arg.name = this->str_(base, scratch);
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-    arg.description = this->str_(base + 1);
-    arg.example = this->str_(base + 2);
+    arg.description = this->str_(base + 1, scratch);
+    arg.example = this->str_(base + 2, scratch);
 #endif
  }
  return msg;
@@ -20,8 +20,9 @@ class APIServer;

 class UserServiceDescriptor {
 public:
-  /// Build the list-entities message; its strings may point into flash (PROGMEM).
-  virtual ListEntitiesServicesResponse encode_list_service_response() = 0;
+  /// Build the list-entities message. On ESP8266 the strings live in PROGMEM and are copied into
+  /// `scratch`, so the returned message is only valid while `scratch` is; other platforms ignore it.
+  virtual ListEntitiesServicesResponse encode_list_service_response(std::span<char> scratch) = 0;

  virtual bool execute_service(const ExecuteServiceRequest &req) = 0;
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
@@ -36,6 +37,13 @@ template<typename T> T get_execute_arg_value(const ExecuteServiceArgument &arg);

 template<typename T> enums::ServiceArgType to_service_arg_type();

+// Scratch buffer list-entities hands to encode_list_service_response(); only ESP8266 copies into it
+#ifdef USE_ESP8266
+using UserActionScratch = std::array<char, API_USER_ACTION_STRINGS_SCRATCH_SIZE>;
+#else
+using UserActionScratch = std::array<char, 0>;
+#endif
+
 // Non-template base for YAML-defined services so the list-entities encoder is compiled once.
 // All strings live in one PROGMEM pointer table emitted by codegen (see _action_strings in
 // __init__.py), so each service costs a single pointer of RAM. Layout: the action name, then
@@ -55,9 +63,12 @@ class UserServiceStatic : public UserServiceDescriptor {
      : strings_(strings), key_(key), supports_response_(supports_response) {}

 protected:
-  ListEntitiesServicesResponse encode_list_service_response_(std::span<const enums::ServiceArgType> arg_types) const;
-  /// Table entry `idx` as it sits in flash; nullptr gives an empty string.
-  ProgmemStringRef str_(size_t idx) const;
+  ListEntitiesServicesResponse encode_list_service_response_(std::span<const enums::ServiceArgType> arg_types,
+                                                             std::span<char> scratch) const;
+  /// Reference table entry `idx`; nullptr gives an empty StringRef.
+  /// On ESP8266 the bytes are copied out of PROGMEM into `scratch` with a terminator, and the span
+  /// is advanced past the copy.
+  StringRef str_(size_t idx, std::span<char> &scratch) const;

  const char *const *strings_;  // PROGMEM pointer table, read with progmem_read_ptr()
  uint32_t key_;
@@ -68,9 +79,9 @@ template<typename... Ts> class UserServiceBase : public UserServiceStatic {
 public:
  using UserServiceStatic::UserServiceStatic;

-  ListEntitiesServicesResponse encode_list_service_response() override {
+  ListEntitiesServicesResponse encode_list_service_response(std::span<char> scratch) override {
    std::array<enums::ServiceArgType, sizeof...(Ts)> arg_types = {to_service_arg_type<Ts>()...};
-    return this->encode_list_service_response_(arg_types);
+    return this->encode_list_service_response_(arg_types, scratch);
  }

  bool execute_service(const ExecuteServiceRequest &req) override {
@@ -114,9 +125,9 @@ template<typename... Ts> class UserServiceDynamic : public UserServiceDescriptor
    this->key_ = fnv1_hash(this->name_.c_str());
  }

-  ListEntitiesServicesResponse encode_list_service_response() override {
+  ListEntitiesServicesResponse encode_list_service_response(std::span<char> /*scratch*/) override {
    ListEntitiesServicesResponse msg;
-    msg.name = ProgmemStringRef(StringRef(this->name_));
+    msg.name = StringRef(this->name_);
    msg.key = this->key_;
    msg.supports_response = enums::SUPPORTS_RESPONSE_NONE;  // Dynamic services don't support responses yet
    std::array<enums::ServiceArgType, sizeof...(Ts)> arg_types = {to_service_arg_type<Ts>()...};
@@ -124,7 +135,7 @@ template<typename... Ts> class UserServiceDynamic : public UserServiceDescriptor
    for (size_t i = 0; i < sizeof...(Ts); i++) {
      auto &arg = msg.args.emplace_back();
      arg.type = arg_types[i];
-      arg.name = ProgmemStringRef(StringRef(this->arg_names_[i]));
+      arg.name = StringRef(this->arg_names_[i]);
    }
    return msg;
  }
@@ -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.1.0")
+    add_idf_component(name="esphome/esp-audio-libs", ref="4.0.1")

    data = _get_data()

@@ -1,11 +1,10 @@
 #pragma once

 #include <set>
-#include "esphome/core/log.h"

 namespace esphome::bedjet {

-ESPHOME_LOG_TAG(TAG, "bedjet");
+static const char *const TAG = "bedjet";

 /// Converts a BedJet fan step to a speed percentage, in the range of 5% to 100%.
 inline static uint8_t bedjet_fan_step_to_speed(const uint8_t fan) {
@@ -4,7 +4,7 @@

 namespace esphome::ble_client {

-const char *const Automation::TAG = "ble_client.automation";  // NOLINT: ble_client never builds for ESP8266
+const char *const Automation::TAG = "ble_client.automation";

 }  // namespace esphome::ble_client

@@ -382,7 +382,7 @@ void BluedroidGattClient::set_disconnecting_() {

 esp_err_t BluedroidGattClient::update_conn_params_(uint16_t min_interval, uint16_t max_interval, uint16_t latency,
                                                   uint16_t timeout, const char *param_type) {
-  esp_ble_conn_update_params_t conn_params = {};
+  esp_ble_conn_update_params_t conn_params = {{0}};
  memcpy(conn_params.bda, this->remote_bda_, sizeof(esp_bd_addr_t));
  conn_params.min_int = min_interval;
  conn_params.max_int = max_interval;
@@ -100,8 +100,7 @@ void BM8563::get_date_(ESPTime &time) {
  this->read_register(DATE_FIRST_REG, buf, sizeof(buf));

  time.day_of_month = this->bcd2_to_byte_(buf[0] & 0x3f);
-  // The chip counts weekdays 0-6 from Sunday (not BCD), ESPTime counts 1-7
-  time.day_of_week = (buf[1] & 0x07) + 1;
+  time.day_of_week = this->bcd2_to_byte_(buf[1] & 0x07);
  time.month = this->bcd2_to_byte_(buf[2] & 0x1f);

  uint8_t year_byte = this->bcd2_to_byte_(buf[3] & 0xff);
@@ -116,7 +115,7 @@ void BM8563::get_date_(ESPTime &time) {
 void BM8563::set_date_(const ESPTime &time) {
  uint8_t buf[4] = {
      this->byte_to_bcd2_(time.day_of_month),
-      static_cast<uint8_t>(time.day_of_week - 1),
+      this->byte_to_bcd2_(time.day_of_week),
      this->byte_to_bcd2_(time.month),
      this->byte_to_bcd2_(time.year % 100),
  };
@@ -2,11 +2,10 @@

 #include "esphome/components/bme280_base/bme280_base.h"
 #include "esphome/components/i2c/i2c.h"
-#include "esphome/core/log.h"

 namespace esphome::bme280_i2c {

-ESPHOME_LOG_TAG(TAG, "bme280_i2c.sensor");
+static const char *const TAG = "bme280_i2c.sensor";

 class BME280I2CComponent final : public esphome::bme280_base::BME280Component, public i2c::I2CDevice {
  bool read_byte(uint8_t a_register, uint8_t *data) override;
@@ -2,7 +2,6 @@
 #include "bmi270_config.h"
 #include "esphome/core/log.h"
 #include "esphome/core/hal.h"
-#include "esphome/core/progmem.h"

 namespace esphome::bmi270 {

@@ -12,9 +11,6 @@ using namespace bmm150;  // NOLINT - sole consumer of the BMM150 aux-device defi

 ESPHOME_LOG_TAG(TAG, "bmi270");

-PROGMEM_STRING_TABLE(AccelRangeStrings, "±2g", "±4g", "±8g", "±16g");
-PROGMEM_STRING_TABLE(GyroRangeStrings, "±2000°/s", "±1000°/s", "±500°/s", "±250°/s", "±125°/s");
-
 #if defined(USE_ARDUINO) && !defined(USE_ESP32)
 static constexpr size_t MAX_I2C_BUFFER_SIZE = 32;
 #else
@@ -277,10 +273,11 @@ void BMI270Component::dump_config() {
    return;
  }

-  ESP_LOGCONFIG(TAG, "  Accel range : %s",
-                LOG_STR_ARG(AccelRangeStrings::get_log_str(this->accel_range_, AccelRangeStrings::LAST_INDEX)));
-  ESP_LOGCONFIG(TAG, "  Gyro  range : %s",
-                LOG_STR_ARG(GyroRangeStrings::get_log_str(this->gyro_range_, GyroRangeStrings::LAST_INDEX)));
+  static constexpr const char *const ACCEL_RANGE_STRS[] = {"±2g", "±4g", "±8g", "±16g"};
+  static constexpr const char *const GYRO_RANGE_STRS[] = {"±2000°/s", "±1000°/s", "±500°/s", "±250°/s", "±125°/s"};
+
+  ESP_LOGCONFIG(TAG, "  Accel range : %s", ACCEL_RANGE_STRS[accel_range_]);
+  ESP_LOGCONFIG(TAG, "  Gyro  range : %s", GYRO_RANGE_STRS[gyro_range_]);
 #ifdef USE_BMI270_BMM150
  if (this->aux_device_ == BMI270_AUX_DEVICE_BMM150) {
    ESP_LOGCONFIG(TAG, "  Aux device  : BMM150 magnetometer (%s)",
@@ -318,8 +315,7 @@ bool BMI270Component::update_data(motion::MotionData &data) {
  }
  // Scale factor: LSB/g depends on range
  // raw is a signed 16-bit value; full-scale = range_g * 2^15 lsb
-  // In PROGMEM; each read is a 32-bit load, which is safe from flash on ESP8266
-  alignas(4) static constexpr float ACCEL_SCALE[] PROGMEM = {
+  static constexpr float ACCEL_SCALE[] = {
      2.0f / 32768.0f,
      4.0f / 32768.0f,
      8.0f / 32768.0f,
@@ -333,7 +329,7 @@ bool BMI270Component::update_data(motion::MotionData &data) {

  // Gyroscope: registers 0x12–0x17 (6 bytes)
  // Scale: full-scale range / 2^15
-  alignas(4) static constexpr float GYRO_SCALE[] PROGMEM = {
+  static constexpr float GYRO_SCALE[] = {
      2000.0f / 32768.0f, 1000.0f / 32768.0f, 500.0f / 32768.0f, 250.0f / 32768.0f, 125.0f / 32768.0f,
  };
  static constexpr uint8_t GYR_OFFS = BMI270_REG_DATA_14 - BMI270_REG_DATA_8;
@@ -2,11 +2,10 @@

 #include "esphome/components/bmp280_base/bmp280_base.h"
 #include "esphome/components/i2c/i2c.h"
-#include "esphome/core/log.h"

 namespace esphome::bmp280_i2c {

-ESPHOME_LOG_TAG(TAG, "bmp280_i2c.sensor");
+static const char *const TAG = "bmp280_i2c.sensor";

 /// This class implements support for the BMP280 Temperature+Pressure i2c sensor.
 class BMP280I2CComponent final : public esphome::bmp280_base::BMP280Component, public i2c::I2CDevice {
@@ -2,11 +2,10 @@

 #include "esphome/components/bmp581_base/bmp581_base.h"
 #include "esphome/components/i2c/i2c.h"
-#include "esphome/core/log.h"

 namespace esphome::bmp581_i2c {

-ESPHOME_LOG_TAG(TAG, "bmp581_i2c.sensor");
+static const char *const TAG = "bmp581_i2c.sensor";

 /// This class implements support for the BMP581 Temperature+Pressure i2c sensor.
 class BMP581I2CComponent final : public esphome::bmp581_base::BMP581Component, public i2c::I2CDevice {
@@ -8,7 +8,7 @@

 namespace esphome::chsc6x {

-ESPHOME_LOG_TAG(TAG, "chsc6x.touchscreen");
+static const char *const TAG = "chsc6x.touchscreen";

 static const uint8_t CHSC6X_REG_STATUS = 0x00;
 static const uint8_t CHSC6X_REG_STATUS_TOUCH = 0x00;
@@ -8,9 +8,6 @@ namespace esphome::cse7766 {

 ESPHOME_LOG_TAG(TAG, "cse7766");

-// The chip only sends the time since the last pulse once a cycle is longer than 1 s (in us)
-static constexpr uint32_t MIN_HELD_POWER_CYCLE = 1000000;
-
 void CSE7766Component::loop() {
  const uint32_t now = App.get_loop_component_start_time();
  if (now - this->last_transmission_ >= 500) {
@@ -157,33 +154,18 @@ void CSE7766Component::parse_data_() {
  if (power_cycle_exceeds_range) {
    // Datasheet: power cycle exceeding range means active power is 0
    have_power = true;
-    this->last_power_cycle_ = 0;
    if (this->power_sensor_ != nullptr) {
      this->power_sensor_->publish_state(0.0f);
    }
  } else if (have_power) {
    power = power_coeff / float(power_cycle);
-    this->last_power_cycle_ = power_cycle;
    if (this->power_sensor_ != nullptr) {
      this->power_sensor_->publish_state(power);
    }
-  } else if (this->last_power_cycle_ > MIN_HELD_POWER_CYCLE && power_cycle <= 2 * this->last_power_cycle_) {
-    // No new measurement in this frame. With cycles over 1 s the register holds the last
-    // cycle or the time elapsed since the last pulse. While that time is within twice the
-    // last cycle, the next pulse is not overdue, so the last measurement still applies.
-    // Shorter cycles never get here in normal operation and keep the previous behaviour.
-    have_power = true;
-    power = power_coeff / float(this->last_power_cycle_);
-    if (this->power_sensor_ != nullptr) {
-      this->power_sensor_->publish_state(power);
-    }
-  } else {
-    // The next pulse is overdue: the load has dropped, report 0 W. A load that drops to less
-    // than half also reads 0 W here until its first new pulse arrives.
-    this->last_power_cycle_ = 0;
-    if (this->power_sensor_ != nullptr) {
-      this->power_sensor_->publish_state(0.0f);
-    }
+  } else if (this->power_sensor_ != nullptr) {
+    // No valid power measurement from chip - publish 0W to avoid stale readings
+    // This typically happens when current is below the measurable threshold (~50mA)
+    this->power_sensor_->publish_state(0.0f);
  }

  float current = 0.0f;
@@ -36,7 +36,6 @@ class CSE7766Component final : public Component, public uart::UARTDevice {

  uint8_t raw_data_[CSE7766_RAW_DATA_SIZE];
  uint8_t raw_data_index_{0};
-  uint16_t cf_pulses_last_{0};
  uint32_t last_transmission_{0};
  sensor::Sensor *voltage_sensor_{nullptr};
  sensor::Sensor *current_sensor_{nullptr};
@@ -46,8 +45,7 @@ class CSE7766Component final : public Component, public uart::UARTDevice {
  sensor::Sensor *reactive_power_sensor_{nullptr};
  sensor::Sensor *power_factor_sensor_{nullptr};
  uint32_t cf_pulses_total_{0};
-  // Power cycle of the last frame that carried a new power measurement, 0 if none
-  uint32_t last_power_cycle_{0};
+  uint16_t cf_pulses_last_{0};
 };

 }  // namespace esphome::cse7766
@@ -8,7 +8,7 @@

 namespace esphome::cst816 {

-ESPHOME_LOG_TAG(TAG, "cst816.touchscreen");
+static const char *const TAG = "cst816.touchscreen";

 static const uint8_t REG_STATUS = 0x00;
 static const uint8_t REG_TOUCH_NUM = 0x02;
@@ -8,7 +8,7 @@

 namespace esphome::cst9220 {

-ESPHOME_LOG_TAG(TAG, "cst9220.touchscreen");
+static const char *const TAG = "cst9220.touchscreen";

 // The CST92xx family uses 16-bit (big-endian) register addresses.
 static const uint16_t REG_TOUCH_DATA = 0xD000;  // touch report
@@ -143,8 +143,6 @@ def validate_wakeup_pin(
        processed_pins: list[ConfigType] = [{CONF_PIN: value}]
    else:
        processed_pins = list(value)
-        if not processed_pins:
-            raise cv.Invalid("'wakeup_pin' needs at least one entry")

    for i, pin_config in enumerate(processed_pins):
        # now validate each item
@@ -156,34 +154,29 @@ def validate_wakeup_pin(


 def validate_config(config: ConfigType) -> ConfigType:
-    wakeup_pins = config.get(CONF_WAKEUP_PIN)
-    has_pin_mode = CONF_WAKEUP_PIN_MODE in config
-    if has_pin_mode and wakeup_pins is None:
+    # right now only BK72XX supports the list format for wakeup pins
+    if CORE.is_bk72xx:
+        if CONF_WAKEUP_PIN_MODE in config:
+            wakeup_pins = config.get(CONF_WAKEUP_PIN, [])
+            if len(wakeup_pins) > 1:
+                raise cv.Invalid(
+                    "You need to remove the global wakeup_pin_mode and define it per pin"
+                )
+            if wakeup_pins:
+                if CONF_WAKEUP_PIN_MODE in wakeup_pins[0]:
+                    raise cv.Invalid(
+                        "Specify wakeup_pin_mode either at the top level under deep_sleep "
+                        "or under the pin entry, not both"
+                    )
+                wakeup_pins[0][CONF_WAKEUP_PIN_MODE] = config.pop(CONF_WAKEUP_PIN_MODE)
+    elif (
+        isinstance(config.get(CONF_WAKEUP_PIN), list)
+        and len(config[CONF_WAKEUP_PIN]) > 1
+    ):
        raise cv.Invalid(
-            "'wakeup_pin_mode' requires 'wakeup_pin'", path=[CONF_WAKEUP_PIN_MODE]
+            "Your platform does not support providing multiple entries in wakeup_pin"
        )
-    multiple_pins = wakeup_pins is not None and len(wakeup_pins) > 1
-    # wakeup_pin is limited to ESP32 and BK72XX, and only BK72XX accepts a list
-    if not CORE.is_bk72xx:
-        if multiple_pins:
-            raise cv.Invalid(
-                "ESP32 does not support multiple entries for 'wakeup_pin'",
-                path=[CONF_WAKEUP_PIN],
-            )
-    elif has_pin_mode:
-        if multiple_pins:
-            raise cv.Invalid(
-                "Remove the global 'wakeup_pin_mode' and define it per pin",
-                path=[CONF_WAKEUP_PIN_MODE],
-            )
-        if CONF_WAKEUP_PIN_MODE in (pin := wakeup_pins[0]):
-            raise cv.Invalid(
-                "Specify 'wakeup_pin_mode' either at the top level under 'deep_sleep' "
-                "or under the pin entry, not both",
-                path=[CONF_WAKEUP_PIN, 0, CONF_WAKEUP_PIN_MODE],
-            )
-        # Move the global mode into the single pin entry, which to_code() reads
-        pin[CONF_WAKEUP_PIN_MODE] = config.pop(CONF_WAKEUP_PIN_MODE)
+
    return config


@@ -210,11 +203,11 @@ def _validate_sleep_duration(value: core.TimePeriod) -> core.TimePeriod:
    if CORE.is_bk72xx:
        max_duration = core.TimePeriod(hours=36)
        if value > max_duration:
-            raise cv.Invalid("'sleep_duration' cannot be more than 36 hours on BK72XX")
+            raise cv.Invalid("sleep duration cannot be more than 36 hours on BK72XX")
    elif CORE.using_zephyr:
        max_duration = core.TimePeriod(days=49)
        if value > max_duration:
-            raise cv.Invalid("'sleep_duration' cannot be more than 49 days on Zephyr")
+            raise cv.Invalid("sleep duration cannot be more than 49 days on Zephyr")
    return value


@@ -297,10 +290,7 @@ CONFIG_SCHEMA = cv.All(
                cv.positive_time_period_milliseconds,
                _validate_sleep_duration,
            ),
-            cv.Optional(CONF_WAKEUP_PIN): cv.All(
-                cv.only_on([PLATFORM_ESP32, PLATFORM_BK72XX]),
-                validate_wakeup_pin,
-            ),
+            cv.Optional(CONF_WAKEUP_PIN): validate_wakeup_pin,
            cv.Optional(CONF_WAKEUP_PIN_MODE): cv.All(
                cv.only_on([PLATFORM_ESP32, PLATFORM_BK72XX]),
                cv.enum(WAKEUP_PIN_MODES, upper=True),
@@ -357,10 +347,11 @@ async def to_code(config: ConfigType) -> None:

    if CONF_SLEEP_DURATION in config:
        cg.add(var.set_sleep_duration(config[CONF_SLEEP_DURATION]))
-    if (wakeup_pins := config.get(CONF_WAKEUP_PIN)) is not None:
+    if CONF_WAKEUP_PIN in config:
+        pins_as_list = config.get(CONF_WAKEUP_PIN, [])
        if CORE.is_bk72xx:
-            cg.add(var.init_wakeup_pins(len(wakeup_pins)))
-            for item in wakeup_pins:
+            cg.add(var.init_wakeup_pins(len(pins_as_list)))
+            for item in pins_as_list:
                cg.add(
                    var.add_wakeup_pin(
                        await cg.gpio_pin_expression(item[CONF_PIN]),
@@ -370,7 +361,7 @@ async def to_code(config: ConfigType) -> None:
                    )
                )
        else:
-            pin = await cg.gpio_pin_expression(wakeup_pins[0][CONF_PIN])
+            pin = await cg.gpio_pin_expression(pins_as_list[0][CONF_PIN])
            cg.add(var.set_wakeup_pin(pin))
    if CONF_WAKEUP_PIN_MODE in config:
        cg.add(var.set_wakeup_pin_mode(config[CONF_WAKEUP_PIN_MODE]))
@@ -250,42 +250,6 @@ 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,7 +5,6 @@
 #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 {
@@ -53,62 +52,37 @@ void Display::line_at_angle(int x, int y, int angle, int start_radius, int stop_
  this->line(x1, y1, x2, y2, color);
 }

-// 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;
-    for (int x = 0; x != w; x++, source_idx++) {
-      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;
+  size_t line_stride = x_offset + w + x_pad;  // length of each source line in pixels
+  uint32_t color_value;
+  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));
+    }
  }
 }

@@ -139,11 +139,6 @@ 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;
@@ -722,12 +717,6 @@ 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.
   */
@@ -1,8 +1,5 @@
 #pragma once
-#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 };
@@ -11,27 +8,6 @@ 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;
@@ -178,54 +154,4 @@ class ColorUtil {
    return color;
  }
 };
-
-/** Rec.601 luma weights (0.299/0.587/0.114), scaled by 256 */
-static constexpr uint16_t REC601_LUMA_R = 77;
-static constexpr uint16_t REC601_LUMA_G = 150;
-static constexpr uint16_t REC601_LUMA_B = 29;
-
-/** Rec.601 luma of an RGB color, for optimum perceptual brightness */
-constexpr uint8_t rec601_luma(Color color) {
-  return (uint8_t) ((REC601_LUMA_R * color.r + REC601_LUMA_G * color.g + REC601_LUMA_B * color.b + 128u) >> 8);
-}
-
-/** Map an RGB color to a single monochrome bit: 1 = white, 0 = black */
-constexpr uint8_t color_to_mono(Color color) { return rec601_luma(color) >= 128 ? 1 : 0; }
-
-/** color_to_mono() of an RGB565 value as ColorUtil::to_color() reads it, from table lookups instead of a division
- * per channel.
- */
-class Rgb565ToMono {
- public:
-  explicit Rgb565ToMono(ColorOrder order) {
-    // Rec.601 weight of the 5-bit, 6-bit and 5-bit fields, by the channel each one holds in this order
-    uint16_t high = REC601_LUMA_R, middle = REC601_LUMA_G, low = REC601_LUMA_B;
-    if (order == COLOR_ORDER_BGR) {
-      high = REC601_LUMA_B;
-      low = REC601_LUMA_R;
-    } else if (order == COLOR_ORDER_GRB) {
-      high = REC601_LUMA_G;
-      middle = REC601_LUMA_R;
-    }
-    // Each field value scaled to 0..255, then weighted
-    for (unsigned i = 0; i != 32; i++) {
-      this->high_[i] = high * esp_scale(i, 31);
-      this->low_[i] = low * esp_scale(i, 31);
-    }
-    for (unsigned i = 0; i != 64; i++)
-      this->middle_[i] = middle * esp_scale(i, 63);
-  }
-
-  uint8_t operator()(uint16_t value) const {
-    const uint32_t weighted = this->high_[value >> 11] + this->middle_[(value >> 5) & 0x3F] + this->low_[value & 0x1F];
-    return ((weighted + 128u) >> 8) >= 128 ? 1 : 0;
-  }
-
- protected:
-  // Weighted contribution of each value of each field
-  std::array<uint16_t, 32> high_{};
-  std::array<uint16_t, 64> middle_{};
-  std::array<uint16_t, 32> low_{};
-};
-
 }  // namespace esphome::display
@@ -118,8 +118,13 @@ void Ecocomfort2Fan::on_status() {

  int new_speed = this->speed;
  uint8_t base_speed = raw_speed & SPEED_MASK;
-  if (base_speed >= SPEED_SLEEP && base_speed <= SPEED_VEL3)
+  if (raw_speed & FLAG_BOOST) {
+    new_speed = SPEED_COUNT;
+  } else if (raw_speed & FLAG_NIGHT) {
+    new_speed = SPEED_SLEEP;
+  } else if (base_speed >= SPEED_SLEEP && base_speed <= SPEED_VEL3) {
    new_speed = base_speed;
+  }
  const Preset *preset = find_preset(mode, (raw_speed & FLAG_AUTO) != 0);
  const char *new_preset = preset != nullptr ? preset->name : nullptr;
  bool same_preset = new_preset == nullptr ? !this->has_preset_mode() : this->get_preset_mode().c_str() == new_preset;
@@ -205,10 +205,6 @@ void Ecocomfort2Hub::publish_unknown_() {
      sensor->publish_state(NAN);
  }
 #endif
-#ifdef USE_BINARY_SENSOR
-  if (this->boost_binary_sensor_ != nullptr)
-    this->boost_binary_sensor_->invalidate_state();
-#endif
 }

 // C_OPER: mode byte, speed/flags byte
@@ -220,6 +216,10 @@ void Ecocomfort2Hub::on_oper_(const uint8_t *data, uint16_t len) {
  this->mode_ = data[0];
  this->speed_ = data[1];
  ESP_LOGD(TAG, "[%s] C_OPER: mode=0x%02x, speed=0x%02x", this->parent_->address_str(), this->mode_, this->speed_);
+#ifdef USE_BINARY_SENSOR
+  if (this->boost_binary_sensor_ != nullptr)
+    this->boost_binary_sensor_->publish_state((this->speed_ & FLAG_BOOST) != 0);
+#endif
 #ifdef ECOCOMFORT2_CHILD_COUNT
  for (auto *child : this->children_) {
    child->on_status();
@@ -227,9 +227,7 @@ void Ecocomfort2Hub::on_oper_(const uint8_t *data, uint16_t len) {
 #endif
 }

-// C_STATE: bytes 0-1 the mode and speed the unit runs; byte 1 also has the boost flag (0x40) and the advanced
-// control step (0x20). Byte 2 the air flow direction, bytes 3-4 temperature and 5-6 humidity in hundredths,
-// 7-8 VOC in ppb
+// C_STATE: bytes 3-4 temperature and 5-6 humidity in hundredths, 7-8 VOC in ppb, byte 2 the air flow direction
 void Ecocomfort2Hub::on_state_(const uint8_t *data, uint16_t len) {
  if (len < 9) {
    ESP_LOGW(TAG, "[%s] C_STATE too short: %u bytes", this->parent_->address_str(), len);
@@ -238,12 +236,8 @@ void Ecocomfort2Hub::on_state_(const uint8_t *data, uint16_t len) {
  const float temperature = static_cast<int16_t>(encode_uint16(data[3], data[4])) / 100.0f;
  const float humidity = encode_uint16(data[5], data[6]) / 100.0f;
  const uint16_t voc = encode_uint16(data[7], data[8]);
-  ESP_LOGD(TAG, "[%s] C_STATE: mode=0x%02x, speed=0x%02x, %.2f °C, %.2f %%, %u ppb, direction=%u",
-           this->parent_->address_str(), data[0], data[1], temperature, humidity, voc, data[2]);
-#ifdef USE_BINARY_SENSOR
-  if (this->boost_binary_sensor_ != nullptr)
-    this->boost_binary_sensor_->publish_state((data[1] & FLAG_BOOST) != 0);
-#endif
+  ESP_LOGD(TAG, "[%s] C_STATE: %.2f °C, %.2f %%, %u ppb, direction=%u", this->parent_->address_str(), temperature,
+           humidity, voc, data[2]);
 #ifdef USE_SENSOR
  if (this->temperature_sensor_ != nullptr)
    this->temperature_sensor_->publish_state(temperature);
@@ -273,7 +267,7 @@ void Ecocomfort2Hub::on_info_(const uint8_t *data, uint16_t len) {
 }

 #ifdef USE_TIME
-// C_CLOCK: two-digit year, month, day, weekday with Monday as 0, hour, minute, second, automatic DST flag
+// C_CLOCK: hour, minute, second, weekday with Monday as 0, day, month, year as two bytes
 void Ecocomfort2Hub::sync_clock_() {
  if (!this->is_ready() || this->char_handle_clock_ == 0)
    return;
@@ -282,11 +276,15 @@ void Ecocomfort2Hub::sync_clock_() {
    return;
  // ESPTime counts Sunday=1 .. Saturday=7, the unit Monday=0 .. Sunday=6
  const uint8_t weekday = (now.day_of_week + 5) % 7;
-  // The time source already applies DST and every sync rewrites the clock, so the unit must not shift it again
-  uint8_t data[8]{
-      static_cast<uint8_t>(now.year % 100), now.month, now.day_of_month, weekday, now.hour, now.minute, now.second, 0};
-  ESP_LOGD(TAG, "[%s] Syncing clock to %04u-%02u-%02u %02u:%02u:%02u", this->parent_->address_str(), now.year,
-           now.month, now.day_of_month, now.hour, now.minute, now.second);
+  uint8_t data[8]{now.hour,
+                  now.minute,
+                  now.second,
+                  weekday,
+                  now.day_of_month,
+                  now.month,
+                  static_cast<uint8_t>(now.year >> 8),
+                  static_cast<uint8_t>(now.year)};
+  ESP_LOGD(TAG, "[%s] Syncing clock to %02u:%02u:%02u", this->parent_->address_str(), now.hour, now.minute, now.second);
  auto status =
      esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_clock_,
                               sizeof(data), data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
@@ -32,8 +32,7 @@ static constexpr uint8_t OPER_OUT = 0x02;
 static constexpr uint8_t OPER_IN_OUT = 0x03;
 static constexpr uint8_t OPER_SENSOR_OR_AUTO = 0x04;

-// Speed byte: speed in the low nibble, flags in the high nibble.
-// C_OPER carries FLAG_AUTO; the unit reports FLAG_BOOST in byte 1 of C_STATE.
+// C_OPER byte 1: speed in the low nibble, flags in the high nibble
 static constexpr uint8_t SPEED_OFF = 0x00;
 static constexpr uint8_t SPEED_SLEEP = 0x01;
 static constexpr uint8_t SPEED_VEL1 = 0x02;
@@ -42,6 +41,7 @@ static constexpr uint8_t SPEED_VEL3 = 0x04;
 static constexpr uint8_t SPEED_MASK = 0x0F;
 static constexpr uint8_t FLAG_AUTO = 0x10;
 static constexpr uint8_t FLAG_BOOST = 0x40;
+static constexpr uint8_t FLAG_NIGHT = 0x80;

 /** Hub component for Ecocomfort 2.0 VMC via BLE. */
 class Ecocomfort2Hub : public esphome::ble_client::BLEClientNode, public PollingComponent {
@@ -23,18 +23,11 @@ DEPENDENCIES = ["uart"]

 emontx_ns = cg.esphome_ns.namespace("emontx")
 EmonTx = emontx_ns.class_("EmonTx", cg.Component, uart.UARTDevice)
-LockOnReboot = emontx_ns.enum("LockOnReboot", is_class=True)

 CONF_EMONTX_ID = "emontx_id"
 CONF_TAG_NAME = "tag_name"
 CONF_ON_JSON = "on_json"
 CONF_LOCK_ON_REBOOT = "lock_on_reboot"
-LOCK_ON_REBOOT_AUTO = "auto"
-LOCK_ON_REBOOT_MODES = {
-    LOCK_ON_REBOOT_AUTO: LockOnReboot.LOCK_ON_REBOOT_AUTO,
-    True: LockOnReboot.LOCK_ON_REBOOT_ALWAYS,
-    False: LockOnReboot.LOCK_ON_REBOOT_NEVER,
-}

 DOMAIN = "emontx"

@@ -66,9 +59,7 @@ CONFIG_SCHEMA = (
            cv.GenerateID(): cv.declare_id(EmonTx),
            cv.Optional(CONF_ON_JSON): _synchronous_automation_schema(),
            cv.Optional(CONF_ON_DATA): _synchronous_automation_schema(),
-            cv.Optional(CONF_LOCK_ON_REBOOT, default=LOCK_ON_REBOOT_AUTO): cv.Any(
-                cv.boolean, cv.one_of(LOCK_ON_REBOOT_AUTO, lower=True)
-            ),
+            cv.Optional(CONF_LOCK_ON_REBOOT, default=False): cv.boolean,
        }
    )
    .extend(cv.COMPONENT_SCHEMA)
@@ -144,11 +135,8 @@ async def to_code(config: ConfigType) -> None:
    await uart.register_uart_device(var, config)
    await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)

-    lock = config[CONF_LOCK_ON_REBOOT]
-    cg.add(var.set_lock_on_reboot(LOCK_ON_REBOOT_MODES[lock]))
-    if lock == LOCK_ON_REBOOT_AUTO:
-        # Locking depends on the firmware version the emonTx reports
-        cg.add_define("USE_EMONTX_VERSION")
+    if config[CONF_LOCK_ON_REBOOT]:
+        cg.add(var.set_lock_on_reboot(True))


 # Action: emontx.send_command
@@ -1,91 +1,23 @@
 #include "emontx.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 #include "esphome/components/json/json_util.h"

 namespace esphome::emontx {

 ESPHOME_LOG_TAG(TAG, "emontx");

-static constexpr uint32_t UNLOCK_ID = 0;
-// The emonTx joins bytes received while a command is pending into that command, so the next one waits
-static constexpr uint32_t COMMAND_GAP_MS = 250;
-
-#ifdef USE_EMONTX_VERSION
-static constexpr uint32_t VERSION_REQUEST_ID = 1;
-// Without a reply, 'v' is sent again every VERSION_RETRY_FRAMES data lines, VERSION_MAX_ATTEMPTS times in all
-static constexpr uint8_t VERSION_RETRY_FRAMES = 2;
-static constexpr uint8_t VERSION_MAX_ATTEMPTS = 3;
-// Line of the 'v' reply (and of the boot banner) carrying the release, e.g. "  - Version:    v1.1.1"
-static const char VERSION_PREFIX[] PROGMEM = "  - Version:";
-// Every data line starts with the message counter, in JSON or text format
-static const char MSG_JSON_PREFIX[] PROGMEM = "{\"MSG\":";
-static const char MSG_TEXT_PREFIX[] PROGMEM = "MSG:";
-// First firmware with 'emonlock' and 'emonunlock'; older firmware takes them for the bootloader command
-static constexpr uint32_t LOCK_MIN_MAJOR = 1;
-static constexpr uint32_t LOCK_MIN_MINOR = 2;
-
-// True if line starts with the PROGMEM prefix and has more after it
-static bool starts_with(const char *line, size_t len, const char *prefix, size_t prefix_len) {
-  return len > prefix_len && ESPHOME_strncmp_P(line, prefix, prefix_len) == 0;
-}
-
-// Reads the decimal number (up to 9 digits) at pos and moves pos past it; false if there is none
-static bool read_number(const char *&pos, const char *end, uint32_t &value) {
-  const char *start = pos;
-  value = 0;
-  while (pos < end && pos - start < 9 && *pos >= '0' && *pos <= '9')
-    value = value * 10 + (*pos++ - '0');
-  return pos != start;
-}
-
-// True for a release such as "v1.2.0" or "v1.3.0-rc1" from LOCK_MIN_MAJOR.LOCK_MIN_MINOR on
-static bool supports_lock(const char *version, const char *end) {
-  if (version < end && (*version == 'v' || *version == 'V'))
-    version++;
-  uint32_t major;
-  if (!read_number(version, end, major) || version == end || *version != '.')
-    return false;
-  version++;
-  uint32_t minor;
-  if (!read_number(version, end, minor))
-    return false;
-  return major > LOCK_MIN_MAJOR || (major == LOCK_MIN_MAJOR && minor >= LOCK_MIN_MINOR);
-}
-#endif
-
 void EmonTx::setup() {
  this->buffer_pos_ = 0;
-  if (this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_ALWAYS) {
-    // The line feed ends any boot noise
-    this->write_byte('\n');
-    this->set_timeout(UNLOCK_ID, COMMAND_GAP_MS, [this]() {
-      this->unlock_();
-#ifdef USE_EMONTX_VERSION
-      if (this->wants_version_())
-        this->request_version_();
-#endif
-    });
+  if (!this->lock_on_reboot_)
    return;
-  }
-#ifdef USE_EMONTX_VERSION
-  // With AUTO, the reply decides whether to unlock
-  if (this->wants_version_())
-    this->request_version_();
-#endif
-}
-
-void EmonTx::unlock_() {
-  ESP_LOGI(TAG, "Unlocking emonTx");
+  // The line feed ends any boot noise first
+  ESP_LOGI(TAG, "Unlocking emonTx after boot");
+  this->write_byte('\n');
  this->send_command("emonunlock");
 }

 void EmonTx::on_shutdown() {
-  bool lock = this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_ALWAYS;
-#ifdef USE_EMONTX_VERSION
-  lock |= this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_AUTO && this->lock_supported_;
-#endif
-  if (!lock)
+  if (!this->lock_on_reboot_)
    return;
  if (this->is_paused()) {
    ESP_LOGW(TAG, "Not locking emonTx before shutdown, UART is paused");
@@ -116,11 +48,6 @@ void EmonTx::loop() {
    uint8_t dropped;
    while (this->available() > 0 && this->read_byte(&dropped))
      this->discarding_line_ = dropped != '\n';
-#ifdef USE_EMONTX_VERSION
-    // The emonTx may have been flashed, or a request dropped, during the pause
-    if (this->wants_version_())
-      this->request_version_();
-#endif
  }

  // Read all available data to prevent UART buffer overflow
@@ -150,12 +77,6 @@ void EmonTx::loop() {
          ESP_LOGV(TAG, "Line is JSON, parsing...");
          this->parse_json_(this->buffer_.data(), len);
        }
-#ifdef USE_EMONTX_VERSION
-        if (this->wants_version_()) {
-          this->parse_msg_number_(this->buffer_.data(), len);
-          this->parse_version_line_(this->buffer_.data(), len);
-        }
-#endif
      }
    } else if (received == '\r' || this->discarding_line_) {
      // Ignore CR, and the rest of a line that overflowed or was interrupted by a pause
@@ -191,91 +112,12 @@ void EmonTx::parse_json_(const char *data, size_t len) {
  }
 }

-#ifdef USE_EMONTX_VERSION
-void EmonTx::request_version_() {
-  // The firmware may have changed; until the reply, an unknown version gets no lock commands
-  this->lock_supported_ = false;
-  this->version_frames_left_ = VERSION_RETRY_FRAMES * VERSION_MAX_ATTEMPTS;
-  this->send_version_request_();
-}
-
-// The line feed ends any pending input; the reply is picked up in loop() by parse_version_line_()
-void EmonTx::send_version_request_() {
-  if (this->is_paused())
-    return;
-  this->write_byte('\n');
-  this->set_timeout(VERSION_REQUEST_ID, COMMAND_GAP_MS, [this]() { this->send_command("v"); });
-}
-
-void EmonTx::parse_msg_number_(const char *line, size_t len) {
-  const char *pos;
-  if (starts_with(line, len, MSG_JSON_PREFIX, sizeof(MSG_JSON_PREFIX) - 1)) {
-    pos = line + sizeof(MSG_JSON_PREFIX) - 1;
-  } else if (starts_with(line, len, MSG_TEXT_PREFIX, sizeof(MSG_TEXT_PREFIX) - 1)) {
-    pos = line + sizeof(MSG_TEXT_PREFIX) - 1;
-  } else {
-    return;
-  }
-  uint32_t msg_number;
-  if (!read_number(pos, line + len, msg_number))
-    return;
-
-  // MSG restarts at 1 when the emonTx reboots, as it does after a firmware update
-  if (msg_number <= this->last_msg_number_) {
-    this->request_version_();
-  } else if (this->version_frames_left_ > 0) {
-    if (--this->version_frames_left_ == 0) {
-      ESP_LOGW(TAG, "No firmware version from the emonTx, it may still be locked");
-    } else if (this->version_frames_left_ % VERSION_RETRY_FRAMES == 0) {
-      this->send_version_request_();
-    }
-  }
-  this->last_msg_number_ = msg_number;
-}
-
-void EmonTx::parse_version_line_(const char *line, size_t len) {
-  constexpr size_t prefix_len = sizeof(VERSION_PREFIX) - 1;
-  if (!starts_with(line, len, VERSION_PREFIX, prefix_len))
-    return;
-  const char *version = line + prefix_len;
-  const char *end = line + len;
-  while (version < end && *version == ' ')
-    version++;
-  if (version == end)
-    return;
-  ESP_LOGI(TAG, "emonTx firmware version: %.*s", static_cast<int>(end - version), version);
-  this->version_frames_left_ = 0;
-#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
-  if (this->version_text_sensor_ != nullptr)
-    this->version_text_sensor_->publish_state(version, end - version);
-#endif
-
-  bool supported = supports_lock(version, end);
-  if (this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_AUTO && supported && !this->unlock_sent_) {
-    // Once the rest of the reply has gone out; a pause drops it, and the version request on resume retries
-    this->set_timeout(UNLOCK_ID, COMMAND_GAP_MS, [this]() {
-      if (this->is_paused())
-        return;
-      this->unlock_();
-      this->unlock_sent_ = true;
-    });
-  }
-  this->lock_supported_ = supported;
-}
-#endif
-
 /**
 * @brief Logs the EmonTx component configuration details.
 */
 void EmonTx::dump_config() {
  ESP_LOGCONFIG(TAG, "EmonTx:");
-  const char *lock = LOG_STR_LITERAL("no");
-  if (this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_ALWAYS) {
-    lock = LOG_STR_LITERAL("yes");
-  } else if (this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_AUTO) {
-    lock = LOG_STR_LITERAL("auto");
-  }
-  ESP_LOGCONFIG(TAG, "  Lock on reboot: %s", lock);
+  ESP_LOGCONFIG(TAG, "  Lock on reboot: %s", YESNO(this->lock_on_reboot_));

 #ifdef USE_SENSOR
  ESP_LOGCONFIG(TAG, "  Registered sensors: %zu", this->sensors_.size());
@@ -285,9 +127,6 @@ void EmonTx::dump_config() {
 #else
  ESP_LOGCONFIG(TAG, "  Sensor support: DISABLED");
 #endif
-#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
-  LOG_TEXT_SENSOR("  ", "Firmware version", this->version_text_sensor_);
-#endif
 }

 /**
@@ -13,21 +13,12 @@
 #ifdef USE_SENSOR
 #include "esphome/components/sensor/sensor.h"
 #endif
-#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
-#include "esphome/components/text_sensor/text_sensor.h"
-#endif

 namespace esphome::emontx {

 /// Maximum line length in bytes (plus one byte reserved for null terminator)
 static constexpr size_t MAX_LINE_LENGTH = 1024;

-enum class LockOnReboot : uint8_t {
-  LOCK_ON_REBOOT_NEVER,
-  LOCK_ON_REBOOT_ALWAYS,
-  LOCK_ON_REBOOT_AUTO,  // Only when the emonTx reports firmware v1.2.0 or later
-};
-
 /**
 * @class EmonTx
 * @brief Main class for the EmonTx component.
@@ -36,9 +27,6 @@ enum class LockOnReboot : uint8_t {
 * extracts tags and values, and publishes them to registered sensors.
 */
 class EmonTx final : public Component, public uart::UARTDevice {
-#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
-  SUB_TEXT_SENSOR(version)
-#endif
 public:
  EmonTx() = default;

@@ -62,8 +50,8 @@ class EmonTx final : public Component, public uart::UARTDevice {
  bool is_paused() const { return this->paused_.load(std::memory_order_relaxed); }

  /// Lock the emonTx ('emonlock') before a reboot, so serial garbage during the reboot is not taken
-  /// as a command, and unlock it after boot. Needs emonTx firmware v1.2.0 or later, which AUTO checks.
-  void set_lock_on_reboot(LockOnReboot lock_on_reboot) { this->lock_on_reboot_ = lock_on_reboot; }
+  /// as a command, and unlock it in setup(). Needs emonTx firmware v1.2.0 or later.
+  void set_lock_on_reboot(bool lock_on_reboot) { this->lock_on_reboot_ = lock_on_reboot; }

 #ifdef USE_SENSOR
  void init_sensors(size_t count) { this->sensors_.init(count); }
@@ -72,20 +60,6 @@ class EmonTx final : public Component, public uart::UARTDevice {

 protected:
  void parse_json_(const char *data, size_t len);
-  void unlock_();
-#ifdef USE_EMONTX_VERSION
-  bool wants_version_() const {
-#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
-    if (this->version_text_sensor_ != nullptr)
-      return true;
-#endif
-    return this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_AUTO;
-  }
-  void request_version_();
-  void send_version_request_();
-  void parse_msg_number_(const char *line, size_t len);
-  void parse_version_line_(const char *line, size_t len);
-#endif

 #ifdef USE_SENSOR
  FixedVector<std::pair<const char *, sensor::Sensor *>> sensors_{};
@@ -95,14 +69,8 @@ class EmonTx final : public Component, public uart::UARTDevice {
  uint16_t buffer_pos_{0};
  std::atomic<bool> paused_{false};
  bool was_paused_{false};
-  LockOnReboot lock_on_reboot_{LockOnReboot::LOCK_ON_REBOOT_NEVER};
+  bool lock_on_reboot_{false};
  bool discarding_line_{false};  // Set after an overflow or a pause until the end of that line
-#ifdef USE_EMONTX_VERSION
-  bool lock_supported_{false};      // The last version reported is v1.2.0 or later
-  bool unlock_sent_{false};         // AUTO has sent 'emonunlock' since boot
-  uint8_t version_frames_left_{0};  // Data lines still to wait for a version reply; 0 when none is owed
-  uint32_t last_msg_number_{0};
-#endif
  std::array<char, MAX_LINE_LENGTH + 1> buffer_{};
 };

@@ -1,24 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import text_sensor
-import esphome.config_validation as cv
-from esphome.const import CONF_VERSION, ENTITY_CATEGORY_DIAGNOSTIC, ICON_CHIP
-from esphome.types import ConfigType
-
-from .. import CONF_EMONTX_ID, EmonTx
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_EMONTX_ID): cv.use_id(EmonTx),
-        cv.Optional(CONF_VERSION): text_sensor.text_sensor_schema(
-            entity_category=ENTITY_CATEGORY_DIAGNOSTIC, icon=ICON_CHIP
-        ),
-    }
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    hub = await cg.get_variable(config[CONF_EMONTX_ID])
-    text_sensors = text_sensor.sub_text_sensors(config)
-    if await text_sensors(CONF_VERSION, hub.set_version_text_sensor) is not None:
-        cg.add_define("USE_EMONTX_VERSION")
-        cg.add_define("USE_EMONTX_VERSION_TEXT_SENSOR")
@@ -2,7 +2,6 @@

 #include <cstdint>
 #include <algorithm>
-#include "esphome/components/display/display_color_utils.h"
 #include "esphome/core/color.h"

 /* Utility for converting internal \a Color RGB representation to supported IC hardware color keys
@@ -14,15 +13,21 @@

 namespace esphome::epaper_spi {

-// The Rec.601 luma helpers and the RGB565 mono lookup live in the shared display utilities, so other
-// drivers (e.g. it8951 in its 1 bit per pixel mode) can use them too.
-using display::color_to_mono;
-using display::rec601_luma;
-using display::Rgb565ToMono;
-
 /** Delta for when to regard as gray */
 static constexpr uint8_t COLORCONV_GRAY_THRESHOLD = 50;

+/** Rec.601 luma (0.299/0.587/0.114 weights, scaled by 256) for optimum perceptual brightness */
+constexpr uint8_t rec601_luma(Color color) {
+  return (uint8_t) ((77u * color.r + 150u * color.g + 29u * color.b + 128u) >> 8);
+}
+
+/** Map RGB color to a single monochrome bit
+ *
+ * @param color RGB color to convert from
+ * @return      1 = white, 0 = black
+ */
+constexpr uint8_t color_to_mono(Color color) { return rec601_luma(color) >= 128 ? 1 : 0; }
+
 /** Map RGB color to one of 4 discrete gray levels (2 bits per pixel)
 *
 * @param color RGB color to convert from
@@ -40,6 +40,7 @@ from esphome.const import (
    CONF_WIDTH,
 )
 from esphome.cpp_generator import RawExpression
+from esphome.final_validate import full_config

 from . import models

@@ -197,11 +198,15 @@ 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 display.has_external_writer(config[CONF_ID]):
+        if LVGL_DOMAIN in global_config:
            if CONF_UPDATE_INTERVAL not in config:
                config[CONF_UPDATE_INTERVAL] = update_interval("never")
        else:
+            # If no drawing methods are configured, and LVGL is not enabled, show a test card
            config[CONF_SHOW_TEST_CARD] = True
    elif CONF_UPDATE_INTERVAL not in config:
        config[CONF_UPDATE_INTERVAL] = update_interval("1min")
@@ -131,7 +131,9 @@ void EPaperBase::update() {
 }

 void EPaperBase::wait_for_idle_(bool should_wait) {
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
  this->waiting_for_idle_start_ = millis();
+#endif
  this->waiting_for_idle_ = should_wait;
 }

@@ -154,10 +156,6 @@ void EPaperBase::loop() {
      ESP_LOGV(TAG, "Screen was busy for %u ms", (unsigned) (millis() - this->waiting_for_idle_start_));
 #endif
    } else {
-      if (now - this->waiting_for_idle_start_ > this->busy_timeout_seconds_ * 1000u) {
-        this->abandon_update_();
-        return;
-      }
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
      if (now - this->waiting_for_idle_last_print_ >= 1000) {
        ESP_LOGV(TAG, "Waiting for idle in state %s", this->epaper_state_to_string_());
@@ -170,20 +168,6 @@ void EPaperBase::loop() {
  this->process_state_();
 }

-// The busy pin never cleared: give up on this update so later ones are not refused, and make the next one full
-void EPaperBase::abandon_update_() {
-  ESP_LOGE(TAG, "Display stayed busy for %u s in state %s; check the busy pin", (unsigned) this->busy_timeout_seconds_,
-           this->epaper_state_to_string_());
-  this->status_set_warning(LOG_STR("Busy pin timeout"));
-  if (this->state_ == EPaperState::TRANSFER_DATA)
-    this->abort_transfer();
-  // Leave the panel powered down rather than with its high-voltage drivers enabled
-  this->power_off();
-  this->full_update_requested_ = true;
-  this->current_data_index_ = 0;
-  this->set_state_(EPaperState::IDLE);
-}
-
 /**
 * Process the state machine.
 * Typical state sequence:
@@ -258,7 +242,6 @@ void EPaperBase::process_state_() {
      break;
    case EPaperState::DEEP_SLEEP:
      this->deep_sleep();
-      this->status_clear_warning();
      this->set_state_(EPaperState::IDLE);
      ESP_LOGD(TAG, "Display update took %" PRIu32 " ms", millis() - this->update_start_time_);
      break;
@@ -362,120 +345,6 @@ void HOT EPaperBase::draw_pixel_at(int x, int y, Color color) {
  }
 }

-namespace {
-// One source row of an RGB565 block, written into a contiguous 1 bit per pixel buffer. Without SwapAxes the row lies
-// along a buffer row and the bit moves by step; with it the row lies along a bit column and the byte moves by step
-// rows.
-template<bool SwapAxes, bool BigEndianSource>
-void HOT write_rgb565_row(uint8_t *byte, uint8_t mask, int step, size_t row_width, const uint8_t *source, int count,
-                          const Rgb565ToMono &to_mono) {
-  const ptrdiff_t byte_step = SwapAxes ? step * static_cast<ptrdiff_t>(row_width) : 0;
-  for (; count != 0; count--, source += 2) {
-    const uint16_t value = BigEndianSource ? (source[0] << 8) | source[1] : source[0] | (source[1] << 8);
-    if (to_mono(value)) {
-      *byte |= mask;
-    } else {
-      *byte &= ~mask;
-    }
-    if constexpr (SwapAxes) {
-      byte += byte_step;
-    } else if (step > 0) {
-      mask >>= 1;
-      if (mask == 0) {
-        mask = 0x80;
-        byte++;
-      }
-    } else {
-      mask <<= 1;
-      if (mask == 0) {
-        mask = 0x01;
-        byte--;
-      }
-    }
-  }
-}
-}  // namespace
-
-// Each source column maps to one buffer coordinate and each source row to the other, each moving by 1 per pixel, so
-// the visible part of a block and its dirty area are worked out once for the whole block.
-void HOT EPaperBase::draw_rgb565_block_(uint8_t *buffer, 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 bool swap = this->effective_transform_ & SWAP_XY;
-  const bool mirror_x = this->effective_transform_ & MIRROR_X;
-  const bool mirror_y = this->effective_transform_ & MIRROR_Y;
-  // The buffer axis a source column moves along, and the one a source row moves along
-  const int column_limit = swap ? this->height_ : this->width_;
-  const int row_limit = swap ? this->width_ : this->height_;
-  const bool column_mirrored = swap ? mirror_y : mirror_x;
-  const bool row_mirrored = swap ? mirror_x : mirror_y;
-  const int first_column = std::max(0, -x_start);
-  const int end_column = std::min(w, column_limit - x_start);
-  const int first_row = std::max(0, -y_start);
-  const int end_row = std::min(h, row_limit - y_start);
-  if (first_column >= end_column || first_row >= end_row)
-    return;
-  auto column_to_buffer = [&](int column) {
-    const int u = x_start + column;
-    return column_mirrored ? column_limit - 1 - u : u;
-  };
-  auto row_to_buffer = [&](int row) {
-    const int v = y_start + row;
-    return row_mirrored ? row_limit - 1 - v : v;
-  };
-
-  const int column_low = std::min(column_to_buffer(first_column), column_to_buffer(end_column - 1));
-  const int row_low = std::min(row_to_buffer(first_row), row_to_buffer(end_row - 1));
-  const int columns = end_column - first_column;
-  const int rows = end_row - first_row;
-  const int x_low = swap ? row_low : column_low;
-  const int y_low = swap ? column_low : row_low;
-  const int x_high = x_low + (swap ? rows : columns);
-  const int y_high = y_low + (swap ? columns : rows);
-
-  const Rgb565ToMono to_mono(order);
-  const size_t line_stride = x_offset + w + x_pad;
-  const size_t row_width = this->row_width_;
-  const int step = column_mirrored ? -1 : 1;
-  for (int row = first_row; row != end_row; row++) {
-    const uint8_t *source = ptr + ((y_offset + row) * line_stride + x_offset + first_column) * 2;
-    const int along = column_to_buffer(first_column);
-    const int across = row_to_buffer(row);
-    const int x = swap ? across : along;
-    const int y = swap ? along : across;
-    uint8_t *byte = buffer + y * row_width + x / 8;
-    const uint8_t mask = 0x80u >> (x % 8);
-    if (swap) {
-      if (big_endian) {
-        write_rgb565_row<true, true>(byte, mask, step, row_width, source, columns, to_mono);
-      } else {
-        write_rgb565_row<true, false>(byte, mask, step, row_width, source, columns, to_mono);
-      }
-    } else if (big_endian) {
-      write_rgb565_row<false, true>(byte, mask, step, row_width, source, columns, to_mono);
-    } else {
-      write_rgb565_row<false, false>(byte, mask, step, row_width, source, columns, to_mono);
-    }
-  }
-  this->x_low_ = clamp_at_most(this->x_low_, x_low);
-  this->x_high_ = clamp_at_least(this->x_high_, x_high);
-  this->y_low_ = clamp_at_most(this->y_low_, y_low);
-  this->y_high_ = clamp_at_least(this->y_high_, y_high);
-}
-
-// Writes an RGB565 block of pixels, as LVGL sends them, straight into a 1 bit per pixel buffer that is one block (the
-// usual case): the same result as draw_pixel_at() for each pixel. Anything else goes through draw_pixel_at().
-void HOT EPaperBase::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 contiguous_length;
-  uint8_t *contiguous = this->buffer_.get_span(0, contiguous_length);
-  if (!this->buffer_is_mono() || this->get_clipping().is_set() || bitness != COLOR_BITNESS_565 ||
-      contiguous_length != this->buffer_length_) {
-    Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
-    return;
-  }
-  this->draw_rgb565_block_(contiguous, x_start, y_start, w, h, ptr, order, big_endian, x_offset, y_offset, x_pad);
-}
-
 void EPaperBase::dump_config() {
  LOG_DISPLAY("", "E-Paper SPI", this);
  ESP_LOGCONFIG(TAG,
@@ -106,10 +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;
  // Make the next update a full one. Applied when that update starts, so one in progress is not affected.
  void request_full_update() { this->full_update_requested_ = true; }
  // True from the start of an update until the display has refreshed and gone back to sleep.
@@ -128,14 +125,9 @@ class EPaperBase : public Display,
  virtual bool initialise(bool partial);
  void send_init_sequence_(const uint8_t *sequence, size_t length);
  void wait_for_idle_(bool should_wait);
-  void abandon_update_();
  bool init_buffer_(size_t buffer_length);
  void update_effective_transform_();
  bool rotate_coordinates_(int &x, int &y);
-  void draw_rgb565_block_(uint8_t *buffer, 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);
-  // Whether the buffer holds 1 bit per pixel as draw_pixel_at() writes it, so draw_pixels_at() can write it directly
-  virtual bool buffer_is_mono() const { return false; }

  /**
   * Methods that must be implemented by concrete classes to control the display
@@ -145,8 +137,6 @@ class EPaperBase : public Display,
   * @return true if done, false if it should be called next loop
   */
  virtual bool transfer_data() = 0;
-  // Called when an update is abandoned in the middle of transfer_data(), to release anything it left open
-  virtual void abort_transfer() {}
  /**
   * Refresh the screen after data transfer
   */
@@ -197,20 +187,18 @@ class EPaperBase : public Display,
  // point to the pixel past the last one updated, i.e. may range up to width/height.
  uint16_t x_low_{}, y_low_{}, x_high_{}, y_high_{};

-  uint32_t waiting_for_idle_start_{};
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
  uint32_t waiting_for_idle_last_print_{};
+  uint32_t waiting_for_idle_start_{};
 #endif
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG
  uint32_t update_start_time_{};
 #endif

  // properties with specific initialisers go last
-  uint32_t reset_duration_{10};
-  // Longer than any panel takes to refresh; past it the busy pin is assumed stuck
-  uint16_t busy_timeout_seconds_{120};
-  uint8_t full_update_every_{1};
  EPaperState state_{EPaperState::IDLE};
+  uint32_t reset_duration_{10};
+  uint8_t full_update_every_{1};
 };

 }  // namespace esphome::epaper_spi
@@ -15,7 +15,6 @@ class EPaperMono : public EPaperBase {
  }

 protected:
-  bool buffer_is_mono() const override { return true; }
  void refresh_screen(bool partial) override;
  void power_on() override {}
  void power_off() override{};
@@ -58,9 +58,7 @@ bool HOT EPaperSSD1677::transfer_data() {
  // A full update ignores 0x26, and the copy may not hold a real frame yet (first update after
  // boot): send the new frame to both planes.
  const bool send_copy = this->plane_ == 0 && this->update_count_ != 0;
-  // A mono buffer already holds the frame as a RAM plane does, so it can be sent as it is; a deeper
-  // buffer (the four-level model) returns false and packs the plane in plane_row().
-  const bool direct = send_copy || this->buffer_is_mono();
+  const bool direct = send_copy || this->buffer_is_plane();
  const auto &source = send_copy ? this->sent_ : this->buffer_;
  const size_t row_length = this->plane_row_length_();
  const size_t plane_length = row_length * this->height_;
@@ -34,6 +34,9 @@ class EPaperSSD1677 : public EPaperMono {
  void init_comparison_frame_();
  // Bytes in one row of a RAM plane: 8 pixels per byte, whatever the buffer holds.
  size_t plane_row_length_() const { return (this->width_ + 7) / 8; }
+  // Whether the buffer already holds the frame as a RAM plane does, so it can be sent as it is.
+  // A subclass with a deeper buffer returns false and overrides plane_row().
+  virtual bool buffer_is_plane() const { return true; }
  // Row y of the frame as a RAM plane holds it, 1 bit per pixel with 1 = white.
  virtual void plane_row(size_t y, uint8_t *out);
  bool reset() override;
@@ -38,9 +38,9 @@ class EPaperSSD1677Gray4 : public EPaperSSD1677 {
  void draw_pixel_at(int x, int y, Color color) override;

 protected:
-  bool buffer_is_mono() const override { return false; }
  // A partial update if partial updates are enabled and this is not a full one.
  bool is_partial_push_() const { return this->update_count_ != 0 && this->sent_.is_valid(); }
+  bool buffer_is_plane() const override { return false; }
  void plane_row(size_t y, uint8_t *out) override;
  void refresh_screen(bool partial) override;
  bool transfer_data() override;
@@ -364,15 +364,6 @@ bool HOT EPaperT133A01::transfer_data() {
  return true;
 }

-void EPaperT133A01::abort_transfer() {
-  // A data stream is open, with one of the chip selects held low, whenever transfer_data() has started sending rows
-  if (this->current_data_index_ == 0)
-    return;
-  this->disable();
-  this->cs_pin_->digital_write(true);
-  this->cs1_pin_->digital_write(true);
-}
-
 void EPaperT133A01::dump_config() {
  EPaperBase::dump_config();
  LOG_PIN("  CS Pin: ", this->cs_pin_);
@@ -46,7 +46,6 @@ class EPaperT133A01 : public EPaperBase {
  void deep_sleep() override;

  bool transfer_data() override;
-  void abort_transfer() override;

  /**
   * Send a command (and optional data) selecting one or both controllers.
@@ -37,7 +37,6 @@ class EPaperUC8179 final : public EPaperBase {
  }

 protected:
-  bool buffer_is_mono() const override { return true; }
  bool initialise(bool partial) override;
  bool transfer_data() override;
  void refresh_screen(bool partial) override;
@@ -87,38 +87,6 @@ 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
@@ -162,7 +130,7 @@ jd79660.extend(
 # Note: busy pin uses LOW=busy, HIGH=idle.
 #
 # fmt: off
-gdey0213f51 = jd79660.extend(
+jd79660.extend(
    "goodisplay-gdey0213f51-2.13",
    width=128,
    height=250,
@@ -186,13 +154,3 @@ gdey0213f51 = 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,11 +24,3 @@ WaveshareB(
    data_rate="10MHz",
    minimum_update_interval="1s",
 )
-
-WaveshareB(
-    "waveshare-2.66in-b",
-    width=152,
-    height=296,
-    data_rate="10MHz",
-    minimum_update_interval="15s",
-)
@@ -111,36 +111,24 @@ void ES8388::setup() {
  // Power on ADC, Enable LIN&RIN, Power off MICBIAS, set int1lp to low power mode
  ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCPOWER, 0x09));

-#ifdef USE_ES8388_SELECT
+#ifdef USE_SELECT
  if (this->dac_output_select_ != nullptr) {
-    if (this->dac_output_initial_.has_value()) {
-      const DacOutputLine line = this->dac_output_initial_.value();
-      ES8388_ERROR_FAILED(this->set_dac_output(line));
-      this->dac_output_select_->publish_state(static_cast<size_t>(line));
-    } else {
-      auto dac_power = this->get_dac_power();
-      if (dac_power.has_value()) {
-        if (this->dac_output_select_->has_index(dac_power.value())) {
-          this->dac_output_select_->publish_state(dac_power.value());
-        } else {
-          ESP_LOGW(TAG, "Unknown DAC output power value: %d", dac_power.value());
-        }
+    auto dac_power = this->get_dac_power();
+    if (dac_power.has_value()) {
+      if (this->dac_output_select_->has_index(dac_power.value())) {
+        this->dac_output_select_->publish_state(dac_power.value());
+      } else {
+        ESP_LOGW(TAG, "Unknown DAC output power value: %d", dac_power.value());
      }
    }
  }
  if (this->adc_input_mic_select_ != nullptr) {
-    if (this->adc_input_mic_initial_.has_value()) {
-      const AdcInputMicLine line = this->adc_input_mic_initial_.value();
-      ES8388_ERROR_FAILED(this->set_adc_input_mic(line));
-      this->adc_input_mic_select_->publish_state(static_cast<size_t>(line));
-    } else {
-      auto mic_input = this->get_mic_input();
-      if (mic_input.has_value()) {
-        if (this->adc_input_mic_select_->has_index(mic_input.value())) {
-          this->adc_input_mic_select_->publish_state(mic_input.value());
-        } else {
-          ESP_LOGW(TAG, "Unknown ADC input mic value: %d", mic_input.value());
-        }
+    auto mic_input = this->get_mic_input();
+    if (mic_input.has_value()) {
+      if (this->adc_input_mic_select_->has_index(mic_input.value())) {
+        this->adc_input_mic_select_->publish_state(mic_input.value());
+      } else {
+        ESP_LOGW(TAG, "Unknown ADC input mic value: %d", mic_input.value());
      }
    }
  }
@@ -150,7 +138,7 @@ void ES8388::setup() {
 void ES8388::dump_config() {
  ESP_LOGCONFIG(TAG, "ES8388 Audio Codec:");
  LOG_I2C_DEVICE(this);
-#ifdef USE_ES8388_SELECT
+#ifdef USE_SELECT
  LOG_SELECT("  ", "DacOutputSelect", this->dac_output_select_);
  LOG_SELECT("  ", "ADCInputMicSelect", this->adc_input_mic_select_);
 #endif
@@ -5,7 +5,7 @@
 #include "esphome/components/audio_dac/audio_dac.h"
 #include "esphome/components/i2c/i2c.h"
 #include "esphome/core/component.h"
-#ifdef USE_ES8388_SELECT
+#ifdef USE_SELECT
 #include "esphome/components/select/select.h"
 #endif

@@ -26,7 +26,7 @@ enum AdcInputMicLine : uint8_t {
 };

 class ES8388 final : public audio_dac::AudioDac, public Component, public i2c::I2CDevice {
-#ifdef USE_ES8388_SELECT
+#ifdef USE_SELECT
  SUB_SELECT(dac_output)
  SUB_SELECT(adc_input_mic)
 #endif
@@ -68,22 +68,11 @@ class ES8388 final : public audio_dac::AudioDac, public Component, public i2c::I
  bool set_dac_output(DacOutputLine line);
  bool set_adc_input_mic(AdcInputMicLine line);

-#ifdef USE_ES8388_SELECT
-  /// Line to apply in setup() instead of keeping what the codec reports.
-  void set_dac_output_initial(DacOutputLine line) { this->dac_output_initial_ = line; }
-  void set_adc_input_mic_initial(AdcInputMicLine line) { this->adc_input_mic_initial_ = line; }
-#endif
-
 protected:
  /// @brief Mutes or unmutes the DAC audio out
  /// @param mute_state True to mute, false to unmute
  /// @return True if successful and false otherwise
  bool set_mute_state_(bool mute_state);
-
-#ifdef USE_ES8388_SELECT
-  optional<DacOutputLine> dac_output_initial_{};
-  optional<AdcInputMicLine> adc_input_mic_initial_{};
-#endif
 };

 }  // namespace esphome::es8388
@@ -1,11 +1,7 @@
 import esphome.codegen as cg
 from esphome.components import select
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_INITIAL_OPTION,
-    ENTITY_CATEGORY_CONFIG,
-    ICON_CHIP,  # noqa: F401
-)
+from esphome.const import ENTITY_CATEGORY_CONFIG, ICON_CHIP  # noqa: F401
 from esphome.types import ConfigType

 from ..audio_dac import CONF_ES8388_ID, ES8388, es8388_ns
@@ -13,21 +9,6 @@ from ..audio_dac import CONF_ES8388_ID, ES8388, es8388_ns
 CONF_DAC_OUTPUT = "dac_output"
 CONF_ADC_INPUT_MIC = "adc_input_mic"

-DacOutputLine = es8388_ns.enum("DacOutputLine")
-DAC_OUTPUT_OPTIONS = {
-    "LINE1": DacOutputLine.DAC_OUTPUT_LINE1,
-    "LINE2": DacOutputLine.DAC_OUTPUT_LINE2,
-    "BOTH": DacOutputLine.DAC_OUTPUT_BOTH,
-}
-DAC_OUTPUT_OPTION_NAMES = list(DAC_OUTPUT_OPTIONS)
-AdcInputMicLine = es8388_ns.enum("AdcInputMicLine")
-ADC_INPUT_MIC_OPTIONS = {
-    "LINE1": AdcInputMicLine.ADC_INPUT_MIC_LINE1,
-    "LINE2": AdcInputMicLine.ADC_INPUT_MIC_LINE2,
-    "DIFFERENCE": AdcInputMicLine.ADC_INPUT_MIC_DIFFERENCE,
-}
-ADC_INPUT_MIC_OPTION_NAMES = list(ADC_INPUT_MIC_OPTIONS)
-
 DacOutputSelect = es8388_ns.class_("DacOutputSelect", select.Select)
 ADCInputMicSelect = es8388_ns.class_("ADCInputMicSelect", select.Select)

@@ -38,45 +19,24 @@ CONFIG_SCHEMA = cv.All(
            DacOutputSelect,
            entity_category=ENTITY_CATEGORY_CONFIG,
            icon=ICON_CHIP,
-        ).extend(
-            {
-                cv.Optional(CONF_INITIAL_OPTION): cv.enum(
-                    DAC_OUTPUT_OPTIONS, upper=True
-                ),
-            }
        ),
        cv.Optional(CONF_ADC_INPUT_MIC): select.select_schema(
            ADCInputMicSelect,
            entity_category=ENTITY_CATEGORY_CONFIG,
            icon=ICON_CHIP,
-        ).extend(
-            {
-                cv.Optional(CONF_INITIAL_OPTION): cv.enum(
-                    ADC_INPUT_MIC_OPTIONS, upper=True
-                ),
-            }
        ),
    }
 )


 async def to_code(config: ConfigType) -> None:
-    cg.add_define("USE_ES8388_SELECT")
    hub = await cg.get_variable(config[CONF_ES8388_ID])
    selects = select.sub_selects(config, parent=hub)
    await selects(
-        CONF_DAC_OUTPUT, hub.set_dac_output_select, options=DAC_OUTPUT_OPTION_NAMES
+        CONF_DAC_OUTPUT, hub.set_dac_output_select, options=["LINE1", "LINE2", "BOTH"]
    )
    await selects(
        CONF_ADC_INPUT_MIC,
        hub.set_adc_input_mic_select,
-        options=ADC_INPUT_MIC_OPTION_NAMES,
+        options=["LINE1", "LINE2", "DIFFERENCE"],
    )
-    if (
-        initial := config.get(CONF_DAC_OUTPUT, {}).get(CONF_INITIAL_OPTION)
-    ) is not None:
-        cg.add(hub.set_dac_output_initial(initial))
-    if (
-        initial := config.get(CONF_ADC_INPUT_MIC, {}).get(CONF_INITIAL_OPTION)
-    ) is not None:
-        cg.add(hub.set_adc_input_mic_initial(initial))
@@ -1,3 +0,0 @@
-CODEOWNERS = ["@GioMez"]
-DEPENDENCIES = ["i2c"]
-DOMAIN = "es9038q2m_katana"
@@ -1,92 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import audio_dac, i2c
-import esphome.config_validation as cv
-from esphome.const import CONF_BITS_PER_SAMPLE, CONF_ID, CONF_SAMPLE_RATE
-from esphome.types import ConfigType
-
-CONF_DEEMPHASIS = "deemphasis"
-CONF_DOP = "dop"
-CONF_FILTER_SHAPE = "filter_shape"
-
-# Fields of the Katana format register: channel layout, word length and rate code.
-FORMAT_STEREO = 0x80
-BITS_PER_SAMPLE_CODES = {16: 0x10, 24: 0x20, 32: 0x30}
-SAMPLE_RATE_CODES = {
-    44100: 0x04,
-    48000: 0x05,
-    88200: 0x06,
-    96000: 0x07,
-    176400: 0x08,
-    192000: 0x09,
-    352800: 0x0A,
-    384000: 0x0B,
-}
-
-es9038q2m_katana_ns = cg.esphome_ns.namespace("es9038q2m_katana")
-ES9038Q2MKatana = es9038q2m_katana_ns.class_(
-    "ES9038Q2MKatana",
-    audio_dac.AudioDac,
-    cg.Component,
-    i2c.I2CDevice,
-)
-
-FilterShape = es9038q2m_katana_ns.enum("FilterShape")
-FILTER_SHAPES = {
-    "linear_phase_fast": FilterShape.FILTER_SHAPE_LINEAR_PHASE_FAST,
-    "linear_phase_slow": FilterShape.FILTER_SHAPE_LINEAR_PHASE_SLOW,
-    "minimum_phase_fast": FilterShape.FILTER_SHAPE_MIN_PHASE_FAST,
-    "minimum_phase_slow": FilterShape.FILTER_SHAPE_MIN_PHASE_SLOW,
-    "apodizing": FilterShape.FILTER_SHAPE_APODIZING,
-    "hybrid": FilterShape.FILTER_SHAPE_HYBRID,
-    "brick_wall": FilterShape.FILTER_SHAPE_BRICK_WALL,
-}
-
-DeemphasisMode = es9038q2m_katana_ns.enum("DeemphasisMode")
-DEEMPHASIS_MODES = {
-    "bypass": DeemphasisMode.DEEMPHASIS_BYPASS,
-    "32khz": DeemphasisMode.DEEMPHASIS_32KHZ,
-    "44_1khz": DeemphasisMode.DEEMPHASIS_44_1KHZ,
-    "48khz": DeemphasisMode.DEEMPHASIS_48KHZ,
-}
-
-CONFIG_SCHEMA = (
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(ES9038Q2MKatana),
-            cv.Optional(CONF_FILTER_SHAPE, default="apodizing"): cv.enum(
-                FILTER_SHAPES, lower=True
-            ),
-            cv.Optional(CONF_BITS_PER_SAMPLE, default="16bit"): cv.All(
-                cv.float_with_unit("bits", "bit"),
-                cv.one_of(*BITS_PER_SAMPLE_CODES, int=True),
-            ),
-            cv.Optional(CONF_SAMPLE_RATE, default=48000): cv.one_of(
-                *SAMPLE_RATE_CODES, int=True
-            ),
-            cv.Optional(CONF_DEEMPHASIS, default="bypass"): cv.enum(
-                DEEMPHASIS_MODES, lower=True
-            ),
-            # Only switches the control logic; the source must already send DoP frames.
-            cv.Optional(CONF_DOP, default=False): cv.boolean,
-        }
-    )
-    .extend(cv.COMPONENT_SCHEMA)
-    .extend(i2c.i2c_device_schema(0x30))
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await i2c.register_i2c_device(var, config)
-
-    cg.add(var.set_filter_shape(config[CONF_FILTER_SHAPE]))
-    cg.add(
-        var.set_format(
-            FORMAT_STEREO
-            | BITS_PER_SAMPLE_CODES[config[CONF_BITS_PER_SAMPLE]]
-            | SAMPLE_RATE_CODES[config[CONF_SAMPLE_RATE]]
-        )
-    )
-    cg.add(var.set_deemphasis_mode(config[CONF_DEEMPHASIS]))
-    cg.add(var.set_dop_enabled(config[CONF_DOP]))
@@ -1,176 +0,0 @@
-#include "es9038q2m_katana.h"
-
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-
-#include <cmath>
-
-namespace esphome::es9038q2m_katana {
-
-ESPHOME_LOG_TAG(TAG, "es9038q2m_katana");
-
-namespace {
-
-constexpr uint8_t KATANA_CHIP_ID = 0x30;
-
-constexpr uint8_t KATANA_REG_CHIP_ID = 0x00;
-constexpr uint8_t KATANA_REG_RESET = 0x01;
-constexpr uint8_t KATANA_REG_VOLUME_1 = 0x02;
-constexpr uint8_t KATANA_REG_VOLUME_2 = 0x03;
-constexpr uint8_t KATANA_REG_MUTE = 0x04;
-constexpr uint8_t KATANA_REG_DSP_PROGRAM = 0x05;
-constexpr uint8_t KATANA_REG_DEEMPHASIS = 0x06;
-constexpr uint8_t KATANA_REG_DOP = 0x07;
-constexpr uint8_t KATANA_REG_FORMAT = 0x08;
-constexpr uint8_t KATANA_REG_COMMAND = 0x09;
-constexpr uint8_t KATANA_REG_MUTE_STREAM = 0x0A;
-
-constexpr float KATANA_VOLUME_MIDPOINT = 0.5f;
-constexpr float KATANA_VOLUME_MIDPOINT_STEPS = 50.0f;  // -25 dB at 50% volume.
-// Cubic amplitude gain: -20 * log10(volume^3) / 0.5 attenuation steps.
-constexpr float KATANA_VOLUME_CUBIC_SCALE = 120.0f;
-constexpr uint8_t KATANA_VOLUME_FULL_ATTENUATION = 255;
-
-// The control logic ignores writes for this long after a reset.
-constexpr uint32_t RESET_SETTLE_DELAY_MS = 10;
-
-const LogString *filter_shape_to_str(FilterShape shape) {
-  switch (shape) {
-    case FILTER_SHAPE_LINEAR_PHASE_FAST:
-      return LOG_STR("linear_phase_fast");
-    case FILTER_SHAPE_LINEAR_PHASE_SLOW:
-      return LOG_STR("linear_phase_slow");
-    case FILTER_SHAPE_MIN_PHASE_FAST:
-      return LOG_STR("minimum_phase_fast");
-    case FILTER_SHAPE_MIN_PHASE_SLOW:
-      return LOG_STR("minimum_phase_slow");
-    case FILTER_SHAPE_APODIZING:
-      return LOG_STR("apodizing");
-    case FILTER_SHAPE_HYBRID:
-      return LOG_STR("hybrid");
-    default:
-      return LOG_STR("brick_wall");
-  }
-}
-
-const LogString *deemphasis_to_str(DeemphasisMode mode) {
-  switch (mode) {
-    case DEEMPHASIS_32KHZ:
-      return LOG_STR("32khz");
-    case DEEMPHASIS_44_1KHZ:
-      return LOG_STR("44_1khz");
-    case DEEMPHASIS_48KHZ:
-      return LOG_STR("48khz");
-    default:
-      return LOG_STR("bypass");
-  }
-}
-
-}  // namespace
-
-void ES9038Q2MKatana::setup() {
-  uint8_t chip_id = 0;
-  if (!this->read_byte(KATANA_REG_CHIP_ID, &chip_id)) {
-    this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
-    return;
-  }
-  if (chip_id != KATANA_CHIP_ID) {
-    ESP_LOGE(TAG, "Unexpected chip ID 0x%02X", chip_id);
-    this->mark_failed(LOG_STR("Unexpected chip ID"));
-    return;
-  }
-  if (!this->write_byte(KATANA_REG_RESET, 0x01)) {
-    this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
-    return;
-  }
-  delay(RESET_SETTLE_DELAY_MS);
-
-  // MUTE_STREAM is the gate the Linux driver closes between streams; ESPHome has no such
-  // notion, so it stays open and mute is only ever driven through MUTE.
-  if (!this->write_byte(KATANA_REG_FORMAT, this->format_) || !this->write_byte(KATANA_REG_COMMAND, 0x00) ||
-      !this->write_byte(KATANA_REG_DSP_PROGRAM, this->filter_shape_) ||
-      !this->write_byte(KATANA_REG_DEEMPHASIS, this->deemphasis_mode_) ||
-      !this->write_byte(KATANA_REG_DOP, this->dop_enabled_ ? 1 : 0) || !this->write_volume_() ||
-      !this->write_byte(KATANA_REG_MUTE, this->is_muted_ ? 1 : 0) || !this->write_byte(KATANA_REG_MUTE_STREAM, 0x00)) {
-    this->mark_failed(LOG_STR("Failed to configure the control logic"));
-  }
-}
-
-void ES9038Q2MKatana::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "ES9038Q2M Katana:\n"
-                "  Filter shape: %s\n"
-                "  De-emphasis: %s\n"
-                "  Format register: 0x%02X\n"
-                "  DoP: %s",
-                LOG_STR_ARG(filter_shape_to_str(this->filter_shape_)),
-                LOG_STR_ARG(deemphasis_to_str(this->deemphasis_mode_)), this->format_, ONOFF(this->dop_enabled_));
-  LOG_I2C_DEVICE(this);
-  if (this->is_failed())
-    return;
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-  for (uint8_t reg = KATANA_REG_CHIP_ID; reg <= KATANA_REG_MUTE_STREAM; reg++) {
-    uint8_t value = 0;
-    if (this->read_byte(reg, &value)) {
-      ESP_LOGV(TAG, "  Register 0x%02X: 0x%02X", reg, value);
-    } else {
-      ESP_LOGV(TAG, "  Register 0x%02X: read failed", reg);
-    }
-  }
-#endif
-}
-
-// Both channel registers follow ESPHome's single master volume.
-bool ES9038Q2MKatana::write_volume_() {
-  return this->write_byte(KATANA_REG_VOLUME_1, this->volume_reg_) &&
-         this->write_byte(KATANA_REG_VOLUME_2, this->volume_reg_);
-}
-
-// Records the outcome of a runtime write; the cached state only changes on success.
-bool ES9038Q2MKatana::check_write_(bool ok) {
-  if (ok) {
-    this->status_clear_warning();
-  } else {
-    this->status_set_warning(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
-  }
-  return ok;
-}
-
-bool ES9038Q2MKatana::set_volume(float volume) {
-  if (this->is_failed())
-    return false;
-  volume = clamp(volume, 0.0f, 1.0f);
-  const uint8_t previous = this->volume_reg_;
-  float attenuation = KATANA_VOLUME_FULL_ATTENUATION;
-  if (volume >= KATANA_VOLUME_MIDPOINT) {
-    attenuation = KATANA_VOLUME_MIDPOINT_STEPS * (1.0f - volume) / (1.0f - KATANA_VOLUME_MIDPOINT);
-  } else if (volume > 0.0f) {
-    attenuation = KATANA_VOLUME_MIDPOINT_STEPS - KATANA_VOLUME_CUBIC_SCALE * log10f(volume / KATANA_VOLUME_MIDPOINT);
-  }
-  this->volume_reg_ =
-      static_cast<uint8_t>(lroundf(clamp(attenuation, 0.0f, static_cast<float>(KATANA_VOLUME_FULL_ATTENUATION))));
-  if (this->check_write_(this->write_volume_()))
-    return true;
-  this->volume_reg_ = previous;
-  return false;
-}
-
-float ES9038Q2MKatana::volume() {
-  if (this->volume_reg_ == KATANA_VOLUME_FULL_ATTENUATION)
-    return 0.0f;
-  if (this->volume_reg_ <= KATANA_VOLUME_MIDPOINT_STEPS)
-    return 1.0f - this->volume_reg_ * (1.0f - KATANA_VOLUME_MIDPOINT) / KATANA_VOLUME_MIDPOINT_STEPS;
-  return KATANA_VOLUME_MIDPOINT *
-         powf(10.0f, (KATANA_VOLUME_MIDPOINT_STEPS - this->volume_reg_) / KATANA_VOLUME_CUBIC_SCALE);
-}
-
-bool ES9038Q2MKatana::set_mute_state_(bool mute_state) {
-  if (this->is_failed())
-    return false;
-  if (!this->check_write_(this->write_byte(KATANA_REG_MUTE, mute_state ? 1 : 0)))
-    return false;
-  this->is_muted_ = mute_state;
-  return true;
-}
-
-}  // namespace esphome::es9038q2m_katana
@@ -1,62 +0,0 @@
-#pragma once
-
-#include "esphome/components/audio_dac/audio_dac.h"
-#include "esphome/components/i2c/i2c.h"
-#include "esphome/core/component.h"
-#include "esphome/core/helpers.h"
-
-namespace esphome::es9038q2m_katana {
-
-// DSP program numbers of the Katana control interface; there is no program 5.
-enum FilterShape : uint8_t {
-  FILTER_SHAPE_LINEAR_PHASE_FAST = 0,
-  FILTER_SHAPE_LINEAR_PHASE_SLOW = 1,
-  FILTER_SHAPE_MIN_PHASE_FAST = 2,
-  FILTER_SHAPE_MIN_PHASE_SLOW = 3,
-  FILTER_SHAPE_APODIZING = 4,
-  FILTER_SHAPE_HYBRID = 6,
-  FILTER_SHAPE_BRICK_WALL = 7,
-};
-
-enum DeemphasisMode : uint8_t {
-  DEEMPHASIS_BYPASS = 0,
-  DEEMPHASIS_32KHZ = 1,
-  DEEMPHASIS_44_1KHZ = 2,
-  DEEMPHASIS_48KHZ = 3,
-};
-
-// Boards that expose an ES9038Q2M through the Allo Katana control logic at I2C address 0x30.
-// Ported from the Linux driver sound/soc/bcm/allo-katana-codec.c; the DAC's own registers
-// are never written, the control logic applies the configuration itself.
-class ES9038Q2MKatana : public audio_dac::AudioDac, public Component, public i2c::I2CDevice {
- public:
-  void setup() override;
-  void dump_config() override;
-
-  // Cubic below 50%, then 0.5 dB per 1% above, meeting at -25 dB.
-  // Zero selects full attenuation (-127.5 dB).
-  bool set_volume(float volume) override;
-  float volume() override;
-  bool set_mute_off() override { return this->set_mute_state_(false); }
-  bool set_mute_on() override { return this->set_mute_state_(true); }
-  bool is_muted() override { return this->is_muted_; }
-
-  void set_filter_shape(FilterShape shape) { this->filter_shape_ = shape; }
-  void set_format(uint8_t format) { this->format_ = format; }
-  void set_deemphasis_mode(DeemphasisMode mode) { this->deemphasis_mode_ = mode; }
-  void set_dop_enabled(bool enabled) { this->dop_enabled_ = enabled; }
-
- protected:
-  bool set_mute_state_(bool mute_state);
-  bool write_volume_();
-  bool check_write_(bool ok);
-
-  FilterShape filter_shape_{FILTER_SHAPE_APODIZING};
-  DeemphasisMode deemphasis_mode_{DEEMPHASIS_BYPASS};
-  uint8_t format_{0};
-  // Attenuation in 0.5 dB steps: 0 is loudest, 255 quietest. Starts 20 dB down.
-  uint8_t volume_reg_{0x28};
-  bool dop_enabled_{false};
-};
-
-}  // namespace esphome::es9038q2m_katana
@@ -243,7 +243,7 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = (
    "esp_coex",  # WiFi/BT coexistence - re-included by esp32_ble_tracker, zigbee; esp_wifi/bt pull it back
    "esp_driver_cam",  # Camera driver - the esp32-camera managed component pulls it back
    "esp_driver_dac",  # DAC driver - only needed by esp32_dac component
-    "esp_driver_gptimer",  # General purpose timer - re-included by ac_dimmer, hdmi_cec, opentherm, Arduino BLE libs
+    "esp_driver_gptimer",  # General purpose timer - re-included by ac_dimmer, opentherm, Arduino BLE libs
    "esp_driver_i2c",  # I2C driver - re-included by i2c; esp32-camera pulls it back itself
    "esp_driver_i2s",  # I2S driver - only needed by i2s_audio component
    "esp_driver_ledc",  # LEDC PWM driver - re-included by ledc; esp32-camera pulls it back itself
@@ -2920,7 +2920,6 @@ async def _finalize_arduino_aware_flags():
    if not arduino_linked:
        cg.add_build_flag("-Wl,--wrap=esp_panic_handler")
        cg.add_define("USE_ESP32_CRASH_HANDLER")
-        cg.add_define("USE_CRASH_HANDLER")
    elif not CORE.using_arduino:
        cg.add_build_flag("-DUSE_ARDUINO")

@@ -161,7 +161,7 @@ static bool s_crash_data_valid = false;  // NOLINT(cppcoreguidelines-avoid-non-c

 namespace esphome::esp32 {

-ESPHOME_LOG_TAG(TAG, CRASH_LOG_TAG);
+ESPHOME_LOG_TAG(TAG, "esp32.crash");

 // RAM copy of the build timestamp. The generated constant lives in flash,
 // which the panic handler must not read (cache may be disabled during
@@ -175,8 +175,7 @@ static uint32_t s_current_build_time = static_cast<uint32_t>(ESPHOME_BUILD_TIME)

 // Validate the NOINIT record. Runs on every has_data() call; re-running is
 // harmless and the magic is left alone so the record survives an OTA
-// rollback reboot, crash_handler_clear() drops it once a log client has it
-// (logger::log_crash_to_client(), for the API and MQTT).
+// rollback reboot, crash_handler_clear() drops it once an API client has it.
 static void read_crash_data() {
  if (s_raw_crash_data.magic == CRASH_MAGIC && s_raw_crash_data.version == CRASH_DATA_VERSION) {
    s_crash_data_valid = true;
@@ -4,9 +4,6 @@

 namespace esphome::esp32 {

-/// The tag the crash record is logged under, so a client can check the level in force for it
-inline constexpr const char *CRASH_LOG_TAG = "esp32.crash";
-
 /// Log crash data if a crash was detected on previous boot.
 void crash_handler_log();

@@ -131,7 +131,6 @@ 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,7 +5,6 @@
 #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>
@@ -29,6 +28,7 @@ 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,9 +77,8 @@ static constexpr uint32_t HOSTED_BT_WDT_TIMEOUT_MS = 60000;

 void ESP32BLE::setup() {
  global_ble = this;
-  // 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");
+  if (!ble_pre_setup_()) {
+    ESP_LOGE(TAG, "BLE could not be prepared for configuration");
    this->mark_failed();
    return;
  }
@@ -186,6 +185,15 @@ 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,6 +185,7 @@ 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,6 +10,7 @@
 #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"
@@ -300,7 +300,7 @@ void BLEClientBase::log_warning_(const char *message) {

 esp_err_t BLEClientBase::update_conn_params_(uint16_t min_interval, uint16_t max_interval, uint16_t latency,
                                             uint16_t timeout, const char *param_type) {
-  esp_ble_conn_update_params_t conn_params = {};
+  esp_ble_conn_update_params_t conn_params = {{0}};
  memcpy(conn_params.bda, this->remote_bda_, sizeof(esp_bd_addr_t));
  conn_params.min_int = min_interval;
  conn_params.max_int = max_interval;
@@ -7,6 +7,7 @@

 #ifdef USE_ESP32

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

 #ifdef USE_OTA
@@ -282,7 +282,7 @@ void ESP32Camera::loop() {
  }
  this->frame_count_++;
  if (now - this->last_log_time_ >= FRAME_LOG_INTERVAL_MS) {
-    ESP_LOGD(TAG, "Received %u images in last %" PRIu32 "s", this->frame_count_, FRAME_LOG_INTERVAL_MS / 1000);
+    ESP_LOGD(TAG, "Received %u images in last %us", this->frame_count_, FRAME_LOG_INTERVAL_MS / 1000);
    this->last_log_time_ = now;
    this->frame_count_ = 0;
  }
@@ -6,8 +6,6 @@ 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,
@@ -22,8 +20,6 @@ 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,
@@ -31,7 +27,6 @@ from esphome.const import (
    CONF_TX_PIN,
    CONF_TX_QUEUE_LEN,
 )
-import esphome.final_validate as fv
 from esphome.types import ConfigType

 CODEOWNERS = ["@Sympatron"]
@@ -47,7 +42,6 @@ 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
@@ -55,7 +49,6 @@ 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,
@@ -121,22 +114,6 @@ 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,10 +33,6 @@ 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;
@@ -79,13 +75,10 @@ bool ESP32Can::setup_internal() {
  }

  // Select TWAI mode based on configuration
-  twai_mode_t twai_mode = TWAI_MODE_NORMAL;
+  twai_mode_t twai_mode = (this->mode_ == CAN_MODE_LISTEN_ONLY) ? TWAI_MODE_LISTEN_ONLY : 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,7 +12,6 @@ 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 {
@@ -42,7 +42,6 @@ extern "C" {
 }

 #include "esp_now_hosted_rpc.h"
-#include "esphome/core/log.h"

 namespace {

@@ -53,8 +52,6 @@ ESPHOME_LOG_TAG(TAG, "esp_now_hosted");
 // single esp-hosted RPC RX thread. Serializing requests keeps the shared
 // response slot race-free; a sequence number stops a late/stale response from
 // being mistaken for ours.
-// NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables): the shim is
-// C-ABI state shared between the main loop and the esp-hosted RX thread.
 SemaphoreHandle_t g_req_mutex = nullptr;
 SemaphoreHandle_t g_resp_sem = nullptr;  // given when the matching RESP lands
 bool g_setup_done = false;               // set only after setup fully succeeds
@@ -88,7 +85,6 @@ constexpr size_t ESP_NOW_HOSTED_MAX_PEERS = 20;
 uint8_t g_peer_cache[ESP_NOW_HOSTED_MAX_PEERS][6];
 size_t g_peer_count = 0;
 portMUX_TYPE g_peer_lock = portMUX_INITIALIZER_UNLOCKED;
-// NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables)

 // Caller must hold g_peer_lock.
 int peer_cache_find_locked(const uint8_t *mac) {
@@ -235,14 +231,12 @@ esp_err_t ensure_setup() {
    g_resp_sem = xSemaphoreCreateBinary();
  if (g_req_mutex == nullptr || g_resp_sem == nullptr)
    return ESP_ERR_NO_MEM;
-  esp_err_t err = esp_hosted_register_custom_callback(ESP_NOW_HOSTED_MSG_RESP, on_resp, nullptr);
-  if (err != ESP_OK)
+  esp_err_t err;
+  if ((err = esp_hosted_register_custom_callback(ESP_NOW_HOSTED_MSG_RESP, on_resp, nullptr)) != ESP_OK)
    return err;
-  err = esp_hosted_register_custom_callback(ESP_NOW_HOSTED_MSG_RECV, on_recv, nullptr);
-  if (err != ESP_OK)
+  if ((err = esp_hosted_register_custom_callback(ESP_NOW_HOSTED_MSG_RECV, on_recv, nullptr)) != ESP_OK)
    return err;
-  err = esp_hosted_register_custom_callback(ESP_NOW_HOSTED_MSG_SEND, on_send, nullptr);
-  if (err != ESP_OK)
+  if ((err = esp_hosted_register_custom_callback(ESP_NOW_HOSTED_MSG_SEND, on_send, nullptr)) != ESP_OK)
    return err;
  g_setup_done = true;
  return ESP_OK;
@@ -428,11 +422,10 @@ esp_err_t esp_now_send(const uint8_t *peer_addr, const uint8_t *data, size_t len
  uint8_t hdr[sizeof(esp_now_hosted_send_req_t)];
  auto *s = reinterpret_cast<esp_now_hosted_send_req_t *>(hdr);
  s->has_addr = peer_addr != nullptr ? 1 : 0;
-  if (peer_addr != nullptr) {
+  if (peer_addr != nullptr)
    memcpy(s->peer_addr, peer_addr, 6);
-  } else {
+  else
    memset(s->peer_addr, 0, 6);
-  }
  s->data_len = static_cast<uint16_t>(len);
  // Fire-and-forget (wait=false): native esp_now_send returns once the frame is
  // queued, with the real TX result delivered later through the send callback.
@@ -53,14 +53,10 @@ from .const import (
    KEY_SERIAL1_REQUIRED,
    KEY_SERIAL_REQUIRED,
    KEY_WAVEFORM_REQUIRED,
-    PREFERENCES_RTC_EBOOT_WORDS,
-    PREFERENCES_RTC_NORMAL_WORDS,
    THROW_STUBS_HEADER,
-    check_preferences_fit,
    enable_serial,
    enable_serial1,
    esp8266_ns,
-    preferences_flash_words,
 )
 from .gpio import PinInitialState, add_pin_initial_states_array

@@ -420,7 +416,6 @@ async def to_code(config: ConfigType) -> None:
    cg.add_define("ESPHOME_VARIANT", "ESP8266")
    cg.add_define(ThreadModel.SINGLE)
    cg.add_define("USE_ESP8266_CRASH_HANDLER")
-    cg.add_define("USE_CRASH_HANDLER")

    enable_scanf_float = config.get(CONF_ENABLE_SCANF_FLOAT)
    if enable_scanf_float is None and lambdas_use_scanf_float(CORE.config):
@@ -472,12 +467,6 @@ async def to_code(config: ConfigType) -> None:
    # Other projects like Tasmota & ESPEasy also use this
    cg.add_build_flag("-DPIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH_LOW_FLASH")

-    cg.add_define("ESP8266_PREFERENCES_RTC_NORMAL_WORDS", PREFERENCES_RTC_NORMAL_WORDS)
-    cg.add_define("ESP8266_PREFERENCES_RTC_EBOOT_WORDS", PREFERENCES_RTC_EBOOT_WORDS)
-    cg.add_define(
-        "ESP8266_PREFERENCES_FLASH_WORDS",
-        preferences_flash_words(config[CONF_RESTORE_FROM_FLASH]),
-    )
    if config[CONF_RESTORE_FROM_FLASH]:
        cg.add_define("USE_ESP8266_PREFERENCES_FLASH")

@@ -539,7 +528,6 @@ async def to_code(config: ConfigType) -> None:
    CORE.add_job(add_pin_initial_states_array)
    CORE.add_job(finalize_waveform_config)
    CORE.add_job(finalize_serial_config)
-    CORE.add_job(check_preferences_fit)


@coroutine_with_priority(CoroPriority.WORKAROUNDS)
@@ -1,13 +1,9 @@
-import logging
-
 import esphome.codegen as cg

 # Re-exported from the shared definition; here it indexes the BOARDS
 # metadata dicts, whose entries in boards.py spell the literal.
 from esphome.const import KEY_FLASH_SIZE  # noqa: F401  # pylint: disable=unused-import
-from esphome.core import CORE, CoroPriority, EsphomeError, coroutine_with_priority
-
-_LOGGER = logging.getLogger(__name__)
+from esphome.core import CORE

 KEY_ESP8266 = "esp8266"
 KEY_BOARD = "board"
@@ -28,87 +24,6 @@ KEY_LDSCRIPT = "ldscript"
 # Crash-decode tools, resolved once per run by __init__
 KEY_DECODE_TOOLS = "decode_tools"

-# Saved-settings space in 4-byte words; preferences.cpp gets these as defines. A value cannot span the two
-# RTC regions, and the flash store is smaller when only explicit flash preferences use it.
-PREFERENCES_RTC_NORMAL_WORDS = 78
-PREFERENCES_RTC_EBOOT_WORDS = 32
-PREFERENCES_RTC_WORDS = PREFERENCES_RTC_NORMAL_WORDS + PREFERENCES_RTC_EBOOT_WORDS
-PREFERENCES_FLASH_WORDS = 128
-PREFERENCES_FLASH_WORDS_WITHOUT_RESTORE = 64
-KEY_PREFERENCES = "preferences"
-
-
-def preferences_flash_words(restore_from_flash: bool) -> int:
-    """Size of the flash store for this configuration."""
-    return (
-        PREFERENCES_FLASH_WORDS
-        if restore_from_flash
-        else PREFERENCES_FLASH_WORDS_WITHOUT_RESTORE
-    )
-
-
-def preference_words(value_bytes: int) -> int:
-    """Words a saved value takes, checksum word included (rtc_pref_bytes_to_words plus one)."""
-    return (value_bytes + 3) // 4 + 1
-
-
-def reserve_preferences(
-    count: int, value_bytes: int, in_flash: bool | None = None
-) -> None:
-    """Record saved values a component creates; check_preferences_fit() adds them all up.
-
-    in_flash is the value's own storage, as passed to make_preference(); None is the two-argument
-    form, which follows restore_from_flash.
-    """
-    if in_flash is None:
-        in_flash = CORE.config[KEY_ESP8266][CONF_RESTORE_FROM_FLASH]
-    reservations = CORE.data.setdefault(KEY_ESP8266, {}).setdefault(KEY_PREFERENCES, [])
-    reservations.extend([(preference_words(value_bytes), in_flash)] * count)
-
-
-def _rtc_values_can_split(values: list[int]) -> bool:
-    """Whether some order fills the two RTC regions without a value spanning them."""
-    total = sum(values)
-    if total <= PREFERENCES_RTC_NORMAL_WORDS:
-        return True
-    # Bit i of reachable is set when some subset of the values sums to i
-    reachable = 1
-    for words in values:
-        reachable |= reachable << words
-    lowest = max(0, total - PREFERENCES_RTC_EBOOT_WORDS)
-    highest = min(total, PREFERENCES_RTC_NORMAL_WORDS)
-    return any(reachable >> normal & 1 for normal in range(lowest, highest + 1))
-
-
-@coroutine_with_priority(CoroPriority.FINAL)
-async def check_preferences_fit() -> None:
-    """Fail the build when the reserved saved values cannot fit the space preferences.cpp has."""
-    flash_store = preferences_flash_words(
-        CORE.config[KEY_ESP8266][CONF_RESTORE_FROM_FLASH]
-    )
-    reservations = CORE.data[KEY_ESP8266].get(KEY_PREFERENCES, [])
-    flash_words = sum(w for w, in_flash in reservations if in_flash)
-    rtc_values = [w for w, in_flash in reservations if not in_flash]
-    if flash_words > flash_store:
-        raise EsphomeError(
-            f"Saved values need {flash_words} words but the ESP8266 flash store has {flash_store}; "
-            "use fewer or smaller saved values"
-        )
-    if not _rtc_values_can_split(rtc_values):
-        raise EsphomeError(
-            f"Saved values need {sum(rtc_values)} words but ESP8266 RTC memory has {PREFERENCES_RTC_WORDS} in "
-            f"regions of {PREFERENCES_RTC_NORMAL_WORDS} and {PREFERENCES_RTC_EBOOT_WORDS} that a value cannot "
-            "span; use fewer or smaller saved values, or store them in flash"
-        )
-    if sum(rtc_values) > PREFERENCES_RTC_NORMAL_WORDS:
-        _LOGGER.warning(
-            "Saved values reserve %d of %d words of ESP8266 RTC memory; the fit depends on setup order, and "
-            "saved settings that do not reserve are not counted",
-            sum(rtc_values),
-            PREFERENCES_RTC_WORDS,
-        )
-
-
 # esp8266 namespace is already defined by arduino, manually prefix esphome
 esp8266_ns = cg.global_ns.namespace("esphome").namespace("esp8266")

@@ -4,7 +4,6 @@
 #ifdef USE_ESP8266_CRASH_HANDLER

 #include "crash_handler.h"
-#include "rtc_layout.h"
 #include "esphome/core/log.h"

 #include <cinttypes>
@@ -47,8 +46,11 @@ static inline bool IRAM_ATTR is_code_addr(uint32_t val) {
 // Recover the actual code address from a windowed-ABI return address on the stack.
 static inline uint32_t IRAM_ATTR recover_code_addr(uint32_t val) { return (val & XTENSA_ADDR_MASK) | XTENSA_CODE_BASE; }

-// Crash data lives in the last esphome::esp8266::RTC_CRASH_WORDS of user RTC memory (rtc_layout.h).
+// RTC user memory layout for crash backtrace data.
+// User-accessible RTC memory: blocks 64-191 (each block = 4 bytes).
+// We use blocks 174-191 (last 18 blocks, 72 bytes) to minimize conflicts.
 // Store 16 raw candidates, filter to real return addresses at log time.
+static constexpr uint8_t RTC_CRASH_BASE = 174;
 static constexpr size_t MAX_BACKTRACE = 16;

 // Magic word packs sentinel, version, and count into one uint32_t:
@@ -76,7 +78,7 @@ struct RtcCrashData {
  uint32_t backtrace[MAX_BACKTRACE];
  uint32_t epc1;  // Fault PC, used to filter duplicates
 };
-static_assert(sizeof(RtcCrashData) == esphome::esp8266::RTC_CRASH_WORDS * 4, "RtcCrashData must fill its RTC words");
+static_assert(sizeof(RtcCrashData) == 72, "RtcCrashData must fit in 18 RTC blocks");

 namespace esphome::esp8266 {

@@ -127,7 +129,7 @@ static const LogString *get_reset_reason(uint32_t reason) {
 // Returns the number of valid backtrace entries (0 if no data found).
 static uint8_t read_rtc_backtrace(uint32_t *backtrace, size_t max_entries) {
  RtcCrashData rtc_data;
-  if (!system_rtc_mem_read(esphome::esp8266::RTC_CRASH_BASE, &rtc_data, sizeof(rtc_data)))
+  if (!system_rtc_mem_read(RTC_CRASH_BASE, &rtc_data, sizeof(rtc_data)))
    return 0;
  uint32_t magic = rtc_data.magic;
  if ((magic & CRASH_SENTINEL_MASK) != CRASH_SENTINEL || (magic & CRASH_VERSION_MASK) != CRASH_VERSION)
@@ -231,7 +233,7 @@ extern "C" void IRAM_ATTR custom_crash_callback(struct rst_info *rst_info, uint3
  data.epc1 = epc1;
  data.magic = CRASH_SENTINEL | CRASH_VERSION | count;

-  system_rtc_mem_write(esphome::esp8266::RTC_CRASH_BASE, &data, sizeof(data));
+  system_rtc_mem_write(RTC_CRASH_BASE, &data, sizeof(data));
 }

 #endif  // USE_ESP8266_CRASH_HANDLER
@@ -6,7 +6,6 @@ extern "C" {
 }

 #include "preferences.h"
-#include "rtc_layout.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/preferences_rtc.h"
@@ -18,26 +17,31 @@ namespace esphome::esp8266 {
 ESPHOME_LOG_TAG(TAG, "preferences");

 static constexpr uint32_t ESP_RTC_USER_MEM_START = 0x60001200;
-static constexpr uint32_t ESP_RTC_USER_MEM_SIZE_WORDS = RTC_USER_MEM_WORDS;
+static constexpr uint32_t ESP_RTC_USER_MEM_SIZE_WORDS = 128;
 static constexpr uint32_t ESP_RTC_USER_MEM_SIZE_BYTES = ESP_RTC_USER_MEM_SIZE_WORDS * 4;

-// RTC memory layout (sizes come from const.py through codegen):
+// RTC memory layout:
 // - Eboot region:  RTC words 0-31   (reserved, mapped from preference offset 78-109)
 // - Normal region: RTC words 32-109 (mapped from preference offset 0-77)
 // - Crash handler: RTC words 110-127 (reserved for crash_handler.cpp backtrace data)
-static constexpr uint32_t RTC_EBOOT_REGION_WORDS = ESP8266_PREFERENCES_RTC_EBOOT_WORDS;
-static constexpr uint32_t RTC_NORMAL_REGION_WORDS = ESP8266_PREFERENCES_RTC_NORMAL_WORDS;
+static constexpr uint32_t RTC_EBOOT_REGION_WORDS = 32;   // Words 0-31 reserved for eboot
+static constexpr uint32_t RTC_NORMAL_REGION_WORDS = 78;  // Words 32-109 for normal prefs
 static constexpr uint32_t PREF_TOTAL_WORDS = RTC_EBOOT_REGION_WORDS + RTC_NORMAL_REGION_WORDS;  // 110
-static_assert(PREF_TOTAL_WORDS <= RTC_CRASH_BASE - RTC_SYSTEM_USER_BASE,
-              "preference regions overlap the crash handler's RTC words");

 // Maximum preference size in words (limited by uint8_t length_words field)
 static constexpr uint32_t MAX_PREFERENCE_WORDS = 255;

 #define ESP_RTC_USER_MEM ((uint32_t *) ESP_RTC_USER_MEM_START)

-// Smaller without restore_from_flash, when only explicit flash preferences live here
-static constexpr uint32_t ESP8266_FLASH_STORAGE_SIZE = ESP8266_PREFERENCES_FLASH_WORDS;
+// Flash storage size depends on esp8266 -> restore_from_flash YAML option (default: false).
+// When enabled (USE_ESP8266_PREFERENCES_FLASH), all preferences default to flash and need
+// 128 words (512 bytes). When disabled, only explicit flash prefs use this storage so
+// 64 words (256 bytes) suffices since most preferences go to RTC memory instead.
+#ifdef USE_ESP8266_PREFERENCES_FLASH
+static constexpr uint32_t ESP8266_FLASH_STORAGE_SIZE = 128;
+#else
+static constexpr uint32_t ESP8266_FLASH_STORAGE_SIZE = 64;
+#endif

 static uint32_t
    s_flash_storage[ESP8266_FLASH_STORAGE_SIZE];  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -56,7 +60,7 @@ static inline bool esp_rtc_user_mem_write(uint32_t index, uint32_t value) {
  if (index >= ESP_RTC_USER_MEM_SIZE_WORDS) {
    return false;
  }
-  if (index < RTC_EBOOT_REGION_WORDS && s_prevent_write) {
+  if (index < 32 && s_prevent_write) {
    return false;
  }

@@ -119,7 +123,7 @@ static bool load_from_rtc(size_t offset, uint32_t *data, size_t len) {

 // Maximum buffer for any single preference - bounded by storage sizes.
 // Flash prefs: bounded by ESP8266_FLASH_STORAGE_SIZE (128 or 64 words).
-// RTC prefs: bounded by RTC_NORMAL_REGION_WORDS (78) - a single pref can't span both RTC regions.
+// RTC prefs: bounded by RTC_NORMAL_REGION_WORDS (96) - a single pref can't span both RTC regions.
 static constexpr size_t PREF_MAX_BUFFER_WORDS =
    ESP8266_FLASH_STORAGE_SIZE > RTC_NORMAL_REGION_WORDS ? ESP8266_FLASH_STORAGE_SIZE : RTC_NORMAL_REGION_WORDS;

@@ -176,8 +180,8 @@ ESPPreferenceObject ESP8266Preferences::make_preference(size_t length, uint32_t
  } else {
    uint32_t start = this->current_offset;
    bool in_normal = start < RTC_NORMAL_REGION_WORDS;
-    // Normal: offset 0-77 maps to RTC offset 32-109
-    // Eboot: offset 78-109 maps to RTC offset 0-31
+    // Normal: offset 0-95 maps to RTC offset 32-127
+    // Eboot: offset 96-127 maps to RTC offset 0-31
    if (in_normal && start + total_words > RTC_NORMAL_REGION_WORDS) {
      // start is in normal but end is not -> switch to Eboot
      this->current_offset = start = RTC_NORMAL_REGION_WORDS;
@@ -1,18 +0,0 @@
-#pragma once
-
-#ifdef USE_ESP8266
-
-#include <cstdint>
-
-namespace esphome::esp8266 {
-
-// User RTC memory is system blocks 64-191, one 4-byte word each. preferences.cpp owns the first
-// words, crash_handler.cpp the last; const.py hands preferences.cpp its region sizes.
-static constexpr uint32_t RTC_SYSTEM_USER_BASE = 64;
-static constexpr uint32_t RTC_USER_MEM_WORDS = 128;
-static constexpr uint32_t RTC_CRASH_WORDS = 18;
-static constexpr uint32_t RTC_CRASH_BASE = RTC_SYSTEM_USER_BASE + RTC_USER_MEM_WORDS - RTC_CRASH_WORDS;
-
-}  // namespace esphome::esp8266
-
-#endif  // USE_ESP8266
@@ -44,14 +44,11 @@ const noise::NoiseContext &ESPHomeOTAComponent::noise_context_() const {
 }
 #endif
 static constexpr uint16_t OTA_BLOCK_SIZE = 8192;
-static constexpr uint32_t OTA_SOCKET_TIMEOUT_HANDSHAKE = 60000;  // milliseconds for initial handshake
+static constexpr uint32_t OTA_SOCKET_TIMEOUT_HANDSHAKE = 20000;  // milliseconds for initial handshake
 // Milliseconds for data transfer. Covers the lwIP retransmit run seen in
 // practice for a lost chunk ack (1.5 + 3 + 6 + 12 + 24 + 48 s); the CLI waits
 // longer (espota2.DATA_PHASE_TIMEOUT) so the device is free before it retries
 static constexpr uint32_t OTA_SOCKET_TIMEOUT_DATA = 105000;
-// A handshake this old gives way to a waiting connection: a client retrying over a lossy link otherwise queues
-// behind its own stalled attempt until both time out
-static constexpr uint32_t OTA_HANDSHAKE_PREEMPT = 10000;
 static constexpr uint32_t OTA_PROGRESS_INTERVAL_MS = 1000;
 static constexpr size_t OTA_SIZE_FIELD_BYTES = 4;  // sizes on the wire are 4 bytes MSB first

@@ -202,9 +199,6 @@ static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_SHA256_AUTH = 0x02;
 static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL = 0x04;
 static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_NOISE = 0x08;
 static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_DEFLATE = 0x10;
-#ifdef ESPHOME_OTA_UDP
-static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_UDP = 0x20;
-#endif
 // Noise needs the extended protocol: the prologue binds the 2-byte feature ack
 static constexpr uint8_t CLIENT_NOISE_FEATURES =
    CLIENT_FEATURE_SUPPORTS_NOISE | CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL;
@@ -214,10 +208,6 @@ static constexpr uint8_t SERVER_FEATURE_SUPPORTS_NOISE = 0x04;
 // Raw deflate, window <= OTA_INFLATE_WINDOW_SIZE. Binding once offered: the
 // client must then send the image size frame and a deflate stream.
 static constexpr uint8_t SERVER_FEATURE_SUPPORTS_DEFLATE = 0x08;
-#ifdef ESPHOME_OTA_UDP
-static constexpr uint8_t SERVER_FEATURE_SUPPORTS_UDP = 0x10;
-static constexpr uint8_t UDP_REQUEST_V1 = 0x01;  // espota2.UDP_REQUEST
-#endif

 #ifdef USE_OTA_ENCRYPTION
 inline bool ESPHomeOTAComponent::noise_offered_() const {
@@ -276,12 +266,6 @@ void ESPHomeOTAComponent::handle_handshake_() {
    this->cleanup_connection_();
    return;
  }
-  // Only unauthenticated handshakes reach here; the data phase blocks inside handle_data_
-  if (now - this->client_connect_time_ > OTA_HANDSHAKE_PREEMPT && this->server_->ready()) {
-    ESP_LOGD(TAG, "Newer connection waiting");
-    this->cleanup_connection_();
-    return;
-  }

  switch (this->ota_state_) {
    case OTAState::MAGIC_READ: {
@@ -345,9 +329,6 @@ void ESPHomeOTAComponent::handle_handshake_() {
        static_assert(HANDSHAKE_BUF_SIZE >= 2, "handshake_buf_ must hold the 2-byte extended-protocol feature ack");
        this->handshake_buf_[0] = ota::OTA_RESPONSE_FEATURE_FLAGS;
        this->handshake_buf_[1] = (supports_compression ? SERVER_FEATURE_SUPPORTS_COMPRESSION : 0);
-#ifdef ESPHOME_OTA_UDP
-        this->handshake_buf_[1] |= SERVER_FEATURE_SUPPORTS_UDP;
-#endif
 #ifdef USE_OTA_PARTITIONS
        this->handshake_buf_[1] |= SERVER_FEATURE_SUPPORTS_PARTITION_ACCESS;
 #endif
@@ -502,10 +483,6 @@ void ESPHomeOTAComponent::handle_data_() {
  char *sbuf = reinterpret_cast<char *>(buf);
  size_t image_size;
  ota::OTAType ota_type = ota::OTA_TYPE_UPDATE_APP;
-#ifdef ESPHOME_OTA_UDP
-  UdpLink udp_link;
-  this->udp_ = nullptr;  // client_connect_time_ is done with
-#endif

  // Set socket timeouts and blocking mode (see strategy table above)
  struct timeval tv;
@@ -521,38 +498,6 @@ void ESPHomeOTAComponent::handle_data_() {
  // Acknowledge auth OK - 1 byte
  this->data_write_byte_(ota::OTA_RESPONSE_AUTH_OK);

-#ifdef ESPHOME_OTA_UDP
-  // The server always offers UDP on the extended protocol
-  if (this->extended_proto_() && (this->ota_features_ & CLIENT_FEATURE_SUPPORTS_UDP) != 0) {
-    // Whether the client wants UDP (0: its link looks good), answered with our token
-    if (!this->data_readall_(buf, 1)) {
-      if (this->client_left_before_start_())
-        return;
-      this->log_read_error_(LOG_STR("UDP request"));
-      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
-    }
-    // 1 is this UDP format; other values are free for later ones, which we decline (a zero reply keeps TCP)
-    if (buf[0] == UDP_REQUEST_V1) {
-      this->udp_open_(udp_link);
-      if (udp_link.reply[0] == 0) {
-        ESP_LOGW(TAG, "UDP unavailable, using TCP");
-      }
-    }
-    if (!this->data_write_(udp_link.reply, sizeof(udp_link.reply)))
-      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
-    if (udp_link.reply[0] != 0) {
-      this->udp_ = &udp_link;
-      if (!this->udp_start_()) {
-        // Nothing started yet: just drop the session, which the client retries as a network failure
-        this->log_read_error_(LOG_STR("UDP start"));
-        this->cleanup_connection_();
-        return;
-      }
-    }
-  }
-
-#endif
-
  if (this->extended_proto_()) {
    // Read ota type, 1 byte
    if (!this->data_readall_(buf, 1)) {
@@ -653,17 +598,11 @@ void ESPHomeOTAComponent::handle_data_() {
  // Acknowledge Update end OK - 1 byte
  this->data_write_byte_(ota::OTA_RESPONSE_UPDATE_END_OK);

-#ifdef ESPHOME_OTA_UDP
-  // UDP never reports a close: wait only until the client has our responses, not for its final ack
-  if (this->udp_ != nullptr) {
-    this->udp_linger_();
-  } else
-#endif
-    // Read ACK
-    if (!this->data_readall_(buf, 1) || buf[0] != ota::OTA_RESPONSE_OK) {
-      this->log_read_error_(LOG_STR("ack"));
-      // do not go to error, this is not fatal
-    }
+  // Read ACK
+  if (!this->data_readall_(buf, 1) || buf[0] != ota::OTA_RESPONSE_OK) {
+    this->log_read_error_(LOG_STR("ack"));
+    // do not go to error, this is not fatal
+  }

  this->cleanup_connection_();
  delay(10);
@@ -684,9 +623,6 @@ void ESPHomeOTAComponent::handle_data_() {

 error:
  this->data_write_byte_(static_cast<uint8_t>(error_code));
-#ifdef ESPHOME_OTA_UDP
-  this->udp_linger_();
-#endif

  // Abort backend before cleanup - cleanup_connection_() destroys the backend.
  // Always call abort() unconditionally: backends register external partitions before
@@ -715,7 +651,7 @@ bool ESPHomeOTAComponent::readall_(uint8_t *buf, size_t len) {
      return false;
    }

-    ssize_t read = this->transport_read_(buf + at, len - at);
+    ssize_t read = this->client_->read(buf + at, len - at);
    if (read == -1) {
      const int err = errno;
      if (!this->would_block_(err)) {
@@ -740,10 +676,6 @@ bool ESPHomeOTAComponent::readall_(uint8_t *buf, size_t len) {
  return true;
 }
 bool ESPHomeOTAComponent::writeall_(const uint8_t *buf, size_t len) {
-#ifdef ESPHOME_OTA_UDP
-  if (this->udp_ != nullptr)
-    return this->udp_send_(buf, len);
-#endif
  uint32_t start = millis();
  uint32_t at = 0;
  while (len - at > 0) {
@@ -796,20 +728,7 @@ void ESPHomeOTAComponent::log_read_error_(const LogString *what) {

 void ESPHomeOTAComponent::log_start_(const LogString *phase) {
  char peername[socket::SOCKADDR_STR_LEN];
-#ifdef ESPHOME_OTA_UDP
-  if (this->client_ == nullptr) {
-    // A committed UDP session has already dropped TCP
-#ifdef ESPHOME_OTA_UDP_LWIP
-    ipaddr_ntoa_r(&this->udp_->peer_ip, peername, sizeof(peername));
-#else
-    socket::format_sockaddr_to(reinterpret_cast<const struct sockaddr *>(&this->udp_->peer), this->udp_->peer_len,
-                               peername);
-#endif
-  } else
-#endif
-  {
-    this->client_->getpeername_to(peername);
-  }
+  this->client_->getpeername_to(peername);
  ESP_LOGD(TAG, "Starting %s from %s", LOG_STR_ARG(phase), peername);
 }

@@ -921,7 +840,7 @@ ssize_t ESPHomeOTAComponent::receive_data_(uint8_t *buf, DataTransfer &xfer) {
      break;
    }
 #endif
-    read = this->transport_read_(buf, requested);
+    read = this->client_->read(buf, requested);
    if (read > 0)
      break;
    if (read == 0) {
@@ -955,11 +874,6 @@ ssize_t ESPHomeOTAComponent::receive_data_(uint8_t *buf, DataTransfer &xfer) {

 void ESPHomeOTAComponent::send_chunk_acks_(DataTransfer &xfer) {
 #if USE_OTA_VERSION == 2
-#ifdef ESPHOME_OTA_UDP
-  // UDP acks every message itself
-  if (this->udp_ != nullptr)
-    return;
-#endif
  while (xfer.acknowledged + OTA_BLOCK_SIZE <= xfer.total ||
         (xfer.total == xfer.ota_size && xfer.acknowledged < xfer.ota_size)) {
    this->data_write_byte_(ota::OTA_RESPONSE_CHUNK_OK);
@@ -969,12 +883,7 @@ void ESPHomeOTAComponent::send_chunk_acks_(DataTransfer &xfer) {
 }

 void ESPHomeOTAComponent::cleanup_connection_() {
-#ifdef ESPHOME_OTA_UDP
-  this->udp_ = nullptr;  // the link itself lives on handle_data_'s stack
-#endif
-  // Already gone once a UDP session committed
-  if (this->client_ != nullptr)
-    this->client_->close();
+  this->client_->close();
  this->client_ = nullptr;
  this->client_connect_time_ = 0;
  this->handshake_buf_pos_ = 0;
@@ -15,25 +15,6 @@
 #include "esphome/core/preferences.h"
 #include "esphome/core/hash_base.h"

-// UDP data phase: raw lwIP needs a main loop lock (or a single thread); the host polls a socket instead
-#ifdef USE_ESP32
-#include <sdkconfig.h>
-#endif
-#if defined(USE_ESP8266) || defined(USE_RP2) || defined(USE_LIBRETINY) || \
-    (defined(USE_ESP32) && defined(CONFIG_LWIP_TCPIP_CORE_LOCKING))
-#define ESPHOME_OTA_UDP
-#define ESPHOME_OTA_UDP_LWIP
-#include "lwip/ip_addr.h"
-#include "lwip/pbuf.h"
-#include "lwip/udp.h"
-#if defined(USE_LIBRETINY) && !LWIP_TCPIP_CORE_LOCKING
-#undef ESPHOME_OTA_UDP
-#undef ESPHOME_OTA_UDP_LWIP
-#endif
-#elif defined(USE_HOST)
-#define ESPHOME_OTA_UDP
-#endif
-
 namespace esphome {

 /// ESPHomeOTAComponent provides a simple way to integrate Over-the-Air updates into your app using ArduinoOTA.
@@ -84,69 +65,6 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
 protected:
  void handle_handshake_();
  void handle_data_();
-
-#ifdef ESPHOME_OTA_UDP
-  // UDP transport for the data phase; wire format in ota_esphome_udp.cpp
-  static constexpr size_t UDP_OUT_SIZE = 64;  // our unacked responses: at most three encrypted ones
-  // Messages the device keeps unread: like TCP's 4 segment window, so no more memory than TCP holds
-  static constexpr uint8_t UDP_WINDOW = 4;
-#ifdef ESPHOME_OTA_UDP_LWIP
-  using UdpSlot = struct pbuf *;
-#else
-  using UdpSlot = struct OtaUdpDatagram *;
-#endif
-  // Lives on handle_data_'s stack; the receive callback shares it under the lwIP lock
-  struct UdpLink {
-    ~UdpLink();
-    void release();  // closes the socket and frees what is queued
-#ifdef ESPHOME_OTA_UDP_LWIP
-    struct udp_pcb *pcb{nullptr};
-    ip_addr_t peer_ip;
-#else
-    std::unique_ptr<socket::Socket> sock;
-    struct sockaddr_storage peer;  // the TCP peer; its port is replaced by peer_port
-    socklen_t peer_len{0};
-#endif
-    uint16_t peer_port{0};  // learned from the client's datagrams
-    // The session token, our answer to the client: top bit clear, so never an error code; all zero declines
-    uint8_t reply[4]{};
-    UdpSlot queue[UDP_WINDOW]{};  // slot seq % UDP_WINDOW for seq in [consumed, consumed + UDP_WINDOW)
-    uint16_t received{0};         // every seq before it is here
-    uint16_t consumed{0};         // the message being read
-    uint16_t read_offset{0};      // payload bytes of it already read
-    uint16_t out_base{0};         // stream offset of out[0]
-    uint8_t out_len{0};
-    bool committed{false};  // the client heard us over UDP
-    uint8_t out[UDP_OUT_SIZE];
-  };
-  // Fills link.reply on success; leaves it all zero (declined) otherwise
-  void udp_open_(UdpLink &link);
-  // Waits for the client to commit to UDP or fall back to TCP; false on failure
-  bool udp_start_();
-  // Like a blocking socket read with SO_RCVTIMEO: up to len bytes, or -1 with EWOULDBLOCK
-  ssize_t udp_read_(uint8_t *buf, size_t len);
-  bool udp_send_(const uint8_t *data, size_t len);
-  // In a UDP session, keeps answering until the client has our responses (an error code), briefly
-  void udp_linger_();
-  // A datagram from the client's IP; caller holds the lwIP lock (or runs in the receive callback)
-  static void udp_on_datagram(UdpLink &link, UdpSlot p, uint16_t port);
-  // Caller holds the lwIP lock (or runs in the receive callback)
-  static void udp_send_ack(UdpLink &link, uint16_t prompted_by);
-#ifdef ESPHOME_OTA_UDP_LWIP
-  static void udp_recv_cb(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, uint16_t port);
-  void udp_poll_() {}
-#else
-  void udp_poll_();  // hands what the socket received to udp_on_datagram
-#endif
-#endif
-  // Data phase only (udp_ shares storage with the handshake's connect time): TCP or, once committed, the UDP stream
-  inline ssize_t transport_read_(uint8_t *buf, size_t len) {
-#ifdef ESPHOME_OTA_UDP
-    if (this->udp_ != nullptr)
-      return this->udp_read_(buf, len);
-#endif
-    return this->client_->read(buf, len);
-  }
 #ifdef USE_OTA_PASSWORD
  static constexpr size_t SHA256_HEX_SIZE = 64;  // SHA256 hash as hex string (32 bytes * 2)
  bool handle_auth_send_();
@@ -157,6 +75,7 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
 #endif  // USE_OTA_PASSWORD
  bool readall_(uint8_t *buf, size_t len);
  bool writeall_(const uint8_t *buf, size_t len);
+  inline bool write_byte_(uint8_t byte) { return this->writeall_(&byte, 1); }

 #ifdef USE_OTA_ENCRYPTION
  // Heap-allocated only while an encrypted OTA session is active.
@@ -186,21 +105,18 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
  ssize_t noise_read_frame_blocking_(uint8_t *buf, size_t min_ciphertext, size_t max_ciphertext);
  bool noise_readall_(uint8_t *buf, size_t len);
  ssize_t noise_read_data_(uint8_t *buf, size_t capacity);
-  static constexpr size_t NOISE_MAX_RESPONSE = 4;  // the UDP token
-  bool noise_write_(const uint8_t *data, size_t len);
+  bool noise_write_byte_(uint8_t byte);
 #endif  // USE_OTA_ENCRYPTION

  // Data-phase I/O dispatch: through the noise transport when a session is
  // active, straight to the socket otherwise.
-  // len is at most NOISE_MAX_RESPONSE
-  inline bool data_write_(const uint8_t *data, size_t len) {
+  inline bool data_write_byte_(uint8_t byte) {
 #ifdef USE_OTA_ENCRYPTION
    if (this->noise_ != nullptr)
-      return this->noise_write_(data, len);
+      return this->noise_write_byte_(byte);
 #endif
-    return this->writeall_(data, len);
+    return this->write_byte_(byte);
  }
-  inline bool data_write_byte_(uint8_t byte) { return this->data_write_(&byte, 1); }
  // When encrypted, buf must have room for len + noise::MAC_SIZE bytes.
  inline bool data_readall_(uint8_t *buf, size_t len) {
 #ifdef USE_OTA_ENCRYPTION
@@ -284,21 +200,7 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
  std::unique_ptr<socket::Socket> client_;
  ota::OTABackendPtr backend_;

-#ifdef ESPHOME_OTA_UDP_LWIP
-  union {
-    uint32_t client_connect_time_{0};  // handshake states
-    UdpLink *udp_;                     // data phase (never both), points into handle_data_'s stack
-  };
-  static_assert(sizeof(UdpLink *) == sizeof(uint32_t), "clearing client_connect_time_ must clear udp_");
-#else
  uint32_t client_connect_time_{0};
-#ifdef ESPHOME_OTA_UDP
-  UdpLink *udp_{nullptr};  // data phase, points into handle_data_'s stack
-#endif
-#endif
-#if defined(ESPHOME_OTA_UDP) && defined(USE_OTA_ENCRYPTION)
-  static_assert(sizeof(UdpLink::reply) <= NOISE_MAX_RESPONSE, "the token goes out through noise_write_");
-#endif
  static constexpr size_t HANDSHAKE_BUF_SIZE = 5;
  // Buffer size for OTA data transfer. The upload client derives its maximum
  // encrypted frame plaintext from this (espota2.NOISE_MAX_PLAINTEXT is this
@@ -266,15 +266,13 @@ ssize_t ESPHomeOTAComponent::noise_read_data_(uint8_t *buf, size_t capacity) {
  return this->noise_read_frame_blocking_(buf, noise::MAC_SIZE + 1, max_ciphertext);
 }

-/// Blocking write of a short response (at most NOISE_MAX_RESPONSE bytes) as one encrypted frame.
-bool ESPHomeOTAComponent::noise_write_(const uint8_t *data, size_t len) {
-  uint8_t frame[noise::FRAME_HEADER_SIZE + NOISE_MAX_RESPONSE + noise::MAC_SIZE];
-  if (len > NOISE_MAX_RESPONSE)
-    return false;
-  memcpy(frame + noise::FRAME_HEADER_SIZE, data, len);
+/// Blocking write of one response byte as an encrypted frame.
+bool ESPHomeOTAComponent::noise_write_byte_(uint8_t byte) {
+  uint8_t frame[noise::FRAME_HEADER_SIZE + 1 + noise::MAC_SIZE];
+  frame[noise::FRAME_HEADER_SIZE] = byte;
  NoiseBuffer mbuf;
  noise_buffer_init(mbuf);
-  noise_buffer_set_inout(mbuf, frame + noise::FRAME_HEADER_SIZE, len, len + noise::MAC_SIZE);
+  noise_buffer_set_inout(mbuf, frame + noise::FRAME_HEADER_SIZE, 1, 1 + noise::MAC_SIZE);
  int err = noise_cipherstate_encrypt(this->noise_->send_cipher, &mbuf);
  if (err != 0) {
    ESP_LOGW(TAG, "Encrypt: %d", err);
@@ -1,375 +0,0 @@
-#include "ota_esphome.h"
-#if defined(USE_OTA) && defined(ESPHOME_OTA_UDP)
-
-#include "esphome/core/application.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-#ifdef ESPHOME_OTA_UDP_LWIP
-#include "lwip/inet.h"
-#ifdef USE_LIBRETINY
-#include "lwip/tcpip.h"
-#endif
-#endif
-
-#include <algorithm>
-#include <cstring>
-#include <memory>
-
-/*
- * UDP data phase: the same byte stream as TCP, cut into numbered datagrams.
- *   client -> device  [type | COMMITTED][token u32][seq u16][device bytes received u16][payload]
- *   device -> client  [ACK][token u32][received u16][seq that prompted it u16][stream offset u16][window u8][our bytes]
- * The lwIP callback acks each datagram on arrival, so flash writes never look like loss, and keeps messages in its
- * UDP_WINDOW slots until the OTA loop reads them. "window": free slots in the high nibble, and in the low nibble bit k
- * set when received + k is already here (like TCP SACK).
- */
-
-namespace esphome {
-
-ESPHOME_LOG_TAG(TAG, "esphome.ota");
-
-// PING (0x02) and PROBE (0x03) only prompt an ACK
-static constexpr uint8_t UDP_MSG_DATA = 0x01;
-static constexpr uint8_t UDP_FLAG_COMMITTED = 0x80;
-static constexpr uint8_t UDP_MSG_ACK = 0x40;
-static constexpr size_t UDP_HEADER_SIZE = 9;
-static constexpr size_t UDP_ACK_HEADER_SIZE = 12;
-// The client's 60 s wait for the token over a lossy TCP link, plus its 15 s probe
-static constexpr uint32_t UDP_COMMIT_TIMEOUT = 80000;
-// Like the TCP socket's SO_RCVTIMEO in handle_data_, so readall_ treats both alike
-static constexpr uint32_t UDP_READ_WAIT_MS = 2000;
-// How often the commit wait looks at the UDP link between reads of the TCP fallback byte
-static constexpr uint32_t UDP_COMMIT_POLL_MS = 100;
-static constexpr uint32_t UDP_LINGER_MS = 3000;
-
-#ifdef ESPHOME_OTA_UDP_LWIP
-#ifdef USE_LIBRETINY
-// LibreTiny's LwIPLock is a no-op; take the core lock directly (the header drops UDP without one)
-struct UdpLock {
-  UdpLock() { LOCK_TCPIP_CORE(); }
-  ~UdpLock() { UNLOCK_TCPIP_CORE(); }
-};
-#else
-using UdpLock = LwIPLock;
-#endif
-static uint16_t slot_len(struct pbuf *p) { return p->tot_len; }
-static uint16_t slot_copy(struct pbuf *p, void *dst, uint16_t len, uint16_t offset) {
-  return pbuf_copy_partial(p, dst, len, offset);
-}
-static void slot_free(struct pbuf *p) { pbuf_free(p); }
-#else
-// The host has no lwIP thread: the OTA loop drains the socket itself. Empty bodies, not = default, so clang-tidy
-// does not flag the guards as unused
-struct UdpLock {
-  UdpLock() {}
-  ~UdpLock() {}
-};
-struct OtaUdpDatagram {
-  uint16_t len;
-  uint8_t data[1500];
-};
-static uint16_t slot_len(OtaUdpDatagram *p) { return p->len; }
-static uint16_t slot_copy(OtaUdpDatagram *p, void *dst, uint16_t len, uint16_t offset) {
-  const uint16_t n = std::min<uint16_t>(len, p->len - offset);
-  memcpy(dst, p->data + offset, n);
-  return n;
-}
-static void slot_free(OtaUdpDatagram *p) { delete p; }
-#endif
-
-static void put_u16(uint8_t *at, uint16_t value) {
-  at[0] = value >> 8;
-  at[1] = value & 0xFF;
-}
-
-ESPHomeOTAComponent::UdpLink::~UdpLink() { this->release(); }
-
-void ESPHomeOTAComponent::UdpLink::release() {
-  UdpLock lock;
-#ifdef ESPHOME_OTA_UDP_LWIP
-  if (this->pcb != nullptr)
-    udp_remove(this->pcb);
-  this->pcb = nullptr;
-#else
-  this->sock = nullptr;
-#endif
-  for (auto &p : this->queue) {
-    if (p != nullptr)
-      slot_free(p);
-    p = nullptr;
-  }
-}
-
-void ESPHomeOTAComponent::udp_send_ack(UdpLink &link, uint16_t prompted_by) {
-  const uint16_t len = UDP_ACK_HEADER_SIZE + link.out_len;
-#ifdef ESPHOME_OTA_UDP_LWIP
-  struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM);
-  if (p == nullptr)
-    return;  // Like a lost ACK: the client asks again
-  auto *ack = static_cast<uint8_t *>(p->payload);
-#else
-  uint8_t ack[UDP_ACK_HEADER_SIZE + UDP_OUT_SIZE];
-#endif
-  ack[0] = UDP_MSG_ACK;
-  memcpy(ack + 1, link.reply, 4);
-  put_u16(ack + 5, link.received);
-  put_u16(ack + 7, prompted_by);
-  put_u16(ack + 9, link.out_base);
-  uint8_t window = (UDP_WINDOW - static_cast<uint16_t>(link.received - link.consumed)) << 4;
-  for (uint8_t k = 1; k < UDP_WINDOW; k++) {
-    if (link.queue[(link.received + k) % UDP_WINDOW] != nullptr)
-      window |= 1 << k;
-  }
-  ack[11] = window;
-  memcpy(ack + UDP_ACK_HEADER_SIZE, link.out, link.out_len);
-  // Best effort: a lost ACK is repeated for the client's next datagram
-#ifdef ESPHOME_OTA_UDP_LWIP
-  udp_sendto(link.pcb, p, &link.peer_ip, link.peer_port);
-  pbuf_free(p);
-#else
-  struct sockaddr_storage to = link.peer;
-  if (to.ss_family == AF_INET6) {
-    reinterpret_cast<sockaddr_in6 *>(&to)->sin6_port = htons(link.peer_port);
-  } else {
-    reinterpret_cast<sockaddr_in *>(&to)->sin_port = htons(link.peer_port);
-  }
-  link.sock->sendto(ack, len, 0, reinterpret_cast<const struct sockaddr *>(&to), link.peer_len);
-#endif
-}
-
-void ESPHomeOTAComponent::udp_on_datagram(UdpLink &link, UdpSlot p, uint16_t port) {
-  uint8_t hdr[UDP_HEADER_SIZE];
-  if (slot_copy(p, hdr, UDP_HEADER_SIZE, 0) != UDP_HEADER_SIZE || memcmp(hdr + 1, link.reply, 4) != 0) {
-    slot_free(p);
-    return;
-  }
-  // The token proves the sender; answer the port it arrived from, which NAT may have rewritten
-  link.peer_port = port;
-  link.committed |= (hdr[0] & UDP_FLAG_COMMITTED) != 0;
-  // Drop the responses the client already has
-  const uint16_t acked = encode_uint16(hdr[7], hdr[8]) - link.out_base;
-  if (acked != 0 && acked <= link.out_len) {
-    link.out_len -= acked;
-    memmove(link.out, link.out + acked, link.out_len);
-    link.out_base += acked;
-  }
-  const uint16_t seq = encode_uint16(hdr[5], hdr[6]);
-  UdpSlot &slot = link.queue[seq % UDP_WINDOW];
-  if ((hdr[0] & ~UDP_FLAG_COMMITTED) == UDP_MSG_DATA && slot_len(p) > UDP_HEADER_SIZE &&
-      static_cast<uint16_t>(seq - link.consumed) < UDP_WINDOW && slot == nullptr) {
-    slot = p;
-    while (static_cast<uint16_t>(link.received - link.consumed) < UDP_WINDOW &&
-           link.queue[link.received % UDP_WINDOW] != nullptr)
-      link.received++;
-  } else {
-    slot_free(p);
-  }
-  udp_send_ack(link, seq);
-}
-
-#ifdef ESPHOME_OTA_UDP_LWIP
-// lwIP context: the tcpip thread (ESP32, LibreTiny), SYS (ESP8266) or an IRQ (RP2040)
-void ESPHomeOTAComponent::udp_recv_cb(void *arg, struct udp_pcb * /*pcb*/, struct pbuf *p, const ip_addr_t *addr,
-                                      uint16_t port) {
-  auto &link = *static_cast<UdpLink *>(arg);
-  if (!ip_addr_cmp(addr, &link.peer_ip)) {
-    pbuf_free(p);
-    return;
-  }
-  udp_on_datagram(link, p, port);
-}
-#else
-static bool same_ip(const struct sockaddr_storage &a, const struct sockaddr_storage &b) {
-  uint32_t ipv4_a, ipv4_b;
-  const bool v4_a = socket::sockaddr_to_ipv4(reinterpret_cast<const struct sockaddr *>(&a), &ipv4_a);
-  const bool v4_b = socket::sockaddr_to_ipv4(reinterpret_cast<const struct sockaddr *>(&b), &ipv4_b);
-  if (v4_a || v4_b)
-    return v4_a && v4_b && ipv4_a == ipv4_b;
-  return a.ss_family == AF_INET6 && b.ss_family == AF_INET6 &&
-         memcmp(&reinterpret_cast<const sockaddr_in6 *>(&a)->sin6_addr,
-                &reinterpret_cast<const sockaddr_in6 *>(&b)->sin6_addr, sizeof(in6_addr)) == 0;
-}
-
-void ESPHomeOTAComponent::udp_poll_() {
-  UdpLink &link = *this->udp_;
-  for (;;) {
-    uint8_t buf[sizeof(OtaUdpDatagram::data)];
-    struct sockaddr_storage from;
-    socklen_t from_len = sizeof(from);
-    const ssize_t len = link.sock->recvfrom(buf, sizeof(buf), reinterpret_cast<struct sockaddr *>(&from), &from_len);
-    if (len < 0)
-      return;
-    if (!same_ip(from, link.peer))
-      continue;
-    auto *datagram = new OtaUdpDatagram;  // NOLINT(cppcoreguidelines-owning-memory)
-    datagram->len = len;
-    memcpy(datagram->data, buf, len);
-    const uint16_t port = from.ss_family == AF_INET6 ? ntohs(reinterpret_cast<sockaddr_in6 *>(&from)->sin6_port)
-                                                     : ntohs(reinterpret_cast<sockaddr_in *>(&from)->sin_port);
-    udp_on_datagram(link, datagram, port);
-  }
-}
-#endif
-
-void ESPHomeOTAComponent::udp_open_(UdpLink &link) {
-  struct sockaddr_storage peer;
-  socklen_t peer_len = sizeof(peer);
-  if (this->client_->getpeername(reinterpret_cast<struct sockaddr *>(&peer), &peer_len) != 0)
-    return;
-  uint8_t token[4];
-  if (!random_bytes(token, sizeof(token)))
-    return;
-#ifdef ESPHOME_OTA_UDP_LWIP
-  uint32_t ipv4;
-  if (socket::sockaddr_to_ipv4(reinterpret_cast<const struct sockaddr *>(&peer), &ipv4)) {
-    ip_addr_set_ip4_u32(&link.peer_ip, ipv4);
-  } else {
-#if USE_NETWORK_IPV6 && LWIP_IPV6
-    inet6_addr_to_ip6addr(ip_2_ip6(&link.peer_ip), &reinterpret_cast<const sockaddr_in6 *>(&peer)->sin6_addr);
-    IP_SET_TYPE_VAL(link.peer_ip, IPADDR_TYPE_V6);
-#else
-    return;
-#endif
-  }
-  UdpLock lock;
-#if LWIP_IPV6
-  link.pcb = udp_new_ip_type(IPADDR_TYPE_ANY);
-#else
-  link.pcb = udp_new();
-#endif
-  // On failure the reply stays all zero and ~UdpLink removes the pcb
-  if (link.pcb == nullptr || udp_bind(link.pcb, IP_ANY_TYPE, this->port_) != ERR_OK)
-    return;
-  udp_recv(link.pcb, udp_recv_cb, &link);
-#else
-  link.peer = peer;
-  link.peer_len = peer_len;
-  // Same domain as the listener, so the peer address from getpeername fits
-  link.sock = socket::socket_ip(SOCK_DGRAM, IPPROTO_UDP);
-  struct sockaddr_storage local;
-  const socklen_t local_len =
-      socket::set_sockaddr_any(reinterpret_cast<struct sockaddr *>(&local), sizeof(local), this->port_);
-  if (link.sock == nullptr || local_len == 0 ||
-      link.sock->bind(reinterpret_cast<struct sockaddr *>(&local), local_len) != 0 ||
-      link.sock->setblocking(false) != 0)
-    return;
-#endif
-  // Below the error codes (0x80 and up) the client checks the first byte against, and never all zero
-  token[0] = (token[0] & 0x7F) | 0x01;
-  memcpy(link.reply, token, sizeof(token));
-}
-
-bool ESPHomeOTAComponent::udp_start_() {
-  // TCP now only carries a fallback byte; short read timeouts let the UDP link be checked in between
-  struct timeval tv {
-    0, UDP_COMMIT_POLL_MS * 1000
-  };
-  this->client_->setsockopt(SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
-  const uint32_t start = millis();
-  while (millis() - start < UDP_COMMIT_TIMEOUT) {
-    this->udp_poll_();
-    bool committed;
-    {
-      UdpLock lock;
-      committed = this->udp_->committed;
-    }
-    if (committed) {
-      // The client heard us over UDP, so TCP is done. Outside the lock: closing a socket waits on the tcpip thread
-      this->client_ = nullptr;
-      return true;
-    }
-    // A raw byte outside any Noise frame: the client heard nothing over UDP. Forging it only forces the ordinary
-    // TCP path, which dropping our datagrams forces anyway
-    uint8_t fallback;
-    const ssize_t read = this->client_->read(&fallback, 1);
-    if (read == 1) {
-      this->udp_->release();
-      this->udp_ = nullptr;
-      tv = {UDP_READ_WAIT_MS / 1000, 0};
-      this->client_->setsockopt(SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
-      return true;
-    }
-    if (read == 0) {
-      this->remote_closed_ = true;
-      return false;
-    }
-    if (!this->would_block_(errno))
-      return false;
-    App.feed_wdt();
-  }
-  return false;
-}
-
-ssize_t ESPHomeOTAComponent::udp_read_(uint8_t *buf, size_t len) {
-  UdpLink &link = *this->udp_;
-  const uint32_t start = millis();
-  size_t got = 0;
-  for (;;) {
-    this->udp_poll_();
-    UdpSlot p;
-    {
-      UdpLock lock;
-      p = link.consumed != link.received ? link.queue[link.consumed % UDP_WINDOW] : nullptr;
-    }
-    if (p == nullptr) {
-      if (got != 0)
-        return got;
-      if (millis() - start >= UDP_READ_WAIT_MS)
-        break;
-      this->yield_and_feed_watchdog_();
-      continue;
-    }
-    // The callback never touches the slot being read, so the copy runs without the lock
-    const uint16_t offset = UDP_HEADER_SIZE + link.read_offset;
-    const uint16_t n = slot_copy(p, buf + got, std::min<size_t>(len - got, slot_len(p) - offset), offset);
-    got += n;
-    link.read_offset += n;
-    if (UDP_HEADER_SIZE + link.read_offset >= slot_len(p)) {
-      UdpLock lock;
-      slot_free(p);
-      link.queue[link.consumed % UDP_WINDOW] = nullptr;
-      // A full window just opened: tell the client, which is holding back
-      const bool was_full = static_cast<uint16_t>(link.received - link.consumed) == UDP_WINDOW;
-      link.consumed++;
-      link.read_offset = 0;
-      if (was_full)
-        udp_send_ack(link, link.received - 1);
-    }
-    if (got == len)
-      return got;
-  }
-  errno = EWOULDBLOCK;
-  return -1;
-}
-
-bool ESPHomeOTAComponent::udp_send_(const uint8_t *data, size_t len) {
-  UdpLink &link = *this->udp_;
-  UdpLock lock;
-  if (link.out_len + len > UDP_OUT_SIZE)
-    return false;
-  memcpy(link.out + link.out_len, data, len);
-  link.out_len += len;
-  // Prompted by nothing new, so the client takes no round trip sample from it
-  udp_send_ack(link, link.received - 1);
-  return true;
-}
-
-void ESPHomeOTAComponent::udp_linger_() {
-  if (this->udp_ == nullptr)
-    return;
-  const uint32_t start = millis();
-  while (millis() - start < UDP_LINGER_MS) {
-    this->udp_poll_();
-    {
-      UdpLock lock;
-      if (this->udp_->out_len == 0)
-        return;
-    }
-    this->yield_and_feed_watchdog_();
-  }
-}
-
-}  // namespace esphome
-#endif  // USE_OTA && ESPHOME_OTA_UDP
@@ -3,12 +3,11 @@
 #include "esphome/core/component.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
-#include "esphome/core/log.h"
 #include <deque>

 namespace esphome::ezo {

-ESPHOME_LOG_TAG(TAG, "ezo.sensor");
+static const char *const TAG = "ezo.sensor";

 enum EzoCommandType : uint8_t {
  EZO_READ = 0,
@@ -330,9 +330,7 @@ async def write_image(
        if byte_order is not None:
            # Check for valid type has already been done in validate_settings
            encoder.set_big_endian(byte_order == "BIG_ENDIAN")
-        pixels = encoder.convert(
-            image.resize((width, height)), path
-        ).get_flattened_data()
+        pixels = encoder.convert(image.resize((width, height)), path).getdata()
        for row in range(height):
            for col in range(width):
                encoder.encode(pixels[row * width + col])
@@ -1,2 +0,0 @@
-CODEOWNERS = ["@tuct"]
-DOMAIN = "filter_lifetime"
Author	SHA1	Message	Date
J. Nick Koston	b501e48ebd	Merge branch 'dev' into uart-debug-event-flash	2026-10-12 17:33:23 -10:00
J. Nick Koston	0572454bed	Merge remote-tracking branch 'origin/dev' into HEAD	2026-10-09 18:27:50 -10:00
J. Nick Koston	8e50491ef9	Merge remote-tracking branch 'origin/dev' into uart-debug-event-flash	2026-10-04 18:06:45 -05:00
J. Nick Koston	e3df568cd7	Cap the number of event types at 65535	2026-10-03 16:06:49 -05:00
J. Nick Koston	1a80e3faf4	Reject lambda delimiters at validation and encode event strings as UTF-8	2026-10-03 15:38:41 -05:00
J. Nick Koston	0a46c81770	Fix the flash read comment	2026-10-03 14:57:45 -05:00
J. Nick Koston	633cf73a9d	[uart] Keep debug delimiters and event match data in shared PROGMEM tables	2026-10-03 14:56:07 -05:00
J. Nick Koston	565ee2a14b	[core] Let shared_progmem_array emit an unshared array Identical lambdas can carry separate static state, so callers need a way to keep such tables apart while still getting a collision free name.	2026-10-03 14:51:31 -05:00
J. Nick Koston	be0f3a32f9	[core] Emit shared PROGMEM arrays at namespace scope A setup() local table could only be reused from the scope of its first use. The arrays are now globals. A lambda in a table only references variables that codegen has already declared, so writing the global straight away keeps the order valid.	2026-10-03 14:51:31 -05:00
J. Nick Koston	c7967c2601	[core] Add cg.shared_progmem_array for deduplicated PROGMEM tables Emits one PROGMEM array per distinct type and contents and returns the same variable to later callers. The array name is made unique against every config id and registered variable, so a generated table can never collide with a user id.	2026-10-03 14:51:31 -05:00