diff --git a/CODEOWNERS b/CODEOWNERS
index cb415bb625a..12aff01e730 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -410,6 +410,7 @@ esphome/components/restart/* @esphome/core
 esphome/components/rf_bridge/* @jesserockz
 esphome/components/rgbct/* @jesserockz
 esphome/components/rp2040/* @jesserockz
+esphome/components/rp2040_ble/* @bdraco
 esphome/components/rp2040_pio_led_strip/* @Papa-DMan
 esphome/components/rp2040_pwm/* @jesserockz
 esphome/components/rpi_dpi_rgb/* @clydebarrow
@@ -458,6 +459,7 @@ esphome/components/sonoff_d1/* @anatoly-savchenkov
 esphome/components/sound_level/* @kahrendt
 esphome/components/speaker/* @jesserockz @kahrendt
 esphome/components/speaker/media_player/* @kahrendt @synesthesiam
+esphome/components/speaker_source/* @kahrendt
 esphome/components/spi/* @clydebarrow @esphome/core
 esphome/components/spi_device/* @clydebarrow
 esphome/components/spi_led_strip/* @clydebarrow
diff --git a/esphome/__main__.py b/esphome/__main__.py
index c86de607866..0433c09e160 100644
--- a/esphome/__main__.py
+++ b/esphome/__main__.py
@@ -65,6 +65,7 @@ from esphome.util import (
     detect_rp2040_bootsel,
     get_picotool_path,
     get_serial_ports,
+    is_picotool_usb_permission_error,
     list_yaml_files,
     run_external_command,
     run_external_process,
@@ -85,6 +86,13 @@ _RP2040_BOOTSEL_INSTRUCTIONS = (
     "Then run the upload command again."
 )
 
+_RP2040_UDEV_HINT = (
+    "You may need to add a udev rule for RP2040 devices. "
+    "See: https://github.com/raspberrypi/picotool"
+    "/blob/master/udev/60-picotool.rules"
+)
+
+
 # Special non-component keys that appear in configs
 _NON_COMPONENT_KEYS = frozenset(
     {
@@ -301,11 +309,7 @@ def choose_upload_log_host(
                 "not be accessed due to USB permissions."
             )
             if sys.platform.startswith("linux"):
-                _LOGGER.warning(
-                    "You may need to add a udev rule for RP2040 devices. "
-                    "See: https://github.com/raspberrypi/picotool"
-                    "/blob/master/udev/60-picotool.rules"
-                )
+                _LOGGER.warning(_RP2040_UDEV_HINT)
         if not options:
             raise EsphomeError(
                 f"No RP2040 device found. {_RP2040_BOOTSEL_INSTRUCTIONS}"
@@ -886,14 +890,10 @@ def upload_using_picotool(config: ConfigType) -> int:
         if stderr:
             for line in stderr.splitlines():
                 safe_print(line)
-        if "LIBUSB_ERROR_ACCESS" in stderr or "Permission denied" in stderr:
+        if is_picotool_usb_permission_error(stderr):
             msg = "Permission denied accessing USB device."
             if sys.platform.startswith("linux"):
-                msg += (
-                    " You may need to add udev rules for RP2040 devices."
-                    " See: https://github.com/raspberrypi/picotool"
-                    "/blob/master/udev/60-picotool.rules"
-                )
+                msg += f" {_RP2040_UDEV_HINT}"
             _LOGGER.error(msg)
         else:
             _LOGGER.error("picotool upload failed (exit code %d).", result.returncode)
diff --git a/esphome/automation.py b/esphome/automation.py
index d9b8b2ec574..36ab30b654a 100644
--- a/esphome/automation.py
+++ b/esphome/automation.py
@@ -1,3 +1,5 @@
+import logging
+
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
@@ -57,22 +59,41 @@ def maybe_conf(conf, *validators):
     return validate
 
 
+_LOGGER = logging.getLogger(__name__)
+
+
 def register_action(
     name: str,
     action_type: MockObjClass,
     schema: cv.Schema,
     *,
-    synchronous: bool = False,
+    synchronous: bool | None = None,
 ):
     """Register an action type.
 
-    Actions default to ``synchronous=False`` (safe default), meaning string
-    arguments use owning std::string to prevent dangling references.
+    All callers must pass ``synchronous`` explicitly.
 
-    Set ``synchronous=True`` only for actions that complete synchronously
-    and never store trigger arguments for later execution.  This allows
-    the code generator to use non-owning StringRef for zero-copy access.
+    ``synchronous=True`` — the action never defers ``play_next_()`` to a
+    later point (callback, timer, or ``loop()``).  Trigger arguments are
+    only used during the initial call, so string args can use non-owning
+    StringRef for zero-copy access.
+
+    ``synchronous=False`` — the action defers ``play_next_()`` via a
+    callback, timer, or ``Component::loop()``.  Trigger arguments must
+    outlive the initial call, so string args use owning std::string to
+    prevent dangling references.
     """
+    if synchronous is None:
+        _LOGGER.warning(
+            "register_action('%s', ...) is missing the synchronous= parameter. "
+            "Defaulting to synchronous=False (safe but prevents StringRef "
+            "optimization). Check the C++ class: use synchronous=False if "
+            "play_next_() is deferred to a callback, timer, or loop(); "
+            "use synchronous=True if play_next_() always runs before the "
+            "initial play/play_complex call returns",
+            name,
+        )
+        synchronous = False
     return ACTION_REGISTRY.register(name, action_type, schema, synchronous=synchronous)
 
 
@@ -353,6 +374,7 @@ async def component_is_idle_condition_to_code(
     "delay",
     DelayAction,
     cv.templatable(cv.positive_time_period_milliseconds),
+    synchronous=False,
 )
 async def delay_action_to_code(
     config: ConfigType,
@@ -465,7 +487,7 @@ _validate_wait_until = cv.maybe_simple_value(
 )
 
 
-@register_action("wait_until", WaitUntilAction, _validate_wait_until)
+@register_action("wait_until", WaitUntilAction, _validate_wait_until, synchronous=False)
 async def wait_until_action_to_code(
     config: ConfigType,
     action_id: ID,
@@ -611,7 +633,7 @@ def has_non_synchronous_actions(actions: ConfigType) -> bool:
 
     Non-synchronous actions (delay, wait_until, script.wait, etc.) store
     trigger args for later execution, making non-owning types like StringRef
-    unsafe.  Actions that haven't been audited default to non-synchronous.
+    unsafe.
     """
     if isinstance(actions, list):
         return any(has_non_synchronous_actions(item) for item in actions)
diff --git a/esphome/build_gen/espidf.py b/esphome/build_gen/espidf.py
index f45efb82c1d..9df9b1069c5 100644
--- a/esphome/build_gen/espidf.py
+++ b/esphome/build_gen/espidf.py
@@ -72,7 +72,7 @@ def get_component_cmakelists(minimal: bool = False) -> str:
 
     # Extract compile definitions from build flags (-DXXX -> XXX)
     compile_defs = [flag[2:] for flag in CORE.build_flags if flag.startswith("-D")]
-    compile_defs_str = "\n    ".join(compile_defs) if compile_defs else ""
+    compile_defs_str = "\n    ".join(sorted(compile_defs)) if compile_defs else ""
 
     # Extract compile options (-W flags, excluding linker flags)
     compile_opts = [
@@ -80,11 +80,11 @@ def get_component_cmakelists(minimal: bool = False) -> str:
         for flag in CORE.build_flags
         if flag.startswith("-W") and not flag.startswith("-Wl,")
     ]
-    compile_opts_str = "\n    ".join(compile_opts) if compile_opts else ""
+    compile_opts_str = "\n    ".join(sorted(compile_opts)) if compile_opts else ""
 
     # Extract linker options (-Wl, flags)
     link_opts = [flag for flag in CORE.build_flags if flag.startswith("-Wl,")]
-    link_opts_str = "\n    ".join(link_opts) if link_opts else ""
+    link_opts_str = "\n    ".join(sorted(link_opts)) if link_opts else ""
 
     return f"""\
 # Auto-generated by ESPHome
diff --git a/esphome/components/ags10/sensor.py b/esphome/components/ags10/sensor.py
index 8f0f3729516..4cfa9e67ec1 100644
--- a/esphome/components/ags10/sensor.py
+++ b/esphome/components/ags10/sensor.py
@@ -92,6 +92,7 @@ AGS10_NEW_I2C_ADDRESS_SCHEMA = cv.maybe_simple_value(
     "ags10.new_i2c_address",
     AGS10NewI2cAddressAction,
     AGS10_NEW_I2C_ADDRESS_SCHEMA,
+    synchronous=True,
 )
 async def ags10newi2caddress_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -121,6 +122,7 @@ AGS10_SET_ZERO_POINT_SCHEMA = cv.Schema(
     "ags10.set_zero_point",
     AGS10SetZeroPointAction,
     AGS10_SET_ZERO_POINT_SCHEMA,
+    synchronous=True,
 )
 async def ags10setzeropoint_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/aic3204/audio_dac.py b/esphome/components/aic3204/audio_dac.py
index da7a54df54d..a644638f696 100644
--- a/esphome/components/aic3204/audio_dac.py
+++ b/esphome/components/aic3204/audio_dac.py
@@ -34,7 +34,10 @@ SET_AUTO_MUTE_ACTION_SCHEMA = cv.maybe_simple_value(
 
 
 @automation.register_action(
-    "aic3204.set_auto_mute_mode", SetAutoMuteAction, SET_AUTO_MUTE_ACTION_SCHEMA
+    "aic3204.set_auto_mute_mode",
+    SetAutoMuteAction,
+    SET_AUTO_MUTE_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def aic3204_set_volume_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/alarm_control_panel/__init__.py b/esphome/components/alarm_control_panel/__init__.py
index b8555861527..aefb18d25cc 100644
--- a/esphome/components/alarm_control_panel/__init__.py
+++ b/esphome/components/alarm_control_panel/__init__.py
@@ -243,7 +243,10 @@ async def new_alarm_control_panel(config, *args):
 
 
 @automation.register_action(
-    "alarm_control_panel.arm_away", ArmAwayAction, ALARM_CONTROL_PANEL_ACTION_SCHEMA
+    "alarm_control_panel.arm_away",
+    ArmAwayAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def alarm_action_arm_away_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -255,7 +258,10 @@ async def alarm_action_arm_away_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "alarm_control_panel.arm_home", ArmHomeAction, ALARM_CONTROL_PANEL_ACTION_SCHEMA
+    "alarm_control_panel.arm_home",
+    ArmHomeAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def alarm_action_arm_home_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -267,7 +273,10 @@ async def alarm_action_arm_home_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "alarm_control_panel.arm_night", ArmNightAction, ALARM_CONTROL_PANEL_ACTION_SCHEMA
+    "alarm_control_panel.arm_night",
+    ArmNightAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def alarm_action_arm_night_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -279,7 +288,10 @@ async def alarm_action_arm_night_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "alarm_control_panel.disarm", DisarmAction, ALARM_CONTROL_PANEL_ACTION_SCHEMA
+    "alarm_control_panel.disarm",
+    DisarmAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def alarm_action_disarm_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -291,7 +303,10 @@ async def alarm_action_disarm_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "alarm_control_panel.pending", PendingAction, ALARM_CONTROL_PANEL_ACTION_SCHEMA
+    "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])
@@ -299,7 +314,10 @@ async def alarm_action_pending_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "alarm_control_panel.triggered", TriggeredAction, ALARM_CONTROL_PANEL_ACTION_SCHEMA
+    "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])
@@ -307,7 +325,10 @@ async def alarm_action_trigger_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "alarm_control_panel.chime", ChimeAction, ALARM_CONTROL_PANEL_ACTION_SCHEMA
+    "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])
@@ -315,7 +336,10 @@ async def alarm_action_chime_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "alarm_control_panel.ready", ReadyAction, ALARM_CONTROL_PANEL_ACTION_SCHEMA
+    "alarm_control_panel.ready",
+    ReadyAction,
+    ALARM_CONTROL_PANEL_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_condition(
     "alarm_control_panel.ready",
diff --git a/esphome/components/animation/__init__.py b/esphome/components/animation/__init__.py
index c4ac7adb236..e9630f5266b 100644
--- a/esphome/components/animation/__init__.py
+++ b/esphome/components/animation/__init__.py
@@ -69,9 +69,15 @@ SET_FRAME_SCHEMA = cv.Schema(
 )
 
 
-@automation.register_action("animation.next_frame", NextFrameAction, NEXT_FRAME_SCHEMA)
-@automation.register_action("animation.prev_frame", PrevFrameAction, PREV_FRAME_SCHEMA)
-@automation.register_action("animation.set_frame", SetFrameAction, SET_FRAME_SCHEMA)
+@automation.register_action(
+    "animation.next_frame", NextFrameAction, NEXT_FRAME_SCHEMA, synchronous=True
+)
+@automation.register_action(
+    "animation.prev_frame", PrevFrameAction, PREV_FRAME_SCHEMA, synchronous=True
+)
+@automation.register_action(
+    "animation.set_frame", SetFrameAction, SET_FRAME_SCHEMA, synchronous=True
+)
 async def animation_action_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)
diff --git a/esphome/components/api/__init__.py b/esphome/components/api/__init__.py
index c7dec6e78be..9772e6afca7 100644
--- a/esphome/components/api/__init__.py
+++ b/esphome/components/api/__init__.py
@@ -712,6 +712,7 @@ API_RESPOND_ACTION_SCHEMA = cv.All(
     "api.respond",
     APIRespondAction,
     API_RESPOND_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def api_respond_to_code(
     config: ConfigType,
diff --git a/esphome/components/at581x/__init__.py b/esphome/components/at581x/__init__.py
index 117ada123db..0780814ea6e 100644
--- a/esphome/components/at581x/__init__.py
+++ b/esphome/components/at581x/__init__.py
@@ -89,6 +89,7 @@ AT581XSettingsAction = at581x_ns.class_("AT581XSettingsAction", automation.Actio
             cv.Required(CONF_ID): cv.use_id(AT581XComponent),
         }
     ),
+    synchronous=True,
 )
 async def at581x_reset_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -160,6 +161,7 @@ RADAR_SETTINGS_SCHEMA = cv.Schema(
     "at581x.settings",
     AT581XSettingsAction,
     RADAR_SETTINGS_SCHEMA,
+    synchronous=True,
 )
 async def at581x_settings_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/audio_adc/__init__.py b/esphome/components/audio_adc/__init__.py
index 2f95a039f5c..3c9b32e6107 100644
--- a/esphome/components/audio_adc/__init__.py
+++ b/esphome/components/audio_adc/__init__.py
@@ -23,7 +23,10 @@ SET_MIC_GAIN_ACTION_SCHEMA = cv.maybe_simple_value(
 
 
 @automation.register_action(
-    "audio_adc.set_mic_gain", SetMicGainAction, SET_MIC_GAIN_ACTION_SCHEMA
+    "audio_adc.set_mic_gain",
+    SetMicGainAction,
+    SET_MIC_GAIN_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def audio_adc_set_mic_gain_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/audio_dac/__init__.py b/esphome/components/audio_dac/__init__.py
index 92e6cb18fa0..a950c1967bf 100644
--- a/esphome/components/audio_dac/__init__.py
+++ b/esphome/components/audio_dac/__init__.py
@@ -31,15 +31,22 @@ SET_VOLUME_ACTION_SCHEMA = cv.maybe_simple_value(
 )
 
 
-@automation.register_action("audio_dac.mute_off", MuteOffAction, MUTE_ACTION_SCHEMA)
-@automation.register_action("audio_dac.mute_on", MuteOnAction, MUTE_ACTION_SCHEMA)
+@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, 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(
-    "audio_dac.set_volume", SetVolumeAction, SET_VOLUME_ACTION_SCHEMA
+    "audio_dac.set_volume",
+    SetVolumeAction,
+    SET_VOLUME_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def audio_dac_set_volume_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/binary_sensor/__init__.py b/esphome/components/binary_sensor/__init__.py
index 1f641185602..37cccc01be6 100644
--- a/esphome/components/binary_sensor/__init__.py
+++ b/esphome/components/binary_sensor/__init__.py
@@ -685,6 +685,7 @@ async def to_code(config):
         },
         key=CONF_ID,
     ),
+    synchronous=True,
 )
 async def binary_sensor_invalidate_state_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/bl0906/sensor.py b/esphome/components/bl0906/sensor.py
index 42c6f06092b..059e10e962d 100644
--- a/esphome/components/bl0906/sensor.py
+++ b/esphome/components/bl0906/sensor.py
@@ -143,6 +143,7 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
             cv.Required(CONF_ID): cv.use_id(BL0906),
         }
     ),
+    synchronous=True,
 )
 async def reset_energy_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/bl0940/bl0940.h b/esphome/components/bl0940/bl0940.h
index 93d54003f5f..e0ca748a222 100644
--- a/esphome/components/bl0940/bl0940.h
+++ b/esphome/components/bl0940/bl0940.h
@@ -69,10 +69,8 @@ class BL0940 : public PollingComponent, public uart::UARTDevice {
   void set_energy_calibration_number(number::Number *num) { this->energy_calibration_number_ = num; }
 #endif
 
-#ifdef USE_BUTTON
-  // Resets all calibration values to defaults (can be triggered by a button)
+  // Resets all calibration values to defaults
   void reset_calibration();
-#endif
 
   // Core component methods
   void loop() override;
diff --git a/esphome/components/ble_client/__init__.py b/esphome/components/ble_client/__init__.py
index 37db181584b..56ac2ea1472 100644
--- a/esphome/components/ble_client/__init__.py
+++ b/esphome/components/ble_client/__init__.py
@@ -172,7 +172,10 @@ BLE_REMOVE_BOND_ACTION_SCHEMA = cv.Schema(
 
 
 @automation.register_action(
-    "ble_client.disconnect", BLEDisconnectAction, BLE_CONNECT_ACTION_SCHEMA
+    "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])
@@ -180,7 +183,10 @@ async def ble_disconnect_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "ble_client.connect", BLEConnectAction, BLE_CONNECT_ACTION_SCHEMA
+    "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])
@@ -188,7 +194,10 @@ async def ble_connect_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "ble_client.ble_write", BLEWriteAction, BLE_WRITE_ACTION_SCHEMA
+    "ble_client.ble_write",
+    BLEWriteAction,
+    BLE_WRITE_ACTION_SCHEMA,
+    synchronous=False,
 )
 async def ble_write_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
@@ -247,6 +256,7 @@ async def ble_write_to_code(config, action_id, template_arg, args):
     "ble_client.numeric_comparison_reply",
     BLENumericComparisonReplyAction,
     BLE_NUMERIC_COMPARISON_REPLY_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def numeric_comparison_reply_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
@@ -263,7 +273,10 @@ async def numeric_comparison_reply_to_code(config, action_id, template_arg, args
 
 
 @automation.register_action(
-    "ble_client.passkey_reply", BLEPasskeyReplyAction, BLE_PASSKEY_REPLY_ACTION_SCHEMA
+    "ble_client.passkey_reply",
+    BLEPasskeyReplyAction,
+    BLE_PASSKEY_REPLY_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def passkey_reply_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
@@ -283,6 +296,7 @@ async def passkey_reply_to_code(config, action_id, template_arg, args):
     "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])
diff --git a/esphome/components/bm8563/time.py b/esphome/components/bm8563/time.py
index 2785315af27..ba264f00bfe 100644
--- a/esphome/components/bm8563/time.py
+++ b/esphome/components/bm8563/time.py
@@ -33,6 +33,7 @@ CONFIG_SCHEMA = (
             cv.GenerateID(): cv.use_id(BM8563),
         }
     ),
+    synchronous=True,
 )
 async def bm8563_write_time_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -49,6 +50,7 @@ async def bm8563_write_time_to_code(config, action_id, template_arg, args):
             cv.Required(CONF_DURATION): cv.templatable(cv.positive_time_period_seconds),
         }
     ),
+    synchronous=True,
 )
 async def bm8563_start_timer_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -66,6 +68,7 @@ async def bm8563_start_timer_to_code(config, action_id, template_arg, args):
             cv.GenerateID(): cv.use_id(BM8563),
         }
     ),
+    synchronous=True,
 )
 async def bm8563_read_time_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/canbus/__init__.py b/esphome/components/canbus/__init__.py
index 7b51c2c45c1..c94c8647a95 100644
--- a/esphome/components/canbus/__init__.py
+++ b/esphome/components/canbus/__init__.py
@@ -155,6 +155,7 @@ async def register_canbus(var, config):
         validate_id,
         key=CONF_DATA,
     ),
+    synchronous=True,
 )
 async def canbus_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/cc1101/__init__.py b/esphome/components/cc1101/__init__.py
index e2e5986daff..27092908621 100644
--- a/esphome/components/cc1101/__init__.py
+++ b/esphome/components/cc1101/__init__.py
@@ -287,10 +287,18 @@ CC1101_ACTION_SCHEMA = cv.Schema(
 )
 
 
-@automation.register_action("cc1101.begin_tx", BeginTxAction, CC1101_ACTION_SCHEMA)
-@automation.register_action("cc1101.begin_rx", BeginRxAction, CC1101_ACTION_SCHEMA)
-@automation.register_action("cc1101.reset", ResetAction, CC1101_ACTION_SCHEMA)
-@automation.register_action("cc1101.set_idle", SetIdleAction, CC1101_ACTION_SCHEMA)
+@automation.register_action(
+    "cc1101.begin_tx", BeginTxAction, CC1101_ACTION_SCHEMA, synchronous=True
+)
+@automation.register_action(
+    "cc1101.begin_rx", BeginRxAction, CC1101_ACTION_SCHEMA, synchronous=True
+)
+@automation.register_action(
+    "cc1101.reset", ResetAction, 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])
@@ -317,7 +325,10 @@ SEND_PACKET_ACTION_SCHEMA = cv.maybe_simple_value(
 
 
 @automation.register_action(
-    "cc1101.send_packet", SendPacketAction, SEND_PACKET_ACTION_SCHEMA
+    "cc1101.send_packet",
+    SendPacketAction,
+    SEND_PACKET_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def send_packet_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -419,9 +430,9 @@ def _register_setter_actions():
                 cg.add(getattr(var, _setter)(_map[data] if _map else data))
             return var
 
-        automation.register_action(f"cc1101.{setter_name}", action_cls, schema)(
-            _setter_action_to_code
-        )
+        automation.register_action(
+            f"cc1101.{setter_name}", action_cls, schema, synchronous=True
+        )(_setter_action_to_code)
 
 
 _register_setter_actions()
diff --git a/esphome/components/climate/__init__.py b/esphome/components/climate/__init__.py
index f5b91c502c7..8cf5fa9b0c2 100644
--- a/esphome/components/climate/__init__.py
+++ b/esphome/components/climate/__init__.py
@@ -476,7 +476,10 @@ CLIMATE_CONTROL_ACTION_SCHEMA = cv.Schema(
 
 
 @automation.register_action(
-    "climate.control", ControlAction, CLIMATE_CONTROL_ACTION_SCHEMA
+    "climate.control",
+    ControlAction,
+    CLIMATE_CONTROL_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def climate_control_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/cm1106/sensor.py b/esphome/components/cm1106/sensor.py
index 1d95bcc6665..3c82fac977f 100644
--- a/esphome/components/cm1106/sensor.py
+++ b/esphome/components/cm1106/sensor.py
@@ -65,6 +65,7 @@ CALIBRATION_ACTION_SCHEMA = maybe_simple_id(
     "cm1106.calibrate_zero",
     CM1106CalibrateZeroAction,
     CALIBRATION_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def cm1106_calibration_to_code(config, action_id, template_arg, args) -> None:
     """Service code generation entry point."""
diff --git a/esphome/components/cs5460a/sensor.py b/esphome/components/cs5460a/sensor.py
index 07b5ea1c635..d2383bd01b8 100644
--- a/esphome/components/cs5460a/sensor.py
+++ b/esphome/components/cs5460a/sensor.py
@@ -132,6 +132,7 @@ async def to_code(config):
             cv.Required(CONF_ID): cv.use_id(CS5460AComponent),
         }
     ),
+    synchronous=True,
 )
 async def restart_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/datetime/__init__.py b/esphome/components/datetime/__init__.py
index 74c9d594f75..90835624bf1 100644
--- a/esphome/components/datetime/__init__.py
+++ b/esphome/components/datetime/__init__.py
@@ -187,6 +187,7 @@ async def to_code(config):
             ),
         }
     ),
+    synchronous=True,
 )
 async def datetime_date_set_to_code(config, action_id, template_arg, args):
     action_var = cg.new_Pvariable(action_id, template_arg)
@@ -218,6 +219,7 @@ async def datetime_date_set_to_code(config, action_id, template_arg, args):
             ),
         }
     ),
+    synchronous=True,
 )
 async def datetime_time_set_to_code(config, action_id, template_arg, args):
     action_var = cg.new_Pvariable(action_id, template_arg)
@@ -249,6 +251,7 @@ async def datetime_time_set_to_code(config, action_id, template_arg, args):
             ),
         },
     ),
+    synchronous=True,
 )
 async def datetime_datetime_set_to_code(config, action_id, template_arg, args):
     action_var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/deep_sleep/__init__.py b/esphome/components/deep_sleep/__init__.py
index 3cfe7aa6417..4098fd3fb8b 100644
--- a/esphome/components/deep_sleep/__init__.py
+++ b/esphome/components/deep_sleep/__init__.py
@@ -405,7 +405,10 @@ DEEP_SLEEP_ENTER_SCHEMA = cv.All(
 
 
 @automation.register_action(
-    "deep_sleep.enter", EnterDeepSleepAction, DEEP_SLEEP_ENTER_SCHEMA
+    "deep_sleep.enter",
+    EnterDeepSleepAction,
+    DEEP_SLEEP_ENTER_SCHEMA,
+    synchronous=True,
 )
 async def deep_sleep_enter_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -428,11 +431,13 @@ async def deep_sleep_enter_to_code(config, action_id, template_arg, args):
     "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, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/dfplayer/__init__.py b/esphome/components/dfplayer/__init__.py
index 53ebda6bcc8..9df108c9c0a 100644
--- a/esphome/components/dfplayer/__init__.py
+++ b/esphome/components/dfplayer/__init__.py
@@ -91,6 +91,7 @@ async def to_code(config):
             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)
@@ -106,6 +107,7 @@ async def dfplayer_next_to_code(config, action_id, template_arg, args):
             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)
@@ -123,6 +125,7 @@ async def dfplayer_previous_to_code(config, action_id, template_arg, args):
         },
         key=CONF_FILE,
     ),
+    synchronous=True,
 )
 async def dfplayer_play_mp3_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -143,6 +146,7 @@ async def dfplayer_play_mp3_to_code(config, action_id, template_arg, args):
         },
         key=CONF_FILE,
     ),
+    synchronous=True,
 )
 async def dfplayer_play_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -166,6 +170,7 @@ async def dfplayer_play_to_code(config, action_id, template_arg, args):
             cv.Optional(CONF_LOOP): cv.templatable(cv.boolean),
         }
     ),
+    synchronous=True,
 )
 async def dfplayer_play_folder_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -191,6 +196,7 @@ async def dfplayer_play_folder_to_code(config, action_id, template_arg, args):
         },
         key=CONF_DEVICE,
     ),
+    synchronous=True,
 )
 async def dfplayer_set_device_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -210,6 +216,7 @@ async def dfplayer_set_device_to_code(config, action_id, template_arg, args):
         },
         key=CONF_VOLUME,
     ),
+    synchronous=True,
 )
 async def dfplayer_set_volume_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -227,6 +234,7 @@ async def dfplayer_set_volume_to_code(config, action_id, template_arg, args):
             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)
@@ -242,6 +250,7 @@ async def dfplayer_volume_up_to_code(config, action_id, template_arg, args):
             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)
@@ -259,6 +268,7 @@ async def dfplayer_volume_down_to_code(config, action_id, template_arg, args):
         },
         key=CONF_EQ_PRESET,
     ),
+    synchronous=True,
 )
 async def dfplayer_set_eq_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -276,6 +286,7 @@ async def dfplayer_set_eq_to_code(config, action_id, template_arg, args):
             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)
@@ -291,6 +302,7 @@ async def dfplayer_sleep_to_code(config, action_id, template_arg, args):
             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)
@@ -306,6 +318,7 @@ async def dfplayer_reset_to_code(config, action_id, template_arg, args):
             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)
@@ -321,6 +334,7 @@ async def dfplayer_start_to_code(config, action_id, template_arg, args):
             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)
@@ -336,6 +350,7 @@ async def dfplayer_pause_to_code(config, action_id, template_arg, args):
             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)
@@ -351,6 +366,7 @@ async def dfplayer_stop_to_code(config, action_id, template_arg, args):
             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)
diff --git a/esphome/components/dfrobot_sen0395/__init__.py b/esphome/components/dfrobot_sen0395/__init__.py
index d54b147036e..ba77e56abb0 100644
--- a/esphome/components/dfrobot_sen0395/__init__.py
+++ b/esphome/components/dfrobot_sen0395/__init__.py
@@ -52,6 +52,7 @@ async def to_code(config):
             cv.GenerateID(): cv.use_id(DfrobotSen0395Component),
         }
     ),
+    synchronous=True,
 )
 async def dfrobot_sen0395_reset_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -151,6 +152,7 @@ MMWAVE_SETTINGS_SCHEMA = cv.Schema(
     "dfrobot_sen0395.settings",
     DfrobotSen0395SettingsAction,
     MMWAVE_SETTINGS_SCHEMA,
+    synchronous=True,
 )
 async def dfrobot_sen0395_settings_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/display/__init__.py b/esphome/components/display/__init__.py
index 919fda76a0e..2cc4a4e8951 100644
--- a/esphome/components/display/__init__.py
+++ b/esphome/components/display/__init__.py
@@ -168,6 +168,7 @@ async def register_display(var, config):
             cv.Required(CONF_ID): cv.templatable(cv.use_id(DisplayPage)),
         }
     ),
+    synchronous=True,
 )
 async def display_page_show_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -188,6 +189,7 @@ async def display_page_show_to_code(config, action_id, template_arg, args):
             cv.GenerateID(CONF_ID): cv.templatable(cv.use_id(Display)),
         }
     ),
+    synchronous=True,
 )
 async def display_page_show_next_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -202,6 +204,7 @@ async def display_page_show_next_to_code(config, action_id, template_arg, args):
             cv.GenerateID(CONF_ID): cv.templatable(cv.use_id(Display)),
         }
     ),
+    synchronous=True,
 )
 async def display_page_show_previous_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/display_menu_base/__init__.py b/esphome/components/display_menu_base/__init__.py
index 658292ec7a3..c9a0c7ee93e 100644
--- a/esphome/components/display_menu_base/__init__.py
+++ b/esphome/components/display_menu_base/__init__.py
@@ -294,50 +294,67 @@ MENU_ACTION_SCHEMA = maybe_simple_id(
 )
 
 
-@automation.register_action("display_menu.up", UpAction, MENU_ACTION_SCHEMA)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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
+    "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])
diff --git a/esphome/components/ds1307/time.py b/esphome/components/ds1307/time.py
index 42b7184db9b..0e7bb976a2d 100644
--- a/esphome/components/ds1307/time.py
+++ b/esphome/components/ds1307/time.py
@@ -27,6 +27,7 @@ CONFIG_SCHEMA = time.TIME_SCHEMA.extend(
             cv.GenerateID(): cv.use_id(DS1307Component),
         }
     ),
+    synchronous=True,
 )
 async def ds1307_write_time_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -42,6 +43,7 @@ async def ds1307_write_time_to_code(config, action_id, template_arg, args):
             cv.GenerateID(): cv.use_id(DS1307Component),
         }
     ),
+    synchronous=True,
 )
 async def ds1307_read_time_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/duty_time/sensor.py b/esphome/components/duty_time/sensor.py
index 1907b3fcfec..456859f8e49 100644
--- a/esphome/components/duty_time/sensor.py
+++ b/esphome/components/duty_time/sensor.py
@@ -90,21 +90,27 @@ DUTY_TIME_ID_SCHEMA = maybe_simple_id(
 )
 
 
-@register_action("sensor.duty_time.start", StartAction, DUTY_TIME_ID_SCHEMA)
+@register_action(
+    "sensor.duty_time.start", StartAction, DUTY_TIME_ID_SCHEMA, synchronous=True
+)
 async def sensor_runtime_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
 
 
-@register_action("sensor.duty_time.stop", StopAction, DUTY_TIME_ID_SCHEMA)
+@register_action(
+    "sensor.duty_time.stop", StopAction, DUTY_TIME_ID_SCHEMA, synchronous=True
+)
 async def sensor_runtime_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
 
 
-@register_action("sensor.duty_time.reset", ResetAction, DUTY_TIME_ID_SCHEMA)
+@register_action(
+    "sensor.duty_time.reset", ResetAction, DUTY_TIME_ID_SCHEMA, synchronous=True
+)
 async def sensor_runtime_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])
diff --git a/esphome/components/esp32_ble/__init__.py b/esphome/components/esp32_ble/__init__.py
index 8b368afc2e2..43208eb87eb 100644
--- a/esphome/components/esp32_ble/__init__.py
+++ b/esphome/components/esp32_ble/__init__.py
@@ -604,11 +604,15 @@ async def ble_enabled_to_code(config, condition_id, template_arg, args):
     return cg.new_Pvariable(condition_id, template_arg)
 
 
-@automation.register_action("ble.enable", BLEEnableAction, cv.Schema({}))
+@automation.register_action(
+    "ble.enable", BLEEnableAction, cv.Schema({}), synchronous=True
+)
 async def ble_enable_to_code(config, action_id, template_arg, args):
     return cg.new_Pvariable(action_id, template_arg)
 
 
-@automation.register_action("ble.disable", BLEDisableAction, cv.Schema({}))
+@automation.register_action(
+    "ble.disable", BLEDisableAction, cv.Schema({}), synchronous=True
+)
 async def ble_disable_to_code(config, action_id, template_arg, args):
     return cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/esp32_ble_server/__init__.py b/esphome/components/esp32_ble_server/__init__.py
index b08e791e7e3..827ddba9554 100644
--- a/esphome/components/esp32_ble_server/__init__.py
+++ b/esphome/components/esp32_ble_server/__init__.py
@@ -622,6 +622,7 @@ async def to_code(config):
         ),
         validate_set_value_action,
     ),
+    synchronous=True,
 )
 async def ble_server_characteristic_set_value(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -641,6 +642,7 @@ async def ble_server_characteristic_set_value(config, action_id, template_arg, a
             cv.Required(CONF_VALUE): value_schema(),
         }
     ),
+    synchronous=True,
 )
 async def ble_server_descriptor_set_value(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -662,6 +664,7 @@ async def ble_server_descriptor_set_value(config, action_id, template_arg, args)
         ),
         validate_notify_action,
     ),
+    synchronous=True,
 )
 async def ble_server_characteristic_notify(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/esp32_ble_tracker/__init__.py b/esphome/components/esp32_ble_tracker/__init__.py
index 37e74672ed8..c5e8f3178d0 100644
--- a/esphome/components/esp32_ble_tracker/__init__.py
+++ b/esphome/components/esp32_ble_tracker/__init__.py
@@ -373,6 +373,7 @@ ESP32_BLE_START_SCAN_ACTION_SCHEMA = cv.Schema(
     "esp32_ble_tracker.start_scan",
     ESP32BLEStartScanAction,
     ESP32_BLE_START_SCAN_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def esp32_ble_tracker_start_scan_action_to_code(
     config, action_id, template_arg, args
@@ -396,6 +397,7 @@ ESP32_BLE_STOP_SCAN_ACTION_SCHEMA = automation.maybe_simple_id(
     "esp32_ble_tracker.stop_scan",
     ESP32BLEStopScanAction,
     ESP32_BLE_STOP_SCAN_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def esp32_ble_tracker_stop_scan_action_to_code(
     config, action_id, template_arg, args
diff --git a/esphome/components/esp32_hosted/__init__.py b/esphome/components/esp32_hosted/__init__.py
index 720d81acc4a..6d49053d6d5 100644
--- a/esphome/components/esp32_hosted/__init__.py
+++ b/esphome/components/esp32_hosted/__init__.py
@@ -103,9 +103,9 @@ async def to_code(config):
     framework_ver: cv.Version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
     os.environ["ESP_IDF_VERSION"] = f"{framework_ver.major}.{framework_ver.minor}"
     if framework_ver >= cv.Version(5, 5, 0):
-        esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="1.3.2")
+        esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="1.4.0")
         esp32.add_idf_component(name="espressif/eppp_link", ref="1.1.4")
-        esp32.add_idf_component(name="espressif/esp_hosted", ref="2.11.5")
+        esp32.add_idf_component(name="espressif/esp_hosted", ref="2.12.0")
     else:
         esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="0.13.0")
         esp32.add_idf_component(name="espressif/eppp_link", ref="0.2.0")
diff --git a/esphome/components/esp8266_pwm/output.py b/esphome/components/esp8266_pwm/output.py
index a78831c516c..b9b6dcc95a3 100644
--- a/esphome/components/esp8266_pwm/output.py
+++ b/esphome/components/esp8266_pwm/output.py
@@ -57,6 +57,7 @@ async def to_code(config) -> None:
             cv.Required(CONF_FREQUENCY): cv.templatable(validate_frequency),
         }
     ),
+    synchronous=True,
 )
 async def esp8266_set_frequency_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/esp_ldo/__init__.py b/esphome/components/esp_ldo/__init__.py
index 5235a9411ee..a489651b598 100644
--- a/esphome/components/esp_ldo/__init__.py
+++ b/esphome/components/esp_ldo/__init__.py
@@ -129,6 +129,7 @@ def adjusted_ldo_id(value):
             ),
         }
     ),
+    synchronous=True,
 )
 async def ldo_voltage_adjust_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/espnow/__init__.py b/esphome/components/espnow/__init__.py
index faeccd910e0..d1a85ae8fd8 100644
--- a/esphome/components/espnow/__init__.py
+++ b/esphome/components/espnow/__init__.py
@@ -220,6 +220,7 @@ SEND_SCHEMA.add_extra(_validate_send_action)
     "espnow.send",
     SendAction,
     SEND_SCHEMA,
+    synchronous=False,
 )
 @automation.register_action(
     "espnow.broadcast",
@@ -232,6 +233,7 @@ SEND_SCHEMA.add_extra(_validate_send_action)
         ),
         key=CONF_DATA,
     ),
+    synchronous=False,
 )
 async def send_action(
     config: ConfigType,
@@ -271,6 +273,7 @@ async def send_action(
         PEER_SCHEMA,
         key=CONF_ADDRESS,
     ),
+    synchronous=True,
 )
 @automation.register_action(
     "espnow.peer.delete",
@@ -279,6 +282,7 @@ async def send_action(
         PEER_SCHEMA,
         key=CONF_ADDRESS,
     ),
+    synchronous=True,
 )
 async def peer_action(
     config: ConfigType,
@@ -303,6 +307,7 @@ async def peer_action(
         },
         key=CONF_CHANNEL,
     ),
+    synchronous=True,
 )
 async def channel_action(
     config: ConfigType,
diff --git a/esphome/components/event/__init__.py b/esphome/components/event/__init__.py
index 14cc1505ad8..300902b8cad 100644
--- a/esphome/components/event/__init__.py
+++ b/esphome/components/event/__init__.py
@@ -129,7 +129,9 @@ TRIGGER_EVENT_SCHEMA = cv.Schema(
 )
 
 
-@automation.register_action("event.trigger", TriggerEventAction, TRIGGER_EVENT_SCHEMA)
+@automation.register_action(
+    "event.trigger", TriggerEventAction, TRIGGER_EVENT_SCHEMA, synchronous=True
+)
 async def event_fire_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
diff --git a/esphome/components/ezo_pmp/__init__.py b/esphome/components/ezo_pmp/__init__.py
index c1f72bb05d5..1538e303f12 100644
--- a/esphome/components/ezo_pmp/__init__.py
+++ b/esphome/components/ezo_pmp/__init__.py
@@ -81,7 +81,10 @@ EzoPMPArbitraryCommandAction = ezo_pmp_ns.class_(
 
 
 @automation.register_action(
-    "ezo_pmp.find", EzoPMPFindAction, EZO_PMP_NO_ARGS_ACTION_SCHEMA
+    "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])
@@ -92,6 +95,7 @@ async def ezo_pmp_find_to_code(config, action_id, template_arg, args):
     "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])
@@ -102,6 +106,7 @@ async def ezo_pmp_dose_continuously_to_code(config, action_id, template_arg, arg
     "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
@@ -114,6 +119,7 @@ async def ezo_pmp_clear_total_volume_dosed_to_code(
     "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])
@@ -121,7 +127,10 @@ async def ezo_pmp_clear_calibration_to_code(config, action_id, template_arg, arg
 
 
 @automation.register_action(
-    "ezo_pmp.pause_dosing", EzoPMPPauseDosingAction, EZO_PMP_NO_ARGS_ACTION_SCHEMA
+    "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])
@@ -129,7 +138,10 @@ async def ezo_pmp_pause_dosing_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "ezo_pmp.stop_dosing", EzoPMPStopDosingAction, EZO_PMP_NO_ARGS_ACTION_SCHEMA
+    "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])
@@ -149,7 +161,10 @@ EZO_PMP_DOSE_VOLUME_ACTION_SCHEMA = cv.All(
 
 
 @automation.register_action(
-    "ezo_pmp.dose_volume", EzoPMPDoseVolumeAction, EZO_PMP_DOSE_VOLUME_ACTION_SCHEMA
+    "ezo_pmp.dose_volume",
+    EzoPMPDoseVolumeAction,
+    EZO_PMP_DOSE_VOLUME_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def ezo_pmp_dose_volume_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -178,6 +193,7 @@ EZO_PMP_DOSE_VOLUME_OVER_TIME_ACTION_SCHEMA = cv.All(
     "ezo_pmp.dose_volume_over_time",
     EzoPMPDoseVolumeOverTimeAction,
     EZO_PMP_DOSE_VOLUME_OVER_TIME_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def ezo_pmp_dose_volume_over_time_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -209,6 +225,7 @@ EZO_PMP_DOSE_WITH_CONSTANT_FLOW_RATE_ACTION_SCHEMA = cv.All(
     "ezo_pmp.dose_with_constant_flow_rate",
     EzoPMPDoseWithConstantFlowRateAction,
     EZO_PMP_DOSE_WITH_CONSTANT_FLOW_RATE_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def ezo_pmp_dose_with_constant_flow_rate_to_code(
     config, action_id, template_arg, args
@@ -239,6 +256,7 @@ EZO_PMP_SET_CALIBRATION_VOLUME_ACTION_SCHEMA = cv.All(
     "ezo_pmp.set_calibration_volume",
     EzoPMPSetCalibrationVolumeAction,
     EZO_PMP_SET_CALIBRATION_VOLUME_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def ezo_pmp_set_calibration_volume_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -262,6 +280,7 @@ EZO_PMP_CHANGE_I2C_ADDRESS_ACTION_SCHEMA = cv.All(
     "ezo_pmp.change_i2c_address",
     EzoPMPChangeI2CAddressAction,
     EZO_PMP_CHANGE_I2C_ADDRESS_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def ezo_pmp_change_i2c_address_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -285,6 +304,7 @@ EZO_PMP_ARBITRARY_COMMAND_ACTION_SCHEMA = cv.All(
     "ezo_pmp.arbitrary_command",
     EzoPMPArbitraryCommandAction,
     EZO_PMP_ARBITRARY_COMMAND_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def ezo_pmp_arbitrary_command_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/fan/__init__.py b/esphome/components/fan/__init__.py
index da28c577c8e..df71c6ab3fd 100644
--- a/esphome/components/fan/__init__.py
+++ b/esphome/components/fan/__init__.py
@@ -365,6 +365,7 @@ async def fan_turn_on_to_code(config, action_id, template_arg, args):
             cv.Optional(CONF_OFF_SPEED_CYCLE, default=True): cv.boolean,
         }
     ),
+    synchronous=True,
 )
 async def fan_cycle_speed_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/fingerprint_grow/__init__.py b/esphome/components/fingerprint_grow/__init__.py
index 115b89433bc..2637097be81 100644
--- a/esphome/components/fingerprint_grow/__init__.py
+++ b/esphome/components/fingerprint_grow/__init__.py
@@ -261,6 +261,7 @@ async def to_code(config):
         },
         key=CONF_FINGER_ID,
     ),
+    synchronous=True,
 )
 async def fingerprint_grow_enroll_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -282,6 +283,7 @@ async def fingerprint_grow_enroll_to_code(config, action_id, template_arg, args)
             cv.GenerateID(): cv.use_id(FingerprintGrowComponent),
         }
     ),
+    synchronous=True,
 )
 async def fingerprint_grow_cancel_enroll_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -299,6 +301,7 @@ async def fingerprint_grow_cancel_enroll_to_code(config, action_id, template_arg
         },
         key=CONF_FINGER_ID,
     ),
+    synchronous=True,
 )
 async def fingerprint_grow_delete_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -317,6 +320,7 @@ async def fingerprint_grow_delete_to_code(config, action_id, template_arg, args)
             cv.GenerateID(): cv.use_id(FingerprintGrowComponent),
         }
     ),
+    synchronous=True,
 )
 async def fingerprint_grow_delete_all_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -337,6 +341,7 @@ FINGERPRINT_GROW_LED_CONTROL_ACTION_SCHEMA = cv.maybe_simple_value(
     "fingerprint_grow.led_control",
     LEDControlAction,
     FINGERPRINT_GROW_LED_CONTROL_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def fingerprint_grow_led_control_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -359,6 +364,7 @@ async def fingerprint_grow_led_control_to_code(config, action_id, template_arg,
             cv.Required(CONF_COUNT): cv.templatable(cv.uint8_t),
         }
     ),
+    synchronous=True,
 )
 async def fingerprint_grow_aura_led_control_to_code(
     config, action_id, template_arg, args
diff --git a/esphome/components/grove_tb6612fng/__init__.py b/esphome/components/grove_tb6612fng/__init__.py
index 869c05387ff..210e2f7babb 100644
--- a/esphome/components/grove_tb6612fng/__init__.py
+++ b/esphome/components/grove_tb6612fng/__init__.py
@@ -72,6 +72,7 @@ async def to_code(config):
             cv.Required(CONF_DIRECTION): cv.enum(DIRECTION_TYPE, upper=True),
         }
     ),
+    synchronous=True,
 )
 async def grove_tb6612fng_run_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -96,6 +97,7 @@ async def grove_tb6612fng_run_to_code(config, action_id, template_arg, args):
             cv.Required(CONF_CHANNEL): cv.templatable(cv.int_range(min=0, max=1)),
         }
     ),
+    synchronous=True,
 )
 async def grove_tb6612fng_break_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -115,6 +117,7 @@ async def grove_tb6612fng_break_to_code(config, action_id, template_arg, args):
             cv.Required(CONF_CHANNEL): cv.templatable(cv.int_range(min=0, max=1)),
         }
     ),
+    synchronous=True,
 )
 async def grove_tb6612fng_stop_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -133,6 +136,7 @@ async def grove_tb6612fng_stop_to_code(config, action_id, template_arg, args):
             cv.Required(CONF_ID): cv.use_id(GROVE_TB6612FNG),
         }
     ),
+    synchronous=True,
 )
 async def grove_tb6612fng_standby_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -149,6 +153,7 @@ async def grove_tb6612fng_standby_to_code(config, action_id, template_arg, args)
             cv.Required(CONF_ID): cv.use_id(GROVE_TB6612FNG),
         }
     ),
+    synchronous=True,
 )
 async def grove_tb6612fng_no_standby_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -166,6 +171,7 @@ async def grove_tb6612fng_no_standby_to_code(config, action_id, template_arg, ar
             cv.Required(CONF_ADDRESS): cv.i2c_address,
         }
     ),
+    synchronous=True,
 )
 async def grove_tb6612fng_change_address_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/haier/climate.py b/esphome/components/haier/climate.py
index 6c208f6caa4..caaaa18dd68 100644
--- a/esphome/components/haier/climate.py
+++ b/esphome/components/haier/climate.py
@@ -319,10 +319,16 @@ HAIER_HON_BASE_ACTION_SCHEMA = automation.maybe_simple_id(
 
 
 @automation.register_action(
-    "climate.haier.display_on", DisplayOnAction, HAIER_BASE_ACTION_SCHEMA
+    "climate.haier.display_on",
+    DisplayOnAction,
+    HAIER_BASE_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "climate.haier.display_off", DisplayOffAction, HAIER_BASE_ACTION_SCHEMA
+    "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])
@@ -330,10 +336,16 @@ async def display_action_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "climate.haier.beeper_on", BeeperOnAction, HAIER_HON_BASE_ACTION_SCHEMA
+    "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
+    "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])
@@ -345,11 +357,13 @@ async def beeper_action_to_code(config, action_id, template_arg, args):
     "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])
@@ -368,6 +382,7 @@ async def start_cleaning_to_code(config, action_id, template_arg, args):
             ),
         }
     ),
+    synchronous=True,
 )
 async def haier_set_vertical_airflow_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -391,6 +406,7 @@ async def haier_set_vertical_airflow_to_code(config, action_id, template_arg, ar
             ),
         }
     ),
+    synchronous=True,
 )
 async def haier_set_horizontal_airflow_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -403,10 +419,16 @@ async def haier_set_horizontal_airflow_to_code(config, action_id, template_arg,
 
 
 @automation.register_action(
-    "climate.haier.health_on", HealthOnAction, HAIER_BASE_ACTION_SCHEMA
+    "climate.haier.health_on",
+    HealthOnAction,
+    HAIER_BASE_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "climate.haier.health_off", HealthOffAction, HAIER_BASE_ACTION_SCHEMA
+    "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])
@@ -414,13 +436,22 @@ async def health_action_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "climate.haier.power_on", PowerOnAction, HAIER_BASE_ACTION_SCHEMA
+    "climate.haier.power_on",
+    PowerOnAction,
+    HAIER_BASE_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "climate.haier.power_off", PowerOffAction, HAIER_BASE_ACTION_SCHEMA
+    "climate.haier.power_off",
+    PowerOffAction,
+    HAIER_BASE_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "climate.haier.power_toggle", PowerToggleAction, HAIER_BASE_ACTION_SCHEMA
+    "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])
diff --git a/esphome/components/hbridge/fan/__init__.py b/esphome/components/hbridge/fan/__init__.py
index 7a86c1b6b7a..cae966a9656 100644
--- a/esphome/components/hbridge/fan/__init__.py
+++ b/esphome/components/hbridge/fan/__init__.py
@@ -52,6 +52,7 @@ CONFIG_SCHEMA = (
     "fan.hbridge.brake",
     BrakeAction,
     maybe_simple_id({cv.GenerateID(): cv.use_id(HBridgeFan)}),
+    synchronous=True,
 )
 async def fan_hbridge_brake_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/hc8/sensor.py b/esphome/components/hc8/sensor.py
index 2f39b47f3cd..29b428e3109 100644
--- a/esphome/components/hc8/sensor.py
+++ b/esphome/components/hc8/sensor.py
@@ -68,7 +68,10 @@ CALIBRATION_ACTION_SCHEMA = cv.Schema(
 
 
 @automation.register_action(
-    "hc8.calibrate", HC8CalibrateAction, CALIBRATION_ACTION_SCHEMA
+    "hc8.calibrate",
+    HC8CalibrateAction,
+    CALIBRATION_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def hc8_calibration_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/hdc302x/sensor.py b/esphome/components/hdc302x/sensor.py
index 7215a4cfb7a..a6265b9b980 100644
--- a/esphome/components/hdc302x/sensor.py
+++ b/esphome/components/hdc302x/sensor.py
@@ -114,7 +114,10 @@ HDC302X_HEATER_ON_ACTION_SCHEMA = maybe_simple_id(
 
 
 @automation.register_action(
-    "hdc302x.heater_on", HeaterOnAction, HDC302X_HEATER_ON_ACTION_SCHEMA
+    "hdc302x.heater_on",
+    HeaterOnAction,
+    HDC302X_HEATER_ON_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def hdc302x_heater_on_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -127,7 +130,10 @@ async def hdc302x_heater_on_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "hdc302x.heater_off", HeaterOffAction, HDC302X_ACTION_SCHEMA
+    "hdc302x.heater_off",
+    HeaterOffAction,
+    HDC302X_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def hdc302x_heater_off_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/hlk_fm22x/__init__.py b/esphome/components/hlk_fm22x/__init__.py
index efd64b65139..cb6d5cdfd6d 100644
--- a/esphome/components/hlk_fm22x/__init__.py
+++ b/esphome/components/hlk_fm22x/__init__.py
@@ -170,6 +170,7 @@ async def to_code(config):
         },
         key=CONF_NAME,
     ),
+    synchronous=True,
 )
 async def hlk_fm22x_enroll_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -192,6 +193,7 @@ async def hlk_fm22x_enroll_to_code(config, action_id, template_arg, args):
         },
         key=CONF_FACE_ID,
     ),
+    synchronous=True,
 )
 async def hlk_fm22x_delete_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -210,6 +212,7 @@ async def hlk_fm22x_delete_to_code(config, action_id, template_arg, args):
             cv.GenerateID(): cv.use_id(HlkFm22xComponent),
         }
     ),
+    synchronous=True,
 )
 async def hlk_fm22x_delete_all_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -225,6 +228,7 @@ async def hlk_fm22x_delete_all_to_code(config, action_id, template_arg, args):
             cv.GenerateID(): cv.use_id(HlkFm22xComponent),
         }
     ),
+    synchronous=True,
 )
 async def hlk_fm22x_scan_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -240,6 +244,7 @@ async def hlk_fm22x_scan_to_code(config, action_id, template_arg, args):
             cv.GenerateID(): cv.use_id(HlkFm22xComponent),
         }
     ),
+    synchronous=True,
 )
 async def hlk_fm22x_reset_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/http_request/__init__.py b/esphome/components/http_request/__init__.py
index 81337ebdf6e..416432cfc44 100644
--- a/esphome/components/http_request/__init__.py
+++ b/esphome/components/http_request/__init__.py
@@ -279,13 +279,22 @@ HTTP_REQUEST_SEND_ACTION_SCHEMA = HTTP_REQUEST_ACTION_SCHEMA.extend(
 
 
 @automation.register_action(
-    "http_request.get", HttpRequestSendAction, HTTP_REQUEST_GET_ACTION_SCHEMA
+    "http_request.get",
+    HttpRequestSendAction,
+    HTTP_REQUEST_GET_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "http_request.post", HttpRequestSendAction, HTTP_REQUEST_POST_ACTION_SCHEMA
+    "http_request.post",
+    HttpRequestSendAction,
+    HTTP_REQUEST_POST_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "http_request.send", HttpRequestSendAction, HTTP_REQUEST_SEND_ACTION_SCHEMA
+    "http_request.send",
+    HttpRequestSendAction,
+    HTTP_REQUEST_SEND_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def http_request_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/http_request/ota/__init__.py b/esphome/components/http_request/ota/__init__.py
index d2c574d8c61..fb59e51943f 100644
--- a/esphome/components/http_request/ota/__init__.py
+++ b/esphome/components/http_request/ota/__init__.py
@@ -70,6 +70,7 @@ OTA_HTTP_REQUEST_FLASH_ACTION_SCHEMA = cv.All(
     "ota.http_request.flash",
     OtaHttpRequestComponentFlashAction,
     OTA_HTTP_REQUEST_FLASH_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def ota_http_request_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/htu21d/sensor.py b/esphome/components/htu21d/sensor.py
index a578670e375..92c088a22fa 100644
--- a/esphome/components/htu21d/sensor.py
+++ b/esphome/components/htu21d/sensor.py
@@ -93,6 +93,7 @@ async def to_code(config):
         },
         key=CONF_LEVEL,
     ),
+    synchronous=True,
 )
 async def set_heater_level_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -112,6 +113,7 @@ async def set_heater_level_to_code(config, action_id, template_arg, args):
         },
         key=CONF_STATUS,
     ),
+    synchronous=True,
 )
 async def set_heater_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/hub75/display.py b/esphome/components/hub75/display.py
index f1e6ef42438..4f62ce7a94a 100644
--- a/esphome/components/hub75/display.py
+++ b/esphome/components/hub75/display.py
@@ -652,6 +652,7 @@ async def to_code(config: ConfigType) -> None:
         },
         key=CONF_BRIGHTNESS,
     ),
+    synchronous=True,
 )
 async def hub75_set_brightness_to_code(
     config: ConfigType,
diff --git a/esphome/components/integration/sensor.py b/esphome/components/integration/sensor.py
index 26766385565..d0aae4201e4 100644
--- a/esphome/components/integration/sensor.py
+++ b/esphome/components/integration/sensor.py
@@ -111,6 +111,7 @@ async def to_code(config):
             cv.Required(CONF_ID): cv.use_id(IntegrationSensor),
         }
     ),
+    synchronous=True,
 )
 async def sensor_integration_reset_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -127,6 +128,7 @@ async def sensor_integration_reset_to_code(config, action_id, template_arg, args
             cv.Required(CONF_VALUE): cv.templatable(cv.float_),
         }
     ),
+    synchronous=True,
 )
 async def sensor_integration_set_value_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/key_collector/__init__.py b/esphome/components/key_collector/__init__.py
index badb28c32ca..1f4519df2d0 100644
--- a/esphome/components/key_collector/__init__.py
+++ b/esphome/components/key_collector/__init__.py
@@ -142,6 +142,7 @@ async def to_code(config):
             cv.GenerateID(): cv.use_id(KeyCollector),
         }
     ),
+    synchronous=True,
 )
 async def enable_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -157,6 +158,7 @@ async def enable_to_code(config, action_id, template_arg, args):
             cv.GenerateID(): cv.use_id(KeyCollector),
         }
     ),
+    synchronous=True,
 )
 async def disable_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/ld2410/__init__.py b/esphome/components/ld2410/__init__.py
index b492bbcd149..360e56330af 100644
--- a/esphome/components/ld2410/__init__.py
+++ b/esphome/components/ld2410/__init__.py
@@ -97,7 +97,10 @@ BLUETOOTH_PASSWORD_SET_SCHEMA = cv.Schema(
 
 
 @automation.register_action(
-    "bluetooth_password.set", BluetoothPasswordSetAction, BLUETOOTH_PASSWORD_SET_SCHEMA
+    "bluetooth_password.set",
+    BluetoothPasswordSetAction,
+    BLUETOOTH_PASSWORD_SET_SCHEMA,
+    synchronous=True,
 )
 async def bluetooth_password_set_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/ledc/output.py b/esphome/components/ledc/output.py
index 7a45b9dc3f6..62ff5ad30ac 100644
--- a/esphome/components/ledc/output.py
+++ b/esphome/components/ledc/output.py
@@ -77,6 +77,7 @@ async def to_code(config):
             cv.Required(CONF_FREQUENCY): cv.templatable(validate_frequency),
         }
     ),
+    synchronous=True,
 )
 async def ledc_set_frequency_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/libretiny_pwm/output.py b/esphome/components/libretiny_pwm/output.py
index 28556514d89..e812b6a8f25 100644
--- a/esphome/components/libretiny_pwm/output.py
+++ b/esphome/components/libretiny_pwm/output.py
@@ -38,6 +38,7 @@ async def to_code(config):
             cv.Required(CONF_FREQUENCY): cv.templatable(cv.int_),
         }
     ),
+    synchronous=True,
 )
 async def libretiny_pwm_set_frequency_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/light/automation.py b/esphome/components/light/automation.py
index 08fd26a9379..55273003b95 100644
--- a/esphome/components/light/automation.py
+++ b/esphome/components/light/automation.py
@@ -278,7 +278,10 @@ LIGHT_ADDRESSABLE_SET_ACTION_SCHEMA = cv.Schema(
 
 
 @automation.register_action(
-    "light.addressable_set", AddressableSet, LIGHT_ADDRESSABLE_SET_ACTION_SCHEMA
+    "light.addressable_set",
+    AddressableSet,
+    LIGHT_ADDRESSABLE_SET_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def light_addressable_set_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/lightwaverf/__init__.py b/esphome/components/lightwaverf/__init__.py
index 802b341601b..acbbbb4de97 100644
--- a/esphome/components/lightwaverf/__init__.py
+++ b/esphome/components/lightwaverf/__init__.py
@@ -55,6 +55,7 @@ LIGHTWAVE_SEND_SCHEMA = cv.Any(
     "lightwaverf.send_raw",
     LightwaveRawAction,
     LIGHTWAVE_SEND_SCHEMA,
+    synchronous=True,
 )
 async def send_raw_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/lock/__init__.py b/esphome/components/lock/__init__.py
index e37092756fb..fe4db23ae3a 100644
--- a/esphome/components/lock/__init__.py
+++ b/esphome/components/lock/__init__.py
@@ -129,9 +129,15 @@ LOCK_ACTION_SCHEMA = maybe_simple_id(
 )
 
 
-@automation.register_action("lock.unlock", UnlockAction, LOCK_ACTION_SCHEMA)
-@automation.register_action("lock.lock", LockAction, LOCK_ACTION_SCHEMA)
-@automation.register_action("lock.open", OpenAction, LOCK_ACTION_SCHEMA)
+@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, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
     return cg.new_Pvariable(action_id, template_arg, paren)
diff --git a/esphome/components/logger/__init__.py b/esphome/components/logger/__init__.py
index 026b8aaf246..e370f4215d4 100644
--- a/esphome/components/logger/__init__.py
+++ b/esphome/components/logger/__init__.py
@@ -337,6 +337,10 @@ async def to_code(config):
     )
     if CORE.is_esp32:
         cg.add(log.create_pthread_key())
+    # pre_setup() must be called before init_log_buffer() because
+    # init_log_buffer() calls disable_loop() which may log at VV level,
+    # and global_logger must be set before any logging occurs.
+    cg.add(log.pre_setup())
     if CORE.is_esp32 or CORE.is_libretiny or CORE.is_nrf52:
         task_log_buffer_size = config[CONF_TASK_LOG_BUFFER_SIZE]
         if task_log_buffer_size > 0:
@@ -356,7 +360,6 @@ async def to_code(config):
                 HARDWARE_UART_TO_UART_SELECTION[config[CONF_HARDWARE_UART]]
             )
         )
-    cg.add(log.pre_setup())
 
     # Enable runtime tag levels if logs are configured or explicitly enabled
     logs_config = config[CONF_LOGS]
@@ -545,6 +548,7 @@ async def logger_log_action_to_code(config, action_id, template_arg, args):
         },
         key=CONF_LEVEL,
     ),
+    synchronous=True,
 )
 async def logger_set_level_to_code(config, action_id, template_arg, args):
     level = LOG_LEVELS[config[CONF_LEVEL]]
diff --git a/esphome/components/lvgl/automation.py b/esphome/components/lvgl/automation.py
index b589e42f3b7..f9adca9c337 100644
--- a/esphome/components/lvgl/automation.py
+++ b/esphome/components/lvgl/automation.py
@@ -182,6 +182,7 @@ async def disp_update(disp, config: dict):
         ),
         LVGL_SCHEMA,
     ),
+    synchronous=True,
 )
 async def obj_invalidate_to_code(config, action_id, template_arg, args):
     if CONF_LVGL_ID in config:
@@ -202,6 +203,7 @@ async def obj_invalidate_to_code(config, action_id, template_arg, args):
     DISP_BG_SCHEMA.extend(LVGL_SCHEMA).add_extra(
         cv.has_at_least_one_key(CONF_DISP_BG_COLOR, CONF_DISP_BG_IMAGE)
     ),
+    synchronous=True,
 )
 async def lvgl_update_to_code(config, action_id, template_arg, args):
     widgets = await get_widgets(config, CONF_LVGL_ID)
@@ -222,6 +224,7 @@ async def lvgl_update_to_code(config, action_id, template_arg, args):
             cv.Optional(CONF_SHOW_SNOW, default=False): lv_bool,
         }
     ),
+    synchronous=True,
 )
 async def pause_action_to_code(config, action_id, template_arg, args):
     lv_comp = await cg.get_variable(config[CONF_LVGL_ID])
@@ -237,6 +240,7 @@ async def pause_action_to_code(config, action_id, template_arg, args):
     "lvgl.resume",
     LvglAction,
     LVGL_SCHEMA,
+    synchronous=True,
 )
 async def resume_action_to_code(config, action_id, template_arg, args):
     lv_comp = await cg.get_variable(config[CONF_LVGL_ID])
@@ -247,7 +251,9 @@ async def resume_action_to_code(config, action_id, template_arg, args):
     return var
 
 
-@automation.register_action("lvgl.widget.disable", ObjUpdateAction, LIST_ACTION_SCHEMA)
+@automation.register_action(
+    "lvgl.widget.disable", ObjUpdateAction, LIST_ACTION_SCHEMA, synchronous=True
+)
 async def obj_disable_to_code(config, action_id, template_arg, args):
     async def do_disable(widget: Widget):
         widget.add_state(LV_STATE.DISABLED)
@@ -257,7 +263,9 @@ async def obj_disable_to_code(config, action_id, template_arg, args):
     )
 
 
-@automation.register_action("lvgl.widget.enable", ObjUpdateAction, LIST_ACTION_SCHEMA)
+@automation.register_action(
+    "lvgl.widget.enable", ObjUpdateAction, LIST_ACTION_SCHEMA, synchronous=True
+)
 async def obj_enable_to_code(config, action_id, template_arg, args):
     async def do_enable(widget: Widget):
         widget.clear_state(LV_STATE.DISABLED)
@@ -267,7 +275,9 @@ async def obj_enable_to_code(config, action_id, template_arg, args):
     )
 
 
-@automation.register_action("lvgl.widget.hide", ObjUpdateAction, LIST_ACTION_SCHEMA)
+@automation.register_action(
+    "lvgl.widget.hide", ObjUpdateAction, LIST_ACTION_SCHEMA, synchronous=True
+)
 async def obj_hide_to_code(config, action_id, template_arg, args):
     async def do_hide(widget: Widget):
         widget.add_flag("LV_OBJ_FLAG_HIDDEN")
@@ -276,7 +286,9 @@ async def obj_hide_to_code(config, action_id, template_arg, args):
     return await action_to_code(widgets, do_hide, action_id, template_arg, args)
 
 
-@automation.register_action("lvgl.widget.show", ObjUpdateAction, LIST_ACTION_SCHEMA)
+@automation.register_action(
+    "lvgl.widget.show", ObjUpdateAction, LIST_ACTION_SCHEMA, synchronous=True
+)
 async def obj_show_to_code(config, action_id, template_arg, args):
     async def do_show(widget: Widget):
         widget.clear_flag("LV_OBJ_FLAG_HIDDEN")
@@ -318,6 +330,7 @@ def focused_id(value):
             key=CONF_ID,
         ),
     ),
+    synchronous=True,
 )
 async def widget_focus(config, action_id, template_arg, args):
     widget = await get_widgets(config)
@@ -357,7 +370,10 @@ async def widget_focus(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "lvgl.widget.update", ObjUpdateAction, base_update_schema(lv_obj_base_t, PARTS)
+    "lvgl.widget.update",
+    ObjUpdateAction,
+    base_update_schema(lv_obj_base_t, PARTS),
+    synchronous=True,
 )
 async def obj_update_to_code(config, action_id, template_arg, args):
     async def do_update(widget: Widget):
@@ -389,6 +405,7 @@ def validate_refresh_config(config):
         ),
         validate_refresh_config,
     ),
+    synchronous=True,
 )
 async def obj_refresh_to_code(config, action_id, template_arg, args):
     widget = await get_widgets(config)
diff --git a/esphome/components/lvgl/styles.py b/esphome/components/lvgl/styles.py
index 3969c9f3887..b9801b41332 100644
--- a/esphome/components/lvgl/styles.py
+++ b/esphome/components/lvgl/styles.py
@@ -59,6 +59,7 @@ async def styles_to_code(config):
             cv.Required(CONF_ID): cv.use_id(lv_style_t),
         }
     ),
+    synchronous=True,
 )
 async def style_update_to_code(config, action_id, template_arg, args):
     await wait_for_widgets()
diff --git a/esphome/components/lvgl/types.py b/esphome/components/lvgl/types.py
index 9c92ca7e986..09d40bb7efe 100644
--- a/esphome/components/lvgl/types.py
+++ b/esphome/components/lvgl/types.py
@@ -164,6 +164,7 @@ class WidgetType:
                 f"lvgl.{self.name}.update",
                 ObjUpdateAction,
                 base_update_schema(self, self.parts).extend(self.modify_schema),
+                synchronous=True,
             )(update_to_code)
 
     @property
diff --git a/esphome/components/lvgl/widgets/animimg.py b/esphome/components/lvgl/widgets/animimg.py
index b824d28fb84..8e2db5ff350 100644
--- a/esphome/components/lvgl/widgets/animimg.py
+++ b/esphome/components/lvgl/widgets/animimg.py
@@ -83,6 +83,7 @@ animimg_spec = AnimimgType()
         },
         key=CONF_ID,
     ),
+    synchronous=True,
 )
 async def animimg_start(config, action_id, template_arg, args):
     widget = await get_widgets(config)
@@ -102,6 +103,7 @@ async def animimg_start(config, action_id, template_arg, args):
         },
         key=CONF_ID,
     ),
+    synchronous=True,
 )
 async def animimg_stop(config, action_id, template_arg, args):
     widget = await get_widgets(config)
diff --git a/esphome/components/lvgl/widgets/buttonmatrix.py b/esphome/components/lvgl/widgets/buttonmatrix.py
index fe421aa4770..f94f12b69b2 100644
--- a/esphome/components/lvgl/widgets/buttonmatrix.py
+++ b/esphome/components/lvgl/widgets/buttonmatrix.py
@@ -245,6 +245,7 @@ buttonmatrix_spec = ButtonMatrixType()
             cv.Optional(CONF_SELECTED): lv_bool,
         }
     ),
+    synchronous=True,
 )
 async def button_update_to_code(config, action_id, template_arg, args):
     widgets = await get_widgets(config[CONF_ID])
diff --git a/esphome/components/lvgl/widgets/canvas.py b/esphome/components/lvgl/widgets/canvas.py
index ead352aa77d..50cc8b0af62 100644
--- a/esphome/components/lvgl/widgets/canvas.py
+++ b/esphome/components/lvgl/widgets/canvas.py
@@ -97,6 +97,7 @@ canvas_spec = CanvasType()
             cv.Optional(CONF_OPA, default="COVER"): opacity,
         },
     ),
+    synchronous=True,
 )
 async def canvas_fill(config, action_id, template_arg, args):
     widget = await get_widgets(config)
@@ -120,6 +121,7 @@ async def canvas_fill(config, action_id, template_arg, args):
             cv.Required(CONF_POINTS): cv.ensure_list(point_schema),
         },
     ),
+    synchronous=True,
 )
 async def canvas_set_pixel(config, action_id, template_arg, args):
     widget = await get_widgets(config)
@@ -229,6 +231,7 @@ RECT_PROPS = {
             **{cv.Optional(prop): STYLE_PROPS[prop] for prop in RECT_PROPS},
         }
     ),
+    synchronous=True,
 )
 async def canvas_draw_rect(config, action_id, template_arg, args):
     width = await pixels.process(config[CONF_WIDTH])
@@ -268,6 +271,7 @@ TEXT_PROPS = {
             **{cv.Optional(prop): STYLE_PROPS[f"text_{prop}"] for prop in TEXT_PROPS},
         },
     ),
+    synchronous=True,
 )
 async def canvas_draw_text(config, action_id, template_arg, args):
     text = await lv_text.process(config[CONF_TEXT])
@@ -302,6 +306,7 @@ IMG_PROPS = {
             **{cv.Optional(prop): validator for prop, validator in IMG_PROPS.items()},
         }
     ),
+    synchronous=True,
 )
 async def canvas_draw_image(config, action_id, template_arg, args):
     src = await lv_image.process(config[CONF_SRC])
@@ -341,6 +346,7 @@ LINE_PROPS = {
             **{cv.Optional(prop): validator for prop, validator in LINE_PROPS.items()},
         }
     ),
+    synchronous=True,
 )
 async def canvas_draw_line(config, action_id, template_arg, args):
     points = [
@@ -369,6 +375,7 @@ async def canvas_draw_line(config, action_id, template_arg, args):
             **{cv.Optional(prop): STYLE_PROPS[prop] for prop in RECT_PROPS},
         },
     ),
+    synchronous=True,
 )
 async def canvas_draw_polygon(config, action_id, template_arg, args):
     points = [
@@ -408,6 +415,7 @@ ARC_PROPS = {
             **{cv.Optional(prop): validator for prop, validator in ARC_PROPS.items()},
         }
     ),
+    synchronous=True,
 )
 async def canvas_draw_arc(config, action_id, template_arg, args):
     radius = await size.process(config[CONF_RADIUS])
diff --git a/esphome/components/lvgl/widgets/meter.py b/esphome/components/lvgl/widgets/meter.py
index aefda0e71a3..b7e3af9a788 100644
--- a/esphome/components/lvgl/widgets/meter.py
+++ b/esphome/components/lvgl/widgets/meter.py
@@ -297,6 +297,7 @@ meter_spec = MeterType()
             cv.Optional(CONF_OPA): opacity,
         }
     ),
+    synchronous=True,
 )
 async def indicator_update_to_code(config, action_id, template_arg, args):
     widget = await get_widgets(config)
diff --git a/esphome/components/lvgl/widgets/page.py b/esphome/components/lvgl/widgets/page.py
index 23c162e010e..7e75ab6a2da 100644
--- a/esphome/components/lvgl/widgets/page.py
+++ b/esphome/components/lvgl/widgets/page.py
@@ -85,6 +85,7 @@ page_spec = PageType()
     "lvgl.page.next",
     LvglAction,
     SHOW_SCHEMA,
+    synchronous=True,
 )
 async def page_next_to_code(config, action_id, template_arg, args):
     animation = await LV_ANIM.process(config[CONF_ANIMATION])
@@ -125,6 +126,7 @@ async def page_is_showing_to_code(config, condition_id, template_arg, args):
     "lvgl.page.previous",
     LvglAction,
     SHOW_SCHEMA,
+    synchronous=True,
 )
 async def page_previous_to_code(config, action_id, template_arg, args):
     animation = await LV_ANIM.process(config[CONF_ANIMATION])
@@ -148,6 +150,7 @@ async def page_previous_to_code(config, action_id, template_arg, args):
         ),
         key=CONF_ID,
     ),
+    synchronous=True,
 )
 async def page_show_to_code(config, action_id, template_arg, args):
     widget = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/lvgl/widgets/spinbox.py b/esphome/components/lvgl/widgets/spinbox.py
index c6f25e9587c..58e3435c5c7 100644
--- a/esphome/components/lvgl/widgets/spinbox.py
+++ b/esphome/components/lvgl/widgets/spinbox.py
@@ -147,6 +147,7 @@ spinbox_spec = SpinboxType()
         },
         key=CONF_ID,
     ),
+    synchronous=True,
 )
 async def spinbox_increment(config, action_id, template_arg, args):
     widgets = await get_widgets(config)
@@ -166,6 +167,7 @@ async def spinbox_increment(config, action_id, template_arg, args):
         },
         key=CONF_ID,
     ),
+    synchronous=True,
 )
 async def spinbox_decrement(config, action_id, template_arg, args):
     widgets = await get_widgets(config)
diff --git a/esphome/components/lvgl/widgets/tabview.py b/esphome/components/lvgl/widgets/tabview.py
index e8931bab7ca..cd7cf7b4716 100644
--- a/esphome/components/lvgl/widgets/tabview.py
+++ b/esphome/components/lvgl/widgets/tabview.py
@@ -109,6 +109,7 @@ tabview_spec = TabviewType()
             cv.Required(CONF_INDEX): lv_int,
         },
     ).add_extra(cv.has_at_least_one_key(CONF_INDEX, CONF_TAB_ID)),
+    synchronous=True,
 )
 async def tabview_select(config, action_id, template_arg, args):
     widget = await get_widgets(config)
diff --git a/esphome/components/lvgl/widgets/tileview.py b/esphome/components/lvgl/widgets/tileview.py
index 5e3a95f017b..430a386d2e2 100644
--- a/esphome/components/lvgl/widgets/tileview.py
+++ b/esphome/components/lvgl/widgets/tileview.py
@@ -112,6 +112,7 @@ def tile_select_validate(config):
             cv.Optional(CONF_TILE_ID): cv.use_id(lv_tile_t),
         },
     ).add_extra(tile_select_validate),
+    synchronous=True,
 )
 async def tileview_select(config, action_id, template_arg, args):
     widgets = await get_widgets(config)
diff --git a/esphome/components/max17043/sensor.py b/esphome/components/max17043/sensor.py
index 3da0f953b09..ebb045dfcea 100644
--- a/esphome/components/max17043/sensor.py
+++ b/esphome/components/max17043/sensor.py
@@ -71,7 +71,9 @@ MAX17043_ACTION_SCHEMA = maybe_simple_id(
 )
 
 
-@automation.register_action("max17043.sleep_mode", SleepAction, MAX17043_ACTION_SCHEMA)
+@automation.register_action(
+    "max17043.sleep_mode", SleepAction, MAX17043_ACTION_SCHEMA, synchronous=True
+)
 async def max17043_sleep_mode_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)
diff --git a/esphome/components/max6956/__init__.py b/esphome/components/max6956/__init__.py
index 0d2ff527c7d..be6390fc17f 100644
--- a/esphome/components/max6956/__init__.py
+++ b/esphome/components/max6956/__init__.py
@@ -112,6 +112,7 @@ async def max6956_pin_to_code(config):
         },
         key=CONF_BRIGHTNESS_GLOBAL,
     ),
+    synchronous=True,
 )
 async def max6956_set_brightness_global_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -133,6 +134,7 @@ async def max6956_set_brightness_global_to_code(config, action_id, template_arg,
         },
         key=CONF_BRIGHTNESS_MODE,
     ),
+    synchronous=True,
 )
 async def max6956_set_brightness_mode_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/max7219digit/display.py b/esphome/components/max7219digit/display.py
index a251eaccea5..eb751b995d1 100644
--- a/esphome/components/max7219digit/display.py
+++ b/esphome/components/max7219digit/display.py
@@ -133,10 +133,16 @@ MAX7219_ON_ACTION_SCHEMA = automation.maybe_simple_id(
 
 
 @automation.register_action(
-    "max7219digit.invert_off", DisplayInvertAction, MAX7219_OFF_ACTION_SCHEMA
+    "max7219digit.invert_off",
+    DisplayInvertAction,
+    MAX7219_OFF_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "max7219digit.invert_on", DisplayInvertAction, MAX7219_ON_ACTION_SCHEMA
+    "max7219digit.invert_on",
+    DisplayInvertAction,
+    MAX7219_ON_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def max7219digit_invert_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -146,10 +152,16 @@ async def max7219digit_invert_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "max7219digit.turn_off", DisplayVisibilityAction, MAX7219_OFF_ACTION_SCHEMA
+    "max7219digit.turn_off",
+    DisplayVisibilityAction,
+    MAX7219_OFF_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "max7219digit.turn_on", DisplayVisibilityAction, MAX7219_ON_ACTION_SCHEMA
+    "max7219digit.turn_on",
+    DisplayVisibilityAction,
+    MAX7219_ON_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def max7219digit_visible_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -159,10 +171,16 @@ async def max7219digit_visible_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "max7219digit.reverse_off", DisplayReverseAction, MAX7219_OFF_ACTION_SCHEMA
+    "max7219digit.reverse_off",
+    DisplayReverseAction,
+    MAX7219_OFF_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "max7219digit.reverse_on", DisplayReverseAction, MAX7219_ON_ACTION_SCHEMA
+    "max7219digit.reverse_on",
+    DisplayReverseAction,
+    MAX7219_ON_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def max7219digit_reverse_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -183,7 +201,10 @@ MAX7219_INTENSITY_SCHEMA = cv.maybe_simple_value(
 
 
 @automation.register_action(
-    "max7219digit.intensity", DisplayIntensityAction, MAX7219_INTENSITY_SCHEMA
+    "max7219digit.intensity",
+    DisplayIntensityAction,
+    MAX7219_INTENSITY_SCHEMA,
+    synchronous=True,
 )
 async def max7219digit_intensity_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/media_player/__init__.py b/esphome/components/media_player/__init__.py
index 051e386eaf7..a5baca29940 100644
--- a/esphome/components/media_player/__init__.py
+++ b/esphome/components/media_player/__init__.py
@@ -177,6 +177,7 @@ MEDIA_PLAYER_CONDITION_SCHEMA = automation.maybe_simple_id(
         },
         key=CONF_MEDIA_URL,
     ),
+    synchronous=True,
 )
 async def media_player_play_media_action(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -206,7 +207,10 @@ def _register_command_actions():
             class_name, automation.Action, cg.Parented.template(MediaPlayer)
         )
         automation.register_action(
-            f"media_player.{action_name}", action_class, MEDIA_PLAYER_ACTION_SCHEMA
+            f"media_player.{action_name}",
+            action_class,
+            MEDIA_PLAYER_ACTION_SCHEMA,
+            synchronous=True,
         )(handler)
 
 
@@ -242,6 +246,7 @@ _register_state_conditions()
         },
         key=CONF_VOLUME,
     ),
+    synchronous=True,
 )
 async def media_player_volume_set_action(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/mhz19/sensor.py b/esphome/components/mhz19/sensor.py
index 2841afde7ac..b7d0ad1998e 100644
--- a/esphome/components/mhz19/sensor.py
+++ b/esphome/components/mhz19/sensor.py
@@ -112,13 +112,22 @@ NO_ARGS_ACTION_SCHEMA = maybe_simple_id(
 
 
 @automation.register_action(
-    "mhz19.calibrate_zero", MHZ19CalibrateZeroAction, NO_ARGS_ACTION_SCHEMA
+    "mhz19.calibrate_zero",
+    MHZ19CalibrateZeroAction,
+    NO_ARGS_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "mhz19.abc_enable", MHZ19ABCEnableAction, NO_ARGS_ACTION_SCHEMA
+    "mhz19.abc_enable",
+    MHZ19ABCEnableAction,
+    NO_ARGS_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "mhz19.abc_disable", MHZ19ABCDisableAction, NO_ARGS_ACTION_SCHEMA
+    "mhz19.abc_disable",
+    MHZ19ABCDisableAction,
+    NO_ARGS_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def mhz19_no_args_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -137,7 +146,10 @@ RANGE_ACTION_SCHEMA = maybe_simple_id(
 
 
 @automation.register_action(
-    "mhz19.detection_range_set", MHZ19DetectionRangeSetAction, RANGE_ACTION_SCHEMA
+    "mhz19.detection_range_set",
+    MHZ19DetectionRangeSetAction,
+    RANGE_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def mhz19_detection_range_set_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/micro_wake_word/__init__.py b/esphome/components/micro_wake_word/__init__.py
index 74696584da9..372eb4c3b00 100644
--- a/esphome/components/micro_wake_word/__init__.py
+++ b/esphome/components/micro_wake_word/__init__.py
@@ -529,8 +529,15 @@ async def to_code(config):
 MICRO_WAKE_WORD_ACTION_SCHEMA = cv.Schema({cv.GenerateID(): cv.use_id(MicroWakeWord)})
 
 
-@register_action("micro_wake_word.start", StartAction, MICRO_WAKE_WORD_ACTION_SCHEMA)
-@register_action("micro_wake_word.stop", StopAction, MICRO_WAKE_WORD_ACTION_SCHEMA)
+@register_action(
+    "micro_wake_word.start",
+    StartAction,
+    MICRO_WAKE_WORD_ACTION_SCHEMA,
+    synchronous=True,
+)
+@register_action(
+    "micro_wake_word.stop", StopAction, MICRO_WAKE_WORD_ACTION_SCHEMA, synchronous=True
+)
 @register_condition(
     "micro_wake_word.is_running", IsRunningCondition, MICRO_WAKE_WORD_ACTION_SCHEMA
 )
@@ -551,11 +558,13 @@ MICRO_WAKE_WORLD_MODEL_ACTION_SCHEMA = automation.maybe_simple_id(
     "micro_wake_word.enable_model",
     EnableModelAction,
     MICRO_WAKE_WORLD_MODEL_ACTION_SCHEMA,
+    synchronous=True,
 )
 @register_action(
     "micro_wake_word.disable_model",
     DisableModelAction,
     MICRO_WAKE_WORLD_MODEL_ACTION_SCHEMA,
+    synchronous=True,
 )
 @register_condition(
     "micro_wake_word.model_is_enabled",
diff --git a/esphome/components/microphone/__init__.py b/esphome/components/microphone/__init__.py
index ce314844134..6b5ee8c3e19 100644
--- a/esphome/components/microphone/__init__.py
+++ b/esphome/components/microphone/__init__.py
@@ -190,19 +190,25 @@ async def microphone_action(config, action_id, template_arg, args):
 
 
 automation.register_action(
-    "microphone.capture", CaptureAction, MICROPHONE_ACTION_SCHEMA
+    "microphone.capture",
+    CaptureAction,
+    MICROPHONE_ACTION_SCHEMA,
+    synchronous=True,
 )(microphone_action)
 
 automation.register_action(
-    "microphone.stop_capture", StopCaptureAction, MICROPHONE_ACTION_SCHEMA
+    "microphone.stop_capture",
+    StopCaptureAction,
+    MICROPHONE_ACTION_SCHEMA,
+    synchronous=True,
 )(microphone_action)
 
-automation.register_action("microphone.mute", MuteAction, MICROPHONE_ACTION_SCHEMA)(
-    microphone_action
-)
-automation.register_action("microphone.unmute", UnmuteAction, MICROPHONE_ACTION_SCHEMA)(
-    microphone_action
-)
+automation.register_action(
+    "microphone.mute", MuteAction, MICROPHONE_ACTION_SCHEMA, synchronous=True
+)(microphone_action)
+automation.register_action(
+    "microphone.unmute", UnmuteAction, MICROPHONE_ACTION_SCHEMA, synchronous=True
+)(microphone_action)
 
 automation.register_condition(
     "microphone.is_capturing", IsCapturingCondition, MICROPHONE_ACTION_SCHEMA
diff --git a/esphome/components/midea/climate.py b/esphome/components/midea/climate.py
index 8a3d4f22ba5..c954b450330 100644
--- a/esphome/components/midea/climate.py
+++ b/esphome/components/midea/climate.py
@@ -53,7 +53,9 @@ def templatize(value):
 
 def register_action(name, type_, schema):
     validator = templatize(schema).extend(MIDEA_ACTION_BASE_SCHEMA)
-    registerer = automation.register_action(f"midea_ac.{name}", type_, validator)
+    registerer = automation.register_action(
+        f"midea_ac.{name}", type_, validator, synchronous=True
+    )
 
     def decorator(func):
         async def new_func(config, action_id, template_arg, args):
diff --git a/esphome/components/mixer/speaker/__init__.py b/esphome/components/mixer/speaker/__init__.py
index a3025d71210..63b419cc98e 100644
--- a/esphome/components/mixer/speaker/__init__.py
+++ b/esphome/components/mixer/speaker/__init__.py
@@ -162,6 +162,7 @@ async def to_code(config):
             ),
         }
     ),
+    synchronous=True,
 )
 async def ducking_set_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/mqtt/__init__.py b/esphome/components/mqtt/__init__.py
index c25c4720387..d110d7c1602 100644
--- a/esphome/components/mqtt/__init__.py
+++ b/esphome/components/mqtt/__init__.py
@@ -607,6 +607,7 @@ async def mqtt_connected_to_code(config, condition_id, template_arg, args):
             cv.GenerateID(): cv.use_id(MQTTClientComponent),
         }
     ),
+    synchronous=True,
 )
 async def mqtt_enable_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -621,6 +622,7 @@ async def mqtt_enable_to_code(config, action_id, template_arg, args):
             cv.GenerateID(): cv.use_id(MQTTClientComponent),
         }
     ),
+    synchronous=True,
 )
 async def mqtt_disable_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/nau7802/sensor.py b/esphome/components/nau7802/sensor.py
index 9192f48f53c..9798c1c2970 100644
--- a/esphome/components/nau7802/sensor.py
+++ b/esphome/components/nau7802/sensor.py
@@ -117,16 +117,19 @@ NAU7802_CALIBRATE_SCHEMA = maybe_simple_id(
     "nau7802.calibrate_internal_offset",
     NAU7802CalbrateInternalOffsetAction,
     NAU7802_CALIBRATE_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
     "nau7802.calibrate_external_offset",
     NAU7802CalbrateExternalOffsetAction,
     NAU7802_CALIBRATE_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
     "nau7802.calibrate_gain",
     NAU7802CalbrateGainAction,
     NAU7802_CALIBRATE_SCHEMA,
+    synchronous=True,
 )
 async def nau7802_calibrate_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/nextion/binary_sensor/__init__.py b/esphome/components/nextion/binary_sensor/__init__.py
index 7ef72c6491b..5b5922887ce 100644
--- a/esphome/components/nextion/binary_sensor/__init__.py
+++ b/esphome/components/nextion/binary_sensor/__init__.py
@@ -70,6 +70,7 @@ async def to_code(config):
             ),
         }
     ),
+    synchronous=True,
 )
 async def sensor_nextion_publish_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/nextion/display.py b/esphome/components/nextion/display.py
index b8fcd5d8cfa..5b2dfc488d2 100644
--- a/esphome/components/nextion/display.py
+++ b/esphome/components/nextion/display.py
@@ -172,6 +172,7 @@ CONFIG_SCHEMA = cv.All(
         },
         key=CONF_BRIGHTNESS,
     ),
+    synchronous=True,
 )
 async def nextion_set_brightness_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/nextion/sensor/__init__.py b/esphome/components/nextion/sensor/__init__.py
index 9802762ff35..cab531f1db6 100644
--- a/esphome/components/nextion/sensor/__init__.py
+++ b/esphome/components/nextion/sensor/__init__.py
@@ -110,6 +110,7 @@ async def to_code(config):
             ),
         }
     ),
+    synchronous=True,
 )
 async def sensor_nextion_publish_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/nextion/switch/__init__.py b/esphome/components/nextion/switch/__init__.py
index 1974ff3b9ea..81e6721d0f9 100644
--- a/esphome/components/nextion/switch/__init__.py
+++ b/esphome/components/nextion/switch/__init__.py
@@ -52,6 +52,7 @@ async def to_code(config):
             ),
         }
     ),
+    synchronous=True,
 )
 async def sensor_nextion_publish_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/nextion/text_sensor/__init__.py b/esphome/components/nextion/text_sensor/__init__.py
index 8fc0a8ceaf0..168a6724979 100644
--- a/esphome/components/nextion/text_sensor/__init__.py
+++ b/esphome/components/nextion/text_sensor/__init__.py
@@ -48,6 +48,7 @@ async def to_code(config):
             ),
         }
     ),
+    synchronous=True,
 )
 async def sensor_nextion_publish_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/online_image/__init__.py b/esphome/components/online_image/__init__.py
index 057244e03d4..35a9de3537e 100644
--- a/esphome/components/online_image/__init__.py
+++ b/esphome/components/online_image/__init__.py
@@ -106,9 +106,14 @@ RELEASE_IMAGE_SCHEMA = automation.maybe_simple_id(
 )
 
 
-@automation.register_action("online_image.set_url", SetUrlAction, SET_URL_SCHEMA)
 @automation.register_action(
-    "online_image.release", ReleaseImageAction, RELEASE_IMAGE_SCHEMA
+    "online_image.set_url", SetUrlAction, SET_URL_SCHEMA, synchronous=True
+)
+@automation.register_action(
+    "online_image.release",
+    ReleaseImageAction,
+    RELEASE_IMAGE_SCHEMA,
+    synchronous=True,
 )
 async def online_image_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/output/__init__.py b/esphome/components/output/__init__.py
index a4c960927ba..a4ce2b2d1a2 100644
--- a/esphome/components/output/__init__.py
+++ b/esphome/components/output/__init__.py
@@ -118,6 +118,7 @@ async def output_set_level_to_code(config, action_id, template_arg, args):
             cv.Required(CONF_MIN_POWER): cv.templatable(cv.percentage),
         }
     ),
+    synchronous=True,
 )
 async def output_set_min_power_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -136,6 +137,7 @@ async def output_set_min_power_to_code(config, action_id, template_arg, args):
             cv.Required(CONF_MAX_POWER): cv.templatable(cv.percentage),
         }
     ),
+    synchronous=True,
 )
 async def output_set_max_power_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/pcf85063/time.py b/esphome/components/pcf85063/time.py
index f3c0c3230f6..8e19178cc99 100644
--- a/esphome/components/pcf85063/time.py
+++ b/esphome/components/pcf85063/time.py
@@ -29,6 +29,7 @@ CONFIG_SCHEMA = time.TIME_SCHEMA.extend(
             cv.GenerateID(): cv.use_id(PCF85063Component),
         }
     ),
+    synchronous=True,
 )
 async def pcf85063_write_time_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -44,6 +45,7 @@ async def pcf85063_write_time_to_code(config, action_id, template_arg, args):
             cv.GenerateID(): cv.use_id(PCF85063Component),
         }
     ),
+    synchronous=True,
 )
 async def pcf85063_read_time_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/pcf8563/time.py b/esphome/components/pcf8563/time.py
index e3b3b572aa3..0d4de3cb73d 100644
--- a/esphome/components/pcf8563/time.py
+++ b/esphome/components/pcf8563/time.py
@@ -32,6 +32,7 @@ CONFIG_SCHEMA = time.TIME_SCHEMA.extend(
             cv.GenerateID(): cv.use_id(pcf8563Component),
         }
     ),
+    synchronous=True,
 )
 async def pcf8563_write_time_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -47,6 +48,7 @@ async def pcf8563_write_time_to_code(config, action_id, template_arg, args):
             cv.GenerateID(): cv.use_id(pcf8563Component),
         }
     ),
+    synchronous=True,
 )
 async def pcf8563_read_time_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/pid/climate.py b/esphome/components/pid/climate.py
index 5fa3166f9df..0e66b676377 100644
--- a/esphome/components/pid/climate.py
+++ b/esphome/components/pid/climate.py
@@ -133,6 +133,7 @@ async def to_code(config):
             cv.Required(CONF_ID): cv.use_id(PIDClimate),
         }
     ),
+    synchronous=True,
 )
 async def pid_reset_integral_term(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -154,6 +155,7 @@ async def pid_reset_integral_term(config, action_id, template_arg, args):
             ): cv.possibly_negative_percentage,
         }
     ),
+    synchronous=True,
 )
 async def esp8266_set_frequency_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -175,6 +177,7 @@ async def esp8266_set_frequency_to_code(config, action_id, template_arg, args):
             cv.Optional(CONF_KD, default=0.0): cv.templatable(cv.float_),
         }
     ),
+    synchronous=True,
 )
 async def set_control_parameters(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/pipsolar/output/__init__.py b/esphome/components/pipsolar/output/__init__.py
index 829f8f70370..81e99e15a29 100644
--- a/esphome/components/pipsolar/output/__init__.py
+++ b/esphome/components/pipsolar/output/__init__.py
@@ -98,6 +98,7 @@ async def to_code(config):
             cv.Required(CONF_VALUE): cv.templatable(cv.positive_float),
         }
     ),
+    synchronous=True,
 )
 async def output_pipsolar_set_level_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/pmwcs3/sensor.py b/esphome/components/pmwcs3/sensor.py
index 075b9b00b52..bb40f3e4995 100644
--- a/esphome/components/pmwcs3/sensor.py
+++ b/esphome/components/pmwcs3/sensor.py
@@ -106,11 +106,13 @@ PMWCS3_CALIBRATION_SCHEMA = cv.Schema(
     "pmwcs3.air_calibration",
     PMWCS3AirCalibrationAction,
     PMWCS3_CALIBRATION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
     "pmwcs3.water_calibration",
     PMWCS3WaterCalibrationAction,
     PMWCS3_CALIBRATION_SCHEMA,
+    synchronous=True,
 )
 async def pmwcs3_calibration_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
@@ -130,6 +132,7 @@ PMWCS3_NEW_I2C_ADDRESS_SCHEMA = cv.maybe_simple_value(
     "pmwcs3.new_i2c_address",
     PMWCS3NewI2cAddressAction,
     PMWCS3_NEW_I2C_ADDRESS_SCHEMA,
+    synchronous=True,
 )
 async def pmwcs3newi2caddress_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/pn7150/__init__.py b/esphome/components/pn7150/__init__.py
index 131b56e30ea..6af14128818 100644
--- a/esphome/components/pn7150/__init__.py
+++ b/esphome/components/pn7150/__init__.py
@@ -119,11 +119,13 @@ PN7150_SCHEMA = cv.Schema(
     "tag.set_emulation_message",
     SetEmulationMessageAction,
     SET_MESSAGE_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
     "tag.set_write_message",
     SetWriteMessageAction,
     SET_MESSAGE_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def pn7150_set_message_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -138,22 +140,43 @@ async def pn7150_set_message_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "tag.emulation_off", EmulationOffAction, SIMPLE_ACTION_SCHEMA
-)
-@automation.register_action("tag.emulation_on", EmulationOnAction, SIMPLE_ACTION_SCHEMA)
-@automation.register_action("tag.polling_off", PollingOffAction, SIMPLE_ACTION_SCHEMA)
-@automation.register_action("tag.polling_on", PollingOnAction, SIMPLE_ACTION_SCHEMA)
-@automation.register_action(
-    "tag.set_clean_mode", SetCleanModeAction, SIMPLE_ACTION_SCHEMA
+    "tag.emulation_off",
+    EmulationOffAction,
+    SIMPLE_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "tag.set_format_mode", SetFormatModeAction, SIMPLE_ACTION_SCHEMA
+    "tag.emulation_on", EmulationOnAction, SIMPLE_ACTION_SCHEMA, synchronous=True
 )
 @automation.register_action(
-    "tag.set_read_mode", SetReadModeAction, SIMPLE_ACTION_SCHEMA
+    "tag.polling_off", PollingOffAction, SIMPLE_ACTION_SCHEMA, synchronous=True
 )
 @automation.register_action(
-    "tag.set_write_mode", SetWriteModeAction, SIMPLE_ACTION_SCHEMA
+    "tag.polling_on", PollingOnAction, SIMPLE_ACTION_SCHEMA, synchronous=True
+)
+@automation.register_action(
+    "tag.set_clean_mode",
+    SetCleanModeAction,
+    SIMPLE_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_action(
+    "tag.set_format_mode",
+    SetFormatModeAction,
+    SIMPLE_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_action(
+    "tag.set_read_mode",
+    SetReadModeAction,
+    SIMPLE_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_action(
+    "tag.set_write_mode",
+    SetWriteModeAction,
+    SIMPLE_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def pn7150_simple_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/pn7160/__init__.py b/esphome/components/pn7160/__init__.py
index 899ecd595ea..54e4b74796b 100644
--- a/esphome/components/pn7160/__init__.py
+++ b/esphome/components/pn7160/__init__.py
@@ -123,11 +123,13 @@ PN7160_SCHEMA = cv.Schema(
     "tag.set_emulation_message",
     SetEmulationMessageAction,
     SET_MESSAGE_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
     "tag.set_write_message",
     SetWriteMessageAction,
     SET_MESSAGE_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def pn7160_set_message_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -142,22 +144,43 @@ async def pn7160_set_message_to_code(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "tag.emulation_off", EmulationOffAction, SIMPLE_ACTION_SCHEMA
-)
-@automation.register_action("tag.emulation_on", EmulationOnAction, SIMPLE_ACTION_SCHEMA)
-@automation.register_action("tag.polling_off", PollingOffAction, SIMPLE_ACTION_SCHEMA)
-@automation.register_action("tag.polling_on", PollingOnAction, SIMPLE_ACTION_SCHEMA)
-@automation.register_action(
-    "tag.set_clean_mode", SetCleanModeAction, SIMPLE_ACTION_SCHEMA
+    "tag.emulation_off",
+    EmulationOffAction,
+    SIMPLE_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "tag.set_format_mode", SetFormatModeAction, SIMPLE_ACTION_SCHEMA
+    "tag.emulation_on", EmulationOnAction, SIMPLE_ACTION_SCHEMA, synchronous=True
 )
 @automation.register_action(
-    "tag.set_read_mode", SetReadModeAction, SIMPLE_ACTION_SCHEMA
+    "tag.polling_off", PollingOffAction, SIMPLE_ACTION_SCHEMA, synchronous=True
 )
 @automation.register_action(
-    "tag.set_write_mode", SetWriteModeAction, SIMPLE_ACTION_SCHEMA
+    "tag.polling_on", PollingOnAction, SIMPLE_ACTION_SCHEMA, synchronous=True
+)
+@automation.register_action(
+    "tag.set_clean_mode",
+    SetCleanModeAction,
+    SIMPLE_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_action(
+    "tag.set_format_mode",
+    SetFormatModeAction,
+    SIMPLE_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_action(
+    "tag.set_read_mode",
+    SetReadModeAction,
+    SIMPLE_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_action(
+    "tag.set_write_mode",
+    SetWriteModeAction,
+    SIMPLE_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def pn7160_simple_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/pulse_counter/sensor.py b/esphome/components/pulse_counter/sensor.py
index 01244635679..c09d778eda2 100644
--- a/esphome/components/pulse_counter/sensor.py
+++ b/esphome/components/pulse_counter/sensor.py
@@ -155,6 +155,7 @@ async def to_code(config):
             cv.Required(CONF_VALUE): cv.templatable(cv.uint32_t),
         }
     ),
+    synchronous=True,
 )
 async def set_total_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/pulse_meter/sensor.py b/esphome/components/pulse_meter/sensor.py
index ca026eefa42..499b7309c88 100644
--- a/esphome/components/pulse_meter/sensor.py
+++ b/esphome/components/pulse_meter/sensor.py
@@ -105,6 +105,7 @@ async def to_code(config):
             cv.Required(CONF_VALUE): cv.templatable(cv.uint32_t),
         }
     ),
+    synchronous=True,
 )
 async def set_total_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/pzemac/sensor.py b/esphome/components/pzemac/sensor.py
index 3af73b86951..fa1c3961d0f 100644
--- a/esphome/components/pzemac/sensor.py
+++ b/esphome/components/pzemac/sensor.py
@@ -88,6 +88,7 @@ CONFIG_SCHEMA = (
             cv.Required(CONF_ID): cv.use_id(PZEMAC),
         }
     ),
+    synchronous=True,
 )
 async def reset_energy_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/pzemdc/sensor.py b/esphome/components/pzemdc/sensor.py
index 383a9dbb2c5..3291be4c341 100644
--- a/esphome/components/pzemdc/sensor.py
+++ b/esphome/components/pzemdc/sensor.py
@@ -72,6 +72,7 @@ CONFIG_SCHEMA = (
             cv.GenerateID(CONF_ID): cv.use_id(PZEMDC),
         }
     ),
+    synchronous=True,
 )
 async def reset_energy_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/remote_base/__init__.py b/esphome/components/remote_base/__init__.py
index 9d3e655c571..bf17ac27b8f 100644
--- a/esphome/components/remote_base/__init__.py
+++ b/esphome/components/remote_base/__init__.py
@@ -163,7 +163,10 @@ BASE_REMOTE_TRANSMITTER_SCHEMA = cv.Schema(
 def register_action(name, type_, schema):
     validator = templatize(schema).extend(BASE_REMOTE_TRANSMITTER_SCHEMA)
     registerer = automation.register_action(
-        f"remote_transmitter.transmit_{name}", type_, validator
+        f"remote_transmitter.transmit_{name}",
+        type_,
+        validator,
+        synchronous=True,
     )
 
     def decorator(func):
diff --git a/esphome/components/remote_transmitter/__init__.py b/esphome/components/remote_transmitter/__init__.py
index 371dbb685f7..89019e296e5 100644
--- a/esphome/components/remote_transmitter/__init__.py
+++ b/esphome/components/remote_transmitter/__init__.py
@@ -120,7 +120,10 @@ DIGITAL_WRITE_ACTION_SCHEMA = cv.maybe_simple_value(
 
 
 @automation.register_action(
-    "remote_transmitter.digital_write", DigitalWriteAction, DIGITAL_WRITE_ACTION_SCHEMA
+    "remote_transmitter.digital_write",
+    DigitalWriteAction,
+    DIGITAL_WRITE_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def digital_write_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/rf_bridge/__init__.py b/esphome/components/rf_bridge/__init__.py
index b4770726b4f..934f24b7890 100644
--- a/esphome/components/rf_bridge/__init__.py
+++ b/esphome/components/rf_bridge/__init__.py
@@ -114,7 +114,10 @@ RFBRIDGE_SEND_CODE_SCHEMA = cv.Schema(
 
 
 @automation.register_action(
-    "rf_bridge.send_code", RFBridgeSendCodeAction, RFBRIDGE_SEND_CODE_SCHEMA
+    "rf_bridge.send_code",
+    RFBridgeSendCodeAction,
+    RFBRIDGE_SEND_CODE_SCHEMA,
+    synchronous=True,
 )
 async def rf_bridge_send_code_to_code(config, action_id, template_args, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -133,7 +136,9 @@ async def rf_bridge_send_code_to_code(config, action_id, template_args, args):
 RFBRIDGE_ID_SCHEMA = cv.Schema({cv.GenerateID(): cv.use_id(RFBridgeComponent)})
 
 
-@automation.register_action("rf_bridge.learn", RFBridgeLearnAction, RFBRIDGE_ID_SCHEMA)
+@automation.register_action(
+    "rf_bridge.learn", RFBridgeLearnAction, RFBRIDGE_ID_SCHEMA, synchronous=True
+)
 async def rf_bridge_learnx_to_code(config, action_id, template_args, args):
     paren = await cg.get_variable(config[CONF_ID])
     return cg.new_Pvariable(action_id, template_args, paren)
@@ -143,6 +148,7 @@ async def rf_bridge_learnx_to_code(config, action_id, template_args, args):
     "rf_bridge.start_advanced_sniffing",
     RFBridgeStartAdvancedSniffingAction,
     RFBRIDGE_ID_SCHEMA,
+    synchronous=True,
 )
 async def rf_bridge_start_advanced_sniffing_to_code(
     config, action_id, template_args, args
@@ -155,6 +161,7 @@ async def rf_bridge_start_advanced_sniffing_to_code(
     "rf_bridge.stop_advanced_sniffing",
     RFBridgeStopAdvancedSniffingAction,
     RFBRIDGE_ID_SCHEMA,
+    synchronous=True,
 )
 async def rf_bridge_stop_advanced_sniffing_to_code(
     config, action_id, template_args, args
@@ -167,6 +174,7 @@ async def rf_bridge_stop_advanced_sniffing_to_code(
     "rf_bridge.start_bucket_sniffing",
     RFBridgeStartBucketSniffingAction,
     RFBRIDGE_ID_SCHEMA,
+    synchronous=True,
 )
 async def rf_bridge_start_bucket_sniffing_to_code(
     config, action_id, template_args, args
@@ -189,6 +197,7 @@ RFBRIDGE_SEND_ADVANCED_CODE_SCHEMA = cv.Schema(
     "rf_bridge.send_advanced_code",
     RFBridgeSendAdvancedCodeAction,
     RFBRIDGE_SEND_ADVANCED_CODE_SCHEMA,
+    synchronous=True,
 )
 async def rf_bridge_send_advanced_code_to_code(config, action_id, template_args, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -211,7 +220,10 @@ RFBRIDGE_SEND_RAW_SCHEMA = cv.Schema(
 
 
 @automation.register_action(
-    "rf_bridge.send_raw", RFBridgeSendRawAction, RFBRIDGE_SEND_RAW_SCHEMA
+    "rf_bridge.send_raw",
+    RFBridgeSendRawAction,
+    RFBRIDGE_SEND_RAW_SCHEMA,
+    synchronous=True,
 )
 async def rf_bridge_send_raw_to_code(config, action_id, template_args, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -229,7 +241,9 @@ RFBRIDGE_BEEP_SCHEMA = cv.Schema(
 )
 
 
-@automation.register_action("rf_bridge.beep", RFBridgeBeepAction, RFBRIDGE_BEEP_SCHEMA)
+@automation.register_action(
+    "rf_bridge.beep", RFBridgeBeepAction, RFBRIDGE_BEEP_SCHEMA, synchronous=True
+)
 async def rf_bridge_beep_to_code(config, action_id, template_args, args):
     paren = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_args, paren)
diff --git a/esphome/components/rotary_encoder/sensor.py b/esphome/components/rotary_encoder/sensor.py
index 645b4a81c5c..be315db55d2 100644
--- a/esphome/components/rotary_encoder/sensor.py
+++ b/esphome/components/rotary_encoder/sensor.py
@@ -139,6 +139,7 @@ async def to_code(config):
             cv.Required(CONF_VALUE): cv.templatable(cv.int_),
         }
     ),
+    synchronous=True,
 )
 async def sensor_template_publish_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/rp2040_ble/__init__.py b/esphome/components/rp2040_ble/__init__.py
new file mode 100644
index 00000000000..648f22691c4
--- /dev/null
+++ b/esphome/components/rp2040_ble/__init__.py
@@ -0,0 +1,31 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.const import CONF_ENABLE_ON_BOOT, CONF_ID
+from esphome.types import ConfigType
+
+DEPENDENCIES = ["rp2040"]
+CODEOWNERS = ["@bdraco"]
+
+rp2040_ble_ns = cg.esphome_ns.namespace("rp2040_ble")
+RP2040BLE = rp2040_ble_ns.class_("RP2040BLE", cg.Component)
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(RP2040BLE),
+        cv.Optional(CONF_ENABLE_ON_BOOT, default=True): cv.boolean,
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+async def to_code(config: ConfigType) -> None:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+
+    cg.add(var.set_enable_on_boot(config[CONF_ENABLE_ON_BOOT]))
+
+    # Enable Bluetooth in the arduino-pico build
+    # This switches linking from liblwip.a to liblwip-bt.a and defines
+    # ENABLE_CLASSIC, ENABLE_BLE, CYW43_ENABLE_BLUETOOTH
+    cg.add_build_flag("-DPIO_FRAMEWORK_ARDUINO_ENABLE_BLUETOOTH")
+
+    cg.add_define("USE_RP2040_BLE")
diff --git a/esphome/components/rp2040_ble/rp2040_ble.cpp b/esphome/components/rp2040_ble/rp2040_ble.cpp
new file mode 100644
index 00000000000..4125da7ec01
--- /dev/null
+++ b/esphome/components/rp2040_ble/rp2040_ble.cpp
@@ -0,0 +1,124 @@
+#include "rp2040_ble.h"
+
+#ifdef USE_RP2040_BLE
+
+#include "esphome/core/log.h"
+
+namespace esphome::rp2040_ble {
+
+static const char *const TAG = "rp2040_ble";
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+RP2040BLE *global_ble = nullptr;
+
+void RP2040BLE::setup() {
+  global_ble = this;
+
+  if (this->enable_on_boot_) {
+    this->enable();
+  } else {
+    this->state_ = BLEComponentState::DISABLED;
+  }
+}
+
+void RP2040BLE::enable() {
+  if (this->state_ == BLEComponentState::ACTIVE || this->state_ == BLEComponentState::ENABLING) {
+    return;
+  }
+
+  ESP_LOGD(TAG, "Enabling BLE...");
+  this->state_ = BLEComponentState::ENABLING;
+  this->active_logged_ = false;
+
+  if (!this->btstack_initialized_) {
+    // BTstack init functions are not idempotent — only call once
+    l2cap_init();
+    sm_init();
+
+    this->hci_event_callback_registration_.callback = &RP2040BLE::packet_handler_;
+    hci_add_event_handler(&this->hci_event_callback_registration_);
+
+    this->sm_event_callback_registration_.callback = &RP2040BLE::packet_handler_;
+    sm_add_event_handler(&this->sm_event_callback_registration_);
+
+    this->btstack_initialized_ = true;
+  }
+
+  hci_power_control(HCI_POWER_ON);
+}
+
+void RP2040BLE::disable() {
+  if (this->state_ == BLEComponentState::DISABLED || this->state_ == BLEComponentState::OFF) {
+    return;
+  }
+
+  ESP_LOGD(TAG, "Disabling BLE...");
+  this->state_ = BLEComponentState::DISABLING;
+
+  hci_power_control(HCI_POWER_OFF);
+
+  this->state_ = BLEComponentState::DISABLED;
+  ESP_LOGD(TAG, "BLE disabled");
+}
+
+void RP2040BLE::loop() {
+  if (this->state_ == BLEComponentState::ACTIVE && !this->active_logged_) {
+    this->active_logged_ = true;
+    ESP_LOGI(TAG, "BLE active");
+  }
+}
+
+static const char *state_to_str(BLEComponentState state) {
+  switch (state) {
+    case BLEComponentState::OFF:
+      return "OFF";
+    case BLEComponentState::ENABLING:
+      return "ENABLING";
+    case BLEComponentState::ACTIVE:
+      return "ACTIVE";
+    case BLEComponentState::DISABLING:
+      return "DISABLING";
+    case BLEComponentState::DISABLED:
+      return "DISABLED";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+void RP2040BLE::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "RP2040 BLE:\n"
+                "  Enable on boot: %s\n"
+                "  State: %s",
+                YESNO(this->enable_on_boot_), state_to_str(this->state_));
+}
+
+float RP2040BLE::get_setup_priority() const { return setup_priority::BLUETOOTH; }
+
+void RP2040BLE::packet_handler_(uint8_t type, uint16_t channel, uint8_t *packet, uint16_t size) {
+  if (global_ble == nullptr) {
+    return;
+  }
+
+  if (type != HCI_EVENT_PACKET) {
+    return;
+  }
+
+  uint8_t event_type = hci_event_packet_get_type(packet);
+
+  switch (event_type) {
+    case BTSTACK_EVENT_STATE: {
+      uint8_t state = btstack_event_state_get_state(packet);
+      if (state == HCI_STATE_WORKING && global_ble->state_ == BLEComponentState::ENABLING) {
+        global_ble->state_ = BLEComponentState::ACTIVE;
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+}  // namespace esphome::rp2040_ble
+
+#endif  // USE_RP2040_BLE
diff --git a/esphome/components/rp2040_ble/rp2040_ble.h b/esphome/components/rp2040_ble/rp2040_ble.h
new file mode 100644
index 00000000000..24b3860cc1e
--- /dev/null
+++ b/esphome/components/rp2040_ble/rp2040_ble.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include "esphome/core/defines.h"  // Must be included before conditional includes
+
+#ifdef USE_RP2040_BLE
+
+#include "esphome/core/component.h"
+
+#include <btstack.h>
+
+namespace esphome::rp2040_ble {
+
+enum class BLEComponentState : uint8_t {
+  OFF = 0,
+  ENABLING,
+  ACTIVE,
+  DISABLING,
+  DISABLED,
+};
+
+class RP2040BLE : public Component {
+ public:
+  void setup() override;
+  void loop() override;
+  void dump_config() override;
+  float get_setup_priority() const override;
+
+  void enable();
+  void disable();
+  bool is_active() const { return this->state_ == BLEComponentState::ACTIVE; }
+
+  void set_enable_on_boot(bool enable_on_boot) { this->enable_on_boot_ = enable_on_boot; }
+
+ protected:
+  static void packet_handler_(uint8_t type, uint16_t channel, uint8_t *packet, uint16_t size);
+
+  btstack_packet_callback_registration_t hci_event_callback_registration_{};
+  btstack_packet_callback_registration_t sm_event_callback_registration_{};
+
+  BLEComponentState state_{BLEComponentState::OFF};
+  bool enable_on_boot_{true};
+  bool btstack_initialized_{false};
+  bool active_logged_{false};
+};
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+extern RP2040BLE *global_ble;
+
+}  // namespace esphome::rp2040_ble
+
+#endif  // USE_RP2040_BLE
diff --git a/esphome/components/rp2040_pwm/output.py b/esphome/components/rp2040_pwm/output.py
index 441a52de7f9..4ea488a6cd1 100644
--- a/esphome/components/rp2040_pwm/output.py
+++ b/esphome/components/rp2040_pwm/output.py
@@ -42,6 +42,7 @@ async def to_code(config):
             cv.Required(CONF_FREQUENCY): cv.templatable(validate_frequency),
         }
     ),
+    synchronous=True,
 )
 async def rp2040_set_frequency_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/rtttl/__init__.py b/esphome/components/rtttl/__init__.py
index 19412bb4547..35667342006 100644
--- a/esphome/components/rtttl/__init__.py
+++ b/esphome/components/rtttl/__init__.py
@@ -117,6 +117,7 @@ async def to_code(config):
         },
         key=CONF_RTTTL,
     ),
+    synchronous=True,
 )
 async def rtttl_play_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -134,6 +135,7 @@ async def rtttl_play_to_code(config, action_id, template_arg, args):
             cv.GenerateID(): cv.use_id(Rtttl),
         }
     ),
+    synchronous=True,
 )
 async def rtttl_stop_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/runtime_image/bmp_decoder.cpp b/esphome/components/runtime_image/bmp_decoder.cpp
index 7003f4da2ff..174f924b285 100644
--- a/esphome/components/runtime_image/bmp_decoder.cpp
+++ b/esphome/components/runtime_image/bmp_decoder.cpp
@@ -12,7 +12,10 @@ static const char *const TAG = "image_decoder.bmp";
 
 int HOT BmpDecoder::decode(uint8_t *buffer, size_t size) {
   size_t index = 0;
-  if (this->current_index_ == 0 && index == 0 && size > 14) {
+  if (this->current_index_ == 0) {
+    if (size <= 14) {
+      return 0;  // Need more data for file header
+    }
     /**
      * BMP file format:
      * 0-1: Signature (BM)
@@ -39,7 +42,10 @@ int HOT BmpDecoder::decode(uint8_t *buffer, size_t size) {
     this->current_index_ = 14;
     index = 14;
   }
-  if (this->current_index_ == 14 && index == 14 && size > this->data_offset_) {
+  if (this->current_index_ == 14) {
+    if (size <= this->data_offset_) {
+      return 0;  // Need more data for DIB header and color table
+    }
     /**
      * BMP DIB header:
      * 14-17: DIB header size
@@ -66,6 +72,28 @@ int HOT BmpDecoder::decode(uint8_t *buffer, size_t size) {
         this->width_bytes_ = (this->width_ + 7) / 8;
         this->padding_bytes_ = (4 - (this->width_bytes_ % 4)) % 4;
         break;
+      case 8: {
+        this->width_bytes_ = this->width_;
+        if (this->color_table_entries_ == 0) {
+          this->color_table_entries_ = 256;
+        } else if (this->color_table_entries_ > 256) {
+          ESP_LOGE(TAG, "Too many color table entries: %" PRIu32, this->color_table_entries_);
+          return DECODE_ERROR_UNSUPPORTED_FORMAT;
+        }
+        size_t header_size = encode_uint32(buffer[17], buffer[16], buffer[15], buffer[14]);
+        size_t offset = 14 + header_size;
+
+        this->color_table_ = std::make_unique<uint32_t[]>(this->color_table_entries_);
+
+        for (size_t i = 0; i < this->color_table_entries_; i++) {
+          this->color_table_[i] = encode_uint32(buffer[offset + i * 4 + 3], buffer[offset + i * 4 + 2],
+                                                buffer[offset + i * 4 + 1], buffer[offset + i * 4]);
+        }
+
+        this->padding_bytes_ = (4 - (this->width_bytes_ % 4)) % 4;
+
+        break;
+      }
       case 24:
         this->width_bytes_ = this->width_ * 3;
         if (this->width_bytes_ % 4 != 0) {
@@ -91,21 +119,24 @@ int HOT BmpDecoder::decode(uint8_t *buffer, size_t size) {
   }
   switch (this->bits_per_pixel_) {
     case 1: {
+      size_t width = static_cast<size_t>(this->width_);
       while (index < size) {
-        uint8_t current_byte = buffer[index];
-        bool end_of_row = false;
-        for (uint8_t i = 0; i < 8; i++) {
-          size_t x = this->paint_index_ % static_cast<size_t>(this->width_);
-          size_t y = static_cast<size_t>(this->height_ - 1) - (this->paint_index_ / static_cast<size_t>(this->width_));
-          Color c = (current_byte & (1 << (7 - i))) ? display::COLOR_ON : display::COLOR_OFF;
-          this->draw(x, y, 1, 1, c);
-          this->paint_index_++;
-          // End of pixel row: skip remaining bits in this byte
-          if (x + 1 >= static_cast<size_t>(this->width_)) {
-            end_of_row = true;
-            break;
-          }
+        size_t x = this->paint_index_ % width;
+        size_t y = static_cast<size_t>(this->height_ - 1) - (this->paint_index_ / width);
+        size_t remaining_in_row = width - x;
+        uint8_t pixels_in_byte = std::min<size_t>(remaining_in_row, 8);
+        bool end_of_row = remaining_in_row <= 8;
+        size_t needed = 1 + (end_of_row ? this->padding_bytes_ : 0);
+        if (index + needed > size) {
+          this->decoded_bytes_ += index;
+          return index;
         }
+        uint8_t current_byte = buffer[index];
+        for (uint8_t i = 0; i < pixels_in_byte; i++) {
+          Color c = (current_byte & (1 << (7 - i))) ? display::COLOR_ON : display::COLOR_OFF;
+          this->draw(x + i, y, 1, 1, c);
+        }
+        this->paint_index_ += pixels_in_byte;
         this->current_index_++;
         index++;
         // End of pixel row: skip row padding bytes (4-byte alignment)
@@ -116,23 +147,57 @@ int HOT BmpDecoder::decode(uint8_t *buffer, size_t size) {
       }
       break;
     }
-    case 24: {
+    case 8: {
+      size_t width = static_cast<size_t>(this->width_);
+      size_t last_col = width - 1;
       while (index < size) {
-        if (index + 2 >= size) {
+        size_t x = this->paint_index_ % width;
+        size_t y = static_cast<size_t>(this->height_ - 1) - (this->paint_index_ / width);
+        size_t needed = 1 + ((x == last_col) ? this->padding_bytes_ : 0);
+        if (index + needed > size) {
+          this->decoded_bytes_ += index;
+          return index;
+        }
+
+        uint8_t color_index = buffer[index];
+        if (color_index >= this->color_table_entries_) {
+          ESP_LOGE(TAG, "Invalid color index: %u", color_index);
+          return DECODE_ERROR_UNSUPPORTED_FORMAT;
+        }
+
+        uint32_t rgb = this->color_table_[color_index];
+        uint8_t b = rgb & 0xff;
+        uint8_t g = (rgb >> 8) & 0xff;
+        uint8_t r = (rgb >> 16) & 0xff;
+        this->draw(x, y, 1, 1, Color(r, g, b));
+        this->paint_index_++;
+        this->current_index_++;
+        index++;
+        if (x == last_col && this->padding_bytes_ > 0) {
+          index += this->padding_bytes_;
+          this->current_index_ += this->padding_bytes_;
+        }
+      }
+      break;
+    }
+    case 24: {
+      size_t width = static_cast<size_t>(this->width_);
+      size_t last_col = width - 1;
+      while (index < size) {
+        size_t x = this->paint_index_ % width;
+        size_t y = static_cast<size_t>(this->height_ - 1) - (this->paint_index_ / width);
+        size_t needed = 3 + ((x == last_col) ? this->padding_bytes_ : 0);
+        if (index + needed > size) {
           this->decoded_bytes_ += index;
           return index;
         }
         uint8_t b = buffer[index];
         uint8_t g = buffer[index + 1];
         uint8_t r = buffer[index + 2];
-        size_t x = this->paint_index_ % static_cast<size_t>(this->width_);
-        size_t y = static_cast<size_t>(this->height_ - 1) - (this->paint_index_ / static_cast<size_t>(this->width_));
-        Color c = Color(r, g, b);
-        this->draw(x, y, 1, 1, c);
+        this->draw(x, y, 1, 1, Color(r, g, b));
         this->paint_index_++;
         this->current_index_ += 3;
         index += 3;
-        size_t last_col = static_cast<size_t>(this->width_) - 1;
         if (x == last_col && this->padding_bytes_ > 0) {
           index += this->padding_bytes_;
           this->current_index_ += this->padding_bytes_;
diff --git a/esphome/components/runtime_image/bmp_decoder.h b/esphome/components/runtime_image/bmp_decoder.h
index 37db6b49405..73e54f54302 100644
--- a/esphome/components/runtime_image/bmp_decoder.h
+++ b/esphome/components/runtime_image/bmp_decoder.h
@@ -3,6 +3,9 @@
 #include "esphome/core/defines.h"
 #ifdef USE_RUNTIME_IMAGE_BMP
 
+#include <algorithm>
+#include <memory>
+
 #include "image_decoder.h"
 #include "runtime_image.h"
 
@@ -36,6 +39,7 @@ class BmpDecoder : public ImageDecoder {
   uint32_t compression_method_{0};
   uint32_t image_data_size_{0};
   uint32_t color_table_entries_{0};
+  std::unique_ptr<uint32_t[]> color_table_;
   size_t width_bytes_{0};
   size_t data_offset_{0};
   uint8_t padding_bytes_{0};
diff --git a/esphome/components/rx8130/time.py b/esphome/components/rx8130/time.py
index cb0402bd323..4f6310358c5 100644
--- a/esphome/components/rx8130/time.py
+++ b/esphome/components/rx8130/time.py
@@ -27,6 +27,7 @@ CONFIG_SCHEMA = time.TIME_SCHEMA.extend(
             cv.GenerateID(): cv.use_id(RX8130Component),
         }
     ),
+    synchronous=True,
 )
 async def rx8130_write_time_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -42,6 +43,7 @@ async def rx8130_write_time_to_code(config, action_id, template_arg, args):
             cv.GenerateID(): cv.use_id(RX8130Component),
         }
     ),
+    synchronous=True,
 )
 async def rx8130_read_time_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/safe_mode/__init__.py b/esphome/components/safe_mode/__init__.py
index f54151b7460..e868985054e 100644
--- a/esphome/components/safe_mode/__init__.py
+++ b/esphome/components/safe_mode/__init__.py
@@ -62,6 +62,7 @@ CONFIG_SCHEMA = cv.All(
             cv.GenerateID(): cv.use_id(SafeModeComponent),
         }
     ),
+    synchronous=True,
 )
 async def safe_mode_mark_successful_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/scd30/sensor.py b/esphome/components/scd30/sensor.py
index 194df8ec4f5..f60e913a0cb 100644
--- a/esphome/components/scd30/sensor.py
+++ b/esphome/components/scd30/sensor.py
@@ -128,6 +128,7 @@ async def to_code(config):
         },
         key=CONF_VALUE,
     ),
+    synchronous=True,
 )
 async def scd30_force_recalibration_with_reference_to_code(
     config, action_id, template_arg, args
diff --git a/esphome/components/scd4x/sensor.py b/esphome/components/scd4x/sensor.py
index ec90234ac39..6f14118660a 100644
--- a/esphome/components/scd4x/sensor.py
+++ b/esphome/components/scd4x/sensor.py
@@ -141,6 +141,7 @@ SCD4X_ACTION_SCHEMA = maybe_simple_id(
     "scd4x.perform_forced_calibration",
     PerformForcedCalibrationAction,
     SCD4X_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def scd4x_frc_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -158,7 +159,10 @@ SCD4X_RESET_ACTION_SCHEMA = maybe_simple_id(
 
 
 @automation.register_action(
-    "scd4x.factory_reset", FactoryResetAction, SCD4X_RESET_ACTION_SCHEMA
+    "scd4x.factory_reset",
+    FactoryResetAction,
+    SCD4X_RESET_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def scd4x_reset_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/script/__init__.py b/esphome/components/script/__init__.py
index 369cefad91a..51cae695b76 100644
--- a/esphome/components/script/__init__.py
+++ b/esphome/components/script/__init__.py
@@ -221,6 +221,7 @@ async def script_stop_action_to_code(config, action_id, template_arg, args):
     "script.wait",
     ScriptWaitAction,
     maybe_simple_id({cv.Required(CONF_ID): cv.use_id(Script)}),
+    synchronous=False,
 )
 async def script_wait_action_to_code(config, action_id, template_arg, args):
     full_id, paren = await cg.get_variable_with_full_id(config[CONF_ID])
diff --git a/esphome/components/sen5x/sensor.py b/esphome/components/sen5x/sensor.py
index 538a2f52395..9fe51121f16 100644
--- a/esphome/components/sen5x/sensor.py
+++ b/esphome/components/sen5x/sensor.py
@@ -267,7 +267,10 @@ SEN5X_ACTION_SCHEMA = maybe_simple_id(
 
 
 @automation.register_action(
-    "sen5x.start_fan_autoclean", StartFanAction, SEN5X_ACTION_SCHEMA
+    "sen5x.start_fan_autoclean",
+    StartFanAction,
+    SEN5X_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def sen54_fan_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/senseair/sensor.py b/esphome/components/senseair/sensor.py
index 2eb2617e307..c5bef76741a 100644
--- a/esphome/components/senseair/sensor.py
+++ b/esphome/components/senseair/sensor.py
@@ -73,20 +73,31 @@ CALIBRATION_ACTION_SCHEMA = maybe_simple_id(
     "senseair.background_calibration",
     SenseAirBackgroundCalibrationAction,
     CALIBRATION_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
     "senseair.background_calibration_result",
     SenseAirBackgroundCalibrationResultAction,
     CALIBRATION_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "senseair.abc_enable", SenseAirABCEnableAction, CALIBRATION_ACTION_SCHEMA
+    "senseair.abc_enable",
+    SenseAirABCEnableAction,
+    CALIBRATION_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "senseair.abc_disable", SenseAirABCDisableAction, CALIBRATION_ACTION_SCHEMA
+    "senseair.abc_disable",
+    SenseAirABCDisableAction,
+    CALIBRATION_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "senseair.abc_get_period", SenseAirABCGetPeriodAction, CALIBRATION_ACTION_SCHEMA
+    "senseair.abc_get_period",
+    SenseAirABCGetPeriodAction,
+    CALIBRATION_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def senseair_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/servo/__init__.py b/esphome/components/servo/__init__.py
index 2fee2840a5c..a23bb53536a 100644
--- a/esphome/components/servo/__init__.py
+++ b/esphome/components/servo/__init__.py
@@ -62,6 +62,7 @@ async def to_code(config):
             cv.Required(CONF_LEVEL): cv.templatable(cv.possibly_negative_percentage),
         }
     ),
+    synchronous=True,
 )
 async def servo_write_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -79,6 +80,7 @@ async def servo_write_to_code(config, action_id, template_arg, args):
             cv.Required(CONF_ID): cv.use_id(Servo),
         }
     ),
+    synchronous=True,
 )
 async def servo_detach_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/sim800l/__init__.py b/esphome/components/sim800l/__init__.py
index c48a3c63c41..ebb74302a9c 100644
--- a/esphome/components/sim800l/__init__.py
+++ b/esphome/components/sim800l/__init__.py
@@ -135,7 +135,10 @@ SIM800L_SEND_SMS_SCHEMA = cv.Schema(
 
 
 @automation.register_action(
-    "sim800l.send_sms", Sim800LSendSmsAction, SIM800L_SEND_SMS_SCHEMA
+    "sim800l.send_sms",
+    Sim800LSendSmsAction,
+    SIM800L_SEND_SMS_SCHEMA,
+    synchronous=True,
 )
 async def sim800l_send_sms_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -155,7 +158,9 @@ SIM800L_DIAL_SCHEMA = cv.Schema(
 )
 
 
-@automation.register_action("sim800l.dial", Sim800LDialAction, SIM800L_DIAL_SCHEMA)
+@automation.register_action(
+    "sim800l.dial", Sim800LDialAction, SIM800L_DIAL_SCHEMA, synchronous=True
+)
 async def sim800l_dial_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)
@@ -168,6 +173,7 @@ async def sim800l_dial_to_code(config, action_id, template_arg, args):
     "sim800l.connect",
     Sim800LConnectAction,
     cv.Schema({cv.GenerateID(): cv.use_id(Sim800LComponent)}),
+    synchronous=True,
 )
 async def sim800l_connect_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -183,7 +189,10 @@ SIM800L_SEND_USSD_SCHEMA = cv.Schema(
 
 
 @automation.register_action(
-    "sim800l.send_ussd", Sim800LSendUssdAction, SIM800L_SEND_USSD_SCHEMA
+    "sim800l.send_ussd",
+    Sim800LSendUssdAction,
+    SIM800L_SEND_USSD_SCHEMA,
+    synchronous=True,
 )
 async def sim800l_send_ussd_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -197,6 +206,7 @@ async def sim800l_send_ussd_to_code(config, action_id, template_arg, args):
     "sim800l.disconnect",
     Sim800LDisconnectAction,
     cv.Schema({cv.GenerateID(): cv.use_id(Sim800LComponent)}),
+    synchronous=True,
 )
 async def sim800l_disconnect_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/sound_level/sensor.py b/esphome/components/sound_level/sensor.py
index 8ca0feccc0f..44f31979b46 100644
--- a/esphome/components/sound_level/sensor.py
+++ b/esphome/components/sound_level/sensor.py
@@ -89,8 +89,12 @@ SOUND_LEVEL_ACTION_SCHEMA = automation.maybe_simple_id(
 )
 
 
-@automation.register_action("sound_level.start", StartAction, SOUND_LEVEL_ACTION_SCHEMA)
-@automation.register_action("sound_level.stop", StopAction, SOUND_LEVEL_ACTION_SCHEMA)
+@automation.register_action(
+    "sound_level.start", StartAction, SOUND_LEVEL_ACTION_SCHEMA, synchronous=True
+)
+@automation.register_action(
+    "sound_level.stop", StopAction, SOUND_LEVEL_ACTION_SCHEMA, synchronous=True
+)
 async def sound_level_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])
diff --git a/esphome/components/speaker/__init__.py b/esphome/components/speaker/__init__.py
index 10ee6d52125..8480eebcdb2 100644
--- a/esphome/components/speaker/__init__.py
+++ b/esphome/components/speaker/__init__.py
@@ -78,6 +78,7 @@ async def speaker_action(config, action_id, template_arg, args):
         },
         key=CONF_DATA,
     ),
+    synchronous=True,
 )
 async def speaker_play_action(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -95,12 +96,12 @@ async def speaker_play_action(config, action_id, template_arg, args):
     return var
 
 
-automation.register_action("speaker.stop", StopAction, SPEAKER_AUTOMATION_SCHEMA)(
-    speaker_action
-)
-automation.register_action("speaker.finish", FinishAction, SPEAKER_AUTOMATION_SCHEMA)(
-    speaker_action
-)
+automation.register_action(
+    "speaker.stop", StopAction, SPEAKER_AUTOMATION_SCHEMA, synchronous=True
+)(speaker_action)
+automation.register_action(
+    "speaker.finish", FinishAction, SPEAKER_AUTOMATION_SCHEMA, synchronous=True
+)(speaker_action)
 
 automation.register_condition(
     "speaker.is_playing", IsPlayingCondition, SPEAKER_AUTOMATION_SCHEMA
@@ -121,6 +122,7 @@ automation.register_condition(
         },
         key=CONF_VOLUME,
     ),
+    synchronous=True,
 )
 async def speaker_volume_set_action(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -131,9 +133,14 @@ async def speaker_volume_set_action(config, action_id, template_arg, args):
 
 
 @automation.register_action(
-    "speaker.mute_off", MuteOffAction, SPEAKER_AUTOMATION_SCHEMA
+    "speaker.mute_off",
+    MuteOffAction,
+    SPEAKER_AUTOMATION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_action(
+    "speaker.mute_on", MuteOnAction, SPEAKER_AUTOMATION_SCHEMA, synchronous=True
 )
-@automation.register_action("speaker.mute_on", MuteOnAction, SPEAKER_AUTOMATION_SCHEMA)
 async def speaker_mute_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)
diff --git a/esphome/components/speaker/media_player/__init__.py b/esphome/components/speaker/media_player/__init__.py
index 42ca762858f..92a178fe95e 100644
--- a/esphome/components/speaker/media_player/__init__.py
+++ b/esphome/components/speaker/media_player/__init__.py
@@ -505,6 +505,7 @@ async def to_code(config):
         },
         key=CONF_MEDIA_FILE,
     ),
+    synchronous=True,
 )
 async def play_on_device_media_media_action(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/speaker_source/__init__.py b/esphome/components/speaker_source/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/esphome/components/speaker_source/media_player.py b/esphome/components/speaker_source/media_player.py
new file mode 100644
index 00000000000..a44cdcbf01e
--- /dev/null
+++ b/esphome/components/speaker_source/media_player.py
@@ -0,0 +1,212 @@
+from esphome import automation
+import esphome.codegen as cg
+from esphome.components import audio, media_player, media_source, speaker
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_FORMAT,
+    CONF_ID,
+    CONF_NUM_CHANNELS,
+    CONF_SAMPLE_RATE,
+    CONF_SPEAKER,
+)
+from esphome.core.entity_helpers import inherit_property_from
+from esphome.types import ConfigType
+
+AUTO_LOAD = ["audio"]
+DEPENDENCIES = ["media_source", "speaker"]
+
+CODEOWNERS = ["@kahrendt"]
+
+CONF_MEDIA_PIPELINE = "media_pipeline"
+CONF_ON_MUTE = "on_mute"
+CONF_ON_UNMUTE = "on_unmute"
+CONF_ON_VOLUME = "on_volume"
+CONF_SOURCES = "sources"
+CONF_VOLUME_INCREMENT = "volume_increment"
+CONF_VOLUME_INITIAL = "volume_initial"
+CONF_VOLUME_MAX = "volume_max"
+CONF_VOLUME_MIN = "volume_min"
+
+speaker_source_ns = cg.esphome_ns.namespace("speaker_source")
+
+SpeakerSourceMediaPlayer = speaker_source_ns.class_(
+    "SpeakerSourceMediaPlayer", cg.Component, media_player.MediaPlayer
+)
+
+PipelineContext = speaker_source_ns.struct("PipelineContext")
+
+Pipeline = speaker_source_ns.enum("Pipeline")
+
+
+FORMAT_MAPPING = {
+    "FLAC": "flac",
+    "MP3": "mp3",
+    "OPUS": "opus",
+    "WAV": "wav",
+}
+
+
+# Returns a media_player.MediaPlayerSupportedFormat struct with the configured
+# format, sample rate, number of channels, purpose, and bytes per sample
+def _get_supported_format_struct(pipeline: ConfigType):
+    args = [
+        media_player.MediaPlayerSupportedFormat,
+    ]
+
+    args.append(("format", FORMAT_MAPPING[pipeline[CONF_FORMAT]]))
+
+    args.append(("sample_rate", pipeline[CONF_SAMPLE_RATE]))
+    args.append(("num_channels", pipeline[CONF_NUM_CHANNELS]))
+    args.append(("purpose", media_player.MEDIA_PLAYER_FORMAT_PURPOSE_ENUM["default"]))
+
+    # Omit sample_bytes for MP3: ffmpeg transcoding in Home Assistant fails
+    # if the number of bytes per sample is specified for MP3.
+    if pipeline[CONF_FORMAT] != "MP3":
+        args.append(("sample_bytes", 2))
+
+    return cg.StructInitializer(*args)
+
+
+def _validate_pipeline(config: ConfigType) -> ConfigType:
+    # Inherit settings from speaker if not manually set
+    inherit_property_from(CONF_NUM_CHANNELS, CONF_SPEAKER)(config)
+    inherit_property_from(CONF_SAMPLE_RATE, CONF_SPEAKER)(config)
+
+    # Opus only supports 48 kHz
+    if config.get(CONF_FORMAT) == "OPUS" and config.get(CONF_SAMPLE_RATE) != 48000:
+        raise cv.Invalid("Opus only supports a sample rate of 48000 Hz")
+
+    audio.final_validate_audio_schema(
+        "speaker_source media_player",
+        audio_device=CONF_SPEAKER,
+        bits_per_sample=16,
+        channels=config.get(CONF_NUM_CHANNELS),
+        sample_rate=config.get(CONF_SAMPLE_RATE),
+    )(config)
+
+    return config
+
+
+PIPELINE_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(
+            PipelineContext
+        ),  # Needed to inherit audio settings from the speaker
+        cv.Required(CONF_SPEAKER): cv.use_id(speaker.Speaker),
+        cv.Required(CONF_SOURCES): cv.All(
+            cv.ensure_list(cv.use_id(media_source.MediaSource)),
+            cv.Length(min=1),
+        ),
+        cv.Optional(CONF_FORMAT, default="FLAC"): cv.enum(audio.AUDIO_FILE_TYPE_ENUM),
+        cv.Optional(CONF_SAMPLE_RATE): cv.int_range(min=1),
+        cv.Optional(CONF_NUM_CHANNELS): cv.int_range(1, 2),
+    }
+)
+
+
+def _validate_volume_settings(config: ConfigType) -> ConfigType:
+    # CONF_VOLUME_INITIAL is in the scaled volume domain (0.0-1.0) and doesn't need to be validated
+    if config[CONF_VOLUME_MIN] > config[CONF_VOLUME_MAX]:
+        raise cv.Invalid(
+            f"{CONF_VOLUME_MIN} ({config[CONF_VOLUME_MIN]}) must be less than or equal to {CONF_VOLUME_MAX} ({config[CONF_VOLUME_MAX]})"
+        )
+    return config
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.Optional(CONF_VOLUME_INCREMENT, default=0.05): cv.percentage,
+            cv.Optional(CONF_VOLUME_INITIAL, default=0.5): cv.percentage,
+            cv.Optional(CONF_VOLUME_MAX, default=1.0): cv.percentage,
+            cv.Optional(CONF_VOLUME_MIN, default=0.0): cv.percentage,
+            cv.Required(CONF_MEDIA_PIPELINE): PIPELINE_SCHEMA,
+            cv.Optional(CONF_ON_MUTE): automation.validate_automation(single=True),
+            cv.Optional(CONF_ON_UNMUTE): automation.validate_automation(single=True),
+            cv.Optional(CONF_ON_VOLUME): automation.validate_automation(single=True),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(media_player.media_player_schema(SpeakerSourceMediaPlayer)),
+    cv.only_on_esp32,
+    _validate_volume_settings,
+)
+
+
+def _final_validate_codecs(config: ConfigType) -> ConfigType:
+    pipeline = config[CONF_MEDIA_PIPELINE]
+    fmt = pipeline[CONF_FORMAT]
+    if fmt == "NONE":
+        audio.request_flac_support()
+        audio.request_mp3_support()
+        audio.request_opus_support()
+    elif fmt == "FLAC":
+        audio.request_flac_support()
+    elif fmt == "MP3":
+        audio.request_mp3_support()
+    elif fmt == "OPUS":
+        audio.request_opus_support()
+
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.Required(CONF_MEDIA_PIPELINE): _validate_pipeline,
+        },
+        extra=cv.ALLOW_EXTRA,
+    ),
+    _final_validate_codecs,
+)
+
+
+async def to_code(config: ConfigType) -> None:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await media_player.register_media_player(var, config)
+
+    cg.add(var.set_volume_increment(config[CONF_VOLUME_INCREMENT]))
+    cg.add(var.set_volume_initial(config[CONF_VOLUME_INITIAL]))
+    cg.add(var.set_volume_max(config[CONF_VOLUME_MAX]))
+    cg.add(var.set_volume_min(config[CONF_VOLUME_MIN]))
+
+    pipeline_config = config[CONF_MEDIA_PIPELINE]
+    pipeline_enum = Pipeline.MEDIA_PIPELINE
+
+    for source in pipeline_config[CONF_SOURCES]:
+        src = await cg.get_variable(source)
+        cg.add(var.add_media_source(pipeline_enum, src))
+
+    cg.add(
+        var.set_speaker(
+            pipeline_enum,
+            await cg.get_variable(pipeline_config[CONF_SPEAKER]),
+        )
+    )
+    if pipeline_config[CONF_FORMAT] != "NONE":
+        cg.add(
+            var.set_format(
+                pipeline_enum,
+                _get_supported_format_struct(pipeline_config),
+            )
+        )
+
+    if on_mute := config.get(CONF_ON_MUTE):
+        await automation.build_automation(
+            var.get_mute_trigger(),
+            [],
+            on_mute,
+        )
+    if on_unmute := config.get(CONF_ON_UNMUTE):
+        await automation.build_automation(
+            var.get_unmute_trigger(),
+            [],
+            on_unmute,
+        )
+    if on_volume := config.get(CONF_ON_VOLUME):
+        await automation.build_automation(
+            var.get_volume_trigger(),
+            [(cg.float_, "x")],
+            on_volume,
+        )
diff --git a/esphome/components/speaker_source/speaker_source_media_player.cpp b/esphome/components/speaker_source/speaker_source_media_player.cpp
new file mode 100644
index 00000000000..a3679891d2d
--- /dev/null
+++ b/esphome/components/speaker_source/speaker_source_media_player.cpp
@@ -0,0 +1,546 @@
+#include "speaker_source_media_player.h"
+
+#ifdef USE_ESP32
+
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+namespace esphome::speaker_source {
+
+static constexpr uint32_t MEDIA_CONTROLS_QUEUE_LENGTH = 20;
+
+static const char *const TAG = "speaker_source_media_player";
+
+// SourceBinding method implementations (defined here because SpeakerSourceMediaPlayer is forward-declared in the
+// header)
+
+// THREAD CONTEXT: Called from media source decode task thread
+size_t SourceBinding::write_audio(const uint8_t *data, size_t length, uint32_t timeout_ms,
+                                  const audio::AudioStreamInfo &stream_info) {
+  return this->player->handle_media_output_(this->pipeline, this->source, data, length, timeout_ms, stream_info);
+}
+
+// THREAD CONTEXT: Called from main loop (media source's loop() calls set_state_ which calls report_state)
+void SourceBinding::report_state(media_source::MediaSourceState state) {
+  this->player->handle_media_state_changed_(this->pipeline, this->source, state);
+}
+
+// THREAD CONTEXT: Called from media source task thread; uses defer() to marshal to main loop
+void SourceBinding::request_volume(float volume) {
+  this->player->defer([this, volume]() { this->player->handle_volume_request_(volume); });
+}
+
+// THREAD CONTEXT: Called from media source task thread; uses defer() to marshal to main loop
+void SourceBinding::request_mute(bool is_muted) {
+  this->player->defer([this, is_muted]() { this->player->handle_mute_request_(is_muted); });
+}
+
+// THREAD CONTEXT: Called from media source task thread; uses defer() to marshal to main loop
+void SourceBinding::request_play_uri(const std::string &uri) {
+  this->player->defer([this, uri]() { this->player->handle_play_uri_request_(this->pipeline, uri); });
+}
+
+// THREAD CONTEXT: Called during code generation setup (main loop)
+void SpeakerSourceMediaPlayer::add_media_source(uint8_t pipeline, media_source::MediaSource *media_source) {
+  auto &binding =
+      this->pipelines_[pipeline].sources.emplace_back(std::make_unique<SourceBinding>(this, media_source, pipeline));
+  media_source->set_listener(binding.get());
+}
+
+void SpeakerSourceMediaPlayer::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "Speaker Source Media Player:\n"
+                "  Volume Increment: %.2f\n"
+                "  Volume Min: %.2f\n"
+                "  Volume Max: %.2f",
+                this->volume_increment_, this->volume_min_, this->volume_max_);
+}
+
+void SpeakerSourceMediaPlayer::setup() {
+  this->state = media_player::MEDIA_PLAYER_STATE_IDLE;
+
+  this->media_control_command_queue_ = xQueueCreate(MEDIA_CONTROLS_QUEUE_LENGTH, sizeof(MediaPlayerControlCommand));
+
+  this->pref_ = this->make_entity_preference<VolumeRestoreState>();
+
+  VolumeRestoreState volume_restore_state;
+  if (this->pref_.load(&volume_restore_state)) {
+    this->set_volume_(volume_restore_state.volume);
+    this->set_mute_state_(volume_restore_state.is_muted);
+  } else {
+    this->set_volume_(this->volume_initial_);
+    this->set_mute_state_(false);
+  }
+
+  // Register callbacks to receive playback notifications from speakers
+  for (size_t i = 0; i < this->pipelines_.size(); i++) {
+    if (this->pipelines_[i].is_configured()) {
+      this->pipelines_[i].speaker->add_audio_output_callback([this, i](uint32_t frames, int64_t timestamp) {
+        this->handle_speaker_playback_callback_(frames, timestamp, i);
+      });
+    }
+  }
+}
+
+// THREAD CONTEXT: Called from the speaker's playback callback task (not main loop)
+void SpeakerSourceMediaPlayer::handle_speaker_playback_callback_(uint32_t frames, int64_t timestamp, uint8_t pipeline) {
+  PipelineContext &ps = this->pipelines_[pipeline];
+
+  // Load once so the null check and use below are consistent
+  media_source::MediaSource *active_source = ps.active_source.load(std::memory_order_relaxed);
+  if (active_source == nullptr) {
+    return;
+  }
+
+  // CAS loop to safely subtract frames without underflow. If pending_frames is reset to 0 (new source
+  // starting) between the load and the subtract, compare_exchange_weak will fail and reload the current value.
+  uint32_t current = ps.pending_frames.load(std::memory_order_relaxed);
+  uint32_t source_frames;
+  do {
+    source_frames = std::min(frames, current);
+  } while (source_frames > 0 &&
+           !ps.pending_frames.compare_exchange_weak(current, current - source_frames, std::memory_order_relaxed));
+
+  if (source_frames > 0) {
+    // Notify the source about the played audio
+    active_source->notify_audio_played(source_frames, timestamp);
+  }
+}
+
+// THREAD CONTEXT: Called from main loop via defer()
+void SpeakerSourceMediaPlayer::handle_volume_request_(float volume) {
+  // Update the media player's volume
+  this->set_volume_(volume);
+  this->publish_state();
+}
+
+// THREAD CONTEXT: Called from main loop via defer()
+void SpeakerSourceMediaPlayer::handle_mute_request_(bool is_muted) {
+  // Update the media player's mute state
+  this->set_mute_state_(is_muted);
+  this->publish_state();
+}
+
+// THREAD CONTEXT: Called from main loop via defer()
+void SpeakerSourceMediaPlayer::handle_play_uri_request_(uint8_t pipeline, const std::string &uri) {
+  // Smart source is requesting the player to play a different URI
+  auto call = this->make_call();
+  call.set_media_url(uri);
+  call.perform();
+}
+
+// THREAD CONTEXT: Called from main loop (media source's loop() calls set_state_ which calls report_state)
+void SpeakerSourceMediaPlayer::handle_media_state_changed_(uint8_t pipeline, media_source::MediaSource *source,
+                                                           media_source::MediaSourceState state) {
+  PipelineContext &ps = this->pipelines_[pipeline];
+
+  if (state == media_source::MediaSourceState::IDLE) {
+    // Source went idle - clear stopping flag if this was the source we asked to stop
+    if (ps.stopping_source == source) {
+      ps.stopping_source = nullptr;
+    }
+
+    // Clear pending flag if this was the source we asked to play
+    if (ps.pending_source == source) {
+      ps.pending_source = nullptr;
+    }
+
+    // Source went idle - clear it if it's the active source
+    if (ps.active_source == source) {
+      ps.last_source = ps.active_source;
+      ps.active_source = nullptr;
+
+      // Finish the speaker to ensure it's ready for the next playback
+      ps.speaker->finish();
+    }
+  } else if (state == media_source::MediaSourceState::PLAYING) {
+    // Source started playing - make it the active source if no one else is active
+    if (ps.active_source == nullptr) {
+      ps.active_source = source;
+      ps.last_source = nullptr;
+
+      // Clear pending flag now that the source is active
+      if (ps.pending_source == source) {
+        ps.pending_source = nullptr;
+      }
+    }
+  }
+}
+
+// THREAD CONTEXT: Called from media source decode task thread (not main loop).
+// Reads ps.active_source (atomic), writes ps.pending_frames (atomic), and calls
+// ps.speaker methods (speaker pointer is immutable after setup).
+size_t SpeakerSourceMediaPlayer::handle_media_output_(uint8_t pipeline, media_source::MediaSource *source,
+                                                      const uint8_t *data, size_t length, uint32_t timeout_ms,
+                                                      const audio::AudioStreamInfo &stream_info) {
+  PipelineContext &ps = this->pipelines_[pipeline];
+
+  // Single read; the if-body only uses ps.speaker (immutable after setup) and the source parameter.
+  if (ps.active_source == source) {
+    // This source is active - play the audio
+    if (ps.speaker->get_audio_stream_info() != stream_info) {
+      // Setup the speaker to play this stream
+      ps.speaker->set_audio_stream_info(stream_info);
+      vTaskDelay(pdMS_TO_TICKS(timeout_ms));
+      return 0;
+    }
+    size_t bytes_written = ps.speaker->play(data, length, pdMS_TO_TICKS(timeout_ms));
+    if (bytes_written > 0) {
+      // Track frames sent to speaker for this source
+      ps.pending_frames.fetch_add(stream_info.bytes_to_frames(bytes_written), std::memory_order_relaxed);
+    }
+    return bytes_written;
+  }
+
+  // Not the active source - wait for state callback to set us as active when we transition to PLAYING
+  vTaskDelay(pdMS_TO_TICKS(timeout_ms));
+  return 0;
+}
+
+media_player::MediaPlayerState SpeakerSourceMediaPlayer::get_media_pipeline_state_(
+    media_source::MediaSource *source) const {
+  if (source != nullptr) {
+    switch (source->get_state()) {
+      case media_source::MediaSourceState::PLAYING:
+        return media_player::MEDIA_PLAYER_STATE_PLAYING;
+      case media_source::MediaSourceState::PAUSED:
+        return media_player::MEDIA_PLAYER_STATE_PAUSED;
+      case media_source::MediaSourceState::ERROR:
+        ESP_LOGE(TAG, "Source error");
+        return media_player::MEDIA_PLAYER_STATE_IDLE;
+      case media_source::MediaSourceState::IDLE:
+      default:
+        return media_player::MEDIA_PLAYER_STATE_IDLE;
+    }
+  }
+
+  return media_player::MEDIA_PLAYER_STATE_IDLE;
+}
+
+void SpeakerSourceMediaPlayer::loop() {
+  // Process queued control commands
+  MediaPlayerControlCommand control_command;
+
+  // Use peek to check command without removing it
+  if (xQueuePeek(this->media_control_command_queue_, &control_command, 0) == pdTRUE) {
+    bool command_executed = false;
+    uint8_t pipeline = control_command.pipeline;
+
+    switch (control_command.type) {
+      case MediaPlayerControlCommand::PLAY_URI: {
+        command_executed = this->try_execute_play_uri_(*control_command.data.uri, pipeline);
+        break;
+      }
+
+      case MediaPlayerControlCommand::SEND_COMMAND: {
+        PipelineContext &ps = this->pipelines_[pipeline];
+
+        // Determine target source: prefer active, fall back to last
+        media_source::MediaSource *target_source = nullptr;
+        if (ps.active_source != nullptr) {
+          target_source = ps.active_source;
+        } else if (ps.last_source != nullptr) {
+          target_source = ps.last_source;
+        }
+
+        media_player::MediaPlayerCommand player_command = control_command.data.command;
+        switch (player_command) {
+          case media_player::MEDIA_PLAYER_COMMAND_TOGGLE: {
+            media_source::MediaSource *active_source = ps.active_source;
+            if ((active_source != nullptr) && (active_source->get_state() == media_source::MediaSourceState::PLAYING)) {
+              if (target_source != nullptr) {
+                target_source->handle_command(media_source::MediaSourceCommand::PAUSE);
+              }
+            } else {
+              if (target_source != nullptr) {
+                target_source->handle_command(media_source::MediaSourceCommand::PLAY);
+              }
+            }
+            break;
+          }
+
+          case media_player::MEDIA_PLAYER_COMMAND_PLAY: {
+            if (target_source != nullptr) {
+              target_source->handle_command(media_source::MediaSourceCommand::PLAY);
+            }
+            break;
+          }
+
+          case media_player::MEDIA_PLAYER_COMMAND_PAUSE: {
+            if (target_source != nullptr) {
+              target_source->handle_command(media_source::MediaSourceCommand::PAUSE);
+            }
+            break;
+          }
+
+          case media_player::MEDIA_PLAYER_COMMAND_STOP: {
+            if (target_source != nullptr) {
+              target_source->handle_command(media_source::MediaSourceCommand::STOP);
+            }
+            break;
+          }
+
+          default:
+            break;
+        }
+
+        command_executed = true;
+        break;
+      }
+    }
+
+    // Only remove from queue if successfully executed
+    if (command_executed) {
+      xQueueReceive(this->media_control_command_queue_, &control_command, 0);
+
+      // Delete the allocated string for PLAY_URI commands
+      if (control_command.type == MediaPlayerControlCommand::PLAY_URI) {
+        delete control_command.data.uri;
+      }
+    }
+  }
+
+  // Update state based on active sources
+  media_player::MediaPlayerState old_state = this->state;
+
+  PipelineContext &media_ps = this->pipelines_[MEDIA_PIPELINE];
+  this->state = this->get_media_pipeline_state_(media_ps.active_source);
+
+  if (this->state != old_state) {
+    this->publish_state();
+    ESP_LOGD(TAG, "State changed to %s", media_player::media_player_state_to_string(this->state));
+  }
+}
+
+media_source::MediaSource *SpeakerSourceMediaPlayer::find_source_for_uri_(const std::string &uri, uint8_t pipeline) {
+  PipelineContext &ps = this->pipelines_[pipeline];
+  media_source::MediaSource *first_match = nullptr;
+  for (auto &binding : ps.sources) {
+    if (binding->source->can_handle(uri)) {
+      // Prefer an idle source; otherwise remember the first match (will be stopped by try_execute_play_uri_)
+      if (binding->source->get_state() == media_source::MediaSourceState::IDLE) {
+        return binding->source;
+      }
+      if (first_match == nullptr) {
+        first_match = binding->source;
+      }
+    }
+  }
+  return first_match;
+}
+
+bool SpeakerSourceMediaPlayer::try_execute_play_uri_(const std::string &uri, uint8_t pipeline) {
+  // Find target source
+  media_source::MediaSource *target_source = this->find_source_for_uri_(uri, pipeline);
+  if (target_source == nullptr) {
+    ESP_LOGW(TAG, "No source for URI");
+    ESP_LOGV(TAG, "URI: %s", uri.c_str());
+    return true;  // Remove from queue (unrecoverable)
+  }
+
+  PipelineContext &ps = this->pipelines_[pipeline];
+
+  media_source::MediaSource *active_source = ps.active_source;
+
+  // If active source exists and is not IDLE, stop it and wait
+  if (active_source != nullptr) {
+    media_source::MediaSourceState active_state = active_source->get_state();
+    if (active_state != media_source::MediaSourceState::IDLE) {
+      // Only send END command once per source - check if we've already asked this source to stop
+      if (ps.stopping_source != active_source) {
+        ESP_LOGV(TAG, "Pipeline %u: stopping active source", pipeline);
+        active_source->handle_command(media_source::MediaSourceCommand::STOP);
+        ps.speaker->stop();
+        ps.stopping_source = active_source;
+      }
+      return false;  // Leave in queue, retry next loop
+    }
+  }
+
+  // Also check target source directly - handles case where source errored before PLAYING state
+  media_source::MediaSourceState target_state = target_source->get_state();
+  if (target_state != media_source::MediaSourceState::IDLE) {
+    // Only send STOP command once per source
+    if (ps.stopping_source != target_source) {
+      ESP_LOGV(TAG, "Pipeline %u: target source busy, stopping", pipeline);
+      target_source->handle_command(media_source::MediaSourceCommand::STOP);
+      ps.speaker->stop();
+      ps.stopping_source = target_source;
+    }
+    return false;  // Leave in queue, retry next loop
+  }
+
+  // Clear stopping flag since we're past the stopping phase
+  ps.stopping_source = nullptr;
+
+  // Check if speaker is ready
+  if (!ps.speaker->is_stopped()) {
+    return false;  // Speaker not ready yet, retry later
+  }
+
+  // Set pending source so handle_media_state_changed_ can recognize it when the source transitions to PLAYING
+  ps.pending_source = target_source;
+
+  // Speaker is ready, try to play
+  if (!target_source->play_uri(uri)) {
+    ESP_LOGE(TAG, "Pipeline %u: Failed to play URI: %s", pipeline, uri.c_str());
+    ps.pending_source = nullptr;
+  }
+
+  // Reset pending frame counter for this pipeline since we're starting a new source
+  ps.pending_frames.store(0, std::memory_order_relaxed);
+
+  return true;  // Remove from queue
+}
+
+// THREAD CONTEXT: Called from main loop only. Entry points:
+// - HA/automation commands (direct)
+// - handle_play_uri_request_() via make_call().perform() (deferred from source tasks)
+void SpeakerSourceMediaPlayer::control(const media_player::MediaPlayerCall &call) {
+  if (!this->is_ready()) {
+    return;
+  }
+
+  MediaPlayerControlCommand control_command;
+  control_command.pipeline = MEDIA_PIPELINE;
+
+  auto media_url = call.get_media_url();
+  if (media_url.has_value()) {
+    control_command.type = MediaPlayerControlCommand::PLAY_URI;
+    // Heap allocation is unavoidable: URIs from Home Assistant are arbitrary-length (media URLs with tokens
+    // can easily exceed 500 bytes). Deleted after the command is consumed. FreeRTOS queues require items to be
+    // copyable, so we store a pointer to the string in the queue rather than the string itself.
+    control_command.data.uri = new std::string(media_url.value());
+    if (xQueueSend(this->media_control_command_queue_, &control_command, 0) != pdTRUE) {
+      delete control_command.data.uri;
+      ESP_LOGE(TAG, "Queue full, URI dropped");
+    }
+    return;
+  }
+
+  auto volume = call.get_volume();
+  if (volume.has_value()) {
+    this->set_volume_(volume.value());
+    this->publish_state();
+    return;
+  }
+
+  auto cmd = call.get_command();
+  if (cmd.has_value()) {
+    switch (cmd.value()) {
+      case media_player::MEDIA_PLAYER_COMMAND_MUTE:
+        this->set_mute_state_(true);
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_UNMUTE:
+        this->set_mute_state_(false);
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_VOLUME_UP:
+        this->set_volume_(std::min(1.0f, this->volume + this->volume_increment_));
+        break;
+      case media_player::MEDIA_PLAYER_COMMAND_VOLUME_DOWN:
+        this->set_volume_(std::max(0.0f, this->volume - this->volume_increment_));
+        break;
+      default:
+        // Queue command for processing in loop()
+        control_command.type = MediaPlayerControlCommand::SEND_COMMAND;
+        control_command.data.command = cmd.value();
+        if (xQueueSend(this->media_control_command_queue_, &control_command, 0) != pdTRUE) {
+          ESP_LOGE(TAG, "Queue full, command dropped");
+        }
+        return;
+    }
+    this->publish_state();
+  }
+}
+
+media_player::MediaPlayerTraits SpeakerSourceMediaPlayer::get_traits() {
+  auto traits = media_player::MediaPlayerTraits();
+  traits.set_supports_pause(true);
+
+  for (const auto &ps : this->pipelines_) {
+    if (ps.format.has_value()) {
+      traits.get_supported_formats().push_back(ps.format.value());
+    }
+  }
+
+  return traits;
+}
+
+void SpeakerSourceMediaPlayer::save_volume_restore_state_() {
+  VolumeRestoreState volume_restore_state;
+  volume_restore_state.volume = this->volume;
+  volume_restore_state.is_muted = this->is_muted_;
+  this->pref_.save(&volume_restore_state);
+}
+
+void SpeakerSourceMediaPlayer::set_mute_state_(bool mute_state, bool publish) {
+  if (this->is_muted_ == mute_state) {
+    return;
+  }
+
+  for (auto &ps : this->pipelines_) {
+    if (ps.is_configured()) {
+      ps.speaker->set_mute_state(mute_state);
+    }
+  }
+
+  this->is_muted_ = mute_state;
+
+  if (publish) {
+    this->save_volume_restore_state_();
+  }
+
+  // Notify all media sources about the mute state change
+  for (auto &ps : this->pipelines_) {
+    for (auto &binding : ps.sources) {
+      binding->source->notify_mute_changed(mute_state);
+    }
+  }
+
+  if (mute_state) {
+    this->defer([this]() { this->mute_trigger_.trigger(); });
+  } else {
+    this->defer([this]() { this->unmute_trigger_.trigger(); });
+  }
+}
+
+void SpeakerSourceMediaPlayer::set_volume_(float volume, bool publish) {
+  // Remap the volume to fit within the configured limits
+  float bounded_volume = remap<float, float>(volume, 0.0f, 1.0f, this->volume_min_, this->volume_max_);
+
+  for (auto &ps : this->pipelines_) {
+    if (ps.is_configured()) {
+      ps.speaker->set_volume(bounded_volume);
+    }
+  }
+
+  if (publish) {
+    this->volume = volume;
+  }
+
+  // Notify all media sources about the volume change
+  for (auto &ps : this->pipelines_) {
+    for (auto &binding : ps.sources) {
+      binding->source->notify_volume_changed(volume);
+    }
+  }
+
+  // Turn on the mute state if the volume is effectively zero, off otherwise.
+  // Pass publish=false to avoid saving twice.
+  if (volume < 0.001) {
+    this->set_mute_state_(true, false);
+  } else {
+    this->set_mute_state_(false, false);
+  }
+
+  // Save after mute mutation so the restored state has the correct is_muted_ value
+  if (publish) {
+    this->save_volume_restore_state_();
+  }
+
+  this->defer([this, volume]() { this->volume_trigger_.trigger(volume); });
+}
+
+}  // namespace esphome::speaker_source
+
+#endif  // USE_ESP32
diff --git a/esphome/components/speaker_source/speaker_source_media_player.h b/esphome/components/speaker_source/speaker_source_media_player.h
new file mode 100644
index 00000000000..7896fef295a
--- /dev/null
+++ b/esphome/components/speaker_source/speaker_source_media_player.h
@@ -0,0 +1,217 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_ESP32
+
+#include "esphome/components/audio/audio.h"
+#include "esphome/components/media_source/media_source.h"
+#include "esphome/components/media_player/media_player.h"
+#include "esphome/components/speaker/speaker.h"
+
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "esphome/core/preferences.h"
+
+#include <array>
+#include <atomic>
+#include <memory>
+#include <vector>
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
+
+namespace esphome::speaker_source {
+
+// THREADING MODEL:
+// This component coordinates media sources that run their own decode tasks with speakers
+// that have their own playback callback tasks. Three thread contexts exist:
+//
+// - Main loop task: setup(), loop(), dump_config(), handle_media_state_changed_(),
+//   handle_volume_request_(), handle_mute_request_(), handle_play_uri_request_(),
+//   set_volume_(), set_mute_state_(), control(), get_media_pipeline_state_(),
+//   find_source_for_uri_(), try_execute_play_uri_(), save_volume_restore_state_()
+//
+// - Media source task(s): handle_media_output_() via SourceBinding::write_audio().
+//   Called from each source's decode task thread when streaming audio data.
+//   Reads ps.active_source (atomic), writes ps.pending_frames (atomic), and calls
+//   ps.speaker methods (speaker pointer is immutable after setup).
+//
+// - Speaker callback task: handle_speaker_playback_callback_() via speaker's
+//   add_audio_output_callback(). Called when the speaker finishes writing frames to the DAC.
+//   Reads ps.active_source (atomic), writes ps.pending_frames (atomic), and calls
+//   active_source->notify_audio_played().
+//
+// control() is only called from the main loop (HA/automation commands).
+// Source tasks use defer() for all requests (volume, mute, play_uri).
+//
+// Thread-safe communication:
+// - FreeRTOS queue (media_control_command_queue_): control() -> loop() for play/command dispatch
+// - defer(): SourceBinding::request_volume/request_mute/request_play_uri -> main loop
+// - Atomic fields (active_source, pending_frames): shared between all three thread contexts
+//
+// Non-atomic pipeline fields (last_source, stopping_source, pending_source) are only accessed
+// from the main loop thread.
+
+enum Pipeline : uint8_t {
+  MEDIA_PIPELINE = 0,
+};
+
+// Forward declaration
+class SpeakerSourceMediaPlayer;
+
+/// @brief Per-source listener binding that captures the source pointer at registration time.
+/// Each binding implements MediaSourceListener and forwards callbacks to the player with the source identified.
+/// Defined before PipelineContext so pipelines can own their bindings directly.
+struct SourceBinding : public media_source::MediaSourceListener {
+  SourceBinding(SpeakerSourceMediaPlayer *player, media_source::MediaSource *source, uint8_t pipeline)
+      : player(player), source(source), pipeline(pipeline) {}
+  SpeakerSourceMediaPlayer *player;
+  media_source::MediaSource *source;
+  uint8_t pipeline;
+
+  // Implementations are in the .cpp file because SpeakerSourceMediaPlayer is only forward-declared here
+  size_t write_audio(const uint8_t *data, size_t length, uint32_t timeout_ms,
+                     const audio::AudioStreamInfo &stream_info) override;
+  void report_state(media_source::MediaSourceState state) override;
+  void request_volume(float volume) override;
+  void request_mute(bool is_muted) override;
+  void request_play_uri(const std::string &uri) override;
+};
+
+struct PipelineContext {
+  speaker::Speaker *speaker{nullptr};
+  optional<media_player::MediaPlayerSupportedFormat> format;
+
+  std::atomic<media_source::MediaSource *> active_source{nullptr};
+  media_source::MediaSource *last_source{nullptr};
+  media_source::MediaSource *stopping_source{nullptr};  // Source we've asked to stop, awaiting IDLE
+  media_source::MediaSource *pending_source{nullptr};   // Source we've asked to play, awaiting PLAYING
+
+  // Each SourceBinding pairs a MediaSource* with its listener implementation.
+  // Uses unique_ptr so binding addresses are stable and set_listener() can be called in add_media_source().
+  // Uses std::vector because the count varies across instances (multiple speaker_source media players may exist).
+  std::vector<std::unique_ptr<SourceBinding>> sources;
+
+  // Track frames sent to speaker to correlate with playback callbacks.
+  // Atomic because it is written from the main loop/source tasks and read/decremented from the speaker playback
+  // callback.
+  std::atomic<uint32_t> pending_frames{0};
+
+  /// @brief Check if this pipeline is configured (has a speaker assigned)
+  bool is_configured() const { return this->speaker != nullptr; }
+};
+
+struct MediaPlayerControlCommand {
+  enum Type : uint8_t {
+    PLAY_URI,      // Find a source that can handle this URI and play it
+    SEND_COMMAND,  // Send command to active source
+  };
+  Type type;
+  uint8_t pipeline;
+
+  union {
+    std::string *uri;  // Owned pointer, must delete after xQueueReceive (for PLAY_URI)
+    media_player::MediaPlayerCommand command;
+  } data;
+};
+
+struct VolumeRestoreState {
+  float volume;
+  bool is_muted;
+};
+
+class SpeakerSourceMediaPlayer : public Component, public media_player::MediaPlayer {
+  friend struct SourceBinding;
+
+ public:
+  float get_setup_priority() const override { return esphome::setup_priority::PROCESSOR; }
+  void setup() override;
+  void loop() override;
+  void dump_config() override;
+
+  // MediaPlayer implementations
+  media_player::MediaPlayerTraits get_traits() override;
+  bool is_muted() const override { return this->is_muted_; }
+
+  // Percentage to increase or decrease the volume for volume up or volume down commands
+  void set_volume_increment(float volume_increment) { this->volume_increment_ = volume_increment; }
+
+  // Volume used initially on first boot when no volume had been previously saved
+  void set_volume_initial(float volume_initial) { this->volume_initial_ = volume_initial; }
+
+  void set_volume_max(float volume_max) { this->volume_max_ = volume_max; }
+  void set_volume_min(float volume_min) { this->volume_min_ = volume_min; }
+
+  /// @brief Adds a media source to a pipeline and registers this player as its listener
+  void add_media_source(uint8_t pipeline, media_source::MediaSource *media_source);
+
+  void set_speaker(uint8_t pipeline, speaker::Speaker *speaker) { this->pipelines_[pipeline].speaker = speaker; }
+  void set_format(uint8_t pipeline, const media_player::MediaPlayerSupportedFormat &format) {
+    this->pipelines_[pipeline].format = format;
+  }
+
+  Trigger<> *get_mute_trigger() { return &this->mute_trigger_; }
+  Trigger<> *get_unmute_trigger() { return &this->unmute_trigger_; }
+  Trigger<float> *get_volume_trigger() { return &this->volume_trigger_; }
+
+ protected:
+  // Callbacks from source bindings (pipeline index is captured at binding creation time)
+  size_t handle_media_output_(uint8_t pipeline, media_source::MediaSource *source, const uint8_t *data, size_t length,
+                              uint32_t timeout_ms, const audio::AudioStreamInfo &stream_info);
+  void handle_media_state_changed_(uint8_t pipeline, media_source::MediaSource *source,
+                                   media_source::MediaSourceState state);
+  void handle_volume_request_(float volume);
+  void handle_mute_request_(bool is_muted);
+  void handle_play_uri_request_(uint8_t pipeline, const std::string &uri);
+
+  void handle_speaker_playback_callback_(uint32_t frames, int64_t timestamp, uint8_t pipeline);
+
+  // Receives commands from HA or from the voice assistant component
+  // Sends commands to the media_control_command_queue_
+  void control(const media_player::MediaPlayerCall &call) override;
+
+  /// @brief Updates this->volume and saves volume/mute state to flash for restoration if publish is true.
+  void set_volume_(float volume, bool publish = true);
+
+  /// @brief Sets the mute state.
+  /// @param mute_state If true, audio will be muted. If false, audio will be unmuted
+  /// @param publish If true, saves volume/mute state to flash for restoration
+  void set_mute_state_(bool mute_state, bool publish = true);
+
+  /// @brief Saves the current volume and mute state to the flash for restoration.
+  void save_volume_restore_state_();
+
+  /// @brief Determine media player state from the media pipeline's active source
+  /// @param media_source Active source for the media pipeline (may be nullptr)
+  /// @return The appropriate MediaPlayerState
+  media_player::MediaPlayerState get_media_pipeline_state_(media_source::MediaSource *media_source) const;
+
+  bool try_execute_play_uri_(const std::string &uri, uint8_t pipeline);
+  media_source::MediaSource *find_source_for_uri_(const std::string &uri, uint8_t pipeline);
+  QueueHandle_t media_control_command_queue_;
+
+  // Pipeline context for media pipeline. See THREADING MODEL at top of namespace for access rules.
+  std::array<PipelineContext, 1> pipelines_;
+
+  // Used to save volume/mute state for restoration on reboot
+  ESPPreferenceObject pref_;
+
+  Trigger<> mute_trigger_;
+  Trigger<> unmute_trigger_;
+  Trigger<float> volume_trigger_;
+
+  // The amount to change the volume on volume up/down commands
+  float volume_increment_;
+
+  // The initial volume used by Setup when no previous volume was saved
+  float volume_initial_;
+
+  float volume_max_;
+  float volume_min_;
+
+  bool is_muted_{false};
+};
+
+}  // namespace esphome::speaker_source
+
+#endif  // USE_ESP32
diff --git a/esphome/components/sprinkler/__init__.py b/esphome/components/sprinkler/__init__.py
index 50c69f94967..6e2ff4ee2e1 100644
--- a/esphome/components/sprinkler/__init__.py
+++ b/esphome/components/sprinkler/__init__.py
@@ -422,6 +422,7 @@ CONFIG_SCHEMA = cv.All(
     "sprinkler.set_divider",
     SetDividerAction,
     SPRINKLER_ACTION_SET_DIVIDER_SCHEMA,
+    synchronous=True,
 )
 async def sprinkler_set_divider_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -435,6 +436,7 @@ async def sprinkler_set_divider_to_code(config, action_id, template_arg, args):
     "sprinkler.set_multiplier",
     SetMultiplierAction,
     SPRINKLER_ACTION_SET_MULTIPLIER_SCHEMA,
+    synchronous=True,
 )
 async def sprinkler_set_multiplier_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -448,6 +450,7 @@ async def sprinkler_set_multiplier_to_code(config, action_id, template_arg, args
     "sprinkler.queue_valve",
     QueueValveAction,
     SPRINKLER_ACTION_QUEUE_VALVE_SCHEMA,
+    synchronous=True,
 )
 async def sprinkler_set_queued_valve_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -463,6 +466,7 @@ async def sprinkler_set_queued_valve_to_code(config, action_id, template_arg, ar
     "sprinkler.set_repeat",
     SetRepeatAction,
     SPRINKLER_ACTION_REPEAT_SCHEMA,
+    synchronous=True,
 )
 async def sprinkler_set_repeat_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -476,6 +480,7 @@ async def sprinkler_set_repeat_to_code(config, action_id, template_arg, args):
     "sprinkler.set_valve_run_duration",
     SetRunDurationAction,
     SPRINKLER_ACTION_SET_RUN_DURATION_SCHEMA,
+    synchronous=True,
 )
 async def sprinkler_set_valve_run_duration_to_code(
     config, action_id, template_arg, args
@@ -490,7 +495,10 @@ async def sprinkler_set_valve_run_duration_to_code(
 
 
 @automation.register_action(
-    "sprinkler.start_from_queue", StartFromQueueAction, SPRINKLER_ACTION_SCHEMA
+    "sprinkler.start_from_queue",
+    StartFromQueueAction,
+    SPRINKLER_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def sprinkler_start_from_queue_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -498,7 +506,10 @@ async def sprinkler_start_from_queue_to_code(config, action_id, template_arg, ar
 
 
 @automation.register_action(
-    "sprinkler.start_full_cycle", StartFullCycleAction, SPRINKLER_ACTION_SCHEMA
+    "sprinkler.start_full_cycle",
+    StartFullCycleAction,
+    SPRINKLER_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def sprinkler_start_full_cycle_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -509,6 +520,7 @@ async def sprinkler_start_full_cycle_to_code(config, action_id, template_arg, ar
     "sprinkler.start_single_valve",
     StartSingleValveAction,
     SPRINKLER_ACTION_SINGLE_VALVE_SCHEMA,
+    synchronous=True,
 )
 async def sprinkler_start_single_valve_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -522,21 +534,40 @@ async def sprinkler_start_single_valve_to_code(config, action_id, template_arg,
 
 
 @automation.register_action(
-    "sprinkler.clear_queued_valves", ClearQueuedValvesAction, SPRINKLER_ACTION_SCHEMA
+    "sprinkler.clear_queued_valves",
+    ClearQueuedValvesAction,
+    SPRINKLER_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "sprinkler.next_valve", NextValveAction, SPRINKLER_ACTION_SCHEMA
+    "sprinkler.next_valve",
+    NextValveAction,
+    SPRINKLER_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "sprinkler.previous_valve", PreviousValveAction, SPRINKLER_ACTION_SCHEMA
-)
-@automation.register_action("sprinkler.pause", PauseAction, SPRINKLER_ACTION_SCHEMA)
-@automation.register_action("sprinkler.resume", ResumeAction, SPRINKLER_ACTION_SCHEMA)
-@automation.register_action(
-    "sprinkler.resume_or_start_full_cycle", ResumeOrStartAction, SPRINKLER_ACTION_SCHEMA
+    "sprinkler.previous_valve",
+    PreviousValveAction,
+    SPRINKLER_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "sprinkler.shutdown", ShutdownAction, SPRINKLER_ACTION_SCHEMA
+    "sprinkler.pause", PauseAction, SPRINKLER_ACTION_SCHEMA, synchronous=True
+)
+@automation.register_action(
+    "sprinkler.resume", ResumeAction, SPRINKLER_ACTION_SCHEMA, synchronous=True
+)
+@automation.register_action(
+    "sprinkler.resume_or_start_full_cycle",
+    ResumeOrStartAction,
+    SPRINKLER_ACTION_SCHEMA,
+    synchronous=True,
+)
+@automation.register_action(
+    "sprinkler.shutdown",
+    ShutdownAction,
+    SPRINKLER_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def sprinkler_simple_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/sps30/sensor.py b/esphome/components/sps30/sensor.py
index 3c967fc01be..40557f2cbde 100644
--- a/esphome/components/sps30/sensor.py
+++ b/esphome/components/sps30/sensor.py
@@ -180,13 +180,22 @@ SPS30_ACTION_SCHEMA = maybe_simple_id(
 
 
 @automation.register_action(
-    "sps30.start_fan_autoclean", StartFanAction, SPS30_ACTION_SCHEMA
+    "sps30.start_fan_autoclean",
+    StartFanAction,
+    SPS30_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "sps30.start_measurement", StartMeasurementAction, SPS30_ACTION_SCHEMA
+    "sps30.start_measurement",
+    StartMeasurementAction,
+    SPS30_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "sps30.stop_measurement", StopMeasurementAction, SPS30_ACTION_SCHEMA
+    "sps30.stop_measurement",
+    StopMeasurementAction,
+    SPS30_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def sps30_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/stepper/__init__.py b/esphome/components/stepper/__init__.py
index 62bc71f2d17..27d4fc276d9 100644
--- a/esphome/components/stepper/__init__.py
+++ b/esphome/components/stepper/__init__.py
@@ -97,6 +97,7 @@ async def register_stepper(var, config):
             cv.Required(CONF_TARGET): cv.templatable(cv.int_),
         }
     ),
+    synchronous=True,
 )
 async def stepper_set_target_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -115,6 +116,7 @@ async def stepper_set_target_to_code(config, action_id, template_arg, args):
             cv.Required(CONF_POSITION): cv.templatable(cv.int_),
         }
     ),
+    synchronous=True,
 )
 async def stepper_report_position_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -133,6 +135,7 @@ async def stepper_report_position_to_code(config, action_id, template_arg, args)
             cv.Required(CONF_SPEED): cv.templatable(validate_speed),
         }
     ),
+    synchronous=True,
 )
 async def stepper_set_speed_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -151,6 +154,7 @@ async def stepper_set_speed_to_code(config, action_id, template_arg, args):
             cv.Required(CONF_ACCELERATION): cv.templatable(validate_acceleration),
         }
     ),
+    synchronous=True,
 )
 async def stepper_set_acceleration_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -169,6 +173,7 @@ async def stepper_set_acceleration_to_code(config, action_id, template_arg, args
             cv.Required(CONF_DECELERATION): cv.templatable(validate_acceleration),
         }
     ),
+    synchronous=True,
 )
 async def stepper_set_deceleration_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/sx126x/__init__.py b/esphome/components/sx126x/__init__.py
index 413eb139d65..08f4c0fb882 100644
--- a/esphome/components/sx126x/__init__.py
+++ b/esphome/components/sx126x/__init__.py
@@ -290,19 +290,34 @@ NO_ARGS_ACTION_SCHEMA = automation.maybe_simple_id(
 
 
 @automation.register_action(
-    "sx126x.run_image_cal", RunImageCalAction, NO_ARGS_ACTION_SCHEMA
+    "sx126x.run_image_cal",
+    RunImageCalAction,
+    NO_ARGS_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "sx126x.set_mode_tx", SetModeTxAction, NO_ARGS_ACTION_SCHEMA
+    "sx126x.set_mode_tx",
+    SetModeTxAction,
+    NO_ARGS_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "sx126x.set_mode_rx", SetModeRxAction, NO_ARGS_ACTION_SCHEMA
+    "sx126x.set_mode_rx",
+    SetModeRxAction,
+    NO_ARGS_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "sx126x.set_mode_sleep", SetModeSleepAction, NO_ARGS_ACTION_SCHEMA
+    "sx126x.set_mode_sleep",
+    SetModeSleepAction,
+    NO_ARGS_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "sx126x.set_mode_standby", SetModeStandbyAction, NO_ARGS_ACTION_SCHEMA
+    "sx126x.set_mode_standby",
+    SetModeStandbyAction,
+    NO_ARGS_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def no_args_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -320,7 +335,10 @@ SEND_PACKET_ACTION_SCHEMA = cv.maybe_simple_value(
 
 
 @automation.register_action(
-    "sx126x.send_packet", SendPacketAction, SEND_PACKET_ACTION_SCHEMA
+    "sx126x.send_packet",
+    SendPacketAction,
+    SEND_PACKET_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def send_packet_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/sx127x/__init__.py b/esphome/components/sx127x/__init__.py
index f3a9cca93f4..7f554fbf841 100644
--- a/esphome/components/sx127x/__init__.py
+++ b/esphome/components/sx127x/__init__.py
@@ -283,19 +283,34 @@ NO_ARGS_ACTION_SCHEMA = automation.maybe_simple_id(
 
 
 @automation.register_action(
-    "sx127x.run_image_cal", RunImageCalAction, NO_ARGS_ACTION_SCHEMA
+    "sx127x.run_image_cal",
+    RunImageCalAction,
+    NO_ARGS_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "sx127x.set_mode_tx", SetModeTxAction, NO_ARGS_ACTION_SCHEMA
+    "sx127x.set_mode_tx",
+    SetModeTxAction,
+    NO_ARGS_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "sx127x.set_mode_rx", SetModeRxAction, NO_ARGS_ACTION_SCHEMA
+    "sx127x.set_mode_rx",
+    SetModeRxAction,
+    NO_ARGS_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "sx127x.set_mode_sleep", SetModeSleepAction, NO_ARGS_ACTION_SCHEMA
+    "sx127x.set_mode_sleep",
+    SetModeSleepAction,
+    NO_ARGS_ACTION_SCHEMA,
+    synchronous=True,
 )
 @automation.register_action(
-    "sx127x.set_mode_standby", SetModeStandbyAction, NO_ARGS_ACTION_SCHEMA
+    "sx127x.set_mode_standby",
+    SetModeStandbyAction,
+    NO_ARGS_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def no_args_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -313,7 +328,10 @@ SEND_PACKET_ACTION_SCHEMA = cv.maybe_simple_value(
 
 
 @automation.register_action(
-    "sx127x.send_packet", SendPacketAction, SEND_PACKET_ACTION_SCHEMA
+    "sx127x.send_packet",
+    SendPacketAction,
+    SEND_PACKET_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def send_packet_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/template/binary_sensor/__init__.py b/esphome/components/template/binary_sensor/__init__.py
index 9d4208dcca5..e537e1f97cf 100644
--- a/esphome/components/template/binary_sensor/__init__.py
+++ b/esphome/components/template/binary_sensor/__init__.py
@@ -59,6 +59,7 @@ async def to_code(config):
             cv.Required(CONF_STATE): cv.templatable(cv.boolean),
         }
     ),
+    synchronous=True,
 )
 async def binary_sensor_template_publish_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/template/cover/__init__.py b/esphome/components/template/cover/__init__.py
index a4fb0b70210..cfc19c00cdf 100644
--- a/esphome/components/template/cover/__init__.py
+++ b/esphome/components/template/cover/__init__.py
@@ -125,6 +125,7 @@ async def to_code(config):
             cv.Optional(CONF_TILT): cv.templatable(cv.zero_to_one_float),
         }
     ),
+    synchronous=True,
 )
 async def cover_template_publish_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/template/lock/__init__.py b/esphome/components/template/lock/__init__.py
index 4c74a521fa2..d8bd9d16c66 100644
--- a/esphome/components/template/lock/__init__.py
+++ b/esphome/components/template/lock/__init__.py
@@ -90,6 +90,7 @@ async def to_code(config):
         },
         key=CONF_STATE,
     ),
+    synchronous=True,
 )
 async def lock_template_publish_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/template/sensor/__init__.py b/esphome/components/template/sensor/__init__.py
index 2c325427e99..b0f48ade465 100644
--- a/esphome/components/template/sensor/__init__.py
+++ b/esphome/components/template/sensor/__init__.py
@@ -44,6 +44,7 @@ async def to_code(config):
             cv.Required(CONF_STATE): cv.templatable(cv.float_),
         }
     ),
+    synchronous=True,
 )
 async def sensor_template_publish_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/template/switch/__init__.py b/esphome/components/template/switch/__init__.py
index 8ae5a07dc3b..eb6f0f46de7 100644
--- a/esphome/components/template/switch/__init__.py
+++ b/esphome/components/template/switch/__init__.py
@@ -80,6 +80,7 @@ async def to_code(config):
             cv.Required(CONF_STATE): cv.templatable(cv.boolean),
         }
     ),
+    synchronous=True,
 )
 async def switch_template_publish_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/template/text_sensor/__init__.py b/esphome/components/template/text_sensor/__init__.py
index 550b27356d1..ddbdd6dadb7 100644
--- a/esphome/components/template/text_sensor/__init__.py
+++ b/esphome/components/template/text_sensor/__init__.py
@@ -43,6 +43,7 @@ async def to_code(config):
             cv.Required(CONF_STATE): cv.templatable(cv.string_strict),
         }
     ),
+    synchronous=True,
 )
 async def text_sensor_template_publish_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/template/valve/__init__.py b/esphome/components/template/valve/__init__.py
index 526751564de..3e8fd816030 100644
--- a/esphome/components/template/valve/__init__.py
+++ b/esphome/components/template/valve/__init__.py
@@ -112,6 +112,7 @@ async def to_code(config):
             ),
         }
     ),
+    synchronous=True,
 )
 async def valve_template_publish_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/template/water_heater/__init__.py b/esphome/components/template/water_heater/__init__.py
index cb5f2dbe56d..814aa401935 100644
--- a/esphome/components/template/water_heater/__init__.py
+++ b/esphome/components/template/water_heater/__init__.py
@@ -134,6 +134,7 @@ async def to_code(config: ConfigType) -> None:
             cv.Optional(CONF_IS_ON): cv.templatable(cv.boolean),
         }
     ),
+    synchronous=True,
 )
 async def water_heater_template_publish_to_code(
     config: ConfigType,
diff --git a/esphome/components/tm1651/__init__.py b/esphome/components/tm1651/__init__.py
index 49796d9b426..fb35eb21b51 100644
--- a/esphome/components/tm1651/__init__.py
+++ b/esphome/components/tm1651/__init__.py
@@ -73,6 +73,7 @@ BINARY_OUTPUT_ACTION_SCHEMA = maybe_simple_id(
         },
         key=CONF_BRIGHTNESS,
     ),
+    synchronous=True,
 )
 async def tm1651_set_brightness_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -92,6 +93,7 @@ async def tm1651_set_brightness_to_code(config, action_id, template_arg, args):
         },
         key=CONF_LEVEL,
     ),
+    synchronous=True,
 )
 async def tm1651_set_level_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -111,6 +113,7 @@ async def tm1651_set_level_to_code(config, action_id, template_arg, args):
         },
         key=CONF_LEVEL_PERCENT,
     ),
+    synchronous=True,
 )
 async def tm1651_set_level_percent_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -121,7 +124,10 @@ async def tm1651_set_level_percent_to_code(config, action_id, template_arg, args
 
 
 @automation.register_action(
-    "tm1651.turn_off", TurnOffAction, BINARY_OUTPUT_ACTION_SCHEMA
+    "tm1651.turn_off",
+    TurnOffAction,
+    BINARY_OUTPUT_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def output_turn_off_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -129,7 +135,9 @@ async def output_turn_off_to_code(config, action_id, template_arg, args):
     return var
 
 
-@automation.register_action("tm1651.turn_on", TurnOnAction, BINARY_OUTPUT_ACTION_SCHEMA)
+@automation.register_action(
+    "tm1651.turn_on", TurnOnAction, BINARY_OUTPUT_ACTION_SCHEMA, synchronous=True
+)
 async def output_turn_on_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
diff --git a/esphome/components/uart/__init__.py b/esphome/components/uart/__init__.py
index 2cb6eac0509..83649cc2092 100644
--- a/esphome/components/uart/__init__.py
+++ b/esphome/components/uart/__init__.py
@@ -500,6 +500,7 @@ async def register_uart_device(var, config):
         },
         key=CONF_DATA,
     ),
+    synchronous=True,
 )
 async def uart_write_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/udp/__init__.py b/esphome/components/udp/__init__.py
index 37dd871a6c1..17bbf19c9ea 100644
--- a/esphome/components/udp/__init__.py
+++ b/esphome/components/udp/__init__.py
@@ -171,6 +171,7 @@ def validate_raw_data(value):
         },
         key=CONF_DATA,
     ),
+    synchronous=True,
 )
 async def udp_write_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/ufire_ec/sensor.py b/esphome/components/ufire_ec/sensor.py
index 9edf0f89ffa..10b4ece6141 100644
--- a/esphome/components/ufire_ec/sensor.py
+++ b/esphome/components/ufire_ec/sensor.py
@@ -97,6 +97,7 @@ UFIRE_EC_CALIBRATE_PROBE_SCHEMA = cv.Schema(
     "ufire_ec.calibrate_probe",
     UFireECCalibrateProbeAction,
     UFIRE_EC_CALIBRATE_PROBE_SCHEMA,
+    synchronous=True,
 )
 async def ufire_ec_calibrate_probe_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -119,6 +120,7 @@ UFIRE_EC_RESET_SCHEMA = cv.Schema(
     "ufire_ec.reset",
     UFireECResetAction,
     UFIRE_EC_RESET_SCHEMA,
+    synchronous=True,
 )
 async def ufire_ec_reset_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/ufire_ise/sensor.py b/esphome/components/ufire_ise/sensor.py
index 8009cdaa6a8..a116012d055 100644
--- a/esphome/components/ufire_ise/sensor.py
+++ b/esphome/components/ufire_ise/sensor.py
@@ -91,6 +91,7 @@ UFIRE_ISE_CALIBRATE_PROBE_SCHEMA = cv.Schema(
     "ufire_ise.calibrate_probe_low",
     UFireISECalibrateProbeLowAction,
     UFIRE_ISE_CALIBRATE_PROBE_SCHEMA,
+    synchronous=True,
 )
 async def ufire_ise_calibrate_probe_low_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -104,6 +105,7 @@ async def ufire_ise_calibrate_probe_low_to_code(config, action_id, template_arg,
     "ufire_ise.calibrate_probe_high",
     UFireISECalibrateProbeHighAction,
     UFIRE_ISE_CALIBRATE_PROBE_SCHEMA,
+    synchronous=True,
 )
 async def ufire_ise_calibrate_probe_high_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
@@ -120,6 +122,7 @@ UFIRE_ISE_RESET_SCHEMA = cv.Schema({cv.GenerateID(): cv.use_id(UFireISEComponent
     "ufire_ise.reset",
     UFireISEResetAction,
     UFIRE_ISE_RESET_SCHEMA,
+    synchronous=True,
 )
 async def ufire_ise_reset_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
diff --git a/esphome/components/update/__init__.py b/esphome/components/update/__init__.py
index c36a4ab769d..db6c1445e34 100644
--- a/esphome/components/update/__init__.py
+++ b/esphome/components/update/__init__.py
@@ -138,6 +138,7 @@ async def to_code(config):
             cv.Optional(CONF_FORCE_UPDATE, default=False): cv.templatable(cv.boolean),
         }
     ),
+    synchronous=True,
 )
 async def update_perform_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -156,6 +157,7 @@ async def update_perform_action_to_code(config, action_id, template_arg, args):
             cv.GenerateID(): cv.use_id(UpdateEntity),
         }
     ),
+    synchronous=True,
 )
 async def update_check_action_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/valve/__init__.py b/esphome/components/valve/__init__.py
index 22cd01988d8..0319ff50e7f 100644
--- a/esphome/components/valve/__init__.py
+++ b/esphome/components/valve/__init__.py
@@ -180,25 +180,33 @@ VALVE_ACTION_SCHEMA = maybe_simple_id(
 )
 
 
-@automation.register_action("valve.open", OpenAction, VALVE_ACTION_SCHEMA)
+@automation.register_action(
+    "valve.open", OpenAction, VALVE_ACTION_SCHEMA, synchronous=True
+)
 async def valve_open_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("valve.close", CloseAction, VALVE_ACTION_SCHEMA)
+@automation.register_action(
+    "valve.close", CloseAction, VALVE_ACTION_SCHEMA, synchronous=True
+)
 async def valve_close_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("valve.stop", StopAction, VALVE_ACTION_SCHEMA)
+@automation.register_action(
+    "valve.stop", StopAction, VALVE_ACTION_SCHEMA, synchronous=True
+)
 async def valve_stop_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("valve.toggle", ToggleAction, VALVE_ACTION_SCHEMA)
+@automation.register_action(
+    "valve.toggle", ToggleAction, VALVE_ACTION_SCHEMA, synchronous=True
+)
 async def valve_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)
@@ -214,7 +222,9 @@ VALVE_CONTROL_ACTION_SCHEMA = cv.Schema(
 )
 
 
-@automation.register_action("valve.control", ControlAction, VALVE_CONTROL_ACTION_SCHEMA)
+@automation.register_action(
+    "valve.control", ControlAction, VALVE_CONTROL_ACTION_SCHEMA, synchronous=True
+)
 async def valve_control_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)
diff --git a/esphome/components/voice_assistant/__init__.py b/esphome/components/voice_assistant/__init__.py
index 8b7dcb4f212..d970df2a44b 100644
--- a/esphome/components/voice_assistant/__init__.py
+++ b/esphome/components/voice_assistant/__init__.py
@@ -393,6 +393,7 @@ VOICE_ASSISTANT_ACTION_SCHEMA = cv.Schema({cv.GenerateID(): cv.use_id(VoiceAssis
     "voice_assistant.start_continuous",
     StartContinuousAction,
     VOICE_ASSISTANT_ACTION_SCHEMA,
+    synchronous=True,
 )
 @register_action(
     "voice_assistant.start",
@@ -403,6 +404,7 @@ VOICE_ASSISTANT_ACTION_SCHEMA = cv.Schema({cv.GenerateID(): cv.use_id(VoiceAssis
             cv.Optional(CONF_WAKE_WORD): cv.templatable(cv.string),
         }
     ),
+    synchronous=True,
 )
 async def voice_assistant_listen_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -415,7 +417,9 @@ async def voice_assistant_listen_to_code(config, action_id, template_arg, args):
     return var
 
 
-@register_action("voice_assistant.stop", StopAction, VOICE_ASSISTANT_ACTION_SCHEMA)
+@register_action(
+    "voice_assistant.stop", StopAction, VOICE_ASSISTANT_ACTION_SCHEMA, synchronous=True
+)
 async def voice_assistant_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])
diff --git a/esphome/components/wifi/__init__.py b/esphome/components/wifi/__init__.py
index 46bdb20a105..3681e0596a6 100644
--- a/esphome/components/wifi/__init__.py
+++ b/esphome/components/wifi/__init__.py
@@ -682,12 +682,16 @@ async def wifi_ap_active_to_code(config, condition_id, template_arg, args):
     return cg.new_Pvariable(condition_id, template_arg)
 
 
-@automation.register_action("wifi.enable", WiFiEnableAction, cv.Schema({}))
+@automation.register_action(
+    "wifi.enable", WiFiEnableAction, cv.Schema({}), synchronous=True
+)
 async def wifi_enable_to_code(config, action_id, template_arg, args):
     return cg.new_Pvariable(action_id, template_arg)
 
 
-@automation.register_action("wifi.disable", WiFiDisableAction, cv.Schema({}))
+@automation.register_action(
+    "wifi.disable", WiFiDisableAction, cv.Schema({}), synchronous=True
+)
 async def wifi_disable_to_code(config, action_id, template_arg, args):
     return cg.new_Pvariable(action_id, template_arg)
 
@@ -793,6 +797,7 @@ async def final_step():
             cv.Optional(CONF_ON_ERROR): automation.validate_automation(single=True),
         }
     ),
+    synchronous=False,
 )
 async def wifi_set_sta_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/wireguard/__init__.py b/esphome/components/wireguard/__init__.py
index 124d9a8c328..e2ea61a5428 100644
--- a/esphome/components/wireguard/__init__.py
+++ b/esphome/components/wireguard/__init__.py
@@ -168,6 +168,7 @@ async def wireguard_enabled_to_code(config, condition_id, template_arg, args):
     "wireguard.enable",
     WireguardEnableAction,
     cv.Schema({cv.GenerateID(): cv.use_id(Wireguard)}),
+    synchronous=True,
 )
 async def wireguard_enable_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
@@ -179,6 +180,7 @@ async def wireguard_enable_to_code(config, action_id, template_arg, args):
     "wireguard.disable",
     WireguardDisableAction,
     cv.Schema({cv.GenerateID(): cv.use_id(Wireguard)}),
+    synchronous=True,
 )
 async def wireguard_disable_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
diff --git a/esphome/components/zigbee/__init__.py b/esphome/components/zigbee/__init__.py
index a327cc29886..280ff6b50cc 100644
--- a/esphome/components/zigbee/__init__.py
+++ b/esphome/components/zigbee/__init__.py
@@ -195,6 +195,7 @@ FactoryResetAction = zigbee_ns.class_(
     "zigbee.factory_reset",
     FactoryResetAction,
     ZIGBEE_ACTION_SCHEMA,
+    synchronous=True,
 )
 async def reset_zigbee_to_code(
     config: ConfigType,
diff --git a/esphome/core/defines.h b/esphome/core/defines.h
index 73791889544..04df5c4103a 100644
--- a/esphome/core/defines.h
+++ b/esphome/core/defines.h
@@ -340,6 +340,7 @@
 #define USE_I2C
 #define USE_LOGGER_USB_CDC
 #define USE_SOCKET_IMPL_LWIP_TCP
+#define USE_RP2040_BLE
 #define USE_SPI
 #endif
 
diff --git a/esphome/core/log.cpp b/esphome/core/log.cpp
index f92b59fe134..0da457adec2 100644
--- a/esphome/core/log.cpp
+++ b/esphome/core/log.cpp
@@ -1,6 +1,7 @@
 #include "log.h"
 #include "defines.h"
 #include "helpers.h"
+#include <cstdio>
 
 #ifdef USE_LOGGER
 #include "esphome/components/logger/logger.h"
@@ -8,16 +9,26 @@
 
 namespace esphome {
 
-// IMPORTANT: Do not add null checks on global_logger here.
-// These functions are the hot path for ALL logging across the entire firmware,
-// so every instruction matters. Logger::pre_setup() sets global_logger before
-// any other component is created in the generated setup() function, so it is
-// guaranteed to be valid by the time any log function is invoked. This invariant
-// is enforced by codegen ordering and tested in
-// tests/component_tests/logger/test_logger.py.
+#ifdef ESPHOME_DEBUG
+static void early_log_printf_(const char *tag, int line, const char *format, va_list args) {
+  fprintf(stderr, "LOG BEFORE LOGGER INIT [%s:%d]: ", tag, line);
+  vfprintf(stderr, format, args);
+  fputc('\n', stderr);
+  assert(false && "log called before Logger::pre_setup()");  // NOLINT
+}
+#endif
+
 void HOT esp_log_printf_(int level, const char *tag, int line, const char *format, ...) {  // NOLINT
 #ifdef USE_LOGGER
-  ESPHOME_DEBUG_ASSERT(logger::global_logger != nullptr);
+#ifdef ESPHOME_DEBUG
+  if (logger::global_logger == nullptr) {
+    va_list arg;
+    va_start(arg, format);
+    early_log_printf_(tag, line, format, arg);
+    va_end(arg);
+    return;
+  }
+#endif
   va_list arg;
   va_start(arg, format);
   logger::global_logger->log_vprintf_(static_cast<uint8_t>(level), tag, line, format, arg);
@@ -39,15 +50,35 @@ void HOT esp_log_printf_(int level, const char *tag, int line, const __FlashStri
 
 void HOT esp_log_vprintf_(int level, const char *tag, int line, const char *format, va_list args) {  // NOLINT
 #ifdef USE_LOGGER
-  ESPHOME_DEBUG_ASSERT(logger::global_logger != nullptr);
+#ifdef ESPHOME_DEBUG
+  if (logger::global_logger == nullptr) {
+    early_log_printf_(tag, line, format, args);
+    return;
+  }
+#endif
   logger::global_logger->log_vprintf_(static_cast<uint8_t>(level), tag, line, format, args);
 #endif
 }
 
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+// Remove before 2026.9.0
+void HOT esp_log_vprintf_(int level, const char *tag, int line, const __FlashStringHelper *format, va_list args) {
+#ifdef USE_LOGGER
+  ESPHOME_DEBUG_ASSERT(logger::global_logger != nullptr);
+  logger::global_logger->log_vprintf_(static_cast<uint8_t>(level), tag, line, format, args);
+#endif
+}
+#endif
+
 #ifdef USE_ESP32
 int HOT esp_idf_log_vprintf_(const char *format, va_list args) {  // NOLINT
 #ifdef USE_LOGGER
-  ESPHOME_DEBUG_ASSERT(logger::global_logger != nullptr);
+#ifdef ESPHOME_DEBUG
+  if (logger::global_logger == nullptr) {
+    early_log_printf_("esp-idf", 0, format, args);
+    return 0;
+  }
+#endif
   logger::global_logger->log_vprintf_(ESPHOME_LOG_LEVEL, "esp-idf", 0, format, args);
 #endif
   return 0;
diff --git a/esphome/core/log.h b/esphome/core/log.h
index 134e8161504..ff39633142e 100644
--- a/esphome/core/log.h
+++ b/esphome/core/log.h
@@ -68,6 +68,11 @@ void esp_log_printf_(int level, const char *tag, int line, const char *format, .
 void esp_log_printf_(int level, const char *tag, int line, const __FlashStringHelper *format, ...);
 #endif
 void esp_log_vprintf_(int level, const char *tag, int line, const char *format, va_list args);  // NOLINT
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+// Remove before 2026.9.0
+__attribute__((deprecated("Use esp_log_printf_() instead. Removed in 2026.9.0."))) void esp_log_vprintf_(
+    int level, const char *tag, int line, const __FlashStringHelper *format, va_list args);
+#endif
 #if defined(USE_ESP32)
 int esp_idf_log_vprintf_(const char *format, va_list args);  // NOLINT
 #endif
diff --git a/esphome/espidf_api.py b/esphome/espidf_api.py
index 9e9c57bfbdb..9ebcc48513c 100644
--- a/esphome/espidf_api.py
+++ b/esphome/espidf_api.py
@@ -8,7 +8,6 @@ import shutil
 import subprocess
 
 from esphome.components.esp32.const import KEY_ESP32, KEY_FLASH_SIZE
-from esphome.const import CONF_COMPILE_PROCESS_LIMIT, CONF_ESPHOME
 from esphome.core import CORE, EsphomeError
 
 _LOGGER = logging.getLogger(__name__)
@@ -102,6 +101,55 @@ def run_reconfigure() -> int:
     return run_idf_py("reconfigure")
 
 
+def has_outdated_files():
+    """Check if the build configuration is stale.
+
+    Returns True if required build files are missing or if configuration inputs
+    are newer than the generated CMake/Ninja build artifacts.
+    """
+    cmakecache_txt_path = CORE.relative_build_path("build/CMakeCache.txt")
+
+    cmakelists_txt_build_path = CORE.relative_build_path("CMakeLists.txt")
+    cmakelists_txt_src_path = CORE.relative_src_path("CMakeLists.txt")
+    build_config_path = CORE.relative_build_path("build/config")
+    sdkconfig_internal_path = CORE.relative_build_path(
+        f"sdkconfig.{CORE.name}.esphomeinternal"
+    )
+    dependency_lock_path = CORE.relative_build_path("dependencies.lock")
+    build_ninja_path = CORE.relative_build_path("build/build.ninja")
+
+    if not os.path.isdir(build_config_path) or not os.listdir(build_config_path):
+        return True
+    if not os.path.isfile(cmakecache_txt_path):
+        return True
+    if not os.path.isfile(build_ninja_path):
+        return True
+    if os.path.isfile(dependency_lock_path) and os.path.getmtime(
+        dependency_lock_path
+    ) > os.path.getmtime(build_ninja_path):
+        return True
+
+    cmakecache_txt_mtime = os.path.getmtime(cmakecache_txt_path)
+    return any(
+        os.path.getmtime(f) > cmakecache_txt_mtime
+        for f in [
+            _get_idf_path(),
+            cmakelists_txt_build_path,
+            cmakelists_txt_src_path,
+            sdkconfig_internal_path,
+            build_config_path,
+        ]
+        if f and os.path.exists(f)
+    )
+
+
+def need_reconfigure() -> bool:
+    from esphome.build_gen.espidf import has_discovered_components
+
+    # We need to reconfigure either if the files are outdated or if there is no component discovered
+    return has_outdated_files() or not has_discovered_components()
+
+
 def run_compile(config, verbose: bool) -> int:
     """Compile the ESP-IDF project.
 
@@ -110,10 +158,10 @@ def run_compile(config, verbose: bool) -> int:
     2. Regenerate CMakeLists.txt with discovered components
     3. Run full build
     """
-    from esphome.build_gen.espidf import has_discovered_components, write_project
+    from esphome.build_gen.espidf import write_project
 
     # Check if we need to do discovery phase
-    if not has_discovered_components():
+    if need_reconfigure():
         _LOGGER.info("Discovering available ESP-IDF components...")
         write_project(minimal=True)
         rc = run_reconfigure()
@@ -124,15 +172,12 @@ def run_compile(config, verbose: bool) -> int:
         write_project(minimal=False)
 
     # Build
-    args = ["build"]
+    args = []
 
     if verbose:
         args.append("-v")
 
-    # Add parallel job limit if configured
-    if CONF_COMPILE_PROCESS_LIMIT in config.get(CONF_ESPHOME, {}):
-        limit = config[CONF_ESPHOME][CONF_COMPILE_PROCESS_LIMIT]
-        args.extend(["-j", str(limit)])
+    args.append("build")
 
     # Set the sdkconfig file
     sdkconfig_path = CORE.relative_build_path(f"sdkconfig.{CORE.name}")
diff --git a/esphome/idf_component.yml b/esphome/idf_component.yml
index 550e7b9af79..acd7f7a4798 100644
--- a/esphome/idf_component.yml
+++ b/esphome/idf_component.yml
@@ -12,7 +12,7 @@ dependencies:
   espressif/mdns:
     version: 1.10.0
   espressif/esp_wifi_remote:
-    version: 1.3.2
+    version: 1.4.0
     rules:
       - if: "target in [esp32h2, esp32p4]"
   espressif/eppp_link:
@@ -20,7 +20,7 @@ dependencies:
     rules:
       - if: "target in [esp32h2, esp32p4]"
   espressif/esp_hosted:
-    version: 2.11.5
+    version: 2.12.0
     rules:
       - if: "target in [esp32h2, esp32p4]"
   zorxx/multipart-parser:
diff --git a/esphome/util.py b/esphome/util.py
index 2bb9c93030a..754e39afabf 100644
--- a/esphome/util.py
+++ b/esphome/util.py
@@ -402,6 +402,21 @@ def get_picotool_path(cc_path: str) -> Path | None:
     return None
 
 
+def is_picotool_usb_permission_error(output: str | bytes) -> bool:
+    """Check if picotool output indicates a USB permission error."""
+    if isinstance(output, str):
+        return (
+            "unable to connect" in output
+            or "LIBUSB_ERROR_ACCESS" in output
+            or "Permission denied" in output
+        )
+    return (
+        b"unable to connect" in output
+        or b"LIBUSB_ERROR_ACCESS" in output
+        or b"Permission denied" in output
+    )
+
+
 @dataclass
 class BootselResult:
     """Result of RP2040 BOOTSEL detection."""
@@ -426,10 +441,9 @@ def detect_rp2040_bootsel(picotool_path: str | Path) -> BootselResult:
         device_count = result.stdout.count(b"type:")
         if device_count > 0:
             return BootselResult(device_count)
-        # Check stderr for permission issues — picotool can see the device
+        # Check for permission issues — picotool can see the device
         # on the USB bus but can't connect without proper permissions
-        combined = result.stderr + result.stdout
-        if b"unable to connect" in combined or b"LIBUSB_ERROR_ACCESS" in combined:
+        if is_picotool_usb_permission_error(result.stderr + result.stdout):
             return BootselResult(0, permission_error=True)
         return BootselResult(0)
     except (OSError, subprocess.TimeoutExpired):
diff --git a/tests/component_tests/logger/test_logger.py b/tests/component_tests/logger/test_logger.py
index 83f8caa2d82..98aa7419642 100644
--- a/tests/component_tests/logger/test_logger.py
+++ b/tests/component_tests/logger/test_logger.py
@@ -11,33 +11,40 @@ def test_logger_pre_setup_before_other_components(generate_main):
     """
     main_cpp = generate_main("tests/component_tests/logger/test_logger.yaml")
 
-    # Find the position of logger pre_setup
-    pre_setup_match = re.search(r"->pre_setup\(\)", main_cpp)
-    assert pre_setup_match is not None, "Logger pre_setup() not found in generated code"
+    # Find the logger's pre_setup() call specifically
+    logger_pre_setup = re.search(r"logger_logger->pre_setup\(\)", main_cpp)
+    if logger_pre_setup is None:
+        # Fall back to finding any logger-related pre_setup
+        logger_pre_setup = re.search(r"logger\w*->pre_setup\(\)", main_cpp)
+    assert logger_pre_setup is not None, (
+        "Logger pre_setup() not found in generated code"
+    )
 
     # Find all "new " allocations (component creation)
     new_allocations = list(re.finditer(r"\bnew [\w:]+", main_cpp))
     assert len(new_allocations) > 0, "No component allocations found"
 
-    # Find the logger allocation
-    logger_new = None
-    for alloc in new_allocations:
-        if "logger" in alloc.group():
-            logger_new = alloc
-            break
+    # Separate logger and non-logger allocations
+    logger_allocs = [a for a in new_allocations if "logger" in a.group().lower()]
+    non_logger_allocs = [
+        a
+        for a in new_allocations
+        if "logger" not in a.group().lower()
+        # Skip placement new for App
+        and "(&App)" not in main_cpp[max(0, a.start() - 5) : a.start()]
+    ]
 
-    assert logger_new is not None, (
+    assert len(logger_allocs) > 0, (
         f"Logger allocation not found in: {[a.group() for a in new_allocations]}"
     )
+    assert len(non_logger_allocs) > 0, (
+        "No non-logger component allocations found — "
+        "add a component to test_logger.yaml so the ordering check is meaningful"
+    )
 
-    # All non-logger allocations must appear after pre_setup()
-    for alloc in new_allocations:
-        if alloc == logger_new:
-            continue
-        # Skip "new (&App)" placement new which is before logger
-        if "(&App)" in main_cpp[max(0, alloc.start() - 5) : alloc.start()]:
-            continue
-        assert alloc.start() > pre_setup_match.start(), (
+    # All non-logger allocations must appear after logger pre_setup()
+    for alloc in non_logger_allocs:
+        assert alloc.start() > logger_pre_setup.start(), (
             f"Component allocation '{alloc.group()}' at position {alloc.start()} "
-            f"appears before logger pre_setup() at position {pre_setup_match.start()}"
+            f"appears before logger pre_setup() at position {logger_pre_setup.start()}"
         )
diff --git a/tests/component_tests/logger/test_logger.yaml b/tests/component_tests/logger/test_logger.yaml
index 5d983cb3f5d..f43e99d94fd 100644
--- a/tests/component_tests/logger/test_logger.yaml
+++ b/tests/component_tests/logger/test_logger.yaml
@@ -7,3 +7,8 @@ esp8266:
 
 logger:
   level: DEBUG
+
+# Need at least one non-logger component so the ordering test
+# can verify that logger pre_setup() comes before other allocations.
+preferences:
+  flash_write_interval: 1min
diff --git a/tests/components/online_image/common.yaml b/tests/components/online_image/common.yaml
index 422a24b5406..fc3cc942172 100644
--- a/tests/components/online_image/common.yaml
+++ b/tests/components/online_image/common.yaml
@@ -40,6 +40,10 @@ online_image:
     url: https://samples-files.com/samples/images/bmp/480-360-sample.bmp
     format: BMP
     type: BINARY
+  - id: online_rgb_bmp_8bit
+    url: https://samples-files.com/samples/images/bmp/480-360-sample.bmp
+    format: BMP
+    type: RGB
   - id: online_jpeg_image
     url: http://www.faqs.org/images/library.jpg
     format: JPEG
diff --git a/tests/components/rp2040_ble/common.yaml b/tests/components/rp2040_ble/common.yaml
new file mode 100644
index 00000000000..f6205a4724f
--- /dev/null
+++ b/tests/components/rp2040_ble/common.yaml
@@ -0,0 +1 @@
+rp2040_ble:
diff --git a/tests/components/rp2040_ble/test-disable-on-boot.rp2040-ard.yaml b/tests/components/rp2040_ble/test-disable-on-boot.rp2040-ard.yaml
new file mode 100644
index 00000000000..2154536111f
--- /dev/null
+++ b/tests/components/rp2040_ble/test-disable-on-boot.rp2040-ard.yaml
@@ -0,0 +1,2 @@
+rp2040_ble:
+  enable_on_boot: false
diff --git a/tests/components/rp2040_ble/test.rp2040-ard.yaml b/tests/components/rp2040_ble/test.rp2040-ard.yaml
new file mode 100644
index 00000000000..dade44d145b
--- /dev/null
+++ b/tests/components/rp2040_ble/test.rp2040-ard.yaml
@@ -0,0 +1 @@
+<<: !include common.yaml
diff --git a/tests/components/speaker_source/common.yaml b/tests/components/speaker_source/common.yaml
new file mode 100644
index 00000000000..cfcb065f57c
--- /dev/null
+++ b/tests/components/speaker_source/common.yaml
@@ -0,0 +1,43 @@
+i2s_audio:
+  i2s_lrclk_pin: ${i2s_bclk_pin}
+  i2s_bclk_pin: ${i2s_lrclk_pin}
+  i2s_mclk_pin: ${i2s_mclk_pin}
+
+speaker:
+  - platform: i2s_audio
+    id: speaker_id
+    dac_type: external
+    i2s_dout_pin: ${i2s_dout_pin}
+    sample_rate: 48000
+    num_channels: 2
+
+audio_file:
+  - id: test_audio
+    file:
+      type: local
+      path: $component_dir/test.wav
+
+media_source:
+  - platform: audio_file
+    id: audio_file_source
+
+media_player:
+  - platform: speaker_source
+    id: media_player_id
+    name: Media Player
+    volume_increment: 0.02
+    volume_initial: 0.75
+    volume_max: 0.95
+    volume_min: 0.0
+    media_pipeline:
+      speaker: speaker_id
+      format: FLAC
+      num_channels: 1
+      sources:
+        - audio_file_source
+    on_mute:
+      - media_player.pause:
+          id: media_player_id
+    on_unmute:
+      - media_player.play:
+          id: media_player_id
diff --git a/tests/components/speaker_source/test.esp32-idf.yaml b/tests/components/speaker_source/test.esp32-idf.yaml
new file mode 100644
index 00000000000..e2439ebdf21
--- /dev/null
+++ b/tests/components/speaker_source/test.esp32-idf.yaml
@@ -0,0 +1,9 @@
+substitutions:
+  scl_pin: GPIO16
+  sda_pin: GPIO17
+  i2s_bclk_pin: GPIO27
+  i2s_lrclk_pin: GPIO26
+  i2s_mclk_pin: GPIO25
+  i2s_dout_pin: GPIO23
+
+<<: !include common.yaml
diff --git a/tests/components/speaker_source/test.wav b/tests/components/speaker_source/test.wav
new file mode 100644
index 00000000000..f9d07ef2238
Binary files /dev/null and b/tests/components/speaker_source/test.wav differ
diff --git a/tests/unit_tests/test_util.py b/tests/unit_tests/test_util.py
index 1ca4375f8f9..ca3fd9b78ab 100644
--- a/tests/unit_tests/test_util.py
+++ b/tests/unit_tests/test_util.py
@@ -2,11 +2,9 @@
 
 from __future__ import annotations
 
-import io
 from pathlib import Path
 import subprocess
 import sys
-from typing import Any
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -536,174 +534,3 @@ def test_detect_rp2040_bootsel_timeout() -> None:
         result = util.detect_rp2040_bootsel("/usr/bin/picotool")
     assert result.device_count == 0
     assert result.permission_error is False
-
-
-def _make_redirect(
-    line_callbacks: list | None = None, filter_lines: list[str] | None = None
-) -> tuple[util.RedirectText, io.StringIO]:
-    """Create a RedirectText that writes to a StringIO buffer."""
-    buf = io.StringIO()
-    redirect = util.RedirectText(
-        buf, filter_lines=filter_lines, line_callbacks=line_callbacks
-    )
-    return redirect, buf
-
-
-def test_redirect_text_callback_called_on_matching_line() -> None:
-    """Test that a line callback is called and its output is written."""
-    results: list[str] = []
-
-    def callback(line: str) -> str | None:
-        results.append(line)
-        if "target" in line:
-            return "CALLBACK OUTPUT\n"
-        return None
-
-    redirect, buf = _make_redirect(line_callbacks=[callback])
-    redirect.write("some target line\n")
-
-    assert "some target line" in buf.getvalue()
-    assert "CALLBACK OUTPUT" in buf.getvalue()
-    assert len(results) == 1
-
-
-def test_redirect_text_callback_not_triggered_on_non_matching_line() -> None:
-    """Test that callback returns None for non-matching lines."""
-
-    def callback(line: str) -> str | None:
-        if "target" in line:
-            return "FOUND\n"
-        return None
-
-    redirect, buf = _make_redirect(line_callbacks=[callback])
-    redirect.write("no match here\n")
-
-    assert "no match here" in buf.getvalue()
-    assert "FOUND" not in buf.getvalue()
-
-
-def test_redirect_text_callback_works_without_filter_pattern() -> None:
-    """Test that callbacks fire even when no filter_lines is set."""
-
-    def callback(line: str) -> str | None:
-        if "Crystal" in line:
-            return "WARNING: mismatch\n"
-        return None
-
-    redirect, buf = _make_redirect(line_callbacks=[callback])
-    redirect.write("Crystal frequency:  26MHz\n")
-
-    assert "Crystal frequency:  26MHz" in buf.getvalue()
-    assert "WARNING: mismatch" in buf.getvalue()
-
-
-def test_redirect_text_callback_works_with_filter_pattern() -> None:
-    """Test that callbacks fire alongside filter patterns."""
-
-    def callback(line: str) -> str | None:
-        if "important" in line:
-            return "NOTED\n"
-        return None
-
-    redirect, buf = _make_redirect(
-        line_callbacks=[callback],
-        filter_lines=[r"^skip this.*"],
-    )
-    redirect.write("skip this line\n")
-    redirect.write("important line\n")
-
-    assert "skip this" not in buf.getvalue()
-    assert "important line" in buf.getvalue()
-    assert "NOTED" in buf.getvalue()
-
-
-def test_redirect_text_multiple_callbacks() -> None:
-    """Test that multiple callbacks are all invoked."""
-
-    def callback_a(line: str) -> str | None:
-        if "test" in line:
-            return "FROM A\n"
-        return None
-
-    def callback_b(line: str) -> str | None:
-        if "test" in line:
-            return "FROM B\n"
-        return None
-
-    redirect, buf = _make_redirect(line_callbacks=[callback_a, callback_b])
-    redirect.write("test line\n")
-
-    output = buf.getvalue()
-    assert "FROM A" in output
-    assert "FROM B" in output
-
-
-def test_redirect_text_incomplete_line_buffered() -> None:
-    """Test that incomplete lines are buffered until newline."""
-    results: list[str] = []
-
-    def callback(line: str) -> str | None:
-        results.append(line)
-        return None
-
-    redirect, buf = _make_redirect(line_callbacks=[callback])
-    redirect.write("partial")
-    assert len(results) == 0
-
-    redirect.write(" line\n")
-    assert len(results) == 1
-    assert results[0] == "partial line"
-
-
-def test_run_external_command_line_callbacks(capsys: pytest.CaptureFixture) -> None:
-    """Test that run_external_command passes line_callbacks to RedirectText."""
-    results: list[str] = []
-
-    def callback(line: str) -> str | None:
-        results.append(line)
-        if "hello" in line:
-            return "CALLBACK FIRED\n"
-        return None
-
-    def fake_main() -> int:
-        print("hello world")
-        return 0
-
-    rc = util.run_external_command(fake_main, "fake", line_callbacks=[callback])
-
-    assert rc == 0
-    assert len(results) == 1
-    assert "hello world" in results[0]
-    captured = capsys.readouterr()
-    assert "CALLBACK FIRED" in captured.out
-
-
-def test_run_external_process_line_callbacks() -> None:
-    """Test that run_external_process passes line_callbacks to RedirectText."""
-    results: list[str] = []
-
-    def callback(line: str) -> str | None:
-        results.append(line)
-        if "from subprocess" in line:
-            return "PROCESS CALLBACK\n"
-        return None
-
-    with patch("esphome.util.subprocess.run") as mock_run:
-
-        def run_side_effect(*args: Any, **kwargs: Any) -> MagicMock:
-            # Simulate subprocess writing to the stdout RedirectText
-            stdout = kwargs.get("stdout")
-            if stdout is not None and isinstance(stdout, util.RedirectText):
-                stdout.write("from subprocess\n")
-            return MagicMock(returncode=0)
-
-        mock_run.side_effect = run_side_effect
-
-        rc = util.run_external_process(
-            "echo",
-            "test",
-            line_callbacks=[callback],
-        )
-
-    assert rc == 0
-    assert any("from subprocess" in r for r in results)