Address review: reference WDT_FEED_INTERVAL_MS in slow-path comment

Merge remote-tracking branch 'upstream/dev' into pr-15656
# Conflicts: # esphome/core/application.cpp # esphome/core/application.h
2026-07-01 13:02:50 +00:00 · 2026-04-14 08:13:06 -10:00 · 2026-04-14 08:12:21 -10:00 · 2026-04-11 15:19:35 -10:00 · 2026-04-11 14:57:01 -10:00 · 2026-04-11 14:54:02 -10:00
436 changed files with 4465 additions and 16274 deletions
@@ -1 +1 @@
-1b1ce6324c50c4595703c7df0a8a479b4fe84b71ff1a8793cce1a16f17a33324
+dc8ad5472d9fb44ce1ca29a0601afd65705642799a2819704dfc8459fbaf9815
@@ -12,7 +12,7 @@
    "--privileged",
    "-e",
    "GIT_EDITOR=code --wait"
-    // uncomment and edit the path in order to pass through local USB serial to the container
+    // uncomment and edit the path in order to pass though local USB serial to the conatiner
    // , "--device=/dev/ttyACM0"
  ],
  "appPort": 6052,
@@ -41,36 +41,16 @@ function generateReviewMessages(finalLabels, originalLabelCount, deprecatedInfo,

    let message = `${TOO_BIG_MARKER}\n### 📦 Pull Request Size\n\n`;

-    message +=
-      `Hey @${prAuthor}, thanks for the contribution! Just a heads up, ` +
-      `this PR is on the large side `;
-
    if (tooManyLabels && tooManyChanges) {
-      message +=
-        `(${nonTestChanges} line changes excluding tests, across ` +
-        `${originalLabelCount} different components/areas)`;
+      message += `This PR is too large with ${nonTestChanges} line changes (excluding tests) and affects ${originalLabelCount} different components/areas.`;
    } else if (tooManyLabels) {
-      message +=
-        `(it touches ${originalLabelCount} different components/areas)`;
+      message += `This PR affects ${originalLabelCount} different components/areas.`;
    } else {
-      message += `(${nonTestChanges} line changes excluding tests)`;
+      message += `This PR is too large with ${nonTestChanges} line changes (excluding tests).`;
    }

-    message += `, which makes it harder for maintainers to review.\n\n`;
-    message +=
-      `Smaller, focused PRs tend to be reviewed much faster since they ` +
-      `fit into the short gaps between other maintainer work; large ones ` +
-      `often have to wait for a rare long uninterrupted block of time. ` +
-      `If you can break this up into smaller pieces that can be reviewed ` +
-      `independently, it will almost certainly land faster overall.\n\n`;
-    message +=
-      `Before putting more time in, it's also worth popping into ` +
-      `\`#devs\` on [Discord](https://esphome.io/chat) so we can help ` +
-      `you scope things and flag anything already in flight.\n\n`;
-    message +=
-      `For more details (including how to split the work up), see: ` +
-      `https://developers.esphome.io/contributing/submitting-your-work/` +
-      `#how-to-approach-large-submissions`;
+    message += ` Please consider breaking it down into smaller, focused PRs to make review easier and reduce the risk of conflicts.\n\n`;
+    message += `For guidance on breaking down large PRs, see: https://developers.esphome.io/contributing/submitting-your-work/#how-to-approach-large-submissions`;

    messages.push(message);
  }
@@ -339,7 +339,7 @@ jobs:
          echo "binary=$BINARY" >> $GITHUB_OUTPUT

      - name: Run CodSpeed benchmarks
-        uses: CodSpeedHQ/action@658a901452bb54c799643e060733b7afe9121b8d # v4.14.0
+        uses: CodSpeedHQ/action@db35df748deb45fdef0960669f57d627c1956c30 # v4
        with:
          run: ${{ steps.build.outputs.binary }}
          mode: simulation
@@ -1,72 +0,0 @@
-name: Close PR From Fork Default Branch
-
-on:
-  # pull_request_target is required so we have permission to comment and close PRs from forks.
-  pull_request_target:
-    types: [opened, reopened]
-
-permissions:
-  pull-requests: write
-  issues: write
-
-jobs:
-  close:
-    name: Close PR opened from fork's default branch
-    runs-on: ubuntu-latest
-    if: >-
-      github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
-      && github.event.pull_request.head.ref == github.event.repository.default_branch
-    steps:
-      - uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
-        with:
-          script: |
-            const { owner, repo } = context.repo;
-            const prNumber = context.payload.pull_request.number;
-            const author = context.payload.pull_request.user.login;
-            const defaultBranch = context.payload.repository.default_branch;
-            const headRepo = context.payload.pull_request.head.repo.full_name;
-
-            const body = [
-              `Hi @${author}, thanks for opening a pull request! :tada:`,
-              ``,
-              `It looks like this PR was opened from the \`${defaultBranch}\` branch of your fork (\`${headRepo}\`), which is the same name as this repository's default branch. Working directly on \`${defaultBranch}\` in your fork causes a few problems:`,
-              ``,
-              `- Your fork's \`${defaultBranch}\` branch will permanently diverge from \`esphome/esphome:${defaultBranch}\`, making it hard to keep your fork up to date.`,
-              `- Any additional commits you push to \`${defaultBranch}\` will be added to this PR, so you can't easily work on multiple changes at once.`,
-              `- Pushing maintainer fixes to your branch is awkward, since it means committing directly to your fork's default branch.`,
-              `- It makes local collaboration painful — \`${defaultBranch}\` in a checkout becomes ambiguous between upstream and your fork, and maintainers end up with naming collisions when fetching your branch.`,
-              ``,
-              `Please re-open this as a new PR from a dedicated feature branch. The usual flow looks like:`,
-              ``,
-              `\`\`\`bash`,
-              `# Make sure your fork's ${defaultBranch} is up to date with upstream`,
-              `git remote add upstream https://github.com/${owner}/${repo}.git  # if you haven't already`,
-              `git fetch upstream`,
-              `git checkout ${defaultBranch}`,
-              `git reset --hard upstream/${defaultBranch}`,
-              `git push --force-with-lease origin ${defaultBranch}`,
-              ``,
-              `# Create a new branch for your change and cherry-pick / re-apply your commits there`,
-              `git checkout -b my-feature-branch upstream/${defaultBranch}`,
-              `# ...re-apply your changes, then:`,
-              `git push origin my-feature-branch`,
-              `\`\`\``,
-              ``,
-              `Then open a new pull request from \`my-feature-branch\` into \`${owner}/${repo}:${defaultBranch}\`.`,
-              ``,
-              `Closing this PR for now — sorry for the friction, and thanks again for contributing! :heart:`,
-            ].join('\n');
-
-            await github.rest.issues.createComment({
-              owner,
-              repo,
-              issue_number: prNumber,
-              body,
-            });
-
-            await github.rest.pulls.update({
-              owner,
-              repo,
-              pull_number: prNumber,
-              state: 'closed',
-            });
@@ -58,7 +58,7 @@ jobs:

      # Initializes the CodeQL tools for scanning.
      - name: Initialize CodeQL
-        uses: github/codeql-action/init@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # v4.35.2
+        uses: github/codeql-action/init@c10b8064de6f491fea524254123dbe5e09572f13 # v4.35.1
        with:
          languages: ${{ matrix.language }}
          build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
          exit 1

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # v4.35.2
+        uses: github/codeql-action/analyze@c10b8064de6f491fea524254123dbe5e09572f13 # v4.35.1
        with:
          category: "/language:${{matrix.language}}"
@@ -8,4 +8,4 @@ on:

 jobs:
  lock:
-    uses: esphome/workflows/.github/workflows/lock.yml@3c4e8446aa1029f1c346a482034b3ee1489077ca  # 2026.4.0
+    uses: esphome/workflows/.github/workflows/lock.yml@main
@@ -11,7 +11,7 @@ ci:
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    # Ruff version.
-    rev: v0.15.12
+    rev: v0.15.10
    hooks:
      # Run the linter.
      - id: ruff
@@ -58,7 +58,6 @@ repos:
        entry: python3 script/run-in-env.py pylint
        language: system
        types: [python]
-        files: ^esphome/.+\.py$
      - id: clang-tidy-hash
        name: Update clang-tidy hash
        entry: python script/clang_tidy_hash.py --update-if-changed
