[ci] Keep the venv ninja on PATH, only cmake is missing in a real install

[ci] Temporary Windows compile without host cmake
[espidf] Resolve cmake through the IDF environment when reading the CMake cache
2026-10-28 00:42:11 +00:00 · 2026-09-30 11:47:54 +02:00 · 2026-09-30 11:45:16 +02:00 · 2026-09-30 11:43:25 +02:00
402 changed files with 1706 additions and 13825 deletions
@@ -0,0 +1,14 @@
+esphome:
+  name: cmake-idf
+
+esp32:
+  board: esp32dev
+  framework:
+    type: esp-idf
+
+logger:
+api:
+
+wifi:
+  ssid: cmake
+  password: cmakepassword
@@ -219,6 +219,5 @@ jobs:
        run: |
          docker run --rm \
            -v "${{ github.workspace }}/docker/test_configs:/config" \
-            -e ESPHOME_LDGEN_STRICT=1 \
            "ghcr.io/esphome/esphome-amd64:${{ needs.check-docker.outputs.tag }}" \
            compile "${{ matrix.id }}.yaml"
@@ -299,7 +299,7 @@ jobs:
      # Pushes any fixes the hooks made back to the pull request. This step
      # must keep its default name: the GitHub App that performs the push
      # locates the workflow run by that name.
-      - uses: pre-commit-ci/lite-action@062bca0919bc9d6e66755cc05074b70c77e111fc # v1.2.0
+      - uses: pre-commit-ci/lite-action@5d6cc0eb514c891a40562a58a8e71576c5c7fb43 # v1.1.0
        if: always()
        with:
          msg: apply automatic formatting fixes
@@ -1225,14 +1225,7 @@ jobs:

          if [ -n "$compile_csv" ]; then
            # Run compilation with grouping and isolation
-            # The bootloader has no ESPHome code and these builds never
-            # flash; the check_idf_py batch keeps the full build so the
-            # native sub-build and the equivalence check stay covered.
-            skip_flag="--skip-bootloader"
-            if [[ "${{ matrix.batch.check_idf_py }}" == "true" ]]; then
-              skip_flag=""
-            fi
-            python3 script/test_build_components.py -e compile -c "$compile_csv" -f --isolate "$directly_changed_csv" $skip_flag
+            python3 script/test_build_components.py -e compile -c "$compile_csv" -f --isolate "$directly_changed_csv"
            if [[ "${{ matrix.batch.check_idf_py }}" == "true" ]]; then
              # The real idf.py must find nothing to configure or build in a
              # tree built above; catches drift on ESP-IDF bumps.
