[factory_reset] Use a user provided default constructor for FactoryResetSwitch

2026-10-14 18:22:48 +00:00 · 2026-09-12 05:35:39 -05:00
708 changed files with 8180 additions and 15696 deletions
@@ -1,116 +0,0 @@
---
-name: code-review
-description: Review guidance for ESPHome pull requests. Use this when reviewing a pull request that changes ESPHome Python, C++, or component code, to check it against the project's coding conventions, embedded-systems memory rules, testing requirements, and breaking-change policy.
---
-
-# Reviewing ESPHome pull requests
-
-ESPHome parses YAML into C++ firmware for memory-constrained microcontrollers
-(ESP32, ESP8266, RP2040, LibreTiny). Review changes with that in mind: RAM and
-flash are scarce, and code runs unattended for months.
-
-`AGENTS.md` in the repository root is the full contributor guide and the
-authority when it disagrees with this summary. The developer documentation at
-https://developers.esphome.io explains the component lifecycle and the reasoning
-behind these rules. This skill lists the concrete things worth flagging in a
-review; read `AGENTS.md` for the detail behind any item.
-
-Only raise findings that the diff actually introduces or changes. Do not ask for
-drive-by cleanup of pre-existing code the PR did not touch.
-
-## Memory and embedded constraints (highest value)
-
-Heap allocation after `setup()` is treated as a reliability bug, not a
-performance nit, because it fragments a small shared heap. Flag:
-
- New heap allocation on a hot path or after setup that could be avoided.
- `std::vector` where the size is known at compile time (use `std::array`, or
-  `StaticVector<T, N>` when a `push_back` API is needed) or fixed at runtime
-  init (use `FixedVector<T>`).
- Listener / child-entity registration lists stored as `std::vector`; these have
-  a compile-time-known count and should use `cg.slot_counter()` plus
-  `StaticVector`.
- `std::vector<uint8_t>` for a byte buffer that never grows: prefer
-  `std::unique_ptr<uint8_t[]>` or `std::array`.
- `std::map` / `std::set` / `std::unordered_map` for small datasets (1-16
-  elements): a `std::vector` of a small struct with linear search is lighter.
- `std::deque` anywhere: it allocates 512-byte blocks and should be avoided.
- `std::string` storing a value set once from config: prefer `StringRef` (the
-  literal already lives in flash).
- `std::string` / `std::to_string` / string-returning helpers on hot paths where
-  a buffer or view API exists.
-
-## C++ conventions
-
- Include what you use: a file referencing a symbol must include the header that
-  declares it, even if it currently arrives transitively. New or changed uses of
-  a symbol need the matching include.
- Prefix all member access with `this->`.
- Naming: `lower_snake_case` for functions/methods/variables, `UpperCamelCase`
-  for classes/structs/enums, `UPPER_SNAKE_CASE` for namespace-scope constants,
-  trailing underscore on protected/private fields.
- `enum class` values must be prefixed with the enum name in `UPPER_SNAKE_CASE`
-  (e.g. `UARTFlushResult::UART_FLUSH_RESULT_SUCCESS`). Bare names like `SUCCESS`,
-  `FAIL`, or `OK` collide with SDK macros on some platforms and break the build.
- Prefer `const`/`enum` over `#define`; `#define` is only for conditional
-  compilation and code-generation sizes.
- Never call `millis()` in a `loop()` body; use
-  `App.get_loop_component_start_time()`. A rate-limit gate below ~16 ms (the loop
-  period) does nothing.
- Pick the timing primitive by cadence: gated `loop()` under 250 ms,
-  `set_interval` at 500 ms and above.
- Do not override a base method to return the value it already returns (e.g.
-  `get_setup_priority()` returning `setup_priority::DATA`).
- Wrap string literals passed as printf `%s` args in `LOG_STR_LITERAL()`.
- Required, invariant dependencies should be constructor parameters, not setters.
- Callback registration methods must be templated (`template<typename F>`), not
-  typed as `std::function`, so lightweight forwarders avoid a heap allocation.
- Two-space indent, `using` over `typedef`, wrap at 120 columns.
-
-## Python conventions
-
- Type-annotate every new function signature (params and return), new dataclass
-  fields, and new module-level variables. Import `ConfigType` from
-  `esphome.types`.
- Use the walrus operator to avoid a double lookup, e.g.
-  `if (blah := config.get(CONF_BLAH)) is not None:`.
- Reuse existing validators from `config_validation.py` (`cv.rename_key`,
-  `cv.has_exactly_one_key`, etc.) via `cv.All(...)` instead of hand-rolling.
- `esphome/const.py` is frozen: no new `CONF_` constants there. Define them in
-  the component's own `.py`, or in `esphome/components/const/__init__.py` when
-  shared. The same constant defined in three or more component files fails CI.
- State that must persist during code generation goes in `CORE.data` namespaced
-  under the component `DOMAIN` (a `@dataclass`), not module-level mutable globals.
- Prefer callback-based triggers via `build_callback_automation()`; only use a
-  `Trigger<Ts...>` subclass when the forwarder needs mutable state.
-
-## Testing and coverage
-
- New and changed lines and branches need test coverage, including defensive
-  early-returns, error paths, and no-op guards. A mocked-out function is not
-  covered; exercise the real call path too.
- Component YAML tests live in `tests/components/<component>/`. Never define
-  buses (uart, i2c, spi, modbus) directly in a test file: pull them from
-  `tests/test_build_components/common/` through dict-style `packages:` so CI can
-  group builds. List-style packages or top-level merge keys block grouping.
- Config-only checks use the `validate.*.yaml` prefix; compiled checks use
-  `test.*.yaml`.
-
-## Breaking changes and public API
-
- Base classes under `esphome/core/` and documented config options are public
-  API. Undocumented `public` members of a component are internal.
- A breaking change needs justification, a migration path in the PR description,
-  and a deprecation window where feasible (`ESPDEPRECATED` in C++,
-  `cv.rename_key(..., removed_in=...)` in Python). Changing a codegen-injected
-  lambda signature is not a breaking change.
-
-## Process and PR hygiene
-
- PR titles start with a `[tag]` prefix: the component name (e.g. `[uart] ...`)
-  or `[core]` for shared code.
- Prose in docs, comments, and commit messages should be plain English. Keep
-  inline comments short and only where the code is not self-explanatory; do not
-  restate what the code says.
- Verify the PR fills out `.github/PULL_REQUEST_TEMPLATE.md` and adds
-  `CODEOWNERS` entries for a new component.
@@ -1 +0,0 @@
-../.agents/skills
@@ -31,4 +31,7 @@ RUN \
    platformio settings set enable_telemetry No \
    && platformio settings set check_platformio_interval 1000000

+COPY script/platformio_install_deps.py platformio.ini ./
+RUN ./platformio_install_deps.py platformio.ini --libraries --platforms --tools
+
 WORKDIR /workspaces
@@ -9,29 +9,6 @@ body:
        If you have a feature request or enhancement, please [request them here instead][fr].

        [fr]: https://github.com/orgs/esphome/discussions
-  - type: markdown
-    attributes:
-      value: |
-        ## Use of AI in bug reports
-
-        AI tools are good at carrying out well-defined tasks, but they are not good at troubleshooting.
-        Please do NOT paste an AI-generated wall of text into the issue template - if the AI hasn't solved
-        your problem, its wild guesses are not likely to help.
-
-        Please DO include your own words and observations, compile/boot logs, and
-        especially a minimal reproducible example of your YAML configuration that demonstrates the problem.
-
-        It is however quite acceptable to use AI to translate your *own* report,
-        if you aren't a competent English speaker.
-
-        If you really think it will be useful to include an AI's analysis, preferably wrap it in a `<details>` block which will be collapsed by default.
-
-        If you are using AI to help solve a problem, rather than asking it to speculate about what the problem is,
-        it can be more useful to ask it to create a step-by-step troubleshooting procedure.
-        AI is also useful for generating boilerplate code, such as a minimal reproducible example of your YAML
-        configuration that demonstrates the problem.
-
-        Used properly, AI can be a useful tool to help you solve your problem, but don't let it get in the way.
  - type: textarea
    validations:
      required: true
@@ -42,7 +42,7 @@ runs:

    - name: Build and push to ghcr by digest
      id: build-ghcr
-      uses: docker/build-push-action@c3c9e263c25d99ce0380d002d59b67737d91b0dc # v7.4.0
+      uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7.3.0
      env:
        DOCKER_BUILD_SUMMARY: false
        DOCKER_BUILD_RECORD_UPLOAD: false
@@ -67,7 +67,7 @@ runs:

    - name: Build and push to dockerhub by digest
      id: build-dockerhub
-      uses: docker/build-push-action@c3c9e263c25d99ce0380d002d59b67737d91b0dc # v7.4.0
+      uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7.3.0
      env:
        DOCKER_BUILD_SUMMARY: false
        DOCKER_BUILD_RECORD_UPLOAD: false
@@ -32,7 +32,7 @@ runs:
      # detects the activated venv via ``VIRTUAL_ENV`` so the venv layout
      # downstream jobs rely on is preserved.
      if: steps.cache-venv.outputs.cache-hit != 'true'
-      uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+      uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
      with:
        enable-cache: true
        # Pull request saves land in per-PR scopes nothing else can
@@ -1 +0,0 @@
-../.agents/skills
@@ -29,7 +29,7 @@ jobs:
      - name: Set up uv
        # ``--system`` (below) installs into the setup-python interpreter;
        # no venv is created or restored by this workflow.
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pull-request-only workflow: a save could never be shared and
@@ -12,7 +12,9 @@ on:
      - ".github/workflows/ci-docker.yml"
      - "requirements*.txt"
      - "pyproject.toml"
+      - "platformio.ini"
      - "esphome/idf_component.yml"
+      - "script/platformio_install_deps.py"
      # Core, build pipeline, toolchain, and target-platform changes can change
      # how a toolchain is set up or built, so re-run the per-toolchain compile
      # smoke test when they change.
@@ -65,7 +67,7 @@ jobs:
        with:
          python-version: "3.12"
      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
+        uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e # v4.3.0

      - name: Determine tag and whether to push
        id: tag
@@ -157,7 +159,7 @@ jobs:
        with:
          python-version: "3.12"
      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
+        uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e # v4.3.0

      - name: Log in to the GitHub container registry
        uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0
@@ -49,7 +49,7 @@ jobs:
        # detects the activated venv via ``VIRTUAL_ENV`` so downstream jobs
        # that ``. venv/bin/activate`` see an identical layout.
        if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -321,7 +321,7 @@ jobs:
          . venv/bin/activate
          pytest -vv --cov-report=xml --tb=native --durations=30 -n auto tests --ignore=tests/integration/
      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@303a32d7a59b442fa8d48b6a1cc6825c09c847a5 # v7.1.1
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
      - name: Save Python virtual environment cache
        if: github.ref == 'refs/heads/dev'
        uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
@@ -350,7 +350,7 @@ jobs:
      - name: Check out code from GitHub
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
      - name: Report empty upload to Codecov
-        uses: codecov/codecov-action@303a32d7a59b442fa8d48b6a1cc6825c09c847a5 # v7.1.1
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
        with:
          run_command: empty-upload
          force: true
@@ -413,7 +413,7 @@ jobs:
      - name: Set up uv
        # Only needed on cache miss to populate the venv.
        if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -1274,7 +1274,7 @@ jobs:
        # install step (order-of-magnitude faster on cold boots,
        # with its own wheel cache). actions/setup-python still
        # provides the interpreter.
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -56,7 +56,7 @@ jobs:

      # Initializes the CodeQL tools for scanning.
      - name: Initialize CodeQL
-        uses: github/codeql-action/init@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+        uses: github/codeql-action/init@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
        with:
          languages: ${{ matrix.language }}
          build-mode: ${{ matrix.build-mode }}
@@ -84,6 +84,6 @@ jobs:
          exit 1

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+        uses: github/codeql-action/analyze@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
        with:
          category: "/language:${{matrix.language}}"
@@ -14,4 +14,4 @@ jobs:
    permissions:
      issues: write         # issues.lock on closed issues
      pull-requests: write  # issues.lock on closed pull requests
-    uses: esphome/workflows/.github/workflows/lock.yml@cc3e76de337dc59bc1cba8da58d963cd23b873f1  # 2026.9.0
+    uses: esphome/workflows/.github/workflows/lock.yml@0fdd5e311b7e744069166696072a1a9cbc5fbeb6  # 2026.8.1
@@ -123,7 +123,7 @@ jobs:
          python-version: "3.12"

      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
+        uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e # v4.3.0

      - name: Log in to docker hub
        uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0
@@ -202,7 +202,7 @@ jobs:
          merge-multiple: true

      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
+        uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e # v4.3.0

      - name: Log in to docker hub
        if: matrix.registry == 'dockerhub'
@@ -16,7 +16,7 @@ jobs:
    # No GITHUB_TOKEN permissions: the reusable workflow mints an ESPHome
    # GitHub App token so the labels, comments and closures come from
    # esphome[bot] instead of github-actions[bot].
-    uses: esphome/workflows/.github/workflows/stale.yml@cc3e76de337dc59bc1cba8da58d963cd23b873f1  # main
+    uses: esphome/workflows/.github/workflows/stale.yml@a1c1485ab46ef41a84a6a9d8abd7fa4b7628fd70  # main
    secrets:
      ESPHOME_GITHUB_APP_PRIVATE_KEY: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
    with:
@@ -47,7 +47,7 @@ jobs:
        # setup-python interpreter so subsequent ``prek`` /
        # ``script/run-in-env.py`` steps find the deps without a
        # ``uv run`` prefix.
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pin uv version so the action does not have to fetch the
@@ -10,7 +10,7 @@ ci:
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    # Ruff version.
-    rev: v0.16.8
+    rev: v0.16.6
    hooks:
      # Run the linter.
      - id: ruff
@@ -431,31 +431,7 @@ file does, and it is the authority when they disagree. The most useful starting
          MyComponent *parent_;
        };
        ```
-        Register it without writing a builder:
-        ```python
-        automation.register_simple_action(
-            "my_component.do_something", MyAction, schema, synchronous=True
-        )
-        ```
-        The constructor receives the object named by `config[CONF_ID]`. Use `register_bare_action` for a
-        no-argument constructor, `register_parented_action` for a class deriving from `Parented<T>`, and
-        the `@automation.register_action(...)` decorator only when the builder must also set fields.
-
-        Use `synchronous=True` for actions that run to completion inside `play()` without deferring. Use `synchronous=False` if the action may suspend/defer execution (e.g. `delay`, `wait_until`, `script.wait`) or store trigger arguments for later use.
-
-        **Actions that only forward templatable values to their parent need no C++ class.** Register them
-        with `register_apply_action`; do not write a `TEMPLATABLE_VALUE` class or a builder for this shape.
-        ```python
-        automation.register_apply_action(
-            "my_component.set_gains",
-            schema,
-            automation.ApplyField(CONF_KP, "set_kp", cg.float_),
-            automation.ApplyField(CONF_KI, "set_ki", cg.float_),
-        )
-        ```
-        The `ApplyField`, `ApplyCall` and `register_apply_action` docstrings in `esphome/automation.py` cover
-        the rest; `cover.control` and `cover.template.publish` are in-tree examples. `TEMPLATABLE_VALUE` with
-        `cg.templatable` stays for actions whose `play()` has real logic beyond forwarding values.
+        Register with `@automation.register_action("my_component.do_something", MyAction, schema, synchronous=True)`. Use `synchronous=True` for actions that run to completion inside `play()` without deferring. Use `synchronous=False` if the action may suspend/defer execution (e.g. `delay`, `wait_until`, `script.wait`) or store trigger arguments for later use.

    *   **Conditions:**
        ```cpp