@@ -56,7 +56,6 @@ esphome/components/audio_adc/* @kbx81
 esphome/components/audio_dac/* @kbx81
 esphome/components/audio_file/* @kahrendt
 esphome/components/audio_file/media_source/* @kahrendt
-esphome/components/audio_http/* @kahrendt
 esphome/components/axs15231/* @clydebarrow
 esphome/components/b_parasite/* @rbaron
 esphome/components/ballu/* @bazuchan
@@ -404,7 +403,6 @@ esphome/components/qmp6988/* @andrewpc
 esphome/components/qr_code/* @wjtje
 esphome/components/qspi_dbi/* @clydebarrow
 esphome/components/qwiic_pir/* @kahrendt
-esphome/components/radio_frequency/* @kbx81
 esphome/components/radon_eye_ble/* @jeffeb3
 esphome/components/radon_eye_rd200/* @jeffeb3
 esphome/components/rc522/* @glmnet
@@ -440,11 +438,6 @@ esphome/components/sen0321/* @notjj
 esphome/components/sen21231/* @shreyaskarnik
 esphome/components/sen5x/* @martgras
 esphome/components/sen6x/* @martgras @mebner86 @mikelawrence @tuct
-esphome/components/sendspin/* @kahrendt
-esphome/components/sendspin/media_player/* @kahrendt
-esphome/components/sendspin/media_source/* @kahrendt
-esphome/components/sendspin/sensor/* @kahrendt
-esphome/components/sendspin/text_sensor/* @kahrendt
 esphome/components/sensirion_common/* @martgras
 esphome/components/sensor/* @esphome/core
 esphome/components/serial_proxy/* @kbx81
@@ -606,6 +599,6 @@ esphome/components/xxtea/* @clydebarrow
 esphome/components/zephyr/* @tomaszduda23
 esphome/components/zephyr_mcumgr/ota/* @tomaszduda23
 esphome/components/zhlt01/* @cfeenstra1024
-esphome/components/zigbee/* @luar123 @tomaszduda23
+esphome/components/zigbee/* @tomaszduda23
 esphome/components/zio_ultrasonic/* @kahrendt
 esphome/components/zwave_proxy/* @kbx81
@@ -4,5 +4,4 @@ include requirements.txt
 recursive-include esphome *.yaml
 recursive-include esphome *.cpp *.h *.tcc *.c
 recursive-include esphome *.py.script
-recursive-include esphome *.jinja
 recursive-include esphome LICENSE.txt
@@ -39,7 +39,6 @@ from esphome.const import (
    CONF_MDNS,
    CONF_MQTT,
    CONF_NAME,
-    CONF_NAME_ADD_MAC_SUFFIX,
    CONF_OTA,
    CONF_PASSWORD,
    CONF_PLATFORM,
@@ -72,7 +71,6 @@ from esphome.util import (
    run_external_process,
    safe_print,
 )
-from esphome.zeroconf import discover_mdns_devices

 _LOGGER = logging.getLogger(__name__)

@@ -206,64 +204,6 @@ def _resolve_with_cache(address: str, purpose: Purpose) -> list[str]:
    return [address]


-def _populate_mdns_cache(hosts_to_addresses: dict[str, list[str]]) -> None:
-    """Store discovered ``host -> [ips]`` entries in ``CORE.address_cache``.
-
-    Ensures ``CORE.address_cache`` exists, then records each mDNS hostname so
-    the downstream resolution path (``resolve_ip_address``) can skip opening a
-    second Zeroconf client.
-    """
-    from esphome.address_cache import AddressCache
-
-    if CORE.address_cache is None:
-        CORE.address_cache = AddressCache()
-    for host, addresses in hosts_to_addresses.items():
-        if addresses:
-            _LOGGER.debug("Caching mDNS result %s -> %s", host, addresses)
-        CORE.address_cache.add_mdns_addresses(host, addresses)
-
-
-def _discover_mac_suffix_devices() -> list[str] | None:
-    """Discover ``<name>-<mac>.local`` devices and cache their IPs.
-
-    Returns:
-        - ``None`` when discovery isn't applicable (``name_add_mac_suffix`` off,
-          mDNS disabled, or ``CORE.address`` is already an IP). Callers should
-          then fall back to whatever default OTA address they normally use.
-        - ``[]`` when discovery ran but found nothing. Callers should NOT fall
-          back to the base name: with ``name_add_mac_suffix`` enabled, the base
-          name by definition doesn't exist on the network.
-        - A non-empty sorted list of ``.local`` hostnames on success.
-
-    Populates ``CORE.address_cache`` so downstream resolution (``espota2`` or
-    ``aioesphomeapi`` via :func:`_resolve_network_devices`) reuses the IPs we
-    already have without opening a second Zeroconf client.
-    """
-    if not (has_name_add_mac_suffix() and has_mdns() and has_non_ip_address()):
-        return None
-    _LOGGER.info("Discovering devices...")
-    if not (discovered := discover_mdns_devices(CORE.name)):
-        _LOGGER.warning(
-            "No devices matching '%s-<mac>.local' were discovered.", CORE.name
-        )
-        return []
-    _populate_mdns_cache(discovered)
-    return list(discovered)
-
-
-def _ota_hostnames_for_default(purpose: Purpose) -> list[str]:
-    """Return OTA hostname(s) for the ``--device OTA`` / default-resolve path.
-
-    When ``name_add_mac_suffix`` is enabled, returns discovered
-    ``<name>-<mac>.local`` hostnames (possibly empty — in which case the
-    caller should not fall back to the base name). Otherwise falls back to
-    the cache-resolved ``CORE.address``.
-    """
-    if (discovered := _discover_mac_suffix_devices()) is not None:
-        return discovered
-    return _resolve_with_cache(CORE.address, purpose)
-
-
 def choose_upload_log_host(
    default: list[str] | str | None,
    check_default: str | None,
@@ -302,14 +242,14 @@ def choose_upload_log_host(
                        resolved.append("MQTT")

                    if has_api() and has_non_ip_address() and has_resolvable_address():
-                        resolved.extend(_ota_hostnames_for_default(purpose))
+                        resolved.extend(_resolve_with_cache(CORE.address, purpose))

                elif purpose == Purpose.UPLOADING:
                    if has_ota() and has_mqtt_ip_lookup():
                        resolved.append("MQTTIP")

                    if has_ota() and has_non_ip_address() and has_resolvable_address():
-                        resolved.extend(_ota_hostnames_for_default(purpose))
+                        resolved.extend(_resolve_with_cache(CORE.address, purpose))
            else:
                resolved.append(device)
        if not resolved:
@@ -341,29 +281,22 @@ def choose_upload_log_host(
        elif bootsel.permission_error:
            bootsel_permission_error = True

-    def add_ota_options() -> None:
-        """Add OTA options, using mDNS discovery if name_add_mac_suffix is enabled."""
-        if (discovered := _discover_mac_suffix_devices()) is not None:
-            # Discovery was applicable. Use whatever we found — on empty,
-            # intentionally skip the base-name fallback since with
-            # name_add_mac_suffix on, the base name doesn't exist on the net.
-            for host in discovered:
-                options.append((f"Over The Air ({host})", host))
-        elif has_resolvable_address():
-            options.append((f"Over The Air ({CORE.address})", CORE.address))
-        if has_mqtt_ip_lookup():
-            options.append(("Over The Air (MQTT IP lookup)", "MQTTIP"))
-
    if purpose == Purpose.LOGGING:
        if has_mqtt_logging():
            mqtt_config = CORE.config[CONF_MQTT]
            options.append((f"MQTT ({mqtt_config[CONF_BROKER]})", "MQTT"))

        if has_api():
-            add_ota_options()
+            if has_resolvable_address():
+                options.append((f"Over The Air ({CORE.address})", CORE.address))
+            if has_mqtt_ip_lookup():
+                options.append(("Over The Air (MQTT IP lookup)", "MQTTIP"))

    elif purpose == Purpose.UPLOADING and has_ota():
-        add_ota_options()
+        if has_resolvable_address():
+            options.append((f"Over The Air ({CORE.address})", CORE.address))
+        if has_mqtt_ip_lookup():
+            options.append(("Over The Air (MQTT IP lookup)", "MQTTIP"))

    # Show helpful BOOTSEL instructions for RP2040 when no BOOTSEL device is found
    if (
@@ -474,17 +407,7 @@ def has_resolvable_address() -> bool:
    return not CORE.address.endswith(".local")


-def has_name_add_mac_suffix() -> bool:
-    """Check if name_add_mac_suffix is enabled in the config."""
-    if CORE.config is None:
-        return False
-    esphome_config = CORE.config.get(CONF_ESPHOME, {})
-    return esphome_config.get(CONF_NAME_ADD_MAC_SUFFIX, False)
-
-
-def mqtt_get_ip(
-    config: ConfigType, username: str, password: str, client_id: str
-) -> list[str]:
+def mqtt_get_ip(config: ConfigType, username: str, password: str, client_id: str):
    from esphome import mqtt

    return mqtt.get_esphome_device_ip(config, username, password, client_id)
@@ -497,9 +420,6 @@ def _resolve_network_devices(

    This function filters the devices list to:
    - Replace MQTT/MQTTIP magic strings with actual IP addresses via MQTT lookup
-    - Expand hostnames that are already in ``CORE.address_cache`` to their
-      cached IPs so downstream code (e.g. aioesphomeapi) doesn't open a second
-      Zeroconf client to resolve them
    - Deduplicate addresses while preserving order
    - Only resolve MQTT once even if multiple MQTT strings are present
    - If MQTT resolution fails, log a warning and continue with other devices
@@ -524,29 +444,13 @@ def _resolve_network_devices(
                    mqtt_ips = mqtt_get_ip(
                        config, args.username, args.password, args.client_id
                    )
-                    # pylint can't infer mqtt_get_ip's return through its
-                    # lazy ``from esphome import mqtt`` import, so it flags
-                    # the genexpr below.
-                    network_devices.extend(
-                        addr
-                        for addr in mqtt_ips  # pylint: disable=not-an-iterable
-                        if addr not in network_devices
-                    )
+                    network_devices.extend(mqtt_ips)
                except EsphomeError as err:
                    _LOGGER.warning(
                        "MQTT IP discovery failed (%s), will try other devices if available",
                        err,
                    )
                mqtt_resolved = True
-            continue
-
-        # If the hostname is already in the address cache (e.g. populated by
-        # mDNS discovery), substitute the cached IPs so aioesphomeapi doesn't
-        # open its own Zeroconf to re-resolve it.
-        if CORE.address_cache and (cached := CORE.address_cache.get_addresses(device)):
-            network_devices.extend(
-                addr for addr in cached if addr not in network_devices
-            )
        elif device not in network_devices:
            # Regular network address or IP - add if not already present
            network_devices.append(device)
@@ -101,17 +101,6 @@ class AddressCache:
        """Check if any cache entries exist."""
        return bool(self.mdns_cache or self.dns_cache)

-    def add_mdns_addresses(self, hostname: str, addresses: list[str]) -> None:
-        """Store resolved mDNS addresses for ``hostname`` in the cache.
-
-        Callers that discover ``.local`` hosts (e.g. via mDNS browse) can use
-        this to avoid a second resolution round-trip during the upload path.
-        No-op when ``addresses`` is empty.
-        """
-        if not addresses:
-            return
-        self.mdns_cache[normalize_hostname(hostname)] = addresses
-
    @classmethod
    def from_cli_args(
        cls, mdns_args: Iterable[str], dns_args: Iterable[str]
@@ -1,56 +0,0 @@
-"""Helpers for running an async coroutine from sync code via a daemon thread.
-
-``asyncio.run(coro())`` in the main thread blocks until the loop's cleanup
-cycle finishes, which can add hundreds of milliseconds before the caller
-receives the result. Running the loop in a daemon thread lets the caller
-observe the result as soon as the coroutine completes while cleanup finishes
-in the background.
-"""
-
-from __future__ import annotations
-
-import asyncio
-from collections.abc import Awaitable, Callable
-import threading
-from typing import Generic, TypeVar
-
-_T = TypeVar("_T")
-
-
-class AsyncThreadRunner(threading.Thread, Generic[_T]):
-    """Run an async coroutine in a daemon thread and expose its result.
-
-    The runner catches all exceptions from the coroutine and stores them in
-    ``exception`` so ``event`` is always set — this prevents callers waiting
-    on ``event`` from hanging forever when the coroutine crashes.
-
-    Typical usage::
-
-        runner = AsyncThreadRunner(lambda: my_coro(arg))
-        runner.start()
-        if not runner.event.wait(timeout=5.0):
-            ...  # timed out
-        if runner.exception is not None:
-            raise runner.exception
-        result = runner.result
-    """
-
-    def __init__(self, coro_factory: Callable[[], Awaitable[_T]]) -> None:
-        super().__init__(daemon=True)
-        self._coro_factory = coro_factory
-        self.result: _T | None = None
-        self.exception: BaseException | None = None
-        self.event = threading.Event()
-
-    async def _runner(self) -> None:
-        try:
-            self.result = await self._coro_factory()
-        except Exception as exc:  # pylint: disable=broad-except
-            # Capture all exceptions so ``event`` is always set — otherwise a
-            # crash would hang the waiter forever.
-            self.exception = exc
-        finally:
-            self.event.set()
-
-    def run(self) -> None:
-        asyncio.run(self._runner())
@@ -199,10 +199,11 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
                    return cv.Schema([schema])(value)
                except cv.Invalid as err2:
                    if "extra keys not allowed" in str(err2) and len(err2.path) == 2:
-                        raise err from None
+                        # pylint: disable=raise-missing-from
+                        raise err
                    if "Unable to find action" in str(err):
-                        raise err2 from None
-                    raise cv.MultipleInvalid([err, err2]) from None
+                        raise err2
+                    raise cv.MultipleInvalid([err, err2])
        elif isinstance(value, dict):
            if CONF_THEN in value:
                return [schema(value)]
@@ -151,8 +151,8 @@ class ConfigBundleCreator:

    def __init__(self, config: dict[str, Any]) -> None:
        self._config = config
-        self._config_dir = Path(CORE.config_dir).resolve()
-        self._config_path = Path(CORE.config_path).resolve()
+        self._config_dir = CORE.config_dir
+        self._config_path = CORE.config_path
        self._files: list[BundleFile] = []
        self._seen_paths: set[Path] = set()
        self._secrets_paths: set[Path] = set()
@@ -258,36 +258,21 @@ class ConfigBundleCreator:
    def _discover_yaml_includes(self) -> None:
        """Discover YAML files loaded during config parsing.

-        Deliberately uses a fresh re-parse and force-loads every deferred
-        ``IncludeFile`` to include *all* potentially-reachable includes,
-        even branches not selected by the local substitutions. Bundles are
-        meant to be compiled on another system where command-line
-        substitution overrides may choose a different branch — e.g.
-        ``!include network/${eth_model}/config.yaml`` must ship every
-        candidate so the remote build can pick any one.
-
-        Entries with unresolved substitution variables in the filename
-        path are skipped with a warning (they cannot be resolved without
-        the substitution pass).
+        We track files by wrapping _load_yaml_internal. The config has already
+        been loaded at this point (bundle is a POST_CONFIG_ACTION), so we
+        re-load just to discover the file list.

        Secrets files are tracked separately so we can filter them to
        only include the keys this config actually references.
        """
-        # Must be a fresh parse: IncludeFile.load() caches its result in
-        # _content, and we discover files by listening for loader calls. On
-        # an already-parsed tree the cache is populated, .load() returns
-        # without calling the loader, the listener never fires, and the
-        # referenced files would be silently dropped from the bundle.
        with yaml_util.track_yaml_loads() as loaded_files:
            try:
-                data = yaml_util.load_yaml(self._config_path)
+                yaml_util.load_yaml(self._config_path)
            except EsphomeError:
                _LOGGER.debug(
                    "Bundle: re-loading YAML for include discovery failed, "
                    "proceeding with partial file list"
                )
-            else:
-                _force_load_include_files(data)

        for fpath in loaded_files:
            if fpath == self._config_path.resolve():
@@ -623,57 +608,6 @@ def _add_bytes_to_tar(tar: tarfile.TarFile, name: str, data: bytes) -> None:
    tar.addfile(info, io.BytesIO(data))


-def _force_load_include_files(obj: Any, _seen: set[int] | None = None) -> None:
-    """Recursively resolve any ``IncludeFile`` instances in a YAML tree.
-
-    Nested ``!include`` returns a deferred ``IncludeFile`` that is only
-    resolved during the substitution pass. During bundle discovery we need
-    the referenced files to actually load so the ``track_yaml_loads``
-    listener fires for them.
-
-    ``IncludeFile`` instances with unresolved substitution variables in the
-    filename cannot be loaded — we skip and warn about those.
-    """
-    if _seen is None:
-        _seen = set()
-
-    if isinstance(obj, yaml_util.IncludeFile):
-        if id(obj) in _seen:
-            return
-        _seen.add(id(obj))
-        if obj.has_unresolved_expressions():
-            _LOGGER.warning(
-                "Bundle: cannot resolve !include %s (referenced from %s) "
-                "with substitutions in path",
-                obj.file,
-                obj.parent_file,
-            )
-            return
-        try:
-            loaded = obj.load()
-        except EsphomeError as err:
-            _LOGGER.warning(
-                "Bundle: failed to load !include %s (referenced from %s): %s",
-                obj.file,
-                obj.parent_file,
-                err,
-            )
-            return
-        _force_load_include_files(loaded, _seen)
-    elif isinstance(obj, dict):
-        if id(obj) in _seen:
-            return
-        _seen.add(id(obj))
-        for value in obj.values():
-            _force_load_include_files(value, _seen)
-    elif isinstance(obj, (list, tuple)):
-        if id(obj) in _seen:
-            return
-        _seen.add(id(obj))
-        for item in obj:
-            _force_load_include_files(item, _seen)
-
-
 def _resolve_include_path(include_path: Any) -> Path | None:
    """Resolve an include path to absolute, skipping system includes."""
    if isinstance(include_path, str) and include_path.startswith("<"):
@@ -190,7 +190,7 @@ void AcDimmer::setup() {
    this->zero_cross_pin_->setup();
    this->store_.zero_cross_pin = this->zero_cross_pin_->to_isr();
    this->zero_cross_pin_->attach_interrupt(&AcDimmerDataStore::s_gpio_intr, &this->store_,
-                                            this->zero_cross_interrupt_type_);
+                                            gpio::INTERRUPT_FALLING_EDGE);
  }

 #ifdef USE_ESP8266
@@ -226,25 +226,19 @@ void AcDimmer::write_state(float state) {
 void AcDimmer::dump_config() {
  ESP_LOGCONFIG(TAG,
                "AcDimmer:\n"
-                "  Min Power: %.1f%%\n"
-                "  Init with half cycle: %s",
+                "   Min Power: %.1f%%\n"
+                "   Init with half cycle: %s",
                this->store_.min_power / 10.0f, YESNO(this->init_with_half_cycle_));
  LOG_PIN("  Output Pin: ", this->gate_pin_);
  LOG_PIN("  Zero-Cross Pin: ", this->zero_cross_pin_);
-  if (this->zero_cross_interrupt_type_ == gpio::INTERRUPT_RISING_EDGE) {
-    ESP_LOGCONFIG(TAG, "  Interrupt Type: rising");
-  } else if (this->zero_cross_interrupt_type_ == gpio::INTERRUPT_FALLING_EDGE) {
-    ESP_LOGCONFIG(TAG, "  Interrupt Type: falling");
-  } else {
-    ESP_LOGCONFIG(TAG, "  Interrupt Type: any");
-  }
  if (method_ == DIM_METHOD_LEADING_PULSE) {
-    ESP_LOGCONFIG(TAG, "  Method: leading pulse");
+    ESP_LOGCONFIG(TAG, "   Method: leading pulse");
  } else if (method_ == DIM_METHOD_LEADING) {
-    ESP_LOGCONFIG(TAG, "  Method: leading");
+    ESP_LOGCONFIG(TAG, "   Method: leading");
  } else {
-    ESP_LOGCONFIG(TAG, "  Method: trailing");
+    ESP_LOGCONFIG(TAG, "   Method: trailing");
  }
+
  LOG_FLOAT_OUTPUT(this);
  ESP_LOGV(TAG, "  Estimated Frequency: %.3fHz", 1e6f / this->store_.cycle_time_us / 2);
 }
@@ -48,7 +48,6 @@ class AcDimmer : public output::FloatOutput, public Component {
  void dump_config() override;
  void set_gate_pin(InternalGPIOPin *gate_pin) { gate_pin_ = gate_pin; }
  void set_zero_cross_pin(InternalGPIOPin *zero_cross_pin) { zero_cross_pin_ = zero_cross_pin; }
-  void set_zero_cross_interrupt_type(gpio::InterruptType type) { zero_cross_interrupt_type_ = type; }
  void set_init_with_half_cycle(bool init_with_half_cycle) { init_with_half_cycle_ = init_with_half_cycle; }
  void set_method(DimMethod method) { method_ = method; }

@@ -57,7 +56,6 @@ class AcDimmer : public output::FloatOutput, public Component {

  InternalGPIOPin *gate_pin_;
  InternalGPIOPin *zero_cross_pin_;
-  gpio::InterruptType zero_cross_interrupt_type_;
  AcDimmerDataStore store_;
  bool init_with_half_cycle_;
  DimMethod method_;
@@ -7,8 +7,6 @@ from esphome.core import CORE

 CODEOWNERS = ["@glmnet"]

-gpio_ns = cg.esphome_ns.namespace("gpio")
-
 ac_dimmer_ns = cg.esphome_ns.namespace("ac_dimmer")
 AcDimmer = ac_dimmer_ns.class_("AcDimmer", output.FloatOutput, cg.Component)

@@ -19,26 +17,15 @@ DIM_METHODS = {
    "TRAILING": DimMethod.DIM_METHOD_TRAILING,
 }

-ZC_INTERRUPT_TYPES = {
-    "RISING": gpio_ns.INTERRUPT_RISING_EDGE,
-    "FALLING": gpio_ns.INTERRUPT_FALLING_EDGE,
-    "ANY": gpio_ns.INTERRUPT_ANY_EDGE,
-}
-
 CONF_GATE_PIN = "gate_pin"
 CONF_ZERO_CROSS_PIN = "zero_cross_pin"
 CONF_INIT_WITH_HALF_CYCLE = "init_with_half_cycle"
-CONF_ZERO_CROSS_INTERRUPT_TYPE = "zero_cross_interrupt_type"
-
 CONFIG_SCHEMA = cv.All(
    output.FLOAT_OUTPUT_SCHEMA.extend(
        {
            cv.Required(CONF_ID): cv.declare_id(AcDimmer),
            cv.Required(CONF_GATE_PIN): pins.internal_gpio_output_pin_schema,
            cv.Required(CONF_ZERO_CROSS_PIN): pins.internal_gpio_input_pin_schema,
-            cv.Optional(CONF_ZERO_CROSS_INTERRUPT_TYPE, default="FALLING"): cv.enum(
-                ZC_INTERRUPT_TYPES, upper=True, space="_"
-            ),
            cv.Optional(CONF_INIT_WITH_HALF_CYCLE, default=True): cv.boolean,
            cv.Optional(CONF_METHOD, default="leading pulse"): cv.enum(
                DIM_METHODS, upper=True, space="_"
@@ -67,6 +54,5 @@ async def to_code(config):
    cg.add(var.set_gate_pin(pin))
    pin = await cg.gpio_pin_expression(config[CONF_ZERO_CROSS_PIN])
    cg.add(var.set_zero_cross_pin(pin))
-    cg.add(var.set_zero_cross_interrupt_type(config[CONF_ZERO_CROSS_INTERRUPT_TYPE]))
    cg.add(var.set_init_with_half_cycle(config[CONF_INIT_WITH_HALF_CYCLE]))
    cg.add(var.set_method(config[CONF_METHOD]))
@@ -2,8 +2,6 @@
 #include <cstdio>
 #include <cstring>

-#include "esphome/core/alloc_helpers.h"
-
 namespace esphome {
 namespace anova {

@@ -107,14 +105,14 @@ void AnovaCodec::decode(const uint8_t *data, uint16_t length) {
    }
    case READ_TARGET_TEMPERATURE:
    case SET_TARGET_TEMPERATURE: {
-      this->target_temp_ = parse_number<float>(str_until(buf, '\r')).value_or(0.0f);  // NOLINT
+      this->target_temp_ = parse_number<float>(str_until(buf, '\r')).value_or(0.0f);
      if (this->fahrenheit_)
        this->target_temp_ = ftoc(this->target_temp_);
      this->has_target_temp_ = true;
      break;
    }
    case READ_CURRENT_TEMPERATURE: {
-      this->current_temp_ = parse_number<float>(str_until(buf, '\r')).value_or(0.0f);  // NOLINT
+      this->current_temp_ = parse_number<float>(str_until(buf, '\r')).value_or(0.0f);
      if (this->fahrenheit_)
        this->current_temp_ = ftoc(this->current_temp_);
      this->has_current_temp_ = true;
@@ -291,12 +291,12 @@ CONFIG_SCHEMA = cv.All(
            cv.SplitDefault(
                CONF_MAX_CONNECTIONS,
                esp8266=4,  # ~40KB free RAM, each connection uses ~500-1000 bytes
-                esp32=5,  # 520KB RAM available
+                esp32=8,  # 520KB RAM available
                rp2040=4,  # 264KB RAM but LWIP constraints
-                bk72xx=5,  # Moderate RAM
-                rtl87xx=5,  # Moderate RAM
+                bk72xx=8,  # Moderate RAM
+                rtl87xx=8,  # Moderate RAM
                host=8,  # Abundant resources
-                ln882x=5,  # Moderate RAM
+                ln882x=8,  # Moderate RAM
            ): cv.int_range(min=1, max=20),
            # Maximum queued send buffers per connection before dropping connection
            # Each buffer uses ~8-12 bytes overhead plus actual message size
@@ -336,7 +336,8 @@ async def to_code(config: ConfigType) -> None:
    cg.add(var.set_batch_delay(config[CONF_BATCH_DELAY]))
    if CONF_LISTEN_BACKLOG in config:
        cg.add(var.set_listen_backlog(config[CONF_LISTEN_BACKLOG]))
-    cg.add_define("MAX_API_CONNECTIONS", config[CONF_MAX_CONNECTIONS])
+    if CONF_MAX_CONNECTIONS in config:
+        cg.add(var.set_max_connections(config[CONF_MAX_CONNECTIONS]))
    cg.add_define("API_MAX_SEND_QUEUE", config[CONF_MAX_SEND_QUEUE])

    # Set USE_API_USER_DEFINED_ACTIONS if any services are enabled
@@ -1025,13 +1025,6 @@ message CameraImageRequest {
  bool stream = 2;
 }

-// ==================== TEMPERATURE UNIT ====================
-enum TemperatureUnit {
-  TEMPERATURE_UNIT_CELSIUS = 0;
-  TEMPERATURE_UNIT_FAHRENHEIT = 1;
-  TEMPERATURE_UNIT_KELVIN = 2;
-}
-
 // ==================== CLIMATE ====================
 enum ClimateMode {
  CLIMATE_MODE_OFF = 0;
@@ -1117,7 +1110,6 @@ message ListEntitiesClimateResponse {
  float visual_max_humidity = 25;
  uint32 device_id = 26 [(field_ifdef) = "USE_DEVICES"];
  uint32 feature_flags = 27;
-  TemperatureUnit temperature_unit = 28;
 }
 message ClimateStateResponse {
  option (id) = 47;
@@ -1211,7 +1203,6 @@ message ListEntitiesWaterHeaterResponse {
  repeated WaterHeaterMode supported_modes = 11 [(container_pointer_no_template) = "water_heater::WaterHeaterModeMask"];
  // Bitmask of WaterHeaterFeature flags
  uint32 supported_features = 12;
-  TemperatureUnit temperature_unit = 13;
 }

 message WaterHeaterStateResponse {
@@ -2553,50 +2544,27 @@ message ListEntitiesInfraredResponse {
 message InfraredRFTransmitRawTimingsRequest {
  option (id) = 136;
  option (source) = SOURCE_CLIENT;
-  option (ifdef) = "USE_IR_RF || USE_RADIO_FREQUENCY";
+  option (ifdef) = "USE_IR_RF";

  uint32 device_id = 1 [(field_ifdef) = "USE_DEVICES"];
-  fixed32 key = 2 [(force) = true];     // Key identifying the transmitter instance
-  uint32 carrier_frequency = 3;         // Carrier frequency in Hz
-  uint32 repeat_count = 4;              // Number of times to transmit (1 = once, 2 = twice, etc.)
+  fixed32 key = 2 [(force) = true];                                       // Key identifying the transmitter instance
+  uint32 carrier_frequency = 3;                          // Carrier frequency in Hz
+  uint32 repeat_count = 4;                               // Number of times to transmit (1 = once, 2 = twice, etc.)
  repeated sint32 timings = 5 [packed = true, (packed_buffer) = true];  // Raw timings in microseconds (zigzag-encoded): positive = mark (LED/TX on), negative = space (LED/TX off)
-  uint32 modulation = 6;  // RadioFrequencyModulation enum value (0 = OOK; ignored for IR entities)
 }

 // Event message for received infrared/RF data
 message InfraredRFReceiveEvent {
  option (id) = 137;
  option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_IR_RF || USE_RADIO_FREQUENCY";
+  option (ifdef) = "USE_IR_RF";
  option (no_delay) = true;

  uint32 device_id = 1 [(field_ifdef) = "USE_DEVICES"];
-  fixed32 key = 2 [(force) = true];     // Key identifying the receiver instance
+  fixed32 key = 2 [(force) = true];                                    // Key identifying the receiver instance
  repeated sint32 timings = 3 [packed = true, (container_pointer_no_template) = "std::vector<int32_t>"];  // Raw timings in microseconds (zigzag-encoded): alternating mark/space periods
 }

-// ==================== RADIO FREQUENCY ====================
-
-// Lists available radio frequency entity instances
-message ListEntitiesRadioFrequencyResponse {
-  option (id) = 148;
-  option (base_class) = "InfoResponseProtoMessage";
-  option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_RADIO_FREQUENCY";
-
-  string object_id = 1 [(max_data_length) = 120, (force) = true];
-  fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true];
-  string icon = 4 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
-  bool disabled_by_default = 5;
-  EntityCategory entity_category = 6;
-  uint32 device_id = 7 [(field_ifdef) = "USE_DEVICES"];
-  uint32 capabilities = 8;           // Bitmask of RadioFrequencyCapabilityFlags: bit 0 = transmitter, bit 1 = receiver
-  uint32 frequency_min = 9;          // Minimum tunable frequency in Hz; if min == max (non-zero): fixed frequency; 0 = unspecified
-  uint32 frequency_max = 10;         // Maximum tunable frequency in Hz; 0 = unspecified
-  uint32 supported_modulations = 11; // Bitmask of supported RadioFrequencyModulation values (bit N = modulation N supported)
-}
-
 // ==================== SERIAL PROXY ====================

 enum SerialProxyParity {
@@ -49,9 +49,6 @@
 #ifdef USE_INFRARED
 #include "esphome/components/infrared/infrared.h"
 #endif
-#ifdef USE_RADIO_FREQUENCY
-#include "esphome/components/radio_frequency/radio_frequency.h"
-#endif

 namespace esphome::api {

@@ -103,12 +100,6 @@ static const int CAMERA_STOP_STREAM = 5000;
  entity_type *entity_var = App.get_##getter_name##_by_key(msg.key, msg.device_id); \
  if ((entity_var) == nullptr) \
    return;
-
-// Helper macro for multi-entity dispatch: looks up an entity by key and device_id without early return or make_call().
-// Use when multiple entity types must be checked in sequence (at most one will match).
-#define ENTITY_COMMAND_LOOKUP(entity_type, entity_var, getter_name) \
-  entity_type *entity_var = App.get_##getter_name##_by_key(msg.key, msg.device_id)
-
 #else  // No device support, use simpler macros
 // Helper macro for entity command handlers - gets entity by key, returns if not found, and creates call
 // object
@@ -124,12 +115,6 @@ static const int CAMERA_STOP_STREAM = 5000;
  entity_type *entity_var = App.get_##getter_name##_by_key(msg.key); \
  if ((entity_var) == nullptr) \
    return;
-
-// Helper macro for multi-entity dispatch: looks up an entity by key without early return or make_call().
-// Use when multiple entity types must be checked in sequence (at most one will match).
-#define ENTITY_COMMAND_LOOKUP(entity_type, entity_var, getter_name) \
-  entity_type *entity_var = App.get_##getter_name##_by_key(msg.key)
-
 #endif  // USE_DEVICES

 APIConnection::APIConnection(std::unique_ptr<socket::Socket> sock, APIServer *parent) : parent_(parent) {
@@ -1486,36 +1471,19 @@ uint16_t APIConnection::try_send_event_info(EntityBase *entity, APIConnection *c
 }
 #endif

-#if defined(USE_IR_RF) || defined(USE_RADIO_FREQUENCY)
+#ifdef USE_IR_RF
 void APIConnection::on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &msg) {
-  // Dispatch by key: infrared entities are checked first, then radio frequency entities.
-  // The key is unique across all entity instances on a device, so at most one lookup will succeed.
+  // TODO: When RF is implemented, add a field to the message to distinguish IR vs RF
+  // and dispatch to the appropriate entity type based on that field.
 #ifdef USE_INFRARED
-  ENTITY_COMMAND_LOOKUP(infrared::Infrared, infrared, infrared);
-  if (infrared != nullptr) {
-    auto call = infrared->make_call();
-    call.set_carrier_frequency(msg.carrier_frequency);
-    call.set_raw_timings_packed(msg.timings_data_, msg.timings_length_, msg.timings_count_);
-    call.set_repeat_count(msg.repeat_count);
-    call.perform();
-    return;
-  }
-#endif
-#ifdef USE_RADIO_FREQUENCY
-  ENTITY_COMMAND_LOOKUP(radio_frequency::RadioFrequency, radio_frequency, radio_frequency);
-  if (radio_frequency != nullptr) {
-    auto call = radio_frequency->make_call();
-    call.set_frequency(msg.carrier_frequency);
-    call.set_modulation(static_cast<radio_frequency::RadioFrequencyModulation>(msg.modulation));
-    call.set_repeat_count(msg.repeat_count);
-    call.set_raw_timings_packed(msg.timings_data_, msg.timings_length_, msg.timings_count_);
-    call.perform();
-  }
+  ENTITY_COMMAND_MAKE_CALL(infrared::Infrared, infrared, infrared)
+  call.set_carrier_frequency(msg.carrier_frequency);
+  call.set_raw_timings_packed(msg.timings_data_, msg.timings_length_, msg.timings_count_);
+  call.set_repeat_count(msg.repeat_count);
+  call.perform();
 #endif
 }
-#endif

-#if defined(USE_IR_RF) || defined(USE_RADIO_FREQUENCY)
 void APIConnection::send_infrared_rf_receive_event(const InfraredRFReceiveEvent &msg) { this->send_message(msg); }
 #endif

@@ -1612,19 +1580,6 @@ uint16_t APIConnection::try_send_infrared_info(EntityBase *entity, APIConnection
 }
 #endif

-#ifdef USE_RADIO_FREQUENCY
-uint16_t APIConnection::try_send_radio_frequency_info(EntityBase *entity, APIConnection *conn,
-                                                      uint32_t remaining_size) {
-  auto *rf = static_cast<radio_frequency::RadioFrequency *>(entity);
-  ListEntitiesRadioFrequencyResponse msg;
-  msg.capabilities = rf->get_capability_flags();
-  msg.frequency_min = rf->get_traits().get_frequency_min_hz();
-  msg.frequency_max = rf->get_traits().get_frequency_max_hz();
-  msg.supported_modulations = rf->get_traits().get_supported_modulations();
-  return fill_and_encode_entity_info(rf, msg, conn, remaining_size);
-}
-#endif
-
 #ifdef USE_UPDATE
 bool APIConnection::send_update_state(update::UpdateEntity *update) {
  return this->send_message_smart_(update, UpdateStateResponse::MESSAGE_TYPE, UpdateStateResponse::ESTIMATED_SIZE);
@@ -2386,9 +2341,6 @@ uint16_t APIConnection::dispatch_message_(const DeferredBatch::BatchItem &item,
 #ifdef USE_INFRARED
    CASE_INFO_ONLY(infrared, ListEntitiesInfraredResponse)
 #endif
-#ifdef USE_RADIO_FREQUENCY
-    CASE_INFO_ONLY(radio_frequency, ListEntitiesRadioFrequencyResponse)
-#endif
 #ifdef USE_EVENT
    CASE_INFO_ONLY(event, ListEntitiesEventResponse)
 #endif
@@ -223,7 +223,7 @@ class APIConnection final : public APIServerConnectionBase {
  void on_water_heater_command_request(const WaterHeaterCommandRequest &msg);
 #endif

-#if defined(USE_IR_RF) || defined(USE_RADIO_FREQUENCY)
+#ifdef USE_IR_RF
  void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &msg);
  void send_infrared_rf_receive_event(const InfraredRFReceiveEvent &msg);
 #endif
@@ -612,9 +612,6 @@ class APIConnection final : public APIServerConnectionBase {
 #ifdef USE_INFRARED
  static uint16_t try_send_infrared_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
-#ifdef USE_RADIO_FREQUENCY
-  static uint16_t try_send_radio_frequency_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
-#endif
 #ifdef USE_EVENT
  static uint16_t try_send_event_response(event::Event *event, StringRef event_type, APIConnection *conn,
                                          uint32_t remaining_size);
@@ -1439,7 +1439,6 @@ uint8_t *ListEntitiesClimateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCO
  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 26, this->device_id);
 #endif
  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 27, this->feature_flags);
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 28, static_cast<uint32_t>(this->temperature_unit));
  return pos;
 }
 uint32_t ListEntitiesClimateResponse::calculate_size() const {
@@ -1489,7 +1488,6 @@ uint32_t ListEntitiesClimateResponse::calculate_size() const {
  size += ProtoSize::calc_uint32(2, this->device_id);
 #endif
  size += ProtoSize::calc_uint32(2, this->feature_flags);
-  size += this->temperature_unit ? 3 : 0;
  return size;
 }
 uint8_t *ClimateStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -1647,7 +1645,6 @@ uint8_t *ListEntitiesWaterHeaterResponse::encode(ProtoWriteBuffer &buffer PROTO_
    ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, static_cast<uint32_t>(it), true);
  }
  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 12, this->supported_features);
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 13, static_cast<uint32_t>(this->temperature_unit));
  return pos;
 }
 uint32_t ListEntitiesWaterHeaterResponse::calculate_size() const {
@@ -1670,7 +1667,6 @@ uint32_t ListEntitiesWaterHeaterResponse::calculate_size() const {
    size += this->supported_modes->size() * 2;
  }
  size += ProtoSize::calc_uint32(1, this->supported_features);
-  size += this->temperature_unit ? 2 : 0;
  return size;
 }
 uint8_t *WaterHeaterStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -3865,7 +3861,7 @@ uint32_t ListEntitiesInfraredResponse::calculate_size() const {
  return size;
 }
 #endif
-#if defined(USE_IR_RF) || defined(USE_RADIO_FREQUENCY)
+#ifdef USE_IR_RF
 bool InfraredRFTransmitRawTimingsRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
  switch (field_id) {
 #ifdef USE_DEVICES
@@ -3879,9 +3875,6 @@ bool InfraredRFTransmitRawTimingsRequest::decode_varint(uint32_t field_id, proto
    case 4:
      this->repeat_count = value;
      break;
-    case 6:
-      this->modulation = value;
-      break;
    default:
      return false;
  }
@@ -3935,46 +3928,6 @@ uint32_t InfraredRFReceiveEvent::calculate_size() const {
  return size;
 }
 #endif
-#ifdef USE_RADIO_FREQUENCY
-uint8_t *ListEntitiesRadioFrequencyResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
-  uint8_t *__restrict__ pos = buffer.get_pos();
-  ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 10, this->object_id);
-  ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, this->key);
-  ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, this->name);
-#ifdef USE_ENTITY_ICON
-  ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 4, this->icon);
-#endif
-  ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 5, this->disabled_by_default);
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, static_cast<uint32_t>(this->entity_category));
-#ifdef USE_DEVICES
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, this->device_id);
-#endif
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 8, this->capabilities);
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 9, this->frequency_min);
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, this->frequency_max);
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 11, this->supported_modulations);
-  return pos;
-}
-uint32_t ListEntitiesRadioFrequencyResponse::calculate_size() const {
-  uint32_t size = 0;
-  size += 2 + this->object_id.size();
-  size += 5;
-  size += 2 + this->name.size();
-#ifdef USE_ENTITY_ICON
-  size += !this->icon.empty() ? 2 + this->icon.size() : 0;
-#endif
-  size += ProtoSize::calc_bool(1, this->disabled_by_default);
-  size += this->entity_category ? 2 : 0;
-#ifdef USE_DEVICES
-  size += ProtoSize::calc_uint32(1, this->device_id);
-#endif
-  size += ProtoSize::calc_uint32(1, this->capabilities);
-  size += ProtoSize::calc_uint32(1, this->frequency_min);
-  size += ProtoSize::calc_uint32(1, this->frequency_max);
-  size += ProtoSize::calc_uint32(1, this->supported_modulations);
-  return size;
-}
-#endif
 #ifdef USE_SERIAL_PROXY
 bool SerialProxyConfigureRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
  switch (field_id) {
@@ -92,11 +92,6 @@ enum SupportsResponseType : uint32_t {
  SUPPORTS_RESPONSE_STATUS = 100,
 };
 #endif
-enum TemperatureUnit : uint32_t {
-  TEMPERATURE_UNIT_CELSIUS = 0,
-  TEMPERATURE_UNIT_FAHRENHEIT = 1,
-  TEMPERATURE_UNIT_KELVIN = 2,
-};
 #ifdef USE_CLIMATE
 enum ClimateMode : uint32_t {
  CLIMATE_MODE_OFF = 0,
@@ -1377,7 +1372,7 @@ class CameraImageRequest final : public ProtoDecodableMessage {
 class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
 public:
  static constexpr uint8_t MESSAGE_TYPE = 46;
-  static constexpr uint8_t ESTIMATED_SIZE = 153;
+  static constexpr uint8_t ESTIMATED_SIZE = 150;
 #ifdef HAS_PROTO_MESSAGE_DUMP
  const LogString *message_name() const override { return LOG_STR("list_entities_climate_response"); }
 #endif
@@ -1399,7 +1394,6 @@ class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
  float visual_min_humidity{0.0f};
  float visual_max_humidity{0.0f};
  uint32_t feature_flags{0};
-  enums::TemperatureUnit temperature_unit{};
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
  uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1477,7 +1471,7 @@ class ClimateCommandRequest final : public CommandProtoMessage {
 class ListEntitiesWaterHeaterResponse final : public InfoResponseProtoMessage {
 public:
  static constexpr uint8_t MESSAGE_TYPE = 132;
-  static constexpr uint8_t ESTIMATED_SIZE = 65;
+  static constexpr uint8_t ESTIMATED_SIZE = 63;
 #ifdef HAS_PROTO_MESSAGE_DUMP
  const LogString *message_name() const override { return LOG_STR("list_entities_water_heater_response"); }
 #endif
@@ -1486,7 +1480,6 @@ class ListEntitiesWaterHeaterResponse final : public InfoResponseProtoMessage {
  float target_temperature_step{0.0f};
  const water_heater::WaterHeaterModeMask *supported_modes{};
  uint32_t supported_features{0};
-  enums::TemperatureUnit temperature_unit{};
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
  uint32_t calculate_size() const;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -3061,11 +3054,11 @@ class ListEntitiesInfraredResponse final : public InfoResponseProtoMessage {
 protected:
 };
 #endif
-#if defined(USE_IR_RF) || defined(USE_RADIO_FREQUENCY)
+#ifdef USE_IR_RF
 class InfraredRFTransmitRawTimingsRequest final : public ProtoDecodableMessage {
 public:
  static constexpr uint8_t MESSAGE_TYPE = 136;
-  static constexpr uint8_t ESTIMATED_SIZE = 224;
+  static constexpr uint8_t ESTIMATED_SIZE = 220;
 #ifdef HAS_PROTO_MESSAGE_DUMP
  const LogString *message_name() const override { return LOG_STR("infrared_rf_transmit_raw_timings_request"); }
 #endif
@@ -3078,7 +3071,6 @@ class InfraredRFTransmitRawTimingsRequest final : public ProtoDecodableMessage {
  const uint8_t *timings_data_{nullptr};
  uint16_t timings_length_{0};
  uint16_t timings_count_{0};
-  uint32_t modulation{0};
 #ifdef HAS_PROTO_MESSAGE_DUMP
  const char *dump_to(DumpBuffer &out) const override;
 #endif
@@ -3109,27 +3101,6 @@ class InfraredRFReceiveEvent final : public ProtoMessage {
 protected:
 };
 #endif
-#ifdef USE_RADIO_FREQUENCY
-class ListEntitiesRadioFrequencyResponse final : public InfoResponseProtoMessage {
- public:
-  static constexpr uint8_t MESSAGE_TYPE = 148;
-  static constexpr uint8_t ESTIMATED_SIZE = 56;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const LogString *message_name() const override { return LOG_STR("list_entities_radio_frequency_response"); }
-#endif
-  uint32_t capabilities{0};
-  uint32_t frequency_min{0};
-  uint32_t frequency_max{0};
-  uint32_t supported_modulations{0};
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
-  uint32_t calculate_size() const;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *dump_to(DumpBuffer &out) const override;
-#endif
-
- protected:
-};
-#endif
 #ifdef USE_SERIAL_PROXY
 class SerialProxyConfigureRequest final : public ProtoDecodableMessage {
 public:
@@ -297,18 +297,6 @@ template<> const char *proto_enum_to_string<enums::SupportsResponseType>(enums::
  }
 }
 #endif
-template<> const char *proto_enum_to_string<enums::TemperatureUnit>(enums::TemperatureUnit value) {
-  switch (value) {
-    case enums::TEMPERATURE_UNIT_CELSIUS:
-      return ESPHOME_PSTR("TEMPERATURE_UNIT_CELSIUS");
-    case enums::TEMPERATURE_UNIT_FAHRENHEIT:
-      return ESPHOME_PSTR("TEMPERATURE_UNIT_FAHRENHEIT");
-    case enums::TEMPERATURE_UNIT_KELVIN:
-      return ESPHOME_PSTR("TEMPERATURE_UNIT_KELVIN");
-    default:
-      return ESPHOME_PSTR("UNKNOWN");
-  }
-}
 #ifdef USE_CLIMATE
 template<> const char *proto_enum_to_string<enums::ClimateMode>(enums::ClimateMode value) {
  switch (value) {
@@ -1551,7 +1539,6 @@ const char *ListEntitiesClimateResponse::dump_to(DumpBuffer &out) const {
  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
  dump_field(out, ESPHOME_PSTR("feature_flags"), this->feature_flags);
-  dump_field(out, ESPHOME_PSTR("temperature_unit"), static_cast<enums::TemperatureUnit>(this->temperature_unit));
  return out.c_str();
 }
 const char *ClimateStateResponse::dump_to(DumpBuffer &out) const {
@@ -1625,7 +1612,6 @@ const char *ListEntitiesWaterHeaterResponse::dump_to(DumpBuffer &out) const {
    dump_field(out, ESPHOME_PSTR("supported_modes"), static_cast<enums::WaterHeaterMode>(it), 4);
  }
  dump_field(out, ESPHOME_PSTR("supported_features"), this->supported_features);
-  dump_field(out, ESPHOME_PSTR("temperature_unit"), static_cast<enums::TemperatureUnit>(this->temperature_unit));
  return out.c_str();
 }
 const char *WaterHeaterStateResponse::dump_to(DumpBuffer &out) const {
@@ -2590,7 +2576,7 @@ const char *ListEntitiesInfraredResponse::dump_to(DumpBuffer &out) const {
  return out.c_str();
 }
 #endif
-#if defined(USE_IR_RF) || defined(USE_RADIO_FREQUENCY)
+#ifdef USE_IR_RF
 const char *InfraredRFTransmitRawTimingsRequest::dump_to(DumpBuffer &out) const {
  MessageDumpHelper helper(out, ESPHOME_PSTR("InfraredRFTransmitRawTimingsRequest"));
 #ifdef USE_DEVICES
@@ -2605,7 +2591,6 @@ const char *InfraredRFTransmitRawTimingsRequest::dump_to(DumpBuffer &out) const
  out.append_p(ESPHOME_PSTR(" values, "));
  append_uint(out, this->timings_length_);
  out.append_p(ESPHOME_PSTR(" bytes]\n"));
-  dump_field(out, ESPHOME_PSTR("modulation"), this->modulation);
  return out.c_str();
 }
 const char *InfraredRFReceiveEvent::dump_to(DumpBuffer &out) const {
@@ -2620,27 +2605,6 @@ const char *InfraredRFReceiveEvent::dump_to(DumpBuffer &out) const {
  return out.c_str();
 }
 #endif
-#ifdef USE_RADIO_FREQUENCY
-const char *ListEntitiesRadioFrequencyResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesRadioFrequencyResponse"));
-  dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
-  dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_field(out, ESPHOME_PSTR("name"), this->name);
-#ifdef USE_ENTITY_ICON
-  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
-#endif
-  dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
-  dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
-#ifdef USE_DEVICES
-  dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
-#endif
-  dump_field(out, ESPHOME_PSTR("capabilities"), this->capabilities);
-  dump_field(out, ESPHOME_PSTR("frequency_min"), this->frequency_min);
-  dump_field(out, ESPHOME_PSTR("frequency_max"), this->frequency_max);
-  dump_field(out, ESPHOME_PSTR("supported_modulations"), this->supported_modulations);
-  return out.c_str();
-}
-#endif
 #ifdef USE_SERIAL_PROXY
 const char *SerialProxyConfigureRequest::dump_to(DumpBuffer &out) const {
  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyConfigureRequest"));
@@ -625,7 +625,7 @@ void APIConnection::read_message_(uint32_t msg_size, uint32_t msg_type, const ui
      break;
    }
 #endif
-#if defined(USE_IR_RF) || defined(USE_RADIO_FREQUENCY)
+#ifdef USE_IR_RF
    case InfraredRFTransmitRawTimingsRequest::MESSAGE_TYPE: {
      InfraredRFTransmitRawTimingsRequest msg;
      msg.decode(msg_data, msg_size);
@@ -211,7 +211,7 @@ class APIServerConnectionBase {
  void on_z_wave_proxy_request(const ZWaveProxyRequest &value){};
 #endif

-#if defined(USE_IR_RF) || defined(USE_RADIO_FREQUENCY)
+#ifdef USE_IR_RF
  void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &value){};
 #endif

@@ -118,7 +118,7 @@ void APIServer::loop() {
    this->accept_new_connections_();
  }

-  if (this->api_connection_count_ == 0) {
+  if (this->clients_.empty()) {
    // Check reboot timeout - done in loop to avoid scheduler heap churn
    // (cancelled scheduler items sit in heap memory until their scheduled time)
    if (this->reboot_timeout_ != 0) {
@@ -135,15 +135,15 @@ void APIServer::loop() {
  // Check network connectivity once for all clients
  if (!network::is_connected()) {
    // Network is down - disconnect all clients
-    for (auto &client : this->active_clients()) {
+    for (auto &client : this->clients_) {
      client->on_fatal_error();
      client->log_client_(ESPHOME_LOG_LEVEL_WARN, LOG_STR("Network down; disconnect"));
    }
    // Continue to process and clean up the clients below
  }

-  uint8_t client_index = 0;
-  while (client_index < this->api_connection_count_) {
+  size_t client_index = 0;
+  while (client_index < this->clients_.size()) {
    auto &client = this->clients_[client_index];

    // Common case: process active client
@@ -161,7 +161,7 @@ void APIServer::loop() {
  }
 }

-void APIServer::remove_client_(uint8_t client_index) {
+void APIServer::remove_client_(size_t client_index) {
  auto &client = this->clients_[client_index];

 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
@@ -179,17 +179,14 @@ void APIServer::remove_client_(uint8_t client_index) {
  // Close socket now (was deferred from on_fatal_error to allow getpeername)
  client->helper_->close();

-  // Swap-and-reset: move the removed client to the trailing slot and null it out so slots
-  // [api_connection_count_, N) remain nullptr.
-  const uint8_t last_index = this->api_connection_count_ - 1;
-  if (client_index < last_index) {
-    std::swap(this->clients_[client_index], this->clients_[last_index]);
+  // Swap with the last element and pop (avoids expensive vector shifts)
+  if (client_index < this->clients_.size() - 1) {
+    std::swap(this->clients_[client_index], this->clients_.back());
  }
-  this->clients_[last_index].reset();
-  this->api_connection_count_--;
+  this->clients_.pop_back();

  // Last client disconnected - set warning and start tracking for reboot timeout
-  if (this->api_connection_count_ == 0 && this->reboot_timeout_ != 0) {
+  if (this->clients_.empty() && this->reboot_timeout_ != 0) {
    this->status_set_warning(LOG_STR("waiting for client connection"));
    this->last_connected_ = App.get_loop_component_start_time();
  }
@@ -213,8 +210,8 @@ void __attribute__((flatten)) APIServer::accept_new_connections_() {
    sock->getpeername_to(peername);

    // Check if we're at the connection limit
-    if (this->api_connection_count_ >= MAX_API_CONNECTIONS) {
-      ESP_LOGW(TAG, "Max connections (%d), rejecting %s", MAX_API_CONNECTIONS, peername);
+    if (this->clients_.size() >= this->max_connections_) {
+      ESP_LOGW(TAG, "Max connections (%d), rejecting %s", this->max_connections_, peername);
      // Immediately close - socket destructor will handle cleanup
      sock.reset();
      continue;
@@ -223,11 +220,11 @@ void __attribute__((flatten)) APIServer::accept_new_connections_() {
    ESP_LOGD(TAG, "Accept %s", peername);

    auto *conn = new APIConnection(std::move(sock), this);
-    this->clients_[this->api_connection_count_++].reset(conn);
+    this->clients_.emplace_back(conn);
    conn->start();

    // First client connected - clear warning and update timestamp
-    if (this->api_connection_count_ == 1 && this->reboot_timeout_ != 0) {
+    if (this->clients_.size() == 1 && this->reboot_timeout_ != 0) {
      this->status_clear_warning();
      this->last_connected_ = App.get_loop_component_start_time();
    }
@@ -240,7 +237,7 @@ void APIServer::dump_config() {
                "  Address: %s:%u\n"
                "  Listen backlog: %u\n"
                "  Max connections: %u",
-                network::get_use_address(), this->port_, this->listen_backlog_, MAX_API_CONNECTIONS);
+                network::get_use_address(), this->port_, this->listen_backlog_, this->max_connections_);
 #ifdef USE_API_NOISE
  ESP_LOGCONFIG(TAG, "  Noise encryption: %s", YESNO(this->noise_ctx_.has_psk()));
  if (!this->noise_ctx_.has_psk()) {
@@ -258,7 +255,7 @@ void APIServer::handle_disconnect(APIConnection *conn) {}
  void APIServer::on_##entity_name##_update(entity_type *obj) { /* NOLINT(bugprone-macro-parentheses) */ \
    if (obj->is_internal()) \
      return; \