@@ -0,0 +1,43 @@
+name: Windows cmake lookup check
+
+on:
+  push:
+    branches:
+      - windows_cmake_lookup_ci
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  compile:
+    name: esp-idf native without host cmake
+    runs-on: windows-latest
+    timeout-minutes: 120
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Set up Python
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        with:
+          python-version: "3.13"
+      # cmd throughout: idf_tools.py refuses to run under MSYS, which the
+      # bash shell announces, and users build from a plain Windows shell
+      - name: Install esphome
+        shell: cmd
+        run: |
+          python -m venv venv
+          call venv\Scripts\activate.bat
+          pip install -r requirements.txt
+          pip install -e .
+      # The runner image has cmake preinstalled on PATH, which would mask
+      # the bug: users of the builder install have no host cmake. Strip
+      # PATH to the interpreter, git and the system dirs, then prove it.
+      # ninja stays reachable through the venv, as in a real install: the
+      # pip ninja package from requirements.txt puts it in Scripts.
+      - name: Compile without cmake on the host PATH
+        shell: cmd
+        run: |
+          set "PATH=%CD%\venv\Scripts;%pythonLocation%;%pythonLocation%\Scripts;C:\Program Files\Git\cmd;%SystemRoot%\system32;%SystemRoot%"
+          where cmake && echo cmake still on PATH, test is invalid && exit /b 1
+          esphome compile .github/cmake_windows/idf.yaml
@@ -541,7 +541,6 @@ esphome/components/st7735/* @SenexCrenshaw
 esphome/components/st7789v/* @kbx81
 esphome/components/st7920/* @marsjan155
 esphome/components/statsd/* @Links2004
-esphome/components/stcc4/* @j9brown
 esphome/components/stts22h/* @B48D81EFCC
 esphome/components/substitutions/* @esphome/core
 esphome/components/sun/* @OttoWinter
@@ -555,12 +554,10 @@ esphome/components/syslog/* @clydebarrow
 esphome/components/systa_bus/* @Mat931
 esphome/components/t6615/* @tylermenezes
 esphome/components/tas2780/* @remcom
-esphome/components/tas58xx/* @mrtoy-me @remcom
 esphome/components/tc74/* @sethgirvan
 esphome/components/tca9548a/* @andreashergert1984
 esphome/components/tca9555/* @mobrembski
 esphome/components/tcl112/* @glmnet
-esphome/components/tcp_uart/* @Bascht74
 esphome/components/tee501/* @Stock-M
 esphome/components/teleinfo/* @0hax
 esphome/components/tem3200/* @bakerkj
@@ -602,7 +599,6 @@ esphome/components/uart/button/* @ssieb
 esphome/components/uart/event/* @eoasmxd
 esphome/components/uart/packet_transport/* @clydebarrow
 esphome/components/uart_mux/* @kbx81
-esphome/components/uart_tcp/* @Bascht74
 esphome/components/udp/* @clydebarrow
 esphome/components/ufire_ec/* @pvizeli
 esphome/components/ufire_ise/* @pvizeli
@@ -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.19.0
+RUN uv pip install --no-cache-dir esphome-device-builder==1.17.2

 RUN \
    platformio settings set enable_telemetry No \
@@ -148,7 +148,6 @@ class ArgsProtocol(Protocol):
    file: str | None
    no_logs: bool
    only_generate: bool
-    skip_bootloader: bool
    show_secrets: bool
    dashboard: bool
    configuration: str
@@ -828,14 +827,6 @@ def write_cpp_file() -> int:


 def compile_program(args: ArgsProtocol, config: ConfigType) -> int:
-    if CORE.skip_bootloader and not (CORE.is_esp32 and CORE.using_toolchain_esp_idf):
-        # Info, not a warning: an orchestrator cannot see YAML toolchain
-        # overrides, this is its expected no-op, and a full build is safe.
-        _LOGGER.info(
-            "--skip-bootloader ignored: only supported on ESP32 with the "
-            "esp-idf toolchain"
-        )
-        CORE.skip_bootloader = False
    # Keep this gate here, NOT in config validation: device-builder needs
    # `esphome config` to keep succeeding with placeholders so onboarding can run.
    if CONF_WIFI in config:
@@ -866,10 +857,7 @@ def compile_program(args: ArgsProtocol, config: ConfigType) -> int:
            return rc

        # Create factory.bin, ota.bin, and firmware.elf copy
-        if not toolchain.create_factory_bin():
-            # A build whose factory image could not be produced must not
-            # exit 0; downloads would serve an image from an older build.
-            return 1
+        toolchain.create_factory_bin()
        toolchain.create_ota_bin()
        toolchain.create_elf_copy()
        from esphome.build_helpers.idedata import warn_if_idedata_missing
@@ -987,9 +975,8 @@ def upload_using_esptool(
        # and partitions included where the target needs them)
        image = native.get_factory_firmware_path()
        if not image.is_file():
-            hint = getattr(native, "missing_image_hint", lambda: None)()
            raise EsphomeError(
-                hint or f"{image} does not exist; compile the configuration first"
+                f"{image} does not exist; compile the configuration first"
            )
        flash_images = [FlashImage(path=image, offset="0x0")]
    else:
@@ -1300,9 +1287,10 @@ def _choose_ota_platform(config: ConfigType, requested: str | None) -> str:
    The native API uses challenge-response auth with MD5/SHA256 hashing of a
    server-issued nonce, so the password is never sent over the wire; the
    ``web_server`` path uses HTTP Basic auth which transmits credentials in
-    cleartext over the LAN. (The native path also compresses the upload:
-    gzip on ESP8266 and RP2040, which inflate it at reboot, and a deflate
-    stream on ESP32/LibreTiny, which inflate it as it arrives.) Falls back to
+    cleartext over the LAN. (The native path also supports gzip compression
+    on ESP8266, where flash space is tight; on ESP32/RP2040/LibreTiny the
+    backend reports ``supports_compression() == false`` and the firmware is
+    sent uncompressed regardless of which platform is used.) Falls back to
    ``web_server`` only when that is the only available platform.
    """
    # Use a dict (insertion-ordered) instead of a list so error messages and
@@ -1391,12 +1379,6 @@ def _upload_via_native_api(
        ota_type = espota2.OTA_TYPE_UPDATE_PARTITION_TABLE
    elif getattr(args, "bootloader", False):
        check_partition_access("--bootloader")
-        if (
-            getattr(args, "file", None) is None
-            and (native := native_backend())
-            and (hint := getattr(native, "missing_image_hint", lambda: None)())
-        ):
-            raise EsphomeError(hint)
        binary = CORE.bootloader_bin
        ota_type = espota2.OTA_TYPE_UPDATE_BOOTLOADER
    if getattr(args, "file", None) is not None:
@@ -1772,18 +1754,6 @@ def command_logs(args: ArgsProtocol, config: ConfigType) -> int | None:


 def command_run(args: ArgsProtocol, config: ConfigType) -> int | None:
-    if (
-        CORE.skip_bootloader
-        and CORE.is_esp32
-        and CORE.using_toolchain_esp_idf
-        and any(
-            get_port_type(device) == PortType.SERIAL for device in (args.device or [])
-        )
-    ):
-        # Fail before the compile: the result could never flash over serial.
-        # Elsewhere the flag is ignored, so serial stays fine there.
-        _LOGGER.error("--skip-bootloader builds cannot be flashed over serial")
-        return 1
    exit_code = write_cpp(config)
    if exit_code != 0:
        return exit_code
@@ -2169,15 +2139,6 @@ SIMPLE_CONFIG_ACTIONS = [
 ]


-def _add_skip_bootloader_arg(parser: argparse.ArgumentParser) -> None:
-    parser.add_argument(
-        "--skip-bootloader",
-        help="Do not build the bootloader or the factory image; "
-        "the result can only be flashed over OTA.",
-        action="store_true",
-    )
-
-
 def _add_states_args(parser: argparse.ArgumentParser) -> None:
    """Add mutually exclusive ``--states``/``--no-states`` flags to a parser.

@@ -2319,7 +2280,6 @@ def parse_args(argv):
        help="Only generate source code, do not compile.",
        action="store_true",
    )
-    _add_skip_bootloader_arg(parser_compile)

    parser_upload = subparsers.add_parser(
        "upload",
@@ -2383,7 +2343,7 @@ def parse_args(argv):
        "-r",
        action="store_true",
        help="Reset the device before starting serial logs.",
-        default=get_bool_env("ESPHOME_SERIAL_LOGGING_RESET"),
+        default=os.getenv("ESPHOME_SERIAL_LOGGING_RESET"),
    )
    _add_states_args(parser_logs)

@@ -2416,7 +2376,6 @@ def parse_args(argv):
    parser_run.add_argument(
        "--no-logs", help="Disable starting logs.", action="store_true"
    )
-    _add_skip_bootloader_arg(parser_run)

    _add_states_args(parser_run)

@@ -2425,7 +2384,7 @@ def parse_args(argv):
        "-r",
        action="store_true",
        help="Reset the device before starting serial logs.",
-        default=get_bool_env("ESPHOME_SERIAL_LOGGING_RESET"),
+        default=os.getenv("ESPHOME_SERIAL_LOGGING_RESET"),
    )
    parser_run.add_argument(
        "--ota-platform",
@@ -2676,7 +2635,6 @@ def run_esphome(argv):

    CORE.config_path = conf_path
    CORE.dashboard = args.dashboard
-    CORE.skip_bootloader = getattr(args, "skip_bootloader", False)
    if args.toolchain is not None:
        # CLI toolchain wins over esp32.toolchain in YAML.
        CORE.toolchain = args.toolchain
@@ -148,13 +148,6 @@ class AddressCache:
                continue
            hostname, ips = arg.split("=", 1)
            # Normalize hostname for consistent lookups
-            normalized = normalize_hostname(hostname.strip())
-            addresses = [ip for value in ips.split(",") if (ip := value.strip())]
-            if not normalized or not addresses:
-                _LOGGER.warning(
-                    "Invalid cache entry: %s (hostname and at least one address are required)",
-                    arg,
-                )
-                continue
-            cache[normalized] = addresses
+            normalized = normalize_hostname(hostname)
+            cache[normalized] = [ip.strip() for ip in ips.split(",")]
        return cache
@@ -1065,10 +1065,10 @@ def write_project(paths: InstalledPaths, ccache: str | None) -> bool:
        "  rspfile_content = $in_newline",
        "  description = LINK $out",
        "rule elf2bin",
-        # --flash_size follows PlatformIO: ldscript filename first, then
-        # upload.maximum_size, so the header always matches the layout.
+        # --flash_size deliberately stays board-derived, as under
+        # PlatformIO (which reads upload.maximum_size, not the ldscript).
        # -W: the framework's own elf2bin.py trips SyntaxWarning on 3.12+.
-        f"  command = $python -W ignore::SyntaxWarning {_q(framework / 'tools' / 'elf2bin.py')} --eboot {_q(framework / 'bootloaders' / 'eboot' / 'eboot.elf')} --app $in --flash_mode {flash_mode} --flash_freq {_FLASH_FREQ_MHZ} --flash_size {_elf2bin_flash_size(board, flash_ld_name)} --path {_q(toolchain_bin)} --out $out",
+        f"  command = $python -W ignore::SyntaxWarning {_q(framework / 'tools' / 'elf2bin.py')} --eboot {_q(framework / 'bootloaders' / 'eboot' / 'eboot.elf')} --app $in --flash_mode {flash_mode} --flash_freq {_FLASH_FREQ_MHZ} --flash_size {_flash_size_str(BOARDS[board][KEY_FLASH_SIZE])} --path {_q(toolchain_bin)} --out $out",
        "  description = BIN $out",
        "rule copy",
        "  command = $python $buildtool copy $in $out",
@@ -1189,28 +1189,3 @@ def _flash_size_str(flash_size: int) -> str:
    """Flash size argument for elf2bin (e.g. ``4M``, ``512K``)."""
    mb = 1024 * 1024
    return f"{flash_size // mb}M" if flash_size >= mb else f"{flash_size // 1024}K"
-
-
-# Same pattern PlatformIO's _get_flash_size applies to the ldscript path
-_LD_FLASH_SIZE_RE = re.compile(r"\.flash\.(\d+[mk]).*\.ld")
-# The framework elf2bin.py's --flash_size choices
-_ELF2BIN_FLASH_SIZES = frozenset({"256K", "512K", "1M", "2M", "4M", "8M", "16M"})
-
-
-def _elf2bin_flash_size(board: str, flash_ld_name: str) -> str:
-    """Image-header flash size as PlatformIO derives it: ldscript filename,
-    else board_upload.maximum_size, else the board table. The SDK clamps the
-    chip to the header size at boot, so a header smaller than the linked
-    layout breaks OTA writes on the running device."""
-    if match := _LD_FLASH_SIZE_RE.search(flash_ld_name):
-        token = match.group(1)
-        base = 1024 if token[-1] == "k" else 1024 * 1024
-        return _flash_size_str(int(token[:-1]) * base)
-    if max_size := _pio_option("board_upload.maximum_size", ""):
-        if (
-            not max_size.isdigit()
-            or (size := _flash_size_str(int(max_size))) not in _ELF2BIN_FLASH_SIZES
-        ):
-            raise EsphomeError(f"Invalid board_upload.maximum_size value {max_size!r}")
-        return size
-    return _flash_size_str(BOARDS[board][KEY_FLASH_SIZE])
@@ -3,7 +3,6 @@
 import json
 import logging
 from pathlib import Path
-import re
 import textwrap

 from esphome.build_helpers import pch
@@ -21,7 +20,7 @@ from esphome.framework_helpers import (
    get_project_cxx_compile_flags,
    get_project_link_flags,
 )
-from esphome.helpers import get_bool_env, mkdir_p, write_file_if_changed
+from esphome.helpers import mkdir_p, write_file_if_changed

 _LOGGER = logging.getLogger(__name__)

@@ -36,83 +35,6 @@ list(FILTER esphome_cxx_compile_options EXCLUDE REGEX "^-std=")
 list(APPEND esphome_cxx_compile_options "-std={standard}")
 idf_build_set_property(CXX_COMPILE_OPTIONS "${{esphome_cxx_compile_options}}")"""

-# Drops the app archive from ldgen's inputs so app-only edits skip the
-# sections.ld regeneration. Safe: no mapping fragment references it
-# (run_compile re-checks each build). Filters only the top-level call;
-# the prior definition stays reachable with an underscore prefix.
-_LDGEN_OVERRIDE = """\
-if(COMMAND __ldgen_get_lib_deps_of_target)
-    set_property(GLOBAL PROPERTY ESPHOME_LDGEN_ARMED 1)
-    function(__ldgen_get_lib_deps_of_target target out_list_var)
-        if(NOT COMMAND ___ldgen_get_lib_deps_of_target)
-            message(FATAL_ERROR "ESPHome ldgen override lost the original "
-                "implementation; set ESPHOME_LDGEN_FULL_DEPS=1 and rebuild.")
-        endif()
-        ___ldgen_get_lib_deps_of_target(${target} ${out_list_var})
-        if(out_list_var STREQUAL "ldgen_libraries")
-            set_property(GLOBAL PROPERTY ESPHOME_LDGEN_FILTERED 1)
-            list(LENGTH ${out_list_var} esphome_ldgen_before)
-            list(REMOVE_ITEM ${out_list_var} idf::src __idf_src)
-            list(LENGTH ${out_list_var} esphome_ldgen_after)
-            if(esphome_ldgen_before EQUAL esphome_ldgen_after)
-                message(@SEVERITY@ "ESPHome ldgen app archive exclusion matched "
-                    "nothing; app edits will regenerate sections.ld.")
-            endif()
-        endif()
-        set(${out_list_var} "${${out_list_var}}" PARENT_SCOPE)
-    endfunction()
-else()
-    message(@MISSING@ "ESPHome ldgen override target not found; "
-        "app edits will regenerate sections.ld.")
-endif()"""
-
-# lwip sources that compile to empty objects with the option off (their own
-# #if guard). (option, regex valid for both Python and CMake); a source is
-# only dropped when its option is defined and off, so a renamed option
-# keeps it.
-LWIP_EMPTY_SOURCES: tuple[tuple[str, str], ...] = (
-    ("CONFIG_LWIP_PPP_SUPPORT", "/netif/ppp/"),
-    ("CONFIG_LWIP_IPV6", "/core/ipv6/"),
-    ("CONFIG_LWIP_AUTOIP", "/core/ipv4/autoip[.]c$"),
-    ("CONFIG_LWIP_STATS", "/core/stats[.]c$"),
-)
-# Drift guard only: keep every lwip source.
-LWIP_FULL_SOURCES_ENV = "ESPHOME_LWIP_FULL_SOURCES"
-
-# Drops the empty objects after project(), once the lwip target exists.
-_LWIP_EMPTY_SOURCES_FILTER = f"""\
-idf_build_get_property(esphome_build_components BUILD_COMPONENTS)
-if(lwip IN_LIST esphome_build_components AND NOT DEFINED ENV{{{LWIP_FULL_SOURCES_ENV}}})
-    idf_component_get_property(esphome_lwip_lib lwip COMPONENT_LIB)
-    get_target_property(esphome_lwip_srcs ${{esphome_lwip_lib}} SOURCES)
-@FILTERS@
-    set_property(TARGET ${{esphome_lwip_lib}} PROPERTY SOURCES ${{esphome_lwip_srcs}})
-endif()"""
-
-
-def lwip_empty_source_gate(option: str, regex: str) -> str:
-    return (
-        f"    if(DEFINED {option} AND NOT {option})\n"
-        f'        list(FILTER esphome_lwip_srcs EXCLUDE REGEX "{regex}")\n'
-        "    endif()"
-    )
-
-
-def _lwip_empty_sources_filter() -> str:
-    gates = "\n".join(lwip_empty_source_gate(*entry) for entry in LWIP_EMPTY_SOURCES)
-    return _LWIP_EMPTY_SOURCES_FILTER.replace("@FILTERS@", gates)
-
-
-# Runs after project() so the walk has happened; catches the remaining
-# silent path where the top-level out-var was renamed.
-_LDGEN_OVERRIDE_CHECK = """\
-get_property(esphome_ldgen_armed GLOBAL PROPERTY ESPHOME_LDGEN_ARMED)
-get_property(esphome_ldgen_filtered GLOBAL PROPERTY ESPHOME_LDGEN_FILTERED)
-if(esphome_ldgen_armed AND NOT esphome_ldgen_filtered)
-    message(@SEVERITY@ "ESPHome ldgen override never filtered the app "
-        "archive; app edits will regenerate sections.ld.")
-endif()"""
-

 def get_available_components() -> list[str] | None:
    """List the built-in ESP-IDF components from ``project_description.json``.
@@ -158,78 +80,6 @@ def _cmake_quote(value: str) -> str:
    return f'"{escaped}"'


-# CONFIG_APP_BUILD_BOOTLOADER is hidden and force-selected, so it can only be
-# cleared at the CMake level (the same state IDF's RAM-app build type uses).
-# The macro is IDF's __build_process_project_includes plus two added lines;
-# the flag is ignored and the bootloader builds as usual if IDF changes it.
-IDF_BOOTLOADER_OVERRIDE = """\
-# ESPHome bootloader skip switch; see esphome/espidf/toolchain.py.
-if(ESPHOME_SKIP_BOOTLOADER)
-    macro(__build_process_project_includes)
-        idf_build_get_property(sdkconfig_cmake SDKCONFIG_CMAKE)
-        include(${sdkconfig_cmake})
-        set(CONFIG_APP_BUILD_BOOTLOADER "")
-        # bt's CMakeLists reads the lowercase idf_target that the (now
-        # skipped) bootloader project_include leaks; keep it defined, or
-        # its empty TARGET_SRC_NAME sends file(GLOB_RECURSE) across /.
-        idf_build_get_property(idf_target IDF_TARGET)
-        idf_build_get_property(build_properties __BUILD_PROPERTIES)
-        foreach(build_property ${build_properties})
-            idf_build_get_property(val ${build_property})
-            set(${build_property} "${val}")
-        endforeach()
-        idf_build_get_property(build_component_targets __BUILD_COMPONENT_TARGETS)
-        foreach(component_target ${build_component_targets})
-            __component_get_property(dir ${component_target} COMPONENT_DIR)
-            __component_get_property(_name ${component_target} COMPONENT_NAME)
-            set(COMPONENT_NAME ${_name})
-            set(COMPONENT_DIR ${dir})
-            set(COMPONENT_PATH ${dir})
-            if(EXISTS ${COMPONENT_DIR}/project_include.cmake)
-                include(${COMPONENT_DIR}/project_include.cmake)
-            endif()
-        endforeach()
-    endmacro()
-endif()
-"""
-
-# The lines the override adds to IDF's macro; idf_macro_matches() below
-# strips them before comparing with the live macro.
-BOOTLOADER_OVERRIDE_ADDED_LINES = (
-    'set(CONFIG_APP_BUILD_BOOTLOADER "")',
-    "idf_build_get_property(idf_target IDF_TARGET)",
-)
-
-_MACRO = re.compile(
-    r"macro\(__build_process_project_includes\)(.*?)endmacro\(\)", re.DOTALL
-)
-
-
-def _normalized_macro(text: str) -> list[str] | None:
-    """The macro body as comment-free, whitespace-collapsed lines."""
-    if (match := _MACRO.search(text)) is None:
-        return None
-    return [
-        re.sub(r"\s+", " ", line)
-        for raw in match.group(1).splitlines()
-        if (line := raw.split("#", 1)[0].strip())
-    ]
-
-
-_EXPECTED_MACRO = [
-    line
-    for line in _normalized_macro(IDF_BOOTLOADER_OVERRIDE)
-    if line not in BOOTLOADER_OVERRIDE_ADDED_LINES
-]
-
-
-def idf_macro_matches(idf_path: Path) -> bool:
-    """Whether IDF's macro still matches the copy the override replays."""
-    build_cmake = idf_path / "tools" / "cmake" / "build.cmake"
-    live = _normalized_macro(build_cmake.read_text(encoding="utf-8"))
-    return live == _EXPECTED_MACRO
-
-
 def get_project_cmakelists(
    minimal: bool = False, builtin_components: list[str] | None = None
 ) -> str:
@@ -275,22 +125,6 @@ def get_project_cmakelists(
        else ""
    )

-    # Stops the ~3s sections.ld regeneration on app-only edits; see
-    # _LDGEN_OVERRIDE. ESPHOME_LDGEN_FULL_DEPS=1 restores stock behavior;
-    # ESPHOME_LDGEN_STRICT=1 (CI) fails the configure when an IDF bump
-    # breaks the override instead of degrading to stock deps.
-    if get_bool_env("ESPHOME_LDGEN_FULL_DEPS"):
-        ldgen_override = ""
-        ldgen_override_check = ""
-    else:
-        strict = get_bool_env("ESPHOME_LDGEN_STRICT")
-        severity = "FATAL_ERROR" if strict else "WARNING"
-        missing = "FATAL_ERROR" if strict else "STATUS"
-        ldgen_override = _LDGEN_OVERRIDE.replace("@SEVERITY@", severity).replace(
-            "@MISSING@", missing
-        )
-        ldgen_override_check = _LDGEN_OVERRIDE_CHECK.replace("@SEVERITY@", severity)
-
    # CMake variables registered via cg.add_cmake_arg(). Emitted before
    # include(project.cmake) so values like EXCLUDE_COMPONENTS are already
    # set when project.cmake seeds the component list, and on minimal
@@ -368,9 +202,6 @@ set(EXTRA_COMPONENT_DIRS ${{CMAKE_SOURCE_DIR}}/src)

 include($ENV{{IDF_PATH}}/tools/cmake/project.cmake)

-{IDF_BOOTLOADER_OVERRIDE}
-{ldgen_override}
-
 {cpp_standard_options}

 {cxx_compile_options}
@@ -383,22 +214,14 @@ include($ENV{{IDF_PATH}}/tools/cmake/project.cmake)

 project({CORE.name})

-{ldgen_override_check}
-
-{_lwip_empty_sources_filter()}
-
 # Emit per-memory-type JSON size data for ESPHome to read post-build.
 # json2 stays small; raw dumps every symbol (~2s on a large map) and
 # this command runs inside the link edge, blocking everything downstream.
-# The map is a BYPRODUCT so ninja knows the link writes it; IDF's size
-# target depends on the map and can then be built in the same run as all.
-# IDF's cmakev2 declares the map itself, so drop this line on that switch.
 add_custom_command(
    TARGET ${{CMAKE_PROJECT_NAME}}.elf POST_BUILD
    COMMAND ${{PYTHON}} -m esp_idf_size {size_ng_flag} --format=json2
            -o ${{CMAKE_BINARY_DIR}}/esp_idf_size.json
            ${{CMAKE_PROJECT_NAME}}.map
-    BYPRODUCTS ${{CMAKE_BINARY_DIR}}/${{CMAKE_PROJECT_NAME}}.map
    WORKING_DIRECTORY ${{CMAKE_BINARY_DIR}}
    VERBATIM
 )
@@ -40,7 +40,6 @@ from esphome.cpp_generator import (  # noqa: F401
    progmem_array,
    safe_exp,
    set_cpp_standard,
-    shared_progmem_array,
    statement,
    static_const_array,
    static_function,
@@ -62,10 +62,16 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TVOC, var.set_tvoc)
-    await sensors(CONF_VERSION, var.set_version)
-    await sensors(CONF_RESISTANCE, var.set_resistance)
+    sens = await sensor.new_sensor(config[CONF_TVOC])
+    cg.add(var.set_tvoc(sens))
+
+    if version_config := config.get(CONF_VERSION):
+        sens = await sensor.new_sensor(version_config)
+        cg.add(var.set_version(sens))
+
+    if resistance_config := config.get(CONF_RESISTANCE):
+        sens = await sensor.new_sensor(resistance_config)
+        cg.add(var.set_resistance(sens))


 AGS10_NEW_I2C_ADDRESS_SCHEMA = cv.maybe_simple_value(
@@ -57,6 +57,10 @@ async def to_code(config: ConfigType) -> None:
    await i2c.register_i2c_device(var, config)
    cg.add(var.set_variant(config[CONF_VARIANT]))

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-    await sensors(CONF_HUMIDITY, var.set_humidity_sensor)
+    if temperature := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature)
+        cg.add(var.set_temperature_sensor(sens))
+
+    if humidity := config.get(CONF_HUMIDITY):
+        sens = await sensor.new_sensor(humidity)
+        cg.add(var.set_humidity_sensor(sens))
@@ -46,6 +46,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-    await sensors(CONF_HUMIDITY, var.set_humidity_sensor)
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
+
+    if humidity_config := config.get(CONF_HUMIDITY):
+        sens = await sensor.new_sensor(humidity_config)
+        cg.add(var.set_humidity_sensor(sens))
@@ -48,6 +48,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-    await sensors(CONF_HUMIDITY, var.set_humidity_sensor)
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
+
+    if humidity_config := config.get(CONF_HUMIDITY):
+        sens = await sensor.new_sensor(humidity_config)
+        cg.add(var.set_humidity_sensor(sens))
@@ -48,6 +48,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await ble_client.register_ble_node(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_BATTERY_LEVEL, var.set_battery)
-    await sensors(CONF_ILLUMINANCE, var.set_illuminance)
+    if battery_level_config := config.get(CONF_BATTERY_LEVEL):
+        sens = await sensor.new_sensor(battery_level_config)
+        cg.add(var.set_battery(sens))
+
+    if illuminance_config := config.get(CONF_ILLUMINANCE):
+        sens = await sensor.new_sensor(illuminance_config)
+        cg.add(var.set_illuminance(sens))
@@ -13,7 +13,6 @@ from esphome.components.logger import request_log_listener
 from esphome.components.noise import (  # noqa: F401
    ENCRYPTION_SCHEMA,
    decode_encryption_key,
-    enable_spare_ephemeral,
    encryption_schema,
    new_psk_progmem,
    validate_encryption_key,
@@ -601,7 +600,7 @@ async def to_code(config: ConfigType) -> None:

    if (encryption_config := config.get(CONF_ENCRYPTION, None)) is not None:
        if key := encryption_config.get(CONF_KEY):
-            cg.add(var.set_noise_psk(new_psk_progmem(key)))
+            cg.add(var.set_noise_psk(new_psk_progmem(config[CONF_ID], key)))
            cg.add_define("USE_API_NOISE_PSK_FROM_YAML")
        else:
            # No key provided, but encryption desired
@@ -614,7 +613,6 @@ async def to_code(config: ConfigType) -> None:
            # and plaintext disabled. Only a factory reset can remove it.
            cg.add_define("USE_API_PLAINTEXT")
        cg.add_define("USE_API_NOISE")
-        enable_spare_ephemeral()
    else:
        cg.add_define("USE_API_PLAINTEXT")

@@ -317,15 +317,9 @@ class APIConnection final : public APIServerConnectionBase {
  void on_noise_encryption_set_key_request(const NoiseEncryptionSetKeyRequest &msg);
 #endif

-  // How long a new connection holds off the spare ephemeral refill
-  static constexpr uint32_t CONNECT_GRACE_MS = 1000;
  bool is_authenticated() {
    return static_cast<ConnectionState>(this->flags_.connection_state) == ConnectionState::AUTHENTICATED;
  }
-  // An older unauthenticated connection is a stale half open client and does not count
-  bool is_still_connecting(uint32_t now) {
-    return !this->is_authenticated() && now - this->last_traffic_ < CONNECT_GRACE_MS;
-  }
  bool is_connection_setup() {
    return static_cast<ConnectionState>(this->flags_.connection_state) == ConnectionState::CONNECTED ||
           this->is_authenticated();
@@ -162,13 +162,6 @@ void APIServer::loop() {
    this->accept_new_connections_();
  }

-  const bool connected = network::is_connected();
-#ifdef USE_NOISE_SPARE_EPHEMERAL
-  if (connected && !noise::has_spare_ephemeral()) {
-    this->refill_spare_ephemeral_();
-  }
-#endif
-
  if (this->api_connection_count_ == 0) {
    // Check reboot timeout - done in loop to avoid scheduler heap churn
    // (cancelled scheduler items sit in heap memory until their scheduled time).
@@ -185,7 +178,8 @@ void APIServer::loop() {
  }

  // Process clients and remove disconnected ones in a single pass
-  if (!connected) {
+  // Check network connectivity once for all clients
+  if (!network::is_connected()) {
    // Network is down - disconnect all clients
    for (auto &client : this->active_clients()) {
      client->on_fatal_error();
@@ -213,19 +207,6 @@ void APIServer::loop() {
  }
 }

-#ifdef USE_NOISE_SPARE_EPHEMERAL
-// An OTA handshake is not visible here and just pays the refill it triggered
-void APIServer::refill_spare_ephemeral_() {
-  const uint32_t now = App.get_loop_component_start_time();
-  for (auto &client : this->active_clients()) {
-    if (client->is_still_connecting(now)) {
-      return;
-    }
-  }
-  noise::prepare_spare_ephemeral();
-}
-#endif
-
 void APIServer::remove_client_(uint8_t client_index) {
  auto &client = this->clients_[client_index];

@@ -5,7 +5,7 @@
 #include "api_buffer.h"
 // Must precede clients_ so APIConnection is complete for default_delete (libc++).
 #include "api_connection.h"
-#if defined(USE_API_NOISE) || defined(USE_NOISE_SPARE_EPHEMERAL)
+#ifdef USE_API_NOISE
 // Only present in the build when the noise component is loaded
 #include "esphome/components/noise/noise.h"
 #endif
@@ -367,9 +367,6 @@ class APIServer final : public Component
  uint8_t provisioning_source_{0};
 #endif

-#ifdef USE_NOISE_SPARE_EPHEMERAL
-  void refill_spare_ephemeral_();
-#endif
 #ifdef USE_API_NOISE
  noise::NoiseContext noise_ctx_;
 #ifndef USE_API_NOISE_PSK_FROM_YAML
@@ -35,6 +35,10 @@ CONFIG_SCHEMA = cv.Schema(
 async def to_code(config: ConfigType) -> None:
    hub = await cg.get_variable(config[CONF_AS3935_ID])

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_DISTANCE, hub.set_distance_sensor)
-    await sensors(CONF_LIGHTNING_ENERGY, hub.set_energy_sensor)
+    if distance_config := config.get(CONF_DISTANCE):
+        sens = await sensor.new_sensor(distance_config)
+        cg.add(hub.set_distance_sensor(sens))
+
+    if lightning_energy_config := config.get(CONF_LIGHTNING_ENERGY):
+        sens = await sensor.new_sensor(lightning_energy_config)
+        cg.add(hub.set_energy_sensor(sens))
@@ -241,9 +241,12 @@ async def to_code(config: ConfigType) -> None:
        if peak_current_config := conf.get(CONF_PEAK_CURRENT):
            sens = await sensor.new_sensor(peak_current_config)
            cg.add(var.set_peak_current_sensor(i, sens))
-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_FREQUENCY, var.set_freq_sensor)
-    await sensors(CONF_CHIP_TEMPERATURE, var.set_chip_temperature_sensor)
+    if frequency_config := config.get(CONF_FREQUENCY):
+        sens = await sensor.new_sensor(frequency_config)
+        cg.add(var.set_freq_sensor(sens))
+    if chip_temperature_config := config.get(CONF_CHIP_TEMPERATURE):
+        sens = await sensor.new_sensor(chip_temperature_config)
+        cg.add(var.set_chip_temperature_sensor(sens))
    cg.add(var.set_line_freq(config[CONF_LINE_FREQUENCY]))
    cg.add(var.set_current_phases(config[CONF_CURRENT_PHASES]))
    cg.add(var.set_pga_gain(config[CONF_GAIN_PGA]))
@@ -36,13 +36,14 @@ CONFIG_SCHEMA = cv.Schema(


 async def to_code(config: ConfigType) -> None:
-    hub = await cg.get_variable(config[CONF_ID])
+    parent = await cg.get_variable(config[CONF_ID])

    if phase_cfg := config.get(CONF_PHASE_STATUS):
        for i, key in enumerate(PHASE_KEYS):
            if sub_phase_cfg := phase_cfg.get(key):
                sens = await text_sensor.new_text_sensor(sub_phase_cfg)
-                cg.add(hub.set_phase_status_text_sensor(i, sens))
+                cg.add(parent.set_phase_status_text_sensor(i, sens))

-    text_sensors = text_sensor.sub_text_sensors(config)
-    await text_sensors(CONF_FREQUENCY_STATUS, hub.set_freq_status_text_sensor)
+    if freq_status_config := config.get(CONF_FREQUENCY_STATUS):
+        sens = await text_sensor.new_text_sensor(freq_status_config)
+        cg.add(parent.set_freq_status_text_sensor(sens))
@@ -14,10 +14,6 @@ class AudioDac {
  virtual bool is_muted() = 0;
  virtual float volume() = 0;

-  /// Called from the main loop by the speaker driving this DAC once its audio clocks are running.
-  /// DACs that can only be configured while clocked (e.g. DSP state lost across clock stops) override this.
-  virtual void on_audio_started() {}
-
 protected:
  bool is_muted_{false};
 };
@@ -44,6 +44,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await register_bedjet_child(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_OUTLET_TEMPERATURE, var.set_outlet_temperature_sensor)
-    await sensors(CONF_AMBIENT_TEMPERATURE, var.set_ambient_temperature_sensor)
+    if outlet_temperature_sensor := config.get(CONF_OUTLET_TEMPERATURE):
+        sensor_var = await sensor.new_sensor(outlet_temperature_sensor)
+        cg.add(var.set_outlet_temperature_sensor(sensor_var))
+
+    if ambient_temperature_sensor := config.get(CONF_AMBIENT_TEMPERATURE):
+        sensor_var = await sensor.new_sensor(ambient_temperature_sensor)
+        cg.add(var.set_ambient_temperature_sensor(sensor_var))
@@ -17,13 +17,6 @@
 #include "esphome/core/log.h"

 #include <cstring>
-#include <esp_idf_version.h>
-
-// cancel_open exists from ESP-IDF 5.5.5 and 6.0.1.
-#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 5) && ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(6, 0, 0)) || \
-    ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 1)
-#define BLUEDROID_HAS_CANCEL_OPEN
-#endif

 namespace esphome::bluetooth_connection {

@@ -70,12 +63,6 @@ void BluedroidGattClient::loop() {
    // The one teardown safety net: a lost CLOSE_EVT, or a scheduled
    // teardown whose OPEN_EVT never arrives.
    if (millis() - this->disconnecting_started_ > ble_device_base::GATT_DISCONNECT_TIMEOUT_MS) {
-      if (this->conn_id_ == UNSET_CONN_ID) {
-        this->cancel_pending_open_();
-      } else if (st == ClientState::CONNECTING) {
-        // CONNECT_EVT came but OPEN_EVT was lost, so our open still holds the ACL link.
-        this->check_and_log_error_("esp_ble_gap_disconnect", esp_ble_gap_disconnect(this->remote_bda_));
-      }
      ESP_LOGE(TAG, "[%d] Timeout waiting for teardown, forcing IDLE", this->connection_index_);
      // Release before idling: a lost completion must not leak the cache.
      this->release_services();
@@ -153,8 +140,6 @@ void BluedroidGattClient::tracker_connect_() {
  this->services_released_ = false;
  this->seen_mtu_ = false;
  this->mtu_failed_ = false;
-  this->cancel_open_sent_ = false;
-  this->conn_id_ = UNSET_CONN_ID;
  this->enable_loop();
  this->set_state(ClientState::CONNECTING);
  if (this->connection_type_ == ConnectionType::V3_WITHOUT_CACHE) {
@@ -198,28 +183,12 @@ int BluedroidGattClient::gatt_disconnect() {
    // Arm the safety window: a lost OPEN_EVT must not leak the teardown.
    this->disconnecting_started_ = millis();
    this->enable_loop();
-    if (this->conn_id_ == UNSET_CONN_ID) {
-      // CANCEL_OPEN_EVT or a racing OPEN_EVT settles the slot.
-      this->cancel_pending_open_();
-    }
    return 0;
  }
  this->unconditional_disconnect_();
  return 0;
 }

-void BluedroidGattClient::cancel_pending_open_() {
-#ifdef BLUEDROID_HAS_CANCEL_OPEN
-  esp_ble_gattc_cancel_open_params_t params{};
-  params.gattc_if = this->gattc_if_;
-  memcpy(params.remote_bda, this->remote_bda_, sizeof(esp_bd_addr_t));
-  // A refused cancel schedules no CANCEL_OPEN_EVT, so the teardown stays cancellable.
-  if (this->check_and_log_error_("esp_ble_gattc_cancel_open", esp_ble_gattc_cancel_open(&params)) == ESP_OK) {
-    this->cancel_open_sent_ = true;
-  }
-#endif
-}
-
 void BluedroidGattClient::unconditional_disconnect_() {
  ESP_LOGI(TAG, "[%d] Disconnecting (conn_id: %d)", this->connection_index_, this->conn_id_);
  if (this->conn_id_ == UNSET_CONN_ID) {
@@ -245,10 +214,6 @@ bool BluedroidGattClient::cancel_gatt_disconnect() {
  if (this->state() != ClientState::CONNECTING || !this->disconnect_pending()) {
    return false;
  }
-  if (this->cancel_open_sent_) {
-    // The cancel already went out, so CANCEL_OPEN_EVT ends it.
-    return false;
-  }
  this->want_disconnect_ = false;
  return true;
 }
@@ -609,8 +574,6 @@ void BluedroidGattClient::handle_open_evt_(esp_ble_gattc_cb_param_t *param) {
    this->listener_->on_connection_state(false, 0, param->open.status);
    return;
  }
-  // ALREADY_OPEN on an existing link sends no CONNECT_EVT, so take the id here.
-  this->conn_id_ = param->open.conn_id;
  if (this->disconnect_pending()) {
    // Open resolved with a teardown scheduled: close now (conn_id_ stays set
    // so CLOSE_EVT still matches).
@@ -654,11 +617,6 @@ void BluedroidGattClient::handle_disconnect_evt_(esp_ble_gattc_cb_param_t *param
    // Active close delivers CLOSE_EVT first; never walk back to DISCONNECTING.
    return;
  }
-  if (this->conn_id_ == UNSET_CONN_ID) {
-    // No CONNECT_EVT for this attempt yet, so the event belongs to an earlier
-    // link, such as one the teardown timeout forced down.
-    return;
-  }
  // Passive disconnect: wait for CLOSE_EVT before going IDLE (reconnecting
  // earlier makes the controller reject with 133 or assert) and before
  // reporting - the wrapper frees the slot on the report, and a freed slot
@@ -687,10 +645,6 @@ bool BluedroidGattClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
    case ESP_GATTC_CONNECT_EVT: {
      if (!this->check_addr_(param->connect.remote_bda))
        return false;
-      // Every client interface gets CONNECT_EVT for every new link; only an
-      // attempt in flight owns it. An idle slot must not adopt another slot's link.
-      if (this->state() != ClientState::CONNECTING)
-        break;
      this->conn_id_ = param->connect.conn_id;
      // MTU request here rather than OPEN_EVT, matching the IDF examples.
      auto ret = esp_ble_gattc_send_mtu_req(this->gattc_if_, param->connect.conn_id);
@@ -702,15 +656,8 @@ bool BluedroidGattClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
      break;
    }
    case ESP_GATTC_OPEN_EVT: {
-      if (!this->check_addr_(param->open.remote_bda)) {
-        // Our interface (filtered above), stale address, so nobody tracks this link.
-        if (param->open.status == ESP_GATT_OK || param->open.status == ESP_GATT_ALREADY_OPEN) {
-          ESP_LOGW(TAG, "[%d] Closing link left by an abandoned open", this->connection_index_);
-          this->check_and_log_error_("esp_ble_gattc_close", esp_ble_gattc_close(this->gattc_if_, param->open.conn_id));
-          return true;
-        }
+      if (!this->check_addr_(param->open.remote_bda))
        return false;
-      }
      this->handle_open_evt_(param);
      break;
    }
@@ -801,24 +748,6 @@ bool BluedroidGattClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_ga
      this->listener_->on_notify_data(param->notify.handle, param->notify.value, param->notify.value_len);
      break;
    }
-#ifdef BLUEDROID_HAS_CANCEL_OPEN
-    case ESP_GATTC_CANCEL_OPEN_EVT: {
-      if (!this->check_addr_(param->cancel_open.remote_bda))
-        return false;
-      if (param->cancel_open.status != ESP_GATT_OK) {
-        // Too late to cancel: OPEN_EVT follows and settles the slot. The latch
-        // stays set because the event cannot be tied to this attempt's cancel.
-        break;
-      }
-      if (this->state() == ClientState::CONNECTING && this->disconnect_pending()) {
-        ESP_LOGD(TAG, "[%d] Pending open cancelled", this->connection_index_);
-        this->release_services();
-        this->set_idle_();
-        this->listener_->on_connection_state(false, 0, ESP_GATT_CONN_CONN_CANCEL);
-      }
-      break;
-    }
-#endif
    default:
      break;
  }
@@ -100,7 +100,6 @@ class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public
  int handle_search_cmpl_(esp_gatt_status_t status);
  void deliver_pending_search_();
  void unconditional_disconnect_();
-  void cancel_pending_open_();
  void set_idle_();
  void set_disconnecting_();
  esp_err_t update_conn_params_(uint16_t min_interval, uint16_t max_interval, uint16_t latency, uint16_t timeout,
@@ -134,9 +133,6 @@ class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public
  bool seen_mtu_ : 1 {false};
  // The MTU request was refused at CONNECT_EVT; OPEN_EVT reports instead.
  bool mtu_failed_ : 1 {false};
-  // esp_ble_gattc_cancel_open() was accepted; CANCEL_OPEN_EVT or OPEN_EVT ends
-  // the attempt, so the scheduled teardown can no longer be cancelled.
-  bool cancel_open_sent_ : 1 {false};
  // Search issued at OPEN_EVT overlaps the MTU exchange; discover_services()
  // completes from it. Reset by set_idle_().
  static_assert(static_cast<uint8_t>(SearchState::REPORT_PENDING) < (1 << 4), "search_state_ bitfield too narrow");
@@ -88,11 +88,16 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_ACCELERATION_X, var.set_accel_x_sensor)
-    await sensors(CONF_GYROSCOPE_X, var.set_gyro_x_sensor)
-    await sensors(CONF_ACCELERATION_Y, var.set_accel_y_sensor)
-    await sensors(CONF_GYROSCOPE_Y, var.set_gyro_y_sensor)
-    await sensors(CONF_ACCELERATION_Z, var.set_accel_z_sensor)
-    await sensors(CONF_GYROSCOPE_Z, var.set_gyro_z_sensor)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
+    for d in ["x", "y", "z"]:
+        accel_key = f"acceleration_{d}"
+        if accel_key in config:
+            sens = await sensor.new_sensor(config[accel_key])
+            cg.add(getattr(var, f"set_accel_{d}_sensor")(sens))
+        accel_key = f"gyroscope_{d}"
+        if accel_key in config:
+            sens = await sensor.new_sensor(config[accel_key])
+            cg.add(getattr(var, f"set_gyro_{d}_sensor")(sens))
+
+    if CONF_TEMPERATURE in config:
+        sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
+        cg.add(var.set_temperature_sensor(sens))
@@ -48,6 +48,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature)
-    await sensors(CONF_PRESSURE, var.set_pressure)
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature(sens))
+
+    if pressure_config := config.get(CONF_PRESSURE):
+        sens = await sensor.new_sensor(pressure_config)
+        cg.add(var.set_pressure(sens))
@@ -75,13 +75,14 @@ async def to_code_base(config: ConfigType) -> MockObj:
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)

-    sensors = sensor.sub_sensors(config)
-    if await sensors(CONF_TEMPERATURE, var.set_temperature_sensor):
-        temperature_config = config[CONF_TEMPERATURE]
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
        cg.add(var.set_temperature_oversampling(temperature_config[CONF_OVERSAMPLING]))

-    if await sensors(CONF_PRESSURE, var.set_pressure_sensor):
-        pressure_config = config[CONF_PRESSURE]
+    if pressure_config := config.get(CONF_PRESSURE):
+        sens = await sensor.new_sensor(pressure_config)
+        cg.add(var.set_pressure_sensor(sens))
        cg.add(var.set_pressure_oversampling(pressure_config[CONF_OVERSAMPLING]))

    cg.add(var.set_iir_filter(config[CONF_IIR_FILTER]))
@@ -80,17 +80,18 @@ async def to_code_base(config: ConfigType) -> MockObj:
    await cg.register_component(var, config)

    cg.add(var.set_iir_filter_config(config[CONF_IIR_FILTER]))
-    sensors = sensor.sub_sensors(config)
-    if await sensors(CONF_TEMPERATURE, var.set_temperature_sensor):
-        temperature_config = config[CONF_TEMPERATURE]
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
        cg.add(
            var.set_temperature_oversampling_config(
                temperature_config[CONF_OVERSAMPLING]
            )
        )

-    if await sensors(CONF_PRESSURE, var.set_pressure_sensor):
-        pressure_config = config[CONF_PRESSURE]
+    if pressure_config := config.get(CONF_PRESSURE):
+        sens = await sensor.new_sensor(pressure_config)
+        cg.add(var.set_pressure_sensor(sens))
        cg.add(var.set_pressure_oversampling_config(pressure_config[CONF_OVERSAMPLING]))

    return var
@@ -137,9 +137,9 @@ CONFIG_SCHEMA_BASE = cv.Schema(
 async def to_code_base(config: ConfigType) -> MockObj:
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
-    sensors = sensor.sub_sensors(config)
-    if await sensors(CONF_TEMPERATURE, var.set_temperature_sensor):
-        temperature_config = config[CONF_TEMPERATURE]
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
        cg.add(
            var.set_temperature_oversampling_config(
                temperature_config[CONF_OVERSAMPLING]
@@ -149,8 +149,9 @@ async def to_code_base(config: ConfigType) -> MockObj:
            var.set_temperature_iir_filter_config(temperature_config[CONF_IIR_FILTER])
        )

-    if await sensors(CONF_PRESSURE, var.set_pressure_sensor):
-        pressure_config = config[CONF_PRESSURE]
+    if pressure_config := config.get(CONF_PRESSURE):
+        sens = await sensor.new_sensor(pressure_config)
+        cg.add(var.set_pressure_sensor(sens))
        cg.add(var.set_pressure_oversampling_config(pressure_config[CONF_OVERSAMPLING]))
        cg.add(var.set_pressure_iir_filter_config(pressure_config[CONF_IIR_FILTER]))

@@ -422,21 +422,6 @@ bool BTHomeMiThermometer::handle_service_data_(const ble_device_base::ServiceDat
        }
        break;
      }
-      case 0x45: {  // temperature (0.1C), e.g. Shelly BLU H&T
-        if (this->temperature_ != nullptr) {
-          const int16_t raw = encode_uint16(value[1], value[0]);
-          this->temperature_->publish_state(raw * 0.1f);
-          reported = true;
-        }
-        break;
-      }
-      case 0x2E: {  // humidity (uint8, 1%), e.g. Shelly BLU H&T
-        if (this->humidity_ != nullptr) {
-          this->humidity_->publish_state(value[0]);
-          reported = true;
-        }
-        break;
-      }
      default:
        break;
    }
@@ -368,11 +368,19 @@ optional<ClimateDeviceRestoreState> Climate::restore_state_() {
 }

 void Climate::save_state_(const ClimateTraits &traits) {
+#if (defined(USE_ESP32) || defined(USE_ESP8266)) && !defined(CLANG_TIDY)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wclass-memaccess"
+#define TEMP_IGNORE_MEMACCESS
+#endif
  ClimateDeviceRestoreState state{};
-  // initialize as zero (including padding) to prevent random data on stack triggering erase;
-  // the void * cast tells GCC the bytewise clear of a non-trivial type is intentional
+  // initialize as zero (including padding) to prevent random data on stack triggering erase
  // NOLINTNEXTLINE(bugprone-raw-memory-call-on-non-trivial-type) -- intentional bytewise zero for RTC save
-  memset(static_cast<void *>(&state), 0, sizeof(ClimateDeviceRestoreState));
+  memset(&state, 0, sizeof(ClimateDeviceRestoreState));
+#ifdef TEMP_IGNORE_MEMACCESS
+#pragma GCC diagnostic pop
+#undef TEMP_IGNORE_MEMACCESS
+#endif

  state.mode = this->mode;
  if (traits.has_feature_flags(CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE |
@@ -54,8 +54,9 @@ 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)
-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_CO2, var.set_co2_sensor)
+    if co2_config := config.get(CONF_CO2):
+        sens = await sensor.new_sensor(co2_config)
+        cg.add(var.set_co2_sensor(sens))


 CALIBRATION_ACTION_SCHEMA = maybe_simple_id(
@@ -203,5 +203,6 @@ async def to_code(config: ConfigType) -> None:
        else:
            cg.add(var.add_source(source))

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_STD_DEV, var.set_std_dev_sensor)
+    if CONF_STD_DEV in config:
+        sens = await sensor.new_sensor(config[CONF_STD_DEV])
+        cg.add(var.set_std_dev_sensor(sens))
@@ -7,7 +7,6 @@ BYTE_ORDER_BIG = "big_endian"

 CONF_ACCELEROMETER_ODR = "accelerometer_odr"
 CONF_ACCELEROMETER_RANGE = "accelerometer_range"
-CONF_ALLOWED_IPS = "allowed_ips"
 CONF_B_CONSTANT = "b_constant"
 CONF_BREATH_VOC_EQUIVALENT = "breath_voc_equivalent"
 CONF_BYTE_ORDER = "byte_order"
@@ -16,7 +15,6 @@ CONF_CLIMATE_ID = "climate_id"
 CONF_CO2_EQUIVALENT = "co2_equivalent"
 CONF_COLOR_DEPTH = "color_depth"
 CONF_COLUMNS = "columns"
-CONF_CONNECTED = "connected"
 CONF_CONVERSION_RATE = "conversion_rate"
 CONF_CRC_ENABLE = "crc_enable"
 CONF_DATA_BITS = "data_bits"
@@ -43,9 +41,7 @@ CONF_ON_SCAN_END = "on_scan_end"
 CONF_ON_STATE_CHANGE = "on_state_change"
 CONF_PARITY = "parity"
 CONF_RECEIVER_FREQUENCY = "receiver_frequency"
-CONF_RECONNECT_INTERVAL = "reconnect_interval"
 CONF_REQUEST_HEADERS = "request_headers"
-CONF_ROLE = "role"
 CONF_ROWS = "rows"
 CONF_SCAN_PARAMETERS = "scan_parameters"
 CONF_SHA256 = "sha256"
@@ -117,10 +117,15 @@ async def to_code(config: ConfigType) -> None:
    cg.add(var.set_hpf_enable(config[CONF_CURRENT_HPF], config[CONF_VOLTAGE_HPF]))
    cg.add(var.set_pulse_energy_wh(config[CONF_PULSE_ENERGY]))

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_VOLTAGE, var.set_voltage_sensor)
-    await sensors(CONF_CURRENT, var.set_current_sensor)
-    await sensors(CONF_POWER, var.set_power_sensor)
+    if voltage_config := config.get(CONF_VOLTAGE):
+        sens = await sensor.new_sensor(voltage_config)
+        cg.add(var.set_voltage_sensor(sens))
+    if current_config := config.get(CONF_CURRENT):
+        sens = await sensor.new_sensor(current_config)
+        cg.add(var.set_current_sensor(sens))
+    if power_config := config.get(CONF_POWER):
+        sens = await sensor.new_sensor(power_config)
+        cg.add(var.set_power_sensor(sens))


 automation.register_apply_action(
@@ -61,8 +61,11 @@ async def to_code(config: ConfigType) -> None:
    pin = await gpio_pin_expression(config[CONF_PIN])
    cg.add(var.set_pin(pin))

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-    await sensors(CONF_HUMIDITY, var.set_humidity_sensor)
+    if CONF_TEMPERATURE in config:
+        sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
+        cg.add(var.set_temperature_sensor(sens))
+    if CONF_HUMIDITY in config:
+        sens = await sensor.new_sensor(config[CONF_HUMIDITY])
+        cg.add(var.set_humidity_sensor(sens))

    cg.add(var.set_dht_model(config[CONF_MODEL]))
@@ -46,6 +46,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-    await sensors(CONF_HUMIDITY, var.set_humidity_sensor)
+    if CONF_TEMPERATURE in config:
+        sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
+        cg.add(var.set_temperature_sensor(sens))
+
+    if CONF_HUMIDITY in config:
+        sens = await sensor.new_sensor(config[CONF_HUMIDITY])
+        cg.add(var.set_humidity_sensor(sens))
@@ -287,15 +287,13 @@ template<typename T> class DisplayWriter {
 // Type alias for Display writer - uses optimized DisplayWriter instead of std::function
 using display_writer_t = DisplayWriter<Display>;

-// Callers usually pass `this`; checking a copy keeps GCC's -Wnonnull-compare quiet.
 #define LOG_DISPLAY(prefix, type, obj) \
-  if (auto *log_display_obj = (obj); log_display_obj != nullptr) { \
+  if ((obj) != nullptr) { \
    ESP_LOGCONFIG(TAG, \
                  prefix type "\n" \
                              "%s  Rotations: %d °\n" \
                              "%s  Dimensions: %dpx x %dpx", \
-                  prefix, log_display_obj->rotation_, prefix, log_display_obj->get_width(), \
-                  log_display_obj->get_height()); \
+                  prefix, (obj)->rotation_, prefix, (obj)->get_width(), (obj)->get_height()); \
  }

 /// Turn the pixel OFF.
@@ -54,6 +54,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-    await sensors(CONF_PRESSURE, var.set_pressure_sensor)
+    if temperature := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature)
+        cg.add(var.set_temperature_sensor(sens))
+
+    if pressure := config.get(CONF_PRESSURE):
+        sens = await sensor.new_sensor(pressure)
+        cg.add(var.set_pressure_sensor(sens))
@@ -63,8 +63,9 @@ async def to_code(config: ConfigType) -> None:
    if CONF_LAMBDA in config:
        lambda_ = await cg.process_lambda(config[CONF_LAMBDA], [], return_type=cg.bool_)
        cg.add(var.set_lambda(lambda_))
-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_LAST_TIME, var.set_last_duty_time_sensor)
+    if CONF_LAST_TIME in config:
+        sens = await sensor.new_sensor(config[CONF_LAST_TIME])
+        cg.add(var.set_last_duty_time_sensor(sens))


 # AUTOMATIONS
@@ -57,7 +57,14 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-    await sensors(CONF_CO2, var.set_co2_sensor)
-    await sensors(CONF_PRESSURE, var.set_pressure_sensor)
+    if temperature := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature)
+        cg.add(var.set_temperature_sensor(sens))
+
+    if co2 := config.get(CONF_CO2):
+        sens = await sensor.new_sensor(co2)
+        cg.add(var.set_co2_sensor(sens))
+
+    if pressure := config.get(CONF_PRESSURE):
+        sens = await sensor.new_sensor(pressure)
+        cg.add(var.set_pressure_sensor(sens))
@@ -50,6 +50,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-    await sensors(CONF_HUMIDITY, var.set_humidity_sensor)
+    if CONF_TEMPERATURE in config:
+        sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
+        cg.add(var.set_temperature_sensor(sens))
+
+    if CONF_HUMIDITY in config:
+        sens = await sensor.new_sensor(config[CONF_HUMIDITY])
+        cg.add(var.set_humidity_sensor(sens))
@@ -92,21 +92,6 @@ uint8_t ES8311::calculate_resolution_value(ES8311Resolution resolution) {
  }
 }

-/// Encodes the MCLK pre-multiplier for REG02 bits 3-4. The coefficient table stores the multiplier as the factor
-/// itself (1, 2, 4 or 8), while the register takes 0, 1, 2 or 3 (ES8311 datasheet, register 0x02 MULT_PRE).
-static uint8_t encode_pre_mult(uint8_t pre_mult) {
-  switch (pre_mult) {
-    case 2:
-      return 1;
-    case 4:
-      return 2;
-    case 8:
-      return 3;
-    default:
-      return 0;
-  }
-}
-
 const ES8311Coefficient *ES8311::get_coefficient(uint32_t mclk, uint32_t rate) {
  for (const auto &coefficient : ES8311_COEFFICIENTS) {
    if (coefficient.mclk == mclk && coefficient.rate == rate)
@@ -142,7 +127,7 @@ bool ES8311::configure_clock_() {
  ES8311_ERROR_CHECK(this->read_byte(ES8311_REG02_CLK_MANAGER, &reg02));
  reg02 &= 0x07;
  reg02 |= (coefficient->pre_div - 1) << 5;
-  reg02 |= encode_pre_mult(coefficient->pre_mult) << 3;
+  reg02 |= coefficient->pre_mult << 3;
  ES8311_ERROR_CHECK(this->write_byte(ES8311_REG02_CLK_MANAGER, reg02));

  // Register 0x03
@@ -30,13 +30,19 @@ CONFIG_SCHEMA = cv.All(


 async def to_code(config: ConfigType) -> None:
-    hub = await cg.get_variable(config[CONF_ES8388_ID])
-    selects = select.sub_selects(config, parent=hub)
-    await selects(
-        CONF_DAC_OUTPUT, hub.set_dac_output_select, options=["LINE1", "LINE2", "BOTH"]
-    )
-    await selects(
-        CONF_ADC_INPUT_MIC,
-        hub.set_adc_input_mic_select,
-        options=["LINE1", "LINE2", "DIFFERENCE"],
-    )
+    parent = await cg.get_variable(config[CONF_ES8388_ID])
+    if dac_output_config := config.get(CONF_DAC_OUTPUT):
+        s = await select.new_select(
+            dac_output_config,
+            options=["LINE1", "LINE2", "BOTH"],
+        )
+        await cg.register_parented(s, parent)
+        cg.add(parent.set_dac_output_select(s))
+
+    if adc_input_mic_config := config.get(CONF_ADC_INPUT_MIC):
+        s = await select.new_select(
+            adc_input_mic_config,
+            options=["LINE1", "LINE2", "DIFFERENCE"],
+        )
+        await cg.register_parented(s, parent)
+        cg.add(parent.set_adc_input_mic_select(s))
@@ -322,34 +322,6 @@ ARDUINO_EXCLUDED_IDF_COMPONENTS = (
    "joltwallet__littlefs",  # LittleFS - ESPHome doesn't use filesystem
 )

-# Entries arduino-esp32 only declares below the given IDF version; stubbing one past
-# it clashes with ESPHome's own managed component of the same short name.
-ARDUINO_EXCLUDED_IDF_COMPONENTS_MAX_IDF: dict[str, cv.Version] = {
-    "espressif__libsodium": cv.Version(6, 0, 0),
-}
-
-
-def arduino_bundles_libsodium() -> bool:
-    """arduino-esp32 ships its own libsodium below IDF 6.0."""
-    return (
-        CORE.using_arduino
-        and idf_version()
-        < ARDUINO_EXCLUDED_IDF_COMPONENTS_MAX_IDF["espressif__libsodium"]
-    )
-
-
-def arduino_excluded_idf_components() -> set[str]:
-    """The arduino-bundled components to stub for this build's IDF version."""
-    version = idf_version()
-    return {
-        component
-        for component in ARDUINO_EXCLUDED_IDF_COMPONENTS
-        if (max_version := ARDUINO_EXCLUDED_IDF_COMPONENTS_MAX_IDF.get(component))
-        is None
-        or version < max_version
-    }
-
-
 # Mapping of Arduino libraries to IDF managed components they require
 # When an Arduino library is enabled via cg.add_library(), these components
 # are automatically un-stubbed from ARDUINO_EXCLUDED_IDF_COMPONENTS.
@@ -670,29 +642,20 @@ def get_download_types(storage_json):
    # No recorded firmware path means nothing was built; no downloads.
    if storage_json.firmware_bin_path is None:
        return []
-    from esphome.espidf.toolchain import tree_skips_bootloader
-
-    types = []
-    # A --skip-bootloader tree deliberately has no factory image; an
-    # unreadable tree (PlatformIO, capability probes) reads as full.
-    if not tree_skips_bootloader(Path(storage_json.firmware_bin_path).parent):
-        types.append(
-            {
-                "title": "Factory format (Previously Modern)",
-                "description": "For use with ESPHome Web and other tools.",
-                "file": "firmware.factory.bin",
-                "download": f"{storage_json.name}.factory.bin",
-            }
-        )
-    types.append(
+    return [
+        {
+            "title": "Factory format (Previously Modern)",
+            "description": "For use with ESPHome Web and other tools.",
+            "file": "firmware.factory.bin",
+            "download": f"{storage_json.name}.factory.bin",
+        },
        {
            "title": "OTA format (Previously Legacy)",
            "description": "For OTA updating a device.",
            "file": "firmware.ota.bin",
            "download": f"{storage_json.name}.ota.bin",
-        }
-    )
-    return types
+        },
+    ]


 def only_on_variant(*, supported=None, unsupported=None, msg_prefix="This feature"):
@@ -3550,7 +3513,9 @@ def _write_idf_component_yml():
        }

        # Only stub components that are not required by any enabled Arduino library
-        components_to_stub = arduino_excluded_idf_components() - required_idf_components
+        components_to_stub = (
+            set(ARDUINO_EXCLUDED_IDF_COMPONENTS) - required_idf_components
+        )

        stubs_dir = CORE.relative_build_path("component_stubs")
        stubs_dir.mkdir(exist_ok=True)
@@ -3615,11 +3580,7 @@ def _write_idf_component_yml():
            # Don't process arduino libraries
            if name not in ARDUINO_DISABLED_LIBRARIES
        ]
-        # A library also declared as a managed component is not converted too, or
-        # IDF sees the same requirement twice; converted components reach it through
-        # ${ESPHOME_PROJECT_MANAGED_COMPONENTS}.
-        managed = set(CORE.data[KEY_ESP32].get(KEY_COMPONENTS, {}))
-        for component in generate_idf_components(libraries, managed=managed):
+        for component in generate_idf_components(libraries):
            dependencies[component.get_sanitized_name()] = {
                "override_path": str(component.path)
            }
@@ -436,25 +436,6 @@ async def to_code(config: ConfigType) -> None:
        cg.add_define("USE_ESP32_BLE_SOFTWARE_COEXISTENCE")


-# First tagged release per series with espressif/esp-idf@82e71c1767 (see bluedroid_stubs.cpp).
-# A series without an entry keeps the guard until a fixed release is tagged; the guard is
-# harmless on fixed sources. The 5.4, 5.5 and 6.1 branches carry the fix but have no tag yet.
-DIRECT_CONN_FIX_VERSIONS = {
-    (5, 2): cv.Version(5, 2, 8),
-    (5, 3): cv.Version(5, 3, 6),
-    (6, 0): cv.Version(6, 0, 3),
-}
-DIRECT_CONN_FIX_ALL_FROM = cv.Version(6, 2, 0)
-
-
-def _needs_direct_conn_guard() -> bool:
-    ver = idf_version()
-    if ver >= DIRECT_CONN_FIX_ALL_FROM:
-        return False
-    fixed = DIRECT_CONN_FIX_VERSIONS.get((ver.major, ver.minor))
-    return fixed is None or ver < fixed
-
-
 # This needs to be run as a job with very low priority so that all components have
 # chance to call register_ble_tracker and register_client before the list is checked
 # and added to the global defines list.
@@ -471,11 +452,6 @@ async def _add_ble_features() -> None:
    if BLEFeatures.ESP_BT_DEVICE in required_features:
        cg.add_define("USE_ESP32_BLE_DEVICE")
        cg.add_define("USE_ESP32_BLE_UUID")
-    if cg.get_slot_count(CLIENT_COUNT_DEFINE) and _needs_direct_conn_guard():
-        # --undefined keeps the wrapper, libsrc.a is scanned before the IDF libraries
-        cg.add_define("USE_ESP32_BLE_TRACKER_DIRECT_CONN_GUARD")
-        cg.add_build_flag("-Wl,--wrap=l2cble_init_direct_conn")
-        cg.add_build_flag("-Wl,--undefined=__wrap_l2cble_init_direct_conn")


 ESP32_BLE_START_SCAN_ACTION_SCHEMA = cv.Schema(
@@ -1,48 +0,0 @@
-/*
- * Bluedroid queues outgoing BLE connections as raw link block pointers and does
- * not drop them when the block is released, so btm_send_pending_direct_conn()
- * can start a connect on a released block and l2c_link_timeout() later crashes
- * on its null timer parameter. Mirrors espressif/esp-idf@82e71c1767; codegen
- * only enables it for releases without that commit.
- */
-
-#include "esphome/core/defines.h"
-
-#ifdef USE_ESP32_BLE_TRACKER_DIRECT_CONN_GUARD
-
-#include <esp_idf_version.h>
-#include <cstdint>
-#include "esphome/core/log.h"
-
-namespace esphome::esp32_ble_tracker {
-static const char *const TAG = "esp32_ble_tracker";
-}  // namespace esphome::esp32_ble_tracker
-
-static_assert(ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(6, 2, 0),
-              "ESP-IDF 6.2 and later have the fix, this guard should not be enabled (esphome/esphome#19373)");
-
-// NOLINTBEGIN(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
-extern "C" {
-
-bool __real_l2cble_init_direct_conn(void *p_lcb);
-void l2cu_release_lcb(void *p_lcb);
-
-bool __wrap_l2cble_init_direct_conn(void *p_lcb) {
-  // in_use is the first member of the private tL2C_LCB (checked ESP-IDF 5.0 to 6.1)
-  const auto *in_use = static_cast<const uint8_t *>(p_lcb);
-  if (p_lcb == nullptr || *in_use == 0) {
-    ESP_LOGW(esphome::esp32_ble_tracker::TAG, "Dropped queued connect on a released link block");
-    return false;
-  }
-  const bool started = __real_l2cble_init_direct_conn(p_lcb);
-  // Every failure path releases the block except unknown device, also fixed upstream
-  if (!started && *in_use != 0) {
-    l2cu_release_lcb(p_lcb);
-  }
-  return started;
-}
-
-}  // extern "C"
-// NOLINTEND(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
-
-#endif  // USE_ESP32_BLE_TRACKER_DIRECT_CONN_GUARD
@@ -315,19 +315,10 @@ FINAL_VALIDATE_SCHEMA = ota_esphome_final_validate


 FILTER_SOURCE_FILES = filter_source_files_from_defines(
-    {
-        "ota_esphome_noise.cpp": "USE_OTA_ENCRYPTION",
-        "ota_esphome_inflate_session.cpp": "USE_OTA_DEFLATE",
-        "ota_esphome_inflate.c": "USE_OTA_DEFLATE",
-    }
+    {"ota_esphome_noise.cpp": "USE_OTA_ENCRYPTION"}
 )


