[at581x] Apply configured false and zero values in the settings action

.devcontainer/Dockerfile

@@ -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

.github/actions/restore-python/action.yml

@@ -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@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+      uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
       with:
         enable-cache: true
         # Pull request saves land in per-PR scopes nothing else can

.github/workflows/ci-api-proto.yml

@@ -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@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
           # Pull-request-only workflow: a save could never be shared and

.github/workflows/ci-docker.yml

@@ -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.

.github/workflows/ci.yml

@@ -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@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
           # Pull request saves land in per-PR scopes nothing else can
@@ -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@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         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@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
           # Pull request saves land in per-PR scopes nothing else can

.github/workflows/sync-device-classes.yml

@@ -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@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
           # Pin uv version so the action does not have to fetch the

AGENTS.md

@@ -443,20 +443,6 @@ file does, and it is the authority when they disagree. The most useful starting
 
         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.
-
     *   **Conditions:**
         ```cpp
         template<typename... Ts> class MyCondition : public Condition<Ts...> {
@@ -470,19 +456,6 @@ file does, and it is the authority when they disagree. The most useful starting
         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.
-
 *   **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`.
 
 *   **Configuration Validation:**
@@ -737,9 +710,7 @@ file does, and it is the authority when they disagree. The most useful starting
 
         6. **Avoid `std::deque`:** It allocates in 512-byte blocks regardless of element size, guaranteeing at least 512 bytes of RAM usage immediately. This is a major source of crashes on memory-constrained devices.
 
-        7. **Never use `new (std::nothrow)`:** On ESP-IDF exceptions are disabled, so a failed nothrow allocation aborts instead of returning `nullptr`. Use `RAMAllocator` from `esphome/core/helpers.h`; CI rejects `std::nothrow`.
-
-        8. **Detection:** Look for these patterns in compiler output:
+        7. **Detection:** Look for these patterns in compiler output:
            - Large code sections with STL symbols (vector, map, set)
            - `alloc`, `realloc`, `dealloc` in symbol names
            - `_M_realloc_insert`, `_M_default_append` (vector reallocation)

CODEOWNERS

@@ -457,7 +457,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
@@ -549,7 +548,6 @@ esphome/components/sx127x/* @swoboda1337
 esphome/components/sy6970/* @linkedupbits
 esphome/components/syslog/* @clydebarrow
 esphome/components/t6615/* @tylermenezes
-esphome/components/tas2780/* @remcom
 esphome/components/tc74/* @sethgirvan
 esphome/components/tca9548a/* @andreashergert1984
 esphome/components/tca9555/* @mobrembski

docker/Dockerfile

@@ -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.9
 
 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 \

docker/ha-addon-rootfs/etc/s6-overlay/s6-rc.d/discovery/run

@@ -4,6 +4,7 @@
 # Home Assistant Add-on: ESPHome
 # Sends discovery information to Home Assistant.
 # ==============================================================================
+declare config
 declare port
 
 # We only disable it when disabled explicitly
@@ -18,17 +19,14 @@ port=$(bashio::addon.ingress_port)
 # Wait for the ESPHome Device Builder to become available
 bashio::net.wait_for "${port}" "127.0.0.1" 300
 
-# Send one discovery message; the config is a JSON string built with bashio::var.json.
-send_discovery() {
-    local service=$1
-    local config=$2
-    if bashio::discovery "${service}" "${config}" > /dev/null; then
-        bashio::log.info "Successfully send ${service} discovery information to Home Assistant."
-    else
-        bashio::log.error "${service} discovery message to Home Assistant failed!"
-    fi
-}
+config=$(\
+    bashio::var.json \
+        host "127.0.0.1" \
+        port "^${port}" \
+)
 
-send_discovery "esphome" "$(bashio::var.json host "127.0.0.1" port "^${port}")"
-# The Device Builder MCP server, consumed by Home Assistant's mcp integration.
-send_discovery "mcp" "$(bashio::var.json url "http://127.0.0.1:${port}/api/mcp")"
+if bashio::discovery "esphome" "${config}" > /dev/null; then
+    bashio::log.info "Successfully send discovery information to Home Assistant."
+else
+    bashio::log.error "Discovery message to Home Assistant failed!"
+fi

docker/test_configs/bk72xx-arduino.yaml

@@ -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

esphome/__main__.py

@@ -762,7 +762,6 @@ def _wrap_to_code(name, comp, yaml_util):
 
     @functools.wraps(comp.to_code)
     async def wrapped(conf):
-        cg.add(cg.ComponentMarker(name))
         cg.add(cg.LineComment(f"{name}:"))
         if comp.config_schema is not None:
             # sort_keys: voluptuous fills defaults in set order, so an
@@ -1344,12 +1343,8 @@ def _upload_via_native_api(
     # fall back to a plaintext upload
     noise_psk = None
     plaintext_fallback = False
-    allow_plaintext_upload = False
     if (encryption_conf := ota_conf.get(CONF_ENCRYPTION)) is not None:
         noise_psk = encryption_conf.get(CONF_KEY)
-        allow_plaintext_upload = bool(
-            encryption_conf.get(espota2.CONF_ALLOW_PLAINTEXT_UPLOAD)
-        )
         if not noise_psk:
             raise EsphomeError(
                 "OTA encryption is configured but no key was resolved; "
@@ -1400,7 +1395,6 @@ def _upload_via_native_api(
         ota_type,
         noise_psk,
         plaintext_fallback=plaintext_fallback,
-        allow_plaintext_upload=allow_plaintext_upload,
     )
 
 

esphome/analyze_memory/cli.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from collections import defaultdict
 from collections.abc import Callable
 import heapq
-import json
 from operator import itemgetter
 from pathlib import Path
 import sys
@@ -43,7 +42,7 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
 
     # Symbol size threshold for detailed analysis
     SYMBOL_SIZE_THRESHOLD: int = (
-        10  # Show symbols larger than this in detailed analysis
+        100  # Show symbols larger than this in detailed analysis
     )
     # Lower threshold for RAM symbols (RAM is more constrained)
     RAM_SYMBOL_SIZE_THRESHOLD: int = 24

esphome/automation.py

@@ -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
 
 
@@ -213,291 +207,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))
-
-
-def literal_with_length(config: ConfigType, value: str) -> str:
-    """Renderer for a ``(const char *, size_t)`` target: a plain literal plus its byte length.
-
-    The target compares or copies the bytes in place, so it needs the RAM literal rather than
-    the PROGMEM rendering on ESP8266, and the length saves a strlen.
-    """
-    return f"{cg.safe_exp(value)}, {len(value.encode('utf-8'))}"
-
-
-@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, id_key: str = CONF_ID) -> str:
-    # Global-scope qualified so a trigger arg named like the id cannot shadow it.
-    return f"::{await cg.get_variable(config[id_key])}"
-
-
-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,
-    id_key: str = CONF_ID,
-) -> None:
-    """Register an action that only forwards config values to its parent, with no C++ class.
-
-    Generates one stateless function for ``ApplyAction<Ts...>``: the parent (read from
-    ``id_key``) 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)
-    ]
-    _check_key_in_schema(name, schema, id_key)
-    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, id_key)
-        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, id_key: str = CONF_ID
-) -> 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
-    _check_key_in_schema(name, schema, id_key)
-    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, id_key)
-        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):
@@ -745,15 +454,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(

esphome/codegen.py

@@ -10,7 +10,6 @@
 # pylint: disable=unused-import
 from esphome.cpp_generator import (  # noqa: F401
     ArrayInitializer,
-    ComponentMarker,
     Expression,
     FlashStringLiteral,
     LineComment,
@@ -65,6 +64,7 @@ from esphome.cpp_types import (  # noqa: F401
     Application,
     Component,
     ComponentPtr,
+    Controller,
     EntityBase,
     EntityCategory,
     ESPTime,

esphome/components/alarm_control_panel/__init__.py

@@ -41,6 +41,14 @@ 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)
+ReadyAction = alarm_control_panel_ns.class_("ReadyAction", automation.Action)
 
 AlarmControlPanelCondition = alarm_control_panel_ns.class_(
     "AlarmControlPanelCondition", automation.Condition
@@ -188,46 +196,125 @@ 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
 
 
-for _name, _call in (
-    ("alarm_control_panel.pending", "pending()"),
-    ("alarm_control_panel.triggered", "triggered()"),
-):
-    automation.register_apply_action(
-        _name,
-        ALARM_CONTROL_PANEL_ACTION_SCHEMA,
-        automation.ApplyCall(_call),
-        call="make_call",
-    )
+@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_simple_condition(
+@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(
+    "alarm_control_panel.pending",
+    PendingAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def alarm_action_pending_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(
+    "alarm_control_panel.triggered",
+    TriggeredAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def alarm_action_trigger_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(
+    "alarm_control_panel.chime",
+    ChimeAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def alarm_action_chime_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(
+    "alarm_control_panel.ready",
+    ReadyAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_condition(
     "alarm_control_panel.ready",
     AlarmControlPanelCondition,
     ALARM_CONTROL_PANEL_CONDITION_SCHEMA,
 )
+async def alarm_action_ready_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_simple_condition(
+@automation.register_condition(
     "alarm_control_panel.is_armed",
     AlarmControlPanelCondition,
     ALARM_CONTROL_PANEL_CONDITION_SCHEMA,
 )
+async def alarm_control_panel_is_armed_to_code(
+    config, condition_id, template_arg, args
+):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren)
 
 
 @coroutine_with_priority(CoroPriority.CORE)

esphome/components/alarm_control_panel/automation.h

@@ -27,6 +27,74 @@ 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) {}
+
+  void play(const Ts &...x) override { this->alarm_control_panel_->make_call().pending().perform(); }
+
+ protected:
+  AlarmControlPanel *alarm_control_panel_;
+};
+
+template<typename... Ts> class TriggeredAction final : public Action<Ts...> {
+ public:
+  explicit TriggeredAction(AlarmControlPanel *alarm_control_panel) : alarm_control_panel_(alarm_control_panel) {}
+
+  void play(const Ts &...x) override { this->alarm_control_panel_->make_call().triggered().perform(); }
+
+ protected:
+  AlarmControlPanel *alarm_control_panel_;
+};
+
 template<typename... Ts> class AlarmControlPanelCondition final : public Condition<Ts...> {
  public:
   AlarmControlPanelCondition(AlarmControlPanel *parent) : parent_(parent) {}

esphome/components/api/__init__.py

@@ -81,7 +81,7 @@ def AUTO_LOAD(config: ConfigType) -> list[str]:
 
 
 api_ns = cg.esphome_ns.namespace("api")
-APIServer = api_ns.class_("APIServer", cg.Component)
+APIServer = api_ns.class_("APIServer", cg.Component, cg.Controller)
 HomeAssistantServiceCallAction = api_ns.class_(
     "HomeAssistantServiceCallAction", automation.Action
 )
@@ -462,7 +462,8 @@ async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
-    CORE.register_controller(var)
+    # Track controller registration for StaticVector sizing
+    CORE.register_controller()
 
     # Request a log listener slot for API log streaming
     request_log_listener()

esphome/components/api/api_connection.cpp

@@ -600,7 +600,7 @@ bool APIConnection::send_light_state(light::LightState *light) {
 uint16_t APIConnection::try_send_light_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *light = static_cast<light::LightState *>(entity);
   LightStateResponse resp;
-  auto values = light->get_reported_values();
+  auto values = light->remote_values;
   auto color_mode = values.get_color_mode();
   resp.state = values.is_on();
   resp.color_mode = static_cast<enums::ColorMode>(color_mode);
@@ -2267,12 +2267,7 @@ bool APIConnection::send_message_(uint32_t payload_size, uint16_t message_type,
   // Capacity reserved above, cannot fail
   (void) shared_buf.resize(write_start + payload_size);
   ProtoWriteBuffer buffer{&shared_buf, write_start};
-  uint8_t *end = encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
-#ifdef ESPHOME_DEBUG_API
-  proto_check_encode_end(end, shared_buf.data() + shared_buf.size());
-#else
-  (void) end;
-#endif
+  encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
   return this->send_buffer(ProtoWriteBuffer{&shared_buf}, message_type);
 }
 // encode_to_buffer is defined inline in api_connection.h (ESPHOME_ALWAYS_INLINE)

esphome/components/api/api_connection.h

@@ -346,7 +346,11 @@ class APIConnection final : public APIServerConnectionBase {
   /// Returns false as soon as the TCP buffer is full. Marked nodiscard so we
   /// have no silent failures: every caller must handle (or log) a refusal.
   template<typename T> [[nodiscard]] bool send_message(const T &msg) {
-    return this->send_message_(T::calc_size_msg(&msg), T::MESSAGE_TYPE, &T::encode_msg, &msg);
+    if constexpr (T::ESTIMATED_SIZE == 0) {
+      return this->send_message_(0, T::MESSAGE_TYPE, &encode_msg_noop, &msg);
+    } else {
+      return this->send_message_(msg.calculate_size(), T::MESSAGE_TYPE, &proto_encode_msg<T>, &msg);
+    }
   }
 
   /// Clear the shared write buffer and reserve space for the first message.
@@ -402,6 +406,16 @@ class APIConnection final : public APIServerConnectionBase {
   void process_state_subscriptions_();
 #endif
 
+  // Size thunk — converts void* back to concrete type for direct calculate_size() call
+  template<typename T> static uint32_t calc_size(const void *msg) {
+    return static_cast<const T *>(msg)->calculate_size();
+  }
+
+  // Shared no-op encode thunk for empty messages (ESTIMATED_SIZE == 0)
+  static uint8_t *encode_msg_noop(const void *, ProtoWriteBuffer &buf PROTO_ENCODE_DEBUG_PARAM) {
+    return buf.get_pos();
+  }
+
   // Non-template buffer management for send_message
   bool send_message_(uint32_t payload_size, uint16_t message_type, MessageEncodeFn encode_fn, const void *msg);
 
@@ -420,7 +434,11 @@ class APIConnection final : public APIServerConnectionBase {
   // Hot paths (state/info) go through fill_and_encode_entity_state/info instead.
   // batch_message_type_ is already set by dispatch_message_ before reaching here.
   template<typename T> static uint16_t encode_message_to_buffer(T &msg, APIConnection *conn, uint32_t remaining_size) {
-    return encode_to_buffer_slow(T::calc_size_msg(&msg), &T::encode_msg, &msg, conn, remaining_size);
+    if constexpr (T::ESTIMATED_SIZE == 0) {
+      return encode_to_buffer_slow(0, &encode_msg_noop, &msg, conn, remaining_size);
+    } else {
+      return encode_to_buffer_slow(msg.calculate_size(), &proto_encode_msg<T>, &msg, conn, remaining_size);
+    }
   }
 
   // Non-template core — fills state fields and encodes
@@ -432,7 +450,7 @@ class APIConnection final : public APIServerConnectionBase {
   template<typename T>
   static uint16_t fill_and_encode_entity_state(EntityBase *entity, T &msg, APIConnection *conn,
                                                uint32_t remaining_size) {
-    return fill_and_encode_entity_state(entity, msg, &T::calc_size_msg, &T::encode_msg, conn, remaining_size);
+    return fill_and_encode_entity_state(entity, msg, &calc_size<T>, &proto_encode_msg<T>, conn, remaining_size);
   }
 
   // Non-template core — fills info fields, allocates buffers, and encodes
@@ -444,7 +462,7 @@ class APIConnection final : public APIServerConnectionBase {
   template<typename T>
   static uint16_t fill_and_encode_entity_info(EntityBase *entity, T &msg, APIConnection *conn,
                                               uint32_t remaining_size) {
-    return fill_and_encode_entity_info(entity, msg, &T::calc_size_msg, &T::encode_msg, conn, remaining_size);
+    return fill_and_encode_entity_info(entity, msg, &calc_size<T>, &proto_encode_msg<T>, conn, remaining_size);
   }
 
   // Non-template core — fills device_class, then delegates to fill_and_encode_entity_info
@@ -458,8 +476,8 @@ class APIConnection final : public APIServerConnectionBase {
   static uint16_t fill_and_encode_entity_info_with_device_class(EntityBase *entity, T &msg,
                                                                 StringRef &device_class_field, APIConnection *conn,
                                                                 uint32_t remaining_size) {
-    return fill_and_encode_entity_info_with_device_class(entity, msg, device_class_field, &T::calc_size_msg,
-                                                         &T::encode_msg, conn, remaining_size);
+    return fill_and_encode_entity_info_with_device_class(entity, msg, device_class_field, &calc_size<T>,
+                                                         &proto_encode_msg<T>, conn, remaining_size);
   }
 
 #ifdef USE_VOICE_ASSISTANT

esphome/components/api/api_connection_buffer.h

@@ -46,13 +46,7 @@ inline uint16_t ESPHOME_ALWAYS_INLINE APIConnection::encode_to_buffer(uint32_t c
     return 0;
   }
   ProtoWriteBuffer buffer{&shared_buf, shared_buf.size() - calculated_size};
-  uint8_t *end = encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
-#ifdef ESPHOME_DEBUG_API
-  // A body that writes fewer bytes than calculate_size() promised would ship stale buffer bytes
-  proto_check_encode_end(end, shared_buf.data() + shared_buf.size());
-#else
-  (void) end;
-#endif
+  encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
 
   return total_calculated_size;
 }

esphome/components/api/api_frame_helper_noise.cpp

@@ -5,13 +5,16 @@
 #include "esphome/components/noise/noise.h"
 #include "esphome/core/application.h"
 #include "esphome/core/entity_base.h"
-#include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "proto.h"
 #include <cstring>
 #include <cinttypes>
 
+#ifdef USE_ESP8266
+#include <pgmspace.h>
+#endif
+
 namespace esphome::api {
 
 using noise::noise_err_to_logstr;
@@ -23,7 +26,11 @@ static_assert(MAX_HANDSHAKE_SIZE == noise::MAX_HANDSHAKE_SIZE,
               "api and noise component handshake size limits must match");
 
 static const char *const TAG = "api.noise";
+#ifdef USE_ESP8266
 static constexpr char PROLOGUE_INIT[] PROGMEM = "NoiseAPIInit";
+#else
+static const char *const PROLOGUE_INIT = "NoiseAPIInit";
+#endif
 static constexpr size_t PROLOGUE_INIT_LEN = 12;  // strlen("NoiseAPIInit")
 
 // Maximum bytes to log in hex format (168 * 3 = 504, under TX buffer size of 512)
@@ -65,7 +72,11 @@ APIError APINoiseFrameHelper::init() {
     state_ = State::FAILED;
     return APIError::OUT_OF_MEMORY;
   }
-  progmem_memcpy(dst, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
+#ifdef USE_ESP8266
+  memcpy_P(dst, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
+#else
+  std::memcpy(dst, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
+#endif
 
   state_ = State::CLIENT_HELLO;
   return APIError::OK;

esphome/components/api/api_server.cpp

@@ -5,6 +5,7 @@
 #include "api_connection.h"
 #include "esphome/components/network/util.h"
 #include "esphome/core/application.h"
+#include "esphome/core/controller_registry.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
@@ -60,6 +61,8 @@ void APIServer::socket_failed_(const LogString *msg) {
 }
 
 void APIServer::setup() {
+  ControllerRegistry::register_controller(this);
+
 #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
@@ -452,9 +455,8 @@ void APIServer::send_homeassistant_action(const HomeassistantActionRequest &call
     // Home Assistant subscribes to actions shortly *after* authenticating, so actions
     // fired right at connection time (on_client_connected, on_time_sync, ...) can
     // arrive before the subscription and are lost - warn instead of failing silently.
-    ESP_LOGW(TAG, "Home Assistant %s '%.*s' dropped; %s",
-             call.is_event ? LOG_STR_LITERAL("event") : LOG_STR_LITERAL("action"),
-             static_cast<int>(call.service.size()), call.service.empty() ? "" : call.service.c_str(),
+    ESP_LOGW(TAG, "Home Assistant %s '%s' dropped; %s",
+             call.is_event ? LOG_STR_LITERAL("event") : LOG_STR_LITERAL("action"), call.service.c_str(),
              this->is_connected() ? LOG_STR_LITERAL("client has not subscribed to actions (yet)")
                                   : LOG_STR_LITERAL("no client connected"));
   }

esphome/components/api/api_server.h

@@ -14,7 +14,7 @@
 #include "esphome/components/socket/socket.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
-#include "esphome/core/entity_includes.h"
+#include "esphome/core/controller.h"
 #include "esphome/core/log.h"
 #include "esphome/core/string_ref.h"
 #ifdef USE_PROVISIONING
@@ -49,7 +49,8 @@ struct SavedNoisePsk {
 bool load_saved_noise_psk(noise::psk_t &out);
 #endif
 
-class APIServer final : public Component
+class APIServer final : public Component,
+                        public Controller
 #ifdef USE_CAMERA
     ,
                         public camera::CameraListener
@@ -93,58 +94,58 @@ class APIServer final : public Component
 
   void handle_disconnect(APIConnection *conn);
 #ifdef USE_BINARY_SENSOR
-  void on_binary_sensor_update(binary_sensor::BinarySensor *obj);
+  void on_binary_sensor_update(binary_sensor::BinarySensor *obj) override;
 #endif
 #ifdef USE_COVER
-  void on_cover_update(cover::Cover *obj);
+  void on_cover_update(cover::Cover *obj) override;
 #endif
 #ifdef USE_FAN
-  void on_fan_update(fan::Fan *obj);
+  void on_fan_update(fan::Fan *obj) override;
 #endif
 #ifdef USE_LIGHT
-  void on_light_update(light::LightState *obj);
+  void on_light_update(light::LightState *obj) override;
 #endif
 #ifdef USE_SENSOR
-  void on_sensor_update(sensor::Sensor *obj);
+  void on_sensor_update(sensor::Sensor *obj) override;
 #endif
 #ifdef USE_SWITCH
-  void on_switch_update(switch_::Switch *obj);
+  void on_switch_update(switch_::Switch *obj) override;
 #endif
 #ifdef USE_TEXT_SENSOR
-  void on_text_sensor_update(text_sensor::TextSensor *obj);
+  void on_text_sensor_update(text_sensor::TextSensor *obj) override;
 #endif
 #ifdef USE_CLIMATE
-  void on_climate_update(climate::Climate *obj);
+  void on_climate_update(climate::Climate *obj) override;
 #endif
 #ifdef USE_NUMBER
-  void on_number_update(number::Number *obj);
+  void on_number_update(number::Number *obj) override;
 #endif
 #ifdef USE_DATETIME_DATE
-  void on_date_update(datetime::DateEntity *obj);
+  void on_date_update(datetime::DateEntity *obj) override;
 #endif
 #ifdef USE_DATETIME_TIME
-  void on_time_update(datetime::TimeEntity *obj);
+  void on_time_update(datetime::TimeEntity *obj) override;
 #endif
 #ifdef USE_DATETIME_DATETIME
-  void on_datetime_update(datetime::DateTimeEntity *obj);
+  void on_datetime_update(datetime::DateTimeEntity *obj) override;
 #endif
 #ifdef USE_TEXT
-  void on_text_update(text::Text *obj);
+  void on_text_update(text::Text *obj) override;
 #endif
 #ifdef USE_SELECT
-  void on_select_update(select::Select *obj);
+  void on_select_update(select::Select *obj) override;
 #endif
 #ifdef USE_LOCK
-  void on_lock_update(lock::Lock *obj);
+  void on_lock_update(lock::Lock *obj) override;
 #endif
 #ifdef USE_VALVE
-  void on_valve_update(valve::Valve *obj);
+  void on_valve_update(valve::Valve *obj) override;
 #endif
 #ifdef USE_MEDIA_PLAYER
-  void on_media_player_update(media_player::MediaPlayer *obj);
+  void on_media_player_update(media_player::MediaPlayer *obj) override;
 #endif
 #ifdef USE_WATER_HEATER
-  void on_water_heater_update(water_heater::WaterHeater *obj);
+  void on_water_heater_update(water_heater::WaterHeater *obj) override;
 #endif
 #ifdef USE_API_HOMEASSISTANT_SERVICES
   void send_homeassistant_action(const HomeassistantActionRequest &call);
@@ -187,13 +188,13 @@ class APIServer final : public Component
 #endif
 
 #ifdef USE_ALARM_CONTROL_PANEL
-  void on_alarm_control_panel_update(alarm_control_panel::AlarmControlPanel *obj);
+  void on_alarm_control_panel_update(alarm_control_panel::AlarmControlPanel *obj) override;
 #endif
 #ifdef USE_EVENT
-  void on_event(event::Event *obj);
+  void on_event(event::Event *obj) override;
 #endif
 #ifdef USE_UPDATE
-  void on_update(update::UpdateEntity *obj);
+  void on_update(update::UpdateEntity *obj) override;
 #endif
 #ifdef USE_ZWAVE_PROXY
   void on_zwave_proxy_request(const ZWaveProxyRequest &msg);

esphome/components/api/proto.cpp

@@ -195,12 +195,6 @@ void proto_check_bounds_failed(const uint8_t *pos, size_t bytes, const uint8_t *
   ESP_LOGE(TAG, "Proto encode bounds check failed in %s: need %zu bytes, %td available", caller, bytes, end - pos);
   abort();
 }
-void proto_check_encode_end(const uint8_t *end, const uint8_t *expected) {
-  if (end == expected)
-    return;
-  ESP_LOGE(TAG, "Proto encode ended %td bytes off the calculated size", end - expected);
-  abort();
-}
 void ProtoWriteBuffer::debug_check_bounds_(size_t bytes, const char *caller) {
   if (this->pos_ + bytes > this->buffer_->data() + this->buffer_->size()) {
     ESP_LOGE(TAG, "ProtoWriteBuffer bounds check failed in %s: bytes=%zu offset=%td buf_size=%zu", caller, bytes,
@@ -216,78 +210,77 @@ void ProtoWriteBuffer::debug_check_encode_size_(uint32_t field_id, uint32_t expe
 
 #endif
 
-void ProtoDecodableMessage::decode_fields(void *msg, const uint8_t *buffer, size_t length, DecodeFieldFn field) {
+void ProtoDecodableMessage::decode(const uint8_t *buffer, size_t length) {
   const uint8_t *ptr = buffer;
   const uint8_t *end = buffer + length;
 
-  // Single-byte varints dominate, so that case advances the cursor inline.
-  auto read_varint = [&](proto_varint_value_t &value) ESPHOME_ALWAYS_INLINE {
-    if (ptr == end)
-      return false;
-    if (*ptr < 0x80) [[likely]] {
-      value = *ptr++;
-      return true;
-    }
-    auto res = ProtoVarInt::parse_non_empty(ptr, end - ptr);
-    if (!res.has_value())
-      return false;
-    value = res.value;
-    ptr += res.consumed;
-    return true;
-  };
-
   while (ptr < end) {
-    proto_varint_value_t tag_value;
-    if (!read_varint(tag_value)) {
+    // Parse field header - ptr < end guarantees len >= 1
+    auto res = ProtoVarInt::parse_non_empty(ptr, end - ptr);
+    if (!res.has_value()) {
       ESP_LOGV(TAG, "Invalid field start at offset %ld", (long) (ptr - buffer));
       return;
     }
 
-    uint32_t tag = static_cast<uint32_t>(tag_value);
+    uint32_t tag = static_cast<uint32_t>(res.value);
     uint32_t field_type = tag & WIRE_TYPE_MASK;
-    // Length-delimited fields move this past the length prefix
-    const uint8_t *data = ptr;
-    proto_varint_value_t scalar;
+    uint32_t field_id = tag >> 3;
+    ptr += res.consumed;
 
-    if (field_type == WIRE_TYPE_VARINT) [[likely]] {
-      if (!read_varint(scalar)) {
-        ESP_LOGV(TAG, "Invalid VarInt at offset %ld", (long) (ptr - buffer));
-        return;
-      }
-    } else {
-      switch (field_type) {
-        case WIRE_TYPE_LENGTH_DELIMITED: {
-          proto_varint_value_t length_value;
-          if (!read_varint(length_value)) {
-            ESP_LOGV(TAG, "Invalid Length Delimited at offset %ld", (long) (ptr - buffer));
-            return;
-          }
-          uint32_t field_length = static_cast<uint32_t>(length_value);
-          if (field_length > static_cast<size_t>(end - ptr)) {
-            ESP_LOGV(TAG, "Out-of-bounds Length Delimited at offset %ld", (long) (ptr - buffer));
-            return;
-          }
-          data = ptr;
-          scalar = field_length;
-          ptr += field_length;
-          break;
-        }
-        case WIRE_TYPE_FIXED32: {
-          if (end - ptr < 4) {
-            ESP_LOGV(TAG, "Out-of-bounds Fixed32-bit at offset %ld", (long) (ptr - buffer));
-            return;
-          }
-          // Byte loads instead of memcpy: ESP-IDF passes -fno-builtin-memcpy, which made this a call
-          scalar = encode_uint32(ptr[3], ptr[2], ptr[1], ptr[0]);
-          ptr += 4;
-          break;
-        }
-        default:
-          ESP_LOGV(TAG, "Invalid field type %" PRIu32 " at offset %ld", field_type, (long) (ptr - buffer));
+    switch (field_type) {
+      case WIRE_TYPE_VARINT: {  // VarInt
+        res = ProtoVarInt::parse(ptr, end - ptr);
+        if (!res.has_value()) {
+          ESP_LOGV(TAG, "Invalid VarInt at offset %ld", (long) (ptr - buffer));
           return;
+        }
+        if (!this->decode_varint(field_id, res.value)) {
+          ESP_LOGV(TAG, "Cannot decode VarInt field %" PRIu32 " with value %" PRIu64 "!", field_id,
+                   static_cast<uint64_t>(res.value));
+        }
+        ptr += res.consumed;
+        break;
       }
+      case WIRE_TYPE_LENGTH_DELIMITED: {  // Length-delimited
+        res = ProtoVarInt::parse(ptr, end - ptr);
+        if (!res.has_value()) {
+          ESP_LOGV(TAG, "Invalid Length Delimited at offset %ld", (long) (ptr - buffer));
+          return;
+        }
+        uint32_t field_length = static_cast<uint32_t>(res.value);
+        ptr += res.consumed;
+        if (field_length > static_cast<size_t>(end - ptr)) {
+          ESP_LOGV(TAG, "Out-of-bounds Length Delimited at offset %ld", (long) (ptr - buffer));
+          return;
+        }
+        if (!this->decode_length(field_id, ProtoLengthDelimited(ptr, field_length))) {
+          ESP_LOGV(TAG, "Cannot decode Length Delimited field %" PRIu32 "!", field_id);
+        }
+        ptr += field_length;
+        break;
+      }
+      case WIRE_TYPE_FIXED32: {  // 32-bit
+        if (end - ptr < 4) {
+          ESP_LOGV(TAG, "Out-of-bounds Fixed32-bit at offset %ld", (long) (ptr - buffer));
+          return;
+        }
+        uint32_t val;
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+        // Protobuf fixed32 is little-endian — direct load on LE platforms
+        memcpy(&val, ptr, 4);
+#else
+        val = encode_uint32(ptr[3], ptr[2], ptr[1], ptr[0]);
+#endif
+        if (!this->decode_32bit(field_id, Proto32Bit(val))) {
+          ESP_LOGV(TAG, "Cannot decode 32-bit field %" PRIu32 " with value %" PRIu32 "!", field_id, val);
+        }
+        ptr += 4;
+        break;
+      }
+      default:
+        ESP_LOGV(TAG, "Invalid field type %" PRIu32 " at offset %ld", field_type, (long) (ptr - buffer));
+        return;
     }
-    field(msg, tag, data, scalar);
   }
 }
 

esphome/components/api/proto.h

@@ -10,7 +10,6 @@
 
 #include <cassert>
 #include <cstring>
-#include <type_traits>
 #include <vector>
 
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
@@ -171,43 +170,40 @@ class ProtoVarInt {
 class ProtoMessage;
 class ProtoSize;
 
-/// Case label for decode_field(): the wire tag of a field, so a field that arrives with another wire
-/// type matches no case.
-constexpr uint32_t proto_tag(uint32_t field_id, uint32_t wire_type) { return (field_id << 3) | wire_type; }
-
-/// One decoded field: the payload pointer and a scalar holding the varint or fixed32 value, or the
-/// length of a length-delimited field. The wire type in the tag says which applies; accessors do not check.
-class ProtoFieldValue {
+class ProtoLengthDelimited {
  public:
-  ProtoFieldValue(const uint8_t *data, proto_varint_value_t scalar) : data_(data), scalar_(scalar) {}
+  explicit ProtoLengthDelimited(const uint8_t *value, size_t length) : value_(value), length_(length) {}
+  std::string as_string() const { return std::string(reinterpret_cast<const char *>(this->value_), this->length_); }
 
-  proto_varint_value_t as_varint() const { return this->scalar_; }
-  // A bool is sent as 0 or 1, so the low word is enough and saves a second compare with 64 bit varints
-  bool as_bool() const { return static_cast<uint32_t>(this->scalar_) != 0; }
+  // Direct access to raw data without string allocation
+  const uint8_t *data() const { return this->value_; }
+  size_t size() const { return this->length_; }
 
-  // Length-delimited accessors
-  const uint8_t *data() const { return this->data_; }
-  size_t size() const { return static_cast<size_t>(this->scalar_); }
-  std::string as_string() const { return std::string(reinterpret_cast<const char *>(this->data_), this->size()); }
-  /// Decode the length-delimited payload into a message instance.
+  /// Decode the length-delimited data into a message instance.
   /// Template preserves concrete type so decode() resolves statically.
-  template<typename T> void decode_to_message(T &msg) const { msg.decode(this->data_, this->size()); }
+  template<typename T> void decode_to_message(T &msg) const;
 
-  // Fixed32 accessors
-  uint32_t as_fixed32() const { return static_cast<uint32_t>(this->scalar_); }
-  int32_t as_sfixed32() const { return static_cast<int32_t>(this->as_fixed32()); }
+ protected:
+  const uint8_t *const value_;
+  const size_t length_;
+};
+
+class Proto32Bit {
+ public:
+  explicit Proto32Bit(uint32_t value) : value_(value) {}
+  uint32_t as_fixed32() const { return this->value_; }
+  int32_t as_sfixed32() const { return static_cast<int32_t>(this->value_); }
   float as_float() const {
     union {
       uint32_t raw;
       float value;
     } s{};
-    s.raw = this->as_fixed32();
+    s.raw = this->value_;
     return s.value;
   }
 
- private:
-  const uint8_t *data_;
-  proto_varint_value_t scalar_;
+ protected:
+  const uint32_t value_;
 };
 
 // NOTE: Proto64Bit class removed - wire type 1 (64-bit fixed) not supported
@@ -225,9 +221,6 @@ class ProtoFieldValue {
       proto_check_bounds_failed(pos, n, proto_debug_end_, __builtin_FUNCTION()); \
   } while (0)
 void proto_check_bounds_failed(const uint8_t *pos, size_t bytes, const uint8_t *end, const char *caller);
-/// Aborts unless an encode body ended exactly where calculate_size() promised. A plain check rather than
-/// assert(), so NDEBUG cannot switch it off.
-void proto_check_encode_end(const uint8_t *end, const uint8_t *expected);
 #else
 #define PROTO_ENCODE_DEBUG_PARAM
 #define PROTO_ENCODE_DEBUG_ARG
@@ -259,7 +252,7 @@ class ProtoWriteBuffer {
    *
    * Following https://protobuf.dev/programming-guides/encoding/#structure
    */