@@ -467,21 +443,7 @@ file does, and it is the authority when they disagree. The most useful starting
          MyComponent *parent_;
        };
        ```
-        Register with `automation.register_simple_condition("my_component.is_active", MyCondition, schema)`;
-        `register_bare_condition`, `register_parented_condition` and the decorator follow the action rules.
-
-        **Conditions that only test their parent need no C++ class either.** Register them with
-        `register_apply_condition`; the expression is applied to the parent, and an `ApplyCall` compares
-        against config values.
-        ```python
-        automation.register_apply_condition("my_component.is_active", schema, "is_active()")
-        automation.register_apply_condition(
-            "my_component.state_is",
-            schema,
-            automation.ApplyCall("state == {}", ((CONF_STATE, cg.bool_),)),
-        )
-        ```
-        `cover.is_open`, `rtttl.is_playing` and `component.is_idle` are in-tree examples.
+        Register with `@automation.register_condition("my_component.is_active", MyCondition, schema)`.

 *   **Type Hints:** Type-hint all function signatures, including test functions and config validators (e.g. `def validate_x(config: ConfigType) -> ConfigType:`, `def test_x() -> None:`). Import `ConfigType` from `esphome.types`.

@@ -182,6 +182,7 @@ esphome/components/esp32_camera_web_server/* @ayufan
 esphome/components/esp32_can/* @Sympatron
 esphome/components/esp32_hosted/* @swoboda1337
 esphome/components/esp32_hosted/update/* @swoboda1337
+esphome/components/esp32_improv/* @jesserockz
 esphome/components/esp32_rmt/* @jesserockz
 esphome/components/esp32_rmt_led_strip/* @jesserockz
 esphome/components/esp8266/* @esphome/core
@@ -265,10 +266,8 @@ esphome/components/i2s_audio/* @jesserockz
 esphome/components/i2s_audio/microphone/* @jesserockz
 esphome/components/i2s_audio/speaker/* @jesserockz @kahrendt
 esphome/components/iaqcore/* @yozik04
-esphome/components/icnt86/* @danepowell
 esphome/components/ili9xxx/* @clydebarrow @nielsnl68
 esphome/components/improv_base/* @esphome/core
-esphome/components/improv_ble/* @jesserockz
 esphome/components/improv_serial/* @esphome/core
 esphome/components/ina226/* @latonita @Sergio303
 esphome/components/ina260/* @mreditor97
@@ -457,7 +456,6 @@ esphome/components/rtl87xx/* @kuba2k2
 esphome/components/rtttl/* @glmnet @ximex
 esphome/components/runtime_image/* @clydebarrow @guillempages @kahrendt
 esphome/components/runtime_stats/* @bdraco
-esphome/components/rx8025t/* @remcom
 esphome/components/rx8130/* @beormund
 esphome/components/safe_mode/* @jsuanet @kbx81 @paulmonigatti
 esphome/components/scd4x/* @martgras @sjtrny
@@ -479,7 +477,6 @@ esphome/components/sendspin/image/* @kahrendt
 esphome/components/sendspin/media_player/* @kahrendt
 esphome/components/sendspin/media_source/* @kahrendt
 esphome/components/sendspin/sensor/* @kahrendt
-esphome/components/sendspin/switch/* @kahrendt
 esphome/components/sendspin/text_sensor/* @kahrendt
 esphome/components/sensirion_common/* @martgras
 esphome/components/sensor/* @esphome/core
@@ -592,7 +589,6 @@ esphome/components/uart/* @esphome/core
 esphome/components/uart/button/* @ssieb
 esphome/components/uart/event/* @eoasmxd
 esphome/components/uart/packet_transport/* @clydebarrow
-esphome/components/uart_mux/* @kbx81
 esphome/components/udp/* @clydebarrow
 esphome/components/ufire_ec/* @pvizeli
 esphome/components/ufire_ise/* @pvizeli
@@ -22,13 +22,16 @@ RUN \
    -r /requirements.txt

 # Install the ESPHome Device Builder dashboard.
-RUN uv pip install --no-cache-dir esphome-device-builder==1.15.0
+RUN uv pip install --no-cache-dir esphome-device-builder==1.14.7

 RUN \
    platformio settings set enable_telemetry No \
    && platformio settings set check_platformio_interval 1000000 \
    && mkdir -p /piolibs

+COPY script/platformio_install_deps.py platformio.ini /
+RUN /platformio_install_deps.py /platformio.ini --libraries
+
 ARG BUILD_VERSION

 LABEL \
@@ -5,15 +5,3 @@ bk72xx:
  board: generic-bk7231n-qfn32-tuya

 logger:
-
-wifi:
-  ssid: MySSID
-  password: password1
-  ap:
-
-# mqtt and captive_portal together pull in AsyncTCP and ESPAsyncWebServer;
-# a stray ESP32 AsyncTCP copy on the library search path breaks this build
-captive_portal:
-
-mqtt:
-  broker: 192.168.178.84
@@ -1,8 +1,5 @@
-from collections.abc import Callable
 from dataclasses import dataclass, field
 import logging
-import string
-from typing import Any

 import esphome.codegen as cg
 import esphome.config_validation as cv
@@ -21,17 +18,15 @@ from esphome.const import (
    CONF_TYPE_ID,
    CONF_UPDATE_INTERVAL,
 )
-from esphome.core import CORE, ID, EsphomeError, Lambda
+from esphome.core import ID, Lambda
 from esphome.cpp_generator import (
-    FlashStringLiteral,
    LambdaExpression,
    MockObj,
    MockObjClass,
    TemplateArgsType,
-    call_lambda,
 )
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
-from esphome.types import ConfigType, SafeExpType
+from esphome.types import ConfigType
 from esphome.util import Registry


@@ -62,7 +57,6 @@ def maybe_conf(conf, *validators):
        with cv.remove_prepend_path([conf]):
            return validator({conf: value})

-    validate.inner_schema = validator
    return validate


@@ -108,101 +102,6 @@ def register_condition(name: str, condition_type: MockObjClass, schema: cv.Schem
    return CONDITION_REGISTRY.register(name, condition_type, schema)


-async def _build_with_parent(
-    config: ConfigType,
-    automation_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    parent = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(automation_id, template_arg, parent)
-
-
-async def _build_without_parent(
-    config: ConfigType,
-    automation_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    return cg.new_Pvariable(automation_id, template_arg)
-
-
-async def _build_parented(
-    config: ConfigType,
-    automation_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(automation_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
-
-
-def register_simple_action(
-    name: str,
-    action_type: MockObjClass,
-    schema: cv.Schema,
-    *,
-    synchronous: bool,
-) -> None:
-    """Register an action whose constructor takes the object named by ``config[CONF_ID]``.
-
-    Use the ``register_action`` decorator instead when the builder must also set fields.
-    """
-    register_action(name, action_type, schema, synchronous=synchronous)(
-        _build_with_parent
-    )
-
-
-def register_simple_condition(
-    name: str, condition_type: MockObjClass, schema: cv.Schema
-) -> None:
-    """Condition counterpart of ``register_simple_action``."""
-    register_condition(name, condition_type, schema)(_build_with_parent)
-
-
-def register_bare_action(
-    name: str,
-    action_type: MockObjClass,
-    schema: cv.Schema,
-    *,
-    synchronous: bool,
-) -> None:
-    """Register an action whose constructor takes no arguments."""
-    register_action(name, action_type, schema, synchronous=synchronous)(
-        _build_without_parent
-    )
-
-
-def register_bare_condition(
-    name: str, condition_type: MockObjClass, schema: cv.Schema
-) -> None:
-    """Condition counterpart of ``register_bare_action``."""
-    register_condition(name, condition_type, schema)(_build_without_parent)
-
-
-def register_parented_action(
-    name: str,
-    action_type: MockObjClass,
-    schema: cv.Schema,
-    *,
-    synchronous: bool,
-) -> None:
-    """Register an action deriving from ``Parented<T>``.
-
-    The object is constructed without arguments and ``set_parent()`` receives the object
-    named by ``config[CONF_ID]``.
-    """
-    register_action(name, action_type, schema, synchronous=synchronous)(_build_parented)
-
-
-def register_parented_condition(
-    name: str, condition_type: MockObjClass, schema: cv.Schema
-) -> None:
-    """Condition counterpart of ``register_parented_action``."""
-    register_condition(name, condition_type, schema)(_build_parented)
-
-
 Action = cg.esphome_ns.class_("Action")
 Trigger = cg.esphome_ns.class_("Trigger")
 ACTION_REGISTRY = Registry()
@@ -213,278 +112,6 @@ validate_action_list = cv.validate_registry("action", ACTION_REGISTRY)
 validate_condition = cv.validate_registry_entry("condition", CONDITION_REGISTRY)
 validate_condition_list = cv.validate_registry("condition", CONDITION_REGISTRY)

-ApplyAction = cg.esphome_ns.class_("ApplyAction", Action)
-ApplyCondition = cg.esphome_ns.class_("ApplyCondition", Condition)
-
-
-def flash_string(config: ConfigType, value: str) -> str:
-    """Default renderer for ``std::string`` constants; copies the literal out of flash on ESP8266."""
-    if CORE.is_esp8266:
-        return f"progmem_string({FlashStringLiteral(value)})"
-    return str(cg.safe_exp(value))
-
-
-@dataclass(frozen=True)
-class ApplyCall:
-    """One statement from config keys, e.g. ``"set_range({}, {})"`` with ``((CONF_LOW, cg.float_), ...)``.
-
-    Each arg is ``(conf_key, type_)`` or ``(conf_key, type_, const_fn)``. A ``conf_key`` may be a
-    path into nested sections. A plain ``str`` ``type_`` is raw C++ type text and may use
-    ``{parent}``. ``const_fn(config, value)`` renders a constant's argument text; a lambda bypasses
-    it. The statement is skipped when none of its keys is set, always emitted when it has no
-    keys, and a partial set is a config error.
-    """
-
-    target: str
-    args: tuple[tuple[Any, ...], ...] = ()
-
-    def __post_init__(self) -> None:
-        fields = [
-            f for _, f, _, _ in string.Formatter().parse(self.target) if f is not None
-        ]
-        if any(fields):
-            raise ValueError(
-                f"apply target {self.target!r}: only bare {{}} placeholders"
-            )
-        if len(fields) != len(self.args):
-            raise ValueError(
-                f"apply target {self.target!r} has {len(fields)} "
-                f"placeholder(s) for {len(self.args)} config key(s)"
-            )
-        if any(len(arg) not in (2, 3) for arg in self.args):
-            raise ValueError(
-                f"apply target {self.target!r}: each arg is (conf_key, type_[, const_fn])"
-            )
-
-    @property
-    def members(self) -> list[tuple[Any, Any, Any]]:
-        """Each arg as ``(conf_key, type_, const_fn or None)``."""
-        return [
-            (arg[0], arg[1], arg[2] if len(arg) == 3 else None) for arg in self.args
-        ]
-
-
-@dataclass(frozen=True)
-class ApplyField:
-    """One config key forwarded as ``target(value)``, or as statement ``target`` when it has ``{}``.
-
-    Double a literal brace in a template. ``conf_key`` may be a path into nested sections.
-    ``type_`` may be a C++ type string using ``{parent}`` when the type is only known per
-    instance. ``const_fn(config, value)`` renders a constant's argument text when ``cg.safe_exp``
-    is not the right spelling (unit conversion belongs in the validator); a lambda bypasses it,
-    so the target must also take a plain ``type_``. An absent key emits nothing.
-    """
-
-    conf_key: str | tuple[str, ...]
-    target: str
-    type_: SafeExpType
-    const_fn: Callable[[ConfigType, Any], str] | None = None
-
-    def call(self) -> ApplyCall:
-        target = self.target if "{}" in self.target else f"{self.target}({{}})"
-        return ApplyCall(target, ((self.conf_key, self.type_, self.const_fn),))
-
-
-def _config_lookup(config: ConfigType, key: str | tuple[str, ...]) -> Any:
-    if isinstance(key, str):
-        return config.get(key)
-    for part in key:
-        if (config := config.get(part)) is None:
-            return None
-    return config
-
-
-def _dict_schema(schema: Any) -> Any:
-    """The dict-backed cv.Schema inside cv.All and maybe_* wrappers, or None; cv.Any is not inspected."""
-    if isinstance(schema, dict):
-        return cv.Schema(schema)
-    if isinstance(getattr(schema, "schema", None), dict):
-        return schema
-    if isinstance(schema, cv.All):
-        inner = schema.validators
-    else:
-        inner = (
-            getattr(schema, "inner_schema", None),
-        )  # maybe_conf / maybe_simple_value
-    for candidate in inner:
-        if candidate is not None and (found := _dict_schema(candidate)) is not None:
-            return found
-    return None
-
-
-def _check_key_in_schema(
-    name: str, schema: Any, conf_key: str | tuple[str, ...]
-) -> None:
-    """Reject a key path the schema does not have; a typo would otherwise be a silent no-op.
-
-    Only dict-backed schemas, also inside cv.All and maybe_* wrappers, can be checked.
-    """
-    for part in (conf_key,) if isinstance(conf_key, str) else conf_key:
-        if (schema := _dict_schema(schema)) is None:
-            return
-        markers = {
-            getattr(marker, "schema", marker): marker for marker in schema.schema
-        }
-        if part not in markers:
-            raise ValueError(f"{name}: config key {part!r} is not in the schema")
-        schema = schema.schema[markers[part]]
-
-
-async def _apply_parent(config: ConfigType) -> str:
-    # Global-scope qualified so a trigger arg named like the id cannot shadow it.
-    return f"::{await cg.get_variable(config[CONF_ID])}"
-
-
-def _apply_lambda_args(args: TemplateArgsType) -> TemplateArgsType:
-    # Must match ApplyAction::ApplyFn and ApplyCondition::CheckFn exactly for the function
-    # pointer conversion.
-    return [
-        (cg.RawExpression(f"const std::remove_cvref_t<{cg.safe_exp(t)}> &"), arg)
-        for t, arg in args
-    ]
-
-
-async def _render_values(
-    name: str,
-    target: str,
-    members: list[tuple[Any, Any, Any]],
-    values: list[Any],
-    config: ConfigType,
-    parent: str,
-    lambda_args: TemplateArgsType,
-    compare: bool = False,
-) -> list[str]:
-    """Render the argument text of one statement; every key must be present.
-
-    ``compare``: an inlined lambda expression is parenthesized so it binds as a whole
-    beside an operator.
-    """
-    if any(value is None for value in values):
-        keys = [key for key, _, _ in members]
-        raise EsphomeError(f"{name}: {target!r} needs all of {keys}")
-    exprs: list[str] = []
-    for (_, type_, const_fn), value in zip(members, values, strict=True):
-        if isinstance(value, Lambda):
-            if isinstance(type_, str):
-                type_ = cg.RawExpression(type_.format(parent=parent))
-            inner = await cg.process_lambda(value, lambda_args, return_type=type_)
-            expr = call_lambda(inner)
-            bare = compare and isinstance(expr, cg.RawExpression)
-            exprs.append(f"({expr})" if bare else str(expr))
-        elif const_fn is not None:
-            exprs.append(const_fn(config, value))
-        else:
-            exprs.append(str(cg.safe_exp(value)))
-    return exprs
-
-
-def _apply_values(config: ConfigType, members: list[tuple[Any, Any, Any]]) -> list[Any]:
-    return [_config_lookup(config, key) for key, _, _ in members]
-
-
-def register_apply_action(
-    name: str,
-    schema: cv.Schema,
-    *fields: ApplyField | ApplyCall,
-    call: str | None = None,
-) -> None:
-    """Register an action that only forwards config values to its parent, with no C++ class.
-
-    Generates one stateless function for ``ApplyAction<Ts...>``: parent and constants are baked
-    in, lambdas are called inline with the trigger args. With ``call`` every statement targets
-    the call object ``auto apply_call = parent->call()``, and ``apply_call.perform()`` is appended.
-    """
-    # An action stores the value, so a std::string constant stays in flash on ESP8266.
-    statements_spec = [
-        (
-            c.target,
-            [
-                (key, t, fn or (flash_string if t is cg.std_string else None))
-                for key, t, fn in c.members
-            ],
-        )
-        for c in (f if isinstance(f, ApplyCall) else f.call() for f in fields)
-    ]
-    for _, members in statements_spec:
-        for conf_key, _, _ in members:
-            _check_key_in_schema(name, schema, conf_key)
-
-    async def builder(
-        config: ConfigType,
-        action_id: ID,
-        template_arg: cg.TemplateArguments,
-        args: TemplateArgsType,
-    ) -> MockObj:
-        parent = await _apply_parent(config)
-        lambda_args = _apply_lambda_args(args)
-        receiver = "apply_call." if call else f"{parent}->"
-        statements: list[str] = []
-        for target, members in statements_spec:
-            values = _apply_values(config, members)
-            if members and all(value is None for value in values):
-                continue
-            exprs = await _render_values(
-                name, target, members, values, config, parent, lambda_args
-            )
-            statements.append(f"{receiver}{target.format(*exprs)};")
-        if call:
-            statements = [
-                f"auto apply_call = {parent}->{call}();",
-                *statements,
-                "apply_call.perform();",
-            ]
-        apply_lambda = LambdaExpression(
-            ["\n".join(statements)], lambda_args, capture="", return_type=cg.void
-        )
-        return cg.new_Pvariable(action_id, template_arg, apply_lambda)
-
-    register_action(name, ApplyAction, schema, synchronous=True)(builder)
-
-
-def register_apply_condition(
-    name: str, schema: cv.Schema, check: str | ApplyCall
-) -> None:
-    """Register a condition that is one expression on its parent, with no C++ class.
-
-    ``check`` is applied to the parent: ``"is_playing()"`` becomes ``parent->is_playing()``; an
-    ``ApplyCall`` such as ``ApplyCall("state == {}", ((CONF_STATE, cg.bool_),))`` compares
-    against config values, all of which must be present. Write ``== false`` to negate.
-    String constants are plain literals, so compare a ``std::string`` or ``StringRef`` member.
-    Generates one stateless function for ``ApplyCondition<Ts...>``.
-    """
-    call = check if isinstance(check, ApplyCall) else ApplyCall(check)
-    members = call.members
-    for conf_key, _, _ in members:
-        _check_key_in_schema(name, schema, conf_key)
-
-    async def builder(
-        config: ConfigType,
-        condition_id: ID,
-        template_arg: cg.TemplateArguments,
-        args: TemplateArgsType,
-    ) -> MockObj:
-        parent = await _apply_parent(config)
-        lambda_args = _apply_lambda_args(args)
-        exprs = await _render_values(
-            name,
-            call.target,
-            members,
-            _apply_values(config, members),
-            config,
-            parent,
-            lambda_args,
-            compare=True,
-        )
-        check_lambda = LambdaExpression(
-            [f"return {parent}->{call.target.format(*exprs)};"],
-            lambda_args,
-            capture="",
-            return_type=cg.bool_,
-        )
-        return cg.new_Pvariable(condition_id, template_arg, check_lambda)
-
-    register_condition(name, ApplyCondition, schema)(builder)
-

 def validate_potentially_and_condition(value):
    if isinstance(value, list):
@@ -732,15 +359,28 @@ async def for_condition_to_code(
    return var


-register_apply_condition(
+@register_condition(
    "component.is_idle",
+    LambdaCondition,
    maybe_simple_id(
        {
            cv.Required(CONF_ID): cv.use_id(cg.Component),
        }
    ),
-    "is_idle()",
 )
+async def component_is_idle_condition_to_code(
+    config: ConfigType,
+    condition_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    comp = await cg.get_variable(config[CONF_ID])
+    lambda_ = await cg.process_lambda(
+        Lambda(f"return {comp}->is_idle();"), args, return_type=bool
+    )
+    return new_lambda_pvariable(
+        condition_id, lambda_, StatelessLambdaCondition, template_arg
+    )


@register_action(
@@ -894,20 +534,44 @@ async def lambda_action_to_code(
    return new_lambda_pvariable(action_id, lambda_, StatelessLambdaAction, template_arg)


-register_simple_action(
+@register_action(
    "component.update",
    UpdateComponentAction,
-    maybe_simple_id({cv.Required(CONF_ID): cv.use_id(cg.PollingComponent)}),
+    maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(cg.PollingComponent),
+        }
+    ),
    synchronous=True,
 )
+async def component_update_action_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    comp = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, comp)


-register_simple_action(
+@register_action(
    "component.suspend",
    SuspendComponentAction,
-    maybe_simple_id({cv.Required(CONF_ID): cv.use_id(cg.PollingComponent)}),
+    maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(cg.PollingComponent),
+        }
+    ),
    synchronous=True,
 )
+async def component_suspend_action_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    comp = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, comp)


@register_action(
@@ -90,10 +90,9 @@ def get_project_cmakelists(
    """
    idf_target = variant_to_idf_target(get_esp32_variant())

-    # esp_idf_size 2.x (IDF >=6.0) made NG the default and removed --ng;
-    # 1.x (IDF 5.5) needs --ng for --format=json2. 1.x json2 also lacks
-    # total_size, hence the ELF fallback in espidf/size_summary.py; both
-    # go away together when 1.x support is dropped.
+    # esp_idf_size 2.x (bundled with IDF >=6.0) made NG the default and
+    # removed the --ng flag; on 1.x (IDF 5.5) --ng is required to get
+    # --format=raw because the legacy mode doesn't support it.
    size_ng_flag = "--ng" if idf_version() < cv.Version(6, 0, 0) else ""

    # Project-wide compile options: -D defines and -W warning flags (skip
@@ -212,12 +211,10 @@ include($ENV{{IDF_PATH}}/tools/cmake/project.cmake)

 project({CORE.name})

-# Emit per-memory-type JSON size data for ESPHome to read post-build.
-# json2 stays small; raw dumps every symbol (~2s on a large map) and
-# this command runs inside the link edge, blocking everything downstream.
+# Emit raw JSON size data for ESPHome to read post-build.
 add_custom_command(
    TARGET ${{CMAKE_PROJECT_NAME}}.elf POST_BUILD
-    COMMAND ${{PYTHON}} -m esp_idf_size {size_ng_flag} --format=json2
+    COMMAND ${{PYTHON}} -m esp_idf_size {size_ng_flag} --format=raw
            -o ${{CMAKE_BINARY_DIR}}/esp_idf_size.json
            ${{CMAKE_PROJECT_NAME}}.map
    WORKING_DIRECTORY ${{CMAKE_BINARY_DIR}}
@@ -6,6 +6,5 @@ See the component-alias section of esphome/loader.py.

 # alias -> (canonical component, removal version or None)
 COMPONENT_ALIASES: dict[str, tuple[str, str | None]] = {
-    "esp32_improv": ("improv_ble", "2027.4.0"),
    "rp2040": ("rp2", "2027.7.0"),
 }
@@ -94,7 +94,7 @@ class ADCSensor final : public sensor::Sensor, public PollingComponent, public v
  ///   - SamplingMode::MIN: Use the lowest sample value
  ///   - SamplingMode::MAX: Use the highest sample value
  /// @param sampling_mode The desired sampling mode to use for aggregating ADC samples.
-  void set_sampling_mode(SamplingMode sampling_mode) { this->sampling_mode_ = sampling_mode; }
+  void set_sampling_mode(SamplingMode sampling_mode);

  /// Perform a single ADC sampling operation and return the measured value.
  /// This function handles raw readings, calibration, and averaging as needed.
@@ -76,4 +76,6 @@ void ADCSensor::set_sample_count(uint8_t sample_count) {
  }
 }

+void ADCSensor::set_sampling_mode(SamplingMode sampling_mode) { this->sampling_mode_ = sampling_mode; }
+
 }  // namespace esphome::adc
@@ -41,6 +41,10 @@ StateAnyForwarder = alarm_control_panel_ns.class_("StateAnyForwarder")
 StateEnterForwarder = alarm_control_panel_ns.class_("StateEnterForwarder")
 AlarmControlPanelState = alarm_control_panel_ns.enum("AlarmControlPanelState")

+ArmAwayAction = alarm_control_panel_ns.class_("ArmAwayAction", automation.Action)
+ArmHomeAction = alarm_control_panel_ns.class_("ArmHomeAction", automation.Action)
+ArmNightAction = alarm_control_panel_ns.class_("ArmNightAction", automation.Action)
+DisarmAction = alarm_control_panel_ns.class_("DisarmAction", automation.Action)
 PendingAction = alarm_control_panel_ns.class_("PendingAction", automation.Action)
 TriggeredAction = alarm_control_panel_ns.class_("TriggeredAction", automation.Action)
 ChimeAction = alarm_control_panel_ns.class_("ChimeAction", automation.Action)
@@ -192,20 +196,64 @@ async def new_alarm_control_panel(config, *args):
    return var


-# Mirrors AlarmControlPanel::arm_with_code_: arm first, set the code only when given.
-for _name, _arm in (
-    ("alarm_control_panel.arm_away", "arm_away()"),
-    ("alarm_control_panel.arm_home", "arm_home()"),
-    ("alarm_control_panel.arm_night", "arm_night()"),
-    ("alarm_control_panel.disarm", "disarm()"),
-):
-    automation.register_apply_action(
-        _name,
-        ALARM_CONTROL_PANEL_ACTION_SCHEMA,
-        automation.ApplyCall(_arm),
-        automation.ApplyField(CONF_CODE, "set_code", cg.std_string),
-        call="make_call",
-    )
+@automation.register_action(
+    "alarm_control_panel.arm_away",
+    ArmAwayAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def alarm_action_arm_away_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 code_config := config.get(CONF_CODE):
+        templatable_ = await cg.templatable(code_config, args, cg.std_string)
+        cg.add(var.set_code(templatable_))
+    return var
+
+
+@automation.register_action(
+    "alarm_control_panel.arm_home",
+    ArmHomeAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def alarm_action_arm_home_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 code_config := config.get(CONF_CODE):
+        templatable_ = await cg.templatable(code_config, args, cg.std_string)
+        cg.add(var.set_code(templatable_))
+    return var
+
+
+@automation.register_action(
+    "alarm_control_panel.arm_night",
+    ArmNightAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def alarm_action_arm_night_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_CODE in config:
+        templatable_ = await cg.templatable(config[CONF_CODE], args, cg.std_string)
+        cg.add(var.set_code(templatable_))
+    return var
+
+
+@automation.register_action(
+    "alarm_control_panel.disarm",
+    DisarmAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def alarm_action_disarm_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 code_config := config.get(CONF_CODE):
+        templatable_ = await cg.templatable(code_config, args, cg.std_string)
+        cg.add(var.set_code(templatable_))
+    return var


@automation.register_action(
@@ -138,11 +138,11 @@ class AlarmControlPanel : public EntityBase {
  // in order to store last panel state in flash
  ESPPreferenceObject pref_;
  // current state
-  AlarmControlPanelState current_state_{ACP_STATE_DISARMED};
+  AlarmControlPanelState current_state_;
  // the desired (or previous) state
-  AlarmControlPanelState desired_state_{ACP_STATE_DISARMED};
+  AlarmControlPanelState desired_state_;
  // last time the state was updated
-  uint32_t last_update_{0};
+  uint32_t last_update_;
  // the call control function
  virtual void control(const AlarmControlPanelCall &call) = 0;
  // state callback - passes the new state to listeners
@@ -27,6 +27,54 @@ static_assert(std::is_trivially_copyable_v<StateAnyForwarder>);
 static_assert(sizeof(StateEnterForwarder<ACP_STATE_TRIGGERED>) <= sizeof(void *));
 static_assert(std::is_trivially_copyable_v<StateEnterForwarder<ACP_STATE_TRIGGERED>>);

+template<typename... Ts> class ArmAwayAction final : public Action<Ts...> {
+ public:
+  explicit ArmAwayAction(AlarmControlPanel *alarm_control_panel) : alarm_control_panel_(alarm_control_panel) {}
+
+  TEMPLATABLE_VALUE(std::string, code)
+
+  void play(const Ts &...x) override { this->alarm_control_panel_->arm_away(this->code_.optional_value(x...)); }
+
+ protected:
+  AlarmControlPanel *alarm_control_panel_;
+};
+
+template<typename... Ts> class ArmHomeAction final : public Action<Ts...> {
+ public:
+  explicit ArmHomeAction(AlarmControlPanel *alarm_control_panel) : alarm_control_panel_(alarm_control_panel) {}
+
+  TEMPLATABLE_VALUE(std::string, code)
+
+  void play(const Ts &...x) override { this->alarm_control_panel_->arm_home(this->code_.optional_value(x...)); }
+
+ protected:
+  AlarmControlPanel *alarm_control_panel_;
+};
+
+template<typename... Ts> class ArmNightAction final : public Action<Ts...> {
+ public:
+  explicit ArmNightAction(AlarmControlPanel *alarm_control_panel) : alarm_control_panel_(alarm_control_panel) {}
+
+  TEMPLATABLE_VALUE(std::string, code)
+
+  void play(const Ts &...x) override { this->alarm_control_panel_->arm_night(this->code_.optional_value(x...)); }
+
+ protected:
+  AlarmControlPanel *alarm_control_panel_;
+};
+
+template<typename... Ts> class DisarmAction final : public Action<Ts...> {
+ public:
+  explicit DisarmAction(AlarmControlPanel *alarm_control_panel) : alarm_control_panel_(alarm_control_panel) {}
+
+  TEMPLATABLE_VALUE(std::string, code)
+
+  void play(const Ts &...x) override { this->alarm_control_panel_->disarm(this->code_.optional_value(x...)); }
+
+ protected:
+  AlarmControlPanel *alarm_control_panel_;
+};
+
 template<typename... Ts> class PendingAction final : public Action<Ts...> {
 public:
  explicit PendingAction(AlarmControlPanel *alarm_control_panel) : alarm_control_panel_(alarm_control_panel) {}
@@ -13,7 +13,6 @@ from esphome.components.logger import request_log_listener
 from esphome.components.noise import (  # noqa: F401
    ENCRYPTION_SCHEMA,
    decode_encryption_key,
-    enable_spare_ephemeral,
    encryption_schema,
    new_psk_progmem,
    validate_encryption_key,
@@ -137,12 +136,6 @@ CONF_LISTEN_BACKLOG = "listen_backlog"
 CONF_MAX_SEND_QUEUE = "max_send_queue"
 CONF_STATE_SUBSCRIPTION_ONLY = "state_subscription_only"

-# Schema defaults that also match the C++ initializers in api_server.h; codegen
-# skips the setter when the config equals them.
-DEFAULT_PORT = 6053
-DEFAULT_REBOOT_TIMEOUT = "15min"
-DEFAULT_BATCH_DELAY = "100ms"
-

 def _register_provisioning_source(config: ConfigType) -> ConfigType:
    """Register the API as a provisioning source when encryption is enabled.
@@ -299,7 +292,7 @@ CONFIG_SCHEMA = cv.All(
    cv.Schema(
        {
            cv.GenerateID(): cv.declare_id(APIServer),
-            cv.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+            cv.Optional(CONF_PORT, default=6053): cv.port,
            # Removed in 2026.1.0 - kept to provide helpful error message
            cv.Optional(CONF_PASSWORD): cv.invalid(
                "The 'password' option has been removed in ESPHome 2026.1.0.\n"
@@ -312,14 +305,14 @@ CONFIG_SCHEMA = cv.All(
                "Or visit https://esphome.io/components/api/#configuration-variables"
            ),
            cv.Optional(
-                CONF_REBOOT_TIMEOUT, default=DEFAULT_REBOOT_TIMEOUT
+                CONF_REBOOT_TIMEOUT, default="15min"
            ): cv.positive_time_period_milliseconds,
            cv.Exclusive(
                CONF_SERVICES, group_of_exclusion=CONF_ACTIONS
            ): ACTIONS_SCHEMA,
            cv.Exclusive(CONF_ACTIONS, group_of_exclusion=CONF_ACTIONS): ACTIONS_SCHEMA,
            cv.Optional(CONF_ENCRYPTION): encryption_schema,
-            cv.Optional(CONF_BATCH_DELAY, default=DEFAULT_BATCH_DELAY): cv.All(
+            cv.Optional(CONF_BATCH_DELAY, default="100ms"): cv.All(
                cv.positive_time_period_milliseconds,
                cv.Range(max=cv.TimePeriod(milliseconds=65535)),
            ),
@@ -357,9 +350,10 @@ CONFIG_SCHEMA = cv.All(
                ln882x=5,  # Moderate RAM
                nrf52=4,  # ~256KB RAM, BSD sockets, Thread (single HA controller)
            ): cv.int_range(min=1, max=20),
-            # Max queued messages per connection, and 2 KB of backlog per slot up
-            # to 64 KB (a lone message is exempt), before the connection is dropped
+            # Maximum queued send buffers per connection before dropping connection
+            # Each buffer uses ~8-12 bytes overhead plus actual message size
            # Platform defaults based on available RAM and typical message rates:
+            # CONF_MAX_SEND_QUEUE defaults are power of 2 for efficient modulo
            cv.SplitDefault(
                CONF_MAX_SEND_QUEUE,
                esp8266=4,  # Limited RAM, need to fail fast
@@ -469,15 +463,9 @@ async def to_code(config: ConfigType) -> None:
    # Request a log listener slot for API log streaming
    request_log_listener()

-    # Skip the setters when the config matches the C++ initializers (DEFAULT_*).
-    if (port := config[CONF_PORT]) != DEFAULT_PORT:
-        cg.add(var.set_port(port))
-    if (reboot_timeout := config[CONF_REBOOT_TIMEOUT]) != cv.time_period(
-        DEFAULT_REBOOT_TIMEOUT
-    ):
-        cg.add(var.set_reboot_timeout(reboot_timeout))
-    if (batch_delay := config[CONF_BATCH_DELAY]) != cv.time_period(DEFAULT_BATCH_DELAY):
-        cg.add(var.set_batch_delay(batch_delay))
+    cg.add(var.set_port(config[CONF_PORT]))
+    cg.add(var.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
+    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])
@@ -615,7 +603,6 @@ async def to_code(config: ConfigType) -> None:
            # and plaintext disabled. Only a factory reset can remove it.
            cg.add_define("USE_API_PLAINTEXT")
        cg.add_define("USE_API_NOISE")
-        enable_spare_ephemeral()
    else:
        cg.add_define("USE_API_PLAINTEXT")

@@ -1,37 +1,20 @@
 #include "api_buffer.h"
-#ifdef ESPHOME_DEBUG_API
-#include "esphome/core/log.h"
-#endif
+#include <new>

 namespace esphome::api {

-#ifdef ESPHOME_DEBUG_API
-void APIBuffer::debug_check_drop_(size_t drop) const {
-  if (drop > this->size_) {
-    ESP_LOGE("api.buffer", "drop_front: drop=%zu size=%u", drop, this->size_);
-    abort();
-  }
-}
-#endif
-
 bool APIBuffer::grow_(size_t n) {
-  if (n > MAX_SIZE)
+  // nothrow (no zero-fill) so OOM is reportable; plain new aborts instead
+  // (NEW_OOM_ABORT on ESP8266 Arduino, exception stub on ESP-IDF).
+  // RAMAllocator is no fit here: unique_ptr needs delete[]-compatible memory.
+  std::unique_ptr<uint8_t[]> new_data(new (std::nothrow) uint8_t[n]);
+  if (new_data == nullptr)
    return false;
-  // realloc extends in place when it can, avoiding the copy
-  uint8_t *grown = RAMAllocator<uint8_t>().reallocate(this->data_.get(), n);
-  if (grown == nullptr)
-    return false;
-  (void) this->data_.release();  // realloc already freed or reused the old block
-  this->data_.reset(grown);
+  if (this->size_)
+    std::memcpy(new_data.get(), this->data_.get(), this->size_);
+  this->data_ = std::move(new_data);
  this->capacity_ = n;
  return true;
 }

-uint8_t *APIBuffer::append(size_t n) {
-  const size_t old_size = this->size_;
-  if (!this->resize(old_size + n))
-    return nullptr;
-  return this->data_.get() + old_size;
-}
-
 }  // namespace esphome::api
@@ -25,7 +25,6 @@ namespace esphome::api {
 /// writes in debug builds.
 class APIBuffer {
 public:
-  static constexpr size_t MAX_SIZE = UINT16_MAX;  // API frames carry 16 bit lengths
  void clear() { this->size_ = 0; }
  /// Returns false if allocation fails; the buffer is left unchanged.
  [[nodiscard]] inline bool reserve(size_t n) ESPHOME_ALWAYS_INLINE { return n <= this->capacity_ || this->grow_(n); }
@@ -37,19 +36,9 @@ class APIBuffer {
  [[nodiscard]] inline bool reserve_and_resize(size_t reserve_size, size_t new_size) ESPHOME_ALWAYS_INLINE {
    if (!this->reserve(std::max(reserve_size, new_size)))
      return false;
-    this->size_ = static_cast<uint16_t>(new_size);
+    this->size_ = new_size;
    return true;
  }
-  /// Grow by n bytes; returns the new bytes, or nullptr on allocation failure.
-  [[nodiscard]] uint8_t *append(size_t n);
-  /// Drop the first `drop` bytes, sliding the rest down. Precondition: drop <= size().
-  void drop_front(size_t drop) {
-#ifdef ESPHOME_DEBUG_API
-    this->debug_check_drop_(drop);
-#endif
-    this->size_ -= drop;
-    std::memmove(this->data_.get(), this->data_.get() + drop, this->size_);
-  }
  uint8_t *data() { return this->data_.get(); }
  const uint8_t *data() const { return this->data_.get(); }
  size_t size() const { return this->size_; }
@@ -66,14 +55,9 @@ class APIBuffer {

 protected:
  bool grow_(size_t n);
-#ifdef ESPHOME_DEBUG_API
-  void debug_check_drop_(size_t drop) const;
-#endif
-  // RAMAllocator: PSRAM when available, and it reports failure where
-  // new (std::nothrow) still aborts on ESP-IDF without exceptions
-  RAMUniquePtr<uint8_t[]> data_;
-  uint16_t size_{0};
-  uint16_t capacity_{0};
+  std::unique_ptr<uint8_t[]> data_;
+  size_t size_{0};
+  size_t capacity_{0};
 };

 }  // namespace esphome::api
@@ -364,10 +364,7 @@ void APIConnection::check_keepalive_(uint32_t now) {
    ESP_LOGVV(TAG, "Sending keepalive PING");
    PingRequest req;
    this->flags_.sent_ping = this->send_message(req);
-    if (this->flags_.sent_ping) {
-      // Quiet for a keepalive period and the ping is on its way: a one-off stall's storage can go
-      this->helper_->release_overflow_buffer();
-    } else {
+    if (!this->flags_.sent_ping) {
      // If we can't send the ping request directly (tx_buffer full),
      // schedule it at the front of the batch so it will be sent with priority
      ESP_LOGW(TAG, "Buffer full, ping queued");
@@ -720,7 +717,12 @@ uint16_t APIConnection::try_send_switch_info(EntityBase *entity, APIConnection *
 }
 void APIConnection::on_switch_command_request(const SwitchCommandRequest &msg) {
  ENTITY_COMMAND_GET(switch_::Switch, a_switch, switch)
-  a_switch->control(msg.state);
+
+  if (msg.state) {
+    a_switch->turn_on();
+  } else {
+    a_switch->turn_off();
+  }
 }
 #endif

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

-  // How long a new connection holds off the spare ephemeral refill
-  static constexpr uint32_t CONNECT_GRACE_MS = 1000;
  bool is_authenticated() {
    return static_cast<ConnectionState>(this->flags_.connection_state) == ConnectionState::AUTHENTICATED;
  }
-  // Unauthenticated and within its grace period; an older unauthenticated
-  // connection is a stale half open client and no longer counts
-  bool is_still_connecting(uint32_t now) {
-    return !this->is_authenticated() && now - this->last_traffic_ < CONNECT_GRACE_MS;
-  }
  bool is_connection_setup() {
    return static_cast<ConnectionState>(this->flags_.connection_state) == ConnectionState::CONNECTED ||
           this->is_authenticated();
@@ -171,7 +171,7 @@ APIError APIFrameHelper::write_raw_iov_(const struct iovec *iov, int iovcnt, uin
    return APIError::OK;

  // Queue unsent data into overflow buffer
-  if (!this->overflow_buf_.enqueue_iov(iov, iovcnt, total_write_len, sent)) {
+  if (!this->overflow_buf_.enqueue_iov(iov, iovcnt, total_write_len, static_cast<uint16_t>(sent))) {
    HELPER_LOG("Overflow buffer full or out of memory, dropping connection");
    this->state_ = State::FAILED;
    return APIError::SOCKET_WRITE_FAILED;
@@ -219,10 +219,7 @@ class APIFrameHelper {
    if (this->rx_buf_len_ == 0) {
      this->rx_buf_.release();
    }
-    this->release_overflow_buffer();
  }
-  // Free the send backlog storage once it has drained
-  void release_overflow_buffer() { this->overflow_buf_.release(); }

 protected:
  // Drain backlogged overflow data to the socket and handle errors.
@@ -67,15 +67,15 @@ APIError APINoiseFrameHelper::init() {
  }

  // init prologue
-  uint8_t *dst = prologue_.append(PROLOGUE_INIT_LEN);
-  if (dst == nullptr) [[unlikely]] {
+  size_t old_size = prologue_.size();
+  if (!prologue_.resize(old_size + PROLOGUE_INIT_LEN)) [[unlikely]] {
    state_ = State::FAILED;
    return APIError::OUT_OF_MEMORY;
  }
 #ifdef USE_ESP8266
-  memcpy_P(dst, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
+  memcpy_P(prologue_.data() + old_size, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
 #else
-  std::memcpy(dst, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
+  std::memcpy(prologue_.data() + old_size, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
 #endif

  state_ = State::CLIENT_HELLO;
@@ -272,17 +272,17 @@ APIError APINoiseFrameHelper::state_action_client_hello_() {
    return handle_handshake_frame_error_(aerr);
  }
  // ignore contents, may be used in future for flags
-  // Append 2 size bytes + frame data to the prologue
+  // Resize for: existing prologue + 2 size bytes + frame data
+  size_t old_size = this->prologue_.size();
  size_t rx_size = this->rx_buf_.size();
-  uint8_t *dst = this->prologue_.append(2 + rx_size);
-  if (dst == nullptr) [[unlikely]] {
+  if (!this->prologue_.resize(old_size + 2 + rx_size)) [[unlikely]] {
    state_ = State::FAILED;
    return APIError::OUT_OF_MEMORY;
  }
-  dst[0] = (uint8_t) (rx_size >> 8);
-  dst[1] = (uint8_t) rx_size;
+  this->prologue_[old_size] = (uint8_t) (rx_size >> 8);
+  this->prologue_[old_size + 1] = (uint8_t) rx_size;
  if (rx_size > 0) {
-    std::memcpy(dst + 2, this->rx_buf_.data(), rx_size);
+    std::memcpy(this->prologue_.data() + old_size + 2, this->rx_buf_.data(), rx_size);
  }

  state_ = State::SERVER_HELLO;
@@ -1,91 +1,98 @@
 #include "api_overflow_buffer.h"
 #ifdef USE_API
 #include <cstring>
+#include <new>

 namespace esphome::api {

+APIOverflowBuffer::~APIOverflowBuffer() {
+  for (auto *entry : this->queue_) {
+    if (entry != nullptr)
+      Entry::destroy(entry);
+  }
+}
+
 ssize_t APIOverflowBuffer::try_drain(socket::Socket *socket) {
-  // Nested call from inside socket->write(); see draining_
+  // socket->write() can re-enter this function: a log message emitted from an
+  // lwip callback during the write goes out over the API and lands back in the
+  // frame helper's write/drain path. If a nested drain ran here it would send
+  // and free the entry the outer drain is still holding, causing a double free.
+  // Report "no progress" instead; the outer drain keeps draining, and the
+  // nested send is enqueued behind the existing backlog.
  if (this->draining_)
    return 0;

+  // RAII so the flag is cleared on every return path
  struct DrainGuard {
-    APIOverflowBuffer &owner;
-    ~DrainGuard() { this->owner.draining_ = false; }
-  } guard{*this};
-  this->draining_ = true;
+    explicit DrainGuard(bool &flag) : flag_(flag) { flag_ = true; }
+    ~DrainGuard() { this->flag_ = false; }
+    bool &flag_;
+  } guard(this->draining_);

  while (this->count_ > 0) {
-    uint8_t *msg = this->buf_.data() + this->head_;
-    size_t len = msg[0] | (msg[1] << 8);
+    Entry *front = this->queue_[this->head_];

-    ssize_t sent = socket->write(msg + LEN_PREFIX, len);
-    if (sent <= 0)
-      return sent;
-    if (static_cast<size_t>(sent) < len) {
-      // Step past the sent bytes and rewrite the prefix there; it lands on bytes already sent
-      this->head_ += sent;
-      len -= sent;
-      msg += sent;
-      msg[0] = len;
-      msg[1] = len >> 8;
+    ssize_t sent = socket->write(front->current_data(), front->remaining());
+
+    if (sent <= 0) {
+      // -1 = error (caller checks errno for EWOULDBLOCK vs hard error)
+      // 0 = nothing sent (treat as no progress)
      return sent;
    }
-    this->head_ += LEN_PREFIX + len;
+
+    if (static_cast<uint16_t>(sent) < front->remaining()) {
+      // Partially sent, update offset and stop
+      front->offset += static_cast<uint16_t>(sent);
+      return sent;
+    }
+
+    // Entry fully sent — unlink it before freeing so a freed pointer is never
+    // reachable from the queue
+    this->queue_[this->head_] = nullptr;
+    this->head_ = (this->head_ + 1) % API_MAX_SEND_QUEUE;
    this->count_--;
+    Entry::destroy(front);
  }

-  this->head_ = 0;
-  if (this->release_when_drained_) {
-    this->release_when_drained_ = false;
-    this->buf_.release();
-  } else {
-    this->buf_.clear();
-  }
-  return 0;
+  return 0;  // All drained
 }

-bool APIOverflowBuffer::enqueue_iov(const struct iovec *iov, int iovcnt, size_t total_len, size_t skip) {
+bool APIOverflowBuffer::enqueue_iov(const struct iovec *iov, int iovcnt, uint16_t total_len, uint16_t skip) {
  if (this->count_ >= API_MAX_SEND_QUEUE)
    return false;

-  const size_t new_len = total_len - skip;
-  const size_t new_bytes = LEN_PREFIX + new_len;
-  const size_t live = this->buf_.size() - this->head_;
-  // A lone message is only bound by the buffer; refusing it would just drop the connection
-  if (live + new_bytes > (this->count_ > 0 ? MAX_BYTES : MAX_LONE_BYTES))
+  uint16_t buffer_size = total_len - skip;
+  // nothrow: a failed allocation returns nullptr so the connection is dropped
+  // cleanly instead of plain new's crash or abort on OOM
+  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
+  auto *data = new (std::nothrow) uint8_t[buffer_size];
+  if (data == nullptr)
+    return false;
+  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
+  auto *entry = new (std::nothrow) Entry{data, buffer_size, 0};
+  if (entry == nullptr) {
+    delete[] data;
    return false;
-
-  if (this->buf_.size() + new_bytes > this->buf_.capacity()) {
-    // Storage would move under an outer drain's write()
-    if (this->draining_)
-      return false;
-    if (this->head_ > 0) {
-      // Reclaim the sent prefix before growing
-      this->buf_.drop_front(this->head_);
-      this->head_ = 0;
-    }
-    if (!this->buf_.reserve(reserve_for(live + new_bytes)))
-      return false;
  }

-  uint8_t *dst = this->buf_.append(new_bytes);
-  if (dst == nullptr)
-    return false;
-  dst[0] = new_len;
-  dst[1] = new_len >> 8;
-  dst += LEN_PREFIX;
-  for (const struct iovec *end = iov + iovcnt; iov != end; iov++) {
-    if (skip >= iov->iov_len) {
-      skip -= iov->iov_len;
+  uint16_t to_skip = skip;
+  uint16_t write_pos = 0;
+
+  for (int i = 0; i < iovcnt; i++) {
+    if (to_skip >= iov[i].iov_len) {
+      to_skip -= static_cast<uint16_t>(iov[i].iov_len);
    } else {
-      const size_t len = iov->iov_len - skip;
-      std::memcpy(dst, static_cast<const uint8_t *>(iov->iov_base) + skip, len);
-      dst += len;
-      skip = 0;
+      const uint8_t *src = reinterpret_cast<uint8_t *>(iov[i].iov_base) + to_skip;
+      uint16_t len = static_cast<uint16_t>(iov[i].iov_len) - to_skip;
+      std::memcpy(entry->data + write_pos, src, len);
+      write_pos += len;
+      to_skip = 0;
    }
  }

+  // Publish only after the copy completes so a half-built entry is never reachable
+  this->queue_[this->tail_] = entry;
+  this->tail_ = (this->tail_ + 1) % API_MAX_SEND_QUEUE;
  this->count_++;
  return true;
 }
@@ -1,6 +1,5 @@
 #pragma once
-#include <algorithm>
-#include <cstddef>
+#include <array>
 #include <cstdint>
 #include <sys/types.h>

@@ -9,57 +8,71 @@

 #include "esphome/components/socket/headers.h"
 #include "esphome/components/socket/socket.h"
-#include "api_buffer.h"
+#include "esphome/core/helpers.h"

 namespace esphome::api {

-/// TCP send backlog, only used when the socket send buffer is full.
-/// One contiguous buffer per connection, allocated on the first stall and
-/// kept at its high-water mark so a lossy link does not churn the heap.
-/// Messages are stored as a 2 byte length prefix plus payload.
-/// API_MAX_SEND_QUEUE bounds queued messages and, at 2 KB per slot, queued
-/// bytes; exceeding either fails the connection.
+/// Circular queue of heap-allocated byte buffers used as a TCP send backlog.
+///
+/// Under normal operation this buffer is **never used** — data goes straight
+/// from the frame helper to the socket.  It only fills when the LWIP TCP
+/// send buffer is full (slow client, congested network, heavy logging).
+/// The queue drains automatically on subsequent write/loop calls once the
+/// socket becomes writable again.
+///
+/// Capacity is compile-time-fixed via API_MAX_SEND_QUEUE (set from Python
+/// config).  If the queue fills completely the connection is marked failed.
 class APIOverflowBuffer {
 public:
+  /// A single heap-allocated send-backlog entry.
+  /// Lifetime is manually managed — see destroy().
+  struct Entry {
+    uint8_t *data;
+    uint16_t size;    // Total size of the buffer
+    uint16_t offset;  // Current send offset within the buffer
+
+    uint16_t remaining() const { return this->size - this->offset; }
+    const uint8_t *current_data() const { return this->data + this->offset; }
+
+    /// Free this entry and its data buffer.
+    static ESPHOME_ALWAYS_INLINE void destroy(Entry *entry) {
+      delete[] entry->data;
+      delete entry;  // NOLINT(cppcoreguidelines-owning-memory)
+    }
+  };
+
+  ~APIOverflowBuffer();
+
  /// True when no backlogged data is waiting.
  bool empty() const { return this->count_ == 0; }

-  /// Drain queued messages to the socket.
-  /// Returns bytes written, 0 for a re-entrant call, -1 on error (check errno
-  /// for EWOULDBLOCK); callers only need to act on -1.
+  /// True when the queue has no room for another entry.
+  bool full() const { return this->count_ >= API_MAX_SEND_QUEUE; }
+
+  /// Number of entries currently queued.
+  uint8_t count() const { return this->count_; }
+
+  /// Try to drain queued data to the socket.
+  /// Returns bytes-written > 0 on success/partial, 0 if all drained or no progress,
+  /// -1 on error (caller must check errno to distinguish EWOULDBLOCK from hard errors).
+  /// Callers only need to act on -1; 0 and positive values both mean "no error".
+  /// Frees entries as they are fully sent.
  ssize_t try_drain(socket::Socket *socket);

-  /// Queue iov data from byte offset `skip` as one message.
-  /// Returns false when a limit is hit, allocation fails, or storage would move
-  /// during a drain; the caller should fail the connection.
-  bool enqueue_iov(const struct iovec *iov, int iovcnt, size_t total_len, size_t skip);
-
-  /// Free the retained storage, now if empty, otherwise once it has drained.
-  void release() {
-    if (this->count_ == 0) {
-      this->buf_.release();
-    } else {
-      this->release_when_drained_ = true;
-    }
-  }
+  /// Enqueue unsent IOV data into the backlog.
+  /// Copies iov data starting at byte offset `skip` into a new entry.
+  /// Returns false if the queue is full or allocation fails (caller should fail the connection).
+  bool enqueue_iov(const struct iovec *iov, int iovcnt, uint16_t total_len, uint16_t skip);

 protected:
-  static constexpr size_t LEN_PREFIX = 2;
-  static constexpr size_t BYTES_PER_SLOT = 2048;
-  // Reserve in 256 byte steps so a creeping high-water mark settles quickly
-  static constexpr size_t GROW_QUANTUM = 256;
-  // Lone message ceiling, rounded down so reserve_for() never exceeds the buffer limit
-  static constexpr size_t MAX_LONE_BYTES = APIBuffer::MAX_SIZE & ~(GROW_QUANTUM - 1);
-  static constexpr size_t MAX_BYTES = std::min(API_MAX_SEND_QUEUE * BYTES_PER_SLOT, MAX_LONE_BYTES);
-  static constexpr size_t reserve_for(size_t want) { return (want + GROW_QUANTUM - 1) & ~(GROW_QUANTUM - 1); }
-
-  APIBuffer buf_;
-  uint16_t head_{0};  // offset of the front message's length prefix; bytes before it are sent
+  std::array<Entry *, API_MAX_SEND_QUEUE> queue_{};
+  uint8_t head_{0};
+  uint8_t tail_{0};
  uint8_t count_{0};
-  // socket->write() can re-enter the send path (log from an lwip callback):
-  // a nested drain makes no progress and a nested enqueue never moves storage
-  bool draining_ : 1 {false};
-  bool release_when_drained_ : 1 {false};
+  // Guards against re-entrant drains: socket->write() can re-enter the API
+  // send path (e.g. a log message emitted from an lwip callback), and a nested
+  // drain would free the entry the outer drain is still holding.
+  bool draining_{false};
 };

 }  // namespace esphome::api
@@ -29,29 +29,6 @@ static const char *const TAG = "api";
 // APIServer
 APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

-#ifdef USE_API_NOISE
-static constexpr uint32_t NOISE_PSK_PREF_HASH = 88491486UL;
-#endif
-
-#if defined(USE_API_NOISE) && defined(USE_OTA_ENCRYPTION_PROVISIONED)
-bool load_saved_noise_psk(noise::psk_t &out) {
-  SavedNoisePsk saved;
-#ifdef USE_PREFERENCE_KEY_LOOKUP
-  const bool loaded =
-      global_preferences->load_from_key(NOISE_PSK_PREF_HASH, reinterpret_cast<uint8_t *>(&saved), sizeof(saved));
-#else
-  // Slot backends need the reservation walk; it only lands on the record when the reservations before
-  // it match a normal boot, otherwise the type checked checksum fails the load
-  const bool loaded = global_preferences->make_preference<SavedNoisePsk>(NOISE_PSK_PREF_HASH, true).load(&saved);
-#endif
-  // The all-zeros record means no key
-  if (!loaded || noise::NoiseContext::is_all_zeros(saved.psk))
-    return false;
-  out = saved.psk;
-  return true;
-}
-#endif
-
 APIServer::APIServer() { global_api_server = this; }

 void APIServer::socket_failed_(const LogString *msg) {
@@ -66,7 +43,8 @@ void APIServer::setup() {
 #ifdef USE_API_NOISE
  // Always reserve the slot: flash preferences are positional on esp8266, so
  // a yaml key build must keep the layout of a runtime key build
-  this->noise_pref_ = global_preferences->make_preference<SavedNoisePsk>(NOISE_PSK_PREF_HASH, true);
+  uint32_t hash = 88491486UL;
+  this->noise_pref_ = global_preferences->make_preference<SavedNoisePsk>(hash, true);
 #ifndef USE_API_NOISE_PSK_FROM_YAML
  // A cleared record loads fine but holds no key
  if (this->load_and_apply_noise_psk_() && this->noise_ctx_.has_psk()) {
@@ -165,15 +143,6 @@ void APIServer::loop() {
    this->accept_new_connections_();
  }

-  // Checked once per pass for the refill and for the clients below
-  const bool connected = network::is_connected();
-#ifdef USE_NOISE_SPARE_EPHEMERAL
-  // Only the flag test is inline; refilling is the rare path
-  if (connected && !noise::has_spare_ephemeral()) {
-    this->refill_spare_ephemeral_();
-  }
-#endif
-
  if (this->api_connection_count_ == 0) {
    // Check reboot timeout - done in loop to avoid scheduler heap churn
    // (cancelled scheduler items sit in heap memory until their scheduled time).
@@ -190,7 +159,8 @@ void APIServer::loop() {
  }

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

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

@@ -5,7 +5,7 @@
 #include "api_buffer.h"
 // Must precede clients_ so APIConnection is complete for default_delete (libc++).
 #include "api_connection.h"
-#if defined(USE_API_NOISE) || defined(USE_NOISE_SPARE_EPHEMERAL)
+#ifdef USE_API_NOISE
 // Only present in the build when the noise component is loaded
 #include "esphome/components/noise/noise.h"
 #endif
@@ -43,11 +43,6 @@ struct SavedNoisePsk {
  noise::psk_t psk;
 } PACKED;  // NOLINT
 #endif
-#if defined(USE_API_NOISE) && defined(USE_OTA_ENCRYPTION_PROVISIONED)
-/// One-shot read of the provisioned key for a boot without an api server (safe mode); false when
-/// there is no key
-bool load_saved_noise_psk(noise::psk_t &out);
-#endif

 class APIServer final : public Component,
                        public Controller
@@ -319,7 +314,7 @@ class APIServer final : public Component,
 #endif

  // 4-byte aligned types
-  uint32_t reboot_timeout_{900000};  // Keep in sync with DEFAULT_REBOOT_TIMEOUT in __init__.py
+  uint32_t reboot_timeout_{300000};
  uint32_t last_connected_{0};

  // Slots [0, api_connection_count_) are populated; trailing slots are always nullptr.
@@ -356,8 +351,8 @@ class APIServer final : public Component,
 #endif

  // Group smaller types together
-  uint16_t port_{6053};        // Keep in sync with DEFAULT_PORT in __init__.py
-  uint16_t batch_delay_{100};  // Keep in sync with DEFAULT_BATCH_DELAY in __init__.py
+  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.
  uint8_t listen_backlog_{4};
@@ -368,9 +363,6 @@ class APIServer final : public Component,
  uint8_t provisioning_source_{0};
 #endif

-#ifdef USE_NOISE_SPARE_EPHEMERAL
-  void refill_spare_ephemeral_();
-#endif
 #ifdef USE_API_NOISE
  noise::NoiseContext noise_ctx_;
 #ifndef USE_API_NOISE_PSK_FROM_YAML
@@ -4,6 +4,8 @@ import esphome.codegen as cg
 from esphome.components import i2c
 import esphome.config_validation as cv
 from esphome.const import CONF_FREQUENCY, CONF_ID
+from esphome.core import ID
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType

 CODEOWNERS = ["@X-Ryl669"]
@@ -78,21 +80,30 @@ async def to_code(config: ConfigType) -> None:


 # Actions
+AT581XResetAction = at581x_ns.class_("AT581XResetAction", automation.Action)
+AT581XSettingsAction = at581x_ns.class_("AT581XSettingsAction", automation.Action)


-automation.register_apply_action(
+@automation.register_action(
    "at581x.reset",
-    maybe_simple_id({cv.Required(CONF_ID): cv.use_id(AT581XComponent)}),
-    automation.ApplyCall("reset_hardware_frontend()"),
+    AT581XResetAction,
+    maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(AT581XComponent),
+        }
+    ),
+    synchronous=True,
 )
+async def at581x_reset_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])

-
-def _megahertz(value: float) -> int:
-    return int(value / 1000000)
-
-
-def _microamps(value: float) -> int:
-    return int(value * 1000000)
+    return var


 RADAR_SETTINGS_SCHEMA = cv.Schema(
@@ -100,7 +111,7 @@ RADAR_SETTINGS_SCHEMA = cv.Schema(
        cv.Required(CONF_ID): cv.use_id(AT581XComponent),
        cv.Optional(CONF_HW_FRONTEND_RESET): cv.templatable(cv.boolean),
        cv.Optional(CONF_FREQUENCY, default="5800MHz"): cv.templatable(
-            cv.All(cv.frequency, cv.one_of(*RADAR_ALLOWED_FREQ), _megahertz)
+            cv.All(cv.frequency, cv.one_of(*RADAR_ALLOWED_FREQ))
        ),
        cv.Optional(CONF_SENSING_DISTANCE, default=823): cv.templatable(
            cv.int_range(min=0, max=1023)
@@ -112,7 +123,7 @@ RADAR_SETTINGS_SCHEMA = cv.Schema(
            )
        ),
        cv.Optional(CONF_POWER_CONSUMPTION, default="70uA"): cv.templatable(
-            cv.All(cv.current, cv.one_of(*RADAR_ALLOWED_CUR_CONSUMPTION), _microamps)
+            cv.All(cv.current, cv.one_of(*RADAR_ALLOWED_CUR_CONSUMPTION))
        ),
        cv.Optional(CONF_PROTECT_TIME, default="1000ms"): cv.templatable(
            cv.All(
@@ -154,22 +165,60 @@ RADAR_SETTINGS_SCHEMA = cv.Schema(
 )


-# i2c_write_config() must follow the setters: it flushes the staged values.
-automation.register_apply_action(
+@automation.register_action(
    "at581x.settings",
+    AT581XSettingsAction,
    RADAR_SETTINGS_SCHEMA,
-    automation.ApplyField(CONF_FREQUENCY, "set_frequency", cg.int_),
-    automation.ApplyField(CONF_SENSING_DISTANCE, "set_sensing_distance", cg.int_),
-    automation.ApplyField(
-        CONF_POWERON_SELFCHECK_TIME, "set_poweron_selfcheck_time", cg.int_
-    ),
-    automation.ApplyField(CONF_POWER_CONSUMPTION, "set_power_consumption", cg.int_),
-    automation.ApplyField(CONF_PROTECT_TIME, "set_protect_time", cg.int_),
-    automation.ApplyField(CONF_TRIGGER_BASE, "set_trigger_base", cg.int_),
-    automation.ApplyField(CONF_TRIGGER_KEEP, "set_trigger_keep", cg.int_),
-    automation.ApplyField(CONF_STAGE_GAIN, "set_stage_gain", cg.int_),
-    automation.ApplyCall("i2c_write_config()"),
-    automation.ApplyField(
-        CONF_HW_FRONTEND_RESET, "reset_hardware_frontend_if", cg.bool_
-    ),
+    synchronous=True,
 )
+async def at581x_settings_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+
+    # Radar configuration
+    if frontend_reset := config.get(CONF_HW_FRONTEND_RESET):
+        template_ = await cg.templatable(frontend_reset, args, cg.int8)
+        cg.add(var.set_hw_frontend_reset(template_))
+
+    if freq := config.get(CONF_FREQUENCY):
+        if not cg.is_template(freq):
+            freq = int(freq / 1000000)
+        template_ = await cg.templatable(freq, args, cg.int_)
+        cg.add(var.set_frequency(template_))
+
+    if (sens_dist := config.get(CONF_SENSING_DISTANCE)) is not None:
+        template_ = await cg.templatable(sens_dist, args, cg.int_)
+        cg.add(var.set_sensing_distance(template_))
+
+    if selfcheck := config.get(CONF_POWERON_SELFCHECK_TIME):
+        template_ = await cg.templatable(selfcheck, args, cg.int_)
+        cg.add(var.set_poweron_selfcheck_time(template_))
+
+    if protect := config.get(CONF_PROTECT_TIME):
+        template_ = await cg.templatable(protect, args, cg.int_)
+        cg.add(var.set_protect_time(template_))
+
+    if trig_base := config.get(CONF_TRIGGER_BASE):
+        template_ = await cg.templatable(trig_base, args, cg.int_)
+        cg.add(var.set_trigger_base(template_))
+
+    if trig_keep := config.get(CONF_TRIGGER_KEEP):
+        template_ = await cg.templatable(trig_keep, args, cg.int_)
+        cg.add(var.set_trigger_keep(template_))
+
+    if (stage_gain := config.get(CONF_STAGE_GAIN)) is not None:
+        template_ = await cg.templatable(stage_gain, args, cg.int_)
+        cg.add(var.set_stage_gain(template_))
+
+    if power := config.get(CONF_POWER_CONSUMPTION):
+        if not cg.is_template(power):
+            power = int(power * 1000000)
+        template_ = await cg.templatable(power, args, cg.int_)
+        cg.add(var.set_power_consumption(template_))
+
+    return var
@@ -38,10 +38,6 @@ class AT581XComponent final : public Component, public i2c::I2CDevice {

  bool i2c_write_config();
  bool reset_hardware_frontend();
-  void reset_hardware_frontend_if(bool reset) {
-    if (reset)
-      this->reset_hardware_frontend();
-  }
  bool i2c_write_reg(uint8_t addr, uint8_t data);
  bool i2c_write_reg(uint8_t addr, uint32_t data);
  bool i2c_write_reg(uint8_t addr, uint16_t data);
@@ -0,0 +1,69 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "esphome/core/helpers.h"
+
+#include "at581x.h"
+
+namespace esphome::at581x {
+
+template<typename... Ts> class AT581XResetAction final : public Action<Ts...>, public Parented<AT581XComponent> {
+ public:
+  void play(const Ts &...x) { this->parent_->reset_hardware_frontend(); }
+};
+
+template<typename... Ts> class AT581XSettingsAction final : public Action<Ts...>, public Parented<AT581XComponent> {
+ public:
+  TEMPLATABLE_VALUE(int8_t, hw_frontend_reset)
+  TEMPLATABLE_VALUE(int, frequency)
+  TEMPLATABLE_VALUE(int, sensing_distance)
+  TEMPLATABLE_VALUE(int, poweron_selfcheck_time)
+  TEMPLATABLE_VALUE(int, power_consumption)
+  TEMPLATABLE_VALUE(int, protect_time)
+  TEMPLATABLE_VALUE(int, trigger_base)
+  TEMPLATABLE_VALUE(int, trigger_keep)
+  TEMPLATABLE_VALUE(int, stage_gain)
+
+  void play(const Ts &...x) {
+    if (this->frequency_.has_value()) {
+      int v = this->frequency_.value(x...);
+      this->parent_->set_frequency(v);
+    }
+    if (this->sensing_distance_.has_value()) {
+      int v = this->sensing_distance_.value(x...);
+      this->parent_->set_sensing_distance(v);
+    }
+    if (this->poweron_selfcheck_time_.has_value()) {
+      int v = this->poweron_selfcheck_time_.value(x...);
+      this->parent_->set_poweron_selfcheck_time(v);
+    }
+    if (this->power_consumption_.has_value()) {
+      int v = this->power_consumption_.value(x...);
+      this->parent_->set_power_consumption(v);
+    }
+    if (this->protect_time_.has_value()) {
+      int v = this->protect_time_.value(x...);
+      this->parent_->set_protect_time(v);
+    }
+    if (this->trigger_base_.has_value()) {
+      int v = this->trigger_base_.value(x...);
+      this->parent_->set_trigger_base(v);
+    }
+    if (this->trigger_keep_.has_value()) {
+      int v = this->trigger_keep_.value(x...);
+      this->parent_->set_trigger_keep(v);
+    }
+    if (this->stage_gain_.has_value()) {
+      int v = this->stage_gain_.value(x...);
+      this->parent_->set_stage_gain(v);
+    }
+
+    // This actually perform all the modification on the system
+    this->parent_->i2c_write_config();
+
+    if (this->hw_frontend_reset_.has_value() && this->hw_frontend_reset_.value(x...) == true) {
+      this->parent_->reset_hardware_frontend();
+    }
+  }
+};
+}  // namespace esphome::at581x
@@ -339,7 +339,10 @@ async def to_code(config: ConfigType) -> None:
    # HTTPS streams verify the server against the root certificate bundle
    require_certificate_bundle()

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

    data = _get_data()

@@ -203,10 +203,16 @@ void BangBangClimate::set_away_config(const BangBangClimateTargetTempConfig &awa
  this->away_config_ = away_config;
 }

+void BangBangClimate::set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
+void BangBangClimate::set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
+
 Trigger<> *BangBangClimate::get_idle_trigger() { return &this->idle_trigger_; }
 Trigger<> *BangBangClimate::get_cool_trigger() { return &this->cool_trigger_; }
 Trigger<> *BangBangClimate::get_heat_trigger() { return &this->heat_trigger_; }

+void BangBangClimate::set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }
+void BangBangClimate::set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }
+
 void BangBangClimate::dump_config() {
  LOG_CLIMATE("", "Bang Bang Climate", this);
  ESP_LOGCONFIG(TAG,
@@ -22,10 +22,10 @@ class BangBangClimate final : public climate::Climate, public Component {
  void setup() override;
  void dump_config() override;

-  void set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
-  void set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
-  void set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }
-  void set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }
+  void set_sensor(sensor::Sensor *sensor);
+  void set_humidity_sensor(sensor::Sensor *humidity_sensor);
+  void set_supports_cool(bool supports_cool);
+  void set_supports_heat(bool supports_heat);
  void set_normal_config(const BangBangClimateTargetTempConfig &normal_config);
  void set_away_config(const BangBangClimateTargetTempConfig &away_config);

@@ -17,7 +17,11 @@ class BinaryLightOutput final : public light::LightOutput {
  void write_state(light::LightState *state) override {
    bool binary;
    state->current_values_as_binary(&binary);
-    this->output_->set_state(binary);
+    if (binary) {
+      this->output_->turn_on();
+    } else {
+      this->output_->turn_off();
+    }
  }

 protected:
@@ -39,7 +39,6 @@ from esphome.const import (
    DEVICE_CLASS_EMPTY,
    DEVICE_CLASS_GARAGE_DOOR,
    DEVICE_CLASS_GAS,
-    DEVICE_CLASS_GLASS_BREAK,
    DEVICE_CLASS_HEAT,
    DEVICE_CLASS_LIGHT,
    DEVICE_CLASS_LOCK,
@@ -82,7 +81,6 @@ DEVICE_CLASSES = [
    DEVICE_CLASS_EMPTY,
    DEVICE_CLASS_GARAGE_DOOR,
    DEVICE_CLASS_GAS,
-    DEVICE_CLASS_GLASS_BREAK,
    DEVICE_CLASS_HEAT,
    DEVICE_CLASS_LIGHT,
    DEVICE_CLASS_LOCK,
@@ -134,6 +132,9 @@ MultiClickTriggerBase = binary_sensor_ns.class_(
 MultiClickTrigger = binary_sensor_ns.class_("MultiClickTrigger", MultiClickTriggerBase)
 MultiClickTriggerEvent = binary_sensor_ns.struct("MultiClickTriggerEvent")

+BinarySensorPublishAction = binary_sensor_ns.class_(
+    "BinarySensorPublishAction", automation.Action
+)
 BinarySensorInvalidateAction = binary_sensor_ns.class_(
    "BinarySensorInvalidateAction", automation.Action
 )
@@ -451,9 +452,7 @@ _BINARY_SENSOR_SCHEMA = (
            cv.Optional(
                CONF_DEVICE_CLASS, visibility=cv.Visibility.ADVANCED
            ): validate_device_class,
-            cv.Optional(
-                CONF_FILTERS, visibility=cv.Visibility.ADVANCED
-            ): validate_filters,
+            cv.Optional(CONF_FILTERS): validate_filters,
            cv.Optional(CONF_ON_PRESS): automation.validate_automation({}),
            cv.Optional(CONF_ON_RELEASE): automation.validate_automation({}),
            cv.Optional(CONF_ON_CLICK): cv.All(
@@ -165,6 +165,20 @@ template<typename... Ts> class BinarySensorCondition final : public Condition<Ts
  bool state_;
 };

+template<typename... Ts> class BinarySensorPublishAction final : public Action<Ts...> {
+ public:
+  explicit BinarySensorPublishAction(BinarySensor *sensor) : sensor_(sensor) {}
+  TEMPLATABLE_VALUE(bool, state)
+
+  void play(const Ts &...x) override {
+    auto val = this->state_.value(x...);
+    this->sensor_->publish_state(val);
+  }
+
+ protected:
+  BinarySensor *sensor_;
+};
+
 template<typename... Ts> class BinarySensorInvalidateAction final : public Action<Ts...> {
 public:
  explicit BinarySensorInvalidateAction(BinarySensor *sensor) : sensor_(sensor) {}
@@ -32,8 +32,7 @@ void log_binary_sensor(const char *tag, const char *prefix, const char *type, Bi
 */
 class BinarySensor : public StatefulEntityBase<bool> {
 public:
-  // User provided, not "= default": `new(p) BinarySensor()` would zero-fill .bss that is already zero.
-  explicit BinarySensor() {}
+  explicit BinarySensor() = default;

  const bool &get_state() const override { return this->state; }
  void set_trigger_on_initial_state(bool value) { this->trigger_on_initial_state_ = value; }
@@ -53,9 +53,6 @@ class DelayedOnOffFilter final : public Filter {

 class DelayedOnFilter : public Filter {
 public:
-  // User provided, not "= default": `new(p) DelayedOnFilter()` would zero-fill .bss that is already zero.
-  DelayedOnFilter() {}
-
  optional<bool> new_value(bool value) override;

  template<typename T> void set_delay(T delay) { this->delay_ = delay; }
@@ -66,9 +63,6 @@ class DelayedOnFilter : public Filter {

 class DelayedOffFilter : public Filter {
 public:
-  // User provided, not "= default": `new(p) DelayedOffFilter()` would zero-fill .bss that is already zero.
-  DelayedOffFilter() {}
-
  optional<bool> new_value(bool value) override;

  template<typename T> void set_delay(T delay) { this->delay_ = delay; }
@@ -149,8 +143,6 @@ class StatelessLambdaFilter : public Filter {

 class SettleFilter : public Filter {
 public:
-  // User provided, not "= default": `new(p) SettleFilter()` would zero-fill .bss that is already zero.
-  SettleFilter() {}
  optional<bool> new_value(bool value) override;

  template<typename T> void set_delay(T delay) { this->delay_ = delay; }
@@ -23,7 +23,7 @@ public ble_api.h.
 import logging

 import esphome.codegen as cg
-from esphome.components import libretiny, wifi
+from esphome.components import libretiny
 from esphome.components.libretiny.const import (
    FAMILY_BK7231N,
    FAMILY_BK7231Q,
@@ -84,15 +84,6 @@ def _final_validate(config: ConfigType) -> None:
    # which run on a BLE 4.2 board. The hard error is raised at codegen.
    if msg := _unsupported_family_message(libretiny.get_libretiny_family()):
        _LOGGER.warning("%s (this configuration cannot compile)", msg)
-    # Any wifi power_save_mode other than NONE also arms the Beken SDK's MCU
-    # sleep. With the BLE controller running, that sleep never wakes up once the
-    # station is stopped (adapter restart after failed roams, wifi.disable): the
-    # device is dead until a power cycle (esphome#18592). Keep power save off
-    # until LibreTiny ships the SDK-side fix (libretiny-eu/libretiny#414).
-    wifi.force_power_save_off(
-        "with BLE running, the Beken SDK's MCU sleep halts the device once the "
-        "station is stopped (https://github.com/esphome/esphome/issues/18592)"
-    )


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -53,6 +53,7 @@ BK72xxBLETracker = bk72xx_ble_tracker_ns.class_(
 )

 StartScanAction = bk72xx_ble_tracker_ns.class_("StartScanAction", automation.Action)
+StopScanAction = bk72xx_ble_tracker_ns.class_("StopScanAction", automation.Action)

 ESPBTAdvertiseTrigger = ble_automation.ESPBTAdvertiseTrigger
 BLEServiceDataAdvertiseTrigger = ble_automation.BLEServiceDataAdvertiseTrigger
@@ -120,8 +121,9 @@ async def start_scan_action_to_code(
    return var


-automation.register_apply_action(
+@automation.register_action(
    "bk72xx_ble_tracker.stop_scan",
+    StopScanAction,
    automation.maybe_simple_id(
        cv.Schema(
            {
@@ -129,8 +131,17 @@ automation.register_apply_action(
            }
        )
    ),
-    automation.ApplyCall("stop_scan()"),
+    synchronous=True,
 )
+async def stop_scan_action_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: list,
+) -> cg.MockObj:
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var


 async def to_code(config: ConfigType) -> None:
@@ -38,6 +38,11 @@ template<typename... Ts> class StartScanAction final : public Action<Ts...>, pub
  }
 };

+template<typename... Ts> class StopScanAction final : public Action<Ts...>, public Parented<BK72xxBLETracker> {
+ public:
+  void play(const Ts &...x) override { this->parent_->stop_scan(); }
+};
+
 }  // namespace esphome::bk72xx_ble_tracker

 #endif  // USE_LIBRETINY
@@ -45,7 +45,15 @@ void BluedroidGattClient::setup() {

 void BluedroidGattClient::loop() {
  if (!esp32_ble::global_ble->is_active()) {
-    // ble_before_disabled_event_handler() settles the slot.
+    // Stack down: no CLOSE_EVT will come. Settle a live link so the consumer
+    // frees its slot, then re-register the app on the next enable.
+    auto down_st = this->state();
+    if (down_st != ClientState::IDLE && down_st != ClientState::INIT) {
+      this->release_services();
+      this->set_idle_();
+      this->listener_->on_connection_state(false, 0, ble_device_base::GATT_ERR_NOT_CONNECTED);
+    }
+    this->set_state(ClientState::INIT);
    return;
  }
  auto st = this->state();
@@ -57,7 +65,7 @@ void BluedroidGattClient::loop() {
      ESP_LOGE(TAG, "gattc app register failed: app_id=%d code=%d", this->app_id, ret);
      this->mark_failed();
    }
-    // Do not wait for REG_EVT; connect() rejects until it lands.
+    // Do not wait for REG_EVT; a dropped event must not wedge the slot.
    this->set_idle_();
  } else if (st == ClientState::DISCONNECTING || this->disconnect_pending()) {
    // The one teardown safety net: a lost CLOSE_EVT, or a scheduled
@@ -70,8 +78,8 @@ void BluedroidGattClient::loop() {
      this->listener_->on_connection_state(false, 0, ESP_GATT_CONN_TIMEOUT);
    }
  } else {
-    // The loop stays on while a link exists (pre-started search flush); it
-    // settles only back at IDLE.
+    // The loop stays on while a link exists (stack-down watch, pre-started
+    // search flush); it settles only back at IDLE.
    this->deliver_pending_search_();
    if (this->state() == ClientState::IDLE) {
      this->disable_loop();
@@ -79,22 +87,6 @@ void BluedroidGattClient::loop() {
  }
 }

-// Stack down: no CLOSE_EVT will come. Settle a live link so the consumer
-// frees its slot, then register the app again on the next enable.
-void BluedroidGattClient::ble_before_disabled_event_handler() {
-  auto st = this->state();
-  if (st != ClientState::IDLE && st != ClientState::INIT) {
-    this->release_services();
-    this->set_idle_();
-    this->listener_->on_connection_state(false, 0, ble_device_base::GATT_ERR_NOT_CONNECTED);
-  }
-  // The interface belongs to the torn-down stack.
-  this->gattc_if_ = ESP_GATT_IF_NONE;
-  this->set_state(ClientState::INIT);
-  // An idle slot runs no loop; the INIT branch must run to register again.
-  this->enable_loop();
-}
-
 void BluedroidGattClient::dump_config() {
  ESP_LOGCONFIG(TAG, "Bluedroid GATT client %d", this->connection_index_);
  if (this->is_failed()) {
@@ -105,11 +97,6 @@ void BluedroidGattClient::dump_config() {
 // ---- contract ops ----

 int BluedroidGattClient::connect(uint64_t address, uint8_t addr_type) {
-  if (this->gattc_if_ == ESP_GATT_IF_NONE) {
-    // Bluedroid drops an open on an unknown interface without any event.
-    ESP_LOGW(TAG, "[%d] Connect rejected, GATT app not registered", this->connection_index_);
-    return ble_device_base::GATT_ERR_NOT_CONNECTED;
-  }
  // Only from idle: clobbering DISCONNECTING would open a new link the
  // stale CLOSE_EVT then tears down.
  if (this->state() != ClientState::IDLE) {
@@ -31,9 +31,6 @@ class BluetoothConnection;
 // void disconnect() cannot overload with an int-returning twin.
 class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public Component {
 public:
-  // User provided, not "= default": `new(p) BluedroidGattClient()` would zero-fill .bss that is already zero.
-  BluedroidGattClient() {}
-
  static constexpr uint16_t UNSET_CONN_ID = 0xFFFF;

  // Lifecycle of one connection attempt's service search.
@@ -59,7 +56,6 @@ class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public
  void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) override;
  void connect() override;
  void disconnect() override;
-  void ble_before_disabled_event_handler() override;
  bool wants_parsed_advertisements() override { return false; }
  void on_scan_end() override {}
  bool parse_device(const ble_device_base::ESPBTDevice &device) override { return false; }
@@ -37,9 +37,6 @@ enum class PendingAck : uint8_t {

 class BluetoothConnection final : public ble_device_base::GattClientListener {
 public:
-  // User provided, not "= default": `new(p) BluetoothConnection()` would zero-fill .bss that is already zero.
-  BluetoothConnection() {}
-
  /// Wire the platform backend. Called from codegen before setup.
  void set_backend(ble_device_base::BLEGattConnection *backend) {
    this->backend_ = backend;
@@ -626,7 +626,7 @@ void RP2GattClient::handle_connected_(uint8_t status, uint16_t con_handle) {
  // explicit kick the MTU would only be exchanged on the first GATT query,
  // which never happens on a V3_WITH_CACHE connection.
  // Both registration calls above return void (BTstack 075a078, arduino-pico
-  // 6.1.0); failures surface as a missing GATT_EVENT_MTU and are reclaimed by
+  // 6.0.0); failures surface as a missing GATT_EVENT_MTU and are reclaimed by
  // the connect timeout in loop().
  gatt_client_send_mtu_negotiation(&RP2GattClient::gatt_packet_handler, this->con_handle_);
 }
@@ -395,17 +395,6 @@ async def _to_code_ble_hub(config: ConfigType) -> None:
    await _connections_to_code(var, config)


-def enable_advertisement_filter() -> None:
-    """Compile the advertisement filter hook into bluetooth_proxy.
-
-    Called by external filtering components from to_code(). The define behind
-    this is an implementation detail; do not emit it directly.
-
-    Public API for external components. Do not remove.
-    """
-    cg.add_define("USE_BLUETOOTH_PROXY_ADVERTISEMENT_FILTER")
-
-
 async def to_code(config: ConfigType) -> None:
    if CORE.is_esp32:
        await _to_code_esp32(config)
@@ -94,15 +94,6 @@ void BluetoothProxy::on_raw_advertisement_(const ble_device_base::RawAdvertiseme
  if (!api::global_api_server->is_connected() || this->api_connection_ == nullptr)
    return;

-#ifdef USE_BLUETOOTH_PROXY_ADVERTISEMENT_FILTER
-  // Ask the filter before the packet is queued, so a dropped advertisement never
-  // reaches the batch or the network.
-  if (this->advertisement_filter_.is_set() && !this->advertisement_filter_.should_forward(raw)) {
-    ESP_LOGVV(TAG, "Filtered packet from %012" PRIX64, raw.address);
-    return;
-  }
-#endif
-
  auto &adv = this->response_.advertisements[this->response_.advertisements_len];
  adv.address = raw.address;
  adv.rssi = raw.rssi;
@@ -193,9 +184,6 @@ void BluetoothProxy::dump_config() {
                "  Adapter MAC: %s",
                scan_mode, mac_out);
 #endif
-#ifdef USE_BLUETOOTH_PROXY_ADVERTISEMENT_FILTER
-  ESP_LOGCONFIG(TAG, "  Advertisement filter: %s", YESNO(this->advertisement_filter_.is_set()));
-#endif
 }

 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
@@ -97,29 +97,6 @@ static_assert(pending_reply_round_trips(0xABCD112233445566ULL, 0x000011223344556
 static_assert(PendingReply{}.empty());
 #endif

-#ifdef USE_BLUETOOTH_PROXY_ADVERTISEMENT_FILTER
-/// Predicate slot letting an external component drop advertisements before they
-/// are queued for the API. Same shape as
-/// ble_device_base::RawAdvertisementCallback. Runs on the advertisement hot
-/// path, so it must be cheap and must not block.
-///
-/// Usage:
-///   proxy->set_advertisement_filter({this, [](void *self, const ble_device_base::RawAdvertisement &adv) {
-///     return static_cast<MyFilter *>(self)->should_forward(adv);
-///   }});
-///
-/// Returning false drops the advertisement. Not called at all while the API is
-/// disconnected, which matters to a stateful filter. Compiled in only when an
-/// external component calls bluetooth_proxy.enable_advertisement_filter().
-struct AdvertisementFilter {
-  void *instance{nullptr};
-  bool (*fn)(void *instance, const ble_device_base::RawAdvertisement &adv){nullptr};
-  /// A default-constructed slot is "no filter"; the proxy guards on this.
-  bool is_set() const { return this->fn != nullptr; }
-  bool should_forward(const ble_device_base::RawAdvertisement &adv) const { return this->fn(this->instance, adv); }
-};
-#endif  // USE_BLUETOOTH_PROXY_ADVERTISEMENT_FILTER
-
 class BluetoothProxy final : public Component {
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
  // Allow the connection to update connections_free_response_
@@ -185,11 +162,6 @@ class BluetoothProxy final : public Component {
  void set_active(bool active) { this->active_ = active; }
  bool has_active() { return this->active_; }

-#ifdef USE_BLUETOOTH_PROXY_ADVERTISEMENT_FILTER
-  /// One subscriber; a later call replaces an earlier one.
-  void set_advertisement_filter(AdvertisementFilter filter) { this->advertisement_filter_ = filter; }
-#endif
-
  uint32_t get_legacy_version() const {
    if (!this->active_) {
      return LEGACY_PASSIVE_ONLY_VERSION;
@@ -358,10 +330,6 @@ class BluetoothProxy final : public Component {
  // start on an even word, closing two alignment holes.
  uint32_t last_advertisement_flush_time_{0};

-#ifdef USE_BLUETOOTH_PROXY_ADVERTISEMENT_FILTER
-  AdvertisementFilter advertisement_filter_{};
-#endif
-
  // BLE advertisement batching
  api::BluetoothLERawAdvertisementsResponse response_;

@@ -341,6 +341,7 @@ void BME280Component::set_pressure_oversampling(BME280Oversampling pressure_over
 void BME280Component::set_humidity_oversampling(BME280Oversampling humidity_over_sampling) {
  this->humidity_oversampling_ = humidity_over_sampling;
 }
+void BME280Component::set_iir_filter(BME280IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
 uint8_t BME280Component::read_u8_(uint8_t a_register) {
  uint8_t data = 0;
  this->read_byte(a_register, &data);
@@ -69,7 +69,7 @@ class BME280Component : public PollingComponent {
  /// Set the oversampling value for the humidity sensor. Default is 16x.
  void set_humidity_oversampling(BME280Oversampling humidity_over_sampling);
  /// Set the IIR Filter used to increase accuracy, defaults to no IIR Filter.
-  void set_iir_filter(BME280IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
+  void set_iir_filter(BME280IIRFilter iir_filter);

  // ========== INTERNAL METHODS ==========
  // (In most use cases you won't need these)
@@ -503,6 +503,7 @@ void BME680Component::set_pressure_oversampling(BME680Oversampling pressure_over
 void BME680Component::set_humidity_oversampling(BME680Oversampling humidity_oversampling) {
  this->humidity_oversampling_ = humidity_oversampling;
 }
+void BME680Component::set_iir_filter(BME680IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
 void BME680Component::set_heater(uint16_t heater_temperature, uint16_t heater_duration) {
  this->heater_temperature_ = heater_temperature;
  this->heater_duration_ = heater_duration;
@@ -74,7 +74,7 @@ class BME680Component final : public PollingComponent, public i2c::I2CDevice {
  /// Set the humidity oversampling value. Defaults to 16X.
  void set_humidity_oversampling(BME680Oversampling humidity_oversampling);
  /// Set the IIR Filter value. Defaults to no IIR Filter.
-  void set_iir_filter(BME680IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
+  void set_iir_filter(BME680IIRFilter iir_filter);

  void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
  void set_pressure_sensor(sensor::Sensor *pressure_sensor) { pressure_sensor_ = pressure_sensor; }
@@ -254,6 +254,7 @@ void BMP280Component::set_temperature_oversampling(BMP280Oversampling temperatur
 void BMP280Component::set_pressure_oversampling(BMP280Oversampling pressure_over_sampling) {
  this->pressure_oversampling_ = pressure_over_sampling;
 }
+void BMP280Component::set_iir_filter(BMP280IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
 uint8_t BMP280Component::read_u8_(uint8_t a_register) {
  uint8_t data = 0;
  this->bmp_read_byte(a_register, &data);
@@ -59,7 +59,7 @@ class BMP280Component : public PollingComponent {
  /// Set the oversampling value for the pressure sensor. Default is 16x.
  void set_pressure_oversampling(BMP280Oversampling pressure_over_sampling);
  /// Set the IIR Filter used to increase accuracy, defaults to no IIR Filter.
-  void set_iir_filter(BMP280IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
+  void set_iir_filter(BMP280IIRFilter iir_filter);

  void setup() override;
  void dump_config() override;
@@ -424,41 +424,91 @@ async def send_packet_action_to_code(config, action_id, template_arg, args):
    return var


-_CONFIG_VALIDATORS = {opt.schema: validator for opt, validator in CONFIG_MAP.items()}
-
-# Each key has a set_<key> action validated exactly like the config option.
-_SETTER_ACTIONS = (
-    (CONF_FREQUENCY, cg.float_),
-    (CONF_OUTPUT_POWER, cg.float_),
-    (CONF_MODULATION_TYPE, Modulation),
-    (CONF_SYMBOL_RATE, cg.float_),
-    (CONF_RX_ATTENUATION, RxAttenuation),
-    (CONF_DC_BLOCKING_FILTER, cg.bool_),
-    (CONF_MANCHESTER, cg.bool_),
-    (CONF_FILTER_BANDWIDTH, cg.float_),
-    (CONF_FSK_DEVIATION, cg.float_),
-    (CONF_MSK_DEVIATION, cg.uint8),
-    (CONF_CHANNEL, cg.uint8),
-    (CONF_CHANNEL_SPACING, cg.float_),
-    (CONF_IF_FREQUENCY, cg.float_),
-)
+# Setter action definitions: (setter_name, validator, template_type, enum_map)
+_SETTER_ACTIONS = [
+    (
+        "set_frequency",
+        cv.All(cv.frequency, cv.float_range(min=300.0e6, max=928.0e6)),
+        float,
+        None,
+    ),
+    ("set_output_power", cv.float_range(min=-30.0, max=11.0), float, None),
+    ("set_modulation_type", cv.enum(MODULATION, upper=False), Modulation, MODULATION),
+    ("set_symbol_rate", cv.float_range(min=600, max=500000), float, None),
+    (
+        "set_rx_attenuation",
+        cv.enum(RX_ATTENUATION, upper=False),
+        RxAttenuation,
+        RX_ATTENUATION,
+    ),
+    ("set_dc_blocking_filter", cv.boolean, bool, None),
+    ("set_manchester", cv.boolean, bool, None),
+    (
+        "set_filter_bandwidth",
+        cv.All(cv.frequency, cv.float_range(min=58000, max=812000)),
+        float,
+        None,
+    ),
+    (
+        "set_fsk_deviation",
+        cv.All(cv.frequency, cv.float_range(min=1500, max=381000)),
+        float,
+        None,
+    ),
+    ("set_msk_deviation", cv.int_range(min=1, max=8), cg.uint8, None),
+    ("set_channel", cv.uint8_t, cg.uint8, None),
+    (
+        "set_channel_spacing",
+        cv.All(cv.frequency, cv.float_range(min=25000, max=405000)),
+        float,
+        None,
+    ),
+    (
+        "set_if_frequency",
+        cv.All(cv.frequency, cv.float_range(min=25000, max=788000)),
+        float,
+        None,
+    ),
+]


-def _register_setter_actions() -> None:
-    for conf_key, value_type in _SETTER_ACTIONS:
-        automation.register_apply_action(
-            f"cc1101.set_{conf_key}",
-            cv.maybe_simple_value(
-                {
-                    cv.GenerateID(): cv.use_id(CC1101Component),
-                    cv.Required(CONF_VALUE): cv.templatable(
-                        _CONFIG_VALIDATORS[conf_key]
-                    ),
-                },
-                key=CONF_VALUE,
-            ),
-            automation.ApplyField(CONF_VALUE, f"set_{conf_key}", value_type),
+def _register_setter_actions():
+    for setter_name, validator, templ_type, enum_map in _SETTER_ACTIONS:
+        class_name = (
+            "".join(word.capitalize() for word in setter_name.split("_")) + "Action"
        )
+        action_cls = ns.class_(
+            class_name, automation.Action, cg.Parented.template(CC1101Component)
+        )
+        schema = cv.maybe_simple_value(
+            {
+                cv.GenerateID(): cv.use_id(CC1101Component),
+                cv.Required(CONF_VALUE): cv.templatable(validator),
+            },
+            key=CONF_VALUE,
+        )
+
+        async def _setter_action_to_code(
+            config,
+            action_id,
+            template_arg,
+            args,
+            _setter=setter_name,
+            _type=templ_type,
+            _map=enum_map,
+        ):
+            var = cg.new_Pvariable(action_id, template_arg)
+            await cg.register_parented(var, config[CONF_ID])
+            data = config[CONF_VALUE]
+            if _map and not cg.is_template(data):
+                data = _map[data]
+            templ_ = await cg.templatable(data, args, _type)
+            cg.add(getattr(var, _setter)(templ_))
+            return var
+
+        automation.register_action(
+            f"cc1101.{setter_name}", action_cls, schema, synchronous=True
+        )(_setter_action_to_code)


 _register_setter_actions()
@@ -174,4 +174,83 @@ template<typename... Ts> class SendPacketAction final : public Action<Ts...>, pu
  size_t data_static_len_{0};
 };

+template<typename... Ts> class SetSymbolRateAction final : public Action<Ts...>, public Parented<CC1101Component> {
+ public:
+  TEMPLATABLE_VALUE(float, symbol_rate)
+  void play(const Ts &...x) override { this->parent_->set_symbol_rate(this->symbol_rate_.value(x...)); }
+};
+
+template<typename... Ts> class SetFrequencyAction final : public Action<Ts...>, public Parented<CC1101Component> {
+ public:
+  TEMPLATABLE_VALUE(float, frequency)
+  void play(const Ts &...x) override { this->parent_->set_frequency(this->frequency_.value(x...)); }
+};
+
+template<typename... Ts> class SetOutputPowerAction final : public Action<Ts...>, public Parented<CC1101Component> {
+ public:
+  TEMPLATABLE_VALUE(float, output_power)
+  void play(const Ts &...x) override { this->parent_->set_output_power(this->output_power_.value(x...)); }
+};
+
+template<typename... Ts> class SetModulationTypeAction final : public Action<Ts...>, public Parented<CC1101Component> {
+ public:
+  TEMPLATABLE_VALUE(Modulation, modulation_type)
+  void play(const Ts &...x) override { this->parent_->set_modulation_type(this->modulation_type_.value(x...)); }
+};
+
+template<typename... Ts> class SetRxAttenuationAction final : public Action<Ts...>, public Parented<CC1101Component> {
+ public:
+  TEMPLATABLE_VALUE(RxAttenuation, rx_attenuation)
+  void play(const Ts &...x) override { this->parent_->set_rx_attenuation(this->rx_attenuation_.value(x...)); }
+};
+
+template<typename... Ts>
+class SetDcBlockingFilterAction final : public Action<Ts...>, public Parented<CC1101Component> {
+ public:
+  TEMPLATABLE_VALUE(bool, dc_blocking_filter)
+  void play(const Ts &...x) override { this->parent_->set_dc_blocking_filter(this->dc_blocking_filter_.value(x...)); }
+};
+
+template<typename... Ts> class SetManchesterAction final : public Action<Ts...>, public Parented<CC1101Component> {
+ public:
+  TEMPLATABLE_VALUE(bool, manchester)
+  void play(const Ts &...x) override { this->parent_->set_manchester(this->manchester_.value(x...)); }
+};
+
+template<typename... Ts> class SetFilterBandwidthAction final : public Action<Ts...>, public Parented<CC1101Component> {
+ public:
+  TEMPLATABLE_VALUE(float, filter_bandwidth)
+  void play(const Ts &...x) override { this->parent_->set_filter_bandwidth(this->filter_bandwidth_.value(x...)); }
+};
+
+template<typename... Ts> class SetFskDeviationAction final : public Action<Ts...>, public Parented<CC1101Component> {
+ public:
+  TEMPLATABLE_VALUE(float, fsk_deviation)
+  void play(const Ts &...x) override { this->parent_->set_fsk_deviation(this->fsk_deviation_.value(x...)); }
+};
+
+template<typename... Ts> class SetMskDeviationAction final : public Action<Ts...>, public Parented<CC1101Component> {
+ public:
+  TEMPLATABLE_VALUE(uint8_t, msk_deviation)
+  void play(const Ts &...x) override { this->parent_->set_msk_deviation(this->msk_deviation_.value(x...)); }
+};
+
+template<typename... Ts> class SetChannelAction final : public Action<Ts...>, public Parented<CC1101Component> {
+ public:
+  TEMPLATABLE_VALUE(uint8_t, channel)
+  void play(const Ts &...x) override { this->parent_->set_channel(this->channel_.value(x...)); }
+};
+
+template<typename... Ts> class SetChannelSpacingAction final : public Action<Ts...>, public Parented<CC1101Component> {
+ public:
+  TEMPLATABLE_VALUE(float, channel_spacing)
+  void play(const Ts &...x) override { this->parent_->set_channel_spacing(this->channel_spacing_.value(x...)); }
+};
+
+template<typename... Ts> class SetIfFrequencyAction final : public Action<Ts...>, public Parented<CC1101Component> {
+ public:
+  TEMPLATABLE_VALUE(float, if_frequency)
+  void play(const Ts &...x) override { this->parent_->set_if_frequency(this->if_frequency_.value(x...)); }
+};
+
 }  // namespace esphome::cc1101
@@ -30,7 +30,6 @@ class CDCACMUARTBridge final : public Component {

  void set_line_coding();
  void set_line_state(bool dtr, bool rts);
-  uart::IDFUARTComponent *get_uart_parent() const { return this->uart_parent_; }

  /**
   * Stop forwarding in both directions and hand the UART back to its configured
@@ -50,13 +50,18 @@ from esphome.const import (
    CONF_VISUAL,
    CONF_WEB_SERVER,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, ID, CoroPriority, Lambda, coroutine_with_priority
 from esphome.core.entity_helpers import (
    entity_duplicate_validator,
    queue_entity_register,
    setup_entity,
 )
-from esphome.cpp_generator import MockObj, MockObjClass
+from esphome.cpp_generator import (
+    LambdaExpression,
+    MockObj,
+    MockObjClass,
+    TemplateArgsType,
+)
 from esphome.types import ConfigType, SafeExpType

 IS_PLATFORM_COMPONENT = True
@@ -164,6 +169,7 @@ def visual_temperature_step(value: Any) -> ConfigType:


 # Actions
+ControlAction = climate_ns.class_("ControlAction", automation.Action)
 StateTrigger = climate_ns.class_(
    "StateTrigger", automation.Trigger.template(Climate.operator("ref"))
 )
@@ -494,41 +500,78 @@ CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema(
 )


-def _literal_with_length(config: ConfigType, value: str) -> str:
-    # The (const char *, size_t) overload compares bytes in place, so it needs a plain
-    # literal rather than the default PROGMEM rendering on ESP8266, and skips a strlen.
-    return f"{cg.safe_exp(value)}, {len(value.encode('utf-8'))}"
-
-
-automation.register_apply_action(
+@automation.register_action(
    "climate.control",
+    ControlAction,
    CLIMATE_CONTROL_ACTION_SCHEMA,
-    automation.ApplyField(CONF_MODE, "set_mode", ClimateMode),
-    automation.ApplyField(CONF_TARGET_TEMPERATURE, "set_target_temperature", cg.float_),
-    automation.ApplyField(
-        CONF_TARGET_TEMPERATURE_LOW, "set_target_temperature_low", cg.float_
-    ),
-    automation.ApplyField(
-        CONF_TARGET_TEMPERATURE_HIGH, "set_target_temperature_high", cg.float_
-    ),
-    automation.ApplyField(CONF_TARGET_HUMIDITY, "set_target_humidity", cg.float_),
-    automation.ApplyField(CONF_FAN_MODE, "set_fan_mode", ClimateFanMode),
-    automation.ApplyField(
-        CONF_CUSTOM_FAN_MODE,
-        "set_fan_mode",
-        cg.std_string,
-        const_fn=_literal_with_length,
-    ),
-    automation.ApplyField(CONF_PRESET, "set_preset", ClimatePreset),
-    automation.ApplyField(
-        CONF_CUSTOM_PRESET,
-        "set_preset",
-        cg.std_string,
-        const_fn=_literal_with_length,
-    ),
-    automation.ApplyField(CONF_SWING_MODE, "set_swing_mode", ClimateSwingMode),
-    call="make_call",
+    synchronous=True,
 )
+async def climate_control_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+
+    # All configured fields are folded into a single stateless lambda whose
+    # constants live in flash; the action stores only a function pointer.
+    # For custom_fan_mode/custom_preset the static-string path emits the
+    # (const char *, size_t) overload of set_fan_mode/set_preset to avoid
+    # constructing a std::string and calling runtime strlen.
+    FIELDS = (
+        (CONF_MODE, "set_mode", ClimateMode),
+        (CONF_TARGET_TEMPERATURE, "set_target_temperature", cg.float_),
+        (CONF_TARGET_TEMPERATURE_LOW, "set_target_temperature_low", cg.float_),
+        (CONF_TARGET_TEMPERATURE_HIGH, "set_target_temperature_high", cg.float_),
+        (CONF_TARGET_HUMIDITY, "set_target_humidity", cg.float_),
+        (CONF_FAN_MODE, "set_fan_mode", ClimateFanMode),
+        (CONF_CUSTOM_FAN_MODE, "set_fan_mode", cg.std_string),
+        (CONF_PRESET, "set_preset", ClimatePreset),
+        (CONF_CUSTOM_PRESET, "set_preset", cg.std_string),
+        (CONF_SWING_MODE, "set_swing_mode", ClimateSwingMode),
+    )
+
+    # Normalize trigger args to `const std::remove_cvref_t<T> &` so the
+    # apply lambda and any inner field lambdas (generated below via
+    # `process_lambda`) share one parameter spelling that's well-formed for
+    # any T (value, ref, or const-ref). Matches ControlAction::ApplyFn.
+    normalized_args = [
+        (cg.RawExpression(f"const std::remove_cvref_t<{cg.safe_exp(t)}> &"), n)
+        for t, n in args
+    ]
+
+    fwd_args = ", ".join(name for _, name in args)
+    body_lines: list[str] = []
+
+    for conf_key, setter, type_ in FIELDS:
+        if (value := config.get(conf_key)) is None:
+            continue
+        if isinstance(value, Lambda):
+            inner = await cg.process_lambda(value, normalized_args, return_type=type_)
+            body_lines.append(f"call.{setter}(({inner})({fwd_args}));")
+        elif type_ is cg.std_string:
+            # Static custom strings: emit a flash literal and pass the
+            # UTF-8 byte length to skip the runtime strlen inside
+            # set_fan_mode/set_preset.
+            literal = cg.safe_exp(value)
+            body_lines.append(
+                f"call.{setter}({literal}, {len(value.encode('utf-8'))});"
+            )
+        else:
+            body_lines.append(f"call.{setter}({cg.safe_exp(value)});")
+
+    apply_args = [
+        (ClimateCall.operator("ref"), "call"),
+        *normalized_args,
+    ]
+    apply_lambda = LambdaExpression(
+        ["\n".join(body_lines)],
+        apply_args,
+        capture="",
+        return_type=cg.void,
+    )
+    return cg.new_Pvariable(action_id, template_arg, paren, apply_lambda)


@coroutine_with_priority(CoroPriority.CORE)
@@ -5,6 +5,34 @@

 namespace esphome::climate {

+// All configured fields are baked into a single stateless lambda whose
+// constants live in flash. The action only stores one function pointer
+// plus one parent pointer, regardless of how many fields the user set.
+// Trigger args are forwarded to the apply function so user lambdas
+// (e.g. `target_temperature: !lambda "return x;"`) keep working.
+//
+// Trigger args are normalized to `const std::remove_cvref_t<Ts> &...` so
+// the codegen can emit a matching parameter list for both the apply lambda
+// and any inner field lambdas without producing invalid C++ source text
+// (e.g. `const T & &` if Ts already carries a reference, or `const const
+// T &` if Ts already carries a const). This keeps trigger args no-copy
+// regardless of whether the trigger supplies `T`, `T &`, or `const T &`.
+template<typename... Ts> class ControlAction final : public Action<Ts...> {
+ public:
+  using ApplyFn = void (*)(ClimateCall &, const std::remove_cvref_t<Ts> &...);
+  ControlAction(Climate *climate, ApplyFn apply) : climate_(climate), apply_(apply) {}
+
+  void play(const Ts &...x) override {
+    auto call = this->climate_->make_call();
+    this->apply_(call, x...);
+    call.perform();
+  }
+
+ protected:
+  Climate *climate_;
+  ApplyFn apply_;
+};
+
 class ControlTrigger final : public Trigger<ClimateCall &> {
 public:
  ControlTrigger(Climate *climate) {
@@ -14,8 +14,6 @@ from esphome.types import ConfigType, SafeExpType

 _LOGGER = logging.getLogger(__name__)

-CONF_SUPPORTS_HEAT_COOL = "supports_heat_cool"
-
 DEPENDENCIES = ["remote_transmitter"]
 AUTO_LOAD = ["sensor", "remote_base"]
 CODEOWNERS = ["@glmnet"]
@@ -39,7 +37,6 @@ def climate_ir_schema(
            {
                cv.Optional(CONF_SUPPORTS_COOL, default=True): cv.boolean,
                cv.Optional(CONF_SUPPORTS_HEAT, default=True): cv.boolean,
-                cv.Optional(CONF_SUPPORTS_HEAT_COOL): cv.boolean,
                cv.Optional(CONF_SENSOR): cv.use_id(sensor.Sensor),
                cv.Optional(CONF_HUMIDITY_SENSOR): cv.use_id(sensor.Sensor),
            }
@@ -64,13 +61,8 @@ def climate_ir_with_receiver_schema(
 async def register_climate_ir(var: MockObj, config: ConfigType) -> None:
    await cg.register_component(var, config)
    await remote_base.register_transmittable(var, config)
-    supports_cool = config[CONF_SUPPORTS_COOL]
-    supports_heat = config[CONF_SUPPORTS_HEAT]
-    cg.add(var.set_supports_cool(supports_cool))
-    cg.add(var.set_supports_heat(supports_heat))
-    # The header default is true, so only the false case needs a call.
-    if not config.get(CONF_SUPPORTS_HEAT_COOL, supports_cool and supports_heat):
-        cg.add(var.set_supports_heat_cool(False))
+    cg.add(var.set_supports_cool(config[CONF_SUPPORTS_COOL]))
+    cg.add(var.set_supports_heat(config[CONF_SUPPORTS_HEAT]))
    if remote_base.CONF_RECEIVER_ID in config:
        await remote_base.register_listener(var, config)
    if sensor_id := config.get(CONF_SENSOR):
@@ -13,13 +13,11 @@ climate::ClimateTraits ClimateIR::traits() {
  if (this->humidity_sensor_ != nullptr) {
    traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_HUMIDITY);
  }
-  traits.set_supported_modes({climate::CLIMATE_MODE_OFF});
+  traits.set_supported_modes({climate::CLIMATE_MODE_OFF, climate::CLIMATE_MODE_HEAT_COOL});
  if (this->supports_cool_)
    traits.add_supported_mode(climate::CLIMATE_MODE_COOL);
  if (this->supports_heat_)
    traits.add_supported_mode(climate::CLIMATE_MODE_HEAT);
-  if (this->supports_heat_cool_)
-    traits.add_supported_mode(climate::CLIMATE_MODE_HEAT_COOL);
  if (this->supports_dry_)
    traits.add_supported_mode(climate::CLIMATE_MODE_DRY);
  if (this->supports_fan_only_)
@@ -96,10 +94,9 @@ void ClimateIR::dump_config() {
                "  Min. Temperature: %.1f°C\n"
                "  Max. Temperature: %.1f°C\n"
                "  Supports HEAT: %s\n"
-                "  Supports COOL: %s\n"
-                "  Supports HEAT_COOL: %s",
+                "  Supports COOL: %s",
                this->minimum_temperature_, this->maximum_temperature_, YESNO(this->supports_heat_),
-                YESNO(this->supports_cool_), YESNO(this->supports_heat_cool_));
+                YESNO(this->supports_cool_));
 }

 }  // namespace esphome::climate_ir
@@ -41,7 +41,6 @@ class ClimateIR : public Component,
  void dump_config() override;
  void set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }
  void set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }
-  void set_supports_heat_cool(bool supports_heat_cool) { this->supports_heat_cool_ = supports_heat_cool; }
  void set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
  void set_humidity_sensor(sensor::Sensor *sensor) { this->humidity_sensor_ = sensor; }

@@ -61,8 +60,6 @@ class ClimateIR : public Component,

  bool supports_cool_{true};
  bool supports_heat_{true};
-  // Default (supports_cool && supports_heat) is resolved during code generation.
-  bool supports_heat_cool_{true};
  bool supports_dry_{false};
  bool supports_fan_only_{false};
  climate::ClimateFanModeMask fan_modes_{};
@@ -13,6 +13,12 @@ void CopySwitch::setup() {

 void CopySwitch::dump_config() { LOG_SWITCH("", "Copy Switch", this); }

-void CopySwitch::write_state(bool state) { this->source_->control(state); }
+void CopySwitch::write_state(bool state) {
+  if (state) {
+    source_->turn_on();
+  } else {
+    source_->turn_off();
+  }
+}

 }  // namespace esphome::copy
@@ -1,7 +1,9 @@
+from collections.abc import Callable
+from dataclasses import dataclass
 import logging

 from esphome import automation
-from esphome.automation import maybe_simple_id
+from esphome.automation import Condition, maybe_simple_id
 import esphome.codegen as cg
 from esphome.components import mqtt, web_server
 import esphome.config_validation as cv