-def enable_deflate() -> None:
-    """Compile the on-the-fly inflater for compressed uploads."""
-    cg.add_define("USE_OTA_DEFLATE")
-
-
@coroutine_with_priority(CoroPriority.OTA_UPDATES)
 async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
@@ -349,10 +340,6 @@ async def to_code(config: ConfigType) -> None:
    if config.get(CONF_ALLOW_PARTITION_ACCESS):
        cg.add_define("USE_OTA_PARTITIONS")

-    # ESP8266 and RP2040 inflate gzip at reboot; the rest inflate on the fly
-    if not (CORE.is_esp8266 or CORE.is_rp2):
-        enable_deflate()
-
    # One key per device: an api encryption block supplies it (static or
    # runtime) and offers; the ota block only adds the requirement
    api_conf = CORE.config.get(CONF_API) or {}
@@ -360,7 +347,7 @@ async def to_code(config: ConfigType) -> None:
        # Build time key: the ota keeps its own pointer so safe mode, which
        # has no api server, still has it
        cg.add_define("USE_OTA_ENCRYPTION")
-        cg.add(var.set_noise_psk(new_psk_progmem(key)))
+        cg.add(var.set_noise_psk(new_psk_progmem(config[CONF_ID], key)))
    elif CONF_ENCRYPTION in api_conf:
        # Runtime key: found in the api server, or in preferences in safe mode
        cg.add_define("USE_OTA_ENCRYPTION")