-  void encode_field_raw(uint32_t field_id, uint32_t type) { this->encode_varint_raw(proto_tag(field_id, type)); }
+  void encode_field_raw(uint32_t field_id, uint32_t type) { this->encode_varint_raw((field_id << 3) | type); }
   /// Single-pass encode for repeated submessage elements.
   /// Thin template wrapper; all buffer work is in the non-template core.
   template<typename T> void encode_sub_message(uint32_t field_id, const T &value);
@@ -294,31 +287,19 @@ class ProtoWriteBuffer {
   uint8_t *pos_;
 };
 
-// A four byte unaligned store is a memcpy call on ESP-IDF (-fno-builtin-memcpy) and on ARM cores without
-// unaligned access (Cortex-M0+, ARM9), so those targets share one outlined byte store helper per fixed32
-// field. Elsewhere the write inlines to a single store, or on ESP8266 to a few stores that measured
-// faster than a call, so it stays inline.
-#if defined(USE_ESP32) || (defined(__arm__) && !defined(__ARM_FEATURE_UNALIGNED))
-#define PROTO_OUTLINE_FOR_SIZE __attribute__((noinline))
-#define PROTO_FIXED32_BYTE_STORES true
-#else
-#define PROTO_OUTLINE_FOR_SIZE inline
-#define PROTO_FIXED32_BYTE_STORES false
-#endif
-
 // Varint encoding thresholds — used by both proto_encode_* free functions and ProtoSize.
 constexpr uint32_t VARINT_MAX_1_BYTE = 1 << 7;   // 128
 constexpr uint32_t VARINT_MAX_2_BYTE = 1 << 14;  // 16384
 