-    for (auto &c : this->active_clients()) { \
+    for (auto &c : this->clients_) { \
      if (c->flags_.state_subscription) \
        c->send_##entity_name##_state(obj); \
    } \
@@ -340,7 +337,7 @@ API_DISPATCH_UPDATE(water_heater::WaterHeater, water_heater)
 void APIServer::on_event(event::Event *obj) {
  if (obj->is_internal())
    return;
-  for (auto &c : this->active_clients()) {
+  for (auto &c : this->clients_) {
    if (c->flags_.state_subscription)
      c->send_event(obj);
  }
@@ -352,7 +349,7 @@ void APIServer::on_event(event::Event *obj) {
 void APIServer::on_update(update::UpdateEntity *obj) {
  if (obj->is_internal())
    return;
-  for (auto &c : this->active_clients()) {
+  for (auto &c : this->clients_) {
    if (c->flags_.state_subscription)
      c->send_update_state(obj);
  }
@@ -363,12 +360,12 @@ void APIServer::on_update(update::UpdateEntity *obj) {
 void APIServer::on_zwave_proxy_request(const ZWaveProxyRequest &msg) {
  // We could add code to manage a second subscription type, but, since this message type is
  //  very infrequent and small, we simply send it to all clients
-  for (auto &c : this->active_clients())
+  for (auto &c : this->clients_)
    c->send_message(msg);
 }
 #endif

-#if defined(USE_IR_RF) || defined(USE_RADIO_FREQUENCY)
+#ifdef USE_IR_RF
 void APIServer::send_infrared_rf_receive_event([[maybe_unused]] uint32_t device_id, uint32_t key,
                                               const std::vector<int32_t> *timings) {
  InfraredRFReceiveEvent resp{};
@@ -378,7 +375,7 @@ void APIServer::send_infrared_rf_receive_event([[maybe_unused]] uint32_t device_
  resp.key = key;
  resp.timings = timings;

-  for (auto &c : this->active_clients())
+  for (auto &c : this->clients_)
    c->send_infrared_rf_receive_event(resp);
 }
 #endif
@@ -395,7 +392,7 @@ void APIServer::set_batch_delay(uint16_t batch_delay) { this->batch_delay_ = bat

 #ifdef USE_API_HOMEASSISTANT_SERVICES
 void APIServer::send_homeassistant_action(const HomeassistantActionRequest &call) {
-  for (auto &client : this->active_clients()) {
+  for (auto &client : this->clients_) {
    client->send_homeassistant_action(call);
  }
 }
@@ -535,7 +532,7 @@ bool APIServer::update_noise_psk_(const SavedNoisePsk &new_psk, const LogString
        return;
      }
      ESP_LOGW(TAG, "Disconnecting all clients to reset PSK");
-      for (auto &c : this->active_clients()) {
+      for (auto &c : this->clients_) {
        DisconnectRequest req;
        c->send_message(req);
      }
@@ -586,7 +583,7 @@ bool APIServer::clear_noise_psk(bool make_active) {

 #ifdef USE_HOMEASSISTANT_TIME
 void APIServer::request_time() {
-  for (auto &client : this->active_clients()) {
+  for (auto &client : this->clients_) {
    if (!client->flags_.remove && client->is_authenticated()) {
      client->send_time_request();
      return;  // Only request from one client to avoid clock conflicts
@@ -596,8 +593,8 @@ void APIServer::request_time() {
 #endif

 bool APIServer::is_connected_with_state_subscription() const {
-  for (uint8_t i = 0; i < this->api_connection_count_; i++) {
-    if (this->clients_[i]->flags_.state_subscription) {
+  for (const auto &client : this->clients_) {
+    if (client->flags_.state_subscription) {
      return true;
    }
  }
@@ -612,7 +609,7 @@ void APIServer::on_log(uint8_t level, const char *tag, const char *message, size
    // we would be filling a buffer we are trying to clear
    return;
  }
-  for (auto &c : this->active_clients()) {
+  for (auto &c : this->clients_) {
    if (!c->flags_.remove && c->get_log_subscription_level() >= level)
      c->try_send_log_message(level, tag, message, message_len);
  }
@@ -621,7 +618,7 @@ void APIServer::on_log(uint8_t level, const char *tag, const char *message, size

 #ifdef USE_CAMERA
 void APIServer::on_camera_image(const std::shared_ptr<camera::CameraImage> &image) {
-  for (auto &c : this->active_clients()) {
+  for (auto &c : this->clients_) {
    if (!c->flags_.remove)
      c->set_camera_state(image);
  }
@@ -638,7 +635,7 @@ void APIServer::on_shutdown() {
  this->batch_delay_ = 5;

  // Send disconnect requests to all connected clients
-  for (auto &c : this->active_clients()) {
+  for (auto &c : this->clients_) {
    DisconnectRequest req;
    if (!c->send_message(req)) {
      // If we can't send the disconnect request directly (tx_buffer full),
@@ -656,7 +653,7 @@ bool APIServer::teardown() {
  this->loop();

  // Return true only when all clients have been torn down
-  return this->api_connection_count_ == 0;
+  return this->clients_.empty();
 }

 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
@@ -21,8 +21,6 @@
 #include "esphome/components/camera/camera.h"
 #endif

-#include <array>
-#include <memory>
 #include <vector>

 namespace esphome::api {
@@ -65,6 +63,7 @@ class APIServer final : public Component,
  void set_batch_delay(uint16_t batch_delay);
  uint16_t get_batch_delay() const { return batch_delay_; }
  void set_listen_backlog(uint8_t listen_backlog) { this->listen_backlog_ = listen_backlog; }
+  void set_max_connections(uint8_t max_connections) { this->max_connections_ = max_connections; }

  // Get reference to shared buffer for API connections
  APIBuffer &get_shared_buffer_ref() { return shared_write_buffer_; }
@@ -183,30 +182,13 @@ class APIServer final : public Component,
 #ifdef USE_ZWAVE_PROXY
  void on_zwave_proxy_request(const ZWaveProxyRequest &msg);
 #endif
-#if defined(USE_IR_RF) || defined(USE_RADIO_FREQUENCY)
+#ifdef USE_IR_RF
  void send_infrared_rf_receive_event(uint32_t device_id, uint32_t key, const std::vector<int32_t> *timings);
 #endif

-  bool is_connected() const { return this->api_connection_count_ != 0; }
+  bool is_connected() const { return !this->clients_.empty(); }
  bool is_connected_with_state_subscription() const;

-  // Range-for view over the populated slice [0, api_connection_count_). Read-only with respect
-  // to ownership — callers get `const unique_ptr&` so they can invoke non-const methods on the
-  // APIConnection but cannot reset/move the slot and break the count invariant.
-  using APIConnectionPtr = std::unique_ptr<APIConnection>;
-  class ActiveClientsView {
-    const APIConnectionPtr *begin_;
-    const APIConnectionPtr *end_;
-
-   public:
-    ActiveClientsView(const APIConnectionPtr *b, const APIConnectionPtr *e) : begin_(b), end_(e) {}
-    const APIConnectionPtr *begin() const { return this->begin_; }
-    const APIConnectionPtr *end() const { return this->end_; }
-  };
-  ActiveClientsView active_clients() const {
-    return {this->clients_.data(), this->clients_.data() + this->api_connection_count_};
-  }
-
 #ifdef USE_API_HOMEASSISTANT_STATES
  struct HomeAssistantStateSubscription {
    const char *entity_id;  // Pointer to flash (internal) or heap (external)
@@ -252,8 +234,8 @@ class APIServer final : public Component,
 protected:
  // Accept incoming socket connections. Only called when socket has pending connections.
  void __attribute__((noinline)) accept_new_connections_();
-  // Remove a disconnected client by index. Swaps with the last populated slot and resets it.
-  void __attribute__((noinline)) remove_client_(uint8_t client_index);
+  // Remove a disconnected client by index. Swaps with last element and pops.
+  void __attribute__((noinline)) remove_client_(size_t client_index);

 #ifdef USE_API_NOISE
  bool update_noise_psk_(const SavedNoisePsk &new_psk, const LogString *save_log_msg, const LogString *fail_log_msg,
@@ -291,9 +273,8 @@ class APIServer final : public Component,
  uint32_t reboot_timeout_{300000};
  uint32_t last_connected_{0};

-  // Slots [0, api_connection_count_) are populated; trailing slots are always nullptr.
-  std::array<std::unique_ptr<APIConnection>, MAX_API_CONNECTIONS> clients_{};
  // Vectors and strings (12 bytes each on 32-bit)
+  std::vector<std::unique_ptr<APIConnection>> clients_;
  // Shared proto write buffer for all connections.
  // Not pre-allocated: all send paths call prepare_first_message_buffer() which
  // reserves the exact needed size. Pre-allocating here would cause heap fragmentation
@@ -328,10 +309,10 @@ class APIServer final : public Component,
  uint16_t port_{6053};
  uint16_t batch_delay_{100};
  // Connection limits - these defaults will be overridden by config values
-  // from cv.SplitDefault in __init__.py which sets platform-specific defaults.
+  // from cv.SplitDefault in __init__.py which sets platform-specific defaults
  uint8_t listen_backlog_{4};
+  uint8_t max_connections_{8};
  bool shutting_down_ = false;
-  uint8_t api_connection_count_{0};
  // 7 bytes used, 1 byte padding

 #ifdef USE_API_NOISE
@@ -93,24 +93,7 @@ async def async_run_logs(
                    config, raw_line, backtrace_state=backtrace_state
                )

-    # Safe to fall back to plaintext here only for this diagnostics use
-    # case: the stream is one-way from device to client, and this code
-    # never accepts commands or acts on any message the device sends.
-    # An on-path attacker could still both inject fabricated log lines
-    # and passively read the device's log output (and any state data
-    # delivered when subscribe_states is enabled), so this does lose
-    # confidentiality as well as authentication/integrity. That tradeoff
-    # is acceptable for operator-visible logs, which aioesphomeapi also
-    # warns may come from an unverified device. Never mirror this opt-in
-    # for any connection that sends data to the device or uses Home
-    # Assistant actions.
-    stop = await async_run(
-        cli,
-        on_log,
-        name=name,
-        subscribe_states=subscribe_states,
-        allow_plaintext_fallback=True,
-    )
+    stop = await async_run(cli, on_log, name=name, subscribe_states=subscribe_states)
    try:
        await asyncio.Event().wait()
    finally:
@@ -79,9 +79,6 @@ LIST_ENTITIES_HANDLER(water_heater, water_heater::WaterHeater, ListEntitiesWater
 #ifdef USE_INFRARED
 LIST_ENTITIES_HANDLER(infrared, infrared::Infrared, ListEntitiesInfraredResponse)
 #endif
-#ifdef USE_RADIO_FREQUENCY
-LIST_ENTITIES_HANDLER(radio_frequency, radio_frequency::RadioFrequency, ListEntitiesRadioFrequencyResponse)
-#endif
 #ifdef USE_EVENT
 LIST_ENTITIES_HANDLER(event, event::Event, ListEntitiesEventResponse)
 #endif
@@ -87,9 +87,6 @@ class ListEntitiesIterator final : public ComponentIterator {
 #ifdef USE_INFRARED
  bool on_infrared(infrared::Infrared *entity) override;
 #endif
-#ifdef USE_RADIO_FREQUENCY
-  bool on_radio_frequency(radio_frequency::RadioFrequency *entity) override;
-#endif
 #ifdef USE_EVENT
  bool on_event(event::Event *entity) override;
 #endif
@@ -82,9 +82,6 @@ class InitialStateIterator final : public ComponentIterator {
 #ifdef USE_INFRARED
  bool on_infrared(infrared::Infrared *infrared) override { return true; };
 #endif
-#ifdef USE_RADIO_FREQUENCY
-  bool on_radio_frequency(radio_frequency::RadioFrequency *radio_frequency) override { return true; };
-#endif
 #ifdef USE_EVENT
  bool on_event(event::Event *event) override { return true; };
 #endif
@@ -83,7 +83,7 @@ def angle_to_position(value, min=-360, max=360):
        value = angle(min=min, max=max)(value)
        return (RESOLUTION + round(value * ANGLE_TO_POSITION)) % RESOLUTION
    except cv.Invalid as e:
-        raise cv.Invalid(f"When using angle, {e.error_message}") from e
+        raise cv.Invalid(f"When using angle, {e.error_message}")


 def percent_to_position(value):
@@ -164,7 +164,7 @@ def has_valid_range_config():
        except cv.Invalid as e:
            raise cv.Invalid(
                f"The range between start and end position is invalid. It was was {range} but {e.error_message}"
-            ) from e
+            )

    return validator

@@ -183,19 +183,19 @@ async def at581x_settings_to_code(config, action_id, template_arg, args):
        cg.add(var.set_sensing_distance(template_))

    if selfcheck := config.get(CONF_POWERON_SELFCHECK_TIME):
-        template_ = await cg.templatable(selfcheck, args, cg.int_)
+        template_ = await cg.templatable(selfcheck, args, cg.int32)
        cg.add(var.set_poweron_selfcheck_time(template_))

    if protect := config.get(CONF_PROTECT_TIME):
-        template_ = await cg.templatable(protect, args, cg.int_)
+        template_ = await cg.templatable(protect, args, cg.int32)
        cg.add(var.set_protect_time(template_))

    if trig_base := config.get(CONF_TRIGGER_BASE):
-        template_ = await cg.templatable(trig_base, args, cg.int_)
+        template_ = await cg.templatable(trig_base, args, cg.int32)
        cg.add(var.set_trigger_base(template_))

    if trig_keep := config.get(CONF_TRIGGER_KEEP):
-        template_ = await cg.templatable(trig_keep, args, cg.int_)
+        template_ = await cg.templatable(trig_keep, args, cg.int32)
        cg.add(var.set_trigger_keep(template_))

    if (stage_gain := config.get(CONF_STAGE_GAIN)) is not None:
@@ -116,7 +116,7 @@ def read_audio_file_and_type(file_config: ConfigType) -> tuple[bytes, MockObj]:
        raise cv.Invalid(
            f"Unable to determine audio file type of '{path}'. "
            f"Try re-encoding the file into a supported format. Details: {e}"
-        ) from e
+        )

    media_file_type = audio.AUDIO_FILE_TYPE_ENUM["NONE"]
    if file_type == "wav":
@@ -1,163 +0,0 @@
-#include "audio_http_media_source.h"
-
-#ifdef USE_ESP32
-
-#include "esphome/core/log.h"
-
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-
-#include <algorithm>
-
-namespace esphome::audio_http {
-
-static const char *const TAG = "audio_http_media_source";
-
-// Decoder task / buffer tuning. Kept here as constants so the header stays free of magic numbers.
-static constexpr size_t DEFAULT_TRANSFER_BUFFER_SIZE = 8 * 1024;  // Staging buffer between HTTP reader and decoder
-static constexpr uint32_t HTTP_TIMEOUT_MS = 5000;                 // HTTP connect/read timeout
-static constexpr uint32_t AUDIO_WRITE_TIMEOUT_MS = 50;            // Max blocking time per on_audio_write() call
-static constexpr uint32_t READER_WRITE_TIMEOUT_MS = 50;           // Max blocking time when writing into the ring buffer
-static constexpr uint8_t READER_TASK_PRIORITY = 2;
-static constexpr uint8_t DECODER_TASK_PRIORITY = 2;
-static constexpr size_t READER_TASK_STACK_SIZE = 4096;
-static constexpr size_t DECODER_TASK_STACK_SIZE = 5120;
-static constexpr uint32_t PAUSE_POLL_DELAY_MS = 20;
-static constexpr const char *const HTTP_URI_PREFIX = "http://";
-static constexpr const char *const HTTPS_URI_PREFIX = "https://";
-
-void AudioHTTPMediaSource::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "Audio HTTP Media Source:\n"
-                "  Buffer Size: %zu bytes\n"
-                "  Decoder Task Stack in PSRAM: %s",
-                this->buffer_size_, YESNO(this->decoder_task_stack_in_psram_));
-}
-
-void AudioHTTPMediaSource::setup() {
-  this->disable_loop();
-
-  micro_decoder::DecoderConfig config;
-  config.ring_buffer_size = this->buffer_size_;
-  // Keep the transfer buffer smaller than the ring buffer so the reader can top up the ring
-  // while the decoder is still draining it, instead of oscillating between empty and full.
-  config.transfer_buffer_size = std::min(DEFAULT_TRANSFER_BUFFER_SIZE, this->buffer_size_ / 2);
-  config.http_timeout_ms = HTTP_TIMEOUT_MS;
-  config.audio_write_timeout_ms = AUDIO_WRITE_TIMEOUT_MS;
-  config.reader_write_timeout_ms = READER_WRITE_TIMEOUT_MS;
-  config.reader_priority = READER_TASK_PRIORITY;
-  config.decoder_priority = DECODER_TASK_PRIORITY;
-  config.reader_stack_size = READER_TASK_STACK_SIZE;
-  config.decoder_stack_size = DECODER_TASK_STACK_SIZE;
-  config.decoder_stack_in_psram = this->decoder_task_stack_in_psram_;
-
-  this->decoder_ = std::make_unique<micro_decoder::DecoderSource>(config);
-  if (this->decoder_ == nullptr) {
-    ESP_LOGE(TAG, "Failed to allocate decoder");
-    this->mark_failed();
-    return;
-  }
-  this->decoder_->set_listener(this);  // We inherit from micro_decoder::DecoderListener
-}
-
-void AudioHTTPMediaSource::loop() { this->decoder_->loop(); }
-
-bool AudioHTTPMediaSource::can_handle(const std::string &uri) const {
-  return uri.starts_with(HTTP_URI_PREFIX) || uri.starts_with(HTTPS_URI_PREFIX);
-}
-
-// Called from the orchestrator's main loop, so no synchronization needed with loop()
-bool AudioHTTPMediaSource::play_uri(const std::string &uri) {
-  if (!this->is_ready() || this->is_failed() || this->status_has_error() || !this->has_listener()) {
-    return false;
-  }
-
-  // Check if source is already playing
-  if (this->get_state() != media_source::MediaSourceState::IDLE) {
-    ESP_LOGE(TAG, "Cannot play '%s': source is busy", uri.c_str());
-    return false;
-  }
-
-  // Validate URI starts with "http://" or "https://"
-  if (!uri.starts_with(HTTP_URI_PREFIX) && !uri.starts_with(HTTPS_URI_PREFIX)) {
-    ESP_LOGE(TAG, "Invalid URI: '%s'", uri.c_str());
-    return false;
-  }
-
-  if (this->decoder_->play_url(uri)) {
-    this->pause_.store(false, std::memory_order_relaxed);
-    this->enable_loop();
-    return true;
-  }
-
-  ESP_LOGE(TAG, "Failed to start playback of '%s'", uri.c_str());
-  return false;
-}
-
-// Called from the orchestrator's main loop, so no synchronization needed with loop()
-void AudioHTTPMediaSource::handle_command(media_source::MediaSourceCommand command) {
-  switch (command) {
-    case media_source::MediaSourceCommand::STOP:
-      this->decoder_->stop();
-      break;
-    case media_source::MediaSourceCommand::PAUSE:
-      // Only valid while actively playing; ignoring from IDLE/ERROR/PAUSED prevents the state
-      // machine from getting stuck in PAUSED when no playback is active (which would block the
-      // next play_uri() call via its IDLE-state precondition).
-      if (this->get_state() != media_source::MediaSourceState::PLAYING)
-        break;
-      // PAUSE does not stop the decoder task. Instead, on_audio_write() returns 0 and temporarily
-      // yields, which fills the ring buffer and applies back pressure that effectively pauses both
-      // the decoder and HTTP reader tasks.
-      this->set_state_(media_source::MediaSourceState::PAUSED);
-      this->pause_.store(true, std::memory_order_relaxed);
-      break;
-    case media_source::MediaSourceCommand::PLAY:
-      // Only resume from PAUSED; don't fabricate a PLAYING state from IDLE/ERROR.
-      if (this->get_state() != media_source::MediaSourceState::PAUSED)
-        break;
-      this->set_state_(media_source::MediaSourceState::PLAYING);
-      this->pause_.store(false, std::memory_order_relaxed);
-      break;
-    default:
-      break;
-  }
-}
-
-// Called from the decoder task. Forwards to the orchestrator's listener, which is responsible for
-// being thread-safe with respect to its own audio writer.
-size_t AudioHTTPMediaSource::on_audio_write(const uint8_t *data, size_t length, uint32_t timeout_ms) {
-  if (this->pause_.load(std::memory_order_relaxed)) {
-    vTaskDelay(pdMS_TO_TICKS(PAUSE_POLL_DELAY_MS));
-    return 0;
-  }
-  return this->write_output(data, length, timeout_ms, this->stream_info_);
-}
-
-// Called from the decoder task before the first on_audio_write().
-void AudioHTTPMediaSource::on_stream_info(const micro_decoder::AudioStreamInfo &info) {
-  this->stream_info_ = audio::AudioStreamInfo(info.get_bits_per_sample(), info.get_channels(), info.get_sample_rate());
-}
-
-// microDecoder invokes on_state_change() from inside decoder_->loop(), so this runs on the main
-// loop thread and it's safe to call set_state_() directly.
-void AudioHTTPMediaSource::on_state_change(micro_decoder::DecoderState state) {
-  switch (state) {
-    case micro_decoder::DecoderState::IDLE:
-      this->set_state_(media_source::MediaSourceState::IDLE);
-      this->disable_loop();
-      break;
-    case micro_decoder::DecoderState::PLAYING:
-      this->set_state_(media_source::MediaSourceState::PLAYING);
-      break;
-    case micro_decoder::DecoderState::FAILED:
-      this->set_state_(media_source::MediaSourceState::ERROR);
-      break;
-    default:
-      break;
-  }
-}
-
-}  // namespace esphome::audio_http
-
-#endif  // USE_ESP32
@@ -1,59 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#ifdef USE_ESP32
-
-#include "esphome/components/audio/audio.h"
-#include "esphome/components/media_source/media_source.h"
-#include "esphome/core/component.h"
-
-#include <micro_decoder/decoder_source.h>
-#include <micro_decoder/types.h>
-
-#include <atomic>
-#include <memory>
-#include <string>
-
-namespace esphome::audio_http {
-
-// Inherits from two unrelated listener-style interfaces:
-//   - media_source::MediaSource: this source reports state and writes audio *to* an orchestrator
-//     (the orchestrator calls set_listener() on us with a MediaSourceListener*).
-//   - micro_decoder::DecoderListener: the underlying decoder calls back *into* us with decoded
-//     audio and state changes (we call decoder_->set_listener(this) in setup()).
-// The two set_listener() methods live on different base classes and serve opposite directions.
-class AudioHTTPMediaSource : public Component, public media_source::MediaSource, public micro_decoder::DecoderListener {
- public:
-  void setup() override;
-  void loop() override;
-  void dump_config() override;
-
-  void set_buffer_size(size_t buffer_size) { this->buffer_size_ = buffer_size; }
-  void set_task_stack_in_psram(bool task_stack_in_psram) { this->decoder_task_stack_in_psram_ = task_stack_in_psram; }
-
-  // MediaSource interface implementation
-  bool play_uri(const std::string &uri) override;
-  void handle_command(media_source::MediaSourceCommand command) override;
-  bool can_handle(const std::string &uri) const override;
-
-  // DecoderListener interface implementation
-  size_t on_audio_write(const uint8_t *data, size_t length, uint32_t timeout_ms) override;
-  void on_stream_info(const micro_decoder::AudioStreamInfo &info) override;
-  void on_state_change(micro_decoder::DecoderState state) override;
-
- protected:
-  std::unique_ptr<micro_decoder::DecoderSource> decoder_;
-  audio::AudioStreamInfo stream_info_;
-
-  size_t buffer_size_{50000};
-
-  // Written from the main loop in handle_command(), read from the decoder task in
-  // on_audio_write(). Must be atomic to avoid a data race.
-  std::atomic<bool> pause_{false};
-  bool decoder_task_stack_in_psram_{false};
-};
-
-}  // namespace esphome::audio_http
-
-#endif  // USE_ESP32
@@ -1,59 +0,0 @@
-from typing import Any
-
-import esphome.codegen as cg
-from esphome.components import audio, esp32, media_source, psram
-import esphome.config_validation as cv
-from esphome.const import CONF_BUFFER_SIZE, CONF_ID, CONF_TASK_STACK_IN_PSRAM
-from esphome.types import ConfigType
-
-CODEOWNERS = ["@kahrendt"]
-AUTO_LOAD = ["audio"]
-
-audio_http_ns = cg.esphome_ns.namespace("audio_http")
-AudioHTTPMediaSource = audio_http_ns.class_(
-    "AudioHTTPMediaSource", cg.Component, media_source.MediaSource
-)
-
-
-def _request_micro_decoder(config: ConfigType) -> ConfigType:
-    audio.request_micro_decoder_support()
-    return config
-
-
-def _validate_task_stack_in_psram(value: Any) -> bool:
-    # Only require the psram component when actually enabling PSRAM stacks; validating
-    # the boolean first means `false` doesn't trigger the requires_component check.
-    if value := cv.boolean(value):
-        return cv.requires_component(psram.DOMAIN)(value)
-    return value
-
-
-CONFIG_SCHEMA = cv.All(
-    media_source.media_source_schema(
-        AudioHTTPMediaSource,
-    )
-    .extend(
-        {
-            cv.Optional(CONF_BUFFER_SIZE, default=50000): cv.int_range(
-                min=5000, max=1000000
-            ),
-            cv.Optional(CONF_TASK_STACK_IN_PSRAM): _validate_task_stack_in_psram,
-        }
-    )
-    .extend(cv.COMPONENT_SCHEMA),
-    cv.only_on_esp32,
-    _request_micro_decoder,
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await media_source.register_media_source(var, config)
-
-    if config.get(CONF_TASK_STACK_IN_PSRAM):
-        cg.add(var.set_task_stack_in_psram(True))
-        esp32.add_idf_sdkconfig_option(
-            "CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY", True
-        )
-    cg.add(var.set_buffer_size(config[CONF_BUFFER_SIZE]))
@@ -154,7 +154,7 @@ void BH1750Sensor::loop() {
        break;
      }

-      ESP_LOGV(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), lx);
+      ESP_LOGD(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), lx);
      this->status_clear_warning();
      this->publish_state(lx);
      this->state_ = IDLE;
@@ -332,9 +332,8 @@ def parse_multi_click_timing_str(value):
    try:
        state = cv.boolean(parts[0])
    except cv.Invalid:
-        raise cv.Invalid(
-            f"First word must either be ON or OFF, not {parts[0]}"
-        ) from None
+        # pylint: disable=raise-missing-from
+        raise cv.Invalid(f"First word must either be ON or OFF, not {parts[0]}")

    if parts[1] != "for":
        raise cv.Invalid(f"Second word must be 'for', got {parts[1]}")
@@ -351,9 +350,7 @@ def parse_multi_click_timing_str(value):
        try:
            length = cv.positive_time_period_milliseconds(parts[4])
        except cv.Invalid as err:
-            raise cv.Invalid(
-                f"Multi Click Grammar Parsing length failed: {err}"
-            ) from err
+            raise cv.Invalid(f"Multi Click Grammar Parsing length failed: {err}")
        return {CONF_STATE: state, key: str(length)}

    if parts[3] != "to":
@@ -362,16 +359,12 @@ def parse_multi_click_timing_str(value):
    try:
        min_length = cv.positive_time_period_milliseconds(parts[2])
    except cv.Invalid as err:
-        raise cv.Invalid(
-            f"Multi Click Grammar Parsing minimum length failed: {err}"
-        ) from err
+        raise cv.Invalid(f"Multi Click Grammar Parsing minimum length failed: {err}")

    try:
        max_length = cv.positive_time_period_milliseconds(parts[4])
    except cv.Invalid as err:
-        raise cv.Invalid(
-            f"Multi Click Grammar Parsing maximum length failed: {err}"
-        ) from err
+        raise cv.Invalid(f"Multi Click Grammar Parsing minimum length failed: {err}")

    return {
        CONF_STATE: state,
@@ -65,8 +65,3 @@ async def to_code(config):
@pins.PIN_SCHEMA_REGISTRY.register("bk72xx", PIN_SCHEMA)
 async def pin_to_code(config):
    return await libretiny.gpio.component_pin_to_code(config)
-
-
-# Called by writer.py; delegates to the shared libretiny implementation.
-def copy_files() -> None:
-    libretiny.copy_files()
@@ -16,7 +16,6 @@ from esphome.components.libretiny.const import (
    FAMILY_BK7231N,
    FAMILY_BK7231Q,
    FAMILY_BK7231T,
-    FAMILY_BK7238,
    FAMILY_BK7251,
 )

@@ -25,32 +24,16 @@ BK72XX_BOARDS = {
        "name": "WB2L_M1 Wi-Fi Module",
        "family": FAMILY_BK7231N,
    },
-    "xh-wb3s": {
-        "name": "NiceMCU XH-WB3S",
-        "family": FAMILY_BK7238,
-    },
    "cbu": {
        "name": "CBU Wi-Fi Module",
        "family": FAMILY_BK7231N,
    },
-    "t1-u": {
-        "name": "T1-U Wi-Fi Module",
-        "family": FAMILY_BK7238,
-    },
-    "generic-bk7238-tuya": {
-        "name": "Generic - BK7238 (Tuya T1)",
-        "family": FAMILY_BK7238,
-    },
-    "t1-m": {
-        "name": "T1-M Wi-Fi Module",
-        "family": FAMILY_BK7238,
-    },
    "generic-bk7231t-qfn32-tuya": {
-        "name": "Generic - BK7231T (Tuya)",
+        "name": "Generic - BK7231T (Tuya QFN32)",
        "family": FAMILY_BK7231T,
    },
    "generic-bk7231n-qfn32-tuya": {
-        "name": "Generic - BK7231N (Tuya)",
+        "name": "Generic - BK7231N (Tuya QFN32)",
        "family": FAMILY_BK7231N,
    },
    "cb1s": {
@@ -81,10 +64,6 @@ BK72XX_BOARDS = {
        "name": "Generic - BK7252",
        "family": FAMILY_BK7251,
    },
-    "t1-3s": {
-        "name": "T1-3S Wi-Fi Module",
-        "family": FAMILY_BK7238,
-    },
    "wb2l": {
        "name": "WB2L Wi-Fi Module",
        "family": FAMILY_BK7231T,
@@ -101,10 +80,6 @@ BK72XX_BOARDS = {
        "name": "CB2S Wi-Fi Module",
        "family": FAMILY_BK7231N,
    },
-    "generic-bk7238": {
-        "name": "Generic - BK7238",
-        "family": FAMILY_BK7238,
-    },
    "wa2": {
        "name": "WA2 Wi-Fi Module",
        "family": FAMILY_BK7231Q,
@@ -125,10 +100,6 @@ BK72XX_BOARDS = {
        "name": "WB3L Wi-Fi Module",
        "family": FAMILY_BK7231T,
    },
-    "t1-2s": {
-        "name": "T1-2S Wi-Fi Module",
-        "family": FAMILY_BK7238,
-    },
    "wb2s": {
        "name": "WB2S Wi-Fi Module",
        "family": FAMILY_BK7231T,
@@ -187,83 +158,6 @@ BK72XX_BOARD_PINS = {
        "D12": 22,
        "A0": 23,
    },
-    "xh-wb3s": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
-        "WIRE2_SCL_0": 15,
-        "WIRE2_SCL_1": 24,
-        "WIRE2_SDA_0": 17,
-        "WIRE2_SDA_1": 26,
-        "SERIAL1_RX": 10,
-        "SERIAL1_TX": 11,
-        "SERIAL2_RX": 1,
-        "SERIAL2_TX": 0,
-        "ADC1": 26,
-        "ADC2": 24,
-        "ADC3": 20,
-        "ADC4": 28,
-        "ADC5": 1,
-        "ADC6": 10,
-        "CS": 15,
-        "MISO": 17,
-        "MOSI": 16,
-        "P0": 0,
-        "P1": 1,
-        "P6": 6,
-        "P7": 7,
-        "P8": 8,
-        "P9": 9,
-        "P10": 10,
-        "P11": 11,
-        "P14": 14,
-        "P15": 15,
-        "P16": 16,
-        "P17": 17,
-        "P20": 20,
-        "P21": 21,
-        "P22": 22,
-        "P23": 23,
-        "P24": 24,
-        "P26": 26,
-        "P28": 28,
-        "PWM0": 6,
-        "PWM1": 7,
-        "PWM2": 8,
-        "PWM3": 9,
-        "PWM4": 24,
-        "PWM5": 26,
-        "RX1": 10,
-        "RX2": 1,
-        "SCK": 14,
-        "TX1": 11,
-        "TX2": 0,
-        "D0": 7,
-        "D1": 23,
-        "D2": 14,
-        "D3": 26,
-        "D4": 24,
-        "D5": 6,
-        "D6": 9,
-        "D7": 0,
-        "D8": 1,
-        "D9": 8,
-        "D10": 10,
-        "D11": 11,
-        "D12": 16,
-        "D13": 20,
-        "D14": 21,
-        "D15": 22,
-        "D16": 15,
-        "D17": 17,
-        "A0": 28,
-        "A1": 26,
-        "A2": 24,
-        "A3": 1,
-        "A4": 10,
-        "A5": 20,
-    },
    "cbu": {
        "SPI0_CS": 15,
        "SPI0_MISO": 17,
@@ -336,204 +230,6 @@ BK72XX_BOARD_PINS = {
        "D18": 21,
        "A0": 23,
    },
-    "t1-u": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
-        "WIRE2_SCL_0": 15,
-        "WIRE2_SCL_1": 24,
-        "WIRE2_SDA_0": 17,
-        "WIRE2_SDA_1": 26,
-        "SERIAL1_RX": 10,
-        "SERIAL1_TX": 11,
-        "SERIAL2_RX": 1,
-        "SERIAL2_TX": 0,
-        "ADC1": 26,
-        "ADC2": 24,
-        "ADC3": 20,
-        "ADC4": 28,
-        "ADC5": 1,
-        "ADC6": 10,
-        "CS": 15,
-        "MISO": 17,
-        "MOSI": 16,
-        "P0": 0,
-        "P1": 1,
-        "P6": 6,
-        "P8": 8,
-        "P9": 9,
-        "P10": 10,
-        "P11": 11,
-        "P14": 14,
-        "P15": 15,
-        "P16": 16,
-        "P17": 17,
-        "P20": 20,
-        "P21": 21,
-        "P22": 22,
-        "P23": 23,
-        "P24": 24,
-        "P26": 26,
-        "P28": 28,
-        "PWM0": 6,
-        "PWM2": 8,
-        "PWM3": 9,
-        "PWM4": 24,
-        "PWM5": 26,
-        "RX1": 10,
-        "RX2": 1,
-        "SCK": 14,
-        "TX1": 11,
-        "TX2": 0,
-        "D0": 14,
-        "D1": 16,
-        "D2": 23,
-        "D3": 22,
-        "D4": 20,
-        "D5": 1,
-        "D6": 0,
-        "D7": 24,
-        "D8": 9,
-        "D9": 26,
-        "D10": 6,
-        "D11": 8,
-        "D12": 11,
-        "D13": 10,
-        "D14": 28,
-        "D15": 21,
-        "D16": 17,
-        "D17": 15,
-        "A0": 20,
-        "A1": 1,
-        "A2": 24,
-        "A3": 26,
-        "A4": 10,
-        "A5": 28,
-    },
-    "generic-bk7238-tuya": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
-        "WIRE2_SCL_0": 15,
-        "WIRE2_SCL_1": 24,
-        "WIRE2_SDA_0": 17,
-        "WIRE2_SDA_1": 26,
-        "SERIAL1_RX": 10,
-        "SERIAL1_TX": 11,
-        "SERIAL2_RX": 1,
-        "SERIAL2_TX": 0,
-        "ADC1": 26,
-        "ADC2": 24,
-        "ADC3": 20,
-        "ADC4": 28,
-        "ADC5": 1,
-        "ADC6": 10,
-        "CS": 15,
-        "MISO": 17,
-        "MOSI": 16,
-        "P0": 0,
-        "P1": 1,
-        "P6": 6,
-        "P7": 7,
-        "P8": 8,
-        "P9": 9,
-        "P10": 10,
-        "P11": 11,
-        "P14": 14,
-        "P15": 15,
-        "P16": 16,
-        "P17": 17,
-        "P20": 20,
-        "P21": 21,
-        "P22": 22,
-        "P23": 23,
-        "P24": 24,
-        "P26": 26,
-        "P28": 28,
-        "PWM0": 6,
-        "PWM1": 7,
-        "PWM2": 8,
-        "PWM3": 9,
-        "PWM4": 24,
-        "PWM5": 26,
-        "RX1": 10,
-        "RX2": 1,
-        "SCK": 14,
-        "TX1": 11,
-        "TX2": 0,
-        "D0": 0,
-        "D1": 1,
-        "D2": 6,
-        "D3": 7,
-        "D4": 8,
-        "D5": 9,
-        "D6": 10,
-        "D7": 11,
-        "D8": 14,
-        "D9": 15,
-        "D10": 16,
-        "D11": 17,
-        "D12": 20,
-        "D13": 21,
-        "D14": 22,
-        "D15": 23,
-        "D16": 24,
-        "D17": 26,
-        "D18": 28,
-        "A0": 1,
-        "A1": 10,
-        "A2": 20,
-        "A3": 24,
-        "A4": 26,
-        "A5": 28,
-    },
-    "t1-m": {
-        "WIRE2_SCL": 24,
-        "WIRE2_SDA": 26,
-        "SERIAL1_RX": 10,
-        "SERIAL1_TX": 11,
-        "SERIAL2_RX": 1,
-        "SERIAL2_TX": 0,
-        "ADC1": 26,
-        "ADC2": 24,
-        "ADC5": 1,
-        "ADC6": 10,
-        "P0": 0,
-        "P1": 1,
-        "P6": 6,
-        "P8": 8,
-        "P9": 9,
-        "P10": 10,
-        "P11": 11,
-        "P24": 24,
-        "P26": 26,
-        "PWM0": 6,
-        "PWM2": 8,
-        "PWM3": 9,
-        "PWM4": 24,
-        "PWM5": 26,
-        "RX1": 10,
-        "RX2": 1,
-        "SCL2": 24,
-        "SDA2": 26,
-        "TX1": 11,
-        "TX2": 0,
-        "D0": 26,
-        "D1": 6,
-        "D2": 8,
-        "D3": 1,
-        "D4": 10,
-        "D5": 11,
-        "D6": 9,
-        "D7": 24,
-        "D11": 0,
-        "A0": 26,
-        "A1": 10,
-        "A2": 1,
-        "A3": 24,
-    },
    "generic-bk7231t-qfn32-tuya": {
        "SPI0_CS": 15,
        "SPI0_MISO": 17,
@@ -1085,75 +781,6 @@ BK72XX_BOARD_PINS = {
        "A6": 12,
        "A7": 13,
    },
-    "t1-3s": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
-        "WIRE2_SCL_0": 15,
-        "WIRE2_SCL_1": 24,
-        "WIRE2_SDA_0": 17,
-        "WIRE2_SDA_1": 26,
-        "SERIAL1_RX": 10,
-        "SERIAL1_TX": 11,
-        "SERIAL2_RX": 1,
-        "SERIAL2_TX": 0,
-        "ADC1": 26,
-        "ADC2": 24,
-        "ADC3": 20,
-        "ADC5": 1,
-        "ADC6": 10,
-        "CS": 15,
-        "MISO": 17,
-        "MOSI": 16,
-        "P0": 0,
-        "P1": 1,
-        "P6": 6,
-        "P8": 8,
-        "P9": 9,
-        "P10": 10,
-        "P11": 11,
-        "P14": 14,
-        "P15": 15,
-        "P16": 16,
-        "P17": 17,
-        "P20": 20,
-        "P22": 22,
-        "P23": 23,
-        "P24": 24,
-        "P26": 26,
-        "PWM0": 6,
-        "PWM2": 8,
-        "PWM3": 9,
-        "PWM4": 24,
-        "PWM5": 26,
-        "RX1": 10,
-        "RX2": 1,
-        "SCK": 14,
-        "TX1": 11,
-        "TX2": 0,
-        "D0": 20,
-        "D1": 22,
-        "D2": 6,
-        "D3": 8,
-        "D4": 9,
-        "D5": 23,
-        "D6": 0,
-        "D7": 1,
-        "D8": 24,
-        "D9": 26,
-        "D10": 10,
-        "D11": 11,
-        "D12": 17,
-        "D13": 16,
-        "D14": 15,
-        "D15": 14,
-        "A0": 20,
-        "A1": 1,
-        "A2": 24,
-        "A3": 26,
-        "A4": 10,
-    },
    "wb2l": {
        "WIRE1_SCL": 20,
        "WIRE1_SDA": 21,
@@ -1338,84 +965,6 @@ BK72XX_BOARD_PINS = {
        "D10": 21,
        "A0": 23,
    },
-    "generic-bk7238": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
-        "WIRE2_SCL_0": 15,
-        "WIRE2_SCL_1": 24,
-        "WIRE2_SDA_0": 17,
-        "WIRE2_SDA_1": 26,
-        "SERIAL1_RX": 10,
-        "SERIAL1_TX": 11,
-        "SERIAL2_RX": 1,
-        "SERIAL2_TX": 0,
-        "ADC1": 26,
-        "ADC2": 24,
-        "ADC3": 20,
-        "ADC4": 28,
-        "ADC5": 1,
-        "ADC6": 10,
-        "CS": 15,
-        "MISO": 17,
-        "MOSI": 16,
-        "P0": 0,
-        "P1": 1,
-        "P6": 6,
-        "P7": 7,
-        "P8": 8,
-        "P9": 9,
-        "P10": 10,
-        "P11": 11,
-        "P14": 14,
-        "P15": 15,
-        "P16": 16,
-        "P17": 17,
-        "P20": 20,
-        "P21": 21,
-        "P22": 22,
-        "P23": 23,
-        "P24": 24,
-        "P26": 26,
-        "P28": 28,
-        "PWM0": 6,
-        "PWM1": 7,
-        "PWM2": 8,
-        "PWM3": 9,
-        "PWM4": 24,
-        "PWM5": 26,
-        "RX1": 10,
-        "RX2": 1,
-        "SCK": 14,
-        "TX1": 11,
-        "TX2": 0,
-        "D0": 0,
-        "D1": 1,
-        "D2": 6,
-        "D3": 7,
-        "D4": 8,
-        "D5": 9,
-        "D6": 10,
-        "D7": 11,
-        "D8": 14,
-        "D9": 15,
-        "D10": 16,
-        "D11": 17,
-        "D12": 20,
-        "D13": 21,
-        "D14": 22,
-        "D15": 23,
-        "D16": 24,
-        "D17": 26,
-        "D18": 28,
-        "A0": 1,
-        "A1": 10,
-        "A2": 20,
-        "A3": 24,
-        "A4": 26,
-        "A5": 28,
-    },
    "wa2": {
        "WIRE1_SCL": 20,
        "WIRE1_SDA": 21,
@@ -1686,51 +1235,6 @@ BK72XX_BOARD_PINS = {
        "D15": 1,
        "A0": 23,
    },
-    "t1-2s": {
-        "WIRE2_SCL": 24,
-        "WIRE2_SDA": 26,
-        "SERIAL1_RX": 10,
-        "SERIAL1_TX": 11,
-        "SERIAL2_RX": 1,
-        "SERIAL2_TX": 0,
-        "ADC1": 26,
-        "ADC2": 24,
-        "ADC5": 1,
-        "ADC6": 10,
-        "P0": 0,
-        "P1": 1,
-        "P6": 6,
-        "P8": 8,
-        "P9": 9,
-        "P10": 10,
-        "P11": 11,
-        "P24": 24,
-        "P26": 26,
-        "PWM0": 6,
-        "PWM2": 8,
-        "PWM3": 9,
-        "PWM4": 24,
-        "PWM5": 26,
-        "RX1": 10,
-        "RX2": 1,
-        "SCL2": 24,
-        "SDA2": 26,
-        "TX1": 11,
-        "TX2": 0,
-        "D0": 26,
-        "D1": 6,
-        "D2": 8,
-        "D3": 1,
-        "D4": 10,
-        "D5": 11,
-        "D6": 9,
-        "D7": 24,
-        "D11": 0,
-        "A0": 26,
-        "A1": 10,
-        "A2": 1,
-        "A3": 24,
-    },
    "wb2s": {
        "WIRE1_SCL": 20,
        "WIRE1_SDA": 21,
@@ -20,77 +20,58 @@ constexpr uint8_t bl0906_checksum(const uint8_t address, const DataPacket *data)
 }

 void BL0906::loop() {
-  while (this->available())
-    this->flush();
-
-  if (this->current_stage_ == STAGE_IDLE) {
-    // Woken up between cycles to drain the action queue. Go back to sleep.
-    this->handle_actions_();
-    this->disable_loop();
+  if (this->current_channel_ == UINT8_MAX) {
    return;
  }

-  if (this->current_stage_ == STAGE_TEMP) {
+  while (this->available())
+    this->flush();
+
+  if (this->current_channel_ == 0) {
    // Temperature
    this->read_data_(BL0906_TEMPERATURE, BL0906_TREF, this->temperature_sensor_);
-  } else if (this->current_stage_ == STAGE_CHANNEL_1) {
+  } else if (this->current_channel_ == 1) {
    this->read_data_(BL0906_I_1_RMS, BL0906_IREF, this->current_1_sensor_);
    this->read_data_(BL0906_WATT_1, BL0906_PREF, this->power_1_sensor_);
    this->read_data_(BL0906_CF_1_CNT, BL0906_EREF, this->energy_1_sensor_);
-  } else if (this->current_stage_ == STAGE_CHANNEL_2) {
+  } else if (this->current_channel_ == 2) {
    this->read_data_(BL0906_I_2_RMS, BL0906_IREF, this->current_2_sensor_);
    this->read_data_(BL0906_WATT_2, BL0906_PREF, this->power_2_sensor_);
    this->read_data_(BL0906_CF_2_CNT, BL0906_EREF, this->energy_2_sensor_);
-  } else if (this->current_stage_ == STAGE_CHANNEL_3) {
+  } else if (this->current_channel_ == 3) {
    this->read_data_(BL0906_I_3_RMS, BL0906_IREF, this->current_3_sensor_);
    this->read_data_(BL0906_WATT_3, BL0906_PREF, this->power_3_sensor_);
    this->read_data_(BL0906_CF_3_CNT, BL0906_EREF, this->energy_3_sensor_);
-  } else if (this->current_stage_ == STAGE_CHANNEL_4) {
+  } else if (this->current_channel_ == 4) {
    this->read_data_(BL0906_I_4_RMS, BL0906_IREF, this->current_4_sensor_);
    this->read_data_(BL0906_WATT_4, BL0906_PREF, this->power_4_sensor_);
    this->read_data_(BL0906_CF_4_CNT, BL0906_EREF, this->energy_4_sensor_);
-  } else if (this->current_stage_ == STAGE_CHANNEL_5) {
+  } else if (this->current_channel_ == 5) {
    this->read_data_(BL0906_I_5_RMS, BL0906_IREF, this->current_5_sensor_);
    this->read_data_(BL0906_WATT_5, BL0906_PREF, this->power_5_sensor_);
    this->read_data_(BL0906_CF_5_CNT, BL0906_EREF, this->energy_5_sensor_);
-  } else if (this->current_stage_ == STAGE_CHANNEL_6) {
+  } else if (this->current_channel_ == 6) {
    this->read_data_(BL0906_I_6_RMS, BL0906_IREF, this->current_6_sensor_);
    this->read_data_(BL0906_WATT_6, BL0906_PREF, this->power_6_sensor_);
    this->read_data_(BL0906_CF_6_CNT, BL0906_EREF, this->energy_6_sensor_);
-  } else if (this->current_stage_ == STAGE_FREQ) {
+  } else if (this->current_channel_ == UINT8_MAX - 2) {
    // Frequency
-    this->read_data_(BL0906_FREQUENCY, BL0906_FREF, this->frequency_sensor_);
+    this->read_data_(BL0906_FREQUENCY, BL0906_FREF, frequency_sensor_);
    // Voltage
-    this->read_data_(BL0906_V_RMS, BL0906_UREF, this->voltage_sensor_);
-  } else if (this->current_stage_ == STAGE_POWER) {
+    this->read_data_(BL0906_V_RMS, BL0906_UREF, voltage_sensor_);
+  } else if (this->current_channel_ == UINT8_MAX - 1) {
    // Total power
    this->read_data_(BL0906_WATT_SUM, BL0906_WATT, this->total_power_sensor_);
    // Total Energy
    this->read_data_(BL0906_CF_SUM_CNT, BL0906_CF, this->total_energy_sensor_);
+  } else {
+    this->current_channel_ = UINT8_MAX - 2;  // Go to frequency and voltage
+    return;
  }
-  this->advance_stage_();
+  this->current_channel_++;
  this->handle_actions_();
 }

-void BL0906::advance_stage_() {
-  switch (this->current_stage_) {
-    case STAGE_CHANNEL_6:
-      this->current_stage_ = STAGE_FREQ;
-      break;
-    case STAGE_FREQ:
-      this->current_stage_ = STAGE_POWER;
-      break;
-    case STAGE_POWER:
-      // Cycle complete; sleep until the next update().
-      this->current_stage_ = STAGE_IDLE;
-      this->disable_loop();
-      break;
-    default:
-      this->current_stage_ = static_cast<BL0906Stage>(this->current_stage_ + 1);
-      break;
-  }
-}
-
 void BL0906::setup() {
  while (this->available())
    this->flush();
@@ -104,20 +85,12 @@ void BL0906::setup() {
  this->bias_correction_(BL0906_RMSOS_6, 0.01200, 0);  // Calibration current_6

  this->write_array(USR_WRPROT_ONLYREAD, sizeof(USR_WRPROT_ONLYREAD));
-
-  // Loop stays idle until the first update() or enqueued action.
-  this->disable_loop();
 }

-void BL0906::update() {
-  this->current_stage_ = STAGE_TEMP;
-  this->enable_loop();
-}
+void BL0906::update() { this->current_channel_ = 0; }

 size_t BL0906::enqueue_action_(ActionCallbackFuncPtr function) {
  this->action_queue_.push_back(function);
-  // Ensure the queue is serviced even if the read cycle has already completed.
-  this->enable_loop();
  return this->action_queue_.size();
 }

@@ -12,22 +12,6 @@
 namespace esphome {
 namespace bl0906 {

-// Stage values for the read state machine. After STAGE_CHANNEL_6 the state machine
-// jumps to the two sentinel stages below, then to STAGE_IDLE which marks the cycle
-// as complete and disables the loop.
-enum BL0906Stage : uint8_t {
-  STAGE_TEMP = 0,       // chip temperature
-  STAGE_CHANNEL_1 = 1,  // per-phase current + power + energy
-  STAGE_CHANNEL_2 = 2,
-  STAGE_CHANNEL_3 = 3,
-  STAGE_CHANNEL_4 = 4,
-  STAGE_CHANNEL_5 = 5,
-  STAGE_CHANNEL_6 = 6,
-  STAGE_FREQ = UINT8_MAX - 2,   // frequency + voltage
-  STAGE_POWER = UINT8_MAX - 1,  // total power + total energy
-  STAGE_IDLE = UINT8_MAX,       // cycle complete
-};
-
 struct DataPacket {  // NOLINT(altera-struct-pack-align)
  uint8_t l{0};
  uint8_t m{0};
@@ -95,8 +79,7 @@ class BL0906 : public PollingComponent, public uart::UARTDevice {

  void bias_correction_(uint8_t address, float measurements, float correction);

-  BL0906Stage current_stage_{STAGE_IDLE};
-  void advance_stage_();
+  uint8_t current_channel_{0};
  size_t enqueue_action_(ActionCallbackFuncPtr function);
  void handle_actions_();

@@ -30,6 +30,19 @@ void BluetoothProxy::setup() {
  this->configured_scan_active_ = this->parent_->get_scan_active();

  this->parent_->add_scanner_state_listener(this);
+
+  this->set_interval(100, [this]() {
+    if (api::global_api_server->is_connected() && this->api_connection_ != nullptr) {
+      this->flush_pending_advertisements_();
+      return;
+    }
+    for (uint8_t i = 0; i < this->connection_count_; i++) {
+      auto *connection = this->connections_[i];
+      if (connection->get_address() != 0 && !connection->disconnect_pending()) {
+        connection->disconnect();
+      }
+    }
+  });
 }

 void BluetoothProxy::on_scanner_state(esp32_ble_tracker::ScannerState state) {
@@ -120,25 +133,6 @@ void BluetoothProxy::dump_config() {
                YESNO(this->active_), this->connection_count_);
 }

-void BluetoothProxy::loop() {
-  // Run advertisement flush / connection cleanup every 100ms
-  uint32_t now = App.get_loop_component_start_time();
-  if (now - this->last_advertisement_flush_time_ < 100)
-    return;
-  this->last_advertisement_flush_time_ = now;
-
-  if (api::global_api_server->is_connected() && this->api_connection_ != nullptr) {
-    this->flush_pending_advertisements_();
-    return;
-  }
-  for (uint8_t i = 0; i < this->connection_count_; i++) {
-    auto *connection = this->connections_[i];
-    if (connection->get_address() != 0 && !connection->disconnect_pending()) {
-      connection->disconnect();
-    }
-  }
-}
-
 esp32_ble_tracker::AdvertisementParserType BluetoothProxy::get_advertisement_parser_type() {
  return esp32_ble_tracker::AdvertisementParserType::RAW_ADVERTISEMENTS;
 }
@@ -207,6 +201,7 @@ void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest
        connection->set_connection_type(espbt::ConnectionType::V3_WITHOUT_CACHE);
        this->log_connection_info_(connection, "v3 without cache");
      }
+      uint64_to_bd_addr(msg.address, connection->remote_bda_);
      connection->set_remote_addr_type(static_cast<esp_ble_addr_type_t>(msg.address_type));
      connection->set_state(espbt::ClientState::DISCOVERED);
      this->send_connections_free();
@@ -65,7 +65,6 @@ class BluetoothProxy final : public esp32_ble_tracker::ESPBTDeviceListener,
  bool parse_devices(const esp32_ble::BLEScanResult *scan_results, size_t count) override;
  void dump_config() override;
  void setup() override;
-  void loop() override;
  esp32_ble_tracker::AdvertisementParserType get_advertisement_parser_type() override;

  void register_connection(BluetoothConnection *connection) {
@@ -177,9 +176,6 @@ class BluetoothProxy final : public esp32_ble_tracker::ESPBTDeviceListener,
  // BLE advertisement batching
  api::BluetoothLERawAdvertisementsResponse response_;

-  // Group 3: 4-byte types
-  uint32_t last_advertisement_flush_time_{0};
-
  // Pre-allocated response message - always ready to send
  api::BluetoothConnectionsFreeResponse connections_free_response_;

@@ -63,7 +63,7 @@ void BM8563::read_time() {
           rtc_time.day_of_week, rtc_time.hour, rtc_time.minute, rtc_time.second);

  rtc_time.recalc_timestamp_utc(false);
-  if (!rtc_time.is_valid(/*check_day_of_week=*/true, /*check_day_of_year=*/false)) {
+  if (!rtc_time.is_valid()) {
    ESP_LOGE(TAG, "Invalid RTC time, not syncing to system clock.");
    return;
  }
@@ -6,7 +6,6 @@ from esphome.const import CONF_ID, CONF_SAMPLE_RATE, CONF_TEMPERATURE_OFFSET, Fr
 CODEOWNERS = ["@trvrnrth"]
 DEPENDENCIES = ["i2c"]
 AUTO_LOAD = ["sensor", "text_sensor"]
-CONFLICTS_WITH = ["bme68x_bsec2"]
 MULTI_CONF = True

 CONF_BME680_BSEC_ID = "bme680_bsec_id"
@@ -13,7 +13,6 @@ from esphome.const import (
 )

 CODEOWNERS = ["@neffs", "@kbx81"]
-CONFLICTS_WITH = ["bme680_bsec"]

 DOMAIN = "bme68x_bsec2"

@@ -172,9 +171,7 @@ async def to_code_base(config):
        with open(path, encoding="utf-8") as f:
            bsec2_iaq_config = f.read()
    except Exception as e:
-        raise core.EsphomeError(
-            f"Could not open binary configuration file {path}: {e}"
-        ) from e
+        raise core.EsphomeError(f"Could not open binary configuration file {path}: {e}")

    # Convert retrieved BSEC2 config to an array of ints
    rhs = [int(x) for x in bsec2_iaq_config.split(",")]
@@ -204,27 +204,24 @@ void CSE7761Component::get_data_() {
  value = this->read_(CSE7761_REG_RMSIA, 3);
  this->data_.current_rms[0] = ((value >= 0x800000) || (value < 1600)) ? 0 : value;  // No load threshold of 10mA
  value = this->read_(CSE7761_REG_POWERPA, 4);
-  // PowerPA is two's complement signed 32-bit per datasheet
-  this->data_.active_power[0] = (0 == this->data_.current_rms[0]) ? 0 : static_cast<int32_t>(value);
+  this->data_.active_power[0] = (0 == this->data_.current_rms[0]) ? 0 : ((uint32_t) abs((int) value));

  value = this->read_(CSE7761_REG_RMSIB, 3);
  this->data_.current_rms[1] = ((value >= 0x800000) || (value < 1600)) ? 0 : value;  // No load threshold of 10mA
  value = this->read_(CSE7761_REG_POWERPB, 4);
-  // PowerPB is two's complement signed 32-bit per datasheet
-  this->data_.active_power[1] = (0 == this->data_.current_rms[1]) ? 0 : static_cast<int32_t>(value);
+  this->data_.active_power[1] = (0 == this->data_.current_rms[1]) ? 0 : ((uint32_t) abs((int) value));

  // convert values and publish to sensors

-  float voltage = static_cast<float>(this->data_.voltage_rms) / this->coefficient_by_unit_(RMS_UC);
+  float voltage = (float) this->data_.voltage_rms / this->coefficient_by_unit_(RMS_UC);
  if (this->voltage_sensor_ != nullptr) {
    this->voltage_sensor_->publish_state(voltage);
  }

  for (uint8_t channel = 0; channel < 2; channel++) {
    // Active power = PowerPA * PowerPAC * 1000 / 0x80000000
-    float active_power =
-        static_cast<float>(this->data_.active_power[channel]) / this->coefficient_by_unit_(POWER_PAC);        // W
-    float amps = static_cast<float>(this->data_.current_rms[channel]) / this->coefficient_by_unit_(RMS_IAC);  // A
+    float active_power = (float) this->data_.active_power[channel] / this->coefficient_by_unit_(POWER_PAC);  // W
+    float amps = (float) this->data_.current_rms[channel] / this->coefficient_by_unit_(RMS_IAC);             // A
    ESP_LOGD(TAG, "Channel %d power %f W, current %f A", channel + 1, active_power, amps);
    if (channel == 0) {
      if (this->power_sensor_1_ != nullptr) {
@@ -11,8 +11,10 @@ struct CSE7761DataStruct {
  uint32_t frequency = 0;
  uint32_t voltage_rms = 0;
  uint32_t current_rms[2] = {0};
-  int32_t active_power[2] = {0};
+  uint32_t energy[2] = {0};
+  uint32_t active_power[2] = {0};
  uint16_t coefficient[8] = {0};
+  uint8_t energy_update = 0;
  bool ready = false;
 };

@@ -30,7 +30,7 @@ void DebugComponent::dump_config() {

  char device_info_buffer[DEVICE_INFO_BUFFER_SIZE];
  ESP_LOGD(TAG, "ESPHome version %s", ESPHOME_VERSION);
-  size_t pos = buf_append_str(device_info_buffer, DEVICE_INFO_BUFFER_SIZE, 0, ESPHOME_VERSION);
+  size_t pos = buf_append_printf(device_info_buffer, DEVICE_INFO_BUFFER_SIZE, 0, "%s", ESPHOME_VERSION);

  this->free_heap_ = get_free_heap_();
  ESP_LOGD(TAG, "Free Heap Size: %" PRIu32 " bytes", this->free_heap_);
@@ -224,21 +224,17 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
  const char *model = ESPHOME_VARIANT;

  // Build features string
-  pos = buf_append_str(buf, size, pos, "|Chip: ");
-  pos = buf_append_str(buf, size, pos, model);
-  pos = buf_append_str(buf, size, pos, " Features:");
+  pos = buf_append_printf(buf, size, pos, "|Chip: %s Features:", model);
  bool first_feature = true;
  for (const auto &feature : CHIP_FEATURES) {
    if (info.features & feature.bit) {
-      pos = buf_append_str(buf, size, pos, first_feature ? "" : ", ");
-      pos = buf_append_str(buf, size, pos, feature.name);
+      pos = buf_append_printf(buf, size, pos, "%s%s", first_feature ? "" : ", ", feature.name);
      first_feature = false;
      info.features &= ~feature.bit;
    }
  }
  if (info.features != 0) {
-    pos = buf_append_str(buf, size, pos, first_feature ? "" : ", ");
-    pos = buf_append_printf(buf, size, pos, "Other:0x%" PRIx32, info.features);
+    pos = buf_append_printf(buf, size, pos, "%sOther:0x%" PRIx32, first_feature ? "" : ", ", info.features);
  }
  pos = buf_append_printf(buf, size, pos, " Cores:%u Revision:%u", info.cores, info.revision);

@@ -271,20 +267,17 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
  // Framework detection
 #ifdef USE_ARDUINO
  ESP_LOGD(TAG, "  Framework: Arduino");
-  pos = buf_append_str(buf, size, pos, "|Framework: Arduino");
+  pos = buf_append_printf(buf, size, pos, "|Framework: Arduino");
 #else
  ESP_LOGD(TAG, "  Framework: ESP-IDF");
-  pos = buf_append_str(buf, size, pos, "|Framework: ESP-IDF");
+  pos = buf_append_printf(buf, size, pos, "|Framework: ESP-IDF");
 #endif

-  pos = buf_append_str(buf, size, pos, "|ESP-IDF: ");
-  pos = buf_append_str(buf, size, pos, esp_get_idf_version());
+  pos = buf_append_printf(buf, size, pos, "|ESP-IDF: %s", esp_get_idf_version());
  pos = buf_append_printf(buf, size, pos, "|EFuse MAC: %02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3],
                          mac[4], mac[5]);
-  pos = buf_append_str(buf, size, pos, "|Reset: ");
-  pos = buf_append_str(buf, size, pos, reset_reason);
-  pos = buf_append_str(buf, size, pos, "|Wakeup: ");
-  pos = buf_append_str(buf, size, pos, wakeup_cause);
+  pos = buf_append_printf(buf, size, pos, "|Reset: %s", reset_reason);
+  pos = buf_append_printf(buf, size, pos, "|Wakeup: %s", wakeup_cause);

  return pos;
 }
@@ -38,12 +38,9 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
           lt_get_version(), lt_cpu_get_model_name(), lt_cpu_get_model(), lt_cpu_get_freq_mhz(), mac_id,
           lt_get_board_code(), flash_kib, ram_kib, reset_reason);

-  pos = buf_append_str(buf, size, pos, "|Version: ");
-  pos = buf_append_str(buf, size, pos, LT_BANNER_STR + 10);
-  pos = buf_append_str(buf, size, pos, "|Reset Reason: ");
-  pos = buf_append_str(buf, size, pos, reset_reason);
-  pos = buf_append_str(buf, size, pos, "|Chip Name: ");
-  pos = buf_append_str(buf, size, pos, lt_cpu_get_model_name());
+  pos = buf_append_printf(buf, size, pos, "|Version: %s", LT_BANNER_STR + 10);
+  pos = buf_append_printf(buf, size, pos, "|Reset Reason: %s", reset_reason);
+  pos = buf_append_printf(buf, size, pos, "|Chip Name: %s", lt_cpu_get_model_name());
  pos = buf_append_printf(buf, size, pos, "|Chip ID: 0x%06" PRIX32, mac_id);
  pos = buf_append_printf(buf, size, pos, "|Flash: %" PRIu32 " KiB", flash_kib);
  pos = buf_append_printf(buf, size, pos, "|RAM: %" PRIu32 " KiB", ram_kib);
@@ -162,18 +162,14 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
  const char *supply_status =
      (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_NORMAL) ? "Normal voltage." : "High voltage.";
  ESP_LOGD(TAG, "Main supply status: %s", supply_status);
-  pos = buf_append_str(buf, size, pos, "|Main supply status: ");
-  pos = buf_append_str(buf, size, pos, supply_status);
+  pos = buf_append_printf(buf, size, pos, "|Main supply status: %s", supply_status);

  // Regulator stage 0
  if (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_HIGH) {
    const char *reg0_type = nrf_power_dcdcen_vddh_get(NRF_POWER) ? "DC/DC" : "LDO";
    const char *reg0_voltage = regout0_to_str((NRF_UICR->REGOUT0 & UICR_REGOUT0_VOUT_Msk) >> UICR_REGOUT0_VOUT_Pos);
    ESP_LOGD(TAG, "Regulator stage 0: %s, %s", reg0_type, reg0_voltage);
-    pos = buf_append_str(buf, size, pos, "|Regulator stage 0: ");
-    pos = buf_append_str(buf, size, pos, reg0_type);
-    pos = buf_append_str(buf, size, pos, ", ");
-    pos = buf_append_str(buf, size, pos, reg0_voltage);
+    pos = buf_append_printf(buf, size, pos, "|Regulator stage 0: %s, %s", reg0_type, reg0_voltage);
 #ifdef USE_NRF52_REG0_VOUT
    if ((NRF_UICR->REGOUT0 & UICR_REGOUT0_VOUT_Msk) >> UICR_REGOUT0_VOUT_Pos != USE_NRF52_REG0_VOUT) {
      ESP_LOGE(TAG, "Regulator stage 0: expected %s", regout0_to_str(USE_NRF52_REG0_VOUT));
@@ -181,14 +177,13 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
 #endif
  } else {
    ESP_LOGD(TAG, "Regulator stage 0: disabled");
-    pos = buf_append_str(buf, size, pos, "|Regulator stage 0: disabled");
+    pos = buf_append_printf(buf, size, pos, "|Regulator stage 0: disabled");
  }

  // Regulator stage 1
  const char *reg1_type = nrf_power_dcdcen_get(NRF_POWER) ? "DC/DC" : "LDO";
  ESP_LOGD(TAG, "Regulator stage 1: %s", reg1_type);
-  pos = buf_append_str(buf, size, pos, "|Regulator stage 1: ");
-  pos = buf_append_str(buf, size, pos, reg1_type);
+  pos = buf_append_printf(buf, size, pos, "|Regulator stage 1: %s", reg1_type);

  // USB power state
  const char *usb_state;
@@ -202,8 +197,7 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
    usb_state = "disconnected";
  }
  ESP_LOGD(TAG, "USB power state: %s", usb_state);
-  pos = buf_append_str(buf, size, pos, "|USB power state: ");
-  pos = buf_append_str(buf, size, pos, usb_state);
+  pos = buf_append_printf(buf, size, pos, "|USB power state: %s", usb_state);

  // Power-fail comparator
  bool enabled;
@@ -308,18 +302,14 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
          break;
      }
      ESP_LOGD(TAG, "Power-fail comparator: %s, VDDH: %s", pof_voltage, vddh_voltage);
-      pos = buf_append_str(buf, size, pos, "|Power-fail comparator: ");
-      pos = buf_append_str(buf, size, pos, pof_voltage);
-      pos = buf_append_str(buf, size, pos, ", VDDH: ");
-      pos = buf_append_str(buf, size, pos, vddh_voltage);
+      pos = buf_append_printf(buf, size, pos, "|Power-fail comparator: %s, VDDH: %s", pof_voltage, vddh_voltage);
    } else {
      ESP_LOGD(TAG, "Power-fail comparator: %s", pof_voltage);
-      pos = buf_append_str(buf, size, pos, "|Power-fail comparator: ");
-      pos = buf_append_str(buf, size, pos, pof_voltage);
+      pos = buf_append_printf(buf, size, pos, "|Power-fail comparator: %s", pof_voltage);
    }
  } else {
    ESP_LOGD(TAG, "Power-fail comparator: disabled");
-    pos = buf_append_str(buf, size, pos, "|Power-fail comparator: disabled");
+    pos = buf_append_printf(buf, size, pos, "|Power-fail comparator: disabled");
  }

  auto package = [](uint32_t value) {
@@ -14,7 +14,6 @@ from esphome.components.esp32 import (
    VARIANT_ESP32S3,
    get_esp32_variant,
 )
-from esphome.components.zephyr import zephyr_add_prj_conf
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
@@ -34,7 +33,6 @@ from esphome.const import (
    PLATFORM_BK72XX,
    PLATFORM_ESP32,
    PLATFORM_ESP8266,
-    PLATFORM_NRF52,
    PlatformFramework,
 )
 from esphome.core import CORE
@@ -306,7 +304,7 @@ CONFIG_SCHEMA = cv.All(
            ),
        }
    ).extend(cv.COMPONENT_SCHEMA),
-    cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266, PLATFORM_BK72XX, PLATFORM_NRF52]),
+    cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266, PLATFORM_BK72XX]),
    validate_config,
 )

@@ -371,8 +369,6 @@ async def to_code(config):

    if CONF_TOUCH_WAKEUP in config:
        cg.add(var.set_touch_wakeup(config[CONF_TOUCH_WAKEUP]))
-    if CORE.using_zephyr and "zigbee" not in CORE.loaded_integrations:
-        zephyr_add_prj_conf("POWEROFF", True)

    cg.add_define("USE_DEEP_SLEEP")

@@ -417,7 +413,7 @@ async def deep_sleep_enter_to_code(config, action_id, template_arg, args):
    paren = await cg.get_variable(config[CONF_ID])
    var = cg.new_Pvariable(action_id, template_arg, paren)
    if CONF_SLEEP_DURATION in config:
-        template_ = await cg.templatable(config[CONF_SLEEP_DURATION], args, cg.uint32)
+        template_ = await cg.templatable(config[CONF_SLEEP_DURATION], args, cg.int32)
        cg.add(var.set_sleep_duration(template_))

    if CONF_UNTIL in config:
@@ -59,8 +59,6 @@ void DeepSleepComponent::deep_sleep_() {
  lt_deep_sleep_enter();
 }

-bool DeepSleepComponent::should_teardown_() { return true; }
-
 }  // namespace esphome::deep_sleep

 #endif  // USE_BK72XX
@@ -9,22 +9,11 @@ static const char *const TAG = "deep_sleep";
 // 5 seconds for deep sleep to ensure clean disconnect from Home Assistant
 static const uint32_t TEARDOWN_TIMEOUT_DEEP_SLEEP_MS = 5000;

-bool global_has_deep_sleep = false;                   // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-std::atomic<DeepSleepComponent *> global_deep_sleep;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+bool global_has_deep_sleep = false;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

 void DeepSleepComponent::setup() {
-#ifdef USE_ZEPHYR
-  k_sem_init(&this->wakeup_sem_, 0, 1);
-#endif
  global_has_deep_sleep = true;
-  this->schedule_sleep_();
-  // It can be used from another thread for waking up the device.
-  // It should be called as last item in setup.
-  global_deep_sleep.store(this);
-}

-void DeepSleepComponent::schedule_sleep_() {
-  this->next_enter_deep_sleep_ = false;
  const optional<uint32_t> run_duration = get_run_duration_();
  if (run_duration.has_value()) {
    ESP_LOGI(TAG, "Scheduling in %" PRIu32 " ms", *run_duration);
@@ -69,17 +58,13 @@ void DeepSleepComponent::begin_sleep(bool manual) {
  if (this->sleep_duration_.has_value()) {
    ESP_LOGI(TAG, "Sleeping for %" PRId64 "us", *this->sleep_duration_);
  }
-
-  if (this->should_teardown_()) {
-    App.run_safe_shutdown_hooks();
-    // It's critical to teardown components cleanly for deep sleep to ensure
-    // Home Assistant sees a clean disconnect instead of marking the device unavailable
-    App.teardown_components(TEARDOWN_TIMEOUT_DEEP_SLEEP_MS);
-    App.run_powerdown_hooks();
-  }
+  App.run_safe_shutdown_hooks();
+  // It's critical to teardown components cleanly for deep sleep to ensure
+  // Home Assistant sees a clean disconnect instead of marking the device unavailable
+  App.teardown_components(TEARDOWN_TIMEOUT_DEEP_SLEEP_MS);
+  App.run_powerdown_hooks();

  this->deep_sleep_();
-  this->schedule_sleep_();
 }

 float DeepSleepComponent::get_setup_priority() const { return setup_priority::LATE; }
@@ -4,7 +4,6 @@
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
-#include <atomic>

 #ifdef USE_ESP32
 #include <esp_sleep.h>
@@ -15,10 +14,6 @@
 #include "esphome/core/time.h"
 #endif

-#ifdef USE_ZEPHYR
-#include <zephyr/kernel.h>
-#endif
-
 #include <cinttypes>

 namespace esphome {
@@ -125,9 +120,6 @@ class DeepSleepComponent : public Component {

  void prevent_deep_sleep();
  void allow_deep_sleep();
-#ifdef USE_ZEPHYR
-  void wakeup();
-#endif

 protected:
  // Returns nullopt if no run duration is set. Otherwise, returns the run
@@ -137,8 +129,6 @@ class DeepSleepComponent : public Component {
  void dump_config_platform_();
  bool prepare_to_sleep_();
  void deep_sleep_();
-  void schedule_sleep_();
-  bool should_teardown_();

 #ifdef USE_BK72XX
  bool pin_prevents_sleep_(WakeUpPinItem &pinItem) const;
@@ -167,9 +157,6 @@ class DeepSleepComponent : public Component {
  optional<uint32_t> run_duration_;
  bool next_enter_deep_sleep_{false};
  bool prevent_{false};
-#ifdef USE_ZEPHYR
-  k_sem wakeup_sem_;
-#endif
 };

 extern bool global_has_deep_sleep;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -256,8 +243,5 @@ template<typename... Ts> class AllowDeepSleepAction : public Action<Ts...>, publ
  void play(const Ts &...x) override { this->parent_->allow_deep_sleep(); }
 };

-extern std::atomic<DeepSleepComponent *>
-    global_deep_sleep;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
 }  // namespace deep_sleep
 }  // namespace esphome
@@ -165,8 +165,6 @@ void DeepSleepComponent::deep_sleep_() {
  esp_deep_sleep_start();
 }

-bool DeepSleepComponent::should_teardown_() { return true; }
-
 }  // namespace deep_sleep
 }  // namespace esphome
 #endif  // USE_ESP32
@@ -18,8 +18,6 @@ void DeepSleepComponent::deep_sleep_() {
  ESP.deepSleep(this->sleep_duration_.value_or(0));  // NOLINT(readability-static-accessed-through-instance)
 }

-bool DeepSleepComponent::should_teardown_() { return true; }
-
 }  // namespace deep_sleep
 }  // namespace esphome
 #endif
@@ -1,60 +0,0 @@
-#include "deep_sleep_component.h"
-#ifdef USE_ZEPHYR
-#include "esphome/core/log.h"
-#include <zephyr/sys/poweroff.h>
-#include <zephyr/kernel.h>
-#include <zephyr/stats/stats.h>
-#include <zephyr/pm/pm.h>
-
-namespace esphome::deep_sleep {
-
-static const char *const TAG = "deep_sleep";
-
-void DeepSleepComponent::wakeup() { k_sem_give(&this->wakeup_sem_); }
-
-optional<uint32_t> DeepSleepComponent::get_run_duration_() const { return this->run_duration_; }
-
-void DeepSleepComponent::dump_config_platform_() {}
-
-bool DeepSleepComponent::prepare_to_sleep_() { return true; }
-
-void DeepSleepComponent::deep_sleep_() {
-  k_timeout_t sleep_duration = K_FOREVER;
-  if (this->sleep_duration_.has_value()) {
-    sleep_duration = K_USEC(*this->sleep_duration_);
-  } else {
-#ifndef USE_ZIGBEE
-    // the device can be woken up through one of the following signals:
-    // - The DETECT signal, optionally generated by the GPIO peripheral.
-    // - The ANADETECT signal, optionally generated by the LPCOMP module.
-    // - The SENSE signal, optionally generated by the NFC module to wake-on-field.
-    // - Detecting a valid USB voltage on the VBUS pin (VBUS,DETECT).
-    // - A reset.
-    //
-    // The system is reset when it wakes up from System OFF mode.
-    sys_poweroff();
-#endif
-  }
-  // It might wake up immediately if k_sem_give was called again after wake up
-  int ret = k_sem_take(&this->wakeup_sem_, sleep_duration);
-  if (ret == 0) {
-    ESP_LOGD(TAG, "Woken up by another thread");
-  } else {
-    ESP_LOGD(TAG, "Timeout expired (normal sleep)");
-  }
-}
-
-bool DeepSleepComponent::should_teardown_() {
-  if (this->sleep_duration_.has_value()) {
-    return false;
-  }
-#ifdef USE_ZIGBEE
-  return false;
-#else
-  return true;
-#endif
-}
-
-}  // namespace esphome::deep_sleep
-
-#endif
@@ -44,7 +44,7 @@ void DS1307Component::read_time() {
      .year = uint16_t(ds1307_.reg.year + 10u * ds1307_.reg.year_10 + 2000),
  };
  rtc_time.recalc_timestamp_utc(false);
-  if (!rtc_time.is_valid(/*check_day_of_week=*/true, /*check_day_of_year=*/false)) {
+  if (!rtc_time.is_valid()) {
    ESP_LOGE(TAG, "Invalid RTC time, not syncing to system clock.");
    return;
  }
@@ -1,19 +1,8 @@
-import logging
-
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import uart
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ID,
-    CONF_RECEIVE_TIMEOUT,
-    CONF_RX_BUFFER_SIZE,
-    CONF_UART_ID,
-)
-import esphome.final_validate as fv
-from esphome.types import ConfigType
-
-_LOGGER = logging.getLogger(__name__)
+from esphome.const import CONF_ID, CONF_RECEIVE_TIMEOUT, CONF_UART_ID

 CODEOWNERS = ["@glmnet", "@PolarGoose"]

@@ -32,7 +21,8 @@ CONF_MAX_TELEGRAM_LENGTH = "max_telegram_length"
 CONF_REQUEST_INTERVAL = "request_interval"
 CONF_REQUEST_PIN = "request_pin"

-dsmr_ns = cg.esphome_ns.namespace("dsmr")
+# Hack to prevent compile error due to ambiguity with lib namespace
+dsmr_ns = cg.esphome_ns.namespace("esphome::dsmr")
 Dsmr = dsmr_ns.class_("Dsmr", cg.Component, uart.UARTDevice)


@@ -64,47 +54,24 @@ CONFIG_SCHEMA = cv.All(

 async def to_code(config):
    uart_component = await cg.get_variable(config[CONF_UART_ID])
+    var = cg.new_Pvariable(config[CONF_ID], uart_component, config[CONF_CRC_CHECK])
+    cg.add(var.set_max_telegram_length(config[CONF_MAX_TELEGRAM_LENGTH]))
+    if CONF_DECRYPTION_KEY in config:
+        cg.add(var.set_decryption_key(config[CONF_DECRYPTION_KEY]))
+    await cg.register_component(var, config)
+
    if CONF_REQUEST_PIN in config:
        request_pin = await cg.gpio_pin_expression(config[CONF_REQUEST_PIN])
-    else:
-        request_pin = cg.nullptr
-    decryption_key = config.get(CONF_DECRYPTION_KEY)
-    if decryption_key is None:
-        decryption_key = cg.nullptr
-    var = cg.new_Pvariable(
-        config[CONF_ID],
-        uart_component,
-        config[CONF_CRC_CHECK],
-        config[CONF_MAX_TELEGRAM_LENGTH],
-        config[CONF_REQUEST_INTERVAL].total_milliseconds,
-        config[CONF_RECEIVE_TIMEOUT].total_milliseconds,
-        request_pin,
-        decryption_key,
-    )
-    await cg.register_component(var, config)
+        cg.add(var.set_request_pin(request_pin))
+    cg.add(var.set_request_interval(config[CONF_REQUEST_INTERVAL].total_milliseconds))
+    cg.add(var.set_receive_timeout(config[CONF_RECEIVE_TIMEOUT].total_milliseconds))

    cg.add_build_flag("-DDSMR_GAS_MBUS_ID=" + str(config[CONF_GAS_MBUS_ID]))
    cg.add_build_flag("-DDSMR_WATER_MBUS_ID=" + str(config[CONF_WATER_MBUS_ID]))
    cg.add_build_flag("-DDSMR_THERMAL_MBUS_ID=" + str(config[CONF_THERMAL_MBUS_ID]))

-    cg.add_library("esphome/dsmr_parser", "1.4.0")
+    # DSMR Parser
+    cg.add_library("esphome/dsmr_parser", "1.1.0")

-
-def final_validate(config: ConfigType) -> ConfigType:
-    full_config = fv.full_config.get()
-
-    for uart_conf in full_config["uart"]:
-        if uart_conf[CONF_ID] == config[CONF_UART_ID]:
-            rx_buffer_size = uart_conf[CONF_RX_BUFFER_SIZE]
-            if rx_buffer_size < 1500:
-                _LOGGER.warning(
-                    "UART '%s' rx_buffer_size should be bigger than 1500 bytes to avoid packet losses (currently %d bytes).",
-                    config[CONF_UART_ID],
-                    rx_buffer_size,
-                )
-            break
-
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = final_validate
+    # Crypto
+    cg.add_library("polargoose/Crypto-no-arduino", "0.4.0")
@@ -1,183 +1,315 @@
-// Ignore Zephyr. It doesn't have any encryption library.
-#if defined(USE_ESP32) || defined(USE_ARDUINO) || defined(USE_HOST)
-
 #include "dsmr.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include <dsmr_parser/util.h>
+
+#include <AES.h>
+#include <Crypto.h>
+#include <GCM.h>

 namespace esphome::dsmr {

-static constexpr auto &TAG = "dsmr";
-
-static void log_callback(dsmr_parser::LogLevel level, const char *fmt, va_list args) {
-  std::array<char, 256> buf;
-  vsnprintf(buf.data(), buf.size(), fmt, args);
-  switch (level) {
-    case dsmr_parser::LogLevel::ERROR:
-      ESP_LOGE(TAG, "%s", buf.data());
-      break;
-    case dsmr_parser::LogLevel::WARNING:
-      ESP_LOGW(TAG, "%s", buf.data());
-      break;
-    case dsmr_parser::LogLevel::INFO:
-      ESP_LOGI(TAG, "%s", buf.data());
-      break;
-    case dsmr_parser::LogLevel::VERBOSE:
-      ESP_LOGV(TAG, "%s", buf.data());
-      break;
-    case dsmr_parser::LogLevel::VERY_VERBOSE:
-      ESP_LOGVV(TAG, "%s", buf.data());
-      break;
-    case dsmr_parser::LogLevel::DEBUG:
-      ESP_LOGD(TAG, "%s", buf.data());
-      break;
-  }
-}
+static const char *const TAG = "dsmr";

 void Dsmr::setup() {
-  dsmr_parser::Logger::set_log_function(log_callback);
+  this->telegram_ = new char[this->max_telegram_len_];  // NOLINT
  if (this->request_pin_ != nullptr) {
    this->request_pin_->setup();
  }
 }

 void Dsmr::loop() {
-  if (!this->ready_to_request_data_()) {
-    return;
-  }
-
-  if (this->encryption_enabled_) {
-    this->receive_encrypted_telegram_();
-  } else {
-    this->receive_telegram_();
+  if (this->ready_to_request_data_()) {
+    if (this->decryption_key_.empty()) {
+      this->receive_telegram_();
+    } else {
+      this->receive_encrypted_telegram_();
+    }
  }
 }

 bool Dsmr::ready_to_request_data_() {
-  if (!this->requesting_data_ && this->request_interval_reached_()) {
-    this->start_requesting_data_();
+  // When using a request pin, then wait for the next request interval.
+  if (this->request_pin_ != nullptr) {
+    if (!this->requesting_data_ && this->request_interval_reached_()) {
+      this->start_requesting_data_();
+    }
+  }
+  // Otherwise, sink serial data until next request interval.
+  else {
+    if (this->request_interval_reached_()) {
+      this->start_requesting_data_();
+    }
+    if (!this->requesting_data_) {
+      this->drain_rx_buffer_();
+    }
  }
  return this->requesting_data_;
 }

-bool Dsmr::request_interval_reached_() const {
+bool Dsmr::request_interval_reached_() {
  if (this->last_request_time_ == 0) {
    return true;
  }
  return millis() - this->last_request_time_ > this->request_interval_;
 }

+bool Dsmr::receive_timeout_reached_() { return millis() - this->last_read_time_ > this->receive_timeout_; }
+
+bool Dsmr::available_within_timeout_() {
+  // Data are available for reading on the UART bus?
+  // Then we can start reading right away.
+  if (this->available()) {
+    this->last_read_time_ = millis();
+    return true;
+  }
+  // When we're not in the process of reading a telegram, then there is
+  // no need to actively wait for new data to come in.
+  if (!header_found_) {
+    return false;
+  }
+  // A telegram is being read. The smart meter might not deliver a telegram
+  // in one go, but instead send it in chunks with small pauses in between.
+  // When the UART RX buffer cannot hold a full telegram, then make sure
+  // that the UART read buffer does not overflow while other components
+  // perform their work in their loop. Do this by not returning control to
+  // the main loop, until the read timeout is reached.
+  if (this->parent_->get_rx_buffer_size() < this->max_telegram_len_) {
+    while (!this->receive_timeout_reached_()) {
+      delay(5);
+      if (this->available()) {
+        this->last_read_time_ = millis();
+        return true;
+      }
+    }
+  }
+  // No new data has come in during the read timeout? Then stop reading the
+  // telegram and start waiting for the next one to arrive.
+  if (this->receive_timeout_reached_()) {
+    ESP_LOGW(TAG, "Timeout while reading data for telegram");
+    this->reset_telegram_();
+  }
+
+  return false;
+}
+
 void Dsmr::start_requesting_data_() {
-  if (this->requesting_data_) {
-    return;
+  if (!this->requesting_data_) {
+    if (this->request_pin_ != nullptr) {
+      ESP_LOGV(TAG, "Start requesting data from P1 port");
+      this->request_pin_->digital_write(true);
+    } else {
+      ESP_LOGV(TAG, "Start reading data from P1 port");
+    }
+    this->requesting_data_ = true;
+    this->last_request_time_ = millis();
  }
-
-  ESP_LOGV(TAG, "Start reading data from P1 port");
-  this->flush_rx_buffer_();
-
-  if (this->request_pin_ != nullptr) {
-    ESP_LOGV(TAG, "Set request pin to 1");
-    this->request_pin_->digital_write(true);
-  }
-
-  this->requesting_data_ = true;
-  this->last_request_time_ = millis();
 }

 void Dsmr::stop_requesting_data_() {
-  if (!this->requesting_data_) {
-    return;
+  if (this->requesting_data_) {
+    if (this->request_pin_ != nullptr) {
+      ESP_LOGV(TAG, "Stop requesting data from P1 port");
+      this->request_pin_->digital_write(false);
+    } else {
+      ESP_LOGV(TAG, "Stop reading data from P1 port");
+    }
+    this->drain_rx_buffer_();
+    this->requesting_data_ = false;
  }
-
-  ESP_LOGV(TAG, "Stop reading data from P1 port");
-  if (this->request_pin_ != nullptr) {
-    ESP_LOGV(TAG, "Set request pin to 0");
-    this->request_pin_->digital_write(false);
-  }
-  this->requesting_data_ = false;
 }

-void Dsmr::flush_rx_buffer_() {
-  ESP_LOGV(TAG, "Flush UART RX buffer");
-  while (!this->uart_read_chunk_().empty()) {
+void Dsmr::drain_rx_buffer_() {
+  uint8_t buf[64];
+  size_t avail;
+  while ((avail = this->available()) > 0) {
+    if (!this->read_array(buf, std::min(avail, sizeof(buf)))) {
+      break;
+    }
  }
 }

+void Dsmr::reset_telegram_() {
+  this->header_found_ = false;
+  this->footer_found_ = false;
+  this->bytes_read_ = 0;
+  this->crypt_bytes_read_ = 0;
+  this->crypt_telegram_len_ = 0;
+}
+
 void Dsmr::receive_telegram_() {
-  for (auto data = this->uart_read_chunk_(); !data.empty(); data = this->uart_read_chunk_()) {
-    for (uint8_t byte : data) {
-      const auto telegram = this->packet_accumulator_.process_byte(byte);
-      if (!telegram) {  // No full packet received yet
-        continue;
-      }
-      if (this->parse_telegram_(telegram.value())) {
+  while (this->available_within_timeout_()) {
+    // Read all available bytes in batches to reduce UART call overhead.
+    uint8_t buf[64];
+    size_t avail = this->available();
+    while (avail > 0) {
+      size_t to_read = std::min(avail, sizeof(buf));
+      if (!this->read_array(buf, to_read))
        return;
+      avail -= to_read;
+
+      for (size_t i = 0; i < to_read; i++) {
+        const char c = static_cast<char>(buf[i]);
+
+        // Find a new telegram header, i.e. forward slash.
+        if (c == '/') {
+          ESP_LOGV(TAG, "Header of telegram found");
+          this->reset_telegram_();
+          this->header_found_ = true;
+        }
+        if (!this->header_found_)
+          continue;
+
+        // Check for buffer overflow.
+        if (this->bytes_read_ >= this->max_telegram_len_) {
+          this->reset_telegram_();
+          ESP_LOGE(TAG, "Error: telegram larger than buffer (%d bytes)", this->max_telegram_len_);
+          return;
+        }
+
+        // Some v2.2 or v3 meters will send a new value which starts with '('
+        // in a new line, while the value belongs to the previous ObisId. For
+        // proper parsing, remove these new line characters.
+        if (c == '(') {
+          while (true) {
+            auto previous_char = this->telegram_[this->bytes_read_ - 1];
+            if (previous_char == '\n' || previous_char == '\r') {
+              this->bytes_read_--;
+            } else {
+              break;
+            }
+          }
+        }
+
+        // Store the byte in the buffer.
+        this->telegram_[this->bytes_read_] = c;
+        this->bytes_read_++;
+
+        // Check for a footer, i.e. exclamation mark, followed by a hex checksum.
+        if (c == '!') {
+          ESP_LOGV(TAG, "Footer of telegram found");
+          this->footer_found_ = true;
+          continue;
+        }
+        // Check for the end of the hex checksum, i.e. a newline.
+        if (this->footer_found_ && c == '\n') {
+          // Parse the telegram and publish sensor values.
+          this->parse_telegram();
+          this->reset_telegram_();
+          return;
+        }
      }
    }
  }
 }

 void Dsmr::receive_encrypted_telegram_() {
-  for (auto data = this->uart_read_chunk_(); !data.empty(); data = this->uart_read_chunk_()) {
-    for (uint8_t byte : data) {
-      if (this->buffer_pos_ >= this->buffer_.size()) {  // Reset buffer if overflow
-        ESP_LOGW(TAG, "Encrypted buffer overflow, resetting");
-        this->buffer_pos_ = 0;
+  while (this->available_within_timeout_()) {
+    // Read all available bytes in batches to reduce UART call overhead.
+    uint8_t buf[64];
+    size_t avail = this->available();
+    while (avail > 0) {
+      size_t to_read = std::min(avail, sizeof(buf));
+      if (!this->read_array(buf, to_read))
+        return;
+      avail -= to_read;
+
+      for (size_t i = 0; i < to_read; i++) {
+        const char c = static_cast<char>(buf[i]);
+
+        // Find a new telegram start byte.
+        if (!this->header_found_) {
+          if ((uint8_t) c != 0xDB) {
+            continue;
+          }
+          ESP_LOGV(TAG, "Start byte 0xDB of encrypted telegram found");
+          this->reset_telegram_();
+          this->header_found_ = true;
+        }
+
+        // Check for buffer overflow.
+        if (this->crypt_bytes_read_ >= this->max_telegram_len_) {
+          this->reset_telegram_();
+          ESP_LOGE(TAG, "Error: encrypted telegram larger than buffer (%d bytes)", this->max_telegram_len_);
+          return;
+        }
+
+        // Store the byte in the buffer.
+        this->crypt_telegram_[this->crypt_bytes_read_] = c;
+        this->crypt_bytes_read_++;
+
+        // Read the length of the incoming encrypted telegram.
+        if (this->crypt_telegram_len_ == 0 && this->crypt_bytes_read_ > 20) {
+          // Complete header + data bytes
+          this->crypt_telegram_len_ = 13 + (this->crypt_telegram_[11] << 8 | this->crypt_telegram_[12]);
+          ESP_LOGV(TAG, "Encrypted telegram length: %d bytes", this->crypt_telegram_len_);
+        }
+
+        // Check for the end of the encrypted telegram.
+        if (this->crypt_telegram_len_ == 0 || this->crypt_bytes_read_ != this->crypt_telegram_len_) {
+          continue;
+        }
+        ESP_LOGV(TAG, "End of encrypted telegram found");
+
+        // Decrypt the encrypted telegram.
+        GCM<AES128> *gcmaes128{new GCM<AES128>()};
+        gcmaes128->setKey(this->decryption_key_.data(), gcmaes128->keySize());
+        // the iv is 8 bytes of the system title + 4 bytes frame counter
+        // system title is at byte 2 and frame counter at byte 15
+        for (int i = 10; i < 14; i++)
+          this->crypt_telegram_[i] = this->crypt_telegram_[i + 4];
+        constexpr uint16_t iv_size{12};
+        gcmaes128->setIV(&this->crypt_telegram_[2], iv_size);
+        gcmaes128->decrypt(reinterpret_cast<uint8_t *>(this->telegram_),
+                           // the ciphertext start at byte 18
+                           &this->crypt_telegram_[18],
+                           // cipher size
+                           this->crypt_bytes_read_ - 17);
+        delete gcmaes128;  // NOLINT(cppcoreguidelines-owning-memory)
+
+        this->bytes_read_ = strnlen(this->telegram_, this->max_telegram_len_);
+        ESP_LOGV(TAG, "Decrypted telegram size: %d bytes", this->bytes_read_);
+        ESP_LOGVV(TAG, "Decrypted telegram: %s", this->telegram_);
+
+        // Parse the decrypted telegram and publish sensor values.
+        this->parse_telegram();
+        this->reset_telegram_();
+        return;
      }
-
-      this->buffer_[this->buffer_pos_] = byte;
-      this->buffer_pos_++;
    }
-    this->last_read_time_ = millis();
-  }
-
-  // Detect inter-frame delay. If no byte is received for more than receive_timeout, then the packet is complete.
-  if (millis() - this->last_read_time_ > this->receive_timeout_ && this->buffer_pos_ > 0) {
-    ESP_LOGV(TAG, "Encrypted telegram received (%zu bytes)", this->buffer_pos_);
-
-    const auto telegram = this->dlms_decryptor_.decrypt_inplace({this->buffer_.data(), this->buffer_pos_});
-
-    // Reset buffer position for the next packet
-    this->buffer_pos_ = 0;
-    this->last_read_time_ = 0;
-
-    if (!telegram) {  // decryption failed
-      return;
-    }
-
-    // Parse and publish the telegram
-    this->parse_telegram_(telegram.value());
  }
 }

-bool Dsmr::parse_telegram_(const dsmr_parser::DsmrUnencryptedTelegram &telegram) {
+bool Dsmr::parse_telegram() {
+  MyData data;
+  ESP_LOGV(TAG, "Trying to parse telegram");
  this->stop_requesting_data_();

-  ESP_LOGV(TAG, "Trying to parse telegram (%zu bytes)", telegram.content().size());
-  ESP_LOGVV(TAG, "Telegram content:\n %.*s", static_cast<int>(telegram.content().size()), telegram.content().data());
-
-  MyData data;
-  if (const bool res = dsmr_parser::DsmrParser::parse(data, telegram); !res) {
-    ESP_LOGE(TAG, "Failed to parse telegram");
+  const auto &res = dsmr_parser::P1Parser::parse(
+      data, this->telegram_, this->bytes_read_, false,
+      this->crc_check_);  // Parse telegram according to data definition. Ignore unknown values.
+  if (res.err) {
+    // Parsing error, show it
+    auto err_str = res.fullError(this->telegram_, this->telegram_ + this->bytes_read_);
+    ESP_LOGE(TAG, "%s", err_str.c_str());
    return false;
-  }
+  } else {
+    this->status_clear_warning();
+    this->publish_sensors(data);

-  this->status_clear_warning();
-  this->publish_sensors(data);
-
-  // Publish the telegram, after publishing the sensors so it can also trigger action based on latest values
-  if (this->s_telegram_ != nullptr) {
-    this->s_telegram_->publish_state(telegram.content().data(), telegram.content().size());
+    // publish the telegram, after publishing the sensors so it can also trigger action based on latest values
+    if (this->s_telegram_ != nullptr) {
+      this->s_telegram_->publish_state(this->telegram_, this->bytes_read_);
+    }
+    return true;
  }
-  return true;
 }

 void Dsmr::dump_config() {
  ESP_LOGCONFIG(TAG,
                "DSMR:\n"
-                "  Max telegram length: %zu\n"
+                "  Max telegram length: %d\n"
                "  Receive timeout: %.1fs",
-                this->buffer_.size(), this->receive_timeout_ / 1e3f);
+                this->max_telegram_len_, this->receive_timeout_ / 1e3f);
  if (this->request_pin_ != nullptr) {
    LOG_PIN("  Request Pin: ", this->request_pin_);
  }
@@ -192,37 +324,30 @@ void Dsmr::dump_config() {
  DSMR_TEXT_SENSOR_LIST(DSMR_LOG_TEXT_SENSOR, )
 }

-void Dsmr::set_decryption_key_(const char *decryption_key) {
+void Dsmr::set_decryption_key(const char *decryption_key) {
  if (decryption_key == nullptr || decryption_key[0] == '\0') {
-    this->encryption_enabled_ = false;
+    ESP_LOGI(TAG, "Disabling decryption");
+    this->decryption_key_.clear();
+    if (this->crypt_telegram_ != nullptr) {
+      delete[] this->crypt_telegram_;
+      this->crypt_telegram_ = nullptr;
+    }
    return;
  }

-  auto key = dsmr_parser::Aes128GcmDecryptionKey::from_hex(decryption_key);
-  if (!key) {
-    ESP_LOGE(TAG, "Error, decryption key has incorrect format");
-    this->encryption_enabled_ = false;
+  if (!parse_hex(decryption_key, this->decryption_key_, 16)) {
+    ESP_LOGE(TAG, "Error, decryption key must be 32 hex characters");
+    this->decryption_key_.clear();
    return;
  }

  ESP_LOGI(TAG, "Decryption key is set");
+  // Verbose level prints decryption key
+  ESP_LOGV(TAG, "Using decryption key: %s", decryption_key);

-  this->gcm_decryptor_.set_encryption_key(key.value());
-  this->encryption_enabled_ = true;
-}
-
-std::span<uint8_t> Dsmr::uart_read_chunk_() {
-  const auto avail = this->available();
-  if (avail == 0) {
-    return {};
+  if (this->crypt_telegram_ == nullptr) {
+    this->crypt_telegram_ = new uint8_t[this->max_telegram_len_];  // NOLINT
  }
-  size_t to_read = std::min(avail, uart_chunk_reading_buf_.size());
-  if (!this->read_array(uart_chunk_reading_buf_.data(), to_read)) {
-    return {};
-  }
-  return {uart_chunk_reading_buf_.data(), to_read};
 }

 }  // namespace esphome::dsmr
-
-#endif
@@ -1,45 +1,30 @@
 #pragma once

-// Ignore Zephyr. It doesn't have any encryption library.
-#if defined(USE_ESP32) || defined(USE_ARDUINO) || defined(USE_HOST)
-
 #include "esphome/core/component.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/text_sensor/text_sensor.h"
 #include "esphome/components/uart/uart.h"
 #include "esphome/core/log.h"
-#include <dsmr_parser/dlms_packet_decryptor.h>
 #include <dsmr_parser/fields.h>
-#include <dsmr_parser/packet_accumulator.h>
 #include <dsmr_parser/parser.h>
-#include <array>
-#include <span>
 #include <vector>

-#if __has_include(<psa/crypto.h>)
-#include <dsmr_parser/decryption/aes128gcm_tfpsa.h>
-#elif __has_include(<mbedtls/gcm.h>)
-#if __has_include(<mbedtls/esp_config.h>)
-#include <mbedtls/esp_config.h>
-#endif
-#include <dsmr_parser/decryption/aes128gcm_mbedtls.h>
-#elif __has_include(<bearssl/bearssl.h>)
-#include <dsmr_parser/decryption/aes128gcm_bearssl.h>
-#else
-#error "The platform doesn't provide a compatible encryption library for dsmr_parser"
-#endif
-
 namespace esphome::dsmr {

-#if __has_include(<psa/crypto.h>)
-using Aes128GcmDecryptorImpl = dsmr_parser::Aes128GcmTfPsa;
-#elif __has_include(<mbedtls/gcm.h>)
-using Aes128GcmDecryptorImpl = dsmr_parser::Aes128GcmMbedTls;
-#else
-using Aes128GcmDecryptorImpl = dsmr_parser::Aes128GcmBearSsl;
+using namespace dsmr_parser::fields;
+
+// DSMR_**_LIST generated by ESPHome and written in esphome/core/defines
+
+#if !defined(DSMR_SENSOR_LIST) && !defined(DSMR_TEXT_SENSOR_LIST)
+// Neither set, set it to a dummy value to not break build
+#define DSMR_TEXT_SENSOR_LIST(F, SEP) F(identification)
 #endif

-using namespace dsmr_parser::fields;
+#if defined(DSMR_SENSOR_LIST) && defined(DSMR_TEXT_SENSOR_LIST)
+#define DSMR_BOTH ,
+#else
+#define DSMR_BOTH
+#endif

 #ifndef DSMR_SENSOR_LIST
 #define DSMR_SENSOR_LIST(F, SEP)
@@ -49,33 +34,21 @@ using namespace dsmr_parser::fields;
 #define DSMR_TEXT_SENSOR_LIST(F, SEP)
 #endif

-#define DSMR_IDENTITY(s) s
+#define DSMR_DATA_SENSOR(s) s
 #define DSMR_COMMA ,
-#define DSMR_PREPEND_COMMA(...) __VA_OPT__(, ) __VA_ARGS__

-#ifdef DSMR_TEXT_SENSOR_LIST_DEFINED
-using MyData = dsmr_parser::ParsedData<DSMR_TEXT_SENSOR_LIST(DSMR_IDENTITY, DSMR_COMMA)
-                                           DSMR_PREPEND_COMMA(DSMR_SENSOR_LIST(DSMR_IDENTITY, DSMR_COMMA))>;
-#else
-using MyData = dsmr_parser::ParsedData<DSMR_SENSOR_LIST(DSMR_IDENTITY, DSMR_COMMA)>;
-#endif
+using MyData = dsmr_parser::ParsedData<DSMR_TEXT_SENSOR_LIST(DSMR_DATA_SENSOR, DSMR_COMMA)
+                                           DSMR_BOTH DSMR_SENSOR_LIST(DSMR_DATA_SENSOR, DSMR_COMMA)>;

 class Dsmr : public Component, public uart::UARTDevice {
 public:
-  Dsmr(uart::UARTComponent *uart, bool crc_check, size_t max_telegram_length, uint32_t request_interval,
-       uint32_t receive_timeout, GPIOPin *request_pin, const char *decryption_key)
-      : uart::UARTDevice(uart),
-        request_interval_(request_interval),
-        receive_timeout_(receive_timeout),
-        request_pin_(request_pin),
-        buffer_(max_telegram_length),
-        packet_accumulator_(buffer_, crc_check) {
-    this->set_decryption_key_(decryption_key);
-  }
+  Dsmr(uart::UARTComponent *uart, bool crc_check) : uart::UARTDevice(uart), crc_check_(crc_check) {}

  void setup() override;
  void loop() override;

+  bool parse_telegram();
+
  void publish_sensors(MyData &data) {
 #define DSMR_PUBLISH_SENSOR(s) \
  if (data.s##_present && this->s_##s##_ != nullptr) \
@@ -84,15 +57,20 @@ class Dsmr : public Component, public uart::UARTDevice {

 #define DSMR_PUBLISH_TEXT_SENSOR(s) \
  if (data.s##_present && this->s_##s##_ != nullptr) \
-    s_##s##_->publish_state(data.s.data(), data.s.size());
+    s_##s##_->publish_state(data.s.c_str());
    DSMR_TEXT_SENSOR_LIST(DSMR_PUBLISH_TEXT_SENSOR, )
  };

  void dump_config() override;

+  void set_decryption_key(const char *decryption_key);
  // Remove before 2026.8.0
-  ESPDEPRECATED("Use 'decryption_key' configuration parameter. This method will be removed in 2026.8.0", "2026.2.0")
-  void set_decryption_key(const std::string &decryption_key) { this->set_decryption_key_(decryption_key.c_str()); }
+  ESPDEPRECATED("Pass .c_str() - e.g. set_decryption_key(key.c_str()). Removed in 2026.8.0", "2026.2.0")
+  void set_decryption_key(const std::string &decryption_key) { this->set_decryption_key(decryption_key.c_str()); }
+  void set_max_telegram_length(size_t length) { this->max_telegram_len_ = length; }
+  void set_request_pin(GPIOPin *request_pin) { this->request_pin_ = request_pin; }
+  void set_request_interval(uint32_t interval) { this->request_interval_ = interval; }
+  void set_receive_timeout(uint32_t timeout) { this->receive_timeout_ = timeout; }

 // Sensor setters
 #define DSMR_SET_SENSOR(s) \
@@ -107,40 +85,56 @@ class Dsmr : public Component, public uart::UARTDevice {
  void set_telegram(text_sensor::TextSensor *sensor) { s_telegram_ = sensor; }

 protected:
-  void set_decryption_key_(const char *decryption_key);
  void receive_telegram_();
  void receive_encrypted_telegram_();
-  void flush_rx_buffer_();
+  void reset_telegram_();
+  void drain_rx_buffer_();

-  bool parse_telegram_(const dsmr_parser::DsmrUnencryptedTelegram &telegram);
-  bool request_interval_reached_() const;
+  /// Wait for UART data to become available within the read timeout.
+  ///
+  /// The smart meter might provide data in chunks, causing available() to
+  /// return 0. When we're already reading a telegram, then we don't return
+  /// right away (to handle further data in an upcoming loop) but wait a
+  /// little while using this method to see if more data are incoming.
+  /// By not returning, we prevent other components from taking so much
+  /// time that the UART RX buffer overflows and bytes of the telegram get
+  /// lost in the process.
+  bool available_within_timeout_();
+
+  // Request telegram
+  uint32_t request_interval_;
+  bool request_interval_reached_();
+  GPIOPin *request_pin_{nullptr};
+  uint32_t last_request_time_{0};
+  bool requesting_data_{false};
  bool ready_to_request_data_();
  void start_requesting_data_();
  void stop_requesting_data_();
-  std::span<uint8_t> uart_read_chunk_();

-  // Config
-  uint32_t request_interval_;
+  // Read telegram
  uint32_t receive_timeout_;
-  GPIOPin *request_pin_{nullptr};
+  bool receive_timeout_reached_();
+  size_t max_telegram_len_;
+  char *telegram_{nullptr};
+  size_t bytes_read_{0};
+  uint8_t *crypt_telegram_{nullptr};
+  size_t crypt_telegram_len_{0};
+  size_t crypt_bytes_read_{0};
+  uint32_t last_read_time_{0};
+  bool header_found_{false};
+  bool footer_found_{false};
+
+  // handled outside dsmr
  text_sensor::TextSensor *s_telegram_{nullptr};
+
+// Sensor member pointers
 #define DSMR_DECLARE_SENSOR(s) sensor::Sensor *s_##s##_{nullptr};
  DSMR_SENSOR_LIST(DSMR_DECLARE_SENSOR, )
+
 #define DSMR_DECLARE_TEXT_SENSOR(s) text_sensor::TextSensor *s_##s##_{nullptr};
  DSMR_TEXT_SENSOR_LIST(DSMR_DECLARE_TEXT_SENSOR, )

-  // State
-  uint32_t last_request_time_{0};
-  uint32_t last_read_time_{0};
-  bool requesting_data_{false};
-  bool encryption_enabled_{false};
-  size_t buffer_pos_{0};
-  std::vector<uint8_t> buffer_;
-  dsmr_parser::PacketAccumulator packet_accumulator_;
-  Aes128GcmDecryptorImpl gcm_decryptor_;
-  dsmr_parser::DlmsPacketDecryptor dlms_decryptor_{gcm_decryptor_};
-  std::array<uint8_t, 256> uart_chunk_reading_buf_;
+  std::vector<uint8_t> decryption_key_{};
+  bool crc_check_;
 };
 }  // namespace esphome::dsmr
-
-#endif
@@ -10,7 +10,6 @@ from esphome.const import (
    DEVICE_CLASS_FREQUENCY,
    DEVICE_CLASS_GAS,
    DEVICE_CLASS_POWER,
-    DEVICE_CLASS_POWER_FACTOR,
    DEVICE_CLASS_REACTIVE_POWER,
    DEVICE_CLASS_VOLTAGE,
    DEVICE_CLASS_WATER,
@@ -120,42 +119,6 @@ CONFIG_SCHEMA = cv.Schema(
            device_class=DEVICE_CLASS_ENERGY,
            state_class=STATE_CLASS_TOTAL_INCREASING,
        ),
-        cv.Optional("energy_delivered_tariff1_il"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("energy_delivered_tariff2_il"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("energy_delivered_tariff3_il"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("energy_returned_tariff1_il"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("energy_returned_tariff2_il"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
-        cv.Optional("energy_returned_tariff3_il"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT_HOURS,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
        cv.Optional("total_imported_energy"): sensor.sensor_schema(
            unit_of_measurement=UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
            accuracy_decimals=3,
@@ -548,12 +511,6 @@ CONFIG_SCHEMA = cv.Schema(
            device_class=DEVICE_CLASS_GAS,
            state_class=STATE_CLASS_TOTAL_INCREASING,
        ),
-        cv.Optional("gas_delivered_gj"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_GIGA_JOULE,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_ENERGY,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-        ),
        cv.Optional("water_delivered"): sensor.sensor_schema(
            unit_of_measurement=UNIT_CUBIC_METER,
            accuracy_decimals=3,
@@ -657,12 +614,6 @@ CONFIG_SCHEMA = cv.Schema(
            device_class=DEVICE_CLASS_POWER,
            state_class=STATE_CLASS_MEASUREMENT,
        ),
-        cv.Optional("active_demand_net"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_KILOWATT,
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
        cv.Optional("active_demand_abs"): sensor.sensor_schema(
            unit_of_measurement=UNIT_KILOWATT,
            accuracy_decimals=3,
@@ -777,37 +728,6 @@ CONFIG_SCHEMA = cv.Schema(
            device_class=DEVICE_CLASS_POWER,
            state_class=STATE_CLASS_MEASUREMENT,
        ),
-        cv.Optional("power_factor"): sensor.sensor_schema(
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER_FACTOR,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("power_factor_l1"): sensor.sensor_schema(
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER_FACTOR,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("power_factor_l2"): sensor.sensor_schema(
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER_FACTOR,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("power_factor_l3"): sensor.sensor_schema(
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER_FACTOR,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("min_power_factor"): sensor.sensor_schema(
-            accuracy_decimals=3,
-            device_class=DEVICE_CLASS_POWER_FACTOR,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional("period_3_for_instantaneous_values"): sensor.sensor_schema(
-            unit_of_measurement=UNIT_SECOND,
-            accuracy_decimals=0,
-            device_class=DEVICE_CLASS_DURATION,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
    }
 ).extend(cv.COMPONENT_SCHEMA)

@@ -826,7 +746,6 @@ async def to_code(config):
            sensors.append(f"F({key})")

    if sensors:
-        cg.add_define("DSMR_SENSOR_LIST_DEFINED")
        cg.add_define(
            "DSMR_SENSOR_LIST(F, sep)", cg.RawExpression(" sep ".join(sensors))
        )
@@ -15,9 +15,7 @@ CONFIG_SCHEMA = cv.Schema(
        cv.Optional("p1_version_be"): text_sensor.text_sensor_schema(),
        cv.Optional("timestamp"): text_sensor.text_sensor_schema(),
        cv.Optional("electricity_tariff"): text_sensor.text_sensor_schema(),
-        cv.Optional("electricity_tariff_il"): text_sensor.text_sensor_schema(),
        cv.Optional("electricity_failure_log"): text_sensor.text_sensor_schema(),
-        cv.Optional("electricity_failure_log_il"): text_sensor.text_sensor_schema(),
        cv.Optional("message_short"): text_sensor.text_sensor_schema(),
        cv.Optional("message_long"): text_sensor.text_sensor_schema(),
        cv.Optional("equipment_id"): text_sensor.text_sensor_schema(),
@@ -54,7 +52,6 @@ async def to_code(config):
                text_sensors.append(f"F({key})")

    if text_sensors:
-        cg.add_define("DSMR_TEXT_SENSOR_LIST_DEFINED")
        cg.add_define(
            "DSMR_TEXT_SENSOR_LIST(F, sep)",
            cg.RawExpression(" sep ".join(text_sensors)),
@@ -1,97 +0,0 @@
-#include "epaper_spi_ssd1683.h"
-
-#include <algorithm>
-
-#include "esphome/core/log.h"
-
-namespace esphome::epaper_spi {
-static constexpr const char *const TAG = "epaper_spi.mono";
-
-void EPaperSSD1683::refresh_screen(bool partial) {
-  ESP_LOGV(TAG, "Refresh screen");
-  this->cmd_data(0x3C, {partial ? (uint8_t) 0x80 : (uint8_t) 0x01});
-  // On partial update, set red RAM to inverse to remove BW ghosting
-  this->cmd_data(0x21, {partial ? (uint8_t) 0x80 : (uint8_t) 0x40, (uint8_t) 0x00});
-  // Set full update to 0xD7 for fast update, 0xF7 for normal
-  // Fast update flashes less and draws sooner but is in busy state for the same amount of time
-  // Manufacturer recommends not using fast update all the time, TODO expose this to the user
-  this->cmd_data(0x22, {partial ? (uint8_t) 0xFC : (uint8_t) 0xF7});
-  this->command(0x20);
-}
-
-// Puts the display into deep sleep mode 1, only way to get out is to reset the display
-// Mode 1 retains RAM while sleeping, necessary for future partial and window updates
-void EPaperSSD1683::deep_sleep() {
-  if (this->is_using_partial_update_()) {
-    ESP_LOGV(TAG, "Deep sleep mode 1");
-    this->cmd_data(0x10, {0x01});  // deep sleep, retain RAM
-  } else {
-    ESP_LOGV(TAG, "Deep sleep mode 2");
-    this->cmd_data(0x10, {0x03});  // deep sleep, lose RAM
-  }
-}
-
-void EPaperSSD1683::set_window() {
-  // if not using partial update, the display will go into deep sleep mode 2, so must rewrite entire
-  // buffer since the display RAM will not retain contents
-  if (!this->is_using_partial_update_()) {
-    this->x_low_ = 0;
-    this->x_high_ = this->width_;
-    this->y_low_ = 0;
-    this->y_high_ = this->height_;
-  }
-
-  // round x-coordinates to byte boundaries
-  this->x_low_ /= 8;
-  this->x_high_ += 7;
-  this->x_high_ /= 8;
-
-  this->cmd_data(0x44, {(uint8_t) this->x_low_, (uint8_t) (this->x_high_ - 1)});
-  this->cmd_data(0x45, {(uint8_t) this->y_low_, (uint8_t) (this->y_low_ / 256), (uint8_t) (this->y_high_ - 1),
-                        (uint8_t) ((this->y_high_ - 1) / 256)});
-  this->cmd_data(0x4E, {(uint8_t) this->x_low_});
-  this->cmd_data(0x4F, {(uint8_t) this->y_low_, (uint8_t) (this->y_low_ / 256)});
-}
-
-bool HOT EPaperSSD1683::transfer_data() {
-  auto start_time = millis();
-  if (this->current_data_index_ == 0) {
-    if (this->send_red_) {
-      // round to byte boundaries
-      this->set_window();
-    }
-    // for monochrome, we need to send red on every refresh to prevent dirty pixels
-    // when doing a partial refresh
-    this->command(this->send_red_ ? 0x26 : 0x24);
-    this->current_data_index_ = this->y_low_;  // actually current line
-  }
-  size_t row_length = this->x_high_ - this->x_low_;
-  FixedVector<uint8_t> bytes_to_send{};
-  bytes_to_send.init(row_length);
-  ESP_LOGV(TAG, "Writing %u bytes at line %zu at %ums", row_length, this->current_data_index_, (unsigned) millis());
-  this->start_data_();
-  while (this->current_data_index_ != this->y_high_) {
-    size_t data_idx = this->current_data_index_ * this->row_width_ + this->x_low_;
-    for (size_t i = 0; i != row_length; i++) {
-      bytes_to_send[i] = this->buffer_[data_idx++];
-    }
-    ++this->current_data_index_;
-    this->write_array(&bytes_to_send.front(), row_length);  // NOLINT
-    if (millis() - start_time > MAX_TRANSFER_TIME) {
-      // Let the main loop run and come back next loop
-      this->disable();
-      return false;
-    }
-  }
-
-  this->disable();
-  this->current_data_index_ = 0;
-  if (this->send_red_) {
-    this->send_red_ = false;
-    return false;
-  }
-  this->send_red_ = true;
-  return true;
-}
-
-}  // namespace esphome::epaper_spi
@@ -1,22 +0,0 @@
-#pragma once
-
-#include "epaper_spi_mono.h"
-
-namespace esphome::epaper_spi {
-/**
- * A class for Solomon SSD1683 epaper displays.
- */
-class EPaperSSD1683 : public EPaperMono {
- public:
-  EPaperSSD1683(const char *name, uint16_t width, uint16_t height, const uint8_t *init_sequence,
-                size_t init_sequence_length)
-      : EPaperMono(name, width, height, init_sequence, init_sequence_length) {}
-
- protected:
-  void refresh_screen(bool partial) override;
-  void deep_sleep() override;
-  void set_window() override;
-  bool transfer_data() override;
-};
-
-}  // namespace esphome::epaper_spi
@@ -1,27 +0,0 @@
-from esphome.const import CONF_DATA_RATE
-
-from . import EpaperModel
-
-
-class SSD1683(EpaperModel):
-    def __init__(self, name, class_name="EPaperSSD1683", data_rate="20MHz", **defaults):
-        defaults[CONF_DATA_RATE] = data_rate
-        super().__init__(name, class_name, **defaults)
-
-    # fmt: off
-    def get_init_sequence(self, config: dict):
-        _width, height = self.get_dimensions(config)
-        return (
-            (0x01, (height - 1) % 256, (height - 1) // 256, 0x00),    # Set column gate limit
-            (0x18, 0x80),    # Select internal Temp sensor
-            (0x11, 0x03),      # Set transform
-        )
-
-
-ssd1683 = SSD1683("ssd1683")
-
-goodisplay_gdey042t81 = ssd1683.extend(
-    "goodisplay-gdey042t81-4.2",
-    width=400,
-    height=300,
-)
@@ -33,7 +33,6 @@ from esphome.const import (
    CONF_TYPE,
    CONF_VARIANT,
    CONF_VERSION,
-    CONF_WATCHDOG_TIMEOUT,
    KEY_CORE,
    KEY_FRAMEWORK_VERSION,
    KEY_NAME,
@@ -129,30 +128,23 @@ ASSERTION_LEVELS = {
 SIGNING_SCHEMES = {
    "rsa3072": "CONFIG_SECURE_SIGNED_APPS_RSA_SCHEME",
    "ecdsa256": "CONFIG_SECURE_SIGNED_APPS_ECDSA_V2_SCHEME",
-    "ecdsa_v1": "CONFIG_SECURE_SIGNED_APPS_ECDSA_SCHEME",
 }

-# Chip variants that only support one V2 signing scheme.
+# Chip variants that only support one signing scheme for Secure Boot V2.
 # Based on SOC_SECURE_BOOT_V2_RSA / SOC_SECURE_BOOT_V2_ECC in soc_caps.h.
-# Variants not listed in either set support both RSA and ECDSA V2
+# Variants not listed in either set support both RSA and ECDSA
 # (e.g. C5, C6, H2, P4). New variants should be added to the
 # appropriate set if they only support one scheme.
-# Note: VARIANT_ESP32 is not listed here because it supports V2 RSA only
-# when minimum_chip_revision >= 3.0, which requires special handling.
-SIGNED_OTA_V2_RSA_ONLY_VARIANTS = {
+SIGNED_OTA_RSA_ONLY_VARIANTS = {
+    VARIANT_ESP32,
    VARIANT_ESP32S2,
    VARIANT_ESP32S3,
    VARIANT_ESP32C3,
 }
-SIGNED_OTA_V2_ECC_ONLY_VARIANTS = {
+SIGNED_OTA_ECC_ONLY_VARIANTS = {
    VARIANT_ESP32C2,
    VARIANT_ESP32C61,
 }
-# V1 ECDSA (Secure Boot V1) is only supported on the original ESP32.
-# Based on SOC_SECURE_BOOT_V1 in soc_caps.h.
-SIGNED_OTA_V1_ECDSA_VARIANTS = {
-    VARIANT_ESP32,
-}

 COMPILER_OPTIMIZATIONS = {
    "DEBUG": "CONFIG_COMPILER_OPTIMIZATION_DEBUG",
@@ -999,73 +991,25 @@ def final_validate(config):
    if signed_ota := advanced.get(CONF_SIGNED_OTA_VERIFICATION):
        scheme = signed_ota[CONF_SIGNING_SCHEME]
        variant = config[CONF_VARIANT]
-        min_rev = advanced.get(CONF_MINIMUM_CHIP_REVISION)
-        scheme_path = [
-            CONF_FRAMEWORK,
-            CONF_ADVANCED,
-            CONF_SIGNED_OTA_VERIFICATION,
-            CONF_SIGNING_SCHEME,
-        ]
-
-        # V1 ECDSA is only available on the original ESP32
-        if scheme == "ecdsa_v1" and variant not in SIGNED_OTA_V1_ECDSA_VARIANTS:
+        scheme_variant_conflicts = {
+            "ecdsa256": (SIGNED_OTA_RSA_ONLY_VARIANTS, "rsa3072"),
+            "rsa3072": (SIGNED_OTA_ECC_ONLY_VARIANTS, "ecdsa256"),
+        }
+        if (conflict := scheme_variant_conflicts.get(scheme)) and variant in conflict[
+            0
+        ]:
            errs.append(
                cv.Invalid(
-                    f"Signing scheme 'ecdsa_v1' is only supported on "
-                    f"{VARIANT_FRIENDLY[VARIANT_ESP32]}. "
-                    f"Use 'rsa3072' or 'ecdsa256' instead.",
-                    path=scheme_path,
+                    f"Signing scheme '{scheme}' is not supported on "
+                    f"{VARIANT_FRIENDLY[variant]}. Use '{conflict[1]}' instead.",
+                    path=[
+                        CONF_FRAMEWORK,
+                        CONF_ADVANCED,
+                        CONF_SIGNED_OTA_VERIFICATION,
+                        CONF_SIGNING_SCHEME,
+                    ],
                )
            )
-        elif variant == VARIANT_ESP32:
-            # On ESP32, V2 RSA requires minimum_chip_revision >= 3.0
-            # Note: string comparison works here because cv.one_of constrains
-            # min_rev to known ESP32_CHIP_REVISIONS values ("0.0".."3.1").
-            if scheme == "rsa3072" and (min_rev is None or min_rev < "3.0"):
-                errs.append(
-                    cv.Invalid(
-                        f"Signing scheme 'rsa3072' on {VARIANT_FRIENDLY[variant]} "
-                        f"requires minimum_chip_revision: '3.0' or higher "
-                        f"(Secure Boot V2 RSA needs chip revision 3.0+). "
-                        f"For older chip revisions, use 'ecdsa_v1' instead.",
-                        path=scheme_path,
-                    )
-                )
-            # ESP32 does not support V2 ECDSA (no SOC_SECURE_BOOT_V2_ECC)
-            elif scheme == "ecdsa256":
-                errs.append(
-                    cv.Invalid(
-                        f"Signing scheme 'ecdsa256' is not supported on "
-                        f"{VARIANT_FRIENDLY[variant]}. Use 'rsa3072' (with "
-                        f"minimum_chip_revision: '3.0') or 'ecdsa_v1' instead.",
-                        path=scheme_path,
-                    )
-                )
-            # V1 on rev 3.0+ -- suggest V2 RSA for stronger security
-            elif scheme == "ecdsa_v1" and min_rev is not None and min_rev >= "3.0":
-                _LOGGER.info(
-                    "Using Secure Boot V1 ECDSA on %s rev %s. "
-                    "Consider using 'rsa3072' (Secure Boot V2 RSA) for "
-                    "stronger security on chip revision 3.0+.",
-                    VARIANT_FRIENDLY[variant],
-                    min_rev,
-                )
-        else:
-            # Non-ESP32 variants: check V2 scheme-variant compatibility
-            scheme_variant_conflicts = {
-                "ecdsa256": (SIGNED_OTA_V2_RSA_ONLY_VARIANTS, "rsa3072"),
-                "rsa3072": (SIGNED_OTA_V2_ECC_ONLY_VARIANTS, "ecdsa256"),
-            }
-            if (
-                conflict := scheme_variant_conflicts.get(scheme)
-            ) and variant in conflict[0]:
-                errs.append(
-                    cv.Invalid(
-                        f"Signing scheme '{scheme}' is not supported on "
-                        f"{VARIANT_FRIENDLY[variant]}. Use '{conflict[1]}' instead.",
-                        path=scheme_path,
-                    )
-                )
        if CONF_OTA not in full_config:
            _LOGGER.warning(
                "Signed OTA verification is enabled but no OTA component is configured. "
@@ -1278,7 +1222,7 @@ FRAMEWORK_SCHEMA = cv.Schema(
                cv.Optional(CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False): cv.boolean,
                cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC, default=False): cv.boolean,
                cv.Optional(CONF_MINIMUM_CHIP_REVISION): cv.one_of(
-                    *ESP32_CHIP_REVISIONS, string=True
+                    *ESP32_CHIP_REVISIONS
                ),
                cv.Optional(CONF_SRAM1_AS_IRAM, default=False): cv.boolean,
                # DHCP server is needed for WiFi AP mode. When WiFi component is used,
@@ -1508,10 +1452,6 @@ CONFIG_SCHEMA = cv.All(
            ),
            cv.Optional(CONF_VARIANT): cv.one_of(*VARIANTS, upper=True),
            cv.Optional(CONF_FRAMEWORK): FRAMEWORK_SCHEMA,
-            cv.Optional(CONF_WATCHDOG_TIMEOUT, default="5s"): cv.All(
-                cv.positive_time_period_seconds,
-                cv.Range(min=cv.TimePeriod(seconds=5), max=cv.TimePeriod(seconds=60)),
-            ),
        }
    ),
    _detect_variant,
@@ -1729,10 +1669,6 @@ async def to_code(config):
        cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ESP_IDF")
        if use_platformio:
            cg.add_platformio_option("framework", "espidf")
-            # Strip volatile build path/time metadata from PlatformIO-managed
-            # ESP-IDF builds so equivalent projects can produce reproducible
-            # outputs and downstream tooling can safely reuse artifacts.
-            add_idf_sdkconfig_option("CONFIG_APP_REPRODUCIBLE_BUILD", True)

        # Wrap std::__throw_* functions to abort immediately, eliminating ~3KB of
        # exception class overhead. See throw_stubs.cpp for implementation.
@@ -1883,10 +1819,6 @@ async def to_code(config):
    add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_PANIC", True)
    add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0", False)
    add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1", False)
-    add_idf_sdkconfig_option(
-        "CONFIG_ESP_TASK_WDT_TIMEOUT_S",
-        config[CONF_WATCHDOG_TIMEOUT].total_seconds,
-    )

    # Disable dynamic log level control to save memory
    add_idf_sdkconfig_option("CONFIG_LOG_DYNAMIC_LEVEL_CONTROL", False)
@@ -23,26 +23,7 @@ extern "C" __attribute__((weak)) void initArduino() {}
 namespace esphome {

 void HOT yield() { vPortYield(); }
-// Use xTaskGetTickCount() when tick rate is 1 kHz (ESPHome's default via sdkconfig),
-// falling back to esp_timer for non-standard rates. IRAM_ATTR is required because
-// Wiegand and ZyAura call millis() from IRAM_ATTR ISR handlers on ESP32.
-// xTaskGetTickCountFromISR() is used in ISR context to satisfy the FreeRTOS API contract.
-uint32_t IRAM_ATTR HOT millis() {
-#if CONFIG_FREERTOS_HZ == 1000
-  if (xPortInIsrContext()) [[unlikely]] {
-    return xTaskGetTickCountFromISR();
-  }
-  return xTaskGetTickCount();
-#else
-  return micros_to_millis(static_cast<uint64_t>(esp_timer_get_time()));
-#endif
-}
-// millis_64() stays on esp_timer — a different clock from xTaskGetTickCount(). This is
-// safe because the two are never cross-compared: millis() values are only used for
-// millis()-vs-millis() deltas (feed_wdt, warn_blocking, component start time), while
-// millis_64() is used by the Scheduler and uptime sensors. On ESP32 (USE_NATIVE_64BIT_TIME),
-// Scheduler::millis_64_from_(now) discards the 32-bit now and calls millis_64() directly,
-// so the Scheduler is internally consistent on the esp_timer clock.
+uint32_t IRAM_ATTR HOT millis() { return micros_to_millis(static_cast<uint64_t>(esp_timer_get_time())); }
 uint64_t HOT millis_64() { return micros_to_millis<uint64_t>(static_cast<uint64_t>(esp_timer_get_time())); }
 void HOT delay(uint32_t ms) { vTaskDelay(ms / portTICK_PERIOD_MS); }
 uint32_t IRAM_ATTR HOT micros() { return (uint32_t) esp_timer_get_time(); }
@@ -172,16 +172,10 @@ def validate_gpio_pin(pin):
            exc,
        )
    else:
-        # `ignore_pin_validation_error` only suppresses an error raised by the
-        # variant's pin_validation above (e.g. SPI flash/PSRAM pins, invalid pin
-        # numbers). If that didn't raise, the option is a no-op -- warn so the
-        # user can clean it up, but don't block the build.
+        # Throw an exception if used for a pin that would not have resulted
+        # in a validation error anyway!
        if ignore_pin_validation_warning:
-            _LOGGER.warning(
-                "GPIO%d has no validation errors to ignore; "
-                "remove `ignore_pin_validation_error: true` from this pin.",
-                pin[CONF_NUMBER],
-            )
+            raise cv.Invalid(f"GPIO{pin[CONF_NUMBER]} is not a reserved pin")

    return pin

@@ -5,7 +5,6 @@ import json  # noqa: E402
 import os  # noqa: E402
 import pathlib  # noqa: E402
 import shutil  # noqa: E402
-import subprocess  # noqa: E402
 from glob import glob  # noqa: E402


@@ -26,114 +25,6 @@ def _parse_sdkconfig(sdkconfig_path):
    return options


-def _generate_v1_verification_key(env):
-    """Generate the V1 ECDSA verification key binary and assembly source file.
-
-    Secure Boot V1 embeds the public verification key directly in the app binary
-    as a compiled object (via a .S assembly file). The ESP-IDF CMake build generates
-    these files via custom commands, but PlatformIO's SCons bridge does not execute
-    them. This function replicates that logic:
-      1. Extracts the raw public key from the PEM signing key using espsecure.
-      2. Generates the .S assembly source that embeds the key bytes.
-    """
-    build_dir = pathlib.Path(env.subst("$BUILD_DIR"))
-    project_dir = pathlib.Path(env.subst("$PROJECT_DIR"))
-    pioenv = env.subst("$PIOENV")
-    sdkconfig = _parse_sdkconfig(project_dir / f"sdkconfig.{pioenv}")
-
-    if sdkconfig.get("CONFIG_SECURE_SIGNED_APPS_ECDSA_SCHEME") != "y":
-        return
-
-    bin_path = build_dir / "signature_verification_key.bin"
-    asm_path = build_dir / "signature_verification_key.bin.S"
-
-    # Determine the source of the verification key
-    if sdkconfig.get("CONFIG_SECURE_BOOT_BUILD_SIGNED_BINARIES") == "y":
-        # Extract public key from the signing key
-        signing_key = sdkconfig.get("CONFIG_SECURE_BOOT_SIGNING_KEY")
-        if not signing_key:
-            return
-        signing_key_path = pathlib.Path(signing_key)
-        if not signing_key_path.exists():
-            print(f"Error: V1 ECDSA signing key not found: {signing_key_path}")
-            env.Exit(1)
-            return
-
-        if not bin_path.exists() or bin_path.stat().st_mtime < signing_key_path.stat().st_mtime:
-            python_exe = env.subst("$PYTHONEXE")
-            result = subprocess.run(
-                [python_exe, "-m", "espsecure", "extract_public_key",
-                 "--keyfile", str(signing_key_path), str(bin_path)],
-                capture_output=True, text=True,
-            )
-            if result.returncode != 0:
-                print(f"Error extracting V1 verification key: {result.stderr}")
-                env.Exit(1)
-                return
-            print(f"Extracted V1 ECDSA verification key from {signing_key_path.name}")
-    else:
-        # User-provided verification key -- should already be a raw binary file
-        verification_key = sdkconfig.get("CONFIG_SECURE_BOOT_VERIFICATION_KEY")
-        if not verification_key:
-            return
-        verification_key_path = pathlib.Path(verification_key)
-        if not verification_key_path.exists():
-            print(f"Error: Verification key not found: {verification_key_path}")
-            env.Exit(1)
-            return
-        shutil.copyfile(str(verification_key_path), str(bin_path))
-
-    if not bin_path.exists():
-        return
-
-    # Generate the .S assembly file from the binary key data.
-    # Replicates ESP-IDF's data_file_embed_asm.cmake with RENAME_TO=signature_verification_key_bin.
-    # The file is needed in both the app build dir and the bootloader build dir, since
-    # the bootloader also embeds the verification key when CONFIG_SECURE_SIGNED_ON_BOOT_NO_SECURE_BOOT
-    # is enabled. PlatformIO's SCons bridge does not execute the CMake custom commands that
-    # normally generate these files.
-    data = bin_path.read_bytes()
-    varname = "signature_verification_key_bin"
-
-    lines = []
-    lines.append(f"/* Data converted from {bin_path.name} */")
-    lines.append(".data")
-    lines.append("#if !defined (__APPLE__) && !defined (__linux__)")
-    lines.append(".section .rodata.embedded")
-    lines.append("#endif")
-    lines.append(f"\n.global {varname}")
-    lines.append(f"{varname}:")
-    lines.append(f"\n.global _binary_{varname}_start")
-    lines.append(f"_binary_{varname}_start: /* for objcopy compatibility */")
-
-    # Format binary data as .byte lines (16 bytes per line)
-    for i in range(0, len(data), 16):
-        chunk = data[i:i + 16]
-        hex_bytes = ", ".join(f"0x{b:02x}" for b in chunk)
-        lines.append(f".byte {hex_bytes}")
-
-    lines.append(f"\n.global _binary_{varname}_end")
-    lines.append(f"_binary_{varname}_end: /* for objcopy compatibility */")
-    lines.append(f"\n.global {varname}_length")
-    lines.append(f"{varname}_length:")
-    lines.append(f".long {len(data)}")
-    lines.append("")
-    lines.append('#if defined (__linux__)')
-    lines.append('.section .note.GNU-stack,"",@progbits')
-    lines.append("#endif")
-
-    asm_content = "\n".join(lines) + "\n"
-
-    # Write to app build dir and bootloader build dir
-    asm_path.write_text(asm_content)
-    bootloader_dir = build_dir / "bootloader"
-    if bootloader_dir.is_dir():
-        bootloader_bin = bootloader_dir / "signature_verification_key.bin"
-        bootloader_asm = bootloader_dir / "signature_verification_key.bin.S"
-        shutil.copyfile(str(bin_path), str(bootloader_bin))
-        bootloader_asm.write_text(asm_content)
-
-
 def sign_firmware(source, target, env):
    """
    Sign the firmware binary using espsecure.py if signed OTA verification is enabled.
@@ -164,12 +55,9 @@ def sign_firmware(source, target, env):
        env.Exit(1)
        return

-    # Determine espsecure signature version from the signing scheme:
-    # V1 ECDSA (Secure Boot V1) uses --version 1, V2 RSA/ECDSA use --version 2.
-    if sdkconfig.get("CONFIG_SECURE_SIGNED_APPS_ECDSA_SCHEME") == "y":
-        sign_version = "1"
-    else:
-        sign_version = "2"
+    # ESPHome only exposes RSA3072 and ECDSA256 (both Secure Boot V2 schemes),
+    # so the espsecure signature version is always 2.
+    sign_version = "2"

    firmware_name = os.path.basename(env.subst("$PROGNAME")) + ".bin"
    firmware_path = build_dir / firmware_name
@@ -329,11 +217,6 @@ def esp32_copy_ota_bin(source, target, env):
    print(f"Copied firmware to {new_file_name}")


-# Generate V1 ECDSA verification key files before build starts.
-# Workaround for PlatformIO not executing CMake custom commands that extract
-# the public key and generate the .S assembly file for Secure Boot V1.
-_generate_v1_verification_key(env)  # noqa: F821
-
 # Run signing first, then merge, then ota copy
 env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", sign_firmware)  # noqa: F821
 env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", merge_factory_bin)  # noqa: F821
@@ -7,7 +7,6 @@ from typing import Any

 from esphome import automation
 import esphome.codegen as cg
-from esphome.components.const import CONF_USE_PSRAM
 from esphome.components.esp32 import add_idf_sdkconfig_option, const, get_esp32_variant
 from esphome.components.esp32.const import VARIANT_ESP32C2
 import esphome.config_validation as cv
@@ -343,9 +342,6 @@ CONFIG_SCHEMA = cv.Schema(
        cv.Optional(CONF_MAX_CONNECTIONS, default=DEFAULT_MAX_CONNECTIONS): cv.All(
            cv.positive_int, cv.Range(min=1, max=IDF_MAX_CONNECTIONS)
        ),
-        cv.Optional(CONF_USE_PSRAM): cv.All(
-            cv.only_on_esp32, cv.requires_component("psram"), cv.boolean
-        ),
    }
 ).extend(cv.COMPONENT_SCHEMA)

@@ -602,22 +598,6 @@ async def to_code(config):
    add_idf_sdkconfig_option("CONFIG_BT_ENABLED", True)
    add_idf_sdkconfig_option("CONFIG_BT_BLE_42_FEATURES_SUPPORTED", True)

-    # When PSRAM and BT are used together, Bluedroid should prefer SPIRAM for
-    # heap allocations and use dynamic (heap-based) environment memory tables
-    # instead of large static DRAM arrays. This frees ~40 kB of internal RAM.
-    # Reference: Espressif ADF Design Considerations
-    # https://espressif-docs.readthedocs-hosted.com/projects/esp-adf/en/latest/
-    #            design-guide/design-considerations.html
-    if config.get(CONF_USE_PSRAM, False):
-        cg.add_define("USE_ESP32_BLE_PSRAM")
-        # CONFIG_BT_ALLOCATION_FROM_SPIRAM_FIRST is only available on ESP32
-        # (BTDM dual-mode controller). BLE-only SoCs (C3, S3, C2, H2) do not
-        # expose this Kconfig symbol; applying it there would cause a build error.
-        if get_esp32_variant() == const.VARIANT_ESP32:
-            add_idf_sdkconfig_option("CONFIG_BT_ALLOCATION_FROM_SPIRAM_FIRST", True)
-        # CONFIG_BT_BLE_DYNAMIC_ENV_MEMORY applies to all Bluedroid-enabled variants.
-        add_idf_sdkconfig_option("CONFIG_BT_BLE_DYNAMIC_ENV_MEMORY", True)
-
    # Register the core BLE loggers that are always needed
    register_bt_logger(BTLoggers.GAP, BTLoggers.BTM, BTLoggers.HCI)

@@ -257,9 +257,11 @@ bool ESP32BLE::ble_setup_() {

  if (this->name_ != nullptr) {
    if (App.is_name_add_mac_suffix_enabled()) {
+      // MAC address length: 12 hex chars + null terminator
+      constexpr size_t mac_address_len = 13;
      // MAC address suffix length (last 6 characters of 12-char MAC address string)
      constexpr size_t mac_address_suffix_len = 6;
-      char mac_addr[MAC_ADDRESS_BUFFER_SIZE];
+      char mac_addr[mac_address_len];
      get_mac_address_into_buffer(mac_addr);
      const char *mac_suffix_ptr = mac_addr + mac_address_suffix_len;
      make_name_with_suffix_to(name_buffer, sizeof(name_buffer), this->name_, strlen(this->name_), '-', mac_suffix_ptr,
@@ -665,9 +667,6 @@ void ESP32BLE::dump_config() {
                  "  MAC address: %s\n"
                  "  IO Capability: %s",
                  mac_s, io_capability_s);
-#ifdef USE_ESP32_BLE_PSRAM
-    ESP_LOGCONFIG(TAG, "  PSRAM BLE allocation: enabled");
-#endif

 #ifdef ESPHOME_ESP32_BLE_EXTENDED_AUTH_PARAMS
    const char *auth_req_mode_s = "<default>";
@@ -78,14 +78,6 @@ def ota_esphome_final_validate(config):
        else:
            new_ota_conf.append(ota_conf)

-    if len(merged_ota_esphome_configs_by_port) > 1:
-        raise cv.Invalid(
-            f"Only a single port is supported for '{CONF_OTA}' "
-            f"'{CONF_PLATFORM}: {CONF_ESPHOME}'. Got ports "
-            f"{sorted(merged_ota_esphome_configs_by_port.keys())}. Consolidate "
-            f"onto a single port; configs sharing a port are merged automatically."
-        )
-
    new_ota_conf.extend(merged_ota_esphome_configs_by_port.values())

    full_conf[CONF_OTA] = new_ota_conf
@@ -150,17 +142,11 @@ async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
    cg.add(var.set_port(config[CONF_PORT]))

-    # Compile the auth path whenever `password:` is present in YAML, even if empty.
-    # An empty password opts in to the auth code path so set_auth_password() can be
-    # called at runtime (e.g. to rotate the password from a lambda). When `password:`
-    # is omitted entirely, the auth path is excluded to save flash on small devices.
-    if CONF_PASSWORD in config:
+    # Password could be set to an empty string and we can assume that means no password
+    if config.get(CONF_PASSWORD):
+        cg.add(var.set_auth_password(config[CONF_PASSWORD]))
        cg.add_define("USE_OTA_PASSWORD")
-        if config[CONF_PASSWORD]:
-            cg.add(var.set_auth_password(config[CONF_PASSWORD]))
    cg.add_define("USE_OTA_VERSION", config[CONF_VERSION])
-    # Build flag so lwip_fast_select.c (a .c file that can't include defines.h) sees it.
-    cg.add_build_flag("-DUSE_OTA_PLATFORM_ESPHOME")

    await cg.register_component(var, config)
    await ota_to_code(var, config)
@@ -15,9 +15,6 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
-#ifdef USE_LWIP_FAST_SELECT
-#include "esphome/core/lwip_fast_select.h"
-#endif

 #include <cerrno>
 #include <cstdio>
@@ -31,17 +28,6 @@ static constexpr size_t OTA_BUFFER_SIZE = 1024;                  // buffer size
 static constexpr uint32_t OTA_SOCKET_TIMEOUT_HANDSHAKE = 20000;  // milliseconds for initial handshake
 static constexpr uint32_t OTA_SOCKET_TIMEOUT_DATA = 90000;       // milliseconds for data transfer

-// Single-instance pointer — multi-port configs are rejected in final_validate.
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-static ESPHomeOTAComponent *global_esphome_ota_component = nullptr;
-
-// Called from any context (LwIP TCP/IP task, RP2040 user-IRQ).
-extern "C" void esphome_wake_ota_component_any_context() {
-  if (global_esphome_ota_component != nullptr) {
-    global_esphome_ota_component->enable_loop_soon_any_context();
-  }
-}
-
 void ESPHomeOTAComponent::setup() {
  this->server_ = socket::socket_ip_loop_monitored(SOCK_STREAM, 0).release();  // monitored for incoming connections
  if (this->server_ == nullptr) {
@@ -79,14 +65,6 @@ void ESPHomeOTAComponent::setup() {
    this->server_failed_(LOG_STR("listen"));
    return;
  }
-
-  // loop() self-disables on its first idle tick; no explicit disable_loop() needed here.
-  global_esphome_ota_component = this;
-#ifdef USE_LWIP_FAST_SELECT
-  // Filter fast-select wakes to this listener only. If the sock lookup returns nullptr,
-  // no wakes fire and loop() falls back to the self-disable safety net.
-  esphome_fast_select_set_ota_listener_sock(esphome_lwip_get_sock(this->server_->get_fd()));
-#endif
 }

 void ESPHomeOTAComponent::dump_config() {
@@ -103,15 +81,13 @@ void ESPHomeOTAComponent::dump_config() {
 }

 void ESPHomeOTAComponent::loop() {
-  // Self-disabling idle loop. Runs when a wake path marks us pending-enable (fast-select
-  // listener filter, raw-TCP accept_fn_, or host select), finds no work, and goes back
-  // to sleep. cleanup_connection_() deliberately leaves the loop enabled for one more
-  // iteration so a connection queued mid-session is still caught here.
-  if (this->client_ == nullptr && !this->server_->ready()) {
-    this->disable_loop();
-    return;
+  // Skip handle_handshake_() call if no client connected and no incoming connections
+  // This optimization reduces idle loop overhead when OTA is not active
+  // Note: No need to check server_ for null as the component is marked failed in setup()
+  // if server_ creation fails
+  if (this->client_ != nullptr || this->server_->ready()) {
+    this->handle_handshake_();
  }
-  this->handle_handshake_();
 }

 static const uint8_t FEATURE_SUPPORTS_COMPRESSION = 0x01;
@@ -590,9 +566,6 @@ void ESPHomeOTAComponent::cleanup_connection_() {
 #ifdef USE_OTA_PASSWORD
  this->cleanup_auth_();
 #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,
-  // set while we were in LOOP state, would be lost to enable_pending_loops_()).
 }

 void ESPHomeOTAComponent::yield_and_feed_watchdog_() {
@@ -28,14 +28,6 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
  };
 #ifdef USE_OTA_PASSWORD
  void set_auth_password(const std::string &password) { password_ = password; }
-#else
-  // Stub so lambdas referencing set_auth_password() produce a clear error instead of
-  // a cryptic "no member" diagnostic. Only fires if the stub is actually instantiated.
-  template<bool B = false> void set_auth_password(const std::string &) {
-    static_assert(B, "set_auth_password() requires the OTA auth path to be compiled. "
-                     "Add 'password: \"\"' (empty string) to your 'ota: - platform: esphome' "
-                     "config to enable runtime password rotation.");
-  }
 #endif  // USE_OTA_PASSWORD

  /// Manually set the port OTA should listen on
@@ -221,7 +221,7 @@ class EthernetComponent final : public Component {
  int reset_pin_{-1};
  int phy_addr_spi_{-1};
  int clock_speed_;
-  spi_host_device_t interface_{SPI2_HOST};
+  spi_host_device_t interface_{SPI3_HOST};
 #ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
  uint32_t polling_interval_{0};
 #endif
@@ -1,6 +1,5 @@
 import logging
 from pathlib import Path
-from typing import Any

 from esphome import git, loader
 import esphome.config_validation as cv
@@ -18,7 +17,7 @@ from esphome.const import (
    TYPE_GIT,
    TYPE_LOCAL,
 )
-from esphome.core import CORE, TimePeriodSeconds
+from esphome.core import CORE

 _LOGGER = logging.getLogger(__name__)

@@ -36,15 +35,17 @@ CONFIG_SCHEMA = cv.ensure_list(
 )


-async def to_code(config: dict[str, Any]) -> None:
+async def to_code(config):
    pass


-def _process_git_config(config: dict[str, Any], refresh: TimePeriodSeconds) -> Path:
+def _process_git_config(config: dict, refresh, skip_update: bool = False) -> str:
+    # When skip_update is True, use NEVER_REFRESH to prevent updates
+    actual_refresh = git.NEVER_REFRESH if skip_update else refresh
    repo_dir, _ = git.clone_or_update(
        url=config[CONF_URL],
        ref=config.get(CONF_REF),
-        refresh=refresh,
+        refresh=actual_refresh,
        domain=DOMAIN,
        username=config.get(CONF_USERNAME),
        password=config.get(CONF_PASSWORD),
@@ -71,12 +72,12 @@ def _process_git_config(config: dict[str, Any], refresh: TimePeriodSeconds) -> P
    return components_dir


-def _process_single_config(config: dict[str, Any]) -> None:
+def _process_single_config(config: dict, skip_update: bool = False):
    conf = config[CONF_SOURCE]
    if conf[CONF_TYPE] == TYPE_GIT:
        with cv.prepend_path([CONF_SOURCE]):
            components_dir = _process_git_config(
-                config[CONF_SOURCE], config[CONF_REFRESH]
+                config[CONF_SOURCE], config[CONF_REFRESH], skip_update
            )
    elif conf[CONF_TYPE] == TYPE_LOCAL:
        components_dir = Path(CORE.relative_config_path(conf[CONF_PATH]))
@@ -106,7 +107,7 @@ def _process_single_config(config: dict[str, Any]) -> None:
    loader.install_meta_finder(components_dir, allowed_components=allowed_components)


-def do_external_components_pass(config: dict[str, Any]) -> None:
+def do_external_components_pass(config: dict, skip_update: bool = False) -> None:
    conf = config.get(DOMAIN)
    if conf is None:
        return
@@ -114,4 +115,4 @@ def do_external_components_pass(config: dict[str, Any]) -> None:
        conf = CONFIG_SCHEMA(conf)
        for i, c in enumerate(conf):
            with cv.prepend_path(i):
-                _process_single_config(c)
+                _process_single_config(c, skip_update)
@@ -325,7 +325,7 @@ def download_gfont(value):
            raise cv.Invalid(
                f"Could not download font at {url}, please check the fonts exists "
                f"at google fonts ({e})"
-            ) from e
+            )
        match = re.search(r"src:\s+url\((.+)\)\s+format\('truetype'\);", req.text)
        if match is None:
            raise cv.Invalid(
@@ -60,73 +60,6 @@ CONFIG_SCHEMA = (
 )


-def _pin_shared_only_with_deep_sleep(pin_num: int) -> bool:
-    """Check if pin is shared exclusively with deep_sleep (wakeup pin)."""
-    pin_key = (CORE.target_platform, CORE.target_platform, pin_num)
-    pin_users = pins.PIN_SCHEMA_REGISTRY.pins_used.get(pin_key, [])
-    if len(pin_users) != 2:
-        return False
-    return any(path and path[0] == "deep_sleep" for path, _, _ in pin_users)
-
-
-def _final_validate(config):
-    use_interrupt = config[CONF_USE_INTERRUPT]
-    if not use_interrupt:
-        return config
-
-    pin_num = config[CONF_PIN][CONF_NUMBER]
-
-    # Expander pins (e.g. PCF8574, MCP23017) don't support direct interrupt
-    # attachment — only internal/native GPIO pins do.
-    if pins.PIN_SCHEMA_REGISTRY.get_key(config[CONF_PIN]) != CORE.target_platform:
-        _LOGGER.info(
-            "GPIO binary_sensor '%s': Pin is not an internal GPIO, "
-            "falling back to polling mode.",
-            config.get(CONF_NAME, config[CONF_ID]),
-        )
-        config[CONF_USE_INTERRUPT] = False
-        return config
-
-    # GPIO16 on ESP8266 doesn't support interrupts through attachInterrupt().
-    if CORE.is_esp8266 and pin_num == 16:
-        _LOGGER.warning(
-            "GPIO binary_sensor '%s': GPIO16 on ESP8266 doesn't support interrupts. "
-            "Falling back to polling mode (same as in ESPHome <2025.7). "
-            "The sensor will work exactly as before, but other pins have better "
-            "performance with interrupts.",
-            config.get(CONF_NAME, config[CONF_ID]),
-        )
-        config[CONF_USE_INTERRUPT] = False
-        return config
-
-    # When a pin is shared, interrupts can interfere with other components
-    # (e.g., duty_cycle sensor) that need to monitor the pin's state changes.
-    # Exception: deep_sleep wakeup pins are compatible with interrupts when
-    # the pin is only shared between this sensor and deep_sleep (count == 2).
-    if config[CONF_PIN].get(CONF_ALLOW_OTHER_USES, False):
-        if not _pin_shared_only_with_deep_sleep(pin_num):
-            _LOGGER.info(
-                "GPIO binary_sensor '%s': Disabling interrupts because pin %s is shared "
-                "with other components. The sensor will use polling mode for "
-                "compatibility with other pin uses.",
-                config.get(CONF_NAME, config[CONF_ID]),
-                pin_num,
-            )
-            config[CONF_USE_INTERRUPT] = False
-        else:
-            _LOGGER.debug(
-                "GPIO binary_sensor '%s': Pin %s is shared with deep_sleep, "
-                "keeping interrupts enabled.",
-                config.get(CONF_NAME, config[CONF_ID]),
-                pin_num,
-            )
-
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
 async def to_code(config):
    var = await binary_sensor.new_binary_sensor(config)
    await cg.register_component(var, config)
@@ -134,7 +67,36 @@ async def to_code(config):
    pin = await cg.gpio_pin_expression(config[CONF_PIN])
    cg.add(var.set_pin(pin))

-    if config[CONF_USE_INTERRUPT]:
+    # Check for ESP8266 GPIO16 interrupt limitation
+    # GPIO16 on ESP8266 is a special pin that doesn't support interrupts through
+    # the Arduino attachInterrupt() function. This is the only known GPIO pin
+    # across all supported platforms that has this limitation, so we handle it
+    # here instead of in the platform-specific code.
+    use_interrupt = config[CONF_USE_INTERRUPT]
+    if use_interrupt and CORE.is_esp8266 and config[CONF_PIN][CONF_NUMBER] == 16:
+        _LOGGER.warning(
+            "GPIO binary_sensor '%s': GPIO16 on ESP8266 doesn't support interrupts. "
+            "Falling back to polling mode (same as in ESPHome <2025.7). "
+            "The sensor will work exactly as before, but other pins have better "
+            "performance with interrupts.",
+            config.get(CONF_NAME, config[CONF_ID]),
+        )
+        use_interrupt = False
+
+    # Check if pin is shared with other components (allow_other_uses)
+    # When a pin is shared, interrupts can interfere with other components
+    # (e.g., duty_cycle sensor) that need to monitor the pin's state changes
+    if use_interrupt and config[CONF_PIN].get(CONF_ALLOW_OTHER_USES, False):
+        _LOGGER.info(
+            "GPIO binary_sensor '%s': Disabling interrupts because pin %s is shared with other components. "
+            "The sensor will use polling mode for compatibility with other pin uses.",
+            config.get(CONF_NAME, config[CONF_ID]),
+            config[CONF_PIN][CONF_NUMBER],
+        )
+        use_interrupt = False
+
+    if use_interrupt:
        cg.add(var.set_interrupt_type(config[CONF_INTERRUPT_TYPE]))
    else:
-        cg.add(var.set_use_interrupt(False))
+        # Only generate call when disabling interrupts (default is true)
+        cg.add(var.set_use_interrupt(use_interrupt))
@@ -46,6 +46,11 @@ void GPIOBinarySensorStore::setup(InternalGPIOPin *pin, Component *component) {
 }

 void GPIOBinarySensor::setup() {
+  if (this->store_.use_interrupt_ && !this->pin_->is_internal()) {
+    ESP_LOGD(TAG, "GPIO is not internal, falling back to polling mode");
+    this->store_.use_interrupt_ = false;
+  }
+
  if (this->store_.use_interrupt_) {
    auto *internal_pin = static_cast<InternalGPIOPin *>(this->pin_);
    this->store_.setup(internal_pin, this);
@@ -8,6 +8,7 @@
 #include <csignal>
 #include <sched.h>
 #include <time.h>
+#include <cmath>
 #include <cstdlib>

 namespace {
@@ -21,7 +22,9 @@ void HOT yield() { ::sched_yield(); }
 uint32_t IRAM_ATTR HOT millis() {
  struct timespec spec;
  clock_gettime(CLOCK_MONOTONIC, &spec);
-  return static_cast<uint32_t>(spec.tv_sec * 1000ULL + spec.tv_nsec / 1000000);
+  time_t seconds = spec.tv_sec;
+  uint32_t ms = round(spec.tv_nsec / 1e6);
+  return ((uint32_t) seconds) * 1000U + ms;
 }
 uint64_t millis_64() {
  struct timespec spec;
@@ -40,7 +43,9 @@ void HOT delay(uint32_t ms) {
 uint32_t IRAM_ATTR HOT micros() {
  struct timespec spec;
  clock_gettime(CLOCK_MONOTONIC, &spec);
-  return static_cast<uint32_t>(spec.tv_sec * 1000000ULL + spec.tv_nsec / 1000);
+  time_t seconds = spec.tv_sec;
+  uint32_t us = round(spec.tv_nsec / 1e3);
+  return ((uint32_t) seconds) * 1000000U + us;
 }
 void IRAM_ATTR HOT delayMicroseconds(uint32_t us) {
  struct timespec ts;
@@ -22,7 +22,7 @@ void HttpRequestComponent::dump_config() {
 }

 std::string HttpContainer::get_response_header(const std::string &header_name) {
-  auto lower = str_lower_case(header_name);  // NOLINT
+  auto lower = str_lower_case(header_name);
  for (const auto &entry : this->response_headers_) {
    if (entry.name == lower) {
      ESP_LOGD(TAG, "Header with name %s found with value %s", lower.c_str(), entry.value.c_str());
@@ -11,7 +11,6 @@
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
-#include "esphome/core/alloc_helpers.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"

@@ -401,7 +400,7 @@ class HttpRequestComponent : public Component {
    std::vector<std::string> lower;
    lower.reserve(collect_headers.size());
    for (const auto &h : collect_headers) {
-      lower.push_back(str_lower_case(h));  // NOLINT
+      lower.push_back(str_lower_case(h));
    }
    return this->perform(url, method, body, request_headers, lower);
  }
@@ -416,7 +415,7 @@ class HttpRequestComponent : public Component {
    std::vector<std::string> lower;
    lower.reserve(collect_headers.size());
    for (const auto &h : collect_headers) {
-      lower.push_back(str_lower_case(h));  // NOLINT
+      lower.push_back(str_lower_case(h));
    }
    return this->perform(url, method, body, std::vector<Header>(request_headers.begin(), request_headers.end()), lower);
  }
@@ -161,7 +161,7 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const std::string &ur
  container->response_headers_.clear();
  auto header_count = container->client_.headers();
  for (int i = 0; i < header_count; i++) {
-    const std::string header_name = str_lower_case(container->client_.headerName(i).c_str());  // NOLINT
+    const std::string header_name = str_lower_case(container->client_.headerName(i).c_str());
    if (should_collect_header(lower_case_collect_headers, header_name)) {
      std::string header_value = container->client_.header(i).c_str();
      ESP_LOGD(TAG, "Received response header, name: %s, value: %s", header_name.c_str(), header_value.c_str());
@@ -115,7 +115,7 @@ std::shared_ptr<HttpContainer> HttpRequestHost::perform(const std::string &url,
  container->content_length = container->response_body_.size();
  for (auto header : response.headers) {
    ESP_LOGD(TAG, "Header: %s: %s", header.first.c_str(), header.second.c_str());
-    auto lower_name = str_lower_case(header.first);  // NOLINT
+    auto lower_name = str_lower_case(header.first);
    if (should_collect_header(lower_case_collect_headers, lower_name)) {
      container->response_headers_.push_back({lower_name, header.second});
    }
@@ -38,7 +38,7 @@ esp_err_t HttpRequestIDF::http_event_handler(esp_http_client_event_t *evt) {

  switch (evt->event_id) {
    case HTTP_EVENT_ON_HEADER: {
-      const std::string header_name = str_lower_case(evt->header_key);  // NOLINT
+      const std::string header_name = str_lower_case(evt->header_key);
      if (should_collect_header(user_data->lower_case_collect_headers, header_name)) {
        const std::string header_value = evt->header_value;
        ESP_LOGD(TAG, "Received response header, name: %s, value: %s", header_name.c_str(), header_value.c_str());
@@ -36,7 +36,7 @@ I2SAudioMicrophone = i2s_audio_ns.class_(
 )

 INTERNAL_ADC_VARIANTS = [esp32.VARIANT_ESP32]
-PDM_VARIANTS = [esp32.VARIANT_ESP32, esp32.VARIANT_ESP32S3, esp32.VARIANT_ESP32P4]
+PDM_VARIANTS = [esp32.VARIANT_ESP32, esp32.VARIANT_ESP32S3]


 def _validate_esp32_variant(config):
@@ -33,16 +33,13 @@ AUTO_LOAD = ["audio"]
 CODEOWNERS = ["@jesserockz", "@kahrendt"]
 DEPENDENCIES = ["i2s_audio"]

-I2SAudioSpeakerBase = i2s_audio_ns.class_(
-    "I2SAudioSpeakerBase", cg.Component, speaker.Speaker, I2SAudioOut
+I2SAudioSpeaker = i2s_audio_ns.class_(
+    "I2SAudioSpeaker", cg.Component, speaker.Speaker, I2SAudioOut
 )
-I2SAudioSpeaker = i2s_audio_ns.class_("I2SAudioSpeaker", I2SAudioSpeakerBase)

 CONF_DAC_TYPE = "dac_type"
 CONF_I2S_COMM_FMT = "i2s_comm_fmt"

-I2SCommFmt = i2s_audio_ns.enum("I2SCommFmt", is_class=True)
-
 i2s_dac_mode_t = cg.global_ns.enum("i2s_dac_mode_t")
 INTERNAL_DAC_OPTIONS = {
    CONF_LEFT: i2s_dac_mode_t.I2S_DAC_CHANNEL_LEFT_EN,
@@ -186,11 +183,11 @@ async def to_code(config):
    await speaker.register_speaker(var, config)

    cg.add(var.set_dout_pin(config[CONF_I2S_DOUT_PIN]))
-    fmt = I2SCommFmt.STANDARD  # equals stand_i2s, stand_pcm_long, i2s_msb, pcm_long
+    fmt = "std"  # equals stand_i2s, stand_pcm_long, i2s_msb, pcm_long
    if config[CONF_I2S_COMM_FMT] in ["stand_msb", "i2s_lsb"]:
-        fmt = I2SCommFmt.MSB
+        fmt = "msb"
    elif config[CONF_I2S_COMM_FMT] in ["stand_pcm_short", "pcm_short", "pcm"]:
-        fmt = I2SCommFmt.PCM
+        fmt = "pcm"
    cg.add(var.set_i2s_comm_fmt(fmt))
    if config[CONF_TIMEOUT] != CONF_NEVER:
        cg.add(var.set_timeout(config[CONF_TIMEOUT]))
@@ -13,10 +13,36 @@

 #include "esp_timer.h"

-namespace esphome::i2s_audio {
+namespace esphome {
+namespace i2s_audio {
+
+static const uint32_t DMA_BUFFER_DURATION_MS = 15;
+static const size_t DMA_BUFFERS_COUNT = 4;
+
+static const size_t TASK_STACK_SIZE = 4096;
+static const ssize_t TASK_PRIORITY = 19;
+
+static const size_t I2S_EVENT_QUEUE_COUNT = DMA_BUFFERS_COUNT + 1;

 static const char *const TAG = "i2s_audio.speaker";

+enum SpeakerEventGroupBits : uint32_t {
+  COMMAND_START = (1 << 0),            // indicates loop should start speaker task
+  COMMAND_STOP = (1 << 1),             // stops the speaker task
+  COMMAND_STOP_GRACEFULLY = (1 << 2),  // Stops the speaker task once all data has been written
+
+  TASK_STARTING = (1 << 10),
+  TASK_RUNNING = (1 << 11),
+  TASK_STOPPING = (1 << 12),
+  TASK_STOPPED = (1 << 13),
+
+  ERR_ESP_NO_MEM = (1 << 19),
+
+  WARN_DROPPED_EVENT = (1 << 20),
+
+  ALL_BITS = 0x00FFFFFF,  // All valid FreeRTOS event group bits
+};
+
 // Lists the Q15 fixed point scaling factor for volume reduction.
 // Has 100 values representing silence and a reduction [49, 48.5, ... 0.5, 0] dB.
 // dB to PCM scaling factor formula: floating_point_scale_factor = 2^(-db/6.014)
@@ -30,21 +56,17 @@ static const std::vector<int16_t> Q15_VOLUME_SCALING_FACTORS = {
    8218,  8706,  9222,  9770,  10349, 10963, 11613, 12302, 13032, 13805, 14624, 15491, 16410, 17384, 18415,
    19508, 20665, 21891, 23189, 24565, 26022, 27566, 29201, 30933, 32767};

-void I2SAudioSpeakerBase::setup() {
+void I2SAudioSpeaker::setup() {
  this->event_group_ = xEventGroupCreate();

  if (this->event_group_ == nullptr) {
-    ESP_LOGE(TAG, "Event group creation failed");
+    ESP_LOGE(TAG, "Failed to create event group");
    this->mark_failed();
    return;
  }
-
-  // Initialize volume control. When audio_dac is configured, this sets the DAC volume.
-  // When no audio_dac is configured, this initializes software volume control.
-  this->set_volume(this->volume_);
 }

-void I2SAudioSpeakerBase::dump_config() {
+void I2SAudioSpeaker::dump_config() {
  ESP_LOGCONFIG(TAG,
                "Speaker:\n"
                "  Pin: %d\n"
@@ -53,9 +75,10 @@ void I2SAudioSpeakerBase::dump_config() {
  if (this->timeout_.has_value()) {
    ESP_LOGCONFIG(TAG, "  Timeout: %" PRIu32 " ms", this->timeout_.value());
  }
+  ESP_LOGCONFIG(TAG, "  Communication format: %s", this->i2s_comm_fmt_.c_str());
 }

-void I2SAudioSpeakerBase::loop() {
+void I2SAudioSpeaker::loop() {
  uint32_t event_group_bits = xEventGroupGetBits(this->event_group_);

  if ((event_group_bits & SpeakerEventGroupBits::COMMAND_START) && (this->state_ == speaker::STATE_STOPPED)) {
@@ -69,12 +92,12 @@ void I2SAudioSpeakerBase::loop() {
    xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::TASK_STARTING);
  }
  if (event_group_bits & SpeakerEventGroupBits::TASK_RUNNING) {
-    ESP_LOGV(TAG, "Started");
+    ESP_LOGD(TAG, "Started");
    xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::TASK_RUNNING);
    this->state_ = speaker::STATE_RUNNING;
  }
  if (event_group_bits & SpeakerEventGroupBits::TASK_STOPPING) {
-    ESP_LOGV(TAG, "Stopping");
+    ESP_LOGD(TAG, "Stopping");
    xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::TASK_STOPPING);
    this->state_ = speaker::STATE_STOPPING;
  }
@@ -88,12 +111,10 @@ void I2SAudioSpeakerBase::loop() {
    xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::ALL_BITS);
    this->status_clear_error();

-    this->on_task_stopped();
-
    this->state_ = speaker::STATE_STOPPED;
  }

-  // Log any errors encountered by the task
+  // Log any errors encounted by the task
  if (event_group_bits & SpeakerEventGroupBits::ERR_ESP_NO_MEM) {
    ESP_LOGE(TAG, "Not enough memory");
    xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::ERR_ESP_NO_MEM);
@@ -112,14 +133,14 @@ void I2SAudioSpeakerBase::loop() {
        break;
      }

-      if (this->start_i2s_driver(this->audio_stream_info_) != ESP_OK) {
+      if (this->start_i2s_driver_(this->audio_stream_info_) != ESP_OK) {
        ESP_LOGE(TAG, "Driver failed to start; retrying in 1 second");
-        this->status_momentary_error("driver-failure", 1000);
+        this->status_momentary_error("driver-faiure", 1000);
        break;
      }

      if (this->speaker_task_handle_ == nullptr) {
-        xTaskCreate(I2SAudioSpeakerBase::speaker_task, "speaker_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
+        xTaskCreate(I2SAudioSpeaker::speaker_task, "speaker_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
                    &this->speaker_task_handle_);

        if (this->speaker_task_handle_ == nullptr) {
@@ -136,7 +157,7 @@ void I2SAudioSpeakerBase::loop() {
  }
 }

-void I2SAudioSpeakerBase::set_volume(float volume) {
+void I2SAudioSpeaker::set_volume(float volume) {
  this->volume_ = volume;
 #ifdef USE_AUDIO_DAC
  if (this->audio_dac_ != nullptr) {
@@ -145,21 +166,15 @@ void I2SAudioSpeakerBase::set_volume(float volume) {
    }
    this->audio_dac_->set_volume(volume);
  } else
-#endif  // USE_AUDIO_DAC
+#endif
  {
-    // Fallback to software volume control by using a Q15 fixed point scaling factor.
-    // At maximum volume (1.0), set to INT16_MAX to completely bypass volume processing
-    // and avoid any floating-point precision issues that could cause slight volume reduction.
-    if (volume >= 1.0f) {
-      this->q15_volume_factor_ = INT16_MAX;
-    } else {
-      ssize_t decibel_index = remap<ssize_t, float>(volume, 0.0f, 1.0f, 0, Q15_VOLUME_SCALING_FACTORS.size() - 1);
-      this->q15_volume_factor_ = Q15_VOLUME_SCALING_FACTORS[decibel_index];
-    }
+    // Fallback to software volume control by using a Q15 fixed point scaling factor
+    ssize_t decibel_index = remap<ssize_t, float>(volume, 0.0f, 1.0f, 0, Q15_VOLUME_SCALING_FACTORS.size() - 1);
+    this->q15_volume_factor_ = Q15_VOLUME_SCALING_FACTORS[decibel_index];
  }
 }

-void I2SAudioSpeakerBase::set_mute_state(bool mute_state) {
+void I2SAudioSpeaker::set_mute_state(bool mute_state) {
  this->mute_state_ = mute_state;
 #ifdef USE_AUDIO_DAC
  if (this->audio_dac_) {
@@ -169,7 +184,7 @@ void I2SAudioSpeakerBase::set_mute_state(bool mute_state) {
      this->audio_dac_->set_mute_off();
    }
  } else
-#endif  // USE_AUDIO_DAC
+#endif
  {
    if (mute_state) {
      // Fallback to software volume control and scale by 0
@@ -181,12 +196,11 @@ void I2SAudioSpeakerBase::set_mute_state(bool mute_state) {
  }
 }

-size_t I2SAudioSpeakerBase::play(const uint8_t *data, size_t length, TickType_t ticks_to_wait) {
+size_t I2SAudioSpeaker::play(const uint8_t *data, size_t length, TickType_t ticks_to_wait) {
  if (this->is_failed()) {
    ESP_LOGE(TAG, "Setup failed; cannot play audio");
    return 0;
  }
-
  if (this->state_ != speaker::STATE_RUNNING && this->state_ != speaker::STATE_STARTING) {
    this->start();
  }
@@ -200,8 +214,8 @@ size_t I2SAudioSpeakerBase::play(const uint8_t *data, size_t length, TickType_t
  size_t bytes_written = 0;
  if (this->state_ == speaker::STATE_RUNNING) {
    std::shared_ptr<RingBuffer> temp_ring_buffer = this->audio_ring_buffer_.lock();
-    if (temp_ring_buffer != nullptr) {
-      // The weak_ptr locks successfully only while the speaker task owns the ring buffer, so it is safe to write
+    if (temp_ring_buffer.use_count() == 2) {
+      // Only the speaker task and this temp_ring_buffer own the ring buffer, so its safe to write to
      bytes_written = temp_ring_buffer->write_without_replacement((void *) data, length, ticks_to_wait);
    }
  }
@@ -209,7 +223,7 @@ size_t I2SAudioSpeakerBase::play(const uint8_t *data, size_t length, TickType_t
  return bytes_written;
 }

-bool I2SAudioSpeakerBase::has_buffered_data() const {
+bool I2SAudioSpeaker::has_buffered_data() const {
  if (this->audio_ring_buffer_.use_count() > 0) {
    std::shared_ptr<RingBuffer> temp_ring_buffer = this->audio_ring_buffer_.lock();
    return temp_ring_buffer->available() > 0;
@@ -217,27 +231,216 @@ bool I2SAudioSpeakerBase::has_buffered_data() const {
  return false;
 }

-void I2SAudioSpeakerBase::speaker_task(void *params) {
-  I2SAudioSpeakerBase *this_speaker = (I2SAudioSpeakerBase *) params;
-  this_speaker->run_speaker_task();
+void I2SAudioSpeaker::speaker_task(void *params) {
+  I2SAudioSpeaker *this_speaker = (I2SAudioSpeaker *) params;
+
+  xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::TASK_STARTING);
+
+  const uint32_t dma_buffers_duration_ms = DMA_BUFFER_DURATION_MS * DMA_BUFFERS_COUNT;
+  // Ensure ring buffer duration is at least the duration of all DMA buffers
+  const uint32_t ring_buffer_duration = std::max(dma_buffers_duration_ms, this_speaker->buffer_duration_ms_);
+
+  // The DMA buffers may have more bits per sample, so calculate buffer sizes based in the input audio stream info
+  const size_t ring_buffer_size = this_speaker->current_stream_info_.ms_to_bytes(ring_buffer_duration);
+
+  const uint32_t frames_to_fill_single_dma_buffer =
+      this_speaker->current_stream_info_.ms_to_frames(DMA_BUFFER_DURATION_MS);
+  const size_t bytes_to_fill_single_dma_buffer =
+      this_speaker->current_stream_info_.frames_to_bytes(frames_to_fill_single_dma_buffer);
+
+  bool successful_setup = false;
+  std::unique_ptr<audio::AudioSourceTransferBuffer> transfer_buffer =
+      audio::AudioSourceTransferBuffer::create(bytes_to_fill_single_dma_buffer);
+
+  if (transfer_buffer != nullptr) {
+    std::shared_ptr<RingBuffer> temp_ring_buffer = RingBuffer::create(ring_buffer_size);
+    if (temp_ring_buffer.use_count() == 1) {
+      transfer_buffer->set_source(temp_ring_buffer);
+      this_speaker->audio_ring_buffer_ = temp_ring_buffer;
+      successful_setup = true;
+    }
+  }
+
+  if (!successful_setup) {
+    xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::ERR_ESP_NO_MEM);
+  } else {
+    bool stop_gracefully = false;
+    bool tx_dma_underflow = true;
+
+    uint32_t frames_written = 0;
+    uint32_t last_data_received_time = millis();
+
+    xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::TASK_RUNNING);
+
+    while (this_speaker->pause_state_ || !this_speaker->timeout_.has_value() ||
+           (millis() - last_data_received_time) <= this_speaker->timeout_.value()) {
+      uint32_t event_group_bits = xEventGroupGetBits(this_speaker->event_group_);
+
+      if (event_group_bits & SpeakerEventGroupBits::COMMAND_STOP) {
+        xEventGroupClearBits(this_speaker->event_group_, SpeakerEventGroupBits::COMMAND_STOP);
+        break;
+      }
+      if (event_group_bits & SpeakerEventGroupBits::COMMAND_STOP_GRACEFULLY) {
+        xEventGroupClearBits(this_speaker->event_group_, SpeakerEventGroupBits::COMMAND_STOP_GRACEFULLY);
+        stop_gracefully = true;
+      }
+
+      if (this_speaker->audio_stream_info_ != this_speaker->current_stream_info_) {
+        // Audio stream info changed, stop the speaker task so it will restart with the proper settings.
+        break;
+      }
+      int64_t write_timestamp;
+      while (xQueueReceive(this_speaker->i2s_event_queue_, &write_timestamp, 0)) {
+        // Receives timing events from the I2S on_sent callback. If actual audio data was sent in this event, it passes
+        // on the timing info via the audio_output_callback.
+        uint32_t frames_sent = frames_to_fill_single_dma_buffer;
+        if (frames_to_fill_single_dma_buffer > frames_written) {
+          tx_dma_underflow = true;
+          frames_sent = frames_written;
+          const uint32_t frames_zeroed = frames_to_fill_single_dma_buffer - frames_written;
+          write_timestamp -= this_speaker->current_stream_info_.frames_to_microseconds(frames_zeroed);
+        } else {
+          tx_dma_underflow = false;
+        }
+        frames_written -= frames_sent;
+        if (frames_sent > 0) {
+          this_speaker->audio_output_callback_(frames_sent, write_timestamp);
+        }
+      }
+
+      if (this_speaker->pause_state_) {
+        // Pause state is accessed atomically, so thread safe
+        // Delay so the task yields, then skip transferring audio data
+        vTaskDelay(pdMS_TO_TICKS(DMA_BUFFER_DURATION_MS));
+        continue;
+      }
+
+      // Wait half the duration of the data already written to the DMA buffers for new audio data
+      // The millisecond helper modifies the frames_written variable, so use the microsecond helper and divide by 1000
+      const uint32_t read_delay =
+          (this_speaker->current_stream_info_.frames_to_microseconds(frames_written) / 1000) / 2;
+
+      size_t bytes_read = transfer_buffer->transfer_data_from_source(pdMS_TO_TICKS(read_delay));
+      uint8_t *new_data = transfer_buffer->get_buffer_end() - bytes_read;
+
+      if (bytes_read > 0) {
+        if (this_speaker->q15_volume_factor_ < INT16_MAX) {
+          // Apply the software volume adjustment by unpacking the sample into a Q31 fixed-point number, shifting it,
+          // multiplying by the volume factor, and packing the sample back into the original bytes per sample.
+
+          const size_t bytes_per_sample = this_speaker->current_stream_info_.samples_to_bytes(1);
+          const uint32_t len = bytes_read / bytes_per_sample;
+
+          // Use Q16 for samples with 1 or 2 bytes: shifted_sample * gain_factor is Q16 * Q15 -> Q31
+          int32_t shift = 15;                                      // Q31 -> Q16
+          int32_t gain_factor = this_speaker->q15_volume_factor_;  // Q15
+
+          if (bytes_per_sample >= 3) {
+            // Use Q23 for samples with 3 or 4 bytes: shifted_sample * gain_factor is Q23 * Q8 -> Q31
+
+            shift = 8;          // Q31 -> Q23
+            gain_factor >>= 7;  // Q15 -> Q8
+          }
+
+          for (uint32_t i = 0; i < len; ++i) {
+            int32_t sample =
+                audio::unpack_audio_sample_to_q31(&new_data[i * bytes_per_sample], bytes_per_sample);  // Q31
+            sample >>= shift;
+            sample *= gain_factor;  // Q31
+            audio::pack_q31_as_audio_sample(sample, &new_data[i * bytes_per_sample], bytes_per_sample);
+          }
+        }
+
+#ifdef USE_ESP32_VARIANT_ESP32
+        // For ESP32 16-bit mono mode, adjacent samples need to be swapped.
+        if (this_speaker->current_stream_info_.get_channels() == 1 &&
+            this_speaker->current_stream_info_.get_bits_per_sample() == 16) {
+          int16_t *samples = reinterpret_cast<int16_t *>(new_data);
+          size_t sample_count = bytes_read / sizeof(int16_t);
+          for (size_t i = 0; i + 1 < sample_count; i += 2) {
+            int16_t tmp = samples[i];
+            samples[i] = samples[i + 1];
+            samples[i + 1] = tmp;
+          }
+        }
+#endif
+      }
+
+      if (transfer_buffer->available() == 0) {
+        if (stop_gracefully && tx_dma_underflow) {
+          break;
+        }
+        vTaskDelay(pdMS_TO_TICKS(DMA_BUFFER_DURATION_MS / 2));
+      } else {
+        size_t bytes_written = 0;
+        if (tx_dma_underflow) {
+          // Temporarily disable channel and callback to reset the I2S driver's internal DMA buffer queue so timing
+          // callbacks are accurate. Preload the data.
+          i2s_channel_disable(this_speaker->tx_handle_);
+          const i2s_event_callbacks_t callbacks = {
+              .on_sent = nullptr,
+          };
+
+          i2s_channel_register_event_callback(this_speaker->tx_handle_, &callbacks, this_speaker);
+          i2s_channel_preload_data(this_speaker->tx_handle_, transfer_buffer->get_buffer_start(),
+                                   transfer_buffer->available(), &bytes_written);
+        } else {
+          // Audio is already playing, use regular I2S write to add to the DMA buffers
+          i2s_channel_write(this_speaker->tx_handle_, transfer_buffer->get_buffer_start(), transfer_buffer->available(),
+                            &bytes_written, DMA_BUFFER_DURATION_MS);
+        }
+        if (bytes_written > 0) {
+          last_data_received_time = millis();
+          frames_written += this_speaker->current_stream_info_.bytes_to_frames(bytes_written);
+          transfer_buffer->decrease_buffer_length(bytes_written);
+          if (tx_dma_underflow) {
+            tx_dma_underflow = false;
+            // Reset the event queue timestamps
+            // Enable the on_sent callback to accurately track the timestamps of played audio
+            // Enable the I2S channel to start sending the preloaded audio
+
+            xQueueReset(this_speaker->i2s_event_queue_);
+
+            const i2s_event_callbacks_t callbacks = {
+                .on_sent = i2s_on_sent_cb,
+            };
+            i2s_channel_register_event_callback(this_speaker->tx_handle_, &callbacks, this_speaker);
+
+            i2s_channel_enable(this_speaker->tx_handle_);
+          }
+        }
+      }
+    }
+  }
+
+  xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::TASK_STOPPING);
+
+  if (transfer_buffer != nullptr) {
+    transfer_buffer.reset();
+  }
+
+  xEventGroupSetBits(this_speaker->event_group_, SpeakerEventGroupBits::TASK_STOPPED);
+
+  while (true) {
+    // Continuously delay until the loop method deletes the task
+    vTaskDelay(pdMS_TO_TICKS(10));
+  }
 }

-void I2SAudioSpeakerBase::start() {
+void I2SAudioSpeaker::start() {
  if (!this->is_ready() || this->is_failed() || this->status_has_error())
    return;
  if ((this->state_ == speaker::STATE_STARTING) || (this->state_ == speaker::STATE_RUNNING))
    return;

-  // Mark STARTING immediately to avoid transient STOPPED observations before loop() processes COMMAND_START.
-  this->state_ = speaker::STATE_STARTING;
  xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::COMMAND_START);
 }

-void I2SAudioSpeakerBase::stop() { this->stop_(false); }
+void I2SAudioSpeaker::stop() { this->stop_(false); }

-void I2SAudioSpeakerBase::finish() { this->stop_(true); }
+void I2SAudioSpeaker::finish() { this->stop_(true); }

-void I2SAudioSpeakerBase::stop_(bool wait_on_empty) {
+void I2SAudioSpeaker::stop_(bool wait_on_empty) {
  if (this->is_failed())
    return;
  if (this->state_ == speaker::STATE_STOPPED)
@@ -250,16 +453,105 @@ void I2SAudioSpeakerBase::stop_(bool wait_on_empty) {
  }
 }

-esp_err_t I2SAudioSpeakerBase::init_i2s_channel_(const i2s_chan_config_t &chan_cfg, const i2s_std_config_t &std_cfg,
-                                                 size_t event_queue_size) {
+esp_err_t I2SAudioSpeaker::start_i2s_driver_(audio::AudioStreamInfo &audio_stream_info) {
+  this->current_stream_info_ = audio_stream_info;  // store the stream info settings the driver will use
+
+  if ((this->i2s_role_ & I2S_ROLE_SLAVE) && (this->sample_rate_ != audio_stream_info.get_sample_rate())) {  // NOLINT
+    // Can't reconfigure I2S bus, so the sample rate must match the configured value
+    ESP_LOGE(TAG, "Audio stream settings are not compatible with this I2S configuration");
+    return ESP_ERR_NOT_SUPPORTED;
+  }
+
+  if (this->slot_bit_width_ != I2S_SLOT_BIT_WIDTH_AUTO &&
+      (i2s_slot_bit_width_t) audio_stream_info.get_bits_per_sample() > this->slot_bit_width_) {
+    // Currently can't handle the case when the incoming audio has more bits per sample than the configured value
+    ESP_LOGE(TAG, "Audio streams with more bits per sample than the I2S speaker's configuration is not supported");
+    return ESP_ERR_NOT_SUPPORTED;
+  }
+
+  if (!this->parent_->try_lock()) {
+    ESP_LOGE(TAG, "Parent I2S bus not free");
+    return ESP_ERR_INVALID_STATE;
+  }
+
+  uint32_t dma_buffer_length = audio_stream_info.ms_to_frames(DMA_BUFFER_DURATION_MS);
+
+  i2s_chan_config_t chan_cfg = {
+      .id = this->parent_->get_port(),
+      .role = this->i2s_role_,
+      .dma_desc_num = DMA_BUFFERS_COUNT,
+      .dma_frame_num = dma_buffer_length,
+      .auto_clear = true,
+      .intr_priority = 3,
+  };
+  /* Allocate a new TX channel and get the handle of this channel */
  esp_err_t err = i2s_new_channel(&chan_cfg, &this->tx_handle_, NULL);
  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "I2S channel allocation failed: %s", esp_err_to_name(err));
+    ESP_LOGE(TAG, "Failed to allocate new I2S channel");
    this->parent_->unlock();
    return err;
  }

+  i2s_clock_src_t clk_src = I2S_CLK_SRC_DEFAULT;
+#ifdef I2S_CLK_SRC_APLL
+  if (this->use_apll_) {
+    clk_src = I2S_CLK_SRC_APLL;
+  }
+#endif
+  i2s_std_gpio_config_t pin_config = this->parent_->get_pin_config();
+
+  i2s_std_clk_config_t clk_cfg = {
+      .sample_rate_hz = audio_stream_info.get_sample_rate(),
+      .clk_src = clk_src,
+      .mclk_multiple = this->mclk_multiple_,
+  };
+
+  i2s_slot_mode_t slot_mode = this->slot_mode_;
+  i2s_std_slot_mask_t slot_mask = this->std_slot_mask_;
+  if (audio_stream_info.get_channels() == 1) {
+    slot_mode = I2S_SLOT_MODE_MONO;
+  } else if (audio_stream_info.get_channels() == 2) {
+    slot_mode = I2S_SLOT_MODE_STEREO;
+    slot_mask = I2S_STD_SLOT_BOTH;
+  }
+
+  i2s_std_slot_config_t std_slot_cfg;
+  if (this->i2s_comm_fmt_ == "std") {
+    std_slot_cfg =
+        I2S_STD_PHILIPS_SLOT_DEFAULT_CONFIG((i2s_data_bit_width_t) audio_stream_info.get_bits_per_sample(), slot_mode);
+  } else if (this->i2s_comm_fmt_ == "pcm") {
+    std_slot_cfg =
+        I2S_STD_PCM_SLOT_DEFAULT_CONFIG((i2s_data_bit_width_t) audio_stream_info.get_bits_per_sample(), slot_mode);
+  } else {
+    std_slot_cfg =
+        I2S_STD_MSB_SLOT_DEFAULT_CONFIG((i2s_data_bit_width_t) audio_stream_info.get_bits_per_sample(), slot_mode);
+  }
+#ifdef USE_ESP32_VARIANT_ESP32
+  // There seems to be a bug on the ESP32 (non-variant) platform where setting the slot bit width higher then the bits
+  // per sample causes the audio to play too fast. Setting the ws_width to the configured slot bit width seems to
+  // make it play at the correct speed while sending more bits per slot.
+  if (this->slot_bit_width_ != I2S_SLOT_BIT_WIDTH_AUTO) {
+    uint32_t configured_bit_width = static_cast<uint32_t>(this->slot_bit_width_);
+    std_slot_cfg.ws_width = configured_bit_width;
+    if (configured_bit_width > 16) {
+      std_slot_cfg.msb_right = false;
+    }
+  }
+#else
+  std_slot_cfg.slot_bit_width = this->slot_bit_width_;
+#endif
+  std_slot_cfg.slot_mask = slot_mask;
+
+  pin_config.dout = this->dout_pin_;
+
+  i2s_std_config_t std_cfg = {
+      .clk_cfg = clk_cfg,
+      .slot_cfg = std_slot_cfg,
+      .gpio_cfg = pin_config,
+  };
+  /* Initialize the channel */
  err = i2s_channel_init_std_mode(this->tx_handle_, &std_cfg);
+
  if (err != ESP_OK) {
    ESP_LOGE(TAG, "Failed to initialize channel");
    i2s_del_channel(this->tx_handle_);
@@ -267,34 +559,23 @@ esp_err_t I2SAudioSpeakerBase::init_i2s_channel_(const i2s_chan_config_t &chan_c
    this->parent_->unlock();
    return err;
  }
-
  if (this->i2s_event_queue_ == nullptr) {
-    this->i2s_event_queue_ = xQueueCreate(event_queue_size, sizeof(int64_t));
-  } else {
-    // Reset queue to clear any stale events from previous task
-    xQueueReset(this->i2s_event_queue_);
+    this->i2s_event_queue_ = xQueueCreate(I2S_EVENT_QUEUE_COUNT, sizeof(int64_t));
  }

-  return ESP_OK;
+  i2s_channel_enable(this->tx_handle_);
+
+  return err;
 }

-void I2SAudioSpeakerBase::stop_i2s_driver_() {
-  if (this->tx_handle_ != nullptr) {
-    i2s_channel_disable(this->tx_handle_);
-    i2s_del_channel(this->tx_handle_);
-    this->tx_handle_ = nullptr;
-  }
-  this->parent_->unlock();
-}
-
-bool IRAM_ATTR I2SAudioSpeakerBase::i2s_on_sent_cb(i2s_chan_handle_t handle, i2s_event_data_t *event, void *user_ctx) {
+bool IRAM_ATTR I2SAudioSpeaker::i2s_on_sent_cb(i2s_chan_handle_t handle, i2s_event_data_t *event, void *user_ctx) {
  int64_t now = esp_timer_get_time();

  BaseType_t need_yield1 = pdFALSE;
  BaseType_t need_yield2 = pdFALSE;
  BaseType_t need_yield3 = pdFALSE;

-  I2SAudioSpeakerBase *this_speaker = (I2SAudioSpeakerBase *) user_ctx;
+  I2SAudioSpeaker *this_speaker = (I2SAudioSpeaker *) user_ctx;

  if (xQueueIsQueueFullFromISR(this_speaker->i2s_event_queue_)) {
    // Queue is full, so discard the oldest event and set the warning flag to inform the user
@@ -308,47 +589,14 @@ bool IRAM_ATTR I2SAudioSpeakerBase::i2s_on_sent_cb(i2s_chan_handle_t handle, i2s
  return need_yield1 | need_yield2 | need_yield3;
 }

-void I2SAudioSpeakerBase::apply_software_volume_(uint8_t *data, size_t bytes_read) {
-  if (this->q15_volume_factor_ >= INT16_MAX) {
-    return;  // Max volume, no processing needed
-  }
-
-  const size_t bytes_per_sample = this->current_stream_info_.samples_to_bytes(1);
-  const uint32_t len = bytes_read / bytes_per_sample;
-
-  // Use Q16 for samples with 1 or 2 bytes: shifted_sample * gain_factor is Q16 * Q15 -> Q31
-  int32_t shift = 15;                              // Q31 -> Q16
-  int32_t gain_factor = this->q15_volume_factor_;  // Q15
-
-  if (bytes_per_sample >= 3) {
-    // Use Q23 for samples with 3 or 4 bytes: shifted_sample * gain_factor is Q23 * Q8 -> Q31
-    shift = 8;          // Q31 -> Q23
-    gain_factor >>= 7;  // Q15 -> Q8
-  }
-
-  for (uint32_t i = 0; i < len; ++i) {
-    int32_t sample = audio::unpack_audio_sample_to_q31(&data[i * bytes_per_sample], bytes_per_sample);  // Q31
-    sample >>= shift;
-    sample *= gain_factor;  // Q31
-    audio::pack_q31_as_audio_sample(sample, &data[i * bytes_per_sample], bytes_per_sample);
-  }
+void I2SAudioSpeaker::stop_i2s_driver_() {
+  i2s_channel_disable(this->tx_handle_);
+  i2s_del_channel(this->tx_handle_);
+  this->tx_handle_ = nullptr;
+  this->parent_->unlock();
 }

-void I2SAudioSpeakerBase::swap_esp32_mono_samples_(uint8_t *data, size_t bytes_read) {
-#ifdef USE_ESP32_VARIANT_ESP32
-  // For ESP32 16-bit mono mode, adjacent samples need to be swapped.
-  if (this->current_stream_info_.get_channels() == 1 && this->current_stream_info_.get_bits_per_sample() == 16) {
-    int16_t *samples = reinterpret_cast<int16_t *>(data);
-    size_t sample_count = bytes_read / sizeof(int16_t);
-    for (size_t i = 0; i + 1 < sample_count; i += 2) {
-      int16_t tmp = samples[i];
-      samples[i] = samples[i + 1];
-      samples[i + 1] = tmp;
-    }
-  }
-#endif  // USE_ESP32_VARIANT_ESP32
-}
-
-}  // namespace esphome::i2s_audio
+}  // namespace i2s_audio
+}  // namespace esphome

 #endif  // USE_ESP32
@@ -16,34 +16,10 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/ring_buffer.h"

-namespace esphome::i2s_audio {
+namespace esphome {
+namespace i2s_audio {

-// Shared constants for I2S audio speaker implementations
-static constexpr uint32_t DMA_BUFFER_DURATION_MS = 15;
-static constexpr size_t TASK_STACK_SIZE = 4096;
-static constexpr ssize_t TASK_PRIORITY = 19;
-
-enum SpeakerEventGroupBits : uint32_t {
-  COMMAND_START = (1 << 0),            // indicates loop should start speaker task
-  COMMAND_STOP = (1 << 1),             // stops the speaker task
-  COMMAND_STOP_GRACEFULLY = (1 << 2),  // Stops the speaker task once all data has been written
-
-  TASK_STARTING = (1 << 10),
-  TASK_RUNNING = (1 << 11),
-  TASK_STOPPING = (1 << 12),
-  TASK_STOPPED = (1 << 13),
-
-  ERR_ESP_NO_MEM = (1 << 19),
-
-  WARN_DROPPED_EVENT = (1 << 20),
-
-  ALL_BITS = 0x00FFFFFF,  // All valid FreeRTOS event group bits
-};
-
-/// @brief Abstract base class for I2S audio speaker implementations.
-/// Provides shared infrastructure (event groups, ring buffer, volume control, task lifecycle)
-/// for derived I2S speaker classes.
-class I2SAudioSpeakerBase : public I2SAudioOut, public speaker::Speaker, public Component {
+class I2SAudioSpeaker : public I2SAudioOut, public speaker::Speaker, public Component {
 public:
  float get_setup_priority() const override { return esphome::setup_priority::PROCESSOR; }

@@ -54,9 +30,7 @@ class I2SAudioSpeakerBase : public I2SAudioOut, public speaker::Speaker, public
  void set_buffer_duration(uint32_t buffer_duration_ms) { this->buffer_duration_ms_ = buffer_duration_ms; }
  void set_timeout(uint32_t ms) { this->timeout_ = ms; }
  void set_dout_pin(uint8_t pin) { this->dout_pin_ = (gpio_num_t) pin; }
-
-  /// @brief Get the I2S TX channel handle
-  i2s_chan_handle_t get_tx_handle() const { return this->tx_handle_; }
+  void set_i2s_comm_fmt(std::string mode) { this->i2s_comm_fmt_ = std::move(mode); }

  void start() override;
  void stop() override;
@@ -89,55 +63,40 @@ class I2SAudioSpeakerBase : public I2SAudioOut, public speaker::Speaker, public
  void set_mute_state(bool mute_state) override;

 protected:
-  /// @brief FreeRTOS task entry point. Casts params to I2SAudioSpeakerBase and calls run_speaker_task_().
-  /// @param params I2SAudioSpeakerBase component pointer
+  /// @brief Function for the FreeRTOS task handling audio output.
+  /// Allocates space for the buffers, reads audio from the ring buffer and writes audio to the I2S port. Stops
+  /// immmiately after receiving the COMMAND_STOP signal and stops only after the ring buffer is empty after receiving
+  /// the COMMAND_STOP_GRACEFULLY signal. Stops if the ring buffer hasn't read data for more than timeout_ milliseconds.
+  /// When stopping, it deallocates the buffers. It communicates its state and any errors via ``event_group_``.
+  /// @param params I2SAudioSpeaker component
  static void speaker_task(void *params);

-  /// @brief The main speaker task loop. Implemented by derived classes for mode-specific behavior.
-  virtual void run_speaker_task() = 0;
-
  /// @brief Sends a stop command to the speaker task via ``event_group_``.
  /// @param wait_on_empty If false, sends the COMMAND_STOP signal. If true, sends the COMMAND_STOP_GRACEFULLY signal.
  void stop_(bool wait_on_empty);

-  /// @brief Callback function used to send playback timestamps to the speaker task.
+  /// @brief Callback function used to send playback timestamps the to the speaker task.
  /// @param handle (i2s_chan_handle_t)
  /// @param event (i2s_event_data_t)
  /// @param user_ctx (void*) User context pointer that the callback accesses
  /// @return True if a higher priority task was interrupted
  static bool i2s_on_sent_cb(i2s_chan_handle_t handle, i2s_event_data_t *event, void *user_ctx);

-  /// @brief Starts the ESP32 I2S driver. Implemented by derived classes for mode-specific configuration.
+  /// @brief Starts the ESP32 I2S driver.
+  /// Attempts to lock the I2S port, starts the I2S driver using the passed in stream information, and sets the data out
+  /// pin. If it fails, it will unlock the I2S port and uninstalls the driver, if necessary.
  /// @param audio_stream_info Stream information for the I2S driver.
-  /// @return ESP_OK if successful, or an error code
-  virtual esp_err_t start_i2s_driver(audio::AudioStreamInfo &audio_stream_info) = 0;
-
-  /// @brief Shared I2S channel allocation, initialization, and event queue setup.
-  /// Called by derived start_i2s_driver_() implementations after building mode-specific configs.
-  /// @param chan_cfg I2S channel configuration
-  /// @param std_cfg I2S standard mode configuration (clock, slot, GPIO)
-  /// @param event_queue_size Size of the event queue
-  /// @return ESP_OK if successful, or an error code. On failure, cleans up channel and unlocks parent.
-  esp_err_t init_i2s_channel_(const i2s_chan_config_t &chan_cfg, const i2s_std_config_t &std_cfg,
-                              size_t event_queue_size);
+  /// @return ESP_ERR_NOT_ALLOWED if the I2S port can't play the incoming audio stream.
+  ///         ESP_ERR_INVALID_STATE if the I2S port is already locked.
+  ///         ESP_ERR_INVALID_ARG if installing the driver or setting the data outpin fails due to a parameter error.
+  ///         ESP_ERR_NO_MEM if the driver fails to install due to a memory allocation error.
+  ///         ESP_FAIL if setting the data out pin fails due to an IO error
+  ///         ESP_OK if successful
+  esp_err_t start_i2s_driver_(audio::AudioStreamInfo &audio_stream_info);

  /// @brief Stops the I2S driver and unlocks the I2S port
  void stop_i2s_driver_();

-  /// @brief Called in loop() when the task has stopped. Override for mode-specific cleanup.
-  virtual void on_task_stopped() {}
-
-  /// @brief Apply software volume control using Q15 fixed-point scaling.
-  /// @param data Pointer to audio sample data (modified in place)
-  /// @param bytes_read Number of bytes of audio data
-  void apply_software_volume_(uint8_t *data, size_t bytes_read);
-
-  /// @brief Swap adjacent 16-bit mono samples for ESP32 (non-variant) hardware quirk.
-  /// Only applies when running on original ESP32 with 16-bit mono audio.
-  /// @param data Pointer to audio sample data (modified in place)
-  /// @param bytes_read Number of bytes of audio data
-  void swap_esp32_mono_samples_(uint8_t *data, size_t bytes_read);
-
  TaskHandle_t speaker_task_handle_{nullptr};
  EventGroupHandle_t event_group_{nullptr};

@@ -156,9 +115,11 @@ class I2SAudioSpeakerBase : public I2SAudioOut, public speaker::Speaker, public
  audio::AudioStreamInfo current_stream_info_;  // The currently loaded driver's stream info

  gpio_num_t dout_pin_;
-  i2s_chan_handle_t tx_handle_{nullptr};
+  std::string i2s_comm_fmt_;
+  i2s_chan_handle_t tx_handle_;
 };

-}  // namespace esphome::i2s_audio
+}  // namespace i2s_audio
+}  // namespace esphome

 #endif  // USE_ESP32
@@ -1,307 +0,0 @@
-#include "i2s_audio_speaker_standard.h"
-
-#ifdef USE_ESP32
-
-#include <driver/i2s_std.h>
-
-#include "esphome/components/audio/audio.h"
-#include "esphome/components/audio/audio_transfer_buffer.h"
-
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-
-#include "esp_timer.h"
-
-namespace esphome::i2s_audio {
-
-static const char *const TAG = "i2s_audio.speaker.std";
-
-static constexpr size_t DMA_BUFFERS_COUNT = 4;
-static constexpr size_t I2S_EVENT_QUEUE_COUNT = DMA_BUFFERS_COUNT + 1;
-
-void I2SAudioSpeaker::dump_config() {
-  I2SAudioSpeakerBase::dump_config();
-  const char *fmt_str;
-  switch (this->i2s_comm_fmt_) {
-    case I2SCommFmt::PCM:
-      fmt_str = "pcm";
-      break;
-    case I2SCommFmt::MSB:
-      fmt_str = "msb";
-      break;
-    default:
-      fmt_str = "std";
-      break;
-  }
-  ESP_LOGCONFIG(TAG, "  Communication format: %s", fmt_str);
-}
-
-void I2SAudioSpeaker::run_speaker_task() {
-  xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::TASK_STARTING);
-
-  const uint32_t dma_buffers_duration_ms = DMA_BUFFER_DURATION_MS * DMA_BUFFERS_COUNT;
-  // Ensure ring buffer duration is at least the duration of all DMA buffers
-  const uint32_t ring_buffer_duration = std::max(dma_buffers_duration_ms, this->buffer_duration_ms_);
-
-  // The DMA buffers may have more bits per sample, so calculate buffer sizes based on the input audio stream info
-  const size_t ring_buffer_size = this->current_stream_info_.ms_to_bytes(ring_buffer_duration);
-  const uint32_t frames_to_fill_single_dma_buffer = this->current_stream_info_.ms_to_frames(DMA_BUFFER_DURATION_MS);
-  const size_t bytes_to_fill_single_dma_buffer =
-      this->current_stream_info_.frames_to_bytes(frames_to_fill_single_dma_buffer);
-
-  bool successful_setup = false;
-  std::unique_ptr<audio::AudioSourceTransferBuffer> transfer_buffer =
-      audio::AudioSourceTransferBuffer::create(bytes_to_fill_single_dma_buffer);
-
-  if (transfer_buffer != nullptr) {
-    std::shared_ptr<RingBuffer> temp_ring_buffer = RingBuffer::create(ring_buffer_size);
-    if (temp_ring_buffer.use_count() == 1) {
-      transfer_buffer->set_source(temp_ring_buffer);
-      this->audio_ring_buffer_ = temp_ring_buffer;
-      successful_setup = true;
-    }
-  }
-
-  if (!successful_setup) {
-    xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_ESP_NO_MEM);
-  } else {
-    bool stop_gracefully = false;
-    bool tx_dma_underflow = true;
-
-    uint32_t frames_written = 0;
-    uint32_t last_data_received_time = millis();
-
-    xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::TASK_RUNNING);
-
-    // Main speaker task loop. Continues while:
-    // - Paused, OR
-    // - No timeout configured, OR
-    // - Timeout hasn't elapsed since last data
-    while (this->pause_state_ || !this->timeout_.has_value() ||
-           (millis() - last_data_received_time) <= this->timeout_.value()) {
-      uint32_t event_group_bits = xEventGroupGetBits(this->event_group_);
-
-      if (event_group_bits & SpeakerEventGroupBits::COMMAND_STOP) {
-        xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::COMMAND_STOP);
-        ESP_LOGV(TAG, "Exiting: COMMAND_STOP received");
-        break;
-      }
-      if (event_group_bits & SpeakerEventGroupBits::COMMAND_STOP_GRACEFULLY) {
-        xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::COMMAND_STOP_GRACEFULLY);
-        stop_gracefully = true;
-      }
-
-      if (this->audio_stream_info_ != this->current_stream_info_) {
-        // Audio stream info changed, stop the speaker task so it will restart with the proper settings.
-        ESP_LOGV(TAG, "Exiting: stream info changed");
-        break;
-      }
-
-      int64_t write_timestamp;
-      while (xQueueReceive(this->i2s_event_queue_, &write_timestamp, 0)) {
-        // Receives timing events from the I2S on_sent callback. If actual audio data was sent in this event, it passes
-        // on the timing info via the audio_output_callback.
-        uint32_t frames_sent = frames_to_fill_single_dma_buffer;
-        if (frames_to_fill_single_dma_buffer > frames_written) {
-          tx_dma_underflow = true;
-          frames_sent = frames_written;
-          const uint32_t frames_zeroed = frames_to_fill_single_dma_buffer - frames_written;
-          write_timestamp -= this->current_stream_info_.frames_to_microseconds(frames_zeroed);
-        } else {
-          tx_dma_underflow = false;
-        }
-        frames_written -= frames_sent;
-
-        // Standard I2S mode: fire callback immediately for each event
-        if (frames_sent > 0) {
-          this->audio_output_callback_(frames_sent, write_timestamp);
-        }
-      }
-
-      if (this->pause_state_) {
-        // Pause state is accessed atomically, so thread safe
-        // Delay so the task yields, then skip transferring audio data
-        vTaskDelay(pdMS_TO_TICKS(DMA_BUFFER_DURATION_MS));
-        continue;
-      }
-
-      // Wait half the duration of the data already written to the DMA buffers for new audio data
-      // The millisecond helper modifies the frames_written variable, so use the microsecond helper and divide by 1000
-      uint32_t read_delay = (this->current_stream_info_.frames_to_microseconds(frames_written) / 1000) / 2;
-
-      size_t bytes_read = transfer_buffer->transfer_data_from_source(pdMS_TO_TICKS(read_delay));
-      uint8_t *new_data = transfer_buffer->get_buffer_end() - bytes_read;
-
-      if (bytes_read > 0) {
-        this->apply_software_volume_(new_data, bytes_read);
-        this->swap_esp32_mono_samples_(new_data, bytes_read);
-      }
-
-      if (transfer_buffer->available() == 0) {
-        if (stop_gracefully && tx_dma_underflow) {
-          break;
-        }
-        vTaskDelay(pdMS_TO_TICKS(DMA_BUFFER_DURATION_MS / 2));
-      } else {
-        size_t bytes_written = 0;
-
-        if (tx_dma_underflow) {
-          // Temporarily disable channel and callback to reset the I2S driver's internal DMA buffer queue
-          i2s_channel_disable(this->tx_handle_);
-          const i2s_event_callbacks_t null_callbacks = {.on_sent = nullptr};
-          i2s_channel_register_event_callback(this->tx_handle_, &null_callbacks, this);
-          i2s_channel_preload_data(this->tx_handle_, transfer_buffer->get_buffer_start(), transfer_buffer->available(),
-                                   &bytes_written);
-        } else {
-          // Audio is already playing, use regular write to add to the DMA buffers
-          i2s_channel_write(this->tx_handle_, transfer_buffer->get_buffer_start(), transfer_buffer->available(),
-                            &bytes_written, DMA_BUFFER_DURATION_MS);
-        }
-
-        if (bytes_written > 0) {
-          last_data_received_time = millis();
-          frames_written += this->current_stream_info_.bytes_to_frames(bytes_written);
-          transfer_buffer->decrease_buffer_length(bytes_written);
-
-          if (tx_dma_underflow) {
-            tx_dma_underflow = false;
-            // Enable the on_sent callback and channel after preload
-            xQueueReset(this->i2s_event_queue_);
-            const i2s_event_callbacks_t callbacks = {.on_sent = i2s_on_sent_cb};
-            i2s_channel_register_event_callback(this->tx_handle_, &callbacks, this);
-            i2s_channel_enable(this->tx_handle_);
-          }
-        }
-      }
-    }
-  }
-
-  xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::TASK_STOPPING);
-
-  if (transfer_buffer != nullptr) {
-    transfer_buffer.reset();
-  }
-
-  xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::TASK_STOPPED);
-
-  while (true) {
-    // Continuously delay until the loop method deletes the task
-    vTaskDelay(pdMS_TO_TICKS(10));
-  }
-}
-
-esp_err_t I2SAudioSpeaker::start_i2s_driver(audio::AudioStreamInfo &audio_stream_info) {
-  this->current_stream_info_ = audio_stream_info;
-
-  if ((this->i2s_role_ & I2S_ROLE_SLAVE) && (this->sample_rate_ != audio_stream_info.get_sample_rate())) {  // NOLINT
-    // Can't reconfigure I2S bus, so the sample rate must match the configured value
-    ESP_LOGE(TAG, "Incompatible stream settings");
-    return ESP_ERR_NOT_SUPPORTED;
-  }
-
-  if (this->slot_bit_width_ != I2S_SLOT_BIT_WIDTH_AUTO &&
-      (i2s_slot_bit_width_t) audio_stream_info.get_bits_per_sample() > this->slot_bit_width_) {
-    // Currently can't handle the case when the incoming audio has more bits per sample than the configured value
-    ESP_LOGE(TAG, "Stream bits per sample must be less than or equal to the speaker's configuration");
-    return ESP_ERR_NOT_SUPPORTED;
-  }
-
-  if (!this->parent_->try_lock()) {
-    ESP_LOGE(TAG, "Parent bus is busy");
-    return ESP_ERR_INVALID_STATE;
-  }
-
-  uint32_t dma_buffer_length = audio_stream_info.ms_to_frames(DMA_BUFFER_DURATION_MS);
-
-  i2s_role_t i2s_role = this->i2s_role_;
-  i2s_clock_src_t clk_src = I2S_CLK_SRC_DEFAULT;
-
-#if SOC_CLK_APLL_SUPPORTED
-  if (this->use_apll_) {
-    clk_src = i2s_clock_src_t::I2S_CLK_SRC_APLL;
-  }
-#endif  // SOC_CLK_APLL_SUPPORTED
-
-  // Log DMA configuration for debugging
-  ESP_LOGV(TAG, "I2S DMA config: %zu buffers x %lu frames", (size_t) DMA_BUFFERS_COUNT,
-           (unsigned long) dma_buffer_length);
-
-  i2s_chan_config_t chan_cfg = {
-      .id = this->parent_->get_port(),
-      .role = i2s_role,
-      .dma_desc_num = DMA_BUFFERS_COUNT,
-      .dma_frame_num = dma_buffer_length,
-      .auto_clear = true,
-      .intr_priority = 3,
-  };
-
-  // Build standard I2S clock/slot/gpio configuration
-  i2s_std_clk_config_t clk_cfg = {
-      .sample_rate_hz = audio_stream_info.get_sample_rate(),
-      .clk_src = clk_src,
-      .mclk_multiple = this->mclk_multiple_,
-  };
-
-  i2s_slot_mode_t slot_mode = this->slot_mode_;
-  i2s_std_slot_mask_t slot_mask = this->std_slot_mask_;
-  if (audio_stream_info.get_channels() == 1) {
-    slot_mode = I2S_SLOT_MODE_MONO;
-  } else if (audio_stream_info.get_channels() == 2) {
-    slot_mode = I2S_SLOT_MODE_STEREO;
-    slot_mask = I2S_STD_SLOT_BOTH;
-  }
-
-  i2s_std_slot_config_t slot_cfg;
-  switch (this->i2s_comm_fmt_) {
-    case I2SCommFmt::PCM:
-      slot_cfg =
-          I2S_STD_PCM_SLOT_DEFAULT_CONFIG((i2s_data_bit_width_t) audio_stream_info.get_bits_per_sample(), slot_mode);
-      break;
-    case I2SCommFmt::MSB:
-      slot_cfg =
-          I2S_STD_MSB_SLOT_DEFAULT_CONFIG((i2s_data_bit_width_t) audio_stream_info.get_bits_per_sample(), slot_mode);
-      break;
-    default:
-      slot_cfg = I2S_STD_PHILIPS_SLOT_DEFAULT_CONFIG((i2s_data_bit_width_t) audio_stream_info.get_bits_per_sample(),
-                                                     slot_mode);
-      break;
-  }
-
-#ifdef USE_ESP32_VARIANT_ESP32
-  // There seems to be a bug on the ESP32 (non-variant) platform where setting the slot bit width higher than the
-  // bits per sample causes the audio to play too fast. Setting the ws_width to the configured slot bit width seems
-  // to make it play at the correct speed while sending more bits per slot.
-  if (this->slot_bit_width_ != I2S_SLOT_BIT_WIDTH_AUTO) {
-    uint32_t configured_bit_width = static_cast<uint32_t>(this->slot_bit_width_);
-    slot_cfg.ws_width = configured_bit_width;
-    if (configured_bit_width > 16) {
-      slot_cfg.msb_right = false;
-    }
-  }
-#else
-  slot_cfg.slot_bit_width = this->slot_bit_width_;
-#endif  // USE_ESP32_VARIANT_ESP32
-  slot_cfg.slot_mask = slot_mask;
-
-  i2s_std_gpio_config_t gpio_cfg = this->parent_->get_pin_config();
-  gpio_cfg.dout = this->dout_pin_;
-
-  i2s_std_config_t std_cfg = {
-      .clk_cfg = clk_cfg,
-      .slot_cfg = slot_cfg,
-      .gpio_cfg = gpio_cfg,
-  };
-
-  esp_err_t err = this->init_i2s_channel_(chan_cfg, std_cfg, I2S_EVENT_QUEUE_COUNT);
-  if (err != ESP_OK) {
-    return err;
-  }
-
-  i2s_channel_enable(this->tx_handle_);
-
-  return ESP_OK;
-}
-
-}  // namespace esphome::i2s_audio
-
-#endif  // USE_ESP32
@@ -1,32 +0,0 @@
-#pragma once
-
-#ifdef USE_ESP32
-
-#include "i2s_audio_speaker.h"
-
-namespace esphome::i2s_audio {
-
-enum class I2SCommFmt : uint8_t {
-  STANDARD,  // Philips / I2S standard
-  PCM,       // PCM short
-  MSB,       // MSB / left-justified
-};
-
-/// @brief Standard I2S speaker implementation.
-/// Outputs PCM audio data directly to an I2S DAC using the standard I2S protocol.
-class I2SAudioSpeaker : public I2SAudioSpeakerBase {
- public:
-  void dump_config() override;
-
-  void set_i2s_comm_fmt(I2SCommFmt fmt) { this->i2s_comm_fmt_ = fmt; }
-
- protected:
-  void run_speaker_task() override;
-  esp_err_t start_i2s_driver(audio::AudioStreamInfo &audio_stream_info) override;
-
-  I2SCommFmt i2s_comm_fmt_{I2SCommFmt::STANDARD};
-};
-
-}  // namespace esphome::i2s_audio
-
-#endif  // USE_ESP32
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
J. Nick Koston	0fbc4e85be	Address review: reference WDT_FEED_INTERVAL_MS in slow-path comment	2026-04-14 08:13:06 -10:00
J. Nick Koston	3af7e9a0db	Merge remote-tracking branch 'upstream/dev' into pr-15656 # Conflicts: # esphome/core/application.cpp # esphome/core/application.h	2026-04-14 08:12:21 -10:00
J. Nick Koston	5926ca5369	[core] Split feed_wdt into hot and cold entries Separate Application::feed_wdt() into two entry points so the hot path callers stop paying for the time==0 check they never trigger: - feed_wdt_with_time(time): inline, hot path. Rate-limit check in 3 Xtensa instructions (load + sub + branch). [[unlikely]] tells the compiler the slow branch is rare so the common path stays fall-through. - feed_wdt(): cold, out of line. Fetches millis() and forwards through the same rate limit. Used by setup loops, upload helpers, yield(), and any other non-hot caller. feed_wdt_slow_() is now pure worker code — 11 bytes. It just calls arch_feed_wdt(), updates last_wdt_feed_, and runs the status LED re-dispatch. Both entries have already confirmed the rate limit was exceeded before calling. Hot call sites updated: - Application::loop() per-component feed - Scheduler::execute_item_() after each scheduled item runs - Application::teardown_components() inner loop (already has 'now')	2026-04-11 15:19:35 -10:00
J. Nick Koston	dc5626eb85	[core] Invert feed_wdt condition so slow-path call is inside the if Cleaner than the early-return form — the action (calling feed_wdt_slow_) reads as the body of the conditional instead of falling through past a guard clause. Logically identical and compiles to the same code.	2026-04-11 14:57:01 -10:00
J. Nick Koston	715f0ca6f7	[core] Extract WDT_FEED_INTERVAL_MS constexpr Replace the magic 3 in both the inline feed_wdt check and the slow path with a named constexpr so the rate-limit threshold is defined once.	2026-04-11 14:54:02 -10:00
J. Nick Koston	a70ec9ec06	[scheduler] Feed watchdog after each scheduled item, drop top-of-loop feed The main loop used to feed the watchdog unconditionally right after Scheduler::call() returned, regardless of whether the scheduler had any actual work to do. On an idle device this meant every outer loop iteration paid the inline rate-limit check (load + sub + branch) for no benefit. Move the feed into Scheduler::execute_item_() so it fires only after a scheduled callback actually runs, and covers both the main heap path and the defer queue path (both go through execute_item_). This also bounds the max feed gap during a burst of back-to-back scheduled items by max(item_runtime) instead of sum(item_runtime). The top-of-loop feed in Application::before_loop_tasks_() is now unnecessary — when Scheduler::call does no work, the only elapsed time is the sleep wake plus a few instructions, and when it does have work, it fed the wdt as it went.	2026-04-11 14:51:59 -10:00
J. Nick Koston	ddbf6f2347	[core] Inline feed_wdt hot path with out-of-line slow path Split Application::feed_wdt() into an ALWAYS_INLINE wrapper that checks the 3ms rate limit against last_wdt_feed_ and a feed_wdt_slow_() callee that performs the actual arch_feed_wdt() + status LED re-dispatch. Callers on the hot path (loop_task before/after each component) that already have a millis() timestamp in hand now pay only a load + sub + branch on the no-op path instead of a full call8 / entry / retw. Moves the rate-limit state from a function-local static to a class member (last_wdt_feed_) so the inline can access it.	2026-04-11 14:32:49 -10:00