@@ -22,10 +22,8 @@
 #include "esphome/core/lwip_fast_select.h"
 #endif

-#include <algorithm>
 #include <cerrno>
 #include <cstdio>
-#include <cstring>
 #include <sys/time.h>

 namespace esphome {
@@ -49,8 +47,6 @@ static constexpr uint32_t OTA_SOCKET_TIMEOUT_HANDSHAKE = 20000;  // milliseconds
 // practice for a lost chunk ack (1.5 + 3 + 6 + 12 + 24 + 48 s); the CLI waits
 // longer (espota2.DATA_PHASE_TIMEOUT) so the device is free before it retries
 static constexpr uint32_t OTA_SOCKET_TIMEOUT_DATA = 105000;
-static constexpr uint32_t OTA_PROGRESS_INTERVAL_MS = 1000;
-static constexpr size_t OTA_SIZE_FIELD_BYTES = 4;  // sizes on the wire are 4 bytes MSB first

 // Single-instance pointer — multi-port configs are rejected in final_validate.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
@@ -198,23 +194,12 @@ static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_COMPRESSION = 0x01;
 static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_SHA256_AUTH = 0x02;
 static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL = 0x04;
 static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_NOISE = 0x08;
-static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_DEFLATE = 0x10;
 // Noise needs the extended protocol: the prologue binds the 2-byte feature ack
 static constexpr uint8_t CLIENT_NOISE_FEATURES =
    CLIENT_FEATURE_SUPPORTS_NOISE | CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL;
 static constexpr uint8_t SERVER_FEATURE_SUPPORTS_COMPRESSION = 0x01;
 static constexpr uint8_t SERVER_FEATURE_SUPPORTS_PARTITION_ACCESS = 0x02;
 static constexpr uint8_t SERVER_FEATURE_SUPPORTS_NOISE = 0x04;
-// Raw deflate, window <= OTA_INFLATE_WINDOW_SIZE. Binding once offered: the
-// client must then send the image size frame and a deflate stream.
-static constexpr uint8_t SERVER_FEATURE_SUPPORTS_DEFLATE = 0x08;
-
-#ifdef USE_OTA_ENCRYPTION
-inline bool ESPHomeOTAComponent::noise_offered_() const {
-  return (this->handshake_buf_[1] & SERVER_FEATURE_SUPPORTS_NOISE) != 0 &&
-         (this->ota_features_ & CLIENT_NOISE_FEATURES) == CLIENT_NOISE_FEATURES;
-}
-#endif

 inline bool ESPHomeOTAComponent::extended_proto_() const {
 #ifdef USE_OTA_ENCRYPTION_REQUIRED
@@ -320,7 +305,7 @@ void ESPHomeOTAComponent::handle_handshake_() {
      this->transition_ota_state_(OTAState::FEATURE_ACK);

      const bool supports_compression =
-          (this->ota_features_ & CLIENT_FEATURE_SUPPORTS_COMPRESSION) != 0 && ota::OTABackend::supports_compression();
+          (this->ota_features_ & CLIENT_FEATURE_SUPPORTS_COMPRESSION) != 0 && this->backend_->supports_compression();

      // Compose the feature-ack response. When the client negotiates the extended protocol we emit
      // a 2-byte response (marker + server feature flags); otherwise we emit the single-byte
@@ -340,28 +325,6 @@ void ESPHomeOTAComponent::handle_handshake_() {
 #elif defined(USE_OTA_ENCRYPTION)
        // A yaml key always exists: validation rejects the all-zeros key
        this->handshake_buf_[1] |= SERVER_FEATURE_SUPPORTS_NOISE;
-#endif
-#ifdef USE_OTA_ENCRYPTION
-        // Reserve the noise session before the optional inflate buffer, so the
-        // required allocation is not starved by the compression window
-        if (this->noise_offered_()) {
-          this->noise_reserve_session_();
-        }
-#endif
-#ifdef USE_OTA_DEFLATE
-        // Offered only once the session memory is in hand; else uncompressed
-        if ((this->ota_features_ & CLIENT_FEATURE_SUPPORTS_DEFLATE) != 0) {
-          // Value initialized: a corrupt stream that back references the
-          // window before it is filled then copies zeros, never stale memory.
-          // Default placement, PSRAM first where present: the session lives for one
-          // upload and keeps 4.9 KB of internal heap free while it runs
-          this->inflate_ = RAMAllocator<InflateSession>().make_unique();
-          if (this->inflate_ != nullptr) {
-            this->handshake_buf_[1] |= SERVER_FEATURE_SUPPORTS_DEFLATE;
-          } else {
-            ESP_LOGW(TAG, "No memory to inflate");
-          }
-        }
 #endif
      } else {
        this->handshake_buf_[0] =
@@ -380,7 +343,8 @@ void ESPHomeOTAComponent::handle_handshake_() {
 #ifdef USE_OTA_ENCRYPTION
      // Latch the offer actually sent: a key activating between the two
      // states must not start a session the client never expects
-      if (this->noise_offered_()) {
+      if ((this->handshake_buf_[1] & SERVER_FEATURE_SUPPORTS_NOISE) != 0 &&
+          (this->ota_features_ & CLIENT_NOISE_FEATURES) == CLIENT_NOISE_FEATURES) {
        // handshake_buf_ still holds the feature ack composed above; a
        // would-block re-entry lands here without rebuilding it
        if (!this->noise_start_session_(this->handshake_buf_[1])) {
@@ -478,11 +442,16 @@ void ESPHomeOTAComponent::handle_data_() {
  // Backend calls overwrite this with OK; reset to UNKNOWN before any
  // goto error that follows a successful begin()/write()
  ota::OTAResponseTypes error_code = ota::OTA_RESPONSE_ERROR_UNKNOWN;
-  DataTransfer xfer;
+  size_t total = 0;
+  uint32_t last_progress = 0;
+  uint32_t last_data_ms = 0;
  uint8_t buf[OTA_BUFFER_SIZE];
  char *sbuf = reinterpret_cast<char *>(buf);
-  size_t image_size;
+  size_t ota_size;
  ota::OTAType ota_type = ota::OTA_TYPE_UPDATE_APP;
+#if USE_OTA_VERSION == 2
+  size_t size_acknowledged = 0;
+#endif

  // Set socket timeouts and blocking mode (see strategy table above)
  struct timeval tv;
@@ -511,20 +480,16 @@ void ESPHomeOTAComponent::handle_data_() {
  ESP_LOGV(TAG, "OTA type is 0x%02x", ota_type);

  // Read size, 4 bytes MSB first
-  if (!this->read_size_(buf, xfer.ota_size, LOG_STR("size"))) {
+  if (!this->data_readall_(buf, 4)) {
    // The first request byte is the type on the extended protocol; a close after it was a cut-off request
    if (!this->extended_proto_() && this->client_left_before_start_())
      return;
    this->log_read_error_(LOG_STR("size"));
    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
  }
-  image_size = xfer.ota_size;
-#ifdef USE_OTA_DEFLATE
-  if (this->inflate_ != nullptr && !this->read_size_(buf, image_size, LOG_STR("image size"))) {
-    this->log_read_error_(LOG_STR("image size"));
-    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
-  }
-#endif
+  ota_size = (static_cast<size_t>(buf[0]) << 24) | (static_cast<size_t>(buf[1]) << 16) |
+             (static_cast<size_t>(buf[2]) << 8) | buf[3];
+  ESP_LOGV(TAG, "Size is %zu bytes", ota_size);

 #ifndef USE_OTA_PARTITIONS
  if (ota_type != ota::OTA_TYPE_UPDATE_APP) {
@@ -544,7 +509,7 @@ void ESPHomeOTAComponent::handle_data_() {
 #endif

  // begin() returns quickly; flash sectors are erased incrementally during write().
-  error_code = this->backend_->begin(image_size, ota_type);
+  error_code = this->backend_->begin(ota_size, ota_type);
  if (error_code != ota::OTA_RESPONSE_OK)
    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)

@@ -564,25 +529,77 @@ void ESPHomeOTAComponent::handle_data_() {
  // Acknowledge MD5 OK - 1 byte
  this->data_write_byte_(ota::OTA_RESPONSE_BIN_MD5_OK);

-  xfer.last_data_ms = millis();
-#ifdef USE_OTA_DEFLATE
-  if (this->inflate_ != nullptr) {
-    error_code = this->inflate_data_(buf, image_size, xfer);
-    if (error_code != ota::OTA_RESPONSE_OK)
+  // Track when we last received data so a silently-vanished peer (no FIN/RST
+  // delivered, e.g. uploader killed mid-transfer or NAT/router dropped state)
+  // can't wedge the device indefinitely. Without this, the loop only exits
+  // on actual data, EOF, or a non-EWOULDBLOCK error from read(), and lwIP
+  // TCP keepalive isn't enabled here.
+  last_data_ms = millis();
+  while (total < ota_size) {
+    if (millis() - last_data_ms > OTA_SOCKET_TIMEOUT_DATA) {
+      ESP_LOGW(TAG, "No data received for %u ms", (unsigned) OTA_SOCKET_TIMEOUT_DATA);
+      error_code = ota::OTA_RESPONSE_ERROR_UNKNOWN;
      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
-  } else
-#endif
-  {
-    while (xfer.total < xfer.ota_size) {
-      ssize_t read = this->receive_data_(buf, xfer);
-      if (read < 0) {
+    }
+    size_t remaining = ota_size - total;
+    size_t requested = remaining < OTA_BUFFER_SIZE ? remaining : OTA_BUFFER_SIZE;
+    ssize_t read;
+#ifdef USE_OTA_ENCRYPTION
+    if (this->noise_ != nullptr) {
+      // One frame per call; noise_read_data_ waits internally (readall_), so
+      // there is no would-block retry here and failures are already logged.
+      read = this->noise_read_data_(buf, requested);
+      if (read <= 0) {
+        if (this->remote_closed_)
+          this->log_remote_closed_(LOG_STR("data"));
        error_code = ota::OTA_RESPONSE_ERROR_UNKNOWN;
        goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
      }
-      error_code = this->write_flash_(buf, read);
-      if (error_code != ota::OTA_RESPONSE_OK)
+    } else
+#endif
+    {
+      read = this->client_->read(buf, requested);
+      if (read == -1) {
+        const int err = errno;
+        if (this->would_block_(err)) {
+          // read() already waited up to SO_RCVTIMEO for data, just feed WDT
+          App.feed_wdt();
+          continue;
+        }
+        ESP_LOGW(TAG, "Read err %d", err);
+        error_code = ota::OTA_RESPONSE_ERROR_UNKNOWN;
        goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
-      this->ack_written_(xfer);
+      } else if (read == 0) {
+        ESP_LOGW(TAG, "Remote closed");
+        error_code = ota::OTA_RESPONSE_ERROR_UNKNOWN;
+        goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
+      }
+    }
+
+    last_data_ms = millis();
+    error_code = this->backend_->write(buf, read);
+    if (error_code != ota::OTA_RESPONSE_OK) {
+      ESP_LOGW(TAG, "Flash write err %d", error_code);
+      goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
+    }
+    total += read;
+#if USE_OTA_VERSION == 2
+    while (size_acknowledged + OTA_BLOCK_SIZE <= total || (total == ota_size && size_acknowledged < ota_size)) {
+      this->data_write_byte_(ota::OTA_RESPONSE_CHUNK_OK);
+      size_acknowledged += OTA_BLOCK_SIZE;
+    }
+#endif
+
+    uint32_t now = millis();
+    if (now - last_progress > 1000) {
+      last_progress = now;
+      float percentage = (total * 100.0f) / ota_size;
+      ESP_LOGD(TAG, "Progress: %0.1f%%", percentage);
+#ifdef USE_OTA_STATE_LISTENER
+      this->notify_state_(ota::OTA_IN_PROGRESS, percentage, 0);
+#endif
+      // feed watchdog and give other tasks a chance to run
+      this->yield_and_feed_watchdog_();
    }
  }

@@ -798,90 +815,6 @@ bool ESPHomeOTAComponent::try_write_(size_t to_write, const LogString *desc) {
  return this->handshake_buf_pos_ >= to_write;
 }

-bool ESPHomeOTAComponent::read_size_(uint8_t *buf, size_t &size, const LogString *desc) {
-  if (!this->data_readall_(buf, OTA_SIZE_FIELD_BYTES))
-    return false;
-  size = encode_uint32(buf[0], buf[1], buf[2], buf[3]);
-  ESP_LOGV(TAG, "%s is %zu bytes", LOG_STR_ARG(desc), size);
-  return true;
-}
-
-ota::OTAResponseTypes ESPHomeOTAComponent::write_flash_(uint8_t *data, size_t len) {
-  ota::OTAResponseTypes result = this->backend_->write(data, len);
-  if (result != ota::OTA_RESPONSE_OK) {
-    ESP_LOGW(TAG, "Flash write err %d", result);
-  }
-  return result;
-}
-
-ssize_t ESPHomeOTAComponent::receive_data_(uint8_t *buf, DataTransfer &xfer) {
-  const size_t remaining = xfer.ota_size - xfer.total;
-  const size_t requested = std::min(remaining, OTA_BUFFER_SIZE);
-  ssize_t read;
-  for (;;) {
-    // A silently-vanished peer (no FIN/RST delivered, e.g. uploader killed
-    // mid-transfer or NAT/router dropped state) must not wedge the device:
-    // read() only fails on EOF or a real error, and lwIP TCP keepalive isn't
-    // enabled here.
-    if (millis() - xfer.last_data_ms > OTA_SOCKET_TIMEOUT_DATA) {
-      ESP_LOGW(TAG, "No data received for %u ms", (unsigned) OTA_SOCKET_TIMEOUT_DATA);
-      return -1;
-    }
-#ifdef USE_OTA_ENCRYPTION
-    if (this->noise_ != nullptr) {
-      // One frame per call; noise_read_data_ waits internally (readall_), so
-      // there is no would-block retry here and failures are already logged.
-      read = this->noise_read_data_(buf, requested);
-      if (read <= 0) {
-        if (this->remote_closed_)
-          this->log_remote_closed_(LOG_STR("data"));
-        return -1;
-      }
-      break;
-    }
-#endif
-    read = this->client_->read(buf, requested);
-    if (read > 0)
-      break;
-    if (read == 0) {
-      this->log_remote_closed_(LOG_STR("data"));
-      return -1;
-    }
-    if (!this->would_block_(errno)) {
-      this->log_socket_error_(LOG_STR("data"));
-      return -1;
-    }
-    // read() already waited up to SO_RCVTIMEO for data, just feed WDT
-    App.feed_wdt();
-  }
-
-  const uint32_t now = millis();
-  xfer.last_data_ms = now;
-  xfer.total += read;
-  this->ack_received_(xfer);
-  if (now - xfer.last_progress > OTA_PROGRESS_INTERVAL_MS) {
-    xfer.last_progress = now;
-    float percentage = (xfer.total * 100.0f) / xfer.ota_size;
-    ESP_LOGD(TAG, "Progress: %0.1f%%", percentage);
-#ifdef USE_OTA_STATE_LISTENER
-    this->notify_state_(ota::OTA_IN_PROGRESS, percentage, 0);
-#endif
-    // feed watchdog and give other tasks a chance to run
-    this->yield_and_feed_watchdog_();
-  }
-  return read;
-}
-
-void ESPHomeOTAComponent::send_chunk_acks_(DataTransfer &xfer) {
-#if USE_OTA_VERSION == 2
-  while (xfer.acknowledged + OTA_BLOCK_SIZE <= xfer.total ||
-         (xfer.total == xfer.ota_size && xfer.acknowledged < xfer.ota_size)) {
-    this->data_write_byte_(ota::OTA_RESPONSE_CHUNK_OK);
-    xfer.acknowledged += OTA_BLOCK_SIZE;
-  }
-#endif
-}
-
 void ESPHomeOTAComponent::cleanup_connection_() {
  this->client_->close();
  this->client_ = nullptr;
@@ -896,9 +829,6 @@ void ESPHomeOTAComponent::cleanup_connection_() {
 #endif
 #ifdef USE_OTA_ENCRYPTION
  this->noise_ = nullptr;
-#endif
-#ifdef USE_OTA_DEFLATE
-  this->inflate_ = nullptr;
 #endif
  // Intentionally no disable_loop() — letting loop() run one more iteration catches
  // any connection that queued on the listener mid-session (otherwise the wake flag,
@@ -7,9 +7,6 @@
 #ifdef USE_OTA_ENCRYPTION
 #include "esphome/components/noise/noise_handshake.h"
 #endif
-#ifdef USE_OTA_DEFLATE
-#include "ota_esphome_inflate.h"
-#endif
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/preferences.h"
@@ -92,9 +89,6 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
  // The api server's live context when it exists, otherwise our own (a build
  // time key, or the saved key loaded in safe mode)
  const noise::NoiseContext &noise_context_() const;
-  // True once the feature ack offers noise and the client asked for it
-  bool noise_offered_() const;
-  void noise_reserve_session_();
  bool noise_start_session_(uint8_t server_feature_flags);
  bool handle_noise_handshake_();
  bool noise_try_read_frame_();
@@ -126,38 +120,6 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
    return this->readall_(buf, len);
  }

-  // Upload accounting shared by the data loop and the inflate read callback
-  struct DataTransfer {
-    size_t ota_size{0};  // bytes the client sends
-    size_t total{0};     // bytes received so far
-#if USE_OTA_VERSION == 2
-    size_t acknowledged{0};
-#endif
-    uint32_t last_data_ms{0};
-    uint32_t last_progress{0};
-  };
-  // Up to OTA_BUFFER_SIZE bytes into buf; returns bytes read, -1 on failure (logged)
-  ssize_t receive_data_(uint8_t *buf, DataTransfer &xfer);
-  // Raw lwIP cannot service the radio during a sector write, so the ack waits
-  // for the write there; a socket task lets the next block arrive meanwhile
-#ifdef USE_SOCKET_IMPL_LWIP_TCP
-  static constexpr bool ACK_AFTER_WRITE = true;
-#else
-  static constexpr bool ACK_AFTER_WRITE = false;
-#endif
-  void send_chunk_acks_(DataTransfer &xfer);
-  inline void ack_received_(DataTransfer &xfer) {
-    if (!ACK_AFTER_WRITE)
-      this->send_chunk_acks_(xfer);
-  }
-  inline void ack_written_(DataTransfer &xfer) {
-    if (ACK_AFTER_WRITE)
-      this->send_chunk_acks_(xfer);
-  }
-  inline bool read_size_(uint8_t *buf, size_t &size, const LogString *desc);
-  // Writes to the backend and logs a failure
-  ota::OTAResponseTypes write_flash_(uint8_t *data, size_t len);
-
  bool try_read_(size_t to_read, const LogString *desc);
  bool try_write_(size_t to_write, const LogString *desc);

@@ -213,34 +175,6 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
  static_assert(OTA_BUFFER_SIZE >= NOISE_CLIENT_MAX_PLAINTEXT + noise::MAC_SIZE,
                "OTA_BUFFER_SIZE must fit a full encrypted data frame");
 #endif
-#ifdef USE_OTA_DEFLATE
-  // At least 1 << espota2.DEFLATE_WINDOW_BITS; also the inflate output buffer
-  static constexpr size_t OTA_INFLATE_WINDOW_SIZE = 4096;
-  // Heap-allocated only while a deflate upload is negotiated; the decoder
-  // state is the base so the read callback can recover the session
-  struct InflateSession : OtaInflateState {
-    // The session outlives the upload it serves, but these three are borrowed
-    // from inflate_data_'s caller and dangle once that call returns; only that
-    // call, and the flush and read callback it drives, may read them
-    ESPHomeOTAComponent *self;
-    DataTransfer *xfer;
-    uint8_t *in;  // caller's buffer for the compressed input
-    size_t image_size;
-    size_t written;               // inflated bytes in flash
-    size_t flushed;               // bytes of the current window already in flash
-    ota::OTAResponseTypes error;  // first failure inside the read callback
-    uint8_t window[OTA_INFLATE_WINDOW_SIZE];
-  };
-#ifndef CLANG_TIDY  // static analysis sets every define at once
-  static_assert(!ota::OTABackend::supports_compression(),
-                "USE_OTA_DEFLATE is for backends that cannot store a gzip image");
-#endif
-  // Writes the decoded bytes not yet in flash without moving dest
-  ota::OTAResponseTypes inflate_flush_(InflateSession &session);
-  ota::OTAResponseTypes inflate_data_(uint8_t *in, size_t image_size, DataTransfer &xfer);
-  RAMUniquePtr<InflateSession> inflate_;
-#endif
-
  static constexpr uint8_t MAGIC_BYTES[5] = {0x6C, 0x26, 0xF7, 0x5C, 0x45};
  // Derived from the feature byte; storing it would pad the trailing bytes
  bool extended_proto_() const;
@@ -1,498 +0,0 @@
-/*
- * uzlib  -  tiny deflate/inflate library (deflate, gzip, zlib)
- *
- * Copyright (c) 2003 by Joergen Ibsen / Jibz
- * All Rights Reserved
- * http://www.ibsensoftware.com/
- *
- * Copyright (c) 2014-2018 by Paul Sokolovsky
- *
- * This software is provided 'as-is', without any express
- * or implied warranty.  In no event will the authors be
- * held liable for any damages arising from the use of
- * this software.
- *
- * Permission is granted to anyone to use this software
- * for any purpose, including commercial applications,
- * and to alter it and redistribute it freely, subject to
- * the following restrictions:
- *
- * 1. The origin of this software must not be
- *    misrepresented; you must not claim that you
- *    wrote the original software. If you use this
- *    software in a product, an acknowledgment in
- *    the product documentation would be appreciated
- *    but is not required.
- *
- * 2. Altered source versions must be plainly marked
- *    as such, and must not be misrepresented as
- *    being the original software.
- *
- * 3. This notice may not be removed or altered from
- *    any source distribution.
- */
-
-/*
- * Altered for ESPHome: this is the raw deflate decoder from uzlib's
- * tinflate.c (v2.9.5) with the gzip/zlib header parsers, checksums,
- * runtime table builder and in-memory (non ring window) output path
- * removed, and the public names prefixed with ota_inflate.
- */
-
-#include "ota_esphome_inflate.h"
-
-#include <stddef.h>
-
-#define TINF_OK OTA_INFLATE_OK
-#define TINF_DONE OTA_INFLATE_DONE
-#define TINF_DATA_ERROR OTA_INFLATE_DATA_ERROR
-#define TINF_DICT_ERROR OTA_INFLATE_DICT_ERROR
-#define TINF_DATA struct OtaInflateState
-#define TINF_TREE struct OtaInflateTree
-#define TINF_ARRAY_SIZE(arr) (sizeof(arr) / sizeof(*(arr)))
-
-/* every output byte also goes into the ring window */
-#define TINF_PUT(d, c) \
-  { \
-    *d->dest++ = c; \
-    d->dict_ring[d->dict_idx++] = c; \
-    if (d->dict_idx == d->dict_size) \
-      d->dict_idx = 0; \
-  }
-
-/* --------------------------------------------------- *
- * -- constant tables (upstream builds them at runtime) -- *
- * --------------------------------------------------- */
-
-static const unsigned char LENGTH_BITS[30] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2,
-                                              2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5};
-static const unsigned short LENGTH_BASE[30] = {3,  4,  5,  6,  7,  8,  9,  10, 11,  13,  15,  17,  19,  23, 27,
-                                               31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258};
-
-static const unsigned char DIST_BITS[30] = {0, 0, 0, 0, 1, 1, 2, 2,  3,  3,  4,  4,  5,  5,  6,
-                                            6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13};
-static const unsigned short DIST_BASE[30] = {1,    2,    3,    4,    5,    7,    9,    13,    17,    25,
-                                             33,   49,   65,   97,   129,  193,  257,  385,   513,   769,
-                                             1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577};
-
-/* special ordering of code length codes */
-static const unsigned char CLCIDX[] = {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
-
-/* ----------------------- *
- * -- utility functions -- *
- * ----------------------- */
-
-/* given an array of code lengths, build a tree */
-static void tinf_build_tree(TINF_TREE *t, const unsigned char *lengths, unsigned int num) {
-  unsigned short offs[16];
-  unsigned int i, sum;
-
-  /* clear code length count table */
-  for (i = 0; i < 16; ++i)
-    t->table[i] = 0;
-
-  /* scan symbol lengths, and sum code length counts */
-  for (i = 0; i < num; ++i)
-    t->table[lengths[i]]++;
-
-  /* In the lengths array, 0 means unused code. So, t->table[0] now contains
-     number of unused codes. But table's purpose is to contain # of codes of
-     particular length, and there're 0 codes of length 0. */
-  t->table[0] = 0;
-
-  /* compute offset table for distribution sort */
-  for (sum = 0, i = 0; i < 16; ++i) {
-    offs[i] = sum;
-    sum += t->table[i];
-  }
-
-  /* create code->symbol translation table (symbols sorted by code) */
-  for (i = 0; i < num; ++i) {
-    if (lengths[i])
-      t->trans[offs[lengths[i]]++] = i;
-  }
-}
-
-/* ---------------------- *
- * -- decode functions -- *
- * ---------------------- */
-
-static unsigned char uzlib_get_byte(TINF_DATA *d) {
-  /* If end of source buffer is not reached, return next byte from source
-     buffer. */
-  if (d->source < d->source_limit) {
-    return *d->source++;
-  }
-
-  /* Otherwise if there's callback and we haven't seen EOF yet, try to
-     read next byte using it. (Note: the callback can also update ->source
-     and ->source_limit). */
-  if (!d->eof) {
-    int val = d->source_read_cb(d);
-    if (val >= 0) {
-      return (unsigned char) val;
-    }
-  }
-
-  /* Otherwise, we hit EOF (either from ->source_read_cb() or from exhaustion
-     of the buffer), and it will be "sticky", i.e. further calls to this
-     function will end up here too. */
-  d->eof = true;
-
-  return 0;
-}
-
-/* get one bit from source stream */
-static int tinf_getbit(TINF_DATA *d) {
-  unsigned int bit;
-
-  /* check if tag is empty */
-  if (!d->bitcount--) {
-    /* load next tag */
-    d->tag = uzlib_get_byte(d);
-    d->bitcount = 7;
-  }
-
-  /* shift bit out of tag */
-  bit = d->tag & 0x01;
-  d->tag >>= 1;
-
-  return bit;
-}
-
-/* read a num bit value from a stream and add base */
-static unsigned int tinf_read_bits(TINF_DATA *d, int num, int base) {
-  unsigned int val = 0;
-
-  /* read num bits */
-  if (num) {
-    unsigned int limit = 1 << (num);
-    unsigned int mask;
-
-    for (mask = 1; mask < limit; mask *= 2)
-      if (tinf_getbit(d))
-        val += mask;
-  }
-
-  return val + base;
-}
-
-/* given a data stream and a tree, decode a symbol */
-static int tinf_decode_symbol(TINF_DATA *d, TINF_TREE *t) {
-  int sum = 0, cur = 0, len = 0;
-
-  /* get more bits while code value is above sum */
-  do {
-    cur = 2 * cur + tinf_getbit(d);
-
-    if (++len == TINF_ARRAY_SIZE(t->table)) {
-      return TINF_DATA_ERROR;
-    }
-
-    sum += t->table[len];
-    cur -= t->table[len];
-
-  } while (cur >= 0);
-
-  sum += cur;
-  if (sum < 0 || sum >= t->size) {
-    return TINF_DATA_ERROR;
-  }
-
-  return t->trans[sum];
-}
-
-/* given a data stream, decode dynamic trees from it */
-static int tinf_decode_trees(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt) {
-  /* code lengths for 288 literal/len symbols and 32 dist symbols */
-  unsigned char lengths[288 + 32];
-  unsigned int hlit, hdist, hclen, hlimit;
-  unsigned int i, num, length;
-
-  /* get 5 bits HLIT (257-286) */
-  hlit = tinf_read_bits(d, 5, 257);
-
-  /* get 5 bits HDIST (1-32) */
-  hdist = tinf_read_bits(d, 5, 1);
-
-  /* get 4 bits HCLEN (4-19) */
-  hclen = tinf_read_bits(d, 4, 4);
-
-  for (i = 0; i < 19; ++i)
-    lengths[i] = 0;
-
-  /* read code lengths for code length alphabet */
-  for (i = 0; i < hclen; ++i) {
-    /* get 3 bits code length (0-7) */
-    unsigned int clen = tinf_read_bits(d, 3, 0);
-
-    lengths[CLCIDX[i]] = clen;
-  }
-
-  /* build code length tree, temporarily use length tree */
-  tinf_build_tree(lt, lengths, 19);
-
-  /* decode code lengths for the dynamic trees */
-  hlimit = hlit + hdist;
-  for (num = 0; num < hlimit;) {
-    int sym = tinf_decode_symbol(d, lt);
-    unsigned char fill_value = 0;
-    int lbits, lbase = 3;
-
-    /* error decoding */
-    if (sym < 0)
-      return sym;
-
-    switch (sym) {
-      case 16:
-        /* copy previous code length 3-6 times (read 2 bits) */
-        if (num == 0)
-          return TINF_DATA_ERROR;
-        fill_value = lengths[num - 1];
-        lbits = 2;
-        break;
-      case 17:
-        /* repeat code length 0 for 3-10 times (read 3 bits) */
-        lbits = 3;
-        break;
-      case 18:
-        /* repeat code length 0 for 11-138 times (read 7 bits) */
-        lbits = 7;
-        lbase = 11;
-        break;
-      default:
-        /* values 0-15 represent the actual code lengths */
-        lengths[num++] = sym;
-        /* continue the for loop */
-        continue;
-    }
-
-    /* special code length 16-18 are handled here */
-    length = tinf_read_bits(d, lbits, lbase);
-    if (num + length > hlimit)
-      return TINF_DATA_ERROR;
-    for (; length; --length) {
-      lengths[num++] = fill_value;
-    }
-  }
-
-  /* Check that there's "end of block" symbol */
-  if (lengths[256] == 0) {
-    return TINF_DATA_ERROR;
-  }
-
-  /* build dynamic trees */
-  tinf_build_tree(lt, lengths, hlit);
-  tinf_build_tree(dt, lengths + hlit, hdist);
-
-  return TINF_OK;
-}
-
-/* build the fixed huffman trees (RFC 1951 3.2.6) through the generic tree
-   builder; altered from upstream, which unrolls them by hand */
-static void tinf_build_fixed_trees(TINF_TREE *lt, TINF_TREE *dt) {
-  unsigned char lengths[288];
-  unsigned int i;
-
-  for (i = 0; i < 144; ++i)
-    lengths[i] = 8;
-  for (; i < 256; ++i)
-    lengths[i] = 9;
-  for (; i < 280; ++i)
-    lengths[i] = 7;
-  for (; i < 288; ++i)
-    lengths[i] = 8;
-  tinf_build_tree(lt, lengths, 288);
-
-  for (i = 0; i < 32; ++i)
-    lengths[i] = 5;
-  tinf_build_tree(dt, lengths, 32);
-}
-
-/* ----------------------------- *
- * -- block inflate functions -- *
- * ----------------------------- */
-
-/* given a stream and two trees, inflate next chunk of output (a byte or more) */
-static int tinf_inflate_block_data(TINF_DATA *d, TINF_TREE *lt, TINF_TREE *dt) {
-  if (d->curlen == 0) {
-    unsigned int offs;
-    int dist;
-    int sym = tinf_decode_symbol(d, lt);
-
-    if (d->eof) {
-      return TINF_DATA_ERROR;
-    }
-
-    if (sym < 0) {
-      return sym;
-    }
-
-    /* literal byte */
-    if (sym < 256) {
-      TINF_PUT(d, sym);
-      return TINF_OK;
-    }
-
-    /* end of block */
-    if (sym == 256) {
-      return TINF_DONE;
-    }
-
-    /* substring from sliding dictionary */
-    sym -= 257;
-    if (sym >= 29) {
-      return TINF_DATA_ERROR;
-    }
-
-    /* possibly get more bits from length code */
-    d->curlen = tinf_read_bits(d, LENGTH_BITS[sym], LENGTH_BASE[sym]);
-
-    dist = tinf_decode_symbol(d, dt);
-    if (dist < 0 || dist >= 30) {
-      return TINF_DATA_ERROR;
-    }
-
-    /* possibly get more bits from distance code */
-    offs = tinf_read_bits(d, DIST_BITS[dist], DIST_BASE[dist]);
-
-    /* calculate and validate actual LZ offset to use */
-    if (offs > d->dict_size) {
-      return TINF_DICT_ERROR;
-    }
-    /* Note: we don't try to catch offset which points to not yet filled
-       part of the dictionary here. Doing so would require keeping another
-       variable to track "filled in" size of the dictionary. Appearance of
-       such an offset cannot lead to accessing memory outside of the
-       dictionary buffer, and clients which don't want to leak unrelated
-       information, should explicitly initialize dictionary buffer passed
-       to uzlib. */
-
-    d->lz_off = d->dict_idx - offs;
-    if (d->lz_off < 0) {
-      d->lz_off += d->dict_size;
-    }
-  }
-
-  /* copy next byte from dict substring */
-  TINF_PUT(d, d->dict_ring[d->lz_off]);
-  if ((unsigned) ++d->lz_off == d->dict_size) {
-    d->lz_off = 0;
-  }
-  d->curlen--;
-  return TINF_OK;
-}
-
-/* inflate next byte from uncompressed block of data */
-static int tinf_inflate_uncompressed_block(TINF_DATA *d) {
-  if (d->curlen == 0) {
-    unsigned int length, invlength;
-
-    /* get length */
-    length = uzlib_get_byte(d);
-    length += 256 * uzlib_get_byte(d);
-    /* get one's complement of length */
-    invlength = uzlib_get_byte(d);
-    invlength += 256 * uzlib_get_byte(d);
-    /* check length */
-    if (length != (~invlength & 0x0000ffff))
-      return TINF_DATA_ERROR;
-
-    /* increment length to properly return TINF_DONE below, without
-       producing data at the same time */
-    d->curlen = length + 1;
-
-    /* make sure we start next block on a byte boundary */
-    d->bitcount = 0;
-  }
-
-  if (--d->curlen == 0) {
-    return TINF_DONE;
-  }
-
-  unsigned char c = uzlib_get_byte(d);
-  TINF_PUT(d, c);
-  return TINF_OK;
-}
-
-/* ---------------------- *
- * -- public functions -- *
- * ---------------------- */
-
-/* initialize decompression structure */
-void ota_inflate_init(TINF_DATA *d, unsigned char *dict, unsigned int dict_len) {
-  d->source = NULL;
-  d->source_limit = NULL;
-  d->tag = 0;
-  d->eof = 0;
-  d->bitcount = 0;
-  d->lz_off = 0;
-  d->bfinal = 0;
-  d->btype = -1;
-  d->dict_size = dict_len;
-  d->dict_ring = dict;
-  d->dict_idx = 0;
-  d->curlen = 0;
-  d->ltree.trans = d->ltrans;
-  d->ltree.size = TINF_ARRAY_SIZE(d->ltrans);
-  d->dtree.trans = d->dtrans;
-  d->dtree.size = TINF_ARRAY_SIZE(d->dtrans);
-}
-
-/* inflate next output bytes from compressed stream */
-int ota_inflate(TINF_DATA *d) {
-  do {
-    int res;
-
-    /* start a new block */
-    if (d->btype == -1) {
-      int old_btype;
-    next_blk:
-      old_btype = d->btype;
-      /* read final block flag */
-      d->bfinal = tinf_getbit(d);
-      /* read block type (2 bits) */
-      d->btype = tinf_read_bits(d, 2, 0);
-
-      if (d->btype == 1 && old_btype != 1) {
-        /* build fixed huffman trees */
-        tinf_build_fixed_trees(&d->ltree, &d->dtree);
-      } else if (d->btype == 2) {
-        /* decode trees from stream */
-        res = tinf_decode_trees(d, &d->ltree, &d->dtree);
-        if (res != TINF_OK) {
-          return res;
-        }
-      }
-    }
-
-    /* process current block */
-    switch (d->btype) {
-      case 0:
-        /* decompress uncompressed block */
-        res = tinf_inflate_uncompressed_block(d);
-        break;
-      case 1:
-      case 2:
-        /* decompress block with fixed/dynamic huffman trees */
-        /* trees were decoded previously, so it's the same routine for both */
-        res = tinf_inflate_block_data(d, &d->ltree, &d->dtree);
-        break;
-      default:
-        return TINF_DATA_ERROR;
-    }
-
-    if (res == TINF_DONE && !d->bfinal) {
-      /* the block has ended (without producing more data), but we
-         can't return without data, so start procesing next block */
-      goto next_blk;
-    }
-
-    if (res != TINF_OK) {
-      return res;
-    }
-
-  } while (d->dest < d->dest_limit);
-
-  return TINF_OK;
-}
@@ -1,65 +0,0 @@
-#pragma once
-// Raw deflate decoder cut down from uzlib (https://github.com/pfalcon/uzlib,
-// zlib licence, see the .c file); output goes through a ring window.
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-enum OtaInflateResult {
-  OTA_INFLATE_OK = 0,   /* more data produced, call again */
-  OTA_INFLATE_DONE = 1, /* end of compressed stream reached */
-  OTA_INFLATE_DATA_ERROR = -3,
-  OTA_INFLATE_DICT_ERROR = -5,
-};
-
-struct OtaInflateTree {
-  uint16_t table[16]; /* table of code length counts */
-  uint16_t *trans;    /* code -> symbol translation table, size entries */
-  uint16_t size;
-};
-
-struct OtaInflateState {
-  /* Next byte in the input buffer and one past its end */
-  const unsigned char *source;
-  const unsigned char *source_limit;
-  /* Called when source is exhausted; returns the next byte or -1 at EOF.
-     It may refill source/source_limit for buffered operation. */
-  int (*source_read_cb)(struct OtaInflateState *d);
-  /* Output cursor and one past the end of the output buffer */
-  unsigned char *dest;
-  unsigned char *dest_limit;
-  /* Ring window holding the last dict_size output bytes for back references */
-  unsigned char *dict_ring;
-
-  unsigned int tag;
-  unsigned int curlen;
-  int lz_off;
-  unsigned int dict_size;
-  unsigned int dict_idx;
-
-  /* One word: btype is -1 between blocks, bitcount never exceeds 7 */
-  int8_t btype;
-  uint8_t bfinal;
-  uint8_t bitcount;
-  bool eof;
-
-  struct OtaInflateTree ltree; /* dynamic length/symbol tree */
-  struct OtaInflateTree dtree; /* dynamic distance tree */
-  uint16_t ltrans[288];
-  uint16_t dtrans[32]; /* the distance alphabet has 30 symbols, so the tree is kept small */
-};
-
-/* dict must cover the encoder's window (its largest back reference) */
-void ota_inflate_init(struct OtaInflateState *d, unsigned char *dict, unsigned int dict_len);
-/* Fills dest up to dest_limit (OK) or to the end of the stream (DONE). dest may
-   alias dict only if dest_limit - dest == dict_len and dest is reset to dict
-   exactly when a call returns OK, so the ring index and dest stay in lockstep */
-int ota_inflate(struct OtaInflateState *d);
-
-#ifdef __cplusplus
-}
-#endif
@@ -1,94 +0,0 @@
-#include "ota_esphome.h"
-#ifdef USE_OTA
-#ifdef USE_OTA_DEFLATE
-#include "esphome/components/ota/ota_backend.h"
-#include "esphome/core/application.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-
-static const char *const TAG = "esphome.ota";
-
-// The window doubles as the output buffer; flushed bytes stay as back
-// reference history for the next windowful.
-ota::OTAResponseTypes ESPHomeOTAComponent::inflate_flush_(InflateSession &session) {
-  const size_t produced = session.dest - session.window;
-  const size_t pending = produced - session.flushed;
-  if (pending != 0) {
-    if (pending > session.image_size - session.written) {
-      ESP_LOGW(TAG, "Inflate overrun");
-      return ota::OTA_RESPONSE_ERROR_UNKNOWN;
-    }
-    ota::OTAResponseTypes result = this->write_flash_(session.window + session.flushed, pending);
-    if (result != ota::OTA_RESPONSE_OK)
-      return result;
-    session.flushed = produced;
-    session.written += pending;
-    // A compressible region yields many windows per socket read
-    App.feed_wdt();
-  }
-  // Even with nothing new written: a block boundary can fall inside a header
-  this->ack_written_(*session.xfer);
-  return ota::OTA_RESPONSE_OK;
-}
-
-ota::OTAResponseTypes ESPHomeOTAComponent::inflate_data_(uint8_t *in, size_t image_size, DataTransfer &xfer) {
-  InflateSession &session = *this->inflate_;
-  session.self = this;
-  session.xfer = &xfer;
-  session.in = in;
-  session.image_size = image_size;
-  session.written = 0;
-  session.error = ota::OTA_RESPONSE_OK;
-  ota_inflate_init(&session, session.window, OTA_INFLATE_WINDOW_SIZE);
-  // Where the ack must follow the write, flush and ack before waiting for
-  // input, or the client waits for an ack while the decoder waits for data
-  session.source_read_cb = [](OtaInflateState *d) -> int {
-    auto *s = static_cast<InflateSession *>(d);
-    if (ACK_AFTER_WRITE) {
-      s->error = s->self->inflate_flush_(*s);
-      if (s->error != ota::OTA_RESPONSE_OK)
-        return -1;
-    }
-    // More input than announced; reported by the size check below
-    if (s->xfer->total >= s->xfer->ota_size)
-      return -1;
-    ssize_t read = s->self->receive_data_(s->in, *s->xfer);
-    if (read <= 0) {
-      // Already logged by receive_data_
-      s->error = ota::OTA_RESPONSE_ERROR_UNKNOWN;
-      return -1;
-    }
-    d->source = s->in + 1;
-    d->source_limit = s->in + read;
-    return s->in[0];
-  };
-
-  int res;
-  do {
-    // The ring index wrapped to 0 exactly when the window filled
-    session.dest = session.window;
-    session.dest_limit = session.window + OTA_INFLATE_WINDOW_SIZE;
-    session.flushed = 0;
-    res = ota_inflate(&session);
-    // A stored block keeps emitting zeros after a failed read, hence eof
-    if (res < 0 || session.eof)
-      break;
-    session.error = this->inflate_flush_(session);
-  } while (res != OTA_INFLATE_DONE && session.error == ota::OTA_RESPONSE_OK);
-
-  // Transport and flash failures are logged where they happen
-  if (session.error != ota::OTA_RESPONSE_OK)
-    return session.error;
-  if (res != OTA_INFLATE_DONE || session.written != image_size || xfer.total != xfer.ota_size) {
-    ESP_LOGW(TAG, "Inflate err %d, %zu of %zu B from %zu of %zu", res, session.written, image_size, xfer.total,
-             xfer.ota_size);
-    return ota::OTA_RESPONSE_ERROR_UNKNOWN;
-  }
-  ESP_LOGD(TAG, "Inflated %zu bytes from %zu", session.written, xfer.total);
-  return ota::OTA_RESPONSE_OK;
-}
-
-}  // namespace esphome
-#endif  // USE_OTA_DEFLATE
-#endif  // USE_OTA
@@ -32,12 +32,7 @@ ESPHomeOTAComponent::NoiseSession::~NoiseSession() {
  }
 }

-void ESPHomeOTAComponent::noise_reserve_session_() {
-  // Default placement, PSRAM first where present: the session lives for one upload
-  this->noise_ = RAMAllocator<NoiseSession>().make_unique();
-}
-
-/** Start the responder handshake, on the session reserved at offer time.
+/** Allocate the session and start the responder handshake.
 *
 * The prologue binds the whole plaintext preamble, so any tampering with the
 * negotiation (a stripped feature flag, a changed version) breaks the first
@@ -46,7 +41,9 @@ void ESPHomeOTAComponent::noise_reserve_session_() {
 */
 bool ESPHomeOTAComponent::noise_start_session_(uint8_t server_feature_flags) {
  // A provisioned key cleared between the offer and here is not guarded: the
-  // session runs on the zero key load_psk fills in and fails the client's MAC
+  // session runs on the zero key load_psk fills in and fails the client's MAC.
+  // Default placement, PSRAM first where present: the session only lives for one upload
+  this->noise_ = RAMAllocator<NoiseSession>().make_unique();
  static constexpr size_t PROLOGUE_ACK_LEN = 2;  // OTA_RESPONSE_OK + version
  static constexpr size_t PROLOGUE_CLIENT_FEATURES_LEN = 1;
  static constexpr size_t PROLOGUE_FEATURE_ACK_LEN = 2;  // OTA_RESPONSE_FEATURE_FLAGS + server flags
@@ -220,9 +220,6 @@ class EthernetComponent final : public Component {
 protected:
  void start_connect_();
  void finish_connect_();
-#if LWIP_IPV6
-  esp_err_t ensure_ip6_linklocal_();
-#endif
  void dump_connect_params_();

 #ifdef USE_ESP32
@@ -10,10 +10,6 @@
 #include <lwip/dns.h>
 #include <cinttypes>
 #include "esp_event.h"
-#if USE_NETWORK_IPV6
-#include <esp_netif_net_stack.h>
-#include <lwip/netif.h>
-#endif
 #ifdef USE_PSRAM
 #include <esp_psram.h>
 #endif
@@ -513,18 +509,6 @@ void EthernetComponent::ethernet_lazy_init_() {
    }
  }
 #endif
-#if USE_NETWORK_IPV6 && ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
-  // Since IDF 5.5 the internal EMAC drops multicast groups that were never added (before,
-  // it passed all multicast), and lwIP never adds all-nodes, so router advertisements
-  // were lost and SLAAC never ran.
-  {
-    uint8_t all_nodes[6] = {0x33, 0x33, 0x00, 0x00, 0x00, 0x01};
-    if (esp_err_t filter_err = esp_eth_ioctl(this->eth_handle_, ETH_CMD_ADD_MAC_FILTER, all_nodes);
-        filter_err != ESP_OK) {
-      ESP_LOGD(TAG, "IPv6 all-nodes multicast filter not added: %s", esp_err_to_name(filter_err));
-    }
-  }
-#endif

  // Register user defined event handers
  err = esp_event_handler_register(ETH_EVENT, ESP_EVENT_ANY_ID, &EthernetComponent::eth_event_handler, nullptr);
@@ -771,13 +755,6 @@ void EthernetComponent::eth_event_handler(void *arg, esp_event_base_t event_base
        global_eth_component->notify_ip_state_listeners_();
      }
 #endif
-#if USE_NETWORK_IPV6
-      // Start SLAAC on link-up, not after the DHCPv4 lease. This also restores the
-      // link-local after a link flap, which clears the IPv6 addresses.
-      if (esp_err_t ll_err = esp_netif_create_ip6_linklocal(global_eth_component->eth_netif_); ll_err != ESP_OK) {
-        ESP_LOGW(TAG, "esp_netif_create_ip6_linklocal failed on link-up: %s", esp_err_to_name(ll_err));
-      }
-#endif /* USE_NETWORK_IPV6 */
      break;
    case ETHERNET_EVENT_DISCONNECTED:
      event_name = "ETH disconnected";
@@ -814,10 +791,7 @@ void EthernetComponent::got_ip6_event_handler(void *arg, esp_event_base_t event_
                                              void *event_data) {
  ip_event_got_ip6_t *event = (ip_event_got_ip6_t *) event_data;
  ESP_LOGV(TAG, "[Ethernet event] ETH Got IPv6: " IPV6STR, IPV62STR(event->ip6_info.ip));
-  // Count the addresses on the interface, not the events: recreating the link-local
-  // after a link flap fires another event for the same address.
-  struct esp_ip6_addr if_ip6s[CONFIG_LWIP_IPV6_NUM_ADDRESSES];
-  global_eth_component->ipv6_count_ = esp_netif_get_all_ip6(global_eth_component->eth_netif_, if_ip6s);
+  global_eth_component->ipv6_count_ += 1;
 #if (USE_NETWORK_MIN_IPV6_ADDR_COUNT > 0)
  global_eth_component->connected_ =
      global_eth_component->got_ipv4_address_ && (global_eth_component->ipv6_count_ >= USE_NETWORK_MIN_IPV6_ADDR_COUNT);
@@ -832,29 +806,6 @@ void EthernetComponent::got_ip6_event_handler(void *arg, esp_event_base_t event_
 }
 #endif /* USE_NETWORK_IPV6 */

-#if USE_NETWORK_IPV6
-// Create the link-local address unless the interface already has one, including one still in
-// duplicate address detection: recreating it would restart DAD. esp_netif_get_ip6_linklocal()
-// only reports a preferred address, so ask lwIP for the slot state instead.
-esp_err_t EthernetComponent::ensure_ip6_linklocal_() {
-  if (auto *netif = static_cast<struct netif *>(esp_netif_get_netif_impl(this->eth_netif_)); netif != nullptr) {
-    u8_t state;
-    {
-      LwIPLock lock;
-      state = netif_ip6_addr_state(netif, 0);
-    }
-    if (ip6_addr_istentative(state) || ip6_addr_isvalid(state)) {
-      return ESP_OK;
-    }
-  }
-  esp_err_t err = esp_netif_create_ip6_linklocal(this->eth_netif_);
-  if (err == ESP_OK) {
-    ESP_LOGD(TAG, "IPv6 link-local address created");
-  }
-  return err;
-}
-#endif /* USE_NETWORK_IPV6 */
-
 void EthernetComponent::finish_connect_() {
 #if USE_NETWORK_IPV6
  // Retry IPv6 link-local setup if it failed during initial connect
@@ -865,7 +816,10 @@ void EthernetComponent::finish_connect_() {
  // - Cable unplugged/network interruption (#10705)
  // We can now retry since we're in CONNECTED state and the interface is definitely up.
  if (!this->ipv6_setup_done_) {
-    this->ensure_ip6_linklocal_();
+    esp_err_t err = esp_netif_create_ip6_linklocal(this->eth_netif_);
+    if (err == ESP_OK) {
+      ESP_LOGD(TAG, "IPv6 link-local address created (retry succeeded)");
+    }
    // Always set the flag to prevent continuous retries
    // If IPv6 setup fails here with the interface up and stable, it's
    // likely a persistent issue (IPv6 disabled at router, hardware
@@ -879,9 +833,7 @@ void EthernetComponent::finish_connect_() {
 void EthernetComponent::start_connect_() {
  global_eth_component->got_ipv4_address_ = false;
 #if USE_NETWORK_IPV6
-  // Recount rather than zero: addresses that survive a reconnect are not announced again.
-  struct esp_ip6_addr if_ip6s[CONFIG_LWIP_IPV6_NUM_ADDRESSES];
-  global_eth_component->ipv6_count_ = esp_netif_get_all_ip6(this->eth_netif_, if_ip6s);
+  global_eth_component->ipv6_count_ = 0;
  this->ipv6_setup_done_ = false;
 #endif /* USE_NETWORK_IPV6 */
  this->connect_begin_ = millis();
@@ -960,7 +912,7 @@ void EthernetComponent::start_connect_() {
  // - At bootup when link isn't ready (#10281)
  // - After disconnection/cable unplugged (#10705)
  // We'll retry in finish_connect_() if it fails here.
-  err = this->ensure_ip6_linklocal_();
+  err = esp_netif_create_ip6_linklocal(this->eth_netif_);
  if (err != ESP_OK) {
    if (err == ESP_ERR_ESP_NETIF_INVALID_PARAMS) {
      // This is a programming error, not a transient failure
@@ -726,8 +726,7 @@ async def to_code(config):
        )
    ]

-    # constexpr Glyph table in flash; on ESP8266 static_const_array would place it in RAM.
-    glyphs = cg.progmem_array(config[CONF_RAW_GLYPH_ID], glyph_initializer)
+    glyphs = cg.static_const_array(config[CONF_RAW_GLYPH_ID], glyph_initializer)

    font_height = pt_to_px(base_font.size.height)
    ascender = pt_to_px(base_font.size.ascender)
@@ -309,8 +309,7 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
      // Unknown char, skip
      ESP_LOGW(TAG, "Codepoint 0x%08" PRIx32 " not found in font", code_point);
      if (!this->glyphs_.empty()) {
-        // Full-width read: a narrowing byte load would fault on a PROGMEM table on ESP8266.
-        int glyph_width = this->glyphs_[0].advance;
+        uint8_t glyph_width = this->glyphs_[0].advance;
        display->rectangle(x_at, y_start, glyph_width, this->height_, color);
        x_at += glyph_width;
      }
@@ -1,7 +1,5 @@
 #pragma once

-#include <type_traits>
-
 #include "esphome/core/color.h"
 #include "esphome/core/datatypes.h"
 #include "esphome/core/defines.h"
@@ -38,18 +36,6 @@ class Glyph final {
  int width;
  int height;
 };
-// The glyph table lives in flash, read with plain loads, which ESP8266 only allows for whole words.
-static_assert(std::is_same_v<decltype(Glyph::code_point), const uint32_t>, "Glyph fields must stay word sized");
-static_assert(std::is_same_v<decltype(Glyph::data), const uint8_t *>, "Glyph fields must stay word sized");
-static_assert(std::is_same_v<decltype(Glyph::advance), int>, "Glyph fields must stay word sized");
-static_assert(std::is_same_v<decltype(Glyph::offset_x), int>, "Glyph fields must stay word sized");
-static_assert(std::is_same_v<decltype(Glyph::offset_y), int>, "Glyph fields must stay word sized");
-static_assert(std::is_same_v<decltype(Glyph::width), int>, "Glyph fields must stay word sized");
-static_assert(std::is_same_v<decltype(Glyph::height), int>, "Glyph fields must stay word sized");
-#ifdef USE_ESP8266
-static_assert(alignof(Glyph) == sizeof(uint32_t), "Glyph fields must stay word sized");
-static_assert(sizeof(Glyph) == 7 * sizeof(uint32_t), "Glyph is read from flash with word loads");
-#endif

 class Font final
 #ifdef USE_DISPLAY
@@ -55,8 +55,9 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await uart.register_uart_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_CO2, var.set_co2_sensor)
+    if co2 := config.get(CONF_CO2):
+        sens = await sensor.new_sensor(co2)
+        cg.add(var.set_co2_sensor(sens))

    cg.add(var.set_warmup_seconds(config[CONF_WARMUP_TIME]))

@@ -48,6 +48,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature)
-    await sensors(CONF_HUMIDITY, var.set_humidity)
+    if CONF_TEMPERATURE in config:
+        sens = await sensor.new_sensor(config[CONF_TEMPERATURE])
+        cg.add(var.set_temperature(sens))
+
+    if CONF_HUMIDITY in config:
+        sens = await sensor.new_sensor(config[CONF_HUMIDITY])
+        cg.add(var.set_humidity(sens))
@@ -48,6 +48,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-    await sensors(CONF_HUMIDITY, var.set_humidity_sensor)
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
+
+    if humidity_config := config.get(CONF_HUMIDITY):
+        sens = await sensor.new_sensor(humidity_config)
+        cg.add(var.set_humidity_sensor(sens))
@@ -49,6 +49,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature)
-    await sensors(CONF_HUMIDITY, var.set_humidity)
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature(sens))
+
+    if humidity_config := config.get(CONF_HUMIDITY):
+        sens = await sensor.new_sensor(humidity_config)
+        cg.add(var.set_humidity(sens))
@@ -66,9 +66,13 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temp_sensor)
-    await sensors(CONF_HUMIDITY, var.set_humidity_sensor)
+    if temp_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temp_config)
+        cg.add(var.set_temp_sensor(sens))
+
+    if humidity_config := config.get(CONF_HUMIDITY):
+        sens = await sensor.new_sensor(humidity_config)
+        cg.add(var.set_humidity_sensor(sens))

    cg.add(var.set_power_mode(config[CONF_POWER_MODE]))

@@ -35,13 +35,16 @@ CONFIG_SCHEMA = cv.All(


 async def to_code(config: ConfigType) -> None:
-    hub = await cg.get_variable(config[CONF_HOERMANN_HCP_ID])
+    parent = await cg.get_variable(config[CONF_HOERMANN_HCP_ID])
    if (conf := config.get(CONF_DOOR_STATE)) is not None:
-        var = await text_sensor.new_text_sensor(conf, hub)
+        var = await text_sensor.new_text_sensor(conf, parent)
        await cg.register_component(var, conf)
    # Only the identity sensors need the exchange with the motor compiled in.
    if CONF_SERIAL_NUMBER in config or CONF_VERSION in config:
        cg.add_define("USE_HOERMANN_HCP_IDENTITY")
-    text_sensors = text_sensor.sub_text_sensors(config)
-    await text_sensors(CONF_SERIAL_NUMBER, hub.set_serial_number_text_sensor)
-    await text_sensors(CONF_VERSION, hub.set_version_text_sensor)
+    if (conf := config.get(CONF_SERIAL_NUMBER)) is not None:
+        sens = await text_sensor.new_text_sensor(conf)
+        cg.add(parent.set_serial_number_text_sensor(sens))
+    if (conf := config.get(CONF_VERSION)) is not None:
+        sens = await text_sensor.new_text_sensor(conf)
+        cg.add(parent.set_version_text_sensor(sens))
@@ -7,23 +7,19 @@ from .. import (
    HOME_ASSISTANT_IMPORT_CONTROL_SCHEMA,
    homeassistant_ns,
    setup_home_assistant_entity,
-    validate_entity_domain,
 )

 CODEOWNERS = ["@landonr"]
 DEPENDENCIES = ["api"]

-SUPPORTED_DOMAINS = ["input_number", "number"]
-
 HomeassistantNumber = homeassistant_ns.class_(
    "HomeassistantNumber", number.Number, cg.Component
 )

-CONFIG_SCHEMA = cv.All(
+CONFIG_SCHEMA = (
    number.number_schema(HomeassistantNumber)
    .extend(HOME_ASSISTANT_IMPORT_CONTROL_SCHEMA)
-    .extend(cv.COMPONENT_SCHEMA),
-    validate_entity_domain("number", SUPPORTED_DOMAINS),
+    .extend(cv.COMPONENT_SCHEMA)
 )


@@ -1,7 +1,5 @@
 #include "homeassistant_number.h"

-#include <cstring>
-
 #include "esphome/components/api/api_pb2.h"
 #include "esphome/components/api/api_server.h"
 #include "esphome/core/log.h"
@@ -82,19 +80,12 @@ void HomeassistantNumber::control(float value) {

  this->publish_state(value);

-  static constexpr auto NUMBER_SERVICE_NAME = StringRef::from_lit("number.set_value");
-  static constexpr auto INPUT_NUMBER_SERVICE_NAME = StringRef::from_lit("input_number.set_value");
-  static constexpr char INPUT_PREFIX[] = "input_";
+  static constexpr auto SERVICE_NAME = StringRef::from_lit("number.set_value");
  static constexpr auto ENTITY_ID_KEY = StringRef::from_lit("entity_id");
  static constexpr auto VALUE_KEY = StringRef::from_lit("value");

  api::HomeassistantActionRequest resp;
-  // input_number entities have their own set_value action
-  if (strncmp(this->entity_id_, INPUT_PREFIX, sizeof(INPUT_PREFIX) - 1) == 0) {
-    resp.service = INPUT_NUMBER_SERVICE_NAME;
-  } else {
-    resp.service = NUMBER_SERVICE_NAME;
-  }
+  resp.service = SERVICE_NAME;

  resp.data.init(2);
  auto &entity_id = resp.data.emplace_back();
@@ -48,6 +48,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-    await sensors(CONF_HUMIDITY, var.set_humidity_sensor)
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
+
+    if humidity_config := config.get(CONF_HUMIDITY):
+        sens = await sensor.new_sensor(humidity_config)
+        cg.add(var.set_humidity_sensor(sens))
@@ -56,9 +56,14 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await spi.register_spi_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    if await sensors(CONF_PRESSURE, var.set_pressure_sensor):
+    if CONF_PRESSURE in config:
        conf = config[CONF_PRESSURE]
+        sens = await sensor.new_sensor(conf)
+        cg.add(var.set_pressure_sensor(sens))
        cg.add(var.set_honeywellabp_min_pressure(conf[CONF_MIN_PRESSURE]))
        cg.add(var.set_honeywellabp_max_pressure(conf[CONF_MAX_PRESSURE]))
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
+
+    if CONF_TEMPERATURE in config:
+        conf = config[CONF_TEMPERATURE]
+        sens = await sensor.new_sensor(conf)
+        cg.add(var.set_temperature_sensor(sens))
@@ -63,11 +63,13 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    if await sensors(CONF_PRESSURE, var.set_pressure_sensor):
-        pressure_config = config[CONF_PRESSURE]
+    if pressure_config := config.get(CONF_PRESSURE):
+        sens = await sensor.new_sensor(pressure_config)
+        cg.add(var.set_pressure_sensor(sens))
        cg.add(var.set_min_pressure(pressure_config[CONF_MIN_PRESSURE]))
        cg.add(var.set_max_pressure(pressure_config[CONF_MAX_PRESSURE]))
        cg.add(var.set_transfer_function(pressure_config[TRANSFER_FUNCTION]))

-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
@@ -50,6 +50,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-    await sensors(CONF_HUMIDITY, var.set_humidity_sensor)
+    if temperature := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature)
+        cg.add(var.set_temperature_sensor(sens))
+
+    if humidity := config.get(CONF_HUMIDITY):
+        sens = await sensor.new_sensor(humidity)
+        cg.add(var.set_humidity_sensor(sens))
@@ -25,10 +25,11 @@ std::string HttpContainer::get_response_header(const std::string &header_name) {
  auto lower = str_lower_case(header_name);  // NOLINT
  for (const auto &entry : this->response_headers_) {
    if (entry.name == lower) {
-      ESP_LOGV(TAG, "Header with name %s found with value %s", lower.c_str(), entry.value.c_str());
+      ESP_LOGD(TAG, "Header with name %s found with value %s", lower.c_str(), entry.value.c_str());
      return entry.value;
    }
  }
+  ESP_LOGW(TAG, "No header with name %s found", lower.c_str());
  return "";
 }

@@ -268,11 +268,6 @@ class HttpContainer : public Parented<HttpRequestComponent> {
    return !this->is_chunked_ && this->bytes_read_ >= this->content_length;
  }

-  /**
-   * @brief Get the value of a response header by name.
-   * @param header_name The name of the header to retrieve.
-   * @return The value of the header if found, otherwise an empty string.
-   */
  std::string get_response_header(const std::string &header_name);

 protected:
@@ -48,6 +48,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature)
-    await sensors(CONF_HUMIDITY, var.set_humidity)
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature(sens))
+
+    if humidity_config := config.get(CONF_HUMIDITY):
+        sens = await sensor.new_sensor(humidity_config)
+        cg.add(var.set_humidity(sens))
@@ -48,6 +48,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature)
-    await sensors(CONF_HUMIDITY, var.set_humidity)
+    if temperature := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature)
+        cg.add(var.set_temperature(sens))
+
+    if humidity := config.get(CONF_HUMIDITY):
+        sens = await sensor.new_sensor(humidity)
+        cg.add(var.set_humidity(sens))
@@ -60,11 +60,11 @@ class I2SAudioMicrophone final : public I2SAudioIn, public microphone::Microphon

  gpio_num_t din_pin_{I2S_GPIO_UNUSED};
  i2s_chan_handle_t rx_handle_;
+  bool pdm_{false};
 #if SOC_I2S_SUPPORTS_PDM_RX
  i2s_pdm_dsr_t pdm_dsr_{I2S_PDM_DSR_8S};
 #endif

-  bool pdm_{false};
  bool correct_dc_offset_;
  bool locked_driver_{false};
  int32_t dc_offset_prev_input_{0};
@@ -77,12 +77,6 @@ void I2SAudioSpeakerBase::loop() {
    ESP_LOGV(TAG, "Started");
    xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::TASK_RUNNING);
    this->state_ = speaker::STATE_RUNNING;
-#ifdef USE_AUDIO_DAC
-    // The task raises TASK_RUNNING only after enabling the channel, so the clocks are already running
-    if (this->audio_dac_ != nullptr) {
-      this->audio_dac_->on_audio_started();
-    }
-#endif  // USE_AUDIO_DAC
  }
  if (event_group_bits & SpeakerEventGroupBits::TASK_STOPPING) {
    ESP_LOGV(TAG, "Stopping");
@@ -47,8 +47,12 @@ async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_CO2, var.set_co2)
-    await sensors(CONF_TVOC, var.set_tvoc)
+    if co2_config := config.get(CONF_CO2):
+        sens = await sensor.new_sensor(co2_config)
+        cg.add(var.set_co2(sens))
+
+    if tvoc_config := config.get(CONF_TVOC):
+        sens = await sensor.new_sensor(tvoc_config)
+        cg.add(var.set_tvoc(sens))

    await i2c.register_i2c_device(var, config)
@@ -59,7 +59,14 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_BUS_VOLTAGE, var.set_bus_voltage_sensor)
-    await sensors(CONF_CURRENT, var.set_current_sensor)
-    await sensors(CONF_POWER, var.set_power_sensor)
+    if CONF_BUS_VOLTAGE in config:
+        sens = await sensor.new_sensor(config[CONF_BUS_VOLTAGE])
+        cg.add(var.set_bus_voltage_sensor(sens))
+
+    if CONF_CURRENT in config:
+        sens = await sensor.new_sensor(config[CONF_CURRENT])
+        cg.add(var.set_current_sensor(sens))
+
+    if CONF_POWER in config:
+        sens = await sensor.new_sensor(config[CONF_POWER])
+        cg.add(var.set_power_sensor(sens))
@@ -48,6 +48,9 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-    await sensors(CONF_INTERNAL_TEMPERATURE, var.set_internal_temperature_sensor)
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
+    if internal_temperature_config := config.get(CONF_INTERNAL_TEMPERATURE):
+        sens = await sensor.new_sensor(internal_temperature_config)
+        cg.add(var.set_internal_temperature_sensor(sens))
@@ -79,10 +79,15 @@ async def to_code(config: ConfigType) -> None:
    cg.add(var.set_pack_size(config.get(CONF_SIZE)))
    cg.add(var.set_pack_voltage(BATTERY_VOLTAGE_OPTIONS[config[CONF_VOLTAGE]]))

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_BATTERY_VOLTAGE, var.set_voltage_sensor)
-    await sensors(CONF_BATTERY_LEVEL, var.set_battery_remaining_sensor)
+    if voltage_config := config.get(CONF_BATTERY_VOLTAGE):
+        sens = await sensor.new_sensor(voltage_config)
+        cg.add(var.set_voltage_sensor(sens))

-    if await sensors(CONF_TEMPERATURE, var.set_temperature_sensor):
-        b_constant = config[CONF_TEMPERATURE][CONF_B_CONSTANT]
-        cg.add(var.set_thermistor_b_constant(b_constant))
+    if level_config := config.get(CONF_BATTERY_LEVEL):
+        sens = await sensor.new_sensor(level_config)
+        cg.add(var.set_battery_remaining_sensor(sens))
+
+    if temp_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temp_config)
+        cg.add(var.set_temperature_sensor(sens))
+        cg.add(var.set_thermistor_b_constant(temp_config[CONF_B_CONSTANT]))
@@ -176,10 +176,6 @@ class LD2450Component : public Component, public uart::UARTDevice {
  bool bluetooth_on_{false};
  Target target_info_[MAX_TARGETS];
  Zone zone_config_[MAX_ZONES];
-#ifdef USE_TEXT_SENSOR
-  // Byte aligned, so it packs after zone_config_ instead of padding before data_callback_
-  std::array<Deduplicator<uint8_t>, MAX_TARGETS> direction_dedup_{};
-#endif

 #ifdef USE_NUMBER
  ESPPreferenceObject pref_;  // only used when numbers are in use
@@ -198,6 +194,7 @@ class LD2450Component : public Component, public uart::UARTDevice {
 #endif
 #ifdef USE_TEXT_SENSOR
  std::array<text_sensor::TextSensor *, MAX_TARGETS> direction_text_sensors_{};
+  std::array<Deduplicator<uint8_t>, MAX_TARGETS> direction_dedup_{};
 #endif

  LazyCallbackManager<void()> data_callback_;
@@ -35,11 +35,11 @@ class LEDCOutput final : public output::FloatOutput, public Component {
  InternalGPIOPin *pin_;
  uint8_t channel_{};
  uint8_t bit_depth_{};
-  bool initialized_ = false;
  float phase_angle_{0.0f};
  float frequency_{};
  float duty_{0.0f};
  uint32_t last_duty_{UINT32_MAX};
+  bool initialized_ = false;
 };

 }  // namespace esphome::ledc
@@ -32,7 +32,6 @@ from esphome.storage_json import StorageJSON
 from . import gpio  # noqa: F401
 from .const import (
    COMPONENT_BK72XX,
-    COMPONENT_LN882X,
    CONF_GPIO_RECOVER,
    CONF_LOGLEVEL,
    CONF_SDK_SILENT,
@@ -491,10 +490,6 @@ async def component_to_code(config):
        # Not enabled on RTL87xx/LN882x — costs more heap than it saves there.
        cg.add_build_flag("-DconfigSUPPORT_STATIC_ALLOCATION=1")

-    # LN882x: a zero-size allocation must not trip the SDK's assert (see ln882x_zero_malloc.c).
-    if config[CONF_COMPONENT_ID] == COMPONENT_LN882X:
-        cg.add_build_flag("-Wl,--wrap=pvPortMalloc")
-
    # RTL8710B needs FreeRTOS 8.2.3+ for xTaskNotifyGive/ulTaskNotifyTake
    # required by AsyncTCP 3.4.3+ (https://github.com/esphome/esphome/issues/10220)
    # RTL8720C (ambz2) requires FreeRTOS 10.x so this only applies to RTL8710B
@@ -1,13 +0,0 @@
-// LN882x: a zero-size pvPortMalloc trips the SDK's malloc-failed LN_ASSERT; ask for 1 byte instead.
-
-#ifdef USE_LN882X
-
-#include <stddef.h>
-
-void *__real_pvPortMalloc(size_t size);  // NOLINT(readability-identifier-naming)
-
-void *__wrap_pvPortMalloc(size_t size) {  // NOLINT(readability-identifier-naming)
-  return __real_pvPortMalloc(size == 0 ? 1 : size);
-}
-
-#endif  // USE_LN882X
@@ -25,7 +25,8 @@ CONFIG_SCHEMA = cv.Schema(


 async def to_code(config):
-    hub = await cg.get_variable(config[CONF_LIBRETINY])
+    lt_component = await cg.get_variable(config[CONF_LIBRETINY])

-    text_sensors = text_sensor.sub_text_sensors(config)
-    await text_sensors(CONF_VERSION, hub.set_version_sensor)
+    if CONF_VERSION in config:
+        sens = await text_sensor.new_text_sensor(config[CONF_VERSION])
+        cg.add(lt_component.set_version_sensor(sens))
@@ -163,11 +163,6 @@ struct StrobeLightEffectColor {
 class StrobeLightEffect : public LightEffect {
 public:
  explicit StrobeLightEffect(const char *name) : LightEffect(name) {}
-  void start() override {
-    // Place the cycle at the end of the last color, so the first apply() switches straight to the first color
-    this->at_color_ = this->colors_.size() - 1;
-    this->last_switch_ = millis() - this->colors_.back().duration;
-  }
  void apply() override {
    const uint32_t now = millis();
    if (now - this->last_switch_ < this->colors_[this->at_color_].duration)
@@ -31,10 +31,9 @@ from esphome.const import (
 )
 from esphome.cpp_generator import MockObjClass
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
-from esphome.types import ConfigType
 from esphome.util import Registry

-from .automation import COLOR_SCHEMA, color_to_rgb, validate_light_state
+from .automation import validate_light_state
 from .types import (
    COLOR_MODES,
    AddressableColorWipeEffect,
@@ -89,28 +88,6 @@ MONOCHROMATIC_EFFECTS = []
 RGB_EFFECTS = []
 ADDRESSABLE_EFFECTS = []

-
-def _with_color_option(schema: cv.Schema, *default_keys: str) -> cv.Schema:
-    """Add the `color:` option to a per-item effect color schema.
-
-    `color_to_rgb` must run before the keys are defaulted to full level below, so a
-    `color:` can populate `default_keys` (red/green/blue and, where the effect has
-    one, color_brightness) and a plain channel list still defaults them to full
-    level. Centralizing both steps here means a new effect schema only has to call
-    this once instead of repeating the ordering rule itself.
-    """
-    schema = schema.extend(COLOR_SCHEMA)
-    schema.add_extra(color_to_rgb)
-
-    def _default_to_full_level(config: ConfigType) -> ConfigType:
-        for key in default_keys:
-            config.setdefault(key, 1.0)
-        return config
-
-    schema.add_extra(_default_to_full_level)
-    return schema
-
-
 EFFECTS_REGISTRY = Registry()


@@ -290,30 +267,6 @@ async def random_effect_to_code(config, effect_id):
    return effect


-STROBE_COLOR_SCHEMA = cv.Schema(
-    {
-        cv.Optional(CONF_STATE, default=True): validate_light_state,
-        cv.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage,
-        cv.Optional(CONF_COLOR_MODE): cv.enum(COLOR_MODES, upper=True, space="_"),
-        cv.Optional(CONF_COLOR_BRIGHTNESS): cv.percentage,
-        cv.Optional(CONF_RED): cv.percentage,
-        cv.Optional(CONF_GREEN): cv.percentage,
-        cv.Optional(CONF_BLUE): cv.percentage,
-        cv.Optional(CONF_WHITE, default=1.0): cv.percentage,
-        cv.Optional(CONF_COLOR_TEMPERATURE): cv.color_temperature,
-        cv.Optional(CONF_COLD_WHITE, default=1.0): cv.percentage,
-        cv.Optional(CONF_WARM_WHITE, default=1.0): cv.percentage,
-        cv.Required(CONF_DURATION): cv.positive_time_period_milliseconds,
-        cv.Optional(
-            CONF_TRANSITION_LENGTH, default="0s"
-        ): cv.positive_time_period_milliseconds,
-    }
-)
-STROBE_COLOR_SCHEMA = _with_color_option(
-    STROBE_COLOR_SCHEMA, CONF_COLOR_BRIGHTNESS, CONF_RED, CONF_GREEN, CONF_BLUE
-)
-
-
@register_binary_effect(
    "strobe",
    StrobeLightEffect,
@@ -327,7 +280,29 @@ STROBE_COLOR_SCHEMA = _with_color_option(
            ],
        ): cv.All(
            cv.ensure_list(
-                STROBE_COLOR_SCHEMA,
+                cv.Schema(
+                    {
+                        cv.Optional(CONF_STATE, default=True): validate_light_state,
+                        cv.Optional(CONF_BRIGHTNESS, default=1.0): cv.percentage,
+                        cv.Optional(CONF_COLOR_MODE): cv.enum(
+                            COLOR_MODES, upper=True, space="_"
+                        ),
+                        cv.Optional(CONF_COLOR_BRIGHTNESS, default=1.0): cv.percentage,
+                        cv.Optional(CONF_RED, default=1.0): cv.percentage,
+                        cv.Optional(CONF_GREEN, default=1.0): cv.percentage,
+                        cv.Optional(CONF_BLUE, default=1.0): cv.percentage,
+                        cv.Optional(CONF_WHITE, default=1.0): cv.percentage,
+                        cv.Optional(CONF_COLOR_TEMPERATURE): cv.color_temperature,
+                        cv.Optional(CONF_COLD_WHITE, default=1.0): cv.percentage,
+                        cv.Optional(CONF_WARM_WHITE, default=1.0): cv.percentage,
+                        cv.Required(
+                            CONF_DURATION
+                        ): cv.positive_time_period_milliseconds,
+                        cv.Optional(
+                            CONF_TRANSITION_LENGTH, default="0s"
+                        ): cv.positive_time_period_milliseconds,
+                    }
+                ),
                cv.has_at_least_one_key(
                    CONF_STATE,
                    CONF_BRIGHTNESS,
@@ -431,27 +406,6 @@ async def addressable_rainbow_effect_to_code(config, effect_id):
    return var


-ADDRESSABLE_COLOR_WIPE_COLOR_SCHEMA = cv.Schema(
-    {
-        cv.Optional(CONF_COLOR_BRIGHTNESS): cv.percentage,
-        cv.Optional(CONF_RED): cv.percentage,
-        cv.Optional(CONF_GREEN): cv.percentage,
-        cv.Optional(CONF_BLUE): cv.percentage,
-        cv.Optional(CONF_WHITE, default=1.0): cv.percentage,
-        cv.Optional(CONF_RANDOM, default=False): cv.boolean,
-        cv.Required(CONF_NUM_LEDS): cv.All(cv.uint32_t, cv.Range(min=1)),
-        cv.Optional(CONF_GRADIENT, default=False): cv.boolean,
-    }
-)
-ADDRESSABLE_COLOR_WIPE_COLOR_SCHEMA = _with_color_option(
-    ADDRESSABLE_COLOR_WIPE_COLOR_SCHEMA,
-    CONF_COLOR_BRIGHTNESS,
-    CONF_RED,
-    CONF_GREEN,
-    CONF_BLUE,
-)
-
-
@register_addressable_effect(
    "addressable_color_wipe",
    AddressableColorWipeEffect,
@@ -459,7 +413,17 @@ ADDRESSABLE_COLOR_WIPE_COLOR_SCHEMA = _with_color_option(
    {
        cv.Optional(
            CONF_COLORS, default=[{CONF_NUM_LEDS: 1, CONF_RANDOM: True}]
-        ): cv.ensure_list(ADDRESSABLE_COLOR_WIPE_COLOR_SCHEMA),
+        ): cv.ensure_list(
+            {
+                cv.Optional(CONF_RED, default=1.0): cv.percentage,
+                cv.Optional(CONF_GREEN, default=1.0): cv.percentage,
+                cv.Optional(CONF_BLUE, default=1.0): cv.percentage,
+                cv.Optional(CONF_WHITE, default=1.0): cv.percentage,
+                cv.Optional(CONF_RANDOM, default=False): cv.boolean,
+                cv.Required(CONF_NUM_LEDS): cv.All(cv.uint32_t, cv.Range(min=1)),
+                cv.Optional(CONF_GRADIENT, default=False): cv.boolean,
+            }
+        ),
        cv.Optional(
            CONF_ADD_LED_INTERVAL, default="0.1s"
        ): cv.positive_time_period_milliseconds,
@@ -470,21 +434,19 @@ async def addressable_color_wipe_effect_to_code(config, effect_id):
    var = cg.new_Pvariable(effect_id, config[CONF_NAME])
    cg.add(var.set_add_led_interval(config[CONF_ADD_LED_INTERVAL]))
    cg.add(var.set_reverse(config[CONF_REVERSE]))
-    colors = []
-    for color in config.get(CONF_COLORS, []):
-        color_brightness = color[CONF_COLOR_BRIGHTNESS]
-        colors.append(
-            cg.StructInitializer(
-                AddressableColorWipeEffectColor,
-                ("r", int(round(color[CONF_RED] * color_brightness * 255))),
-                ("g", int(round(color[CONF_GREEN] * color_brightness * 255))),
-                ("b", int(round(color[CONF_BLUE] * color_brightness * 255))),
-                ("w", int(round(color[CONF_WHITE] * 255))),
-                ("random", color[CONF_RANDOM]),
-                ("num_leds", color[CONF_NUM_LEDS]),
-                ("gradient", color[CONF_GRADIENT]),
-            )
+    colors = [
+        cg.StructInitializer(
+            AddressableColorWipeEffectColor,
+            ("r", int(round(color[CONF_RED] * 255))),
+            ("g", int(round(color[CONF_GREEN] * 255))),
+            ("b", int(round(color[CONF_BLUE] * 255))),
+            ("w", int(round(color[CONF_WHITE] * 255))),
+            ("random", color[CONF_RANDOM]),
+            ("num_leds", color[CONF_NUM_LEDS]),
+            ("gradient", color[CONF_GRADIENT]),
        )
+        for color in config.get(CONF_COLORS, [])
+    ]
    cg.add(var.set_colors(colors))
    return var

@@ -156,13 +156,11 @@ void LightCall::perform() {
      ESP_LOGV(TAG, "  Effect: '%.*s'", (int) effect_s.size(), effect_s.c_str());
    }

-    if (this->effect_ != this->parent_->active_effect_index_) {
-      this->parent_->start_effect_(this->effect_);
+    this->parent_->start_effect_(this->effect_);

-      // Also set light color values when starting an effect
-      // For example to turn off the light
-      this->parent_->set_immediately_(v, true);
-    }
+    // Also set light color values when starting an effect
+    // For example to turn off the light
+    this->parent_->set_immediately_(v, true);
  } else {
    // INSTANT CHANGE
    this->parent_->set_immediately_(v, publish);
@@ -195,9 +193,10 @@ LightColorValues LightCall::validate_() {
  auto *name = this->parent_->get_name().c_str();
  auto traits = this->parent_->get_traits();

+#ifdef USE_LIGHT_RESUME_EFFECT
  // Snapshot before the adjustments below add flags of their own
-  const bool sets_values = (this->flags_ & VALUE_FLAGS_MASK) != 0;
  const bool plain_turn_on = this->has_state() && this->state_ && (this->flags_ & ~STATE_ONLY_FLAGS_MASK) == 0;
+#endif  // USE_LIGHT_RESUME_EFFECT

  // Color mode check
  if (this->has_color_mode() && !traits.supports_color_mode(this->color_mode_)) {
@@ -349,25 +348,9 @@ LightColorValues LightCall::validate_() {
  }
 #endif  // USE_LIGHT_RESUME_EFFECT

-  // A plain turn-on of a lit light keeps a running effect as it is.
-  // Effects' own calls don't publish, so they are not caught here.
-  if (plain_turn_on && this->get_publish_() && this->parent_->remote_values.is_on() &&
-      this->parent_->active_effect_index_ != 0) {
-    this->effect_ = this->parent_->active_effect_index_;
-    this->set_flag_(FLAG_HAS_EFFECT);
-  }
-
-  // If effect is already active, remove effect start. When a lit light that stays on gets no new values or flash,
-  // keep the flag and drop any transition, which has nothing to fade to; perform() then leaves the running effect
-  // undisturbed. A call that turns the light off keeps no flag, so the turn-off block below stops the effect.
-  // has_brightness() catches the brightness added above to make the turn-on visible.
+  // If effect is already active, remove effect start
  if (this->has_effect_() && this->effect_ == this->parent_->active_effect_index_) {
-    if (sets_values || this->has_brightness() || this->has_flash_() || this->effect_ == 0 ||
-        !this->parent_->remote_values.is_on() || !v.is_on()) {
-      this->clear_flag_(FLAG_HAS_EFFECT);
-    } else {
-      this->clear_flag_(FLAG_HAS_TRANSITION);
-    }
+    this->clear_flag_(FLAG_HAS_EFFECT);
  }

  // validate effect index
@@ -217,7 +217,6 @@ class LightCall {
  static constexpr uint16_t CLAMP_FLAGS_MASK = 0x00FFu;  // bits 0-7
  // Flags a plain turn-on may carry; any other flag means the caller asked for something specific
  static constexpr uint16_t STATE_ONLY_FLAGS_MASK = FLAG_HAS_STATE | FLAG_PUBLISH | FLAG_SAVE;
-  static constexpr uint16_t VALUE_FLAGS_MASK = CLAMP_FLAGS_MASK | FLAG_HAS_COLOR_TEMPERATURE | FLAG_HAS_COLOR_MODE;

  inline bool has_transition_() { return (this->flags_ & FLAG_HAS_TRANSITION) != 0; }
  inline bool has_flash_() { return (this->flags_ & FLAG_HAS_FLASH) != 0; }
@@ -20,13 +20,6 @@ __attribute__((weak)) void print_coredump() {}

 namespace esphome::logger {

-// Zephyr 3.7 renamed z_arch_esf_t to struct arch_esf; the old name was later removed.
-#if KERNEL_VERSION_NUMBER >= 0x030700
-using FatalErrorEsf = ::arch_esf;
-#else
-using FatalErrorEsf = z_arch_esf_t;
-#endif
-
 __attribute__((section(".noinit"))) struct {
  uint32_t magic;
  uint32_t reason;
@@ -175,7 +168,7 @@ void Logger::dump_crash_() {
  }
 }

-void k_sys_fatal_error_handler(unsigned int reason, const FatalErrorEsf *esf) {
+void k_sys_fatal_error_handler(unsigned int reason, const z_arch_esf_t *esf) {
  crash_buf.magic = App.get_config_hash();
  crash_buf.reason = reason;
  if (esf) {
@@ -199,7 +192,7 @@ void k_sys_fatal_error_handler(unsigned int reason, const FatalErrorEsf *esf) {

 extern "C" {

-void k_sys_fatal_error_handler(unsigned int reason, const esphome::logger::FatalErrorEsf *esf) {
+void k_sys_fatal_error_handler(unsigned int reason, const z_arch_esf_t *esf) {
  esphome::logger::k_sys_fatal_error_handler(reason, esf);
 }
 }
@@ -50,6 +50,10 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_TEMPERATURE, var.set_temperature_sensor)
-    await sensors(CONF_PRESSURE, var.set_pressure_sensor)
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
+
+    if pressure_config := config.get(CONF_PRESSURE):
+        sens = await sensor.new_sensor(pressure_config)
+        cg.add(var.set_pressure_sensor(sens))
@@ -48,7 +48,6 @@ from esphome.cpp_generator import MockObj
 from esphome.final_validate import full_config
 from esphome.helpers import write_file_if_changed
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
-from esphome.types import ConfigType
 from esphome.writer import clean_build
 from esphome.yaml_util import load_yaml

@@ -642,15 +641,7 @@ LVGL_TOP_LEVEL_SCHEMA = (
 )


-def _not_on_esp8266(config: ConfigType) -> ConfigType:
-    # ESP8266 does not have enough RAM for LVGL to be practical.
-    if CORE.is_esp8266:
-        raise cv.Invalid("LVGL is not supported on ESP8266")
-    return config
-
-
 LVGL_SCHEMA = cv.All(
-    _not_on_esp8266,
    container_schema(obj_spec, LVGL_TOP_LEVEL_SCHEMA),
    cv.has_at_most_one_key(CONF_PAGES, df.CONF_LAYOUT),
    add_hello_world,
@@ -1037,7 +1037,7 @@ void lv_mem_init() {}

 void lv_mem_deinit() {}

-#ifndef USE_ESP32
+#if defined(USE_HOST) || defined(USE_RP2) || defined(USE_ESP8266)
 void *lv_malloc_core(size_t size) {
  auto *ptr = malloc(size);  // NOLINT
  if (ptr == nullptr) {
@@ -1053,7 +1053,7 @@ static void *lv_alloc_draw_buf(size_t size, bool internal) {
  return malloc(size);  // NOLINT
 }

-#else
+#elif defined(USE_ESP32)
 static unsigned cap_bits = MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT;  // NOLINT

 static void *lv_alloc_draw_buf(size_t size, bool internal) {
@@ -53,9 +53,13 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_BATTERY_VOLTAGE, var.set_voltage_sensor)
-    await sensors(CONF_BATTERY_LEVEL, var.set_battery_remaining_sensor)
+    if voltage_config := config.get(CONF_BATTERY_VOLTAGE):
+        sens = await sensor.new_sensor(voltage_config)
+        cg.add(var.set_voltage_sensor(sens))
+
+    if CONF_BATTERY_LEVEL in config:
+        sens = await sensor.new_sensor(config[CONF_BATTERY_LEVEL])
+        cg.add(var.set_battery_remaining_sensor(sens))


 MAX17043_ACTION_SCHEMA = maybe_simple_id(
@@ -41,5 +41,6 @@ async def to_code(config: ConfigType) -> None:
    var = await sensor.new_sensor(config)
    await cg.register_component(var, config)
    await spi.register_spi_device(var, config)
-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_REFERENCE_TEMPERATURE, var.set_reference_sensor)
+    if CONF_REFERENCE_TEMPERATURE in config:
+        tc_ref = await sensor.new_sensor(config[CONF_REFERENCE_TEMPERATURE])
+        cg.add(var.set_reference_sensor(tc_ref))
@@ -71,6 +71,12 @@ async def to_code(config: ConfigType) -> None:

    cg.add(var.set_thermocouple_type(config[CONF_THERMOCOUPLE_TYPE]))

-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_HOT_JUNCTION, var.set_hot_junction)
-    await sensors(CONF_COLD_JUNCTION, var.set_cold_junction)
+    if CONF_HOT_JUNCTION in config:
+        conf = config[CONF_HOT_JUNCTION]
+        sens = await sensor.new_sensor(conf)
+        cg.add(var.set_hot_junction(sens))
+
+    if CONF_COLD_JUNCTION in config:
+        conf = config[CONF_COLD_JUNCTION]
+        sens = await sensor.new_sensor(conf)
+        cg.add(var.set_cold_junction(sens))
Author	SHA1	Message	Date
J. Nick Koston	256677a467	[ci] Keep the venv ninja on PATH, only cmake is missing in a real install	2026-09-30 11:47:54 +02:00
J. Nick Koston	65152ad82b	[ci] Temporary Windows compile without host cmake	2026-09-30 11:45:16 +02:00
J. Nick Koston	0f8713797c	[espidf] Resolve cmake through the IDF environment when reading the CMake cache	2026-09-30 11:43:25 +02:00