-/// Static encode helpers for the generated encode bodies. Each takes the write cursor by value and
-/// returns it advanced, so outlined calls at -Os chain through the return register instead of a
-/// stack slot. Helpers without a _force suffix skip fields holding the proto3 default.
+/// Static encode helpers for generated encode() functions.
+/// Generated code hoists buffer.pos_ into a local uint8_t *__restrict__ pos,
+/// then calls these methods which take pos by reference. No struct, no overhead.
+/// For sub-messages, pos is synced back to buffer before the call and reloaded after.
 class ProtoEncode {
  public:
   /// Write a multi-byte varint directly through a pos pointer.
   template<typename T>
-  [[nodiscard]] static inline uint8_t *encode_varint_raw_loop(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                              T value) {
+  static inline void encode_varint_raw_loop(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, T value) {
     do {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
       *pos++ = static_cast<uint8_t>(value | 0x80);
@@ -326,49 +307,48 @@ class ProtoEncode {
     } while (value > 0x7F);
     PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
     *pos++ = static_cast<uint8_t>(value);
-    return pos;
   }
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  encode_varint_raw(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint32_t value) {
+  static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
+                                                             uint32_t value) {
     if (value < VARINT_MAX_1_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
       *pos++ = static_cast<uint8_t>(value);
-      return pos;
+      return;
     }
-    return encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
   /// Encode a varint that is expected to be 1-2 bytes (e.g. zigzag RSSI, small lengths).
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  encode_varint_raw_short(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint32_t value) {
+  static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw_short(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
+                                                                   uint32_t value) {
     if (value < VARINT_MAX_1_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
       *pos++ = static_cast<uint8_t>(value);
-      return pos;
+      return;
     }
     if (value < VARINT_MAX_2_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 2);
       *pos++ = static_cast<uint8_t>(value | 0x80);
       *pos++ = static_cast<uint8_t>(value >> 7);
-      return pos;
+      return;
     }
-    return encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  encode_varint_raw_64(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint64_t value) {
+  static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw_64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
+                                                                uint64_t value) {
     if (value < VARINT_MAX_1_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
       *pos++ = static_cast<uint8_t>(value);
-      return pos;
+      return;
     }
-    return encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
   /// Encode a 48-bit MAC address (stored in a uint64) as varint.
   /// Real MAC addresses occupy the full 48 bits (OUI in upper 24), so the
   /// fast path -- any non-zero bit in the top 6 of 48 -- emits exactly 7 bytes
   /// with no per-byte branch. Falls back to the general loop otherwise.
   /// Caller must guarantee value fits in 48 bits (checked in debug builds).
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  encode_varint_raw_48bit(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint64_t value) {
+  static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw_48bit(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
+                                                                   uint64_t value) {
 #ifdef ESPHOME_DEBUG_API
     assert(value < (1ULL << (MAC_ADDRESS_SIZE * 8)) && "encode_varint_raw_48bit: value exceeds 48 bits");
 #endif
@@ -383,39 +363,38 @@ class ProtoEncode {
       pos[4] = static_cast<uint8_t>((value >> 28) | 0x80);
       pos[5] = static_cast<uint8_t>((value >> 35) | 0x80);
       pos[6] = static_cast<uint8_t>(value >> 42);
-      return pos + 7;
+      pos += 7;
+      return;
     }
-    return encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
+    encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  encode_field_raw(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, uint32_t type) {
-    return encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, proto_tag(field_id, type));
+  static inline void ESPHOME_ALWAYS_INLINE encode_field_raw(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
+                                                            uint32_t field_id, uint32_t type) {
+    encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, (field_id << 3) | type);
   }
   /// Write a single precomputed tag byte. Tag must be < 128.
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  write_raw_byte(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint8_t b) {
+  static inline void ESPHOME_ALWAYS_INLINE write_raw_byte(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
+                                                          uint8_t b) {
     PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
     *pos++ = b;
-    return pos;
   }
   /// Reserve one byte for later backpatch (e.g., sub-message length).
   /// Advances pos past the reserved byte without writing a value.
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  reserve_byte(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
+  static inline void ESPHOME_ALWAYS_INLINE reserve_byte(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM) {
     PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
-    return pos + 1;
+    pos++;
   }
   /// Write raw bytes to the buffer (no tag, no length prefix).
-  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
-  encode_raw(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, const void *data, size_t len) {
+  static inline void ESPHOME_ALWAYS_INLINE encode_raw(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
+                                                      const void *data, size_t len) {
     PROTO_ENCODE_CHECK_BOUNDS(pos, len);
     std::memcpy(pos, data, len);
-    return pos + len;
+    pos += len;
   }
   /// Encode tag + 1-byte length + raw string data. For strings with max_data_length < 128.
   /// Tag must be a single-byte varint (< 128). Always encodes (no zero check).
-  [[nodiscard]] static inline uint8_t *encode_short_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                                 uint8_t tag, const StringRef &ref) {
+  static inline void encode_short_string_force(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint8_t tag,
+                                               const StringRef &ref) {
 #ifdef ESPHOME_DEBUG_API
     assert(ref.size() < 128 && "encode_short_string_force: string exceeds max_data_length < 128");
 #endif
@@ -423,191 +402,137 @@ class ProtoEncode {
     pos[0] = tag;
     pos[1] = static_cast<uint8_t>(ref.size());
     std::memcpy(pos + 2, ref.c_str(), ref.size());
-    return pos + 2 + ref.size();
+    pos += 2 + ref.size();
   }
-  /// Write a precomputed tag byte + 32-bit value. Outlined on embedded: one copy beats inline stores per field.
-  [[nodiscard]] static PROTO_OUTLINE_FOR_SIZE uint8_t *write_tag_and_fixed32(
-      uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint8_t tag, uint32_t value) {
+  /// Write a precomputed tag byte + 32-bit value in one operation.
+  static inline void ESPHOME_ALWAYS_INLINE write_tag_and_fixed32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
+                                                                 uint8_t tag, uint32_t value) {
     PROTO_ENCODE_CHECK_BOUNDS(pos, 5);
     pos[0] = tag;
-    write_fixed32_le(pos + 1, value);
-    return pos + 5;
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    std::memcpy(pos + 1, &value, 4);
+#else
+    pos[1] = static_cast<uint8_t>(value & 0xFF);
+    pos[2] = static_cast<uint8_t>((value >> 8) & 0xFF);
+    pos[3] = static_cast<uint8_t>((value >> 16) & 0xFF);
+    pos[4] = static_cast<uint8_t>((value >> 24) & 0xFF);
+#endif
+    pos += 5;
   }
-  [[nodiscard]] static inline uint8_t *encode_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                           uint32_t field_id, const char *string, size_t len) {
-    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 2);  // type 2: Length-delimited string
+  static inline void encode_string(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                   const char *string, size_t len, bool force = false) {
+    if (len == 0 && !force)
+      return;
+    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 2);  // type 2: Length-delimited string
     // NOLINTNEXTLINE(readability-inconsistent-ifelse-braces) -- false positive on [[likely]] attribute
     if (len < VARINT_MAX_1_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1 + len);
       *pos++ = static_cast<uint8_t>(len);
     } else {
-      pos = encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, len);
+      encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, len);
       PROTO_ENCODE_CHECK_BOUNDS(pos, len);
     }
     std::memcpy(pos, string, len);
-    return pos + len;
+    pos += len;
   }
-  [[nodiscard]] static inline uint8_t *encode_string(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                     uint32_t field_id, const char *string, size_t len) {
-    if (len == 0)
-      return pos;
-    return encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, string, len);
+  static inline void encode_string(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                   const std::string &value, bool force = false) {
+    encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, value.data(), value.size(), force);
   }
-  [[nodiscard]] static inline uint8_t *encode_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                           uint32_t field_id, const std::string &value) {
-    return encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value.data(), value.size());
+  static inline void encode_string(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                   const StringRef &ref, bool force = false) {
+    encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, ref.c_str(), ref.size(), force);
   }
-  [[nodiscard]] static inline uint8_t *encode_string(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                     uint32_t field_id, const StringRef &ref) {
-    return encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, ref.c_str(), ref.size());
+  static inline void encode_bytes(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                  const uint8_t *data, size_t len, bool force = false) {
+    encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, reinterpret_cast<const char *>(data), len, force);
   }
-  [[nodiscard]] static inline uint8_t *encode_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                           uint32_t field_id, const StringRef &ref) {
-    return encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, ref.c_str(), ref.size());
+  static inline void encode_uint32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                   uint32_t value, bool force = false) {
+    if (value == 0 && !force)
+      return;
+    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
+    encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
-  [[nodiscard]] static inline uint8_t *encode_bytes(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                    uint32_t field_id, const uint8_t *data, size_t len) {
-    return encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, reinterpret_cast<const char *>(data), len);
+  static inline void encode_uint64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                   uint64_t value, bool force = false) {
+    if (value == 0 && !force)
+      return;
+    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
+    encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
-  [[nodiscard]] static inline uint8_t *encode_bytes_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                          uint32_t field_id, const uint8_t *data, size_t len) {
-    return encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, reinterpret_cast<const char *>(data), len);
-  }
-  [[nodiscard]] static inline uint8_t *encode_uint32_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                           uint32_t field_id, uint32_t value) {
-    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
-    return encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, value);
-  }
-  [[nodiscard]] static inline uint8_t *encode_uint32(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                     uint32_t field_id, uint32_t value) {
-    if (value == 0)
-      return pos;
-    return encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
-  }
-  [[nodiscard]] static inline uint8_t *encode_uint64_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                           uint32_t field_id, uint64_t value) {
-    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
-    return encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
-  }
-  [[nodiscard]] static inline uint8_t *encode_uint64(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                     uint32_t field_id, uint64_t value) {
-    if (value == 0)
-      return pos;
-    return encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
-  }
-  [[nodiscard]] static inline uint8_t *encode_bool_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                         uint32_t field_id, bool value) {
-    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
+  static inline void encode_bool(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, bool value,
+                                 bool force = false) {
+    if (!value && !force)
+      return;
+    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
     PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
     *pos++ = value ? 0x01 : 0x00;
-    return pos;
   }
-  [[nodiscard]] static inline uint8_t *encode_bool(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                   uint32_t field_id, bool value) {
-    if (!value)
-      return pos;
-    return encode_bool_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
-  }
-  /// Tag + fixed32 for multi-byte tags; single-byte tags use write_tag_and_fixed32.
-  [[nodiscard]] static PROTO_OUTLINE_FOR_SIZE uint8_t *encode_fixed32_force(
-      uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, uint32_t value) {
-    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 5);
+  static inline void encode_fixed32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                    uint32_t value, bool force = false) {
+    if (value == 0 && !force)
+      return;
+    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 5);
     PROTO_ENCODE_CHECK_BOUNDS(pos, 4);
-    write_fixed32_le(pos, value);
-    return pos + 4;
-  }
-  [[nodiscard]] static inline uint8_t *encode_fixed32(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                      uint32_t field_id, uint32_t value) {
-    if (value == 0)
-      return pos;
-    return encode_fixed32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    std::memcpy(pos, &value, 4);
+    pos += 4;
+#else
+    *pos++ = (value >> 0) & 0xFF;
+    *pos++ = (value >> 8) & 0xFF;
+    *pos++ = (value >> 16) & 0xFF;
+    *pos++ = (value >> 24) & 0xFF;
+#endif
   }
   // NOTE: Wire type 1 (64-bit fixed: double, fixed64, sfixed64) is intentionally
   // not supported to reduce overhead on embedded systems. All ESPHome devices are
   // 32-bit microcontrollers where 64-bit operations are expensive. If 64-bit support
   // is needed in the future, the necessary encoding/decoding functions must be added.
-  [[nodiscard]] static inline uint8_t *encode_float(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                    uint32_t field_id, float value) {
-    return encode_fixed32(pos PROTO_ENCODE_DEBUG_ARG, field_id, float_to_raw(value));
+  static inline void encode_float(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, float value,
+                                  bool force = false) {
+    uint32_t raw = float_to_raw(value);
+    if (raw == 0 && !force)
+      return;
+    encode_fixed32(pos PROTO_ENCODE_DEBUG_ARG, field_id, raw);
   }
-  [[nodiscard]] static inline uint8_t *encode_float_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                          uint32_t field_id, float value) {
-    return encode_fixed32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, float_to_raw(value));
-  }
-  [[nodiscard]] static inline uint8_t *encode_int32_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                          uint32_t field_id, int32_t value) {
+  static inline void encode_int32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, int32_t value,
+                                  bool force = false) {
     if (value < 0) {
       // negative int32 is always 10 byte long
-      return encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value));
+      encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value), force);
+      return;
     }
-    return encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint32_t>(value));
+    encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint32_t>(value), force);
   }
-  [[nodiscard]] static inline uint8_t *encode_int32(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                    uint32_t field_id, int32_t value) {
-    if (value == 0)
-      return pos;
-    return encode_int32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
+  static inline void encode_int64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, int64_t value,
+                                  bool force = false) {
+    encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value), force);
   }
-  [[nodiscard]] static inline uint8_t *encode_int64(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                    uint32_t field_id, int64_t value) {
-    return encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value));
+  static inline void encode_sint32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                   int32_t value, bool force = false) {
+    encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag32(value), force);
   }
-  [[nodiscard]] static inline uint8_t *encode_int64_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                          uint32_t field_id, int64_t value) {
-    return encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value));
+  static inline void encode_sint64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
+                                   int64_t value, bool force = false) {
+    encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag64(value), force);
   }
-  [[nodiscard]] static inline uint8_t *encode_sint32(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                     uint32_t field_id, int32_t value) {
-    return encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag32(value));
-  }
-  [[nodiscard]] static inline uint8_t *encode_sint32_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                           uint32_t field_id, int32_t value) {
-    return encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag32(value));
-  }
-  [[nodiscard]] static inline uint8_t *encode_sint64(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                     uint32_t field_id, int64_t value) {
-    return encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag64(value));
-  }
-  [[nodiscard]] static inline uint8_t *encode_sint64_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                           uint32_t field_id, int64_t value) {
-    return encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag64(value));
-  }
-  /// Sub-message encoding: sync pos to buffer, delegate, read the cursor back.
+  /// Sub-message encoding: sync pos to buffer, delegate, get pos from return value.
   template<typename T>
-  [[nodiscard]] static inline uint8_t *encode_sub_message(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                          ProtoWriteBuffer &buffer, uint32_t field_id, const T &value) {
+  static inline void encode_sub_message(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, ProtoWriteBuffer &buffer,
+                                        uint32_t field_id, const T &value) {
     buffer.set_pos(pos);
     buffer.encode_sub_message(field_id, value);
-    return buffer.get_pos();
+    pos = buffer.get_pos();
   }
   template<typename T>
-  [[nodiscard]] static inline uint8_t *encode_optional_sub_message(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                                   ProtoWriteBuffer &buffer, uint32_t field_id,
-                                                                   const T &value) {
+  static inline void encode_optional_sub_message(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
+                                                 ProtoWriteBuffer &buffer, uint32_t field_id, const T &value) {
     buffer.set_pos(pos);
     buffer.encode_optional_sub_message(field_id, value);
-    return buffer.get_pos();
-  }
-
- private:
-  /// Unaligned little endian store of four bytes: byte stores where the outlined helper lives (ESP-IDF, ARM
-  /// without unaligned access), otherwise a memcpy the compiler folds into one store. Callers bounds check
-  /// and advance the cursor themselves.
-  static inline void ESPHOME_ALWAYS_INLINE write_fixed32_le(uint8_t *__restrict__ pos, uint32_t value) {
-    if constexpr (PROTO_FIXED32_BYTE_STORES) {
-      // Spelled out so the outlined helper does not itself become a memcpy call
-      pos[0] = static_cast<uint8_t>(value);
-      pos[1] = static_cast<uint8_t>(value >> 8);
-      pos[2] = static_cast<uint8_t>(value >> 16);
-      pos[3] = static_cast<uint8_t>(value >> 24);
-    } else {
-      const uint32_t le = convert_little_endian(value);
-      __builtin_memcpy(pos, &le, 4);
-    }
+    pos = buffer.get_pos();
   }
 };
-#undef PROTO_OUTLINE_FOR_SIZE
-#undef PROTO_FIXED32_BYTE_STORES
 
 #ifdef HAS_PROTO_MESSAGE_DUMP
 /**
@@ -699,12 +624,11 @@ class DumpBuffer {
 
 class ProtoMessage {
  public:
-  // Non-virtual defaults for messages with no fields; generated classes hide all four. The
-  // static encode_msg/calc_size_msg take const void * so &T::encode_msg needs no thunk.
-  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
-    return buffer.get_pos();
-  }
-  static uint32_t calc_size_msg(const void *self) { return 0; }
+  // Non-virtual defaults for messages with no fields.
+  // Concrete message classes hide these with their own implementations.
+  // All call sites use templates to preserve the concrete type, so virtual
+  // dispatch is not needed. This eliminates per-message vtable entries for
+  // encode/calculate_size, saving ~1.3 KB of flash across all message types.
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const { return buffer.get_pos(); }
   uint32_t calculate_size() const { return 0; }
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -724,13 +648,7 @@ class ProtoMessage {
 // Base class for messages that support decoding
 class ProtoDecodableMessage : public ProtoMessage {
  public:
-  /// Stores one decoded field into \p msg; generated per message type. \p scalar is the varint or
-  /// fixed32 value, or the length of the length-delimited payload at \p data. An unknown field or
-  /// wrong wire type matches no case and is skipped.
-  using DecodeFieldFn = void (*)(void *msg, uint32_t tag, const uint8_t *data, proto_varint_value_t scalar);
-  /// Walk \p buffer and hand every field to \p field. The generated decode() passes the message's
-  /// own decode_field, so decodable messages carry no vtable.
-  static void decode_fields(void *msg, const uint8_t *buffer, size_t length, DecodeFieldFn field);
+  void decode(const uint8_t *buffer, size_t length);
 
   /**
    * Count occurrences of a repeated field in a protobuf buffer.
@@ -742,15 +660,14 @@ class ProtoDecodableMessage : public ProtoMessage {
    * @return Number of times the field appears in the buffer
    */
   static uint32_t count_repeated_field(const uint8_t *buffer, size_t length, uint32_t target_field_id);
-  // The destructor stays accessible on purpose: the generated messages are aggregates that brace
-  // initialise sub message members, which copies a base temporary. That trades away the compile time
-  // guard against deleting through this type; messages are stack locals and never owned through a base
-  // pointer. ProtoMessage keeps its guard for the dump builds.
+
+ protected:
+  ~ProtoDecodableMessage() = default;
+  virtual bool decode_varint(uint32_t field_id, proto_varint_value_t value) { return false; }
+  virtual bool decode_length(uint32_t field_id, ProtoLengthDelimited value) { return false; }
+  virtual bool decode_32bit(uint32_t field_id, Proto32Bit value) { return false; }
+  // NOTE: decode_64bit removed - wire type 1 not supported
 };
-#ifndef HAS_PROTO_MESSAGE_DUMP
-// decode() passes decode_field explicitly, so nothing here may add a vtable
-static_assert(!std::is_polymorphic_v<ProtoDecodableMessage>, "decodable messages carry no vtable");
-#endif
 
 class ProtoSize {
  public:
@@ -875,7 +792,7 @@ class ProtoSize {
    * @return The number of bytes needed to encode the field ID and wire type
    */
   static constexpr uint32_t field(uint32_t field_id, uint32_t type) {
-    uint32_t tag = proto_tag(field_id, type & WIRE_TYPE_MASK);
+    uint32_t tag = (field_id << 3) | (type & WIRE_TYPE_MASK);
     return varint(tag);
   }
 
@@ -959,14 +876,24 @@ class ProtoSize {
 
 // Implementation of methods that depend on ProtoSize being fully defined
 
+// Encode thunk — converts void* back to concrete type for direct encode() call
+template<typename T> uint8_t *proto_encode_msg(const void *msg, ProtoWriteBuffer &buf PROTO_ENCODE_DEBUG_PARAM) {
+  return static_cast<const T *>(msg)->encode(buf PROTO_ENCODE_DEBUG_ARG);
+}
+
 // Thin template wrapper; delegates to non-template core in proto.cpp.
 template<typename T> inline void ProtoWriteBuffer::encode_sub_message(uint32_t field_id, const T &value) {
-  this->encode_sub_message(field_id, &value, &T::encode_msg);
+  this->encode_sub_message(field_id, &value, &proto_encode_msg<T>);
 }
 
 // Thin template wrapper; delegates to non-template core.
 template<typename T> inline void ProtoWriteBuffer::encode_optional_sub_message(uint32_t field_id, const T &value) {
-  this->encode_optional_sub_message(field_id, T::calc_size_msg(&value), &value, &T::encode_msg);
+  this->encode_optional_sub_message(field_id, value.calculate_size(), &value, &proto_encode_msg<T>);
+}
+
+// Template decode_to_message - preserves concrete type so decode() resolves statically
+template<typename T> void ProtoLengthDelimited::decode_to_message(T &msg) const {
+  msg.decode(this->value_, this->length_);
 }
 
 template<typename T> const char *proto_enum_to_string(T value);

esphome/components/api/subscribe_state.h

@@ -4,6 +4,7 @@
 #ifdef USE_API
 #include "esphome/core/component.h"
 #include "esphome/core/component_iterator.h"
+#include "esphome/core/controller.h"
 namespace esphome::api {
 
 class APIConnection;

esphome/components/as7341/sensor.py

@@ -1,6 +1,5 @@
 import esphome.codegen as cg
 from esphome.components import i2c, sensor
-from esphome.components.const import UNIT_COUNTS
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CLEAR,
@@ -34,6 +33,8 @@ CONF_F7 = "f7"
 CONF_F8 = "f8"
 CONF_NIR = "nir"
 
+UNIT_COUNTS = "#"
+
 AS7341_GAIN = as7341_ns.enum("AS7341Gain")
 GAIN_OPTIONS = {
     "X0.5": AS7341_GAIN.AS7341_GAIN_0_5X,

esphome/components/at581x/__init__.py

@@ -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)) is not None:
+        template_ = await cg.templatable(frontend_reset, args, cg.int8)
+        cg.add(var.set_hw_frontend_reset(template_))
+
+    if (freq := config.get(CONF_FREQUENCY)) is not None:
+        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)) is not None:
+        template_ = await cg.templatable(selfcheck, args, cg.int_)
+        cg.add(var.set_poweron_selfcheck_time(template_))
+
+    if (protect := config.get(CONF_PROTECT_TIME)) is not None:
+        template_ = await cg.templatable(protect, args, cg.int_)
+        cg.add(var.set_protect_time(template_))
+
+    if (trig_base := config.get(CONF_TRIGGER_BASE)) is not None:
+        template_ = await cg.templatable(trig_base, args, cg.int_)
+        cg.add(var.set_trigger_base(template_))
+
+    if (trig_keep := config.get(CONF_TRIGGER_KEEP)) is not None:
+        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)) is not None:
+        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

esphome/components/at581x/at581x.h

@@ -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);

esphome/components/at581x/automation.h

@@ -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

esphome/components/audio_dac/__init__.py