@@ -36,15 +38,15 @@ from esphome.const import (
    DEVICE_CLASS_SHUTTER,
    DEVICE_CLASS_WINDOW,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, ID, CoroPriority, Lambda, coroutine_with_priority
 from esphome.core.entity_helpers import (
    entity_duplicate_validator,
    queue_entity_register,
    setup_device_class,
    setup_entity,
 )
-from esphome.cpp_generator import MockObj, MockObjClass
-from esphome.types import ConfigType, SafeExpType
+from esphome.cpp_generator import LambdaExpression, MockObj, MockObjClass
+from esphome.types import ConfigType, SafeExpType, TemplateArgsType

 IS_PLATFORM_COMPONENT = True

@@ -68,6 +70,7 @@ _LOGGER = logging.getLogger(__name__)
 cover_ns = cg.esphome_ns.namespace("cover")

 Cover = cover_ns.class_("Cover", cg.EntityBase)
+CoverCall = cover_ns.class_("CoverCall")

 COVER_OPEN = cover_ns.COVER_OPEN
 COVER_CLOSED = cover_ns.COVER_CLOSED
@@ -87,6 +90,14 @@ COVER_OPERATIONS = {
 validate_cover_operation = cv.enum(COVER_OPERATIONS, upper=True)

 # Actions
+OpenAction = cover_ns.class_("OpenAction", automation.Action)
+CloseAction = cover_ns.class_("CloseAction", automation.Action)
+StopAction = cover_ns.class_("StopAction", automation.Action)
+ToggleAction = cover_ns.class_("ToggleAction", automation.Action)
+ControlAction = cover_ns.class_("ControlAction", automation.Action)
+CoverPublishAction = cover_ns.class_("CoverPublishAction", automation.Action)
+CoverIsOpenCondition = cover_ns.class_("CoverIsOpenCondition", Condition)
+CoverIsClosedCondition = cover_ns.class_("CoverIsClosedCondition", Condition)
 CoverOpenedTrigger = cover_ns.class_(
    "CoverOpenedTrigger", automation.Trigger.template()
 )
@@ -245,15 +256,56 @@ COVER_ACTION_SCHEMA = maybe_simple_id(
 )


-for _name, _command in (
-    ("cover.open", "set_command_open()"),
-    ("cover.close", "set_command_close()"),
-    ("cover.stop", "set_command_stop()"),
-    ("cover.toggle", "set_command_toggle()"),
-):
-    automation.register_apply_action(
-        _name, COVER_ACTION_SCHEMA, automation.ApplyCall(_command), call="make_call"
-    )
+@automation.register_action(
+    "cover.open", OpenAction, COVER_ACTION_SCHEMA, synchronous=True
+)
+async def cover_open_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)
+
+
+@automation.register_action(
+    "cover.close", CloseAction, COVER_ACTION_SCHEMA, synchronous=True
+)
+async def cover_close_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)
+
+
+@automation.register_action(
+    "cover.stop", StopAction, COVER_ACTION_SCHEMA, synchronous=True
+)
+async def cover_stop_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)
+
+
+@automation.register_action(
+    "cover.toggle", ToggleAction, COVER_ACTION_SCHEMA, synchronous=True
+)
+async def cover_toggle_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)


 COVER_CONTROL_ACTION_SCHEMA = cv.Schema(
@@ -267,30 +319,125 @@ COVER_CONTROL_ACTION_SCHEMA = cv.Schema(
 )


+@dataclass(frozen=True)
+class ApplyField:
+    """One field in a folded-lambda action.
+
+    `conf_key` is the YAML key looked up in `config`. When present, the
+    helper emits `statement_fn(target, value_expr)` into the lambda body.
+    `target` is whatever the statement function needs to identify the
+    field (typically a setter name like `"set_position"` or a struct
+    member like `"position"`). `type_` is the C++ return type for
+    `cg.process_lambda` when the value is a user lambda.
+    """
+
+    conf_key: str
+    target: str
+    type_: object
+
+
+async def build_apply_lambda_action(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+    fields: tuple[ApplyField, ...],
+    prefix_args: list[tuple[object, str]],
+    statement_fn: Callable[[str, str], str],
+) -> MockObj:
+    """Fold configured fields into a single stateless apply lambda action.
+
+    Used by both `cover.control` and `cover.template.publish` (and shared
+    with the template/cover platform). Constants are emitted as flash
+    immediates; user lambdas are invoked inline so trigger args still flow.
+    Trigger arg types are normalized to `const std::remove_cvref_t<T> &`
+    to match the ApplyFn signature for any T (value, ref, or const-ref).
+    """
+    paren = await cg.get_variable(config[CONF_ID])
+    # Normalize trigger args to `const std::remove_cvref_t<T> &` so the
+    # apply lambda and any inner field lambdas (generated below via
+    # `process_lambda`) share one parameter spelling that's well-formed for
+    # any T.
+    normalized_args = [
+        (cg.RawExpression(f"const std::remove_cvref_t<{cg.safe_exp(t)}> &"), n)
+        for t, n in args
+    ]
+
+    fwd_args = ", ".join(name for _, name in args)
+    body_lines: list[str] = []
+    for field in fields:
+        if (value := config.get(field.conf_key)) is None:
+            continue
+        if isinstance(value, Lambda):
+            inner = await cg.process_lambda(
+                value, normalized_args, return_type=field.type_
+            )
+            value_expr = f"({inner})({fwd_args})"
+        else:
+            value_expr = str(cg.safe_exp(value))
+        body_lines.append(statement_fn(field.target, value_expr))
+
+    apply_args = [
+        *prefix_args,
+        *normalized_args,
+    ]
+    apply_lambda = LambdaExpression(
+        ["\n".join(body_lines)],
+        apply_args,
+        capture="",
+        return_type=cg.void,
+    )
+    return cg.new_Pvariable(action_id, template_arg, paren, apply_lambda)
+
+
 # CONF_STATE and CONF_POSITION are cv.Exclusive in the schema, so at most
 # one is present and both dispatch to set_position.
-automation.register_apply_action(
-    "cover.control",
-    COVER_CONTROL_ACTION_SCHEMA,
-    automation.ApplyField(CONF_STOP, "set_stop", cg.bool_),
-    automation.ApplyField(CONF_STATE, "set_position", cg.float_),
-    automation.ApplyField(CONF_POSITION, "set_position", cg.float_),
-    automation.ApplyField(CONF_TILT, "set_tilt", cg.float_),
-    call="make_call",
+_COVER_CONTROL_FIELDS: tuple[ApplyField, ...] = (
+    ApplyField(CONF_STOP, "set_stop", cg.bool_),
+    ApplyField(CONF_STATE, "set_position", cg.float_),
+    ApplyField(CONF_POSITION, "set_position", cg.float_),
+    ApplyField(CONF_TILT, "set_tilt", cg.float_),
 )


+@automation.register_action(
+    "cover.control", ControlAction, COVER_CONTROL_ACTION_SCHEMA, synchronous=True
+)
+async def cover_control_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    return await build_apply_lambda_action(
+        config=config,
+        action_id=action_id,
+        template_arg=template_arg,
+        args=args,
+        fields=_COVER_CONTROL_FIELDS,
+        prefix_args=[(CoverCall.operator("ref"), "call")],
+        statement_fn=lambda setter, expr: f"call.{setter}({expr});",
+    )
+
+
 COVER_CONDITION_SCHEMA = cv.maybe_simple_value(
    {cv.Required(CONF_ID): cv.use_id(Cover)}, key=CONF_ID
 )


-automation.register_apply_condition(
-    "cover.is_open", COVER_CONDITION_SCHEMA, f"position == {COVER_OPEN}"
-)
-automation.register_apply_condition(
-    "cover.is_closed", COVER_CONDITION_SCHEMA, f"position == {COVER_CLOSED}"
-)
+async def cover_condition_to_code(
+    config: ConfigType, condition_id: ID, template_arg: MockObj, args: TemplateArgsType
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren)
+
+
+automation.register_condition(
+    "cover.is_open", CoverIsOpenCondition, COVER_CONDITION_SCHEMA
+)(cover_condition_to_code)
+automation.register_condition(
+    "cover.is_closed", CoverIsClosedCondition, COVER_CONDITION_SCHEMA
+)(cover_condition_to_code)


@coroutine_with_priority(CoroPriority.CORE)
@@ -6,6 +6,103 @@

 namespace esphome::cover {

+template<typename... Ts> class OpenAction final : public Action<Ts...> {
+ public:
+  explicit OpenAction(Cover *cover) : cover_(cover) {}
+
+  void play(const Ts &...x) override { this->cover_->make_call().set_command_open().perform(); }
+
+ protected:
+  Cover *cover_;
+};
+
+template<typename... Ts> class CloseAction final : public Action<Ts...> {
+ public:
+  explicit CloseAction(Cover *cover) : cover_(cover) {}
+
+  void play(const Ts &...x) override { this->cover_->make_call().set_command_close().perform(); }
+
+ protected:
+  Cover *cover_;
+};
+
+template<typename... Ts> class StopAction final : public Action<Ts...> {
+ public:
+  explicit StopAction(Cover *cover) : cover_(cover) {}
+
+  void play(const Ts &...x) override { this->cover_->make_call().set_command_stop().perform(); }
+
+ protected:
+  Cover *cover_;
+};
+
+template<typename... Ts> class ToggleAction final : public Action<Ts...> {
+ public:
+  explicit ToggleAction(Cover *cover) : cover_(cover) {}
+
+  void play(const Ts &...x) override { this->cover_->make_call().set_command_toggle().perform(); }
+
+ protected:
+  Cover *cover_;
+};
+
+// All configured fields are baked into a single stateless lambda whose
+// constants live in flash. Each action stores only one function pointer
+// plus one parent pointer, regardless of how many fields the user set.
+// Trigger args are forwarded to the apply function so user lambdas
+// (e.g. `position: !lambda "return x;"`) keep working.
+//
+// Trigger args are normalized to `const std::remove_cvref_t<Ts> &...` so
+// the codegen can emit a matching parameter list for both the apply lambda
+// and any inner field lambdas without producing invalid C++ source text
+// (e.g. `const T & &` if Ts already carries a reference, or `const const
+// T &` if Ts already carries a const). This keeps trigger args no-copy
+// regardless of whether the trigger supplies `T`, `T &`, or `const T &`.
+
+template<typename... Ts> class ControlAction final : public Action<Ts...> {
+ public:
+  using ApplyFn = void (*)(CoverCall &, const std::remove_cvref_t<Ts> &...);
+  ControlAction(Cover *cover, ApplyFn apply) : cover_(cover), apply_(apply) {}
+
+  void play(const Ts &...x) override {
+    auto call = this->cover_->make_call();
+    this->apply_(call, x...);
+    call.perform();
+  }
+
+ protected:
+  Cover *cover_;
+  ApplyFn apply_;
+};
+
+template<typename... Ts> class CoverPublishAction final : public Action<Ts...> {
+ public:
+  using ApplyFn = void (*)(Cover *, const std::remove_cvref_t<Ts> &...);
+  CoverPublishAction(Cover *cover, ApplyFn apply) : cover_(cover), apply_(apply) {}
+
+  void play(const Ts &...x) override {
+    this->apply_(this->cover_, x...);
+    this->cover_->publish_state();
+  }
+
+ protected:
+  Cover *cover_;
+  ApplyFn apply_;
+};
+
+template<bool OPEN, typename... Ts> class CoverPositionCondition final : public Condition<Ts...> {
+ public:
+  CoverPositionCondition(Cover *cover) : cover_(cover) {}
+
+  bool check(const Ts &...x) override { return this->cover_->position == (OPEN ? COVER_OPEN : COVER_CLOSED); }
+
+ protected:
+  Cover *cover_;
+};
+
+template<typename... Ts> using CoverIsOpenCondition = CoverPositionCondition<true, Ts...>;
+template<typename... Ts> using CoverIsClosedCondition = CoverPositionCondition<false, Ts...>;
+
 template<bool OPEN> class CoverPositionTrigger final : public Trigger<> {
 public:
  CoverPositionTrigger(Cover *a_cover) : cover_(a_cover) {
@@ -1,5 +1,3 @@
-from collections.abc import Callable
-
 from esphome import automation
 import esphome.codegen as cg
 from esphome.components import mqtt, time, web_server
@@ -23,13 +21,13 @@ from esphome.const import (
    CONF_WEB_SERVER,
    CONF_YEAR,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
    entity_duplicate_validator,
    queue_entity_register,
    setup_entity,
 )
-from esphome.cpp_generator import MockObj, MockObjClass
+from esphome.cpp_generator import MockObj, MockObjClass, TemplateArgsType
 from esphome.types import ConfigType, SafeExpType

 CODEOWNERS = ["@rfdarter", "@jesserockz"]
@@ -42,6 +40,11 @@ DateEntity = datetime_ns.class_("DateEntity", DateTimeBase)
 TimeEntity = datetime_ns.class_("TimeEntity", DateTimeBase)
 DateTimeEntity = datetime_ns.class_("DateTimeEntity", DateTimeBase)

+# Actions
+DateSetAction = datetime_ns.class_("DateSetAction", automation.Action)
+TimeSetAction = datetime_ns.class_("TimeSetAction", automation.Action)
+DateTimeSetAction = datetime_ns.class_("DateTimeSetAction", automation.Action)
+
 DateTimeStateTrigger = datetime_ns.class_(
    "DateTimeStateTrigger", automation.Trigger.template(cg.ESPTime)
 )
@@ -178,64 +181,118 @@ async def to_code(config: ConfigType) -> None:
    cg.add_global(datetime_ns.using)


-def _esptime_initializer(
-    members: tuple[tuple[str, str], ...],
-) -> Callable[[ConfigType, ConfigType], str]:
-    def const_fn(config: ConfigType, value: ConfigType) -> str:
-        return str(
-            cg.StructInitializer(
-                cg.ESPTime, *((member, value[key]) for member, key in members)
-            )
+@automation.register_action(
+    "datetime.date.set",
+    DateSetAction,
+    cv.Schema(
+        {
+            cv.Required(CONF_ID): cv.use_id(DateEntity),
+            cv.Required(CONF_DATE): cv.Any(
+                cv.returning_lambda, cv.date_time(date=True, time=False)
+            ),
+        }
+    ),
+    synchronous=True,
+)
+async def datetime_date_set_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    action_var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(action_var, config[CONF_ID])
+
+    date_config = config[CONF_DATE]
+    if cg.is_template(date_config):
+        template_ = await cg.templatable(date_config, args, cg.ESPTime)
+        cg.add(action_var.set_date(template_))
+    else:
+        date_struct = cg.StructInitializer(
+            cg.ESPTime,
+            ("day_of_month", date_config[CONF_DAY]),
+            ("month", date_config[CONF_MONTH]),
+            ("year", date_config[CONF_YEAR]),
        )
-
-    return const_fn
+        template_ = await cg.templatable(date_struct, args, cg.ESPTime)
+        cg.add(action_var.set_date(template_))
+    return action_var


-# ESPTime member order, so the designated initializer compiles.
-_TIME_MEMBERS = (("second", CONF_SECOND), ("minute", CONF_MINUTE), ("hour", CONF_HOUR))
-_DATE_MEMBERS = (("day_of_month", CONF_DAY), ("month", CONF_MONTH), ("year", CONF_YEAR))
-
-for _name, _entity, _key, _target, _date, _time, _members in (
-    (
-        "datetime.date.set",
-        DateEntity,
-        CONF_DATE,
-        "set_date",
-        True,
-        False,
-        _DATE_MEMBERS,
+@automation.register_action(
+    "datetime.time.set",
+    TimeSetAction,
+    cv.Schema(
+        {
+            cv.Required(CONF_ID): cv.use_id(TimeEntity),
+            cv.Required(CONF_TIME): cv.Any(
+                cv.returning_lambda, cv.date_time(date=False, time=True)
+            ),
+        }
    ),
-    (
-        "datetime.time.set",
-        TimeEntity,
-        CONF_TIME,
-        "set_time",
-        False,
-        True,
-        _TIME_MEMBERS,
+    synchronous=True,
+)
+async def datetime_time_set_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    action_var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(action_var, config[CONF_ID])
+
+    time_config = config[CONF_TIME]
+    if cg.is_template(time_config):
+        template_ = await cg.templatable(time_config, args, cg.ESPTime)
+        cg.add(action_var.set_time(template_))
+    else:
+        time_struct = cg.StructInitializer(
+            cg.ESPTime,
+            ("second", time_config[CONF_SECOND]),
+            ("minute", time_config[CONF_MINUTE]),
+            ("hour", time_config[CONF_HOUR]),
+        )
+        template_ = await cg.templatable(time_struct, args, cg.ESPTime)
+        cg.add(action_var.set_time(template_))
+    return action_var
+
+
+@automation.register_action(
+    "datetime.datetime.set",
+    DateTimeSetAction,
+    cv.Schema(
+        {
+            cv.Required(CONF_ID): cv.use_id(DateTimeEntity),
+            cv.Required(CONF_DATETIME): cv.Any(
+                cv.returning_lambda, cv.date_time(date=True, time=True)
+            ),
+        },
    ),
-    (
-        "datetime.datetime.set",
-        DateTimeEntity,
-        CONF_DATETIME,
-        "set_datetime",
-        True,
-        True,
-        _TIME_MEMBERS + _DATE_MEMBERS,
-    ),
-):
-    automation.register_apply_action(
-        _name,
-        cv.Schema(
-            {
-                cv.Required(CONF_ID): cv.use_id(_entity),
-                cv.Required(_key): cv.Any(
-                    cv.returning_lambda, cv.date_time(date=_date, time=_time)
-                ),
-            }
-        ),
-        automation.ApplyField(
-            _key, _target, cg.ESPTime, const_fn=_esptime_initializer(_members)
-        ),
-        call="make_call",
-    )
+    synchronous=True,
+)
+async def datetime_datetime_set_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    action_var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(action_var, config[CONF_ID])
+
+    datetime_config = config[CONF_DATETIME]
+    if cg.is_template(datetime_config):
+        template_ = await cg.templatable(datetime_config, args, cg.ESPTime)
+        cg.add(action_var.set_datetime(template_))
+    else:
+        datetime_struct = cg.StructInitializer(
+            cg.ESPTime,
+            ("second", datetime_config[CONF_SECOND]),
+            ("minute", datetime_config[CONF_MINUTE]),
+            ("hour", datetime_config[CONF_HOUR]),
+            ("day_of_month", datetime_config[CONF_DAY]),
+            ("month", datetime_config[CONF_MONTH]),
+            ("year", datetime_config[CONF_YEAR]),
+        )
+        template_ = await cg.templatable(datetime_struct, args, cg.ESPTime)
+        cg.add(action_var.set_datetime(template_))
+    return action_var
@@ -98,6 +98,20 @@ class DateCall {

 inline DateCall DateEntity::make_call() { return DateCall(this); }

+template<typename... Ts> class DateSetAction final : public Action<Ts...>, public Parented<DateEntity> {
+ public:
+  TEMPLATABLE_VALUE(ESPTime, date)
+
+  void play(const Ts &...x) override {
+    auto call = this->parent_->make_call();
+
+    if (this->date_.has_value()) {
+      call.set_date(this->date_.value(x...));
+    }
+    call.perform();
+  }
+};
+
 }  // namespace esphome::datetime

 #endif  // USE_DATETIME_DATE
@@ -123,6 +123,20 @@ class DateTimeCall {

 inline DateTimeCall DateTimeEntity::make_call() { return DateTimeCall(this); }

+template<typename... Ts> class DateTimeSetAction final : public Action<Ts...>, public Parented<DateTimeEntity> {
+ public:
+  TEMPLATABLE_VALUE(ESPTime, datetime)
+
+  void play(const Ts &...x) override {
+    auto call = this->parent_->make_call();
+
+    if (this->datetime_.has_value()) {
+      call.set_datetime(this->datetime_.value(x...));
+    }
+    call.perform();
+  }
+};
+
 #ifdef USE_TIME
 class OnDateTimeTrigger final : public Trigger<>, public Component, public Parented<DateTimeEntity> {
 public:
@@ -100,6 +100,20 @@ class TimeCall {

 inline TimeCall TimeEntity::make_call() { return TimeCall(this); }

+template<typename... Ts> class TimeSetAction final : public Action<Ts...>, public Parented<TimeEntity> {
+ public:
+  TEMPLATABLE_VALUE(ESPTime, time)
+
+  void play(const Ts &...x) override {
+    auto call = this->parent_->make_call();
+
+    if (this->time_.has_value()) {
+      call.set_time(this->time_.value(x...));
+    }
+    call.perform();
+  }
+};
+
 #ifdef USE_TIME
 class OnTimeTrigger final : public Trigger<>, public Component, public Parented<TimeEntity> {
 public:
@@ -1,5 +1,3 @@
-from typing import Any
-
 from esphome import automation
 import esphome.codegen as cg
 from esphome.components import uart
@@ -18,7 +16,6 @@ DFPlayerIsPlayingCondition = dfplayer_ns.class_(

 MULTI_CONF = True
 CONF_FOLDER = "folder"
-CONF_ENABLE = "enable"
 CONF_EQ_PRESET = "eq_preset"
 CONF_ON_FINISHED_PLAYBACK = "on_finished_playback"

@@ -378,32 +375,6 @@ async def dfplayer_random_to_code(config, action_id, template_arg, args):
    return var


-def _default_enable(value: Any) -> Any:
-    """Fill in ``enable: true`` for a bare action or a mapping that only picks the player.
-
-    Done before ``maybe_simple_value`` so neither form is wrapped as the ``enable`` value.
-    """
-    if value is None or isinstance(value, dict):
-        return {CONF_ENABLE: True, **(value or {})}
-    return value
-
-
-automation.register_apply_action(
-    "dfplayer.set_current_track_repeat",
-    cv.All(
-        _default_enable,
-        cv.maybe_simple_value(
-            {
-                cv.GenerateID(): cv.use_id(DFPlayer),
-                cv.Optional(CONF_ENABLE, default=True): cv.templatable(cv.boolean),
-            },
-            key=CONF_ENABLE,
-        ),
-    ),
-    automation.ApplyField(CONF_ENABLE, "set_current_track_repeat", cg.bool_),
-)
-
-
@automation.register_condition(
    "dfplayer.is_playing",
    DFPlayerIsPlayingCondition,
@@ -102,13 +102,6 @@ void DFPlayer::random() {
  this->send_cmd_(0x18);
 }

-void DFPlayer::set_current_track_repeat(bool enable) {
-  uint16_t arg = enable ? 0x00 : 0x01;
-  ESP_LOGD(TAG, "Setting current track repeat to %s",
-           enable ? LOG_STR_LITERAL("enabled") : LOG_STR_LITERAL("disabled"));
-  this->send_cmd_(0x19, arg);
-}
-
 void DFPlayer::play_folder(uint16_t folder, uint16_t file) {
  ESP_LOGD(TAG, "Playing file %d in folder %d", file, folder);
  if (folder < 100 && file < 256) {
@@ -46,7 +46,6 @@ class DFPlayer final : public uart::UARTDevice, public Component {
  void pause();
  void stop();
  void random();
-  void set_current_track_repeat(bool enable);

  bool is_playing() { return is_playing_; }
  void dump_config() override;
@@ -39,6 +39,12 @@ DisplayPage = display_ns.class_("DisplayPage")
 DisplayPagePtr = DisplayPage.operator("ptr")
 DisplayRef = Display.operator("ref")
 DisplayPageShowAction = display_ns.class_("DisplayPageShowAction", automation.Action)
+DisplayPageShowNextAction = display_ns.class_(
+    "DisplayPageShowNextAction", automation.Action
+)
+DisplayPageShowPrevAction = display_ns.class_(
+    "DisplayPageShowPrevAction", automation.Action
+)
 DisplayIsDisplayingPageCondition = display_ns.class_(
    "DisplayIsDisplayingPageCondition", automation.Condition
 )
@@ -282,23 +288,34 @@ async def display_page_show_to_code(config, action_id, template_arg, args):
    return var


-# The id is the display itself, so it cannot be a lambda; a plain use_id rejects one clearly.
-DISPLAY_PAGE_CYCLE_ACTION_SCHEMA = maybe_simple_id(
-    {
-        cv.GenerateID(CONF_ID): cv.use_id(Display),
-    }
-)
-
-automation.register_apply_action(
+@automation.register_action(
    "display.page.show_next",
-    DISPLAY_PAGE_CYCLE_ACTION_SCHEMA,
-    automation.ApplyCall("show_next_page()"),
+    DisplayPageShowNextAction,
+    maybe_simple_id(
+        {
+            cv.GenerateID(CONF_ID): cv.templatable(cv.use_id(Display)),
+        }
+    ),
+    synchronous=True,
 )
-automation.register_apply_action(
+async def display_page_show_next_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)
+
+
+@automation.register_action(
    "display.page.show_previous",
-    DISPLAY_PAGE_CYCLE_ACTION_SCHEMA,
-    automation.ApplyCall("show_prev_page()"),
+    DisplayPageShowPrevAction,
+    maybe_simple_id(
+        {
+            cv.GenerateID(CONF_ID): cv.templatable(cv.use_id(Display)),
+        }
+    ),
+    synchronous=True,
 )
+async def display_page_show_previous_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)


@automation.register_condition(
@@ -3,7 +3,6 @@
 #include <utility>
 #include <numbers>
 #include "display_color_utils.h"
-#include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"

@@ -771,12 +770,10 @@ Rect Display::get_clipping() const {

 void Display::clear_clipping_() { this->clipping_rectangle_.clear(); }

-void Display::feed_wdt_pixel_slow_() { App.feed_wdt(); }
-
 bool Display::clip(int x, int y) {
  if (x < 0 || x >= this->get_width() || y < 0 || y >= this->get_height())
    return false;
-  if (this->is_point_clipped(x, y))
+  if (!this->get_clipping().inside(x, y))
    return false;
  return true;
 }
@@ -758,13 +758,6 @@ class Display : public PollingComponent {

  bool is_clipping() const { return !this->clipping_rectangle_.empty(); }

-  /// Whether (x, y) falls outside the active clipping rectangle. Tests the
-  /// stack top in place: get_clipping() is out of line and returns the Rect
-  /// by value, which per pixel drawing cannot afford.
-  bool ESPHOME_ALWAYS_INLINE is_point_clipped(int x, int y) const {
-    return this->is_clipping() && !this->clipping_rectangle_.back().inside(x, y);
-  }
-
  /** Check if pixel is within region of display.
   */
  bool clip(int x, int y);
@@ -781,17 +774,6 @@ class Display : public PollingComponent {
  void do_update_();
  void clear_clipping_();

-  /// Watchdog feed for per pixel loops. App.feed_wdt() is already rate
-  /// limited, but every call reads the clock; only every 256th pixel makes
-  /// that call, so the real feeds are unchanged and a pixel costs a counter.
-  /// At 20 us per pixel on the slowest e-paper path that is about 5 ms
-  /// between clock reads.
-  void ESPHOME_ALWAYS_INLINE feed_wdt_per_pixel_() {
-    if (++this->wdt_pixel_counter_ == 0)
-      this->feed_wdt_pixel_slow_();
-  }
-  void feed_wdt_pixel_slow_();
-
  virtual int get_height_internal() = 0;
  virtual int get_width_internal() = 0;

@@ -811,7 +793,6 @@ class Display : public PollingComponent {
  std::vector<DisplayOnPageChangeTrigger *> on_page_change_triggers_;
  bool auto_clear_enabled_{true};
  std::vector<Rect> clipping_rectangle_;
-  uint8_t wdt_pixel_counter_{0};
  bool show_test_card_{false};
 };

@@ -848,6 +829,24 @@ template<typename... Ts> class DisplayPageShowAction final : public Action<Ts...
  }
 };

+template<typename... Ts> class DisplayPageShowNextAction final : public Action<Ts...> {
+ public:
+  DisplayPageShowNextAction(Display *buffer) : buffer_(buffer) {}
+
+  void play(const Ts &...x) override { this->buffer_->show_next_page(); }
+
+  Display *buffer_;
+};
+
+template<typename... Ts> class DisplayPageShowPrevAction final : public Action<Ts...> {
+ public:
+  DisplayPageShowPrevAction(Display *buffer) : buffer_(buffer) {}
+
+  void play(const Ts &...x) override { this->buffer_->show_prev_page(); }
+
+  Display *buffer_;
+};
+
 template<typename... Ts> class DisplayIsDisplayingPageCondition final : public Condition<Ts...> {
 public:
  DisplayIsDisplayingPageCondition(Display *parent) : parent_(parent) {}
@@ -2,6 +2,7 @@

 #include <utility>

+#include "esphome/core/application.h"
 #include "esphome/core/log.h"

 namespace esphome::display {
@@ -43,7 +44,7 @@ int DisplayBuffer::get_height() {
 }

 void HOT DisplayBuffer::draw_pixel_at(int x, int y, Color color) {
-  if (this->is_point_clipped(x, y))
+  if (!this->get_clipping().inside(x, y))
    return;  // NOLINT

  switch (this->rotation_) {
@@ -63,7 +64,7 @@ void HOT DisplayBuffer::draw_pixel_at(int x, int y, Color color) {
      break;
  }
  this->draw_absolute_pixel_internal(x, y, color);
-  this->feed_wdt_per_pixel_();
+  App.feed_wdt();
 }

 }  // namespace esphome::display
@@ -63,6 +63,16 @@ bool Rect::equal(Rect rect) const {
  return (rect.x == this->x) && (rect.w == this->w) && (rect.y == this->y) && (rect.h == this->h);
 }

+bool Rect::inside(int16_t test_x, int16_t test_y, bool absolute) const {  // NOLINT
+  if (!this->is_set()) {
+    return true;
+  }
+  if (absolute) {
+    return test_x >= this->x && test_x < this->x2() && test_y >= this->y && test_y < this->y2();
+  }
+  return test_x >= 0 && test_x < this->w && test_y >= 0 && test_y < this->h;
+}
+
 bool Rect::inside(Rect rect) const {
  if (!this->is_set() || !rect.is_set()) {
    return true;
@@ -26,15 +26,7 @@ class Rect {
  void shrink(Rect rect);

  bool inside(Rect rect) const;
-  bool ESPHOME_ALWAYS_INLINE inside(int16_t test_x, int16_t test_y, bool absolute = true) const {
-    if (!this->is_set()) {
-      return true;
-    }
-    if (absolute) {
-      return test_x >= this->x && test_x < this->x2() && test_y >= this->y && test_y < this->y2();
-    }
-    return test_x >= 0 && test_x < this->w && test_y >= 0 && test_y < this->h;
-  }
+  bool inside(int16_t test_x, int16_t test_y, bool absolute = true) const;
  bool equal(Rect rect) const;
  void info(const std::string &prefix = "rect info:");
 };
@@ -299,7 +299,7 @@ bool EPaperBase::initialise(bool partial) {
 * @return false if the coordinates are out of bounds
 */
 bool EPaperBase::rotate_coordinates_(int &x, int &y) {
-  if (this->is_point_clipped(x, y))
+  if (!this->get_clipping().inside(x, y))
    return false;
  if (this->effective_transform_ & SWAP_XY)
    std::swap(x, y);
@@ -111,7 +111,6 @@ CONF_ENGINEERING_SAMPLE = "engineering_sample"
 CONF_INCLUDE_BUILTIN_IDF_COMPONENTS = "include_builtin_idf_components"
 CONF_ENABLE_LWIP_ASSERT = "enable_lwip_assert"
 CONF_EXECUTE_FROM_PSRAM = "execute_from_psram"
-CONF_FLASH_CHIP = "flash_chip"
 CONF_KEY_ID = "key_id"
 CONF_MINIMUM_CHIP_REVISION = "minimum_chip_revision"
 CONF_NVS_ENCRYPTION = "nvs_encryption"
@@ -262,7 +261,7 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = (
    "esp_lcd",  # LCD controller drivers - only needed by display component
    "esp_local_ctrl",  # Local control over HTTPS/BLE - ESPHome has native API
    "esp_phy",  # RF PHY - re-included by internal_temperature on the original ESP32; esp_wifi/bt/ieee802154 pull it back
-    "esp_wifi",  # WiFi stack - re-included by request_wifi(), espnow, esp32_hosted; bt pulls it back for BLE builds
+    "esp_wifi",  # WiFi stack - re-included by request_wifi(), espnow; bt pulls it back for BLE builds
    "espcoredump",  # Core dump support - ESPHome has its own debug component
    "fatfs",  # FAT filesystem - ESPHome doesn't use filesystem storage
    "ieee802154",  # 802.15.4 radio - IDF openthread and the Zigbee libs pull it back
@@ -424,7 +423,6 @@ ARDUINO_DISABLED_LIBRARIES: frozenset[str] = frozenset(
        "Hash",
        "HTTPClient",
        "HTTPUpdate",
-        "HTTPUpdateServer",
        "Insights",
        "LittleFS",
        "Matter",
@@ -466,20 +464,6 @@ ESP32_CHIP_REVISIONS = {
    "3.1": "CONFIG_ESP32_REV_MIN_3_1",
 }

-# Flash vendor drivers ESP-IDF can link; each costs IRAM plus a 124 B table in DRAM
-# and only the one matching the flash ID is ever used
-ESP32_FLASH_CHIPS = {
-    "gd": "CONFIG_SPI_FLASH_SUPPORT_GD_CHIP",
-    "issi": "CONFIG_SPI_FLASH_SUPPORT_ISSI_CHIP",
-    "mxic": "CONFIG_SPI_FLASH_SUPPORT_MXIC_CHIP",
-    "winbond": "CONFIG_SPI_FLASH_SUPPORT_WINBOND_CHIP",
-    "boya": "CONFIG_SPI_FLASH_SUPPORT_BOYA_CHIP",
-    "th": "CONFIG_SPI_FLASH_SUPPORT_TH_CHIP",
-    "mxic_opi": "CONFIG_SPI_FLASH_SUPPORT_MXIC_OPI_CHIP",
-}
-FLASH_CHIP_GENERIC = "generic"
-FLASH_CHIP_OPI = "mxic_opi"  # the octal driver, ESP32-S3 only
-
 # Socket limit configuration for ESP-IDF
 # ESP-IDF CONFIG_LWIP_MAX_SOCKETS has range 1-253, default 10
 DEFAULT_MAX_SOCKETS = 10  # ESP-IDF default
@@ -932,15 +916,14 @@ def _is_framework_url(source: str) -> bool:
 # The default/recommended arduino framework version
 #  - https://github.com/espressif/arduino-esp32/releases
 ARDUINO_FRAMEWORK_VERSION_LOOKUP = {
-    "recommended": cv.Version(3, 3, 12),
-    "latest": cv.Version(3, 3, 12),
-    "dev": cv.Version(3, 3, 12),
+    "recommended": cv.Version(3, 3, 11),
+    "latest": cv.Version(3, 3, 11),
+    "dev": cv.Version(3, 3, 11),
 }
 ARDUINO_PLATFORM_VERSION_LOOKUP = {
    cv.Version(
        4, 0, 0, "alpha1"
    ): "https://github.com/pioarduino/platform-espressif32.git#prep_IDF6",
-    cv.Version(3, 3, 12): cv.Version(55, 3, 312),
    cv.Version(3, 3, 11): cv.Version(55, 3, 311),
    cv.Version(3, 3, 10): cv.Version(55, 3, 39),
    cv.Version(3, 3, 9): cv.Version(55, 3, 39),
@@ -965,7 +948,6 @@ ARDUINO_PLATFORM_VERSION_LOOKUP = {
 # See: https://github.com/pioarduino/esp-idf/releases
 ARDUINO_IDF_VERSION_LOOKUP = {
    cv.Version(4, 0, 0, "alpha1"): cv.Version(6, 0, 1),
-    cv.Version(3, 3, 12): cv.Version(5, 5, 5),
    cv.Version(3, 3, 11): cv.Version(5, 5, 5),
    cv.Version(3, 3, 10): cv.Version(5, 5, 5),
    cv.Version(3, 3, 9): cv.Version(5, 5, 4),
@@ -1001,7 +983,7 @@ ESP_IDF_PLATFORM_VERSION_LOOKUP = {
    cv.Version(
        6, 0, 0
    ): "https://github.com/pioarduino/platform-espressif32.git#prep_IDF6",
-    cv.Version(5, 5, 5): cv.Version(55, 3, 312),
+    cv.Version(5, 5, 5): cv.Version(55, 3, 311),
    cv.Version(5, 5, 4): cv.Version(55, 3, 39),
    cv.Version(5, 5, 3, "1"): cv.Version(55, 3, 37),
    cv.Version(5, 5, 3): cv.Version(55, 3, 37),
@@ -1022,8 +1004,8 @@ ESP_IDF_PLATFORM_VERSION_LOOKUP = {
 # The platform-espressif32 version
 #  - https://github.com/pioarduino/platform-espressif32/releases
 PLATFORM_VERSION_LOOKUP = {
-    "recommended": cv.Version(55, 3, 312),
-    "latest": cv.Version(55, 3, 312),
+    "recommended": cv.Version(55, 3, 311),
+    "latest": cv.Version(55, 3, 311),
    "dev": "https://github.com/pioarduino/platform-espressif32.git#develop",
 }

@@ -1537,13 +1519,6 @@ def final_validate(config) -> None:
                path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_MINIMUM_CHIP_REVISION],
            )
        )
-    if config[CONF_VARIANT] != VARIANT_ESP32S3 and config.get(CONF_FLASH_MODE) == "opi":
-        errs.append(
-            cv.Invalid(
-                f"'{CONF_FLASH_MODE}: opi' is only supported on {VARIANT_ESP32S3}",
-                path=[CONF_FLASH_MODE],
-            )
-        )
    if config[CONF_VARIANT] != VARIANT_ESP32 and advanced[CONF_SRAM1_AS_IRAM]:
        errs.append(
            cv.Invalid(
@@ -1551,25 +1526,6 @@ def final_validate(config) -> None:
                path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_SRAM1_AS_IRAM],
            )
        )
-    if (flash_chip := advanced.get(CONF_FLASH_CHIP)) is not None:
-        opi = flash_chip == FLASH_CHIP_OPI
-        if opi and config[CONF_VARIANT] != VARIANT_ESP32S3:
-            errs.append(
-                cv.Invalid(
-                    f"'{CONF_FLASH_CHIP}: {flash_chip}' is only supported on {VARIANT_ESP32S3}",
-                    path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_FLASH_CHIP],
-                )
-            )
-        elif opi != (config.get(CONF_FLASH_MODE) == "opi"):
-            errs.append(
-                cv.Invalid(
-                    f"'{CONF_FLASH_CHIP}: {flash_chip}' requires '{CONF_FLASH_MODE}: opi'"
-                    if opi
-                    else f"'{CONF_FLASH_CHIP}: {flash_chip}' does not match "
-                    f"'{CONF_FLASH_MODE}: opi'; octal flash uses {FLASH_CHIP_OPI}",
-                    path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_FLASH_CHIP],
-                )
-            )
    if (
        config[CONF_VARIANT] != VARIANT_ESP32P4
        and config.get(CONF_ENGINEERING_SAMPLE) is not None
@@ -2008,9 +1964,6 @@ FRAMEWORK_SCHEMA = cv.Schema(
                    *ESP32_CHIP_REVISIONS, string=True
                ),
                cv.Optional(CONF_SRAM1_AS_IRAM, default=False): cv.boolean,
-                cv.Optional(CONF_FLASH_CHIP): cv.one_of(
-                    FLASH_CHIP_GENERIC, *ESP32_FLASH_CHIPS, lower=True
-                ),
                # DHCP server is needed for WiFi AP mode. When WiFi component is used,
                # it will handle disabling DHCP server when AP is not configured.
                # Default to false (disabled) when WiFi is not used.
@@ -2656,13 +2609,6 @@ async def to_code(config):
    # NVS finds stored preferences by key, so preference key migration is possible
    cg.add_define("USE_PREFERENCE_KEY_LOOKUP")
    cg.add_build_flag("-Wl,-z,noexecstack")
-    # assert(), HAL_ASSERT and ESP_ERROR_CHECK bake __FILE__ into rodata, and
-    # IDF's noflash placement puts the flash driver's copies in DRAM. The
-    # basename keeps the panic output useful at a fraction of the size.
-    # __FILE_NAME__ is a GCC 12 builtin; IDF 5.0 still ships GCC 11.2.
-    if idf_version() >= cv.Version(5, 1, 0):
-        cg.add_build_flag("-D__FILE__=__FILE_NAME__")
-        cg.add_build_flag("-Wno-builtin-macro-redefined")
    # Deferred so KEY_COMPONENTS is fully populated -- see the coroutine.
    CORE.add_job(_finalize_arduino_aware_flags)
    cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
@@ -2779,8 +2725,6 @@ async def to_code(config):
        add_idf_sdkconfig_option(
            f"CONFIG_ESPTOOLPY_FLASHMODE_{flash_mode.upper()}", True
        )
-        # the opi mode choice only exists once octal flash is enabled
-        add_idf_sdkconfig_option("CONFIG_ESPTOOLPY_OCT_FLASH", flash_mode == "opi")
    if flash_frequency := config.get(CONF_FLASH_FREQUENCY):
        add_idf_sdkconfig_option(
            f"CONFIG_ESPTOOLPY_FLASHFREQ_{flash_frequency[:-3]}M", True
@@ -2795,11 +2739,6 @@ async def to_code(config):
            config.get(CONF_ENGINEERING_SAMPLE, False),
        )

-    # ESP32-C2 defaults to the ROM's newlib "nano" printf, which does not
-    # understand %zu or %lld and crashes on any %s that follows one.
-    if variant == VARIANT_ESP32C2:
-        add_idf_sdkconfig_option("CONFIG_LIBC_NEWLIB_NANO_FORMAT", False)
-
    # Set minimum chip revision for ESP32 variant
    # Setting this to 3.0 or higher reduces flash size by excluding workaround code,
    # and for PSRAM users saves significant IRAM by keeping C library functions in ROM.
@@ -2810,11 +2749,6 @@ async def to_code(config):
                add_idf_sdkconfig_option(flag, rev == min_rev)
            cg.add_define("USE_ESP32_MIN_CHIP_REVISION_SET")

-    # Keep only the flash vendor driver the board needs; the boot log names it
-    if (flash_chip := conf[CONF_ADVANCED].get(CONF_FLASH_CHIP)) is not None:
-        for chip, flag in ESP32_FLASH_CHIPS.items():
-            add_idf_sdkconfig_option(flag, chip == flash_chip)
-
    # Use SRAM1 region as IRAM on ESP32 (original) variant
    # This provides an additional 40KB of IRAM by using SRAM1 memory that was previously
    # reserved for bootloader DRAM. Requires a bootloader from ESP-IDF v5.1 or later.
@@ -173,10 +173,7 @@ static const char *const TAG = "esp32.crash";
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static uint32_t s_current_build_time = static_cast<uint32_t>(ESPHOME_BUILD_TIME);

-// Validate the NOINIT record. Runs on every has_data() call; re-running is
-// harmless and the magic is left alone so the record survives an OTA
-// rollback reboot, crash_handler_clear() drops it once an API client has it.
-static void read_crash_data() {
+void crash_handler_read_and_clear() {
  if (s_raw_crash_data.magic == CRASH_MAGIC && s_raw_crash_data.version == CRASH_DATA_VERSION) {
    s_crash_data_valid = true;
    // Clamp counts to prevent out-of-bounds reads from corrupt .noinit data
@@ -197,12 +194,11 @@ static void read_crash_data() {
      s_raw_crash_data.other_reg_frame_count = s_raw_crash_data.other_backtrace_count;
 #endif
  }
+  // Don't clear magic here — crash data must survive OTA rollback reboots.
+  // Magic is cleared by crash_handler_clear() after an API client receives the data.
 }

-bool crash_handler_has_data() {
-  read_crash_data();
-  return s_crash_data_valid;
-}
+bool crash_handler_has_data() { return s_crash_data_valid; }

 void crash_handler_clear() {
  // Only clear the magic so data doesn't survive the next reboot.
@@ -430,7 +426,7 @@ static void log_foreign_addresses() {
 // crashes again during boot, and allowing the CLI's process_stacktrace to match
 // and decode each address individually.
 void crash_handler_log() {
-  if (!crash_handler_has_data())
+  if (!s_crash_data_valid)
    return;

  ESP_LOGE(TAG, "*** CRASH DETECTED ON PREVIOUS BOOT ***");
@@ -4,6 +4,11 @@

 namespace esphome::esp32 {

+/// Read and validate crash data from NOINIT memory.
+/// Does not clear the magic marker — call crash_handler_clear() after
+/// the data has been delivered to an API client so it survives OTA rollback reboots.
+void crash_handler_read_and_clear();
+
 /// Log crash data if a crash was detected on previous boot.
 void crash_handler_log();

@@ -11,7 +16,7 @@ void crash_handler_log();
 /// Call after the data has been delivered to an API client.
 void crash_handler_clear();

-/// Returns true if crash data was found this boot, reading it first if needed.
+/// Returns true if crash data was found this boot.
 bool crash_handler_has_data();

 }  // namespace esphome::esp32
@@ -1,6 +1,9 @@
 #ifdef USE_ESP32

+// defines.h must come before crash_handler.h so USE_ESP32_CRASH_HANDLER is set
+// before crash_handler.h's #ifdef-guarded namespace block is parsed.
 #include "esphome/core/defines.h"
+#include "crash_handler.h"
 #include "esphome/core/hal.h"

 #include <esp_clk_tree.h>
@@ -42,6 +45,11 @@ void arch_restart() {
 }

 void arch_init() {
+#ifdef USE_ESP32_CRASH_HANDLER
+  // Read crash data from previous boot before anything else
+  esp32::crash_handler_read_and_clear();
+#endif
+
  // Enable the task watchdog only on the loop task (from which we're currently running)
  esp_task_wdt_add(nullptr);

@@ -83,23 +83,18 @@ void ESP32BLE::setup() {
  }
 }

-// Queue the transition for loop(). A pending transition the other way is
-// cancelled instead, since nothing was torn down or brought up yet; any other
-// state is already there or on its way.
-void ESP32BLE::request_state_(bool enable) {
-  if (enable) {
-    if (this->state_ == BLE_COMPONENT_STATE_DISABLED) {
-      this->state_ = BLE_COMPONENT_STATE_ENABLE;
-    } else if (this->state_ == BLE_COMPONENT_STATE_DISABLE) {
-      this->state_ = BLE_COMPONENT_STATE_ACTIVE;
-    }
-  } else {
-    if (this->state_ == BLE_COMPONENT_STATE_ACTIVE) {
-      this->state_ = BLE_COMPONENT_STATE_DISABLE;
-    } else if (this->state_ == BLE_COMPONENT_STATE_ENABLE) {
-      this->state_ = BLE_COMPONENT_STATE_DISABLED;
-    }
-  }
+void ESP32BLE::enable() {
+  if (this->state_ != BLE_COMPONENT_STATE_DISABLED)
+    return;
+
+  this->state_ = BLE_COMPONENT_STATE_ENABLE;
+}
+
+void ESP32BLE::disable() {
+  if (this->state_ == BLE_COMPONENT_STATE_DISABLED)
+    return;
+
+  this->state_ = BLE_COMPONENT_STATE_DISABLE;
 }

 #ifdef USE_ESP32_BLE_ADVERTISING
@@ -585,11 +580,7 @@ void ESP32BLE::loop_handle_state_transition_not_active_() {
      this->mark_failed();
      return;
    }
-    this->drain_ble_events_();
-    // A status callback may have asked for BLE back; the stack is down now, so
-    // that request becomes a bring-up.
-    this->state_ =
-        this->state_ == BLE_COMPONENT_STATE_ACTIVE ? BLE_COMPONENT_STATE_ENABLE : BLE_COMPONENT_STATE_DISABLED;
+    this->state_ = BLE_COMPONENT_STATE_DISABLED;
  } else if (this->state_ == BLE_COMPONENT_STATE_ENABLE) {
    ESP_LOGD(TAG, "Enabling");
    this->state_ = BLE_COMPONENT_STATE_OFF;
@@ -102,8 +102,8 @@ class ESP32BLE final : public Component {
  }
  uint32_t get_advertising_cycle_time() const { return this->advertising_cycle_time_; }

-  void enable() { this->request_state_(true); }
-  void disable() { this->request_state_(false); }
+  void enable();
+  void disable();
  ESPHOME_ALWAYS_INLINE bool is_active() { return this->state_ == BLE_COMPONENT_STATE_ACTIVE; }
  void setup() override;
  void loop() override;
@@ -176,15 +176,6 @@ class ESP32BLE final : public Component {

  bool ble_setup_();
  bool ble_dismantle_();
-  void request_state_(bool enable);
-  // Drop what the old stack queued; the next stack reuses the same interface ids.
-  void drain_ble_events_() {
-    BLEEvent *ble_event;
-    while ((ble_event = this->ble_events_.pop()) != nullptr) {
-      this->ble_event_pool_.release(ble_event);
-    }
-    this->ble_events_.get_and_reset_dropped_count();
-  }
  bool ble_pre_setup_();
 #ifdef USE_ESP32_BLE_ADVERTISING
  void advertising_init_();
--- a/Show More
+++ b/Show More