Merge branch 'time-filter-posix-tz' into time-filter-posix-tz-cpptest

.claude/settings.json

@@ -1,16 +0,0 @@
-{
-  "hooks": {
-    "SessionStart": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "d=\"${CLAUDE_PROJECT_DIR:-.}\"; [ -x \"$d/venv/bin/python\" ] || { mkdir -p \"$d/.temp\"; env -u VIRTUAL_ENV \"$d/script/setup\" >\"$d/.temp/setup.log\" 2>&1 || echo '{\"systemMessage\":\"script/setup failed; see .temp/setup.log\"}'; }",
-            "statusMessage": "Setting up dev environment (script/setup)...",
-            "timeout": 900
-          }
-        ]
-      }
-    ]
-  }
-}

.github/actions/cache-clang-tidy-idedata/action.yml

@@ -1,50 +0,0 @@
-name: Cache clang-tidy idedata
-description: >
-  Cache the clang-tidy idedata and the headers it references under .temp
-  (headers only, about 30MB per env). Run after restore-python and cache-esp-idf.
-inputs:
-  environment:
-    description: 'clang-tidy environment (e.g. esp32-idf-tidy).'
-    required: true
-runs:
-  using: composite
-  steps:
-    - name: Compute cache key
-      id: key
-      shell: bash
-      run: |
-        . venv/bin/activate
-        [ -n "${{ inputs.environment }}" ] || { echo "::error::cache-clang-tidy-idedata: 'environment' input is empty"; exit 1; }
-        hash=$(python -c 'import sys; sys.path.insert(0, "script"); from clang_tidy_hash import idedata_cache_hash; print(idedata_cache_hash("${{ inputs.environment }}"))')
-        pyver=$(python -c 'import platform; print(platform.python_version())')
-        # Generating idedata is what installs ESP-IDF; never skip it over a missing
-        # install. This also skips the save, so a dev run that installs ESP-IDF
-        # warms the idedata cache on the next run.
-        if [ -d ~/.esphome-idf/frameworks ]; then
-          echo "skip=false" >> "$GITHUB_OUTPUT"
-        else
-          echo "ESP-IDF install missing, not using the clang-tidy idedata cache"
-          echo "skip=true" >> "$GITHUB_OUTPUT"
-        fi
-        echo "key=${{ runner.os }}-tidy-idedata-${{ inputs.environment }}-$hash-py$pyver" >> "$GITHUB_OUTPUT"
-        {
-          echo "path<<EOF"
-          printf '%s\n' '.temp/idedata-*.json' '.temp/idedata-*.hash'
-          printf '.temp/**/*.%s\n' h hpp hh hxx inc inl ipp tpp
-          echo "EOF"
-        } >> "$GITHUB_OUTPUT"
-    # Mirror cache-esp-idf: write on dev, restore-only on PRs. The post-step
-    # save only runs when the job succeeded, so a failed generation is never saved.
-    # Extend the extension list if a component ships extensionless headers.
-    - name: Cache clang-tidy idedata (write on dev)
-      if: (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write')) && steps.key.outputs.skip != 'true'
-      uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
-      with:
-        path: ${{ steps.key.outputs.path }}
-        key: ${{ steps.key.outputs.key }}
-    - name: Cache clang-tidy idedata (restore-only off dev)
-      if: github.ref != 'refs/heads/dev' && !contains(github.event.pull_request.labels.*.name, 'ci-cache-write') && steps.key.outputs.skip != 'true'
-      uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
-      with:
-        path: ${{ steps.key.outputs.path }}
-        key: ${{ steps.key.outputs.key }}

.github/actions/cache-esp-idf/action.yml

@@ -26,9 +26,6 @@ runs:
       # The native-IDF version is pinned in code, not in any file that feeds the
       # other cache keys, so resolve it explicitly. Keying on it means the cache
       # invalidates on a version bump (actions/cache never overwrites a key).
-      # Also key on the Python version: the cached IDF venv links to the
-      # runner's toolcache interpreter and is reinstalled every run after a
-      # runner image bump.
       id: version
       shell: bash
       run: |
@@ -39,32 +36,19 @@ runs:
           version=$(python -c 'from esphome.components.esp32 import ESP_IDF_FRAMEWORK_VERSION_LOOKUP as L; print(L["recommended"])')
         fi
         echo "version=$version" >> "$GITHUB_OUTPUT"
-        echo "python-version=$(python -c 'import platform; print(platform.python_version())')" >> "$GITHUB_OUTPUT"
     # Mirror the adjacent PlatformIO cache: only dev-branch runs write the
     # shared cache (so it lives in the default-branch scope readable by all
     # PRs), and PRs are restore-only -- they never push multi-GB artifacts into
-    # their own scope / the repo quota (e.g. on a version-bump PR). The
-    # ci-cache-write label lets a PR write into its own scope to test the hit path;
-    # that costs about 1GB of the repo cache quota per run, so remove it when done.
-    # -slim: bump when prune-esp-idf changes what it removes; a key is never overwritten.
+    # their own scope / the repo quota (e.g. on a version-bump PR).
     - name: Cache ESP-IDF install (write on dev)
-      if: (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write')) && inputs.restore-only != 'true'
+      if: github.ref == 'refs/heads/dev' && inputs.restore-only != 'true'
       uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
       with:
         path: ~/.esphome-idf
-        key: ${{ runner.os }}-esphome-idf-${{ steps.version.outputs.version }}-py${{ steps.version.outputs.python-version }}-slim
+        key: ${{ runner.os }}-esphome-idf-${{ steps.version.outputs.version }}
     - name: Cache ESP-IDF install (restore-only off dev)
-      if: github.ref != 'refs/heads/dev' && !contains(github.event.pull_request.labels.*.name, 'ci-cache-write') || inputs.restore-only == 'true'
+      if: github.ref != 'refs/heads/dev' || inputs.restore-only == 'true'
       uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
       with:
         path: ~/.esphome-idf
-        key: ${{ runner.os }}-esphome-idf-${{ steps.version.outputs.version }}-py${{ steps.version.outputs.python-version }}-slim
-    # Install explicitly so the prune below sees the toolchains on a cache miss
-    # too, instead of the install happening inside the first build step.
-    - name: Install ESP-IDF
-      shell: bash
-      run: |
-        . venv/bin/activate
-        python -c 'from esphome.espidf.framework import check_esp_idf_install; check_esp_idf_install("${{ steps.version.outputs.version }}")'
-    - name: Prune ESP-IDF install
-      uses: ./.github/actions/prune-esp-idf
+        key: ${{ runner.os }}-esphome-idf-${{ steps.version.outputs.version }}

.github/actions/prune-esp-idf/action.yml

@@ -1,34 +0,0 @@
-name: Prune ESP-IDF install
-description: >
-  Remove the picolibc sysroots (1.1GB of the 3.9GB install) from the native
-  ESP-IDF toolchains; IDF 5.x links newlib. Skipped when an IDF 6 install is
-  present, which links picolibc (see esp32/__init__.py).
-runs:
-  using: composite
-  steps:
-    - name: Prune picolibc
-      shell: bash
-      run: |
-        shopt -s nullglob
-        prefix="${ESPHOME_ESP_IDF_PREFIX:-$HOME/.esphome-idf}"
-        prefix="${prefix/#\~/$HOME}"
-        for fw in "$prefix"/frameworks/*/; do
-          case "$(basename "$fw")" in
-            [6-9].*) echo "IDF $(basename "$fw") installed, keeping picolibc"; exit 0 ;;
-          esac
-        done
-        n=0
-        for dir in "$prefix"/tools/*-esp-elf/*/*-esp-elf/picolibc; do
-          echo "Removing $dir ($(du -sh "$dir" | cut -f1))"
-          rm -rf "$dir"
-          n=$((n + 1))
-        done
-        # The marker rides along in the cache entry so a restored slim tree stays quiet.
-        if [ "$n" -gt 0 ]; then
-          touch "$prefix/.picolibc-pruned"
-        elif [ -d "$prefix/tools" ] && [ ! -f "$prefix/.picolibc-pruned" ]; then
-          echo "::warning::no picolibc sysroots matched under $prefix/tools"
-        fi
-        if [ -d "$prefix" ]; then
-          du -sh "$prefix"
-        fi

.github/workflows/ci-docker.yml

@@ -119,22 +119,16 @@ jobs:
       # pushed image) keeps it working for fork PRs, which never push to ghcr.io.
       - name: Export image for compile-test
         if: matrix.os == 'ubuntu-24.04' && matrix.build_type == 'docker'
-        # zstd over gzip: docker save is on the critical path for every
-        # compile-test job, and zstd -T0 is multithreaded (export 50s -> 9s).
-        # docker load auto-detects the format; its time is layer extraction,
-        # not decompression, so it is unchanged. shell: bash adds pipefail so
-        # a failed docker save cannot upload a truncated artifact.
-        shell: bash
-        run: docker save "ghcr.io/esphome/esphome-amd64:${{ steps.tag.outputs.tag }}" | zstd -T0 -3 > compile-test-image.tar.zst
+        run: docker save "ghcr.io/esphome/esphome-amd64:${{ steps.tag.outputs.tag }}" | gzip > compile-test-image.tar.gz
 
       - name: Upload compile-test image artifact
         if: matrix.os == 'ubuntu-24.04' && matrix.build_type == 'docker'
         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
-          # (the `name` input is ignored in that mode).
-          path: compile-test-image.tar.zst
+          # The tar is already gzipped, so upload it as-is. archive: false skips
+          # the redundant zip and makes the file name the artifact name (the
+          # `name` input is ignored in that mode).
+          path: compile-test-image.tar.gz
           retention-days: 1
           archive: false
 
@@ -188,6 +182,8 @@ jobs:
       contents: read  # actions/checkout to load the test configs
     strategy:
       fail-fast: false
+      # Modest cap so this smoke test leaves room on the shared runner pool.
+      max-parallel: 8
       matrix:
         # One entry per distinct toolchain. ESP32 variants (c3/c6/s2/s3/p4)
         # share a toolchain bundle, so esp32 is exercised on the base variant
@@ -212,9 +208,9 @@ jobs:
       - name: Download image artifact
         uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
-          name: compile-test-image.tar.zst
+          name: compile-test-image.tar.gz
       - name: Load image
-        run: docker load --input compile-test-image.tar.zst
+        run: docker load --input compile-test-image.tar.gz
       - name: Compile ${{ matrix.id }}
         run: |
           docker run --rm \

.github/workflows/ci.yml

@@ -112,12 +112,6 @@ jobs:
       component-test-batches: ${{ steps.determine.outputs.component-test-batches }}
       validate-only-components: ${{ steps.determine.outputs.validate-only-components }}
       benchmarks: ${{ steps.determine.outputs.benchmarks }}
-      # "true" when this run is a pull request into one of the release
-      # branches. Those pull requests are batches of changes already tested on
-      # their original dev pull requests, so several jobs below trade coverage
-      # for turnaround time on them. Matched exactly, not by prefix, so an
-      # ordinary branch named e.g. "release-notes" is not caught by it.
-      release-pr: ${{ github.base_ref == 'beta' || github.base_ref == 'release' }}
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -236,7 +230,7 @@ jobs:
     runs-on: ubuntu-latest
     needs:
       - determine-jobs
-    if: github.event_name == 'pull_request' && needs.determine-jobs.outputs.release-pr == 'false' && needs.determine-jobs.outputs.core-ci == 'true'
+    if: github.event_name == 'pull_request' && !startsWith(github.base_ref, 'beta') && !startsWith(github.base_ref, 'release') && needs.determine-jobs.outputs.core-ci == 'true'
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -455,21 +449,10 @@ jobs:
     if: >-
       github.repository == 'esphome/esphome' && (
         (github.event_name == 'push' && github.ref_name == 'dev') ||
-        (
-          github.event_name == 'pull_request' &&
-          needs.determine-jobs.outputs.release-pr == 'false' &&
-          needs.determine-jobs.outputs.benchmarks == 'true'
-        )
+        (github.event_name == 'pull_request' && needs.determine-jobs.outputs.benchmarks == 'true')
       )
     # CodSpeed benchmarks require a CodSpeed account linked to the repository to run
     # (https://codspeed.io) -- disabled on forks that aren't esphome/esphome itself.
-    #
-    # Pull requests into beta and release are skipped as well. CodSpeed compares a
-    # pull request against the newest commit of its base branch that has a benchmark
-    # run of its own, and only dev is benchmarked. A release pull request therefore
-    # falls back to dev's latest run, so every speed-up merged into dev since the
-    # release branched is reported as a regression in the release. The changes there
-    # have already been benchmarked on their original dev pull requests.
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -536,7 +519,7 @@ jobs:
             apt-get install -y libc6-dbg
 
       - name: Run CodSpeed benchmarks
-        uses: CodSpeedHQ/action@373d6868929f444bc08d901fd0eb0ad52a8875ea # v5.2.1
+        uses: CodSpeedHQ/action@4296e51e7041e24dadb86d1d6e8b9320d223dbe8 # v5.0.3
         with:
           run: |
             . venv/bin/activate
@@ -649,12 +632,6 @@ jobs:
         with:
           framework: arduino
 
-      - name: Cache clang-tidy idedata
-        if: matrix.cache_idf
-        uses: ./.github/actions/cache-clang-tidy-idedata
-        with:
-          environment: esp32-arduino-tidy
-
       - name: Cache nRF Connect SDK install
         if: matrix.cache_sdk_nrf
         uses: ./.github/actions/cache-sdk-nrf
@@ -704,10 +681,6 @@ jobs:
           # Also cache libdeps, store them in a ~/.platformio subfolder
           PLATFORMIO_LIBDEPS_DIR: ~/.platformio/libdeps
 
-      - name: Prune ESP-IDF install before cache save
-        if: matrix.cache_idf && (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write'))
-        uses: ./.github/actions/prune-esp-idf
-
       - name: Suggested changes
         run: script/ci-suggest-changes ${{ matrix.ignore_errors && '|| true' || '' }}
         # yamllint disable-line rule:line-length
@@ -740,11 +713,6 @@ jobs:
       - name: Cache ESP-IDF install
         uses: ./.github/actions/cache-esp-idf
 
-      - name: Cache clang-tidy idedata
-        uses: ./.github/actions/cache-clang-tidy-idedata
-        with:
-          environment: esp32-idf-tidy
-
       - name: Register problem matchers
         run: |
           echo "::add-matcher::.github/workflows/matchers/gcc.json"
@@ -779,10 +747,6 @@ jobs:
           # Also cache libdeps, store them in a ~/.platformio subfolder
           PLATFORMIO_LIBDEPS_DIR: ~/.platformio/libdeps
 
-      - name: Prune ESP-IDF install before cache save
-        if: (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write'))
-        uses: ./.github/actions/prune-esp-idf
-
       - name: Suggested changes
         run: script/ci-suggest-changes
         if: always()
@@ -828,11 +792,6 @@ jobs:
       - name: Cache ESP-IDF install
         uses: ./.github/actions/cache-esp-idf
 
-      - name: Cache clang-tidy idedata
-        uses: ./.github/actions/cache-clang-tidy-idedata
-        with:
-          environment: esp32-idf-tidy
-
       - name: Register problem matchers
         run: |
           echo "::add-matcher::.github/workflows/matchers/gcc.json"
@@ -867,10 +826,6 @@ jobs:
           # Also cache libdeps, store them in a ~/.platformio subfolder
           PLATFORMIO_LIBDEPS_DIR: ~/.platformio/libdeps
 
-      - name: Prune ESP-IDF install before cache save
-        if: (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write'))
-        uses: ./.github/actions/prune-esp-idf
-
       - name: Suggested changes
         run: script/ci-suggest-changes
         if: always()
@@ -894,19 +849,16 @@ jobs:
             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
-            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 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
             # yamllint disable-line rule:line-length
             options: --environment esp32c6-idf-tidy --grep SOC_LP_I2C_SUPPORTED --grep USE_ESP32_VARIANT_ESP32C6 --grep USE_OPENTHREAD --grep USE_ZIGBEE
-            tidy_environment: esp32c6-idf-tidy
 
     steps:
       - name: Check out code from GitHub
@@ -924,11 +876,6 @@ jobs:
       - name: Cache ESP-IDF install
         uses: ./.github/actions/cache-esp-idf
 
-      - name: Cache clang-tidy idedata
-        uses: ./.github/actions/cache-clang-tidy-idedata
-        with:
-          environment: ${{ matrix.tidy_environment }}
-
       - name: Register problem matchers
         run: |
           echo "::add-matcher::.github/workflows/matchers/gcc.json"
@@ -962,10 +909,6 @@ jobs:
             script/clang-tidy --fix --changed ${{ matrix.options }}
           fi
 
-      - name: Prune ESP-IDF install before cache save
-        if: (github.ref == 'refs/heads/dev' || contains(github.event.pull_request.labels.*.name, 'ci-cache-write'))
-        uses: ./.github/actions/prune-esp-idf
-
       - name: Suggested changes
         run: script/ci-suggest-changes
         if: always()
@@ -986,6 +929,7 @@ jobs:
       ESPHOME_SDK_NRF_PREFIX: ~/.esphome-sdk-nrf
     strategy:
       fail-fast: false
+      max-parallel: ${{ (startsWith(github.base_ref, 'beta') || startsWith(github.base_ref, 'release')) && 32 || 16 }}
       matrix:
         batch: ${{ fromJson(needs.determine-jobs.outputs.component-test-batches) }}
     steps:
@@ -1072,7 +1016,7 @@ jobs:
           # - This catches pin conflicts and other issues in directly changed code
           # - Grouped tests use --testing-mode to allow config merging (disables some checks)
           # - Dependencies are safe to group since they weren't modified in this PR
-          if [[ "${{ needs.determine-jobs.outputs.release-pr }}" == "true" ]]; then
+          if [[ "${{ github.base_ref }}" == beta* ]] || [[ "${{ github.base_ref }}" == release* ]]; then
             directly_changed_csv=""
             echo "Testing components: $components_csv"
             echo "Target branch: ${{ github.base_ref }} - grouping all components"

.github/workflows/codeql.yml

@@ -56,7 +56,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@db488ddef3bf6cb639b32c2e9a7c0a7ea8271d28 # v4.37.8
+        uses: github/codeql-action/init@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7
         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@db488ddef3bf6cb639b32c2e9a7c0a7ea8271d28 # v4.37.8
+        uses: github/codeql-action/analyze@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7
         with:
           category: "/language:${{matrix.language}}"

CODEOWNERS

@@ -350,7 +350,6 @@ esphome/components/mipi_spi/* @clydebarrow
 esphome/components/mitsubishi/* @RubyBailey
 esphome/components/mitsubishi_cn105/* @crnjan
 esphome/components/mixer/speaker/* @kahrendt
-esphome/components/mk2pvrouter/* @FredM67
 esphome/components/mlx90393/* @functionpointer
 esphome/components/mlx90614/* @jesserockz
 esphome/components/mmc5603/* @benhoff
@@ -477,7 +476,6 @@ esphome/components/sensirion_common/* @martgras
 esphome/components/sensor/* @esphome/core
 esphome/components/serial_proxy/* @kbx81
 esphome/components/sfa30/* @ghsensdev
-esphome/components/sfa40/* @NoQuarrel
 esphome/components/sgp40/* @SenexCrenshaw
 esphome/components/sgp4x/* @martgras @SenexCrenshaw
 esphome/components/sha256/* @esphome/core
@@ -578,7 +576,6 @@ esphome/components/tuya/select/* @bearpawmaxim
 esphome/components/tuya/sensor/* @jesserockz
 esphome/components/tuya/switch/* @jesserockz
 esphome/components/tuya/text_sensor/* @dentra
-esphome/components/tuya/water_heater/* @iago-veiga
 esphome/components/uart/* @esphome/core
 esphome/components/uart/button/* @ssieb
 esphome/components/uart/event/* @eoasmxd

docker/Dockerfile

@@ -22,7 +22,7 @@ RUN \
     -r /requirements.txt
 
 # Install the ESPHome Device Builder dashboard.
-RUN uv pip install --no-cache-dir esphome-device-builder==1.13.1
+RUN uv pip install --no-cache-dir esphome-device-builder==1.12.4
 
 RUN \
     platformio settings set enable_telemetry No \

esphome/__main__.py

@@ -857,20 +857,7 @@ def compile_program(args: ArgsProtocol, config: ConfigType) -> int:
         toolchain.create_factory_bin()
         toolchain.create_ota_bin()
         toolchain.create_elf_copy()
-        from esphome.build_helpers.idedata import IDEDATA_BEST_EFFORT_ERRORS
-
-        try:
-            if toolchain.get_idedata() is None:
-                _LOGGER.warning("No idedata was generated for this build")
-        except IDEDATA_BEST_EFFORT_ERRORS as err:
-            # The firmware already built; an idedata failure must not fail
-            # a successful build.
-            _LOGGER.warning(
-                "Could not generate idedata: %s (IDE, clang-tidy, and "
-                "memory-analysis data will be unavailable for this build)",
-                err,
-            )
-            _LOGGER.debug("Idedata failure detail", exc_info=True)
+        toolchain.get_idedata()
     else:
         from esphome.platformio import toolchain
 
@@ -2734,14 +2721,10 @@ def run_esphome(argv):
     # Skipped when -s overrides are passed, since the cache was written
     # against the previous substitution set.
     config: ConfigType | None = None
-    cache_write_eligible = (
+    cache_eligible = (
         args.command in ("upload", "logs") and not command_line_substitutions
     )
-    # An explicit --toolchain must re-run the per-platform validators, so
-    # gate only the cache read; the refresh below saves the result unless
-    # the sidecar records a different toolchain.
-    cache_read_eligible = cache_write_eligible and args.toolchain is None
-    if cache_read_eligible:
+    if cache_eligible:
         from esphome.compiled_config import load_compiled_config
 
         config = load_compiled_config(conf_path)
@@ -2765,14 +2748,17 @@ def run_esphome(argv):
             return 2
     CORE.config = config
 
-    # The cache fast path skips validation, and legacy sidecars lack the
-    # toolchain field. Must run before the cache refresh below.
+    # Fallback for platforms whose validators didn't set the toolchain
+    # (only the esp32 component reads esp32.framework.toolchain). All
+    # other platforms only support PlatformIO today. Must run before the
+    # cache refresh below so its sidecar records the same toolchain a
+    # compile would.
     if CORE.toolchain is None:
         CORE.toolchain = Toolchain.PLATFORMIO
 
     # Refresh the cache so the next upload/logs hits the fast path
     # instead of re-running read_config.
-    if cache_write_eligible and cache_missed:
+    if cache_eligible and cache_missed:
         from esphome.compiled_config import save_compiled_config_and_sidecar
 
         save_compiled_config_and_sidecar(config)

esphome/arduino/library.py

@@ -1,531 +0,0 @@
-"""Arduino-core backend for the shared PlatformIO library converter.
-
-Bundled names build straight from the framework tree; everything else goes
-through ``esphome.platformio.library``. Mirrors ``lib_ldf_mode=off``: each
-library builds its own archive; all include dirs join one global path.
-
-Deviations from PlatformIO: flat-layout libraries get the recursive default
-source filter; ``dot_a_linkage`` is honored; bundled libraries never run a
-manifest ``extraScript``; manifest ``-I`` flags join the global include path;
-``precompiled``/``ldflags`` properties are refused by name.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-import logging
-from pathlib import Path
-import re
-
-from esphome.core import CORE, EsphomeError, Library
-from esphome.helpers import walk_files
-from esphome.platformio.extra_script import apply_extra_script
-from esphome.platformio.library import (
-    DEFAULT_BUILD_INCLUDE_DIR,
-    DEFAULT_BUILD_SRC_FILTER,
-    ESPHOME_DATA_KEY,
-    ESPHOME_DATA_LINK_FLAGS_KEY,
-    LIBRARY_HEADER_SUFFIXES,
-    SRC_FILE_EXTENSIONS,
-    ConvertedLibrary,
-    IncompatiblePlatform,
-    InvalidLibrary,
-    LibraryBackend,
-    _url_or_none,
-    check_library_data,
-    collect_filtered_files,
-    convert_libraries,
-    ensure_list,
-    is_lib_ignored,
-    lex_build_flags,
-    lib_ignore_set,
-    normalize_dependencies,
-    parse_library_json,
-    parse_library_properties,
-    warn_properties_depends,
-)
-
-_LOGGER = logging.getLogger(__name__)
-
-
-@dataclass
-class ArduinoLibrary:
-    """One resolved library, ready for the ninja generator."""
-
-    name: str
-    sources: list[Path] = field(default_factory=list)
-    include_dirs: list[Path] = field(default_factory=list)
-    # Extra compile flags private to this library's own sources
-    flags: list[str] = field(default_factory=list)
-    # PlatformIO's build.libArchive / Arduino's dot_a_linkage: when False the
-    # objects go to the linker directly (symbols nothing references survive)
-    lib_archive: bool = True
-    # Link inputs the library contributes (-L dirs / -l libs, e.g. from
-    # precompiled vendor blobs) and -Wl, options for the firmware link
-    link_dirs: list[Path] = field(default_factory=list)
-    link_libs: list[str] = field(default_factory=list)
-    link_flags: list[str] = field(default_factory=list)
-
-
-# Source-like suffixes the case-sensitive suffix map rejects
-_UNMAPPED_SOURCE_SUFFIXES = frozenset(
-    {s.lower() for s in SRC_FILE_EXTENSIONS} | {".ino"}
-)
-
-# Filename-plain names: an allowlist excludes separators, drive colons,
-# and dot-only names by shape
-_SAFE_LIBRARY_NAME_RE = re.compile(r"[A-Za-z0-9_][A-Za-z0-9_. +-]*\Z")
-
-
-def _is_safe_library_name(name: object) -> bool:
-    """Whether a name may be joined under the framework's libraries dir."""
-    return isinstance(name, str) and _SAFE_LIBRARY_NAME_RE.fullmatch(name) is not None
-
-
-def _manifest_build(name: str, data: object) -> dict:
-    """The manifest's ``build`` section; malformed manifests fail by name."""
-    build = data.get("build", {}) if isinstance(data, dict) else None
-    if not isinstance(build, dict):
-        raise EsphomeError(f"Library {name} has a malformed manifest")
-    return build
-
-
-def _resolve_src_dir(name: str, read_path: Path, build: dict) -> str:
-    """Resolve PIO's source dir: manifest srcDir, else src/Src, else the root."""
-    if "srcDir" not in build:
-        return next((d for d in ("src", "Src") if (read_path / d).is_dir()), ".")
-    # A declared srcDir (falsy included) that does not resolve is a manifest error
-    src_dir = build["srcDir"]
-    if not (isinstance(src_dir, str) and src_dir and (read_path / src_dir).is_dir()):
-        raise EsphomeError(
-            f"Library {name} declares srcDir {src_dir!r} which does not exist"
-        )
-    return src_dir
-
-
-def _reject_unsupported_link_fields(name: str, data: dict) -> None:
-    # PIO honors these; ignoring them would fail at link with no stated
-    # cause. Property values are strings, so "false" is not a declaration.
-    precompiled = data.get("precompiled")
-    if precompiled and str(precompiled).strip().lower() != "false":
-        raise EsphomeError(
-            f"Library {name} declares precompiled, which this backend does not support"
-        )
-    if data.get("ldflags"):
-        raise EsphomeError(
-            f"Library {name} declares ldflags, which this backend does not support"
-        )
-
-
-def _resolve_lib_archive(name: str, data: dict, build: dict) -> bool:
-    """build.libArchive, else dot_a_linkage (an Arduino IDE property PIO
-    ignores; a deliberate extra), else archive."""
-
-    # Strict parse: bool("false") is True
-    def _parse(key: str, raw: object) -> bool:
-        if isinstance(raw, bool):
-            return raw
-        value = str(raw).strip().lower()
-        if value in ("true", "false"):
-            return value == "true"
-        raise EsphomeError(f"Library {name} has a malformed {key} value {raw!r}")
-
-    if "libArchive" in build:
-        return _parse("libArchive", build["libArchive"])
-    if "dot_a_linkage" in data:
-        return _parse("dot_a_linkage", data["dot_a_linkage"])
-    return True
-
-
-def _classify_build_flags(
-    name: str, read_path: Path, lib: ArduinoLibrary, flag_tokens: list[str]
-) -> list[str]:
-    """Route the lexed build.flags into the library's flag lists.
-
-    Returns the ``-I`` arguments for the include-dir resolution.
-    """
-    include_flags: list[str] = []
-    for tok in flag_tokens:
-        if tok.startswith("-I"):
-            include_flags.append(tok[2:])
-        elif tok.startswith("-L"):
-            link_dir = (read_path / tok[2:]).resolve()
-            if not link_dir.is_dir():
-                # Kept (the linker ignores missing -L dirs); the warning
-                # names the culprit before a bare "cannot find -lfoo"
-                _LOGGER.warning(
-                    "Library %s declares library dir %s which does not exist",
-                    name,
-                    tok[2:],
-                )
-            lib.link_dirs.append(link_dir)
-        elif tok.startswith("-l"):
-            lib.link_libs.append(tok[2:])
-        elif tok.startswith("-Wl,"):
-            lib.link_flags.append(tok)
-        else:
-            lib.flags.append(tok)
-    return include_flags
-
-
-def _resolve_include_dirs(
-    name: str,
-    read_path: Path,
-    lib: ArduinoLibrary,
-    build: dict,
-    src_dir: str,
-    include_flags: list[str],
-) -> None:
-    include_dir = build.get("includeDir", DEFAULT_BUILD_INCLUDE_DIR)
-    if not isinstance(include_dir, str):
-        raise EsphomeError(f"Library {name} has a malformed includeDir")
-    for d, explicit in [
-        (include_dir, "includeDir" in build),
-        (src_dir, False),  # _resolve_src_dir already validated it
-        *((flag, True) for flag in include_flags),
-    ]:
-        if (path := (read_path / d)).is_dir():
-            lib.include_dirs.append(path.resolve())
-        elif explicit:
-            # Warn-and-drop (unlike srcDir): a missing include dir is
-            # harmless until a header is needed, and the compile names it
-            _LOGGER.warning(
-                "Library %s declares include dir %s which does not exist", name, d
-            )
-
-
-def _collect_lib_sources(
-    name: str,
-    read_path: Path,
-    lib: ArduinoLibrary,
-    src_dir: str,
-    src_filter: list[str],
-) -> None:
-    sources: list[Path] = []
-    dropped: list[str] = []
-    saw_header = False
-    for f in collect_filtered_files(read_path / src_dir, src_filter):
-        path = Path(f)
-        suffix = path.suffix
-        if suffix in SRC_FILE_EXTENSIONS:
-            # resolve() per file: srcFilter patterns may escape src_dir
-            sources.append(path.resolve())
-        elif suffix.lower() in _UNMAPPED_SOURCE_SUFFIXES:
-            # A source-like suffix the case-sensitive map rejects (.CPP,
-            # .ino) is a dropped compilation unit; headers fall through
-            dropped.append(path.name)
-        elif suffix.lower() in LIBRARY_HEADER_SUFFIXES:
-            saw_header = True
-    lib.sources = sorted(sources)
-    if dropped:
-        _LOGGER.warning(
-            "Library %s: %d file(s) with unmapped source suffixes are not compiled: %s",
-            name,
-            len(dropped),
-            ", ".join(sorted(dropped)),
-        )
-    if not lib.sources and not saw_header:
-        # Matched headers mean header-only; a filter matching nothing is
-        # a manifest/tree problem (a truly empty tree raises elsewhere)
-        _LOGGER.warning("Library %s: no source files matched", name)
-
-
-def _library_info(name: str, read_path: Path, data: dict) -> ArduinoLibrary:
-    """Resolve one library's sources, include dirs, and flags (PIO semantics)."""
-    build = _manifest_build(name, data)
-    _reject_unsupported_link_fields(name, data)
-    src_dir = _resolve_src_dir(name, read_path, build)
-    src_filter = ensure_list(build.get("srcFilter", DEFAULT_BUILD_SRC_FILTER))
-    if not all(isinstance(entry, str) for entry in src_filter):
-        raise EsphomeError(f"Library {name} has a malformed srcFilter")
-    lib = ArduinoLibrary(name=name, lib_archive=_resolve_lib_archive(name, data, build))
-    # PlatformIO shell-lexes each build.flags entry
-    include_flags = _classify_build_flags(
-        name, read_path, lib, lex_build_flags(build.get("flags", []), f"library {name}")
-    )
-    _resolve_include_dirs(name, read_path, lib, build, src_dir, include_flags)
-    _collect_lib_sources(name, read_path, lib, src_dir, src_filter)
-    return lib
-
-
-def _bundled_library(framework_path: Path, name: str) -> ArduinoLibrary:
-    """A library bundled with the Arduino core, read from the framework tree.
-
-    ``library.json`` wins over ``library.properties`` when both exist, as in
-    PlatformIO's LibBuilderFactory; only the JSON manifest can carry a
-    ``build`` section (srcDir, srcFilter, flags).
-    """
-    lib_dir = framework_path / "libraries" / name
-    manifest_json = lib_dir / "library.json"
-    if manifest_json.is_file():
-        try:
-            data = parse_library_json(manifest_json)
-        except ValueError as err:  # JSONDecodeError
-            raise EsphomeError(
-                f"Bundled library {name} has a corrupt library.json ({err}); "
-                "the framework install may be incomplete (run 'esphome clean-all')"
-            ) from err
-    elif (manifest := lib_dir / "library.properties").is_file():
-        data = parse_library_properties(manifest)
-    else:
-        # Debug, not warning: the legacy manifest-less layout is legal and
-        # the 3.1.2 core ships one such library (FSTools), so a warning
-        # would be unactionable noise on every build using it
-        _LOGGER.debug("Bundled library %s has no manifest; using defaults", name)
-        data = {}
-    if isinstance(data, dict):
-        # Bundled manifest deps are never walked; make the skip visible
-        if data.get("dependencies"):
-            _LOGGER.warning(
-                "Bundled library %s declares dependencies, which are not "
-                "resolved automatically; add them with add_library() if needed",
-                name,
-            )
-        warn_properties_depends(name, data)
-        build = data.get("build")
-        if isinstance(build, dict) and build.get("extraScript"):
-            # Scripts only run on the converted path; building without
-            # the script's flags would miscompile
-            raise EsphomeError(
-                f"Bundled library {name} declares an extraScript, which is "
-                "not run for bundled libraries"
-            )
-    lib = _library_info(name, lib_dir, data)
-    _assert_tree_has_code(
-        name,
-        lib_dir,
-        "the framework install may be incomplete (run 'esphome clean-all')",
-    )
-    return lib
-
-
-def _assert_tree_has_code(name: str, root: Path, hint: str) -> None:
-    """An empty or half-extracted tree can never link; fail by name (a
-    warning would scroll away and resurface as undefined symbols)."""
-    if not any(
-        Path(p).suffix in SRC_FILE_EXTENSIONS
-        or Path(p).suffix.lower() in LIBRARY_HEADER_SUFFIXES
-        for p in walk_files(root)
-    ):
-        raise EsphomeError(f"Library {name} has no sources or headers; {hint}")
-
-
-def _external_short_name(name: str) -> str:
-    """The short library name of a requested spec.
-
-    "owner/Name" and plain names take the last path segment; "Name=<url>"
-    takes the declared name. Git tails (".git", "#ref") are stripped like
-    the walk's URL normalization; the comparand is a manifest dependency
-    name, never a spec.
-    """
-    head, sep, tail = name.partition("=")
-    if sep and "://" in tail:
-        return head
-    short = name.rsplit("/", maxsplit=1)[-1]
-    return short.partition("#")[0].removesuffix(".git")
-
-
-def _check_unfulfilled_provides(
-    provided_requests: set[str], satisfied: set[str], still_requested: set[str]
-) -> None:
-    """Fail by name when a walk-skipped dependency was never added.
-
-    An unfulfilled provides() promise only surfaces as undefined symbols
-    at link. The walk records across re-resolutions, so a name no final
-    manifest still requests is stale state, never a failure.
-    """
-    if missing := sorted((provided_requests & still_requested) - satisfied):
-        raise EsphomeError(
-            "provides() skipped these dependencies but nothing added them: "
-            f"{', '.join(missing)}; the build is missing libraries"
-        )
-
-
-def resolve_libraries(
-    framework_path: Path, *, pio_platform: str, board_mcu: str, cache_key: str
-) -> list[ArduinoLibrary]:
-    """Resolve every ``cg.add_library()`` entry into an :class:`ArduinoLibrary`.
-
-    ``pio_platform``/``board_mcu`` filter manifests the way PlatformIO would
-    for that core (e.g. ``espressif8266``/``esp8266``); ``cache_key`` keys the
-    shared converter's download cache.
-
-    The returned list is not topologically sorted, so the caller must link
-    the archives inside one ``--start-group``/``--end-group`` pair (the
-    bundled-first grouping is incidental).
-    """
-    bundled: list[ArduinoLibrary] = []
-    external: list[Library] = []
-    # PlatformIO's lib_ignore covers framework-bundled libraries too; the
-    # shared converter only filters the registry/git ones.
-    lib_ignore = lib_ignore_set()
-    # Exact directory names keep membership case-sensitive everywhere
-    # (an is_dir() probe would match "wire" on macOS/Windows and build
-    # the bundled Wire twice)
-    libraries_dir = framework_path / "libraries"
-    if not libraries_dir.is_dir():
-        # A registry fallback would fail later with a misleading
-        # package-not-found error per bundled name
-        raise EsphomeError(
-            f"{libraries_dir} is missing; the framework install may be "
-            "incomplete (run 'esphome clean-all')"
-        )
-    bundled_dir_names = frozenset(p.name for p in libraries_dir.iterdir() if p.is_dir())
-
-    def _provided(name: object) -> bool:
-        return _is_safe_library_name(name) and name in bundled_dir_names
-
-    for library in CORE.platformio_libraries.values():
-        if is_lib_ignored(library.name, lib_ignore):
-            continue
-        # Bundled only for a bare name with a matching framework dir; pinned
-        # or unmatched names resolve from the registry, as under PlatformIO.
-        if not library.repository and not library.version and _provided(library.name):
-            # Bundled manifest deps are not walked; _bundled_library warns
-            bundled.append(_bundled_library(framework_path, library.name))
-        else:
-            external.append(library)
-
-    converted: list[ArduinoLibrary] = []
-    bundled_names = {lib.name for lib in bundled}
-    converted_manifest_names: set[str] = set()
-    # Bundled candidates skipped on purpose (platform filter); the
-    # provides() reconciliation must count them as satisfied
-    knowingly_skipped: set[str] = set()
-    # Dependency names of the manifests actually emitted; a walk recording
-    # for a since-re-resolved manifest must not fail the reconciliation
-    final_dep_names: set[str] = set()
-    # Ordered set of bundled dependency names to add once conversion is done
-    pending_bundled: dict[str, None] = {}
-    # Deps matching a separately-requested external are already in the build
-    # (a duplicate archive means duplicate-symbol link errors)
-    external_short_names = {
-        _external_short_name(lib.name) for lib in external if lib.name
-    }
-
-    def _add_bundled_dependencies(component: ConvertedLibrary) -> None:
-        # A version-less bare name ("Hash") is a core-bundled library the
-        # shared converter cannot resolve from the registry
-        for dep in normalize_dependencies(
-            component.data.get("dependencies"), component.name
-        ):
-            # normalize_dependencies guarantees a non-empty str name
-            name = dep["name"]
-            final_dep_names.add(name)
-            if "/" in name:
-                owner, _, pkg = name.partition("/")
-                if _is_safe_library_name(owner) and _is_safe_library_name(pkg):
-                    # Owner-qualified; the converter resolves it from the registry
-                    continue
-            if not _is_safe_library_name(name):
-                # The name becomes a path component; never join a traversal
-                _LOGGER.warning(
-                    "Ignoring malformed dependency entry %r of library %s",
-                    dep,
-                    component.name,
-                )
-                continue
-            if name in external_short_names:
-                if _provided(name):
-                    # A bundled copy is suppressed; a coincidental name
-                    # collision would surface as link errors
-                    _LOGGER.warning(
-                        "Dependency %s of %s is assumed satisfied by a "
-                        "requested external library; the bundled copy is "
-                        "not added",
-                        name,
-                        component.name,
-                    )
-                else:
-                    _LOGGER.debug(
-                        "Dependency %s of %s assumed satisfied by a requested "
-                        "external library",
-                        name,
-                        component.name,
-                    )
-                continue
-            if name in bundled_names or is_lib_ignored(name, lib_ignore):
-                continue
-            if _url_or_none(dep.get("version")) is not None:
-                # A URL names one specific source; never add the bundled copy
-                continue
-            if dep.get("owner") or not _provided(name):
-                # Only owner-less framework-tree names take the bundled
-                # copy (PIO's process_dependencies); the walk reports drops
-                continue
-            try:
-                # framework=None: the walk already warned for non-platform
-                # causes; debug keeps one fault from warning twice (pinned
-                # by test_nonplatform_rejection_warns_once_through_real_converter)
-                check_library_data(dep, pio_platform, None)
-            except IncompatiblePlatform as err:
-                # A knowing skip (platform filter), not a broken promise
-                knowingly_skipped.add(name)
-                _LOGGER.debug("Skip bundled candidate %s: %s", name, err)
-                continue
-            except InvalidLibrary as err:
-                # Malformed manifest data never counts as satisfied; the
-                # walk owns the warning (see the warns-once test above)
-                _LOGGER.debug("Skip malformed bundled candidate %s: %s", name, err)
-                continue
-            # Deferred: a later manifest name may satisfy this
-            pending_bundled.setdefault(name)
-
-    def _emit(component: ConvertedLibrary) -> None:
-        apply_extra_script(
-            component, board_mcu=lambda: board_mcu, pio_platform=pio_platform
-        )
-        _assert_tree_has_code(
-            component.get_require_name(),
-            component.source_dir,
-            "the download may be incomplete (run 'esphome clean-all')",
-        )
-        if isinstance(manifest_name := component.data.get("name"), str):
-            converted_manifest_names.add(manifest_name)
-        lib = _library_info(
-            component.get_require_name(), component.source_dir, component.data
-        )
-        # Extra-script LINKFLAGS travel outside build.flags; dropping
-        # them would link wrong with no stated cause
-        lib.link_flags.extend(
-            component.data.get(ESPHOME_DATA_KEY, {}).get(
-                ESPHOME_DATA_LINK_FLAGS_KEY, []
-            )
-        )
-        converted.append(lib)
-        _add_bundled_dependencies(component)
-
-    backend = LibraryBackend(
-        platform=pio_platform,
-        framework="arduino",
-        emit=_emit,
-        cache_key=cache_key,
-        # The walk must not resolve bundled names from the registry;
-        # _add_bundled_dependencies adds them after emit
-        provides=_provided,
-    )
-    if external:
-        convert_libraries(external, backend)
-    for name in pending_bundled:
-        if name in converted_manifest_names:
-            # The converted library is this one; the bundled copy would
-            # double the archive. Warn like the external_short_names twin.
-            _LOGGER.warning(
-                "Dependency %s is assumed satisfied by a converted library's "
-                "manifest name; the bundled copy is not added",
-                name,
-            )
-            continue
-        bundled_names.add(name)
-        bundled.append(_bundled_library(framework_path, name))
-
-    _check_unfulfilled_provides(
-        backend.provided_requests,
-        bundled_names
-        | converted_manifest_names
-        | external_short_names
-        | knowingly_skipped,
-        final_dep_names,
-    )
-
-    return bundled + converted

esphome/arduino8266/__init__.py

@@ -1,9 +0,0 @@
-"""Native (PlatformIO-free) build support for the ESP8266 Arduino core.
-
-This package downloads the Arduino ESP8266 core and the xtensa-lx106
-toolchain, generates a ninja build for them plus the ESPHome sources, and
-drives the build directly — the ESP8266 equivalent of ``esphome.espidf``.
-
-Deliberately importable without the esp8266 component to avoid circular
-imports; the component wires these modules in via lazy imports.
-"""

esphome/arduino8266/framework.py

@@ -1,164 +0,0 @@
-"""Download and install the Arduino ESP8266 core, toolchain, and ninja.
-
-Artifacts land in a machine-global cache (shared across projects, like the
-ESP-IDF install in ``esphome.espidf.framework``):
-
-    <cache>/arduino8266/frameworks/<version>/   framework-arduinoespressif8266
-    <cache>/arduino8266/toolchains/<version>/   toolchain-xtensa (gcc 10.3)
-
-Packages come from the PlatformIO registry (identical bits to the PlatformIO
-backend); ``ESPHOME_ARDUINO8266_*_MIRRORS`` overrides the URLs. ninja comes
-from PATH or the ninja PyPI wheel.
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-from typing import NamedTuple
-
-from esphome.build_helpers.ccache import ccache_defaults_env
-from esphome.build_helpers.ninja import find_ninja
-from esphome.build_helpers.tools_cache import ARDUINO8266_TOOLS_CACHE, tools_cache_path
-from esphome.core import EsphomeError, Version
-from esphome.framework_helpers import str_to_lst_of_str
-from esphome.platformio.registry import install_package, prefetch_packages
-
-FRAMEWORK_PACKAGE = "framework-arduinoespressif8266"
-TOOLCHAIN_PACKAGE = "toolchain-xtensa"
-# gcc 10.3, the toolchain Arduino core 3.x builds with; the build
-# generator's compile flags are tuned to it.
-TOOLCHAIN_VERSION = "2.100300.220621"
-
-ESPHOME_ARDUINO8266_FRAMEWORK_MIRRORS = str_to_lst_of_str(
-    os.environ.get("ESPHOME_ARDUINO8266_FRAMEWORK_MIRRORS", "")
-)
-ESPHOME_ARDUINO8266_TOOLCHAIN_MIRRORS = str_to_lst_of_str(
-    os.environ.get("ESPHOME_ARDUINO8266_TOOLCHAIN_MIRRORS", "")
-)
-
-
-def get_arduino8266_tools_path() -> Path:
-    # Machine-global so all projects share one install; see
-    # espidf.framework.get_idf_tools_path for the location rationale.
-    return tools_cache_path(*ARDUINO8266_TOOLS_CACHE)
-
-
-# 3.1.1 rather than 3.1.0: the registry has no package for 3.1.0, and the
-# encoder below cannot name 3.0.0/3.0.1 either (see its docstring)
-MIN_FRAMEWORK_VERSION = Version(3, 1, 1)
-
-
-def framework_package_version(ver: Version) -> str:
-    """Map an Arduino core version to its registry package version (3.1.2 ->
-    3.30102.0; the leading 3 is the package major).
-
-    Exact registry names only for cores > 2.6.2 and >= 3.0.2; callers floor
-    at MIN_FRAMEWORK_VERSION.
-    """
-    if ver.major > 3:
-        raise EsphomeError(
-            f"Arduino core {ver} is not supported yet; "
-            "the newest known core series is 3.x"
-        )
-    if ver <= Version(2, 6, 2):
-        # Cores <= 2.6.2 use the older 1.x/2.x package-major encodings (same
-        # boundary as _format_framework_arduino_version's era guard)
-        raise EsphomeError(
-            f"Arduino core {ver} uses an older package encoding than this "
-            "helper implements (newer than 2.6.2)"
-        )
-    return f"3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
-
-
-def get_framework_path(package_version: str) -> Path:
-    return get_arduino8266_tools_path() / "frameworks" / package_version
-
-
-def get_toolchain_path() -> Path:
-    return get_arduino8266_tools_path() / "toolchains" / TOOLCHAIN_VERSION
-
-
-class InstalledPaths(NamedTuple):
-    """Locations of the installed framework, toolchain, and ninja binary."""
-
-    framework: Path
-    toolchain: Path
-    ninja: Path
-
-
-def check_and_install(framework_version: Version) -> InstalledPaths:
-    """Ensure framework, toolchain, and ninja are installed; return their paths."""
-    if framework_version < MIN_FRAMEWORK_VERSION:
-        # Config validation enforces this too; keep the module honest when
-        # called directly.
-        raise EsphomeError(
-            f"The native toolchain requires the Arduino core "
-            f">= {MIN_FRAMEWORK_VERSION}, got {framework_version}"
-        )
-    # Probe the cheap local dependency before ~110 MB of downloads
-    ninja_path = find_ninja()
-    package_version = framework_package_version(framework_version)
-    framework_path = get_framework_path(package_version)
-    downloads_dir = get_arduino8266_tools_path() / "downloads"
-    toolchain_path = get_toolchain_path()
-    # One spec per package: the prefetch and the installs must agree
-    specs = (
-        (
-            FRAMEWORK_PACKAGE,
-            package_version,
-            framework_path,
-            ESPHOME_ARDUINO8266_FRAMEWORK_MIRRORS,
-            ("cores/esp8266", "tools/sdk", "libraries"),
-        ),
-        (
-            TOOLCHAIN_PACKAGE,
-            TOOLCHAIN_VERSION,
-            toolchain_path,
-            ESPHOME_ARDUINO8266_TOOLCHAIN_MIRRORS,
-            # xtensa-lx106-elf pins the target: every gcc package has a bin/
-            ("bin", "xtensa-lx106-elf"),
-        ),
-    )
-    # Fetch both archives at once; the installs below verify and extract
-    prefetch_packages([spec[:4] for spec in specs], downloads_dir)
-    for name, version, dest, mirrors, expect in specs:
-        install_package(name, version, dest, mirrors, downloads_dir, expect=expect)
-    return InstalledPaths(
-        framework=framework_path, toolchain=toolchain_path, ninja=ninja_path
-    )
-
-
-def toolchain_tool(toolchain_path: Path, name: str) -> Path:
-    """Path to one toolchain tool (gcc, g++, ar, size, addr2line, ...).
-
-    The single owner of the ``bin/xtensa-lx106-elf-<name>`` layout and the
-    Windows suffix, so a toolchain package bump touches one spot.
-    """
-    suffix = ".exe" if os.name == "nt" else ""
-    return toolchain_path / "bin" / f"xtensa-lx106-elf-{name}{suffix}"
-
-
-def get_build_env(toolchain_path: Path, ccache: str | None) -> dict[str, str]:
-    env = os.environ.copy()
-    # Drop empty entries: a trailing separator from an absent PATH would
-    # make the shell search the current directory for tools
-    parts = [
-        str(toolchain_path / "bin"),
-        *filter(None, env.get("PATH", "").split(os.pathsep)),
-    ]
-    env["PATH"] = os.pathsep.join(parts)
-    env.update(ccache_env(ccache))
-    return env
-
-
-def ccache_env(ccache: str | None) -> dict[str, str]:
-    """Return ccache settings for the build subprocess (not os.environ).
-
-    ``ccache`` is the pre-resolved binary (resolve_ccache_path), or None
-    when disabled. Values the user already set in the environment are
-    respected.
-    """
-    if ccache is None:
-        return {}
-    return ccache_defaults_env(get_arduino8266_tools_path() / "ccache")

esphome/build_gen/build_tool.py

@@ -1,108 +0,0 @@
-"""Tiny cross-platform build steps invoked from the generated ninja file.
-
-Plain script (not ``python -m``): it runs from ninja with whatever Python
-started esphome and must not depend on the package being importable.
-
-Subcommands:
-    ar <ar-binary> <archive> <rspfile>   remove stale archive, then ``ar rcs``
-    copy <src> <dst>                     copy a file
-
-The ar rspfile carries one object path per line (the generating rule must
-use ``$in_newline``, never ``$in``).
-"""
-
-from pathlib import Path
-import shutil
-import subprocess
-import sys
-
-
-def _read_rspfile(rspfile: str) -> list[str]:
-    r"""The object paths listed in ``rspfile``, unquoted.
-
-    GNU ar treats backslashes in response files as escapes (corrupts
-    Windows paths), so the caller expands the list into argv; strip the
-    simple surrounding quote ninja adds to special paths, then undo
-    ninja's POSIX escape for an embedded quote ('a'\\''b.o' -> a'b.o).
-    """
-    return [
-        line[1:-1].replace("'\\''", "'")
-        if len(line) >= 2 and line[0] == line[-1] and line[0] in "'\""
-        else line
-        for line in Path(rspfile).read_text(encoding="utf-8").splitlines()
-        if line
-    ]
-
-
-def _run_ar(ar: str, archive: str, rspfile: str) -> int:
-    # Remove first: ``ar rcs`` replaces members but never drops ones whose
-    # source was removed from the build, which would leak stale objects.
-    Path(archive).unlink(missing_ok=True)
-    objects = _read_rspfile(rspfile)
-    if not objects:
-        # An empty archive would "succeed" here and fail far away at link
-        print(f"ar: no objects listed in {rspfile} for {archive}", file=sys.stderr)
-        return 1
-    # Batch by argv length: expanding the rspfile gives back the Windows
-    # 32767-char command-line limit it existed to avoid. "rcs" creates,
-    # "qs" appends; the s keeps the symbol index explicit on every ar.
-    op = "rcs"
-    ok = False
-    try:
-        while objects:
-            batch = [objects.pop(0)]
-            batch_len = len(batch[0])
-            while objects and batch_len + len(objects[0]) < 25000:
-                batch_len += len(objects[0]) + 1
-                batch.append(objects.pop(0))
-            rc = subprocess.run(
-                [ar, op, archive, *batch], check=False, close_fds=False
-            ).returncode
-            if rc != 0:
-                return rc
-            op = "qs"
-        ok = True
-        return 0
-    finally:
-        if not ok:
-            # Any failure (bad exit, missing ar binary, interrupt) must not
-            # leave a truncated archive behind
-            Path(archive).unlink(missing_ok=True)
-
-
-def _run_copy(src: str, dst: str) -> int:
-    try:
-        shutil.copyfile(src, dst)
-    except OSError as err:
-        # Never leave a partially written output (e.g. a firmware image);
-        # SameFileError means dst IS src, where unlinking destroys the input
-        if not isinstance(err, shutil.SameFileError):
-            Path(dst).unlink(missing_ok=True)
-        print(f"copy: {src} -> {dst} failed: {err}", file=sys.stderr)
-        return 1
-    return 0
-
-
-# mode -> (handler, expected operand count); surplus argv means a
-# mis-specified ninja rule and must error, not silently drop operands
-_MODES = {"ar": (_run_ar, 3), "copy": (_run_copy, 2)}
-
-
-def main() -> int:
-    mode = sys.argv[1] if len(sys.argv) > 1 else ""
-    if entry := _MODES.get(mode):
-        handler, argc = entry
-        args = sys.argv[2:]
-        if len(args) != argc:
-            print(
-                f"build_tool {mode}: expected {argc} arguments, got {len(args)}",
-                file=sys.stderr,
-            )
-            return 1
-        return handler(*args)
-    print(f"unknown build_tool mode: {mode}", file=sys.stderr)
-    return 1
-
-
-if __name__ == "__main__":  # pragma: no cover
-    sys.exit(main())

esphome/build_gen/espidf.py

@@ -1,7 +1,6 @@
 """ESP-IDF direct build generator for ESPHome."""
 
 import json
-import logging
 from pathlib import Path
 
 from esphome.components.esp32 import (
@@ -12,7 +11,6 @@ from esphome.components.esp32 import (
 )
 import esphome.config_validation as cv
 from esphome.core import CORE
-from esphome.espidf import variant_to_idf_target
 from esphome.framework_helpers import (
     get_project_compile_flags,
     get_project_cxx_compile_flags,
@@ -20,8 +18,6 @@ from esphome.framework_helpers import (
 )
 from esphome.helpers import mkdir_p, write_file_if_changed
 
-_LOGGER = logging.getLogger(__name__)
-
 # Replaces the IDF default C++ standard (-std=gnu++2b appended to
 # CXX_COMPILE_OPTIONS by project.cmake's __build_init) with the one set via
 # cg.set_cpp_standard(). Emitted between include(project.cmake) and project(),
@@ -35,12 +31,11 @@ idf_build_set_property(CXX_COMPILE_OPTIONS "${{esphome_cxx_compile_options}}")""
 
 
 def get_available_components() -> list[str] | None:
-    """List the built-in ESP-IDF components from ``project_description.json``.
+    """Get list of built-in ESP-IDF components from project_description.json.
 
-    Only components below its ``idf_path/components`` count, which leaves out
-    ``src``, IDF-managed components, converted PIO libs and project local
-    ones such as the Arduino ``component_stubs``. Returns ``None`` if the
-    build dir or ``project_description.json`` isn't ready yet.
+    Excludes ``src``, IDF-managed components (``managed_components/``), and
+    converted PIO libs (``pio_components/``). Returns ``None`` if the build
+    dir or ``project_description.json`` isn't ready yet.
     """
     if CORE.build_path is None:
         return None
@@ -51,24 +46,30 @@ def get_available_components() -> list[str] | None:
     try:
         with project_desc.open(encoding="utf-8") as f:
             data = json.load(f)
-        root = (Path(data["idf_path"]) / "components").resolve()
-        result = [
-            name
-            for name, info in data.get("build_component_info", {}).items()
-            if (comp_dir := info.get("dir"))
-            and Path(comp_dir).resolve().is_relative_to(root)
-        ]
-    except (json.JSONDecodeError, KeyError, OSError) as err:
-        _LOGGER.debug("Could not read %s: %s", project_desc, err)
+
+        component_info = data.get("build_component_info", {})
+
+        result = []
+        for name, info in component_info.items():
+            # Exclude our own src component
+            if name == "src":
+                continue
+
+            # Exclude IDF-managed and converted-PIO components (external).
+            comp_dir = info.get("dir", "")
+            if "managed_components" in comp_dir or "pio_components" in comp_dir:
+                continue
+
+            result.append(name)
+
+        return result
+    except (json.JSONDecodeError, OSError):
         return None
-    if not result:
-        _LOGGER.warning("No ESP-IDF components found under %s", root)
-    return result
 
 
 def has_discovered_components() -> bool:
-    """Check if a previous configure discovered any built-in components."""
-    return bool(get_available_components())
+    """Check if we have discovered components from a previous configure."""
+    return get_available_components() is not None
 
 
 def _cmake_quote(value: str) -> str:
@@ -78,17 +79,15 @@ def _cmake_quote(value: str) -> str:
     return f'"{escaped}"'
 
 
-def get_project_cmakelists(
-    minimal: bool = False, builtin_components: list[str] | None = None
-) -> str:
+def get_project_cmakelists(minimal: bool = False) -> str:
     """Generate the top-level CMakeLists.txt for ESP-IDF project.
 
     When ``minimal`` is true, omit ``ESPHOME_PROJECT_BUILTIN_COMPONENTS``
     since ``project_description.json`` may be stale on the first write.
-    ``builtin_components`` supplies the discovered list (from the cache)
-    instead of reading it from ``project_description.json``.
     """
-    idf_target = variant_to_idf_target(get_esp32_variant())
+    # Get IDF target from ESP32 variant (e.g., ESP32S3 -> esp32s3)
+    variant = get_esp32_variant()
+    idf_target = variant.lower().replace("-", "")
 
     # esp_idf_size 2.x (bundled with IDF >=6.0) made NG the default and
     # removed the --ng flag; on 1.x (IDF 5.5) --ng is required to get
@@ -163,11 +162,9 @@ def get_project_cmakelists(
         else "\n".join(
             f"idf_build_set_property(ESPHOME_PROJECT_BUILTIN_COMPONENTS {name} APPEND)"
             for name in sorted(
-                set(
-                    builtin_components
-                    if builtin_components is not None
-                    else get_available_components() or []
-                ).difference(CORE.cmake_args.get("EXCLUDE_COMPONENTS", "").split(";"))
+                set(get_available_components() or []).difference(
+                    CORE.cmake_args.get("EXCLUDE_COMPONENTS", "").split(";")
+                )
             )
         )
     )
@@ -282,9 +279,7 @@ target_link_options(${{COMPONENT_LIB}} PUBLIC
 """
 
 
-def write_project(
-    minimal: bool = False, builtin_components: list[str] | None = None
-) -> None:
+def write_project(minimal: bool = False) -> None:
     """Write ESP-IDF project files."""
     mkdir_p(CORE.build_path)
     mkdir_p(CORE.relative_src_path())
@@ -292,7 +287,7 @@ def write_project(
     # Write top-level CMakeLists.txt
     write_file_if_changed(
         CORE.relative_build_path("CMakeLists.txt"),
-        get_project_cmakelists(minimal=minimal, builtin_components=builtin_components),
+        get_project_cmakelists(minimal=minimal),
     )
 
     # Write component CMakeLists.txt in src/

esphome/build_helpers/__init__.py

@@ -1 +0,0 @@
-"""Build helpers shared by the native (non-PlatformIO) toolchains."""

esphome/build_helpers/ccache.py

@@ -1,92 +0,0 @@
-"""Shared ccache policy for build backends: env-knob parsing, binary
-resolution, and default ``CCACHE_*`` values."""
-
-from __future__ import annotations
-
-import logging
-import os
-from pathlib import Path
-
-from esphome.framework_helpers import strip_win_long_path_prefix, tool_version_runs
-from esphome.helpers import FALSY_ENV_STRINGS, TRUTHY_ENV_STRINGS
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def _ccache_runs(ccache: str) -> bool:
-    """Return True when the ``ccache`` found on PATH actually runs."""
-    return tool_version_runs(
-        ccache,
-        "Ignoring ccache at %s because it failed to run; compiling without ccache",
-    )
-
-
-def parse_enable_env(name: str) -> bool | None:
-    """Strictly parse an on/off environment knob; None when unset or invalid.
-
-    ``bool(str)`` truthiness would flip ``no``/``off`` to enabled, so only
-    1/true/yes/on and 0/false/no/off count; anything else warns and reads
-    as unset so the caller's default policy applies.
-    """
-    raw = os.environ.get(name)
-    if raw is None:
-        return None
-    lowered = raw.strip().lower()
-    if not lowered:
-        # ENV KNOB= (Docker/CI) has always read as a disable
-        return False
-    if lowered in TRUTHY_ENV_STRINGS:
-        return True
-    if lowered in FALSY_ENV_STRINGS:
-        return False
-    _LOGGER.warning("Ignoring unrecognized %s=%r; use 1 or 0", name, raw)
-    return None
-
-
-def resolve_ccache_path() -> str | None:
-    """The ccache binary to wrap compiles with, or None when disabled.
-
-    An explicit ``ESPHOME_CCACHE_ENABLE=1`` skips the runnability probe; the
-    Windows extended-length prefix is stripped before probing (#18399).
-    """
-    import shutil
-
-    explicit = parse_enable_env("ESPHOME_CCACHE_ENABLE")
-    if explicit is False:
-        return None
-    ccache = shutil.which("ccache")
-    if ccache is None:
-        if explicit:
-            _LOGGER.warning(
-                "ESPHOME_CCACHE_ENABLE is set but no ccache binary is on PATH; "
-                "compiling without ccache"
-            )
-        return None
-    ccache = strip_win_long_path_prefix(ccache)
-    if not explicit and not _ccache_runs(ccache):
-        return None
-    return ccache
-
-
-def ccache_defaults_env(cache_dir: Path) -> dict[str, str]:
-    """Default ``CCACHE_*`` values for a build subprocess (not os.environ).
-
-    Values the user already set in the environment are respected. Depend
-    mode is on: both native backends emit depfiles (-MMD / CMake), which
-    keeps cache-miss overhead low.
-    """
-    from esphome.core import CORE
-
-    # An unset build_path means the env was built before preload; fail loudly
-    # rather than silently drop CCACHE_BASEDIR.
-    if CORE.build_path is None:
-        raise ValueError(
-            "CORE.build_path must be set before constructing the build environment"
-        )
-    defaults = {
-        "CCACHE_DIR": str(cache_dir),
-        "CCACHE_NOHASHDIR": "true",
-        "CCACHE_DEPEND": "1",
-        "CCACHE_BASEDIR": str(Path(CORE.build_path).resolve()),
-    }
-    return {k: v for k, v in defaults.items() if k not in os.environ}

esphome/build_helpers/ninja.py

@@ -1,92 +0,0 @@
-"""Platform-neutral helpers for ninja-driven native builds."""
-
-from __future__ import annotations
-
-import logging
-import os
-from pathlib import Path
-import re
-import shutil
-
-from esphome.core import EsphomeError
-from esphome.framework_helpers import strip_win_long_path_prefix, tool_version_runs
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def _ninja_runs(binary: str) -> bool:
-    """Whether the ninja found on PATH actually runs (see tool_version_runs)."""
-    return tool_version_runs(
-        binary,
-        "Ignoring ninja at %s because it failed to run; "
-        "falling back to the bundled wheel",
-    )
-
-
-def find_ninja() -> Path:
-    """Locate the ninja binary: a runnable PATH hit first, else the ninja
-    PyPI wheel."""
-    if binary := shutil.which("ninja"):
-        binary = strip_win_long_path_prefix(binary)
-        if _ninja_runs(binary):
-            return Path(binary)
-    import_error: ImportError | None = None
-    try:
-        import ninja
-    except ImportError as err:
-        import_error = err
-        wheel_binary = None
-    else:
-        wheel_binary = Path(ninja.BIN_DIR) / (
-            "ninja.exe" if os.name == "nt" else "ninja"
-        )
-    if wheel_binary is None or not wheel_binary.is_file():
-        raise EsphomeError(
-            "ninja not found on PATH or in the ninja package; reinstall the "
-            "esphome Python environment"
-        ) from import_error
-    return wheel_binary
-
-
-def escape(value: Path | str) -> str:
-    """Escape a path or token for a ninja file."""
-    return str(value).replace("$", "$$").replace(":", "$:").replace(" ", "$ ")
-
-
-def quote_arg(tok: str) -> str:
-    """Quote with the CreateProcess argv rule (as ``subprocess.list2cmdline``):
-    backslash runs double only before a quote. Windows-only; ``$`` must
-    already be doubled for ninja.
-    """
-    quoted = re.sub(r'(\\*)"', lambda m: m.group(1) * 2 + '\\"', tok)
-    quoted = re.sub(r"(\\+)\Z", lambda m: m.group(1) * 2, quoted)
-    return f'"{quoted}"'
-
-
-# Force-quote any token containing a character outside the shlex.quote-style
-# safe set: ninja hands POSIX commands to /bin/sh -c, so bare (, ;, <, *, `
-# and friends would be re-parsed as shell syntax.
-_NEEDS_QUOTE = re.compile(r"[^\w@%+=:,./-]")
-
-
-def shell_token(tok: str, force: bool = False) -> str:
-    """Re-quote a lexed token for the platform shell; ``force`` always quotes.
-
-    Single quotes on POSIX (/bin/sh), the argv rule on Windows
-    (CreateProcess). ``$`` is doubled first because ninja expands it before
-    the command reaches the shell.
-    """
-    tok = tok.replace("$", "$$")  # ninja would expand a bare $ to nothing
-    if not (force or not tok or _NEEDS_QUOTE.search(tok)):
-        return tok
-    # An empty token must become '' / "" or it vanishes from the argv
-    if os.name == "nt":
-        return quote_arg(tok)
-    # shlex.quote's rule; inlined because the $-doubled token must not be
-    # re-examined for safe characters
-    return "'" + tok.replace("'", "'\"'\"'") + "'"
-
-
-def quote_path(value: Path | str) -> str:
-    """Force-quote a path for the ninja command line (shell/CreateProcess)."""
-    return shell_token(str(value), force=True)

esphome/build_helpers/size_summary.py

@@ -1,24 +0,0 @@
-"""The PlatformIO-format size bar shared by the native toolchains."""
-
-from __future__ import annotations
-
-
-def format_bar(used: int, total: int) -> str:
-    """Match PlatformIO's ``_format_availale_bytes`` (sic, pioupload.py) exactly."""
-    pct_raw = used / total if total else 0
-    blocks = 10
-    filled = min(int(round(blocks * pct_raw)), blocks)
-    progress = "=" * filled
-    return (
-        f"[{progress:<{blocks}}] {pct_raw: 6.1%} "
-        f"(used {used:d} bytes from {total:d} bytes)"
-    )
-
-
-def print_size_line(label: str, used: int, total: int) -> None:
-    """One PlatformIO-format summary line (``RAM``/``Flash``).
-
-    The label padding is part of the format: ``script/ci_memory_impact_extract.py``
-    matches these lines verbatim.
-    """
-    print(f"{label + ':':<7}{format_bar(used, total)}")

esphome/build_helpers/tools_cache.py

@@ -1,36 +0,0 @@
-"""Machine-global tools cache location shared by the native backends."""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-
-def tools_cache_path(env_var: str, subdir: str) -> Path:
-    """A backend's machine-global tools directory, with an env override.
-
-    A blank/whitespace override is treated as unset: ``Path("")`` resolves
-    to the CWD, which ``clean-all`` would then delete.
-    """
-    import platformdirs
-
-    from esphome.helpers import get_str_env
-
-    if prefix := get_str_env(env_var, "").strip():
-        # resolve(): symlinked prefixes otherwise trip idf.py's
-        # venv-mismatch warning on every build
-        return Path(prefix).expanduser().resolve()
-    # appauthor=False keeps the Windows path short (no vendor segment);
-    # deep IDF trees run into MAX_PATH otherwise
-    return (
-        Path(platformdirs.user_cache_dir("esphome", appauthor=False)) / subdir
-    ).resolve()
-
-
-# (env override, cache subdir) per native backend. writer.clean_all wipes
-# every entry via tools_cache_path, so listing a cache here is the single
-# step that registers it for removal; the backends' own path getters use
-# the same named pairs so the two cannot drift.
-IDF_TOOLS_CACHE = ("ESPHOME_ESP_IDF_PREFIX", "idf")
-SDK_NRF_TOOLS_CACHE = ("ESPHOME_SDK_NRF_PREFIX", "sdk-nrf")
-ARDUINO8266_TOOLS_CACHE = ("ESPHOME_ARDUINO8266_PREFIX", "arduino8266")
-TOOLS_CACHE_SPECS = (IDF_TOOLS_CACHE, SDK_NRF_TOOLS_CACHE, ARDUINO8266_TOOLS_CACHE)

esphome/compiled_config.py

@@ -100,21 +100,6 @@ def _refresh_sidecar() -> bool:
             )
             return False
         if old is not None and old.can_apply_to_core():
-            if (
-                old.toolchain is not None
-                and CORE.toolchain is not None
-                and old.toolchain != CORE.toolchain.value
-            ):
-                # Platforms normalize toolchain-sensitive keys differently;
-                # never cache a config validated under a different toolchain
-                # than the compile's
-                _LOGGER.debug(
-                    "Not caching: config validated with toolchain %r but the "
-                    "last compile used %r",
-                    CORE.toolchain.value,
-                    old.toolchain,
-                )
-                return False
             # Compile-written; nothing to refresh.
             return True
         if CORE.build_path is not None and CORE.build_path.exists():

esphome/components/api/__init__.py

@@ -1,5 +1,4 @@
 import logging
-import re
 from typing import Any
 
 from esphome import automation
@@ -500,40 +499,6 @@ async def to_code(config: ConfigType) -> None:
 
 KEY_VALUE_SCHEMA = cv.Schema({cv.string: cv.templatable(cv.string_strict)})
 
-_ID_CALL_PROG = re.compile(r"\bid\s*\(")
-
-
-# Remove before 2027.3.0: untagged strings that look like lambda source keep
-# being compiled as lambdas during the deprecation window
-def _coerce_implicit_lambda(value: Any) -> Any:
-    if not isinstance(value, str):
-        return value
-    if cv.looks_like_returning_lambda(value):
-        _LOGGER.warning(
-            "[api] The 'variables' value '%s' looks like a lambda but is "
-            "missing the !lambda tag. It is compiled as a lambda for now but "
-            "will be sent as literal text from 2027.3.0. Add !lambda to keep "
-            "it evaluated; literal text belongs under 'data:'.",
-            value,
-        )
-        # cv.templatable runs returning_lambda on the coerced Lambda
-        return cv.lambda_(value)
-    if _ID_CALL_PROG.search(value):
-        # lambda source without a return: issue 5394's mistake class
-        _LOGGER.warning(
-            "[api] The 'variables' value '%s' is sent as literal text; wrap "
-            "it in !lambda 'return ...;' to evaluate it instead.",
-            value,
-        )
-    return value
-
-
-# Static strings or !lambda values. cv.templatable stays introspectable for
-# schema tooling; removing the shim leaves KEY_VALUE_SCHEMA.
-VARIABLES_SCHEMA = cv.Schema(
-    {cv.string: cv.All(_coerce_implicit_lambda, cv.templatable(cv.string_strict))}
-)
-
 
 def _validate_response_config(config: ConfigType) -> ConfigType:
     # Validate dependencies:
@@ -570,7 +535,9 @@ HOMEASSISTANT_ACTION_ACTION_SCHEMA = cv.All(
             ),
             cv.Optional(CONF_DATA, default={}): KEY_VALUE_SCHEMA,
             cv.Optional(CONF_DATA_TEMPLATE, default={}): KEY_VALUE_SCHEMA,
-            cv.Optional(CONF_VARIABLES, default={}): VARIABLES_SCHEMA,
+            cv.Optional(CONF_VARIABLES, default={}): cv.Schema(
+                {cv.string: cv.returning_lambda}
+            ),
             cv.Optional(CONF_RESPONSE_TEMPLATE): cv.templatable(cv.string),
             cv.Optional(CONF_CAPTURE_RESPONSE, default=False): cv.boolean,
             cv.Optional(CONF_ON_SUCCESS): automation.validate_automation(single=True),
@@ -631,8 +598,6 @@ async def homeassistant_service_to_code(
     cg.add(var.init_variables(len(config[CONF_VARIABLES])))
     for key, value in config[CONF_VARIABLES].items():
         templ = await cg.templatable(value, args, None)
-        if isinstance(templ, str):
-            templ = cg.FlashStringLiteral(templ)
         cg.add(var.add_variable(cg.FlashStringLiteral(key), templ))
 
     if on_error := config.get(CONF_ON_ERROR):
@@ -687,7 +652,7 @@ HOMEASSISTANT_EVENT_ACTION_SCHEMA = cv.Schema(
         cv.Required(CONF_EVENT): validate_homeassistant_event,
         cv.Optional(CONF_DATA, default={}): KEY_VALUE_SCHEMA,
         cv.Optional(CONF_DATA_TEMPLATE, default={}): KEY_VALUE_SCHEMA,
-        cv.Optional(CONF_VARIABLES, default={}): VARIABLES_SCHEMA,
+        cv.Optional(CONF_VARIABLES, default={}): KEY_VALUE_SCHEMA,
     }
 )
 
@@ -733,8 +698,6 @@ async def homeassistant_event_to_code(
     cg.add(var.init_variables(len(config[CONF_VARIABLES])))
     for key, value in config[CONF_VARIABLES].items():
         templ = await cg.templatable(value, args, None)
-        if isinstance(templ, str):
-            templ = cg.FlashStringLiteral(templ)
         cg.add(var.add_variable(cg.FlashStringLiteral(key), templ))
 
     return var

esphome/components/api/api.proto

@@ -232,7 +232,6 @@ enum SerialProxyPortType {
 message SerialProxyInfo {
   string name = 1;                    // Human-readable port name
   SerialProxyPortType port_type = 2;  // Port type (RS232, RS485)
-  uint32 configured_line_states = 3;  // Bitmask of SerialProxyLineStateFlags this instance can drive
 }
 
 // DeviceInfoResponse max_data_length values:
@@ -1654,8 +1653,7 @@ message ListEntitiesMediaPlayerResponse {
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
 
-  // Deprecated in ESPHome 2026.9.0; use feature_flags instead.
-  bool supports_pause = 8 [deprecated = true];
+  bool supports_pause = 8;
 
   repeated MediaPlayerSupportedFormat supported_formats = 9;
 
@@ -2628,22 +2626,6 @@ message ZWaveProxyRequest {
   bytes data = 2;
 }
 
-enum ZWaveProxyStatus {
-  ZWAVE_PROXY_STATUS_OK = 0;             // Request completed successfully
-  ZWAVE_PROXY_STATUS_IN_USE = 1;         // Denied: another client is already subscribed
-  ZWAVE_PROXY_STATUS_NOT_SUPPORTED = 2;  // Request type not supported
-}
-
-// Acknowledges a ZWaveProxyRequest (subscribe/unsubscribe). Sent since API 1.16.
-message ZWaveProxyRequestResponse {
-  option (id) = 151;
-  option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_ZWAVE_PROXY";
-
-  ZWaveProxyRequestType type = 1;  // Which request type this responds to
-  ZWaveProxyStatus status = 2;     // Result status
-}
-
 // ==================== INFRARED ====================
 // Note: Feature and capability flag enums are defined in
 // esphome/components/infrared/infrared.h
@@ -2787,18 +2769,12 @@ message SerialProxyGetModemPinsResponse {
 
   uint32 instance = 1;          // Instance index (0-based)
   uint32 line_states = 2;       // Bitmask of SerialProxyLineStateFlags
-  SerialProxyStatus status = 3; // INVALID_ARGUMENT if the instance index is out of range (since API 1.16)
 }
 
 enum SerialProxyRequestType {
   SERIAL_PROXY_REQUEST_TYPE_SUBSCRIBE = 0;   // Subscribe to receive data from this serial proxy instance
   SERIAL_PROXY_REQUEST_TYPE_UNSUBSCRIBE = 1; // Unsubscribe from this serial proxy instance
   SERIAL_PROXY_REQUEST_TYPE_FLUSH = 2;       // Flush the serial port (block until all TX data is sent)
-  // Values below are only valid in SerialProxyRequestResponse.type, identifying which
-  // operation is being acknowledged. Sending them in SerialProxyRequest.type is an
-  // error the device answers with INVALID_ARGUMENT.
-  SERIAL_PROXY_REQUEST_TYPE_CONFIGURE = 3;      // Acknowledges a SerialProxyConfigureRequest
-  SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS = 4; // Acknowledges a SerialProxySetModemPinsRequest
 }
 
 enum SerialProxyStatus {
@@ -2807,8 +2783,6 @@ enum SerialProxyStatus {
   SERIAL_PROXY_STATUS_ERROR = 2;           // Driver or hardware error
   SERIAL_PROXY_STATUS_TIMEOUT = 3;         // Timed out before TX completed
   SERIAL_PROXY_STATUS_NOT_SUPPORTED = 4;   // Request type not supported by this instance
-  SERIAL_PROXY_STATUS_PORT_IN_USE = 5;     // Denied: another client holds the port
-  SERIAL_PROXY_STATUS_INVALID_ARGUMENT = 6; // Invalid instance index or parameter value
 }
 
 // Generic request message for simple serial proxy operations
@@ -2821,9 +2795,7 @@ message SerialProxyRequest {
   SerialProxyRequestType type = 2;      // Request type
 }
 
-// Acknowledges a serial proxy operation; the type field identifies which
-// operation is being acknowledged. Flush has been acknowledged since the
-// message was introduced; all other acknowledgements are sent since API 1.16.
+// Response to a SerialProxyRequest (e.g. flush completion or failure)
 message SerialProxyRequestResponse {
   option (id) = 147;
   option (source) = SOURCE_SERVER;

esphome/components/api/api_buffer.cpp

@@ -1,20 +1,13 @@
 #include "api_buffer.h"
-#include <new>
 
 namespace esphome::api {
 
-bool APIBuffer::grow_(size_t n) {
-  // nothrow (no zero-fill) so OOM is reportable; plain new aborts instead
-  // (NEW_OOM_ABORT on ESP8266 Arduino, exception stub on ESP-IDF).
-  // RAMAllocator is no fit here: unique_ptr needs delete[]-compatible memory.
-  std::unique_ptr<uint8_t[]> new_data(new (std::nothrow) uint8_t[n]);
-  if (new_data == nullptr)
-    return false;
+void APIBuffer::grow_(size_t n) {
+  auto new_data = make_buffer(n);
   if (this->size_)
     std::memcpy(new_data.get(), this->data_.get(), this->size_);
   this->data_ = std::move(new_data);
   this->capacity_ = n;
-  return true;
 }
 
 }  // namespace esphome::api

esphome/components/api/api_buffer.h

@@ -9,6 +9,16 @@
 
 namespace esphome::api {
 
+/// Helper to use make_unique_for_overwrite where available (skips zero-fill),
+/// falling back to make_unique on older GCC (ESP8266, LibreTiny).
+inline std::unique_ptr<uint8_t[]> make_buffer(size_t n) {
+#if defined(USE_ESP8266) || defined(USE_LIBRETINY)
+  return std::make_unique<uint8_t[]>(n);
+#else
+  return std::make_unique_for_overwrite<uint8_t[]>(n);
+#endif
+}
+
 /// Byte buffer that skips zero-initialization on resize().
 ///
 /// std::vector<uint8_t>::resize() zero-fills new bytes via memset. For the
@@ -26,23 +36,23 @@ namespace esphome::api {
 class APIBuffer {
  public:
   void clear() { this->size_ = 0; }
-  /// Returns false if allocation fails; the buffer is left unchanged.
-  [[nodiscard]] inline bool reserve(size_t n) ESPHOME_ALWAYS_INLINE { return n <= this->capacity_ || this->grow_(n); }
-  /// Returns false if allocation fails; the buffer is left unchanged. No zero-fill.
-  [[nodiscard]] inline bool resize(size_t n) ESPHOME_ALWAYS_INLINE { return this->reserve_and_resize(n, n); }
+  inline void reserve(size_t n) ESPHOME_ALWAYS_INLINE {
+    if (n > this->capacity_)
+      this->grow_(n);
+  }
+  inline void resize(size_t n) ESPHOME_ALWAYS_INLINE {
+    this->reserve(n);
+    this->size_ = n;  // no zero-fill
+  }
   /// Reserve capacity for max(reserve_size, new_size) bytes, then set size to new_size.
   /// Single grow_ check regardless of argument order.
-  /// Returns false if allocation fails; the buffer is left unchanged.
-  [[nodiscard]] inline bool reserve_and_resize(size_t reserve_size, size_t new_size) ESPHOME_ALWAYS_INLINE {
-    if (!this->reserve(std::max(reserve_size, new_size)))
-      return false;
+  inline void reserve_and_resize(size_t reserve_size, size_t new_size) ESPHOME_ALWAYS_INLINE {
+    this->reserve(std::max(reserve_size, new_size));
     this->size_ = new_size;
-    return true;
   }
   uint8_t *data() { return this->data_.get(); }
   const uint8_t *data() const { return this->data_.get(); }
   size_t size() const { return this->size_; }
-  size_t capacity() const { return this->capacity_; }
   bool empty() const { return this->size_ == 0; }
   uint8_t &operator[](size_t i) { return this->data_[i]; }
   const uint8_t &operator[](size_t i) const { return this->data_[i]; }
@@ -54,7 +64,7 @@ class APIBuffer {
   }
 
  protected:
-  bool grow_(size_t n);
+  void grow_(size_t n);
   std::unique_ptr<uint8_t[]> data_;
   size_t size_{0};
   size_t capacity_{0};

esphome/components/api/api_connection.cpp

@@ -1,6 +1,6 @@
 #include "api_connection.h"
 #ifdef USE_API
-#include "api_connection_buffer.h"  // for the APIServer-dependent APIConnection inlines
+#include "api_connection_buffer.h"  // for encode_to_buffer / get_batch_delay_ms_ inlines
 #ifdef USE_API_NOISE
 #include "api_frame_helper_noise.h"
 #endif
@@ -1099,6 +1099,7 @@ uint16_t APIConnection::try_send_media_player_info(EntityBase *entity, APIConnec
   auto *media_player = static_cast<media_player::MediaPlayer *>(entity);
   ListEntitiesMediaPlayerResponse msg;
   auto traits = media_player->get_traits();
+  msg.supports_pause = traits.get_supports_pause();
   msg.feature_flags = traits.get_feature_flags();
   for (auto &supported_format : traits.get_supported_formats()) {
     msg.supported_formats.emplace_back();
@@ -1380,12 +1381,7 @@ void APIConnection::on_z_wave_proxy_frame(const ZWaveProxyFrame &msg) {
 }
 
 void APIConnection::on_z_wave_proxy_request(const ZWaveProxyRequest &msg) {
-  ZWaveProxyRequestResponse resp{};
-  resp.type = msg.type;
-  resp.status = zwave_proxy::global_zwave_proxy->zwave_proxy_request(this, msg.type);
-  if (!this->send_message(resp)) {
-    API_LOG_MSG_DROPPED(TAG, "Z-Wave proxy response");
-  }
+  zwave_proxy::global_zwave_proxy->zwave_proxy_request(this, msg.type);
 }
 #endif
 
@@ -1554,50 +1550,15 @@ void APIConnection::send_infrared_rf_receive_event(const InfraredRFReceiveEvent
 #endif
 
 #ifdef USE_SERIAL_PROXY
-static enums::SerialProxyStatus serial_proxy_result_to_status(serial_proxy::SerialProxyResult result) {
-  switch (result) {
-    case serial_proxy::SerialProxyResult::SERIAL_PROXY_RESULT_OK:
-      return enums::SERIAL_PROXY_STATUS_OK;
-    case serial_proxy::SerialProxyResult::SERIAL_PROXY_RESULT_ASSUMED_SUCCESS:
-      return enums::SERIAL_PROXY_STATUS_ASSUMED_SUCCESS;
-    case serial_proxy::SerialProxyResult::SERIAL_PROXY_RESULT_PORT_IN_USE:
-      return enums::SERIAL_PROXY_STATUS_PORT_IN_USE;
-    case serial_proxy::SerialProxyResult::SERIAL_PROXY_RESULT_INVALID_ARGUMENT:
-      return enums::SERIAL_PROXY_STATUS_INVALID_ARGUMENT;
-    case serial_proxy::SerialProxyResult::SERIAL_PROXY_RESULT_TIMEOUT:
-      return enums::SERIAL_PROXY_STATUS_TIMEOUT;
-    case serial_proxy::SerialProxyResult::SERIAL_PROXY_RESULT_NOT_SUPPORTED:
-      return enums::SERIAL_PROXY_STATUS_NOT_SUPPORTED;
-    case serial_proxy::SerialProxyResult::SERIAL_PROXY_RESULT_ERROR:
-      return enums::SERIAL_PROXY_STATUS_ERROR;
-  }
-  return enums::SERIAL_PROXY_STATUS_ERROR;  // Unreachable; all enum values handled above
-}
-
-static void send_serial_proxy_ack(APIConnection *conn, uint32_t instance, enums::SerialProxyRequestType type,
-                                  enums::SerialProxyStatus status) {
-  SerialProxyRequestResponse resp{};
-  resp.instance = instance;
-  resp.type = type;
-  resp.status = status;
-  if (!conn->send_message(resp)) {
-    API_LOG_MSG_DROPPED(TAG, "Serial proxy response");
-  }
-}
-
 void APIConnection::on_serial_proxy_configure_request(const SerialProxyConfigureRequest &msg) {
   auto &proxies = App.get_serial_proxies();
   if (msg.instance >= proxies.size()) {
     ESP_LOGW(TAG, "Serial proxy instance %" PRIu32 " out of range (max %" PRIu32 ")", msg.instance,
              static_cast<uint32_t>(proxies.size()));
-    send_serial_proxy_ack(this, msg.instance, enums::SERIAL_PROXY_REQUEST_TYPE_CONFIGURE,
-                          enums::SERIAL_PROXY_STATUS_INVALID_ARGUMENT);
     return;
   }
-  serial_proxy::SerialProxyResult result = proxies[msg.instance]->configure(
-      this, msg.baudrate, msg.flow_control, static_cast<uint8_t>(msg.parity), msg.stop_bits, msg.data_size);
-  send_serial_proxy_ack(this, msg.instance, enums::SERIAL_PROXY_REQUEST_TYPE_CONFIGURE,
-                        serial_proxy_result_to_status(result));
+  proxies[msg.instance]->configure(this, msg.baudrate, msg.flow_control, static_cast<uint8_t>(msg.parity),
+                                   msg.stop_bits, msg.data_size);
 }
 
 void APIConnection::on_serial_proxy_write_request(const SerialProxyWriteRequest &msg) {
@@ -1613,30 +1574,20 @@ void APIConnection::on_serial_proxy_set_modem_pins_request(const SerialProxySetM
   auto &proxies = App.get_serial_proxies();
   if (msg.instance >= proxies.size()) {
     ESP_LOGW(TAG, "Serial proxy instance %" PRIu32 " out of range", msg.instance);
-    send_serial_proxy_ack(this, msg.instance, enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS,
-                          enums::SERIAL_PROXY_STATUS_INVALID_ARGUMENT);
     return;
   }
-  serial_proxy::SerialProxyResult result = proxies[msg.instance]->set_modem_pins(this, msg.line_states);
-  send_serial_proxy_ack(this, msg.instance, enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS,
-                        serial_proxy_result_to_status(result));
+  proxies[msg.instance]->set_modem_pins(this, msg.line_states);
 }
 
 void APIConnection::on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &msg) {
   auto &proxies = App.get_serial_proxies();
-  SerialProxyGetModemPinsResponse resp{};
-  resp.instance = msg.instance;
   if (msg.instance >= proxies.size()) {
     ESP_LOGW(TAG, "Serial proxy instance %" PRIu32 " out of range", msg.instance);
-    // Pre-1.16 clients do not read the status field and would take this error
-    // for a successful "both pins deasserted" answer; let them time out as before
-    if (!this->client_supports_api_version(1, 16)) {
-      return;
-    }
-    resp.status = enums::SERIAL_PROXY_STATUS_INVALID_ARGUMENT;
-  } else {
-    resp.line_states = proxies[msg.instance]->get_modem_pins();
+    return;
   }
+  SerialProxyGetModemPinsResponse resp{};
+  resp.instance = msg.instance;
+  resp.line_states = proxies[msg.instance]->get_modem_pins();
   if (!this->send_message(resp)) {
     API_LOG_MSG_DROPPED(TAG, "Serial proxy response");
   }
@@ -1646,31 +1597,40 @@ void APIConnection::on_serial_proxy_request(const SerialProxyRequest &msg) {
   auto &proxies = App.get_serial_proxies();
   if (msg.instance >= proxies.size()) {
     ESP_LOGW(TAG, "Serial proxy instance %" PRIu32 " out of range", msg.instance);
-    send_serial_proxy_ack(this, msg.instance, msg.type, enums::SERIAL_PROXY_STATUS_INVALID_ARGUMENT);
     return;
   }
-  auto *proxy = proxies[msg.instance];
-  enums::SerialProxyStatus status;
   switch (msg.type) {
     case enums::SERIAL_PROXY_REQUEST_TYPE_SUBSCRIBE:
     case enums::SERIAL_PROXY_REQUEST_TYPE_UNSUBSCRIBE:
-      status = serial_proxy_result_to_status(proxy->serial_proxy_request(this, msg.type));
+      proxies[msg.instance]->serial_proxy_request(this, msg.type);
       break;
-    case enums::SERIAL_PROXY_REQUEST_TYPE_FLUSH:
-      status = serial_proxy_result_to_status(proxy->flush_port(this));
-      break;
-    case enums::SERIAL_PROXY_REQUEST_TYPE_CONFIGURE:
-    case enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS:
-      // Response-only discriminators; never valid in a request
-      ESP_LOGW(TAG, "Response-only serial proxy request type: %" PRIu32, static_cast<uint32_t>(msg.type));
-      status = enums::SERIAL_PROXY_STATUS_INVALID_ARGUMENT;
+    case enums::SERIAL_PROXY_REQUEST_TYPE_FLUSH: {
+      SerialProxyRequestResponse resp{};
+      resp.instance = msg.instance;
+      resp.type = enums::SERIAL_PROXY_REQUEST_TYPE_FLUSH;
+      switch (proxies[msg.instance]->flush_port()) {
+        case uart::UARTFlushResult::UART_FLUSH_RESULT_SUCCESS:
+          resp.status = enums::SERIAL_PROXY_STATUS_OK;
+          break;
+        case uart::UARTFlushResult::UART_FLUSH_RESULT_ASSUMED_SUCCESS:
+          resp.status = enums::SERIAL_PROXY_STATUS_ASSUMED_SUCCESS;
+          break;
+        case uart::UARTFlushResult::UART_FLUSH_RESULT_TIMEOUT:
+          resp.status = enums::SERIAL_PROXY_STATUS_TIMEOUT;
+          break;
+        case uart::UARTFlushResult::UART_FLUSH_RESULT_FAILED:
+          resp.status = enums::SERIAL_PROXY_STATUS_ERROR;
+          break;
+      }
+      if (!this->send_message(resp)) {
+        API_LOG_MSG_DROPPED(TAG, "Serial proxy response");
+      }
       break;
+    }
     default:
       ESP_LOGW(TAG, "Unknown serial proxy request type: %" PRIu32, static_cast<uint32_t>(msg.type));
-      status = enums::SERIAL_PROXY_STATUS_NOT_SUPPORTED;
       break;
   }
-  send_serial_proxy_ack(this, msg.instance, msg.type, status);
 }
 
 void APIConnection::send_serial_proxy_data(const SerialProxyDataReceived &msg) {
@@ -1789,17 +1749,15 @@ void APIConnection::complete_authentication_() {
 bool APIConnection::send_hello_response_(const HelloRequest &msg) {
   // Copy client name with truncation if needed (set_client_name handles truncation)
   this->helper_->set_client_name(msg.client_info.c_str(), msg.client_info.size());
-  this->client_api_version_major_ =
-      static_cast<uint8_t>(std::min<uint32_t>(msg.api_version_major, std::numeric_limits<uint8_t>::max()));
-  this->client_api_version_minor_ =
-      static_cast<uint8_t>(std::min<uint32_t>(msg.api_version_minor, std::numeric_limits<uint8_t>::max()));
+  this->client_api_version_major_ = msg.api_version_major;
+  this->client_api_version_minor_ = msg.api_version_minor;
   char peername[socket::SOCKADDR_STR_LEN];
-  ESP_LOGV(TAG, "Hello from client: '%s' | %s | API Version %u.%u", this->helper_->get_client_name(),
+  ESP_LOGV(TAG, "Hello from client: '%s' | %s | API Version %" PRIu16 ".%" PRIu16, this->helper_->get_client_name(),
            this->helper_->get_peername_to(peername), this->client_api_version_major_, this->client_api_version_minor_);
 
   HelloResponse resp;
   resp.api_version_major = 1;
-  resp.api_version_minor = 16;
+  resp.api_version_minor = 15;
   // Send only the version string - the client only logs this for debugging and doesn't use it otherwise
   resp.server_info = ESPHOME_VERSION_REF;
   resp.name = StringRef(App.get_name());
@@ -1933,7 +1891,6 @@ bool APIConnection::send_device_info_response_() {
     auto &info = resp.serial_proxies[serial_proxy_index++];
     info.name = StringRef(proxy->get_name());
     info.port_type = proxy->get_port_type();
-    info.configured_line_states = proxy->get_configured_modem_pins();
   }
 #endif
 #ifdef USE_API_NOISE
@@ -1994,7 +1951,6 @@ bool APIConnection::send_device_capabilities_response_() {
     auto &info = resp.serial_proxies[serial_proxy_index++];
     info.name = StringRef(proxy->get_name());
     info.port_type = proxy->get_port_type();
-    info.configured_line_states = proxy->get_configured_modem_pins();
   }
 #endif
   return this->send_message(resp);
@@ -2225,7 +2181,7 @@ bool APIConnection::try_to_clear_buffer_slow_(bool log_out_of_space) {
   }
   return false;
 }
-bool APIConnection::send_message_(uint32_t payload_size, uint16_t message_type, MessageEncodeFn encode_fn,
+bool APIConnection::send_message_(uint32_t payload_size, uint8_t message_type, MessageEncodeFn encode_fn,
                                   const void *msg) {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   // Skip dump for log messages (recursive logging risk) and camera frames (high-frequency noise)
@@ -2239,17 +2195,10 @@ bool APIConnection::send_message_(uint32_t payload_size, uint16_t message_type,
     this->log_send_message_(proto_msg->message_name(), proto_msg->dump_to(dump_buf));
   }
 #endif
-  if (!this->prepare_first_message_buffer(payload_size)) [[unlikely]] {
-    this->fatal_out_of_memory_();
-    return false;
-  }
   auto &shared_buf = this->parent_->get_shared_buffer_ref();
+  this->prepare_first_message_buffer(shared_buf, payload_size);
   size_t write_start = shared_buf.size();
-#ifdef ESPHOME_DEBUG_API
-  assert(shared_buf.capacity() >= write_start + payload_size);
-#endif
-  // Capacity reserved above, cannot fail
-  (void) shared_buf.resize(write_start + payload_size);
+  shared_buf.resize(write_start + payload_size);
   ProtoWriteBuffer buffer{&shared_buf, write_start};
   encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
   return this->send_buffer(ProtoWriteBuffer{&shared_buf}, message_type);
@@ -2261,7 +2210,7 @@ uint16_t APIConnection::encode_to_buffer_slow(uint32_t calculated_size, MessageE
                                               APIConnection *conn, uint32_t remaining_size) {
   return encode_to_buffer(calculated_size, encode_fn, msg, conn, remaining_size);
 }
-bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint16_t message_type) {
+bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) {
   const bool is_log_message = (message_type == SubscribeLogsResponse::MESSAGE_TYPE);
 
   if (!this->try_to_clear_buffer(!is_log_message)) {
@@ -2285,42 +2234,30 @@ void APIConnection::on_no_setup_connection() {
   this->on_fatal_error();
   this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("no connection setup"));
 }
-void APIConnection::fatal_out_of_memory_() {
-  this->fatal_error_with_log_(LOG_STR("Out of memory"), APIError::OUT_OF_MEMORY);
-}
 void APIConnection::on_fatal_error() {
   // Don't close socket here - keep it open so getpeername() works for logging
   // Socket will be closed when client is removed from the list in APIServer::loop()
   this->flags_.remove = true;
 }
 
-bool APIConnection::schedule_message_front_(EntityBase *entity, uint16_t message_type, uint8_t estimated_size) {
+bool APIConnection::schedule_message_front_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size) {
   this->deferred_batch_.add_item_front(entity, message_type, estimated_size);
   return this->schedule_batch_();
 }
 
-bool APIConnection::send_message_smart_(EntityBase *entity, uint16_t message_type, uint8_t estimated_size,
+bool APIConnection::send_message_smart_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
                                         uint8_t aux_data_index) {
   if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
-    // No local for the shared buffer here: keeping it live across
-    // dispatch_message_ costs a register and spills message_type into the
-    // batching path's dedup loop (measured on x86 GCC -Os)
-    if (!this->prepare_first_message_buffer(estimated_size)) [[unlikely]] {
-      this->fatal_out_of_memory_();
-      return false;
-    }
+    auto &shared_buf = this->parent_->get_shared_buffer_ref();
+    this->prepare_first_message_buffer(shared_buf, estimated_size);
     DeferredBatch::BatchItem item{entity, message_type, estimated_size, aux_data_index};
     if (this->dispatch_message_(item, MAX_BATCH_PACKET_SIZE, true) &&
-        this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
+        this->send_buffer(ProtoWriteBuffer{&shared_buf}, message_type)) {
 #ifdef HAS_PROTO_MESSAGE_DUMP
       this->log_batch_item_(item);
 #endif
       return true;
     }
-    // An OOM during the immediate attempt marks the connection for removal;
-    // don't queue more work (schedule_message_'s push_back may allocate again)
-    if (this->flags_.remove) [[unlikely]]
-      return false;
   }
   return this->schedule_message_(entity, message_type, estimated_size, aux_data_index);
 }
@@ -2370,11 +2307,7 @@ void APIConnection::process_batch_() {
     total_estimated_size = MAX_BATCH_PACKET_SIZE;
   }
 
-  if (!this->prepare_first_message_buffer(header_padding, total_estimated_size)) [[unlikely]] {
-    this->fatal_out_of_memory_();
-    this->clear_batch_();
-    return;
-  }
+  this->prepare_first_message_buffer(shared_buf, header_padding, total_estimated_size);
 
   // Fast path for single message - buffer already allocated above
   if (num_items == 1) {
@@ -2389,10 +2322,8 @@ void APIConnection::process_batch_() {
 #endif
       this->clear_batch_();
     } else if (payload_size == 0) {
-      // payload_size == 0 with remove set means encoding hit OOM and the
-      // connection is being dropped; warn only for a genuinely oversized message
-      if (!this->flags_.remove)
-        ESP_LOGW(TAG, "Message too large to send: type=%u", item.message_type);
+      // Message too large to fit in available space
+      ESP_LOGW(TAG, "Message too large to send: type=%u", item.message_type);
       this->clear_batch_();
     }
     return;
@@ -2455,10 +2386,8 @@ void APIConnection::process_batch_multi_(APIBuffer &shared_buf, size_t num_items
 
   if (items_processed > 0) {
     // Add footer space for the last message (for Noise protocol MAC)
-    if (footer_size > 0 && !shared_buf.resize(shared_buf.size() + footer_size)) [[unlikely]] {
-      this->fatal_out_of_memory_();
-      this->clear_batch_();
-      return;
+    if (footer_size > 0) {
+      shared_buf.resize(shared_buf.size() + footer_size);
     }
 
     // Send all collected messages

esphome/components/api/api_connection.h

@@ -326,10 +326,8 @@ class APIConnection final : public APIServerConnectionBase {
   bool is_marked_for_removal() const { return this->flags_.remove; }
   uint8_t get_log_subscription_level() const { return this->flags_.log_subscription; }
 
-  // Get client API version for feature detection.
-  // Stored versions saturate at 255 (see send_hello_response_), so requesting
-  // a minimum above that can never match.
-  bool client_supports_api_version(uint8_t major, uint8_t minor) const {
+  // Get client API version for feature detection
+  bool client_supports_api_version(uint16_t major, uint16_t minor) const {
     return this->client_api_version_major_ > major ||
            (this->client_api_version_major_ == major && this->client_api_version_minor_ >= minor);
   }
@@ -352,13 +350,22 @@ class APIConnection final : public APIServerConnectionBase {
     }
   }
 
-  /// Clear the shared write buffer and reserve space for the first message.
-  /// Returns false if the allocation fails (out of memory).
-  /// Defined in api_connection_buffer.h (needs APIServer complete).
-  [[nodiscard]] bool prepare_first_message_buffer(size_t header_padding, size_t total_size);
+  void prepare_first_message_buffer(APIBuffer &shared_buf, size_t header_padding, size_t total_size) {
+    shared_buf.clear();
+    // Reserve space for header padding + message + footer
+    // - Header padding: space for protocol headers (7 bytes for Noise, 6 for Plaintext)
+    // - Footer: space for MAC (16 bytes for Noise, 0 for Plaintext)
+    // Reserve full size but only set initial size to header padding
+    // so message encoding starts at the correct position
+    shared_buf.reserve_and_resize(total_size, header_padding);
+  }
 
   // Convenience overload - computes frame overhead internally
-  [[nodiscard]] bool prepare_first_message_buffer(size_t payload_size);
+  void prepare_first_message_buffer(APIBuffer &shared_buf, size_t payload_size) {
+    const uint8_t header_padding = this->helper_->frame_header_padding();
+    const uint8_t footer_size = this->helper_->frame_footer_size();
+    this->prepare_first_message_buffer(shared_buf, header_padding, payload_size + header_padding + footer_size);
+  }
 
   bool try_to_clear_buffer(bool log_out_of_space) {
     if (this->flags_.remove)
@@ -367,7 +374,7 @@ class APIConnection final : public APIServerConnectionBase {
       return true;
     return this->try_to_clear_buffer_slow_(log_out_of_space);
   }
-  bool send_buffer(ProtoWriteBuffer buffer, uint16_t message_type);
+  bool send_buffer(ProtoWriteBuffer buffer, uint8_t message_type);
 
   const char *get_name() const { return this->helper_->get_client_name(); }
   /// Get peer name (IP address) into caller-provided buffer, returns buf for convenience
@@ -416,7 +423,7 @@ class APIConnection final : public APIServerConnectionBase {
   }
 
   // Non-template buffer management for send_message
-  bool send_message_(uint32_t payload_size, uint16_t message_type, MessageEncodeFn encode_fn, const void *msg);
+  bool send_message_(uint32_t payload_size, uint8_t message_type, MessageEncodeFn encode_fn, const void *msg);
 
   // Core batch encoding logic. ALWAYS_INLINE so encode_fn devirtualizes at hot call sites.
   // Defined in api_connection_buffer.h (needs APIServer complete).
@@ -657,9 +664,10 @@ class APIConnection final : public APIServerConnectionBase {
 
     struct BatchItem {
       EntityBase *entity;                       // 4 bytes - Entity pointer
-      uint16_t message_type;                    // 2 bytes - Message type for protocol and dispatch
+      uint8_t message_type;                     // 1 byte - Message type for protocol and dispatch
       uint8_t estimated_size;                   // 1 byte - Estimated message size (max 255 bytes)
       uint8_t aux_data_index{AUX_DATA_UNUSED};  // 1 byte - For events: index into entity's event_types
+      // 1 byte padding
     };
 
     std::vector<BatchItem> items;
@@ -669,7 +677,7 @@ class APIConnection final : public APIServerConnectionBase {
     // connections that do, buffers are released after initial sync anyway
 
     // Add item to the batch (with deduplication)
-    void add_item(EntityBase *entity, uint16_t message_type, uint8_t estimated_size,
+    void add_item(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
                   uint8_t aux_data_index = AUX_DATA_UNUSED) {
       // Dedup: O(n) scan but optimized for RAM over performance
       // Skip deduplication for events - they are edge-triggered, every occurrence matters
@@ -685,7 +693,7 @@ class APIConnection final : public APIServerConnectionBase {
       this->items.push_back({entity, message_type, estimated_size, aux_data_index});
     }
     // Add item to the front of the batch (for high priority messages like ping)
-    void add_item_front(EntityBase *entity, uint16_t message_type, uint8_t estimated_size) {
+    void add_item_front(EntityBase *entity, uint8_t message_type, uint8_t estimated_size) {
       // Swap to front avoids expensive vector::insert which shifts all elements
       this->items.push_back({entity, message_type, estimated_size, AUX_DATA_UNUSED});
       if (this->items.size() > 1) {
@@ -750,15 +758,13 @@ class APIConnection final : public APIServerConnectionBase {
 #endif
   } flags_{};  // 2 bytes total
 
-  // 2-byte type immediately after flags_ (no padding between them)
-  uint16_t batch_message_type_{0};  // Current message type during batch encoding
+  // 2-byte types immediately after flags_ (no padding between them)
+  uint16_t client_api_version_major_{0};
+  uint16_t client_api_version_minor_{0};
   // 1-byte types to fill remaining space before next 4-byte boundary
-  // Client API versions are clamped to 255 on receive (see send_hello_response_)
-  uint8_t client_api_version_major_{0};
-  uint8_t client_api_version_minor_{0};
   ActiveIterator active_iterator_{ActiveIterator::NONE};
-  // Total: 2 (flags) + 2 + 1 + 1 + 1 + 1 (batch_header_size_ below) = 8 bytes,
-  // aligned to 4-byte boundary
+  uint8_t batch_message_type_{0};  // Current message type during batch encoding
+  // Total: 2 (flags) + 2 + 2 + 1 + 1 = 8 bytes, aligned to 4-byte boundary
 
   // Actual header size used by encode_to_buffer for the current message.
   // Read by process_batch_multi_ to pass into MessageInfo.
@@ -807,7 +813,7 @@ class APIConnection final : public APIServerConnectionBase {
   // 2. It's an EventResponse (events are edge-triggered - every occurrence matters)
   // 3. OR: User has opted into immediate sending (should_try_send_immediately = true
   //    AND batch_delay = 0)
-  inline bool should_send_immediately_(uint16_t message_type) const {
+  inline bool should_send_immediately_(uint8_t message_type) const {
     return (
 #ifdef USE_UPDATE
         message_type == UpdateStateResponse::MESSAGE_TYPE ||
@@ -821,11 +827,11 @@ class APIConnection final : public APIServerConnectionBase {
   // Helper method to send a message either immediately or via batching
   // Tries immediate send if should_send_immediately_() returns true and buffer has space
   // Falls back to batching if immediate send fails or isn't applicable
-  bool send_message_smart_(EntityBase *entity, uint16_t message_type, uint8_t estimated_size,
+  bool send_message_smart_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
                            uint8_t aux_data_index = DeferredBatch::AUX_DATA_UNUSED);
 
   // Helper function to schedule a deferred message with known message type
-  bool schedule_message_(EntityBase *entity, uint16_t message_type, uint8_t estimated_size,
+  bool schedule_message_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
                          uint8_t aux_data_index = DeferredBatch::AUX_DATA_UNUSED) {
     this->deferred_batch_.add_item(entity, message_type, estimated_size, aux_data_index);
     return this->schedule_batch_();
@@ -833,7 +839,7 @@ class APIConnection final : public APIServerConnectionBase {
 
   // Helper function to schedule a high priority message at the front of the batch
   // Out-of-line: callers (on_shutdown, check_keepalive_) are cold paths
-  bool schedule_message_front_(EntityBase *entity, uint16_t message_type, uint8_t estimated_size);
+  bool schedule_message_front_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size);
 
   // Helper function to log client messages with name and peername
   void log_client_(int level, const LogString *message);
@@ -844,9 +850,6 @@ class APIConnection final : public APIServerConnectionBase {
     this->on_fatal_error();
     this->log_warning_(message, err);
   }
-  // Shared cold path for buffer allocation failures — noinline keeps the
-  // OOM handling out of the hot send paths
-  void __attribute__((noinline)) fatal_out_of_memory_();
 };
 
 }  // namespace esphome::api

esphome/components/api/api_connection_buffer.h

@@ -3,8 +3,8 @@
 #include "esphome/core/defines.h"
 #ifdef USE_API
 
-// Inline APIConnection members that need APIServer complete. Include this
-// instead of api_connection.h when calling them.
+// Inline APIConnection methods that need APIServer complete. Include this
+// instead of api_connection.h when calling encode_to_buffer or get_batch_delay_ms_.
 
 #include "api_connection.h"
 #include "api_server.h"
@@ -41,10 +41,7 @@ inline uint16_t ESPHOME_ALWAYS_INLINE APIConnection::encode_to_buffer(uint32_t c
     return 0;
 
   auto &shared_buf = conn->parent_->get_shared_buffer_ref();
-  if (!shared_buf.resize(shared_buf.size() + to_add)) [[unlikely]] {
-    conn->fatal_out_of_memory_();
-    return 0;
-  }
+  shared_buf.resize(shared_buf.size() + to_add);
   ProtoWriteBuffer buffer{&shared_buf, shared_buf.size() - calculated_size};
   encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
 
@@ -53,22 +50,5 @@ inline uint16_t ESPHOME_ALWAYS_INLINE APIConnection::encode_to_buffer(uint32_t c
 
 inline uint32_t APIConnection::get_batch_delay_ms_() const { return this->parent_->get_batch_delay(); }
 
-inline bool APIConnection::prepare_first_message_buffer(size_t header_padding, size_t total_size) {
-  auto &shared_buf = this->parent_->get_shared_buffer_ref();
-  shared_buf.clear();
-  // Reserve space for header padding + message + footer
-  // - Header padding: space for protocol headers (7 bytes for Noise, 6 for Plaintext)
-  // - Footer: space for MAC (16 bytes for Noise, 0 for Plaintext)
-  // Reserve full size but only set initial size to header padding
-  // so message encoding starts at the correct position
-  return shared_buf.reserve_and_resize(total_size, header_padding);
-}
-
-inline bool APIConnection::prepare_first_message_buffer(size_t payload_size) {
-  const uint8_t header_padding = this->helper_->frame_header_padding();
-  const uint8_t footer_size = this->helper_->frame_footer_size();
-  return this->prepare_first_message_buffer(header_padding, payload_size + header_padding + footer_size);
-}
-
 }  // namespace esphome::api
 #endif

esphome/components/api/api_frame_helper.cpp

@@ -172,7 +172,7 @@ APIError APIFrameHelper::write_raw_iov_(const struct iovec *iov, int iovcnt, uin
 
   // Queue unsent data into overflow buffer
   if (!this->overflow_buf_.enqueue_iov(iov, iovcnt, total_write_len, static_cast<uint16_t>(sent))) {
-    HELPER_LOG("Overflow buffer full or out of memory, dropping connection");
+    HELPER_LOG("Overflow buffer full, dropping connection");
     this->state_ = State::FAILED;
     return APIError::SOCKET_WRITE_FAILED;
   }

esphome/components/api/api_frame_helper.h

@@ -49,16 +49,16 @@ struct ReadPacketBuffer {
 };
 
 // Packed message info structure to minimize memory usage
-// message_type matches the wire formats: noise carries a fixed 16-bit type
-// field, plaintext a type varint. The proto codegen caps message IDs at 16383
-// so the plaintext type varint fits the 2 bytes budgeted in HEADER_PADDING.
+// Note: message_type is uint8_t — all current protobuf message types fit in 8 bits.
+// The noise wire format encodes types as 16-bit, but the high byte is always 0.
+// If message types ever exceed 255, this and encrypt_noise_message_ must be updated.
 struct MessageInfo {
   uint16_t offset;        // Offset in buffer where message starts
   uint16_t payload_size;  // Size of the message payload
-  uint16_t message_type;  // Message type (0-16383)
+  uint8_t message_type;   // Message type (0-255)
   uint8_t header_size;    // Actual header size used (avoids recomputation in write path)
 
-  MessageInfo(uint16_t type, uint16_t off, uint16_t size, uint8_t hdr)
+  MessageInfo(uint8_t type, uint16_t off, uint16_t size, uint8_t hdr)
       : offset(off), payload_size(size), message_type(type), header_size(hdr) {}
 };
 
@@ -173,7 +173,7 @@ class APIFrameHelper {
   }
   // Write a single protobuf message - the hot path (87-100% of all writes).
   // Caller must ensure state is DATA before calling.
-  virtual APIError write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) = 0;
+  virtual APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) = 0;
   // Write multiple protobuf messages in a single batched operation.
   // Caller must ensure state is DATA and messages is not empty.
   // messages contains (message_type, offset, length) for each message in the buffer.
@@ -187,15 +187,15 @@ class APIFrameHelper {
   // Distinguishes protocols via frame_footer_size_ (noise always has a non-zero MAC
   // footer, plaintext has footer=0). If a protocol with a plaintext footer is ever
   // added, this should become a virtual method.
-  uint8_t frame_header_size(uint16_t payload_size, uint16_t message_type) const {
+  uint8_t frame_header_size(uint16_t payload_size, uint8_t message_type) const {
 #if defined(USE_API_NOISE) && defined(USE_API_PLAINTEXT)
     return this->frame_footer_size_
                ? this->frame_header_padding_
-               : static_cast<uint8_t>(1 + ProtoSize::varint16(payload_size) + ProtoSize::varint16(message_type));
+               : static_cast<uint8_t>(1 + ProtoSize::varint16(payload_size) + ProtoSize::varint8(message_type));
 #elif defined(USE_API_NOISE)
     return this->frame_header_padding_;
 #else  // USE_API_PLAINTEXT only
-    return static_cast<uint8_t>(1 + ProtoSize::varint16(payload_size) + ProtoSize::varint16(message_type));
+    return static_cast<uint8_t>(1 + ProtoSize::varint16(payload_size) + ProtoSize::varint8(message_type));
 #endif
   }
   // Get the frame footer size required by this protocol

esphome/components/api/api_frame_helper_noise.cpp

@@ -68,10 +68,7 @@ APIError APINoiseFrameHelper::init() {
 
   // init prologue
   size_t old_size = prologue_.size();
-  if (!prologue_.resize(old_size + PROLOGUE_INIT_LEN)) [[unlikely]] {
-    state_ = State::FAILED;
-    return APIError::OUT_OF_MEMORY;
-  }
+  prologue_.resize(old_size + PROLOGUE_INIT_LEN);
 #ifdef USE_ESP8266
   memcpy_P(prologue_.data() + old_size, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
 #else
@@ -205,10 +202,7 @@ APIError APINoiseFrameHelper::try_read_frame_() {
   // During handshake, rx_buf_.size() is used in prologue construction, so
   // the buffer must be exactly msg_size to avoid prologue mismatch.)
   uint16_t alloc_size = msg_size + (is_data ? RX_BUF_NULL_TERMINATOR : 0);
-  if (!this->rx_buf_.resize(alloc_size)) [[unlikely]] {
-    state_ = State::FAILED;
-    return APIError::OUT_OF_MEMORY;
-  }
+  this->rx_buf_.resize(alloc_size);
 
   if (rx_buf_len_ < msg_size) {
     // more data to read
@@ -275,10 +269,7 @@ APIError APINoiseFrameHelper::state_action_client_hello_() {
   // Resize for: existing prologue + 2 size bytes + frame data
   size_t old_size = this->prologue_.size();
   size_t rx_size = this->rx_buf_.size();
-  if (!this->prologue_.resize(old_size + 2 + rx_size)) [[unlikely]] {
-    state_ = State::FAILED;
-    return APIError::OUT_OF_MEMORY;
-  }
+  this->prologue_.resize(old_size + 2 + rx_size);
   this->prologue_[old_size] = (uint8_t) (rx_size >> 8);
   this->prologue_[old_size + 1] = (uint8_t) rx_size;
   if (rx_size > 0) {
@@ -451,7 +442,7 @@ APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {
 }
 // Encrypt a single noise message in place and return the encrypted frame length.
 // Returns APIError::OK on success.
-APIError APINoiseFrameHelper::encrypt_noise_message_(uint8_t *buf_start, uint16_t payload_size, uint16_t message_type,
+APIError APINoiseFrameHelper::encrypt_noise_message_(uint8_t *buf_start, uint16_t payload_size, uint8_t message_type,
                                                      uint16_t &encrypted_len_out) {
   // The noise frame header is written after encryption, when the size is known
 
@@ -481,20 +472,18 @@ APIError APINoiseFrameHelper::encrypt_noise_message_(uint8_t *buf_start, uint16_
   return APIError::OK;
 }
 
-APIError APINoiseFrameHelper::write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) {
+APIError APINoiseFrameHelper::write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) {
 #ifdef ESPHOME_DEBUG_API
   assert(this->state_ == State::DATA);
 #endif
 
-  APIBuffer *buf = buffer.get_buffer();
   // Resize buffer to include footer space for Noise MAC
-  if (this->frame_footer_size_ && !buf->resize(buf->size() + this->frame_footer_size_)) [[unlikely]] {
-    state_ = State::FAILED;
-    return APIError::OUT_OF_MEMORY;
-  }
+  if (this->frame_footer_size_)
+    buffer.get_buffer()->resize(buffer.get_buffer()->size() + this->frame_footer_size_);
 
-  uint16_t payload_size = static_cast<uint16_t>(buf->size() - HEADER_PADDING - this->frame_footer_size_);
-  uint8_t *buf_start = buf->data();
+  uint16_t payload_size =
+      static_cast<uint16_t>(buffer.get_buffer()->size() - HEADER_PADDING - this->frame_footer_size_);
+  uint8_t *buf_start = buffer.get_buffer()->data();
   uint16_t encrypted_len;
   APIError aerr = this->encrypt_noise_message_(buf_start, payload_size, type, encrypted_len);
   if (aerr != APIError::OK)

esphome/components/api/api_frame_helper_noise.h

@@ -31,7 +31,7 @@ class APINoiseFrameHelper final : public APIFrameHelper {
 #endif
   APIError loop() override;
   APIError read_packet(ReadPacketBuffer *buffer) override;
-  APIError write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) override;
+  APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) override;
   APIError write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) override;
 
  protected:
@@ -44,7 +44,7 @@ class APINoiseFrameHelper final : public APIFrameHelper {
   APIError state_action_handshake_write_();
   APIError try_read_frame_();
   APIError write_frame_(const uint8_t *data, uint16_t len);
-  APIError encrypt_noise_message_(uint8_t *buf_start, uint16_t payload_size, uint16_t message_type,
+  APIError encrypt_noise_message_(uint8_t *buf_start, uint16_t payload_size, uint8_t message_type,
                                   uint16_t &encrypted_len_out);
   APIError init_handshake_();
   APIError check_handshake_finished_();

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -5,7 +5,6 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include "api_pb2.h"
 #include "proto.h"
 #include <cstring>
 #include <cinttypes>
@@ -172,10 +171,7 @@ APIError APIPlaintextFrameHelper::try_read_frame_() {
 
   // Reserve space for body (+ null terminator so protobuf StringRef fields
   // can be safely null-terminated in-place after decode)
-  if (!this->rx_buf_.resize(this->rx_header_parsed_len_ + RX_BUF_NULL_TERMINATOR)) [[unlikely]] {
-    state_ = State::FAILED;
-    return APIError::OUT_OF_MEMORY;
-  }
+  this->rx_buf_.resize(this->rx_header_parsed_len_ + RX_BUF_NULL_TERMINATOR);
 
   if (rx_buf_len_ < rx_header_parsed_len_) {
     // more data to read
@@ -256,21 +252,24 @@ ESPHOME_ALWAYS_INLINE static inline void encode_varint_16(uint16_t value, uint8_
   *p = static_cast<uint8_t>(value);
 }
 
-// The generator rejects message IDs above MAX_MESSAGE_TYPE, so the type varint
-// can never outgrow the 2 bytes HEADER_PADDING budgets for it. Without this
-// bound, write_plaintext_header's header_offset would underflow for the first
-// message in a batch and the header write would land outside the buffer.
-static_assert(1 + 3 + ProtoSize::varint16(MAX_MESSAGE_TYPE) <= APIPlaintextFrameHelper::HEADER_PADDING,
-              "HEADER_PADDING cannot fit the type varint of the largest message ID");
+// Encode an 8-bit varint (1-2 bytes) using pre-computed length.
+ESPHOME_ALWAYS_INLINE static inline void encode_varint_8(uint8_t value, uint8_t varint_len, uint8_t *p) {
+  if (varint_len == 2) {
+    *p++ = static_cast<uint8_t>(value | 0x80);
+    *p = static_cast<uint8_t>(value >> 7);
+  } else {
+    *p = value;
+  }
+}
 
 // Write plaintext header into pre-allocated padding before payload.
 // padding_size: bytes reserved before payload (HEADER_PADDING for first/single msg,
 //               actual header size for contiguous batch messages).
 // Returns the total header length (indicator + varints).
 ESPHOME_ALWAYS_INLINE static inline uint8_t write_plaintext_header(uint8_t *buf_start, uint16_t payload_size,
-                                                                   uint16_t message_type, uint8_t padding_size) {
+                                                                   uint8_t message_type, uint8_t padding_size) {
   uint8_t size_varint_len = ProtoSize::varint16(payload_size);
-  uint8_t type_varint_len = ProtoSize::varint16(message_type);
+  uint8_t type_varint_len = ProtoSize::varint8(message_type);
   uint8_t total_header_len = 1 + size_varint_len + type_varint_len;
 
   // The header is right-justified within the padding so it sits immediately before payload.
@@ -293,12 +292,12 @@ ESPHOME_ALWAYS_INLINE static inline uint8_t write_plaintext_header(uint8_t *buf_
 
   // Encode varints directly into buffer using pre-computed lengths
   encode_varint_16(payload_size, size_varint_len, buf_start + header_offset + 1);
-  encode_varint_16(message_type, type_varint_len, buf_start + header_offset + 1 + size_varint_len);
+  encode_varint_8(message_type, type_varint_len, buf_start + header_offset + 1 + size_varint_len);
 
   return total_header_len;
 }
 
-APIError APIPlaintextFrameHelper::write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) {
+APIError APIPlaintextFrameHelper::write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) {
 #ifdef ESPHOME_DEBUG_API
   assert(this->state_ == State::DATA);
 #endif

esphome/components/api/api_frame_helper_plaintext.h

@@ -10,8 +10,7 @@ class APIPlaintextFrameHelper final : public APIFrameHelper {
   // Plaintext header structure (worst case):
   // Pos 0: indicator (0x00)
   // Pos 1-3: payload size varint (up to 3 bytes)
-  // Pos 4-5: message type varint (up to 2 bytes; covers message IDs up to
-  //          16383, enforced by the proto codegen)
+  // Pos 4-5: message type varint (up to 2 bytes)
   // Pos 6+: actual payload data
   static constexpr uint8_t HEADER_PADDING = 1 + 3 + 2;  // indicator + size varint + type varint
 
@@ -22,7 +21,7 @@ class APIPlaintextFrameHelper final : public APIFrameHelper {
   APIError init() override;
   APIError loop() override;
   APIError read_packet(ReadPacketBuffer *buffer) override;
-  APIError write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) override;
+  APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) override;
   APIError write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) override;
 #ifdef USE_API_NOISE
   // After try_read_frame_ returned PROTOCOL_SWITCH_TO_NOISE: copy out the

esphome/components/api/api_overflow_buffer.cpp

@@ -1,7 +1,6 @@
 #include "api_overflow_buffer.h"
 #ifdef USE_API
 #include <cstring>
-#include <new>
 
 namespace esphome::api {
 
@@ -62,18 +61,9 @@ bool APIOverflowBuffer::enqueue_iov(const struct iovec *iov, int iovcnt, uint16_
     return false;
 
   uint16_t buffer_size = total_len - skip;
-  // nothrow: a failed allocation returns nullptr so the connection is dropped
-  // cleanly instead of plain new's crash or abort on OOM
   // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
-  auto *data = new (std::nothrow) uint8_t[buffer_size];
-  if (data == nullptr)
-    return false;
-  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
-  auto *entry = new (std::nothrow) Entry{data, buffer_size, 0};
-  if (entry == nullptr) {
-    delete[] data;
-    return false;
-  }
+  auto *entry = new Entry{new uint8_t[buffer_size], buffer_size, 0};
+  this->queue_[this->tail_] = entry;
 
   uint16_t to_skip = skip;
   uint16_t write_pos = 0;
@@ -90,8 +80,6 @@ bool APIOverflowBuffer::enqueue_iov(const struct iovec *iov, int iovcnt, uint16_
     }
   }
 
-  // Publish only after the copy completes so a half-built entry is never reachable
-  this->queue_[this->tail_] = entry;
   this->tail_ = (this->tail_ + 1) % API_MAX_SEND_QUEUE;
   this->count_++;
   return true;

esphome/components/api/api_overflow_buffer.h

@@ -61,7 +61,7 @@ class APIOverflowBuffer {
 
   /// Enqueue unsent IOV data into the backlog.
   /// Copies iov data starting at byte offset `skip` into a new entry.
-  /// Returns false if the queue is full or allocation fails (caller should fail the connection).
+  /// Returns false if the queue is full (caller should fail the connection).
   bool enqueue_iov(const struct iovec *iov, int iovcnt, uint16_t total_len, uint16_t skip);
 
  protected:

esphome/components/api/api_pb2.cpp

@@ -102,14 +102,12 @@ uint8_t *SerialProxyInfo::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PAR
   uint8_t *__restrict__ pos = buffer.get_pos();
   ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, this->name);
   ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(this->port_type));
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, this->configured_line_states);
   return pos;
 }
 uint32_t SerialProxyInfo::calculate_size() const {
   uint32_t size = 0;
   size += ProtoSize::calc_length(1, this->name.size());
   size += this->port_type ? 2 : 0;
-  size += ProtoSize::calc_uint32(1, this->configured_line_states);
   return size;
 }
 #endif
@@ -2323,6 +2321,7 @@ uint8_t *ListEntitiesMediaPlayerResponse::encode(ProtoWriteBuffer &buffer PROTO_
 #endif
   ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 6, this->disabled_by_default);
   ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, static_cast<uint32_t>(this->entity_category));
+  ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 8, this->supports_pause);
   for (auto &it : this->supported_formats) {
     ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, buffer, 9, it);
   }
@@ -2342,6 +2341,7 @@ uint32_t ListEntitiesMediaPlayerResponse::calculate_size() const {
 #endif
   size += ProtoSize::calc_bool(1, this->disabled_by_default);
   size += this->entity_category ? 2 : 0;
+  size += ProtoSize::calc_bool(1, this->supports_pause);
   if (!this->supported_formats.empty()) {
     for (const auto &it : this->supported_formats) {
       size += ProtoSize::calc_message_force(1, it.calculate_size());
@@ -3942,18 +3942,6 @@ uint32_t ZWaveProxyRequest::calculate_size() const {
   size += ProtoSize::calc_length(1, this->data_len);
   return size;
 }
-uint8_t *ZWaveProxyRequestResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
-  uint8_t *__restrict__ pos = buffer.get_pos();
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(this->type));
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(this->status));
-  return pos;
-}
-uint32_t ZWaveProxyRequestResponse::calculate_size() const {
-  uint32_t size = 0;
-  size += this->type ? 2 : 0;
-  size += this->status ? 2 : 0;
-  return size;
-}
 #endif
 #ifdef USE_INFRARED
 uint8_t *ListEntitiesInfraredResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -4196,14 +4184,12 @@ uint8_t *SerialProxyGetModemPinsResponse::encode(ProtoWriteBuffer &buffer PROTO_
   uint8_t *__restrict__ pos = buffer.get_pos();
   ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->instance);
   ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, this->line_states);
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, static_cast<uint32_t>(this->status));
   return pos;
 }
 uint32_t SerialProxyGetModemPinsResponse::calculate_size() const {
   uint32_t size = 0;
   size += ProtoSize::calc_uint32(1, this->instance);
   size += ProtoSize::calc_uint32(1, this->line_states);
-  size += this->status ? 2 : 0;
   return size;
 }
 bool SerialProxyRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {

esphome/components/api/api_pb2_dump.cpp

@@ -816,18 +816,6 @@ template<> const char *proto_enum_to_string<enums::ZWaveProxyRequestType>(enums:
       return ESPHOME_PSTR("UNKNOWN");
   }
 }
-template<> const char *proto_enum_to_string<enums::ZWaveProxyStatus>(enums::ZWaveProxyStatus value) {
-  switch (value) {
-    case enums::ZWAVE_PROXY_STATUS_OK:
-      return ESPHOME_PSTR("ZWAVE_PROXY_STATUS_OK");
-    case enums::ZWAVE_PROXY_STATUS_IN_USE:
-      return ESPHOME_PSTR("ZWAVE_PROXY_STATUS_IN_USE");
-    case enums::ZWAVE_PROXY_STATUS_NOT_SUPPORTED:
-      return ESPHOME_PSTR("ZWAVE_PROXY_STATUS_NOT_SUPPORTED");
-    default:
-      return ESPHOME_PSTR("UNKNOWN");
-  }
-}
 #endif
 #ifdef USE_SERIAL_PROXY
 template<> const char *proto_enum_to_string<enums::SerialProxyParity>(enums::SerialProxyParity value) {
@@ -850,10 +838,6 @@ template<> const char *proto_enum_to_string<enums::SerialProxyRequestType>(enums
       return ESPHOME_PSTR("SERIAL_PROXY_REQUEST_TYPE_UNSUBSCRIBE");
     case enums::SERIAL_PROXY_REQUEST_TYPE_FLUSH:
       return ESPHOME_PSTR("SERIAL_PROXY_REQUEST_TYPE_FLUSH");
-    case enums::SERIAL_PROXY_REQUEST_TYPE_CONFIGURE:
-      return ESPHOME_PSTR("SERIAL_PROXY_REQUEST_TYPE_CONFIGURE");
-    case enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS:
-      return ESPHOME_PSTR("SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS");
     default:
       return ESPHOME_PSTR("UNKNOWN");
   }
@@ -870,10 +854,6 @@ template<> const char *proto_enum_to_string<enums::SerialProxyStatus>(enums::Ser
       return ESPHOME_PSTR("SERIAL_PROXY_STATUS_TIMEOUT");
     case enums::SERIAL_PROXY_STATUS_NOT_SUPPORTED:
       return ESPHOME_PSTR("SERIAL_PROXY_STATUS_NOT_SUPPORTED");
-    case enums::SERIAL_PROXY_STATUS_PORT_IN_USE:
-      return ESPHOME_PSTR("SERIAL_PROXY_STATUS_PORT_IN_USE");
-    case enums::SERIAL_PROXY_STATUS_INVALID_ARGUMENT:
-      return ESPHOME_PSTR("SERIAL_PROXY_STATUS_INVALID_ARGUMENT");
     default:
       return ESPHOME_PSTR("UNKNOWN");
   }
@@ -934,7 +914,6 @@ const char *SerialProxyInfo::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyInfo"));
   dump_field(out, ESPHOME_PSTR("name"), this->name);
   dump_field(out, ESPHOME_PSTR("port_type"), static_cast<enums::SerialProxyPortType>(this->port_type));
-  dump_field(out, ESPHOME_PSTR("configured_line_states"), this->configured_line_states);
   return out.c_str();
 }
 #endif
@@ -1962,6 +1941,7 @@ const char *ListEntitiesMediaPlayerResponse::dump_to(DumpBuffer &out) const {
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
+  dump_field(out, ESPHOME_PSTR("supports_pause"), this->supports_pause);
   for (const auto &it : this->supported_formats) {
     out.append(4, ' ').append_p(ESPHOME_PSTR("supported_formats")).append(": ");
     it.dump_to(out);
@@ -2664,12 +2644,6 @@ const char *ZWaveProxyRequest::dump_to(DumpBuffer &out) const {
   dump_bytes_field(out, ESPHOME_PSTR("data"), this->data, this->data_len);
   return out.c_str();
 }
-const char *ZWaveProxyRequestResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, ESPHOME_PSTR("ZWaveProxyRequestResponse"));
-  dump_field(out, ESPHOME_PSTR("type"), static_cast<enums::ZWaveProxyRequestType>(this->type));
-  dump_field(out, ESPHOME_PSTR("status"), static_cast<enums::ZWaveProxyStatus>(this->status));
-  return out.c_str();
-}
 #endif
 #ifdef USE_INFRARED
 const char *ListEntitiesInfraredResponse::dump_to(DumpBuffer &out) const {
@@ -2779,7 +2753,6 @@ const char *SerialProxyGetModemPinsResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyGetModemPinsResponse"));
   dump_field(out, ESPHOME_PSTR("instance"), this->instance);
   dump_field(out, ESPHOME_PSTR("line_states"), this->line_states);
-  dump_field(out, ESPHOME_PSTR("status"), static_cast<enums::SerialProxyStatus>(this->status));
   return out.c_str();
 }
 const char *SerialProxyRequest::dump_to(DumpBuffer &out) const {

esphome/components/api/proto.h

@@ -684,6 +684,11 @@ class ProtoSize {
     return value < VARINT_THRESHOLD_1_BYTE ? 1 : (value < VARINT_THRESHOLD_2_BYTE ? 2 : 3);
   }
 
+  // Varint encoded length for an 8-bit value (1 or 2 bytes).
+  static constexpr inline uint8_t ESPHOME_ALWAYS_INLINE varint8(uint8_t value) {
+    return value < VARINT_THRESHOLD_1_BYTE ? 1 : 2;
+  }
+
   /**
    * @brief Calculates the size in bytes needed to encode a uint32_t value as a varint
    *

esphome/components/audio/__init__.py

@@ -6,8 +6,7 @@ import esphome.codegen as cg
 from esphome.components.esp32 import (
     add_idf_component,
     add_idf_sdkconfig_option,
-    request_http_client,
-    require_certificate_bundle,
+    include_builtin_idf_component,
 )
 import esphome.config_validation as cv
 from esphome.const import (
@@ -334,9 +333,8 @@ def _emit_memory_pair(value: str | None, psram_key: str, internal_key: str) -> N
 
 
 async def to_code(config: ConfigType) -> None:
-    request_http_client()
-    # HTTPS streams verify the server against the root certificate bundle
-    require_certificate_bundle()
+    # Re-enable ESP-IDF's HTTP client (excluded by default to save compile time)
+    include_builtin_idf_component("esp_http_client")
 
     add_idf_component(
         name="esphome/esp-audio-libs",

esphome/components/audio_http/audio_http_media_source.cpp

@@ -30,9 +30,8 @@ void AudioHTTPMediaSource::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "Audio HTTP Media Source:\n"
                 "  Buffer Size: %zu bytes\n"
-                "  Persistent Ring Buffer: %s\n"
                 "  Decoder Task Stack in PSRAM: %s",
-                this->buffer_size_, YESNO(this->persistent_ring_buffer_), YESNO(this->decoder_task_stack_in_psram_));
+                this->buffer_size_, YESNO(this->decoder_task_stack_in_psram_));
 }
 
 void AudioHTTPMediaSource::setup() {
@@ -40,7 +39,6 @@ void AudioHTTPMediaSource::setup() {
 
   micro_decoder::DecoderConfig config;
   config.ring_buffer_size = this->buffer_size_;
-  config.persistent_ring_buffer = this->persistent_ring_buffer_;
   // Keep the transfer buffer smaller than the ring buffer so the reader can top up the ring
   // while the decoder is still draining it, instead of oscillating between empty and full.
   config.transfer_buffer_size = std::min(DEFAULT_TRANSFER_BUFFER_SIZE, this->buffer_size_ / 2);

esphome/components/audio_http/audio_http_media_source.h

@@ -33,7 +33,6 @@ class AudioHTTPMediaSource final : public Component,
 
   void set_buffer_size(size_t buffer_size) { this->buffer_size_ = buffer_size; }
   void set_task_stack_in_psram(bool task_stack_in_psram) { this->decoder_task_stack_in_psram_ = task_stack_in_psram; }
-  void set_persistent_ring_buffer(bool persistent) { this->persistent_ring_buffer_ = persistent; }
 
   // MediaSource interface implementation
   bool play_uri(const std::string &uri) override;
@@ -55,7 +54,6 @@ class AudioHTTPMediaSource final : public Component,
   // on_audio_write(). Must be atomic to avoid a data race.
   std::atomic<bool> pause_{false};
   bool decoder_task_stack_in_psram_{false};
-  bool persistent_ring_buffer_{false};
 };
 
 }  // namespace esphome::audio_http

esphome/components/audio_http/media_source.py

@@ -7,8 +7,6 @@ from esphome.types import ConfigType
 CODEOWNERS = ["@kahrendt"]
 AUTO_LOAD = ["audio"]
 
-CONF_PERSISTENT_RING_BUFFER = "persistent_ring_buffer"
-
 audio_http_ns = cg.esphome_ns.namespace("audio_http")
 AudioHTTPMediaSource = audio_http_ns.class_(
     "AudioHTTPMediaSource", cg.Component, media_source.MediaSource
@@ -30,7 +28,6 @@ CONFIG_SCHEMA = cv.All(
                 min=5000, max=1000000
             ),
             cv.Optional(CONF_TASK_STACK_IN_PSRAM): psram.validate_task_stack_in_psram,
-            cv.Optional(CONF_PERSISTENT_RING_BUFFER, default=False): cv.boolean,
         }
     )
     .extend(cv.COMPONENT_SCHEMA),
@@ -48,4 +45,3 @@ async def to_code(config: ConfigType) -> None:
         cg.add(var.set_task_stack_in_psram(True))
         psram.request_external_task_stack()
     cg.add(var.set_buffer_size(config[CONF_BUFFER_SIZE]))
-    cg.add(var.set_persistent_ring_buffer(config[CONF_PERSISTENT_RING_BUFFER]))

esphome/components/captive_portal/captive_index.h

@@ -7,146 +7,146 @@ namespace esphome::captive_portal {
 
 #ifdef USE_CAPTIVE_PORTAL_GZIP
 constexpr uint8_t INDEX_GZ[] PROGMEM = {
-    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x95, 0x56, 0x6d, 0x8f, 0xdb, 0x36, 0x0c, 0xfe, 0xbe,
-    0x5f, 0xa1, 0x79, 0xdd, 0x6a, 0xaf, 0xb1, 0xfc, 0x92, 0x4b, 0xda, 0x3a, 0x96, 0x8b, 0xee, 0xd6, 0x62, 0x03, 0xd6,
-    0xad, 0xc0, 0xdd, 0xba, 0x0f, 0x45, 0x01, 0x2b, 0x32, 0x1d, 0xab, 0x27, 0x4b, 0x9e, 0xa4, 0xbc, 0x35, 0xc8, 0x7e,
-    0xfb, 0x20, 0xdb, 0xc9, 0xe5, 0x8a, 0x16, 0xd8, 0x10, 0xc4, 0xa0, 0x44, 0xf2, 0xe1, 0x8b, 0x28, 0x52, 0xf9, 0xb7,
-    0x95, 0x62, 0x76, 0xdf, 0x01, 0x6a, 0x6c, 0x2b, 0x8a, 0xdc, 0x7d, 0x91, 0xa0, 0x72, 0x45, 0x40, 0x16, 0x79, 0x03,
-    0xb4, 0x2a, 0xf2, 0x16, 0x2c, 0x45, 0xac, 0xa1, 0xda, 0x80, 0x25, 0x7f, 0xde, 0xbe, 0x0e, 0x9f, 0x15, 0xb9, 0xe0,
-    0xf2, 0x0e, 0x69, 0x10, 0x84, 0x33, 0x25, 0x51, 0xa3, 0xa1, 0x26, 0x15, 0xb5, 0x34, 0xe3, 0x2d, 0x5d, 0xc1, 0xa8,
-    0x22, 0x69, 0x0b, 0x64, 0xc3, 0x61, 0xdb, 0x29, 0x6d, 0x11, 0x53, 0xd2, 0x82, 0xb4, 0xc4, 0xdb, 0xf2, 0xca, 0x36,
-    0xa4, 0x82, 0x0d, 0x67, 0x10, 0xf6, 0x8b, 0x09, 0x97, 0xdc, 0x72, 0x2a, 0x42, 0xc3, 0xa8, 0x00, 0x92, 0x4c, 0xd6,
-    0x06, 0x74, 0xbf, 0xa0, 0x4b, 0x01, 0x44, 0x2a, 0xaf, 0xc8, 0x0d, 0xd3, 0xbc, 0xb3, 0xc8, 0xb9, 0x4a, 0x5a, 0x55,
-    0xad, 0x05, 0x20, 0xa6, 0x95, 0x31, 0x4a, 0xf3, 0x15, 0x97, 0x45, 0xa5, 0xd8, 0xba, 0x05, 0x69, 0xb1, 0x50, 0x8c,
-    0x5a, 0xae, 0x24, 0x36, 0x40, 0x35, 0x6b, 0x08, 0x21, 0xe5, 0x0b, 0x43, 0x37, 0x50, 0xfe, 0xf0, 0x83, 0x7f, 0x16,
-    0x5a, 0x81, 0x7d, 0x25, 0xc0, 0x91, 0xe6, 0xa7, 0xfd, 0x2d, 0x5d, 0xfd, 0x4e, 0x5b, 0xf0, 0x4b, 0x6a, 0x78, 0x05,
-    0x65, 0xf0, 0x3e, 0xfe, 0x80, 0x8d, 0xdd, 0x0b, 0xc0, 0x15, 0x37, 0x9d, 0xa0, 0x7b, 0x52, 0x2e, 0x85, 0x62, 0x77,
-    0x65, 0xb0, 0xa8, 0xd7, 0x92, 0x39, 0x70, 0x04, 0x3e, 0x04, 0x07, 0x01, 0x16, 0x49, 0xf2, 0x86, 0xda, 0x06, 0xb7,
-    0x74, 0xe7, 0x0f, 0x04, 0x97, 0x7e, 0xfa, 0xa3, 0x0f, 0x4f, 0x92, 0x38, 0x0e, 0x26, 0xfd, 0x27, 0x0e, 0xa2, 0x24,
-    0x8e, 0x17, 0x1a, 0xec, 0x5a, 0x4b, 0x64, 0xfd, 0x32, 0xef, 0xa8, 0x6d, 0x50, 0x45, 0xbc, 0x37, 0x49, 0x8a, 0x92,
-    0xe7, 0x38, 0x9d, 0xfd, 0x86, 0x9f, 0xa2, 0x2b, 0x9c, 0xce, 0xd8, 0xd3, 0x70, 0x86, 0x92, 0xab, 0x70, 0x86, 0xd2,
-    0x14, 0xcf, 0x50, 0xfc, 0xc9, 0x43, 0x35, 0x17, 0x82, 0x78, 0x52, 0x49, 0xf0, 0x90, 0xb1, 0x5a, 0xdd, 0x01, 0xf1,
-    0xd8, 0x5a, 0x6b, 0x90, 0xf6, 0x5a, 0x09, 0xa5, 0xbd, 0xa8, 0xf8, 0xe6, 0x7f, 0x01, 0x5a, 0x4d, 0xa5, 0xa9, 0x95,
-    0x6e, 0x89, 0xd7, 0xa7, 0xdb, 0x7f, 0x74, 0x90, 0x47, 0xe4, 0x3e, 0xc1, 0x05, 0x33, 0x1c, 0xf2, 0x4a, 0x3c, 0x87,
-    0xf8, 0xcc, 0x8b, 0x8a, 0x32, 0x38, 0x9e, 0xa3, 0xb7, 0x2e, 0xfa, 0x31, 0x1e, 0xed, 0xbf, 0x2f, 0x73, 0xb3, 0x59,
-    0xa1, 0x5d, 0x2b, 0xa4, 0x21, 0x5e, 0x63, 0x6d, 0x97, 0x45, 0xd1, 0x76, 0xbb, 0xc5, 0xdb, 0x29, 0x56, 0x7a, 0x15,
-    0xa5, 0x71, 0x1c, 0x47, 0x66, 0xb3, 0xf2, 0xd0, 0x70, 0xf2, 0x5e, 0x7a, 0xe5, 0xa1, 0x06, 0xf8, 0xaa, 0xb1, 0x3d,
-    0x5d, 0x3c, 0x3a, 0xc0, 0x31, 0x77, 0x12, 0x45, 0xf9, 0xe1, 0xc2, 0x8a, 0xbc, 0xb0, 0x02, 0x2f, 0x2e, 0xf2, 0xf6,
-    0xb8, 0x0f, 0xf3, 0x29, 0x4d, 0x51, 0x8a, 0xe2, 0xfe, 0x97, 0x86, 0x8e, 0x1e, 0x57, 0xe1, 0x67, 0x2b, 0x74, 0xb1,
-    0x72, 0x54, 0x3b, 0x0f, 0x9f, 0x9f, 0x75, 0x13, 0xb7, 0xb3, 0x49, 0xe2, 0xfb, 0x0d, 0xa7, 0xf0, 0xcb, 0xfc, 0x72,
-    0x1d, 0xa6, 0xef, 0x2e, 0x05, 0x9c, 0xb5, 0x26, 0x79, 0x37, 0xa7, 0x33, 0x34, 0x1b, 0x77, 0x66, 0xa1, 0xa3, 0xcf,
-    0x2b, 0x34, 0xdb, 0xa4, 0x4d, 0xd2, 0x86, 0xf3, 0x70, 0x46, 0xa7, 0x68, 0x3a, 0x3a, 0x32, 0x45, 0xd3, 0x4d, 0xda,
-    0xcc, 0xdf, 0xcd, 0x2f, 0xf7, 0xc2, 0xe9, 0xa7, 0xc7, 0x2e, 0xb9, 0x59, 0x59, 0xde, 0x47, 0xae, 0x2f, 0x23, 0xc7,
-    0x1f, 0x15, 0x97, 0x7e, 0xe9, 0xf2, 0x0f, 0x96, 0x35, 0x7e, 0x19, 0x31, 0x25, 0x6b, 0xbe, 0xc2, 0x1f, 0x8d, 0x92,
-    0x65, 0x80, 0x6d, 0x03, 0xd2, 0x3f, 0xa9, 0xfa, 0x36, 0x38, 0xd8, 0x9e, 0xe3, 0x7f, 0x81, 0x73, 0xae, 0x7f, 0xcb,
-    0xad, 0x00, 0x62, 0xb1, 0xbb, 0xa1, 0x93, 0x2f, 0xdc, 0x8a, 0x9f, 0xf6, 0xbf, 0x56, 0x7e, 0xd9, 0x52, 0x56, 0x06,
-    0x98, 0x4b, 0x09, 0xfa, 0x16, 0x76, 0x96, 0x94, 0x6f, 0x5e, 0x5e, 0xa3, 0x97, 0x55, 0xa5, 0xc1, 0x98, 0x0c, 0x95,
-    0x4f, 0x2c, 0x6e, 0x29, 0xfb, 0xba, 0x7a, 0x93, 0x3c, 0xd4, 0xfe, 0x8b, 0xbf, 0xe6, 0xe8, 0x77, 0xb0, 0x5b, 0xa5,
-    0xef, 0x46, 0x7d, 0x67, 0x7f, 0xe1, 0xae, 0x91, 0x26, 0x5f, 0x85, 0x91, 0x60, 0xcb, 0x60, 0xc2, 0xbf, 0x2e, 0x60,
-    0x0c, 0xaf, 0xca, 0x60, 0x42, 0xbf, 0x2e, 0xd1, 0x19, 0x77, 0x79, 0x2d, 0xa6, 0x9d, 0xc1, 0x46, 0x70, 0x06, 0x7e,
-    0x12, 0xe0, 0x5a, 0xe9, 0x57, 0x94, 0x35, 0x0f, 0x12, 0xe4, 0x5c, 0x51, 0xf7, 0x38, 0x4c, 0x03, 0xb5, 0x30, 0x42,
-    0xf9, 0x65, 0xc5, 0x37, 0x65, 0xb0, 0x50, 0x98, 0x09, 0x6a, 0x8c, 0x6b, 0x19, 0xc4, 0x39, 0xe7, 0xc2, 0x29, 0x27,
-    0x6a, 0x88, 0xf4, 0x97, 0xdb, 0x37, 0xbf, 0x91, 0x32, 0xa7, 0x43, 0x47, 0xf4, 0xbe, 0xf3, 0x50, 0x2f, 0x4c, 0xbc,
-    0x51, 0x30, 0x14, 0x50, 0xdb, 0xbe, 0xe2, 0x7d, 0x8b, 0xb5, 0x31, 0x3c, 0x38, 0xe6, 0xa6, 0xa3, 0xf2, 0x73, 0x31,
-    0x17, 0x93, 0x57, 0xe4, 0x91, 0xe3, 0x15, 0x79, 0x44, 0x8b, 0x47, 0x07, 0xe9, 0xf7, 0xcd, 0xed, 0x2e, 0x38, 0x3a,
-    0x6b, 0x7f, 0xaf, 0x41, 0xef, 0x6f, 0x40, 0x00, 0xb3, 0x4a, 0xfb, 0x25, 0xbe, 0x54, 0x74, 0x45, 0x01, 0x3b, 0x7b,
-    0x3d, 0x36, 0x5c, 0x8b, 0xdd, 0xe6, 0x44, 0x61, 0x25, 0x99, 0xe0, 0xec, 0x8e, 0x9c, 0x23, 0x0e, 0x0e, 0x1c, 0x6f,
-    0xa8, 0x58, 0xc3, 0x49, 0x86, 0xe2, 0x5a, 0xb1, 0xb5, 0xf1, 0x83, 0xe3, 0x44, 0x63, 0xda, 0x75, 0x20, 0xab, 0xeb,
-    0x86, 0x8b, 0xca, 0x57, 0xc1, 0x31, 0xb8, 0x3f, 0xe9, 0xcf, 0x8c, 0xbb, 0x59, 0xf0, 0x5e, 0x83, 0xf8, 0x87, 0x3c,
-    0x76, 0xd3, 0xe0, 0xf1, 0x87, 0x32, 0xc0, 0x7d, 0xfc, 0xe5, 0xfd, 0x48, 0x70, 0xd7, 0xfb, 0xc9, 0xae, 0x15, 0x13,
-    0x17, 0x7a, 0x38, 0x9f, 0x05, 0xc7, 0xf2, 0x18, 0x1c, 0x83, 0x45, 0x1e, 0x0d, 0x8d, 0xbd, 0xc8, 0xfb, 0x96, 0xdb,
-    0x8f, 0x94, 0x9e, 0x32, 0x0d, 0x80, 0x7d, 0xd0, 0xe2, 0x7f, 0x3c, 0x2c, 0xd5, 0x2e, 0x34, 0xfc, 0x13, 0x97, 0xab,
-    0x8c, 0xcb, 0x06, 0x34, 0xb7, 0xc7, 0x8a, 0x6f, 0x26, 0x5c, 0x76, 0x6b, 0x7b, 0xe8, 0x68, 0x55, 0x39, 0xce, 0xac,
-    0xdb, 0x2d, 0x6a, 0x25, 0xad, 0x93, 0x84, 0x2c, 0x81, 0xf6, 0x38, 0xf0, 0xfb, 0xe6, 0x93, 0x3d, 0x9f, 0x7d, 0x7f,
-    0x5c, 0xaa, 0x6a, 0x7f, 0x70, 0x19, 0x0a, 0xa9, 0xe0, 0x2b, 0x99, 0x31, 0x90, 0x16, 0xf4, 0xa0, 0x54, 0xd3, 0x96,
-    0x8b, 0x7d, 0x66, 0xa8, 0x34, 0xa1, 0x01, 0xcd, 0xeb, 0xe3, 0x72, 0x6d, 0xad, 0x92, 0x07, 0xe6, 0x9a, 0x6d, 0xf6,
-    0x5d, 0x5d, 0xd7, 0x0b, 0xb6, 0xd6, 0x46, 0xe9, 0xac, 0x53, 0xbc, 0xd7, 0x5b, 0x52, 0x76, 0xb7, 0xd2, 0x6a, 0x2d,
-    0xab, 0x70, 0x14, 0x4a, 0x6a, 0x3a, 0x05, 0xb6, 0x58, 0x2a, 0x5d, 0x81, 0xce, 0xe2, 0x91, 0x08, 0x35, 0xad, 0xf8,
-    0xda, 0x64, 0x78, 0xaa, 0xa1, 0x5d, 0x0c, 0xee, 0x24, 0x71, 0xfc, 0xfd, 0xe2, 0xe4, 0x79, 0x7c, 0xe9, 0x37, 0x4e,
-    0x9d, 0x94, 0xe0, 0x12, 0xc2, 0xa1, 0x57, 0x66, 0x29, 0xbe, 0xd2, 0xd0, 0x1e, 0x5b, 0xca, 0xe5, 0xa5, 0xf7, 0xae,
-    0xa2, 0x16, 0x2d, 0x97, 0xc3, 0x28, 0xcd, 0xd2, 0x79, 0xdc, 0xed, 0x16, 0xe3, 0xe4, 0xca, 0xb8, 0xec, 0x11, 0xfa,
-    0xf9, 0x75, 0x3c, 0x15, 0xc9, 0xe1, 0xe3, 0xda, 0x58, 0x5e, 0xef, 0xc3, 0x71, 0x24, 0x67, 0xa6, 0xa3, 0x0c, 0xc2,
-    0x25, 0xd8, 0x2d, 0x80, 0x5c, 0xf4, 0xb0, 0x21, 0xb7, 0xd0, 0x9a, 0x53, 0x6a, 0x4e, 0x70, 0xb5, 0x80, 0xdd, 0x19,
-    0xa6, 0xaf, 0xe5, 0xc3, 0x7f, 0x96, 0x76, 0x05, 0x76, 0x68, 0xa9, 0x5e, 0x71, 0x19, 0x2e, 0x95, 0xb5, 0xaa, 0xcd,
-    0xc2, 0xa7, 0xdd, 0x6e, 0x31, 0x6e, 0x39, 0xb0, 0x2c, 0x89, 0xbb, 0xdd, 0xb1, 0x1f, 0xc3, 0xa7, 0x7c, 0x5f, 0xd5,
-    0xcf, 0x68, 0x12, 0x7f, 0x21, 0xc7, 0x55, 0x5d, 0xa7, 0xcb, 0xfa, 0x94, 0xe3, 0xa4, 0xdb, 0x21, 0xa3, 0x04, 0xaf,
-    0x46, 0xb8, 0x1e, 0x09, 0xc5, 0xe7, 0xd4, 0x26, 0xb3, 0x6e, 0x87, 0x92, 0xcb, 0xcc, 0xb8, 0x89, 0xea, 0xa6, 0x8e,
-    0xab, 0xb5, 0x22, 0x8f, 0x86, 0x97, 0x8e, 0xab, 0x8c, 0x22, 0x77, 0x19, 0x2e, 0xf2, 0x26, 0x41, 0xbc, 0x22, 0x2d,
-    0x65, 0xc5, 0x45, 0xdb, 0xcb, 0xa3, 0x26, 0x39, 0xb1, 0x9a, 0xa4, 0x78, 0xd0, 0xd2, 0x06, 0x5e, 0xef, 0x7d, 0x71,
-    0xad, 0xa4, 0x04, 0x66, 0xb9, 0x5c, 0x21, 0xab, 0xd0, 0x98, 0x02, 0x8c, 0x71, 0xbe, 0xd4, 0xc5, 0x5b, 0x01, 0xd4,
-    0x00, 0xda, 0x52, 0x6e, 0x71, 0x1e, 0x0d, 0xf2, 0x43, 0x13, 0xe0, 0x15, 0x91, 0x60, 0xcf, 0xd7, 0xbe, 0x99, 0x0e,
-    0x06, 0x6e, 0xc0, 0x3a, 0x24, 0x67, 0x60, 0x5a, 0xe4, 0x6e, 0x3a, 0x23, 0xda, 0x5f, 0x60, 0x12, 0x6d, 0x79, 0xcd,
-    0xdd, 0xeb, 0xa6, 0xc8, 0xfb, 0x22, 0x77, 0x08, 0x2e, 0xcf, 0xc3, 0xd3, 0xab, 0xa7, 0x04, 0xc8, 0x95, 0x6d, 0xc8,
-    0x34, 0x45, 0x9d, 0xa0, 0x0c, 0x1a, 0x25, 0x2a, 0xd0, 0xe4, 0xe6, 0xe6, 0xd7, 0x9f, 0x0b, 0xe7, 0xcc, 0xbd, 0x5e,
-    0x67, 0xee, 0x06, 0x35, 0x47, 0x8c, 0x5a, 0xf3, 0xab, 0xe1, 0xc1, 0xd5, 0x51, 0x63, 0xb6, 0x4a, 0x57, 0x0f, 0x30,
-    0xde, 0x8e, 0x9b, 0x03, 0x4e, 0xff, 0xef, 0xaf, 0x4a, 0x71, 0x43, 0x37, 0x90, 0x47, 0xe3, 0x22, 0x8f, 0x9c, 0xc3,
-    0x03, 0xbf, 0x19, 0xe5, 0x9a, 0xa4, 0xf8, 0xe3, 0xf6, 0x25, 0xfa, 0xb3, 0xab, 0xa8, 0x85, 0x21, 0x6d, 0x7d, 0x54,
-    0x2d, 0xd8, 0x46, 0x55, 0xe4, 0xed, 0x1f, 0x37, 0xb7, 0xe7, 0x08, 0xd7, 0xbd, 0x10, 0x02, 0xc9, 0x86, 0xa7, 0xdf,
-    0x5a, 0x58, 0xde, 0x51, 0x6d, 0x7b, 0xd8, 0xd0, 0x35, 0x98, 0x53, 0x0c, 0x3d, 0xbf, 0xe6, 0x02, 0x86, 0x30, 0x06,
-    0xc5, 0x02, 0x9d, 0xbc, 0x3a, 0x59, 0xfb, 0xcc, 0xaf, 0x68, 0x38, 0xed, 0x68, 0x38, 0xfa, 0xa8, 0x7f, 0x05, 0xff,
-    0x0b, 0x54, 0xcf, 0x54, 0x8b, 0x15, 0x0b, 0x00, 0x00};
+    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x95, 0x16, 0x6b, 0x8f, 0xdb, 0x36, 0xf2, 0x7b, 0x7f,
+    0x05, 0x8f, 0x4d, 0x1b, 0xa9, 0xb1, 0xa8, 0x87, 0xd7, 0xde, 0x44, 0x96, 0x54, 0xa4, 0x7b, 0x2d, 0x5a, 0xa0, 0x69,
+    0x03, 0xec, 0x36, 0xf7, 0x21, 0x08, 0xb0, 0x34, 0x39, 0xb2, 0x98, 0xa5, 0x48, 0x1d, 0x49, 0xbf, 0x62, 0xf8, 0x7e,
+    0xfb, 0x81, 0x92, 0xec, 0xf5, 0x2e, 0x9a, 0x03, 0x0e, 0x86, 0x85, 0x19, 0xce, 0x7b, 0x38, 0x0f, 0x16, 0xff, 0xe0,
+    0x9a, 0xb9, 0x7d, 0x07, 0xa8, 0x71, 0xad, 0xac, 0x0a, 0xff, 0x45, 0x92, 0xaa, 0x55, 0x09, 0xaa, 0x2a, 0x1a, 0xa0,
+    0xbc, 0x2a, 0x5a, 0x70, 0x14, 0xb1, 0x86, 0x1a, 0x0b, 0xae, 0xfc, 0xeb, 0xee, 0x97, 0xe8, 0x75, 0x55, 0x48, 0xa1,
+    0x1e, 0x90, 0x01, 0x59, 0x0a, 0xa6, 0x15, 0x6a, 0x0c, 0xd4, 0x25, 0xa7, 0x8e, 0xe6, 0xa2, 0xa5, 0x2b, 0x18, 0x45,
+    0x14, 0x6d, 0xa1, 0xdc, 0x08, 0xd8, 0x76, 0xda, 0x38, 0xc4, 0xb4, 0x72, 0xa0, 0x5c, 0x89, 0xb7, 0x82, 0xbb, 0xa6,
+    0xe4, 0xb0, 0x11, 0x0c, 0xa2, 0x1e, 0x99, 0x08, 0x25, 0x9c, 0xa0, 0x32, 0xb2, 0x8c, 0x4a, 0x28, 0xd3, 0xc9, 0xda,
+    0x82, 0xe9, 0x11, 0xba, 0x94, 0x50, 0x2a, 0x8d, 0xab, 0xc2, 0x32, 0x23, 0x3a, 0x87, 0xbc, 0xab, 0x65, 0xab, 0xf9,
+    0x5a, 0x42, 0x15, 0xc7, 0xd4, 0x5a, 0x70, 0x36, 0x16, 0x8a, 0xc3, 0x8e, 0xd0, 0x6b, 0xb8, 0xa6, 0x2c, 0x4d, 0xc8,
+    0x67, 0xfb, 0x0d, 0xd7, 0x6c, 0xdd, 0x82, 0x72, 0x44, 0x6a, 0x46, 0x9d, 0xd0, 0x8a, 0x58, 0xa0, 0x86, 0x35, 0x65,
+    0x59, 0xe2, 0x1f, 0x2d, 0xdd, 0x00, 0xfe, 0xfe, 0xfb, 0xe0, 0xcc, 0xb4, 0x02, 0xf7, 0xb3, 0x04, 0x0f, 0xda, 0x9f,
+    0xf6, 0x77, 0x74, 0xf5, 0x07, 0x6d, 0x21, 0xc0, 0xd4, 0x0a, 0x0e, 0x38, 0xfc, 0x98, 0x7c, 0x22, 0xd6, 0xed, 0x25,
+    0x10, 0x2e, 0x6c, 0x27, 0xe9, 0xbe, 0xc4, 0x4b, 0xa9, 0xd9, 0x03, 0x0e, 0x17, 0xf5, 0x5a, 0x31, 0xaf, 0x1c, 0xe9,
+    0x00, 0xc2, 0x83, 0x04, 0x87, 0x5c, 0xf9, 0x8e, 0xba, 0x86, 0xb4, 0x74, 0x17, 0x0c, 0x80, 0x50, 0x41, 0xf6, 0x43,
+    0x00, 0xaf, 0xd2, 0x24, 0x09, 0x27, 0xfd, 0x27, 0x09, 0xe3, 0x34, 0x49, 0x16, 0x06, 0xdc, 0xda, 0x28, 0x44, 0x83,
+    0xfb, 0xa2, 0xa3, 0xae, 0x41, 0xbc, 0xc4, 0xef, 0xd2, 0x0c, 0xa5, 0x6f, 0x48, 0x36, 0xfb, 0x9d, 0x5c, 0xa3, 0x2b,
+    0x92, 0xcd, 0xd8, 0x75, 0x34, 0x43, 0xe9, 0x55, 0x34, 0x43, 0x59, 0x46, 0x66, 0x28, 0xf9, 0x82, 0x51, 0x2d, 0xa4,
+    0x2c, 0xb1, 0xd2, 0x0a, 0x30, 0xb2, 0xce, 0xe8, 0x07, 0x28, 0x31, 0x5b, 0x1b, 0x03, 0xca, 0xdd, 0x68, 0xa9, 0x0d,
+    0x8e, 0xab, 0x6f, 0xfe, 0x2f, 0x85, 0xce, 0x50, 0x65, 0x6b, 0x6d, 0xda, 0x12, 0xf7, 0xd9, 0x0f, 0x5e, 0x1c, 0xdc,
+    0x11, 0xf9, 0x4f, 0x78, 0x41, 0x8c, 0xb4, 0x11, 0x2b, 0xa1, 0x4a, 0xec, 0x35, 0xbe, 0xc6, 0x71, 0x75, 0x1f, 0x1e,
+    0xcf, 0xd1, 0x53, 0x1f, 0xfd, 0x18, 0x0f, 0x0f, 0x3e, 0xde, 0x17, 0x76, 0xb3, 0x42, 0xbb, 0x56, 0x2a, 0x5b, 0xe2,
+    0xc6, 0xb9, 0x2e, 0x8f, 0xe3, 0xed, 0x76, 0x4b, 0xb6, 0x53, 0xa2, 0xcd, 0x2a, 0xce, 0x92, 0x24, 0x89, 0xed, 0x66,
+    0x85, 0xd1, 0x50, 0x08, 0x38, 0xbb, 0xc2, 0xa8, 0x01, 0xb1, 0x6a, 0x5c, 0x0f, 0x57, 0x2f, 0x0e, 0x70, 0x2c, 0x3c,
+    0x47, 0x75, 0xff, 0xe9, 0xc2, 0x8a, 0xb9, 0xb0, 0x02, 0x3f, 0xd2, 0x00, 0x9f, 0xc2, 0x7c, 0xd9, 0x87, 0x79, 0x4d,
+    0x33, 0x94, 0xa1, 0xa4, 0xff, 0x65, 0x91, 0x87, 0x47, 0x2c, 0x7a, 0x86, 0xa1, 0x0b, 0xcc, 0x43, 0xed, 0x3c, 0x7a,
+    0x73, 0x96, 0x4d, 0xfd, 0xc9, 0x26, 0x4d, 0x1e, 0x0f, 0xbc, 0xc0, 0xaf, 0xf3, 0x4b, 0x3c, 0xca, 0x3e, 0x5c, 0x32,
+    0x78, 0x6b, 0x4d, 0xfa, 0x61, 0x4e, 0x67, 0x68, 0x36, 0x9e, 0xcc, 0x22, 0x0f, 0x9f, 0x31, 0x34, 0xdb, 0x64, 0x4d,
+    0xda, 0x46, 0xf3, 0x68, 0x46, 0xa7, 0x68, 0x3a, 0x3a, 0x32, 0x45, 0xd3, 0x4d, 0xd6, 0xcc, 0x3f, 0xcc, 0x2f, 0xcf,
+    0xa2, 0xe9, 0x97, 0x97, 0x71, 0x85, 0xc3, 0x1c, 0xe3, 0xc7, 0xc8, 0xf9, 0x65, 0xe4, 0xe4, 0xb3, 0x16, 0x2a, 0xc0,
+    0x38, 0x3c, 0xd6, 0xe0, 0x58, 0x13, 0xe0, 0x98, 0x69, 0x55, 0x8b, 0x15, 0xf9, 0x6c, 0xb5, 0xc2, 0x21, 0x71, 0x0d,
+    0xa8, 0xe0, 0x24, 0xea, 0x05, 0xa1, 0xa7, 0x04, 0xcf, 0x29, 0x2e, 0x3c, 0x9c, 0xeb, 0xdf, 0x09, 0x27, 0xa1, 0x74,
+    0xc4, 0x37, 0xec, 0xe4, 0x6f, 0xba, 0xe2, 0xa7, 0xfd, 0x6f, 0x3c, 0xc0, 0x2d, 0x65, 0x38, 0x24, 0x42, 0x29, 0x30,
+    0x77, 0xb0, 0x73, 0x25, 0x7e, 0xf7, 0xf6, 0x06, 0xbd, 0xe5, 0xdc, 0x80, 0xb5, 0x39, 0xc2, 0xaf, 0x1c, 0x69, 0x29,
+    0xfb, 0xba, 0x78, 0x93, 0x3e, 0x95, 0xfe, 0x97, 0xf8, 0x45, 0xa0, 0x3f, 0xc0, 0x6d, 0xb5, 0x79, 0x18, 0xe5, 0xbd,
+    0xfd, 0x85, 0x6f, 0x23, 0x56, 0x7e, 0x55, 0x8d, 0x02, 0x87, 0xc3, 0x89, 0xf8, 0x3a, 0x83, 0xb5, 0x82, 0xe3, 0x70,
+    0x22, 0xbf, 0xce, 0xd1, 0x59, 0xdf, 0xbc, 0x8e, 0xd0, 0xce, 0x12, 0x2b, 0x05, 0x83, 0x20, 0x0d, 0x49, 0xad, 0xcd,
+    0xcf, 0x94, 0x35, 0x8f, 0x09, 0xb2, 0x43, 0x47, 0xab, 0x47, 0x3d, 0xcc, 0x00, 0x75, 0x30, 0xaa, 0x0a, 0x30, 0x17,
+    0x1b, 0x1c, 0x2e, 0x14, 0x61, 0x92, 0x5a, 0xeb, 0x47, 0x46, 0xe9, 0x9d, 0xf3, 0xe1, 0xe0, 0x89, 0x1a, 0x22, 0xfd,
+    0xf5, 0xee, 0xdd, 0xef, 0xe5, 0x7d, 0x41, 0x87, 0x01, 0x89, 0xbf, 0xc5, 0xa8, 0x67, 0x3e, 0x33, 0x46, 0x12, 0x6a,
+    0xe7, 0x2b, 0x5e, 0x07, 0x96, 0x18, 0x6b, 0x45, 0x78, 0x2c, 0x6c, 0x47, 0xd5, 0x73, 0xb6, 0x3e, 0xa6, 0xaa, 0x88,
+    0x3d, 0xad, 0x2a, 0x62, 0x5a, 0xbd, 0x38, 0x98, 0xc0, 0xfa, 0xe1, 0xf6, 0x10, 0x1e, 0xef, 0x27, 0x8a, 0xfc, 0x7b,
+    0x0d, 0x66, 0x7f, 0x0b, 0x12, 0x98, 0xd3, 0x26, 0xc0, 0xe4, 0x89, 0x60, 0x48, 0x1c, 0xec, 0xdc, 0xcd, 0x38, 0x7f,
+    0x2d, 0xf1, 0x87, 0x13, 0x45, 0xb4, 0x62, 0x52, 0xb0, 0x87, 0xf2, 0x1c, 0x71, 0x78, 0x10, 0x64, 0x43, 0xe5, 0x1a,
+    0x4e, 0x3c, 0x92, 0xd4, 0x9a, 0xad, 0x6d, 0x10, 0x1e, 0x27, 0x8c, 0xd0, 0xae, 0x03, 0xc5, 0x6f, 0x1a, 0x21, 0x79,
+    0xa0, 0xc2, 0x63, 0xf8, 0x78, 0xd3, 0xcf, 0x8c, 0xfb, 0xd5, 0xf0, 0xd1, 0x80, 0xfc, 0x4f, 0xf9, 0xd2, 0x2f, 0x87,
+    0x97, 0x9f, 0x70, 0x48, 0xfa, 0xf8, 0xef, 0x1f, 0x37, 0x84, 0x6f, 0xef, 0x57, 0xbb, 0x56, 0x4e, 0x7c, 0xe8, 0xd1,
+    0x7c, 0x16, 0x1e, 0xef, 0x8f, 0xe1, 0x31, 0x5c, 0x14, 0xf1, 0x30, 0xe7, 0xab, 0xa2, 0x1f, 0xb9, 0xd5, 0x0f, 0x87,
+    0xa5, 0xde, 0x45, 0x56, 0x7c, 0x11, 0x6a, 0x95, 0x0b, 0xd5, 0x80, 0x11, 0xee, 0xc8, 0xc5, 0x66, 0x22, 0x54, 0xb7,
+    0x76, 0x87, 0x8e, 0x72, 0xee, 0x29, 0xb3, 0x6e, 0xb7, 0xa8, 0xb5, 0x72, 0x9e, 0x13, 0xf2, 0x14, 0xda, 0xe3, 0x40,
+    0xef, 0x27, 0x4c, 0xfe, 0x66, 0xf6, 0xdd, 0x71, 0xa9, 0xf9, 0xfe, 0xe0, 0xd3, 0x10, 0x51, 0x29, 0x56, 0x2a, 0x67,
+    0xa0, 0x1c, 0x98, 0x41, 0xa8, 0xa6, 0xad, 0x90, 0xfb, 0xdc, 0x52, 0x65, 0x23, 0x0b, 0x46, 0xd4, 0xc7, 0xe5, 0xda,
+    0x39, 0xad, 0x0e, 0x4b, 0x6d, 0x38, 0x98, 0x3c, 0x59, 0x0c, 0x40, 0x64, 0x28, 0x17, 0x6b, 0x9b, 0x93, 0xa9, 0x81,
+    0x76, 0xb1, 0xa4, 0xec, 0x61, 0x65, 0xf4, 0x5a, 0xf1, 0x88, 0xf9, 0xc9, 0x9b, 0x7f, 0x9b, 0xd6, 0x74, 0x0a, 0x6c,
+    0x31, 0x62, 0x75, 0x5d, 0x2f, 0xa4, 0x50, 0x10, 0x0d, 0xb3, 0x2d, 0xcf, 0xc8, 0x95, 0x17, 0xbb, 0x70, 0x93, 0x64,
+    0xfe, 0x60, 0xf0, 0x31, 0x4d, 0x92, 0xef, 0x16, 0xa7, 0x70, 0x92, 0x05, 0x5b, 0x1b, 0xab, 0x4d, 0xde, 0x69, 0xe1,
+    0xdd, 0x3c, 0xb6, 0x54, 0xa8, 0x4b, 0xef, 0x7d, 0xd9, 0x2c, 0xc6, 0x75, 0x94, 0x0b, 0xd5, 0x9b, 0xe9, 0x97, 0xd2,
+    0xa2, 0x15, 0x6a, 0xd8, 0xa9, 0x79, 0x36, 0x4f, 0xba, 0xdd, 0xf1, 0x54, 0x09, 0x87, 0x13, 0x77, 0x2d, 0x61, 0xb7,
+    0xf8, 0xbc, 0xb6, 0x4e, 0xd4, 0xfb, 0x68, 0xdc, 0xc9, 0xb9, 0xed, 0x28, 0x83, 0x68, 0x09, 0x6e, 0x0b, 0xa0, 0x16,
+    0xbd, 0x8d, 0x48, 0x38, 0x68, 0xed, 0x98, 0xa7, 0xb3, 0x9a, 0xbe, 0x60, 0x9f, 0xea, 0xfa, 0x5f, 0xdc, 0xbe, 0x8a,
+    0x0e, 0x2d, 0x35, 0x2b, 0xa1, 0xa2, 0xa5, 0x76, 0x4e, 0xb7, 0x79, 0x74, 0xdd, 0xed, 0x16, 0xe3, 0x91, 0x57, 0x96,
+    0xa7, 0xde, 0xcd, 0x7e, 0xd7, 0x9e, 0xf2, 0x9d, 0x76, 0x3b, 0x64, 0xb5, 0x14, 0x7c, 0xe4, 0xeb, 0x59, 0x50, 0x72,
+    0x4e, 0x4f, 0x3a, 0xeb, 0x76, 0xc8, 0x9f, 0x9d, 0x52, 0x7d, 0x55, 0xbf, 0xa6, 0x69, 0xf2, 0x37, 0x37, 0xc2, 0xeb,
+    0x3a, 0x5b, 0xd6, 0xe7, 0x4c, 0xf9, 0xb5, 0xe9, 0x57, 0x4b, 0x5f, 0x5a, 0x45, 0x3c, 0xbc, 0x6e, 0x7c, 0x65, 0x54,
+    0x85, 0xcf, 0x70, 0x55, 0x34, 0x29, 0x12, 0xbc, 0x6c, 0x29, 0xab, 0x2e, 0x66, 0x5b, 0x11, 0x37, 0xe9, 0x89, 0xd4,
+    0xa4, 0xd5, 0x93, 0xb9, 0x35, 0xd0, 0x7a, 0xef, 0xab, 0x1b, 0xad, 0x14, 0x30, 0x27, 0xd4, 0x0a, 0x39, 0x8d, 0xc6,
+    0x14, 0x10, 0x42, 0x8a, 0xa5, 0xa9, 0xde, 0x4b, 0xa0, 0x16, 0xd0, 0x96, 0x0a, 0x47, 0x8a, 0x78, 0xe0, 0x1f, 0x3a,
+    0x5d, 0xf0, 0x52, 0x81, 0x3b, 0xf7, 0x76, 0x33, 0x1d, 0x0c, 0xdc, 0x82, 0xf3, 0x9a, 0xbc, 0x81, 0x69, 0x55, 0xf8,
+    0x15, 0x8c, 0x68, 0xdf, 0xa5, 0x65, 0xbc, 0x15, 0xb5, 0xf0, 0x4f, 0x98, 0xaa, 0xe8, 0x8b, 0xdc, 0x6b, 0xf0, 0x79,
+    0x1e, 0x9e, 0x5b, 0x3d, 0x24, 0x41, 0xad, 0x5c, 0x53, 0x4e, 0x33, 0xd4, 0x49, 0xca, 0xa0, 0xd1, 0x92, 0x83, 0x29,
+    0x6f, 0x6f, 0x7f, 0xfb, 0x67, 0xe5, 0x9d, 0x79, 0x94, 0xeb, 0xec, 0xc3, 0x20, 0xe6, 0x81, 0x51, 0x6a, 0x7e, 0x35,
+    0x3c, 0xb2, 0x3a, 0x6a, 0xed, 0x56, 0x1b, 0xfe, 0x44, 0xc7, 0xfb, 0xf1, 0x70, 0xd0, 0xd3, 0xff, 0xfb, 0x56, 0xa9,
+    0x6e, 0xe9, 0x06, 0x8a, 0x78, 0x44, 0x8a, 0xd8, 0x3b, 0x3c, 0xd0, 0x9b, 0x91, 0xaf, 0x49, 0xab, 0x3f, 0xef, 0xde,
+    0xa2, 0xbf, 0x3a, 0x4e, 0x1d, 0x0c, 0x69, 0xeb, 0xa3, 0x6a, 0xc1, 0x35, 0x9a, 0x97, 0xef, 0xff, 0xbc, 0xbd, 0x3b,
+    0x47, 0xb8, 0xee, 0x99, 0x10, 0x28, 0x36, 0x3c, 0xf7, 0xd6, 0xd2, 0x89, 0x8e, 0x1a, 0xd7, 0xab, 0x8d, 0xfc, 0x14,
+    0x39, 0xc5, 0xd0, 0xd3, 0x6b, 0x21, 0x61, 0x08, 0x63, 0x10, 0xac, 0xd0, 0xc9, 0xab, 0x93, 0xb5, 0x67, 0x7e, 0xc5,
+    0xc3, 0x6d, 0xc7, 0xc3, 0xd5, 0xc7, 0xfd, 0xcb, 0xf7, 0xbf, 0x81, 0xdb, 0x13, 0xb5, 0x09, 0x0b, 0x00, 0x00};
 
 #else  // Brotli (default, smaller)
 constexpr uint8_t INDEX_BR[] PROGMEM = {
-    0x1b, 0x14, 0x0b, 0x00, 0xe4, 0x6f, 0xcd, 0xfc, 0x7b, 0x2e, 0x27, 0xd2, 0x21, 0x2b, 0x58, 0xea, 0x16, 0xf8, 0xa5,
-    0xb6, 0x47, 0x14, 0xb3, 0x4c, 0x56, 0xcc, 0x20, 0x5b, 0x1d, 0xfe, 0x7d, 0xfb, 0xb5, 0x7a, 0x12, 0x0a, 0xd6, 0x48,
-    0x84, 0xa2, 0x21, 0x69, 0x0d, 0x77, 0x33, 0xf3, 0x77, 0xcf, 0x4c, 0x21, 0xf1, 0xde, 0xee, 0x7d, 0x44, 0xbc, 0xd3,
-    0xc4, 0x33, 0x89, 0x1a, 0x69, 0x68, 0x48, 0x57, 0xa7, 0x17, 0x0b, 0x4d, 0x91, 0xac, 0x30, 0x48, 0x21, 0x4d, 0x4c,
-    0x10, 0x57, 0x46, 0x14, 0x17, 0xd5, 0x21, 0x0e, 0xb4, 0x50, 0x87, 0xad, 0x62, 0xda, 0x11, 0x68, 0xc3, 0x20, 0x7f,
-    0x2d, 0xdc, 0x57, 0xeb, 0x2c, 0x36, 0xdb, 0xc4, 0x84, 0x0f, 0xac, 0xec, 0x08, 0x91, 0xa3, 0x92, 0x27, 0x45, 0xc4,
-    0x1e, 0xa4, 0x9e, 0x72, 0x3b, 0xc2, 0xe3, 0x20, 0x7d, 0xf8, 0x05, 0x09, 0xea, 0xe3, 0xa6, 0x3f, 0x11, 0x8b, 0x16,
-    0x11, 0x6b, 0x26, 0x91, 0x1a, 0x2c, 0x19, 0x24, 0xf7, 0x5d, 0x44, 0x82, 0x49, 0x44, 0x15, 0xce, 0x39, 0xdc, 0xcb,
-    0x8f, 0x5b, 0xe1, 0xe2, 0x42, 0x96, 0xa2, 0x10, 0x3c, 0x20, 0xa5, 0x65, 0x85, 0x49, 0x6a, 0x06, 0x08, 0xd1, 0xcb,
-    0x41, 0xb8, 0x49, 0x20, 0x73, 0x71, 0xfe, 0x55, 0x61, 0x45, 0xc6, 0x95, 0x72, 0xc8, 0xf0, 0xa5, 0xe9, 0xe6, 0x3a,
-    0xb9, 0xc3, 0x8a, 0x9f, 0xb5, 0xc1, 0xc9, 0x15, 0x56, 0x93, 0x38, 0x8a, 0x48, 0xf0, 0x4f, 0x38, 0x22, 0xe1, 0x8d,
-    0x55, 0xbb, 0x8c, 0xc3, 0xb0, 0x68, 0xcc, 0x7f, 0x6f, 0xf8, 0xc9, 0x9b, 0x38, 0x41, 0xf1, 0x94, 0x25, 0xf9, 0x6b,
-    0x56, 0xa2, 0xec, 0xa7, 0xbd, 0x2e, 0x69, 0x8e, 0xe2, 0xec, 0x36, 0x94, 0x24, 0x2c, 0x12, 0x1d, 0x4e, 0x76, 0x7e,
-    0x23, 0xcc, 0xf2, 0x6e, 0x35, 0x1a, 0x9c, 0xed, 0x6f, 0x15, 0x3f, 0xc9, 0x72, 0xdc, 0xfd, 0x13, 0x0f, 0x16, 0x8a,
-    0x23, 0x4f, 0xf9, 0x2e, 0x63, 0x44, 0x91, 0x77, 0xe0, 0xb3, 0xd1, 0x78, 0x74, 0xdb, 0x4a, 0x2c, 0xd8, 0xe8, 0xf9,
-    0x2c, 0x03, 0xbe, 0xae, 0xac, 0x4e, 0x42, 0x01, 0xc4, 0x4b, 0x40, 0xe7, 0x94, 0x34, 0x85, 0x2c, 0xfe, 0xf5, 0x74,
-    0x75, 0xd8, 0xdc, 0xec, 0x6a, 0x00, 0x3f, 0x3f, 0x81, 0x77, 0xa8, 0xcd, 0xde, 0x6d, 0x5a, 0x47, 0xa1, 0x99, 0x36,
-    0x87, 0xb6, 0x78, 0x35, 0x3c, 0x9a, 0x64, 0x15, 0x7c, 0x56, 0x76, 0x22, 0xce, 0x46, 0xe5, 0x17, 0x57, 0x05, 0xfc,
-    0x09, 0x69, 0xae, 0x39, 0xaa, 0xee, 0xc9, 0x4e, 0x7f, 0x99, 0x2a, 0x65, 0x82, 0x7e, 0xeb, 0x23, 0x4f, 0x42, 0xd5,
-    0xca, 0xcb, 0x42, 0x74, 0x2e, 0xd2, 0xa2, 0x62, 0x57, 0xd0, 0xa9, 0x7b, 0x4b, 0xac, 0x7b, 0x65, 0x13, 0x47, 0x0f,
-    0x2d, 0x3d, 0xf6, 0xbc, 0x78, 0x5c, 0xa3, 0xc9, 0x57, 0x4b, 0x10, 0x62, 0x68, 0x19, 0x7f, 0xfd, 0x1a, 0xcb, 0x51,
-    0x1e, 0x41, 0x39, 0x55, 0xf3, 0x97, 0x30, 0xca, 0x37, 0xb6, 0x42, 0x1d, 0x2d, 0x8c, 0xc6, 0x65, 0x8a, 0xd2, 0x89,
-    0x88, 0xa6, 0x28, 0xbd, 0x56, 0x7c, 0x2d, 0x5e, 0x0d, 0x2f, 0x9e, 0xc3, 0xa5, 0x80, 0xaf, 0xcc, 0x00, 0xde, 0xe6,
-    0x5a, 0x8b, 0xda, 0xff, 0x1f, 0x16, 0xc8, 0x83, 0x5e, 0xe5, 0xea, 0x25, 0x86, 0x70, 0x55, 0x25, 0x01, 0x14, 0x0c,
-    0x77, 0xd8, 0x31, 0x21, 0xcc, 0x79, 0x15, 0x3b, 0x32, 0x3a, 0xd3, 0xc5, 0x30, 0xaf, 0x03, 0xd8, 0x3e, 0x44, 0xb8,
-    0x63, 0xb5, 0x74, 0x4f, 0x41, 0x4b, 0xf0, 0x24, 0x74, 0xb2, 0x06, 0xb2, 0x7b, 0x06, 0x60, 0xdc, 0xc1, 0x3e, 0x0e,
-    0x6f, 0x1e, 0x3c, 0x42, 0xa0, 0xdb, 0x36, 0x43, 0x30, 0x71, 0xcc, 0xd6, 0x1a, 0xbd, 0x38, 0x61, 0x19, 0x3f, 0xf2,
-    0xdf, 0xf4, 0x53, 0x3d, 0xc1, 0x14, 0xbe, 0x50, 0x1c, 0x2c, 0xf3, 0xaa, 0x74, 0x36, 0xcb, 0xbd, 0x7a, 0x4b, 0xa3,
-    0x1c, 0x90, 0x40, 0x5b, 0x4a, 0x0f, 0x83, 0x6e, 0x9e, 0x96, 0x28, 0x3d, 0x77, 0x43, 0x05, 0x0e, 0x39, 0x26, 0x15,
-    0xb8, 0x6b, 0x4e, 0x3a, 0x62, 0xc2, 0xda, 0xde, 0x8e, 0x29, 0x29, 0x0b, 0x09, 0xa2, 0xb3, 0xa7, 0x1e, 0x9a, 0x0c,
-    0x8f, 0xa1, 0x46, 0x6f, 0x92, 0xf3, 0x9e, 0xb5, 0xc5, 0x7e, 0x0e, 0x8d, 0xeb, 0x55, 0x08, 0xfa, 0xc9, 0xd8, 0x4e,
-    0xe3, 0xd0, 0xca, 0x2a, 0x96, 0x11, 0x7e, 0xb1, 0xd4, 0x7f, 0x8f, 0x1d, 0xb3, 0xc3, 0xa0, 0x89, 0x6f, 0x93, 0x99,
-    0x55, 0x48, 0x97, 0x08, 0x79, 0x66, 0xe9, 0x4a, 0x6b, 0xa0, 0x29, 0xf2, 0x10, 0x1f, 0x22, 0xa2, 0x1b, 0x41, 0xdf,
-    0xa3, 0xde, 0x62, 0x60, 0x8e, 0xa1, 0x60, 0xc4, 0xd5, 0xce, 0x81, 0x47, 0x84, 0x3b, 0x66, 0x60, 0x74, 0xa7, 0x74,
-    0xcc, 0x48, 0xe0, 0xe1, 0xd5, 0x0c, 0x15, 0x98, 0x3d, 0xa7, 0x9c, 0xb2, 0xec, 0xba, 0x0f, 0x2c, 0x52, 0x14, 0x7b,
-    0xe2, 0x49, 0x6e, 0x0f, 0x8c, 0x00, 0xe0, 0x81, 0xf6, 0x57, 0xe4, 0x3f, 0xbf, 0x7c, 0xa9, 0x5e, 0xfe, 0x01, 0xc2,
-    0x64, 0xb0, 0x05, 0x60, 0x01, 0xaa, 0x78, 0x65, 0xb2, 0xeb, 0x56, 0x41, 0xf2, 0xbf, 0xa3, 0x45, 0x4e, 0x3c, 0x78,
-    0xe2, 0xa1, 0x0d, 0xa9, 0x2a, 0xc0, 0x8a, 0xc0, 0x6f, 0xe4, 0x66, 0xbe, 0x72, 0x35, 0x5e, 0xf7, 0x3b, 0x42, 0x53,
-    0xd4, 0xe6, 0x66, 0xb6, 0x78, 0xcd, 0xaa, 0x6f, 0xf4, 0x26, 0x80, 0x3a, 0x4e, 0x74, 0x80, 0x17, 0x88, 0x44, 0x23,
-    0xa6, 0x3a, 0x6f, 0x87, 0xb8, 0xd0, 0x4d, 0xd3, 0xfc, 0x7c, 0xd6, 0x38, 0x2a, 0x00, 0x28, 0x01, 0xa2, 0x40, 0x94,
-    0x6c, 0x1e, 0x8a, 0xed, 0xe3, 0x92, 0x9d, 0x90, 0xe3, 0x0d, 0x02, 0x4e, 0x15, 0x30, 0xed, 0x8f, 0x5b, 0x99, 0xaa,
-    0x7a, 0x4e, 0xb9, 0xec, 0x91, 0xe2, 0x9f, 0xd4, 0xca, 0x46, 0xaf, 0x87, 0x19, 0x4b, 0xad, 0xea, 0xe6, 0x6c, 0x8d,
-    0x53, 0x4b, 0x29, 0xee, 0x1e, 0x96, 0xd8, 0x94, 0x30, 0x3a, 0x9c, 0xb0, 0x4c, 0xdb, 0xe2, 0xa1, 0x7f, 0xc7, 0x11,
-    0xdd, 0xe3, 0x9d, 0x36, 0x44, 0xd3, 0x93, 0x14, 0x9c, 0x4c, 0x9d, 0xdd, 0x3a, 0x7c, 0x41, 0xb1, 0x8f, 0x14, 0xd9,
-    0x4e, 0x61, 0xd9, 0x3a, 0xe3, 0x0d, 0x76, 0xca, 0x6c, 0xac, 0x73, 0xaf, 0xad, 0x94, 0x87, 0x30, 0xf1, 0x30, 0x2f,
-    0x8b, 0xed, 0x4a, 0xed, 0xbc, 0xc2, 0xf2, 0x7c, 0x30, 0xa3, 0x0b, 0x28, 0x64, 0x3b, 0x8c, 0xd4, 0xc3, 0x42, 0xb9,
-    0xa3, 0x44, 0x51, 0x80, 0x07, 0x5a, 0x3d, 0x14, 0x33, 0x99, 0xbf, 0x2a, 0x6b, 0x2b, 0x19, 0x47, 0x72, 0x9e, 0xd4,
-    0xb4, 0x6d, 0x72, 0xdd, 0x8a, 0x4b, 0x33, 0x55, 0xbc, 0xb4, 0xcd, 0xc8, 0x2b, 0x17, 0x2f, 0x74, 0xeb, 0x22, 0x17,
-    0x94, 0x08, 0x27, 0x27, 0xc2, 0x5b, 0x17, 0xb4, 0xa9, 0x22, 0x16, 0x9d, 0xd4, 0xfc, 0xc7, 0x15, 0xa3, 0x9b, 0x86,
-    0x1f, 0xad, 0x45, 0xd3, 0x87, 0x94, 0x5b, 0x31, 0x36, 0xaa, 0xe4, 0x66, 0x8d, 0xcc, 0x31, 0x05, 0x5b, 0xc4, 0x40,
-    0xc0, 0xb8, 0xeb, 0x91, 0x18, 0x22, 0x8c, 0x31, 0x1e, 0xad, 0xd0, 0x3a, 0x98, 0x07, 0xb5, 0x6f, 0x11, 0xba, 0x11,
-    0xa6, 0x14, 0x35, 0x5a, 0xe7, 0x55, 0xdf, 0xb7, 0x4c, 0x03, 0x61, 0xa3, 0x74, 0x23, 0xdf, 0x55, 0x1f, 0x02, 0x51,
-    0x09, 0xb7, 0xba, 0xd5, 0x0c, 0x67, 0xab, 0x98, 0x70, 0x14, 0x64, 0x8d, 0xf4, 0x8b, 0x54, 0x44, 0x07, 0x6f, 0xe0,
-    0x69, 0x32, 0xca, 0x48, 0xe5, 0xd3, 0xa7, 0x17, 0x8f, 0x45, 0x84, 0x04, 0xb7, 0xd1, 0xbb, 0xe1, 0xf6, 0x01, 0x0a,
-    0xf6, 0xee, 0x2b, 0x32, 0xd2, 0xc5, 0xf8, 0xa6, 0xec, 0x0f, 0x1b, 0x09, 0x1d, 0xfc, 0xa2, 0xbf, 0x54, 0x5d, 0x2c,
-    0x62, 0xf4, 0x77, 0xde, 0xad, 0xa0, 0x50, 0x6a, 0xb4, 0xe3, 0x5f, 0xda, 0xff, 0x6b, 0xb1, 0x78, 0xf7, 0xf9, 0xc1,
-    0xa6, 0xa8, 0x93, 0xe8, 0xe4, 0x11, 0x56, 0xa0, 0x5b, 0x85, 0xa7, 0x92, 0x7a, 0x58, 0x45, 0x95, 0xa9, 0x63, 0x83,
-    0xb4, 0x1f, 0x18, 0x31, 0x7a, 0x6d, 0xa1, 0x8d, 0x8c, 0xdc, 0x91, 0x02, 0x3c, 0x9c, 0x92, 0x42, 0x8e, 0x03, 0x02,
-    0xc5, 0x0c, 0x43, 0x54, 0xf9, 0xb2, 0x85, 0x39, 0x2e, 0x77, 0xad, 0x00};
+    0x1b, 0x08, 0x0b, 0x00, 0xe4, 0x7f, 0x9b, 0xad, 0xbb, 0x97, 0x53, 0xde, 0xb7, 0x25, 0x0e, 0x69, 0xd4, 0x69, 0x89,
+    0xba, 0xa5, 0x55, 0x22, 0x04, 0x27, 0xeb, 0x00, 0x52, 0xac, 0xbc, 0xec, 0x5f, 0xfb, 0xb5, 0x7a, 0x12, 0x0a, 0xd6,
+    0x48, 0x84, 0x4a, 0x48, 0x5a, 0xcb, 0xbd, 0xb7, 0x72, 0x66, 0x4e, 0x62, 0xd8, 0xbd, 0x7f, 0x88, 0x68, 0x86, 0x28,
+    0xd6, 0xf1, 0xda, 0x2c, 0xa2, 0x32, 0x5c, 0xdd, 0xab, 0xb2, 0x15, 0xbc, 0x24, 0x13, 0xe6, 0xbd, 0x0c, 0x52, 0x63,
+    0x82, 0x88, 0x6d, 0x74, 0x71, 0x51, 0x9c, 0xe2, 0x40, 0x56, 0xea, 0xb0, 0x5c, 0xb7, 0x1d, 0x81, 0x3a, 0x0c, 0xf2,
+    0xd7, 0xa8, 0x5c, 0x35, 0x2d, 0x43, 0xb3, 0x42, 0x37, 0x7c, 0x60, 0xd8, 0xc1, 0x95, 0x91, 0x94, 0x3c, 0x29, 0x20,
+    0x96, 0x20, 0xf6, 0x24, 0xb7, 0x83, 0x4a, 0x06, 0xf1, 0xc3, 0x2f, 0x88, 0x50, 0x55, 0x35, 0x2d, 0xe8, 0xb6, 0x21,
+    0x38, 0x61, 0x8e, 0x44, 0x2a, 0xac, 0x39, 0xcf, 0x74, 0xaa, 0x31, 0x7f, 0x62, 0x32, 0x9b, 0x99, 0x42, 0x0a, 0xf6,
+    0x6f, 0xd8, 0x89, 0x3f, 0x49, 0xb1, 0xa2, 0x52, 0x0a, 0x8e, 0xb3, 0x27, 0x0b, 0x07, 0x07, 0x58, 0xb0, 0x8f, 0xaa,
+    0xdc, 0x68, 0x12, 0x0f, 0x95, 0xbf, 0xc7, 0x36, 0xd5, 0x60, 0x5a, 0xc7, 0x80, 0xac, 0x52, 0xf7, 0xa7, 0x2d, 0xb6,
+    0x64, 0xda, 0xda, 0x11, 0x8d, 0x6a, 0xe5, 0xba, 0xe9, 0xda, 0xdc, 0x62, 0xc3, 0xcb, 0xae, 0xc1, 0xe1, 0x11, 0xb6,
+    0x33, 0x29, 0x04, 0x09, 0xfe, 0x09, 0x08, 0xc2, 0x1f, 0x98, 0x16, 0x26, 0x0d, 0xce, 0xd7, 0x75, 0xfb, 0xd7, 0xa5,
+    0x82, 0xd7, 0x32, 0x44, 0x72, 0xc1, 0xc2, 0xe4, 0x15, 0xcb, 0x50, 0xfc, 0xd3, 0x58, 0x64, 0x34, 0x41, 0x32, 0xbe,
+    0x1f, 0x08, 0x43, 0x16, 0x14, 0xf7, 0x70, 0x2c, 0x1c, 0x61, 0x09, 0x78, 0x73, 0xd1, 0x30, 0xf6, 0xed, 0x85, 0x55,
+    0x50, 0x02, 0xf0, 0x68, 0x50, 0x5c, 0x1a, 0xd7, 0x3b, 0x8e, 0xf2, 0x23, 0xc8, 0x88, 0x39, 0xd0, 0x84, 0xf7, 0xa6,
+    0xd1, 0xa3, 0xfb, 0xe5, 0x44, 0xc0, 0x4c, 0x2f, 0x6f, 0x19, 0x70, 0x75, 0xf6, 0x1c, 0xb8, 0xce, 0x89, 0x4f, 0x01,
+    0x8d, 0xa1, 0x71, 0xf2, 0x97, 0xf8, 0xe7, 0xd3, 0xf1, 0xe1, 0xfa, 0xfc, 0xc8, 0x03, 0x78, 0x14, 0xa0, 0x3d, 0x28,
+    0xb7, 0xeb, 0x26, 0x52, 0x59, 0xa8, 0xb5, 0x0d, 0x5c, 0x8a, 0x6b, 0xe5, 0xf6, 0x30, 0xd6, 0xf7, 0x71, 0x31, 0xe8,
+    0xbd, 0xc9, 0xfa, 0xf5, 0x71, 0x9d, 0xff, 0xf6, 0x69, 0x62, 0x5f, 0xb5, 0xc7, 0x06, 0x43, 0x54, 0xb5, 0x87, 0xf1,
+    0xcc, 0x84, 0xe8, 0xb7, 0x56, 0x38, 0x43, 0x6a, 0xa6, 0x2f, 0x53, 0xd1, 0x89, 0x48, 0x8d, 0x72, 0x75, 0x4a, 0x17,
+    0xf6, 0x8d, 0xb2, 0xeb, 0xb1, 0x6b, 0x29, 0x1e, 0xd5, 0x74, 0xc7, 0xb3, 0xf4, 0xf1, 0x04, 0x0d, 0xbf, 0x08, 0x81,
+    0x8f, 0xfe, 0x8d, 0xfc, 0xf2, 0x35, 0x92, 0xa0, 0x24, 0x88, 0x12, 0x6a, 0xe6, 0x2f, 0x01, 0x94, 0x5c, 0x4b, 0xf9,
+    0x6b, 0x9a, 0xf6, 0x1a, 0x35, 0x11, 0x8a, 0xc6, 0x04, 0x8d, 0x50, 0x64, 0x48, 0x2d, 0x8b, 0xdf, 0xdf, 0xa1, 0xd1,
+    0xfd, 0x21, 0xd7, 0x40, 0x96, 0x00, 0xb1, 0x9f, 0x54, 0xc2, 0xe1, 0x00, 0x79, 0x15, 0x80, 0xf8, 0xca, 0x8e, 0xc5,
+    0x06, 0x03, 0xdf, 0x72, 0x49, 0xc0, 0x08, 0x27, 0x90, 0xe3, 0x14, 0xc2, 0xac, 0xc3, 0x83, 0xc9, 0xf6, 0x9d, 0x12,
+    0xab, 0x46, 0xae, 0x03, 0x74, 0x1d, 0x27, 0xce, 0x91, 0x1d, 0x4e, 0xb4, 0xbe, 0x80, 0xe7, 0x6a, 0x6d, 0x0a, 0x20,
+    0x47, 0x6b, 0x00, 0x4e, 0x25, 0x52, 0xe6, 0xf5, 0xe9, 0x43, 0x84, 0xc1, 0x0d, 0x4b, 0x04, 0xb3, 0x91, 0x49, 0xf5,
+    0xe9, 0xc4, 0x2e, 0x1b, 0xf9, 0x98, 0xf9, 0xea, 0x9e, 0xb8, 0xf6, 0x53, 0xf8, 0x42, 0xc2, 0x60, 0x5c, 0xa9, 0xd2,
+    0xfe, 0x0a, 0xe5, 0xd4, 0x7d, 0x36, 0x76, 0x04, 0x12, 0x38, 0xa1, 0xc4, 0x30, 0xb8, 0xf2, 0x69, 0x86, 0x5b, 0xe7,
+    0xe5, 0xa0, 0xc0, 0xfe, 0x91, 0x19, 0x03, 0x1e, 0xa9, 0x93, 0x26, 0x49, 0x58, 0xd5, 0xf6, 0x33, 0x4e, 0x0a, 0x89,
+    0x64, 0x1e, 0xb4, 0x7a, 0x5d, 0x0d, 0x12, 0xcf, 0x2b, 0xdd, 0x35, 0x90, 0x55, 0xc3, 0x0e, 0xcd, 0x0e, 0xad, 0x6b,
+    0x8f, 0x43, 0xd0, 0xb4, 0x6a, 0xdb, 0x4b, 0xe5, 0xa4, 0x9b, 0x09, 0x23, 0x1a, 0x43, 0xa9, 0xff, 0x61, 0x8b, 0x07,
+    0xd6, 0x0f, 0x83, 0x23, 0xbe, 0x8a, 0x66, 0xa2, 0x10, 0x2f, 0x11, 0x01, 0x0d, 0xc6, 0x96, 0xba, 0x87, 0xaa, 0xa8,
+    0x44, 0x7c, 0x1e, 0x34, 0xdb, 0xba, 0x41, 0x90, 0xf0, 0x7a, 0xdb, 0x63, 0x60, 0x96, 0x8d, 0x64, 0xcb, 0x2f, 0x28,
+    0x96, 0x04, 0xd5, 0xc0, 0x7a, 0xe8, 0xec, 0xd1, 0x61, 0x1b, 0x09, 0x4b, 0x4c, 0x6e, 0x1b, 0x31, 0x98, 0x9c, 0x6d,
+    0xdb, 0xd0, 0xec, 0xa4, 0x0f, 0x0a, 0xe0, 0xc8, 0x35, 0xc4, 0x93, 0xdc, 0xee, 0x19, 0x00, 0x80, 0x07, 0xf5, 0xcf,
+    0xe0, 0x7f, 0x75, 0xf8, 0x52, 0x3a, 0xfc, 0x0d, 0x84, 0xa5, 0xc1, 0xb2, 0x1c, 0x25, 0x40, 0xc5, 0x8b, 0xb3, 0xdb,
+    0x7a, 0x1b, 0x44, 0xff, 0x79, 0x9a, 0x26, 0xc4, 0xe7, 0x9e, 0x78, 0x4c, 0xa5, 0x94, 0xab, 0x78, 0x34, 0x9d, 0xb5,
+    0xb7, 0x24, 0x26, 0xe7, 0x9a, 0xf3, 0xe5, 0x2a, 0x35, 0x4b, 0xbe, 0x74, 0xd7, 0x01, 0xbc, 0x71, 0x72, 0x03, 0x5c,
+    0x40, 0x24, 0x17, 0x61, 0x5b, 0x7b, 0x19, 0xc2, 0x7f, 0x4e, 0x5b, 0x24, 0xfb, 0x8b, 0xc3, 0x51, 0x00, 0x3d, 0x09,
+    0x04, 0x05, 0x72, 0x64, 0xf6, 0xf0, 0x6b, 0x99, 0x38, 0x93, 0x5b, 0xac, 0x0c, 0xff, 0x40, 0x7b, 0x53, 0xba, 0xab,
+    0x61, 0xc9, 0xa2, 0xde, 0xd6, 0x2b, 0x0c, 0xbd, 0x85, 0xac, 0x4c, 0x64, 0x8b, 0xe6, 0x69, 0x2b, 0x56, 0x10, 0x1b,
+    0x08, 0x59, 0x6c, 0x55, 0x0a, 0xaa, 0x93, 0x85, 0x1d, 0x45, 0xda, 0xc6, 0x39, 0xe6, 0x6a, 0xab, 0x71, 0x73, 0x46,
+    0x0f, 0xf7, 0xab, 0x4e, 0x88, 0xae, 0x8c, 0xe0, 0x91, 0xda, 0x35, 0x8c, 0xd3, 0x18, 0x92, 0x3d, 0xab, 0x2f, 0x0d,
+    0xd6, 0xc9, 0x06, 0xdb, 0xc2, 0x62, 0xcb, 0x8a, 0x23, 0x5b, 0x28, 0x2e, 0x9b, 0x96, 0xc4, 0xc1, 0x42, 0xa9, 0x8d,
+    0x69, 0xe5, 0x8f, 0x89, 0x12, 0x11, 0x9a, 0x56, 0x3b, 0x3c, 0x2b, 0xb4, 0xb2, 0x7b, 0xfd, 0xdb, 0x80, 0x92, 0xb4,
+    0xca, 0x44, 0x37, 0x8c, 0x94, 0x2f, 0x4a, 0xb4, 0xc4, 0x28, 0x83, 0x8a, 0x78, 0xcb, 0xd2, 0x5c, 0x5c, 0x35, 0x29,
+    0x95, 0x35, 0x2f, 0x99, 0x28, 0x4f, 0x22, 0x18, 0x70, 0x85, 0xee, 0x2c, 0xb9, 0xef, 0x14, 0x57, 0x73, 0x23, 0x45,
+    0xae, 0xdc, 0x54, 0x56, 0x55, 0x78, 0x56, 0xad, 0x48, 0x26, 0x27, 0xbf, 0xcb, 0xd7, 0x54, 0xa9, 0xa8, 0xd7, 0xb5,
+    0x71, 0x9c, 0xe7, 0x79, 0x89, 0x5c, 0xa9, 0x6a, 0x53, 0xe8, 0xfa, 0x0d, 0x69, 0x36, 0xed, 0xad, 0x33, 0xc9, 0x75,
+    0x17, 0xe9, 0x8f, 0x31, 0x58, 0xa6, 0x27, 0xfc, 0x79, 0xc6, 0xb6, 0xd5, 0x65, 0x90, 0x31, 0xc6, 0x9d, 0x29, 0x95,
+    0x83, 0xe5, 0x4e, 0xbb, 0xd7, 0xdc, 0x8e, 0xd0, 0x3a, 0x54, 0x27, 0xce, 0xf5, 0xdb, 0xbd, 0x89, 0x3c, 0x61, 0xb3,
+    0x71, 0x23, 0xc7, 0x55, 0x9e, 0xea, 0x50, 0xe4, 0x37, 0xae, 0x72, 0x34, 0x66, 0xb9, 0x6e, 0x2c, 0x0a, 0x69, 0x8d,
+    0x94, 0x8b, 0x98, 0x08, 0x05, 0x3c, 0x45, 0x45, 0xe1, 0x6c, 0x22, 0xc5, 0x8f, 0x1f, 0x9f, 0x3f, 0xd2, 0x01, 0x12,
+    0xec, 0x86, 0x2f, 0x87, 0x8b, 0x47, 0x30, 0xd0, 0x77, 0x77, 0x1a, 0x13, 0x2d, 0xc6, 0x31, 0x65, 0x77, 0xd8, 0x8c,
+    0xe7, 0xe0, 0x16, 0xf9, 0x4b, 0xd4, 0xc5, 0xa8, 0x67, 0x79, 0xe7, 0xc3, 0x07, 0x94, 0x46, 0xa3, 0x8c, 0x67, 0xd3,
+    0xff, 0x5f, 0x96, 0xfa, 0xed, 0xa7, 0xd3, 0xdd, 0x4f, 0x27, 0x49, 0x27, 0xcf, 0xa4, 0x02, 0xc3, 0x27, 0x3c, 0x96,
+    0x64, 0x24, 0x55, 0xc8, 0x36, 0x45, 0x68, 0x90, 0xea, 0x03, 0x0b, 0x46, 0xa7, 0x8d, 0xb4, 0x26, 0x91, 0x07, 0x4c,
+    0x80, 0x7b, 0x93, 0xa8, 0x10, 0xcb, 0x5e, 0x8d, 0x42, 0x86, 0x3e, 0x2a, 0x7c, 0x99, 0x79, 0x8e, 0xcb, 0x43, 0x28};
 
 // Backwards compatibility alias
 #define INDEX_GZ INDEX_BR

esphome/components/captive_portal/captive_portal.cpp

@@ -6,9 +6,6 @@
 #include "esphome/core/string_ref.h"
 #include "esphome/components/wifi/scan_list.h"
 #include "esphome/components/wifi/wifi_component.h"
-#ifdef USE_PROVISIONING
-#include "esphome/components/provisioning/provisioning.h"
-#endif
 #include "captive_index.h"
 
 namespace esphome::captive_portal {
@@ -81,20 +78,6 @@ void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
 void CaptivePortal::setup() {
   // Disable loop by default - will be enabled when captive portal starts
   this->disable_loop();
-#ifdef USE_PROVISIONING
-  // The captive portal is a provisioning surface: once the provisioning window
-  // has closed, stop serving it. WiFi's own closed-callback shuts down the
-  // access point the portal runs on, and the gated fallback in WiFiComponent's
-  // loop() ensures neither is started again afterwards.
-  if (provisioning::global_provisioning_manager != nullptr) {
-    provisioning::global_provisioning_manager->add_on_closed_callback([this]() {
-      if (this->active_) {
-        ESP_LOGD(TAG, "Provisioning window closed; stopping captive portal");
-        this->end();
-      }
-    });
-  }
-#endif
 }
 void CaptivePortal::start() {
   this->base_->init();

esphome/components/climate/climate.cpp

@@ -551,14 +551,7 @@ ClimateCall ClimateDeviceRestoreState::to_call(Climate *climate) {
 
 void ClimateDeviceRestoreState::apply(Climate *climate) {
   auto traits = climate->get_traits();
-  // A saved mode the device no longer offers cannot be selected again, so skip it and leave the
-  // entity on the mode it already has. The other saved fields are still restored.
-  if (traits.supports_mode(this->mode)) {
-    climate->mode = this->mode;
-  } else {
-    ESP_LOGW(TAG, "'%s' - Saved mode %s is no longer supported, keeping %s", climate->get_name().c_str(),
-             LOG_STR_ARG(climate_mode_to_string(this->mode)), LOG_STR_ARG(climate_mode_to_string(climate->mode)));
-  }
+  climate->mode = this->mode;
   if (traits.has_feature_flags(CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE |
                                CLIMATE_REQUIRES_TWO_POINT_TARGET_TEMPERATURE)) {
     climate->target_temperature_low = this->target_temperature_low;

esphome/components/climate_ir_lg/climate.py

@@ -13,11 +13,9 @@ CONF_HEADER_LOW = "header_low"
 CONF_BIT_HIGH = "bit_high"
 CONF_BIT_ONE_LOW = "bit_one_low"
 CONF_BIT_ZERO_LOW = "bit_zero_low"
-CONF_ADVANCED_COMMANDS_SUPPORT = "advanced_commands_support"
 
 CONFIG_SCHEMA = climate_ir.climate_ir_with_receiver_schema(LgIrClimate).extend(
     {
-        cv.Optional(CONF_ADVANCED_COMMANDS_SUPPORT, default=False): cv.boolean,
         cv.Optional(
             CONF_HEADER_HIGH, default="8000us"
         ): cv.positive_time_period_microseconds,
@@ -40,7 +38,6 @@ CONFIG_SCHEMA = climate_ir.climate_ir_with_receiver_schema(LgIrClimate).extend(
 async def to_code(config: ConfigType) -> None:
     var = await climate_ir.new_climate_ir(config)
 
-    cg.add(var.set_advanced_commands_support(config[CONF_ADVANCED_COMMANDS_SUPPORT]))
     cg.add(var.set_header_high(config[CONF_HEADER_HIGH]))
     cg.add(var.set_header_low(config[CONF_HEADER_LOW]))
     cg.add(var.set_bit_high(config[CONF_BIT_HIGH]))

esphome/components/climate_ir_lg/climate_ir_lg.cpp

@@ -5,85 +5,11 @@ namespace esphome::climate_ir_lg {
 
 static const char *const TAG = "climate.climate_ir_lg";
 
-// All codes provided here are missing the checksum (last 4 bits)
-// this checksum needs to be calculated before sending (look at `calc_checksum_()`)
-
-const uint32_t LG_HEADER = 0x8800000;
-
 // Commands
-const uint32_t COMMAND_HEADER_MASK = 0xFF000;
-const uint32_t COMMAND_DATA_MASK = 0x00FF0;
-const uint32_t CHECKSUM_MASK = 0xF;
+const uint32_t COMMAND_MASK = 0xFF000;
+const uint32_t COMMAND_OFF = 0xC0000;
+const uint32_t COMMAND_SWING = 0x10000;
 
-enum CommandBasic : uint32_t {
-  HEADER_BASIC = 0x10000,
-  BASIC_SWING_TOGGLE = 0x000,
-
-  // JET MODE (only for cooling/drying/heating modes)
-  // For 30 minutes: max airflow (stronger than F5 aka FAN_MAX) + PO (min/min/max temperature respectively)
-  // After 30 minutes: F5 aka FAN_MAX + min/min/max temperature respectively
-  BASIC_JET = 0x080,
-};
-
-enum CommandSys : uint32_t {
-  HEADER_SYS = 0xC0000,
-
-  COMMAND_OFF = 0x050,
-
-  // Also known as 'auto-dry'
-  AUTO_CLEAN_ON = 0x0B0,
-  AUTO_CLEAN_OFF = 0x0C0,
-
-  PURIFY_ON = 0x000,   // From either OFF or Mode -> Purify
-  PURIFY_OFF = 0x080,  // From Mode + Purify -> Mode
-
-  QUIET_OUTDOOR_ON = 0xA60,
-  QUIET_OUTDOOR_OFF = 0xA70,
-
-  // ENERGY CTRL (only in Cooling mode)
-  COOL_ENERG_CTRL_80 = 0x7D0,   // 80%
-  COOL_ENERG_CTRL_60 = 0x7E0,   // 60%
-  COOL_ENERG_CTRL_40 = 0x800,   // 40%
-  COOL_ENERG_CTRL_OFF = 0x7F0,  // OFF
-
-  DISPLAY_KW = 0x460,
-  LIGHT_ON_OFF = 0x0A0,
-
-  TEMP_UNIT_F = 0x170,
-  TEMP_UNIT_C = 0x160,
-};
-
-enum CommandAdvSwing : uint32_t {
-  HEADER_ADV_SWING = 0x13000,
-
-  // Only 5 bits are relevant, I got 0x13952 once - not sure what is the 8th bit so ignoring that.
-  ADV_SWING_DATA_MASK = 0x1F0,
-
-  // Commands for Advanced Vertical Control: Swing + 6 fixed positions
-  VERT_FIX_1 = 0x040,  // Down
-  VERT_FIX_2 = 0x050,
-  VERT_FIX_3 = 0x060,
-  VERT_FIX_4 = 0x070,
-  VERT_FIX_5 = 0x080,
-  VERT_FIX_6 = 0x090,      // Up
-  VERT_SWING_ON = 0x140,   // Swing between 1 and 6
-  VERT_SWING_OFF = 0x150,  // Stops immediately
-
-  // Commands for Advanced Horizontal Control: Swing (3 modes) + 5 fixed positions
-  HORI_FIX_1 = 0x0B0,  // Left
-  HORI_FIX_2 = 0x0C0,
-  HORI_FIX_3 = 0x0D0,
-  HORI_FIX_4 = 0x0E0,
-  HORI_FIX_5 = 0x0F0,           // Right
-  HORI_SWING_ON_LEFT = 0x100,   // Swing between 1 and 3
-  HORI_SWING_ON_RIGHT = 0x110,  // Swing between 3 and 5
-  HORI_SWING_ON_FULL = 0x160,   // Swing between 1 and 5
-  HORI_SWING_OFF = 0x170,       // Stops immediately
-};
-
-// Following commands contain mode, fan speed and temperature
-
-// Modes
 const uint32_t COMMAND_ON_COOL = 0x00000;
 const uint32_t COMMAND_ON_DRY = 0x01000;
 const uint32_t COMMAND_ON_FAN_ONLY = 0x02000;
@@ -97,13 +23,11 @@ const uint32_t COMMAND_AI = 0x0B000;
 const uint32_t COMMAND_HEAT = 0x0C000;
 
 // Fan speed
-const uint32_t FAN_SPEED_MASK = 0xF0;
+const uint32_t FAN_MASK = 0xF0;
 const uint32_t FAN_AUTO = 0x50;
-const uint32_t FAN_MIN = 0x00;  // AKA F1
-const uint32_t FAN_F2 = 0x90;
-const uint32_t FAN_MED = 0x20;  // AKA F3
-const uint32_t FAN_F4 = 0xA0;
-const uint32_t FAN_MAX = 0x40;  // AKA F5
+const uint32_t FAN_MIN = 0x00;
+const uint32_t FAN_MED = 0x20;
+const uint32_t FAN_MAX = 0x40;
 
 // Temperature
 const uint8_t TEMP_RANGE = TEMP_MAX - TEMP_MIN + 1;
@@ -113,37 +37,16 @@ const uint32_t TEMP_SHIFT = 8;
 const uint16_t BITS = 28;
 
 void LgIrClimate::transmit_state() {
-  uint32_t remote_state = LG_HEADER;
+  uint32_t remote_state = 0x8800000;
 
-  // ESP_LOGD(TAG, "climate_lg_ir mode_before_ code: 0x%02X", this->modeBefore_);
+  // ESP_LOGD(TAG, "climate_lg_ir mode_before_ code: 0x%02X", modeBefore_);
 
   // Set command
   if (this->send_swing_cmd_) {
     this->send_swing_cmd_ = false;
-    if (this->advanced_commands_support_) {
-      switch (this->swing_mode) {
-        case climate::CLIMATE_SWING_VERTICAL:
-          ESP_LOGD(TAG, "setting swing vertical");
-          remote_state |= CommandAdvSwing::HEADER_ADV_SWING;
-          remote_state |= CommandAdvSwing::VERT_SWING_ON;
-          break;
-        case climate::CLIMATE_SWING_OFF:
-          ESP_LOGD(TAG, "setting swing off");
-          remote_state |= CommandAdvSwing::HEADER_ADV_SWING;
-          remote_state |= CommandAdvSwing::VERT_SWING_OFF;
-          break;
-        default:
-          return;
-      }
-      this->transmit_(remote_state);
-      this->publish_state();
-      return;
-    } else {  // just toggle swing when advanced_commands_support is not set
-      remote_state |= HEADER_BASIC;
-      remote_state |= BASIC_SWING_TOGGLE;
-    }
-  } else {  // Mode commands
-    const bool climate_is_off = (this->mode_before_ == climate::CLIMATE_MODE_OFF);
+    remote_state |= COMMAND_SWING;
+  } else {
+    bool climate_is_off = (this->mode_before_ == climate::CLIMATE_MODE_OFF);
     switch (this->mode) {
       case climate::CLIMATE_MODE_COOL:
         remote_state |= climate_is_off ? COMMAND_ON_COOL : COMMAND_COOL;
@@ -162,8 +65,8 @@ void LgIrClimate::transmit_state() {
         break;
       case climate::CLIMATE_MODE_OFF:
       default:
-        remote_state |= CommandSys::HEADER_SYS;
-        remote_state |= CommandSys::COMMAND_OFF;
+        remote_state |= COMMAND_OFF;
+        break;
     }
   }
 
@@ -172,8 +75,9 @@ void LgIrClimate::transmit_state() {
   ESP_LOGD(TAG, "climate_lg_ir mode code: 0x%02X", this->mode);
 
   // Set fan speed
-  if (this->mode !=
-      climate::CLIMATE_MODE_OFF) {  // https://github.com/esphome/esphome/pull/10875#issuecomment-5042765948
+  if (this->mode == climate::CLIMATE_MODE_OFF) {
+    remote_state |= FAN_AUTO;
+  } else {
     switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
       case climate::CLIMATE_FAN_HIGH:
         remote_state |= FAN_MAX;
@@ -191,20 +95,10 @@ void LgIrClimate::transmit_state() {
     }
   }
 
-  uint8_t temp;
-  switch (this->mode) {
-    case climate::CLIMATE_MODE_HEAT_COOL:
-      if (!this->advanced_commands_support_) {  // Keep previous behavior
-        break;
-      }
-      [[fallthrough]];
-    case climate::CLIMATE_MODE_COOL:
-    case climate::CLIMATE_MODE_HEAT:
-      temp = static_cast<uint8_t>(roundf(clamp<float>(this->target_temperature, TEMP_MIN, TEMP_MAX)));
-      remote_state |= (temp - 15) << TEMP_SHIFT;
-      break;
-    default:
-      break;
+  // Set temperature
+  if (this->mode == climate::CLIMATE_MODE_COOL || this->mode == climate::CLIMATE_MODE_HEAT) {
+    auto temp = (uint8_t) roundf(clamp<float>(this->target_temperature, TEMP_MIN, TEMP_MAX));
+    remote_state |= ((temp - 15) << TEMP_SHIFT);
   }
 
   this->transmit_(remote_state);
@@ -230,134 +124,62 @@ bool LgIrClimate::on_receive(remote_base::RemoteReceiveData data) {
     }
   }
 
-  ESP_LOGD(TAG, "Received 0x%02" PRIX32, remote_state);
-  if ((remote_state & 0xFF00000) != LG_HEADER)
+  ESP_LOGD(TAG, "Decoded 0x%02" PRIX32, remote_state);
+  if ((remote_state & 0xFF00000) != 0x8800000)
     return false;
 
-  // Decode commands
-  switch (remote_state & COMMAND_HEADER_MASK) {
-    case CommandSys::HEADER_SYS:
-      ESP_LOGD(TAG, "Got system command! With data: 0x%02" PRIX32, remote_state & COMMAND_DATA_MASK);
-      if ((remote_state & COMMAND_DATA_MASK) == CommandSys::COMMAND_OFF) {
-        this->mode = climate::CLIMATE_MODE_OFF;
-      } else {
-        return false;
-      }
-      break;
-    case CommandAdvSwing::HEADER_ADV_SWING:
-      ESP_LOGD(TAG, "Got advanced swing command! With data: 0x%02" PRIX32,
-               remote_state & CommandAdvSwing::ADV_SWING_DATA_MASK);
-      switch (remote_state & CommandAdvSwing::ADV_SWING_DATA_MASK) {
-        case CommandAdvSwing::VERT_SWING_ON:
-          this->swing_mode = climate::CLIMATE_SWING_VERTICAL;
-          break;
-        case CommandAdvSwing::VERT_SWING_OFF:
-        case CommandAdvSwing::VERT_FIX_1:
-        case CommandAdvSwing::VERT_FIX_2:
-        case CommandAdvSwing::VERT_FIX_3:
-        case CommandAdvSwing::VERT_FIX_4:
-        case CommandAdvSwing::VERT_FIX_5:
-        case CommandAdvSwing::VERT_FIX_6:
-          this->swing_mode = climate::CLIMATE_SWING_OFF;
-          break;
-        default:
-          return false;  // Ignore all other (horizontal) swing commands
-      }
+  // Get command
+  if ((remote_state & COMMAND_MASK) == COMMAND_OFF) {
+    this->mode = climate::CLIMATE_MODE_OFF;
+  } else if ((remote_state & COMMAND_MASK) == COMMAND_SWING) {
+    this->swing_mode =
+        this->swing_mode == climate::CLIMATE_SWING_OFF ? climate::CLIMATE_SWING_VERTICAL : climate::CLIMATE_SWING_OFF;
+  } else {
+    switch (remote_state & COMMAND_MASK) {
+      case COMMAND_DRY:
+      case COMMAND_ON_DRY:
+        this->mode = climate::CLIMATE_MODE_DRY;
+        break;
+      case COMMAND_FAN_ONLY:
+      case COMMAND_ON_FAN_ONLY:
+        this->mode = climate::CLIMATE_MODE_FAN_ONLY;
+        break;
+      case COMMAND_AI:
+      case COMMAND_ON_AI:
+        this->mode = climate::CLIMATE_MODE_HEAT_COOL;
+        break;
+      case COMMAND_HEAT:
+      case COMMAND_ON_HEAT:
+        this->mode = climate::CLIMATE_MODE_HEAT;
+        break;
+      case COMMAND_COOL:
+      case COMMAND_ON_COOL:
+      default:
+        this->mode = climate::CLIMATE_MODE_COOL;
+        break;
+    }
 
-      this->publish_state();
-      return true;
-
-    case HEADER_BASIC:
-      if ((remote_state & COMMAND_DATA_MASK) == BASIC_JET) {
-        switch (this->mode) {
-          case climate::CLIMATE_MODE_COOL:
-          case climate::CLIMATE_MODE_HEAT:
-          case climate::CLIMATE_MODE_DRY:
-            this->target_temperature =
-                this->mode == climate::CLIMATE_MODE_HEAT ? this->maximum_temperature_ : this->minimum_temperature_;
-            this->fan_mode = climate::CLIMATE_FAN_HIGH;
-            // When enabling PO(WER) also known as JET mode, swing is set to VERT_3, but after 30 mins it will switch
-            // back to what it was before, so let's just not change it here it at all
-            this->publish_state();
-            return true;
-          default:
-            ESP_LOGD(TAG, "Got jet command, but current mode does not support it! Ignoring.");
-            return false;
-        }
-      }
-
-      // Keep previous behavior in case of other BASIC command
-      if (this->swing_mode == climate::CLIMATE_SWING_OFF) {  // Just flip between vertical and off
-        this->swing_mode = climate::CLIMATE_SWING_VERTICAL;
-      } else {
-        this->swing_mode = climate::CLIMATE_SWING_OFF;
-      }
-      this->publish_state();
-      return true;
-    // Following commands also contain fan speed and temperature, so no 'return' in these cases
-    case COMMAND_DRY:
-    case COMMAND_ON_DRY:
-      this->mode = climate::CLIMATE_MODE_DRY;
-      break;
-    case COMMAND_FAN_ONLY:
-    case COMMAND_ON_FAN_ONLY:
-      this->mode = climate::CLIMATE_MODE_FAN_ONLY;
-      break;
-    case COMMAND_AI:
-    case COMMAND_ON_AI:
-      this->mode = climate::CLIMATE_MODE_HEAT_COOL;
-      break;
-    case COMMAND_HEAT:
-    case COMMAND_ON_HEAT:
-      this->mode = climate::CLIMATE_MODE_HEAT;
-      break;
-    case COMMAND_COOL:
-    case COMMAND_ON_COOL:
-      this->mode = climate::CLIMATE_MODE_COOL;
-      break;
-    default:
-      ESP_LOGD(TAG, "Got unknown command! Ignoring!");
-      return false;
-  }
-
-  // Decode fan speed
-  switch (remote_state & FAN_SPEED_MASK) {
-    case FAN_AUTO:
+    // Get fan speed
+    if (this->mode == climate::CLIMATE_MODE_HEAT_COOL) {
       this->fan_mode = climate::CLIMATE_FAN_AUTO;
-      break;
-    case FAN_MIN:
-    case FAN_F2:
-      this->fan_mode = climate::CLIMATE_FAN_LOW;
-      break;
-    case FAN_MED:
-    case FAN_F4:
-      this->fan_mode = climate::CLIMATE_FAN_MEDIUM;
-      break;
-    case FAN_MAX:
-      this->fan_mode = climate::CLIMATE_FAN_HIGH;
-      break;
-    default:
-      ESP_LOGD(TAG, "Got unknown fan speed! Ignoring!");
-      return false;
-  }
+    } else if (this->mode == climate::CLIMATE_MODE_COOL || this->mode == climate::CLIMATE_MODE_DRY ||
+               this->mode == climate::CLIMATE_MODE_FAN_ONLY || this->mode == climate::CLIMATE_MODE_HEAT) {
+      if ((remote_state & FAN_MASK) == FAN_AUTO) {
+        this->fan_mode = climate::CLIMATE_FAN_AUTO;
+      } else if ((remote_state & FAN_MASK) == FAN_MIN) {
+        this->fan_mode = climate::CLIMATE_FAN_LOW;
+      } else if ((remote_state & FAN_MASK) == FAN_MED) {
+        this->fan_mode = climate::CLIMATE_FAN_MEDIUM;
+      } else if ((remote_state & FAN_MASK) == FAN_MAX) {
+        this->fan_mode = climate::CLIMATE_FAN_HIGH;
+      }
+    }
 
-  // Keep previous behavior
-  if (this->mode == climate::CLIMATE_MODE_HEAT_COOL && !(this->advanced_commands_support_)) {
-    this->fan_mode = climate::CLIMATE_FAN_AUTO;
-  }
-
-  // Decode temperature for modes that support it
-  switch (this->mode) {
-    case climate::CLIMATE_MODE_HEAT_COOL:
-    case climate::CLIMATE_MODE_COOL:
-    case climate::CLIMATE_MODE_HEAT:
+    // Get temperature
+    if (this->mode == climate::CLIMATE_MODE_COOL || this->mode == climate::CLIMATE_MODE_HEAT) {
       this->target_temperature = ((remote_state & TEMP_MASK) >> TEMP_SHIFT) + 15;
-      break;
-    default:
-      break;
+    }
   }
-
-  this->mode_before_ = this->mode;
   this->publish_state();
 
   return true;
@@ -385,14 +207,14 @@ void LgIrClimate::transmit_(uint32_t value) {
   data->mark(this->bit_high_);
   transmit.perform();
 }
-
 void LgIrClimate::calc_checksum_(uint32_t &value) {
+  uint32_t mask = 0xF;
   uint32_t sum = 0;
   for (uint8_t i = 1; i < 8; i++) {
-    sum += (value & (CHECKSUM_MASK << (i * 4))) >> (i * 4);
+    sum += (value & (mask << (i * 4))) >> (i * 4);
   }
 
-  value |= (sum & CHECKSUM_MASK);
+  value |= (sum & mask);
 }
 
 }  // namespace esphome::climate_ir_lg

esphome/components/climate_ir_lg/climate_ir_lg.h

@@ -21,13 +21,12 @@ class LgIrClimate final : public climate_ir::ClimateIR {
   /// Override control to change settings of the climate device.
   void control(const climate::ClimateCall &call) override {
     this->send_swing_cmd_ = call.get_swing_mode().has_value();
-    // swing resets after unit powered off, except when advanced_commands_support_ is set
+    // swing resets after unit powered off
     auto mode = call.get_mode();
-    if (mode.has_value() && *mode == climate::CLIMATE_MODE_OFF && !(this->advanced_commands_support_))
+    if (mode.has_value() && *mode == climate::CLIMATE_MODE_OFF)
       this->swing_mode = climate::CLIMATE_SWING_OFF;
     climate_ir::ClimateIR::control(call);
   }
-  void set_advanced_commands_support(bool value) { this->advanced_commands_support_ = value; }
   void set_header_high(uint32_t header_high) { this->header_high_ = header_high; }
   void set_header_low(uint32_t header_low) { this->header_low_ = header_low; }
   void set_bit_high(uint32_t bit_high) { this->bit_high_ = bit_high; }
@@ -45,7 +44,6 @@ class LgIrClimate final : public climate_ir::ClimateIR {
   void calc_checksum_(uint32_t &value);
   void transmit_(uint32_t value);
 
-  bool advanced_commands_support_{false};
   uint32_t header_high_;
   uint32_t header_low_;
   uint32_t bit_high_;

esphome/components/dashboard_import/__init__.py

@@ -4,6 +4,7 @@ import re
 import secrets
 from typing import Any
 
+import requests
 from ruamel.yaml import YAML
 
 from esphome import git
@@ -12,7 +13,7 @@ from esphome.components.packages import validate_source_shorthand
 import esphome.config_validation as cv
 from esphome.const import CONF_ESPHOME, CONF_PROJECT, CONF_REF, CONF_WIFI
 import esphome.final_validate as fv
-from esphome.net_retry import fetch_with_retry, http_request
+from esphome.happy_eyeballs import ensure_happy_eyeballs
 from esphome.types import ConfigType
 from esphome.yaml_util import dump
 
@@ -110,20 +111,14 @@ def import_config(
 
     if git_file.query and "full_config" in git_file.query:
         url = git_file.raw_url
-
-        # Deferred so config-time imports of this component stay light;
-        # http_request does the lazy import for the request itself.
-        import requests
-
-        def _fetch() -> str:
-            req = http_request("GET", url, timeout=30)
-            req.raise_for_status()
-            return req.text
-
         try:
-            contents = fetch_with_retry(url, _fetch, what="Import")
+            ensure_happy_eyeballs()
+            req = requests.get(url, timeout=30)
+            req.raise_for_status()
         except requests.exceptions.RequestException as e:
             raise ValueError(f"Error while fetching {url}: {e}") from e
+
+        contents = req.text
         yaml = YAML()
         loaded_yaml = yaml.load(contents)
         if (

esphome/components/emontx/__init__.py

@@ -116,16 +116,14 @@ _CALLBACK_AUTOMATIONS = (
 
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await uart.register_uart_device(var, config)
 
-    # Initialize sensor storage with count from final_validate before any
-    # await, so platform to_code() calls always see it initialized
-    # regardless of YAML key order.
+    # Initialize sensor storage with count from final_validate
     sensor_count = _get_data().sensor_counts.get(str(config[CONF_ID]), 0)
     if sensor_count > 0:
         cg.add(var.init_sensors(sensor_count))
 
-    await cg.register_component(var, config)
-    await uart.register_uart_device(var, config)
     await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
 

esphome/components/emontx/sensor/__init__.py

@@ -7,10 +7,8 @@ from esphome.const import (
     CONF_ID,
     CONF_STATE_CLASS,
     CONF_UNIT_OF_MEASUREMENT,
-    DEVICE_CLASS_APPARENT_POWER,
     DEVICE_CLASS_CURRENT,
     DEVICE_CLASS_ENERGY,
-    DEVICE_CLASS_FREQUENCY,
     DEVICE_CLASS_POWER,
     DEVICE_CLASS_POWER_FACTOR,
     DEVICE_CLASS_TEMPERATURE,
@@ -20,10 +18,8 @@ from esphome.const import (
     UNIT_AMPERE,
     UNIT_CELSIUS,
     UNIT_EMPTY,
-    UNIT_HERTZ,
     UNIT_PULSES,
     UNIT_VOLT,
-    UNIT_VOLT_AMPS,
     UNIT_WATT,
     UNIT_WATT_HOURS,
 )
@@ -33,32 +29,6 @@ from .. import CONF_EMONTX_ID, CONF_TAG_NAME, EmonTx, emontx_ns
 
 EmonTxSensor = emontx_ns.class_("EmonTxSensor", sensor.Sensor, cg.Component)
 
-# Known emonTx/avrdb JSON tag conventions, gathered from real firmware
-# (see https://github.com/openenergymonitor/avrdb_firmware), used to decide
-# whether each tag below requires a numeric index or may also appear bare:
-#
-#   Tag family    Bare (no index)          Numeric-indexed
-#   -----------   -----------------------  ----------------------------------
-#   P (power)     no                       P1, P2, ... (multi-channel boards)
-#   E (energy)    no                       E1, E2, ...
-#   V (voltage)   Vrms (NOT matched here,  V1, V2, V3 (per-phase boards)
-#                 doesn't fit "V"+digits)
-#   I (current)   no                       I1, I2, ...
-#   T (temp.)     no                       T1, T2, ...
-#   F (frequency) F (single mains freq.)   not seen indexed
-#   PULSE         pulse (single-CT boards) PULSE1, PULSE2, ... (other variants)
-#   PF (power     not seen bare            PF1, PF2, ... (currently unused/
-#     factor)                              commented out in avrdb firmware)
-#   AP (apparent  not seen bare            AP1, AP2, ... (not an avrdb tag at
-#     power)                               all; avrdb uses "VA"+index instead,
-#                                           itself currently unused/commented
-#                                           out; "AP" is kept here for other
-#                                           firmware/integrations using it)
-#
-# This is why a bare "PULSE" resolves to proper defaults below, but bare
-# "PF"/"AP" fall back to generic defaults instead: only PULSE has a
-# confirmed bare-tag use in real, currently-shipping firmware.
-
 # Define sensor type configurations by prefix
 SENSOR_CONFIGS = {
     "P": {
@@ -93,25 +63,7 @@ SENSOR_CONFIGS = {
     },
 }
 
-# Tags reported once, without a numeric index (e.g. "F"), matched exactly
-# rather than by prefix.
-EXACT_TAG_CONFIGS = {
-    "F": {
-        CONF_UNIT_OF_MEASUREMENT: UNIT_HERTZ,
-        CONF_DEVICE_CLASS: DEVICE_CLASS_FREQUENCY,
-        CONF_STATE_CLASS: STATE_CLASS_MEASUREMENT,
-        CONF_ACCURACY_DECIMALS: 2,
-    },
-}
-
-# Pattern-based configurations. The remainder after the prefix must be a
-# non-empty numeric index (like V1/I1/E1), so e.g. "APPLE" doesn't collide
-# with the "AP" prefix and a bare "PF"/"AP" (no index) doesn't match.
-# "PULSE" is the exception: some emonTx firmware (e.g. avrdb-based single-CT
-# variants) reports a single pulse counter as a bare "pulse" tag with no
-# numeric index at all, so that pattern also accepts an empty suffix.
-PATTERNS_ALLOWING_BARE_TAG = {"PULSE"}
-
+# Pattern-based configurations
 PATTERN_CONFIGS = {
     "PULSE": {
         CONF_UNIT_OF_MEASUREMENT: UNIT_PULSES,
@@ -125,21 +77,14 @@ PATTERN_CONFIGS = {
         CONF_STATE_CLASS: STATE_CLASS_MEASUREMENT,
         CONF_ACCURACY_DECIMALS: 2,
     },
-    "AP": {
-        CONF_UNIT_OF_MEASUREMENT: UNIT_VOLT_AMPS,
-        CONF_DEVICE_CLASS: DEVICE_CLASS_APPARENT_POWER,
-        CONF_STATE_CLASS: STATE_CLASS_MEASUREMENT,
-        CONF_ACCURACY_DECIMALS: 2,
-    },
 }
 
 # BASE_SCHEMA intentionally omits state_class and accuracy_decimals defaults.
 # Passing them to sensor_schema() would register them via cv.Optional(key, default=...),
 # making them always present in the validated config dict and preventing
 # apply_tag_defaults from overriding them with the correct per-prefix values.
-# They are injected by apply_tag_defaults below, after running through the
-# same validators sensor_schema() would use (see _DEFAULT_VALIDATORS) so the
-# values are code-generation-ready.
+# They are injected by apply_tag_defaults below, after running through
+# sensor.validate_state_class() so the value is code-generation-ready.
 BASE_SCHEMA = sensor.sensor_schema(EmonTxSensor).extend(
     {
         cv.GenerateID(CONF_EMONTX_ID): cv.use_id(EmonTx),
@@ -148,43 +93,30 @@ BASE_SCHEMA = sensor.sensor_schema(EmonTxSensor).extend(
 )
 
 
-_DEFAULT_VALIDATORS = {
-    CONF_STATE_CLASS: sensor.validate_state_class,
-    CONF_DEVICE_CLASS: sensor.validate_device_class,
-    CONF_UNIT_OF_MEASUREMENT: sensor.validate_unit_of_measurement,
-}
-
-
 def _apply_defaults(config: ConfigType, defaults: dict) -> None:
     """Inject defaults into config, skipping keys already set by the user.
-    Values are run through the same validators sensor_schema() would use, so
-    they are code-generation-ready and a typo'd constant fails validation
-    instead of shipping silently."""
+    state_class values are run through validate_state_class so they are
+    code-generation-ready, matching what sensor_schema() would normally do."""
     for key, value in defaults.items():
         if key not in config:
-            if key in _DEFAULT_VALIDATORS:
-                value = _DEFAULT_VALIDATORS[key](value)
+            if key == CONF_STATE_CLASS:
+                value = sensor.validate_state_class(value)
             config[key] = value
 
 
 def apply_tag_defaults(config: ConfigType) -> ConfigType:
     """Apply defaults based on tag prefix if applicable, but don't restrict any tags."""
     tag = config[CONF_TAG_NAME]
-    tag_upper = tag.upper()
 
-    if (exact_config := EXACT_TAG_CONFIGS.get(tag_upper)) is not None:
-        _apply_defaults(config, exact_config)
-        return config
-
-    for pattern, pattern_config in PATTERN_CONFIGS.items():
-        suffix = tag_upper[len(pattern) :]
-        bare_ok = not suffix and pattern in PATTERNS_ALLOWING_BARE_TAG
-        if tag_upper.startswith(pattern) and (suffix.isdigit() or bare_ok):
-            _apply_defaults(config, pattern_config)
-            return config
-
-    # Only apply defaults for known prefixes with numeric indices (e.g. E1, V2, T3)
     if len(tag) >= 2:
+        tag_upper = tag.upper()
+
+        for pattern, pattern_config in PATTERN_CONFIGS.items():
+            if tag_upper.startswith(pattern):
+                _apply_defaults(config, pattern_config)
+                return config
+
+        # Only apply defaults for known prefixes with numeric indices (e.g. E1, V2, T3)
         prefix = tag_upper[0]
         if prefix in SENSOR_CONFIGS and tag[1:].isdigit():
             _apply_defaults(config, SENSOR_CONFIGS[prefix])

esphome/components/esp32/__init__.py

@@ -65,7 +65,6 @@ from .boards import BOARDS, STANDARD_BOARDS
 from .const import (
     KEY_ARDUINO_LIBRARIES,
     KEY_BOARD,
-    KEY_CERT_BUNDLE,
     KEY_COMPONENTS,
     KEY_ESP32,
     KEY_EXCLUDE_COMPONENTS,
@@ -73,7 +72,6 @@ from .const import (
     KEY_FLASH_SIZE,
     KEY_FULL_CERT_BUNDLE,
     KEY_IDF_VERSION,
-    KEY_MBEDTLS_SDKCONFIG,
     KEY_NETWORK_SDKCONFIG,
     KEY_PATH,
     KEY_REF,
@@ -215,13 +213,11 @@ COMPILER_OPTIMIZATIONS = {
 # builds that need them.
 DEFAULT_EXCLUDED_IDF_COMPONENTS = (
     "app_trace",  # CPU trace/SystemView support - unused by ESPHome
-    "bt",  # Bluetooth stack - re-included by request_bluetooth(); its REQUIRES pulls the WiFi stack back
     "cmock",  # Unit testing mock framework - ESPHome doesn't use IDF's testing
     "console",  # Console REPL - unused by ESPHome; espressif/mdns pulls it back when configured
     "driver",  # Legacy driver shim - only needed by esp32_touch, esp32_can for legacy headers
-    "esp-tls",  # TLS wrapper - re-included by request_tls()
+    "esp-tls",  # TLS wrapper - re-included by http_request, mqtt, web_server_idf
     "esp_adc",  # ADC driver - only needed by adc component
-    "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, opentherm, Arduino BLE libs
@@ -239,22 +235,16 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = (
     "esp_driver_twai",  # TWAI/CAN driver - only needed by esp32_can component
     "esp_eth",  # Ethernet driver - only needed by ethernet component
     "esp_gdbstub",  # GDB stub panic handler - unused by ESPHome; bt pulls it back
-    "esp_hal_ieee802154",  # 802.15.4 HAL - ieee802154 pulls it back
     "esp_hid",  # HID host/device support - ESPHome doesn't implement HID functionality
     "esp_http_client",  # HTTP client - only needed by http_request component
-    "esp_http_server",  # HTTP server - re-included by web_server_idf, esp32_camera_web_server
     "esp_https_ota",  # ESP-IDF HTTPS OTA - ESPHome has its own OTA implementation
     "esp_https_server",  # HTTPS server - ESPHome has its own web server
     "esp_lcd",  # LCD controller drivers - only needed by display component
     "esp_local_ctrl",  # Local control over HTTPS/BLE - ESPHome has native API
-    "esp_phy",  # RF PHY - esp_wifi/bt/ieee802154 pull it back when they are in the build
-    "esp_wifi",  # WiFi stack - re-included by request_wifi(), espnow; bt pulls it back for BLE builds
     "espcoredump",  # Core dump support - ESPHome has its own debug component
     "fatfs",  # FAT filesystem - ESPHome doesn't use filesystem storage
-    "ieee802154",  # 802.15.4 radio - IDF openthread and the Zigbee libs pull it back
     "json",  # cJSON library - ESPHome uses ArduinoJson instead
     "mqtt",  # ESP-IDF MQTT library - ESPHome has its own MQTT implementation
-    "nvs_sec_provider",  # NVS encryption key provider - re-included when CONFIG_NVS_ENCRYPTION is set
     "openthread",  # Thread protocol - only needed by openthread component
     "perfmon",  # Xtensa performance monitor - ESPHome has its own debug component
     "protobuf-c",  # Protobuf runtime - only used by provisioning components (also excluded)
@@ -267,7 +257,6 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = (
     "unity",  # Unit testing framework - ESPHome doesn't use IDF's testing
     "wear_levelling",  # Flash wear levelling for fatfs - unused since fatfs unused
     "wifi_provisioning",  # WiFi provisioning - ESPHome uses its own improv implementation
-    "wpa_supplicant",  # WPA supplicant - re-included by request_wifi() for esp_eap_client.h
 )
 
 # Additional IDF managed components to exclude for Arduino framework builds
@@ -354,10 +343,6 @@ ARDUINO_LIBRARY_IDF_COMPONENTS: dict[str, tuple[str, ...]] = {
     "Zigbee": ("espressif__esp-zigbee-lib", "espressif__esp-zboss-lib"),
 }
 
-# Arduino libraries whose sources reference esp_crt_bundle_attach without a
-# CONFIG_MBEDTLS_CERTIFICATE_BUNDLE guard, so enabling them needs the bundle.
-ARDUINO_LIBRARIES_NEEDING_CERT_BUNDLE = frozenset({"NetworkClientSecure"})
-
 # Arduino library to Arduino library dependencies
 # When enabling one library, also enable its dependencies
 # Kconfig "select" statements don't work with CONFIG_ARDUINO_SELECTIVE_COMPILATION
@@ -659,27 +644,6 @@ class RawSdkconfigValue:
 SdkconfigValueType = bool | int | HexInt | str | RawSdkconfigValue
 
 
-def is_idf_sdkconfig_option_enabled(name: str) -> bool:
-    """Return True when a bool sdkconfig option resolves to ``y``.
-
-    Handles both the ``True`` a component sets and the raw ``y`` a user sets
-    in ``sdkconfig_options``.
-    """
-    value = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS].get(name)
-    return value is not None and _format_sdkconfig_val(value) == "y"
-
-
-def set_idf_sdkconfig_default(name: str, value: SdkconfigValueType) -> None:
-    """Set an sdkconfig option unless it is already set.
-
-    For the FINAL priority reconcile jobs: they run after every to_code,
-    including the user's sdkconfig_options, and must not override an
-    existing value.
-    """
-    if name not in CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS]:
-        add_idf_sdkconfig_option(name, value)
-
-
 def add_idf_sdkconfig_option(name: str, value: SdkconfigValueType):
     """Set an esp-idf sdkconfig value."""
     CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS][name] = value
@@ -717,9 +681,6 @@ def request_wifi(ap: bool = False) -> None:
     net.wifi = True
     if ap:
         net.wifi_ap = True
-    include_builtin_idf_component("esp_wifi")
-    # wifi_component.cpp includes esp_eap_client.h/esp_wpa2.h
-    include_builtin_idf_component("wpa_supplicant")
 
 
 def request_ethernet() -> None:
@@ -731,56 +692,11 @@ def request_bluetooth() -> None:
     """Request the Bluetooth controller."""
     net = _network_sdkconfig()
     net.bluetooth = True
-    include_builtin_idf_component("bt")
 
 
 def request_software_coexistence() -> None:
     """Request WiFi/BT software coexistence (only valid alongside WiFi)."""
     _network_sdkconfig().software_coexistence = True
-    # Callers include esp_coexist.h directly.
-    include_builtin_idf_component("esp_coex")
-
-
-@dataclass
-class MbedtlsSdkconfigData:
-    """Inputs for the mbedTLS sdkconfig flags, reconciled at FINAL.
-
-    Components call request_tls() / require_mbedtls_*() instead of writing the
-    CONFIG_MBEDTLS_* flags directly; _reconcile_mbedtls_sdkconfig() decides the
-    final values once every to_code has run.
-    """
-
-    tls_required: bool = False  # TLS/DTLS handshake user
-    ecp_required: bool = False  # ECDH/ECDSA without TLS (openthread SRP host key)
-    peer_cert_required: bool = False  # keep the peer certificate after the handshake
-    pkcs7_required: bool = False  # PKCS#7 parsing
-    sha512_required: bool = False  # SHA-384/SHA-512
-    # esp32 advanced disable_mbedtls_peer_cert / disable_mbedtls_pkcs7 options
-    disable_peer_cert: bool = True
-    disable_pkcs7: bool = True
-
-
-def _mbedtls_sdkconfig() -> MbedtlsSdkconfigData:
-    data = CORE.data[KEY_ESP32]
-    if KEY_MBEDTLS_SDKCONFIG not in data:
-        data[KEY_MBEDTLS_SDKCONFIG] = MbedtlsSdkconfigData()
-    return data[KEY_MBEDTLS_SDKCONFIG]
-
-
-def request_tls() -> None:
-    """Request the mbedTLS TLS stack and the esp-tls wrapper.
-
-    Without a request TLS and its ECP/PEM-write/CRL/CSR crypto compile out;
-    hashes, AES and RSA stay available.
-    """
-    _mbedtls_sdkconfig().tls_required = True
-    include_builtin_idf_component("esp-tls")
-
-
-def request_http_client() -> None:
-    """Request ESP-IDF's HTTP client; it links esp_tls even for plain http."""
-    include_builtin_idf_component("esp_http_client")
-    request_tls()
 
 
 def add_idf_component(
@@ -872,10 +788,6 @@ def _enable_arduino_library(name: str) -> None:
     # Also enable any required IDF components
     for idf_component in ARDUINO_LIBRARY_IDF_COMPONENTS.get(name, ()):
         include_builtin_idf_component(idf_component)
-    if not ARDUINO_LIBRARIES_NEEDING_CERT_BUNDLE.isdisjoint(
-        {name, *ARDUINO_LIBRARY_DEPENDENCIES.get(name, ())}
-    ):
-        require_certificate_bundle()
 
 
 def add_extra_script(stage: str, filename: str, path: Path):
@@ -1161,11 +1073,19 @@ def _check_esp_idf_versions(config: ConfigType) -> ConfigType:
     return config
 
 
-_TOOLCHAINS = (Toolchain.PLATFORMIO, Toolchain.ESP_IDF)
-_validate_toolchain = cv.toolchain_enum(_TOOLCHAINS)
-# Runs before _detect_variant so downstream validators can rely on
-# CORE.toolchain instead of re-resolving it from the config dict.
-_resolve_toolchain = cv.resolve_toolchain("ESP32", _TOOLCHAINS, Toolchain.ESP_IDF)
+def _validate_toolchain(value) -> Toolchain:
+    return Toolchain(
+        cv.one_of(Toolchain.PLATFORMIO, Toolchain.ESP_IDF, lower=True)(value)
+    )
+
+
+def _resolve_toolchain(value: ConfigType) -> ConfigType:
+    # Resolve toolchain: CLI (already on CORE.toolchain) > YAML > default.
+    # Runs before _detect_variant so downstream validators can rely on
+    # CORE.toolchain instead of re-resolving it from the config dict.
+    if CORE.toolchain is None:
+        CORE.toolchain = value.get(CONF_TOOLCHAIN, Toolchain.ESP_IDF)
+    return value
 
 
 def _check_versions(config: ConfigType) -> ConfigType:
@@ -1780,7 +1700,10 @@ KEY_VFS_TERMIOS_REQUIRED = "vfs_termios_required"
 # Feature requirement tracking - components can call require_* functions to re-enable
 # These are stored in CORE.data[KEY_ESP32] dict
 KEY_USB_SERIAL_JTAG_SECONDARY_REQUIRED = "usb_serial_jtag_secondary_required"
+KEY_MBEDTLS_PEER_CERT_REQUIRED = "mbedtls_peer_cert_required"
+KEY_MBEDTLS_PKCS7_REQUIRED = "mbedtls_pkcs7_required"
 KEY_FATFS_REQUIRED = "fatfs_required"
+KEY_MBEDTLS_SHA512_REQUIRED = "mbedtls_sha512_required"
 KEY_ADC_ONESHOT_IRAM_REQUIRED = "adc_oneshot_iram_required"
 KEY_LIBC_PICOLIBC_NEWLIB_COMPAT_REQUIRED = "libc_picolibc_newlib_compat_required"
 
@@ -1812,18 +1735,6 @@ def require_vfs_termios() -> None:
     CORE.data[KEY_VFS_TERMIOS_REQUIRED] = True
 
 
-def require_certificate_bundle() -> None:
-    """Enable the mbedTLS root certificate bundle for this build.
-
-    The bundle is off by default; components that verify TLS server
-    certificates (http_request, audio streaming) call this so the bundle is
-    compiled and gen_crt_bundle runs only when something uses it.
-    """
-    # esp_crt_bundle.c calls mbedtls_ssl_conf_*, so a bundle always needs TLS.
-    request_tls()
-    CORE.data[KEY_ESP32][KEY_CERT_BUNDLE] = True
-
-
 def require_full_certificate_bundle() -> None:
     """Request the full certificate bundle instead of the common-CAs-only bundle.
 
@@ -1833,7 +1744,6 @@ def require_full_certificate_bundle() -> None:
 
     Call this from components that need to connect to services using uncommon CAs.
     """
-    require_certificate_bundle()
     CORE.data[KEY_ESP32][KEY_FULL_CERT_BUNDLE] = True
 
 
@@ -1846,32 +1756,33 @@ def require_usb_serial_jtag_secondary() -> None:
     CORE.data[KEY_ESP32][KEY_USB_SERIAL_JTAG_SECONDARY_REQUIRED] = True
 
 
-def require_mbedtls_ecp() -> None:
-    """Keep mbedTLS elliptic curve support (ECDH/ECDSA) without requesting TLS.
-
-    Call this from components that sign or verify with ECDSA outside a TLS
-    handshake (openthread's SRP host key). WiFi, Bluetooth and secure boot
-    select it through Kconfig on their own.
-    """
-    _mbedtls_sdkconfig().ecp_required = True
-
-
 def require_mbedtls_peer_cert() -> None:
-    """Keep the peer certificate after the TLS handshake (CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE).
+    """Mark that mbedTLS peer certificate retention is required by a component.
 
-    A user sdkconfig_options value takes precedence.
+    Call this from components that need access to the peer certificate after
+    the TLS handshake is complete. This prevents CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE
+    from being disabled.
     """
-    _mbedtls_sdkconfig().peer_cert_required = True
+    CORE.data[KEY_ESP32][KEY_MBEDTLS_PEER_CERT_REQUIRED] = True
 
 
 def require_mbedtls_pkcs7() -> None:
-    """Keep mbedTLS PKCS#7 support (CONFIG_MBEDTLS_PKCS7_C). A user sdkconfig_options value takes precedence."""
-    _mbedtls_sdkconfig().pkcs7_required = True
+    """Mark that mbedTLS PKCS#7 support is required by a component.
+
+    Call this from components that need PKCS#7 certificate validation.
+    This prevents CONFIG_MBEDTLS_PKCS7_C from being disabled.
+    """
+    CORE.data[KEY_ESP32][KEY_MBEDTLS_PKCS7_REQUIRED] = True
 
 
 def require_mbedtls_sha512() -> None:
-    """Keep mbedTLS SHA-384/SHA-512 (CONFIG_MBEDTLS_SHA384_C / CONFIG_MBEDTLS_SHA512_C)."""
-    _mbedtls_sdkconfig().sha512_required = True
+    """Mark that mbedTLS SHA-384/SHA-512 support is required by a component.
+
+    Call this from components that need to verify TLS certificates or signatures
+    using SHA-384 or SHA-512 algorithms. This prevents CONFIG_MBEDTLS_SHA384_C
+    and CONFIG_MBEDTLS_SHA512_C from being disabled.
+    """
+    CORE.data[KEY_ESP32][KEY_MBEDTLS_SHA512_REQUIRED] = True
 
 
 def idf_version() -> cv.Version:
@@ -2249,10 +2160,6 @@ def register_exclude_components_cmake_arg() -> None:
 @coroutine_with_priority(CoroPriority.FINAL)
 async def _write_exclude_components() -> None:
     """Write EXCLUDE_COMPONENTS cmake arg after all components have registered exclusions."""
-    # NVS encryption needs nvs_sec_provider however it was enabled: the
-    # nvs_encryption option, raw sdkconfig_options or another component.
-    if is_idf_sdkconfig_option_enabled("CONFIG_NVS_ENCRYPTION"):
-        include_builtin_idf_component("nvs_sec_provider")
     register_exclude_components_cmake_arg()
 
 
@@ -2311,106 +2218,6 @@ async def _set_libc_picolibc_newlib_compat() -> None:
     )
 
 
-@coroutine_with_priority(CoroPriority.FINAL)
-async def _reconcile_certificate_bundle_sdkconfig() -> None:
-    """Enable the mbedTLS certificate bundle only when something asked for it.
-
-    Runs at FINAL priority so every require_certificate_bundle() call has
-    happened. Without a request the bundle is disabled, which skips
-    esp_crt_bundle.c, the gen_crt_bundle step and the x509_crt_bundle.S embed.
-    A user-supplied sdkconfig_options value takes precedence.
-    """
-    data = CORE.data[KEY_ESP32]
-    enabled = data.get(KEY_CERT_BUNDLE, False)
-    set_idf_sdkconfig_default("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", enabled)
-    if not enabled:
-        return
-    # Use CMN (common CAs) bundle by default to save ~51KB flash
-    # CMN covers CAs with >1% market share (~99% of websites)
-    # Components needing uncommon CAs can call require_full_certificate_bundle()
-    use_full_bundle = data.get(KEY_FULL_CERT_BUNDLE, False)
-    set_idf_sdkconfig_default(
-        "CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL", use_full_bundle
-    )
-    if not use_full_bundle:
-        set_idf_sdkconfig_default("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN", True)
-
-
-# User sdkconfig_options that mean "keep TLS on" when set to y.
-_MBEDTLS_TLS_ON_OPTIONS = (
-    "CONFIG_MBEDTLS_TLS_ENABLED",
-    "CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT",
-    "CONFIG_MBEDTLS_TLS_SERVER_ONLY",
-    "CONFIG_MBEDTLS_TLS_CLIENT_ONLY",
-)
-# Any user option under these prefixes only makes sense with TLS compiled in.
-_TLS_OPTION_PREFIXES = ("CONFIG_ESP_TLS_", "CONFIG_MBEDTLS_SSL_", "CONFIG_ESP_HTTPS_")
-
-
-def _user_sdkconfig_wants_tls(options: dict[str, Any]) -> bool:
-    """True when sdkconfig_options turn TLS on or tune something under it; an `n` is never a request."""
-    return any(
-        (name in _MBEDTLS_TLS_ON_OPTIONS and value == "y")
-        or (name == "CONFIG_MBEDTLS_TLS_DISABLED" and value == "n")
-        or (name.startswith(_TLS_OPTION_PREFIXES) and value != "n")
-        for name, value in options.items()
-    )
-
-
-@coroutine_with_priority(CoroPriority.FINAL)
-async def _reconcile_mbedtls_sdkconfig() -> None:
-    """Reconcile the mbedTLS sdkconfig flags after every request_tls() / require_mbedtls_*() call.
-
-    mbedtls cannot be excluded from an IDF build (bootloader_support needs its
-    SHA-256), but with no TLS user the ssl_*.c sources and the TLS-only crypto
-    compile to empty objects. User sdkconfig_options win.
-    """
-    data = _mbedtls_sdkconfig()
-    idf6 = idf_version() >= cv.Version(6, 0, 0)
-    # A component that re-includes esp-tls on its own (external components
-    # predating request_tls()) wants TLS just as much as a request_tls() call.
-    tls_required = (
-        data.tls_required
-        or "esp-tls" not in CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS]
-    )
-
-    if not CORE.using_arduino and not tls_required:
-        # IDF 6 made CONFIG_MBEDTLS_TLS_ENABLED a normal bool; on IDF 5 it has
-        # no prompt and is only reachable through the "None" TLS role choice.
-        if idf6:
-            set_idf_sdkconfig_default("CONFIG_MBEDTLS_TLS_ENABLED", False)
-        else:
-            set_idf_sdkconfig_default("CONFIG_MBEDTLS_TLS_DISABLED", True)
-        # Enterprise WiFi selects TLS back on; wifi writes this itself, but
-        # esp_wifi can also be in the build without a wifi: block (openthread).
-        set_idf_sdkconfig_default("CONFIG_ESP_WIFI_ENTERPRISE_SUPPORT", False)
-        # WiFi (ESP_WIFI_MBEDTLS_CRYPTO), Bluetooth and signed apps
-        # (SECURE_SIGNED_APPS) select ECP back on through Kconfig.
-        if not data.ecp_required:
-            set_idf_sdkconfig_default("CONFIG_MBEDTLS_ECP_C", False)
-        set_idf_sdkconfig_default("CONFIG_MBEDTLS_PEM_WRITE_C", False)
-        set_idf_sdkconfig_default("CONFIG_MBEDTLS_X509_CRL_PARSE_C", False)
-        set_idf_sdkconfig_default("CONFIG_MBEDTLS_X509_CSR_PARSE_C", False)
-
-    # Keeping the peer certificate costs ~4KB heap per connection.
-    if data.peer_cert_required:
-        set_idf_sdkconfig_default("CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE", True)
-    elif data.disable_peer_cert:
-        set_idf_sdkconfig_default("CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE", False)
-
-    if data.pkcs7_required:
-        set_idf_sdkconfig_default("CONFIG_MBEDTLS_PKCS7_C", True)
-    elif data.disable_pkcs7:
-        set_idf_sdkconfig_default("CONFIG_MBEDTLS_PKCS7_C", False)
-
-    # SHA-384 shares the SHA-512 compression function, so both go together.
-    # Only IDF 6.0's PSA engine links a ~3KB software fallback for them; on
-    # IDF 5 they are a single hardware-only option with no code size cost.
-    if idf6 and not data.sha512_required:
-        set_idf_sdkconfig_default("CONFIG_MBEDTLS_SHA384_C", False)
-        set_idf_sdkconfig_default("CONFIG_MBEDTLS_SHA512_C", False)
-
-
 @coroutine_with_priority(CoroPriority.FINAL)
 async def _reconcile_network_sdkconfig() -> None:
     """Reconcile WiFi/Ethernet/Bluetooth/coexistence sdkconfig flags.
@@ -2422,33 +2229,37 @@ async def _reconcile_network_sdkconfig() -> None:
     always takes precedence.
     """
     net = CORE.data[KEY_ESP32].get(KEY_NETWORK_SDKCONFIG, NetworkSdkconfigData())
+    opts = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS]
     is_arduino = CORE.using_arduino
 
+    def set_opt(name: str, value: SdkconfigValueType) -> None:
+        # User sdkconfig_options (applied during to_code) win.
+        if name not in opts:
+            add_idf_sdkconfig_option(name, value)
+
     # Bluetooth: only ever enable when requested. The IDF default is off.
     # According to the IDF docs, only one of 4.2 or 5.0 should be enabled.
     if net.bluetooth:
-        set_idf_sdkconfig_default("CONFIG_BT_ENABLED", True)
-        set_idf_sdkconfig_default("CONFIG_BT_BLE_42_FEATURES_SUPPORTED", True)
-        set_idf_sdkconfig_default("CONFIG_BT_BLE_50_FEATURES_SUPPORTED", False)
+        set_opt("CONFIG_BT_ENABLED", True)
+        set_opt("CONFIG_BT_BLE_42_FEATURES_SUPPORTED", True)
+        set_opt("CONFIG_BT_BLE_50_FEATURES_SUPPORTED", False)
 
     # WiFi stack: disable only when Ethernet is present and WiFi is not. WiFi
     # relies on the IDF default (enabled), so it is never written True here.
-    # esp_wifi is excluded by default on IDF, so this only matters for Arduino
-    # or when bt pulls it back.
     wifi_disabled = net.ethernet and not net.wifi
     if wifi_disabled:
-        set_idf_sdkconfig_default("CONFIG_ESP_WIFI_ENABLED", False)
+        set_opt("CONFIG_ESP_WIFI_ENABLED", False)
 
     # Software coexistence: enable when requested (the schema only allows it
     # alongside WiFi). Disable only in the Ethernet-without-WiFi case.
     if net.software_coexistence:
-        set_idf_sdkconfig_default("CONFIG_SW_COEXIST_ENABLE", True)
+        set_opt("CONFIG_SW_COEXIST_ENABLE", True)
     elif wifi_disabled:
-        set_idf_sdkconfig_default("CONFIG_SW_COEXIST_ENABLE", False)
+        set_opt("CONFIG_SW_COEXIST_ENABLE", False)
 
     # SoftAP support: drop it when WiFi is used without AP mode (IDF only).
     if not is_arduino and net.wifi and not net.wifi_ap:
-        set_idf_sdkconfig_default("CONFIG_ESP_WIFI_SOFTAP_SUPPORT", False)
+        set_opt("CONFIG_ESP_WIFI_SOFTAP_SUPPORT", False)
 
     # LWIP DHCP server: a WiFi-AP-mode / enable_lwip_dhcp_server concern (not
     # coexistence). Disable when WiFi has no AP (IDF) or the enable_lwip_dhcp_server
@@ -2459,7 +2270,7 @@ async def _reconcile_network_sdkconfig() -> None:
     if (
         wifi_wants_dhcps_off or dhcp_server_disabled_by_option
     ) and not arduino_eth_exclusion:
-        set_idf_sdkconfig_default("CONFIG_LWIP_DHCPS", False)
+        set_opt("CONFIG_LWIP_DHCPS", False)
 
 
 @coroutine_with_priority(CoroPriority.FINAL)
@@ -2484,24 +2295,29 @@ async def _reconcile_vfs_fatfs_sdkconfig(
     """Reconcile VFS/FATFS sdkconfig flags after all require_*() calls; user sdkconfig_options win."""
     opts = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS]
 
+    def set_opt(name: str, value: SdkconfigValueType) -> None:
+        # User sdkconfig_options (applied during to_code) win.
+        if name not in opts:
+            add_idf_sdkconfig_option(name, value)
+
     # USB Serial JTAG VFS needs termios (require_vfs_termios(), e.g. logger). ~1.8KB flash when off.
     if CORE.data.get(KEY_VFS_TERMIOS_REQUIRED, False):
-        set_idf_sdkconfig_default("CONFIG_VFS_SUPPORT_TERMIOS", True)
+        set_opt("CONFIG_VFS_SUPPORT_TERMIOS", True)
     else:
-        set_idf_sdkconfig_default("CONFIG_VFS_SUPPORT_TERMIOS", not disable_vfs_termios)
+        set_opt("CONFIG_VFS_SUPPORT_TERMIOS", not disable_vfs_termios)
 
     # VFS select is only needed for UART/eventfd fds (require_vfs_select(), e.g. openthread);
     # sockets use lwip_select() either way. ~2.7KB flash when off.
     if CORE.data.get(KEY_VFS_SELECT_REQUIRED, False):
-        set_idf_sdkconfig_default("CONFIG_VFS_SUPPORT_SELECT", True)
+        set_opt("CONFIG_VFS_SUPPORT_SELECT", True)
     else:
-        set_idf_sdkconfig_default("CONFIG_VFS_SUPPORT_SELECT", not disable_vfs_select)
+        set_opt("CONFIG_VFS_SUPPORT_SELECT", not disable_vfs_select)
 
     # Directory functions: opendir/readdir/mkdir etc. (require_vfs_dir()). ~0.5KB flash when off.
     if CORE.data.get(KEY_VFS_DIR_REQUIRED, False):
-        set_idf_sdkconfig_default("CONFIG_VFS_SUPPORT_DIR", True)
+        set_opt("CONFIG_VFS_SUPPORT_DIR", True)
     else:
-        set_idf_sdkconfig_default("CONFIG_VFS_SUPPORT_DIR", not disable_vfs_dir)
+        set_opt("CONFIG_VFS_SUPPORT_DIR", not disable_vfs_dir)
 
     # FATFS (require_fatfs()): LFN + one volume per esp_vfs_fat mount. Defaults only;
     # sdkconfig_options override. FATFS_LONG_FILENAMES is a Kconfig choice -- if the user set
@@ -2514,15 +2330,15 @@ async def _reconcile_vfs_fatfs_sdkconfig(
     user_picked_lfn = any(k in opts for k in lfn_keys)
     if CORE.data[KEY_ESP32].get(KEY_FATFS_REQUIRED, False):
         if not user_picked_lfn:
-            set_idf_sdkconfig_default("CONFIG_FATFS_LFN_NONE", False)
-            set_idf_sdkconfig_default("CONFIG_FATFS_LFN_HEAP", True)
-            set_idf_sdkconfig_default("CONFIG_FATFS_MAX_LFN", 255)
-        set_idf_sdkconfig_default("CONFIG_FATFS_VOLUME_COUNT", 4)
+            set_opt("CONFIG_FATFS_LFN_NONE", False)
+            set_opt("CONFIG_FATFS_LFN_HEAP", True)
+            set_opt("CONFIG_FATFS_MAX_LFN", 255)
+        set_opt("CONFIG_FATFS_VOLUME_COUNT", 4)
     elif disable_fatfs:
         if not user_picked_lfn:
-            set_idf_sdkconfig_default("CONFIG_FATFS_LFN_NONE", True)
+            set_opt("CONFIG_FATFS_LFN_NONE", True)
         # Kconfig range is [1,10]; 0 gets clamped to the default.
-        set_idf_sdkconfig_default("CONFIG_FATFS_VOLUME_COUNT", 1)
+        set_opt("CONFIG_FATFS_VOLUME_COUNT", 1)
 
 
 @coroutine_with_priority(CoroPriority.FINAL - 1)
@@ -2709,11 +2525,21 @@ async def to_code(config):
         )
 
         add_idf_sdkconfig_option("CONFIG_MBEDTLS_PSK_MODES", True)
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", True)
 
     cg.add_build_flag("-Wno-nonnull-compare")
 
-    if conf[CONF_ADVANCED].get(CONF_USE_FULL_CERTIFICATE_BUNDLE, False):
-        require_full_certificate_bundle()
+    # Use CMN (common CAs) bundle by default to save ~51KB flash
+    # CMN covers CAs with >1% market share (~99% of websites)
+    # Components needing uncommon CAs can call require_full_certificate_bundle()
+    use_full_bundle = conf[CONF_ADVANCED].get(
+        CONF_USE_FULL_CERTIFICATE_BUNDLE, False
+    ) or CORE.data[KEY_ESP32].get(KEY_FULL_CERT_BUNDLE, False)
+    add_idf_sdkconfig_option(
+        "CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL", use_full_bundle
+    )
+    if not use_full_bundle:
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN", True)
 
     add_idf_sdkconfig_option(f"CONFIG_IDF_TARGET_{variant}", True)
     add_idf_sdkconfig_option(
@@ -3065,21 +2891,44 @@ async def to_code(config):
     if advanced[CONF_DISABLE_DEV_NULL_VFS]:
         add_idf_sdkconfig_option("CONFIG_VFS_INITIALIZE_DEV_NULL", False)
 
+    # Disable keeping peer certificate after TLS handshake
+    # Saves ~4KB heap per connection, but prevents certificate inspection after handshake
+    # Components that need it can call require_mbedtls_peer_cert()
+    if CORE.data[KEY_ESP32].get(KEY_MBEDTLS_PEER_CERT_REQUIRED, False):
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE", True)
+    elif advanced[CONF_DISABLE_MBEDTLS_PEER_CERT]:
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_SSL_KEEP_PEER_CERTIFICATE", False)
+
+    # Disable PKCS#7 support in mbedTLS
+    # Only needed for specific certificate validation scenarios
+    # Components that need it can call require_mbedtls_pkcs7()
+    if CORE.data[KEY_ESP32].get(KEY_MBEDTLS_PKCS7_REQUIRED, False):
+        # Component called require_mbedtls_pkcs7() - enable regardless of user setting
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_PKCS7_C", True)
+    elif advanced[CONF_DISABLE_MBEDTLS_PKCS7]:
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_PKCS7_C", False)
+
+    # Disable SHA-384 and SHA-512 in mbedTLS
+    # ESPHome doesn't use either algorithm. SHA-384 shares the same
+    # compression function as SHA-512 (mbedtls_internal_sha512_process),
+    # so both must be disabled to eliminate the ~3KB software fallback
+    # that IDF 6.0's PSA parallel engine always links in.
+    # On IDF < 6.0 these are a single config and hardware-only (no
+    # software fallback), so there was no code size cost to leaving
+    # them enabled.
+    # Components that need SHA-384/SHA-512 can call require_mbedtls_sha512()
+    if idf_version() >= cv.Version(6, 0, 0) and not CORE.data[KEY_ESP32].get(
+        KEY_MBEDTLS_SHA512_REQUIRED, False
+    ):
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_SHA384_C", False)
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_SHA512_C", False)
+
     # FINAL priority: runs after every require_libc_picolibc_newlib_compat() call
     CORE.add_job(_set_libc_picolibc_newlib_compat)
 
     # FINAL priority: runs after every network/coexistence request_*() call
     CORE.add_job(_reconcile_network_sdkconfig)
 
-    # FINAL priority: runs after every require_certificate_bundle() call
-    CORE.add_job(_reconcile_certificate_bundle_sdkconfig)
-
-    # FINAL priority: runs after every request_tls() / require_mbedtls_*() call
-    mbedtls = _mbedtls_sdkconfig()
-    mbedtls.disable_peer_cert = advanced[CONF_DISABLE_MBEDTLS_PEER_CERT]
-    mbedtls.disable_pkcs7 = advanced[CONF_DISABLE_MBEDTLS_PKCS7]
-    CORE.add_job(_reconcile_mbedtls_sdkconfig)
-
     # FINAL: require_*() calls can come from to_code at or below this priority, so an
     # inline read would be iteration-order-dependent; reconcile once after every job ran.
     CORE.add_job(
@@ -3107,12 +2956,6 @@ async def to_code(config):
 
     for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():
         add_idf_sdkconfig_option(name, RawSdkconfigValue(value))
-    # A bundle forced on through sdkconfig_options is a request like any other,
-    # so it still gets the CMN variant pinned.
-    if conf[CONF_SDKCONFIG_OPTIONS].get("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE") == "y":
-        require_certificate_bundle()
-    if _user_sdkconfig_wants_tls(conf[CONF_SDKCONFIG_OPTIONS]):
-        request_tls()
 
     # Components from YAML are added in a separate coroutine with FINAL priority
     # Schedule it to run after all other components
@@ -3341,13 +3184,7 @@ def _write_sdkconfig():
     if write_file_if_changed(internal_path, contents):
         # internal changed, update real one
         write_file_if_changed(sdk_path, contents)
-        if not CORE.using_toolchain_esp_idf:
-            # PIO's dependency tracking under-declares sdkconfig inputs
-            # (ldgen, linker scripts); without a clean the image can be
-            # unbootable (esphome#15336). The esp-idf toolchain tracks
-            # sdkconfig via IDF's cmake and has_outdated_files(), so a
-            # reconfigure suffices there; everything else fails safe.
-            clean_build(clear_pio_cache=False)
+        clean_build(clear_pio_cache=False)
 
 
 def _write_idf_component_yml():

esphome/components/esp32/const.py

@@ -27,10 +27,8 @@ KEY_REFRESH = "refresh"
 KEY_PATH = "path"
 KEY_SUBMODULES = "submodules"
 KEY_EXTRA_BUILD_FILES = "extra_build_files"
-KEY_CERT_BUNDLE = "cert_bundle"
 KEY_FULL_CERT_BUNDLE = "full_cert_bundle"
 KEY_NETWORK_SDKCONFIG = "network_sdkconfig"
-KEY_MBEDTLS_SDKCONFIG = "mbedtls_sdkconfig"
 
 VARIANT_ESP32 = "ESP32"
 VARIANT_ESP32C2 = "ESP32C2"

esphome/components/esp32/core.cpp

@@ -2,7 +2,6 @@
 
 #include "esphome/core/application.h"
 #include "esphome/core/defines.h"
-#include "esphome/core/helpers.h"
 #include "preferences.h"
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
@@ -30,13 +29,6 @@ void loop_task(void *pv_params) {
 }
 
 extern "C" void app_main() {
-  // Apply the custom eFuse MAC (if burned and valid) as the base MAC before any
-  // interface (Wi-Fi, Ethernet, Bluetooth, 802.15.4) derives its address from it.
-  // The logger does not exist yet, so only log-free helpers may be used here.
-  uint8_t mac[MAC_ADDRESS_SIZE];
-  if (get_custom_mac_address(mac)) {
-    set_mac_address(mac);
-  }
   initArduino();
   esp32::setup_preferences();
 #if CONFIG_FREERTOS_UNICORE

esphome/components/esp32/helpers.cpp

@@ -71,32 +71,23 @@ static bool read_valid_mac(uint8_t *mac, esp_err_t err) { return err == ESP_OK &
 
 static constexpr size_t MAC_ADDRESS_SIZE_BITS = MAC_ADDRESS_SIZE * 8;  // 48 bits
 
-// Must not use the ESPHome logger (may run before it exists, e.g. from app_main()).
-bool get_custom_mac_address(uint8_t *mac) {
-  // has_custom_mac_address() checks the raw eFuse field, while the reads below select their
-  // method differently and may still fail (CRC), so the result must be validated again.
-  if (!has_custom_mac_address())
-    return false;
-#if defined(CONFIG_SOC_IEEE802154_SUPPORTED)
-  return read_valid_mac(mac, esp_efuse_read_field_blob(ESP_EFUSE_MAC_CUSTOM, mac, MAC_ADDRESS_SIZE_BITS));
-#else
-  return read_valid_mac(mac, esp_efuse_mac_get_custom(mac));
-#endif
-}
-
 void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
-  if (get_custom_mac_address(mac)) {
-    return;
-  }
 #if defined(CONFIG_SOC_IEEE802154_SUPPORTED)
   // When CONFIG_SOC_IEEE802154_SUPPORTED is defined, esp_efuse_mac_get_default
   // returns the 802.15.4 EUI-64 address, so we read directly from eFuse instead.
-  // This already reads raw eFuse bytes, so there is no CRC-bypass fallback
+  // Both paths already read raw eFuse bytes, so there is no CRC-bypass fallback
   // (unlike the non-IEEE802154 path where esp_efuse_mac_get_default does CRC checks).
+  if (has_custom_mac_address() &&
+      read_valid_mac(mac, esp_efuse_read_field_blob(ESP_EFUSE_MAC_CUSTOM, mac, MAC_ADDRESS_SIZE_BITS))) {
+    return;
+  }
   if (read_valid_mac(mac, esp_efuse_read_field_blob(ESP_EFUSE_MAC_FACTORY, mac, MAC_ADDRESS_SIZE_BITS))) {
     return;
   }
 #else
+  if (has_custom_mac_address() && read_valid_mac(mac, esp_efuse_mac_get_custom(mac))) {
+    return;
+  }
   if (read_valid_mac(mac, esp_efuse_mac_get_default(mac))) {
     return;
   }

esphome/components/esp32_ble_tracker/__init__.py

@@ -143,13 +143,6 @@ def validate_max_connections_deprecated(config: ConfigType) -> ConfigType:
 # BLE uses the airtime wifi does not claim.
 IDF_SCAN_WINDOW_FIX_VERSION = cv.Version(5, 5, 5)
 
-# Above this the scanner holds the shared radio long enough that wifi drops
-# packets and connections on some access points (others cope fine, which is
-# why this is a warning and not an error); old proxy configs with 1100 ms
-# windows are a recurring cause of instability (esphome/esphome#18655). Only
-# wifi shares the radio; long windows are fine on ethernet builds.
-MAX_RECOMMENDED_WIFI_SCAN_WINDOW = TimePeriod(milliseconds=600)
-
 
 @dataclass
 class TrackerData:
@@ -216,45 +209,6 @@ def _raise_defaulted_scan_window(config: ConfigType) -> ConfigType:
     return config
 
 
-def _warn_long_scan_window_with_wifi(config: ConfigType) -> ConfigType:
-    """Warn when the scan window is long enough to starve wifi.
-
-    Runs after _raise_defaulted_scan_window so it sees the final window.
-    software_coexistence is only present when wifi is configured, so ethernet
-    builds never warn: BLE has the radio to itself there. Presence is what
-    matters, not the value; with the arbiter disabled a long window starves
-    wifi outright.
-    """
-    params = config[CONF_SCAN_PARAMETERS]
-    window = params[CONF_WINDOW]
-    if CONF_SOFTWARE_COEXISTENCE not in config:
-        return config
-    if window <= MAX_RECOMMENDED_WIFI_SCAN_WINDOW:
-        return config
-    if _get_data().scan_window_defaulted:
-        # The window was raised to match the interval, so point at the key the
-        # user actually set.
-        _LOGGER.warning(
-            "BLE scan interval of %s sets the scan window to the same value, "
-            "which starves wifi on the same radio and can cause wifi disconnects "
-            "depending on the access point; keep the interval at or below %s "
-            "(for example interval: 320ms). Long windows are only a problem with "
-            "wifi, they are fine on ethernet",
-            params[CONF_INTERVAL],
-            MAX_RECOMMENDED_WIFI_SCAN_WINDOW,
-        )
-        return config
-    _LOGGER.warning(
-        "BLE scan window of %s with wifi on the same radio starves wifi and "
-        "can cause wifi disconnects depending on the access point; keep the "
-        "window at or below %s (for example interval: 320ms, window: 300ms). "
-        "Long windows are only a problem with wifi, they are fine on ethernet",
-        window,
-        MAX_RECOMMENDED_WIFI_SCAN_WINDOW,
-    )
-    return config
-
-
 # 320 ms is the ESP-IDF reference scan interval; the shared schema also
 # tightens validation to the controller's 2.5 ms .. 10240 ms range and rejects
 # window/interval pairs that collapse to the same 0.625 ms unit count.
@@ -317,7 +271,6 @@ CONFIG_SCHEMA = cv.All(
     ).extend(cv.COMPONENT_SCHEMA),
     validate_max_connections_deprecated,
     _raise_defaulted_scan_window,
-    _warn_long_scan_window_with_wifi,
 )
 
 

esphome/components/esp32_camera_web_server/__init__.py

@@ -1,5 +1,4 @@
 import esphome.codegen as cg
-from esphome.components.esp32 import include_builtin_idf_component
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_MODE, CONF_PORT
 from esphome.types import ConfigType
@@ -36,7 +35,6 @@ CONFIG_SCHEMA = cv.All(
             cv.Required(CONF_MODE): cv.enum(MODES, upper=True),
         },
     ).extend(cv.COMPONENT_SCHEMA),
-    cv.only_on_esp32,
     _consume_camera_web_server_sockets,
 )
 
@@ -46,5 +44,3 @@ async def to_code(config: ConfigType) -> None:
     cg.add(server.set_port(config[CONF_PORT]))
     cg.add(server.set_mode(config[CONF_MODE]))
     await cg.register_component(server, config)
-    # esp_http_server is excluded from IDF builds by default to save compile time
-    include_builtin_idf_component("esp_http_server")

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -1,7 +1,5 @@
 #include "esp32_improv_component.h"
 
-#include <array>
-
 #include "esphome/components/bytebuffer/bytebuffer.h"
 #include "esphome/components/esp32_ble/ble.h"
 #include "esphome/components/esp32_ble_server/ble_2902.h"
@@ -21,13 +19,7 @@ using namespace bytebuffer;
 
 static const char *const TAG = "esp32_improv.component";
 static constexpr size_t IMPROV_MAX_LOG_BYTES = 128;
-static constexpr char ESPHOME_MY_LINK[] = "https://my.home-assistant.io/redirect/config_flow_start?domain=esphome";
-// command + data length + trailing byte
-static constexpr size_t RPC_RESPONSE_OVERHEAD = 3;
-// Reserves the ESPHOME_MY_LINK entry; a maximal next URL displaces only the
-// lower value web server URL
-static constexpr size_t MAX_NEXT_URL_LEN =
-    improv::RPC_RESPONSE_MAX_SIZE - RPC_RESPONSE_OVERHEAD - 1 - sizeof(ESPHOME_MY_LINK);
+static const char *const ESPHOME_MY_LINK = "https://my.home-assistant.io/redirect/config_flow_start?domain=esphome";
 static constexpr uint16_t STOP_ADVERTISING_DELAY =
     10000;  // Delay (ms) before stopping service to allow BLE clients to read the final state
 static constexpr uint16_t NAME_ADVERTISING_INTERVAL = 60000;  // Advertise name every 60 seconds
@@ -293,9 +285,8 @@ void ESP32ImprovComponent::set_error_(improv::Error error) {
   }
 }
 
-void ESP32ImprovComponent::send_response_(std::span<const uint8_t> response) {
-  // The BLE characteristic owns its value, so one exact-size copy is required here
-  this->rpc_response_->set_value(std::vector<uint8_t>(response.begin(), response.end()));
+void ESP32ImprovComponent::send_response_(std::vector<uint8_t> &&response) {
+  this->rpc_response_->set_value(std::move(response));
   if (this->state_ != improv::STATE_STOPPED)
     this->rpc_response_->notify();
 }
@@ -439,35 +430,40 @@ void ESP32ImprovComponent::check_wifi_connection_() {
     this->connecting_sta_ = {};
     this->cancel_timeout("wifi-connect-timeout");
 
-    // Build the URL list directly into a stack buffer with no heap allocation
-    std::array<uint8_t, improv::RPC_RESPONSE_MAX_SIZE> buf;
-    improv::RpcResponseBuilder builder(buf, improv::WIFI_SETTINGS);
+    // Build URL list with minimal allocations
+    // Maximum 3 URLs: custom next_url + ESPHOME_MY_LINK + webserver URL
+    std::string url_strings[3];
+    size_t url_count = 0;
 
 #ifdef USE_ESP32_IMPROV_NEXT_URL
     // Add next_url if configured (should be first per Improv BLE spec)
-    this->add_next_url_(builder, MAX_NEXT_URL_LEN);
+    {
+      char url_buffer[384];
+      size_t len = this->get_formatted_next_url_(url_buffer, sizeof(url_buffer));
+      if (len > 0) {
+        url_strings[url_count++] = std::string(url_buffer, len);
+      }
+    }
 #endif
 
-    // Add default URLs for backward compatibility; MAX_NEXT_URL_LEN reserves this
-    // entry's space, so it always fits
-    builder.add_string(ESPHOME_MY_LINK, sizeof(ESPHOME_MY_LINK) - 1);
+    // Add default URLs for backward compatibility
+    url_strings[url_count++] = ESPHOME_MY_LINK;
 #ifdef USE_WEBSERVER
     for (auto &ip : wifi::global_wifi_component->wifi_sta_ip_addresses()) {
       if (ip.is_ip4()) {
-        char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
-        ip.str_to(ip_buf);
-        // "http://" (7) + IP (40) + ":" (1) + port (5) + null (1) = 54
-        char webserver_url[7 + network::IP_ADDRESS_BUFFER_SIZE + 1 + 5 + 1];
-        size_t len =
-            buf_append_printf(webserver_url, sizeof(webserver_url), 0, "http://%s:%u", ip_buf, USE_WEBSERVER_PORT);
-        if (!builder.add_string(webserver_url, len)) {
-          ESP_LOGW(TAG, "Response full; URL dropped");
-        }
+        // "http://" (7) + IPv4 max (15) + ":" (1) + port max (5) + null = 29
+        char url_buffer[32];
+        memcpy(url_buffer, "http://", 7);  // NOLINT(bugprone-not-null-terminated-result) - str_to null-terminates
+        ip.str_to(url_buffer + 7);
+        size_t len = strlen(url_buffer);
+        snprintf(url_buffer + len, sizeof(url_buffer) - len, ":%d", USE_WEBSERVER_PORT);
+        url_strings[url_count++] = url_buffer;
         break;
       }
     }
 #endif
-    this->send_response_(builder.finish());
+    this->send_response_(improv::build_rpc_response(improv::WIFI_SETTINGS,
+                                                    std::vector<std::string>(url_strings, url_strings + url_count)));
   } else if (this->is_active() && this->state_ != improv::STATE_PROVISIONED) {
     ESP_LOGD(TAG, "WiFi provisioned externally");
   }

esphome/components/esp32_improv/esp32_improv_component.h

@@ -22,7 +22,6 @@
 #include "esphome/components/output/binary_output.h"
 #endif
 
-#include <span>
 #include <vector>
 
 #ifdef USE_ESP32
@@ -110,7 +109,7 @@ class ESP32ImprovComponent final : public Component, public improv_base::ImprovB
   void set_state_(improv::State state, bool update_advertising = true);
   void set_error_(improv::Error error);
   improv::State get_initial_state_() const;
-  void send_response_(std::span<const uint8_t> response);
+  void send_response_(std::vector<uint8_t> &&response);
   void process_incoming_data_();
   void on_wifi_connect_timeout_();
   void check_wifi_connection_();

esphome/components/esp8266/__init__.py

@@ -35,7 +35,7 @@ from esphome.platformio.toolchain import copy_ccache_script
 from esphome.storage_json import StorageJSON
 from esphome.types import ConfigType
 
-from .boards import BOARDS, ESP8266_LD_SCRIPTS, board_ld_script
+from .boards import BOARDS, ESP8266_LD_SCRIPTS
 from .const import (
     CONF_EARLY_PIN_INIT,
     CONF_ENABLE_SERIAL,
@@ -44,7 +44,6 @@ from .const import (
     KEY_BOARD,
     KEY_ESP8266,
     KEY_FLASH_SIZE,
-    KEY_LDSCRIPT,
     KEY_PIN_INITIAL_STATES,
     KEY_SERIAL1_REQUIRED,
     KEY_SERIAL_REQUIRED,
@@ -137,16 +136,7 @@ def _format_framework_arduino_version(ver: cv.Version) -> str:
         return f"~1.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
     if ver <= cv.Version(2, 6, 2):
         return f"~2.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
-    # Same encoding the native toolchain uses for its package download, so a
-    # version bump cannot drift between the two paths.
-    from esphome.arduino8266.framework import framework_package_version
-
-    try:
-        return f"~{framework_package_version(ver)}"
-    except EsphomeError as err:
-        # Anchor the 4.x rejection to the framework version line instead of
-        # aborting with a bare traceback-level error
-        raise cv.Invalid(str(err), path=[CONF_VERSION]) from err
+    return f"~3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
 
 
 # NOTE: Keep this in mind when updating the recommended version:
@@ -256,9 +246,6 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_ENABLE_SCANF_FLOAT): cv.boolean,
         }
     ),
-    # Until the native toolchain lands, PlatformIO is the only backend;
-    # reject a --toolchain this platform cannot serve yet.
-    cv.require_platformio_toolchain("ESP8266"),
     set_core_data,
 )
 
@@ -289,31 +276,6 @@ def check_rosetta() -> None:
         )
 
 
-def _choose_ld_script(board: str, ver: cv.Version) -> str | None:
-    """The flash ld to pin for this board and core, or None for cores
-    without ld-script support."""
-    board_data = BOARDS[board]
-    ld_scripts = ESP8266_LD_SCRIPTS[board_data[KEY_FLASH_SIZE]]
-    if ver <= cv.Version(2, 3, 0):
-        # No ld script support
-        return None
-    if ver <= cv.Version(2, 4, 2):
-        # Old ld script path; the modern per-board override names do not
-        # exist in this core's SDK, so the override cannot be honored.
-        # Substituting the size default would move _FS_end and the
-        # preferences sector, wiping flash-backed state on flash.
-        if KEY_LDSCRIPT in board_data:
-            raise EsphomeError(
-                f"Board {board} requires its {board_data[KEY_LDSCRIPT]} "
-                f"flash layout, which Arduino core {ver} cannot honor; "
-                "use a core newer than 2.4.2"
-            )
-        return ld_scripts[0]
-    # A per-board override preserves a layout the board shipped with
-    # (see d1_wroom_02 in boards.py)
-    return board_ld_script(board_data)
-
-
 @coroutine_with_priority(CoroPriority.PLATFORM)
 async def to_code(config: ConfigType) -> None:
     cg.add(esp8266_ns.setup_preferences())
@@ -435,7 +397,17 @@ async def to_code(config: ConfigType) -> None:
     )
 
     if config[CONF_BOARD] in BOARDS:
-        ld_script = _choose_ld_script(config[CONF_BOARD], ver)
+        flash_size = BOARDS[config[CONF_BOARD]][KEY_FLASH_SIZE]
+        ld_scripts = ESP8266_LD_SCRIPTS[flash_size]
+
+        if ver <= cv.Version(2, 3, 0):
+            # No ld script support
+            ld_script = None
+        elif ver <= cv.Version(2, 4, 2):
+            # Old ld script path
+            ld_script = ld_scripts[0]
+        else:
+            ld_script = ld_scripts[1]
 
         if ld_script is not None:
             cg.add_platformio_option("board_build.ldscript", ld_script)

esphome/components/esp8266/boards.py

@@ -1,5 +1,3 @@
-from .const import KEY_FLASH_SIZE, KEY_LDSCRIPT
-
 FLASH_SIZE_1_MB = 2**20
 FLASH_SIZE_512_KB = FLASH_SIZE_1_MB // 2
 FLASH_SIZE_2_MB = 2 * FLASH_SIZE_1_MB
@@ -166,8 +164,7 @@ ESP8266_BOARD_PINS = {
 }
 
 """
-BOARDS generate with (preserve per-board KEY_LDSCRIPT overrides such as
-d1_wroom_02; the recipe emits only name/flash_size):
+BOARDS generate with:
 
 git clone https://github.com/platformio/platform-espressif8266
 for x in platform-espressif8266/boards/*.json; do
@@ -185,19 +182,6 @@ for x in platform-espressif8266/boards/*.json; do
 done | sort
 """
 
-
-def board_ld_script(board_data: dict) -> str:
-    """The modern (core > 2.4.2) flash linker script for a board: its
-    shipped-layout override, else the size default (the no-FS layout).
-
-    Single source of truth for the PlatformIO pinning in __init__ and the
-    native generator's fallback, so the per-board rule cannot drift.
-    """
-    return board_data.get(
-        KEY_LDSCRIPT, ESP8266_LD_SCRIPTS[board_data[KEY_FLASH_SIZE]][1]
-    )
-
-
 BOARDS = {
     "agruminolemon": {
         "name": "Lifely Agrumino Lemon v4",
@@ -215,15 +199,6 @@ BOARDS = {
         "name": "WeMos D1 mini Pro",
         "flash_size": FLASH_SIZE_16_MB,
     },
-    "d1_wroom_02": {
-        "name": "WeMos D1 ESP-WROOM-02",
-        "flash_size": FLASH_SIZE_2_MB,
-        # This board joined BOARDS after shipping with the manifest default
-        # (64 KB filesystem region); the flash-size default (2m.ld) would
-        # move _FS_end and with it the preferences sector, wiping existing
-        # devices' flash-backed state on update.
-        KEY_LDSCRIPT: "eagle.flash.2m64.ld",
-    },
     "d1": {
         "name": "WEMOS D1 R1",
         "flash_size": FLASH_SIZE_4_MB,
@@ -385,112 +360,3 @@ BOARDS = {
         "flash_size": FLASH_SIZE_4_MB,
     },
 }
-
-
-# Per-board variant dir + identity defines from platform-espressif8266 4.x
-# build.extra_flags; the shared -DESP8266/-DARDUINO_ARCH_ESP8266 are added
-# by the generator.
-#
-# Regenerate ESP8266_BOARD_BUILD with (v4.2.1 is the platform version the
-# native toolchain mirrors; regenerate against the tag when bumping it):
-#
-# git clone -b v4.2.1 https://github.com/platformio/platform-espressif8266
-# python3 - <<'EOF'
-# import json, glob, os
-# for f in sorted(glob.glob("platform-espressif8266/boards/*.json")):
-#     b = json.load(open(f))["build"]
-#     extra = b["extra_flags"]
-#     extra = extra.split() if isinstance(extra, str) else extra
-#     defines = [
-#         e[2:] for e in extra if e not in ("-DESP8266", "-DARDUINO_ARCH_ESP8266")
-#     ]
-#     entries = ", ".join(f'"{d}"' for d in defines) + ("," if len(defines) == 1 else "")
-#     board = os.path.splitext(os.path.basename(f))[0]
-#     print(f'    "{board}": {{"variant": "{b["variant"]}", "defines": ({entries})}},')
-# EOF
-ESP8266_BOARD_BUILD = {
-    "agruminolemon": {
-        "variant": "agruminolemonv4",
-        "defines": ("ARDUINO_ESP8266_AGRUMINO_LEMON_V4",),
-    },
-    "d1": {"variant": "d1", "defines": ("ARDUINO_ESP8266_WEMOS_D1R1",)},
-    "d1_mini": {"variant": "d1_mini", "defines": ("ARDUINO_ESP8266_WEMOS_D1MINI",)},
-    "d1_mini_lite": {
-        "variant": "d1_mini",
-        "defines": ("ARDUINO_ESP8266_WEMOS_D1MINILITE",),
-    },
-    "d1_mini_pro": {
-        "variant": "d1_mini",
-        "defines": ("ARDUINO_ESP8266_WEMOS_D1MINIPRO",),
-    },
-    "d1_wroom_02": {
-        "variant": "d1_mini",
-        "defines": ("ARDUINO_ESP8266_WEMOS_D1WROOM02",),
-    },
-    "eduinowifi": {
-        "variant": "eduinowifi",
-        "defines": ("ARDUINO_ESP8266_SCHIRMILABS_EDUINO_WIFI",),
-    },
-    "esp01": {"variant": "generic", "defines": ("ARDUINO_ESP8266_ESP01",)},
-    "esp01_1m": {"variant": "generic", "defines": ("ARDUINO_ESP8266_ESP01",)},
-    "esp07": {"variant": "generic", "defines": ("ARDUINO_ESP8266_ESP07",)},
-    "esp07s": {"variant": "nodemcu", "defines": ("ARDUINO_ESP8266_ESP07",)},
-    "esp12e": {"variant": "nodemcu", "defines": ("ARDUINO_ESP8266_ESP12",)},
-    "esp210": {"variant": "generic", "defines": ("ARDUINO_ESP8266_ESP210",)},
-    "esp8285": {"variant": "esp8285", "defines": ("ARDUINO_ESP8266_ESP01",)},
-    "esp_wroom_02": {
-        "variant": "nodemcu",
-        "defines": ("ARDUINO_ESP8266_ESP_WROOM_02",),
-    },
-    "espduino": {"variant": "ESPDuino", "defines": ("ARDUINO_ESP8266_ESP13",)},
-    "espectro": {"variant": "espectro", "defines": ("ARDUINO_ESP8266_ESPECTRO_CORE",)},
-    "espino": {"variant": "espino", "defines": ("ARDUINO_ESP8266_ESP12",)},
-    "espinotee": {"variant": "espinotee", "defines": ("ARDUINO_ESP8266_ESP13",)},
-    "espmxdevkit": {
-        "variant": "esp8285",
-        "defines": ("ARDUINO_ESP8266_ESP01", "LED_BUILTIN=16"),
-    },
-    "espresso_lite_v1": {
-        "variant": "espresso_lite_v1",
-        "defines": ("ARDUINO_ESP8266_ESPRESSO_LITE_V1",),
-    },
-    "espresso_lite_v2": {
-        "variant": "espresso_lite_v2",
-        "defines": ("ARDUINO_ESP8266_ESPRESSO_LITE_V2",),
-    },
-    "gen4iod": {"variant": "generic", "defines": ("ARDUINO_GEN4_IOD",)},
-    "heltec_wifi_kit_8": {
-        "variant": "wifi_kit_8",
-        "defines": ("ARDUINO_wifi_kit_8",),
-    },
-    "huzzah": {"variant": "adafruit", "defines": ("ARDUINO_ESP8266_ADAFRUIT_HUZZAH",)},
-    "inventone": {"variant": "inventone", "defines": ("ARDUINO_ESP8266_INVENT_ONE",)},
-    "modwifi": {"variant": "generic", "defines": ("ARDUINO_MOD_WIFI_ESP8266",)},
-    "nodemcu": {"variant": "nodemcu", "defines": ("ARDUINO_ESP8266_NODEMCU",)},
-    "nodemcuv2": {"variant": "nodemcu", "defines": ("ARDUINO_ESP8266_NODEMCU_ESP12E",)},
-    "oak": {"variant": "oak", "defines": ("ARDUINO_ESP8266_OAK",)},
-    "phoenix_v1": {
-        "variant": "phoenix_v1",
-        "defines": ("ARDUINO_ESP8266_PHOENIX_V1",),
-    },
-    "phoenix_v2": {
-        "variant": "phoenix_v2",
-        "defines": ("ARDUINO_ESP8266_PHOENIX_V2",),
-    },
-    "sonoff_basic": {"variant": "itead", "defines": ("ARDUINO_ESP8266_SONOFF_BASIC",)},
-    "sonoff_s20": {"variant": "itead", "defines": ("ARDUINO_ESP8266_SONOFF_S20",)},
-    "sonoff_sv": {"variant": "itead", "defines": ("ARDUINO_ESP8266_SONOFF_SV",)},
-    "sonoff_th": {"variant": "itead", "defines": ("ARDUINO_ESP8266_SONOFF_TH",)},
-    "sparkfunBlynk": {"variant": "thing", "defines": ("ARDUINO_ESP8266_THING",)},
-    "thing": {"variant": "thing", "defines": ("ARDUINO_ESP8266_THING",)},
-    "thingdev": {"variant": "thing", "defines": ("ARDUINO_ESP8266_THING_DEV",)},
-    "wifi_slot": {"variant": "wifi_slot", "defines": ("ARDUINO_AMPERKA_WIFI_SLOT",)},
-    "wifiduino": {"variant": "wifiduino", "defines": ("ARDUINO_WIFIDUINO_ESP8266",)},
-    "wifinfo": {"variant": "wifinfo", "defines": ("ARDUINO_WIFINFO",)},
-    "wio_link": {"variant": "wiolink", "defines": ("ARDUINO_ESP8266_WIO_LINK",)},
-    "wio_node": {"variant": "nodemcu", "defines": ("ARDUINO_ESP8266_ESP_WROOM_02",)},
-    "xinabox_cw01": {
-        "variant": "xinabox",
-        "defines": ("ARDUINO_ESP8266_XINABOX_CW01",),
-    },
-}

esphome/components/esp8266/build_surgery.py

@@ -1,123 +0,0 @@
-"""Linker-script surgery shared with the native (PlatformIO-free) toolchain.
-
-These mirror the PlatformIO extra scripts in this directory
-(``relocate_ratetable.py.script`` and ``testing_mode.py.script``), which run
-inside SCons and must stay self-contained. The native build generator applies
-the same patches to the linker scripts it generates, so the logic lives here
-as plain functions. Keep both in sync when changing either.
-``segment_length`` is native-toolchain-only and has no script twin.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Collection
-import hashlib
-import re
-
-# Move the NONOS SDK wifi rate tables from flash to DRAM; see
-# relocate_ratetable.py.script for the full background (NONOS SDK issue 320).
-RATETABLE_RULE = "*libnet80211.a:ieee80211_phy.o(.irom.text .irom.text.*)"
-_RATETABLE_COMMENT = (
-    "/* ESPHome: wifi rate tables must live in DRAM, see NONOS SDK issue 320 */"
-)
-# Match the whole line: "_data_start" is also a substring of the
-# "_dport0_data_start" line in the earlier .dport0.data section
-_RATETABLE_ANCHOR = re.compile(r"^\s*_data_start = ABSOLUTE\(\.\);", re.MULTILINE)
-
-# Memory sizes for testing mode (allow larger builds for CI component grouping)
-TESTING_IRAM_SIZE = "0x200000"  # 2MB
-TESTING_DRAM_SIZE = "0x200000"  # 2MB
-TESTING_FLASH_SIZE = "0x2000000"  # 32MB
-
-
-def relocate_ratetable(content: str) -> str:
-    """Insert the rate-table DRAM rule into a generated common linker script."""
-    if RATETABLE_RULE in content:
-        return content
-    match = _RATETABLE_ANCHOR.search(content)
-    if match is None:
-        raise RuntimeError(
-            "'_data_start' anchor not found in the generated linker script; "
-            "cannot apply wifi rate table DRAM relocation "
-            "(has the Arduino core linker script changed?)"
-        )
-    insert_pos = match.end()
-    return (
-        content[:insert_pos]
-        + f"\n    {_RATETABLE_COMMENT}"
-        + f"\n    {RATETABLE_RULE}"
-        + content[insert_pos:]
-    )
-
-
-_TESTING_SEGMENT_SIZES = {
-    "iram1_0_seg": TESTING_IRAM_SIZE,
-    "dram0_0_seg": TESTING_DRAM_SIZE,
-    "irom0_0_seg": TESTING_FLASH_SIZE,
-}
-
-
-def _segment_line_re(segment_name: str) -> re.Pattern[str]:
-    """The MEMORY line for one segment: ``<seg> : org = 0x..., len = 0x...``.
-
-    Anchored to the start of the line so a name never matches inside a
-    longer one (``ram0_0_seg`` must not read ``dram0_0_seg``). The size
-    group stops at the hex digits, leaving any ``ul`` suffix (from the
-    preprocessed ``MMU_IRAM_SIZE``) in place.
-    """
-    return re.compile(
-        rf"(^[ \t]*{re.escape(segment_name)}"
-        r"\s*:\s*org\s*=\s*0x[0-9a-fA-F]+\s*,\s*len\s*=\s*)"
-        r"(0x[0-9a-fA-F]+)",
-        re.MULTILINE,
-    )
-
-
-def apply_testing_memory_patches(content: str, segments: Collection[str]) -> str:
-    """Enlarge the named memory segments so grouped CI test builds can link.
-
-    Each caller passes the segments its linker script defines: the
-    generated common ld carries ``iram1_0_seg``; the flash ld carries
-    ``dram0_0_seg`` and ``irom0_0_seg``. A segment that fails to match
-    raises, since a silently kept real memory limit would fail grouped
-    builds far from the cause.
-    """
-    for segment in _TESTING_SEGMENT_SIZES:
-        if segment not in segments and _segment_line_re(segment).search(content):
-            raise RuntimeError(
-                f"Testing-mode segment {segment} is present in the linker "
-                "script but was not selected for patching"
-            )
-    for segment in segments:
-        if segment not in _TESTING_SEGMENT_SIZES:
-            raise RuntimeError(f"Unknown testing-mode segment {segment!r}")
-        content, count = _segment_line_re(segment).subn(
-            rf"\g<1>{_TESTING_SEGMENT_SIZES[segment]}", content
-        )
-        if count == 0:
-            raise RuntimeError(
-                f"Testing-mode memory patch failed: segment {segment} "
-                "not found (has the Arduino core linker script changed?)"
-            )
-    return content
-
-
-def segment_length(content: str, segment_name: str) -> int | None:
-    """Read a memory segment's length from linker script content.
-
-    Returns None for an absent segment OR an unparsable line; callers must
-    treat None as "no usable budget" and warn (as the Flash summary does),
-    never as "no limit".
-    """
-    match = _segment_line_re(segment_name).search(content)
-    return int(match.group(2), 16) if match else None
-
-
-def surgery_fingerprint() -> str:
-    """Hash of this module's source; linker-script caches include it so an
-    edit here invalidates them."""
-    import inspect
-    import sys
-
-    source = inspect.getsource(sys.modules[__name__])
-    return hashlib.sha256(source.encode()).hexdigest()

esphome/components/esp8266/const.py

@@ -15,11 +15,6 @@ CONF_ENABLE_SERIAL1 = "enable_serial1"
 KEY_WAVEFORM_REQUIRED = "waveform_required"
 KEY_SERIAL_REQUIRED = "serial_required"
 KEY_SERIAL1_REQUIRED = "serial1_required"
-# Set for the native (non-PlatformIO) toolchain's build generator
-KEY_FLASH_MODE = "flash_mode"
-KEY_SCANF_FLOAT = "scanf_float"
-# Per-board flash-layout override consumed by board_ld_script()
-KEY_LDSCRIPT = "ldscript"
 
 # esp8266 namespace is already defined by arduino, manually prefix esphome
 esp8266_ns = cg.global_ns.namespace("esphome").namespace("esp8266")

esphome/components/espnow/__init__.py

@@ -155,11 +155,6 @@ async def to_code(config: ConfigType) -> None:
     cg.add_define("USE_ESPNOW")
     cg.add_define("USE_ESPNOW_MAX_PAYLOAD_SIZE", config[CONF_MAX_PAYLOAD_SIZE])
 
-    if CORE.is_esp32:
-        from esphome.components.esp32 import include_builtin_idf_component
-
-        include_builtin_idf_component("esp_wifi")
-
     if CONF_WIFI in CORE.config:
         # Track the Wi-Fi channel via connect events instead of polling every loop
         wifi.request_wifi_connect_state_listener()

esphome/components/ethernet/__init__.py

@@ -4,7 +4,6 @@ import logging
 from esphome import automation, pins
 from esphome.automation import Condition
 import esphome.codegen as cg
-from esphome.components import spi
 from esphome.components.network import (
     add_use_address,
     get_network_priority,
@@ -40,7 +39,6 @@ from esphome.const import (
     CONF_POLLING_INTERVAL,
     CONF_RESET_PIN,
     CONF_SPI,
-    CONF_SPI_ID,
     CONF_STATIC_IP,
     CONF_SUBNET,
     CONF_TYPE,
@@ -265,42 +263,10 @@ def _is_framework_spi_polling_mode_supported() -> bool:
     return False
 
 
-# Options that come from the referenced spi bus when spi_id is set
-_SPI_BUS_PROVIDED_OPTIONS = (
-    CONF_CLK_PIN,
-    CONF_MOSI_PIN,
-    CONF_MISO_PIN,
-    CONF_INTERFACE,
-)
-
-
-def _validate_spi_bus(config: ConfigType) -> ConfigType:
-    """Cross-validate spi_id against the options the referenced bus provides."""
-    if CONF_SPI_ID in config:
-        for key in _SPI_BUS_PROVIDED_OPTIONS:
-            if key in config:
-                raise cv.Invalid(
-                    f"'{key}' cannot be used together with '{CONF_SPI_ID}'; "
-                    f"it comes from the referenced 'spi:' bus.",
-                    path=[key],
-                )
-    else:
-        for key in (CONF_CLK_PIN, CONF_MOSI_PIN, CONF_MISO_PIN):
-            if key not in config:
-                raise cv.Invalid(
-                    f"'{key}' is a required option when '{CONF_SPI_ID}' is not set.",
-                    path=[key],
-                )
-    return config
-
-
 def _validate_spi_interface(config: ConfigType) -> ConfigType:
     """Set default SPI interface or validate user choice against the variant."""
     if not CORE.is_esp32:
         return config
-    if CONF_SPI_ID in config:
-        # The interface comes from the referenced spi bus; don't set a default.
-        return config
     from esphome.components.esp32 import VARIANT_ESP32, get_esp32_variant
     from esphome.components.spi import get_hw_interface_list
 
@@ -485,14 +451,9 @@ def _spi_schema(default_clock: str = "26.67MHz", max_clock: int = int(80e6)) ->
         BASE_SCHEMA.extend(
             cv.Schema(
                 {
-                    # clk/mosi/miso are required unless spi_id is set; enforced
-                    # by _validate_spi_bus below.
-                    cv.Optional(CONF_CLK_PIN): pins.internal_gpio_output_pin_number,
-                    cv.Optional(CONF_MISO_PIN): pins.internal_gpio_input_pin_number,
-                    cv.Optional(CONF_MOSI_PIN): pins.internal_gpio_output_pin_number,
-                    cv.Optional(CONF_SPI_ID): cv.All(
-                        cv.only_on_esp32, cv.use_id(spi.SPIComponent)
-                    ),
+                    cv.Required(CONF_CLK_PIN): pins.internal_gpio_output_pin_number,
+                    cv.Required(CONF_MISO_PIN): pins.internal_gpio_input_pin_number,
+                    cv.Required(CONF_MOSI_PIN): pins.internal_gpio_output_pin_number,
                     cv.Required(CONF_CS_PIN): pins.internal_gpio_output_pin_number,
                     cv.Optional(
                         CONF_INTERRUPT_PIN
@@ -517,7 +478,6 @@ def _spi_schema(default_clock: str = "26.67MHz", max_clock: int = int(80e6)) ->
             ),
         ),
         cv.only_on([Platform.ESP32, Platform.RP2]),
-        _validate_spi_bus,
         _validate_spi_interface,
     )
 
@@ -569,30 +529,6 @@ def _final_validate_spi(config: ConfigType) -> None:
         return
     from esphome.components.spi import CONF_INTERFACE_INDEX, get_spi_interface
 
-    if CONF_SPI_ID in config:
-        # Sharing the bus: the standard spi device schema enforces that the
-        # referenced bus declares both data lines. The IDF ethernet drivers
-        # additionally need a hardware host, which shows as an interface index
-        # on the validated bus config.
-        spi.final_validate_device_schema(
-            "ethernet", require_mosi=True, require_miso=True
-        )(config)
-        cv.Schema(
-            {
-                cv.Required(CONF_SPI_ID): fv.id_declaration_match_schema(
-                    {
-                        cv.Required(
-                            CONF_INTERFACE_INDEX,
-                            msg="Component ethernet requires this spi bus to use "
-                            "a hardware interface",
-                        ): cv.valid
-                    }
-                )
-            },
-            extra=cv.ALLOW_EXTRA,
-        )(config)
-        return
-
     if spi_configs := fv.full_config.get().get(CONF_SPI):
         # get_spi_interface() returns strings like "SPI2_HOST"
         spi_host = f"{config[CONF_INTERFACE].upper()}_HOST"
@@ -689,15 +625,9 @@ async def _to_code_esp32(var: cg.MockObj, config: ConfigType) -> None:
     )
 
     if config[CONF_TYPE] in SPI_ETHERNET_TYPES:
-        if (spi_id := config.get(CONF_SPI_ID)) is not None:
-            # Pins and host come from the shared spi bus.
-            spi_parent = await cg.get_variable(spi_id)
-            cg.add(var.set_spi_parent(spi_parent))
-        else:
-            cg.add(var.set_clk_pin(config[CONF_CLK_PIN]))
-            cg.add(var.set_miso_pin(config[CONF_MISO_PIN]))
-            cg.add(var.set_mosi_pin(config[CONF_MOSI_PIN]))
-            cg.add(var.set_interface(SPI_INTERFACE_MAP[config[CONF_INTERFACE]]))
+        cg.add(var.set_clk_pin(config[CONF_CLK_PIN]))
+        cg.add(var.set_miso_pin(config[CONF_MISO_PIN]))
+        cg.add(var.set_mosi_pin(config[CONF_MOSI_PIN]))
         cg.add(var.set_cs_pin(config[CONF_CS_PIN]))
         if CONF_INTERRUPT_PIN in config:
             cg.add(var.set_interrupt_pin(config[CONF_INTERRUPT_PIN]))
@@ -711,6 +641,7 @@ async def _to_code_esp32(var: cg.MockObj, config: ConfigType) -> None:
 
         cg.add_define("USE_ETHERNET_SPI")
 
+        cg.add(var.set_interface(SPI_INTERFACE_MAP[config[CONF_INTERFACE]]))
         add_idf_sdkconfig_option("CONFIG_ETH_USE_SPI_ETHERNET", True)
         # CONFIG_ETH_SPI_ETHERNET_{TYPE} Kconfig options were removed in IDF 6.0
         # Types that are never built into IDF ship no Kconfig option at all

esphome/components/ethernet/ethernet_component.h

@@ -13,9 +13,6 @@
 #include "esp_eth.h"
 #ifdef USE_ETHERNET_SPI
 #include "hal/spi_types.h"
-#ifdef USE_SPI
-#include "esphome/components/spi/spi.h"
-#endif
 #endif
 #include "esp_eth_mac.h"
 #include "esp_eth_mac_esp.h"
@@ -179,9 +176,6 @@ class EthernetComponent final : public Component {
   void set_reset_pin(uint8_t reset_pin) { this->reset_pin_ = reset_pin; }
   void set_clock_speed(int clock_speed) { this->clock_speed_ = clock_speed; }
   void set_interface(spi_host_device_t interface) { this->interface_ = interface; }
-#ifdef USE_SPI
-  void set_spi_parent(spi::SPIComponent *parent) { this->spi_parent_ = parent; }
-#endif
 #ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
   void set_polling_interval(uint32_t polling_interval) { this->polling_interval_ = polling_interval; }
 #endif
@@ -264,11 +258,6 @@ class EthernetComponent final : public Component {
   int phy_addr_spi_{-1};
   int clock_speed_;
   spi_host_device_t interface_{SPI2_HOST};
-#ifdef USE_SPI
-  // When set, the SPI bus is owned and initialized by this spi component
-  // and the ethernet chip only adds a device to it.
-  spi::SPIComponent *spi_parent_{nullptr};
-#endif
 #ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
   uint32_t polling_interval_{0};
 #endif

esphome/components/ethernet/ethernet_component_esp32.cpp

@@ -59,9 +59,6 @@
 #ifdef USE_ETHERNET_SPI
 #include <driver/gpio.h>
 #include <driver/spi_master.h>
-#ifdef USE_SPI
-#include "esphome/components/spi/spi.h"
-#endif
 #endif
 
 namespace esphome::ethernet {
@@ -171,34 +168,25 @@ void EthernetComponent::ethernet_lazy_init_() {
   // Install GPIO ISR handler to be able to service SPI Eth modules interrupts
   gpio_install_isr_service(0);
 
-  spi_host_device_t host;
-#ifdef USE_SPI
-  if (this->spi_parent_ != nullptr) {
-    // The bus is owned and already initialized by the spi component; share its host.
-    host = this->spi_parent_->get_interface();
-  } else
-#endif
-  {
-    spi_bus_config_t buscfg = {
-        .mosi_io_num = this->mosi_pin_,
-        .miso_io_num = this->miso_pin_,
-        .sclk_io_num = this->clk_pin_,
-        .quadwp_io_num = -1,
-        .quadhd_io_num = -1,
-        .data4_io_num = -1,
-        .data5_io_num = -1,
-        .data6_io_num = -1,
-        .data7_io_num = -1,
-        .max_transfer_sz = 0,
-        .flags = 0,
-        .intr_flags = 0,
-    };
+  spi_bus_config_t buscfg = {
+      .mosi_io_num = this->mosi_pin_,
+      .miso_io_num = this->miso_pin_,
+      .sclk_io_num = this->clk_pin_,
+      .quadwp_io_num = -1,
+      .quadhd_io_num = -1,
+      .data4_io_num = -1,
+      .data5_io_num = -1,
+      .data6_io_num = -1,
+      .data7_io_num = -1,
+      .max_transfer_sz = 0,
+      .flags = 0,
+      .intr_flags = 0,
+  };
 
-    host = this->interface_;
+  auto host = this->interface_;
 
-    err = spi_bus_initialize(host, &buscfg, SPI_DMA_CH_AUTO);
-    ESPHL_ERROR_CHECK(err, "SPI bus initialize error");
-  }
+  err = spi_bus_initialize(host, &buscfg, SPI_DMA_CH_AUTO);
+  ESPHL_ERROR_CHECK(err, "SPI bus initialize error");
 #endif
   // Network interface setup handled by network component
 
@@ -587,25 +575,17 @@ void EthernetComponent::dump_config() {
                 YESNO(this->is_connected()));
   this->dump_connect_params_();
 #ifdef USE_ETHERNET_SPI
-#ifdef USE_SPI
-  if (this->spi_parent_ != nullptr) {
-    // Pins and interface come from the shared spi bus; only CS is ours.
-    ESP_LOGCONFIG(TAG, "  CS Pin: %u", this->cs_pin_);
-  } else
-#endif
-  {
-    ESP_LOGCONFIG(TAG,
-                  "  CLK Pin: %u\n"
-                  "  MISO Pin: %u\n"
-                  "  MOSI Pin: %u\n"
-                  "  CS Pin: %u",
-                  this->clk_pin_, this->miso_pin_, this->mosi_pin_, this->cs_pin_);
-    const char *spi_interface = "spi3";
-    if (this->interface_ == SPI2_HOST) {
-      spi_interface = "spi2";
-    }
-    ESP_LOGCONFIG(TAG, "  Interface: %s", spi_interface);
+  ESP_LOGCONFIG(TAG,
+                "  CLK Pin: %u\n"
+                "  MISO Pin: %u\n"
+                "  MOSI Pin: %u\n"
+                "  CS Pin: %u",
+                this->clk_pin_, this->miso_pin_, this->mosi_pin_, this->cs_pin_);
+  const char *spi_interface = "spi3";
+  if (this->interface_ == SPI2_HOST) {
+    spi_interface = "spi2";
   }
+  ESP_LOGCONFIG(TAG, "  Interface: %s", spi_interface);
 #ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
   if (this->polling_interval_ != 0) {
     ESP_LOGCONFIG(TAG, "  Polling Interval: %" PRIu32 " ms", this->polling_interval_);

esphome/components/external_components/__init__.py

@@ -71,33 +71,6 @@ def _process_git_config(config: dict[str, Any], refresh: TimePeriodSeconds) -> P
     return components_dir
 
 
-def _log_overridden_components(
-    conf: dict[str, Any], component_names: list[str]
-) -> None:
-    overridden = [
-        name
-        for name in component_names
-        if (loader.CORE_COMPONENTS_PATH / name / "__init__.py").is_file()
-    ]
-    if not overridden:
-        return
-    if conf[CONF_TYPE] == TYPE_GIT:
-        source = conf[CONF_URL]
-        if ref := conf.get(CONF_REF):
-            source = f"{source}@{ref}"
-        if path := conf.get(CONF_PATH):
-            source = f"{source} ({path})"
-    else:
-        source = conf[CONF_PATH]
-    _LOGGER.info(
-        "External components are overriding built-in components:\n"
-        "  source: %s\n"
-        "  components: %s",
-        source,
-        ", ".join(sorted(overridden)),
-    )
-
-
 def _process_single_config(config: dict[str, Any]) -> None:
     conf = config[CONF_SOURCE]
     if conf[CONF_TYPE] == TYPE_GIT:
@@ -111,8 +84,8 @@ def _process_single_config(config: dict[str, Any]) -> None:
         raise NotImplementedError
 
     if config[CONF_COMPONENTS] == "all":
-        component_names = [p.parent.name for p in components_dir.glob("*/__init__.py")]
-        if len(component_names) > 100:
+        num_components = len(list(components_dir.glob("*/__init__.py")))
+        if num_components > 100:
             # Prevent accidentally including all components from an esphome fork/branch
             # In this case force the user to manually specify which components they want to include
             raise cv.Invalid(
@@ -129,9 +102,6 @@ def _process_single_config(config: dict[str, Any]) -> None:
                     [CONF_COMPONENTS, i],
                 )
         allowed_components = config[CONF_COMPONENTS]
-        component_names = allowed_components
-
-    _log_overridden_components(conf, component_names)
 
     loader.install_meta_finder(components_dir, allowed_components=allowed_components)
 

esphome/components/gpio/one_wire/gpio_one_wire.cpp

@@ -55,11 +55,8 @@ int HOT IRAM_ATTR GPIOOneWireBus::reset_int() {
     delayMicroseconds(1);
   }
 
-  // delay J: finish the 480us slot, but never spin if it already elapsed
-  // (unsigned wrap here would busy-wait for minutes with interrupts off)
-  uint32_t elapsed = micros() - start;
-  if (elapsed < 480)
-    delayMicroseconds(480 - elapsed);
+  // delay J
+  delayMicroseconds(start + 480 - micros());
   this->pin_.digital_write(true);
   this->pin_.pin_mode(gpio::FLAG_OUTPUT);
   return r ? 1 : 0;

esphome/components/growatt_solar/growatt_solar.cpp

@@ -1,68 +1,105 @@
 #include "growatt_solar.h"
+#include "esphome/core/application.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome::growatt_solar {
 
-namespace helpers = modbus::helpers;
-
 static const char *const TAG = "growatt_solar";
 
 static const uint8_t MODBUS_REGISTER_COUNT[] = {33, 95};  // indexed with enum GrowattProtocolVersion
 
-void GrowattSolar::update() { this->read_input_registers(0, MODBUS_REGISTER_COUNT[this->protocol_version_]); }
+void GrowattSolar::loop() {
+  // If update() was unable to send we retry until we can send.
+  if (!this->waiting_to_update_)
+    return;
+  update();
+}
 
-void GrowattSolar::on_read_input_registers(uint16_t start_address, std::span<const uint16_t> registers,
-                                           modbus::ResponseStatus status) {
-  if (!modbus::succeeded(status))
+void GrowattSolar::update() {
+  // If our last send has had no reply yet, and it wasn't that long ago, do nothing.
+  const uint32_t now = App.get_loop_component_start_time();
+  if (now - this->last_send_ < this->get_update_interval() / 2) {
+    return;
+  }
+
+  // The bus might be slow, or there might be other devices, or other components might be talking to our device.
+  if (!this->ready_for_immediate_send()) {
+    this->waiting_to_update_ = true;
+    return;
+  }
+
+  this->waiting_to_update_ = false;
+  this->read_input_registers(0, MODBUS_REGISTER_COUNT[this->protocol_version_]);
+  this->last_send_ = millis();
+}
+
+void GrowattSolar::on_response(std::span<const uint8_t> request_pdu, std::span<const uint8_t> response_pdu) {
+  auto data = modbus::helpers::server_pdu_payload(response_pdu);
+  // Other components might be sending commands to our device. But we don't get called with enough
+  // context to know what is what. So if we didn't do a send, we ignore the data.
+  if (!this->last_send_)
+    return;
+  this->last_send_ = 0;
+
+  // Also ignore the data if the message is too short. Otherwise we will publish invalid values.
+  if (data.size() < MODBUS_REGISTER_COUNT[this->protocol_version_] * 2)
     return;
 
-  // Publish a sensor if its register(s) are in this response; skipping absent registers keeps this
-  // correct for any read range, so the poll may be split into multiple requests.
-  auto publish_1_reg_sensor_state = [&](sensor::Sensor *sensor, uint16_t reg, float unit) -> void {
+  auto publish_1_reg_sensor_state = [&](sensor::Sensor *sensor, size_t i, float unit) -> void {
     if (sensor == nullptr)
       return;
-    if (auto value = helpers::value_at<helpers::SensorValueType::U_WORD>(registers, start_address, reg))
-      sensor->publish_state(*value * unit);
+    float value = encode_uint16(data[i * 2], data[i * 2 + 1]) * unit;
+    sensor->publish_state(value);
   };
 
-  auto publish_2_reg_sensor_state = [&](sensor::Sensor *sensor, uint16_t reg, float unit) -> void {
-    if (sensor == nullptr)
-      return;
-    if (auto value = helpers::value_at<helpers::SensorValueType::U_DWORD>(registers, start_address, reg))
-      sensor->publish_state(*value * unit);
+  auto publish_2_reg_sensor_state = [&](sensor::Sensor *sensor, size_t reg1, size_t reg2, float unit) -> void {
+    float value = ((encode_uint16(data[reg1 * 2], data[reg1 * 2 + 1]) << 16) +
+                   encode_uint16(data[reg2 * 2], data[reg2 * 2 + 1])) *
+                  unit;
+    if (sensor != nullptr)
+      sensor->publish_state(value);
   };
 
   switch (this->protocol_version_) {
     case RTU: {
       publish_1_reg_sensor_state(this->inverter_status_, RTU_INVERTER_STATUS, 1);
 
-      publish_2_reg_sensor_state(this->pv_active_power_sensor_, RTU_PV_ACTIVE_POWER, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->pv_active_power_sensor_, RTU_PV_ACTIVE_POWER, RTU_PV_ACTIVE_POWER + 1,
+                                 ONE_DEC_UNIT);
 
       publish_1_reg_sensor_state(this->pvs_[0].voltage_sensor_, RTU_PV1_VOLTAGE, ONE_DEC_UNIT);
       publish_1_reg_sensor_state(this->pvs_[0].current_sensor_, RTU_PV1_CURRENT, ONE_DEC_UNIT);
-      publish_2_reg_sensor_state(this->pvs_[0].active_power_sensor_, RTU_PV1_ACTIVE_POWER, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->pvs_[0].active_power_sensor_, RTU_PV1_ACTIVE_POWER, RTU_PV1_ACTIVE_POWER + 1,
+                                 ONE_DEC_UNIT);
 
       publish_1_reg_sensor_state(this->pvs_[1].voltage_sensor_, RTU_PV2_VOLTAGE, ONE_DEC_UNIT);
       publish_1_reg_sensor_state(this->pvs_[1].current_sensor_, RTU_PV2_CURRENT, ONE_DEC_UNIT);
-      publish_2_reg_sensor_state(this->pvs_[1].active_power_sensor_, RTU_PV2_ACTIVE_POWER, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->pvs_[1].active_power_sensor_, RTU_PV2_ACTIVE_POWER, RTU_PV2_ACTIVE_POWER + 1,
+                                 ONE_DEC_UNIT);
 
-      publish_2_reg_sensor_state(this->grid_active_power_sensor_, RTU_GRID_ACTIVE_POWER, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->grid_active_power_sensor_, RTU_GRID_ACTIVE_POWER, RTU_GRID_ACTIVE_POWER + 1,
+                                 ONE_DEC_UNIT);
       publish_1_reg_sensor_state(this->grid_frequency_sensor_, RTU_GRID_FREQUENCY, TWO_DEC_UNIT);
 
       publish_1_reg_sensor_state(this->phases_[0].voltage_sensor_, RTU_PHASE1_VOLTAGE, ONE_DEC_UNIT);
       publish_1_reg_sensor_state(this->phases_[0].current_sensor_, RTU_PHASE1_CURRENT, ONE_DEC_UNIT);
-      publish_2_reg_sensor_state(this->phases_[0].active_power_sensor_, RTU_PHASE1_ACTIVE_POWER, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->phases_[0].active_power_sensor_, RTU_PHASE1_ACTIVE_POWER,
+                                 RTU_PHASE1_ACTIVE_POWER + 1, ONE_DEC_UNIT);
 
       publish_1_reg_sensor_state(this->phases_[1].voltage_sensor_, RTU_PHASE2_VOLTAGE, ONE_DEC_UNIT);
       publish_1_reg_sensor_state(this->phases_[1].current_sensor_, RTU_PHASE2_CURRENT, ONE_DEC_UNIT);
-      publish_2_reg_sensor_state(this->phases_[1].active_power_sensor_, RTU_PHASE2_ACTIVE_POWER, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->phases_[1].active_power_sensor_, RTU_PHASE2_ACTIVE_POWER,
+                                 RTU_PHASE2_ACTIVE_POWER + 1, ONE_DEC_UNIT);
 
       publish_1_reg_sensor_state(this->phases_[2].voltage_sensor_, RTU_PHASE3_VOLTAGE, ONE_DEC_UNIT);
       publish_1_reg_sensor_state(this->phases_[2].current_sensor_, RTU_PHASE3_CURRENT, ONE_DEC_UNIT);
-      publish_2_reg_sensor_state(this->phases_[2].active_power_sensor_, RTU_PHASE3_ACTIVE_POWER, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->phases_[2].active_power_sensor_, RTU_PHASE3_ACTIVE_POWER,
+                                 RTU_PHASE3_ACTIVE_POWER + 1, ONE_DEC_UNIT);
 
-      publish_2_reg_sensor_state(this->today_production_, RTU_TODAY_PRODUCTION, ONE_DEC_UNIT);
-      publish_2_reg_sensor_state(this->total_energy_production_, RTU_TOTAL_ENERGY_PRODUCTION, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->today_production_, RTU_TODAY_PRODUCTION, RTU_TODAY_PRODUCTION + 1, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->total_energy_production_, RTU_TOTAL_ENERGY_PRODUCTION,
+                                 RTU_TOTAL_ENERGY_PRODUCTION + 1, ONE_DEC_UNIT);
 
       publish_1_reg_sensor_state(this->inverter_module_temp_, RTU_INVERTER_MODULE_TEMP, ONE_DEC_UNIT);
       break;
@@ -70,33 +107,42 @@ void GrowattSolar::on_read_input_registers(uint16_t start_address, std::span<con
     case RTU2: {
       publish_1_reg_sensor_state(this->inverter_status_, RTU2_INVERTER_STATUS, 1);
 
-      publish_2_reg_sensor_state(this->pv_active_power_sensor_, RTU2_PV_ACTIVE_POWER, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->pv_active_power_sensor_, RTU2_PV_ACTIVE_POWER, RTU2_PV_ACTIVE_POWER + 1,
+                                 ONE_DEC_UNIT);
 
       publish_1_reg_sensor_state(this->pvs_[0].voltage_sensor_, RTU2_PV1_VOLTAGE, ONE_DEC_UNIT);
       publish_1_reg_sensor_state(this->pvs_[0].current_sensor_, RTU2_PV1_CURRENT, ONE_DEC_UNIT);
-      publish_2_reg_sensor_state(this->pvs_[0].active_power_sensor_, RTU2_PV1_ACTIVE_POWER, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->pvs_[0].active_power_sensor_, RTU2_PV1_ACTIVE_POWER, RTU2_PV1_ACTIVE_POWER + 1,
+                                 ONE_DEC_UNIT);
 
       publish_1_reg_sensor_state(this->pvs_[1].voltage_sensor_, RTU2_PV2_VOLTAGE, ONE_DEC_UNIT);
       publish_1_reg_sensor_state(this->pvs_[1].current_sensor_, RTU2_PV2_CURRENT, ONE_DEC_UNIT);
-      publish_2_reg_sensor_state(this->pvs_[1].active_power_sensor_, RTU2_PV2_ACTIVE_POWER, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->pvs_[1].active_power_sensor_, RTU2_PV2_ACTIVE_POWER, RTU2_PV2_ACTIVE_POWER + 1,
+                                 ONE_DEC_UNIT);
 
-      publish_2_reg_sensor_state(this->grid_active_power_sensor_, RTU2_GRID_ACTIVE_POWER, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->grid_active_power_sensor_, RTU2_GRID_ACTIVE_POWER, RTU2_GRID_ACTIVE_POWER + 1,
+                                 ONE_DEC_UNIT);
       publish_1_reg_sensor_state(this->grid_frequency_sensor_, RTU2_GRID_FREQUENCY, TWO_DEC_UNIT);
 
       publish_1_reg_sensor_state(this->phases_[0].voltage_sensor_, RTU2_PHASE1_VOLTAGE, ONE_DEC_UNIT);
       publish_1_reg_sensor_state(this->phases_[0].current_sensor_, RTU2_PHASE1_CURRENT, ONE_DEC_UNIT);
-      publish_2_reg_sensor_state(this->phases_[0].active_power_sensor_, RTU2_PHASE1_ACTIVE_POWER, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->phases_[0].active_power_sensor_, RTU2_PHASE1_ACTIVE_POWER,
+                                 RTU2_PHASE1_ACTIVE_POWER + 1, ONE_DEC_UNIT);
 
       publish_1_reg_sensor_state(this->phases_[1].voltage_sensor_, RTU2_PHASE2_VOLTAGE, ONE_DEC_UNIT);
       publish_1_reg_sensor_state(this->phases_[1].current_sensor_, RTU2_PHASE2_CURRENT, ONE_DEC_UNIT);
-      publish_2_reg_sensor_state(this->phases_[1].active_power_sensor_, RTU2_PHASE2_ACTIVE_POWER, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->phases_[1].active_power_sensor_, RTU2_PHASE2_ACTIVE_POWER,
+                                 RTU2_PHASE2_ACTIVE_POWER + 1, ONE_DEC_UNIT);
 
       publish_1_reg_sensor_state(this->phases_[2].voltage_sensor_, RTU2_PHASE3_VOLTAGE, ONE_DEC_UNIT);
       publish_1_reg_sensor_state(this->phases_[2].current_sensor_, RTU2_PHASE3_CURRENT, ONE_DEC_UNIT);
-      publish_2_reg_sensor_state(this->phases_[2].active_power_sensor_, RTU2_PHASE3_ACTIVE_POWER, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->phases_[2].active_power_sensor_, RTU2_PHASE3_ACTIVE_POWER,
+                                 RTU2_PHASE3_ACTIVE_POWER + 1, ONE_DEC_UNIT);
 
-      publish_2_reg_sensor_state(this->today_production_, RTU2_TODAY_PRODUCTION, ONE_DEC_UNIT);
-      publish_2_reg_sensor_state(this->total_energy_production_, RTU2_TOTAL_ENERGY_PRODUCTION, ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->today_production_, RTU2_TODAY_PRODUCTION, RTU2_TODAY_PRODUCTION + 1,
+                                 ONE_DEC_UNIT);
+      publish_2_reg_sensor_state(this->total_energy_production_, RTU2_TOTAL_ENERGY_PRODUCTION,
+                                 RTU2_TOTAL_ENERGY_PRODUCTION + 1, ONE_DEC_UNIT);
 
       publish_1_reg_sensor_state(this->inverter_module_temp_, RTU2_INVERTER_MODULE_TEMP, ONE_DEC_UNIT);
       break;

esphome/components/growatt_solar/growatt_solar.h

@@ -17,59 +17,59 @@ enum GrowattProtocolVersion {
 };
 
 // Register addresses for the RTU protocol.
-constexpr uint16_t RTU_INVERTER_STATUS = 0;           // length = 1
-constexpr uint16_t RTU_PV_ACTIVE_POWER = 1;           // length = 2
-constexpr uint16_t RTU_PV1_VOLTAGE = 3;               // length = 1
-constexpr uint16_t RTU_PV1_CURRENT = 4;               // length = 1
-constexpr uint16_t RTU_PV1_ACTIVE_POWER = 5;          // length = 2
-constexpr uint16_t RTU_PV2_VOLTAGE = 7;               // length = 1
-constexpr uint16_t RTU_PV2_CURRENT = 8;               // length = 1
-constexpr uint16_t RTU_PV2_ACTIVE_POWER = 9;          // length = 2
-constexpr uint16_t RTU_GRID_ACTIVE_POWER = 11;        // length = 2
-constexpr uint16_t RTU_GRID_FREQUENCY = 13;           // length = 1
-constexpr uint16_t RTU_PHASE1_VOLTAGE = 14;           // length = 1
-constexpr uint16_t RTU_PHASE1_CURRENT = 15;           // length = 1
-constexpr uint16_t RTU_PHASE1_ACTIVE_POWER = 16;      // length = 2
-constexpr uint16_t RTU_PHASE2_VOLTAGE = 18;           // length = 1
-constexpr uint16_t RTU_PHASE2_CURRENT = 19;           // length = 1
-constexpr uint16_t RTU_PHASE2_ACTIVE_POWER = 20;      // length = 2
-constexpr uint16_t RTU_PHASE3_VOLTAGE = 22;           // length = 1
-constexpr uint16_t RTU_PHASE3_CURRENT = 23;           // length = 1
-constexpr uint16_t RTU_PHASE3_ACTIVE_POWER = 24;      // length = 2
-constexpr uint16_t RTU_TODAY_PRODUCTION = 26;         // length = 2
-constexpr uint16_t RTU_TOTAL_ENERGY_PRODUCTION = 28;  // length = 2
-constexpr uint16_t RTU_INVERTER_MODULE_TEMP = 32;     // length = 1
+constexpr size_t RTU_INVERTER_STATUS = 0;           // length = 1
+constexpr size_t RTU_PV_ACTIVE_POWER = 1;           // length = 2
+constexpr size_t RTU_PV1_VOLTAGE = 3;               // length = 1
+constexpr size_t RTU_PV1_CURRENT = 4;               // length = 1
+constexpr size_t RTU_PV1_ACTIVE_POWER = 5;          // length = 2
+constexpr size_t RTU_PV2_VOLTAGE = 7;               // length = 1
+constexpr size_t RTU_PV2_CURRENT = 8;               // length = 1
+constexpr size_t RTU_PV2_ACTIVE_POWER = 9;          // length = 2
+constexpr size_t RTU_GRID_ACTIVE_POWER = 11;        // length = 2
+constexpr size_t RTU_GRID_FREQUENCY = 13;           // length = 1
+constexpr size_t RTU_PHASE1_VOLTAGE = 14;           // length = 1
+constexpr size_t RTU_PHASE1_CURRENT = 15;           // length = 1
+constexpr size_t RTU_PHASE1_ACTIVE_POWER = 16;      // length = 2
+constexpr size_t RTU_PHASE2_VOLTAGE = 18;           // length = 1
+constexpr size_t RTU_PHASE2_CURRENT = 19;           // length = 1
+constexpr size_t RTU_PHASE2_ACTIVE_POWER = 20;      // length = 2
+constexpr size_t RTU_PHASE3_VOLTAGE = 22;           // length = 1
+constexpr size_t RTU_PHASE3_CURRENT = 23;           // length = 1
+constexpr size_t RTU_PHASE3_ACTIVE_POWER = 24;      // length = 2
+constexpr size_t RTU_TODAY_PRODUCTION = 26;         // length = 2
+constexpr size_t RTU_TOTAL_ENERGY_PRODUCTION = 28;  // length = 2
+constexpr size_t RTU_INVERTER_MODULE_TEMP = 32;     // length = 1
 
 // Input register addresses for the RTU2 protocol as described
 // in the "GROWATT INVERTER MODBUS PROTOCOL_II V1.39" document.
-constexpr uint16_t RTU2_INVERTER_STATUS = 0;           // length = 1
-constexpr uint16_t RTU2_PV_ACTIVE_POWER = 1;           // length = 2
-constexpr uint16_t RTU2_PV1_VOLTAGE = 3;               // length = 1
-constexpr uint16_t RTU2_PV1_CURRENT = 4;               // length = 1
-constexpr uint16_t RTU2_PV1_ACTIVE_POWER = 5;          // length = 2
-constexpr uint16_t RTU2_PV2_VOLTAGE = 7;               // length = 1
-constexpr uint16_t RTU2_PV2_CURRENT = 8;               // length = 1
-constexpr uint16_t RTU2_PV2_ACTIVE_POWER = 9;          // length = 2
-constexpr uint16_t RTU2_GRID_ACTIVE_POWER = 35;        // length = 2
-constexpr uint16_t RTU2_GRID_FREQUENCY = 37;           // length = 1
-constexpr uint16_t RTU2_PHASE1_VOLTAGE = 38;           // length = 1
-constexpr uint16_t RTU2_PHASE1_CURRENT = 39;           // length = 1
-constexpr uint16_t RTU2_PHASE1_ACTIVE_POWER = 40;      // length = 2
-constexpr uint16_t RTU2_PHASE2_VOLTAGE = 42;           // length = 1
-constexpr uint16_t RTU2_PHASE2_CURRENT = 43;           // length = 1
-constexpr uint16_t RTU2_PHASE2_ACTIVE_POWER = 44;      // length = 2
-constexpr uint16_t RTU2_PHASE3_VOLTAGE = 46;           // length = 1
-constexpr uint16_t RTU2_PHASE3_CURRENT = 47;           // length = 1
-constexpr uint16_t RTU2_PHASE3_ACTIVE_POWER = 48;      // length = 2
-constexpr uint16_t RTU2_TODAY_PRODUCTION = 53;         // length = 2
-constexpr uint16_t RTU2_TOTAL_ENERGY_PRODUCTION = 55;  // length = 2
-constexpr uint16_t RTU2_INVERTER_MODULE_TEMP = 93;     // length = 1
+constexpr size_t RTU2_INVERTER_STATUS = 0;           // length = 1
+constexpr size_t RTU2_PV_ACTIVE_POWER = 1;           // length = 2
+constexpr size_t RTU2_PV1_VOLTAGE = 3;               // length = 1
+constexpr size_t RTU2_PV1_CURRENT = 4;               // length = 1
+constexpr size_t RTU2_PV1_ACTIVE_POWER = 5;          // length = 2
+constexpr size_t RTU2_PV2_VOLTAGE = 7;               // length = 1
+constexpr size_t RTU2_PV2_CURRENT = 8;               // length = 1
+constexpr size_t RTU2_PV2_ACTIVE_POWER = 9;          // length = 2
+constexpr size_t RTU2_GRID_ACTIVE_POWER = 35;        // length = 2
+constexpr size_t RTU2_GRID_FREQUENCY = 37;           // length = 1
+constexpr size_t RTU2_PHASE1_VOLTAGE = 38;           // length = 1
+constexpr size_t RTU2_PHASE1_CURRENT = 39;           // length = 1
+constexpr size_t RTU2_PHASE1_ACTIVE_POWER = 40;      // length = 2
+constexpr size_t RTU2_PHASE2_VOLTAGE = 42;           // length = 1
+constexpr size_t RTU2_PHASE2_CURRENT = 43;           // length = 1
+constexpr size_t RTU2_PHASE2_ACTIVE_POWER = 44;      // length = 2
+constexpr size_t RTU2_PHASE3_VOLTAGE = 46;           // length = 1
+constexpr size_t RTU2_PHASE3_CURRENT = 47;           // length = 1
+constexpr size_t RTU2_PHASE3_ACTIVE_POWER = 48;      // length = 2
+constexpr size_t RTU2_TODAY_PRODUCTION = 53;         // length = 2
+constexpr size_t RTU2_TOTAL_ENERGY_PRODUCTION = 55;  // length = 2
+constexpr size_t RTU2_INVERTER_MODULE_TEMP = 93;     // length = 1
 
 class GrowattSolar final : public PollingComponent, public modbus::ModbusClientDevice {
  public:
+  void loop() override;
   void update() override;
-  void on_read_input_registers(uint16_t start_address, std::span<const uint16_t> registers,
-                               modbus::ResponseStatus status) override;
+  void on_response(std::span<const uint8_t> request_pdu, std::span<const uint8_t> response_pdu) override;
   void dump_config() override;
 
   void set_protocol_version(GrowattProtocolVersion protocol_version) { this->protocol_version_ = protocol_version; }
@@ -104,6 +104,9 @@ class GrowattSolar final : public PollingComponent, public modbus::ModbusClientD
   }
 
  protected:
+  bool waiting_to_update_{false};
+  uint32_t last_send_{0};
+
   struct GrowattPhase {
     sensor::Sensor *voltage_sensor_{nullptr};
     sensor::Sensor *current_sensor_{nullptr};

esphome/components/havells_solar/havells_solar.cpp

@@ -1,71 +1,124 @@
 #include "havells_solar.h"
 #include "havells_solar_registers.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome::havells_solar {
 
-namespace helpers = modbus::helpers;
-
 static const char *const TAG = "havells_solar";
 
 static const uint8_t MODBUS_REGISTER_COUNT = 48;  // 48 x 16-bit registers
 
-void HavellsSolar::on_read_holding_registers(uint16_t start_address, std::span<const uint16_t> registers,
-                                             modbus::ResponseStatus status) {
-  if (!modbus::succeeded(status))
-    return;  // the hub already logs exception responses
+void HavellsSolar::on_response(std::span<const uint8_t> request_pdu, std::span<const uint8_t> response_pdu) {
+  auto data = modbus::helpers::server_pdu_payload(response_pdu);
+  if (data.size() < MODBUS_REGISTER_COUNT * 2) {
+    ESP_LOGW(TAG, "Invalid size for HavellsSolar!");
+    return;
+  }
 
-  // Publish a sensor if its register(s) are in this response; skipping absent registers keeps this
-  // correct for any read range, so the poll may be split into multiple requests.
-  auto publish_1_register = [&](sensor::Sensor *sensor, uint16_t reg, float unit) -> void {
-    if (sensor == nullptr)
-      return;
-    if (auto value = helpers::value_at<helpers::SensorValueType::U_WORD>(registers, start_address, reg))
-      sensor->publish_state(*value * unit);
+  /* Usage: returns the float value of 1 register read by modbus
+            Arg1: Register address * number of bytes per register
+            Arg2: Multiplier for final register value
+  */
+  auto havells_solar_get_2_registers = [&](size_t i, float unit) -> float {
+    uint32_t temp = encode_uint32(data[i], data[i + 1], data[i + 2], data[i + 3]);
+    return temp * unit;
   };
 
-  auto publish_2_registers = [&](sensor::Sensor *sensor, uint16_t reg, float unit) -> void {
-    if (sensor == nullptr)
-      return;
-    if (auto value = helpers::value_at<helpers::SensorValueType::U_DWORD>(registers, start_address, reg))
-      sensor->publish_state(*value * unit);
+  /* Usage: returns the float value of 2 registers read by modbus
+            Arg1: Register address * number of bytes per register
+            Arg2: Multiplier for final register value
+  */
+  auto havells_solar_get_1_register = [&](size_t i, float unit) -> float {
+    uint16_t temp = encode_uint16(data[i], data[i + 1]);
+    return temp * unit;
   };
 
   for (uint8_t i = 0; i < 3; i++) {
-    auto &phase = this->phases_[i];
+    auto phase = this->phases_[i];
     if (!phase.setup)
       continue;
-    publish_1_register(phase.voltage_sensor_, HAVELLS_PHASE_1_VOLTAGE + i * 2, ONE_DEC_UNIT);
-    publish_1_register(phase.current_sensor_, HAVELLS_PHASE_1_CURRENT + i * 2, TWO_DEC_UNIT);
+
+    float voltage = havells_solar_get_1_register(HAVELLS_PHASE_1_VOLTAGE * 2 + (i * 4), ONE_DEC_UNIT);
+    float current = havells_solar_get_1_register(HAVELLS_PHASE_1_CURRENT * 2 + (i * 4), TWO_DEC_UNIT);
+
+    if (phase.voltage_sensor_ != nullptr)
+      phase.voltage_sensor_->publish_state(voltage);
+    if (phase.current_sensor_ != nullptr)
+      phase.current_sensor_->publish_state(current);
   }
 
   for (uint8_t i = 0; i < 2; i++) {
-    auto &pv = this->pvs_[i];
+    auto pv = this->pvs_[i];
     if (!pv.setup)
       continue;
-    publish_1_register(pv.voltage_sensor_, HAVELLS_PV_1_VOLTAGE + i * 2, ONE_DEC_UNIT);
-    publish_1_register(pv.current_sensor_, HAVELLS_PV_1_CURRENT + i * 2, TWO_DEC_UNIT);
-    publish_1_register(pv.active_power_sensor_, HAVELLS_PV_1_POWER + i, MULTIPLY_TEN_UNIT);
-    publish_1_register(pv.voltage_sampled_by_secondary_cpu_sensor_, HAVELLS_PV1_VOLTAGE_SAMPLED_BY_SECONDARY_CPU + i,
-                       ONE_DEC_UNIT);
-    publish_1_register(pv.insulation_of_p_to_ground_sensor_, HAVELLS_PV1_INSULATION_OF_P_TO_GROUND + i, NO_DEC_UNIT);
+
+    float voltage = havells_solar_get_1_register(HAVELLS_PV_1_VOLTAGE * 2 + (i * 4), ONE_DEC_UNIT);
+    float current = havells_solar_get_1_register(HAVELLS_PV_1_CURRENT * 2 + (i * 4), TWO_DEC_UNIT);
+    float active_power = havells_solar_get_1_register(HAVELLS_PV_1_POWER * 2 + (i * 2), MULTIPLY_TEN_UNIT);
+    float voltage_sampled_by_secondary_cpu =
+        havells_solar_get_1_register(HAVELLS_PV1_VOLTAGE_SAMPLED_BY_SECONDARY_CPU * 2 + (i * 2), ONE_DEC_UNIT);
+    float insulation_of_p_to_ground =
+        havells_solar_get_1_register(HAVELLS_PV1_INSULATION_OF_P_TO_GROUND * 2 + (i * 2), NO_DEC_UNIT);
+
+    if (pv.voltage_sensor_ != nullptr)
+      pv.voltage_sensor_->publish_state(voltage);
+    if (pv.current_sensor_ != nullptr)
+      pv.current_sensor_->publish_state(current);
+    if (pv.active_power_sensor_ != nullptr)
+      pv.active_power_sensor_->publish_state(active_power);
+    if (pv.voltage_sampled_by_secondary_cpu_sensor_ != nullptr)
+      pv.voltage_sampled_by_secondary_cpu_sensor_->publish_state(voltage_sampled_by_secondary_cpu);
+    if (pv.insulation_of_p_to_ground_sensor_ != nullptr)
+      pv.insulation_of_p_to_ground_sensor_->publish_state(insulation_of_p_to_ground);
   }
 
-  publish_1_register(this->frequency_sensor_, HAVELLS_GRID_FREQUENCY, TWO_DEC_UNIT);
-  publish_1_register(this->active_power_sensor_, HAVELLS_SYSTEM_ACTIVE_POWER, MULTIPLY_TEN_UNIT);
-  publish_1_register(this->reactive_power_sensor_, HAVELLS_SYSTEM_REACTIVE_POWER, TWO_DEC_UNIT);
-  publish_1_register(this->today_production_sensor_, HAVELLS_TODAY_PRODUCTION, TWO_DEC_UNIT);
-  publish_2_registers(this->total_energy_production_sensor_, HAVELLS_TOTAL_ENERGY_PRODUCTION, NO_DEC_UNIT);
-  publish_2_registers(this->total_generation_time_sensor_, HAVELLS_TOTAL_GENERATION_TIME, NO_DEC_UNIT);
-  publish_1_register(this->today_generation_time_sensor_, HAVELLS_TODAY_GENERATION_TIME, NO_DEC_UNIT);
-  publish_1_register(this->inverter_module_temp_sensor_, HAVELLS_INVERTER_MODULE_TEMP, NO_DEC_UNIT);
-  publish_1_register(this->inverter_inner_temp_sensor_, HAVELLS_INVERTER_INNER_TEMP, NO_DEC_UNIT);
-  publish_1_register(this->inverter_bus_voltage_sensor_, HAVELLS_INVERTER_BUS_VOLTAGE, NO_DEC_UNIT);
-  publish_1_register(this->insulation_pv_n_to_ground_sensor_, HAVELLS_INSULATION_OF_PV_N_TO_GROUND, NO_DEC_UNIT);
-  publish_1_register(this->gfci_value_sensor_, HAVELLS_GFCI_VALUE, NO_DEC_UNIT);
-  publish_1_register(this->dci_of_r_sensor_, HAVELLS_DCI_OF_R, NO_DEC_UNIT);
-  publish_1_register(this->dci_of_s_sensor_, HAVELLS_DCI_OF_S, NO_DEC_UNIT);
-  publish_1_register(this->dci_of_t_sensor_, HAVELLS_DCI_OF_T, NO_DEC_UNIT);
+  float frequency = havells_solar_get_1_register(HAVELLS_GRID_FREQUENCY * 2, TWO_DEC_UNIT);
+  float active_power = havells_solar_get_1_register(HAVELLS_SYSTEM_ACTIVE_POWER * 2, MULTIPLY_TEN_UNIT);
+  float reactive_power = havells_solar_get_1_register(HAVELLS_SYSTEM_REACTIVE_POWER * 2, TWO_DEC_UNIT);
+  float today_production = havells_solar_get_1_register(HAVELLS_TODAY_PRODUCTION * 2, TWO_DEC_UNIT);
+  float total_energy_production = havells_solar_get_2_registers(HAVELLS_TOTAL_ENERGY_PRODUCTION * 2, NO_DEC_UNIT);
+  float total_generation_time = havells_solar_get_2_registers(HAVELLS_TOTAL_GENERATION_TIME * 2, NO_DEC_UNIT);
+  float today_generation_time = havells_solar_get_1_register(HAVELLS_TODAY_GENERATION_TIME * 2, NO_DEC_UNIT);
+  float inverter_module_temp = havells_solar_get_1_register(HAVELLS_INVERTER_MODULE_TEMP * 2, NO_DEC_UNIT);
+  float inverter_inner_temp = havells_solar_get_1_register(HAVELLS_INVERTER_INNER_TEMP * 2, NO_DEC_UNIT);
+  float inverter_bus_voltage = havells_solar_get_1_register(HAVELLS_INVERTER_BUS_VOLTAGE * 2, NO_DEC_UNIT);
+  float insulation_pv_n_to_ground = havells_solar_get_1_register(HAVELLS_INSULATION_OF_PV_N_TO_GROUND * 2, NO_DEC_UNIT);
+  float gfci_value = havells_solar_get_1_register(HAVELLS_GFCI_VALUE * 2, NO_DEC_UNIT);
+  float dci_of_r = havells_solar_get_1_register(HAVELLS_DCI_OF_R * 2, NO_DEC_UNIT);
+  float dci_of_s = havells_solar_get_1_register(HAVELLS_DCI_OF_S * 2, NO_DEC_UNIT);
+  float dci_of_t = havells_solar_get_1_register(HAVELLS_DCI_OF_T * 2, NO_DEC_UNIT);
+
+  if (this->frequency_sensor_ != nullptr)
+    this->frequency_sensor_->publish_state(frequency);
+  if (this->active_power_sensor_ != nullptr)
+    this->active_power_sensor_->publish_state(active_power);
+  if (this->reactive_power_sensor_ != nullptr)
+    this->reactive_power_sensor_->publish_state(reactive_power);
+  if (this->today_production_sensor_ != nullptr)
+    this->today_production_sensor_->publish_state(today_production);
+  if (this->total_energy_production_sensor_ != nullptr)
+    this->total_energy_production_sensor_->publish_state(total_energy_production);
+  if (this->total_generation_time_sensor_ != nullptr)
+    this->total_generation_time_sensor_->publish_state(total_generation_time);
+  if (this->today_generation_time_sensor_ != nullptr)
+    this->today_generation_time_sensor_->publish_state(today_generation_time);
+  if (this->inverter_module_temp_sensor_ != nullptr)
+    this->inverter_module_temp_sensor_->publish_state(inverter_module_temp);
+  if (this->inverter_inner_temp_sensor_ != nullptr)
+    this->inverter_inner_temp_sensor_->publish_state(inverter_inner_temp);
+  if (this->inverter_bus_voltage_sensor_ != nullptr)
+    this->inverter_bus_voltage_sensor_->publish_state(inverter_bus_voltage);
+  if (this->insulation_pv_n_to_ground_sensor_ != nullptr)
+    this->insulation_pv_n_to_ground_sensor_->publish_state(insulation_pv_n_to_ground);
+  if (this->gfci_value_sensor_ != nullptr)
+    this->gfci_value_sensor_->publish_state(gfci_value);
+  if (this->dci_of_r_sensor_ != nullptr)
+    this->dci_of_r_sensor_->publish_state(dci_of_r);
+  if (this->dci_of_s_sensor_ != nullptr)
+    this->dci_of_s_sensor_->publish_state(dci_of_s);
+  if (this->dci_of_t_sensor_ != nullptr)
+    this->dci_of_t_sensor_->publish_state(dci_of_t);
 }
 
 void HavellsSolar::update() { this->read_holding_registers(0, MODBUS_REGISTER_COUNT); }

esphome/components/havells_solar/havells_solar.h

@@ -77,8 +77,7 @@ class HavellsSolar final : public PollingComponent, public modbus::ModbusClientD
 
   void update() override;
 
-  void on_read_holding_registers(uint16_t start_address, std::span<const uint16_t> registers,
-                                 modbus::ResponseStatus status) override;
+  void on_response(std::span<const uint8_t> request_pdu, std::span<const uint8_t> response_pdu) override;
 
   void dump_config() override;
 

esphome/components/hoermann_hcp/button/__init__.py

@@ -1,43 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import button
-import esphome.config_validation as cv
-from esphome.const import ICON_AIR_FILTER
-from esphome.types import ConfigType
-
-from .. import CONF_HOERMANN_HCP_ID, HoermannHcp, hoermann_hcp_ns
-
-DEPENDENCIES = ["hoermann_hcp"]
-
-CONF_HALF_OPEN = "half_open"
-CONF_VENT = "vent"
-
-ICON_GARAGE_OPEN_VARIANT = "mdi:garage-open-variant"
-
-HoermannHcpVentButton = hoermann_hcp_ns.class_("HoermannHcpVentButton", button.Button)
-HoermannHcpHalfOpenButton = hoermann_hcp_ns.class_(
-    "HoermannHcpHalfOpenButton", button.Button
-)
-
-BUTTON_KEYS = (CONF_VENT, CONF_HALF_OPEN)
-
-CONFIG_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(CONF_HOERMANN_HCP_ID): cv.use_id(HoermannHcp),
-            cv.Optional(CONF_VENT): button.button_schema(
-                HoermannHcpVentButton, icon=ICON_AIR_FILTER
-            ),
-            cv.Optional(CONF_HALF_OPEN): button.button_schema(
-                HoermannHcpHalfOpenButton, icon=ICON_GARAGE_OPEN_VARIANT
-            ),
-        }
-    ),
-    cv.has_at_least_one_key(*BUTTON_KEYS),
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    parent = await cg.get_variable(config[CONF_HOERMANN_HCP_ID])
-    for key in BUTTON_KEYS:
-        if (conf := config.get(key)) is not None:
-            await button.new_button(conf, parent)

esphome/components/hoermann_hcp/button/hoermann_hcp_button.h

@@ -1,34 +0,0 @@
-#pragma once
-
-#include "esphome/components/button/button.h"
-#include "../hoermann_hcp.h"
-
-namespace esphome::hoermann_hcp {
-
-// The door commands the cover has no equivalent for. A refused command is already reported by the hub and
-// leaves nothing to correct here, because a button carries no state of its own.
-class HoermannHcpButton : public button::Button {
- public:
-  explicit HoermannHcpButton(HoermannHcp *parent) : parent_(parent) {}
-
- protected:
-  HoermannHcp *const parent_;
-};
-
-class HoermannHcpVentButton final : public HoermannHcpButton {
- public:
-  using HoermannHcpButton::HoermannHcpButton;
-
- protected:
-  void press_action() override { this->parent_->vent_door(); }
-};
-
-class HoermannHcpHalfOpenButton final : public HoermannHcpButton {
- public:
-  using HoermannHcpButton::HoermannHcpButton;
-
- protected:
-  void press_action() override { this->parent_->half_open_door(); }
-};
-
-}  // namespace esphome::hoermann_hcp

esphome/components/hoermann_hcp/hoermann_hcp.cpp

@@ -22,9 +22,6 @@ static constexpr uint8_t MAX_LIGHT_TOGGLES_IN_FLIGHT = 4;
 static constexpr HoermannHcpCommand COMMAND_OPEN{"open", 0x0210, 0x0110};
 static constexpr HoermannHcpCommand COMMAND_CLOSE{"close", 0x0220, 0x0120};
 static constexpr HoermannHcpCommand COMMAND_IMPULSE{"impulse", 0x0240, 0x0140};
-// The intermediate positions are named in the second register, so the first only carries the phase.
-static constexpr HoermannHcpCommand COMMAND_VENT{"vent", 0x0200, 0x0100, 0x4000, 0x4000};
-static constexpr HoermannHcpCommand COMMAND_HALF_OPEN{"half open", 0x0200, 0x0100, 0x0400, 0x0400};
 // The lamp is named in the second register, but its phase bytes follow no scheme the door commands share.
 static constexpr HoermannHcpCommand COMMAND_TOGGLE_LAMP{"toggle light", 0x0100, 0x0800, 0x0200, 0x0200, false};
 
@@ -289,8 +286,6 @@ bool HoermannHcp::queue_command_(const HoermannHcpCommand &command) {
 bool HoermannHcp::open_door() { return this->queue_command_(COMMAND_OPEN); }
 bool HoermannHcp::close_door() { return this->queue_command_(COMMAND_CLOSE); }
 bool HoermannHcp::impulse_door() { return this->queue_command_(COMMAND_IMPULSE); }
-bool HoermannHcp::vent_door() { return this->queue_command_(COMMAND_VENT); }
-bool HoermannHcp::half_open_door() { return this->queue_command_(COMMAND_HALF_OPEN); }
 bool HoermannHcp::toggle_light() {
   if (this->light_toggles_in_flight_ >= MAX_LIGHT_TOGGLES_IN_FLIGHT) {
     ESP_LOGW(TAG, "Too many lamp toggles are still waiting to be confirmed, dropping this one");

esphome/components/hoermann_hcp/hoermann_hcp.h

@@ -22,8 +22,7 @@ enum class DoorState : uint8_t {
 };
 
 // A HCP command is a simulated key press: the pressed value is presented to the bus controller, then after a
-// short delay the released value. Each half also carries a second register, which names the buttons that do
-// not fit into the first.
+// short delay the released value. Each half also carries a second register, which only the lamp command uses.
 struct HoermannHcpCommand {
   const char *name;
   uint16_t pressed_value;
@@ -55,9 +54,6 @@ class HoermannHcp : public PollingComponent, public modbus::ModbusServerDevice {
   bool open_door();
   bool close_door();
   bool impulse_door();
-  // The door drives to these intermediate positions on its own, so neither takes a target to be stopped at.
-  bool vent_door();
-  bool half_open_door();
   bool stop_door();
   bool set_position(float position);
   bool toggle_light();

esphome/components/host/__init__.py

@@ -37,7 +37,6 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_MAC_ADDRESS, default="98:35:69:ab:f6:79"): cv.mac_address,
         }
     ),
-    cv.require_platformio_toolchain("host"),
     set_core_data,
 )
 
@@ -50,7 +49,6 @@ async def to_code(config: ConfigType) -> None:
     cg.add_define("USE_ESPHOME_HOST_MAC_ADDRESS", config[CONF_MAC_ADDRESS].parts)
     cg.add_build_flag("-std=gnu++20")
     cg.add_define("ESPHOME_BOARD", "host")
-    cg.add_define("ESPHOME_VARIANT", "HOST")
     cg.add_define(ThreadModel.MULTI_ATOMICS)
     cg.add_platformio_option("platform", "platformio/native")
     cg.add_platformio_option("lib_ldf_mode", "off")

esphome/components/http_request/__init__.py

@@ -17,14 +17,12 @@ from esphome.const import (
     CONF_TIMEOUT,
     CONF_URL,
     CONF_WATCHDOG_TIMEOUT,
-    PLATFORM_ESP32,
     PLATFORM_HOST,
     PlatformFramework,
     __version__,
 )
-from esphome.core import CORE, ID, Lambda, TimePeriodMilliseconds
+from esphome.core import CORE, ID, Lambda
 from esphome.cpp_generator import MockObj, TemplateArgsType
-import esphome.final_validate as fv
 from esphome.helpers import IS_MACOS
 from esphome.types import ConfigType
 
@@ -96,34 +94,6 @@ def validate_ssl_verification(config: ConfigType) -> ConfigType:
     return config
 
 
-# esp_http_client_open() runs DNS, TCP connect and the TLS handshake with no
-# watchdog feed in between; each can take up to `timeout` on ESP-IDF.
-WATCHDOG_TIMEOUT_MULTIPLIER = 3
-# Headroom over the exact worst case so a fully stalled open does not land on
-# the watchdog deadline.
-WATCHDOG_TIMEOUT_MARGIN_MS = 1000
-
-
-def default_watchdog_timeout(config: ConfigType) -> None:
-    """Arm the request watchdog on ESP32 when the user did not set it.
-
-    The default never goes below the platform task watchdog, so a user who
-    widened `esp32.watchdog_timeout` keeps that window during requests.
-    """
-    if not CORE.is_esp32 or CONF_WATCHDOG_TIMEOUT in config:
-        return
-    derived_ms = (
-        config[CONF_TIMEOUT].total_milliseconds * WATCHDOG_TIMEOUT_MULTIPLIER
-        + WATCHDOG_TIMEOUT_MARGIN_MS
-    )
-    platform_ms = fv.full_config.get()[PLATFORM_ESP32][
-        CONF_WATCHDOG_TIMEOUT
-    ].total_milliseconds
-    config[CONF_WATCHDOG_TIMEOUT] = TimePeriodMilliseconds(
-        milliseconds=max(derived_ms, platform_ms)
-    )
-
-
 def _declare_request_class(value: Any) -> ID:
     if CORE.is_host:
         return cv.declare_id(HttpRequestHost)(value)
@@ -183,8 +153,6 @@ CONFIG_SCHEMA = cv.All(
     validate_ssl_verification,
 )
 
-FINAL_VALIDATE_SCHEMA = default_watchdog_timeout
-
 
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])
@@ -202,7 +170,11 @@ async def to_code(config: ConfigType) -> None:
         cg.add(var.set_watchdog_timeout(timeout_ms))
 
     if CORE.is_esp32:
-        esp32.request_http_client()
+        # Re-enable ESP-IDF's HTTP client (excluded by default to save compile time).
+        # esp-tls is re-enabled too because http_request includes <esp_tls.h>
+        # directly and esp_http_client only pulls it in as a private dependency.
+        esp32.include_builtin_idf_component("esp_http_client")
+        esp32.include_builtin_idf_component("esp-tls")
 
         cg.add(var.set_buffer_size_rx(config[CONF_BUFFER_SIZE_RX]))
         cg.add(var.set_buffer_size_tx(config[CONF_BUFFER_SIZE_TX]))
@@ -224,7 +196,9 @@ async def to_code(config: ConfigType) -> None:
                 #     framework:
                 #       advanced:
                 #         use_full_certificate_bundle: true
-                esp32.require_certificate_bundle()
+                esp32.add_idf_sdkconfig_option(
+                    "CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", True
+                )
 
         esp32.add_idf_sdkconfig_option(
             "CONFIG_ESP_TLS_INSECURE",

esphome/components/http_request/http_request_idf.cpp

@@ -142,13 +142,12 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
     const char *buf = body.c_str();
     while (write_left > 0) {
       int written = esp_http_client_write(client, buf + write_index, write_left);
-      if (written <= 0) {
+      if (written < 0) {
         err = ESP_FAIL;
         break;
       }
       write_left -= written;
       write_index += written;
-      container->feed_wdt();
     }
   }
 

esphome/components/improv_base/__init__.py

@@ -43,4 +43,4 @@ async def setup_improv_core(var: MockObj, config: ConfigType, component: str) ->
         cg.add(var.set_next_url(_process_next_url(next_url)))
         cg.add_define(f"USE_{component.upper()}_NEXT_URL")
 
-    cg.add_library("improv/Improv", "1.2.7")
+    cg.add_library("improv/Improv", "1.2.6")

esphome/components/improv_base/improv_base.cpp

@@ -4,13 +4,10 @@
 #include "esphome/components/network/util.h"
 #include "esphome/core/application.h"
 #include "esphome/core/defines.h"
-#include "esphome/core/log.h"
 
 namespace esphome::improv_base {
 
 #if defined(USE_ESP32_IMPROV_NEXT_URL) || defined(USE_IMPROV_SERIAL_NEXT_URL)
-static const char *const TAG = "improv_base";
-
 static constexpr const char DEVICE_NAME_PLACEHOLDER[] = "{{device_name}}";
 static constexpr size_t DEVICE_NAME_PLACEHOLDER_LEN = sizeof(DEVICE_NAME_PLACEHOLDER) - 1;
 static constexpr const char IP_ADDRESS_PLACEHOLDER[] = "{{ip_address}}";
@@ -65,21 +62,6 @@ size_t ImprovBase::get_formatted_next_url_(char *buffer, size_t buffer_size) {
   *out = '\0';
   return out - buffer;
 }
-
-void ImprovBase::add_next_url_(improv::RpcResponseBuilder &builder, size_t max_len) {
-  // The builder rejects strings above 254 bytes, so anything longer than this
-  // buffer could never be sent anyway
-  char url_buffer[256];
-  size_t len = this->get_formatted_next_url_(url_buffer, sizeof(url_buffer));
-  if (len == 0) {
-    return;
-  }
-  // max_len is the transport's budget for this entry; skipping an over-long URL
-  // here keeps the rest of the response sendable instead of oversizing the frame
-  if (len > max_len || !builder.add_string(url_buffer, len)) {
-    ESP_LOGW(TAG, "Next URL too long; skipping");
-  }
-}
 #endif
 
 }  // namespace esphome::improv_base

esphome/components/improv_base/improv_base.h

@@ -3,10 +3,6 @@
 #include <cstddef>
 #include "esphome/core/defines.h"
 
-#if defined(USE_ESP32_IMPROV_NEXT_URL) || defined(USE_IMPROV_SERIAL_NEXT_URL)
-#include <improv.h>
-#endif
-
 namespace esphome::improv_base {
 
 class ImprovBase {
@@ -19,8 +15,6 @@ class ImprovBase {
 #if defined(USE_ESP32_IMPROV_NEXT_URL) || defined(USE_IMPROV_SERIAL_NEXT_URL)
   /// Format next_url_ into buffer, replacing placeholders. Returns length written.
   size_t get_formatted_next_url_(char *buffer, size_t buffer_size);
-  /// Append the formatted next_url to the RPC response, warning if it does not fit.
-  void add_next_url_(improv::RpcResponseBuilder &builder, size_t max_len);
   const char *next_url_{nullptr};
 #endif
 };

esphome/components/improv_serial/__init__.py

@@ -1,15 +1,9 @@
 import esphome.codegen as cg
-from esphome.components import improv_base, uart
+from esphome.components import improv_base
 from esphome.components.esp32 import VARIANT_ESP32S3, get_esp32_variant
 from esphome.components.logger import USB_CDC
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_BAUD_RATE,
-    CONF_HARDWARE_UART,
-    CONF_ID,
-    CONF_LOGGER,
-    CONF_UART_ID,
-)
+from esphome.const import CONF_BAUD_RATE, CONF_HARDWARE_UART, CONF_ID, CONF_LOGGER
 from esphome.core import CORE
 import esphome.final_validate as fv
 from esphome.types import ConfigType
@@ -23,35 +17,13 @@ improv_serial_ns = cg.esphome_ns.namespace("improv_serial")
 ImprovSerialComponent = improv_serial_ns.class_("ImprovSerialComponent", cg.Component)
 
 CONFIG_SCHEMA = (
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(ImprovSerialComponent),
-            # YAML only: rewiring Improv onto another UART is not a knob for a
-            # visual editor and the device builder must not expose it
-            cv.Optional(CONF_UART_ID, visibility=cv.Visibility.YAML_ONLY): cv.use_id(
-                uart.UARTComponent
-            ),
-        }
-    )
+    cv.Schema({cv.GenerateID(): cv.declare_id(ImprovSerialComponent)})
     .extend(improv_base.IMPROV_SCHEMA)
     .extend(cv.COMPONENT_SCHEMA)
 )
 
 
-_UART_FINAL_VALIDATE = uart.final_validate_device_schema(
-    "improv_serial", require_tx=True, require_rx=True
-)
-
-
-def validate_transport(config: ConfigType) -> None:
-    if CONF_UART_ID in config:
-        # A dedicated UART bus is used; the logger's serial settings are irrelevant,
-        # but the bus itself must be bidirectional and not claimed by another device
-        _UART_FINAL_VALIDATE(config)
-        return
-    # The host logger has no serial port for Improv to share
-    if CORE.is_host:
-        raise cv.Invalid("improv_serial on the host platform requires uart_id")
+def validate_logger(config: ConfigType) -> None:
     logger_conf = fv.full_config.get()[CONF_LOGGER]
     if logger_conf[CONF_BAUD_RATE] == 0:
         raise cv.Invalid("improv_serial requires the logger baud_rate to be not 0")
@@ -64,7 +36,7 @@ def validate_transport(config: ConfigType) -> None:
         )
 
 
-FINAL_VALIDATE_SCHEMA = validate_transport
+FINAL_VALIDATE_SCHEMA = validate_logger
 
 
 async def to_code(config: ConfigType) -> None:
@@ -72,6 +44,3 @@ async def to_code(config: ConfigType) -> None:
     await cg.register_component(var, config)
     await improv_base.setup_improv_core(var, config, "improv_serial")
     cg.add_define("USE_IMPROV_SERIAL")
-    if (uart_id := config.get(CONF_UART_ID)) is not None:
-        cg.add(var.set_uart(await cg.get_variable(uart_id)))
-        cg.add_define("USE_IMPROV_SERIAL_UART")

esphome/components/improv_serial/improv_serial_component.cpp

@@ -9,17 +9,13 @@
 #include "esphome/components/logger/logger.h"
 #include "esphome/components/wifi/scan_list.h"
 
-#include <array>
-
 namespace esphome::improv_serial {
 
 static const char *const TAG = "improv_serial";
 
 void ImprovSerialComponent::setup() {
   global_improv_serial_component = this;
-#ifdef USE_IMPROV_SERIAL_UART
-  // Transport is a dedicated UART bus set via set_uart() in generated code
-#elif defined(USE_ESP32)
+#ifdef USE_ESP32
   this->uart_num_ = logger::global_logger->get_uart_num();
   this->uart_selection_ = logger::global_logger->get_uart();
 #elif defined(USE_ARDUINO)
@@ -63,7 +59,8 @@ void ImprovSerialComponent::loop() {
       this->cancel_timeout("wifi-connect-timeout");
       this->set_state_(improv::STATE_PROVISIONED);
 
-      this->send_settings_response_(improv::WIFI_SETTINGS);
+      std::vector<uint8_t> url = this->build_rpc_settings_response_(improv::WIFI_SETTINGS);
+      this->send_response_(url);
     }
   }
 }
@@ -92,13 +89,7 @@ void ImprovSerialComponent::write_data_(const uint8_t *data, const size_t size)
   }
   this->tx_header_[TX_CHECKSUM_IDX] = checksum;
 
-#ifdef USE_IMPROV_SERIAL_UART
-  this->uart_->write_array(this->tx_header_, header_tx_len);
-  if (there_is_data) {
-    this->uart_->write_array(data, size);
-    this->uart_->write_array(&this->tx_header_[TX_CHECKSUM_IDX], 2);  // Footer: checksum and newline
-  }
-#elif defined(USE_ESP32)
+#ifdef USE_ESP32
   switch (this->uart_selection_) {
     case logger::UART_SELECTION_UART0:
     case logger::UART_SELECTION_UART1:
@@ -143,11 +134,16 @@ void ImprovSerialComponent::write_data_(const uint8_t *data, const size_t size)
 #endif
 }
 
-void ImprovSerialComponent::send_settings_response_(improv::Command command) {
-  std::array<uint8_t, improv::RPC_RESPONSE_MAX_SIZE> buf;
-  improv::RpcResponseBuilder builder(buf, command);
+std::vector<uint8_t> ImprovSerialComponent::build_rpc_settings_response_(improv::Command command) {
+  std::vector<std::string> urls;
 #ifdef USE_IMPROV_SERIAL_NEXT_URL
-  this->add_next_url_(builder, MAX_NEXT_URL_LEN);
+  {
+    char url_buffer[384];
+    size_t len = this->get_formatted_next_url_(url_buffer, sizeof(url_buffer));
+    if (len > 0) {
+      urls.emplace_back(url_buffer, len);
+    }
+  }
 #endif
 #ifdef USE_WEBSERVER
   for (auto &ip : wifi::global_wifi_component->wifi_sta_ip_addresses()) {
@@ -156,63 +152,25 @@ void ImprovSerialComponent::send_settings_response_(improv::Command command) {
       ip.str_to(ip_buf);
       // "http://" (7) + IP (40) + ":" (1) + port (5) + null (1) = 54
       char webserver_url[7 + network::IP_ADDRESS_BUFFER_SIZE + 1 + 5 + 1];
-      // buf_append_printf keeps the format string in flash on ESP8266
-      size_t len =
-          buf_append_printf(webserver_url, sizeof(webserver_url), 0, "http://%s:%u", ip_buf, USE_WEBSERVER_PORT);
-      if (!builder.add_string(webserver_url, len)) {
-        ESP_LOGW(TAG, "Response full; URL dropped");
-      }
+      snprintf(webserver_url, sizeof(webserver_url), "http://%s:%u", ip_buf, USE_WEBSERVER_PORT);
+      urls.emplace_back(webserver_url);
       break;
     }
   }
 #endif
-  this->send_response_(builder.finish(false));
+  std::vector<uint8_t> data = improv::build_rpc_response(command, urls, false);
+  return data;
 }
 
-void ImprovSerialComponent::send_version_info_() {
-// Entry cost per field is sizeof(lit): a length byte plus the string
+std::vector<uint8_t> ImprovSerialComponent::build_version_info_() {
 #ifdef ESPHOME_PROJECT_NAME
-  static constexpr size_t INFO_ENTRIES_LEN =
-      sizeof(ESPHOME_PROJECT_NAME) + sizeof(ESPHOME_PROJECT_VERSION) + sizeof(ESPHOME_VARIANT);
+  std::vector<std::string> infos = {ESPHOME_PROJECT_NAME, ESPHOME_PROJECT_VERSION, ESPHOME_VARIANT, App.get_name()};
 #else
-  static constexpr size_t INFO_ENTRIES_LEN = sizeof("ESPHome") + sizeof(ESPHOME_VERSION) + sizeof(ESPHOME_VARIANT);
+  std::vector<std::string> infos = {"ESPHome", ESPHOME_VERSION, ESPHOME_VARIANT, App.get_name()};
 #endif
-  static_assert(INFO_ENTRIES_LEN < MAX_SERIAL_PAYLOAD,
-                "esphome project name and version too long for the improv_serial device info frame");
-  std::array<uint8_t, improv::RPC_RESPONSE_MAX_SIZE> buf;
-  improv::RpcResponseBuilder builder(buf, improv::GET_DEVICE_INFO);
-#ifdef USE_ESP8266
-  // Keep each literal in flash and copy it through an exact size stack buffer,
-  // so a long project name or version can never be truncated
-#define IMPROV_ADD_INFO(lit) \
-  do { \
-    static const char progmem_str[] PROGMEM = lit; \
-    char tmp[sizeof(lit)]; \
-    progmem_memcpy(tmp, progmem_str, sizeof(lit)); \
-    builder.add_string(tmp, sizeof(lit) - 1); \
-  } while (0)
-#else
-  // Literals are directly flash mapped on all other platforms
-#define IMPROV_ADD_INFO(lit) builder.add_string(lit, sizeof(lit) - 1)
-#endif
-#ifdef ESPHOME_PROJECT_NAME
-  IMPROV_ADD_INFO(ESPHOME_PROJECT_NAME);
-  IMPROV_ADD_INFO(ESPHOME_PROJECT_VERSION);
-#else
-  IMPROV_ADD_INFO("ESPHome");
-  IMPROV_ADD_INFO(ESPHOME_VERSION);
-#endif
-  IMPROV_ADD_INFO(ESPHOME_VARIANT);
-#undef IMPROV_ADD_INFO
-  // Only the device name length is unknown at compile time
-  const auto &name = App.get_name();
-  if (INFO_ENTRIES_LEN + 1 + name.size() <= MAX_SERIAL_PAYLOAD) {
-    builder.add_string(name.c_str(), name.size());
-  } else {
-    ESP_LOGW(TAG, "Response full; device name dropped");
-  }
-  this->send_response_(builder.finish(false));
-}
+  std::vector<uint8_t> data = improv::build_rpc_response(improv::GET_DEVICE_INFO, infos, false);
+  return data;
+};
 
 bool ImprovSerialComponent::parse_improv_serial_byte_(uint8_t byte) {
   size_t at = this->rx_buffer_.size();
@@ -263,35 +221,32 @@ bool ImprovSerialComponent::parse_improv_payload_(improv::ImprovCommand &command
       }
       this->set_state_(this->state_);
       if (this->state_ == improv::STATE_PROVISIONED) {
-        this->send_settings_response_(improv::GET_CURRENT_STATE);
+        std::vector<uint8_t> url = this->build_rpc_settings_response_(improv::GET_CURRENT_STATE);
+        this->send_response_(url);
       }
       return true;
     case improv::GET_DEVICE_INFO: {
-      this->send_version_info_();
+      std::vector<uint8_t> info = this->build_version_info_();
+      this->send_response_(info);
       return true;
     }
     case improv::GET_WIFI_NETWORKS: {
       const auto &results = wifi::global_wifi_component->get_scan_result();
-      std::array<uint8_t, improv::RPC_RESPONSE_MAX_SIZE> buf;
       for (const auto &scan : results) {
         bool with_auth = false;
         if (!wifi::should_show_scan_entry(results, scan, with_auth))
           continue;
         // Send each ssid separately to avoid overflowing the buffer
         char rssi_buf[5];  // int8_t: -128 to 127, max 4 chars + null
-        char *rssi_end = int8_to_str(rssi_buf, scan.get_rssi());
-        *rssi_end = '\0';
-        improv::RpcResponseBuilder builder(buf, improv::GET_WIFI_NETWORKS);
-        // SSID(32) + RSSI(4) + YESNO(3) entries always fit the payload
-        const auto &ssid = scan.get_ssid();
-        builder.add_string(ssid.c_str(), ssid.size());
-        builder.add_string(rssi_buf, rssi_end - rssi_buf);
-        builder.add_string(YESNO(with_auth));
-        this->send_response_(builder.finish(false));
+        *int8_to_str(rssi_buf, scan.get_rssi()) = '\0';
+        std::vector<uint8_t> data = improv::build_rpc_response(
+            improv::GET_WIFI_NETWORKS, {scan.get_ssid().str(), rssi_buf, YESNO(with_auth)}, false);
+        this->send_response_(data);
       }
       // Send empty response to signify the end of the list.
-      improv::RpcResponseBuilder builder(buf, improv::GET_WIFI_NETWORKS);
-      this->send_response_(builder.finish(false));
+      std::vector<uint8_t> data =
+          improv::build_rpc_response(improv::GET_WIFI_NETWORKS, std::vector<std::string>{}, false);
+      this->send_response_(data);
       return true;
     }
     default: {
@@ -319,14 +274,7 @@ void ImprovSerialComponent::set_error_(improv::Error error) {
   this->write_data_();
 }
 
-void ImprovSerialComponent::send_response_(std::span<const uint8_t> response) {
-  // The serial frame length field is a single byte
-  if (response.size() > MAX_SERIAL_RESPONSE) {
-    ESP_LOGE(TAG, "Response too long");
-    // Fail fast instead of leaving the client to wait out its timeout
-    this->set_error_(improv::ERROR_UNKNOWN);
-    return;
-  }
+void ImprovSerialComponent::send_response_(std::vector<uint8_t> &response) {
   this->tx_header_[TX_TYPE_IDX] = TYPE_RPC_RESPONSE;
   this->write_data_(response.data(), response.size());
 }

esphome/components/improv_serial/improv_serial_component.h

@@ -8,12 +8,9 @@
 #include "esphome/core/helpers.h"
 #ifdef USE_WIFI
 #include <improv.h>
-#include <span>
 #include <vector>
 
-#ifdef USE_IMPROV_SERIAL_UART
-#include "esphome/components/uart/uart_component.h"
-#elif defined(USE_ESP32)
+#ifdef USE_ESP32
 #include <driver/uart.h>
 #ifdef USE_LOGGER_USB_SERIAL_JTAG
 #include <driver/usb_serial_jtag.h>
@@ -48,22 +45,6 @@ enum ImprovSerialType : uint8_t {
 static const uint16_t IMPROV_SERIAL_TIMEOUT = 100;
 static const uint8_t IMPROV_SERIAL_VERSION = 1;
 
-// The serial frame length field is one byte
-static constexpr size_t MAX_SERIAL_RESPONSE = 255;
-// command + data length + trailing byte
-static constexpr size_t RPC_RESPONSE_OVERHEAD = 3;
-static constexpr size_t MAX_SERIAL_PAYLOAD = MAX_SERIAL_RESPONSE - RPC_RESPONSE_OVERHEAD;
-#ifdef USE_WEBSERVER
-// length byte + "http://" + IPv4 + ":" + port
-static constexpr size_t WEBSERVER_URL_RESERVE = 1 + 7 + 15 + 1 + 5;
-#else
-static constexpr size_t WEBSERVER_URL_RESERVE = 0;
-#endif
-// Entry budget minus its own length byte
-static constexpr size_t MAX_NEXT_URL_LEN = MAX_SERIAL_PAYLOAD - WEBSERVER_URL_RESERVE - 1;
-
-static_assert(MAX_SERIAL_RESPONSE <= improv::RPC_RESPONSE_MAX_SIZE, "builder buffer too small for the frame");
-
 class ImprovSerialComponent final : public Component, public improv_base::ImprovBase {
  public:
   void setup() override;
@@ -72,10 +53,6 @@ class ImprovSerialComponent final : public Component, public improv_base::Improv
 
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
 
-#ifdef USE_IMPROV_SERIAL_UART
-  void set_uart(uart::UARTComponent *uart) { this->uart_ = uart; }
-#endif
-
  protected:
   bool parse_improv_serial_byte_(uint8_t byte);
   bool parse_improv_payload_(improv::ImprovCommand &command);
@@ -83,20 +60,16 @@ class ImprovSerialComponent final : public Component, public improv_base::Improv
   void set_state_(improv::State state);
   void send_current_state_(improv::State state);
   void set_error_(improv::Error error);
-  void send_response_(std::span<const uint8_t> response);
+  void send_response_(std::vector<uint8_t> &response);
   void on_wifi_connect_timeout_();
 
-  void send_settings_response_(improv::Command command);
-  void send_version_info_();
+  std::vector<uint8_t> build_rpc_settings_response_(improv::Command command);
+  std::vector<uint8_t> build_version_info_();
 
   ESPHOME_ALWAYS_INLINE optional<uint8_t> read_byte_() {
     optional<uint8_t> byte;
     uint8_t data = 0;
-#ifdef USE_IMPROV_SERIAL_UART
-    if (this->uart_->available() && this->uart_->read_byte(&data)) {
-      byte = data;
-    }
-#elif defined(USE_ESP32)
+#ifdef USE_ESP32
     switch (this->uart_selection_) {
       case logger::UART_SELECTION_UART0:
       case logger::UART_SELECTION_UART1:
@@ -156,9 +129,7 @@ class ImprovSerialComponent final : public Component, public improv_base::Improv
       '\n',
   };
 
-#ifdef USE_IMPROV_SERIAL_UART
-  uart::UARTComponent *uart_{nullptr};
-#elif defined(USE_ESP32)
+#ifdef USE_ESP32
   uart_port_t uart_num_;
   logger::UARTSelection uart_selection_{logger::UART_SELECTION_UART0};
 #elif defined(USE_ARDUINO)

esphome/components/key_collector/key_collector.cpp

@@ -14,7 +14,6 @@ void KeyCollector::loop() {
 }
 
 void KeyCollector::dump_config() {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_CONFIG
   ESP_LOGCONFIG(TAG, "Key Collector:");
   if (this->min_length_ > 0)
     ESP_LOGCONFIG(TAG, "  min length: %d", this->min_length_);
@@ -36,7 +35,6 @@ void KeyCollector::dump_config() {
     ESP_LOGCONFIG(TAG, "  allowed keys '%s'", this->allowed_keys_.c_str());
   if (this->timeout_ > 0)
     ESP_LOGCONFIG(TAG, "  entry timeout: %0.1f", this->timeout_ / 1000.0);
-#endif
 }
 
 void KeyCollector::add_provider(key_provider::KeyProvider *provider) {

esphome/components/kuntze/kuntze.cpp

@@ -1,74 +1,87 @@
 #include "kuntze.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/application.h"
 
 namespace esphome::kuntze {
 
 static const char *const TAG = "kuntze";
 
-static constexpr uint16_t REGISTER_PH = 4136;
-static constexpr uint16_t REGISTER_TEMPERATURE = 4160;
-static constexpr uint16_t REGISTER_DIS1 = 4680;
-static constexpr uint16_t REGISTER_DIS2 = 6000;
-static constexpr uint16_t REGISTER_REDOX = 4688;
-static constexpr uint16_t REGISTER_EC = 4728;
-static constexpr uint16_t REGISTER_OCI = 5832;
-static constexpr uint16_t REGISTER[] = {REGISTER_PH,    REGISTER_TEMPERATURE, REGISTER_DIS1, REGISTER_DIS2,
-                                        REGISTER_REDOX, REGISTER_EC,          REGISTER_OCI};
+static const uint16_t REGISTER[] = {4136, 4160, 4680, 6000, 4688, 4728, 5832};
 
-void Kuntze::on_read_holding_registers(uint16_t start_address, std::span<const uint16_t> registers,
-                                       modbus::ResponseStatus status) {
-  if (!modbus::succeeded(status) || registers.size() < 2)
-    return;
+// Maximum bytes to log for Modbus responses (2 registers = 4, plus count = 5)
+static constexpr size_t KUNTZE_MAX_LOG_BYTES = 8;
 
-  // Each value is a register pair: the reading, then the number of decimal places in its low byte.
-  float value = registers[0];
-  for (uint16_t i = 0; i < (registers[1] & 0xFF); i++)
-    value /= 10.0f;
+void Kuntze::on_response(std::span<const uint8_t> request_pdu, std::span<const uint8_t> response_pdu) {
+  auto data = modbus::helpers::server_pdu_payload(response_pdu);
+  auto get_16bit = [&](int i) -> uint16_t { return (uint16_t(data[i * 2]) << 8) | uint16_t(data[i * 2 + 1]); };
 
-  switch (start_address) {
-    case REGISTER_PH:
+  this->waiting_ = false;
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+  char hex_buf[format_hex_pretty_size(KUNTZE_MAX_LOG_BYTES)];
+#endif
+  ESP_LOGV(TAG, "Data: %s", format_hex_pretty_to(hex_buf, data.data(), data.size()));
+
+  float value = (float) get_16bit(0);
+  for (int i = 0; i < data[3]; i++)
+    value /= 10.0;
+  switch (this->state_) {
+    case 1:
       ESP_LOGD(TAG, "pH=%.1f", value);
       if (this->ph_sensor_ != nullptr)
         this->ph_sensor_->publish_state(value);
       break;
-    case REGISTER_TEMPERATURE:
+    case 2:
       ESP_LOGD(TAG, "temperature=%.1f", value);
       if (this->temperature_sensor_ != nullptr)
         this->temperature_sensor_->publish_state(value);
       break;
-    case REGISTER_DIS1:
+    case 3:
       ESP_LOGD(TAG, "DIS1=%.1f", value);
       if (this->dis1_sensor_ != nullptr)
         this->dis1_sensor_->publish_state(value);
       break;
-    case REGISTER_DIS2:
+    case 4:
       ESP_LOGD(TAG, "DIS2=%.1f", value);
       if (this->dis2_sensor_ != nullptr)
         this->dis2_sensor_->publish_state(value);
       break;
-    case REGISTER_REDOX:
+    case 5:
       ESP_LOGD(TAG, "REDOX=%.1f", value);
       if (this->redox_sensor_ != nullptr)
         this->redox_sensor_->publish_state(value);
       break;
-    case REGISTER_EC:
+    case 6:
       ESP_LOGD(TAG, "EC=%.1f", value);
       if (this->ec_sensor_ != nullptr)
         this->ec_sensor_->publish_state(value);
       break;
-    case REGISTER_OCI:
+    case 7:
       ESP_LOGD(TAG, "OCI=%.1f", value);
       if (this->oci_sensor_ != nullptr)
         this->oci_sensor_->publish_state(value);
       break;
   }
+  if (++this->state_ > 7)
+    this->state_ = 0;
 }
 
-void Kuntze::update() {
-  for (uint16_t reg : REGISTER)
-    this->read_holding_registers(reg, 2);
+void Kuntze::loop() {
+  uint32_t now = App.get_loop_component_start_time();
+  // timeout after 15 seconds
+  if (this->waiting_ && (now - this->last_send_ > 15000)) {
+    ESP_LOGW(TAG, "timed out waiting for response");
+    this->waiting_ = false;
+  }
+  if (this->waiting_ || (this->state_ == 0))
+    return;
+  this->last_send_ = now;
+  this->read_holding_registers(REGISTER[this->state_ - 1], 2);
+  this->waiting_ = true;
 }
 
+void Kuntze::update() { this->state_ = 1; }
+
 void Kuntze::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "Kuntze:\n"

esphome/components/kuntze/kuntze.h

@@ -18,14 +18,18 @@ class Kuntze final : public PollingComponent, public modbus::ModbusClientDevice
   void set_ec_sensor(sensor::Sensor *ec_sensor) { ec_sensor_ = ec_sensor; }
   void set_oci_sensor(sensor::Sensor *oci_sensor) { oci_sensor_ = oci_sensor; }
 
+  void loop() override;
   void update() override;
 
-  void on_read_holding_registers(uint16_t start_address, std::span<const uint16_t> registers,
-                                 modbus::ResponseStatus status) override;
+  void on_response(std::span<const uint8_t> request_pdu, std::span<const uint8_t> response_pdu) override;
 
   void dump_config() override;
 
  protected:
+  int state_{0};
+  bool waiting_{false};
+  uint32_t last_send_{0};
+
   sensor::Sensor *ph_sensor_{nullptr};
   sensor::Sensor *temperature_sensor_{nullptr};
   sensor::Sensor *dis1_sensor_{nullptr};

esphome/components/libretiny/__init__.py

@@ -300,7 +300,7 @@ FRAMEWORK_SCHEMA = cv.All(
     _check_debug_order,
 )
 
-CONFIG_SCHEMA = cv.All(_notify_old_style, cv.require_platformio_toolchain("LibreTiny"))
+CONFIG_SCHEMA = cv.All(_notify_old_style)
 
 BASE_SCHEMA = cv.Schema(
     {
@@ -314,7 +314,6 @@ BASE_SCHEMA = cv.Schema(
 )
 
 BASE_SCHEMA.add_extra(_detect_variant)
-BASE_SCHEMA.add_extra(cv.require_platformio_toolchain("LibreTiny"))
 BASE_SCHEMA.add_extra(_update_core_data)
 
 

esphome/components/light/esp_color_correction.cpp

@@ -5,11 +5,7 @@ namespace esphome::light {
 uint8_t ESPColorCorrection::gamma_correct_(uint8_t value) const {
   if (this->gamma_table_ == nullptr)
     return value;
-  uint16_t table_value = progmem_read_uint16(&this->gamma_table_[value]);
-  uint8_t result = (table_value + 128) / 257;
-  if (result == 0 && table_value != 0)
-    return 1;
-  return result;
+  return static_cast<uint8_t>((progmem_read_uint16(&this->gamma_table_[value]) + 128) / 257);
 }
 
 uint8_t ESPColorCorrection::gamma_uncorrect_(uint8_t value) const {

esphome/components/lvgl/__init__.py

@@ -57,6 +57,7 @@ from .defines import (
     CONF_ALIGN_TO_LAMBDA_ID,
     CONF_ANIMATIONS,
     LOGGER,
+    add_lv_use,
     get_focused_widgets,
     get_lv_images_used,
     get_refreshed_widgets,
@@ -73,6 +74,7 @@ from .keypads import KEYPADS_CONFIG, keypads_to_code
 from .lv_validation import lv_bool
 from .lvcode import LvContext, LvglComponent, lv_event_t_ptr, lvgl_static
 from .schemas import (
+    BASE_PROPS,
     DISP_BG_SCHEMA,
     FULL_STYLE_SCHEMA,
     SET_STATE_SCHEMA,
@@ -81,7 +83,6 @@ from .schemas import (
     STYLE_SCHEMA,
     WIDGET_TYPES,
     any_widget_schema,
-    apply_style_driven_defines,
     container_schema,
     container_schema_value,
     theme_schema,
@@ -107,6 +108,7 @@ from .widgets import (
     get_screen_active,
     set_obj_properties,
 )
+from .widgets.img import CONF_IMAGE
 
 # Import only what we actually use directly in this file
 from .widgets.msgbox import MSGBOX_SCHEMA, msgboxes_to_code
@@ -453,15 +455,6 @@ async def to_code(configs):
     # Mark all widgets as completed so awaiters of ``wait_for_widgets`` proceed.
     set_widgets_completed(True)
     async with LvContext():
-        # Local import: lv_list imports meter, which imports obj_spec/set_obj_properties
-        # from this module's own namespace - a top-level import here would be circular.
-        from .widgets.lv_list import finish_list_triggers
-
-        # Must run before generate_triggers(): that's what actually processes other
-        # widgets' on_click etc. automations, which can include lvgl.list.add/remove/
-        # clear actions that fire a list's on_add/on_remove triggers - those need to
-        # already exist by then, not still be pending.
-        await finish_list_triggers()
         await generate_triggers()
         await generate_align_tos(configs[0])
         for config in configs:
@@ -488,16 +481,34 @@ async def to_code(configs):
 
     # This must be done after all widgets are created
     styles_used = df.get_styles_used()
-    apply_style_driven_defines(styles_used)
+    if any(BASE_PROPS.get(x) is lvalid.lv_image for x in styles_used):
+        add_lv_use(CONF_IMAGE)
     for use in df.get_lv_uses():
         df.add_define(f"LV_USE_{use.upper()}")
         cg.add_define(f"USE_LVGL_{use.upper()}")
 
+    if {
+        "transform_rotation",
+        "transform_scale",
+        "transform_scale_x",
+        "transform_scale_y",
+    } & styles_used:
+        df.add_define("LV_COLOR_SCREEN_TRANSP", "1")
+
     if configs[0].get(df.CONF_THEME, {}).get(df.CONF_DARK_MODE):
         df.add_define("LV_THEME_DEFAULT_DARK", "1")
 
     # Currently always need RGB565 for the display buffer, and ARGB8888 is used for layer blending
     lv_image_formats = {"RGB565", "ARGB8888"}
+    if {
+        "drop_shadow_color",
+        "drop_shadow_offset_x",
+        "drop_shadow_offset_y",
+        "drop_shadow_opa",
+        "drop_shadow_quality",
+        "drop_shadow_radius",
+    } & styles_used:
+        lv_image_formats.add("A8")
 
     for image_id in get_lv_images_used():
         await cg.get_variable(image_id)

esphome/components/lvgl/automation.py

@@ -416,7 +416,7 @@ async def obj_set_z_index_to_code(config, action_id, template_arg, args):
                 widget.obj, literal(f"{lv_expr.obj_get_index(widget.obj)} + 1")
             )
         elif position == "DOWN":
-            with LvConditional(literal(f"{lv_expr.obj_get_index(widget.obj)} > 0")):
+            with LvConditional(f"{lv_expr.obj_get_index(widget.obj)} > 0"):
                 lv_obj.move_to_index(
                     widget.obj, literal(f"{lv_expr.obj_get_index(widget.obj)} - 1")
                 )

esphome/components/lvgl/defines.py

@@ -585,21 +585,6 @@ FLEX_FLOWS = LvConstant(
     "COLUMN_WRAP_REVERSE",
 )
 
-TRANSFORM_STYLE_PROPS = frozenset(
-    {"transform_rotation", "transform_scale", "transform_scale_x", "transform_scale_y"}
-)
-
-DROP_SHADOW_STYLE_PROPS = frozenset(
-    {
-        "drop_shadow_color",
-        "drop_shadow_offset_x",
-        "drop_shadow_offset_y",
-        "drop_shadow_opa",
-        "drop_shadow_quality",
-        "drop_shadow_radius",
-    }
-)
-
 OBJ_FLAGS = (
     "hidden",
     "clickable",

esphome/components/lvgl/lvcode.py

@@ -242,7 +242,7 @@ class LocalVariable(MockObj):
                     self.base.type, self.modifier, self.base.id
                 )
             )
-        return MockObj(self.base, "->" if self.modifier == "*" else ".")
+        return MockObj(self.base)
 
     def __exit__(self, *args):
         CodeContext.end_block()
@@ -283,15 +283,7 @@ class MockLv:
 
 class LvConditional:
     def __init__(self, condition):
-        # Condition is embedded directly into a raw `if (...)` statement below, rather than
-        # going through the argument-list machinery (ExpressionList) that would otherwise
-        # convert a native Python value (e.g. a plain bool) to a proper Expression.
-        if isinstance(condition, str):
-            raise ValueError(
-                "LvConditional condition must not be a raw str; wrap it in literal() "
-                "if a string literal condition is really intended"
-            )
-        self.condition = cg.safe_exp(condition) if condition is not None else None
+        self.condition = condition
 
     def __enter__(self):
         if self.condition is not None:
@@ -311,35 +303,6 @@ class LvConditional:
         CodeContext.code_context.indent()
 
 
-class LvCountdown:
-    """
-    Emits a C++ `for` loop that counts an int variable down from `count - 1` to `0` inclusive.
-    Used to iterate over a widget's children in reverse, e.g. to fire a trigger once per child
-    before they're all removed.
-    """
-
-    def __init__(self, var_name: str, count):
-        self.var_name = var_name
-        self.count = count
-
-    def __enter__(self):
-        # Cast explicitly rather than relying on `count`'s (typically unsigned) type to wrap
-        # and then narrow back to a negative int when count is 0 -- true in practice on every
-        # toolchain ESPHome targets, but not worth leaning on.
-        CodeContext.append(
-            RawStatement(
-                f"for (int {self.var_name} = (int) ({self.count}) - 1; {self.var_name} >= 0; "
-                f"{self.var_name}--) {{"
-            )
-        )
-        CodeContext.code_context.indent()
-        return literal(self.var_name)
-
-    def __exit__(self, *args):
-        CodeContext.code_context.detent()
-        CodeContext.append(RawStatement("}"))
-
-
 class ReturnStatement(ExpressionStatement):
     def __str__(self):
         return f"return {self.expression};"

esphome/components/lvgl/lvgl_esphome.cpp

@@ -208,21 +208,21 @@ void LvglComponent::esphome_lvgl_init() {
   lv_update_event = static_cast<lv_event_code_t>(lv_event_register_id());
 }
 
-void LvglComponent::add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event, void *user_data) {
-  lv_obj_add_event_cb(obj, callback, event, user_data);
+void LvglComponent::add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event) {
+  lv_obj_add_event_cb(obj, callback, event, nullptr);
 }
 
 void LvglComponent::add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event1,
-                                 lv_event_code_t event2, void *user_data) {
-  add_event_cb(obj, callback, event1, user_data);
-  add_event_cb(obj, callback, event2, user_data);
+                                 lv_event_code_t event2) {
+  add_event_cb(obj, callback, event1);
+  add_event_cb(obj, callback, event2);
 }
 
 void LvglComponent::add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event1,
-                                 lv_event_code_t event2, lv_event_code_t event3, void *user_data) {
-  add_event_cb(obj, callback, event1, user_data);
-  add_event_cb(obj, callback, event2, user_data);
-  add_event_cb(obj, callback, event3, user_data);
+                                 lv_event_code_t event2, lv_event_code_t event3) {
+  add_event_cb(obj, callback, event1);
+  add_event_cb(obj, callback, event2);
+  add_event_cb(obj, callback, event3);
 }
 
 void LvglComponent::add_page(LvPageType *page) {
@@ -525,52 +525,6 @@ void IndicatorLine::update_length_() {
 }
 #endif
 
-#ifdef USE_LVGL_TABLE
-uint32_t lv_table_get_selected_row(lv_obj_t *obj) {
-  uint32_t row;
-  uint32_t column;
-  lv_table_get_selected_cell(obj, &row, &column);
-  return row;
-}
-
-uint32_t lv_table_get_selected_column(lv_obj_t *obj) {
-  uint32_t row;
-  uint32_t column;
-  lv_table_get_selected_cell(obj, &row, &column);
-  return column;
-}
-
-void LvTableType::set_obj(lv_obj_t *lv_obj) {
-  LvCompound::set_obj(lv_obj);
-  lv_obj_add_event_cb(
-      lv_obj,
-      [](lv_event_t *e) {
-        auto *table = static_cast<LvTableType *>(lv_event_get_user_data(e));
-        table->update_column_widths_();
-      },
-      LV_EVENT_SIZE_CHANGED, this);
-}
-
-void LvTableType::add_column_width_pct(uint32_t col, uint8_t pct) {
-  for (auto &i : this->column_pct_) {
-    if (i.col == col) {
-      i.pct = pct;
-      this->update_column_widths_();
-      return;
-    }
-  }
-  this->column_pct_.push_back({col, pct});
-  this->update_column_widths_();
-}
-
-void LvTableType::update_column_widths_() {
-  auto content_width = lv_obj_get_content_width(this->obj);
-  for (const auto &col : this->column_pct_) {
-    lv_table_set_column_width(this->obj, col.col, content_width * col.pct / 100);
-  }
-}
-#endif  // USE_LVGL_TABLE
-
 #ifdef USE_LVGL_KEY_LISTENER
 LVEncoderListener::LVEncoderListener(lv_indev_type_t type, uint16_t long_press_time, uint16_t long_press_repeat_time) {
   this->drv_ = lv_indev_create();
@@ -597,21 +551,21 @@ std::string LvSelectable::get_selected_text() {
   return this->options_[selected];
 }
 
-static std::string join_string(const FixedVector<const char *> &options) {
+static std::string join_string(std::vector<std::string> options) {
   return std::accumulate(
       options.begin(), options.end(), std::string(),
-      [](const std::string &a, const char *b) -> std::string { return a + (!a.empty() ? "\n" : "") + b; });
+      [](const std::string &a, const std::string &b) -> std::string { return a + (!a.empty() ? "\n" : "") + b; });
 }
 
 void LvSelectable::set_selected_text(const std::string &text, lv_anim_enable_t anim) {
-  auto *index = std::find(this->options_.begin(), this->options_.end(), text);
+  auto index = std::find(this->options_.begin(), this->options_.end(), text);
   if (index != this->options_.end()) {
     this->set_selected_index(index - this->options_.begin(), anim);
     lv_obj_send_event(this->obj, lv_update_event, nullptr);
   }
 }
 
-void LvSelectable::set_options(FixedVector<const char *> options) {
+void LvSelectable::set_options(std::vector<std::string> options) {
   auto index = this->get_selected_index();
   if (index >= options.size())
     index = options.size() - 1;
@@ -1009,25 +963,6 @@ lv_obj_t *lv_container_create(lv_obj_t *parent) {
   lv_obj_class_init_obj(obj);
   return obj;
 }
-
-#ifdef USE_LVGL_LIST
-int lv_list_get_row_index(lv_obj_t *list, lv_obj_t *child) {
-  for (lv_obj_t *obj = child; obj != nullptr; obj = lv_obj_get_parent(obj)) {
-    if (lv_obj_get_parent(obj) == list)
-      return lv_obj_get_index(obj);
-  }
-  ESP_LOGW(TAG, "lvgl.list: entry is not inside the list it was added to");
-  return -1;
-}
-
-lv_obj_t *lv_list_get_row_for_remove(lv_obj_t *list, int index) {
-  lv_obj_t *child = index < 0 ? nullptr : lv_obj_get_child(list, index);
-  if (child == nullptr) {
-    ESP_LOGW(TAG, "lvgl.list.remove: index %d is out of range, ignoring", index);
-  }
-  return child;
-}
-#endif  // USE_LVGL_LIST
 }  // namespace esphome::lvgl
 
 lv_result_t lv_mem_test_core() { return LV_RESULT_OK; }

esphome/components/lvgl/lvgl_esphome.h

@@ -58,10 +58,6 @@ lv_obj_t *lv_container_create(lv_obj_t *parent);
 void lv_scale_draw_event_cb(lv_event_t *e, int16_t range_start, int16_t range_end, lv_color_t color_start,
                             lv_color_t color_end, int width, bool local);
 #endif
-#ifdef USE_LVGL_TABLE
-uint32_t lv_table_get_selected_row(lv_obj_t *obj);
-uint32_t lv_table_get_selected_column(lv_obj_t *obj);
-#endif
 #if LV_COLOR_DEPTH == 16
 static const display::ColorBitness LV_BITNESS = display::ColorBitness::COLOR_BITNESS_565;
 #elif LV_COLOR_DEPTH == 32
@@ -120,18 +116,6 @@ inline void lv_animimg_set_src(lv_obj_t *img, std::vector<image::Image *> images
 int16_t lv_get_needle_angle_for_value(lv_obj_t *obj, int32_t value);
 #endif
 
-#ifdef USE_LVGL_LIST
-// Returns the index, within `list`, of the entry that contains `child`: `child` itself if it's a
-// direct child of `list`, or the ancestor of `child` that is, when `child` is nested inside a
-// widget hierarchy added via `lvgl.list.add`. Returns -1 if `child` isn't inside `list` at all.
-int lv_list_get_row_index(lv_obj_t *list, lv_obj_t *child);
-
-// Returns the entry at `index` within `list`, or nullptr (logging why) if `index` is out of
-// range -- shared by every `lvgl.list.remove` call site, since a templatable index can go out of
-// range at runtime in ways config validation can't catch (e.g. driven by a sensor value).
-lv_obj_t *lv_list_get_row_for_remove(lv_obj_t *list, int index);
-#endif
-
 #ifdef USE_LVGL_GRADIENT
 /**
  *
@@ -151,12 +135,6 @@ class LvCompound {
   lv_obj_t *obj{};
 };
 
-// Frees a heap-allocated LvCompound wrapper on LV_EVENT_DELETE, since lv_obj_del() only knows how to destroy LVGL's own
-// object tree, not a separate C++ object paired with one of its nodes.
-template<typename T> void delete_lv_compound_on_delete(lv_event_t *e) {
-  delete static_cast<T *>(lv_event_get_user_data(e));
-}
-
 class LvglComponent;
 
 class LvPageType : public Parented<LvglComponent> {
@@ -263,11 +241,10 @@ class LvglComponent final : public PollingComponent {
   static void esphome_lvgl_init();
 
   //  Convenience overloads for adding a callback for one or more events
-  static void add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event, void *user_data = nullptr);
+  static void add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event);
+  static void add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event1, lv_event_code_t event2);
   static void add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event1, lv_event_code_t event2,
-                           void *user_data = nullptr);
-  static void add_event_cb(lv_obj_t *obj, event_callback_t callback, lv_event_code_t event1, lv_event_code_t event2,
-                           lv_event_code_t event3, void *user_data = nullptr);
+                           lv_event_code_t event3);
 
   // change the state of a widget and fire an event if changed (only needed for CHECKED)
 
@@ -515,27 +492,6 @@ class LvLineType : public LvCompound {
   FixedVector<lv_point_precise_t> points_{};
 };
 #endif
-#ifdef USE_LVGL_TABLE
-// Unlike most size properties, lv_table_set_column_width() only accepts a literal pixel
-// count, so percentage column widths must be recomputed by hand whenever the table's own
-// content width changes.
-class LvTableType : public LvCompound {
- public:
-  void set_obj(lv_obj_t *lv_obj) override;
-  // count is the number of percentage-width columns, known at code-generation time.
-  void init_column_pct(size_t count) { this->column_pct_.init(count); }
-  void add_column_width_pct(uint32_t col, uint8_t pct);
-
- protected:
-  void update_column_widths_();
-
-  struct ColumnPct {
-    uint32_t col;
-    uint8_t pct;
-  };
-  FixedVector<ColumnPct> column_pct_{};
-};
-#endif  // USE_LVGL_TABLE
 #if defined(USE_LVGL_DROPDOWN) || defined(LV_USE_ROLLER)
 class LvSelectable : public LvCompound {
  public:
@@ -543,12 +499,12 @@ class LvSelectable : public LvCompound {
   virtual void set_selected_index(size_t index, lv_anim_enable_t anim) = 0;
   void set_selected_text(const std::string &text, lv_anim_enable_t anim);
   std::string get_selected_text();
-  const FixedVector<const char *> &get_options() { return this->options_; }
-  void set_options(FixedVector<const char *> options);
+  const std::vector<std::string> &get_options() { return this->options_; }
+  void set_options(std::vector<std::string> options);
 
  protected:
   virtual void set_option_string(const char *options) = 0;
-  FixedVector<const char *> options_{};
+  std::vector<std::string> options_{};
 };
 
 #ifdef USE_LVGL_DROPDOWN