@@ -2,8 +2,9 @@ from esphome import automation
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.const import CONF_VOLUME
-from esphome.core import CoroPriority, coroutine_with_priority
+from esphome.const import CONF_ID, CONF_VOLUME
+from esphome.core import ID, CoroPriority, coroutine_with_priority
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@kbx81"]
@@ -12,6 +13,10 @@ IS_PLATFORM_COMPONENT = True
 audio_dac_ns = cg.esphome_ns.namespace("audio_dac")
 AudioDac = audio_dac_ns.class_("AudioDac")
 
+MuteOffAction = audio_dac_ns.class_("MuteOffAction", automation.Action)
+MuteOnAction = audio_dac_ns.class_("MuteOnAction", automation.Action)
+SetVolumeAction = audio_dac_ns.class_("SetVolumeAction", automation.Action)
+
 
 MUTE_ACTION_SCHEMA = maybe_simple_id(
     {
@@ -28,19 +33,41 @@ SET_VOLUME_ACTION_SCHEMA = cv.maybe_simple_value(
 )
 
 
-for _name, _call in (
-    ("audio_dac.mute_off", "set_mute_off()"),
-    ("audio_dac.mute_on", "set_mute_on()"),
-):
-    automation.register_apply_action(
-        _name, MUTE_ACTION_SCHEMA, automation.ApplyCall(_call)
-    )
-
-automation.register_apply_action(
-    "audio_dac.set_volume",
-    SET_VOLUME_ACTION_SCHEMA,
-    automation.ApplyField(CONF_VOLUME, "set_volume", cg.float_),
+@automation.register_action(
+    "audio_dac.mute_off", MuteOffAction, MUTE_ACTION_SCHEMA, synchronous=True
 )
+@automation.register_action(
+    "audio_dac.mute_on", MuteOnAction, MUTE_ACTION_SCHEMA, synchronous=True
+)
+async def audio_dac_mute_action_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(
+    "audio_dac.set_volume",
+    SetVolumeAction,
+    SET_VOLUME_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def audio_dac_set_volume_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+
+    template_ = await cg.templatable(config.get(CONF_VOLUME), args, cg.float_)
+    cg.add(var.set_volume(template_))
+
+    return var
 
 
 @coroutine_with_priority(CoroPriority.CORE)

esphome/components/audio_dac/automation.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "audio_dac.h"
+
+namespace esphome::audio_dac {
+
+template<typename... Ts> class MuteOffAction final : public Action<Ts...> {
+ public:
+  explicit MuteOffAction(AudioDac *audio_dac) : audio_dac_(audio_dac) {}
+
+  void play(const Ts &...x) override { this->audio_dac_->set_mute_off(); }
+
+ protected:
+  AudioDac *audio_dac_;
+};
+
+template<typename... Ts> class MuteOnAction final : public Action<Ts...> {
+ public:
+  explicit MuteOnAction(AudioDac *audio_dac) : audio_dac_(audio_dac) {}
+
+  void play(const Ts &...x) override { this->audio_dac_->set_mute_on(); }
+
+ protected:
+  AudioDac *audio_dac_;
+};
+
+template<typename... Ts> class SetVolumeAction final : public Action<Ts...> {
+ public:
+  explicit SetVolumeAction(AudioDac *audio_dac) : audio_dac_(audio_dac) {}
+
+  TEMPLATABLE_VALUE(float, volume)
+
+  void play(const Ts &...x) override { this->audio_dac_->set_volume(this->volume_.value(x...)); }
+
+ protected:
+  AudioDac *audio_dac_;
+};
+
+}  // namespace esphome::audio_dac

esphome/components/binary_sensor/__init__.py

@@ -1,7 +1,7 @@
 from logging import getLogger
 
 from esphome import automation, core
-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, zigbee
 from esphome.components.const import CONF_ON_STATE_CHANGE
@@ -134,10 +134,16 @@ 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
 )
 
+# Condition
+BinarySensorCondition = binary_sensor_ns.class_("BinarySensorCondition", Condition)
+
 # Filters
 Filter = binary_sensor_ns.class_("Filter")
 TimeoutFilter = binary_sensor_ns.class_("TimeoutFilter", Filter)
@@ -642,12 +648,20 @@ BINARY_SENSOR_CONDITION_SCHEMA = maybe_simple_id(
 )
 
 
-automation.register_apply_condition(
-    "binary_sensor.is_on", BINARY_SENSOR_CONDITION_SCHEMA, "state"
+@automation.register_condition(
+    "binary_sensor.is_on", BinarySensorCondition, BINARY_SENSOR_CONDITION_SCHEMA
 )
-automation.register_apply_condition(
-    "binary_sensor.is_off", BINARY_SENSOR_CONDITION_SCHEMA, "state == false"
+async def binary_sensor_is_on_to_code(config, condition_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren, True)
+
+
+@automation.register_condition(
+    "binary_sensor.is_off", BinarySensorCondition, BINARY_SENSOR_CONDITION_SCHEMA
 )
+async def binary_sensor_is_off_to_code(config, condition_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren, False)
 
 
 @coroutine_with_priority(CoroPriority.CORE)
@@ -655,7 +669,7 @@ async def to_code(config):
     cg.add_global(binary_sensor_ns.using)
 
 
-automation.register_simple_action(
+@automation.register_action(
     "binary_sensor.invalidate_state",
     BinarySensorInvalidateAction,
     cv.maybe_simple_value(
@@ -666,6 +680,9 @@ automation.register_simple_action(
     ),
     synchronous=True,
 )
+async def binary_sensor_invalidate_state_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.cpp only implements the click/double_click/multi_click triggers

esphome/components/binary_sensor/automation.h

@@ -18,6 +18,26 @@ struct MultiClickTriggerEvent {
   uint32_t max_length;
 };
 
+class PressTrigger final : public Trigger<> {
+ public:
+  explicit PressTrigger(BinarySensor *parent) {
+    parent->add_on_state_callback([this](bool state) {
+      if (state)
+        this->trigger();
+    });
+  }
+};
+
+class ReleaseTrigger final : public Trigger<> {
+ public:
+  explicit ReleaseTrigger(BinarySensor *parent) {
+    parent->add_on_state_callback([this](bool state) {
+      if (!state)
+        this->trigger();
+    });
+  }
+};
+
 bool match_interval(uint32_t min_length, uint32_t max_length, uint32_t length);
 
 class ClickTrigger final : public Trigger<> {
@@ -120,6 +140,45 @@ template<size_t N> class MultiClickTrigger final : public MultiClickTriggerBase
   std::array<MultiClickTriggerEvent, N> timing_storage_{};
 };
 
+class StateTrigger final : public Trigger<bool> {
+ public:
+  explicit StateTrigger(BinarySensor *parent) {
+    parent->add_on_state_callback([this](bool state) { this->trigger(state); });
+  }
+};
+
+class StateChangeTrigger final : public Trigger<optional<bool>, optional<bool> > {
+ public:
+  explicit StateChangeTrigger(BinarySensor *parent) {
+    parent->add_full_state_callback(
+        [this](optional<bool> old_state, optional<bool> state) { this->trigger(old_state, state); });
+  }
+};
+
+template<typename... Ts> class BinarySensorCondition final : public Condition<Ts...> {
+ public:
+  BinarySensorCondition(BinarySensor *parent, bool state) : parent_(parent), state_(state) {}
+  bool check(const Ts &...x) override { return this->parent_->state == this->state_; }
+
+ protected:
+  BinarySensor *parent_;
+  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) {}

esphome/components/bk72xx_ble_tracker/__init__.py

@@ -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:

esphome/components/bk72xx_ble_tracker/automation.h

@@ -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

esphome/components/bl0906/sensor.py

@@ -32,6 +32,8 @@ from esphome.const import (
     UNIT_VOLT,
     UNIT_WATT,
 )
+from esphome.core import ID
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 # Import ICONS not included in esphome's const.py, from the local components const.py
@@ -136,7 +138,7 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
 )
 
 
-automation.register_parented_action(
+@automation.register_action(
     "bl0906.reset_energy",
     ResetEnergyAction,
     maybe_simple_id(
@@ -146,6 +148,15 @@ automation.register_parented_action(
     ),
     synchronous=True,
 )
+async def reset_energy_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])
+    return var
 
 
 async def to_code(config: ConfigType) -> None:

esphome/components/ble_client/__init__.py

@@ -207,20 +207,26 @@ BLE_REMOVE_BOND_ACTION_SCHEMA = cv.Schema(
 )
 
 
-automation.register_simple_action(
+@automation.register_action(
     "ble_client.disconnect",
     BLEDisconnectAction,
     BLE_CONNECT_ACTION_SCHEMA,
     synchronous=False,
 )
+async def ble_disconnect_to_code(config, action_id, template_arg, args):
+    parent = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, parent)
 
 
-automation.register_simple_action(
+@automation.register_action(
     "ble_client.connect",
     BLEConnectAction,
     BLE_CONNECT_ACTION_SCHEMA,
     synchronous=False,
 )
+async def ble_connect_to_code(config, action_id, template_arg, args):
+    parent = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, parent)
 
 
 @automation.register_action(
@@ -322,12 +328,15 @@ async def passkey_reply_to_code(config, action_id, template_arg, args):
     return var
 
 
-automation.register_simple_action(
+@automation.register_action(
     "ble_client.remove_bond",
     BLERemoveBondAction,
     BLE_REMOVE_BOND_ACTION_SCHEMA,
     synchronous=True,
 )
+async def remove_bond_to_code(config, action_id, template_arg, args):
+    parent = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, parent)
 
 
 async def to_code(config):

esphome/components/bm8563/time.py

@@ -28,7 +28,7 @@ CONFIG_SCHEMA = (
 )
 
 
-automation.register_parented_action(
+@automation.register_action(
     "bm8563.write_time",
     WriteAction,
     automation.maybe_simple_id(
@@ -38,6 +38,15 @@ automation.register_parented_action(
     ),
     synchronous=True,
 )
+async def bm8563_write_time_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])
+    return var
 
 
 @automation.register_action(
@@ -64,7 +73,7 @@ async def bm8563_start_timer_to_code(
     return var
 
 
-automation.register_parented_action(
+@automation.register_action(
     "bm8563.read_time",
     ReadAction,
     automation.maybe_simple_id(
@@ -74,6 +83,15 @@ automation.register_parented_action(
     ),
     synchronous=True,
 )
+async def bm8563_read_time_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])
+    return var
 
 
 async def to_code(config: ConfigType) -> None:

esphome/components/button/__init__.py

@@ -16,14 +16,14 @@ from esphome.const import (
     DEVICE_CLASS_RESTART,
     DEVICE_CLASS_UPDATE,
 )
-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_device_class,
     setup_entity,
 )
-from esphome.cpp_generator import MockObj, MockObjClass
+from esphome.cpp_generator import MockObj, MockObjClass, TemplateArgsType
 from esphome.types import ConfigType, SafeExpType
 
 CODEOWNERS = ["@esphome/core"]
@@ -40,6 +40,8 @@ button_ns = cg.esphome_ns.namespace("button")
 Button = button_ns.class_("Button", cg.EntityBase)
 ButtonPtr = Button.operator("ptr")
 
+PressAction = button_ns.class_("PressAction", automation.Action)
+
 validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
 
 
@@ -121,9 +123,17 @@ BUTTON_PRESS_SCHEMA = maybe_simple_id(
 )
 
 
-automation.register_apply_action(
-    "button.press", BUTTON_PRESS_SCHEMA, automation.ApplyCall("press()")
+@automation.register_action(
+    "button.press", PressAction, BUTTON_PRESS_SCHEMA, synchronous=True
 )
+async def button_press_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)
 
 
 @coroutine_with_priority(CoroPriority.CORE)

esphome/components/button/automation.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "esphome/components/button/button.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+
+namespace esphome::button {
+
+template<typename... Ts> class PressAction final : public Action<Ts...> {
+ public:
+  explicit PressAction(Button *button) : button_(button) {}
+
+  void play(const Ts &...x) override { this->button_->press(); }
+
+ protected:
+  Button *button_;
+};
+
+class ButtonPressTrigger final : public Trigger<> {
+ public:
+  ButtonPressTrigger(Button *button) {
+    button->add_on_press_callback([this]() { this->trigger(); });
+  }
+};
+
+}  // namespace esphome::button

esphome/components/cc1101/__init__.py

@@ -364,36 +364,22 @@ CC1101_ACTION_SCHEMA = cv.Schema(
 )
 
 
-automation.register_parented_action(
-    "cc1101.begin_tx",
-    BeginTxAction,
-    CC1101_ACTION_SCHEMA,
-    synchronous=True,
+@automation.register_action(
+    "cc1101.begin_tx", BeginTxAction, CC1101_ACTION_SCHEMA, synchronous=True
 )
-
-
-automation.register_parented_action(
-    "cc1101.begin_rx",
-    BeginRxAction,
-    CC1101_ACTION_SCHEMA,
-    synchronous=True,
+@automation.register_action(
+    "cc1101.begin_rx", BeginRxAction, CC1101_ACTION_SCHEMA, synchronous=True
 )
-
-
-automation.register_parented_action(
-    "cc1101.reset",
-    ResetAction,
-    CC1101_ACTION_SCHEMA,
-    synchronous=True,
+@automation.register_action(
+    "cc1101.reset", ResetAction, CC1101_ACTION_SCHEMA, synchronous=True
 )
-
-
-automation.register_parented_action(
-    "cc1101.set_idle",
-    SetIdleAction,
-    CC1101_ACTION_SCHEMA,
-    synchronous=True,
+@automation.register_action(
+    "cc1101.set_idle", SetIdleAction, CC1101_ACTION_SCHEMA, synchronous=True
 )
+async def cc1101_action_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
 
 
 def validate_raw_data(value):
@@ -438,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()

esphome/components/cc1101/cc1101.h

@@ -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

esphome/components/climate/__init__.py

@@ -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,35 +500,78 @@ CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema(
 )
 
 
-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=automation.literal_with_length,
-    ),
-    automation.ApplyField(CONF_PRESET, "set_preset", ClimatePreset),
-    automation.ApplyField(
-        CONF_CUSTOM_PRESET,
-        "set_preset",
-        cg.std_string,
-        const_fn=automation.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)

esphome/components/climate/automation.h

@@ -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) {

esphome/components/climate_ir/__init__.py

@@ -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):

esphome/components/climate_ir/climate_ir.cpp

@@ -13,7 +13,15 @@ climate::ClimateTraits ClimateIR::traits() {
   if (this->humidity_sensor_ != nullptr) {
     traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_HUMIDITY);
   }
-  traits.set_supported_modes(this->modes_);
+  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_dry_)
+    traits.add_supported_mode(climate::CLIMATE_MODE_DRY);
+  if (this->supports_fan_only_)
+    traits.add_supported_mode(climate::CLIMATE_MODE_FAN_ONLY);
 
   traits.set_visual_min_temperature(this->minimum_temperature_);
   traits.set_visual_max_temperature(this->maximum_temperature_);
@@ -86,12 +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",
-                this->minimum_temperature_, this->maximum_temperature_,
-                YESNO(this->modes_.count(climate::CLIMATE_MODE_HEAT)),
-                YESNO(this->modes_.count(climate::CLIMATE_MODE_COOL)),
-                YESNO(this->modes_.count(climate::CLIMATE_MODE_HEAT_COOL)));
+                "  Supports COOL: %s",
+                this->minimum_temperature_, this->maximum_temperature_, YESNO(this->supports_heat_),
+                YESNO(this->supports_cool_));
 }
 
 }  // namespace esphome::climate_ir

esphome/components/climate_ir/climate_ir.h

@@ -30,10 +30,8 @@ class ClimateIR : public Component,
     this->minimum_temperature_ = minimum_temperature;
     this->maximum_temperature_ = maximum_temperature;
     this->temperature_step_ = temperature_step;
-    if (supports_dry)
-      this->modes_.insert(climate::CLIMATE_MODE_DRY);
-    if (supports_fan_only)
-      this->modes_.insert(climate::CLIMATE_MODE_FAN_ONLY);
+    this->supports_dry_ = supports_dry;
+    this->supports_fan_only_ = supports_fan_only;
     this->fan_modes_ = fan_modes;
     this->swing_modes_ = swing_modes;
     this->presets_ = presets;
@@ -41,11 +39,8 @@ class ClimateIR : public Component,
 
   void setup() override;
   void dump_config() override;
-  void set_supports_cool(bool supports_cool) { this->set_mode_supported_(climate::CLIMATE_MODE_COOL, supports_cool); }
-  void set_supports_heat(bool supports_heat) { this->set_mode_supported_(climate::CLIMATE_MODE_HEAT, supports_heat); }
-  void set_supports_heat_cool(bool supports_heat_cool) {
-    this->set_mode_supported_(climate::CLIMATE_MODE_HEAT_COOL, supports_heat_cool);
-  }
+  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) { this->sensor_ = sensor; }
   void set_humidity_sensor(sensor::Sensor *sensor) { this->humidity_sensor_ = sensor; }
 
@@ -63,18 +58,10 @@ class ClimateIR : public Component,
   // Dummy implement on_receive so implementation is optional for inheritors
   bool on_receive(remote_base::RemoteReceiveData data) override { return false; };
 
-  ESPHOME_ALWAYS_INLINE void set_mode_supported_(climate::ClimateMode mode, bool supported) {
-    if (supported) {
-      this->modes_.insert(mode);
-    } else {
-      this->modes_.erase(mode);
-    }
-  }
-
-  // The HEAT_COOL default (supports_cool && supports_heat) is resolved during code generation.
-  static constexpr climate::ClimateModeMask DEFAULT_MODES{climate::CLIMATE_MODE_OFF, climate::CLIMATE_MODE_COOL,
-                                                          climate::CLIMATE_MODE_HEAT, climate::CLIMATE_MODE_HEAT_COOL};
-  climate::ClimateModeMask modes_{DEFAULT_MODES};
+  bool supports_cool_{true};
+  bool supports_heat_{true};
+  bool supports_dry_{false};
+  bool supports_fan_only_{false};
   climate::ClimateFanModeMask fan_modes_{};
   climate::ClimateSwingModeMask swing_modes_{};
   climate::ClimatePresetMask presets_{};

esphome/components/cm1106/sensor.py

@@ -13,6 +13,8 @@ from esphome.const import (
     STATE_CLASS_MEASUREMENT,
     UNIT_PARTS_PER_MILLION,
 )
+from esphome.core import ID
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 DEPENDENCIES = ["uart"]
@@ -70,9 +72,18 @@ CALIBRATION_ACTION_SCHEMA = maybe_simple_id(
 )
 
 
-automation.register_simple_action(
+@automation.register_action(
     "cm1106.calibrate_zero",
     CM1106CalibrateZeroAction,
     CALIBRATION_ACTION_SCHEMA,
     synchronous=True,
 )
+async def cm1106_calibration_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    """Service code generation entry point."""
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)

esphome/components/const/__init__.py

@@ -23,7 +23,6 @@ CONF_ENABLE_OTA_DOWNGRADE_PROTECTION = "enable_ota_downgrade_protection"
 CONF_ENABLED = "enabled"
 CONF_GYROSCOPE_ODR = "gyroscope_odr"
 CONF_GYROSCOPE_RANGE = "gyroscope_range"
-CONF_HUMIDITY_SOURCE = "humidity_source"
 CONF_IAQ = "iaq"
 CONF_IGNORE_NOT_FOUND = "ignore_not_found"
 CONF_IS_WRGB = "is_wrgb"
@@ -62,4 +61,3 @@ ICON_SOLAR_POWER = "mdi:solar-power"
 KEY_METADATA = "metadata"
 
 UNIT_AMPERE_HOUR = "Ah"
-UNIT_COUNTS = "#"

esphome/components/cover/__init__.py

@@ -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)

esphome/components/cover/automation.h

@@ -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) {

esphome/components/cs5460a/sensor.py

@@ -17,6 +17,8 @@ from esphome.const import (
     UNIT_VOLT,
     UNIT_WATT,
 )
+from esphome.core import ID
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@balrog-kun"]
@@ -129,7 +131,7 @@ async def to_code(config: ConfigType) -> None:
         cg.add(var.set_power_sensor(sens))
 
 
-automation.register_simple_action(
+@automation.register_action(
     "cs5460a.restart",
     CS5460ARestartAction,
     maybe_simple_id(
@@ -139,3 +141,11 @@ automation.register_simple_action(
     ),
     synchronous=True,
 )
+async def restart_action_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)

esphome/components/datetime/__init__.py

@@ -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

esphome/components/datetime/date_entity.h

@@ -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

esphome/components/datetime/datetime_entity.h

@@ -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:

esphome/components/datetime/time_entity.h

@@ -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:

esphome/components/deep_sleep/__init__.py

@@ -214,6 +214,16 @@ def _validate_sleep_duration(value: core.TimePeriod) -> core.TimePeriod:
 deep_sleep_ns = cg.esphome_ns.namespace("deep_sleep")
 DeepSleepComponent = deep_sleep_ns.class_("DeepSleepComponent", cg.Component)
 EnterDeepSleepAction = deep_sleep_ns.class_("EnterDeepSleepAction", automation.Action)
+PreventDeepSleepAction = deep_sleep_ns.class_(
+    "PreventDeepSleepAction",
+    automation.Action,
+    cg.Parented.template(DeepSleepComponent),
+)
+AllowDeepSleepAction = deep_sleep_ns.class_(
+    "AllowDeepSleepAction",
+    automation.Action,
+    cg.Parented.template(DeepSleepComponent),
+)
 
 WakeupPinMode = deep_sleep_ns.enum("WakeupPinMode")
 WAKEUP_PIN_MODES = {
@@ -412,12 +422,8 @@ async def to_code(config: ConfigType) -> None:
 
     if CONF_TOUCH_WAKEUP in config:
         cg.add(var.set_touch_wakeup(config[CONF_TOUCH_WAKEUP]))
-    if CORE.using_zephyr:
-        # Devices are suspended when CPU is entering a low power state
-        # https://github.com/nrfconnect/sdk-zephyr/blob/v3.7.99-ncs2-2/doc/services/pm/device.rst#system-managed-device-power-management
-        zephyr_add_prj_conf("PM_DEVICE", True)
-        if "zigbee" not in CORE.loaded_integrations:
-            zephyr_add_prj_conf("POWEROFF", True)
+    if CORE.using_zephyr and "zigbee" not in CORE.loaded_integrations:
+        zephyr_add_prj_conf("POWEROFF", True)
 
     cg.add_define("USE_DEEP_SLEEP")
 
@@ -480,15 +486,27 @@ async def deep_sleep_enter_to_code(
     return var
 
 
-for _name, _call in (
-    ("deep_sleep.prevent", "prevent_deep_sleep()"),
-    ("deep_sleep.allow", "allow_deep_sleep()"),
-):
-    automation.register_apply_action(
-        _name,
-        automation.maybe_simple_id(DEEP_SLEEP_ACTION_SCHEMA),
-        automation.ApplyCall(_call),
-    )
+@automation.register_action(
+    "deep_sleep.prevent",
+    PreventDeepSleepAction,
+    automation.maybe_simple_id(DEEP_SLEEP_ACTION_SCHEMA),
+    synchronous=True,
+)
+@automation.register_action(
+    "deep_sleep.allow",
+    AllowDeepSleepAction,
+    automation.maybe_simple_id(DEEP_SLEEP_ACTION_SCHEMA),
+    synchronous=True,
+)
+async def deep_sleep_action_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])
+    return var
 
 
 FILTER_SOURCE_FILES = filter_source_files_from_platform(

esphome/components/deep_sleep/deep_sleep_component.h

@@ -121,6 +121,8 @@ class Ext1WakeTrigger : public Trigger<>, public Component {
 
 template<typename... Ts> class EnterDeepSleepAction;
 
+template<typename... Ts> class PreventDeepSleepAction;
+
 /** This component allows setting up the node to go into deep sleep mode to conserve battery.
  *
  * To set this component up, first set *when* the deep sleep should trigger using set_run_cycles
@@ -296,4 +298,15 @@ template<typename... Ts> class EnterDeepSleepAction final : public Action<Ts...>
 #endif
 };
 
+template<typename... Ts>
+class PreventDeepSleepAction final : public Action<Ts...>, public Parented<DeepSleepComponent> {
+ public:
+  void play(const Ts &...x) override { this->parent_->prevent_deep_sleep(); }
+};
+
+template<typename... Ts> class AllowDeepSleepAction final : public Action<Ts...>, public Parented<DeepSleepComponent> {
+ public:
+  void play(const Ts &...x) override { this->parent_->allow_deep_sleep(); }
+};
+
 }  // namespace esphome::deep_sleep

esphome/components/dfplayer/__init__.py

@@ -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"
 
@@ -37,6 +34,23 @@ DEVICE = {
     "TF_CARD": Device.TF_CARD,
 }
 
+NextAction = dfplayer_ns.class_("NextAction", automation.Action)
+PreviousAction = dfplayer_ns.class_("PreviousAction", automation.Action)
+PlayMp3Action = dfplayer_ns.class_("PlayMp3Action", automation.Action)
+PlayFileAction = dfplayer_ns.class_("PlayFileAction", automation.Action)
+PlayFolderAction = dfplayer_ns.class_("PlayFolderAction", automation.Action)
+SetVolumeAction = dfplayer_ns.class_("SetVolumeAction", automation.Action)
+VolumeUpAction = dfplayer_ns.class_("VolumeUpAction", automation.Action)
+VolumeDownAction = dfplayer_ns.class_("VolumeDownAction", automation.Action)
+SetEqAction = dfplayer_ns.class_("SetEqAction", automation.Action)
+SleepAction = dfplayer_ns.class_("SleepAction", automation.Action)
+ResetAction = dfplayer_ns.class_("ResetAction", automation.Action)
+StartAction = dfplayer_ns.class_("StartAction", automation.Action)
+PauseAction = dfplayer_ns.class_("PauseAction", automation.Action)
+StopAction = dfplayer_ns.class_("StopAction", automation.Action)
+RandomAction = dfplayer_ns.class_("RandomAction", automation.Action)
+SetDeviceAction = dfplayer_ns.class_("SetDeviceAction", automation.Action)
+
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
@@ -70,30 +84,41 @@ async def to_code(config):
     await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
 
-DFPLAYER_ACTION_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.use_id(DFPlayer),
-    }
+@automation.register_action(
+    "dfplayer.play_next",
+    NextAction,
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(DFPlayer),
+        }
+    ),
+    synchronous=True,
 )
+async def dfplayer_next_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
 
-for _name, _call in (
-    ("dfplayer.play_next", "next()"),
-    ("dfplayer.play_previous", "previous()"),
-    ("dfplayer.volume_up", "volume_up()"),
-    ("dfplayer.volume_down", "volume_down()"),
-    ("dfplayer.sleep", "sleep()"),
-    ("dfplayer.reset", "reset()"),
-    ("dfplayer.start", "start()"),
-    ("dfplayer.pause", "pause()"),
-    ("dfplayer.stop", "stop()"),
-    ("dfplayer.random", "random()"),
-):
-    automation.register_apply_action(
-        _name, DFPLAYER_ACTION_SCHEMA, automation.ApplyCall(_call)
-    )
 
-automation.register_apply_action(
+@automation.register_action(
+    "dfplayer.play_previous",
+    PreviousAction,
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(DFPlayer),
+        }
+    ),
+    synchronous=True,
+)
+async def dfplayer_previous_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
+
+
+@automation.register_action(
     "dfplayer.play_mp3",
+    PlayMp3Action,
     cv.maybe_simple_value(
         {
             cv.GenerateID(): cv.use_id(DFPlayer),
@@ -101,43 +126,70 @@ automation.register_apply_action(
         },
         key=CONF_FILE,
     ),
-    automation.ApplyField(CONF_FILE, "play_mp3", cg.uint16),
+    synchronous=True,
 )
+async def dfplayer_play_mp3_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    template_ = await cg.templatable(config[CONF_FILE], args, cg.uint16)
+    cg.add(var.set_file(template_))
+    return var
 
-# loop and file default to what the old action's unset templatable values evaluated to
-automation.register_apply_action(
+
+@automation.register_action(
     "dfplayer.play",
+    PlayFileAction,
     cv.maybe_simple_value(
         {
             cv.GenerateID(): cv.use_id(DFPlayer),
             cv.Required(CONF_FILE): cv.templatable(cv.int_),
-            cv.Optional(CONF_LOOP, default=False): cv.templatable(cv.boolean),
+            cv.Optional(CONF_LOOP): cv.templatable(cv.boolean),
         },
         key=CONF_FILE,
     ),
-    automation.ApplyCall(
-        "play_file({}, {})", ((CONF_FILE, cg.uint16), (CONF_LOOP, cg.bool_))
-    ),
+    synchronous=True,
 )
+async def dfplayer_play_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    template_ = await cg.templatable(config[CONF_FILE], args, cg.uint16)
+    cg.add(var.set_file(template_))
+    if CONF_LOOP in config:
+        template_ = await cg.templatable(config[CONF_LOOP], args, cg.bool_)
+        cg.add(var.set_loop(template_))
+    return var
 
-automation.register_apply_action(
+
+@automation.register_action(
     "dfplayer.play_folder",
+    PlayFolderAction,
     cv.Schema(
         {
             cv.GenerateID(): cv.use_id(DFPlayer),
             cv.Required(CONF_FOLDER): cv.templatable(cv.int_),
-            cv.Optional(CONF_FILE, default=0): cv.templatable(cv.int_),
-            cv.Optional(CONF_LOOP, default=False): cv.templatable(cv.boolean),
+            cv.Optional(CONF_FILE): cv.templatable(cv.int_),
+            cv.Optional(CONF_LOOP): cv.templatable(cv.boolean),
         }
     ),
-    automation.ApplyCall(
-        "play_folder({}, {}, {})",
-        ((CONF_FOLDER, cg.uint16), (CONF_FILE, cg.uint16), (CONF_LOOP, cg.bool_)),
-    ),
+    synchronous=True,
 )
+async def dfplayer_play_folder_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    template_ = await cg.templatable(config[CONF_FOLDER], args, cg.uint16)
+    cg.add(var.set_folder(template_))
+    if CONF_FILE in config:
+        template_ = await cg.templatable(config[CONF_FILE], args, cg.uint16)
+        cg.add(var.set_file(template_))
+    if CONF_LOOP in config:
+        template_ = await cg.templatable(config[CONF_LOOP], args, cg.bool_)
+        cg.add(var.set_loop(template_))
+    return var
 
-automation.register_apply_action(
+
+@automation.register_action(
     "dfplayer.set_device",
+    SetDeviceAction,
     cv.maybe_simple_value(
         {
             cv.GenerateID(): cv.use_id(DFPlayer),
@@ -145,11 +197,19 @@ automation.register_apply_action(
         },
         key=CONF_DEVICE,
     ),
-    automation.ApplyField(CONF_DEVICE, "set_device", Device),
+    synchronous=True,
 )
+async def dfplayer_set_device_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    template_ = await cg.templatable(config[CONF_DEVICE], args, Device)
+    cg.add(var.set_device(template_))
+    return var
 
-automation.register_apply_action(
+
+@automation.register_action(
     "dfplayer.set_volume",
+    SetVolumeAction,
     cv.maybe_simple_value(
         {
             cv.GenerateID(): cv.use_id(DFPlayer),
@@ -157,11 +217,51 @@ automation.register_apply_action(
         },
         key=CONF_VOLUME,
     ),
-    automation.ApplyField(CONF_VOLUME, "set_volume", cg.uint8),
+    synchronous=True,
 )
+async def dfplayer_set_volume_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    template_ = await cg.templatable(config[CONF_VOLUME], args, cg.uint8)
+    cg.add(var.set_volume(template_))
+    return var
 
-automation.register_apply_action(
+
+@automation.register_action(
+    "dfplayer.volume_up",
+    VolumeUpAction,
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(DFPlayer),
+        }
+    ),
+    synchronous=True,
+)
+async def dfplayer_volume_up_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
+
+
+@automation.register_action(
+    "dfplayer.volume_down",
+    VolumeDownAction,
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(DFPlayer),
+        }
+    ),
+    synchronous=True,
+)
+async def dfplayer_volume_down_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
+
+
+@automation.register_action(
     "dfplayer.set_eq",
+    SetEqAction,
     cv.maybe_simple_value(
         {
             cv.GenerateID(): cv.use_id(DFPlayer),
@@ -169,37 +269,113 @@ automation.register_apply_action(
         },
         key=CONF_EQ_PRESET,
     ),
-    automation.ApplyField(CONF_EQ_PRESET, "set_eq", EqPreset),
+    synchronous=True,
 )
+async def dfplayer_set_eq_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    template_ = await cg.templatable(config[CONF_EQ_PRESET], args, EqPreset)
+    cg.add(var.set_eq(template_))
+    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.register_action(
+    "dfplayer.sleep",
+    SleepAction,
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(DFPlayer),
+        }
     ),
-    automation.ApplyField(CONF_ENABLE, "set_current_track_repeat", cg.bool_),
+    synchronous=True,
 )
+async def dfplayer_sleep_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
 
 
-automation.register_parented_condition(
+@automation.register_action(
+    "dfplayer.reset",
+    ResetAction,
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(DFPlayer),
+        }
+    ),
+    synchronous=True,
+)
+async def dfplayer_reset_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
+
+
+@automation.register_action(
+    "dfplayer.start",
+    StartAction,
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(DFPlayer),
+        }
+    ),
+    synchronous=True,
+)
+async def dfplayer_start_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
+
+
+@automation.register_action(
+    "dfplayer.pause",
+    PauseAction,
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(DFPlayer),
+        }
+    ),
+    synchronous=True,
+)
+async def dfplayer_pause_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
+
+
+@automation.register_action(
+    "dfplayer.stop",
+    StopAction,
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(DFPlayer),
+        }
+    ),
+    synchronous=True,
+)
+async def dfplayer_stop_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
+
+
+@automation.register_action(
+    "dfplayer.random",
+    RandomAction,
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(DFPlayer),
+        }
+    ),
+    synchronous=True,
+)
+async def dfplayer_random_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
+
+
+@automation.register_condition(
     "dfplayer.is_playing",
     DFPlayerIsPlayingCondition,
     cv.Schema(
@@ -208,3 +384,7 @@ automation.register_parented_condition(
         }
     ),
 )
+async def dfplayer_is_playing_to_code(config, condition_id, template_arg, args):
+    var = cg.new_Pvariable(condition_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var

esphome/components/dfplayer/dfplayer.cpp

@@ -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) {

esphome/components/dfplayer/dfplayer.h

@@ -33,13 +33,8 @@ class DFPlayer final : public uart::UARTDevice, public Component {
   void play_mp3(uint16_t file);
   void play_file(uint16_t file);
   void play_file_loop(uint16_t file);
-  void play_file(uint16_t file, bool loop) { loop ? this->play_file_loop(file) : this->play_file(file); }
   void play_folder(uint16_t folder, uint16_t file);
   void play_folder_loop(uint16_t folder);
-  // The loop command plays the whole folder, so file is ignored when loop is set.
-  void play_folder(uint16_t folder, uint16_t file, bool loop) {
-    loop ? this->play_folder_loop(folder) : this->play_folder(folder, file);
-  }
   void volume_up();
   void volume_down();
   void set_device(Device device);
@@ -51,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;
@@ -77,6 +71,100 @@ class DFPlayer final : public uart::UARTDevice, public Component {
   CallbackManager<void()> on_finished_playback_callback_;
 };
 
+#define DFPLAYER_SIMPLE_ACTION(ACTION_CLASS, ACTION_METHOD) \
+  template<typename... Ts> \
+  class ACTION_CLASS : /* NOLINT */ \
+                       public Action<Ts...>, \
+                       public Parented<DFPlayer> { \
+    void play(const Ts &...x) override { this->parent_->ACTION_METHOD(); } \
+  };
+
+DFPLAYER_SIMPLE_ACTION(NextAction, next)
+DFPLAYER_SIMPLE_ACTION(PreviousAction, previous)
+
+template<typename... Ts> class PlayMp3Action final : public Action<Ts...>, public Parented<DFPlayer> {
+ public:
+  TEMPLATABLE_VALUE(uint16_t, file)
+
+  void play(const Ts &...x) override {
+    auto file = this->file_.value(x...);
+    this->parent_->play_mp3(file);
+  }
+};
+
+template<typename... Ts> class PlayFileAction final : public Action<Ts...>, public Parented<DFPlayer> {
+ public:
+  TEMPLATABLE_VALUE(uint16_t, file)
+  TEMPLATABLE_VALUE(bool, loop)
+
+  void play(const Ts &...x) override {
+    auto file = this->file_.value(x...);
+    auto loop = this->loop_.value(x...);
+    if (loop) {
+      this->parent_->play_file_loop(file);
+    } else {
+      this->parent_->play_file(file);
+    }
+  }
+};
+
+template<typename... Ts> class PlayFolderAction final : public Action<Ts...>, public Parented<DFPlayer> {
+ public:
+  TEMPLATABLE_VALUE(uint16_t, folder)
+  TEMPLATABLE_VALUE(uint16_t, file)
+  TEMPLATABLE_VALUE(bool, loop)
+
+  void play(const Ts &...x) override {
+    auto folder = this->folder_.value(x...);
+    auto file = this->file_.value(x...);
+    auto loop = this->loop_.value(x...);
+    if (loop) {
+      this->parent_->play_folder_loop(folder);
+    } else {
+      this->parent_->play_folder(folder, file);
+    }
+  }
+};
+
+template<typename... Ts> class SetDeviceAction final : public Action<Ts...>, public Parented<DFPlayer> {
+ public:
+  TEMPLATABLE_VALUE(Device, device)
+
+  void play(const Ts &...x) override {
+    auto device = this->device_.value(x...);
+    this->parent_->set_device(device);
+  }
+};
+
+template<typename... Ts> class SetVolumeAction final : public Action<Ts...>, public Parented<DFPlayer> {
+ public:
+  TEMPLATABLE_VALUE(uint8_t, volume)
+
+  void play(const Ts &...x) override {
+    auto volume = this->volume_.value(x...);
+    this->parent_->set_volume(volume);
+  }
+};
+
+template<typename... Ts> class SetEqAction final : public Action<Ts...>, public Parented<DFPlayer> {
+ public:
+  TEMPLATABLE_VALUE(EqPreset, eq)
+
+  void play(const Ts &...x) override {
+    auto eq = this->eq_.value(x...);
+    this->parent_->set_eq(eq);
+  }
+};
+
+DFPLAYER_SIMPLE_ACTION(SleepAction, sleep)
+DFPLAYER_SIMPLE_ACTION(ResetAction, reset)
+DFPLAYER_SIMPLE_ACTION(StartAction, start)
+DFPLAYER_SIMPLE_ACTION(PauseAction, pause)
+DFPLAYER_SIMPLE_ACTION(StopAction, stop)
+DFPLAYER_SIMPLE_ACTION(RandomAction, random)
+DFPLAYER_SIMPLE_ACTION(VolumeUpAction, volume_up)
+DFPLAYER_SIMPLE_ACTION(VolumeDownAction, volume_down)
+
 template<typename... Ts> class DFPlayerIsPlayingCondition final : public Condition<Ts...>, public Parented<DFPlayer> {
  public:
   bool check(const Ts &...x) override { return this->parent_->is_playing(); }

esphome/components/dfrobot_sen0395/__init__.py

@@ -49,7 +49,7 @@ async def to_code(config: ConfigType) -> None:
     await uart.register_uart_device(var, config)
 
 
-automation.register_parented_action(
+@automation.register_action(
     "dfrobot_sen0395.reset",
     DfrobotSen0395ResetAction,
     maybe_simple_id(
@@ -59,6 +59,16 @@ automation.register_parented_action(
     ),
     synchronous=True,
 )
+async def dfrobot_sen0395_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])
+
+    return var
 
 
 def range_segment_list(input: Any) -> list:

esphome/components/display/__init__.py

@@ -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(

esphome/components/display/display.h

@@ -848,6 +848,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) {}

esphome/components/display_menu_base/__init__.py

@@ -55,6 +55,18 @@ MenuItemSwitch = display_menu_base_ns.class_("MenuItemSwitch")
 MenuItemCommand = display_menu_base_ns.class_("MenuItemCommand")
 MenuItemCustom = display_menu_base_ns.class_("MenuItemCustom")
 
+UpAction = display_menu_base_ns.class_("UpAction", automation.Action)
+DownAction = display_menu_base_ns.class_("DownAction", automation.Action)
+LeftAction = display_menu_base_ns.class_("LeftAction", automation.Action)
+RightAction = display_menu_base_ns.class_("RightAction", automation.Action)
+EnterAction = display_menu_base_ns.class_("EnterAction", automation.Action)
+ShowAction = display_menu_base_ns.class_("ShowAction", automation.Action)
+HideAction = display_menu_base_ns.class_("HideAction", automation.Action)
+ShowMainAction = display_menu_base_ns.class_("ShowMainAction", automation.Action)
+
+IsActiveCondition = display_menu_base_ns.class_(
+    "IsActiveCondition", automation.Condition
+)
 
 MenuItemType = display_menu_base_ns.enum("MenuItemType")
 
@@ -282,23 +294,85 @@ MENU_ACTION_SCHEMA = maybe_simple_id(
 )
 
 
-for _name, _call in (
-    ("display_menu.up", "up()"),
-    ("display_menu.down", "down()"),
-    ("display_menu.left", "left()"),
-    ("display_menu.right", "right()"),
-    ("display_menu.enter", "enter()"),
-    ("display_menu.show", "show()"),
-    ("display_menu.hide", "hide()"),
-    ("display_menu.show_main", "show_main()"),
-):
-    automation.register_apply_action(
-        _name, MENU_ACTION_SCHEMA, automation.ApplyCall(_call)
-    )
-
-automation.register_apply_condition(
-    "display_menu.is_active", MENU_ACTION_SCHEMA, "is_active()"
+@automation.register_action(
+    "display_menu.up", UpAction, MENU_ACTION_SCHEMA, synchronous=True
 )
+async def menu_up_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_menu.down", DownAction, MENU_ACTION_SCHEMA, synchronous=True
+)
+async def menu_down_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_menu.left", LeftAction, MENU_ACTION_SCHEMA, synchronous=True
+)
+async def menu_left_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_menu.right", RightAction, MENU_ACTION_SCHEMA, synchronous=True
+)
+async def menu_right_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_menu.enter", EnterAction, MENU_ACTION_SCHEMA, synchronous=True
+)
+async def menu_enter_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_menu.show", ShowAction, MENU_ACTION_SCHEMA, synchronous=True
+)
+async def menu_show_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_menu.hide", HideAction, MENU_ACTION_SCHEMA, synchronous=True
+)
+async def menu_hide_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_menu.show_main",
+    ShowMainAction,
+    MENU_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def menu_show_main_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(
+    "display_menu.is_active",
+    IsActiveCondition,
+    automation.maybe_simple_id(
+        {
+            cv.GenerateID(CONF_ID): cv.use_id(DisplayMenuComponent),
+        }
+    ),
+)
+async def display_menu_is_active_to_code(config, condition_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren)
 
 
 async def menu_item_to_code(menu, config, parent):

esphome/components/display_menu_base/automation.h

@@ -5,6 +5,94 @@
 
 namespace esphome::display_menu_base {
 
+template<typename... Ts> class UpAction final : public Action<Ts...> {
+ public:
+  explicit UpAction(DisplayMenuComponent *menu) : menu_(menu) {}
+
+  void play(const Ts &...x) override { this->menu_->up(); }
+
+ protected:
+  DisplayMenuComponent *menu_;
+};
+
+template<typename... Ts> class DownAction final : public Action<Ts...> {
+ public:
+  explicit DownAction(DisplayMenuComponent *menu) : menu_(menu) {}
+
+  void play(const Ts &...x) override { this->menu_->down(); }
+
+ protected:
+  DisplayMenuComponent *menu_;
+};
+
+template<typename... Ts> class LeftAction final : public Action<Ts...> {
+ public:
+  explicit LeftAction(DisplayMenuComponent *menu) : menu_(menu) {}
+
+  void play(const Ts &...x) override { this->menu_->left(); }
+
+ protected:
+  DisplayMenuComponent *menu_;
+};
+
+template<typename... Ts> class RightAction final : public Action<Ts...> {
+ public:
+  explicit RightAction(DisplayMenuComponent *menu) : menu_(menu) {}
+
+  void play(const Ts &...x) override { this->menu_->right(); }
+
+ protected:
+  DisplayMenuComponent *menu_;
+};
+
+template<typename... Ts> class EnterAction final : public Action<Ts...> {
+ public:
+  explicit EnterAction(DisplayMenuComponent *menu) : menu_(menu) {}
+
+  void play(const Ts &...x) override { this->menu_->enter(); }
+
+ protected:
+  DisplayMenuComponent *menu_;
+};
+
+template<typename... Ts> class ShowAction final : public Action<Ts...> {
+ public:
+  explicit ShowAction(DisplayMenuComponent *menu) : menu_(menu) {}
+
+  void play(const Ts &...x) override { this->menu_->show(); }
+
+ protected:
+  DisplayMenuComponent *menu_;
+};
+
+template<typename... Ts> class HideAction final : public Action<Ts...> {
+ public:
+  explicit HideAction(DisplayMenuComponent *menu) : menu_(menu) {}
+
+  void play(const Ts &...x) override { this->menu_->hide(); }
+
+ protected:
+  DisplayMenuComponent *menu_;
+};
+
+template<typename... Ts> class ShowMainAction final : public Action<Ts...> {
+ public:
+  explicit ShowMainAction(DisplayMenuComponent *menu) : menu_(menu) {}
+
+  void play(const Ts &...x) override { this->menu_->show_main(); }
+
+ protected:
+  DisplayMenuComponent *menu_;
+};
+template<typename... Ts> class IsActiveCondition final : public Condition<Ts...> {
+ public:
+  explicit IsActiveCondition(DisplayMenuComponent *menu) : menu_(menu) {}
+  bool check(const Ts &...x) override { return this->menu_->is_active(); }
+
+ protected:
+  DisplayMenuComponent *menu_;
+};
+
 class DisplayMenuOnEnterTrigger final : public Trigger<const MenuItem *> {
  public:
   explicit DisplayMenuOnEnterTrigger(MenuItem *parent) : parent_(parent) {

esphome/components/ds1307/time.py

@@ -3,6 +3,8 @@ import esphome.codegen as cg
 from esphome.components import i2c, time
 import esphome.config_validation as cv
 from esphome.const import CONF_ID
+from esphome.core import ID
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@badbadc0ffee"]
@@ -20,7 +22,7 @@ CONFIG_SCHEMA = time.TIME_SCHEMA.extend(
 ).extend(i2c.i2c_device_schema(0x68))
 
 
-automation.register_parented_action(
+@automation.register_action(
     "ds1307.write_time",
     WriteAction,
     cv.Schema(
@@ -30,9 +32,18 @@ automation.register_parented_action(
     ),
     synchronous=True,
 )
+async def ds1307_write_time_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])
+    return var
 
 
-automation.register_parented_action(
+@automation.register_action(
     "ds1307.read_time",
     ReadAction,
     automation.maybe_simple_id(
@@ -42,6 +53,15 @@ automation.register_parented_action(
     ),
     synchronous=True,
 )
+async def ds1307_read_time_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])
+    return var
 
 
 async def to_code(config: ConfigType) -> None:

esphome/components/duty_time/sensor.py

@@ -1,4 +1,10 @@
-from esphome import automation
+from esphome.automation import (
+    Action,
+    Condition,
+    maybe_simple_id,
+    register_action,
+    register_condition,
+)
 import esphome.codegen as cg
 from esphome.components import binary_sensor, sensor
 import esphome.config_validation as cv
@@ -23,13 +29,13 @@ duty_time_sensor_ns = cg.esphome_ns.namespace("duty_time_sensor")
 DutyTimeSensor = duty_time_sensor_ns.class_(
     "DutyTimeSensor", sensor.Sensor, cg.PollingComponent
 )
-BaseAction = duty_time_sensor_ns.class_("BaseAction", automation.Action, cg.Parented)
+BaseAction = duty_time_sensor_ns.class_("BaseAction", Action, cg.Parented)
 StartAction = duty_time_sensor_ns.class_("StartAction", BaseAction)
 StopAction = duty_time_sensor_ns.class_("StopAction", BaseAction)
 ResetAction = duty_time_sensor_ns.class_("ResetAction", BaseAction)
 SetAction = duty_time_sensor_ns.class_("SetAction", BaseAction)
 RunningCondition = duty_time_sensor_ns.class_(
-    "RunningCondition", automation.Condition, cg.Parented
+    "RunningCondition", Condition, cg.Parented
 )
 
 
@@ -80,38 +86,56 @@ async def to_code(config: ConfigType) -> None:
 
 # AUTOMATIONS
 
-DUTY_TIME_ID_SCHEMA = automation.maybe_simple_id(
+DUTY_TIME_ID_SCHEMA = maybe_simple_id(
     {
         cv.Required(CONF_ID): cv.use_id(DutyTimeSensor),
     }
 )
 
 
-automation.register_parented_action(
-    "sensor.duty_time.start",
-    StartAction,
-    DUTY_TIME_ID_SCHEMA,
-    synchronous=True,
+@register_action(
+    "sensor.duty_time.start", StartAction, DUTY_TIME_ID_SCHEMA, synchronous=True
 )
+async def sensor_runtime_start_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])
+    return var
 
 
-automation.register_parented_action(
-    "sensor.duty_time.stop",
-    StopAction,
-    DUTY_TIME_ID_SCHEMA,
-    synchronous=True,
+@register_action(
+    "sensor.duty_time.stop", StopAction, DUTY_TIME_ID_SCHEMA, synchronous=True
 )
+async def sensor_runtime_stop_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])
+    return var
 
 
-automation.register_parented_action(
-    "sensor.duty_time.reset",
-    ResetAction,
-    DUTY_TIME_ID_SCHEMA,
-    synchronous=True,
+@register_action(
+    "sensor.duty_time.reset", ResetAction, DUTY_TIME_ID_SCHEMA, synchronous=True
 )
+async def sensor_runtime_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])
+    return var
 
 
-@automation.register_condition(
+@register_condition(
     "sensor.duty_time.is_running", RunningCondition, DUTY_TIME_ID_SCHEMA
 )
 async def duty_time_is_running_to_code(
@@ -124,7 +148,7 @@ async def duty_time_is_running_to_code(
     return cg.new_Pvariable(condition_id, template_arg, paren, True)
 
 
-@automation.register_condition(
+@register_condition(
     "sensor.duty_time.is_not_running", RunningCondition, DUTY_TIME_ID_SCHEMA
 )
 async def duty_time_is_not_running_to_code(

esphome/components/esp32/__init__.py

@@ -11,10 +11,7 @@ from typing import Any
 
 from esphome import yaml_util
 import esphome.codegen as cg
-from esphome.components.const import (
-    CONF_ENABLE_OTA_DOWNGRADE_PROTECTION,
-    CONF_IGNORE_NOT_FOUND,
-)
+from esphome.components.const import CONF_ENABLE_OTA_DOWNGRADE_PROTECTION
 from esphome.config_helpers import filter_source_files_from_defines
 import esphome.config_validation as cv
 from esphome.const import (
@@ -114,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_NVS_CACHE_IN_PSRAM = "nvs_cache_in_psram"
 CONF_FLASH_CHIP = "flash_chip"
 CONF_KEY_ID = "key_id"
 CONF_MINIMUM_CHIP_REVISION = "minimum_chip_revision"
@@ -428,7 +424,6 @@ ARDUINO_DISABLED_LIBRARIES: frozenset[str] = frozenset(
         "Hash",
         "HTTPClient",
         "HTTPUpdate",
-        "HTTPUpdateServer",
         "Insights",
         "LittleFS",
         "Matter",
@@ -936,15 +931,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),
@@ -969,7 +963,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),
@@ -1005,7 +998,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),
@@ -1026,8 +1019,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",
 }
 
@@ -1599,29 +1592,6 @@ def final_validate(config) -> None:
                     path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_EXECUTE_FROM_PSRAM],
                 )
             )
-    if advanced.get(CONF_NVS_CACHE_IN_PSRAM):
-        psram_conf = full_config.get(PSRAM_DOMAIN)
-        if (
-            psram_conf is None
-            or psram_conf[CONF_DISABLED]
-            or psram_conf[CONF_IGNORE_NOT_FOUND]
-        ):
-            errs.append(
-                cv.Invalid(
-                    f"'{CONF_NVS_CACHE_IN_PSRAM}' requires PSRAM with 'ignore_not_found: false'",
-                    path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_NVS_CACHE_IN_PSRAM],
-                )
-            )
-        if (
-            advanced.get(CONF_NVS_ENCRYPTION) is not None
-            or conf_fw[CONF_SDKCONFIG_OPTIONS].get("CONFIG_NVS_ENCRYPTION") == "y"
-        ):
-            errs.append(
-                cv.Invalid(
-                    f"'{CONF_NVS_CACHE_IN_PSRAM}' cannot be used with NVS encryption; the keys must stay in internal RAM",
-                    path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_NVS_CACHE_IN_PSRAM],
-                )
-            )
 
     final_validate_pins(full_config)
 
@@ -2062,7 +2032,6 @@ FRAMEWORK_SCHEMA = cv.Schema(
                 cv.Optional(CONF_RINGBUF_IN_IRAM, default=False): cv.boolean,
                 cv.Optional(CONF_HEAP_IN_IRAM, default=False): cv.boolean,
                 cv.Optional(CONF_EXECUTE_FROM_PSRAM, default=False): cv.boolean,
-                cv.Optional(CONF_NVS_CACHE_IN_PSRAM): cv.boolean,
                 cv.Optional(CONF_LOOP_TASK_STACK_SIZE, default=8192): cv.int_range(
                     min=8192, max=32768
                 ),
@@ -2389,20 +2358,6 @@ async def _set_libc_picolibc_newlib_compat() -> None:
     )
 
 
-@coroutine_with_priority(CoroPriority.FINAL)
-async def _apply_nvs_cache_in_psram(explicit: bool) -> None:
-    """Keep the NVS cache in PSRAM unless NVS encryption is on, however it was enabled."""
-    # The encrypted partition object holds the derived keys, which must stay in internal RAM
-    if is_idf_sdkconfig_option_enabled("CONFIG_NVS_ENCRYPTION"):
-        if explicit:
-            _LOGGER.warning(
-                "%s ignored: NVS encryption keeps the NVS cache in internal RAM",
-                CONF_NVS_CACHE_IN_PSRAM,
-            )
-        return
-    set_idf_sdkconfig_default("CONFIG_NVS_ALLOCATE_CACHE_IN_SPIRAM", True)
-
-
 @coroutine_with_priority(CoroPriority.FINAL)
 async def _reconcile_certificate_bundle_sdkconfig() -> None:
     """Enable the mbedTLS certificate bundle only when something asked for it.
@@ -2955,17 +2910,6 @@ async def to_code(config):
     if advanced[CONF_EXECUTE_FROM_PSRAM]:
         add_idf_sdkconfig_option("CONFIG_SPIRAM_XIP_FROM_PSRAM", True)
 
-    # Imported here as psram imports this module
-    from esphome.components.psram import is_guaranteed as psram_is_guaranteed
-
-    # Frees internal heap (the cache scales with the NVS partition) but slows NVS, so only
-    # where PSRAM is known to be fitted. Decided at FINAL so every way of enabling NVS
-    # encryption has been seen and a user's sdkconfig_options value wins.
-    # Unset means on; only an explicit true is worth a warning when it has to be dropped.
-    requested = advanced.get(CONF_NVS_CACHE_IN_PSRAM)
-    if requested is not False and psram_is_guaranteed():
-        CORE.add_job(_apply_nvs_cache_in_psram, requested is True)
-
     # Apply LWIP core locking for better socket performance
     # This is already enabled by default in Arduino framework, where it provides
     # significant performance benefits. Our benchmarks show socket operations are

esphome/components/esp32_ble/__init__.py

@@ -32,7 +32,8 @@ from esphome.const import (
     CONF_NAME,
     CONF_NAME_ADD_MAC_SUFFIX,
 )
-from esphome.core import CORE, TimePeriod
+from esphome.core import CORE, ID, TimePeriod
+from esphome.cpp_generator import MockObj, TemplateArgsType
 import esphome.final_validate as fv
 from esphome.types import ConfigType
 
@@ -605,27 +606,38 @@ async def to_code(config: ConfigType) -> None:
         cg.add_define("USE_ESP32_BLE_UUID")
 
 
-automation.register_bare_condition(
-    "ble.enabled",
-    BLEEnabledCondition,
-    cv.Schema({}),
+@automation.register_condition("ble.enabled", BLEEnabledCondition, cv.Schema({}))
+async def ble_enabled_to_code(
+    config: ConfigType,
+    condition_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    return cg.new_Pvariable(condition_id, template_arg)
+
+
+@automation.register_action(
+    "ble.enable", BLEEnableAction, cv.Schema({}), synchronous=True
 )
+async def ble_enable_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    return cg.new_Pvariable(action_id, template_arg)
 
 
-automation.register_bare_action(
-    "ble.enable",
-    BLEEnableAction,
-    cv.Schema({}),
-    synchronous=True,
-)
-
-
-automation.register_bare_action(
-    "ble.disable",
-    BLEDisableAction,
-    cv.Schema({}),
-    synchronous=True,
+@automation.register_action(
+    "ble.disable", BLEDisableAction, cv.Schema({}), synchronous=True
 )
+async def ble_disable_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    return cg.new_Pvariable(action_id, template_arg)
 
 
 # ble_advertising.cpp is fully #ifdef'd on USE_ESP32_BLE_ADVERTISING, set

esphome/components/esp32_ble_server/__init__.py

@@ -3,7 +3,7 @@ import encodings
 from esphome import automation
 import esphome.codegen as cg
 from esphome.components import esp32_ble
-from esphome.components.const import CONF_DESCRIPTION, CONF_MANUFACTURER
+from esphome.components.const import CONF_MANUFACTURER
 from esphome.components.esp32 import request_bluetooth
 from esphome.components.esp32_ble import BTLoggers, bt_uuid
 import esphome.config_validation as cv
@@ -37,6 +37,7 @@ CONF_ADVERTISE = "advertise"
 CONF_APPEARANCE = "appearance"
 CONF_BROADCAST = "broadcast"
 CONF_CHARACTERISTICS = "characteristics"
+CONF_DESCRIPTION = "description"
 CONF_DESCRIPTORS = "descriptors"
 CONF_ENDIANNESS = "endianness"
 CONF_FIRMWARE_VERSION = "firmware_version"

esphome/components/esp32_ble_tracker/__init__.py

@@ -39,7 +39,8 @@ from esphome.const import (
     CONF_SERVICE_UUID,
     CONF_TRIGGER_ID,
 )
-from esphome.core import CORE, CoroPriority, TimePeriod, coroutine_with_priority
+from esphome.core import CORE, ID, CoroPriority, TimePeriod, coroutine_with_priority
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.enum import StrEnum
 from esphome.types import ConfigType
 
@@ -115,6 +116,12 @@ BLEEndOfScanTrigger = esp32_ble_tracker_ns.class_(
     "BLEEndOfScanTrigger", automation.Trigger.template()
 )
 # Actions
+ESP32BLEStartScanAction = esp32_ble_tracker_ns.class_(
+    "ESP32BLEStartScanAction", automation.Action
+)
+ESP32BLEStopScanAction = esp32_ble_tracker_ns.class_(
+    "ESP32BLEStopScanAction", automation.Action
+)
 
 
 def validate_max_connections_deprecated(config: ConfigType) -> ConfigType:
@@ -462,12 +469,23 @@ ESP32_BLE_START_SCAN_ACTION_SCHEMA = cv.Schema(
 )
 
 
-automation.register_apply_action(
+@automation.register_action(
     "esp32_ble_tracker.start_scan",
+    ESP32BLEStartScanAction,
     ESP32_BLE_START_SCAN_ACTION_SCHEMA,
-    automation.ApplyField(CONF_CONTINUOUS, "set_scan_continuous", cg.bool_),
-    automation.ApplyCall("start_scan_if_idle()"),
+    synchronous=True,
 )
+async def esp32_ble_tracker_start_scan_action_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    template_ = await cg.templatable(config[CONF_CONTINUOUS], args, cg.bool_)
+    cg.add(var.set_continuous(template_))
+    return var
 
 
 ESP32_BLE_STOP_SCAN_ACTION_SCHEMA = automation.maybe_simple_id(
@@ -479,11 +497,21 @@ ESP32_BLE_STOP_SCAN_ACTION_SCHEMA = automation.maybe_simple_id(
 )
 
 
-automation.register_apply_action(
+@automation.register_action(
     "esp32_ble_tracker.stop_scan",
+    ESP32BLEStopScanAction,
     ESP32_BLE_STOP_SCAN_ACTION_SCHEMA,
-    automation.ApplyCall("stop_scan()"),
+    synchronous=True,
 )
+async def esp32_ble_tracker_stop_scan_action_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])
+    return var
 
 
 async def register_ble_device(

esphome/components/esp32_ble_tracker/automation.h

@@ -94,6 +94,30 @@ class BLEEndOfScanTrigger final : public Trigger<>, public ESPBTDeviceListener {
   void on_scan_end() override { this->trigger(); }
 };
 
+template<typename... Ts> class ESP32BLEStartScanAction final : public Action<Ts...> {
+ public:
+  ESP32BLEStartScanAction(ESP32BLETracker *parent) : parent_(parent) {}
+  TEMPLATABLE_VALUE(bool, continuous)
+  void play(const Ts &...x) override {
+    this->parent_->set_scan_continuous(this->continuous_.value(x...));
+    // Only call start_scan() if scanner is IDLE
+    // For other states (STARTING, RUNNING, STOPPING, FAILED), the normal state
+    // machine flow will eventually transition back to IDLE, at which point
+    // loop() will see scan_continuous_ and restart scanning if it is true.
+    if (this->parent_->get_scanner_state() == ScannerState::IDLE) {
+      this->parent_->start_scan();
+    }
+  }
+
+ protected:
+  ESP32BLETracker *parent_;
+};
+
+template<typename... Ts> class ESP32BLEStopScanAction final : public Action<Ts...>, public Parented<ESP32BLETracker> {
+ public:
+  void play(const Ts &...x) override { this->parent_->stop_scan(); }
+};
+
 }  // namespace esphome::esp32_ble_tracker
 
 #endif

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -218,12 +218,6 @@ class ESP32BLETracker final : public Component,
 #endif
 
   void start_scan();
-  // For the start_scan action: in any other state the state machine returns to IDLE on its own
-  // and loop() restarts scanning when scan_continuous_ is set, so only an idle scanner starts here.
-  void start_scan_if_idle() {
-    if (this->scanner_state_ == ScannerState::IDLE)
-      this->start_scan();
-  }
   void stop_scan();
 
   void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param);

esphome/components/esp32_hosted/__init__.py

@@ -313,7 +313,7 @@ async def to_code(config: ConfigType) -> None:
     esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="1.6.3")
     esp32.add_idf_component(name="espressif/wifi_remote_over_eppp", ref="0.3.3")
     esp32.add_idf_component(name="espressif/eppp_link", ref="1.1.5")
-    esp32.add_idf_component(name="espressif/esp_hosted", ref="2.12.13")
+    esp32.add_idf_component(name="espressif/esp_hosted", ref="2.12.12")
     esp32.add_extra_script(
         "post",
         "esp32_hosted.py",

esphome/components/esp8266/__init__.py

@@ -37,7 +37,6 @@ from esphome.types import ConfigType
 
 from .boards import BOARDS, board_ld_script
 from .const import (
-    BUILD_FLASH_MODES,
     CONF_EARLY_PIN_INIT,
     CONF_ENABLE_SERIAL,
     CONF_ENABLE_SERIAL1,
@@ -45,7 +44,6 @@ from .const import (
     KEY_BOARD,
     KEY_ESP8266,
     KEY_PIN_INITIAL_STATES,
-    KEY_SCANF_FLOAT,
     KEY_SERIAL1_REQUIRED,
     KEY_SERIAL_REQUIRED,
     KEY_WAVEFORM_REQUIRED,
@@ -235,6 +233,7 @@ ARDUINO_FRAMEWORK_SCHEMA = cv.All(
 )
 
 
+BUILD_FLASH_MODES = ["qio", "qout", "dio", "dout"]
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
@@ -316,9 +315,6 @@ async def to_code(config: ConfigType) -> None:
             "enabling scanf float support (~8KB flash)"
         )
 
-    # The native generator reads the same decision (KEY_SCANF_FLOAT)
-    CORE.data[KEY_ESP8266][KEY_SCANF_FLOAT] = bool(enable_scanf_float)
-
     extra_scripts = [
         "pre:ccache.py",
         "pre:testing_mode.py",
@@ -339,16 +335,7 @@ async def to_code(config: ConfigType) -> None:
     cg.add_platformio_option("platform", conf[CONF_PLATFORM_VERSION])
     cg.add_platformio_option(
         "platform_packages",
-        [
-            f"platformio/framework-arduinoespressif8266@{conf[CONF_SOURCE]}",
-            # Override the ancient tool-esptoolpy ~1.30000.0 pinned by
-            # platform-espressif8266 4.2.1 with the same 5.x build the
-            # pioarduino ESP32 platform uses, so both platforms share the
-            # same installed package and stop reinstalling on every switch.
-            # The 0.0.1 path component is pioarduino's stable registry
-            # release tag (not the tool version); the tool itself is 5.2.0.
-            "pioarduino/tool-esptoolpy@https://github.com/pioarduino/registry/releases/download/0.0.1/esptoolpy-v5.2.0.zip",
-        ],
+        [f"platformio/framework-arduinoespressif8266@{conf[CONF_SOURCE]}"],
     )
 
     # Default for platformio is LWIP2_LOW_MEMORY with:

esphome/components/esp8266/const.py

@@ -16,6 +16,7 @@ KEY_WAVEFORM_REQUIRED = "waveform_required"
 KEY_SERIAL_REQUIRED = "serial_required"
 KEY_SERIAL1_REQUIRED = "serial1_required"
 # Set for the native (non-PlatformIO) toolchain's build generator
+KEY_FLASH_MODE = "flash_mode"
 KEY_SCANF_FLOAT = "scanf_float"
 # Per-board flash-layout override consumed by board_ld_script()
 KEY_LDSCRIPT = "ldscript"
@@ -72,6 +73,3 @@ def enable_serial1() -> None:
             enable_serial1()
     """
     CORE.data.setdefault(KEY_ESP8266, {})[KEY_SERIAL1_REQUIRED] = True
-
-
-BUILD_FLASH_MODES = ("qio", "qout", "dio", "dout")

esphome/components/esp8266_pwm/esp8266_pwm.h

@@ -4,6 +4,7 @@
 
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/automation.h"
 #include "esphome/components/output/float_output.h"
 
 namespace esphome::esp8266_pwm {
@@ -36,6 +37,19 @@ class ESP8266PWM final : public output::FloatOutput, public Component {
   float last_output_{0.0};
 };
 
+template<typename... Ts> class SetFrequencyAction final : public Action<Ts...> {
+ public:
+  SetFrequencyAction(ESP8266PWM *parent) : parent_(parent) {}
+  TEMPLATABLE_VALUE(float, frequency);
+
+  void play(const Ts &...x) {
+    float freq = this->frequency_.value(x...);
+    this->parent_->update_frequency(freq);
+  }
+
+  ESP8266PWM *parent_;
+};
+
 }  // namespace esphome::esp8266_pwm
 
 #endif

esphome/components/esp8266_pwm/output.py

@@ -4,6 +4,8 @@ from esphome.components import output
 from esphome.components.esp8266.const import require_waveform
 import esphome.config_validation as cv
 from esphome.const import CONF_FREQUENCY, CONF_ID, CONF_NUMBER, CONF_PIN
+from esphome.core import ID
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 DEPENDENCIES = ["esp8266"]
@@ -17,6 +19,7 @@ def valid_pwm_pin(value: ConfigType) -> ConfigType:
 
 esp8266_pwm_ns = cg.esphome_ns.namespace("esp8266_pwm")
 ESP8266PWM = esp8266_pwm_ns.class_("ESP8266PWM", output.FloatOutput, cg.Component)
+SetFrequencyAction = esp8266_pwm_ns.class_("SetFrequencyAction", automation.Action)
 validate_frequency = cv.All(cv.frequency, cv.float_range(min=1.0e-6))
 
 # Schema default that also matches the C++ initializer in esp8266_pwm.h; codegen
@@ -54,13 +57,25 @@ async def to_code(config: ConfigType) -> None:
         cg.add(var.set_frequency(frequency))
 
 
-automation.register_apply_action(
+@automation.register_action(
     "output.esp8266_pwm.set_frequency",
+    SetFrequencyAction,
     cv.Schema(
         {
             cv.Required(CONF_ID): cv.use_id(ESP8266PWM),
             cv.Required(CONF_FREQUENCY): cv.templatable(validate_frequency),
         }
     ),
-    automation.ApplyField(CONF_FREQUENCY, "update_frequency", cg.float_),
+    synchronous=True,
 )
+async def esp8266_set_frequency_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    template_ = await cg.templatable(config[CONF_FREQUENCY], args, cg.float_)
+    cg.add(var.set_frequency(template_))
+    return var

esphome/components/esphome/ota/__init__.py

@@ -2,7 +2,7 @@ import logging
 
 import esphome.codegen as cg
 from esphome.components.noise import (
-    ENCRYPTION_SCHEMA,
+    encryption_schema,
     new_psk_progmem,
     static_encryption_key,
 )
@@ -27,7 +27,6 @@ from esphome.const import (
 )
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
-from esphome.espota2 import CONF_ALLOW_PLAINTEXT_UPLOAD
 import esphome.final_validate as fv
 from esphome.types import ConfigType
 
@@ -232,38 +231,15 @@ def _resolve_encryption_key(encryption_conf: ConfigType, api_conf: ConfigType) -
         encryption_conf[CONF_KEY] = api_key
 
 
-# Uploader side options live only on the ota block; the api block keeps the
-# shared schema
-_ENCRYPTION_SCHEMA = ENCRYPTION_SCHEMA.extend(
-    {
-        cv.Optional(CONF_ALLOW_PLAINTEXT_UPLOAD): cv.boolean,
-    }
-)
-
-
-def _encryption_schema(config: ConfigType | None) -> ConfigType:
-    # Only a bare `encryption:` block is keyless; `false` or a list must fail
-    return _ENCRYPTION_SCHEMA({} if config is None else config)
-
-
 # Also called on merged same-port configs in final validate, where schemas
 # do not run
 def _validate_no_password_with_encryption(config: ConfigType) -> ConfigType:
-    if (
-        CONF_PASSWORD not in config
-        or (encryption := config.get(CONF_ENCRYPTION)) is None
-    ):
-        return config
-    # The migration install may still have to answer the old firmware's
-    # password prompt on the plaintext leg; the password is not built in
-    if encryption.get(CONF_ALLOW_PLAINTEXT_UPLOAD):
-        return config
-    raise cv.Invalid(
-        f"'{CONF_PASSWORD}' cannot be combined with '{CONF_ENCRYPTION}'; the "
-        f"encryption key already authenticates the uploader, remove '{CONF_PASSWORD}' "
-        f"(or set '{CONF_ALLOW_PLAINTEXT_UPLOAD}: true' for the one install that "
-        f"migrates a device still asking for it)"
-    )
+    if CONF_PASSWORD in config and CONF_ENCRYPTION in config:
+        raise cv.Invalid(
+            f"'{CONF_PASSWORD}' cannot be combined with '{CONF_ENCRYPTION}'; the "
+            f"encryption key already authenticates the uploader, remove '{CONF_PASSWORD}'"
+        )
+    return config
 
 
 def _consume_ota_sockets(config: ConfigType) -> ConfigType:
@@ -293,7 +269,7 @@ CONFIG_SCHEMA = cv.All(
             ): cv.port,
             cv.Optional(CONF_ALLOW_PARTITION_ACCESS, default=False): cv.boolean,
             cv.Optional(CONF_PASSWORD): cv.sensitive(),
-            cv.Optional(CONF_ENCRYPTION): _encryption_schema,
+            cv.Optional(CONF_ENCRYPTION): encryption_schema,
             cv.Optional(CONF_NUM_ATTEMPTS): cv.invalid(
                 f"'{CONF_SAFE_MODE}' (and its related configuration variables) has moved from 'ota' to its own component. See https://esphome.io/components/safe_mode"
             ),
@@ -328,10 +304,7 @@ async def to_code(config: ConfigType) -> None:
     # An empty password opts in to the auth code path so set_auth_password() can be
     # called at runtime (e.g. to rotate the password from a lambda). When `password:`
     # is omitted entirely, the auth path is excluded to save flash on small devices.
-    # A password is never built in next to encryption: validation only lets
-    # the two coexist for the migration install, where the password answers
-    # the running firmware and the build is authenticated by the key
-    if CONF_PASSWORD in config and CONF_ENCRYPTION not in config:
+    if CONF_PASSWORD in config:
         cg.add_define("USE_OTA_PASSWORD")
         if config[CONF_PASSWORD]:
             cg.add(var.set_auth_password(config[CONF_PASSWORD]))

esphome/components/esphome/ota/ota_esphome.cpp

@@ -467,8 +467,6 @@ void ESPHomeOTAComponent::handle_data_() {
   if (this->extended_proto_()) {
     // Read ota type, 1 byte
     if (!this->data_readall_(buf, 1)) {
-      if (this->client_left_before_start_())
-        return;
       this->log_read_error_(LOG_STR("OTA type"));
       goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
     }
@@ -478,9 +476,6 @@ void ESPHomeOTAComponent::handle_data_() {
 
   // Read size, 4 bytes MSB first
   if (!this->data_readall_(buf, 4)) {
-    // The first request byte is the type on the extended protocol; a close after it was a cut-off request
-    if (!this->extended_proto_() && this->client_left_before_start_())
-      return;
     this->log_read_error_(LOG_STR("size"));
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
@@ -547,8 +542,6 @@ void ESPHomeOTAComponent::handle_data_() {
       // there is no would-block retry here and failures are already logged.
       read = this->noise_read_data_(buf, requested);
       if (read <= 0) {
-        if (this->remote_closed_)
-          this->log_remote_closed_(LOG_STR("data"));
         error_code = ota::OTA_RESPONSE_ERROR_UNKNOWN;
         goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
       }
@@ -673,11 +666,7 @@ bool ESPHomeOTAComponent::readall_(uint8_t *buf, size_t len) {
         return false;
       }
     } else if (read == 0) {
-      // A partial message is a cut-off request, not a clean close; the caller reports the clean one
-      this->remote_closed_ = at == 0;
-      if (at > 0) {
-        ESP_LOGW(TAG, "Remote closed after %u of %zu bytes", (unsigned) at, len);
-      }
+      ESP_LOGW(TAG, "Remote closed");
       return false;
     } else {
       at += read;
@@ -723,22 +712,7 @@ void ESPHomeOTAComponent::log_socket_error_(const LogString *msg) {
   ESP_LOGW(TAG, "Socket %s: errno %d", LOG_STR_ARG(msg), errno);
 }
 
-bool ESPHomeOTAComponent::client_left_before_start_() {
-  // Key probes and scanners hang up right after the handshake; nothing started, so no error status or callback
-  if (!this->remote_closed_)
-    return false;
-  ESP_LOGD(TAG, "Client left after the handshake");
-  this->cleanup_connection_();
-  return true;
-}
-
-void ESPHomeOTAComponent::log_read_error_(const LogString *what) {
-  if (this->remote_closed_) {
-    this->log_remote_closed_(what);
-    return;
-  }
-  ESP_LOGW(TAG, "Read %s failed", LOG_STR_ARG(what));
-}
+void ESPHomeOTAComponent::log_read_error_(const LogString *what) { ESP_LOGW(TAG, "Read %s failed", LOG_STR_ARG(what)); }
 
 void ESPHomeOTAComponent::log_start_(const LogString *phase) {
   char peername[socket::SOCKADDR_STR_LEN];
@@ -819,7 +793,6 @@ void ESPHomeOTAComponent::cleanup_connection_() {
   this->handshake_buf_pos_ = 0;
   this->ota_state_ = OTAState::IDLE;
   this->ota_features_ = 0;
-  this->remote_closed_ = false;
   this->backend_ = nullptr;
 #ifdef USE_OTA_PASSWORD
   this->cleanup_auth_();

esphome/components/esphome/ota/ota_esphome.h

@@ -134,7 +134,6 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
   void server_failed_(const LogString *msg);
   void log_socket_error_(const LogString *msg);
   void log_read_error_(const LogString *what);
-  bool client_left_before_start_();
   void log_start_(const LogString *phase);
   void log_remote_closed_(const LogString *during);
   void cleanup_connection_();
@@ -187,7 +186,6 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
   OTAState ota_state_{OTAState::IDLE};
   uint8_t handshake_buf_pos_{0};
   uint8_t ota_features_{0};
-  bool remote_closed_{false};  // the peer hung up cleanly during a blocking read
 #ifdef USE_OTA_PASSWORD
   uint8_t auth_buf_pos_{0};
   uint8_t auth_type_{0};  // Store auth type to know which hasher to use

esphome/components/espnow/__init__.py

@@ -39,6 +39,9 @@ ESPNowRecvInfo = espnow_ns.class_("ESPNowRecvInfo")
 ESPNowRecvInfoConstRef = ESPNowRecvInfo.operator("const").operator("ref")
 
 SendAction = espnow_ns.class_("SendAction", automation.Action)
+SetChannelAction = espnow_ns.class_("SetChannelAction", automation.Action)
+AddPeerAction = espnow_ns.class_("AddPeerAction", automation.Action)
+DeletePeerAction = espnow_ns.class_("DeletePeerAction", automation.Action)
 
 ESPNowHandlerTrigger = automation.Trigger.template(
     ESPNowRecvInfoConstRef,
@@ -229,16 +232,12 @@ def _validate_raw_data(value: Any) -> str | list:
     )
 
 
-def _mac_bytes(address: core.MACAddress) -> list[HexInt]:
-    return [HexInt(p) for p in address.parts]
-
-
 async def register_peer(
     var: MockObj, config: ConfigType, args: TemplateArgsType
 ) -> None:
     peer = config[CONF_ADDRESS]
     if isinstance(peer, core.MACAddress):
-        peer = _mac_bytes(peer)
+        peer = [HexInt(p) for p in peer.parts]
 
     template_ = await cg.templatable(peer, args, peer_address_t, peer_address_t)
     cg.add(var.set_address(template_))
@@ -324,28 +323,40 @@ async def send_action(
     return var
 
 
-def _peer_address(config: ConfigType, value: core.MACAddress) -> str:
-    return str(cg.safe_exp(_mac_bytes(value)))
+@automation.register_action(
+    "espnow.peer.add",
+    AddPeerAction,
+    cv.maybe_simple_value(
+        PEER_SCHEMA,
+        key=CONF_ADDRESS,
+    ),
+    synchronous=True,
+)
+@automation.register_action(
+    "espnow.peer.delete",
+    DeletePeerAction,
+    cv.maybe_simple_value(
+        PEER_SCHEMA,
+        key=CONF_ADDRESS,
+    ),
+    synchronous=True,
+)
+async def peer_action(
+    config: ConfigType,
+    action_id: core.ID,
+    template_arg: cg.TemplateArguments,
+    args: list[tuple],
+) -> MockObj:
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    await register_peer(var, config, args)
+
+    return var
 
 
-for _name, _method in (
-    ("espnow.peer.add", "add_peer_from_action"),
-    ("espnow.peer.delete", "del_peer_from_action"),
-):
-    automation.register_apply_action(
-        _name,
-        cv.maybe_simple_value(
-            PEER_SCHEMA,
-            key=CONF_ADDRESS,
-        ),
-        automation.ApplyField(
-            CONF_ADDRESS, _method, peer_address_t, const_fn=_peer_address
-        ),
-    )
-
-
-automation.register_apply_action(
+@automation.register_action(
     "espnow.set_channel",
+    SetChannelAction,
     cv.maybe_simple_value(
         {
             cv.GenerateID(): cv.use_id(ESPNowComponent),
@@ -353,5 +364,16 @@ automation.register_apply_action(
         },
         key=CONF_CHANNEL,
     ),
-    automation.ApplyField(CONF_CHANNEL, "set_channel_from_action", cg.uint8),
+    synchronous=True,
 )
+async def channel_action(
+    config: ConfigType,
+    action_id: core.ID,
+    template_arg: cg.TemplateArguments,
+    args: list[tuple],
+) -> MockObj:
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    template_ = await cg.templatable(config[CONF_CHANNEL], args, cg.uint8)
+    cg.add(var.set_channel(template_))
+    return var

esphome/components/espnow/automation.h

@@ -86,6 +86,39 @@ template<typename... Ts> class SendAction final : public Action<Ts...>, public P
   } flags_{0};
 };
 
+template<typename... Ts> class AddPeerAction final : public Action<Ts...>, public Parented<ESPNowComponent> {
+  TEMPLATABLE_VALUE(peer_address_t, address);
+
+ protected:
+  void play(const Ts &...x) override {
+    peer_address_t address = this->address_.value(x...);
+    this->parent_->add_peer(address.data());
+  }
+};
+
+template<typename... Ts> class DeletePeerAction final : public Action<Ts...>, public Parented<ESPNowComponent> {
+  TEMPLATABLE_VALUE(peer_address_t, address);
+
+ protected:
+  void play(const Ts &...x) override {
+    peer_address_t address = this->address_.value(x...);
+    this->parent_->del_peer(address.data());
+  }
+};
+
+template<typename... Ts> class SetChannelAction final : public Action<Ts...>, public Parented<ESPNowComponent> {
+  TEMPLATABLE_VALUE(uint8_t, channel)
+
+ protected:
+  void play(const Ts &...x) override {
+    if (this->parent_->is_wifi_enabled()) {
+      return;
+    }
+    this->parent_->set_wifi_channel(this->channel_.value(x...));
+    this->parent_->apply_wifi_channel();
+  }
+};
+
 class OnReceiveTrigger final : public Trigger<const ESPNowRecvInfo &, const uint8_t *, uint16_t>,
                                public ESPNowReceivedPacketHandler {
  public:

esphome/components/espnow/espnow_component.h

@@ -116,18 +116,9 @@ class ESPNowComponent final : public Component {
   esp_err_t add_peer(const uint8_t *peer);
   // Remove a peer with the esp_now api and remove from the internal list if exists
   esp_err_t del_peer(const uint8_t *peer);
-  // Action entry points; distinct names because add_peer(peer_address_t) only fills the boot-time list
-  esp_err_t add_peer_from_action(const peer_address_t &address) { return this->add_peer(address.data()); }
-  esp_err_t del_peer_from_action(const peer_address_t &address) { return this->del_peer(address.data()); }
 
   void set_wifi_channel(uint8_t channel) { this->wifi_channel_ = channel; }
   void apply_wifi_channel();
-  void set_channel_from_action(uint8_t channel) {
-    if (this->is_wifi_enabled())
-      return;
-    this->set_wifi_channel(channel);
-    this->apply_wifi_channel();
-  }
   uint8_t get_wifi_channel();
 
   void set_auto_add_peer(bool value) { this->auto_add_peer_ = value; }

esphome/components/ethernet/__init__.py

@@ -53,10 +53,12 @@ from esphome.const import (
 )
 from esphome.core import (
     CORE,
+    ID,
     CoroPriority,
     TimePeriodMilliseconds,
     coroutine_with_priority,
 )
+from esphome.cpp_generator import MockObj, TemplateArgsType
 import esphome.final_validate as fv
 from esphome.types import ConfigType
 
@@ -922,15 +924,24 @@ def _filter_source_files() -> list[str]:
 FILTER_SOURCE_FILES = _filter_source_files
 
 
-automation.register_bare_condition(
-    "ethernet.connected", EthernetConnectedCondition, cv.Schema({})
-)
-automation.register_bare_condition(
-    "ethernet.enabled", EthernetEnabledCondition, cv.Schema({})
-)
-automation.register_bare_action(
-    "ethernet.enable", EthernetEnableAction, cv.Schema({}), synchronous=True
-)
-automation.register_bare_action(
-    "ethernet.disable", EthernetDisableAction, cv.Schema({}), synchronous=True
-)
+async def _new_pvariable_to_code(
+    config: ConfigType,
+    id_: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    return cg.new_Pvariable(id_, template_arg)
+
+
+for _name, _cls in (
+    ("ethernet.connected", EthernetConnectedCondition),
+    ("ethernet.enabled", EthernetEnabledCondition),
+):
+    automation.register_condition(_name, _cls, cv.Schema({}))(_new_pvariable_to_code)
+for _name, _cls in (
+    ("ethernet.enable", EthernetEnableAction),
+    ("ethernet.disable", EthernetDisableAction),
+):
+    automation.register_action(_name, _cls, cv.Schema({}), synchronous=True)(
+        _new_pvariable_to_code
+    )

esphome/components/event/__init__.py

@@ -16,14 +16,14 @@ from esphome.const import (
     DEVICE_CLASS_EMPTY,
     DEVICE_CLASS_MOTION,
 )
-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_device_class,
     setup_entity,
 )
-from esphome.cpp_generator import MockObj, MockObjClass
+from esphome.cpp_generator import MockObj, MockObjClass, TemplateArgsType
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@nohat"]
@@ -40,6 +40,8 @@ event_ns = cg.esphome_ns.namespace("event")
 Event = event_ns.class_("Event", cg.EntityBase)
 EventPtr = Event.operator("ptr")
 
+TriggerEventAction = event_ns.class_("TriggerEventAction", automation.Action)
+
 validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")
 
 _EVENT_SCHEMA = (
@@ -133,18 +135,20 @@ TRIGGER_EVENT_SCHEMA = cv.Schema(
 )
 
 
-def _event_type_literal(config: ConfigType, value: str) -> str:
-    """A constant event type is a plain literal; trigger() only compares it, so no copy is needed."""
-    return str(cg.safe_exp(value))
-
-
-automation.register_apply_action(
-    "event.trigger",
-    TRIGGER_EVENT_SCHEMA,
-    automation.ApplyField(
-        CONF_EVENT_TYPE, "trigger", cg.std_string, _event_type_literal
-    ),
+@automation.register_action(
+    "event.trigger", TriggerEventAction, TRIGGER_EVENT_SCHEMA, synchronous=True
 )
+async def event_fire_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])
+    templ = await cg.templatable(config[CONF_EVENT_TYPE], args, cg.std_string)
+    cg.add(var.set_event_type(templ))
+    return var
 
 
 @coroutine_with_priority(CoroPriority.CORE)

esphome/components/event/automation.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "esphome/components/event/event.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+
+namespace esphome::event {
+
+template<typename... Ts> class TriggerEventAction final : public Action<Ts...>, public Parented<Event> {
+ public:
+  TEMPLATABLE_VALUE(std::string, event_type)
+
+  void play(const Ts &...x) override { this->parent_->trigger(this->event_type_.value(x...)); }
+};
+
+class EventTrigger final : public Trigger<StringRef> {
+ public:
+  EventTrigger(Event *event) {
+    event->add_on_event_callback([this](StringRef event_type) { this->trigger(event_type); });
+  }
+};
+
+}  // namespace esphome::event

esphome/components/event/event.cpp

@@ -7,17 +7,17 @@ namespace esphome::event {
 
 static const char *const TAG = "event";
 
-void Event::trigger(const char *event_type) {
+void Event::trigger(const std::string &event_type) {
   // Linear search with strcmp - faster than std::set for small datasets (1-5 items typical)
   const char *found = nullptr;
   for (const char *type : this->types_) {
-    if (strcmp(type, event_type) == 0) {
+    if (strcmp(type, event_type.c_str()) == 0) {
       found = type;
       break;
     }
   }
   if (found == nullptr) {
-    ESP_LOGE(TAG, "'%s': invalid event type for trigger(): %s", this->get_name().c_str(), event_type);
+    ESP_LOGE(TAG, "'%s': invalid event type for trigger(): %s", this->get_name().c_str(), event_type.c_str());
     return;
   }
   this->last_event_type_ = found;
@@ -36,4 +36,12 @@ void Event::set_event_types(const FixedVector<const char *> &event_types) {
   this->last_event_type_ = nullptr;  // Reset when types change
 }
 
+void Event::set_event_types(const std::vector<const char *> &event_types) {
+  this->types_.init(event_types.size());
+  for (const char *type : event_types) {
+    this->types_.push_back(type);
+  }
+  this->last_event_type_ = nullptr;  // Reset when types change
+}
+
 }  // namespace esphome::event

esphome/components/event/event.h

@@ -3,6 +3,7 @@
 #include <cstring>
 #include <limits>
 #include <string>
+#include <vector>
 
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
@@ -20,21 +21,22 @@ namespace esphome::event {
 
 class Event : public EntityBase {
  public:
-  /// Trigger an event; the type is matched against the configured types by string compare.
-  void trigger(const char *event_type);
-  void trigger(const std::string &event_type) { this->trigger(event_type.c_str()); }
+  void trigger(const std::string &event_type);
 
-  /// Set the event types supported by this event; called by generated code with string literals.
+  /// Set the event types supported by this event (from initializer list).
   void set_event_types(std::initializer_list<const char *> event_types) {
     this->types_ = event_types;
     this->last_event_type_ = nullptr;  // Reset when types change
   }
-  /// Copy the event types of another event, for components that wrap one.
+  /// Set the event types supported by this event (from FixedVector).
   void set_event_types(const FixedVector<const char *> &event_types);
+  /// Set the event types supported by this event (from vector).
+  void set_event_types(const std::vector<const char *> &event_types);
 
   // Deleted overloads to catch incorrect std::string usage at compile time with clear error messages
   void set_event_types(std::initializer_list<std::string> event_types) = delete;
   void set_event_types(const FixedVector<std::string> &event_types) = delete;
+  void set_event_types(const std::vector<std::string> &event_types) = delete;
 
   /// Return the event types supported by this event.
   const FixedVector<const char *> &get_event_types() const { return this->types_; }

esphome/components/ezo_pmp/__init__.py

@@ -80,52 +80,72 @@ EzoPMPArbitraryCommandAction = ezo_pmp_ns.class_(
 )
 
 
-automation.register_simple_action(
+@automation.register_action(
     "ezo_pmp.find",
     EzoPMPFindAction,
     EZO_PMP_NO_ARGS_ACTION_SCHEMA,
     synchronous=True,
 )
+async def ezo_pmp_find_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_simple_action(
+@automation.register_action(
     "ezo_pmp.dose_continuously",
     EzoPMPDoseContinuouslyAction,
     EZO_PMP_NO_ARGS_ACTION_SCHEMA,
     synchronous=True,
 )
+async def ezo_pmp_dose_continuously_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_simple_action(
+@automation.register_action(
     "ezo_pmp.clear_total_volume_dosed",
     EzoPMPClearTotalVolumeDispensedAction,
     EZO_PMP_NO_ARGS_ACTION_SCHEMA,
     synchronous=True,
 )
+async def ezo_pmp_clear_total_volume_dosed_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_simple_action(
+@automation.register_action(
     "ezo_pmp.clear_calibration",
     EzoPMPClearCalibrationAction,
     EZO_PMP_NO_ARGS_ACTION_SCHEMA,
     synchronous=True,
 )
+async def ezo_pmp_clear_calibration_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_simple_action(
+@automation.register_action(
     "ezo_pmp.pause_dosing",
     EzoPMPPauseDosingAction,
     EZO_PMP_NO_ARGS_ACTION_SCHEMA,
     synchronous=True,
 )
+async def ezo_pmp_pause_dosing_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_simple_action(
+@automation.register_action(
     "ezo_pmp.stop_dosing",
     EzoPMPStopDosingAction,
     EZO_PMP_NO_ARGS_ACTION_SCHEMA,
     synchronous=True,
 )
+async def ezo_pmp_stop_dosing_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)
 
 
 # Actions that require Multiple Args

esphome/components/fan/__init__.py

@@ -31,17 +31,19 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_WEB_SERVER,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, Lambda, coroutine_with_priority
 from esphome.core.entity_helpers import (
     entity_duplicate_validator,
     queue_entity_register,
     setup_entity,
 )
+from esphome.cpp_generator import LambdaExpression
 
 IS_PLATFORM_COMPONENT = True
 
 fan_ns = cg.esphome_ns.namespace("fan")
 Fan = fan_ns.class_("Fan", cg.EntityBase)
+FanCall = fan_ns.class_("FanCall")
 
 FanDirection = fan_ns.enum("FanDirection", is_class=True)
 FAN_DIRECTION_ENUM = {
@@ -61,6 +63,9 @@ RESTORE_MODES = {
 }
 
 # Actions
+TurnOnAction = fan_ns.class_("TurnOnAction", automation.Action)
+TurnOffAction = fan_ns.class_("TurnOffAction", automation.Action)
+ToggleAction = fan_ns.class_("ToggleAction", automation.Action)
 CycleSpeedAction = fan_ns.class_("CycleSpeedAction", automation.Action)
 
 FanStateTrigger = fan_ns.class_(
@@ -81,6 +86,9 @@ FanPresetSetTrigger = fan_ns.class_(
     "FanPresetSetTrigger", automation.Trigger.template(cg.StringRef)
 )
 
+FanIsOnCondition = fan_ns.class_("FanIsOnCondition", automation.Condition.template())
+FanIsOffCondition = fan_ns.class_("FanIsOffCondition", automation.Condition.template())
+
 _FAN_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
@@ -308,11 +316,25 @@ FAN_ACTION_SCHEMA = maybe_simple_id(
 )
 
 
-automation.register_apply_action("fan.toggle", FAN_ACTION_SCHEMA, call="toggle")
-automation.register_apply_action("fan.turn_off", FAN_ACTION_SCHEMA, call="turn_off")
+@automation.register_action(
+    "fan.toggle", ToggleAction, FAN_ACTION_SCHEMA, synchronous=True
+)
+async def fan_toggle_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_apply_action(
+
+@automation.register_action(
+    "fan.turn_off", TurnOffAction, FAN_ACTION_SCHEMA, synchronous=True
+)
+async def fan_turn_off_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(
     "fan.turn_on",
+    TurnOnAction,
     maybe_simple_id(
         {
             cv.Required(CONF_ID): cv.use_id(Fan),
@@ -323,11 +345,50 @@ automation.register_apply_action(
             ),
         }
     ),
-    automation.ApplyField(CONF_OSCILLATING, "set_oscillating", cg.bool_),
-    automation.ApplyField(CONF_SPEED, "set_speed", cg.int_),
-    automation.ApplyField(CONF_DIRECTION, "set_direction", FanDirection),
-    call="turn_on",
+    synchronous=True,
 )
+async def fan_turn_on_to_code(config, action_id, template_arg, args):
+    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.
+    FIELDS = (
+        (CONF_OSCILLATING, "set_oscillating", cg.bool_),
+        (CONF_SPEED, "set_speed", cg.int_),
+        (CONF_DIRECTION, "set_direction", FanDirection),
+    )
+
+    # 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 TurnOnAction::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}));")
+        else:
+            body_lines.append(f"call.{setter}({cg.safe_exp(value)});")
+
+    apply_args = [
+        (FanCall.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)
 
 
 @automation.register_action(
@@ -349,16 +410,27 @@ async def fan_cycle_speed_to_code(config, action_id, template_arg, args):
     return var
 
 
-FAN_CONDITION_SCHEMA = automation.maybe_simple_id(
-    {
-        cv.Required(CONF_ID): cv.use_id(Fan),
-    }
+@automation.register_condition(
+    "fan.is_on",
+    FanIsOnCondition,
+    automation.maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(Fan),
+        }
+    ),
 )
-
-automation.register_apply_condition("fan.is_on", FAN_CONDITION_SCHEMA, "state")
-automation.register_apply_condition(
-    "fan.is_off", FAN_CONDITION_SCHEMA, "state == false"
+@automation.register_condition(
+    "fan.is_off",
+    FanIsOffCondition,
+    automation.maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(Fan),
+        }
+    ),
 )
+async def fan_is_on_off_to_code(config, condition_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren)
 
 
 @coroutine_with_priority(CoroPriority.CORE)

esphome/components/fan/automation.h

@@ -6,6 +6,51 @@
 
 namespace esphome::fan {
 
+// 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. `speed: !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 TurnOnAction final : public Action<Ts...> {
+ public:
+  using ApplyFn = void (*)(FanCall &, const std::remove_cvref_t<Ts> &...);
+  TurnOnAction(Fan *state, ApplyFn apply) : state_(state), apply_(apply) {}
+
+  void play(const Ts &...x) override {
+    auto call = this->state_->turn_on();
+    this->apply_(call, x...);
+    call.perform();
+  }
+
+  Fan *state_;
+  ApplyFn apply_;
+};
+
+template<typename... Ts> class TurnOffAction final : public Action<Ts...> {
+ public:
+  explicit TurnOffAction(Fan *state) : state_(state) {}
+
+  void play(const Ts &...x) override { this->state_->turn_off().perform(); }
+
+  Fan *state_;
+};
+
+template<typename... Ts> class ToggleAction final : public Action<Ts...> {
+ public:
+  explicit ToggleAction(Fan *state) : state_(state) {}
+
+  void play(const Ts &...x) override { this->state_->toggle().perform(); }
+
+  Fan *state_;
+};
+
 template<typename... Ts> class CycleSpeedAction final : public Action<Ts...> {
  public:
   explicit CycleSpeedAction(Fan *state) : state_(state) {}
@@ -50,6 +95,23 @@ template<typename... Ts> class CycleSpeedAction final : public Action<Ts...> {
   Fan *state_;
 };
 
+template<typename... Ts> class FanIsOnCondition final : public Condition<Ts...> {
+ public:
+  explicit FanIsOnCondition(Fan *state) : state_(state) {}
+  bool check(const Ts &...x) override { return this->state_->state; }
+
+ protected:
+  Fan *state_;
+};
+template<typename... Ts> class FanIsOffCondition final : public Condition<Ts...> {
+ public:
+  explicit FanIsOffCondition(Fan *state) : state_(state) {}
+  bool check(const Ts &...x) override { return !this->state_->state; }
+
+ protected:
+  Fan *state_;
+};
+
 class FanStateTrigger final : public Trigger<Fan *> {
  public:
   FanStateTrigger(Fan *state) : fan_(state) {

esphome/components/fan/fan.cpp

@@ -83,7 +83,7 @@ void FanCall::validate_() {
   auto traits = this->parent_.get_traits();
 
   if (this->speed_.has_value()) {
-    this->speed_ = clamp(*this->speed_, 1, static_cast<int>(traits.supported_speed_count()));
+    this->speed_ = clamp(*this->speed_, 1, traits.supported_speed_count());
 
     // https://developers.home-assistant.io/docs/core/entity/fan/#preset-modes
     // "Manually setting a speed must disable any set preset mode"

esphome/components/fan/fan_traits.h

@@ -14,7 +14,7 @@ class FanTraits {
 
  public:
   FanTraits() = default;
-  FanTraits(bool oscillation, bool speed, bool direction, uint8_t speed_count)
+  FanTraits(bool oscillation, bool speed, bool direction, int speed_count)
       : oscillation_(oscillation), speed_(speed), direction_(direction), speed_count_(speed_count) {}
 
   /// Return if this fan supports oscillation.
@@ -26,9 +26,9 @@ class FanTraits {
   /// Set whether this fan supports speed levels.
   void set_speed(bool speed) { this->speed_ = speed; }
   /// Return how many speed levels the fan has
-  uint8_t supported_speed_count() const { return this->speed_count_; }
+  int supported_speed_count() const { return this->speed_count_; }
   /// Set how many speed levels this fan has.
-  void set_supported_speed_count(uint8_t speed_count) { this->speed_count_ = speed_count; }
+  void set_supported_speed_count(int speed_count) { this->speed_count_ = speed_count; }
   /// Return if this fan supports changing direction
   bool supports_direction() const { return this->direction_; }
   /// Set whether this fan supports changing direction