Merge branch 'dev' into noise-combo-test

libsodium 1.10021.10 takes the SHA256 padding block, the SHA256 initial
state and the AEAD zero pad out of DRAM on the ESP8266; noise-c 0.1.29
pins it.

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

@@ -737,9 +737,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

@@ -549,7 +549,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/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

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

@@ -224,15 +224,6 @@ def flash_string(config: ConfigType, value: str) -> str:
     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_), ...)``.
@@ -339,9 +330,9 @@ def _check_key_in_schema(
         schema = schema.schema[markers[part]]
 
 
-async def _apply_parent(config: ConfigType, id_key: str = CONF_ID) -> str:
+async def _apply_parent(config: ConfigType) -> str:
     # Global-scope qualified so a trigger arg named like the id cannot shadow it.
-    return f"::{await cg.get_variable(config[id_key])}"
+    return f"::{await cg.get_variable(config[CONF_ID])}"
 
 
 def _apply_lambda_args(args: TemplateArgsType) -> TemplateArgsType:
@@ -396,14 +387,12 @@ def register_apply_action(
     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.
+    Generates one stateless function for ``ApplyAction<Ts...>``: parent and constants are baked
+    in, lambdas are called inline with the trigger args. With ``call`` every statement targets
+    the call object ``auto apply_call = parent->call()``, and ``apply_call.perform()`` is appended.
     """
     # An action stores the value, so a std::string constant stays in flash on ESP8266.
     statements_spec = [
@@ -416,7 +405,6 @@ def register_apply_action(
         )
         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)
@@ -427,7 +415,7 @@ def register_apply_action(
         template_arg: cg.TemplateArguments,
         args: TemplateArgsType,
     ) -> MockObj:
-        parent = await _apply_parent(config, id_key)
+        parent = await _apply_parent(config)
         lambda_args = _apply_lambda_args(args)
         receiver = "apply_call." if call else f"{parent}->"
         statements: list[str] = []
@@ -454,7 +442,7 @@ def register_apply_action(
 
 
 def register_apply_condition(
-    name: str, schema: cv.Schema, check: str | ApplyCall, id_key: str = CONF_ID
+    name: str, schema: cv.Schema, check: str | ApplyCall
 ) -> None:
     """Register a condition that is one expression on its parent, with no C++ class.
 
@@ -466,7 +454,6 @@ def register_apply_condition(
     """
     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)
 
@@ -476,7 +463,7 @@ def register_apply_condition(
         template_arg: cg.TemplateArguments,
         args: TemplateArgsType,
     ) -> MockObj:
-        parent = await _apply_parent(config, id_key)
+        parent = await _apply_parent(config)
         lambda_args = _apply_lambda_args(args)
         exprs = await _render_values(
             name,

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,10 @@ StateAnyForwarder = alarm_control_panel_ns.class_("StateAnyForwarder")
 StateEnterForwarder = alarm_control_panel_ns.class_("StateEnterForwarder")
 AlarmControlPanelState = alarm_control_panel_ns.enum("AlarmControlPanelState")
 
+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
@@ -204,30 +208,65 @@ for _name, _arm in (
     )
 
 
-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.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_simple_condition(
+@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,26 @@ 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 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

@@ -13,6 +13,7 @@ from esphome.components.logger import request_log_listener
 from esphome.components.noise import (  # noqa: F401
     ENCRYPTION_SCHEMA,
     decode_encryption_key,
+    enable_spare_ephemeral,
     encryption_schema,
     new_psk_progmem,
     validate_encryption_key,
@@ -81,7 +82,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 +463,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()
@@ -613,6 +615,7 @@ async def to_code(config: ConfigType) -> None:
             # and plaintext disabled. Only a factory reset can remove it.
             cg.add_define("USE_API_PLAINTEXT")
         cg.add_define("USE_API_NOISE")
+        enable_spare_ephemeral()
     else:
         cg.add_define("USE_API_PLAINTEXT")
 

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

@@ -317,9 +317,16 @@ class APIConnection final : public APIServerConnectionBase {
   void on_noise_encryption_set_key_request(const NoiseEncryptionSetKeyRequest &msg);
 #endif
 
+  // How long a new connection holds off the spare ephemeral refill
+  static constexpr uint32_t CONNECT_GRACE_MS = 1000;
   bool is_authenticated() {
     return static_cast<ConnectionState>(this->flags_.connection_state) == ConnectionState::AUTHENTICATED;
   }
+  // Unauthenticated and within its grace period; an older unauthenticated
+  // connection is a stale half open client and no longer counts
+  bool is_still_connecting(uint32_t now) {
+    return !this->is_authenticated() && now - this->last_traffic_ < CONNECT_GRACE_MS;
+  }
   bool is_connection_setup() {
     return static_cast<ConnectionState>(this->flags_.connection_state) == ConnectionState::CONNECTED ||
            this->is_authenticated();
@@ -346,7 +353,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 +413,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 +441,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 +457,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 +469,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 +483,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
@@ -162,6 +165,15 @@ void APIServer::loop() {
     this->accept_new_connections_();
   }
 
+  // Checked once per pass for the refill and for the clients below
+  const bool connected = network::is_connected();
+#ifdef USE_NOISE_SPARE_EPHEMERAL
+  // Only the flag test is inline; refilling is the rare path
+  if (connected && !noise::has_spare_ephemeral()) {
+    this->refill_spare_ephemeral_();
+  }
+#endif
+
   if (this->api_connection_count_ == 0) {
     // Check reboot timeout - done in loop to avoid scheduler heap churn
     // (cancelled scheduler items sit in heap memory until their scheduled time).
@@ -178,8 +190,7 @@ void APIServer::loop() {
   }
 
   // Process clients and remove disconnected ones in a single pass
-  // Check network connectivity once for all clients
-  if (!network::is_connected()) {
+  if (!connected) {
     // Network is down - disconnect all clients
     for (auto &client : this->active_clients()) {
       client->on_fatal_error();
@@ -207,6 +218,21 @@ void APIServer::loop() {
   }
 }
 
+#ifdef USE_NOISE_SPARE_EPHEMERAL
+// Called with the network up; refill only while no api client is still
+// connecting (an OTA handshake is not visible here and just pays the refill
+// it triggered).
+void APIServer::refill_spare_ephemeral_() {
+  const uint32_t now = App.get_loop_component_start_time();
+  for (auto &client : this->active_clients()) {
+    if (client->is_still_connecting(now)) {
+      return;
+    }
+  }
+  noise::prepare_spare_ephemeral();
+}
+#endif
+
 void APIServer::remove_client_(uint8_t client_index) {
   auto &client = this->clients_[client_index];
 
@@ -452,9 +478,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

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

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/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
@@ -138,6 +138,9 @@ 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 +645,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 +666,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 +677,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,31 @@ 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 BinarySensorInvalidateAction final : public Action<Ts...> {
  public:
   explicit BinarySensorInvalidateAction(BinarySensor *sensor) : sensor_(sensor) {}

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

esphome/components/climate/__init__.py

@@ -494,6 +494,12 @@ CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema(
 )
 
 
+def _literal_with_length(config: ConfigType, value: str) -> str:
+    # The (const char *, size_t) overload compares bytes in place, so it needs a plain
+    # literal rather than the default PROGMEM rendering on ESP8266, and skips a strlen.
+    return f"{cg.safe_exp(value)}, {len(value.encode('utf-8'))}"
+
+
 automation.register_apply_action(
     "climate.control",
     CLIMATE_CONTROL_ACTION_SCHEMA,
@@ -511,14 +517,14 @@ automation.register_apply_action(
         CONF_CUSTOM_FAN_MODE,
         "set_fan_mode",
         cg.std_string,
-        const_fn=automation.literal_with_length,
+        const_fn=_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,
+        const_fn=_literal_with_length,
     ),
     automation.ApplyField(CONF_SWING_MODE, "set_swing_mode", ClimateSwingMode),
     call="make_call",

esphome/components/climate_ir/climate_ir.cpp

@@ -13,7 +13,17 @@ 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});
+  if (this->supports_cool_)
+    traits.add_supported_mode(climate::CLIMATE_MODE_COOL);
+  if (this->supports_heat_)
+    traits.add_supported_mode(climate::CLIMATE_MODE_HEAT);
+  if (this->supports_heat_cool_)
+    traits.add_supported_mode(climate::CLIMATE_MODE_HEAT_COOL);
+  if (this->supports_dry_)
+    traits.add_supported_mode(climate::CLIMATE_MODE_DRY);
+  if (this->supports_fan_only_)
+    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_);
@@ -88,10 +98,8 @@ void ClimateIR::dump_config() {
                 "  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)));
+                this->minimum_temperature_, this->maximum_temperature_, YESNO(this->supports_heat_),
+                YESNO(this->supports_cool_), YESNO(this->supports_heat_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,9 @@ 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_supports_heat_cool(bool supports_heat_cool) { this->supports_heat_cool_ = supports_heat_cool; }
   void set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
   void set_humidity_sensor(sensor::Sensor *sensor) { this->humidity_sensor_ = sensor; }
 
@@ -63,18 +59,12 @@ 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};
+  // Default (supports_cool && supports_heat) is resolved during code generation.
+  bool supports_heat_cool_{true};
+  bool supports_dry_{false};
+  bool supports_fan_only_{false};
   climate::ClimateFanModeMask fan_modes_{};
   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/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/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

@@ -37,6 +37,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 +87,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 +129,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 +200,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 +220,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,8 +272,110 @@ 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
+
+
+@automation.register_action(
+    "dfplayer.sleep",
+    SleepAction,
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(DFPlayer),
+        }
+    ),
+    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_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
 
 
 def _default_enable(value: Any) -> Any:
@@ -199,7 +404,7 @@ automation.register_apply_action(
 )
 
 
-automation.register_parented_condition(
+@automation.register_condition(
     "dfplayer.is_playing",
     DFPlayerIsPlayingCondition,
     cv.Schema(
@@ -208,3 +413,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.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);
@@ -77,6 +72,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_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"
@@ -1599,29 +1595,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 +2035,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 +2361,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 +2913,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/esp8266/__init__.py

@@ -339,16 +339,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/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/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

@@ -133,17 +133,10 @@ 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.ApplyField(CONF_EVENT_TYPE, "trigger", cg.std_string),
 )
 
 

esphome/components/event/automation.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "esphome/components/event/event.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+
+namespace esphome::event {
+
+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

@@ -61,6 +61,8 @@ RESTORE_MODES = {
 }
 
 # Actions
+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 +83,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,8 +313,21 @@ 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_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_apply_action(
     "fan.turn_on",
@@ -349,16 +367,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,24 @@
 
 namespace esphome::fan {
 
+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 +68,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

esphome/components/fingerprint_grow/__init__.py

@@ -206,7 +206,7 @@ async def fingerprint_grow_enroll_to_code(config, action_id, template_arg, args)
     return var
 
 
-automation.register_parented_action(
+@automation.register_action(
     "fingerprint_grow.cancel_enroll",
     CancelEnrollmentAction,
     cv.Schema(
@@ -216,6 +216,10 @@ automation.register_parented_action(
     ),
     synchronous=True,
 )
+async def fingerprint_grow_cancel_enroll_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(
@@ -239,7 +243,7 @@ async def fingerprint_grow_delete_to_code(config, action_id, template_arg, args)
     return var
 
 
-automation.register_parented_action(
+@automation.register_action(
     "fingerprint_grow.delete_all",
     DeleteAllAction,
     cv.Schema(
@@ -249,6 +253,10 @@ automation.register_parented_action(
     ),
     synchronous=True,
 )
+async def fingerprint_grow_delete_all_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
 
 
 FINGERPRINT_GROW_LED_CONTROL_ACTION_SCHEMA = cv.maybe_simple_value(

esphome/components/grove_tb6612fng/__init__.py

@@ -126,7 +126,7 @@ async def grove_tb6612fng_stop_to_code(config, action_id, template_arg, args):
     return var
 
 
-automation.register_parented_action(
+@automation.register_action(
     "grove_tb6612fng.standby",
     GROVETB6612FNGMotorStandbyAction,
     cv.Schema(
@@ -136,9 +136,14 @@ automation.register_parented_action(
     ),
     synchronous=True,
 )
+async def grove_tb6612fng_standby_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_action(
+@automation.register_action(
     "grove_tb6612fng.no_standby",
     GROVETB6612FNGMotorNoStandbyAction,
     cv.Schema(
@@ -148,6 +153,11 @@ automation.register_parented_action(
     ),
     synchronous=True,
 )
+async def grove_tb6612fng_no_standby_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(

esphome/components/growatt_solar/sensor.py

@@ -22,7 +22,6 @@ from esphome.const import (
     UNIT_AMPERE,
     UNIT_CELSIUS,
     UNIT_HERTZ,
-    UNIT_KILOWATT_HOURS,
     UNIT_VOLT,
     UNIT_WATT,
 )
@@ -34,6 +33,7 @@ CONF_TOTAL_GENERATION_TIME = "total_generation_time"
 CONF_TODAY_GENERATION_TIME = "today_generation_time"
 CONF_PV1 = "pv1"
 CONF_PV2 = "pv2"
+UNIT_KILOWATT_HOURS = "kWh"
 UNIT_HOURS = "h"
 UNIT_KOHM = "kΩ"
 UNIT_MILLIAMPERE = "mA"

esphome/components/haier/automation.h

@@ -0,0 +1,128 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "haier_base.h"
+#include "hon_climate.h"
+
+namespace esphome::haier {
+
+template<typename... Ts> class DisplayOnAction final : public Action<Ts...> {
+ public:
+  DisplayOnAction(HaierClimateBase *parent) : parent_(parent) {}
+  void play(const Ts &...x) { this->parent_->set_display_state(true); }
+
+ protected:
+  HaierClimateBase *parent_;
+};
+
+template<typename... Ts> class DisplayOffAction final : public Action<Ts...> {
+ public:
+  DisplayOffAction(HaierClimateBase *parent) : parent_(parent) {}
+  void play(const Ts &...x) { this->parent_->set_display_state(false); }
+
+ protected:
+  HaierClimateBase *parent_;
+};
+
+template<typename... Ts> class BeeperOnAction final : public Action<Ts...> {
+ public:
+  BeeperOnAction(HonClimate *parent) : parent_(parent) {}
+  void play(const Ts &...x) { this->parent_->set_beeper_state(true); }
+
+ protected:
+  HonClimate *parent_;
+};
+
+template<typename... Ts> class BeeperOffAction final : public Action<Ts...> {
+ public:
+  BeeperOffAction(HonClimate *parent) : parent_(parent) {}
+  void play(const Ts &...x) { this->parent_->set_beeper_state(false); }
+
+ protected:
+  HonClimate *parent_;
+};
+
+template<typename... Ts> class VerticalAirflowAction final : public Action<Ts...> {
+ public:
+  VerticalAirflowAction(HonClimate *parent) : parent_(parent) {}
+  TEMPLATABLE_VALUE(hon_protocol::VerticalSwingMode, direction)
+  void play(const Ts &...x) { this->parent_->set_vertical_airflow(this->direction_.value(x...)); }
+
+ protected:
+  HonClimate *parent_;
+};
+
+template<typename... Ts> class HorizontalAirflowAction final : public Action<Ts...> {
+ public:
+  HorizontalAirflowAction(HonClimate *parent) : parent_(parent) {}
+  TEMPLATABLE_VALUE(hon_protocol::HorizontalSwingMode, direction)
+  void play(const Ts &...x) { this->parent_->set_horizontal_airflow(this->direction_.value(x...)); }
+
+ protected:
+  HonClimate *parent_;
+};
+
+template<typename... Ts> class HealthOnAction final : public Action<Ts...> {
+ public:
+  HealthOnAction(HaierClimateBase *parent) : parent_(parent) {}
+  void play(const Ts &...x) { this->parent_->set_health_mode(true); }
+
+ protected:
+  HaierClimateBase *parent_;
+};
+
+template<typename... Ts> class HealthOffAction final : public Action<Ts...> {
+ public:
+  HealthOffAction(HaierClimateBase *parent) : parent_(parent) {}
+  void play(const Ts &...x) { this->parent_->set_health_mode(false); }
+
+ protected:
+  HaierClimateBase *parent_;
+};
+
+template<typename... Ts> class StartSelfCleaningAction final : public Action<Ts...> {
+ public:
+  StartSelfCleaningAction(HonClimate *parent) : parent_(parent) {}
+  void play(const Ts &...x) { this->parent_->start_self_cleaning(); }
+
+ protected:
+  HonClimate *parent_;
+};
+
+template<typename... Ts> class StartSteriCleaningAction final : public Action<Ts...> {
+ public:
+  StartSteriCleaningAction(HonClimate *parent) : parent_(parent) {}
+  void play(const Ts &...x) { this->parent_->start_steri_cleaning(); }
+
+ protected:
+  HonClimate *parent_;
+};
+
+template<typename... Ts> class PowerOnAction final : public Action<Ts...> {
+ public:
+  PowerOnAction(HaierClimateBase *parent) : parent_(parent) {}
+  void play(const Ts &...x) { this->parent_->send_power_on_command(); }
+
+ protected:
+  HaierClimateBase *parent_;
+};
+
+template<typename... Ts> class PowerOffAction final : public Action<Ts...> {
+ public:
+  PowerOffAction(HaierClimateBase *parent) : parent_(parent) {}
+  void play(const Ts &...x) { this->parent_->send_power_off_command(); }
+
+ protected:
+  HaierClimateBase *parent_;
+};
+
+template<typename... Ts> class PowerToggleAction final : public Action<Ts...> {
+ public:
+  PowerToggleAction(HaierClimateBase *parent) : parent_(parent) {}
+  void play(const Ts &...x) { this->parent_->toggle_power(); }
+
+ protected:
+  HaierClimateBase *parent_;
+};
+
+}  // namespace esphome::haier

esphome/components/haier/climate.py

@@ -9,6 +9,7 @@ from esphome.const import (
     CONF_BEEPER,
     CONF_CURRENT_TEMPERATURE,
     CONF_DISPLAY,
+    CONF_ID,
     CONF_LEVEL,
     CONF_LOGGER,
     CONF_LOGS,
@@ -253,6 +254,23 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
+# Actions
+DisplayOnAction = haier_ns.class_("DisplayOnAction", automation.Action)
+DisplayOffAction = haier_ns.class_("DisplayOffAction", automation.Action)
+BeeperOnAction = haier_ns.class_("BeeperOnAction", automation.Action)
+BeeperOffAction = haier_ns.class_("BeeperOffAction", automation.Action)
+StartSelfCleaningAction = haier_ns.class_("StartSelfCleaningAction", automation.Action)
+StartSteriCleaningAction = haier_ns.class_(
+    "StartSteriCleaningAction", automation.Action
+)
+VerticalAirflowAction = haier_ns.class_("VerticalAirflowAction", automation.Action)
+HorizontalAirflowAction = haier_ns.class_("HorizontalAirflowAction", automation.Action)
+HealthOnAction = haier_ns.class_("HealthOnAction", automation.Action)
+HealthOffAction = haier_ns.class_("HealthOffAction", automation.Action)
+PowerOnAction = haier_ns.class_("PowerOnAction", automation.Action)
+PowerOffAction = haier_ns.class_("PowerOffAction", automation.Action)
+PowerToggleAction = haier_ns.class_("PowerToggleAction", automation.Action)
+
 HAIER_BASE_ACTION_SCHEMA = automation.maybe_simple_id(
     {
         cv.GenerateID(): cv.use_id(HaierClimateBase),
@@ -266,35 +284,62 @@ HAIER_HON_BASE_ACTION_SCHEMA = automation.maybe_simple_id(
 )
 
 
-for _name, _schema, _call in (
-    ("climate.haier.display_on", HAIER_BASE_ACTION_SCHEMA, "set_display_state(true)"),
-    ("climate.haier.display_off", HAIER_BASE_ACTION_SCHEMA, "set_display_state(false)"),
-    ("climate.haier.beeper_on", HAIER_HON_BASE_ACTION_SCHEMA, "set_beeper_state(true)"),
-    (
-        "climate.haier.beeper_off",
-        HAIER_HON_BASE_ACTION_SCHEMA,
-        "set_beeper_state(false)",
-    ),
-    (
-        "climate.haier.start_self_cleaning",
-        HAIER_HON_BASE_ACTION_SCHEMA,
-        "start_self_cleaning()",
-    ),
-    (
-        "climate.haier.start_steri_cleaning",
-        HAIER_HON_BASE_ACTION_SCHEMA,
-        "start_steri_cleaning()",
-    ),
-    ("climate.haier.health_on", HAIER_BASE_ACTION_SCHEMA, "set_health_mode(true)"),
-    ("climate.haier.health_off", HAIER_BASE_ACTION_SCHEMA, "set_health_mode(false)"),
-    ("climate.haier.power_on", HAIER_BASE_ACTION_SCHEMA, "send_power_on_command()"),
-    ("climate.haier.power_off", HAIER_BASE_ACTION_SCHEMA, "send_power_off_command()"),
-    ("climate.haier.power_toggle", HAIER_BASE_ACTION_SCHEMA, "toggle_power()"),
-):
-    automation.register_apply_action(_name, _schema, automation.ApplyCall(_call))
+@automation.register_action(
+    "climate.haier.display_on",
+    DisplayOnAction,
+    HAIER_BASE_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_action(
+    "climate.haier.display_off",
+    DisplayOffAction,
+    HAIER_BASE_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def display_action_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(
+    "climate.haier.beeper_on",
+    BeeperOnAction,
+    HAIER_HON_BASE_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_action(
+    "climate.haier.beeper_off",
+    BeeperOffAction,
+    HAIER_HON_BASE_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def beeper_action_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)
+
+
+# Start self cleaning or steri-cleaning action action
+@automation.register_action(
+    "climate.haier.start_self_cleaning",
+    StartSelfCleaningAction,
+    HAIER_HON_BASE_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_action(
+    "climate.haier.start_steri_cleaning",
+    StartSteriCleaningAction,
+    HAIER_HON_BASE_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def start_cleaning_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)
+
+
+# Set vertical airflow direction action
+@automation.register_action(
     "climate.haier.set_vertical_airflow",
+    VerticalAirflowAction,
     cv.Schema(
         {
             cv.GenerateID(): cv.use_id(HonClimate),
@@ -303,13 +348,22 @@ automation.register_apply_action(
             ),
         }
     ),
-    automation.ApplyField(
-        CONF_VERTICAL_AIRFLOW, "set_vertical_airflow", AirflowVerticalDirection
-    ),
+    synchronous=True,
 )
+async def haier_set_vertical_airflow_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)
+    template_ = await cg.templatable(
+        config[CONF_VERTICAL_AIRFLOW], args, AirflowVerticalDirection
+    )
+    cg.add(var.set_direction(template_))
+    return var
 
-automation.register_apply_action(
+
+# Set horizontal airflow direction action
+@automation.register_action(
     "climate.haier.set_horizontal_airflow",
+    HorizontalAirflowAction,
     cv.Schema(
         {
             cv.GenerateID(): cv.use_id(HonClimate),
@@ -318,10 +372,56 @@ automation.register_apply_action(
             ),
         }
     ),
-    automation.ApplyField(
-        CONF_HORIZONTAL_AIRFLOW, "set_horizontal_airflow", AirflowHorizontalDirection
-    ),
+    synchronous=True,
 )
+async def haier_set_horizontal_airflow_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)
+    template_ = await cg.templatable(
+        config[CONF_HORIZONTAL_AIRFLOW], args, AirflowHorizontalDirection
+    )
+    cg.add(var.set_direction(template_))
+    return var
+
+
+@automation.register_action(
+    "climate.haier.health_on",
+    HealthOnAction,
+    HAIER_BASE_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_action(
+    "climate.haier.health_off",
+    HealthOffAction,
+    HAIER_BASE_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def health_action_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(
+    "climate.haier.power_on",
+    PowerOnAction,
+    HAIER_BASE_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_action(
+    "climate.haier.power_off",
+    PowerOffAction,
+    HAIER_BASE_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_action(
+    "climate.haier.power_toggle",
+    PowerToggleAction,
+    HAIER_BASE_ACTION_SCHEMA,
+    synchronous=True,
+)
+async def power_action_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)
 
 
 def _final_validate(config) -> None:

esphome/components/havells_solar/sensor.py

@@ -23,7 +23,6 @@ from esphome.const import (
     UNIT_AMPERE,
     UNIT_DEGREES,
     UNIT_HERTZ,
-    UNIT_KILOWATT_HOURS,
     UNIT_MINUTE,
     UNIT_VOLT,
     UNIT_VOLT_AMPS_REACTIVE,
@@ -37,6 +36,7 @@ CONF_TOTAL_GENERATION_TIME = "total_generation_time"
 CONF_TODAY_GENERATION_TIME = "today_generation_time"
 CONF_PV1 = "pv1"
 CONF_PV2 = "pv2"
+UNIT_KILOWATT_HOURS = "kWh"
 UNIT_HOURS = "h"
 UNIT_KOHM = "kΩ"
 UNIT_MILLIAMPERE = "mA"

esphome/components/hbridge/fan/__init__.py

@@ -7,11 +7,14 @@ import esphome.config_validation as cv
 from esphome.const import (
     CONF_DECAY_MODE,
     CONF_ENABLE_PIN,
+    CONF_ID,
     CONF_PIN_A,
     CONF_PIN_B,
     CONF_PRESET_MODES,
     CONF_SPEED_COUNT,
 )
+from esphome.core import ID
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 from .. import hbridge_ns
@@ -39,7 +42,7 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_DECAY_MODE, default="SLOW"): cv.enum(
                 DECAY_MODE_OPTIONS, upper=True
             ),
-            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1, max=255),
+            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1),
             cv.Optional(CONF_ENABLE_PIN): cv.use_id(output.FloatOutput),
             cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
         }
@@ -48,12 +51,20 @@ CONFIG_SCHEMA = (
 )
 
 
-automation.register_simple_action(
+@automation.register_action(
     "fan.hbridge.brake",
     BrakeAction,
     maybe_simple_id({cv.GenerateID(): cv.use_id(HBridgeFan)}),
     synchronous=True,
 )
+async def fan_hbridge_brake_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)
 
 
 async def to_code(config: ConfigType) -> None:

esphome/components/hbridge/fan/hbridge_fan.h

@@ -14,7 +14,7 @@ enum DecayMode {
 
 class HBridgeFan final : public Component, public fan::Fan {
  public:
-  HBridgeFan(uint8_t speed_count, DecayMode decay_mode) : speed_count_(speed_count), decay_mode_(decay_mode) {}
+  HBridgeFan(int speed_count, DecayMode decay_mode) : speed_count_(speed_count), decay_mode_(decay_mode) {}
 
   void set_pin_a(output::FloatOutput *pin_a) { pin_a_ = pin_a; }
   void set_pin_b(output::FloatOutput *pin_b) { pin_b_ = pin_b; }
@@ -35,7 +35,7 @@ class HBridgeFan final : public Component, public fan::Fan {
   output::FloatOutput *pin_b_;
   output::FloatOutput *enable_{nullptr};
   output::BinaryOutput *oscillating_{nullptr};
-  uint8_t speed_count_{};
+  int speed_count_{};
   DecayMode decay_mode_{DECAY_MODE_SLOW};
   fan::FanTraits traits_;
 

esphome/components/hdc302x/sensor.py

@@ -139,9 +139,18 @@ async def hdc302x_heater_on_to_code(
     return var
 
 
-automation.register_parented_action(
+@automation.register_action(
     "hdc302x.heater_off",
     HeaterOffAction,
     HDC302X_ACTION_SCHEMA,
     synchronous=True,
 )
+async def hdc302x_heater_off_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

esphome/components/heatpumpir/heatpumpir.cpp

@@ -187,7 +187,7 @@ void HeatpumpIRClimate::transmit_state() {
     swing_h_cmd = HDIR_SWING;
   }
 
-  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_AUTO)) {
     case climate::CLIMATE_FAN_LOW:
       fan_speed_cmd = FAN_2;
       break;

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -118,7 +118,7 @@ void IDFI2CBus::dump_config() {
         if (s.second) {
           ESP_LOGCONFIG(TAG, "Found device at address 0x%02X", s.first);
         } else {
-          ESP_LOGCONFIG(TAG, "Unknown error at address 0x%02X", s.first);
+          ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
         }
       }
     }

esphome/components/ina2xx_base/__init__.py

@@ -24,7 +24,6 @@ from esphome.const import (
     STATE_CLASS_TOTAL_INCREASING,
     UNIT_AMPERE,
     UNIT_CELSIUS,
-    UNIT_MILLIVOLT,
     UNIT_VOLT,
     UNIT_WATT,
     UNIT_WATT_HOURS,
@@ -45,6 +44,7 @@ CONF_TEMPERATURE_COEFFICIENT = "temperature_coefficient"
 CONF_RESET_ON_BOOT = "reset_on_boot"
 UNIT_COULOMB = "C"
 UNIT_JOULE = "J"
+UNIT_MILLIVOLT = "mV"
 
 ina2xx_base_ns = cg.esphome_ns.namespace("ina2xx_base")
 INA2XX = ina2xx_base_ns.class_("INA2XX", cg.PollingComponent)

esphome/components/integration/integration_sensor.h

@@ -71,4 +71,16 @@ class IntegrationSensor final : public sensor::Sensor, public Component {
   float last_value_{0.0f};
 };
 
+template<typename... Ts> class ResetAction final : public Action<Ts...>, public Parented<IntegrationSensor> {
+ public:
+  void play(const Ts &...x) override { this->parent_->reset(); }
+};
+
+template<typename... Ts> class SetValueAction final : public Action<Ts...>, public Parented<IntegrationSensor> {
+ public:
+  TEMPLATABLE_VALUE(float, value)
+
+  void play(const Ts &...x) override { this->parent_->set_value(this->value_.value(x...)); }
+};
+
 }  // namespace esphome::integration

esphome/components/integration/sensor.py

@@ -11,13 +11,17 @@ from esphome.const import (
     CONF_UNIT_OF_MEASUREMENT,
     CONF_VALUE,
 )
+from esphome.core import ID
 from esphome.core.entity_helpers import inherit_property_from
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 integration_ns = cg.esphome_ns.namespace("integration")
 IntegrationSensor = integration_ns.class_(
     "IntegrationSensor", sensor.Sensor, cg.Component
 )
+ResetAction = integration_ns.class_("ResetAction", automation.Action)
+SetValueAction = integration_ns.class_("SetValueAction", automation.Action)
 
 IntegrationSensorTime = integration_ns.enum("IntegrationSensorTime")
 INTEGRATION_TIMES = {
@@ -102,23 +106,46 @@ async def to_code(config: ConfigType) -> None:
     cg.add(var.set_restore(config[CONF_RESTORE]))
 
 
-automation.register_apply_action(
+@automation.register_action(
     "sensor.integration.reset",
+    ResetAction,
     automation.maybe_simple_id(
         {
             cv.Required(CONF_ID): cv.use_id(IntegrationSensor),
         }
     ),
-    automation.ApplyCall("reset()"),
+    synchronous=True,
 )
+async def sensor_integration_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_apply_action(
+
+@automation.register_action(
     "sensor.integration.set_value",
+    SetValueAction,
     cv.Schema(
         {
             cv.Required(CONF_ID): cv.use_id(IntegrationSensor),
             cv.Required(CONF_VALUE): cv.templatable(cv.float_),
         }
     ),
-    automation.ApplyField(CONF_VALUE, "set_value", cg.float_),
+    synchronous=True,
 )
+async def sensor_integration_set_value_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])
+    template_ = await cg.templatable(config[CONF_VALUE], args, cg.float_)
+    cg.add(var.set_value(template_))
+    return var

esphome/components/key_collector/__init__.py

@@ -15,6 +15,7 @@ from esphome.const import (
     CONF_TIMEOUT,
     CONF_TRIGGER_ID,
 )
+from esphome.core import ID
 from esphome.cpp_generator import MockObj, literal
 from esphome.types import ConfigType, TemplateArgsType
 
@@ -134,7 +135,7 @@ async def to_code(config: ConfigType) -> None:
     cg.add(var.set_enabled(config[CONF_ENABLE_ON_BOOT]))
 
 
-automation.register_parented_action(
+@automation.register_action(
     "key_collector.enable",
     EnableAction,
     automation.maybe_simple_id(
@@ -144,9 +145,18 @@ automation.register_parented_action(
     ),
     synchronous=True,
 )
+async def enable_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(
     "key_collector.disable",
     DisableAction,
     automation.maybe_simple_id(
@@ -156,3 +166,12 @@ automation.register_parented_action(
     ),
     synchronous=True,
 )
+async def disable_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

esphome/components/ld24xx/ld24xx.h

@@ -31,9 +31,6 @@
 
 namespace esphome::ld24xx {
 
-/// Parse a little-endian 16-bit unsigned value from two bytes.
-static constexpr uint16_t two_byte_to_uint16(uint8_t low, uint8_t high) { return ((uint16_t) high << 8) | low; }
-
 // Helper to find index of value in constexpr array
 template<size_t N> optional<size_t> find_index(const uint32_t (&arr)[N], uint32_t value) {
   for (size_t i = 0; i < N; i++) {

esphome/components/light/__init__.py

@@ -343,7 +343,6 @@ RESTORE_MODES = {
 # Schema default that also matches the C++ initializer in light_state.h; codegen
 # skips the setter when the config equals it.
 DEFAULT_FLASH_TRANSITION_LENGTH = "0s"
-CONF_TRANSITION_STATE_PUBLISH_INTERVAL = "transition_state_publish_interval"
 
 LIGHT_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
@@ -394,11 +393,6 @@ BRIGHTNESS_ONLY_LIGHT_SCHEMA = LIGHT_SCHEMA.extend(
         cv.Optional(
             CONF_FLASH_TRANSITION_LENGTH, default=DEFAULT_FLASH_TRANSITION_LENGTH
         ): cv.positive_time_period_milliseconds,
-        # Below 150ms a device cannot publish any faster and only spends CPU and traffic
-        cv.Optional(CONF_TRANSITION_STATE_PUBLISH_INTERVAL): cv.All(
-            cv.positive_time_period_milliseconds,
-            cv.Range(min=cv.TimePeriod(milliseconds=150)),
-        ),
         cv.Optional(CONF_EFFECTS): validate_effects(MONOCHROMATIC_EFFECTS),
     }
 )
@@ -412,11 +406,6 @@ RGB_LIGHT_SCHEMA = BRIGHTNESS_ONLY_LIGHT_SCHEMA.extend(
 ADDRESSABLE_LIGHT_SCHEMA = RGB_LIGHT_SCHEMA.extend(
     {
         cv.GenerateID(): cv.declare_id(AddressableLightState),
-        # The addressable transformer writes the LED buffer directly, so there is no
-        # intermediate state to publish
-        cv.Optional(CONF_TRANSITION_STATE_PUBLISH_INTERVAL): cv.invalid(
-            "transition_state_publish_interval is not supported on addressable lights"
-        ),
         cv.Optional(CONF_EFFECTS): validate_effects(ADDRESSABLE_EFFECTS),
         cv.Optional(CONF_COLOR_CORRECT): cv.All(
             [cv.percentage], cv.Length(min=3, max=4)
@@ -524,10 +513,6 @@ async def setup_light_core_(light_var, config, output_var):
         DEFAULT_FLASH_TRANSITION_LENGTH
     ):
         cg.add(light_var.set_flash_transition_length(flash_transition_length))
-    # Setting an interval opts this light in and compiles the feature in
-    if (interval := config.get(CONF_TRANSITION_STATE_PUBLISH_INTERVAL)) is not None:
-        cg.add(light_var.set_transition_state_publish_interval(interval))
-        cg.add_define("USE_LIGHT_TRANSITION_PUBLISH_INTERVAL")
     if (gamma_correct := config.get(CONF_GAMMA_CORRECT)) is not None:
         cg.add(light_var.set_gamma_correct(gamma_correct))
         fwd_arr = _get_or_create_gamma_table(gamma_correct)

esphome/components/light/automation.h

@@ -117,6 +117,23 @@ template<bool Forward, typename... Ts> class LightEffectCycleAction final : publ
   bool include_none_{false};
 };
 
+template<typename... Ts> class LightIsOnCondition final : public Condition<Ts...> {
+ public:
+  explicit LightIsOnCondition(LightState *state) : state_(state) {}
+  bool check(const Ts &...x) override { return this->state_->current_values.is_on(); }
+
+ protected:
+  LightState *state_;
+};
+template<typename... Ts> class LightIsOffCondition final : public Condition<Ts...> {
+ public:
+  explicit LightIsOffCondition(LightState *state) : state_(state) {}
+  bool check(const Ts &...x) override { return !this->state_->current_values.is_on(); }
+
+ protected:
+  LightState *state_;
+};
+
 class LightTurnOnTrigger final : public Trigger<>, public LightRemoteValuesListener {
  public:
   explicit LightTurnOnTrigger(LightState *a_light) : light_(a_light) {

esphome/components/light/automation.py

@@ -38,6 +38,8 @@ from .types import (
     ColorMode,
     DimRelativeAction,
     LightEffectCycleAction,
+    LightIsOffCondition,
+    LightIsOnCondition,
     LightState,
     ToggleAction,
 )
@@ -379,15 +381,24 @@ async def light_addressable_set_to_code(config, action_id, template_arg, args):
     return var
 
 
-LIGHT_CONDITION_SCHEMA = automation.maybe_simple_id(
-    {
-        cv.Required(CONF_ID): cv.use_id(LightState),
-    }
+@automation.register_condition(
+    "light.is_on",
+    LightIsOnCondition,
+    automation.maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(LightState),
+        }
+    ),
 )
-
-automation.register_apply_condition(
-    "light.is_on", LIGHT_CONDITION_SCHEMA, "current_values.is_on()"
-)
-automation.register_apply_condition(
-    "light.is_off", LIGHT_CONDITION_SCHEMA, "current_values.is_on() == false"
+@automation.register_condition(
+    "light.is_off",
+    LightIsOffCondition,
+    automation.maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(LightState),
+        }
+    ),
 )
+async def light_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)

esphome/components/light/light_json_schema.cpp

@@ -32,7 +32,7 @@ void LightJSONSchema::dump_json(LightState &state, JsonObject root) {
     root[ESPHOME_F("effect_count")] = state.get_effect_count();
   }
 
-  auto values = state.get_reported_values();
+  auto values = state.remote_values;
 
   const auto color_mode = values.get_color_mode();
   const auto *mode_str = get_color_mode_json_str(color_mode);
@@ -131,13 +131,6 @@ void LightJSONSchema::parse_color_json(LightState &state, LightCall &call, JsonO
     call.set_white(float(root[ESPHOME_F("white_value")]) / 255.0f);
   }
 
-  if (root[ESPHOME_F("white")].is<uint8_t>()) {
-    // White stays full because ESPHome multiplies brightness and white
-    call.set_color_mode_if_supported(ColorMode::WHITE);
-    call.set_brightness(float(root[ESPHOME_F("white")]) / 255.0f);
-    call.set_white(1.0f);
-  }
-
   if (root[ESPHOME_F("color_temp")].is<uint16_t>()) {
     call.set_color_temperature(float(root[ESPHOME_F("color_temp")]));
   }

esphome/components/light/light_state.cpp

@@ -1,9 +1,6 @@
 #include "light_state.h"
 #include "esp_color_correction.h"
 #include "esphome/core/defines.h"
-#ifdef USE_LIGHT_TRANSITION_PUBLISH_INTERVAL
-#include "esphome/core/application.h"
-#endif
 #include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
 #include "light_output.h"
@@ -108,13 +105,6 @@ void LightState::dump_config() {
                   "  Default Transition Length: %.1fs\n"
                   "  Gamma Correct: %.2f",
                   this->default_transition_length_ / 1e3f, this->gamma_correct_);
-#ifdef USE_LIGHT_TRANSITION_PUBLISH_INTERVAL
-    // The define is build wide; only lights that set the option have an interval
-    if (this->transition_state_publish_interval_ != 0) {
-      ESP_LOGCONFIG(TAG, "  Transition State Publish Interval: %" PRIu32 "ms",
-                    this->transition_state_publish_interval_);
-    }
-#endif
   }
   if (traits.supports_color_capability(ColorCapability::COLOR_TEMPERATURE)) {
     ESP_LOGCONFIG(TAG,
@@ -140,30 +130,13 @@ void LightState::loop() {
       this->next_write_ = true;
     }
 
-    const bool finished = this->transformer_->is_finished();
-#ifdef USE_LIGHT_TRANSITION_PUBLISH_INTERVAL
-    if (this->transition_publish_enabled_ && !finished) {
-      const uint32_t now = App.get_loop_component_start_time();
-      if (now - this->last_transition_state_publish_ >= this->transition_state_publish_interval_) {
-        this->publish_state();
-        this->last_transition_state_publish_ = now;
-      }
-    }
-#endif
-
-    if (finished) {
+    if (this->transformer_->is_finished()) {
       // if the transition has written directly to the output, current_values is outdated, so update it
       this->current_values = this->transformer_->get_target_values();
+
       this->transformer_->stop();
       this->is_transformer_active_ = false;
       this->transformer_ = nullptr;
-#ifdef USE_LIGHT_TRANSITION_PUBLISH_INTERVAL
-      if (this->transition_publish_enabled_) {
-        // Report the end state from remote_values; a flash's stop() left publishing to us
-        this->transition_publish_enabled_ = false;
-        this->publish_state();
-      }
-#endif
       if (this->target_state_reached_listeners_) {
         for (auto *listener : *this->target_state_reached_listeners_) {
           listener->on_light_target_state_reached();
@@ -375,7 +348,10 @@ void LightState::stop_effect_() {
 void LightState::start_transition_(const LightColorValues &target, uint32_t length, bool set_remote_values) {
   this->transformer_ = this->output_->create_default_transition();
   this->transformer_->setup(this->current_values, target, length);
-  this->set_transformer_remote_values_(target, set_remote_values);
+
+  if (set_remote_values) {
+    this->remote_values = target;
+  }
   // Enable loop while transition is active
   this->enable_loop();
 }
@@ -389,7 +365,10 @@ void LightState::start_flash_(const LightColorValues &target, uint32_t length, b
 
   this->transformer_ = make_unique<LightFlashTransformer>(*this);
   this->transformer_->setup(end_colors, target, length);
-  this->set_transformer_remote_values_(target, set_remote_values);
+
+  if (set_remote_values) {
+    this->remote_values = target;
+  };
   // Enable loop while flash is active
   this->enable_loop();
 }
@@ -397,9 +376,6 @@ void LightState::start_flash_(const LightColorValues &target, uint32_t length, b
 void LightState::set_immediately_(const LightColorValues &target, bool set_remote_values) {
   this->is_transformer_active_ = false;
   this->transformer_ = nullptr;
-#ifdef USE_LIGHT_TRANSITION_PUBLISH_INTERVAL
-  this->transition_publish_enabled_ = false;
-#endif
   this->current_values = target;
   if (set_remote_values) {
     this->remote_values = target;
@@ -415,18 +391,6 @@ void LightState::disable_loop_if_idle_() {
   }
 }
 
-#ifdef USE_LIGHT_TRANSITION_PUBLISH_INTERVAL
-void LightState::set_transformer_remote_values_(const LightColorValues &target, bool set_remote_values) {
-  this->transition_publish_enabled_ = set_remote_values && this->transition_state_publish_interval_ > 0;
-  if (this->transition_publish_enabled_) {
-    this->last_transition_state_publish_ = App.get_loop_component_start_time();
-  }
-  if (set_remote_values) {
-    this->remote_values = target;
-  }
-}
-#endif
-
 void LightState::save_remote_values_() {
   LightStateRTCState saved;
   saved.color_mode = this->remote_values.get_color_mode();

esphome/components/light/light_state.h

@@ -100,21 +100,6 @@ class LightState : public EntityBase, public Component {
   LightCall turn_on();
   LightCall turn_off();
   LightCall toggle();
-
-  /// The values reported to the frontend: current_values while a light publishes intermediate
-  /// states on an interval, otherwise remote_values. Each interval sample is a publish_state(),
-  /// so on_state automations run on every sample as well.
-  const LightColorValues &get_reported_values() const {
-#ifdef USE_LIGHT_TRANSITION_PUBLISH_INTERVAL
-    if (this->transition_publish_enabled_) {
-      return this->current_values;
-    }
-#endif
-    return this->remote_values;
-  }
-
-  /// True from the call that starts a transition or flash until it reaches its target.
-  bool is_transitioning() const { return this->transformer_ != nullptr; }
   LightCall make_call();
 
   // ========== INTERNAL METHODS ==========
@@ -187,13 +172,6 @@ class LightState : public EntityBase, public Component {
   void set_gamma_correct(float gamma_correct) { this->gamma_correct_ = gamma_correct; }
   float get_gamma_correct() const { return this->gamma_correct_; }
 
-#ifdef USE_LIGHT_TRANSITION_PUBLISH_INTERVAL
-  void set_transition_state_publish_interval(uint32_t transition_state_publish_interval) {
-    this->transition_state_publish_interval_ = transition_state_publish_interval;
-  }
-  uint32_t get_transition_state_publish_interval() const { return this->transition_state_publish_interval_; }
-#endif
-
 #ifdef USE_LIGHT_GAMMA_LUT
   /// Set pre-computed gamma forward lookup table (256-entry uint16 PROGMEM array)
   void set_gamma_table(const uint16_t *forward) { this->gamma_table_ = forward; }
@@ -313,7 +291,6 @@ class LightState : public EntityBase, public Component {
   friend LightOutput;
   friend LightCall;
   friend class AddressableLight;
-  friend class LightFlashTransformer;
 
   /// Internal method to start an effect with the given index
   void start_effect_(uint32_t effect_index);
@@ -330,18 +307,6 @@ class LightState : public EntityBase, public Component {
   /// Internal method to set the color values to target immediately (with no transition).
   void set_immediately_(const LightColorValues &target, bool set_remote_values);
 
-  /// Point remote_values at the new transformer's target and, when this light publishes
-  /// intermediate states on an interval, start the interval clock.
-#ifdef USE_LIGHT_TRANSITION_PUBLISH_INTERVAL
-  void set_transformer_remote_values_(const LightColorValues &target, bool set_remote_values);
-#else
-  void set_transformer_remote_values_(const LightColorValues &target, bool set_remote_values) {
-    if (set_remote_values) {
-      this->remote_values = target;
-    }
-  }
-#endif
-
   /// Internal method to save the current remote_values to the preferences
   void save_remote_values_();
 
@@ -392,10 +357,6 @@ class LightState : public EntityBase, public Component {
   uint32_t default_transition_length_{};
   /// Transition length to use for flash transitions.
   uint32_t flash_transition_length_{};  // Keep in sync with DEFAULT_FLASH_TRANSITION_LENGTH in __init__.py
-#ifdef USE_LIGHT_TRANSITION_PUBLISH_INTERVAL
-  uint32_t transition_state_publish_interval_{0};
-  uint32_t last_transition_state_publish_{0};
-#endif
   /// Gamma correction factor for the light.
   float gamma_correct_{};
 #ifdef USE_LIGHT_GAMMA_LUT
@@ -406,10 +367,6 @@ class LightState : public EntityBase, public Component {
   bool next_write_{true};
   // for effects, true if a transformer (transition) is active.
   bool is_transformer_active_{false};
-#ifdef USE_LIGHT_TRANSITION_PUBLISH_INTERVAL
-  /// True while the active transformer publishes current_values on an interval from loop().
-  bool transition_publish_enabled_{false};
-#endif
   /// Restore mode of the light.
   LightRestoreMode restore_mode_;
 };

esphome/components/light/transformers.h

@@ -105,11 +105,6 @@ class LightFlashTransformer : public LightTransformer {
     }
     this->state_.current_values = this->get_start_values();
     this->state_.remote_values = this->get_start_values();
-#ifdef USE_LIGHT_TRANSITION_PUBLISH_INTERVAL
-    // The light reports the end state itself once the transformer finishes
-    if (this->state_.transition_publish_enabled_)
-      return;
-#endif
     this->state_.publish_state();
   }
 

esphome/components/light/types.py

@@ -44,6 +44,8 @@ ToggleAction = light_ns.class_("ToggleAction", automation.Action)
 LightEffectCycleAction = light_ns.class_("LightEffectCycleAction", automation.Action)
 DimRelativeAction = light_ns.class_("DimRelativeAction", automation.Action)
 AddressableSet = light_ns.class_("AddressableSet", automation.Action)
+LightIsOnCondition = light_ns.class_("LightIsOnCondition", automation.Condition)
+LightIsOffCondition = light_ns.class_("LightIsOffCondition", automation.Condition)
 
 # Triggers
 LightTurnOnTrigger = light_ns.class_(

esphome/components/lock/__init__.py

@@ -1,5 +1,5 @@
 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
@@ -12,13 +12,13 @@ from esphome.const import (
     CONF_ON_UNLOCK,
     CONF_WEB_SERVER,
 )
-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 = ["@esphome/core"]
@@ -29,8 +29,12 @@ Lock = lock_ns.class_("Lock", cg.EntityBase)
 LockPtr = Lock.operator("ptr")
 LockCall = lock_ns.class_("LockCall")
 
+UnlockAction = lock_ns.class_("UnlockAction", automation.Action)
+LockAction = lock_ns.class_("LockAction", automation.Action)
+OpenAction = lock_ns.class_("OpenAction", automation.Action)
 LockPublishAction = lock_ns.class_("LockPublishAction", automation.Action)
 
+LockCondition = lock_ns.class_("LockCondition", Condition)
 LockStateForwarder = lock_ns.class_("LockStateForwarder")
 
 LockState = lock_ns.enum("LockState")
@@ -131,24 +135,45 @@ LOCK_ACTION_SCHEMA = maybe_simple_id(
 )
 
 
-for _name, _call in (
-    ("lock.unlock", "unlock()"),
-    ("lock.lock", "lock()"),
-    ("lock.open", "open()"),
-):
-    automation.register_apply_action(
-        _name, LOCK_ACTION_SCHEMA, automation.ApplyCall(_call)
-    )
+@automation.register_action(
+    "lock.unlock", UnlockAction, LOCK_ACTION_SCHEMA, synchronous=True
+)
+@automation.register_action(
+    "lock.lock", LockAction, LOCK_ACTION_SCHEMA, synchronous=True
+)
+@automation.register_action(
+    "lock.open", OpenAction, LOCK_ACTION_SCHEMA, synchronous=True
+)
+async def lock_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_apply_condition(
-    "lock.is_locked", LOCK_ACTION_SCHEMA, f"state == {LockState.LOCK_STATE_LOCKED}"
-)
-automation.register_apply_condition(
-    "lock.is_unlocked",
-    LOCK_ACTION_SCHEMA,
-    f"state == {LockState.LOCK_STATE_UNLOCKED}",
-)
+@automation.register_condition("lock.is_locked", LockCondition, LOCK_ACTION_SCHEMA)
+async def lock_is_on_to_code(
+    config: ConfigType,
+    condition_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren, True)
+
+
+@automation.register_condition("lock.is_unlocked", LockCondition, LOCK_ACTION_SCHEMA)
+async def lock_is_off_to_code(
+    config: ConfigType,
+    condition_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren, False)
 
 
 @coroutine_with_priority(CoroPriority.CORE)

esphome/components/lock/automation.h

@@ -6,6 +6,49 @@
 
 namespace esphome::lock {
 
+template<typename... Ts> class LockAction final : public Action<Ts...> {
+ public:
+  explicit LockAction(Lock *a_lock) : lock_(a_lock) {}
+
+  void play(const Ts &...x) override { this->lock_->lock(); }
+
+ protected:
+  Lock *lock_;
+};
+
+template<typename... Ts> class UnlockAction final : public Action<Ts...> {
+ public:
+  explicit UnlockAction(Lock *a_lock) : lock_(a_lock) {}
+
+  void play(const Ts &...x) override { this->lock_->unlock(); }
+
+ protected:
+  Lock *lock_;
+};
+
+template<typename... Ts> class OpenAction final : public Action<Ts...> {
+ public:
+  explicit OpenAction(Lock *a_lock) : lock_(a_lock) {}
+
+  void play(const Ts &...x) override { this->lock_->open(); }
+
+ protected:
+  Lock *lock_;
+};
+
+template<typename... Ts> class LockCondition final : public Condition<Ts...> {
+ public:
+  LockCondition(Lock *parent, bool state) : parent_(parent), state_(state) {}
+  bool check(const Ts &...x) override {
+    auto check_state = this->state_ ? LockState::LOCK_STATE_LOCKED : LockState::LOCK_STATE_UNLOCKED;
+    return this->parent_->state == check_state;
+  }
+
+ protected:
+  Lock *parent_;
+  bool state_;
+};
+
 /// Callback forwarder that triggers an Automation<> only when a specific lock state is entered.
 /// Pointer-sized (single Automation* field) to fit inline in Callback::ctx_.
 template<LockState State> struct LockStateForwarder {

esphome/components/lock/lock.h

@@ -32,6 +32,9 @@ enum LockState : uint8_t {
 };
 const LogString *lock_state_to_string(LockState state);
 
+/// Maximum length of lock state string (including null terminator): "UNLOCKING" = 10
+static constexpr size_t LOCK_STATE_STR_SIZE = 10;
+
 class LockTraits {
  public:
   LockTraits() = default;

esphome/components/logger/__init__.py

@@ -1,4 +1,3 @@
-import logging
 import re
 from typing import Any
 
@@ -64,8 +63,6 @@ from esphome.core import CORE, ID, CoroPriority, Lambda, coroutine_with_priority
 from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
-_LOGGER = logging.getLogger(__name__)
-
 CODEOWNERS = ["@esphome/core"]
 logger_ns = cg.esphome_ns.namespace("logger")
 LOG_LEVELS = {
@@ -108,7 +105,6 @@ DEFAULT = "DEFAULT"
 
 CONF_INITIAL_LEVEL = "initial_level"
 CONF_LOGGER_ID = "logger_id"
-CONF_ESP8266_STORE_LOG_STRINGS_IN_FLASH = "esp8266_store_log_strings_in_flash"
 CONF_RUNTIME_TAG_LEVELS = "runtime_tag_levels"
 CONF_TASK_LOG_BUFFER_SIZE = "task_log_buffer_size"
 CONF_WAIT_FOR_CDC = "wait_for_cdc"
@@ -223,18 +219,6 @@ def validate_initial_no_higher_than_global(config: ConfigType) -> ConfigType:
     return config
 
 
-def warn_ram_log_strings(config: ConfigType) -> ConfigType:
-    # Remove before 2027.4.0
-    if config.get(CONF_ESP8266_STORE_LOG_STRINGS_IN_FLASH) is False:
-        _LOGGER.warning(
-            "'%s: false' is ignored and will be rejected in 2027.4.0. Log format strings "
-            "always stay in flash now; copying them into RAM gave no speed gain and the "
-            "lost RAM caused crashes. Remove the option",
-            CONF_ESP8266_STORE_LOG_STRINGS_IN_FLASH,
-        )
-    return config
-
-
 def validate_wait_for_cdc(config: ConfigType) -> ConfigType:
     if config.get(CONF_WAIT_FOR_CDC) and config.get(CONF_HARDWARE_UART) != USB_CDC:
         raise cv.Invalid("wait_for_cdc requires hardware_uart: USB_CDC")
@@ -248,6 +232,7 @@ LoggerMessageTrigger = logger_ns.class_(
 )
 
 
+CONF_ESP8266_STORE_LOG_STRINGS_IN_FLASH = "esp8266_store_log_strings_in_flash"
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
@@ -347,7 +332,6 @@ CONFIG_SCHEMA = cv.All(
     validate_local_no_higher_than_global,
     validate_initial_no_higher_than_global,
     validate_wait_for_cdc,
-    warn_ram_log_strings,
 )
 
 
@@ -466,6 +450,9 @@ async def _late_logger_init(config: ConfigType) -> None:
         cg.add_build_flag("-DCORE_DEBUG_LEVEL=5")
     if CORE.is_esp32 and is_at_least_very_verbose:
         cg.add_build_flag("-DENABLE_I2C_DEBUG_BUFFER")
+    if config.get(CONF_ESP8266_STORE_LOG_STRINGS_IN_FLASH):
+        cg.add_build_flag("-DUSE_STORE_LOG_STR_IN_FLASH")
+
     if CORE.is_esp32:
         if config[CONF_HARDWARE_UART] == USB_CDC:
             add_idf_sdkconfig_option("CONFIG_ESP_CONSOLE_USB_CDC", True)

esphome/components/logger/log_buffer.h

@@ -105,9 +105,9 @@ struct LogBuffer {
     this->format_vsnprintf_(format, args);
     this->finalize_();
   }
-#ifdef USE_ESP8266
-  void HOT format_body_p(PGM_P format, va_list args) {
-    this->format_vsnprintf_p_(format, args);
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+  void HOT format_body_P(PGM_P format, va_list args) {
+    this->format_vsnprintf_P_(format, args);
     this->finalize_();
   }
 #endif
@@ -158,8 +158,8 @@ struct LogBuffer {
       return;
     this->process_vsnprintf_result_(vsnprintf(this->current_(), this->remaining_(), format, args));
   }
-#ifdef USE_ESP8266
-  void format_vsnprintf_p_(PGM_P format, va_list args) {
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+  void format_vsnprintf_P_(PGM_P format, va_list args) {
     if (this->full_())
       return;
     this->process_vsnprintf_result_(vsnprintf_P(this->current_(), this->remaining_(), format, args));

esphome/components/logger/logger.cpp

@@ -127,8 +127,9 @@ void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const ch
 }
 #endif  // USE_ESP32 || USE_HOST || USE_LIBRETINY || USE_ZEPHYR
 
-#ifdef USE_ESP8266
-// ESP8266 keeps log format strings in flash.
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+// Implementation for ESP8266 with flash string support.
+// Note: USE_STORE_LOG_STR_IN_FLASH is only defined for ESP8266.
 //
 // This function handles format strings stored in flash memory (PROGMEM) to save RAM.
 // Uses vsnprintf_P to read the format string directly from flash without copying to RAM.
@@ -140,7 +141,7 @@ void Logger::log_vprintf_(uint8_t level, const char *tag, int line, const __Flas
 
   this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args, nullptr);
 }
-#endif  // USE_ESP8266
+#endif  // USE_STORE_LOG_STR_IN_FLASH
 
 inline uint8_t Logger::level_for(const char *tag) {
 #ifdef USE_LOGGER_RUNTIME_TAG_LEVELS

esphome/components/logger/logger.h

@@ -200,9 +200,9 @@ class Logger final : public Component {
   float get_setup_priority() const override { return setup_priority::BUS + 500.0f; }
 
   void log_vprintf_(uint8_t level, const char *tag, int line, const char *format, va_list args);  // NOLINT
-#ifdef USE_ESP8266
-  // NOLINTNEXTLINE(readability-identifier-naming)
-  void log_vprintf_(uint8_t level, const char *tag, int line, const __FlashStringHelper *format, va_list args);
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+  void log_vprintf_(uint8_t level, const char *tag, int line, const __FlashStringHelper *format,
+                    va_list args);  // NOLINT
 #endif
 
  protected:
@@ -244,14 +244,14 @@ class Logger final : public Component {
     buf.format_body(format, args);
   }
 
-#ifdef USE_ESP8266
+#ifdef USE_STORE_LOG_STR_IN_FLASH
   // Format a log message with flash string format and write it to a buffer with header, footer, and null terminator
   // ESP8266-only (single-task), thread_name is always nullptr
-  inline void HOT format_log_to_buffer_with_terminator_p_(uint8_t level, const char *tag, int line,
+  inline void HOT format_log_to_buffer_with_terminator_P_(uint8_t level, const char *tag, int line,
                                                           const __FlashStringHelper *format, va_list args,
                                                           LogBuffer &buf) {
     buf.write_header(level, tag, line, nullptr);
-    buf.format_body_p(reinterpret_cast<PGM_P>(format), args);
+    buf.format_body_P(reinterpret_cast<PGM_P>(format), args);
   }
 #endif
 
@@ -283,9 +283,9 @@ class Logger final : public Component {
                                                   FormatType format, va_list args, const char *thread_name) {
     RecursionGuard guard(recursion_guard);
     LogBuffer buf{this->tx_buffer_, ESPHOME_LOGGER_TX_BUFFER_SIZE};
-#ifdef USE_ESP8266
+#ifdef USE_STORE_LOG_STR_IN_FLASH
     if constexpr (std::is_same_v<FormatType, const __FlashStringHelper *>) {
-      this->format_log_to_buffer_with_terminator_p_(level, tag, line, format, args, buf);
+      this->format_log_to_buffer_with_terminator_P_(level, tag, line, format, args, buf);
     } else
 #endif
     {

esphome/components/ltr390/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_AMBIENT_LIGHT,
@@ -29,6 +28,7 @@ CONF_UV_INDEX = "uv_index"
 CONF_UV = "uv"
 CONF_WINDOW_CORRECTION_FACTOR = "window_correction_factor"
 
+UNIT_COUNTS = "#"
 UNIT_UVI = "UVI"
 
 LTR390GAIN = ltr390_ns.enum("LTR390GAIN")