diff --git a/.claude/skills/pr-workflow/SKILL.md b/.agents/skills/pr-workflow/SKILL.md
similarity index 100%
rename from .claude/skills/pr-workflow/SKILL.md
rename to .agents/skills/pr-workflow/SKILL.md
diff --git a/.claude/skills b/.claude/skills
new file mode 120000
index 00000000000..2b7a412b8fa
--- /dev/null
+++ b/.claude/skills
@@ -0,0 +1 @@
+../.agents/skills
\ No newline at end of file
diff --git a/.github/actions/restore-python/action.yml b/.github/actions/restore-python/action.yml
index ce14b0152a8..fa42372ac81 100644
--- a/.github/actions/restore-python/action.yml
+++ b/.github/actions/restore-python/action.yml
@@ -32,7 +32,7 @@ runs:
       # detects the activated venv via ``VIRTUAL_ENV`` so the venv layout
       # downstream jobs rely on is preserved.
       if: steps.cache-venv.outputs.cache-hit != 'true'
-      uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+      uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
       with:
         enable-cache: true
         # Pull request saves land in per-PR scopes nothing else can
diff --git a/.github/skills b/.github/skills
new file mode 120000
index 00000000000..2b7a412b8fa
--- /dev/null
+++ b/.github/skills
@@ -0,0 +1 @@
+../.agents/skills
\ No newline at end of file
diff --git a/.github/workflows/ci-api-proto.yml b/.github/workflows/ci-api-proto.yml
index 63219a1dbcd..c4c1ab072ff 100644
--- a/.github/workflows/ci-api-proto.yml
+++ b/.github/workflows/ci-api-proto.yml
@@ -29,7 +29,7 @@ jobs:
       - name: Set up uv
         # ``--system`` (below) installs into the setup-python interpreter;
         # no venv is created or restored by this workflow.
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
           # Pull-request-only workflow: a save could never be shared and
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 173d2c227ad..689baa1292e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -49,7 +49,7 @@ jobs:
         # detects the activated venv via ``VIRTUAL_ENV`` so downstream jobs
         # that ``. venv/bin/activate`` see an identical layout.
         if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
           # Pull request saves land in per-PR scopes nothing else can
@@ -413,7 +413,7 @@ jobs:
       - name: Set up uv
         # Only needed on cache miss to populate the venv.
         if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
           # Pull request saves land in per-PR scopes nothing else can
@@ -1274,7 +1274,7 @@ jobs:
         # install step (order-of-magnitude faster on cold boots,
         # with its own wheel cache). actions/setup-python still
         # provides the interpreter.
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
           # Pull request saves land in per-PR scopes nothing else can
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index aab3dea592c..0daae69ccf0 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -56,7 +56,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
+        uses: github/codeql-action/init@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -84,6 +84,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
+        uses: github/codeql-action/analyze@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
         with:
           category: "/language:${{matrix.language}}"
diff --git a/.github/workflows/sync-device-classes.yml b/.github/workflows/sync-device-classes.yml
index 9100064176c..84d5e229d91 100644
--- a/.github/workflows/sync-device-classes.yml
+++ b/.github/workflows/sync-device-classes.yml
@@ -47,7 +47,7 @@ jobs:
         # setup-python interpreter so subsequent ``prek`` /
         # ``script/run-in-env.py`` steps find the deps without a
         # ``uv run`` prefix.
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
           # Pin uv version so the action does not have to fetch the
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 95e6f0f73e4..0c7600ec127 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -10,7 +10,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.16.6
+    rev: v0.16.7
     hooks:
       # Run the linter.
       - id: ruff
diff --git a/AGENTS.md b/AGENTS.md
index 8db3cd3d624..448bf49114f 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -431,7 +431,17 @@ file does, and it is the authority when they disagree. The most useful starting
           MyComponent *parent_;
         };
         ```
-        Register with `@automation.register_action("my_component.do_something", MyAction, schema, synchronous=True)`. Use `synchronous=True` for actions that run to completion inside `play()` without deferring. Use `synchronous=False` if the action may suspend/defer execution (e.g. `delay`, `wait_until`, `script.wait`) or store trigger arguments for later use.
+        Register it without writing a builder:
+        ```python
+        automation.register_simple_action(
+            "my_component.do_something", MyAction, schema, synchronous=True
+        )
+        ```
+        The constructor receives the object named by `config[CONF_ID]`. Use `register_bare_action` for a
+        no-argument constructor, `register_parented_action` for a class deriving from `Parented<T>`, and
+        the `@automation.register_action(...)` decorator only when the builder must also set fields.
+
+        Use `synchronous=True` for actions that run to completion inside `play()` without deferring. Use `synchronous=False` if the action may suspend/defer execution (e.g. `delay`, `wait_until`, `script.wait`) or store trigger arguments for later use.
 
     *   **Conditions:**
         ```cpp
@@ -443,7 +453,8 @@ file does, and it is the authority when they disagree. The most useful starting
           MyComponent *parent_;
         };
         ```
-        Register with `@automation.register_condition("my_component.is_active", MyCondition, schema)`.
+        Register with `automation.register_simple_condition("my_component.is_active", MyCondition, schema)`;
+        `register_bare_condition`, `register_parented_condition` and the decorator follow the action rules.
 
 *   **Type Hints:** Type-hint all function signatures, including test functions and config validators (e.g. `def validate_x(config: ConfigType) -> ConfigType:`, `def test_x() -> None:`). Import `ConfigType` from `esphome.types`.
 
diff --git a/CODEOWNERS b/CODEOWNERS
index 06d4d660349..685d2aa4e4b 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -182,7 +182,6 @@ esphome/components/esp32_camera_web_server/* @ayufan
 esphome/components/esp32_can/* @Sympatron
 esphome/components/esp32_hosted/* @swoboda1337
 esphome/components/esp32_hosted/update/* @swoboda1337
-esphome/components/esp32_improv/* @jesserockz
 esphome/components/esp32_rmt/* @jesserockz
 esphome/components/esp32_rmt_led_strip/* @jesserockz
 esphome/components/esp8266/* @esphome/core
@@ -266,8 +265,10 @@ esphome/components/i2s_audio/* @jesserockz
 esphome/components/i2s_audio/microphone/* @jesserockz
 esphome/components/i2s_audio/speaker/* @jesserockz @kahrendt
 esphome/components/iaqcore/* @yozik04
+esphome/components/icnt86/* @danepowell
 esphome/components/ili9xxx/* @clydebarrow @nielsnl68
 esphome/components/improv_base/* @esphome/core
+esphome/components/improv_ble/* @jesserockz
 esphome/components/improv_serial/* @esphome/core
 esphome/components/ina226/* @latonita @Sergio303
 esphome/components/ina260/* @mreditor97
@@ -477,6 +478,7 @@ esphome/components/sendspin/image/* @kahrendt
 esphome/components/sendspin/media_player/* @kahrendt
 esphome/components/sendspin/media_source/* @kahrendt
 esphome/components/sendspin/sensor/* @kahrendt
+esphome/components/sendspin/switch/* @kahrendt
 esphome/components/sendspin/text_sensor/* @kahrendt
 esphome/components/sensirion_common/* @martgras
 esphome/components/sensor/* @esphome/core
@@ -590,6 +592,7 @@ esphome/components/uart/* @esphome/core
 esphome/components/uart/button/* @ssieb
 esphome/components/uart/event/* @eoasmxd
 esphome/components/uart/packet_transport/* @clydebarrow
+esphome/components/uart_mux/* @kbx81
 esphome/components/udp/* @clydebarrow
 esphome/components/ufire_ec/* @pvizeli
 esphome/components/ufire_ise/* @pvizeli
diff --git a/esphome/automation.py b/esphome/automation.py
index 1689d29c42f..3ffda50c812 100644
--- a/esphome/automation.py
+++ b/esphome/automation.py
@@ -102,6 +102,101 @@ def register_condition(name: str, condition_type: MockObjClass, schema: cv.Schem
     return CONDITION_REGISTRY.register(name, condition_type, schema)
 
 
+async def _build_with_parent(
+    config: ConfigType,
+    automation_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    parent = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(automation_id, template_arg, parent)
+
+
+async def _build_without_parent(
+    config: ConfigType,
+    automation_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    return cg.new_Pvariable(automation_id, template_arg)
+
+
+async def _build_parented(
+    config: ConfigType,
+    automation_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    var = cg.new_Pvariable(automation_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    return var
+
+
+def register_simple_action(
+    name: str,
+    action_type: MockObjClass,
+    schema: cv.Schema,
+    *,
+    synchronous: bool,
+) -> None:
+    """Register an action whose constructor takes the object named by ``config[CONF_ID]``.
+
+    Use the ``register_action`` decorator instead when the builder must also set fields.
+    """
+    register_action(name, action_type, schema, synchronous=synchronous)(
+        _build_with_parent
+    )
+
+
+def register_simple_condition(
+    name: str, condition_type: MockObjClass, schema: cv.Schema
+) -> None:
+    """Condition counterpart of ``register_simple_action``."""
+    register_condition(name, condition_type, schema)(_build_with_parent)
+
+
+def register_bare_action(
+    name: str,
+    action_type: MockObjClass,
+    schema: cv.Schema,
+    *,
+    synchronous: bool,
+) -> None:
+    """Register an action whose constructor takes no arguments."""
+    register_action(name, action_type, schema, synchronous=synchronous)(
+        _build_without_parent
+    )
+
+
+def register_bare_condition(
+    name: str, condition_type: MockObjClass, schema: cv.Schema
+) -> None:
+    """Condition counterpart of ``register_bare_action``."""
+    register_condition(name, condition_type, schema)(_build_without_parent)
+
+
+def register_parented_action(
+    name: str,
+    action_type: MockObjClass,
+    schema: cv.Schema,
+    *,
+    synchronous: bool,
+) -> None:
+    """Register an action deriving from ``Parented<T>``.
+
+    The object is constructed without arguments and ``set_parent()`` receives the object
+    named by ``config[CONF_ID]``.
+    """
+    register_action(name, action_type, schema, synchronous=synchronous)(_build_parented)
+
+
+def register_parented_condition(
+    name: str, condition_type: MockObjClass, schema: cv.Schema
+) -> None:
+    """Condition counterpart of ``register_parented_action``."""
+    register_condition(name, condition_type, schema)(_build_parented)
+
+
 Action = cg.esphome_ns.class_("Action")
 Trigger = cg.esphome_ns.class_("Trigger")
 ACTION_REGISTRY = Registry()
@@ -534,44 +629,20 @@ async def lambda_action_to_code(
     return new_lambda_pvariable(action_id, lambda_, StatelessLambdaAction, template_arg)
 
 
-@register_action(
+register_simple_action(
     "component.update",
     UpdateComponentAction,
-    maybe_simple_id(
-        {
-            cv.Required(CONF_ID): cv.use_id(cg.PollingComponent),
-        }
-    ),
+    maybe_simple_id({cv.Required(CONF_ID): cv.use_id(cg.PollingComponent)}),
     synchronous=True,
 )
-async def component_update_action_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    comp = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, comp)
 
 
-@register_action(
+register_simple_action(
     "component.suspend",
     SuspendComponentAction,
-    maybe_simple_id(
-        {
-            cv.Required(CONF_ID): cv.use_id(cg.PollingComponent),
-        }
-    ),
+    maybe_simple_id({cv.Required(CONF_ID): cv.use_id(cg.PollingComponent)}),
     synchronous=True,
 )
-async def component_suspend_action_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    comp = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, comp)
 
 
 @register_action(
diff --git a/esphome/build_gen/espidf.py b/esphome/build_gen/espidf.py
index 2ef89cf595b..7689fc93b0e 100644
--- a/esphome/build_gen/espidf.py
+++ b/esphome/build_gen/espidf.py
@@ -90,9 +90,10 @@ def get_project_cmakelists(
     """
     idf_target = variant_to_idf_target(get_esp32_variant())
 
-    # esp_idf_size 2.x (bundled with IDF >=6.0) made NG the default and
-    # removed the --ng flag; on 1.x (IDF 5.5) --ng is required to get
-    # --format=raw because the legacy mode doesn't support it.
+    # esp_idf_size 2.x (IDF >=6.0) made NG the default and removed --ng;
+    # 1.x (IDF 5.5) needs --ng for --format=json2. 1.x json2 also lacks
+    # total_size, hence the ELF fallback in espidf/size_summary.py; both
+    # go away together when 1.x support is dropped.
     size_ng_flag = "--ng" if idf_version() < cv.Version(6, 0, 0) else ""
 
     # Project-wide compile options: -D defines and -W warning flags (skip
@@ -211,10 +212,12 @@ include($ENV{{IDF_PATH}}/tools/cmake/project.cmake)
 
 project({CORE.name})
 
-# Emit raw JSON size data for ESPHome to read post-build.
+# Emit per-memory-type JSON size data for ESPHome to read post-build.
+# json2 stays small; raw dumps every symbol (~2s on a large map) and
+# this command runs inside the link edge, blocking everything downstream.
 add_custom_command(
     TARGET ${{CMAKE_PROJECT_NAME}}.elf POST_BUILD
-    COMMAND ${{PYTHON}} -m esp_idf_size {size_ng_flag} --format=raw
+    COMMAND ${{PYTHON}} -m esp_idf_size {size_ng_flag} --format=json2
             -o ${{CMAKE_BINARY_DIR}}/esp_idf_size.json
             ${{CMAKE_PROJECT_NAME}}.map
     WORKING_DIRECTORY ${{CMAKE_BINARY_DIR}}
diff --git a/esphome/component_aliases.py b/esphome/component_aliases.py
index e701bd98d4e..53a34d1e15f 100644
--- a/esphome/component_aliases.py
+++ b/esphome/component_aliases.py
@@ -6,5 +6,6 @@ See the component-alias section of esphome/loader.py.
 
 # alias -> (canonical component, removal version or None)
 COMPONENT_ALIASES: dict[str, tuple[str, str | None]] = {
+    "esp32_improv": ("improv_ble", "2027.4.0"),
     "rp2040": ("rp2", "2027.7.0"),
 }
diff --git a/esphome/components/adc/adc_sensor.h b/esphome/components/adc/adc_sensor.h
index 71318987479..46b7e7a2ffd 100644
--- a/esphome/components/adc/adc_sensor.h
+++ b/esphome/components/adc/adc_sensor.h
@@ -94,7 +94,7 @@ class ADCSensor final : public sensor::Sensor, public PollingComponent, public v
   ///   - SamplingMode::MIN: Use the lowest sample value
   ///   - SamplingMode::MAX: Use the highest sample value
   /// @param sampling_mode The desired sampling mode to use for aggregating ADC samples.
-  void set_sampling_mode(SamplingMode sampling_mode);
+  void set_sampling_mode(SamplingMode sampling_mode) { this->sampling_mode_ = sampling_mode; }
 
   /// Perform a single ADC sampling operation and return the measured value.
   /// This function handles raw readings, calibration, and averaging as needed.
diff --git a/esphome/components/adc/adc_sensor_common.cpp b/esphome/components/adc/adc_sensor_common.cpp
index 5ca58df10e0..70211000c3d 100644
--- a/esphome/components/adc/adc_sensor_common.cpp
+++ b/esphome/components/adc/adc_sensor_common.cpp
@@ -76,6 +76,4 @@ void ADCSensor::set_sample_count(uint8_t sample_count) {
   }
 }
 
-void ADCSensor::set_sampling_mode(SamplingMode sampling_mode) { this->sampling_mode_ = sampling_mode; }
-
 }  // namespace esphome::adc
diff --git a/esphome/components/alarm_control_panel/alarm_control_panel.h b/esphome/components/alarm_control_panel/alarm_control_panel.h
index e748b8621b9..aced89b7ffc 100644
--- a/esphome/components/alarm_control_panel/alarm_control_panel.h
+++ b/esphome/components/alarm_control_panel/alarm_control_panel.h
@@ -138,11 +138,11 @@ class AlarmControlPanel : public EntityBase {
   // in order to store last panel state in flash
   ESPPreferenceObject pref_;
   // current state
-  AlarmControlPanelState current_state_;
+  AlarmControlPanelState current_state_{ACP_STATE_DISARMED};
   // the desired (or previous) state
-  AlarmControlPanelState desired_state_;
+  AlarmControlPanelState desired_state_{ACP_STATE_DISARMED};
   // last time the state was updated
-  uint32_t last_update_;
+  uint32_t last_update_{0};
   // the call control function
   virtual void control(const AlarmControlPanelCall &call) = 0;
   // state callback - passes the new state to listeners
diff --git a/esphome/components/api/__init__.py b/esphome/components/api/__init__.py
index 272b0786905..854bceecfad 100644
--- a/esphome/components/api/__init__.py
+++ b/esphome/components/api/__init__.py
@@ -136,6 +136,12 @@ CONF_LISTEN_BACKLOG = "listen_backlog"
 CONF_MAX_SEND_QUEUE = "max_send_queue"
 CONF_STATE_SUBSCRIPTION_ONLY = "state_subscription_only"
 
+# Schema defaults that also match the C++ initializers in api_server.h; codegen
+# skips the setter when the config equals them.
+DEFAULT_PORT = 6053
+DEFAULT_REBOOT_TIMEOUT = "15min"
+DEFAULT_BATCH_DELAY = "100ms"
+
 
 def _register_provisioning_source(config: ConfigType) -> ConfigType:
     """Register the API as a provisioning source when encryption is enabled.
@@ -292,7 +298,7 @@ CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(APIServer),
-            cv.Optional(CONF_PORT, default=6053): cv.port,
+            cv.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
             # Removed in 2026.1.0 - kept to provide helpful error message
             cv.Optional(CONF_PASSWORD): cv.invalid(
                 "The 'password' option has been removed in ESPHome 2026.1.0.\n"
@@ -305,14 +311,14 @@ CONFIG_SCHEMA = cv.All(
                 "Or visit https://esphome.io/components/api/#configuration-variables"
             ),
             cv.Optional(
-                CONF_REBOOT_TIMEOUT, default="15min"
+                CONF_REBOOT_TIMEOUT, default=DEFAULT_REBOOT_TIMEOUT
             ): cv.positive_time_period_milliseconds,
             cv.Exclusive(
                 CONF_SERVICES, group_of_exclusion=CONF_ACTIONS
             ): ACTIONS_SCHEMA,
             cv.Exclusive(CONF_ACTIONS, group_of_exclusion=CONF_ACTIONS): ACTIONS_SCHEMA,
             cv.Optional(CONF_ENCRYPTION): encryption_schema,
-            cv.Optional(CONF_BATCH_DELAY, default="100ms"): cv.All(
+            cv.Optional(CONF_BATCH_DELAY, default=DEFAULT_BATCH_DELAY): cv.All(
                 cv.positive_time_period_milliseconds,
                 cv.Range(max=cv.TimePeriod(milliseconds=65535)),
             ),
@@ -462,9 +468,15 @@ async def to_code(config: ConfigType) -> None:
     # Request a log listener slot for API log streaming
     request_log_listener()
 
-    cg.add(var.set_port(config[CONF_PORT]))
-    cg.add(var.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
-    cg.add(var.set_batch_delay(config[CONF_BATCH_DELAY]))
+    # Skip the setters when the config matches the C++ initializers (DEFAULT_*).
+    if (port := config[CONF_PORT]) != DEFAULT_PORT:
+        cg.add(var.set_port(port))
+    if (reboot_timeout := config[CONF_REBOOT_TIMEOUT]) != cv.time_period(
+        DEFAULT_REBOOT_TIMEOUT
+    ):
+        cg.add(var.set_reboot_timeout(reboot_timeout))
+    if (batch_delay := config[CONF_BATCH_DELAY]) != cv.time_period(DEFAULT_BATCH_DELAY):
+        cg.add(var.set_batch_delay(batch_delay))
     if CONF_LISTEN_BACKLOG in config:
         cg.add(var.set_listen_backlog(config[CONF_LISTEN_BACKLOG]))
     cg.add_define("MAX_API_CONNECTIONS", config[CONF_MAX_CONNECTIONS])
diff --git a/esphome/components/api/api_connection.cpp b/esphome/components/api/api_connection.cpp
index 20b1302259d..767592a9a72 100644
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -730,12 +730,7 @@ uint16_t APIConnection::try_send_switch_info(EntityBase *entity, APIConnection *
 }
 void APIConnection::on_switch_command_request(const SwitchCommandRequest &msg) {
   ENTITY_COMMAND_GET(switch_::Switch, a_switch, switch)
-
-  if (msg.state) {
-    a_switch->turn_on();
-  } else {
-    a_switch->turn_off();
-  }
+  a_switch->control(msg.state);
 }
 #endif
 
diff --git a/esphome/components/api/api_server.h b/esphome/components/api/api_server.h
index 618ea4eb11a..e5a22dcef82 100644
--- a/esphome/components/api/api_server.h
+++ b/esphome/components/api/api_server.h
@@ -314,7 +314,7 @@ class APIServer final : public Component,
 #endif
 
   // 4-byte aligned types
-  uint32_t reboot_timeout_{300000};
+  uint32_t reboot_timeout_{900000};  // Keep in sync with DEFAULT_REBOOT_TIMEOUT in __init__.py
   uint32_t last_connected_{0};
 
   // Slots [0, api_connection_count_) are populated; trailing slots are always nullptr.
@@ -351,8 +351,8 @@ class APIServer final : public Component,
 #endif
 
   // Group smaller types together
-  uint16_t port_{6053};
-  uint16_t batch_delay_{100};
+  uint16_t port_{6053};        // Keep in sync with DEFAULT_PORT in __init__.py
+  uint16_t batch_delay_{100};  // Keep in sync with DEFAULT_BATCH_DELAY in __init__.py
   // Connection limits - these defaults will be overridden by config values
   // from cv.SplitDefault in __init__.py which sets platform-specific defaults.
   uint8_t listen_backlog_{4};
diff --git a/esphome/components/audio/__init__.py b/esphome/components/audio/__init__.py
index 14a08188949..b882aaa6b75 100644
--- a/esphome/components/audio/__init__.py
+++ b/esphome/components/audio/__init__.py
@@ -339,7 +339,7 @@ async def to_code(config: ConfigType) -> None:
     # HTTPS streams verify the server against the root certificate bundle
     require_certificate_bundle()
 
-    add_idf_component(name="esphome/esp-audio-libs", ref="4.0.0")
+    add_idf_component(name="esphome/esp-audio-libs", ref="4.0.1")
 
     data = _get_data()
 
diff --git a/esphome/components/bang_bang/bang_bang_climate.cpp b/esphome/components/bang_bang/bang_bang_climate.cpp
index 5dfb1213429..a1104aa1b2a 100644
--- a/esphome/components/bang_bang/bang_bang_climate.cpp
+++ b/esphome/components/bang_bang/bang_bang_climate.cpp
@@ -203,16 +203,10 @@ void BangBangClimate::set_away_config(const BangBangClimateTargetTempConfig &awa
   this->away_config_ = away_config;
 }
 
-void BangBangClimate::set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
-void BangBangClimate::set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
-
 Trigger<> *BangBangClimate::get_idle_trigger() { return &this->idle_trigger_; }
 Trigger<> *BangBangClimate::get_cool_trigger() { return &this->cool_trigger_; }
 Trigger<> *BangBangClimate::get_heat_trigger() { return &this->heat_trigger_; }
 
-void BangBangClimate::set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }
-void BangBangClimate::set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }
-
 void BangBangClimate::dump_config() {
   LOG_CLIMATE("", "Bang Bang Climate", this);
   ESP_LOGCONFIG(TAG,
diff --git a/esphome/components/bang_bang/bang_bang_climate.h b/esphome/components/bang_bang/bang_bang_climate.h
index d83257f9f34..fff9bf873ff 100644
--- a/esphome/components/bang_bang/bang_bang_climate.h
+++ b/esphome/components/bang_bang/bang_bang_climate.h
@@ -22,10 +22,10 @@ class BangBangClimate final : public climate::Climate, public Component {
   void setup() override;
   void dump_config() override;
 
-  void set_sensor(sensor::Sensor *sensor);
-  void set_humidity_sensor(sensor::Sensor *humidity_sensor);
-  void set_supports_cool(bool supports_cool);
-  void set_supports_heat(bool supports_heat);
+  void set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
+  void set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
+  void set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }
+  void set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }
   void set_normal_config(const BangBangClimateTargetTempConfig &normal_config);
   void set_away_config(const BangBangClimateTargetTempConfig &away_config);
 
diff --git a/esphome/components/binary/light/binary_light_output.h b/esphome/components/binary/light/binary_light_output.h
index 32707e8b0c8..b8de7932cd6 100644
--- a/esphome/components/binary/light/binary_light_output.h
+++ b/esphome/components/binary/light/binary_light_output.h
@@ -17,11 +17,7 @@ class BinaryLightOutput final : public light::LightOutput {
   void write_state(light::LightState *state) override {
     bool binary;
     state->current_values_as_binary(&binary);
-    if (binary) {
-      this->output_->turn_on();
-    } else {
-      this->output_->turn_off();
-    }
+    this->output_->set_state(binary);
   }
 
  protected:
diff --git a/esphome/components/binary_sensor/__init__.py b/esphome/components/binary_sensor/__init__.py
index 9ef7efc96a3..a114ab42051 100644
--- a/esphome/components/binary_sensor/__init__.py
+++ b/esphome/components/binary_sensor/__init__.py
@@ -39,6 +39,7 @@ from esphome.const import (
     DEVICE_CLASS_EMPTY,
     DEVICE_CLASS_GARAGE_DOOR,
     DEVICE_CLASS_GAS,
+    DEVICE_CLASS_GLASS_BREAK,
     DEVICE_CLASS_HEAT,
     DEVICE_CLASS_LIGHT,
     DEVICE_CLASS_LOCK,
@@ -81,6 +82,7 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_EMPTY,
     DEVICE_CLASS_GARAGE_DOOR,
     DEVICE_CLASS_GAS,
+    DEVICE_CLASS_GLASS_BREAK,
     DEVICE_CLASS_HEAT,
     DEVICE_CLASS_LIGHT,
     DEVICE_CLASS_LOCK,
diff --git a/esphome/components/binary_sensor/binary_sensor.h b/esphome/components/binary_sensor/binary_sensor.h
index 28c156763a8..a96113b520e 100644
--- a/esphome/components/binary_sensor/binary_sensor.h
+++ b/esphome/components/binary_sensor/binary_sensor.h
@@ -32,7 +32,8 @@ void log_binary_sensor(const char *tag, const char *prefix, const char *type, Bi
  */
 class BinarySensor : public StatefulEntityBase<bool> {
  public:
-  explicit BinarySensor() = default;
+  // User provided, not "= default": `new(p) BinarySensor()` would zero-fill .bss that is already zero.
+  explicit BinarySensor() {}
 
   const bool &get_state() const override { return this->state; }
   void set_trigger_on_initial_state(bool value) { this->trigger_on_initial_state_ = value; }
diff --git a/esphome/components/binary_sensor/filter.h b/esphome/components/binary_sensor/filter.h
index 6887de35e1d..1ec255d63d6 100644
--- a/esphome/components/binary_sensor/filter.h
+++ b/esphome/components/binary_sensor/filter.h
@@ -53,6 +53,9 @@ class DelayedOnOffFilter final : public Filter {
 
 class DelayedOnFilter : public Filter {
  public:
+  // User provided, not "= default": `new(p) DelayedOnFilter()` would zero-fill .bss that is already zero.
+  DelayedOnFilter() {}
+
   optional<bool> new_value(bool value) override;
 
   template<typename T> void set_delay(T delay) { this->delay_ = delay; }
@@ -63,6 +66,9 @@ class DelayedOnFilter : public Filter {
 
 class DelayedOffFilter : public Filter {
  public:
+  // User provided, not "= default": `new(p) DelayedOffFilter()` would zero-fill .bss that is already zero.
+  DelayedOffFilter() {}
+
   optional<bool> new_value(bool value) override;
 
   template<typename T> void set_delay(T delay) { this->delay_ = delay; }
@@ -143,6 +149,8 @@ class StatelessLambdaFilter : public Filter {
 
 class SettleFilter : public Filter {
  public:
+  // User provided, not "= default": `new(p) SettleFilter()` would zero-fill .bss that is already zero.
+  SettleFilter() {}
   optional<bool> new_value(bool value) override;
 
   template<typename T> void set_delay(T delay) { this->delay_ = delay; }
diff --git a/esphome/components/bk72xx_ble/__init__.py b/esphome/components/bk72xx_ble/__init__.py
index 74b9cb59548..38cba56c623 100644
--- a/esphome/components/bk72xx_ble/__init__.py
+++ b/esphome/components/bk72xx_ble/__init__.py
@@ -23,7 +23,7 @@ public ble_api.h.
 import logging
 
 import esphome.codegen as cg
-from esphome.components import libretiny
+from esphome.components import libretiny, wifi
 from esphome.components.libretiny.const import (
     FAMILY_BK7231N,
     FAMILY_BK7231Q,
@@ -84,6 +84,15 @@ def _final_validate(config: ConfigType) -> None:
     # which run on a BLE 4.2 board. The hard error is raised at codegen.
     if msg := _unsupported_family_message(libretiny.get_libretiny_family()):
         _LOGGER.warning("%s (this configuration cannot compile)", msg)
+    # Any wifi power_save_mode other than NONE also arms the Beken SDK's MCU
+    # sleep. With the BLE controller running, that sleep never wakes up once the
+    # station is stopped (adapter restart after failed roams, wifi.disable): the
+    # device is dead until a power cycle (esphome#18592). Keep power save off
+    # until LibreTiny ships the SDK-side fix (libretiny-eu/libretiny#414).
+    wifi.force_power_save_off(
+        "with BLE running, the Beken SDK's MCU sleep halts the device once the "
+        "station is stopped (https://github.com/esphome/esphome/issues/18592)"
+    )
 
 
 FINAL_VALIDATE_SCHEMA = _final_validate
diff --git a/esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.h b/esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.h
index f285260e763..a4e9edec233 100644
--- a/esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.h
+++ b/esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.h
@@ -31,6 +31,9 @@ class BluetoothConnection;
 // void disconnect() cannot overload with an int-returning twin.
 class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public Component {
  public:
+  // User provided, not "= default": `new(p) BluedroidGattClient()` would zero-fill .bss that is already zero.
+  BluedroidGattClient() {}
+
   static constexpr uint16_t UNSET_CONN_ID = 0xFFFF;
 
   // Lifecycle of one connection attempt's service search.
diff --git a/esphome/components/bluetooth_connection/bluetooth_connection_hub.h b/esphome/components/bluetooth_connection/bluetooth_connection_hub.h
index 47181e81a73..4c87b876c3a 100644
--- a/esphome/components/bluetooth_connection/bluetooth_connection_hub.h
+++ b/esphome/components/bluetooth_connection/bluetooth_connection_hub.h
@@ -37,6 +37,9 @@ enum class PendingAck : uint8_t {
 
 class BluetoothConnection final : public ble_device_base::GattClientListener {
  public:
+  // User provided, not "= default": `new(p) BluetoothConnection()` would zero-fill .bss that is already zero.
+  BluetoothConnection() {}
+
   /// Wire the platform backend. Called from codegen before setup.
   void set_backend(ble_device_base::BLEGattConnection *backend) {
     this->backend_ = backend;
diff --git a/esphome/components/bluetooth_connection/bluetooth_connection_rp2.cpp b/esphome/components/bluetooth_connection/bluetooth_connection_rp2.cpp
index 16a89dcfdd1..eec2c8c3186 100644
--- a/esphome/components/bluetooth_connection/bluetooth_connection_rp2.cpp
+++ b/esphome/components/bluetooth_connection/bluetooth_connection_rp2.cpp
@@ -626,7 +626,7 @@ void RP2GattClient::handle_connected_(uint8_t status, uint16_t con_handle) {
   // explicit kick the MTU would only be exchanged on the first GATT query,
   // which never happens on a V3_WITH_CACHE connection.
   // Both registration calls above return void (BTstack 075a078, arduino-pico
-  // 6.0.0); failures surface as a missing GATT_EVENT_MTU and are reclaimed by
+  // 6.1.0); failures surface as a missing GATT_EVENT_MTU and are reclaimed by
   // the connect timeout in loop().
   gatt_client_send_mtu_negotiation(&RP2GattClient::gatt_packet_handler, this->con_handle_);
 }
diff --git a/esphome/components/bme280_base/bme280_base.cpp b/esphome/components/bme280_base/bme280_base.cpp
index 0f7e42cce3e..11c796352a3 100644
--- a/esphome/components/bme280_base/bme280_base.cpp
+++ b/esphome/components/bme280_base/bme280_base.cpp
@@ -341,7 +341,6 @@ void BME280Component::set_pressure_oversampling(BME280Oversampling pressure_over
 void BME280Component::set_humidity_oversampling(BME280Oversampling humidity_over_sampling) {
   this->humidity_oversampling_ = humidity_over_sampling;
 }
-void BME280Component::set_iir_filter(BME280IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
 uint8_t BME280Component::read_u8_(uint8_t a_register) {
   uint8_t data = 0;
   this->read_byte(a_register, &data);
diff --git a/esphome/components/bme280_base/bme280_base.h b/esphome/components/bme280_base/bme280_base.h
index 7fe5f7401da..8b4906b7b77 100644
--- a/esphome/components/bme280_base/bme280_base.h
+++ b/esphome/components/bme280_base/bme280_base.h
@@ -69,7 +69,7 @@ class BME280Component : public PollingComponent {
   /// Set the oversampling value for the humidity sensor. Default is 16x.
   void set_humidity_oversampling(BME280Oversampling humidity_over_sampling);
   /// Set the IIR Filter used to increase accuracy, defaults to no IIR Filter.
-  void set_iir_filter(BME280IIRFilter iir_filter);
+  void set_iir_filter(BME280IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
 
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)
diff --git a/esphome/components/bme680/bme680.cpp b/esphome/components/bme680/bme680.cpp
index 164424de096..bac8ed8a5a8 100644
--- a/esphome/components/bme680/bme680.cpp
+++ b/esphome/components/bme680/bme680.cpp
@@ -503,7 +503,6 @@ void BME680Component::set_pressure_oversampling(BME680Oversampling pressure_over
 void BME680Component::set_humidity_oversampling(BME680Oversampling humidity_oversampling) {
   this->humidity_oversampling_ = humidity_oversampling;
 }
-void BME680Component::set_iir_filter(BME680IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
 void BME680Component::set_heater(uint16_t heater_temperature, uint16_t heater_duration) {
   this->heater_temperature_ = heater_temperature;
   this->heater_duration_ = heater_duration;
diff --git a/esphome/components/bme680/bme680.h b/esphome/components/bme680/bme680.h
index a274578fc18..e401d036595 100644
--- a/esphome/components/bme680/bme680.h
+++ b/esphome/components/bme680/bme680.h
@@ -74,7 +74,7 @@ class BME680Component final : public PollingComponent, public i2c::I2CDevice {
   /// Set the humidity oversampling value. Defaults to 16X.
   void set_humidity_oversampling(BME680Oversampling humidity_oversampling);
   /// Set the IIR Filter value. Defaults to no IIR Filter.
-  void set_iir_filter(BME680IIRFilter iir_filter);
+  void set_iir_filter(BME680IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
   void set_pressure_sensor(sensor::Sensor *pressure_sensor) { pressure_sensor_ = pressure_sensor; }
diff --git a/esphome/components/bmp280_base/bmp280_base.cpp b/esphome/components/bmp280_base/bmp280_base.cpp
index 1dae5a689e6..34e1d671019 100644
--- a/esphome/components/bmp280_base/bmp280_base.cpp
+++ b/esphome/components/bmp280_base/bmp280_base.cpp
@@ -254,7 +254,6 @@ void BMP280Component::set_temperature_oversampling(BMP280Oversampling temperatur
 void BMP280Component::set_pressure_oversampling(BMP280Oversampling pressure_over_sampling) {
   this->pressure_oversampling_ = pressure_over_sampling;
 }
-void BMP280Component::set_iir_filter(BMP280IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
 uint8_t BMP280Component::read_u8_(uint8_t a_register) {
   uint8_t data = 0;
   this->bmp_read_byte(a_register, &data);
diff --git a/esphome/components/bmp280_base/bmp280_base.h b/esphome/components/bmp280_base/bmp280_base.h
index 3bf1edab043..860fff6b4b1 100644
--- a/esphome/components/bmp280_base/bmp280_base.h
+++ b/esphome/components/bmp280_base/bmp280_base.h
@@ -59,7 +59,7 @@ class BMP280Component : public PollingComponent {
   /// Set the oversampling value for the pressure sensor. Default is 16x.
   void set_pressure_oversampling(BMP280Oversampling pressure_over_sampling);
   /// Set the IIR Filter used to increase accuracy, defaults to no IIR Filter.
-  void set_iir_filter(BMP280IIRFilter iir_filter);
+  void set_iir_filter(BMP280IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
 
   void setup() override;
   void dump_config() override;
diff --git a/esphome/components/cdc_acm_uart/bridge/cdc_acm_uart_bridge.h b/esphome/components/cdc_acm_uart/bridge/cdc_acm_uart_bridge.h
index 64522c86bd5..405b794653d 100644
--- a/esphome/components/cdc_acm_uart/bridge/cdc_acm_uart_bridge.h
+++ b/esphome/components/cdc_acm_uart/bridge/cdc_acm_uart_bridge.h
@@ -30,6 +30,7 @@ class CDCACMUARTBridge final : public Component {
 
   void set_line_coding();
   void set_line_state(bool dtr, bool rts);
+  uart::IDFUARTComponent *get_uart_parent() const { return this->uart_parent_; }
 
   /**
    * Stop forwarding in both directions and hand the UART back to its configured
diff --git a/esphome/components/copy/switch/copy_switch.cpp b/esphome/components/copy/switch/copy_switch.cpp
index 91b76f11c0a..555f0030a5b 100644
--- a/esphome/components/copy/switch/copy_switch.cpp
+++ b/esphome/components/copy/switch/copy_switch.cpp
@@ -13,12 +13,6 @@ void CopySwitch::setup() {
 
 void CopySwitch::dump_config() { LOG_SWITCH("", "Copy Switch", this); }
 
-void CopySwitch::write_state(bool state) {
-  if (state) {
-    source_->turn_on();
-  } else {
-    source_->turn_off();
-  }
-}
+void CopySwitch::write_state(bool state) { this->source_->control(state); }
 
 }  // namespace esphome::copy
diff --git a/esphome/components/display/display.cpp b/esphome/components/display/display.cpp
index c2d45dbb600..66fadf12ece 100644
--- a/esphome/components/display/display.cpp
+++ b/esphome/components/display/display.cpp
@@ -3,6 +3,7 @@
 #include <utility>
 #include <numbers>
 #include "display_color_utils.h"
+#include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 
@@ -770,10 +771,12 @@ Rect Display::get_clipping() const {
 
 void Display::clear_clipping_() { this->clipping_rectangle_.clear(); }
 
+void Display::feed_wdt_pixel_slow_() { App.feed_wdt(); }
+
 bool Display::clip(int x, int y) {
   if (x < 0 || x >= this->get_width() || y < 0 || y >= this->get_height())
     return false;
-  if (!this->get_clipping().inside(x, y))
+  if (this->is_point_clipped(x, y))
     return false;
   return true;
 }
diff --git a/esphome/components/display/display.h b/esphome/components/display/display.h
index a9ffda422d1..c1389721496 100644
--- a/esphome/components/display/display.h
+++ b/esphome/components/display/display.h
@@ -758,6 +758,13 @@ class Display : public PollingComponent {
 
   bool is_clipping() const { return !this->clipping_rectangle_.empty(); }
 
+  /// Whether (x, y) falls outside the active clipping rectangle. Tests the
+  /// stack top in place: get_clipping() is out of line and returns the Rect
+  /// by value, which per pixel drawing cannot afford.
+  bool ESPHOME_ALWAYS_INLINE is_point_clipped(int x, int y) const {
+    return this->is_clipping() && !this->clipping_rectangle_.back().inside(x, y);
+  }
+
   /** Check if pixel is within region of display.
    */
   bool clip(int x, int y);
@@ -774,6 +781,17 @@ class Display : public PollingComponent {
   void do_update_();
   void clear_clipping_();
 
+  /// Watchdog feed for per pixel loops. App.feed_wdt() is already rate
+  /// limited, but every call reads the clock; only every 256th pixel makes
+  /// that call, so the real feeds are unchanged and a pixel costs a counter.
+  /// At 20 us per pixel on the slowest e-paper path that is about 5 ms
+  /// between clock reads.
+  void ESPHOME_ALWAYS_INLINE feed_wdt_per_pixel_() {
+    if (++this->wdt_pixel_counter_ == 0)
+      this->feed_wdt_pixel_slow_();
+  }
+  void feed_wdt_pixel_slow_();
+
   virtual int get_height_internal() = 0;
   virtual int get_width_internal() = 0;
 
@@ -793,6 +811,7 @@ class Display : public PollingComponent {
   std::vector<DisplayOnPageChangeTrigger *> on_page_change_triggers_;
   bool auto_clear_enabled_{true};
   std::vector<Rect> clipping_rectangle_;
+  uint8_t wdt_pixel_counter_{0};
   bool show_test_card_{false};
 };
 
diff --git a/esphome/components/display/display_buffer.cpp b/esphome/components/display/display_buffer.cpp
index 4c919140494..d564ea67bd5 100644
--- a/esphome/components/display/display_buffer.cpp
+++ b/esphome/components/display/display_buffer.cpp
@@ -2,7 +2,6 @@
 
 #include <utility>
 
-#include "esphome/core/application.h"
 #include "esphome/core/log.h"
 
 namespace esphome::display {
@@ -44,7 +43,7 @@ int DisplayBuffer::get_height() {
 }
 
 void HOT DisplayBuffer::draw_pixel_at(int x, int y, Color color) {
-  if (!this->get_clipping().inside(x, y))
+  if (this->is_point_clipped(x, y))
     return;  // NOLINT
 
   switch (this->rotation_) {
@@ -64,7 +63,7 @@ void HOT DisplayBuffer::draw_pixel_at(int x, int y, Color color) {
       break;
   }
   this->draw_absolute_pixel_internal(x, y, color);
-  App.feed_wdt();
+  this->feed_wdt_per_pixel_();
 }
 
 }  // namespace esphome::display
diff --git a/esphome/components/display/rect.cpp b/esphome/components/display/rect.cpp
index a47f7269175..3ecf6d1cf15 100644
--- a/esphome/components/display/rect.cpp
+++ b/esphome/components/display/rect.cpp
@@ -63,16 +63,6 @@ bool Rect::equal(Rect rect) const {
   return (rect.x == this->x) && (rect.w == this->w) && (rect.y == this->y) && (rect.h == this->h);
 }
 
-bool Rect::inside(int16_t test_x, int16_t test_y, bool absolute) const {  // NOLINT
-  if (!this->is_set()) {
-    return true;
-  }
-  if (absolute) {
-    return test_x >= this->x && test_x < this->x2() && test_y >= this->y && test_y < this->y2();
-  }
-  return test_x >= 0 && test_x < this->w && test_y >= 0 && test_y < this->h;
-}
-
 bool Rect::inside(Rect rect) const {
   if (!this->is_set() || !rect.is_set()) {
     return true;
diff --git a/esphome/components/display/rect.h b/esphome/components/display/rect.h
index f4958fab88c..d65d844b9e6 100644
--- a/esphome/components/display/rect.h
+++ b/esphome/components/display/rect.h
@@ -26,7 +26,15 @@ class Rect {
   void shrink(Rect rect);
 
   bool inside(Rect rect) const;
-  bool inside(int16_t test_x, int16_t test_y, bool absolute = true) const;
+  bool ESPHOME_ALWAYS_INLINE inside(int16_t test_x, int16_t test_y, bool absolute = true) const {
+    if (!this->is_set()) {
+      return true;
+    }
+    if (absolute) {
+      return test_x >= this->x && test_x < this->x2() && test_y >= this->y && test_y < this->y2();
+    }
+    return test_x >= 0 && test_x < this->w && test_y >= 0 && test_y < this->h;
+  }
   bool equal(Rect rect) const;
   void info(const std::string &prefix = "rect info:");
 };
diff --git a/esphome/components/epaper_spi/epaper_spi.cpp b/esphome/components/epaper_spi/epaper_spi.cpp
index 3214f932bfb..3b3418d911f 100644
--- a/esphome/components/epaper_spi/epaper_spi.cpp
+++ b/esphome/components/epaper_spi/epaper_spi.cpp
@@ -299,7 +299,7 @@ bool EPaperBase::initialise(bool partial) {
  * @return false if the coordinates are out of bounds
  */
 bool EPaperBase::rotate_coordinates_(int &x, int &y) {
-  if (!this->get_clipping().inside(x, y))
+  if (this->is_point_clipped(x, y))
     return false;
   if (this->effective_transform_ & SWAP_XY)
     std::swap(x, y);
diff --git a/esphome/components/esp32/__init__.py b/esphome/components/esp32/__init__.py
index d027c9a1c61..748be9ae4cf 100644
--- a/esphome/components/esp32/__init__.py
+++ b/esphome/components/esp32/__init__.py
@@ -111,6 +111,7 @@ CONF_ENGINEERING_SAMPLE = "engineering_sample"
 CONF_INCLUDE_BUILTIN_IDF_COMPONENTS = "include_builtin_idf_components"
 CONF_ENABLE_LWIP_ASSERT = "enable_lwip_assert"
 CONF_EXECUTE_FROM_PSRAM = "execute_from_psram"
+CONF_FLASH_CHIP = "flash_chip"
 CONF_KEY_ID = "key_id"
 CONF_MINIMUM_CHIP_REVISION = "minimum_chip_revision"
 CONF_NVS_ENCRYPTION = "nvs_encryption"
@@ -464,6 +465,20 @@ ESP32_CHIP_REVISIONS = {
     "3.1": "CONFIG_ESP32_REV_MIN_3_1",
 }
 
+# Flash vendor drivers ESP-IDF can link; each costs IRAM plus a 124 B table in DRAM
+# and only the one matching the flash ID is ever used
+ESP32_FLASH_CHIPS = {
+    "gd": "CONFIG_SPI_FLASH_SUPPORT_GD_CHIP",
+    "issi": "CONFIG_SPI_FLASH_SUPPORT_ISSI_CHIP",
+    "mxic": "CONFIG_SPI_FLASH_SUPPORT_MXIC_CHIP",
+    "winbond": "CONFIG_SPI_FLASH_SUPPORT_WINBOND_CHIP",
+    "boya": "CONFIG_SPI_FLASH_SUPPORT_BOYA_CHIP",
+    "th": "CONFIG_SPI_FLASH_SUPPORT_TH_CHIP",
+    "mxic_opi": "CONFIG_SPI_FLASH_SUPPORT_MXIC_OPI_CHIP",
+}
+FLASH_CHIP_GENERIC = "generic"
+FLASH_CHIP_OPI = "mxic_opi"  # the octal driver, ESP32-S3 only
+
 # Socket limit configuration for ESP-IDF
 # ESP-IDF CONFIG_LWIP_MAX_SOCKETS has range 1-253, default 10
 DEFAULT_MAX_SOCKETS = 10  # ESP-IDF default
@@ -1519,6 +1534,13 @@ def final_validate(config) -> None:
                 path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_MINIMUM_CHIP_REVISION],
             )
         )
+    if config[CONF_VARIANT] != VARIANT_ESP32S3 and config.get(CONF_FLASH_MODE) == "opi":
+        errs.append(
+            cv.Invalid(
+                f"'{CONF_FLASH_MODE}: opi' is only supported on {VARIANT_ESP32S3}",
+                path=[CONF_FLASH_MODE],
+            )
+        )
     if config[CONF_VARIANT] != VARIANT_ESP32 and advanced[CONF_SRAM1_AS_IRAM]:
         errs.append(
             cv.Invalid(
@@ -1526,6 +1548,25 @@ def final_validate(config) -> None:
                 path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_SRAM1_AS_IRAM],
             )
         )
+    if (flash_chip := advanced.get(CONF_FLASH_CHIP)) is not None:
+        opi = flash_chip == FLASH_CHIP_OPI
+        if opi and config[CONF_VARIANT] != VARIANT_ESP32S3:
+            errs.append(
+                cv.Invalid(
+                    f"'{CONF_FLASH_CHIP}: {flash_chip}' is only supported on {VARIANT_ESP32S3}",
+                    path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_FLASH_CHIP],
+                )
+            )
+        elif opi != (config.get(CONF_FLASH_MODE) == "opi"):
+            errs.append(
+                cv.Invalid(
+                    f"'{CONF_FLASH_CHIP}: {flash_chip}' requires '{CONF_FLASH_MODE}: opi'"
+                    if opi
+                    else f"'{CONF_FLASH_CHIP}: {flash_chip}' does not match "
+                    f"'{CONF_FLASH_MODE}: opi'; octal flash uses {FLASH_CHIP_OPI}",
+                    path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_FLASH_CHIP],
+                )
+            )
     if (
         config[CONF_VARIANT] != VARIANT_ESP32P4
         and config.get(CONF_ENGINEERING_SAMPLE) is not None
@@ -1964,6 +2005,9 @@ FRAMEWORK_SCHEMA = cv.Schema(
                     *ESP32_CHIP_REVISIONS, string=True
                 ),
                 cv.Optional(CONF_SRAM1_AS_IRAM, default=False): cv.boolean,
+                cv.Optional(CONF_FLASH_CHIP): cv.one_of(
+                    FLASH_CHIP_GENERIC, *ESP32_FLASH_CHIPS, lower=True
+                ),
                 # DHCP server is needed for WiFi AP mode. When WiFi component is used,
                 # it will handle disabling DHCP server when AP is not configured.
                 # Default to false (disabled) when WiFi is not used.
@@ -2609,6 +2653,13 @@ async def to_code(config):
     # NVS finds stored preferences by key, so preference key migration is possible
     cg.add_define("USE_PREFERENCE_KEY_LOOKUP")
     cg.add_build_flag("-Wl,-z,noexecstack")
+    # assert(), HAL_ASSERT and ESP_ERROR_CHECK bake __FILE__ into rodata, and
+    # IDF's noflash placement puts the flash driver's copies in DRAM. The
+    # basename keeps the panic output useful at a fraction of the size.
+    # __FILE_NAME__ is a GCC 12 builtin; IDF 5.0 still ships GCC 11.2.
+    if idf_version() >= cv.Version(5, 1, 0):
+        cg.add_build_flag("-D__FILE__=__FILE_NAME__")
+        cg.add_build_flag("-Wno-builtin-macro-redefined")
     # Deferred so KEY_COMPONENTS is fully populated -- see the coroutine.
     CORE.add_job(_finalize_arduino_aware_flags)
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
@@ -2725,6 +2776,8 @@ async def to_code(config):
         add_idf_sdkconfig_option(
             f"CONFIG_ESPTOOLPY_FLASHMODE_{flash_mode.upper()}", True
         )
+        # the opi mode choice only exists once octal flash is enabled
+        add_idf_sdkconfig_option("CONFIG_ESPTOOLPY_OCT_FLASH", flash_mode == "opi")
     if flash_frequency := config.get(CONF_FLASH_FREQUENCY):
         add_idf_sdkconfig_option(
             f"CONFIG_ESPTOOLPY_FLASHFREQ_{flash_frequency[:-3]}M", True
@@ -2749,6 +2802,11 @@ async def to_code(config):
                 add_idf_sdkconfig_option(flag, rev == min_rev)
             cg.add_define("USE_ESP32_MIN_CHIP_REVISION_SET")
 
+    # Keep only the flash vendor driver the board needs; the boot log names it
+    if (flash_chip := conf[CONF_ADVANCED].get(CONF_FLASH_CHIP)) is not None:
+        for chip, flag in ESP32_FLASH_CHIPS.items():
+            add_idf_sdkconfig_option(flag, chip == flash_chip)
+
     # Use SRAM1 region as IRAM on ESP32 (original) variant
     # This provides an additional 40KB of IRAM by using SRAM1 memory that was previously
     # reserved for bootloader DRAM. Requires a bootloader from ESP-IDF v5.1 or later.
diff --git a/esphome/components/esp32/crash_handler.cpp b/esphome/components/esp32/crash_handler.cpp
index 6f65243aaa0..b72a2777c7a 100644
--- a/esphome/components/esp32/crash_handler.cpp
+++ b/esphome/components/esp32/crash_handler.cpp
@@ -173,7 +173,10 @@ static const char *const TAG = "esp32.crash";
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static uint32_t s_current_build_time = static_cast<uint32_t>(ESPHOME_BUILD_TIME);
 
-void crash_handler_read_and_clear() {
+// Validate the NOINIT record. Runs on every has_data() call; re-running is
+// harmless and the magic is left alone so the record survives an OTA
+// rollback reboot, crash_handler_clear() drops it once an API client has it.
+static void read_crash_data() {
   if (s_raw_crash_data.magic == CRASH_MAGIC && s_raw_crash_data.version == CRASH_DATA_VERSION) {
     s_crash_data_valid = true;
     // Clamp counts to prevent out-of-bounds reads from corrupt .noinit data
@@ -194,11 +197,12 @@ void crash_handler_read_and_clear() {
       s_raw_crash_data.other_reg_frame_count = s_raw_crash_data.other_backtrace_count;
 #endif
   }
-  // Don't clear magic here — crash data must survive OTA rollback reboots.
-  // Magic is cleared by crash_handler_clear() after an API client receives the data.
 }
 
-bool crash_handler_has_data() { return s_crash_data_valid; }
+bool crash_handler_has_data() {
+  read_crash_data();
+  return s_crash_data_valid;
+}
 
 void crash_handler_clear() {
   // Only clear the magic so data doesn't survive the next reboot.
@@ -426,7 +430,7 @@ static void log_foreign_addresses() {
 // crashes again during boot, and allowing the CLI's process_stacktrace to match
 // and decode each address individually.
 void crash_handler_log() {
-  if (!s_crash_data_valid)
+  if (!crash_handler_has_data())
     return;
 
   ESP_LOGE(TAG, "*** CRASH DETECTED ON PREVIOUS BOOT ***");
diff --git a/esphome/components/esp32/crash_handler.h b/esphome/components/esp32/crash_handler.h
index c5e7d145ece..314be80314c 100644
--- a/esphome/components/esp32/crash_handler.h
+++ b/esphome/components/esp32/crash_handler.h
@@ -4,11 +4,6 @@
 
 namespace esphome::esp32 {
 
-/// Read and validate crash data from NOINIT memory.
-/// Does not clear the magic marker — call crash_handler_clear() after
-/// the data has been delivered to an API client so it survives OTA rollback reboots.
-void crash_handler_read_and_clear();
-
 /// Log crash data if a crash was detected on previous boot.
 void crash_handler_log();
 
@@ -16,7 +11,7 @@ void crash_handler_log();
 /// Call after the data has been delivered to an API client.
 void crash_handler_clear();
 
-/// Returns true if crash data was found this boot.
+/// Returns true if crash data was found this boot, reading it first if needed.
 bool crash_handler_has_data();
 
 }  // namespace esphome::esp32
diff --git a/esphome/components/esp32/hal.cpp b/esphome/components/esp32/hal.cpp
index f6199d557f3..199cb89f516 100644
--- a/esphome/components/esp32/hal.cpp
+++ b/esphome/components/esp32/hal.cpp
@@ -1,9 +1,6 @@
 #ifdef USE_ESP32
 
-// defines.h must come before crash_handler.h so USE_ESP32_CRASH_HANDLER is set
-// before crash_handler.h's #ifdef-guarded namespace block is parsed.
 #include "esphome/core/defines.h"
-#include "crash_handler.h"
 #include "esphome/core/hal.h"
 
 #include <esp_clk_tree.h>
@@ -45,11 +42,6 @@ void arch_restart() {
 }
 
 void arch_init() {
-#ifdef USE_ESP32_CRASH_HANDLER
-  // Read crash data from previous boot before anything else
-  esp32::crash_handler_read_and_clear();
-#endif
-
   // Enable the task watchdog only on the loop task (from which we're currently running)
   esp_task_wdt_add(nullptr);
 
diff --git a/esphome/components/esp32_ble_server/__init__.py b/esphome/components/esp32_ble_server/__init__.py
index 118ae06e420..924d11db2b1 100644
--- a/esphome/components/esp32_ble_server/__init__.py
+++ b/esphome/components/esp32_ble_server/__init__.py
@@ -597,7 +597,7 @@ async def to_code(config):
     cg.add(parent.advertising_set_appearance(config[CONF_APPEARANCE]))
     cg.add(var.set_max_clients(config[CONF_MAX_CLIENTS]))
     # Only advertise for the server itself when the configuration gives clients something to
-    # find. A server that is auto-loaded purely to host a runtime service (esp32_improv) stays
+    # find. A server that is auto-loaded purely to host a runtime service (improv_ble) stays
     # silent until that service asks for advertising.
     cg.add(
         var.set_advertising_required(
diff --git a/esphome/components/esp32_ble_server/ble_server.h b/esphome/components/esp32_ble_server/ble_server.h
index 7869c73cc53..e469b60e088 100644
--- a/esphome/components/esp32_ble_server/ble_server.h
+++ b/esphome/components/esp32_ble_server/ble_server.h
@@ -40,7 +40,7 @@ class BLEServer final : public Component, public Parented<ESP32BLE> {
 
   /** Whether this server needs the device to advertise so clients can find and connect to it.
    *
-   * False for a server that only hosts services created at runtime (e.g. esp32_improv), which
+   * False for a server that only hosts services created at runtime (e.g. improv_ble), which
    * request advertising themselves for as long as they need it.
    */
   void set_advertising_required(bool required) { this->advertising_required_ = required; }
diff --git a/esphome/components/esp32_ble_tracker/esp32_ble_tracker.h b/esphome/components/esp32_ble_tracker/esp32_ble_tracker.h
index 1a424a4a8e8..aa470983df9 100644
--- a/esphome/components/esp32_ble_tracker/esp32_ble_tracker.h
+++ b/esphome/components/esp32_ble_tracker/esp32_ble_tracker.h
@@ -135,7 +135,7 @@ class ESPBTClient : public ESPBTDeviceListener {
   void set_tracker_state_version(uint8_t *version) { this->tracker_state_version_ = version; }
 
   // Memory optimized layout
-  uint8_t app_id;  // App IDs are small integers assigned sequentially
+  uint8_t app_id{0};  // App IDs are small integers assigned sequentially
 
  protected:
   /// Set state without IDLE handling - use for direct state transitions.
diff --git a/esphome/components/esp32_camera/esp32_camera.cpp b/esphome/components/esp32_camera/esp32_camera.cpp
index 598fe61d464..03fdbc4de7c 100644
--- a/esphome/components/esp32_camera/esp32_camera.cpp
+++ b/esphome/components/esp32_camera/esp32_camera.cpp
@@ -433,25 +433,10 @@ void ESP32Camera::set_pixel_format(ESP32CameraPixelFormat format) {
   }
 }
 void ESP32Camera::set_jpeg_quality(uint8_t quality) { this->config_.jpeg_quality = quality; }
-void ESP32Camera::set_vertical_flip(bool vertical_flip) { this->vertical_flip_ = vertical_flip; }
-void ESP32Camera::set_horizontal_mirror(bool horizontal_mirror) { this->horizontal_mirror_ = horizontal_mirror; }
-void ESP32Camera::set_contrast(int contrast) { this->contrast_ = contrast; }
-void ESP32Camera::set_brightness(int brightness) { this->brightness_ = brightness; }
-void ESP32Camera::set_saturation(int saturation) { this->saturation_ = saturation; }
-void ESP32Camera::set_special_effect(ESP32SpecialEffect effect) { this->special_effect_ = effect; }
 /* set exposure parameters */
-void ESP32Camera::set_aec_mode(ESP32GainControlMode mode) { this->aec_mode_ = mode; }
-void ESP32Camera::set_aec2(bool aec2) { this->aec2_ = aec2; }
-void ESP32Camera::set_ae_level(int ae_level) { this->ae_level_ = ae_level; }
-void ESP32Camera::set_aec_value(uint32_t aec_value) { this->aec_value_ = aec_value; }
 /* set gains parameters */
-void ESP32Camera::set_agc_mode(ESP32GainControlMode mode) { this->agc_mode_ = mode; }
-void ESP32Camera::set_agc_value(uint8_t agc_value) { this->agc_value_ = agc_value; }
-void ESP32Camera::set_agc_gain_ceiling(ESP32AgcGainCeiling gain_ceiling) { this->agc_gain_ceiling_ = gain_ceiling; }
 /* set white balance */
-void ESP32Camera::set_wb_mode(ESP32WhiteBalanceMode mode) { this->wb_mode_ = mode; }
 /* set test mode */
-void ESP32Camera::set_test_pattern(bool test_pattern) { this->test_pattern_ = test_pattern; }
 /* set fps */
 void ESP32Camera::set_max_update_interval(uint32_t max_update_interval) {
   this->max_update_interval_ = max_update_interval;
diff --git a/esphome/components/esp32_camera/esp32_camera.h b/esphome/components/esp32_camera/esp32_camera.h
index 83dab5f77a3..9ff309ad4a0 100644
--- a/esphome/components/esp32_camera/esp32_camera.h
+++ b/esphome/components/esp32_camera/esp32_camera.h
@@ -140,25 +140,25 @@ class ESP32Camera final : public camera::Camera {
   void set_pixel_format(ESP32CameraPixelFormat format);
   void set_frame_size(ESP32CameraFrameSize size);
   void set_jpeg_quality(uint8_t quality);
-  void set_vertical_flip(bool vertical_flip);
-  void set_horizontal_mirror(bool horizontal_mirror);
-  void set_contrast(int contrast);
-  void set_brightness(int brightness);
-  void set_saturation(int saturation);
-  void set_special_effect(ESP32SpecialEffect effect);
+  void set_vertical_flip(bool vertical_flip) { this->vertical_flip_ = vertical_flip; }
+  void set_horizontal_mirror(bool horizontal_mirror) { this->horizontal_mirror_ = horizontal_mirror; }
+  void set_contrast(int contrast) { this->contrast_ = contrast; }
+  void set_brightness(int brightness) { this->brightness_ = brightness; }
+  void set_saturation(int saturation) { this->saturation_ = saturation; }
+  void set_special_effect(ESP32SpecialEffect effect) { this->special_effect_ = effect; }
   /* -- exposure */
-  void set_aec_mode(ESP32GainControlMode mode);
-  void set_aec2(bool aec2);
-  void set_ae_level(int ae_level);
-  void set_aec_value(uint32_t aec_value);
+  void set_aec_mode(ESP32GainControlMode mode) { this->aec_mode_ = mode; }
+  void set_aec2(bool aec2) { this->aec2_ = aec2; }
+  void set_ae_level(int ae_level) { this->ae_level_ = ae_level; }
+  void set_aec_value(uint32_t aec_value) { this->aec_value_ = aec_value; }
   /* -- gains */
-  void set_agc_mode(ESP32GainControlMode mode);
-  void set_agc_value(uint8_t agc_value);
-  void set_agc_gain_ceiling(ESP32AgcGainCeiling gain_ceiling);
+  void set_agc_mode(ESP32GainControlMode mode) { this->agc_mode_ = mode; }
+  void set_agc_value(uint8_t agc_value) { this->agc_value_ = agc_value; }
+  void set_agc_gain_ceiling(ESP32AgcGainCeiling gain_ceiling) { this->agc_gain_ceiling_ = gain_ceiling; }
   /* -- white balance */
-  void set_wb_mode(ESP32WhiteBalanceMode mode);
+  void set_wb_mode(ESP32WhiteBalanceMode mode) { this->wb_mode_ = mode; }
   /* -- test */
-  void set_test_pattern(bool test_pattern);
+  void set_test_pattern(bool test_pattern) { this->test_pattern_ = test_pattern; }
   /* -- framerates */
   void set_max_update_interval(uint32_t max_update_interval);
   void set_idle_update_interval(uint32_t idle_update_interval);
diff --git a/esphome/components/esp32_hosted/update/esp32_hosted_update.cpp b/esphome/components/esp32_hosted/update/esp32_hosted_update.cpp
index 4eb5d1745be..d9b375dd20c 100644
--- a/esphome/components/esp32_hosted/update/esp32_hosted_update.cpp
+++ b/esphome/components/esp32_hosted/update/esp32_hosted_update.cpp
@@ -169,7 +169,7 @@ void Esp32HostedUpdate::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "  Mode: HTTP\n"
                 "  Source URL: %s",
-                this->source_url_.c_str());
+                this->source_url_);
 #else
   ESP_LOGCONFIG(TAG,
                 "  Mode: Embedded\n"
@@ -215,7 +215,7 @@ bool Esp32HostedUpdate::fetch_manifest_() {
 
   auto container = this->http_request_parent_->get(this->source_url_);
   if (container == nullptr || container->status_code != 200) {
-    ESP_LOGE(TAG, "Failed to fetch manifest from %s", this->source_url_.c_str());
+    ESP_LOGE(TAG, "Failed to fetch manifest from %s", this->source_url_);
     this->status_set_error(LOG_STR("Failed to fetch manifest"));
     return false;
   }
diff --git a/esphome/components/esp32_hosted/update/esp32_hosted_update.h b/esphome/components/esp32_hosted/update/esp32_hosted_update.h
index 4f9d04738dd..c319852bff9 100644
--- a/esphome/components/esp32_hosted/update/esp32_hosted_update.h
+++ b/esphome/components/esp32_hosted/update/esp32_hosted_update.h
@@ -25,7 +25,7 @@ class Esp32HostedUpdate final : public update::UpdateEntity, public PollingCompo
 
 #ifdef USE_ESP32_HOSTED_HTTP_UPDATE
   // HTTP mode setters
-  void set_source_url(const std::string &url) { this->source_url_ = url; }
+  void set_source_url(const char *url) { this->source_url_ = url; }
   void set_http_request_parent(http_request::HttpRequestComponent *parent) { this->http_request_parent_ = parent; }
 #else
   // Embedded mode setters
@@ -38,7 +38,7 @@ class Esp32HostedUpdate final : public update::UpdateEntity, public PollingCompo
 #ifdef USE_ESP32_HOSTED_HTTP_UPDATE
   // HTTP mode members
   http_request::HttpRequestComponent *http_request_parent_{nullptr};
-  std::string source_url_;
+  const char *source_url_{nullptr};  // literal from codegen
   std::string firmware_url_;
 
   // HTTP mode helpers
diff --git a/esphome/components/esp8266/__init__.py b/esphome/components/esp8266/__init__.py
index 19dbb68f29a..cef0e6ea11d 100644
--- a/esphome/components/esp8266/__init__.py
+++ b/esphome/components/esp8266/__init__.py
@@ -363,14 +363,6 @@ async def to_code(config: ConfigType) -> None:
     if config.get(CONF_ENABLE_SERIAL1):
         enable_serial1()
 
-    # Arduino 2 has a non-standards conformant new that returns a nullptr instead of failing when
-    # out of memory and exceptions are disabled. Since Arduino 2.6.0, this flag can be used to make
-    # new abort instead. Use it so that OOM fails early (on allocation) instead of on dereference of
-    # a NULL pointer (so the stacktrace makes more sense), and for consistency with Arduino 3,
-    # which always aborts if exceptions are disabled.
-    # For cases where nullptrs can be handled, use nothrow: `new (std::nothrow) T;`
-    cg.add_build_flag("-DNEW_OOM_ABORT")
-
     # Force-include inline std::__throw_* overrides so GCC dead-strips the unused
     # libstdc++ error message strings (e.g. "basic_string::_M_create") from DRAM.
     # See throw_stubs.h for details. Must be prepended before <string>, so this
diff --git a/esphome/components/esp8266_pwm/esp8266_pwm.h b/esphome/components/esp8266_pwm/esp8266_pwm.h
index 79c2e509848..87b76a392a6 100644
--- a/esphome/components/esp8266_pwm/esp8266_pwm.h
+++ b/esphome/components/esp8266_pwm/esp8266_pwm.h
@@ -11,6 +11,9 @@ namespace esphome::esp8266_pwm {
 
 class ESP8266PWM final : public output::FloatOutput, public Component {
  public:
+  // User provided, not "= default": `new(p) ESP8266PWM()` would zero-fill .bss that is already zero.
+  ESP8266PWM() {}
+
   void set_pin(InternalGPIOPin *pin) { pin_ = pin; }
   void set_frequency(float frequency) { this->frequency_ = frequency; }
   /// Dynamically update frequency
@@ -28,7 +31,7 @@ class ESP8266PWM final : public output::FloatOutput, public Component {
  protected:
   void write_state(float state) override;
 
-  InternalGPIOPin *pin_;
+  InternalGPIOPin *pin_{nullptr};
   float frequency_{1000.0};  // Keep in sync with DEFAULT_FREQUENCY in output.py
   /// Cache last output level for dynamic frequency updating
   float last_output_{0.0};
diff --git a/esphome/components/esphome/ota/__init__.py b/esphome/components/esphome/ota/__init__.py
index f5eb878260c..bcf2a2271cb 100644
--- a/esphome/components/esphome/ota/__init__.py
+++ b/esphome/components/esphome/ota/__init__.py
@@ -166,9 +166,17 @@ def ota_esphome_final_validate(config: ConfigType) -> None:
                 CONF_PASSWORD,
             )
     # web_server and prometheus keep the shared listener up; the captive
-    # portal's copy only exists on the fallback AP and is the recovery path
+    # portal's copy only exists on the fallback AP and is the recovery path.
+    # web_server `ota: false` gates /update behind the captive portal on
+    # every listener
+    web_server_conf = full_conf.get(CONF_WEB_SERVER)
+    plaintext_update_reachable = (
+        web_server_conf.get(CONF_OTA) is not False
+        if web_server_conf is not None
+        else "prometheus" in full_conf
+    )
     if (
-        (CONF_WEB_SERVER in full_conf or "prometheus" in full_conf)
+        plaintext_update_reachable
         and any(conf.get(CONF_PLATFORM) == CONF_WEB_SERVER for conf in full_ota_conf)
         and any(
             CONF_ENCRYPTION in conf
diff --git a/esphome/components/ethernet_info/ethernet_info_text_sensor.h b/esphome/components/ethernet_info/ethernet_info_text_sensor.h
index 11002d51bad..c9fcda225f4 100644
--- a/esphome/components/ethernet_info/ethernet_info_text_sensor.h
+++ b/esphome/components/ethernet_info/ethernet_info_text_sensor.h
@@ -13,6 +13,9 @@ class IPAddressEthernetInfo final : public Component,
                                     public text_sensor::TextSensor,
                                     public ethernet::EthernetIPStateListener {
  public:
+  // User provided, not "= default": `new(p) IPAddressEthernetInfo()` would zero-fill .bss that is already zero.
+  IPAddressEthernetInfo() {}
+
   void setup() override;
   void dump_config() override;
   void add_ip_sensors(uint8_t index, text_sensor::TextSensor *s) { this->ip_sensors_[index] = s; }
diff --git a/esphome/components/fan/fan.h b/esphome/components/fan/fan.h
index 106e6e74cd8..7e21971639e 100644
--- a/esphome/components/fan/fan.h
+++ b/esphome/components/fan/fan.h
@@ -183,7 +183,7 @@ class Fan : public EntityBase {
 
   LazyCallbackManager<void()> state_callback_{};
   ESPPreferenceObject rtc_;
-  FanRestoreMode restore_mode_;
+  FanRestoreMode restore_mode_{FanRestoreMode::NO_RESTORE};
 
  private:
   /// Lazy-allocate preset modes vector (never freed — entity lives forever).
diff --git a/esphome/components/file/image.py b/esphome/components/file/image.py
index 7cef7c754a4..ab769954124 100644
--- a/esphome/components/file/image.py
+++ b/esphome/components/file/image.py
@@ -42,7 +42,7 @@ from esphome.const import (
     CONF_TYPE,
     CONF_URL,
 )
-from esphome.core import CORE, HexInt
+from esphome.core import HexInt
 from esphome.cpp_generator import MockObj, MockObjClass
 from esphome.external_files import RemoteFile
 from esphome.types import ConfigType
@@ -76,16 +76,18 @@ def compute_local_image_path(value: str | ConfigType) -> Path:
     return external_files.compute_local_file_path(DOMAIN, url)
 
 
-def local_path(value: str | ConfigType) -> str:
-    value = value[CONF_PATH] if isinstance(value, dict) else value
-    return str(CORE.relative_config_path(value))
+def local_path(value: Path | ConfigType) -> Path:
+    # cv.file_ has already resolved the path against the config dir.
+    return value[CONF_PATH] if isinstance(value, dict) else value
 
 
-def download_file(url: str, path: Path) -> str:
+def download_file(url: str, path: Path) -> Path:
     # The shared NETWORK_TIMEOUT applies; a per-caller timeout would be
     # silently ignored on a per-run memo hit anyway (memos key by path).
     external_files.download_content(url, path)
-    return str(path)
+    # Keep the Path: config-hash normalizes Path values under the data dir,
+    # which a str would dump verbatim and break the CLI/add-on comparison.
+    return path
 
 
 def _gh_svg_url_path(mdi_id: str, source: str) -> tuple[str, Path]:
@@ -93,13 +95,13 @@ def _gh_svg_url_path(mdi_id: str, source: str) -> tuple[str, Path]:
     return MDI_SOURCES[source] + mdi_id + ".svg", base_dir / f"{mdi_id}.svg"
 
 
-def download_gh_svg(value: str | ConfigType, source: str) -> str:
+def download_gh_svg(value: str | ConfigType, source: str) -> Path:
     mdi_id = value[CONF_ICON] if isinstance(value, dict) else value
     url, path = _gh_svg_url_path(mdi_id, source)
     return download_file(url, path)
 
 
-def download_image(value: str | ConfigType) -> str:
+def download_image(value: str | ConfigType) -> Path:
     value = value[CONF_URL] if isinstance(value, dict) else value
     return download_file(value, compute_local_image_path(value))
 
@@ -147,7 +149,7 @@ def _extract_entry_ref(entry: ConfigType) -> RemoteFile | None:
 PREFETCH_FILES = external_files.single_stage_prefetch(_extract_entry_ref)
 
 
-def validate_file_shorthand(value: Any) -> str:
+def validate_file_shorthand(value: Any) -> Path:
     value = cv.string_strict(value)
     if (remote := _parse_remote_shorthand(value)) is not None:
         return download_file(remote.url, remote.path)
@@ -165,7 +167,7 @@ LOCAL_SCHEMA = cv.All(
 
 
 def mdi_schema(source: str) -> cv.All:
-    def validate_mdi(value: ConfigType) -> str:
+    def validate_mdi(value: ConfigType) -> Path:
         return download_gh_svg(value, source)
 
     return cv.All(
diff --git a/esphome/components/gpio/binary_sensor/gpio_binary_sensor.h b/esphome/components/gpio/binary_sensor/gpio_binary_sensor.h
index 956443fab55..80636e29a6e 100644
--- a/esphome/components/gpio/binary_sensor/gpio_binary_sensor.h
+++ b/esphome/components/gpio/binary_sensor/gpio_binary_sensor.h
@@ -47,6 +47,9 @@ class GPIOBinarySensorStore {
 
 class GPIOBinarySensor final : public binary_sensor::BinarySensor, public Component {
  public:
+  // User provided, not "= default": `new(p) GPIOBinarySensor()` would zero-fill .bss that is already zero.
+  GPIOBinarySensor() {}
+
   // No destructor needed: ESPHome components are created at boot and live forever.
   // Interrupts are only detached on reboot when memory is cleared anyway.
 
@@ -70,7 +73,7 @@ class GPIOBinarySensor final : public binary_sensor::BinarySensor, public Compon
   void loop() override;
 
  protected:
-  GPIOPin *pin_;
+  GPIOPin *pin_{nullptr};
   GPIOBinarySensorStore store_;
 };
 
diff --git a/esphome/components/gpio/switch/gpio_switch.cpp b/esphome/components/gpio/switch/gpio_switch.cpp
index d432655a2a4..d231b3d77a5 100644
--- a/esphome/components/gpio/switch/gpio_switch.cpp
+++ b/esphome/components/gpio/switch/gpio_switch.cpp
@@ -13,18 +13,10 @@ void GPIOSwitch::setup() {
   bool initial_state = this->get_initial_state_with_restore_mode().value_or(false);
 
   // write state before setup
-  if (initial_state) {
-    this->turn_on();
-  } else {
-    this->turn_off();
-  }
+  this->control(initial_state);
   this->pin_->setup();
   // write after setup again for other IOs
-  if (initial_state) {
-    this->turn_on();
-  } else {
-    this->turn_off();
-  }
+  this->control(initial_state);
 }
 void GPIOSwitch::dump_config() {
   LOG_SWITCH("", "GPIO Switch", this);
diff --git a/esphome/components/gpio/switch/gpio_switch.h b/esphome/components/gpio/switch/gpio_switch.h
index 7ed0de7c6f0..e7323e6e937 100644
--- a/esphome/components/gpio/switch/gpio_switch.h
+++ b/esphome/components/gpio/switch/gpio_switch.h
@@ -9,6 +9,9 @@ namespace esphome::gpio {
 
 class GPIOSwitch final : public switch_::Switch, public Component {
  public:
+  // User provided, not "= default": `new(p) GPIOSwitch()` would zero-fill .bss that is already zero.
+  GPIOSwitch() {}
+
   void set_pin(GPIOPin *pin) { pin_ = pin; }
 
   // ========== INTERNAL METHODS ==========
@@ -25,7 +28,7 @@ class GPIOSwitch final : public switch_::Switch, public Component {
  protected:
   void write_state(bool state) override;
 
-  GPIOPin *pin_;
+  GPIOPin *pin_{nullptr};
 #ifdef USE_GPIO_SWITCH_INTERLOCK
   FixedVector<Switch *> interlock_;
   uint32_t interlock_wait_time_{0};
diff --git a/esphome/components/graphical_display_menu/graphical_display_menu.cpp b/esphome/components/graphical_display_menu/graphical_display_menu.cpp
index f0642d2e8c7..d261c488557 100644
--- a/esphome/components/graphical_display_menu/graphical_display_menu.cpp
+++ b/esphome/components/graphical_display_menu/graphical_display_menu.cpp
@@ -57,10 +57,6 @@ void GraphicalDisplayMenu::dump_config() {
   }
 }
 
-void GraphicalDisplayMenu::set_display(display::Display *display) { this->display_ = display; }
-
-void GraphicalDisplayMenu::set_font(display::BaseFont *font) { this->font_ = font; }
-
 void GraphicalDisplayMenu::set_foreground_color(Color foreground_color) { this->foreground_color_ = foreground_color; }
 void GraphicalDisplayMenu::set_background_color(Color background_color) { this->background_color_ = background_color; }
 
diff --git a/esphome/components/graphical_display_menu/graphical_display_menu.h b/esphome/components/graphical_display_menu/graphical_display_menu.h
index ccdf3d304c5..13c0f9d73f8 100644
--- a/esphome/components/graphical_display_menu/graphical_display_menu.h
+++ b/esphome/components/graphical_display_menu/graphical_display_menu.h
@@ -38,8 +38,8 @@ class GraphicalDisplayMenu final : public display_menu_base::DisplayMenuComponen
   void setup() override;
   void dump_config() override;
 
-  void set_display(display::Display *display);
-  void set_font(display::BaseFont *font);
+  void set_display(display::Display *display) { this->display_ = display; }
+  void set_font(display::BaseFont *font) { this->font_ = font; }
   template<typename V> void set_menu_item_value(V menu_item_value) { this->menu_item_value_ = menu_item_value; }
   void set_foreground_color(Color foreground_color);
   void set_background_color(Color background_color);
diff --git a/esphome/components/haier/haier_base.cpp b/esphome/components/haier/haier_base.cpp
index 48f72dc16b9..87f9331d555 100644
--- a/esphome/components/haier/haier_base.cpp
+++ b/esphome/components/haier/haier_base.cpp
@@ -190,8 +190,6 @@ void HaierClimateBase::set_supported_presets(climate::ClimatePresetMask presets)
     this->traits_.add_supported_preset(climate::CLIMATE_PRESET_NONE);
 }
 
-void HaierClimateBase::set_send_wifi(bool send_wifi) { this->send_wifi_signal_ = send_wifi; }
-
 void HaierClimateBase::send_custom_command(const haier_protocol::HaierMessage &message) {
   this->action_request_ = PendingAction({ActionRequest::SEND_CUSTOM_COMMAND, message});
 }
diff --git a/esphome/components/haier/haier_base.h b/esphome/components/haier/haier_base.h
index db4c1abceb3..18ddbcc1cc5 100644
--- a/esphome/components/haier/haier_base.h
+++ b/esphome/components/haier/haier_base.h
@@ -71,7 +71,7 @@ class HaierClimateBase : public esphome::Component,
   };
   bool can_send_message() const { return haier_protocol_.get_outgoing_queue_size() == 0; };
   void set_answer_timeout(uint32_t timeout);
-  void set_send_wifi(bool send_wifi);
+  void set_send_wifi(bool send_wifi) { this->send_wifi_signal_ = send_wifi; }
   void send_custom_command(const haier_protocol::HaierMessage &message);
   template<typename F> void add_status_message_callback(F &&callback) {
     this->status_message_callback_.add(std::forward<F>(callback));
diff --git a/esphome/components/http_request/http_request.h b/esphome/components/http_request/http_request.h
index 4471dffdc2b..71668b8556f 100644
--- a/esphome/components/http_request/http_request.h
+++ b/esphome/components/http_request/http_request.h
@@ -331,27 +331,46 @@ class HttpRequestComponent : public Component {
   void set_follow_redirects(bool follow_redirects) { this->follow_redirects_ = follow_redirects; }
   void set_redirect_limit(uint16_t limit) { this->redirect_limit_ = limit; }
 
-  std::shared_ptr<HttpContainer> get(const std::string &url) {
-    return this->start(url, "GET", "", std::vector<Header>{});
-  }
-  std::shared_ptr<HttpContainer> get(const std::string &url, const std::vector<Header> &request_headers) {
+  std::shared_ptr<HttpContainer> get(const char *url) { return this->start(url, "GET", "", std::vector<Header>{}); }
+  std::shared_ptr<HttpContainer> get(const char *url, const std::vector<Header> &request_headers) {
     return this->start(url, "GET", "", request_headers);
   }
-  std::shared_ptr<HttpContainer> get(const std::string &url, const std::vector<Header> &request_headers,
+  std::shared_ptr<HttpContainer> get(const char *url, const std::vector<Header> &request_headers,
                                      const std::vector<std::string> &lower_case_collect_headers) {
     return this->start(url, "GET", "", request_headers, lower_case_collect_headers);
   }
-  std::shared_ptr<HttpContainer> post(const std::string &url, const std::string &body) {
+  std::shared_ptr<HttpContainer> post(const char *url, const std::string &body) {
     return this->start(url, "POST", body, std::vector<Header>{});
   }
+  std::shared_ptr<HttpContainer> post(const char *url, const std::string &body,
+                                      const std::vector<Header> &request_headers) {
+    return this->start(url, "POST", body, request_headers);
+  }
+  std::shared_ptr<HttpContainer> post(const char *url, const std::string &body,
+                                      const std::vector<Header> &request_headers,
+                                      const std::vector<std::string> &lower_case_collect_headers) {
+    return this->start(url, "POST", body, request_headers, lower_case_collect_headers);
+  }
+
+  std::shared_ptr<HttpContainer> get(const std::string &url) { return this->get(url.c_str()); }
+  std::shared_ptr<HttpContainer> get(const std::string &url, const std::vector<Header> &request_headers) {
+    return this->get(url.c_str(), request_headers);
+  }
+  std::shared_ptr<HttpContainer> get(const std::string &url, const std::vector<Header> &request_headers,
+                                     const std::vector<std::string> &lower_case_collect_headers) {
+    return this->get(url.c_str(), request_headers, lower_case_collect_headers);
+  }
+  std::shared_ptr<HttpContainer> post(const std::string &url, const std::string &body) {
+    return this->post(url.c_str(), body);
+  }
   std::shared_ptr<HttpContainer> post(const std::string &url, const std::string &body,
                                       const std::vector<Header> &request_headers) {
-    return this->start(url, "POST", body, request_headers);
+    return this->post(url.c_str(), body, request_headers);
   }
   std::shared_ptr<HttpContainer> post(const std::string &url, const std::string &body,
                                       const std::vector<Header> &request_headers,
                                       const std::vector<std::string> &lower_case_collect_headers) {
-    return this->start(url, "POST", body, request_headers, lower_case_collect_headers);
+    return this->post(url.c_str(), body, request_headers, lower_case_collect_headers);
   }
 
   // Remove before 2027.1.0
@@ -379,11 +398,15 @@ class HttpRequestComponent : public Component {
     return this->post(url, body, std::vector<Header>(request_headers.begin(), request_headers.end()), collect_headers);
   }
 
-  std::shared_ptr<HttpContainer> start(const std::string &url, const std::string &method, const std::string &body,
+  std::shared_ptr<HttpContainer> start(const char *url, const char *method, const std::string &body,
                                        const std::vector<Header> &request_headers) {
     // Call perform() directly to avoid ambiguity with the deprecated overloads
     return this->perform(url, method, body, request_headers, {});
   }
+  std::shared_ptr<HttpContainer> start(const std::string &url, const std::string &method, const std::string &body,
+                                       const std::vector<Header> &request_headers) {
+    return this->start(url.c_str(), method.c_str(), body, request_headers);
+  }
 
   // Remove before 2027.1.0
   ESPDEPRECATED("Pass request_headers as std::vector<Header> instead of std::list. Removed in 2027.1.0.", "2026.7.0")
@@ -403,7 +426,7 @@ class HttpRequestComponent : public Component {
     for (const auto &h : collect_headers) {
       lower.push_back(str_lower_case(h));  // NOLINT
     }
-    return this->perform(url, method, body, request_headers, lower);
+    return this->perform(url.c_str(), method.c_str(), body, request_headers, lower);
   }
 
   // Remove before 2027.1.0
@@ -418,7 +441,8 @@ class HttpRequestComponent : public Component {
     for (const auto &h : collect_headers) {
       lower.push_back(str_lower_case(h));  // NOLINT
     }
-    return this->perform(url, method, body, std::vector<Header>(request_headers.begin(), request_headers.end()), lower);
+    return this->perform(url.c_str(), method.c_str(), body,
+                         std::vector<Header>(request_headers.begin(), request_headers.end()), lower);
   }
 
   // Remove before 2027.1.0
@@ -426,19 +450,25 @@ class HttpRequestComponent : public Component {
   std::shared_ptr<HttpContainer> start(const std::string &url, const std::string &method, const std::string &body,
                                        const std::list<Header> &request_headers,
                                        const std::vector<std::string> &lower_case_collect_headers) {
-    return this->perform(url, method, body, std::vector<Header>(request_headers.begin(), request_headers.end()),
+    return this->perform(url.c_str(), method.c_str(), body,
+                         std::vector<Header>(request_headers.begin(), request_headers.end()),
                          lower_case_collect_headers);
   }
 
-  std::shared_ptr<HttpContainer> start(const std::string &url, const std::string &method, const std::string &body,
+  std::shared_ptr<HttpContainer> start(const char *url, const char *method, const std::string &body,
                                        const std::vector<Header> &request_headers,
                                        const std::vector<std::string> &lower_case_collect_headers) {
     return this->perform(url, method, body, request_headers, lower_case_collect_headers);
   }
+  std::shared_ptr<HttpContainer> start(const std::string &url, const std::string &method, const std::string &body,
+                                       const std::vector<Header> &request_headers,
+                                       const std::vector<std::string> &lower_case_collect_headers) {
+    return this->start(url.c_str(), method.c_str(), body, request_headers, lower_case_collect_headers);
+  }
 
  protected:
-  virtual std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method,
-                                                 const std::string &body, const std::vector<Header> &request_headers,
+  virtual std::shared_ptr<HttpContainer> perform(const char *url, const char *method, const std::string &body,
+                                                 const std::vector<Header> &request_headers,
                                                  const std::vector<std::string> &lower_case_collect_headers) = 0;
   const char *useragent_{nullptr};
   bool follow_redirects_{};
@@ -499,8 +529,8 @@ template<typename... Ts> class HttpRequestSendAction final : public Action<Ts...
       request_headers.push_back({key, val.value(x...)});
     }
 
-    auto container = this->parent_->start(this->url_.value(x...), this->method_.value(x...), body, request_headers,
-                                          this->lower_case_collect_headers_);
+    auto container = this->parent_->start(this->url_.value(x...).c_str(), this->method_.value(x...), body,
+                                          request_headers, this->lower_case_collect_headers_);
 
     auto captured_args = std::make_tuple(x...);
 
diff --git a/esphome/components/http_request/http_request_arduino.cpp b/esphome/components/http_request/http_request_arduino.cpp
index 43ab2e5b53a..0d968222e9e 100644
--- a/esphome/components/http_request/http_request_arduino.cpp
+++ b/esphome/components/http_request/http_request_arduino.cpp
@@ -2,6 +2,8 @@
 
 #if defined(USE_ARDUINO) && !defined(USE_ESP32) && !defined(USE_LIBRETINY)
 
+#include <cstring>
+
 #include "esphome/components/network/util.h"
 #include "esphome/components/watchdog/watchdog.h"
 
@@ -22,8 +24,7 @@ static const char *const TAG = "http_request";
 static constexpr int ESP8266_SSL_ERR_OOM = -1000;
 #endif
 
-std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const std::string &url, const std::string &method,
-                                                           const std::string &body,
+std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const char *url, const char *method, const std::string &body,
                                                            const std::vector<Header> &request_headers,
                                                            const std::vector<std::string> &lower_case_collect_headers) {
   if (!network::is_connected()) {
@@ -37,7 +38,7 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const std::string &ur
 
   const uint32_t start = millis();
 
-  bool secure = url.find("https:") != std::string::npos;
+  bool secure = strstr(url, "https:") != nullptr;
   container->set_secure(secure);
 
   watchdog::WatchdogManager wdm(this->get_watchdog_timeout());
@@ -70,19 +71,19 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const std::string &ur
   stream_ptr = std::make_unique<WiFiClient>();
 #endif  // USE_HTTP_REQUEST_ESP8266_HTTPS
 
-  bool status = container->client_.begin(*stream_ptr, url.c_str());
+  bool status = container->client_.begin(*stream_ptr, url);
 
 #elif defined(USE_RP2)
   if (secure) {
     container->client_.setInsecure();
   }
-  bool status = container->client_.begin(url.c_str());
+  bool status = container->client_.begin(url);
 #endif
 
   App.feed_wdt();
 
   if (!status) {
-    ESP_LOGW(TAG, "HTTP Request failed; URL: %s", url.c_str());
+    ESP_LOGW(TAG, "HTTP Request failed; URL: %s", url);
     container->end();
     this->status_momentary_error("failed", 1000);
     return nullptr;
@@ -107,7 +108,7 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const std::string &ur
   container->client_.collectHeaders(header_keys, index);
 
   App.feed_wdt();
-  container->status_code = container->client_.sendRequest(method.c_str(), body.c_str());
+  container->status_code = container->client_.sendRequest(method, body.c_str());
   App.feed_wdt();
   if (container->status_code < 0) {
 #if defined(USE_ESP8266) && defined(USE_HTTP_REQUEST_ESP8266_HTTPS)
@@ -139,7 +140,7 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const std::string &ur
     }
 #endif
 
-    ESP_LOGW(TAG, "HTTP Request failed; URL: %s; Error: %s", url.c_str(),
+    ESP_LOGW(TAG, "HTTP Request failed; URL: %s; Error: %s", url,
              HTTPClient::errorToString(container->status_code).c_str());
 
     this->status_momentary_error("failed", 1000);
@@ -147,7 +148,7 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const std::string &ur
     return nullptr;
   }
   if (!is_success(container->status_code)) {
-    ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url.c_str(), container->status_code);
+    ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url, container->status_code);
     this->status_momentary_error("failed", 1000);
     // Still return the container, so it can be used to get the status code and error message
   }
diff --git a/esphome/components/http_request/http_request_arduino.h b/esphome/components/http_request/http_request_arduino.h
index 028b9f44a1c..62737f4d0d1 100644
--- a/esphome/components/http_request/http_request_arduino.h
+++ b/esphome/components/http_request/http_request_arduino.h
@@ -54,7 +54,7 @@ class HttpRequestArduino final : public HttpRequestComponent {
 #endif
 
  protected:
-  std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method, const std::string &body,
+  std::shared_ptr<HttpContainer> perform(const char *url, const char *method, const std::string &body,
                                          const std::vector<Header> &request_headers,
                                          const std::vector<std::string> &lower_case_collect_headers) override;
 #ifdef USE_ESP8266
diff --git a/esphome/components/http_request/http_request_host.cpp b/esphome/components/http_request/http_request_host.cpp
index cf231e20bdc..a7889702023 100644
--- a/esphome/components/http_request/http_request_host.cpp
+++ b/esphome/components/http_request/http_request_host.cpp
@@ -5,6 +5,8 @@
 #include "httplib.h"
 #include "http_request_host.h"
 
+#include <cstring>
+
 #include <regex>
 #include "esphome/components/network/util.h"
 #include "esphome/components/watchdog/watchdog.h"
@@ -16,8 +18,7 @@ namespace esphome::http_request {
 
 static const char *const TAG = "http_request";
 
-std::shared_ptr<HttpContainer> HttpRequestHost::perform(const std::string &url, const std::string &method,
-                                                        const std::string &body,
+std::shared_ptr<HttpContainer> HttpRequestHost::perform(const char *url, const char *method, const std::string &body,
                                                         const std::vector<Header> &request_headers,
                                                         const std::vector<std::string> &lower_case_collect_headers) {
   if (!network::is_connected()) {
@@ -27,10 +28,10 @@ std::shared_ptr<HttpContainer> HttpRequestHost::perform(const std::string &url,
   }
 
   std::regex url_regex(R"(^(([^:\/?#]+):)?(//([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?)", std::regex::extended);
-  std::smatch url_match_result;
+  std::cmatch url_match_result;
 
   if (!std::regex_match(url, url_match_result, url_regex) || url_match_result.length() < 7) {
-    ESP_LOGE(TAG, "HTTP Request failed; Malformed URL: %s", url.c_str());
+    ESP_LOGE(TAG, "HTTP Request failed; Malformed URL: %s", url);
     return nullptr;
   }
   auto host = url_match_result[4].str();
@@ -54,7 +55,7 @@ std::shared_ptr<HttpContainer> HttpRequestHost::perform(const std::string &url,
   }
   httplib::Client client(scheme_host.c_str());
   if (!client.is_valid()) {
-    ESP_LOGE(TAG, "HTTP Request failed; Invalid URL: %s", url.c_str());
+    ESP_LOGE(TAG, "HTTP Request failed; Invalid URL: %s", url);
     return nullptr;
   }
   client.set_follow_location(this->follow_redirects_);
@@ -64,41 +65,41 @@ std::shared_ptr<HttpContainer> HttpRequestHost::perform(const std::string &url,
 #endif
 
   httplib::Result result;
-  if (method == "GET") {
+  if (strcmp(method, "GET") == 0) {
     result = client.Get(path, h_headers, [&](const char *data, size_t data_length) {
       ESP_LOGV(TAG, "Got data length: %zu", data_length);
       container->response_body_.insert(container->response_body_.end(), (const uint8_t *) data,
                                        (const uint8_t *) data + data_length);
       return true;
     });
-  } else if (method == "HEAD") {
+  } else if (strcmp(method, "HEAD") == 0) {
     result = client.Head(path, h_headers);
-  } else if (method == "PUT") {
+  } else if (strcmp(method, "PUT") == 0) {
     result = client.Put(path, h_headers, body, "");
     if (result) {
       auto data = std::vector<uint8_t>(result->body.begin(), result->body.end());
       container->response_body_.insert(container->response_body_.end(), data.begin(), data.end());
     }
-  } else if (method == "PATCH") {
+  } else if (strcmp(method, "PATCH") == 0) {
     result = client.Patch(path, h_headers, body, "");
     if (result) {
       auto data = std::vector<uint8_t>(result->body.begin(), result->body.end());
       container->response_body_.insert(container->response_body_.end(), data.begin(), data.end());
     }
-  } else if (method == "POST") {
+  } else if (strcmp(method, "POST") == 0) {
     result = client.Post(path, h_headers, body, "");
     if (result) {
       auto data = std::vector<uint8_t>(result->body.begin(), result->body.end());
       container->response_body_.insert(container->response_body_.end(), data.begin(), data.end());
     }
   } else {
-    ESP_LOGW(TAG, "HTTP Request failed - unsupported method %s; URL: %s", method.c_str(), url.c_str());
+    ESP_LOGW(TAG, "HTTP Request failed - unsupported method %s; URL: %s", method, url);
     container->end();
     return nullptr;
   }
   App.feed_wdt();
   if (!result) {
-    ESP_LOGW(TAG, "HTTP Request failed; URL: %s, error code: %u", url.c_str(), (unsigned) result.error());
+    ESP_LOGW(TAG, "HTTP Request failed; URL: %s, error code: %u", url, (unsigned) result.error());
     container->end();
     this->status_momentary_error("failed", 1000);
     return nullptr;
@@ -107,7 +108,7 @@ std::shared_ptr<HttpContainer> HttpRequestHost::perform(const std::string &url,
   auto response = *result;
   container->status_code = response.status;
   if (!is_success(response.status)) {
-    ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url.c_str(), response.status);
+    ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url, response.status);
     this->status_momentary_error("failed", 1000);
     // Still return the container, so it can be used to get the status code and error message
   }
diff --git a/esphome/components/http_request/http_request_host.h b/esphome/components/http_request/http_request_host.h
index 9045702f46a..0ae9f2e27b9 100644
--- a/esphome/components/http_request/http_request_host.h
+++ b/esphome/components/http_request/http_request_host.h
@@ -18,7 +18,7 @@ class HttpContainerHost : public HttpContainer {
 
 class HttpRequestHost final : public HttpRequestComponent {
  public:
-  std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method, const std::string &body,
+  std::shared_ptr<HttpContainer> perform(const char *url, const char *method, const std::string &body,
                                          const std::vector<Header> &request_headers,
                                          const std::vector<std::string> &lower_case_collect_headers) override;
   void set_ca_path(const char *ca_path) { this->ca_path_ = ca_path; }
diff --git a/esphome/components/http_request/http_request_idf.cpp b/esphome/components/http_request/http_request_idf.cpp
index 10313be89db..4e5a2c42b57 100644
--- a/esphome/components/http_request/http_request_idf.cpp
+++ b/esphome/components/http_request/http_request_idf.cpp
@@ -2,6 +2,8 @@
 
 #ifdef USE_ESP32
 
+#include <cstring>
+
 #include "esphome/components/network/util.h"
 #include "esphome/components/watchdog/watchdog.h"
 
@@ -48,8 +50,7 @@ esp_err_t HttpRequestIDF::http_event_handler(esp_http_client_event_t *evt) {
   return ESP_OK;
 }
 
-std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, const std::string &method,
-                                                       const std::string &body,
+std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const char *url, const char *method, const std::string &body,
                                                        const std::vector<Header> &request_headers,
                                                        const std::vector<std::string> &lower_case_collect_headers) {
   if (!network::is_connected()) {
@@ -59,15 +60,15 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
   }
 
   esp_http_client_method_t method_idf;
-  if (method == "GET") {
+  if (strcmp(method, "GET") == 0) {
     method_idf = HTTP_METHOD_GET;
-  } else if (method == "POST") {
+  } else if (strcmp(method, "POST") == 0) {
     method_idf = HTTP_METHOD_POST;
-  } else if (method == "PUT") {
+  } else if (strcmp(method, "PUT") == 0) {
     method_idf = HTTP_METHOD_PUT;
-  } else if (method == "DELETE") {
+  } else if (strcmp(method, "DELETE") == 0) {
     method_idf = HTTP_METHOD_DELETE;
-  } else if (method == "PATCH") {
+  } else if (strcmp(method, "PATCH") == 0) {
     method_idf = HTTP_METHOD_PATCH;
   } else {
     this->status_momentary_error("failed", ERROR_DURATION_MS);
@@ -75,11 +76,11 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
     return nullptr;
   }
 
-  bool secure = url.find("https:") != std::string::npos;
+  bool secure = strstr(url, "https:") != nullptr;
 
   esp_http_client_config_t config = {};
 
-  config.url = url.c_str();
+  config.url = url;
   config.method = method_idf;
   config.timeout_ms = this->timeout_;
   config.disable_auto_redirect = !this->follow_redirects_;
@@ -218,7 +219,7 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
     }
   }
 
-  ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url.c_str(), container->status_code);
+  ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url, container->status_code);
   this->status_momentary_error("failed", ERROR_DURATION_MS);
   return container;
 }
diff --git a/esphome/components/http_request/http_request_idf.h b/esphome/components/http_request/http_request_idf.h
index 16a5b6a161c..f84dc9576bd 100644
--- a/esphome/components/http_request/http_request_idf.h
+++ b/esphome/components/http_request/http_request_idf.h
@@ -30,6 +30,9 @@ class HttpContainerIDF : public HttpContainer {
 
 class HttpRequestIDF final : public HttpRequestComponent {
  public:
+  // User provided, not "= default": `new(p) HttpRequestIDF()` would zero-fill .bss that is already zero.
+  HttpRequestIDF() {}
+
   void dump_config() override;
 
   void set_buffer_size_rx(uint16_t buffer_size_rx) { this->buffer_size_rx_ = buffer_size_rx; }
@@ -38,7 +41,7 @@ class HttpRequestIDF final : public HttpRequestComponent {
   void set_ca_certificate(const char *ca_certificate) { this->ca_certificate_ = ca_certificate; }
 
  protected:
-  std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method, const std::string &body,
+  std::shared_ptr<HttpContainer> perform(const char *url, const char *method, const std::string &body,
                                          const std::vector<Header> &request_headers,
                                          const std::vector<std::string> &lower_case_collect_headers) override;
   // if zero ESP-IDF will use DEFAULT_HTTP_BUF_SIZE
diff --git a/esphome/components/http_request/update/http_request_update.cpp b/esphome/components/http_request/update/http_request_update.cpp
index 57dc86d55cf..6a74c00e8e5 100644
--- a/esphome/components/http_request/update/http_request_update.cpp
+++ b/esphome/components/http_request/update/http_request_update.cpp
@@ -1,5 +1,7 @@
 #include "http_request_update.h"
 
+#include <cstring>
+
 #include "esphome/core/application.h"
 #include "esphome/core/version.h"
 
@@ -94,7 +96,7 @@ void HttpRequestUpdate::update_task(void *params) {
   auto container = this_update->request_parent_->get(this_update->source_url_);
 
   if (container == nullptr || container->status_code != HTTP_STATUS_OK) {
-    ESP_LOGE(TAG, "Failed to fetch manifest from %s", this_update->source_url_.c_str());
+    ESP_LOGE(TAG, "Failed to fetch manifest from %s", this_update->source_url_);
     if (container != nullptr)
       container->end();
     result->error_str = LOG_STR("Failed to fetch manifest");
@@ -174,21 +176,26 @@ void HttpRequestUpdate::update_task(void *params) {
     allocator.deallocate(data, content_length);
 
     if (!valid) {
-      ESP_LOGE(TAG, "Failed to parse JSON from %s", this_update->source_url_.c_str());
+      ESP_LOGE(TAG, "Failed to parse JSON from %s", this_update->source_url_);
       result->error_str = LOG_STR("Failed to parse manifest JSON");
       goto defer;  // NOLINT(cppcoreguidelines-avoid-goto)
     }
 
     // Merge source_url_ and firmware_url
     if (!info->firmware_url.empty() && info->firmware_url.find("http") == std::string::npos) {
-      std::string path = info->firmware_url;
-      if (path[0] == '/') {
-        std::string domain = this_update->source_url_.substr(0, this_update->source_url_.find('/', 8));
-        info->firmware_url = domain + path;
+      const char *source = this_update->source_url_;
+      const size_t source_len = strlen(source);
+      size_t prefix_len;
+      if (info->firmware_url[0] == '/') {
+        // scheme and host, up to the first slash after "https://"
+        const char *host_end = source_len > 8 ? strchr(source + 8, '/') : nullptr;
+        prefix_len = host_end != nullptr ? host_end - source : source_len;
       } else {
-        std::string domain = this_update->source_url_.substr(0, this_update->source_url_.rfind('/') + 1);
-        info->firmware_url = domain + path;
+        // directory of the manifest, up to and including its last slash
+        const char *dir_end = strrchr(source, '/');
+        prefix_len = dir_end != nullptr ? dir_end - source + 1 : 0;
       }
+      info->firmware_url.insert(0, source, prefix_len);
     }
 
 #ifdef ESPHOME_PROJECT_VERSION
diff --git a/esphome/components/http_request/update/http_request_update.h b/esphome/components/http_request/update/http_request_update.h
index be9fbf72bfd..05a741b6cd9 100644
--- a/esphome/components/http_request/update/http_request_update.h
+++ b/esphome/components/http_request/update/http_request_update.h
@@ -21,7 +21,7 @@ class HttpRequestUpdate final : public update::UpdateEntity, public PollingCompo
   void perform(bool force) override;
   void check() override { this->update(); }
 
-  void set_source_url(const std::string &source_url) { this->source_url_ = source_url; }
+  void set_source_url(const char *source_url) { this->source_url_ = source_url; }
 
   void set_request_parent(HttpRequestComponent *request_parent) { this->request_parent_ = request_parent; }
   void set_ota_parent(OtaHttpRequestComponent *ota_parent) { this->ota_parent_ = ota_parent; }
@@ -33,13 +33,15 @@ class HttpRequestUpdate final : public update::UpdateEntity, public PollingCompo
  protected:
   HttpRequestComponent *request_parent_;
   OtaHttpRequestComponent *ota_parent_;
-  std::string source_url_;
 
   static void update_task(void *params);
 #ifdef USE_ESP32
   TaskHandle_t update_task_handle_{nullptr};
 #endif
   uint8_t initial_check_remaining_{0};
+
+ private:
+  const char *source_url_{nullptr};  // literal from codegen
 };
 
 }  // namespace esphome::http_request
diff --git a/esphome/components/hub75/hub75.cpp b/esphome/components/hub75/hub75.cpp
index ba652d427d9..d36928a83af 100644
--- a/esphome/components/hub75/hub75.cpp
+++ b/esphome/components/hub75/hub75.cpp
@@ -1,5 +1,4 @@
 #include "hub75_component.h"
-#include "esphome/core/application.h"
 
 #include <cinttypes>
 
@@ -124,11 +123,11 @@ void HOT HUB75Display::draw_pixel_at(int x, int y, Color color) {
   if (x >= this->get_width_internal() || x < 0 || y >= this->get_height_internal() || y < 0) [[unlikely]]
     return;
 
-  if (!this->get_clipping().inside(x, y))
+  if (this->is_point_clipped(x, y))
     return;
 
   driver_->set_pixel(x, y, color.r, color.g, color.b);
-  App.feed_wdt();
+  this->feed_wdt_per_pixel_();
 }
 
 void HOT HUB75Display::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
diff --git a/esphome/components/i2s_audio/speaker/i2s_audio_spdif.cpp b/esphome/components/i2s_audio/speaker/i2s_audio_spdif.cpp
index ed5145d4b0e..ec4e459be78 100644
--- a/esphome/components/i2s_audio/speaker/i2s_audio_spdif.cpp
+++ b/esphome/components/i2s_audio/speaker/i2s_audio_spdif.cpp
@@ -48,10 +48,11 @@ static esp_err_t spdif_write_cb(void *user_ctx, uint32_t *data, size_t size, Tic
   auto *speaker = static_cast<I2SAudioSpeakerSPDIF *>(user_ctx);
   size_t bytes_written = 0;
   esp_err_t err = i2s_channel_write(speaker->get_tx_handle(), data, size, &bytes_written, ticks_to_wait);
-  if (err != ESP_OK) {
+  if (err != ESP_OK || bytes_written != size) {
     ESP_LOGV(TAG, "I2S write failed: %s (wrote %zu/%zu bytes)", esp_err_to_name(err), bytes_written, size);
+    return (err != ESP_OK) ? err : ESP_FAIL;
   }
-  return err;
+  return ESP_OK;
 }
 
 void I2SAudioSpeakerSPDIF::setup() {
@@ -167,33 +168,44 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
     }
   }
 
-  if (!successful_setup) {
-    xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_ESP_NO_MEM);
-  } else {
-    // Preload DMA buffers with SPDIF-encoded silence before enabling the channel.
-    // This ensures the first data transmitted is valid SPDIF (not raw zeros from
-    // auto_clear) and prevents phantom DMA events before real audio is available.
-    // Each preloaded block pushes a 0-real-frame record so that the corresponding
-    // on_sent events drain in lockstep without crediting any audio frames.
+  // Preload DMA buffers with SPDIF-encoded silence before enabling the channel.
+  // This ensures the first data transmitted is valid SPDIF (not raw zeros from
+  // auto_clear) and prevents phantom DMA events before real audio is available.
+  // Each preloaded block pushes a 0-real-frame record so that the corresponding
+  // on_sent events drain in lockstep without crediting any audio frames. Runs with
+  // the channel disabled: at startup and after a resync.
+  auto preload_silence = [&]() -> bool {
+    bool ok = true;
     this->spdif_encoder_->set_preload_mode(true);
     for (size_t i = 0; i < SPDIF_DMA_BUFFERS_COUNT; i++) {
       // i2s_channel_preload_data is non-blocking (returns immediately when the preload buffer fills), so no wait.
-      esp_err_t preload_err = this->spdif_encoder_->flush_with_silence(0);
-      if (preload_err != ESP_OK) {
-        break;  // DMA preload buffer full or error
-      }
       const uint32_t silence_record = 0;
-      xQueueSendToBack(this->write_records_queue_, &silence_record, 0);
+      if ((this->spdif_encoder_->flush_with_silence(0) != ESP_OK) ||
+          (xQueueSendToBack(this->write_records_queue_, &silence_record, 0) != pdTRUE)) {
+        ok = false;
+        break;
+      }
     }
     this->spdif_encoder_->set_preload_mode(false);
     this->spdif_encoder_->reset();  // Clean encoder state for the main loop
+    return ok;
+  };
 
-    // Now register the callback and enable the channel
+  if (successful_setup) {
+    successful_setup = preload_silence();
+  }
+
+  if (successful_setup) {
+    // Register the callback before enabling so the first transmitted block generates a queued event.
     xQueueReset(this->i2s_event_queue_);
     const i2s_event_callbacks_t callbacks = {.on_sent = i2s_on_sent_cb};
     i2s_channel_register_event_callback(this->tx_handle_, &callbacks, this);
-    i2s_channel_enable(this->tx_handle_);
+    successful_setup = i2s_channel_enable(this->tx_handle_) == ESP_OK;
+  }
 
+  if (!successful_setup) {
+    xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_ESP_NO_MEM);
+  } else {
     // Always-fill model: each iteration produces exactly one SPDIF block (= one DMA buffer).
     // We drain real PCM up to one block from the ring buffer and silence-pad any remainder.
     // Blocking writes pace the loop at the DMA consumption rate. This mirrors the standard
@@ -210,24 +222,20 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
     uint32_t spdif_pending_frames = 0;
     int64_t spdif_pending_timestamp = 0;
     uint32_t spdif_dma_event_count = 0;
+    bool resync_needed = false;
+    // Real frames consumed from the ring buffer that never reached a write record
+    uint32_t unrecorded_frames = 0;
 
     xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::TASK_RUNNING);
 
     // SPDIF continuous mode: loop runs indefinitely, outputting silence when no audio data
     // to keep the receiver synced. Exits only via break (stream info change, silence timeout,
-    // lockstep desync, dropped event, or partial-write failure).
+    // or a failed lockstep resync).
     while (true) {
       uint32_t event_group_bits = xEventGroupGetBits(this->event_group_);
 
       if (event_group_bits & SpeakerEventGroupBits::COMMAND_STOP) {
         xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::COMMAND_STOP);
-        // The ISR pairs COMMAND_STOP with ERR_DROPPED_EVENT when it has to discard a completion
-        // event; that desyncs the lockstep queues permanently and the only safe recovery is a full
-        // task restart.
-        if (event_group_bits & SpeakerEventGroupBits::ERR_DROPPED_EVENT) {
-          ESP_LOGV(TAG, "Exiting: ISR dropped event, restarting to recover lockstep");
-          break;
-        }
         // User-initiated stop. In SPDIF continuous mode, transition to silence output rather
         // than tearing the task down.
         this->spdif_silence_start_ = millis();
@@ -244,6 +252,30 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
         break;
       }
 
+      if (event_group_bits & SpeakerEventGroupBits::ERR_DROPPED_EVENT) {
+        ESP_LOGE(TAG, "ISR event queue overflow, resyncing DMA lockstep");
+        resync_needed = true;
+      }
+      if (resync_needed) {
+        // Rebuild the lockstep in place. Frames held back by decimation are credited too, since their
+        // blocks are discarded with the rest of the DMA contents.
+        this->spdif_encoder_->reset();
+        const uint32_t credited_frames = unrecorded_frames + spdif_pending_frames;
+        const bool resynced = this->resync_lockstep_(credited_frames, preload_silence);
+        unrecorded_frames = 0;
+        spdif_pending_frames = 0;
+        spdif_dma_event_count = 0;
+        resync_needed = false;
+        if (credited_frames > 0) {
+          // Real audio was dropped, so the silence timer's start no longer reflects the stream
+          this->spdif_silence_start_ = 0;
+        }
+        if (!resynced) {
+          ESP_LOGE(TAG, "DMA lockstep resync failed, restarting speaker task");
+          break;
+        }
+      }
+
       // Drain ISR completion events, popping a matching record for each.
       int64_t write_timestamp;
       bool lockstep_broken = false;
@@ -253,8 +285,7 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
         // order matches DMA completion order. Empty records queue here means lockstep broke.
         uint32_t real_frames = 0;
         if (xQueueReceive(this->write_records_queue_, &real_frames, 0) != pdTRUE) {
-          ESP_LOGV(TAG, "Event without matching write record");
-          xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_LOCKSTEP_DESYNC);
+          ESP_LOGE(TAG, "Event without matching write record, resyncing DMA lockstep");
           lockstep_broken = true;
           break;
         }
@@ -290,8 +321,8 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
         }
       }
       if (lockstep_broken) {
-        ESP_LOGV(TAG, "Exiting: lockstep desync, restarting task");
-        break;
+        resync_needed = true;
+        continue;
       }
 
       // Always-fill: produce exactly one SPDIF block this iteration. The blocking encoder write
@@ -322,9 +353,8 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
                                                       &blocks_sent, &pcm_consumed);
           if (err != ESP_OK) {
             // A failed (or timed-out) send leaves an unsent block in the encoder's stitch buffer;
-            // resuming would credit the next iteration's bytes against an old block. Bail and
-            // let loop() restart the task with a clean encoder.
-            xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_PARTIAL_WRITE);
+            // resuming would credit the next iteration's bytes against an old block.
+            ESP_LOGE(TAG, "SPDIF block send failed, resyncing DMA lockstep");
             partial_write_failure = true;
             break;
           }
@@ -341,7 +371,9 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
       }
 
       if (partial_write_failure) {
-        break;
+        unrecorded_frames += real_frames_in_block;
+        resync_needed = true;
+        continue;
       }
 
       if (!block_committed) {
@@ -349,16 +381,20 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
         // or emit a full silence block if the encoder is empty.
         esp_err_t err = this->spdif_encoder_->flush_with_silence(write_timeout_ticks);
         if (err != ESP_OK) {
-          xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_PARTIAL_WRITE);
-          break;
+          ESP_LOGE(TAG, "SPDIF block send failed, resyncing DMA lockstep");
+          unrecorded_frames += real_frames_in_block;
+          resync_needed = true;
+          continue;
         }
       }
 
       // One block committed to DMA; push exactly one record carrying its real-audio frame count.
       // Failure here means the records queue is full, which violates the lockstep invariant.
       if (xQueueSendToBack(this->write_records_queue_, &real_frames_in_block, 0) != pdTRUE) {
-        xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_LOCKSTEP_DESYNC);
-        break;
+        ESP_LOGE(TAG, "Write records queue full, resyncing DMA lockstep");
+        unrecorded_frames += real_frames_in_block;
+        resync_needed = true;
+        continue;
       }
 
       // Silence-timeout tracking and graceful-stop reset.
diff --git a/esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp b/esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp
index 9feaf39ffff..cb82b09f33a 100644
--- a/esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp
+++ b/esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp
@@ -14,17 +14,19 @@
 
 #include "esp_timer.h"
 
-// esp-audio-libs
-#include <gain.h>
+#include <cmath>
 
 namespace esphome::i2s_audio {
 
 static const char *const TAG = "i2s_audio.speaker";
 
-// Software volume control maps the user-facing [0.0, 1.0] range to a Q31 scale factor.
-// Volumes in (0.0, 1.0) map linearly to a dB reduction in [-49.0, 0.0] dB.
+// Software volume control maps the user-facing (0.0, 1.0) range linearly to a dB reduction in
+// [-49.0, 0.0] dB; 0.0 is silence.
 static constexpr float SOFTWARE_VOLUME_MIN_DB = -49.0f;
 
+// Rate at which the software gain moves toward a new target.
+static constexpr uint32_t GAIN_RAMP_MS_PER_DB = 1;
+
 void I2SAudioSpeakerBase::setup() {
   this->event_group_ = xEventGroupCreate();
 
@@ -34,9 +36,10 @@ void I2SAudioSpeakerBase::setup() {
     return;
   }
 
-  // Initialize volume control. When audio_dac is configured, this sets the DAC volume.
+  // Initialize volume control. When audio_dac is configured, this sets the DAC volume and mute state.
   // When no audio_dac is configured, this initializes software volume control.
   this->set_volume(this->volume_);
+  this->set_mute_state(this->mute_state_);
 }
 
 void I2SAudioSpeakerBase::dump_config() {
@@ -77,17 +80,6 @@ void I2SAudioSpeakerBase::loop() {
   }
   if (event_group_bits & SpeakerEventGroupBits::TASK_STOPPING) {
     ESP_LOGV(TAG, "Stopping");
-    // Lockstep-breaking error bits are latched by the task and cleared along with all other bits
-    // when TASK_STOPPED is processed; log them here, exactly once, as the task winds down.
-    if (event_group_bits & SpeakerEventGroupBits::ERR_DROPPED_EVENT) {
-      ESP_LOGE(TAG, "ISR event queue overflow, restarting speaker task to recover timestamp sync");
-    }
-    if (event_group_bits & SpeakerEventGroupBits::ERR_PARTIAL_WRITE) {
-      ESP_LOGE(TAG, "Partial DMA write broke buffer alignment, restarting speaker task");
-    }
-    if (event_group_bits & SpeakerEventGroupBits::ERR_LOCKSTEP_DESYNC) {
-      ESP_LOGE(TAG, "Event/record queues desynced, restarting speaker task");
-    }
     xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::TASK_STOPPING);
     this->state_ = speaker::STATE_STOPPING;
   }
@@ -136,6 +128,10 @@ void I2SAudioSpeakerBase::loop() {
         break;
       }
 
+      // Seed the ramp at the live target so this run adopts it instantly rather than fading to it
+      // from wherever the previous run left off. Posted here, not in the task: the ramp's mailbox
+      // allows one writer, and that is the main loop.
+      this->post_software_gain_(0);
       xTaskCreate(I2SAudioSpeakerBase::speaker_task, "speaker_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
                   &this->speaker_task_handle_);
 
@@ -153,50 +149,31 @@ void I2SAudioSpeakerBase::loop() {
 }
 
 void I2SAudioSpeakerBase::set_volume(float volume) {
-  this->volume_ = volume;
-#ifdef USE_AUDIO_DAC
-  if (this->audio_dac_ != nullptr) {
-    if (volume > 0.0f) {
-      this->audio_dac_->set_mute_off();
-    }
-    this->audio_dac_->set_volume(volume);
-  } else
-#endif  // USE_AUDIO_DAC
-  {
-    // Fallback to software volume control by using a Q31 fixed point scaling factor.
-    // At maximum volume (1.0), set to INT32_MAX to bypass volume processing entirely
-    // and avoid any floating-point precision issues that could cause slight volume reduction.
-    if (volume >= 1.0f) {
-      this->q31_volume_factor_ = INT32_MAX;
-    } else if (volume <= 0.0f) {
-      this->q31_volume_factor_ = 0;
-    } else {
-      this->q31_volume_factor_ =
-          esp_audio_libs::gain::db_to_q31(remap<float, float>(volume, 0.0f, 1.0f, SOFTWARE_VOLUME_MIN_DB, 0.0f));
-    }
-  }
+  speaker::Speaker::set_volume(volume);
+  this->post_software_gain_(this->audio_stream_info_.ms_to_samples(GAIN_RAMP_MS_PER_DB));
 }
 
 void I2SAudioSpeakerBase::set_mute_state(bool mute_state) {
-  this->mute_state_ = mute_state;
+  speaker::Speaker::set_mute_state(mute_state);
+  this->post_software_gain_(this->audio_stream_info_.ms_to_samples(GAIN_RAMP_MS_PER_DB));
+}
+
+void I2SAudioSpeakerBase::post_software_gain_(uint32_t rate_samples) {
 #ifdef USE_AUDIO_DAC
-  if (this->audio_dac_) {
-    if (mute_state) {
-      this->audio_dac_->set_mute_on();
-    } else {
-      this->audio_dac_->set_mute_off();
-    }
-  } else
-#endif  // USE_AUDIO_DAC
-  {
-    if (mute_state) {
-      // Fallback to software volume control and scale by 0
-      this->q31_volume_factor_ = 0;
-    } else {
-      // Revert to previous volume when unmuting
-      this->set_volume(this->volume_);
-    }
+  if (this->audio_dac_ != nullptr) {
+    return;  // Hardware volume; the ramp stays at unity
   }
+#endif  // USE_AUDIO_DAC
+  // Software volume control. The ramp treats 0 dB as unity and skips processing there.
+  float target_db;
+  if (this->is_silent_()) {
+    target_db = -INFINITY;
+  } else if (this->volume_ >= 1.0f) {
+    target_db = 0.0f;
+  } else {
+    target_db = remap<float, float>(this->volume_, 0.0f, 1.0f, SOFTWARE_VOLUME_MIN_DB, 0.0f);
+  }
+  this->gain_ramp_.set_target_db_at_rate(target_db, rate_samples);
 }
 
 size_t I2SAudioSpeakerBase::play(const uint8_t *data, size_t length, TickType_t ticks_to_wait) {
@@ -337,16 +314,10 @@ bool IRAM_ATTR I2SAudioSpeakerBase::i2s_on_sent_cb(i2s_chan_handle_t handle, i2s
   I2SAudioSpeakerBase *this_speaker = (I2SAudioSpeakerBase *) user_ctx;
 
   if (xQueueIsQueueFullFromISR(this_speaker->i2s_event_queue_)) {
-    // Queue is full, so discard the oldest event. Once we drop a completion event, ``i2s_event_queue_``
-    // and any per-buffer record queue maintained by the task are permanently desynced, so the task
-    // must restart to recover. Set both ERR_DROPPED_EVENT (so loop() can log it) and COMMAND_STOP
-    // (so the task bails immediately, closing the race where loop() could clear the error bit
-    // before the task observes it).
+    // Queue is full, so discard the oldest event. The lockstep queues are now desynced; the task resyncs them.
     int64_t dummy;
     xQueueReceiveFromISR(this_speaker->i2s_event_queue_, &dummy, &need_yield1);
-    xEventGroupSetBitsFromISR(this_speaker->event_group_,
-                              SpeakerEventGroupBits::ERR_DROPPED_EVENT | SpeakerEventGroupBits::COMMAND_STOP,
-                              &need_yield2);
+    xEventGroupSetBitsFromISR(this_speaker->event_group_, SpeakerEventGroupBits::ERR_DROPPED_EVENT, &need_yield2);
   }
 
   xQueueSendToBackFromISR(this_speaker->i2s_event_queue_, &now, &need_yield3);
@@ -354,15 +325,33 @@ bool IRAM_ATTR I2SAudioSpeakerBase::i2s_on_sent_cb(i2s_chan_handle_t handle, i2s
   return need_yield1 | need_yield2 | need_yield3;
 }
 
-void I2SAudioSpeakerBase::apply_software_volume_(uint8_t *data, size_t bytes_read) {
-  if (this->q31_volume_factor_ == INT32_MAX) {
-    return;  // Max volume, no processing needed
+void I2SAudioSpeakerBase::drain_lockstep_(uint32_t extra_frames) {
+  // Stop DMA so no more completion events arrive while the queues are rebuilt
+  i2s_channel_disable(this->tx_handle_);
+  xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::ERR_DROPPED_EVENT);
+
+  uint32_t frames = extra_frames;
+  uint32_t record_frames = 0;
+  while (xQueueReceive(this->write_records_queue_, &record_frames, 0) == pdTRUE) {
+    frames += record_frames;
   }
+  xQueueReset(this->i2s_event_queue_);
 
+  if (frames > 0) {
+    ESP_LOGV(TAG, "Crediting %" PRIu32 " dropped frames as played", frames);
+    this->audio_output_callback_(frames, esp_timer_get_time());
+  }
+}
+
+void I2SAudioSpeakerBase::apply_software_volume_(uint8_t *data, size_t bytes_read) {
+#ifdef USE_AUDIO_DAC
+  if (this->audio_dac_ != nullptr) {
+    return;  // Hardware volume; the ramp is never targeted
+  }
+#endif  // USE_AUDIO_DAC
   const size_t bytes_per_sample = this->current_stream_info_.samples_to_bytes(1);
-  const uint32_t len = bytes_read / bytes_per_sample;
-
-  esp_audio_libs::gain::apply(data, data, this->q31_volume_factor_, len, bytes_per_sample);
+  this->gain_ramp_.process(data, static_cast<uint8_t>(bytes_per_sample),
+                           this->current_stream_info_.bytes_to_samples(bytes_read));
 }
 
 void I2SAudioSpeakerBase::swap_esp32_mono_samples_(uint8_t *data, size_t bytes_read) {
diff --git a/esphome/components/i2s_audio/speaker/i2s_audio_speaker.h b/esphome/components/i2s_audio/speaker/i2s_audio_speaker.h
index adb6ca5e3f7..b443166ea1b 100644
--- a/esphome/components/i2s_audio/speaker/i2s_audio_speaker.h
+++ b/esphome/components/i2s_audio/speaker/i2s_audio_speaker.h
@@ -16,6 +16,8 @@
 #include "esphome/core/gpio.h"
 #include "esphome/core/helpers.h"
 
+#include <gain.h>  // esp-audio-libs
+
 namespace esphome::i2s_audio {
 
 // Shared constants used by both standard and SPDIF speaker implementations
@@ -34,9 +36,7 @@ enum SpeakerEventGroupBits : uint32_t {
 
   ERR_ESP_NO_MEM = (1 << 19),
 
-  ERR_DROPPED_EVENT = (1 << 20),    // ISR overflowed the event queue, dropping a completion event
-  ERR_PARTIAL_WRITE = (1 << 21),    // i2s_channel_write returned fewer bytes than requested
-  ERR_LOCKSTEP_DESYNC = (1 << 22),  // i2s_event_queue_ and write_records_queue_ fell out of sync
+  ERR_DROPPED_EVENT = (1 << 20),  // ISR overflowed the event queue, dropping a completion event
 
   ALL_BITS = 0x00FFFFFF,  // All valid FreeRTOS event group bits
 };
@@ -77,19 +77,23 @@ class I2SAudioSpeakerBase : public I2SAudioOut, public speaker::Speaker, public
 
   bool has_buffered_data() const override;
 
-  /// @brief Sets the volume of the speaker. Uses the speaker's configured audio dac component. If unavailble, it is
-  /// implemented as a software volume control. Overrides the default setter to convert the floating point volume to a
-  /// Q15 fixed-point factor.
+  /// @brief Sets the volume of the speaker. Uses the speaker's configured audio dac component. If unavailable, it is
+  /// implemented as a software volume control. Overrides the default setter to convert the volume to a dB target for
+  /// the gain ramp.
   /// @param volume between 0.0 and 1.0
   void set_volume(float volume) override;
 
-  /// @brief Mutes or unmute the speaker. Uses the speaker's configured audio dac component. If unavailble, it is
-  /// implemented as a software volume control. Overrides the default setter to convert the floating point volume to a
-  /// Q15 fixed-point factor.
+  /// @brief Mutes or unmutes the speaker. Uses the speaker's configured audio dac component. If unavailable, it is
+  /// implemented as a software volume control. Overrides the default setter to post the mute state to the gain ramp.
   /// @param mute_state true for muting, false for unmuting
   void set_mute_state(bool mute_state) override;
 
  protected:
+  /// @brief Posts the ramp target derived from the current volume and mute state. No-op when an audio dac owns
+  /// volume. Main loop only.
+  /// @param rate_samples Samples the ramp takes per dB of change; 0 adopts the target at once
+  void post_software_gain_(uint32_t rate_samples);
+
   /// @brief FreeRTOS task entry point. Casts params to I2SAudioSpeakerBase and calls run_speaker_task_().
   /// @param params I2SAudioSpeakerBase component pointer
   static void speaker_task(void *params);
@@ -128,7 +132,23 @@ class I2SAudioSpeakerBase : public I2SAudioOut, public speaker::Speaker, public
   /// @brief Called in loop() when the task has stopped. Override for mode-specific cleanup.
   virtual void on_task_stopped() {}
 
-  /// @brief Apply software volume control using Q15 fixed-point scaling.
+  /// @brief Rebuilds the lockstep queues in place: disables the channel, credits every in-flight real frame as
+  /// played now, empties both queues, preloads silence through ``preload`` and re-enables the channel. Speaker
+  /// task only.
+  /// @param extra_frames Real frames the caller consumed that never reached a write record
+  /// @param preload Callable returning true once every DMA descriptor holds silence with a matching record
+  /// @return false if the preload or the channel enable failed; the caller should restart the task
+  template<typename F> bool resync_lockstep_(uint32_t extra_frames, F &&preload) {
+    this->drain_lockstep_(extra_frames);
+    return preload() && (i2s_channel_enable(this->tx_handle_) == ESP_OK);
+  }
+
+  /// @brief Disables the channel, credits ``extra_frames`` plus every real frame still recorded as in flight,
+  /// and empties both lockstep queues.
+  void drain_lockstep_(uint32_t extra_frames);
+
+  /// @brief Apply software volume control by running the samples through the gain ramp. Called from the
+  /// speaker task only.
   /// @param data Pointer to audio sample data (modified in place)
   /// @param bytes_read Number of bytes of audio data
   void apply_software_volume_(uint8_t *data, size_t bytes_read);
@@ -155,7 +175,9 @@ class I2SAudioSpeakerBase : public I2SAudioOut, public speaker::Speaker, public
 
   bool pause_state_{false};
 
-  int32_t q31_volume_factor_{INT32_MAX};
+  // Smooths software gain changes. The main loop posts targets, the speaker task processes;
+  // GainRamp's mailbox makes that safe. The main loop is the only poster.
+  esp_audio_libs::gain::GainRamp gain_ramp_;
 
   audio::AudioStreamInfo current_stream_info_;  // Format of the audio in the ring buffer (the I2S input)
   // Format actually clocked out of the I2S peripheral. Same channel count and sample rate as
diff --git a/esphome/components/i2s_audio/speaker/i2s_audio_speaker_standard.cpp b/esphome/components/i2s_audio/speaker/i2s_audio_speaker_standard.cpp
index 17c93763d63..b4b6173458b 100644
--- a/esphome/components/i2s_audio/speaker/i2s_audio_speaker_standard.cpp
+++ b/esphome/components/i2s_audio/speaker/i2s_audio_speaker_standard.cpp
@@ -134,27 +134,29 @@ void I2SAudioSpeaker::run_speaker_task() {
     }
   }
 
-  if (successful_setup) {
-    // Preload every DMA descriptor with silence and push a matching zero-real-frames record per buffer.
-    // This guarantees that every on_sent event has a corresponding write record from the start, so
-    // ``i2s_event_queue_`` and ``write_records_queue_`` stay in lockstep for the entire task lifetime.
+  // Preload every DMA descriptor with silence and push a matching zero-real-frames record per buffer, so every
+  // on_sent event has a write record from the start. Runs with the channel disabled: at startup and after a resync.
+  auto preload_silence = [&]() -> bool {
     for (size_t i = 0; i < DMA_BUFFERS_COUNT; i++) {
       size_t bytes_loaded = 0;
       esp_err_t err = i2s_channel_preload_data(this->tx_handle_, silence_buffer, dma_buffer_bytes, &bytes_loaded);
       if (err != ESP_OK || bytes_loaded != dma_buffer_bytes) {
         ESP_LOGV(TAG, "Failed to preload silence into DMA buffer %u (err=%d, loaded=%u)", (unsigned) i, (int) err,
                  (unsigned) bytes_loaded);
-        successful_setup = false;
-        break;
+        return false;
       }
       uint32_t zero_real_frames = 0;
       if (xQueueSend(this->write_records_queue_, &zero_real_frames, 0) != pdTRUE) {
         // Should never happen: the queue was just reset and is sized for DMA_BUFFERS_COUNT * 2 entries.
         ESP_LOGV(TAG, "Failed to push preload write record");
-        successful_setup = false;
-        break;
+        return false;
       }
     }
+    return true;
+  };
+
+  if (successful_setup) {
+    successful_setup = preload_silence();
   }
 
   if (successful_setup) {
@@ -177,6 +179,9 @@ void I2SAudioSpeaker::run_speaker_task() {
     // stop to wait until every real-audio buffer has been confirmed played by an ISR event.
     uint32_t pending_real_buffers = 0;
     uint32_t last_data_received_time = millis();
+    bool resync_needed = false;
+    // Real frames consumed from the ring buffer that never reached a write record
+    uint32_t unrecorded_frames = 0;
 
     xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::TASK_RUNNING);
 
@@ -197,8 +202,6 @@ void I2SAudioSpeaker::run_speaker_task() {
       uint32_t event_group_bits = xEventGroupGetBits(this->event_group_);
 
       if (event_group_bits & SpeakerEventGroupBits::COMMAND_STOP) {
-        // COMMAND_STOP is set both by user-initiated stop() and by the ISR when it drops a completion
-        // event (paired with ERR_DROPPED_EVENT so loop() can distinguish the two cases).
         xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::COMMAND_STOP);
         ESP_LOGV(TAG, "Exiting: COMMAND_STOP received");
         break;
@@ -214,6 +217,22 @@ void I2SAudioSpeaker::run_speaker_task() {
         break;
       }
 
+      if (event_group_bits & SpeakerEventGroupBits::ERR_DROPPED_EVENT) {
+        ESP_LOGE(TAG, "ISR event queue overflow, resyncing DMA lockstep");
+        resync_needed = true;
+      }
+      if (resync_needed) {
+        // Rebuild the lockstep in place; the ring buffer keeps accepting audio throughout
+        const bool resynced = this->resync_lockstep_(unrecorded_frames, preload_silence);
+        unrecorded_frames = 0;
+        pending_real_buffers = 0;
+        resync_needed = false;
+        if (!resynced) {
+          ESP_LOGE(TAG, "DMA lockstep resync failed, restarting speaker task");
+          break;
+        }
+      }
+
       // Drain ISR-stamped completion events. Each event corresponds 1:1 with a write_records_queue_
       // entry by construction (preloaded records at startup, plus exactly one record pushed per
       // iteration alongside exactly one DMA-buffer-sized write).
@@ -223,8 +242,7 @@ void I2SAudioSpeaker::run_speaker_task() {
         uint32_t real_frames = 0;
         if (xQueueReceive(this->write_records_queue_, &real_frames, 0) != pdTRUE) {
           // Should never happen: would indicate the lockstep invariant is broken.
-          ESP_LOGV(TAG, "Event without matching write record");
-          xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_LOCKSTEP_DESYNC);
+          ESP_LOGE(TAG, "Event without matching write record, resyncing DMA lockstep");
           lockstep_broken = true;
           break;
         }
@@ -240,7 +258,8 @@ void I2SAudioSpeaker::run_speaker_task() {
         }
       }
       if (lockstep_broken) {
-        break;
+        resync_needed = true;
+        continue;
       }
 
       // Graceful stop: exit only after the source's exposed chunk is drained, the underlying ring
@@ -299,10 +318,12 @@ void I2SAudioSpeaker::run_speaker_task() {
           size_t bw = 0;
           i2s_channel_write(this->tx_handle_, chunk, output_bytes, &bw, WRITE_TIMEOUT_TICKS);
           if (bw != output_bytes) {
-            // A short real-audio write breaks DMA descriptor alignment for every subsequent event;
-            // the only safe recovery is to restart the task.
-            ESP_LOGV(TAG, "Partial real audio write: %u of %u bytes", (unsigned) bw, (unsigned) output_bytes);
-            xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_PARTIAL_WRITE);
+            // A short write breaks DMA descriptor alignment for every subsequent event. Drop the chunk rather
+            // than retry it: it was already narrowed in place.
+            ESP_LOGE(TAG, "Partial DMA write (%u of %u bytes), resyncing DMA lockstep", (unsigned) bw,
+                     (unsigned) output_bytes);
+            audio_source->consume(input_bytes);
+            real_frames_total += frames_to_write;
             partial_write_failure = true;
             break;
           }
@@ -316,7 +337,9 @@ void I2SAudioSpeaker::run_speaker_task() {
       }
 
       if (partial_write_failure) {
-        break;
+        unrecorded_frames += real_frames_total;
+        resync_needed = true;
+        continue;
       }
 
       const size_t silence_bytes = dma_buffer_bytes - bytes_written_total;
@@ -325,19 +348,22 @@ void I2SAudioSpeaker::run_speaker_task() {
         i2s_channel_write(this->tx_handle_, silence_buffer, silence_bytes, &bw, WRITE_TIMEOUT_TICKS);
         if (bw != silence_bytes) {
           // Same descriptor-alignment hazard as a partial real-audio write.
-          ESP_LOGV(TAG, "Partial silence write: %u of %u bytes", (unsigned) bw, (unsigned) silence_bytes);
-          xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_PARTIAL_WRITE);
-          break;
+          ESP_LOGE(TAG, "Partial DMA write (%u of %u bytes), resyncing DMA lockstep", (unsigned) bw,
+                   (unsigned) silence_bytes);
+          unrecorded_frames += real_frames_total;
+          resync_needed = true;
+          continue;
         }
       }
 
       // Push the matching write record. Capacity headroom in I2S_EVENT_QUEUE_COUNT guarantees this
       // succeeds even with a transient backlog of unprocessed events; if it ever fails the lockstep
-      // invariant is broken and every subsequent timestamp would be silently wrong, so bail.
+      // invariant is broken and every subsequent timestamp would be silently wrong, so rebuild it.
       if (xQueueSend(this->write_records_queue_, &real_frames_total, 0) != pdTRUE) {
-        ESP_LOGV(TAG, "Exiting: write records queue full");
-        xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_LOCKSTEP_DESYNC);
-        break;
+        ESP_LOGE(TAG, "Write records queue full, resyncing DMA lockstep");
+        unrecorded_frames += real_frames_total;
+        resync_needed = true;
+        continue;
       }
       if (real_frames_total > 0) {
         pending_real_buffers++;
diff --git a/esphome/components/icnt86/__init__.py b/esphome/components/icnt86/__init__.py
new file mode 100644
index 00000000000..07f3b4e31ca
--- /dev/null
+++ b/esphome/components/icnt86/__init__.py
@@ -0,0 +1 @@
+CODEOWNERS = ["@danepowell"]
diff --git a/esphome/components/icnt86/icnt86.cpp b/esphome/components/icnt86/icnt86.cpp
new file mode 100644
index 00000000000..62a4586ebc3
--- /dev/null
+++ b/esphome/components/icnt86/icnt86.cpp
@@ -0,0 +1,84 @@
+#include "icnt86.h"
+#include "esphome/core/log.h"
+
+namespace esphome::icnt86 {
+
+static const char *const TAG = "icnt86";
+static constexpr uint16_t REG_TOUCH_NUM = 0x1001;
+static constexpr uint16_t REG_POINT1 = 0x1002;
+static constexpr uint8_t MAX_TOUCHES = 5;
+static constexpr uint8_t POINT_SIZE = 7;
+
+void ICNT86Touchscreen::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up icnt86 Touchscreen...");
+
+  // Register interrupt pin
+  if (this->interrupt_pin_ != nullptr) {
+    this->interrupt_pin_->setup();
+    this->attach_interrupt_(this->interrupt_pin_, gpio::INTERRUPT_FALLING_EDGE);
+  }
+
+  // Perform reset if necessary
+  if (this->reset_pin_ != nullptr) {
+    this->reset_pin_->setup();
+    this->reset_pin_->digital_write(false);
+    delay(10);
+    this->reset_pin_->digital_write(true);
+  }
+
+  if (this->x_raw_max_ == this->x_raw_min_) {
+    this->x_raw_max_ = this->display_->get_native_width();
+  }
+  if (this->y_raw_max_ == this->y_raw_min_) {
+    this->y_raw_max_ = this->display_->get_native_height();
+  }
+}
+
+void ICNT86Touchscreen::update_touches() {
+  uint8_t buf[MAX_TOUCHES * POINT_SIZE] = {0};
+  uint8_t mask[1] = {0x00};
+
+  if (this->read_register16(REG_TOUCH_NUM, buf, 1) != i2c::ERROR_OK) {
+    this->status_set_warning();
+    this->skip_update_ = true;
+    ESP_LOGW(TAG, "Failed to read touch count");
+    return;
+  }
+  uint8_t touch_count = buf[0];
+
+  if (touch_count == 0x00 || touch_count > MAX_TOUCHES) {  // No new touch
+    this->status_clear_warning();
+    return;
+  }
+  if (this->read_register16(REG_POINT1, buf, touch_count * POINT_SIZE) != i2c::ERROR_OK) {
+    this->status_set_warning();
+    this->skip_update_ = true;
+    ESP_LOGW(TAG, "Failed to read touch points");
+    return;
+  }
+  this->write_register16(REG_TOUCH_NUM, mask, 1);
+  ESP_LOGV(TAG, "Touch count: %d", touch_count);
+  this->status_clear_warning();
+
+  for (uint8_t i = 0; i < touch_count; i++) {
+    uint16_t x = ((uint16_t) buf[2 + 7 * i] << 8) + buf[1 + 7 * i];
+    uint16_t y = ((uint16_t) buf[4 + 7 * i] << 8) + buf[3 + 7 * i];
+    uint8_t pressure = buf[5 + 7 * i];
+    uint8_t touch_id = buf[6 + 7 * i];
+
+    // A zero-pressure report just means this point is no longer touched; skipping it here leaves is_touched_
+    // false (when no other point is active) so send_touches_() reports the release as normal.
+    if (pressure != 0) {
+      this->add_raw_touch_position_(touch_id, x, y, pressure);
+    }
+  }
+}
+
+void ICNT86Touchscreen::dump_config() {
+  ESP_LOGCONFIG(TAG, "icnt86 Touchscreen:");
+  LOG_I2C_DEVICE(this);
+  LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
+  LOG_PIN("  Reset Pin: ", this->reset_pin_);
+}
+
+}  // namespace esphome::icnt86
diff --git a/esphome/components/icnt86/icnt86.h b/esphome/components/icnt86/icnt86.h
new file mode 100644
index 00000000000..0d96b015247
--- /dev/null
+++ b/esphome/components/icnt86/icnt86.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/components/touchscreen/touchscreen.h"
+#include "esphome/core/component.h"
+#include "esphome/core/hal.h"
+
+namespace esphome::icnt86 {
+
+class ICNT86Touchscreen : public touchscreen::Touchscreen, public i2c::I2CDevice {
+ public:
+  void setup() override;
+  void dump_config() override;
+
+  void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
+  void set_reset_pin(GPIOPin *pin) { this->reset_pin_ = pin; }
+
+ protected:
+  void update_touches() override;
+  InternalGPIOPin *interrupt_pin_{};
+  GPIOPin *reset_pin_{nullptr};
+};
+
+}  // namespace esphome::icnt86
diff --git a/esphome/components/icnt86/touchscreen.py b/esphome/components/icnt86/touchscreen.py
new file mode 100644
index 00000000000..5d7a7386120
--- /dev/null
+++ b/esphome/components/icnt86/touchscreen.py
@@ -0,0 +1,40 @@
+from esphome import pins
+import esphome.codegen as cg
+from esphome.components import i2c, touchscreen
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_INTERRUPT_PIN, CONF_RESET_PIN
+from esphome.types import ConfigType
+
+CODEOWNERS = ["@danepowell"]
+DEPENDENCIES = ["i2c"]
+
+icnt86_ns = cg.esphome_ns.namespace("icnt86")
+ICNT86Touchscreen = icnt86_ns.class_(
+    "ICNT86Touchscreen",
+    touchscreen.Touchscreen,
+    i2c.I2CDevice,
+)
+
+CONFIG_SCHEMA = touchscreen.touchscreen_schema("250ms").extend(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(ICNT86Touchscreen),
+            cv.Optional(CONF_INTERRUPT_PIN): pins.internal_gpio_input_pin_schema,
+            cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
+        }
+    ).extend(i2c.i2c_device_schema(0x48))
+)
+
+
+async def to_code(config: ConfigType) -> None:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await touchscreen.register_touchscreen(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    if interrupt_pin_config := config.get(CONF_INTERRUPT_PIN):
+        cg.add(
+            var.set_interrupt_pin(await cg.gpio_pin_expression(interrupt_pin_config))
+        )
+
+    if reset_pin_config := config.get(CONF_RESET_PIN):
+        cg.add(var.set_reset_pin(await cg.gpio_pin_expression(reset_pin_config)))
diff --git a/esphome/components/image/image.cpp b/esphome/components/image/image.cpp
index 9b603683abc..bfe311be284 100644
--- a/esphome/components/image/image.cpp
+++ b/esphome/components/image/image.cpp
@@ -48,14 +48,12 @@ void Image::draw(int x, int y, display::Display *display, Color color_on, Color
                 continue;  // skip drawing
               }
               break;
-            case TRANSPARENCY_ALPHA_CHANNEL: {
-              auto on = (float) gray / 255.0f;
-              auto off = 1.0f - on;
-              // blend color_on and color_off
-              color = Color(color_on.r * on + color_off.r * off, color_on.g * on + color_off.g * off,
-                            color_on.b * on + color_off.b * off, 0xFF);
+            case TRANSPARENCY_ALPHA_CHANNEL:
+              // gray is the alpha: blend from color_off to color_on, drawn opaque
+              color = Color(Color::blend_channel(color_off.r, color_on.r, gray),
+                            Color::blend_channel(color_off.g, color_on.g, gray),
+                            Color::blend_channel(color_off.b, color_on.b, gray), 0xFF);
               break;
-            }
             default:
               break;
           }
diff --git a/esphome/components/image/image.h b/esphome/components/image/image.h
index ccc2f23f200..fd9e92c21d3 100644
--- a/esphome/components/image/image.h
+++ b/esphome/components/image/image.h
@@ -54,7 +54,6 @@ class Image : public display::BaseImage {
   const uint8_t *data_start_;
   Transparency transparency_;
   size_t bpp_{};
-  size_t stride_{};
 #ifdef USE_LVGL
   lv_img_dsc_t dsc_{};
 #endif
diff --git a/esphome/components/improv_base/__init__.py b/esphome/components/improv_base/__init__.py
index 412d143a486..9b57b6561f9 100644
--- a/esphome/components/improv_base/__init__.py
+++ b/esphome/components/improv_base/__init__.py
@@ -38,9 +38,11 @@ def _process_next_url(url: str) -> str:
     return url
 
 
-async def setup_improv_core(var: MockObj, config: ConfigType, component: str) -> None:
+async def setup_improv_core(var: MockObj, config: ConfigType) -> None:
     if next_url := config.get(CONF_NEXT_URL):
         cg.add(var.set_next_url(_process_next_url(next_url)))
-        cg.add_define(f"USE_{component.upper()}_NEXT_URL")
+        # One define for all transports: next_url_ is per object, so a transport
+        # configured without next_url: calls add_next_url_ and appends nothing.
+        cg.add_define("USE_IMPROV_NEXT_URL")
 
     cg.add_library("improv/Improv", "1.2.7")
diff --git a/esphome/components/improv_base/improv_base.cpp b/esphome/components/improv_base/improv_base.cpp
index 1babeb5b5a2..6745f8064b1 100644
--- a/esphome/components/improv_base/improv_base.cpp
+++ b/esphome/components/improv_base/improv_base.cpp
@@ -8,7 +8,7 @@
 
 namespace esphome::improv_base {
 
-#if defined(USE_ESP32_IMPROV_NEXT_URL) || defined(USE_IMPROV_SERIAL_NEXT_URL)
+#ifdef USE_IMPROV_NEXT_URL
 static const char *const TAG = "improv_base";
 
 static constexpr const char DEVICE_NAME_PLACEHOLDER[] = "{{device_name}}";
diff --git a/esphome/components/improv_base/improv_base.h b/esphome/components/improv_base/improv_base.h
index 352bb75d5fc..97801302d4f 100644
--- a/esphome/components/improv_base/improv_base.h
+++ b/esphome/components/improv_base/improv_base.h
@@ -3,7 +3,7 @@
 #include <cstddef>
 #include "esphome/core/defines.h"
 
-#if defined(USE_ESP32_IMPROV_NEXT_URL) || defined(USE_IMPROV_SERIAL_NEXT_URL)
+#ifdef USE_IMPROV_NEXT_URL
 #include <improv.h>
 #endif
 
@@ -11,12 +11,12 @@ namespace esphome::improv_base {
 
 class ImprovBase {
  public:
-#if defined(USE_ESP32_IMPROV_NEXT_URL) || defined(USE_IMPROV_SERIAL_NEXT_URL)
+#ifdef USE_IMPROV_NEXT_URL
   void set_next_url(const char *next_url) { this->next_url_ = next_url; }
 #endif
 
  protected:
-#if defined(USE_ESP32_IMPROV_NEXT_URL) || defined(USE_IMPROV_SERIAL_NEXT_URL)
+#ifdef USE_IMPROV_NEXT_URL
   /// Format next_url_ into buffer, replacing placeholders. Returns length written.
   size_t get_formatted_next_url_(char *buffer, size_t buffer_size);
   /// Append the formatted next_url to the RPC response, warning if it does not fit.
diff --git a/esphome/components/esp32_improv/__init__.py b/esphome/components/improv_ble/__init__.py
similarity index 63%
rename from esphome/components/esp32_improv/__init__.py
rename to esphome/components/improv_ble/__init__.py
index 32eb1660142..72ac5866286 100644
--- a/esphome/components/esp32_improv/__init__.py
+++ b/esphome/components/improv_ble/__init__.py
@@ -1,14 +1,41 @@
 from esphome import automation
 import esphome.codegen as cg
-from esphome.components import binary_sensor, esp32_ble, improv_base, output
-from esphome.components.esp32_ble import BTLoggers
+from esphome.components import binary_sensor, improv_base, output
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_ON_START, CONF_ON_STATE, CONF_TRIGGER_ID
+from esphome.const import (
+    CONF_ID,
+    CONF_ON_START,
+    CONF_ON_STATE,
+    CONF_TRIGGER_ID,
+    PLATFORM_ESP32,
+)
+from esphome.core import CORE
 from esphome.types import ConfigType
 
-AUTO_LOAD = ["esp32_ble_server", "improv_base"]
+# The BLE GATT server component that hosts the Improv service, per target
+# platform. improv_ble itself is platform neutral; supporting another chip
+# means adding its BLE server component here and the matching backend in
+# improv_ble_component.cpp. Doubles as the platform gate below, so an
+# unsupported chip is rejected in validation rather than at link time.
+BLE_SERVER_BACKENDS: dict[str, str] = {
+    PLATFORM_ESP32: "esp32_ble_server",
+}
+
+
+def AUTO_LOAD() -> list[str]:
+    auto_load = ["improv_base"]
+    if backend := BLE_SERVER_BACKENDS.get(CORE.target_platform):
+        auto_load.append(backend)
+    return auto_load
+
+
 CODEOWNERS = ["@jesserockz"]
-DEPENDENCIES = ["wifi", "esp32"]
+DEPENDENCIES = ["wifi"]
+
+# Legacy top-level YAML key that routes here; esphome/loader.py and
+# esphome/config.py handle the warning and the key rename.
+ALIASES = ["esp32_improv"]
+ALIAS_REMOVAL_VERSION = "2027.4.0"
 
 CONF_AUTHORIZED_DURATION = "authorized_duration"
 CONF_AUTHORIZER = "authorizer"
@@ -29,29 +56,29 @@ improv_ns = cg.esphome_ns.namespace("improv")
 Error = improv_ns.enum("Error")
 State = improv_ns.enum("State")
 
-esp32_improv_ns = cg.esphome_ns.namespace("esp32_improv")
-ESP32ImprovComponent = esp32_improv_ns.class_("ESP32ImprovComponent", cg.Component)
-ESP32ImprovProvisionedTrigger = esp32_improv_ns.class_(
-    "ESP32ImprovProvisionedTrigger", automation.Trigger.template()
+improv_ble_ns = cg.esphome_ns.namespace("improv_ble")
+ImprovBLEComponent = improv_ble_ns.class_("ImprovBLEComponent", cg.Component)
+ImprovBLEProvisionedTrigger = improv_ble_ns.class_(
+    "ImprovBLEProvisionedTrigger", automation.Trigger.template()
 )
-ESP32ImprovProvisioningTrigger = esp32_improv_ns.class_(
-    "ESP32ImprovProvisioningTrigger", automation.Trigger.template()
+ImprovBLEProvisioningTrigger = improv_ble_ns.class_(
+    "ImprovBLEProvisioningTrigger", automation.Trigger.template()
 )
-ESP32ImprovStartTrigger = esp32_improv_ns.class_(
-    "ESP32ImprovStartTrigger", automation.Trigger.template()
+ImprovBLEStartTrigger = improv_ble_ns.class_(
+    "ImprovBLEStartTrigger", automation.Trigger.template()
 )
-ESP32ImprovStateTrigger = esp32_improv_ns.class_(
-    "ESP32ImprovStateTrigger", automation.Trigger.template()
+ImprovBLEStateTrigger = improv_ble_ns.class_(
+    "ImprovBLEStateTrigger", automation.Trigger.template()
 )
-ESP32ImprovStoppedTrigger = esp32_improv_ns.class_(
-    "ESP32ImprovStoppedTrigger", automation.Trigger.template()
+ImprovBLEStoppedTrigger = improv_ble_ns.class_(
+    "ImprovBLEStoppedTrigger", automation.Trigger.template()
 )
 
 
-CONFIG_SCHEMA = (
+CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
-            cv.GenerateID(): cv.declare_id(ESP32ImprovComponent),
+            cv.GenerateID(): cv.declare_id(ImprovBLEComponent),
             cv.Required(CONF_AUTHORIZER): cv.Any(
                 cv.none, cv.use_id(binary_sensor.BinarySensor)
             ),
@@ -68,55 +95,60 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_ON_PROVISIONED): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        ESP32ImprovProvisionedTrigger
+                        ImprovBLEProvisionedTrigger
                     ),
                 }
             ),
             cv.Optional(CONF_ON_PROVISIONING): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        ESP32ImprovProvisioningTrigger
+                        ImprovBLEProvisioningTrigger
                     ),
                 }
             ),
             cv.Optional(CONF_ON_START): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        ESP32ImprovStartTrigger
+                        ImprovBLEStartTrigger
                     ),
                 }
             ),
             cv.Optional(CONF_ON_STATE): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        ESP32ImprovStateTrigger
+                        ImprovBLEStateTrigger
                     ),
                 }
             ),
             cv.Optional(CONF_ON_STOP): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        ESP32ImprovStoppedTrigger
+                        ImprovBLEStoppedTrigger
                     ),
                 }
             ),
         }
     )
     .extend(improv_base.IMPROV_SCHEMA)
-    .extend(cv.COMPONENT_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA),
+    cv.only_on(list(BLE_SERVER_BACKENDS)),
 )
 
 
 async def to_code(config: ConfigType) -> None:
+    # ESP32 backend setup: the platform gate above means this is the only backend
+    # that can reach to_code. Make it conditional when a second one is added.
+    from esphome.components import esp32_ble
+
     # Register the loggers this component needs
-    esp32_ble.register_bt_logger(BTLoggers.GATT, BTLoggers.SMP)
+    esp32_ble.register_bt_logger(esp32_ble.BTLoggers.GATT, esp32_ble.BTLoggers.SMP)
 
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
-    cg.add_define("USE_IMPROV")
+    cg.add_define("USE_IMPROV_BLE")
 
-    await improv_base.setup_improv_core(var, config, "esp32_improv")
+    await improv_base.setup_improv_core(var, config)
 
     cg.add(var.set_identify_duration(config[CONF_IDENTIFY_DURATION]))
     cg.add(var.set_authorized_duration(config[CONF_AUTHORIZED_DURATION]))
@@ -155,4 +187,4 @@ async def to_code(config: ConfigType) -> None:
         await automation.build_automation(trigger, [], conf)
         use_state_callback = True
     if use_state_callback:
-        cg.add_define("USE_ESP32_IMPROV_STATE_CALLBACK")
+        cg.add_define("USE_IMPROV_BLE_STATE_CALLBACK")
diff --git a/esphome/components/esp32_improv/automation.h b/esphome/components/improv_ble/automation.h
similarity index 55%
rename from esphome/components/esp32_improv/automation.h
rename to esphome/components/improv_ble/automation.h
index b3b61f47785..223a1292384 100644
--- a/esphome/components/esp32_improv/automation.h
+++ b/esphome/components/improv_ble/automation.h
@@ -1,17 +1,17 @@
 #pragma once
 #ifdef USE_ESP32
-#ifdef USE_ESP32_IMPROV_STATE_CALLBACK
-#include "esp32_improv_component.h"
+#ifdef USE_IMPROV_BLE_STATE_CALLBACK
+#include "improv_ble_component.h"
 
 #include "esphome/core/automation.h"
 
 #include <improv.h>
 
-namespace esphome::esp32_improv {
+namespace esphome::improv_ble {
 
-class ESP32ImprovProvisionedTrigger final : public Trigger<> {
+class ImprovBLEProvisionedTrigger final : public Trigger<> {
  public:
-  explicit ESP32ImprovProvisionedTrigger(ESP32ImprovComponent *parent) : parent_(parent) {
+  explicit ImprovBLEProvisionedTrigger(ImprovBLEComponent *parent) : parent_(parent) {
     parent->add_on_state_callback([this](improv::State state, improv::Error error) {
       if (state == improv::STATE_PROVISIONED && !this->parent_->is_failed()) {
         this->trigger();
@@ -20,12 +20,12 @@ class ESP32ImprovProvisionedTrigger final : public Trigger<> {
   }
 
  protected:
-  ESP32ImprovComponent *parent_;
+  ImprovBLEComponent *parent_;
 };
 
-class ESP32ImprovProvisioningTrigger final : public Trigger<> {
+class ImprovBLEProvisioningTrigger final : public Trigger<> {
  public:
-  explicit ESP32ImprovProvisioningTrigger(ESP32ImprovComponent *parent) : parent_(parent) {
+  explicit ImprovBLEProvisioningTrigger(ImprovBLEComponent *parent) : parent_(parent) {
     parent->add_on_state_callback([this](improv::State state, improv::Error error) {
       if (state == improv::STATE_PROVISIONING && !this->parent_->is_failed()) {
         this->trigger();
@@ -34,12 +34,12 @@ class ESP32ImprovProvisioningTrigger final : public Trigger<> {
   }
 
  protected:
-  ESP32ImprovComponent *parent_;
+  ImprovBLEComponent *parent_;
 };
 
-class ESP32ImprovStartTrigger final : public Trigger<> {
+class ImprovBLEStartTrigger final : public Trigger<> {
  public:
-  explicit ESP32ImprovStartTrigger(ESP32ImprovComponent *parent) : parent_(parent) {
+  explicit ImprovBLEStartTrigger(ImprovBLEComponent *parent) : parent_(parent) {
     parent->add_on_state_callback([this](improv::State state, improv::Error error) {
       if ((state == improv::STATE_AUTHORIZED || state == improv::STATE_AWAITING_AUTHORIZATION) &&
           !this->parent_->is_failed()) {
@@ -49,12 +49,12 @@ class ESP32ImprovStartTrigger final : public Trigger<> {
   }
 
  protected:
-  ESP32ImprovComponent *parent_;
+  ImprovBLEComponent *parent_;
 };
 
-class ESP32ImprovStateTrigger final : public Trigger<improv::State, improv::Error> {
+class ImprovBLEStateTrigger final : public Trigger<improv::State, improv::Error> {
  public:
-  explicit ESP32ImprovStateTrigger(ESP32ImprovComponent *parent) : parent_(parent) {
+  explicit ImprovBLEStateTrigger(ImprovBLEComponent *parent) : parent_(parent) {
     parent->add_on_state_callback([this](improv::State state, improv::Error error) {
       if (!this->parent_->is_failed()) {
         this->trigger(state, error);
@@ -63,12 +63,12 @@ class ESP32ImprovStateTrigger final : public Trigger<improv::State, improv::Erro
   }
 
  protected:
-  ESP32ImprovComponent *parent_;
+  ImprovBLEComponent *parent_;
 };
 
-class ESP32ImprovStoppedTrigger final : public Trigger<> {
+class ImprovBLEStoppedTrigger final : public Trigger<> {
  public:
-  explicit ESP32ImprovStoppedTrigger(ESP32ImprovComponent *parent) : parent_(parent) {
+  explicit ImprovBLEStoppedTrigger(ImprovBLEComponent *parent) : parent_(parent) {
     parent->add_on_state_callback([this](improv::State state, improv::Error error) {
       if (state == improv::STATE_STOPPED && !this->parent_->is_failed()) {
         this->trigger();
@@ -77,10 +77,10 @@ class ESP32ImprovStoppedTrigger final : public Trigger<> {
   }
 
  protected:
-  ESP32ImprovComponent *parent_;
+  ImprovBLEComponent *parent_;
 };
 
-}  // namespace esphome::esp32_improv
+}  // namespace esphome::improv_ble
 
 #endif
 #endif
diff --git a/esphome/components/esp32_improv/esp32_improv_component.cpp b/esphome/components/improv_ble/improv_ble_component.cpp
similarity index 91%
rename from esphome/components/esp32_improv/esp32_improv_component.cpp
rename to esphome/components/improv_ble/improv_ble_component.cpp
index 9ec6eb7bab6..0a20beb33c8 100644
--- a/esphome/components/esp32_improv/esp32_improv_component.cpp
+++ b/esphome/components/improv_ble/improv_ble_component.cpp
@@ -1,10 +1,7 @@
-#include "esp32_improv_component.h"
+#include "improv_ble_component.h"
 
 #include <array>
 
-#include "esphome/components/bytebuffer/bytebuffer.h"
-#include "esphome/components/esp32_ble/ble.h"
-#include "esphome/components/esp32_ble_server/ble_2902.h"
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
@@ -15,11 +12,15 @@
 
 #ifdef USE_ESP32
 
-namespace esphome::esp32_improv {
+#include "esphome/components/bytebuffer/bytebuffer.h"
+#include "esphome/components/esp32_ble/ble.h"
+#include "esphome/components/esp32_ble_server/ble_2902.h"
+
+namespace esphome::improv_ble {
 
 using namespace bytebuffer;
 
-static const char *const TAG = "esp32_improv.component";
+static const char *const TAG = "improv_ble.component";
 static constexpr size_t IMPROV_MAX_LOG_BYTES = 128;
 static constexpr char ESPHOME_MY_LINK[] = "https://my.home-assistant.io/redirect/config_flow_start?domain=esphome";
 // command + data length + trailing byte
@@ -38,9 +39,9 @@ static constexpr uint8_t IMPROV_SERVICE_DATA_SIZE = 8;
 static constexpr uint8_t IMPROV_PROTOCOL_ID_1 = 0x77;  // 'P' << 1 | 'R' >> 7
 static constexpr uint8_t IMPROV_PROTOCOL_ID_2 = 0x46;  // 'I' << 1 | 'M' >> 7
 
-ESP32ImprovComponent::ESP32ImprovComponent() { global_improv_component = this; }
+ImprovBLEComponent::ImprovBLEComponent() { global_improv_component = this; }
 
-void ESP32ImprovComponent::setup() {
+void ImprovBLEComponent::setup() {
 #ifdef USE_BINARY_SENSOR
   if (this->authorizer_ != nullptr) {
     this->authorizer_->add_on_state_callback([this](bool state) {
@@ -66,7 +67,7 @@ void ESP32ImprovComponent::setup() {
   this->disable_loop();
 }
 
-void ESP32ImprovComponent::setup_characteristics() {
+void ImprovBLEComponent::setup_characteristics() {
   this->status_ = this->service_->create_characteristic(
       improv::STATUS_UUID, BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
   BLEDescriptor *status_descriptor = new BLE2902();
@@ -104,11 +105,11 @@ void ESP32ImprovComponent::setup_characteristics() {
   this->setup_complete_ = true;
 }
 
-void ESP32ImprovComponent::loop() {
+void ImprovBLEComponent::loop() {
   if (!global_ble_server->is_running()) {
     if (this->state_ != improv::STATE_STOPPED) {
       this->state_ = improv::STATE_STOPPED;
-#ifdef USE_ESP32_IMPROV_STATE_CALLBACK
+#ifdef USE_IMPROV_BLE_STATE_CALLBACK
       this->state_callback_.call(this->state_, this->error_state_);
 #endif
     }
@@ -200,23 +201,19 @@ void ESP32ImprovComponent::loop() {
   }
 }
 
-void ESP32ImprovComponent::set_status_indicator_state_(bool state) {
+void ImprovBLEComponent::set_status_indicator_state_(bool state) {
 #ifdef USE_OUTPUT
   if (this->status_indicator_ == nullptr)
     return;
   if (this->status_indicator_state_ == state)
     return;
   this->status_indicator_state_ = state;
-  if (state) {
-    this->status_indicator_->turn_on();
-  } else {
-    this->status_indicator_->turn_off();
-  }
+  this->status_indicator_->set_state(state);
 #endif
 }
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG
-const char *ESP32ImprovComponent::state_to_string_(improv::State state) {
+const char *ImprovBLEComponent::state_to_string_(improv::State state) {
   switch (state) {
     case improv::STATE_STOPPED:
       return "STOPPED";
@@ -234,7 +231,7 @@ const char *ESP32ImprovComponent::state_to_string_(improv::State state) {
 }
 #endif
 
-bool ESP32ImprovComponent::check_identify_() {
+bool ImprovBLEComponent::check_identify_() {
   uint32_t now = millis();
 
   bool identify = this->identify_start_ != 0 && now - this->identify_start_ <= this->identify_duration_;
@@ -246,7 +243,7 @@ bool ESP32ImprovComponent::check_identify_() {
   return identify;
 }
 
-void ESP32ImprovComponent::set_state_(improv::State state, bool update_advertising) {
+void ImprovBLEComponent::set_state_(improv::State state, bool update_advertising) {
   // Skip if state hasn't changed
   if (this->state_ == state) {
     return;
@@ -274,12 +271,12 @@ void ESP32ImprovComponent::set_state_(improv::State state, bool update_advertisi
     // Advertise the new state via service data
     this->advertise_service_data_();
   }
-#ifdef USE_ESP32_IMPROV_STATE_CALLBACK
+#ifdef USE_IMPROV_BLE_STATE_CALLBACK
   this->state_callback_.call(this->state_, this->error_state_);
 #endif
 }
 
-void ESP32ImprovComponent::set_error_(improv::Error error) {
+void ImprovBLEComponent::set_error_(improv::Error error) {
   if (error != improv::ERROR_NONE) {
     ESP_LOGE(TAG, "Error: %d", error);
   }
@@ -295,14 +292,14 @@ void ESP32ImprovComponent::set_error_(improv::Error error) {
   }
 }
 
-void ESP32ImprovComponent::send_response_(std::span<const uint8_t> response) {
+void ImprovBLEComponent::send_response_(std::span<const uint8_t> response) {
   // The BLE characteristic owns its value, so one exact-size copy is required here
   this->rpc_response_->set_value(std::vector<uint8_t>(response.begin(), response.end()));
   if (this->state_ != improv::STATE_STOPPED)
     this->rpc_response_->notify();
 }
 
-void ESP32ImprovComponent::start() {
+void ImprovBLEComponent::start() {
   if (this->should_start_ || this->state_ != improv::STATE_STOPPED)
     return;
 
@@ -320,7 +317,7 @@ void ESP32ImprovComponent::start() {
   this->enable_loop();
 }
 
-void ESP32ImprovComponent::stop() {
+void ImprovBLEComponent::stop() {
   this->should_start_ = false;
   // Wait before stopping the service to ensure all BLE clients see the state change.
   // This prevents clients from repeatedly reconnecting and wasting resources by allowing
@@ -335,10 +332,10 @@ void ESP32ImprovComponent::stop() {
   });
 }
 
-float ESP32ImprovComponent::get_setup_priority() const { return setup_priority::AFTER_BLUETOOTH; }
+float ImprovBLEComponent::get_setup_priority() const { return setup_priority::AFTER_BLUETOOTH; }
 
-void ESP32ImprovComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "ESP32 Improv:");
+void ImprovBLEComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "Improv BLE:");
 #ifdef USE_BINARY_SENSOR
   LOG_BINARY_SENSOR("  ", "Authorizer", this->authorizer_);
 #endif
@@ -347,7 +344,7 @@ void ESP32ImprovComponent::dump_config() {
 #endif
 }
 
-void ESP32ImprovComponent::process_incoming_data_() {
+void ImprovBLEComponent::process_incoming_data_() {
   if (this->incoming_data_.size() < 3)
     return;
   uint8_t length = this->incoming_data_[1];
@@ -422,7 +419,7 @@ void ESP32ImprovComponent::process_incoming_data_() {
   }
 }
 
-void ESP32ImprovComponent::on_wifi_connect_timeout_() {
+void ImprovBLEComponent::on_wifi_connect_timeout_() {
   this->set_error_(improv::ERROR_UNABLE_TO_CONNECT);
   this->set_state_(improv::STATE_AUTHORIZED);
 #ifdef USE_BINARY_SENSOR
@@ -433,7 +430,7 @@ void ESP32ImprovComponent::on_wifi_connect_timeout_() {
   wifi::global_wifi_component->clear_sta();
 }
 
-void ESP32ImprovComponent::check_wifi_connection_() {
+void ImprovBLEComponent::check_wifi_connection_() {
   if (!wifi::global_wifi_component->is_connected()) {
     return;
   }
@@ -447,7 +444,7 @@ void ESP32ImprovComponent::check_wifi_connection_() {
     std::array<uint8_t, improv::RPC_RESPONSE_MAX_SIZE> buf;
     improv::RpcResponseBuilder builder(buf, improv::WIFI_SETTINGS);
 
-#ifdef USE_ESP32_IMPROV_NEXT_URL
+#ifdef USE_IMPROV_NEXT_URL
     // Add next_url if configured (should be first per Improv BLE spec)
     this->add_next_url_(builder, MAX_NEXT_URL_LEN);
 #endif
@@ -480,7 +477,7 @@ void ESP32ImprovComponent::check_wifi_connection_() {
   this->stop();
 }
 
-void ESP32ImprovComponent::advertise_service_data_() {
+void ImprovBLEComponent::advertise_service_data_() {
   uint8_t service_data[IMPROV_SERVICE_DATA_SIZE] = {};
   service_data[0] = IMPROV_PROTOCOL_ID_1;  // PR
   service_data[1] = IMPROV_PROTOCOL_ID_2;  // IM
@@ -499,7 +496,7 @@ void ESP32ImprovComponent::advertise_service_data_() {
   esp32_ble::global_ble->advertising_set_service_data_and_name(std::span<const uint8_t>(service_data), false);
 }
 
-void ESP32ImprovComponent::update_advertising_type_() {
+void ImprovBLEComponent::update_advertising_type_() {
   uint32_t now = App.get_loop_component_start_time();
 
   // If we're advertising the device name and it's been more than NAME_ADVERTISING_DURATION, switch back to service data
@@ -524,21 +521,21 @@ void ESP32ImprovComponent::update_advertising_type_() {
   }
 }
 
-void ESP32ImprovComponent::request_advertising_() {
+void ImprovBLEComponent::request_advertising_() {
   if (this->advertising_requested_)
     return;
   this->advertising_requested_ = true;
   esp32_ble::global_ble->advertising_start();
 }
 
-void ESP32ImprovComponent::release_advertising_() {
+void ImprovBLEComponent::release_advertising_() {
   if (!this->advertising_requested_)
     return;
   this->advertising_requested_ = false;
   esp32_ble::global_ble->advertising_stop();
 }
 
-improv::State ESP32ImprovComponent::get_initial_state_() const {
+improv::State ImprovBLEComponent::get_initial_state_() const {
 #ifdef USE_BINARY_SENSOR
   // If we have an authorizer, start in awaiting authorization state
   return this->authorizer_ == nullptr ? improv::STATE_AUTHORIZED : improv::STATE_AWAITING_AUTHORIZATION;
@@ -548,8 +545,8 @@ improv::State ESP32ImprovComponent::get_initial_state_() const {
 #endif
 }
 
-ESP32ImprovComponent *global_improv_component = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+ImprovBLEComponent *global_improv_component = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-}  // namespace esphome::esp32_improv
+}  // namespace esphome::improv_ble
 
 #endif
diff --git a/esphome/components/esp32_improv/esp32_improv_component.h b/esphome/components/improv_ble/improv_ble_component.h
similarity index 86%
rename from esphome/components/esp32_improv/esp32_improv_component.h
rename to esphome/components/improv_ble/improv_ble_component.h
index a40d60552a8..2552bed69b5 100644
--- a/esphome/components/esp32_improv/esp32_improv_component.h
+++ b/esphome/components/improv_ble/improv_ble_component.h
@@ -5,12 +5,10 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
 
-#include "esphome/components/esp32_ble_server/ble_characteristic.h"
-#include "esphome/components/esp32_ble_server/ble_server.h"
 #include "esphome/components/improv_base/improv_base.h"
 #include "esphome/components/wifi/wifi_component.h"
 
-#ifdef USE_ESP32_IMPROV_STATE_CALLBACK
+#ifdef USE_IMPROV_BLE_STATE_CALLBACK
 #include "esphome/core/automation.h"
 #endif
 
@@ -25,17 +23,23 @@
 #include <span>
 #include <vector>
 
+// ESP-IDF is currently the only target platform with a BLE GATT server, so it is
+// the only backend this component has. The Python side keeps the platform table
+// (BLE_SERVER_BACKENDS in __init__.py); a second backend adds another arm here.
 #ifdef USE_ESP32
 
+#include "esphome/components/esp32_ble_server/ble_characteristic.h"
+#include "esphome/components/esp32_ble_server/ble_server.h"
+
 #include <improv.h>
 
-namespace esphome::esp32_improv {
+namespace esphome::improv_ble {
 
 using namespace esp32_ble_server;
 
-class ESP32ImprovComponent final : public Component, public improv_base::ImprovBase {
+class ImprovBLEComponent final : public Component, public improv_base::ImprovBase {
  public:
-  ESP32ImprovComponent();
+  ImprovBLEComponent();
   void dump_config() override;
   void loop() override;
   void setup() override;
@@ -47,7 +51,7 @@ class ESP32ImprovComponent final : public Component, public improv_base::ImprovB
   bool is_active() const { return this->state_ != improv::STATE_STOPPED; }
   bool should_start() const { return this->should_start_; }
 
-#ifdef USE_ESP32_IMPROV_STATE_CALLBACK
+#ifdef USE_IMPROV_BLE_STATE_CALLBACK
   template<typename F> void add_on_state_callback(F &&callback) {
     this->state_callback_.add(std::forward<F>(callback));
   }
@@ -97,7 +101,7 @@ class ESP32ImprovComponent final : public Component, public improv_base::ImprovB
 
   improv::State state_{improv::STATE_STOPPED};
   improv::Error error_state_{improv::ERROR_NONE};
-#ifdef USE_ESP32_IMPROV_STATE_CALLBACK
+#ifdef USE_IMPROV_BLE_STATE_CALLBACK
   CallbackManager<void(improv::State, improv::Error)> state_callback_{};
 #endif
 
@@ -125,8 +129,8 @@ class ESP32ImprovComponent final : public Component, public improv_base::ImprovB
 };
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-extern ESP32ImprovComponent *global_improv_component;
+extern ImprovBLEComponent *global_improv_component;
 
-}  // namespace esphome::esp32_improv
+}  // namespace esphome::improv_ble
 
 #endif
diff --git a/esphome/components/improv_serial/__init__.py b/esphome/components/improv_serial/__init__.py
index a34e2ab7931..0231791e9b3 100644
--- a/esphome/components/improv_serial/__init__.py
+++ b/esphome/components/improv_serial/__init__.py
@@ -70,7 +70,7 @@ FINAL_VALIDATE_SCHEMA = validate_transport
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
-    await improv_base.setup_improv_core(var, config, "improv_serial")
+    await improv_base.setup_improv_core(var, config)
     cg.add_define("USE_IMPROV_SERIAL")
     if (uart_id := config.get(CONF_UART_ID)) is not None:
         cg.add(var.set_uart(await cg.get_variable(uart_id)))
diff --git a/esphome/components/improv_serial/improv_serial_component.cpp b/esphome/components/improv_serial/improv_serial_component.cpp
index ffa7b79d9bf..3827fb6ed45 100644
--- a/esphome/components/improv_serial/improv_serial_component.cpp
+++ b/esphome/components/improv_serial/improv_serial_component.cpp
@@ -208,7 +208,7 @@ void ImprovSerialComponent::add_webserver_urls_(improv::RpcResponseBuilder &buil
 void ImprovSerialComponent::send_settings_response_(improv::Command command) {
   std::array<uint8_t, improv::RPC_RESPONSE_MAX_SIZE> buf;
   improv::RpcResponseBuilder builder(buf, command);
-#ifdef USE_IMPROV_SERIAL_NEXT_URL
+#ifdef USE_IMPROV_NEXT_URL
   this->add_next_url_(builder, MAX_NEXT_URL_LEN);
 #endif
 #ifdef USE_WEBSERVER
diff --git a/esphome/components/improv_serial/improv_serial_component.h b/esphome/components/improv_serial/improv_serial_component.h
index 68cdd752149..c7d89c76d6b 100644
--- a/esphome/components/improv_serial/improv_serial_component.h
+++ b/esphome/components/improv_serial/improv_serial_component.h
@@ -55,7 +55,7 @@ static const uint8_t IMPROV_SERIAL_VERSION = 1;
 #ifdef USE_WIFI
 // Wi-Fi connect failure timers: a fresh provision reports at 30 s (stock behavior), while
 // switching networks on an already-connected device (disconnect + reconnect) can legitimately
-// take longer; 90 s matches esp32_improv's default wifi_timeout.
+// take longer; 90 s matches improv_ble's default wifi_timeout.
 static const uint32_t WIFI_CONNECT_TIMEOUT_MS = 30000;
 static const uint32_t WIFI_SWITCH_TIMEOUT_MS = 90000;
 #endif
diff --git a/esphome/components/internal_temperature/internal_temperature.h b/esphome/components/internal_temperature/internal_temperature.h
index 90831cf211d..6a9889ef29c 100644
--- a/esphome/components/internal_temperature/internal_temperature.h
+++ b/esphome/components/internal_temperature/internal_temperature.h
@@ -13,6 +13,9 @@ namespace esphome::internal_temperature {
 
 class InternalTemperatureSensor final : public sensor::Sensor, public PollingComponent {
  public:
+  // User provided, not "= default": `new(p) InternalTemperatureSensor()` would zero-fill .bss that is already zero.
+  InternalTemperatureSensor() {}
+
 #if defined(USE_ESP32) || (defined(USE_ZEPHYR) && defined(USE_NRF52))
   void setup() override;
 #endif  // USE_ESP32 || (USE_ZEPHYR && USE_NRF52)
diff --git a/esphome/components/it8951/it8951.cpp b/esphome/components/it8951/it8951.cpp
index 179c2e5f63d..237f1c3c8bd 100644
--- a/esphome/components/it8951/it8951.cpp
+++ b/esphome/components/it8951/it8951.cpp
@@ -855,7 +855,7 @@ void IT8951Display::apply_transform_(int &x, int &y) const {
 }
 
 bool IT8951Display::rotate_coordinates_(int &x, int &y) {
-  if (!this->get_clipping().inside(x, y))
+  if (this->is_point_clipped(x, y))
     return false;
   this->apply_transform_(x, y);
   if (x >= this->width_ || y >= this->height_ || x < 0 || y < 0)
@@ -929,7 +929,7 @@ void IT8951Display::fill(Color color) {
 void HOT IT8951Display::draw_pixel_at(int x, int y, Color color) {
   if (this->buffer_ == nullptr)
     return;
-  App.feed_wdt();
+  this->feed_wdt_per_pixel_();
   if (!this->rotate_coordinates_(x, y))
     return;
   this->write_pixel_native_(static_cast<uint16_t>(x), static_cast<uint16_t>(y), color);
diff --git a/esphome/components/json/json_util.cpp b/esphome/components/json/json_util.cpp
index 984134b95f9..1b1eefe59b3 100644
--- a/esphome/components/json/json_util.cpp
+++ b/esphome/components/json/json_util.cpp
@@ -66,6 +66,8 @@ JsonDocument parse_json(const uint8_t *data, size_t len) {
   // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks,clang-analyzer-core.StackAddressEscape)
 }
 
+JsonBuilder::JsonBuilder() = default;
+
 SerializationBuffer<> JsonBuilder::serialize() {
   // ===========================================================================================
   // CRITICAL: NRVO (Named Return Value Optimization) - DO NOT REFACTOR WITHOUT UNDERSTANDING
diff --git a/esphome/components/json/json_util.h b/esphome/components/json/json_util.h
index 9f51d9927b8..130e1503321 100644
--- a/esphome/components/json/json_util.h
+++ b/esphome/components/json/json_util.h
@@ -168,6 +168,9 @@ inline JsonDocument parse_json(const std::string &data) {
 /// Builder class for creating JSON documents without lambdas
 class JsonBuilder {
  public:
+  // Out of line: inlining the JsonDocument constructor duplicates it at every call site
+  JsonBuilder();
+
   JsonObject root() {
     if (!root_created_) {
       root_ = doc_.to<JsonObject>();
diff --git a/esphome/components/lc709203f/lc709203f.cpp b/esphome/components/lc709203f/lc709203f.cpp
index a5dda6ca437..36e5bce8e3c 100644
--- a/esphome/components/lc709203f/lc709203f.cpp
+++ b/esphome/components/lc709203f/lc709203f.cpp
@@ -275,8 +275,4 @@ void Lc709203f::set_pack_size(uint16_t pack_size) {
   //  not cause an error or crash, so I am not doing any additional checking here.
 }
 
-void Lc709203f::set_thermistor_b_constant(uint16_t b_constant) { this->b_constant_ = b_constant; }
-
-void Lc709203f::set_pack_voltage(LC709203FBatteryVoltage pack_voltage) { this->pack_voltage_ = pack_voltage; }
-
 }  // namespace esphome::lc709203f
diff --git a/esphome/components/lc709203f/lc709203f.h b/esphome/components/lc709203f/lc709203f.h
index 46f773873af..e9c60e285f5 100644
--- a/esphome/components/lc709203f/lc709203f.h
+++ b/esphome/components/lc709203f/lc709203f.h
@@ -26,8 +26,8 @@ class Lc709203f final : public sensor::Sensor, public PollingComponent, public i
   void dump_config() override;
 
   void set_pack_size(uint16_t pack_size);
-  void set_thermistor_b_constant(uint16_t b_constant);
-  void set_pack_voltage(LC709203FBatteryVoltage pack_voltage);
+  void set_thermistor_b_constant(uint16_t b_constant) { this->b_constant_ = b_constant; }
+  void set_pack_voltage(LC709203FBatteryVoltage pack_voltage) { this->pack_voltage_ = pack_voltage; }
   void set_voltage_sensor(sensor::Sensor *voltage_sensor) { voltage_sensor_ = voltage_sensor; }
   void set_battery_remaining_sensor(sensor::Sensor *battery_remaining_sensor) {
     battery_remaining_sensor_ = battery_remaining_sensor;
diff --git a/esphome/components/ld2412/number/__init__.py b/esphome/components/ld2412/number/__init__.py
index 1a81c330adf..f27e241491d 100644
--- a/esphome/components/ld2412/number/__init__.py
+++ b/esphome/components/ld2412/number/__init__.py
@@ -109,14 +109,14 @@ async def to_code(config: ConfigType) -> None:
     for x in range(14):
         if gate_conf := config.get(f"gate_{x}"):
             move_config = gate_conf[CONF_MOVE_THRESHOLD]
-            n = cg.new_Pvariable(move_config[CONF_ID], x)
+            n = cg.new_Pvariable(move_config[CONF_ID])
             await number.register_number(
                 n, move_config, min_value=0, max_value=100, step=1
             )
             await cg.register_parented(n, config[CONF_LD2412_ID])
             cg.add(LD2412_component.set_gate_move_threshold_number(x, n))
             still_config = gate_conf[CONF_STILL_THRESHOLD]
-            n = cg.new_Pvariable(still_config[CONF_ID], x)
+            n = cg.new_Pvariable(still_config[CONF_ID])
             await number.register_number(
                 n, still_config, min_value=0, max_value=100, step=1
             )
diff --git a/esphome/components/ld2412/number/gate_threshold_number.cpp b/esphome/components/ld2412/number/gate_threshold_number.cpp
index 8d12bad1151..a0a525a8107 100644
--- a/esphome/components/ld2412/number/gate_threshold_number.cpp
+++ b/esphome/components/ld2412/number/gate_threshold_number.cpp
@@ -2,8 +2,6 @@
 
 namespace esphome::ld2412 {
 
-GateThresholdNumber::GateThresholdNumber(uint8_t gate) : gate_(gate) {}
-
 void GateThresholdNumber::control(float value) {
   this->publish_state(value);
   this->parent_->set_gate_threshold();
diff --git a/esphome/components/ld2412/number/gate_threshold_number.h b/esphome/components/ld2412/number/gate_threshold_number.h
index 918b6dfad1a..308da43a34d 100644
--- a/esphome/components/ld2412/number/gate_threshold_number.h
+++ b/esphome/components/ld2412/number/gate_threshold_number.h
@@ -7,10 +7,10 @@ namespace esphome::ld2412 {
 
 class GateThresholdNumber final : public number::Number, public Parented<LD2412Component> {
  public:
-  GateThresholdNumber(uint8_t gate);
+  // Not "= default": that makes new(p) T() zero-fill the object at every codegen site before the ctor runs.
+  GateThresholdNumber() {}
 
  protected:
-  uint8_t gate_;
   void control(float value) override;
 };
 
diff --git a/esphome/components/ld2412/number/light_threshold_number.h b/esphome/components/ld2412/number/light_threshold_number.h
index f62d523af38..710b47957c1 100644
--- a/esphome/components/ld2412/number/light_threshold_number.h
+++ b/esphome/components/ld2412/number/light_threshold_number.h
@@ -7,7 +7,8 @@ namespace esphome::ld2412 {
 
 class LightThresholdNumber final : public number::Number, public Parented<LD2412Component> {
  public:
-  LightThresholdNumber() = default;
+  // User provided, not "= default": `new(p) LightThresholdNumber()` would zero-fill .bss that is already zero.
+  LightThresholdNumber() {}
 
  protected:
   void control(float value) override;
diff --git a/esphome/components/ld2412/select/baud_rate_select.h b/esphome/components/ld2412/select/baud_rate_select.h
index 46ec9be1d1e..527b1a1e934 100644
--- a/esphome/components/ld2412/select/baud_rate_select.h
+++ b/esphome/components/ld2412/select/baud_rate_select.h
@@ -7,7 +7,8 @@ namespace esphome::ld2412 {
 
 class BaudRateSelect final : public select::Select, public Parented<LD2412Component> {
  public:
-  BaudRateSelect() = default;
+  // User provided, not "= default": `new(p) BaudRateSelect()` would zero-fill .bss that is already zero.
+  BaudRateSelect() {}
 
  protected:
   void control(size_t index) override;
diff --git a/esphome/components/ld2412/select/distance_resolution_select.h b/esphome/components/ld2412/select/distance_resolution_select.h
index be8dba90b5d..d1bc15dea93 100644
--- a/esphome/components/ld2412/select/distance_resolution_select.h
+++ b/esphome/components/ld2412/select/distance_resolution_select.h
@@ -7,7 +7,8 @@ namespace esphome::ld2412 {
 
 class DistanceResolutionSelect final : public select::Select, public Parented<LD2412Component> {
  public:
-  DistanceResolutionSelect() = default;
+  // User provided, not "= default": `new(p) DistanceResolutionSelect()` would zero-fill .bss that is already zero.
+  DistanceResolutionSelect() {}
 
  protected:
   void control(size_t index) override;
diff --git a/esphome/components/ld2412/select/light_out_control_select.h b/esphome/components/ld2412/select/light_out_control_select.h
index c8988fda78e..0867f3b1c2e 100644
--- a/esphome/components/ld2412/select/light_out_control_select.h
+++ b/esphome/components/ld2412/select/light_out_control_select.h
@@ -7,7 +7,8 @@ namespace esphome::ld2412 {
 
 class LightOutControlSelect final : public select::Select, public Parented<LD2412Component> {
  public:
-  LightOutControlSelect() = default;
+  // User provided, not "= default": `new(p) LightOutControlSelect()` would zero-fill .bss that is already zero.
+  LightOutControlSelect() {}
 
  protected:
   void control(size_t index) override;
diff --git a/esphome/components/ld2412/switch/bluetooth_switch.h b/esphome/components/ld2412/switch/bluetooth_switch.h
index 8fd4a86e43c..e753613cdfa 100644
--- a/esphome/components/ld2412/switch/bluetooth_switch.h
+++ b/esphome/components/ld2412/switch/bluetooth_switch.h
@@ -7,7 +7,8 @@ namespace esphome::ld2412 {
 
 class BluetoothSwitch final : public switch_::Switch, public Parented<LD2412Component> {
  public:
-  BluetoothSwitch() = default;
+  // User provided, not "= default": `new(p) BluetoothSwitch()` would zero-fill .bss that is already zero.
+  BluetoothSwitch() {}
 
  protected:
   void write_state(bool state) override;
diff --git a/esphome/components/ld2412/switch/engineering_mode_switch.h b/esphome/components/ld2412/switch/engineering_mode_switch.h
index defeb4c76ba..279128ddbc5 100644
--- a/esphome/components/ld2412/switch/engineering_mode_switch.h
+++ b/esphome/components/ld2412/switch/engineering_mode_switch.h
@@ -7,7 +7,8 @@ namespace esphome::ld2412 {
 
 class EngineeringModeSwitch final : public switch_::Switch, public Parented<LD2412Component> {
  public:
-  EngineeringModeSwitch() = default;
+  // User provided, not "= default": `new(p) EngineeringModeSwitch()` would zero-fill .bss that is already zero.
+  EngineeringModeSwitch() {}
 
  protected:
   void write_state(bool state) override;
diff --git a/esphome/components/ld2450/button/factory_reset_button.h b/esphome/components/ld2450/button/factory_reset_button.h
index 392fc67ffdd..71dc19a6cd3 100644
--- a/esphome/components/ld2450/button/factory_reset_button.h
+++ b/esphome/components/ld2450/button/factory_reset_button.h
@@ -7,7 +7,8 @@ namespace esphome::ld2450 {
 
 class FactoryResetButton : public button::Button, public Parented<LD2450Component> {
  public:
-  FactoryResetButton() = default;
+  // User provided, not "= default": `new(p) FactoryResetButton()` would zero-fill .bss that is already zero.
+  FactoryResetButton() {}
 
  protected:
   void press_action() override;
diff --git a/esphome/components/ld2450/button/restart_button.h b/esphome/components/ld2450/button/restart_button.h
index 9219011f8ba..87b1a2bbd1e 100644
--- a/esphome/components/ld2450/button/restart_button.h
+++ b/esphome/components/ld2450/button/restart_button.h
@@ -7,7 +7,8 @@ namespace esphome::ld2450 {
 
 class RestartButton : public button::Button, public Parented<LD2450Component> {
  public:
-  RestartButton() = default;
+  // User provided, not "= default": `new(p) RestartButton()` would zero-fill .bss that is already zero.
+  RestartButton() {}
 
  protected:
   void press_action() override;
diff --git a/esphome/components/ld2450/number/presence_timeout_number.h b/esphome/components/ld2450/number/presence_timeout_number.h
index 09c8afca55b..8c44fa39dc0 100644
--- a/esphome/components/ld2450/number/presence_timeout_number.h
+++ b/esphome/components/ld2450/number/presence_timeout_number.h
@@ -7,7 +7,8 @@ namespace esphome::ld2450 {
 
 class PresenceTimeoutNumber : public number::Number, public Parented<LD2450Component> {
  public:
-  PresenceTimeoutNumber() = default;
+  // User provided, not "= default": `new(p) PresenceTimeoutNumber()` would zero-fill .bss that is already zero.
+  PresenceTimeoutNumber() {}
 
  protected:
   void control(float value) override;
diff --git a/esphome/components/ld2450/select/baud_rate_select.h b/esphome/components/ld2450/select/baud_rate_select.h
index cb531181707..af4c477dff2 100644
--- a/esphome/components/ld2450/select/baud_rate_select.h
+++ b/esphome/components/ld2450/select/baud_rate_select.h
@@ -7,7 +7,8 @@ namespace esphome::ld2450 {
 
 class BaudRateSelect : public select::Select, public Parented<LD2450Component> {
  public:
-  BaudRateSelect() = default;
+  // User provided, not "= default": `new(p) BaudRateSelect()` would zero-fill .bss that is already zero.
+  BaudRateSelect() {}
 
  protected:
   void control(size_t index) override;
diff --git a/esphome/components/ld2450/select/zone_type_select.h b/esphome/components/ld2450/select/zone_type_select.h
index 566346eb482..cf79c2324dc 100644
--- a/esphome/components/ld2450/select/zone_type_select.h
+++ b/esphome/components/ld2450/select/zone_type_select.h
@@ -7,7 +7,8 @@ namespace esphome::ld2450 {
 
 class ZoneTypeSelect : public select::Select, public Parented<LD2450Component> {
  public:
-  ZoneTypeSelect() = default;
+  // User provided, not "= default": `new(p) ZoneTypeSelect()` would zero-fill .bss that is already zero.
+  ZoneTypeSelect() {}
 
  protected:
   void control(size_t index) override;
diff --git a/esphome/components/ld2450/switch/bluetooth_switch.h b/esphome/components/ld2450/switch/bluetooth_switch.h
index 3d48a89b57f..8b118a7b8c1 100644
--- a/esphome/components/ld2450/switch/bluetooth_switch.h
+++ b/esphome/components/ld2450/switch/bluetooth_switch.h
@@ -7,7 +7,8 @@ namespace esphome::ld2450 {
 
 class BluetoothSwitch : public switch_::Switch, public Parented<LD2450Component> {
  public:
-  BluetoothSwitch() = default;
+  // User provided, not "= default": `new(p) BluetoothSwitch()` would zero-fill .bss that is already zero.
+  BluetoothSwitch() {}
 
  protected:
   void write_state(bool state) override;
diff --git a/esphome/components/ld2450/switch/multi_target_switch.h b/esphome/components/ld2450/switch/multi_target_switch.h
index 739f308cce9..d711a2d2d29 100644
--- a/esphome/components/ld2450/switch/multi_target_switch.h
+++ b/esphome/components/ld2450/switch/multi_target_switch.h
@@ -7,7 +7,8 @@ namespace esphome::ld2450 {
 
 class MultiTargetSwitch : public switch_::Switch, public Parented<LD2450Component> {
  public:
-  MultiTargetSwitch() = default;
+  // User provided, not "= default": `new(p) MultiTargetSwitch()` would zero-fill .bss that is already zero.
+  MultiTargetSwitch() {}
 
  protected:
   void write_state(bool state) override;
diff --git a/esphome/components/ld6002b/ld6002b.cpp b/esphome/components/ld6002b/ld6002b.cpp
index 73fc7df3311..aa34ad9d392 100644
--- a/esphome/components/ld6002b/ld6002b.cpp
+++ b/esphome/components/ld6002b/ld6002b.cpp
@@ -301,14 +301,10 @@ void LD6002BComponent::setup() {
       target_display_controlled = true;
       // Nothing reports this switch back, so its restored state is the only state
       // there is.  Restoring through the switch keeps its inversion in the path:
-      // the restored value is logical, and turn_on()/turn_off() are what turn it
+      // the restored value is logical, and driving the switch is what turns it
       // into the raw command, the published state and the stream flag.
       const bool state = this->target_display_switch_->get_initial_state_with_restore_mode().value_or(true);
-      if (state) {
-        this->target_display_switch_->turn_on();
-      } else {
-        this->target_display_switch_->turn_off();
-      }
+      this->target_display_switch_->control(state);
     }
 #endif
     if (!target_display_controlled) {
@@ -328,11 +324,7 @@ void LD6002BComponent::setup() {
       // The switch owns the stream, so it is also what applies the restored state:
       // driving it rather than the module keeps the entity's inversion in the path.
       const bool state = this->point_cloud_switch_->get_initial_state_with_restore_mode().value_or(false);
-      if (state) {
-        this->point_cloud_switch_->turn_on();
-      } else {
-        this->point_cloud_switch_->turn_off();
-      }
+      this->point_cloud_switch_->control(state);
     }
 #endif
     if (!point_cloud_controlled) {
@@ -375,11 +367,7 @@ void LD6002BComponent::setup() {
       // Driving the switch applies its inversion; it also marks the restored value
       // as reported, so the work mode fallback runs on that until the query lands.
       const bool state = this->low_power_switch_->get_initial_state_with_restore_mode().value_or(false);
-      if (state) {
-        this->low_power_switch_->turn_on();
-      } else {
-        this->low_power_switch_->turn_off();
-      }
+      this->low_power_switch_->control(state);
     }
 #else
     bool want_low_power = false;
diff --git a/esphome/components/max44009/max44009.cpp b/esphome/components/max44009/max44009.cpp
index 6b8bdc8de5e..731f5840563 100644
--- a/esphome/components/max44009/max44009.cpp
+++ b/esphome/components/max44009/max44009.cpp
@@ -134,6 +134,4 @@ void MAX44009Sensor::write_(uint8_t reg, uint8_t value) {
   }
 }
 
-void MAX44009Sensor::set_mode(MAX44009Mode mode) { this->mode_ = mode; }
-
 }  // namespace esphome::max44009
diff --git a/esphome/components/max44009/max44009.h b/esphome/components/max44009/max44009.h
index b62aed7a567..5eb1555350a 100644
--- a/esphome/components/max44009/max44009.h
+++ b/esphome/components/max44009/max44009.h
@@ -16,7 +16,7 @@ class MAX44009Sensor final : public sensor::Sensor, public PollingComponent, pub
   void setup() override;
   void dump_config() override;
   void update() override;
-  void set_mode(MAX44009Mode mode);
+  void set_mode(MAX44009Mode mode) { this->mode_ = mode; }
   bool set_continuous_mode();
   bool set_low_power_mode();
 
diff --git a/esphome/components/mcp4461/output/mcp4461_output.cpp b/esphome/components/mcp4461/output/mcp4461_output.cpp
index 5c373ddc7d2..d38eed4d096 100644
--- a/esphome/components/mcp4461/output/mcp4461_output.cpp
+++ b/esphome/components/mcp4461/output/mcp4461_output.cpp
@@ -38,14 +38,6 @@ float Mcp4461Wiper::update_state() {
   return this->state_;
 }
 
-void Mcp4461Wiper::set_state(bool state) {
-  if (state) {
-    this->turn_on();
-  } else {
-    this->turn_off();
-  }
-}
-
 void Mcp4461Wiper::turn_on() { this->parent_->enable_wiper_(this->wiper_); }
 
 void Mcp4461Wiper::turn_off() { this->parent_->disable_wiper_(this->wiper_); }
diff --git a/esphome/components/mcp4461/output/mcp4461_output.h b/esphome/components/mcp4461/output/mcp4461_output.h
index c8d1ef1ec51..1052369a744 100644
--- a/esphome/components/mcp4461/output/mcp4461_output.h
+++ b/esphome/components/mcp4461/output/mcp4461_output.h
@@ -13,9 +13,6 @@ class Mcp4461Wiper final : public output::FloatOutput, public Parented<Mcp4461Co
   /// @brief Set level of wiper
   /// @param[in] state - The desired float level in range 0-1.0
   void set_level(float state);
-  /// @brief Enables/Disables current output using bool parameter
-  /// @param[in] state boolean var representing desired state (true=ON, false=OFF)
-  void set_state(bool state) override;
   /// @brief Enables current output
   void turn_on() override;
   /// @brief Disables current output
diff --git a/esphome/components/mdns/__init__.py b/esphome/components/mdns/__init__.py
index c8020104b37..0fb24fdf1df 100644
--- a/esphome/components/mdns/__init__.py
+++ b/esphome/components/mdns/__init__.py
@@ -5,6 +5,8 @@ import esphome.config_validation as cv
 from esphome.const import (
     CONF_DISABLED,
     CONF_ID,
+    CONF_MDNS,
+    CONF_OPENTHREAD,
     CONF_PORT,
     CONF_PROTOCOL,
     CONF_SERVICE,
@@ -184,6 +186,28 @@ def enable_mdns_storage() -> None:
     cg.add_define("USE_MDNS_STORE_SERVICES")
 
 
+def request_service_enable_disable() -> bool:
+    """Request MDNSComponent::set_service_enabled() support.
+
+    ESP32 only, not with OpenThread. Returns True when the
+    USE_MDNS_SUPPORTS_ENABLE_DISABLE define was added; guard C++ usage with it.
+
+    Public API for external components. Do not remove.
+    """
+    mdns_config = CORE.config.get(CONF_MDNS)
+    if (
+        mdns_config is None
+        or mdns_config[CONF_DISABLED]
+        or not CORE.is_esp32
+        or CONF_OPENTHREAD in CORE.config
+    ):
+        return False
+    cg.add_define("USE_MDNS_SUPPORTS_ENABLE_DISABLE")
+    # Services must stay stored so a disabled service can be re-registered
+    enable_mdns_storage()
+    return True
+
+
 @coroutine_with_priority(CoroPriority.NETWORK_SERVICES)
 async def to_code(config: ConfigType) -> None:
     if config[CONF_DISABLED] is True:
diff --git a/esphome/components/mdns/mdns_component.cpp b/esphome/components/mdns/mdns_component.cpp
index fa39e86ed0d..9d1e5853391 100644
--- a/esphome/components/mdns/mdns_component.cpp
+++ b/esphome/components/mdns/mdns_component.cpp
@@ -221,6 +221,10 @@ void MDNSComponent::compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUN
   sendspin_service.proto = MDNS_STR(SERVICE_TCP);
   sendspin_service.port = []() -> uint16_t { return USE_SENDSPIN_PORT; };
   sendspin_service.txt_records = {{MDNS_STR(TXT_SENDSPIN_PATH), MDNS_STR(VALUE_SENDSPIN_PATH)}};
+#ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
+  // Starts disabled; the sendspin hub enables it once its server is running
+  sendspin_service.enabled = false;
+#endif
 #endif
 
 #ifdef USE_WEBSERVER
diff --git a/esphome/components/mdns/mdns_component.h b/esphome/components/mdns/mdns_component.h
index 4f97e8cb996..ed06b8e1330 100644
--- a/esphome/components/mdns/mdns_component.h
+++ b/esphome/components/mdns/mdns_component.h
@@ -63,6 +63,9 @@ struct MDNSService {
   const MDNSString *proto;
   TemplatableFn<uint16_t> port;
   FixedVector<MDNSTXTRecord> txt_records;
+#ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
+  bool enabled{true};
+#endif
 };
 
 class MDNSComponent final : public Component
@@ -112,6 +115,19 @@ class MDNSComponent final : public Component
   const StaticVector<MDNSService, MDNS_SERVICE_COUNT> &get_services() const { return this->services_; }
 #endif
 
+#ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
+#ifndef USE_MDNS_STORE_SERVICES
+#error "USE_MDNS_SUPPORTS_ENABLE_DISABLE requires USE_MDNS_STORE_SERVICES"
+#endif
+#ifdef USE_OPENTHREAD
+#error "USE_MDNS_SUPPORTS_ENABLE_DISABLE is not supported with OpenThread"
+#endif
+  /// Enable or disable a compiled-in service, matched by type and proto (e.g. "_sendspin", "_tcp").
+  /// Only valid once this component is ready. Re-enabling re-reads the port but keeps the boot-time TXT values.
+  /// Returns true if the service is in the requested state afterwards. Blocks briefly on the mDNS task.
+  bool set_service_enabled(const char *service_type, const char *proto, bool enabled);
+#endif
+
   void on_shutdown() override;
 
 #ifdef USE_MDNS_DYNAMIC_TXT
diff --git a/esphome/components/mdns/mdns_esp32.cpp b/esphome/components/mdns/mdns_esp32.cpp
index 17000a2bd76..48df61326e2 100644
--- a/esphome/components/mdns/mdns_esp32.cpp
+++ b/esphome/components/mdns/mdns_esp32.cpp
@@ -2,6 +2,7 @@
 #if defined(USE_ESP32) && defined(USE_MDNS)
 
 #include <mdns.h>
+#include <cstring>
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
@@ -11,6 +12,23 @@ namespace esphome::mdns {
 
 static const char *const TAG = "mdns";
 
+#ifndef USE_OPENTHREAD
+static esp_err_t add_service(const MDNSService &service) {
+  // Stack buffer for up to 16 txt records, heap fallback for more
+  SmallBufferWithHeapFallback<16, mdns_txt_item_t> txt_records(service.txt_records.size());
+  for (size_t i = 0; i < service.txt_records.size(); i++) {
+    const auto &record = service.txt_records[i];
+    // key and value are either compile-time string literals in flash or pointers to dynamic_txt_values_
+    // Both remain valid for the lifetime of this function, and ESP-IDF makes internal copies
+    txt_records.get()[i].key = MDNS_STR_ARG(record.key);
+    txt_records.get()[i].value = MDNS_STR_ARG(record.value);
+  }
+  uint16_t port = service.port.value();
+  return mdns_service_add(nullptr, MDNS_STR_ARG(service.service_type), MDNS_STR_ARG(service.proto), port,
+                          txt_records.get(), service.txt_records.size());
+}
+#endif
+
 static void register_esp32(MDNSComponent *comp, StaticVector<MDNSService, MDNS_SERVICE_COUNT> &services) {
 #ifdef USE_OPENTHREAD
   // OpenThread handles service registration via SRP client
@@ -27,27 +45,50 @@ static void register_esp32(MDNSComponent *comp, StaticVector<MDNSService, MDNS_S
   mdns_hostname_set(hostname);
   mdns_instance_name_set(hostname);
 
-  for (const auto &service : services) {
-    // Stack buffer for up to 16 txt records, heap fallback for more
-    SmallBufferWithHeapFallback<16, mdns_txt_item_t> txt_records(service.txt_records.size());
-    for (size_t i = 0; i < service.txt_records.size(); i++) {
-      const auto &record = service.txt_records[i];
-      // key and value are either compile-time string literals in flash or pointers to dynamic_txt_values_
-      // Both remain valid for the lifetime of this function, and ESP-IDF makes internal copies
-      txt_records.get()[i].key = MDNS_STR_ARG(record.key);
-      txt_records.get()[i].value = MDNS_STR_ARG(record.value);
-    }
-    uint16_t port = service.port.value();
-    err = mdns_service_add(nullptr, MDNS_STR_ARG(service.service_type), MDNS_STR_ARG(service.proto), port,
-                           txt_records.get(), service.txt_records.size());
-
+  for (auto &service : services) {
+#ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
+    if (!service.enabled)
+      continue;
+#endif
+    err = add_service(service);
     if (err != ESP_OK) {
       ESP_LOGW(TAG, "Failed to register service %s: %s", MDNS_STR_ARG(service.service_type), esp_err_to_name(err));
+#ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
+      // Let a later enable call retry
+      service.enabled = false;
+#endif
     }
   }
 #endif
 }
 
+#if defined(USE_MDNS_SUPPORTS_ENABLE_DISABLE) && !defined(USE_OPENTHREAD)
+bool MDNSComponent::set_service_enabled(const char *service_type, const char *proto, bool enabled) {
+  // services_ is compiled in setup()
+  if (!this->is_ready()) {
+    ESP_LOGW(TAG, "Cannot %s service %s before setup", enabled ? "enable" : "disable", service_type);
+    return false;
+  }
+  for (auto &service : this->services_) {
+    if (strcmp(MDNS_STR_ARG(service.service_type), service_type) != 0 ||
+        strcmp(MDNS_STR_ARG(service.proto), proto) != 0) {
+      continue;
+    }
+    if (service.enabled == enabled)
+      return true;
+    esp_err_t err = enabled ? add_service(service) : mdns_service_remove(service_type, proto);
+    if (err != ESP_OK) {
+      ESP_LOGW(TAG, "Failed to %s service %s: %s", enabled ? "enable" : "disable", service_type, esp_err_to_name(err));
+      return false;
+    }
+    service.enabled = enabled;
+    return true;
+  }
+  ESP_LOGW(TAG, "Service %s not found", service_type);
+  return false;
+}
+#endif  // USE_MDNS_SUPPORTS_ENABLE_DISABLE && !USE_OPENTHREAD
+
 void MDNSComponent::setup() { this->setup_buffers_and_register_(register_esp32); }
 
 void MDNSComponent::on_shutdown() {
diff --git a/esphome/components/mipi_dsi/mipi_dsi.cpp b/esphome/components/mipi_dsi/mipi_dsi.cpp
index 0150cc25442..b6612038b6d 100644
--- a/esphome/components/mipi_dsi/mipi_dsi.cpp
+++ b/esphome/components/mipi_dsi/mipi_dsi.cpp
@@ -259,7 +259,7 @@ bool MipiDsi::check_buffer_() {
 }
 
 void MipiDsi::draw_pixel_at(int x, int y, Color color) {
-  if (!this->get_clipping().inside(x, y))
+  if (this->is_point_clipped(x, y))
     return;
 
   switch (this->rotation_) {
diff --git a/esphome/components/mipi_rgb/mipi_rgb.cpp b/esphome/components/mipi_rgb/mipi_rgb.cpp
index c11044c2882..3f83da7f803 100644
--- a/esphome/components/mipi_rgb/mipi_rgb.cpp
+++ b/esphome/components/mipi_rgb/mipi_rgb.cpp
@@ -259,7 +259,7 @@ bool MipiRgb::check_buffer_() {
 }
 
 void MipiRgb::draw_pixel_at(int x, int y, Color color) {
-  if (!this->get_clipping().inside(x, y) || this->is_failed())
+  if (this->is_point_clipped(x, y) || this->is_failed())
     return;
 
   switch (this->rotation_) {
diff --git a/esphome/components/mipi_spi/mipi_spi.h b/esphome/components/mipi_spi/mipi_spi.h
index 2552451bd7c..550e1998bb5 100644
--- a/esphome/components/mipi_spi/mipi_spi.h
+++ b/esphome/components/mipi_spi/mipi_spi.h
@@ -604,7 +604,7 @@ class MipiSpiBuffer
 
   // Draw a pixel at the given coordinates.
   void draw_pixel_at(int x, int y, Color color) override {
-    if (!this->get_clipping().inside(x, y))
+    if (this->is_point_clipped(x, y))
       return;
     if constexpr (not HAS_HARDWARE_ROTATION) {
       if (this->rotation_ == display::DISPLAY_ROTATION_180_DEGREES) {
diff --git a/esphome/components/mixer/speaker/__init__.py b/esphome/components/mixer/speaker/__init__.py
index a3746c019a0..26619f35a76 100644
--- a/esphome/components/mixer/speaker/__init__.py
+++ b/esphome/components/mixer/speaker/__init__.py
@@ -155,7 +155,7 @@ async def to_code(config: ConfigType) -> None:
         {
             cv.GenerateID(): cv.use_id(SourceSpeaker),
             cv.Required(CONF_DECIBEL_REDUCTION): cv.templatable(
-                cv.int_range(min=0, max=51)
+                cv.int_range(min=0, max=255)
             ),
             cv.Optional(CONF_DURATION, default="0.0s"): cv.templatable(
                 cv.positive_time_period_milliseconds
diff --git a/esphome/components/mixer/speaker/mixer_speaker.cpp b/esphome/components/mixer/speaker/mixer_speaker.cpp
index 7d33b6c49f8..41b7123269a 100644
--- a/esphome/components/mixer/speaker/mixer_speaker.cpp
+++ b/esphome/components/mixer/speaker/mixer_speaker.cpp
@@ -385,7 +385,8 @@ void MixerSpeaker::loop() {
   // Retries on a subsequent loop if the task is still running on the other core
   if ((event_group_bits & MIXER_TASK_STATE_STOPPED) && this->task_.deallocate()) {
     ESP_LOGD(TAG, "Stopped");
-    xEventGroupClearBits(this->event_group_, MIXER_TASK_ALL_BITS);
+    // Keep a start request that arrived while the task was stopping, otherwise it is lost for good
+    xEventGroupClearBits(this->event_group_, MIXER_TASK_ALL_BITS & ~MIXER_TASK_COMMAND_START);
     this->all_stopped_since_ms_ = 0;
   }
 
diff --git a/esphome/components/modbus/__init__.py b/esphome/components/modbus/__init__.py
index 76cfdbed706..fe937587261 100644
--- a/esphome/components/modbus/__init__.py
+++ b/esphome/components/modbus/__init__.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 import logging
 from typing import Any, Literal, NamedTuple
 
@@ -7,13 +8,7 @@ from esphome import pins
 import esphome.codegen as cg
 from esphome.components import uart
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ADDRESS,
-    CONF_CONTINUOUS,
-    CONF_DISABLE_CRC,
-    CONF_FLOW_CONTROL_PIN,
-    CONF_ID,
-)
+from esphome.const import CONF_ADDRESS, CONF_CONTINUOUS, CONF_FLOW_CONTROL_PIN, CONF_ID
 from esphome.cpp_generator import MockObj
 from esphome.cpp_helpers import gpio_pin_expression
 import esphome.final_validate as fv
@@ -48,6 +43,8 @@ ModbusServerDevice = modbus_ns.class_("ModbusServerDevice")
 CommandOptions = modbus_ns.struct("CommandOptions")
 MULTI_CONF = True
 
+CONF_ALLOW_BROADCAST_READ = "allow_broadcast_read"
+CONF_EXPECT_BROADCAST_WRITE_RESPONSE = "expect_broadcast_write_response"
 CONF_ROLE = "role"
 CONF_MODBUS_ID = "modbus_id"
 CONF_SEND_WAIT_TIME = "send_wait_time"
@@ -56,6 +53,28 @@ CONF_TURNAROUND_TIME = "turnaround_time"
 MODBUS_ROLES = ["client", "server"]
 
 
+# The write (mutating) function codes, matching modbus::helpers::is_function_code_write(). 0x17
+# (read/write multiple) is included: it mutates, so the hub treats it as a write despite its read half.
+_WRITE_FUNCTION_CODES = frozenset({0x05, 0x06, 0x0F, 0x10, 0x16, 0x17})
+
+# Codes the hub refuses at address 0; keep in sync with modbus::helpers::is_function_code_broadcastable().
+_NON_BROADCASTABLE_FUNCTION_CODES = frozenset(
+    {0x01, 0x02, 0x03, 0x04, 0x14, 0x15, 0x17, 0x18}
+)
+
+
+def is_function_code_write(function_code: int) -> bool:
+    """True if the Modbus function code writes (mutates). The exception bit (0x80) is masked off first,
+    so an exception-flagged code still classifies by its base code (the runtime hub never queues one:
+    queue_pdu() refuses them). Keep in sync with modbus::helpers::is_function_code_write()."""
+    return function_code & 0x7F in _WRITE_FUNCTION_CODES
+
+
+def is_function_code_broadcastable(function_code: int) -> bool:
+    """True if the hub accepts the function code at address 0 without allow_broadcast_read."""
+    return function_code & 0x7F not in _NON_BROADCASTABLE_FUNCTION_CODES
+
+
 class _CommandOption(NamedTuple):
     """One per-command option forwarded to the hub (modbus::CommandOptions)."""
 
@@ -64,14 +83,47 @@ class _CommandOption(NamedTuple):
     validator: Any  # the static (non-templatable) validator for the key
     cpp_type: Any  # the C++ type the value is generated as
     default: Any
+    # Function codes the hub honours the option on; it is stripped from any other.
+    applies_to: Callable[[int], bool]
+    requires_broadcast_address: bool = False
 
 
-# Per-direction command options. Single-sourcing the schema and the setter generation here keeps
-# them from drifting; the C++ side must add the matching field per the rules documented on
-# CommandOptions (modbus.h).
+def _not_write(function_code: int) -> bool:
+    return not is_function_code_write(function_code)
+
+
+def _not_broadcastable(function_code: int) -> bool:
+    return not is_function_code_broadcastable(function_code)
+
+
+# Per-direction command options, single-sourced so the schema, setters and applicability rule cannot
+# drift; the C++ side adds the matching field per the rules on CommandOptions (modbus.h).
 _COMMAND_OPTIONS: dict[str, list[_CommandOption]] = {
-    "read": [_CommandOption(CONF_CONTINUOUS, "continuous", cv.boolean, bool, False)],
-    "write": [],
+    "read": [
+        _CommandOption(
+            CONF_CONTINUOUS, "continuous", cv.boolean, bool, False, _not_write
+        ),
+        _CommandOption(
+            CONF_ALLOW_BROADCAST_READ,
+            "allow_broadcast_read",
+            cv.boolean,
+            bool,
+            False,
+            _not_broadcastable,
+            requires_broadcast_address=True,
+        ),
+    ],
+    "write": [
+        _CommandOption(
+            CONF_EXPECT_BROADCAST_WRITE_RESPONSE,
+            "expect_broadcast_write_response",
+            cv.boolean,
+            bool,
+            False,
+            is_function_code_broadcastable,
+            requires_broadcast_address=True,
+        ),
+    ],
 }
 
 
@@ -82,32 +134,75 @@ def _command_options(direction: str) -> list[_CommandOption]:
         raise ValueError(f"unknown command-options direction {direction!r}") from None
 
 
-# The write (mutating) function codes, matching modbus::helpers::is_function_code_write(). 0x17
-# (read/write multiple) is included: it mutates, so the hub treats it as a write despite its read half.
-_WRITE_FUNCTION_CODES = frozenset({0x05, 0x06, 0x0F, 0x10, 0x16, 0x17})
+def broadcast_only_option_keys() -> list[str]:
+    return [
+        option.conf_key
+        for options in _COMMAND_OPTIONS.values()
+        for option in options
+        if option.requires_broadcast_address
+    ]
 
 
-def is_function_code_write(function_code: int) -> bool:
-    """True if the Modbus function code writes (mutates). The exception bit (0x80) is masked off first,
-    so an exception-flagged code still classifies by its base code (the runtime hub never queues one:
-    queue_pdu() refuses them). Keep in sync with modbus::helpers::is_function_code_write()."""
-    return function_code & 0x7F in _WRITE_FUNCTION_CODES
+def reject_broadcast_options_for_unicast(
+    address_key: str,
+) -> Callable[[ConfigType], ConfigType]:
+    """Reject a broadcast-only option set true on a literal address other than 0."""
+
+    def validator(config: ConfigType) -> ConfigType:
+        address = config.get(address_key)
+        if not isinstance(address, int) or address == BROADCAST_ADDRESS:
+            return config
+        for key in broadcast_only_option_keys():
+            if config.get(key) is True:
+                raise cv.Invalid(
+                    f"'{key}' only applies to the broadcast address; set '{address_key}: 0' or "
+                    f"remove the option.",
+                    path=[key],
+                )
+        return config
+
+    return validator
+
+
+def reject_inapplicable_command_options(
+    pdu_key: str,
+) -> Callable[[ConfigType], ConfigType]:
+    """Reject an option set true that the hub would strip from a literal PDU's function code."""
+
+    def validator(config: ConfigType) -> ConfigType:
+        pdu = config[pdu_key]
+        if not isinstance(pdu, list):
+            return config
+        for direction in _COMMAND_OPTIONS:
+            for option in _command_options(direction):
+                if config.get(option.conf_key) is True and not option.applies_to(
+                    pdu[0]
+                ):
+                    raise cv.Invalid(
+                        f"'{option.conf_key}: true' does not apply to function code "
+                        f"0x{pdu[0]:02X}",
+                        path=[option.conf_key],
+                    )
+        return config
+
+    return validator
 
 
 def command_options_schema(
-    *, direction: Literal["read", "write"], templatable: bool = False
+    *,
+    direction: Literal["read", "write"],
+    templatable: bool = False,
+    function_code: int | None = None,
 ) -> dict[cv.Optional, Any]:
-    """Schema fragment for the per-command options a component forwards to the hub
-    (modbus::CommandOptions). Extend this into any schema that queues commands. Keys are
-    direction-specific so a schema never offers an option the hub would strip (e.g.
-    continuous on a write); the write side has no options yet. For actions (templatable=True the
-    keys also accept lambdas), register the values with register_templatable_command_options().
+    """Schema fragment for the per-command options of one direction; `function_code` (a typed
+    action's fixed code) leaves out the options that do not apply to it.
     """
     return {
         cv.Optional(option.conf_key, default=option.default): (
             cv.templatable(option.validator) if templatable else option.validator
         )
         for option in _command_options(direction)
+        if function_code is None or option.applies_to(function_code)
     }
 
 
@@ -130,6 +225,25 @@ def command_options_expression(
     )
 
 
+def add_command_options(
+    var: MockObj,
+    setter: str,
+    config: ConfigType,
+    *,
+    direction: Literal["read", "write"],
+) -> None:
+    """Emit `var.<setter>(<options>)` for a config validated with command_options_schema() of the
+    same direction, skipped when every option is at its C++ default."""
+    if all(
+        config.get(option.conf_key, option.default) == option.default
+        for option in _command_options(direction)
+    ):
+        return
+    cg.add(
+        getattr(var, setter)(command_options_expression(config, direction=direction))
+    )
+
+
 async def register_templatable_command_options(
     var: MockObj, config: ConfigType, args: TemplateArgsType, direction: str
 ) -> None:
@@ -165,10 +279,6 @@ CONFIG_SCHEMA = cv.typed_schema(
                 cv.Optional(
                     CONF_TURNAROUND_TIME, default="600ms"
                 ): cv.positive_time_period_milliseconds,
-                # Remove before 2026.10.0
-                cv.Optional(CONF_DISABLE_CRC): cv.invalid(
-                    "'disable_crc' has been removed. The parser no longer requires it — remove this option."
-                ),
             }
         )
         .extend(cv.COMPONENT_SCHEMA)
@@ -177,10 +287,6 @@ CONFIG_SCHEMA = cv.typed_schema(
             {
                 cv.GenerateID(): cv.declare_id(ModbusServer),
                 cv.Optional(CONF_FLOW_CONTROL_PIN): pins.gpio_output_pin_schema,
-                # Remove before 2026.10.0
-                cv.Optional(CONF_DISABLE_CRC): cv.invalid(
-                    "'disable_crc' has been removed. The parser no longer requires it — remove this option."
-                ),
             }
         )
         .extend(cv.COMPONENT_SCHEMA)
diff --git a/esphome/components/modbus/modbus.cpp b/esphome/components/modbus/modbus.cpp
index f428236a821..037901a8733 100644
--- a/esphome/components/modbus/modbus.cpp
+++ b/esphome/components/modbus/modbus.cpp
@@ -832,7 +832,7 @@ void ModbusClientHub::send_next_frame_() {
   }
 
   cmd->sent();
-  if (cmd->frame.address() == BROADCAST_ADDRESS) {
+  if (cmd->fire_and_forget()) {
     // A broadcast (address 0) is never answered (Modbus 4.1), so it is fire-and-forget: on_sent above
     // reports the transmission, and the entry then retires with no terminal callback instead of
     // occupying the waiting slot until the send-wait timeout expires. The turnaround delay already
@@ -1074,11 +1074,6 @@ bool ModbusClientHub::queue_pdu(uint8_t address, std::span<const uint8_t> pdu, M
     return false;
   }
 
-  if (address == BROADCAST_ADDRESS && !helpers::is_function_code_broadcastable(pdu[0])) {
-    ESP_LOGW(TAG, "Broadcast refused for function 0x%X: a broadcast (address 0) is never answered", pdu[0]);
-    return false;
-  }
-
   // Normalize the caller's options in place (the param is a by-value copy) so everything stored or
   // merged below carries effective options, never the raw request.
   // continuous is ignored for every mutating code (re-writing a value forever is never intended).
@@ -1086,6 +1081,24 @@ bool ModbusClientHub::queue_pdu(uint8_t address, std::span<const uint8_t> pdu, M
     ESP_LOGW(TAG, "continuous is ignored for a mutating function (0x%X, address %" PRIu8 ")", pdu[0], address);
     options.continuous = false;
   }
+  if (address != BROADCAST_ADDRESS) {
+    options.allow_broadcast_read = false;
+    options.expect_broadcast_write_response = false;
+  } else {
+    const bool broadcastable = helpers::is_function_code_broadcastable(pdu[0]);
+    if (options.allow_broadcast_read && broadcastable) {
+      ESP_LOGV(TAG, "allow_broadcast_read is ignored for function 0x%X: it is broadcastable", pdu[0]);
+      options.allow_broadcast_read = false;
+    }
+    if (options.expect_broadcast_write_response && !broadcastable) {
+      ESP_LOGV(TAG, "expect_broadcast_write_response is ignored for function 0x%X: it is not broadcastable", pdu[0]);
+      options.expect_broadcast_write_response = false;
+    }
+    if (!broadcastable && !options.allow_broadcast_read) {
+      ESP_LOGW(TAG, "Broadcast refused for function 0x%X: a broadcast (address 0) is never answered", pdu[0]);
+      return false;
+    }
+  }
 
   // A duplicate of a live entry with the same owner is not queued twice; it resolves against that
   // entry: anonymous -> dropped; continuous incoming -> convert the entry to a poll; one-shot onto a
@@ -1126,6 +1139,7 @@ bool ModbusClientHub::queue_pdu(uint8_t address, std::span<const uint8_t> pdu, M
       ESP_LOGV(TAG, "Frame already active for %" PRIu8 ", request absorbed (pending %" PRIu8 ")", address,
                item.pending);
     }
+    item.options.expect_broadcast_write_response |= options.expect_broadcast_write_response;
     return true;
   }
 
diff --git a/esphome/components/modbus/modbus.h b/esphome/components/modbus/modbus.h
index 7d7818239d5..298cd9f5278 100644
--- a/esphome/components/modbus/modbus.h
+++ b/esphome/components/modbus/modbus.h
@@ -111,11 +111,15 @@ enum class FrameState : uint8_t {
 // Per-command send options. Append-only; pass via designated initializers ({.continuous = true}).
 // A new field reaches the queue with no plumbing but arrives inert until it defines three rules:
 // normalization in queue_pdu(), a merge rule for duplicate absorption, and teardown in
-// retire()/silent_retire().
+// retire()/silent_retire(). Bit-packed: stored per entry, controller and writer entity, passed by value.
 struct CommandOptions {
   // A continuous poll lives in the queue until cancelled or failed; ignored for mutating codes.
-  bool continuous{false};
+  bool continuous : 1 {false};
+  // Wait for the reply to a read sent to address 0, for a device that answers the broadcast address.
+  bool allow_broadcast_read : 1 {false};
+  bool expect_broadcast_write_response : 1 {false};
 };
+static_assert(sizeof(CommandOptions) == 1, "CommandOptions must stay one byte");
 
 struct ModbusDeviceCommand {
   ModbusClientDevice *device;
@@ -158,6 +162,10 @@ struct ModbusDeviceCommand {
     this->pending = 0;
     this->device = nullptr;
   }
+  bool fire_and_forget() const {
+    return this->frame.address() == BROADCAST_ADDRESS && !this->options.allow_broadcast_read &&
+           !this->options.expect_broadcast_write_response;
+  }
   // Fire-and-forget completion for a broadcast (address 0): the frame was transmitted (on_sent already
   // fired), but a broadcast is never answered (Modbus 4.1), so the entry retires with no terminal callback.
   void complete_broadcast() {
@@ -191,7 +199,8 @@ struct ModbusDeviceCommand {
     } else if (!this->waiting_state()) {  // an already-retired shell stays put; off the wire -> RETIRED
       this->state = FrameState::RETIRED;
     }
-    this->options = {};  // reset every option
+    // Only continuous ends with the clear; the delivery flags must survive for a granted retry.
+    this->options.continuous = false;
   }
 
   // True while the entry is still waiting for a response
@@ -243,14 +252,6 @@ class ModbusClientHub : public Modbus {
   void set_turnaround_time(uint16_t time_in_ms) { this->turnaround_delay_us_ = time_in_ms * 1000UL; }
   bool tx_buffer_empty();
   bool tx_blocked() override;
-  ESPDEPRECATED("Use queue_pdu() with create_client_pdu() instead. Removed in 2026.10.0", "2026.4.0")
-  void send(uint8_t address, uint8_t function_code, uint16_t start_address, uint16_t number_of_entities,
-            uint8_t payload_len = 0, const uint8_t *payload = nullptr, ModbusClientDevice *device = nullptr) {
-    this->queue_pdu(address,
-                    helpers::create_client_pdu((FunctionCode) function_code, start_address, number_of_entities, payload,
-                                               payload_len),
-                    device);
-  };
   /// Queue a request. True = accepted: it resolves in exactly one terminal callback (a broadcast,
   /// address 0, gets only on_sent()). False = refused, and no callback of any kind follows.
   /// Neither means anything reached the wire - on_sent() reports that.
@@ -534,27 +535,27 @@ class ModbusClientDevice {
     return this->queue_pdu(
         helpers::create_read_pdu(FunctionCode::READ_DISCRETE_INPUTS, start_address, number_of_inputs), options);
   }
-  bool write_single_register(uint16_t start_address, uint16_t value) {
-    return this->queue_pdu(helpers::create_write_single_register_pdu(start_address, value));
+  bool write_single_register(uint16_t start_address, uint16_t value, CommandOptions options = {}) {
+    return this->queue_pdu(helpers::create_write_single_register_pdu(start_address, value), options);
   }
-  bool write_single_coil(uint16_t address, bool value) {
-    return this->queue_pdu(helpers::create_write_single_coil_pdu(address, value));
+  bool write_single_coil(uint16_t address, bool value, CommandOptions options = {}) {
+    return this->queue_pdu(helpers::create_write_single_coil_pdu(address, value), options);
   }
-  bool write_multiple_registers(uint16_t start_address, std::span<const uint16_t> values) {
+  bool write_multiple_registers(uint16_t start_address, std::span<const uint16_t> values, CommandOptions options = {}) {
     // Empty goes to the full-size builder so the rejection log names this method's limit, not the small one's.
     if (!values.empty() && values.size() <= helpers::MAX_FEW_REGISTERS)
-      return this->queue_pdu(helpers::create_write_few_registers_pdu(start_address, values));
-    return this->queue_pdu(helpers::create_write_registers_pdu(start_address, values));
+      return this->queue_pdu(helpers::create_write_few_registers_pdu(start_address, values), options);
+    return this->queue_pdu(helpers::create_write_registers_pdu(start_address, values), options);
   }
   /// Note: std::vector<bool> cannot bind to std::span<const bool>; use a contiguous bool container or the packed
   /// overload.
-  bool write_multiple_coils(uint16_t start_address, std::span<const bool> values) {
-    return this->queue_pdu(helpers::create_write_coils_pdu(start_address, values));
+  bool write_multiple_coils(uint16_t start_address, std::span<const bool> values, CommandOptions options = {}) {
+    return this->queue_pdu(helpers::create_write_coils_pdu(start_address, values), options);
   }
   /// Packed variant: a PackedBits view (the same layout on_read_coils() delivers), so
   /// read-modify-write needs no unpack/repack.
-  bool write_multiple_coils(uint16_t start_address, PackedBits bits) {
-    return this->queue_pdu(helpers::create_write_coils_pdu(start_address, bits));
+  bool write_multiple_coils(uint16_t start_address, PackedBits bits, CommandOptions options = {}) {
+    return this->queue_pdu(helpers::create_write_coils_pdu(start_address, bits), options);
   }
   /// FC 0x17: the read-back is delivered through on_read_holding_registers(), and a device exception
   /// (typically a rejected write half) arrives there too via its status - one callback handles both
diff --git a/esphome/components/modbus_client/__init__.py b/esphome/components/modbus_client/__init__.py
index a59eb910664..66ddcd7722d 100644
--- a/esphome/components/modbus_client/__init__.py
+++ b/esphome/components/modbus_client/__init__.py
@@ -7,7 +7,6 @@ from esphome.components import modbus
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ADDRESS,
-    CONF_CONTINUOUS,
     CONF_COUNT,
     CONF_ID,
     CONF_ON_ERROR,
@@ -158,24 +157,6 @@ _ACTION_BASE_SCHEMA = cv.Schema(
 )
 
 
-def _no_continuous_on_write(config: ConfigType) -> ConfigType:
-    """Reject `continuous: true` on a static write PDU: continuous polling only applies to reads.
-    Only the fully-static case is decidable here; the hub strips the flag from mutating PDUs at
-    runtime, so a templated pdu or continuous falls through to that backstop."""
-    pdu = config[CONF_PDU]
-    if (
-        isinstance(pdu, list)
-        and config.get(CONF_CONTINUOUS) is True
-        and modbus.is_function_code_write(pdu[0])
-    ):
-        raise cv.Invalid(
-            f"'{CONF_CONTINUOUS}: true' does not apply to a write PDU (function code "
-            f"0x{pdu[0]:02X}); continuous polling only applies to reads",
-            path=[CONF_CONTINUOUS],
-        )
-    return config
-
-
 MODBUS_CLIENT_SEND_SCHEMA = cv.All(
     _ACTION_BASE_SCHEMA.extend(
         {
@@ -186,10 +167,12 @@ MODBUS_CLIENT_SEND_SCHEMA = cv.All(
                 )
             ),
             **modbus.command_options_schema(direction="read", templatable=True),
+            **modbus.command_options_schema(direction="write", templatable=True),
             cv.Optional(CONF_ON_RESPONSE): _handler_schema(),
         }
     ),
-    _no_continuous_on_write,
+    modbus.reject_inapplicable_command_options(CONF_PDU),
+    modbus.reject_broadcast_options_for_unicast(CONF_ADDRESS),
 )
 
 
@@ -261,8 +244,7 @@ async def register_client_action(
             var.get_not_sent_trigger(), [(_PDU_SPAN, "request")], not_sent_conf
         )
     # Wire any command options the action's schema opted into (e.g. continuous on reads). Pass the
-    # matching direction so a write action never generates a read option's setter; the write side
-    # has no options yet, so this is a no-op there.
+    # matching direction so a write action never generates a read option's setter.
     await modbus.register_templatable_command_options(
         var, config, args, command_direction
     )
@@ -279,6 +261,8 @@ async def modbus_client_send_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     template_ = await cg.templatable(config[CONF_PDU], args, _PDU_BUFFER)
     cg.add(var.set_pdu(template_))
+    # The read set is wired by register_client_action() below.
+    await modbus.register_templatable_command_options(var, config, args, "write")
     return await register_client_action(
         var,
         config,
@@ -353,6 +337,7 @@ def _read_schema(max_count: int) -> cv.All:
             }
         ),
         _no_address_overflow(CONF_COUNT),
+        modbus.reject_broadcast_options_for_unicast(CONF_ADDRESS),
     )
 
 
@@ -364,21 +349,35 @@ def _write_multiple_schema(item: Callable[[Any], Any], max_values: int) -> cv.Al
                 cv.Required(CONF_VALUES): cv.templatable(
                     cv.All(cv.ensure_list(item), cv.Length(min=1, max=max_values))
                 ),
+                **modbus.command_options_schema(direction="write", templatable=True),
             }
         ),
         _no_address_overflow(CONF_VALUES),
+        modbus.reject_broadcast_options_for_unicast(CONF_ADDRESS),
     )
 
 
 _READ_REGISTERS_SCHEMA = _read_schema(modbus.MAX_NUM_OF_REGISTERS_TO_READ)
 
-_WRITE_SINGLE_REGISTER_SCHEMA = _TYPED_ACTION_SCHEMA.extend(
-    {cv.Required(CONF_VALUE): cv.templatable(cv.hex_uint16_t)}
+_WRITE_SINGLE_REGISTER_SCHEMA = cv.All(
+    _TYPED_ACTION_SCHEMA.extend(
+        {
+            cv.Required(CONF_VALUE): cv.templatable(cv.hex_uint16_t),
+            **modbus.command_options_schema(direction="write", templatable=True),
+        }
+    ),
+    modbus.reject_broadcast_options_for_unicast(CONF_ADDRESS),
 )
 
 # A coil is one bit, so the value is a boolean - the wire only carries 0x0000 or 0xFF00.
-_WRITE_SINGLE_COIL_SCHEMA = _TYPED_ACTION_SCHEMA.extend(
-    {cv.Required(CONF_VALUE): cv.templatable(cv.boolean)}
+_WRITE_SINGLE_COIL_SCHEMA = cv.All(
+    _TYPED_ACTION_SCHEMA.extend(
+        {
+            cv.Required(CONF_VALUE): cv.templatable(cv.boolean),
+            **modbus.command_options_schema(direction="write", templatable=True),
+        }
+    ),
+    modbus.reject_broadcast_options_for_unicast(CONF_ADDRESS),
 )
 
 
@@ -542,10 +541,15 @@ _READ_WRITE_MULTIPLE_REGISTERS_SCHEMA = cv.All(
                     cv.Length(min=1, max=modbus.MAX_NUM_OF_REGISTERS_TO_WRITE_RW),
                 )
             ),
+            # 0x17 counts as a read at address 0, so it takes allow_broadcast_read only.
+            **modbus.command_options_schema(
+                direction="read", templatable=True, function_code=0x17
+            ),
         }
     ),
     _no_address_overflow(CONF_READ_COUNT, CONF_READ_ADDRESS),
     _no_address_overflow(CONF_VALUES, CONF_WRITE_ADDRESS),
+    modbus.reject_broadcast_options_for_unicast(CONF_ADDRESS),
 )
 
 
diff --git a/esphome/components/modbus_client/modbus_client.h b/esphome/components/modbus_client/modbus_client.h
index 03744239a9b..4c1d11da838 100644
--- a/esphome/components/modbus_client/modbus_client.h
+++ b/esphome/components/modbus_client/modbus_client.h
@@ -85,18 +85,36 @@ template<typename... Ts> class ClientActionBase : public Action<Ts...>, public m
 /// builds its static struct; declaring the values here instead of per action means a new read option
 /// costs one TEMPLATABLE_VALUE plus one field below, and every read action picks it up.
 /// The read/write split mirrors _COMMAND_OPTIONS in the modbus component's Python
-/// (command_options_schema(direction="read") adds exactly these keys). When a write-side option
-/// arrives it gets a WriteCommandOptions twin, so write actions never carry read-only members.
+/// (command_options_schema(direction="read") adds exactly these keys); WriteCommandOptions is the twin.
 template<typename... Ts> class ReadCommandOptions {
  public:
   // Poll: re-queue after each success until downgraded (replay with false) or failed. The hub strips
   // it for mutating function codes at the door (see modbus::CommandOptions).
   TEMPLATABLE_VALUE(bool, continuous)
+  TEMPLATABLE_VALUE(bool, allow_broadcast_read)
 
  protected:
   /// The options for this send, with every templatable value resolved against the action's arguments.
   modbus::CommandOptions command_options_(const Ts &...x) const {
-    return {.continuous = this->continuous_.value(x...)};
+    return {.continuous = this->continuous_.value(x...),
+            .allow_broadcast_read = this->allow_broadcast_read_.value(x...)};
+  }
+};
+
+/// The write-side per-command options (command_options_schema(direction="write") adds exactly these keys).
+template<typename... Ts> class WriteCommandOptions {
+ public:
+  TEMPLATABLE_VALUE(bool, expect_broadcast_write_response)
+
+ protected:
+  /// Resolves every write option into `options`, so send's merge of both sets stays exhaustive.
+  void apply_write_command_options_(modbus::CommandOptions &options, const Ts &...x) const {
+    options.expect_broadcast_write_response = this->expect_broadcast_write_response_.value(x...);
+  }
+  modbus::CommandOptions write_command_options_(const Ts &...x) const {
+    modbus::CommandOptions options{};
+    this->apply_write_command_options_(options, x...);
+    return options;
   }
 };
 
@@ -107,8 +125,11 @@ template<typename... Ts> class ReadCommandOptions {
 /// modbus::helpers::create_*_pdu() builders and return it directly (smaller builder results convert).
 /// A PduBuffer drops bytes past modbus::MAX_PDU_SIZE without reporting it (the hub's oversize check
 /// cannot fire - that limit is the capacity), so an over-long lambda-built PDU is silently truncated.
+/// A raw PDU may be a read or a write, so this action carries both option sets.
 template<typename... Ts>
-class ModbusClientSendAction : public ClientActionBase<Ts...>, public ReadCommandOptions<Ts...> {
+class ModbusClientSendAction : public ClientActionBase<Ts...>,
+                               public ReadCommandOptions<Ts...>,
+                               public WriteCommandOptions<Ts...> {
  public:
   TEMPLATABLE_VALUE(modbus::helpers::PduBuffer, pdu)
 
@@ -116,7 +137,11 @@ class ModbusClientSendAction : public ClientActionBase<Ts...>, public ReadComman
     return &this->response_trigger_;
   }
 
-  void play(const Ts &...x) override { this->send_or_resolve_(this->pdu_.value(x...), this->command_options_(x...)); }
+  void play(const Ts &...x) override {
+    modbus::CommandOptions options = this->command_options_(x...);
+    this->apply_write_command_options_(options, x...);
+    this->send_or_resolve_(this->pdu_.value(x...), options);
+  }
 
   void on_response(std::span<const uint8_t> request_pdu, std::span<const uint8_t> response_pdu) override {
     this->response_trigger_.trigger(request_pdu, response_pdu);
@@ -218,7 +243,8 @@ template<typename... Ts> class ReadBitsAction : public TypedClientActionBase<Ts.
 
 /// modbus_client.write_single_register: on_response is the acknowledgement (the ack only echoes the
 /// request, so it carries no arguments).
-template<typename... Ts> class WriteSingleRegisterAction : public TypedClientActionBase<Ts...> {
+template<typename... Ts>
+class WriteSingleRegisterAction : public TypedClientActionBase<Ts...>, public WriteCommandOptions<Ts...> {
  public:
   TEMPLATABLE_VALUE(uint16_t, start_address)
   TEMPLATABLE_VALUE(uint16_t, value)
@@ -227,7 +253,8 @@ template<typename... Ts> class WriteSingleRegisterAction : public TypedClientAct
 
   void play(const Ts &...x) override {
     this->send_or_resolve_(
-        modbus::helpers::create_write_single_register_pdu(this->start_address_.value(x...), this->value_.value(x...)));
+        modbus::helpers::create_write_single_register_pdu(this->start_address_.value(x...), this->value_.value(x...)),
+        this->write_command_options_(x...));
   }
   void on_write_single_register(uint16_t address, uint16_t value, modbus::ResponseStatus status) override {
     if (modbus::succeeded(status))
@@ -240,7 +267,8 @@ template<typename... Ts> class WriteSingleRegisterAction : public TypedClientAct
 
 /// modbus_client.write_single_coil: on_response is the acknowledgement (no arguments). A coil holds one
 /// bit, so the value is a bool - the wire only ever carries 0x0000 or 0xFF00.
-template<typename... Ts> class WriteSingleCoilAction : public TypedClientActionBase<Ts...> {
+template<typename... Ts>
+class WriteSingleCoilAction : public TypedClientActionBase<Ts...>, public WriteCommandOptions<Ts...> {
  public:
   TEMPLATABLE_VALUE(uint16_t, start_address)
   TEMPLATABLE_VALUE(bool, value)
@@ -249,7 +277,8 @@ template<typename... Ts> class WriteSingleCoilAction : public TypedClientActionB
 
   void play(const Ts &...x) override {
     this->send_or_resolve_(
-        modbus::helpers::create_write_single_coil_pdu(this->start_address_.value(x...), this->value_.value(x...)));
+        modbus::helpers::create_write_single_coil_pdu(this->start_address_.value(x...), this->value_.value(x...)),
+        this->write_command_options_(x...));
   }
   void on_write_single_coil(uint16_t address, bool value, modbus::ResponseStatus status) override {
     if (modbus::succeeded(status))
@@ -264,7 +293,8 @@ template<typename... Ts> class WriteSingleCoilAction : public TypedClientActionB
 /// A `values:` list is emitted as a flash array and sent straight from there; only a lambda builds a
 /// vector, and only when it runs. Same split as canbus's send action, and for the same reason: a static
 /// list must not allocate on every play().
-template<typename... Ts> class WriteMultipleRegistersAction : public TypedClientActionBase<Ts...> {
+template<typename... Ts>
+class WriteMultipleRegistersAction : public TypedClientActionBase<Ts...>, public WriteCommandOptions<Ts...> {
  public:
   TEMPLATABLE_VALUE(uint16_t, start_address)
 
@@ -288,11 +318,13 @@ template<typename... Ts> class WriteMultipleRegistersAction : public TypedClient
     // the empty PDU then resolves via on_not_sent like any refused send.
     if (this->len_ >= 0) {
       this->send_or_resolve_(modbus::helpers::create_write_registers_pdu(
-          start, std::span<const uint16_t>(this->values_.data, static_cast<size_t>(this->len_))));
+                                 start, std::span<const uint16_t>(this->values_.data, static_cast<size_t>(this->len_))),
+                             this->write_command_options_(x...));
       return;
     }
     const std::vector<uint16_t> values = this->values_.func(x...);
-    this->send_or_resolve_(modbus::helpers::create_write_registers_pdu(start, std::span<const uint16_t>(values)));
+    this->send_or_resolve_(modbus::helpers::create_write_registers_pdu(start, std::span<const uint16_t>(values)),
+                           this->write_command_options_(x...));
   }
   void on_write_multiple_registers(uint16_t start_address, std::span<const uint16_t> registers,
                                    modbus::ResponseStatus status) override {
@@ -313,7 +345,8 @@ template<typename... Ts> class WriteMultipleRegistersAction : public TypedClient
 /// A `values:` list is packed into wire layout at code-generation time and stored in flash, so play()
 /// neither allocates nor packs. A lambda returns std::vector<bool> - already a bit per coil rather than
 /// a byte - and is packed into a stack buffer on the way to the builder.
-template<typename... Ts> class WriteMultipleCoilsAction : public TypedClientActionBase<Ts...> {
+template<typename... Ts>
+class WriteMultipleCoilsAction : public TypedClientActionBase<Ts...>, public WriteCommandOptions<Ts...> {
  public:
   TEMPLATABLE_VALUE(uint16_t, start_address)
 
@@ -334,13 +367,16 @@ template<typename... Ts> class WriteMultipleCoilsAction : public TypedClientActi
     const uint16_t start = this->start_address_.value(x...);
     if (this->count_ >= 0) {
       const auto count = static_cast<uint16_t>(this->count_);
-      this->send_or_resolve_(modbus::helpers::create_write_coils_pdu(
-          start,
-          modbus::PackedBits(std::span<const uint8_t>(this->values_.packed, modbus::packed_bit_bytes(count)), count)));
+      this->send_or_resolve_(
+          modbus::helpers::create_write_coils_pdu(
+              start, modbus::PackedBits(std::span<const uint8_t>(this->values_.packed, modbus::packed_bit_bytes(count)),
+                                        count)),
+          this->write_command_options_(x...));
       return;
     }
     // The builder packs and bound-checks; an over-long set is rejected and logged there.
-    this->send_or_resolve_(modbus::helpers::create_write_coils_pdu(start, this->values_.func(x...)));
+    this->send_or_resolve_(modbus::helpers::create_write_coils_pdu(start, this->values_.func(x...)),
+                           this->write_command_options_(x...));
   }
   void on_write_multiple_coils(uint16_t start_address, modbus::PackedBits bits,
                                modbus::ResponseStatus status) override {
@@ -359,7 +395,8 @@ template<typename... Ts> class WriteMultipleCoilsAction : public TypedClientActi
 
 /// modbus_client.read_write_multiple_registers (FC 0x17): writes one register block and reads another back in
 /// one transaction (write first, per Modbus 6.17). on_response delivers the read-back words as `values`.
-template<typename... Ts> class ReadWriteMultipleRegistersAction : public TypedClientActionBase<Ts...> {
+template<typename... Ts>
+class ReadWriteMultipleRegistersAction : public TypedClientActionBase<Ts...>, public ReadCommandOptions<Ts...> {
  public:
   TEMPLATABLE_VALUE(uint16_t, read_address)
   TEMPLATABLE_VALUE(uint16_t, read_count)
@@ -385,13 +422,15 @@ template<typename... Ts> class ReadWriteMultipleRegistersAction : public TypedCl
     // An out-of-range read/write count builds an empty PDU (the builder logs why), resolving via on_not_sent.
     if (this->len_ >= 0) {
       this->send_or_resolve_(modbus::helpers::create_read_write_multiple_registers_pdu(
-          read_start, read_count, write_start,
-          std::span<const uint16_t>(this->values_.data, static_cast<size_t>(this->len_))));
+                                 read_start, read_count, write_start,
+                                 std::span<const uint16_t>(this->values_.data, static_cast<size_t>(this->len_))),
+                             this->command_options_(x...));
       return;
     }
     const std::vector<uint16_t> values = this->values_.func(x...);
     this->send_or_resolve_(modbus::helpers::create_read_write_multiple_registers_pdu(
-        read_start, read_count, write_start, std::span<const uint16_t>(values)));
+                               read_start, read_count, write_start, std::span<const uint16_t>(values)),
+                           this->command_options_(x...));
   }
   // The 0x17 response carries only the read block, so the hub dispatch delivers it as a holding-register read.
   void on_read_registers(modbus::EntityType entity_type, uint16_t start_address, std::span<const uint16_t> registers,
diff --git a/esphome/components/modbus_controller/__init__.py b/esphome/components/modbus_controller/__init__.py
index f888cc060e3..aa72a08a60b 100644
--- a/esphome/components/modbus_controller/__init__.py
+++ b/esphome/components/modbus_controller/__init__.py
@@ -103,12 +103,20 @@ def _warn_removed_options(config: ConfigType) -> ConfigType:
 
 
 def _reject_broadcast_address(config: ConfigType) -> ConfigType:
-    """A modbus_controller polls one device, so its address cannot be the broadcast address (0):
-    a broadcast is never answered (Modbus 4.1), so no register could ever read back."""
+    """Address 0 is rejected unless allow_broadcast_read, which in turn requires address 0."""
+    if config[modbus.CONF_ALLOW_BROADCAST_READ]:
+        if config.get(CONF_ADDRESS) != modbus.BROADCAST_ADDRESS:
+            raise cv.Invalid(
+                f"'{modbus.CONF_ALLOW_BROADCAST_READ}' only applies to the broadcast address; "
+                f"set 'address: 0' or remove the option.",
+                [modbus.CONF_ALLOW_BROADCAST_READ],
+            )
+        return config
     modbus.reject_broadcast_address(
         config.get(CONF_ADDRESS),
         "a modbus_controller device address",
-        "Assign the unit address of the device you want to poll.",
+        "Assign the unit address of the device you want to poll, or set allow_broadcast_read if "
+        "it answers address 0.",
         [CONF_ADDRESS],
     )
     return config
@@ -346,12 +354,52 @@ def _reject_continuous_write_custom_pdu(config: ConfigType) -> None:
         )
 
 
+def _reject_broadcastable_custom_pdu(config: ConfigType) -> None:
+    """A broadcastable custom_pdu under an address-0 controller is a real broadcast, never answered."""
+    pdu = config.get(CONF_CUSTOM_PDU)
+    if pdu is None or not modbus.is_function_code_broadcastable(pdu[0]):
+        return
+    fconf = fv.full_config.get()
+    path = fconf.get_path_for_id(config[CONF_MODBUS_CONTROLLER_ID])[:-1]
+    controller = fconf.get_config_for_path(path)
+    if (
+        controller.get(CONF_ADDRESS) == modbus.BROADCAST_ADDRESS
+        and controller.get(modbus.CONF_ALLOW_BROADCAST_READ) is True
+    ):
+        raise cv.Invalid(
+            f"a '{CONF_CUSTOM_PDU}' with function code 0x{pdu[0] & 0x7F:02X} is a real broadcast at "
+            f"address 0 and is never answered, so it can't be polled through the "
+            f"'{controller[CONF_ID]}' modbus_controller; use a read function code.",
+            [CONF_CUSTOM_PDU],
+        )
+
+
 def validate_custom_pdu_item(config: ConfigType) -> None:
-    """Final-validate for the read platforms that accept custom_pdu (sensor, binary_sensor,
-    text_sensor): migrate the deprecated custom_command, then reject a write-coded custom_pdu under a
-    continuously-polling controller."""
+    """Final-validate for the platforms that accept custom_pdu."""
     migrate_custom_command(config)
     _reject_continuous_write_custom_pdu(config)
+    _reject_broadcastable_custom_pdu(config)
+
+
+def _reject_write_option_off_broadcast(config: ConfigType) -> None:
+    if not any(config.get(key) is True for key in modbus.broadcast_only_option_keys()):
+        return
+    fconf = fv.full_config.get()
+    path = fconf.get_path_for_id(config[CONF_MODBUS_CONTROLLER_ID])[:-1]
+    controller = fconf.get_config_for_path(path)
+    if controller.get(CONF_ADDRESS) != modbus.BROADCAST_ADDRESS:
+        raise cv.Invalid(
+            f"'{modbus.CONF_EXPECT_BROADCAST_WRITE_RESPONSE}' only applies when the "
+            f"'{controller[CONF_ID]}' modbus_controller is at address 0; remove the option.",
+            [modbus.CONF_EXPECT_BROADCAST_WRITE_RESPONSE],
+        )
+
+
+def validate_writer_item(config: ConfigType) -> None:
+    """Final-validate for the writer platforms (number, output, select, switch)."""
+    if CONF_CUSTOM_PDU in config or CONF_CUSTOM_COMMAND in config:
+        validate_custom_pdu_item(config)
+    _reject_write_option_off_broadcast(config)
 
 
 def _final_validate(config: ConfigType) -> None:
@@ -448,11 +496,7 @@ async def to_code(config: ConfigType) -> None:
     await cg.register_component(var, config)
     cg.add(var.set_max_cmd_retries(config[CONF_MAX_CMD_RETRIES]))
     cg.add(var.set_offline_skip_updates(config[CONF_OFFLINE_SKIP_UPDATES]))
-    cg.add(
-        var.set_read_options(
-            modbus.command_options_expression(config, direction="read")
-        )
-    )
+    modbus.add_command_options(var, "set_read_options", config, direction="read")
     await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
 
diff --git a/esphome/components/modbus_controller/modbus_controller.cpp b/esphome/components/modbus_controller/modbus_controller.cpp
index c7fc10a0bb0..b8d06d3d5a3 100644
--- a/esphome/components/modbus_controller/modbus_controller.cpp
+++ b/esphome/components/modbus_controller/modbus_controller.cpp
@@ -24,7 +24,7 @@ void WriterDevice::warn_write_buffer_deprecated(const LogString *platform, uint1
 bool WriterDevice::send_raw_frame_deprecated(std::span<const uint8_t> frame) {
   if (frame.empty())
     return false;
-  return this->parent_->queue_pdu(frame[0], frame.subspan(1), this);
+  return this->parent_->queue_pdu(frame[0], frame.subspan(1), this, this->write_options_);
 }
 
 void ControllerDevice::set_controller(ModbusController *controller) {
@@ -234,10 +234,13 @@ void ModbusCommandItem::on_sent(std::span<const uint8_t> request_pdu) {
   // (frame[0]), which may differ from this controller's. (unqueue_command() is a no-op for a poll.)
   // A custom polling command sends its PDU to this controller's own address, so only a factory custom
   // command (a raw frame staged in payload) can carry a different address byte.
+  // An address-0 read with allow_broadcast_read is answered, so it keeps its terminal callback.
   uint8_t wire_address = this->address_;
   if (this->function_code_ == FunctionCode::CUSTOM && !this->payload.empty())
     wire_address = this->payload.data()[0];
-  if (wire_address == modbus::BROADCAST_ADDRESS)
+  const bool answered = this->controller_->read_options().allow_broadcast_read &&
+                        !modbus::helpers::is_function_code_broadcastable(request_pdu[0]);
+  if (wire_address == modbus::BROADCAST_ADDRESS && !answered)
     this->controller_->unqueue_command(this);
 }
 
@@ -285,8 +288,8 @@ void ModbusController::queue_command(ModbusCommandItem command) {
   this->one_shot_command_items_.push_back(make_unique<ModbusCommandItem>(std::move(command)));
   // A refused frame gets no terminal callback (see the hub contract), so reclaim the item here.
   auto &item = this->one_shot_command_items_.back();
-  // We intentionally do not pass read_options_ here, because one-shot commands are usually writes, and are non-polling.
-  if (!item->send()) {
+  // One-shots never poll, so only the broadcast flag is passed (the hub strips it from writes).
+  if (!item->send({.allow_broadcast_read = this->read_options_.allow_broadcast_read})) {
     // The caller (e.g. a write entity) has usually already published optimistically - surface the loss.
     ESP_LOGW(TAG, "Command refused by hub: type=0x%X address=0x%X", static_cast<uint8_t>(item->register_type()),
              item->register_address());
@@ -340,7 +343,7 @@ void ModbusController::update() {
   if (this->can_send()) {
     for (auto &poll : this->polling_devices_) {
       ESP_LOGVV(TAG, "Updating range 0x%X", poll.register_address());
-      // read_options_ carries the controller's continuous flag (the offline probe above sends it too).
+      // read_options_ carries the controller's read-side flags (the offline probe above sends them too).
       // A refusal is already logged by the hub; note the affected range for controller-level diagnostics.
       if (!poll.queue(this->read_options_)) {
         ESP_LOGD(TAG, "Poll refused by hub for range 0x%X", poll.register_address());
diff --git a/esphome/components/modbus_controller/modbus_controller.h b/esphome/components/modbus_controller/modbus_controller.h
index 821c500a31e..d21b3194358 100644
--- a/esphome/components/modbus_controller/modbus_controller.h
+++ b/esphome/components/modbus_controller/modbus_controller.h
@@ -30,53 +30,10 @@ using modbus::ModbusFunctionCode;
 using modbus::ModbusRegisterType;
 #pragma GCC diagnostic pop
 
-// Remove before 2026.10.0 — these helpers have moved to modbus::helpers
-ESPDEPRECATED("Use modbus::helpers::value_type_is_float() instead. Removed in 2026.10.0", "2026.4.0")
-inline bool value_type_is_float(SensorValueType v) { return modbus::helpers::value_type_is_float(v); }
-
-ESPDEPRECATED("Use modbus::helpers::modbus_register_read_function() instead. Removed in 2026.10.0", "2026.4.0")
-inline FunctionCode modbus_register_read_function(modbus::EntityType reg_type) {
-  return modbus::helpers::modbus_register_read_function(reg_type);
-}
-
-ESPDEPRECATED("Use modbus::helpers::modbus_register_write_function() instead. Removed in 2026.10.0", "2026.4.0")
-inline FunctionCode modbus_register_write_function(modbus::EntityType reg_type) {
-  return modbus::helpers::modbus_register_write_function(reg_type);
-}
-
-ESPDEPRECATED("Use modbus::helpers::c_to_hex() instead. Removed in 2026.10.0", "2026.4.0")
-inline uint8_t c_to_hex(char c) { return modbus::helpers::c_to_hex(c); }
-
-ESPDEPRECATED("Use modbus::helpers::byte_from_hex_str() instead. Removed in 2026.10.0", "2026.4.0")
-inline uint8_t byte_from_hex_str(const std::string &value, uint8_t pos) {
-  return modbus::helpers::byte_from_hex_str(value, pos);
-}
-
-ESPDEPRECATED("Use modbus::helpers::word_from_hex_str() instead. Removed in 2026.10.0", "2026.4.0")
-inline uint16_t word_from_hex_str(const std::string &value, uint8_t pos) {
-  return modbus::helpers::word_from_hex_str(value, pos);
-}
-
-ESPDEPRECATED("Use modbus::helpers::dword_from_hex_str() instead. Removed in 2026.10.0", "2026.4.0")
-inline uint32_t dword_from_hex_str(const std::string &value, uint8_t pos) {
-  return modbus::helpers::dword_from_hex_str(value, pos);
-}
-
-ESPDEPRECATED("Use modbus::helpers::qword_from_hex_str() instead. Removed in 2026.10.0", "2026.4.0")
-inline uint64_t qword_from_hex_str(const std::string &value, uint8_t pos) {
-  return modbus::helpers::qword_from_hex_str(value, pos);
-}
-
-template<typename T>
-ESPDEPRECATED("Use modbus::helpers::get_data() instead. Removed in 2026.10.0", "2026.4.0")
-T get_data(const std::vector<uint8_t> &data, size_t buffer_offset) {
-  return modbus::helpers::get_data<T>(data, buffer_offset);
-}
-
-// Span overloads of the deprecated helpers below: read lambdas receive their payload as a
+// Span overloads of the former modbus_controller helpers: read lambdas receive their payload as a
 // std::span<const uint8_t> (previously a const std::vector<uint8_t> &), and a span does not convert to
 // a vector, so existing lambdas calling these by name need an overload that accepts one. These carry
-// this release's deprecation window, since the span forms only exist from it.
+// the 2026.8.0 deprecation window, since the span forms only exist from it.
 // payload_to_number() deliberately has no such overload: one of its arguments is a modbus::helpers
 // type, so a span call already reaches the helper by argument-dependent lookup, and a forwarder here
 // would only make that call ambiguous.
@@ -99,33 +56,6 @@ inline bool coil_from_vector(int coil, std::span<const uint8_t> data) {
   return modbus::helpers::bit_from_packed(coil, data);
 }
 
-template<typename N>
-ESPDEPRECATED("Use modbus::helpers::mask_and_shift_by_rightbit() instead. Removed in 2026.10.0", "2026.4.0")
-N mask_and_shift_by_rightbit(N data, uint32_t mask) {
-  return modbus::helpers::mask_and_shift_by_rightbit(data, mask);
-}
-
-ESPDEPRECATED("Use modbus::helpers::number_to_payload() instead. Removed in 2026.10.0", "2026.4.0")
-inline void number_to_payload(std::vector<uint16_t> &data, int64_t value, SensorValueType value_type) {
-  modbus::helpers::number_to_payload(data, value, value_type);
-}
-
-ESPDEPRECATED("Use modbus::helpers::payload_to_number() instead. Removed in 2026.10.0", "2026.4.0")
-inline int64_t payload_to_number(const std::vector<uint8_t> &data, SensorValueType sensor_value_type, uint8_t offset,
-                                 uint32_t bitmask) {
-  return modbus::helpers::payload_to_number(std::span<const uint8_t>(data), sensor_value_type, offset, bitmask)
-      .value_or(0);
-}
-
-ESPDEPRECATED("Use modbus::helpers::float_to_payload() instead. Removed in 2026.10.0", "2026.4.0")
-inline std::vector<uint16_t> float_to_payload(float value, SensorValueType value_type) {
-  std::vector<uint16_t> data;
-  modbus::helpers::float_to_payload(data, value, value_type);
-  return data;
-}
-
-class ModbusController;
-
 /// How an item relates to the register range built just before it (same register type, address order).
 /// The numeric order doubles as the comparator tiebreak for items at the same address (see
 /// SensorItemsComparator): AUTO items form the shared range first, so a NEVER item comes last and
@@ -280,10 +210,11 @@ class ControllerDevice : protected modbus::ModbusClientDevice {
 
   void notify_online_(std::span<const uint8_t> request_pdu);
 
-  /// Write-path state owned by WriterEntity's forwarders, stored here so both bools land in the base's
-  /// tail padding instead of adding a word to every writer entity. The warn flag leaves in 2027.3.0.
-  bool dispatched_{false};
-  bool write_buffer_deprecated_warned_{false};
+  /// Write-path state for WriterEntity's forwarders, packed into the base's tail padding. The warn flag
+  /// leaves in 2027.3.0.
+  bool dispatched_ : 1 {false};
+  bool write_buffer_deprecated_warned_ : 1 {false};
+  modbus::CommandOptions write_options_{};
   ModbusController *controller_{nullptr};
 };
 
@@ -305,6 +236,8 @@ class WriterDevice final : public ControllerDevice {
   bool dispatched() const { return this->dispatched_; }
   void set_dispatched() { this->dispatched_ = true; }
   void clear_dispatched() { this->dispatched_ = false; }
+  modbus::CommandOptions write_options() const { return this->write_options_; }
+  void set_write_options(modbus::CommandOptions options) { this->write_options_ = options; }
   /// Warn once per entity that filling the write_lambda buffer parameter is deprecated (the entity is now the
   /// command - call a write helper / queue_pdu() on `item` instead). The buffer parameter is removed in 2027.3.0.
   void warn_write_buffer_deprecated(const LogString *platform, uint16_t address);
@@ -326,27 +259,29 @@ class WriterEntity {
   /// Whether the lambda called a request helper since the last clear_dispatched_(). Deliberately records
   /// the call, not the hub's accept/refuse: a refused lambda write must not fall through to the default write.
   bool dispatched() const { return this->device_.dispatched(); }
+  void set_write_options(modbus::CommandOptions options) { this->device_.set_write_options(options); }
   bool write_single_register(uint16_t address, uint16_t value) {
     this->device_.set_dispatched();
-    return this->device_.write_single_register(address, value);
+    return this->device_.write_single_register(address, value, this->device_.write_options());
   }
   bool write_single_coil(uint16_t address, bool value) {
     this->device_.set_dispatched();
-    return this->device_.write_single_coil(address, value);
+    return this->device_.write_single_coil(address, value, this->device_.write_options());
   }
   bool write_multiple_registers(uint16_t address, std::span<const uint16_t> values) {
     this->device_.set_dispatched();
-    return this->device_.write_multiple_registers(address, values);
+    return this->device_.write_multiple_registers(address, values, this->device_.write_options());
   }
   bool write_multiple_coils(uint16_t address, std::span<const bool> values) {
     this->device_.set_dispatched();
-    return this->device_.write_multiple_coils(address, values);
+    return this->device_.write_multiple_coils(address, values, this->device_.write_options());
   }
   bool write_multiple_coils(uint16_t address, modbus::PackedBits bits) {
     this->device_.set_dispatched();
-    return this->device_.write_multiple_coils(address, bits);
+    return this->device_.write_multiple_coils(address, bits, this->device_.write_options());
   }
-  bool queue_pdu(std::span<const uint8_t> pdu, modbus::CommandOptions options = {}) {
+  bool queue_pdu(std::span<const uint8_t> pdu) { return this->queue_pdu(pdu, this->device_.write_options()); }
+  bool queue_pdu(std::span<const uint8_t> pdu, modbus::CommandOptions options) {
     this->device_.set_dispatched();
     return this->device_.queue_pdu(pdu, options);
   }
diff --git a/esphome/components/modbus_controller/number/__init__.py b/esphome/components/modbus_controller/number/__init__.py
index 6f7bf588af7..242e2eea218 100644
--- a/esphome/components/modbus_controller/number/__init__.py
+++ b/esphome/components/modbus_controller/number/__init__.py
@@ -1,5 +1,5 @@
 import esphome.codegen as cg
-from esphome.components import number
+from esphome.components import modbus, number
 from esphome.components.modbus.helpers import (
     MODBUS_WRITE_REGISTER_TYPE,
     SENSOR_VALUE_TYPE,
@@ -23,8 +23,8 @@ from .. import (
     add_modbus_base_properties,
     modbus_calc_properties,
     modbus_controller_ns,
-    validate_custom_pdu_item,
     validate_range_reuse_migration,
+    validate_writer_item,
 )
 from ..const import (
     CONF_BITMASK,
@@ -84,6 +84,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_STEP, default=1): cv.positive_float,
             cv.Optional(CONF_MULTIPLY, default=1.0): cv.float_,
             cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean,
+            **modbus.command_options_schema(direction="write"),
         }
     ),
     validate_min_max,
@@ -91,7 +92,7 @@ CONFIG_SCHEMA = cv.All(
     validate_range_reuse_migration,
 )
 
-FINAL_VALIDATE_SCHEMA = validate_custom_pdu_item
+FINAL_VALIDATE_SCHEMA = validate_writer_item
 
 
 async def to_code(config: ConfigType) -> None:
@@ -122,6 +123,7 @@ async def to_code(config: ConfigType) -> None:
     cg.add(parent.add_sensor_item(var))
     await add_modbus_base_properties(var, config, ModbusNumber)
     cg.add(var.set_use_write_mutiple(config[CONF_USE_WRITE_MULTIPLE]))
+    modbus.add_command_options(var, "set_write_options", config, direction="write")
     if CONF_WRITE_LAMBDA in config:
         template_ = await cg.process_lambda(
             config[CONF_WRITE_LAMBDA],
diff --git a/esphome/components/modbus_controller/number/modbus_number.cpp b/esphome/components/modbus_controller/number/modbus_number.cpp
index aff05cd517a..223aa12bec2 100644
--- a/esphome/components/modbus_controller/number/modbus_number.cpp
+++ b/esphome/components/modbus_controller/number/modbus_number.cpp
@@ -23,7 +23,6 @@ void ModbusNumber::parse_and_publish(std::span<const uint8_t> data) {
     }
   }
   ESP_LOGD(TAG, "Number new state : %.02f", result);
-  // this->sensor_->raw_state = result;
   this->publish_state(result);
 }
 
diff --git a/esphome/components/modbus_controller/output/__init__.py b/esphome/components/modbus_controller/output/__init__.py
index 0e8d5363d74..c964ced987b 100644
--- a/esphome/components/modbus_controller/output/__init__.py
+++ b/esphome/components/modbus_controller/output/__init__.py
@@ -1,7 +1,7 @@
 import logging
 
 import esphome.codegen as cg
-from esphome.components import output
+from esphome.components import modbus, output
 from esphome.components.modbus.helpers import (
     SENSOR_VALUE_TYPE,
     PduBuffer,
@@ -18,6 +18,7 @@ from .. import (
     modbus_calc_properties,
     modbus_controller_ns,
     reject_odd_holding_write_offset,
+    validate_writer_item,
 )
 from ..const import (
     CONF_CUSTOM_COMMAND,
@@ -79,6 +80,7 @@ CONFIG_SCHEMA = cv.All(
                     ),
                     cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda,
                     cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean,
+                    **modbus.command_options_schema(direction="write"),
                 }
             ),
             "holding": cv.All(
@@ -98,6 +100,7 @@ CONFIG_SCHEMA = cv.All(
                         cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda,
                         cv.Optional(CONF_MULTIPLY, default=1.0): cv.float_,
                         cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean,
+                        **modbus.command_options_schema(direction="write"),
                     }
                 ),
                 reject_odd_holding_write_offset,
@@ -111,6 +114,9 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
+FINAL_VALIDATE_SCHEMA = validate_writer_item
+
+
 async def to_code(config: ConfigType) -> None:
     byte_offset = modbus_calc_properties(config)
     # Binary Output
@@ -153,6 +159,7 @@ async def to_code(config: ConfigType) -> None:
     await output.register_output(var, config)
     parent = await cg.get_variable(config[CONF_MODBUS_CONTROLLER_ID])
     cg.add(var.set_use_write_mutiple(config[CONF_USE_WRITE_MULTIPLE]))
+    modbus.add_command_options(var, "set_write_options", config, direction="write")
     cg.add(var.set_parent(parent))
     if write_template:
         cg.add(var.set_write_template(write_template))
diff --git a/esphome/components/modbus_controller/select/__init__.py b/esphome/components/modbus_controller/select/__init__.py
index d8319932ab6..6fc8c8331cf 100644
--- a/esphome/components/modbus_controller/select/__init__.py
+++ b/esphome/components/modbus_controller/select/__init__.py
@@ -2,7 +2,7 @@ from collections.abc import Callable
 from typing import Any
 
 import esphome.codegen as cg
-from esphome.components import select
+from esphome.components import modbus, select
 from esphome.components.modbus.helpers import SENSOR_VALUE_TYPE, RegisterValues
 import esphome.config_validation as cv
 from esphome.const import CONF_ADDRESS, CONF_ID, CONF_LAMBDA, CONF_OPTIMISTIC
@@ -15,6 +15,7 @@ from .. import (
     modbus_controller_ns,
     validate_range_reuse_migration,
     validate_skip_updates_deprecated,
+    validate_writer_item,
 )
 from ..const import (
     CONF_FORCE_NEW_RANGE,
@@ -77,6 +78,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_REGISTER_COUNT): cv.positive_int,
             cv.Required(CONF_OPTIONSMAP): ensure_option_map(),
             cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean,
+            **modbus.command_options_schema(direction="write"),
             cv.Optional(CONF_OPTIMISTIC, default=False): cv.boolean,
             cv.Optional(CONF_LAMBDA): cv.returning_lambda,
             cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda,
@@ -86,6 +88,9 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
+FINAL_VALIDATE_SCHEMA = validate_writer_item
+
+
 async def to_code(config: ConfigType) -> None:
     options_map = config[CONF_OPTIONSMAP]
 
@@ -104,6 +109,7 @@ async def to_code(config: ConfigType) -> None:
     cg.add(parent.add_sensor_item(var))
     cg.add(var.set_parent(parent))
     cg.add(var.set_use_write_mutiple(config[CONF_USE_WRITE_MULTIPLE]))
+    modbus.add_command_options(var, "set_write_options", config, direction="write")
     cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
 
     if CONF_LAMBDA in config:
diff --git a/esphome/components/modbus_controller/sensor/modbus_sensor.cpp b/esphome/components/modbus_controller/sensor/modbus_sensor.cpp
index b2bc2b5fd04..2035f2220a3 100644
--- a/esphome/components/modbus_controller/sensor/modbus_sensor.cpp
+++ b/esphome/components/modbus_controller/sensor/modbus_sensor.cpp
@@ -22,7 +22,6 @@ void ModbusSensor::parse_and_publish(std::span<const uint8_t> data) {
     }
   }
   ESP_LOGD(TAG, "Sensor new state: %.02f", result);
-  // this->sensor_->raw_state = result;
   this->publish_state(result);
 }
 
diff --git a/esphome/components/modbus_controller/switch/__init__.py b/esphome/components/modbus_controller/switch/__init__.py
index 00b67446a31..2c5b92b810b 100644
--- a/esphome/components/modbus_controller/switch/__init__.py
+++ b/esphome/components/modbus_controller/switch/__init__.py
@@ -1,5 +1,5 @@
 import esphome.codegen as cg
-from esphome.components import switch
+from esphome.components import modbus, switch
 from esphome.components.modbus.helpers import MODBUS_REGISTER_TYPE, PduBuffer
 import esphome.config_validation as cv
 from esphome.const import CONF_ADDRESS, CONF_ASSUMED_STATE, CONF_ID
@@ -13,9 +13,9 @@ from .. import (
     modbus_calc_properties,
     modbus_controller_ns,
     reject_odd_holding_write_offset,
-    validate_custom_pdu_item,
     validate_modbus_register,
     validate_range_reuse_migration,
+    validate_writer_item,
 )
 from ..const import (
     CONF_BITMASK,
@@ -51,6 +51,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_ASSUMED_STATE, default=False): cv.boolean,
             cv.Optional(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE),
             cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean,
+            **modbus.command_options_schema(direction="write"),
             cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda,
         }
     ),
@@ -59,7 +60,7 @@ CONFIG_SCHEMA = cv.All(
     validate_range_reuse_migration,
 )
 
-FINAL_VALIDATE_SCHEMA = validate_custom_pdu_item
+FINAL_VALIDATE_SCHEMA = validate_writer_item
 
 
 async def to_code(config: ConfigType) -> None:
@@ -78,6 +79,7 @@ async def to_code(config: ConfigType) -> None:
     paren = await cg.get_variable(config[CONF_MODBUS_CONTROLLER_ID])
     cg.add(var.set_parent(paren))
     cg.add(var.set_use_write_mutiple(config[CONF_USE_WRITE_MULTIPLE]))
+    modbus.add_command_options(var, "set_write_options", config, direction="write")
     assumed_state = config[CONF_ASSUMED_STATE]
     cg.add(var.set_assumed_state(assumed_state))
     if not assumed_state:
diff --git a/esphome/components/modbus_controller/switch/modbus_switch.cpp b/esphome/components/modbus_controller/switch/modbus_switch.cpp
index 7bf45366c0a..855a7b28c30 100644
--- a/esphome/components/modbus_controller/switch/modbus_switch.cpp
+++ b/esphome/components/modbus_controller/switch/modbus_switch.cpp
@@ -16,17 +16,11 @@ void ModbusSwitch::setup() {
   optional<bool> initial_state = Switch::get_initial_state_with_restore_mode();
   if (initial_state.has_value()) {
     // if it has a value, restore_mode is not "DISABLED", therefore act on the switch:
-    if (initial_state.value()) {
-      this->turn_on();
-    } else {
-      this->turn_off();
-    }
+    this->control(initial_state.value());
   }
 }
 void ModbusSwitch::dump_config() { LOG_SWITCH(TAG, "Modbus Controller Switch", this); }
 
-void ModbusSwitch::set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
-
 bool ModbusSwitch::assumed_state() { return this->assumed_state_; }
 
 void ModbusSwitch::parse_and_publish(std::span<const uint8_t> data) {
diff --git a/esphome/components/modbus_controller/switch/modbus_switch.h b/esphome/components/modbus_controller/switch/modbus_switch.h
index 688a620bac1..b98543532e6 100644
--- a/esphome/components/modbus_controller/switch/modbus_switch.h
+++ b/esphome/components/modbus_controller/switch/modbus_switch.h
@@ -31,7 +31,7 @@ class ModbusSwitch final : public Component, public switch_::Switch, public Sens
   void setup() override;
   void write_state(bool state) override;
   void dump_config() override;
-  void set_assumed_state(bool assumed_state);
+  void set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
   void set_state(bool state) { this->state = state; }
   void parse_and_publish(std::span<const uint8_t> data) override;
   void set_parent(ModbusController *parent) { this->set_controller_(parent); }
diff --git a/esphome/components/mqtt_subscribe/sensor/mqtt_subscribe_sensor.cpp b/esphome/components/mqtt_subscribe/sensor/mqtt_subscribe_sensor.cpp
index 40b5b46e1d2..afb725feb64 100644
--- a/esphome/components/mqtt_subscribe/sensor/mqtt_subscribe_sensor.cpp
+++ b/esphome/components/mqtt_subscribe/sensor/mqtt_subscribe_sensor.cpp
@@ -25,7 +25,6 @@ void MQTTSubscribeSensor::setup() {
 }
 
 float MQTTSubscribeSensor::get_setup_priority() const { return setup_priority::AFTER_CONNECTION; }
-void MQTTSubscribeSensor::set_qos(uint8_t qos) { this->qos_ = qos; }
 void MQTTSubscribeSensor::dump_config() {
   LOG_SENSOR("", "MQTT Subscribe", this);
   ESP_LOGCONFIG(TAG, "  Topic: %s", this->topic_.c_str());
diff --git a/esphome/components/mqtt_subscribe/sensor/mqtt_subscribe_sensor.h b/esphome/components/mqtt_subscribe/sensor/mqtt_subscribe_sensor.h
index 739e8456ee8..b0a8a0a78a2 100644
--- a/esphome/components/mqtt_subscribe/sensor/mqtt_subscribe_sensor.h
+++ b/esphome/components/mqtt_subscribe/sensor/mqtt_subscribe_sensor.h
@@ -18,7 +18,7 @@ class MQTTSubscribeSensor final : public sensor::Sensor, public Component {
   void dump_config() override;
   float get_setup_priority() const override;
 
-  void set_qos(uint8_t qos);
+  void set_qos(uint8_t qos) { this->qos_ = qos; }
 
  protected:
   mqtt::MQTTClientComponent *parent_;
diff --git a/esphome/components/mqtt_subscribe/text_sensor/mqtt_subscribe_text_sensor.cpp b/esphome/components/mqtt_subscribe/text_sensor/mqtt_subscribe_text_sensor.cpp
index edc197671e6..470e08d59ae 100644
--- a/esphome/components/mqtt_subscribe/text_sensor/mqtt_subscribe_text_sensor.cpp
+++ b/esphome/components/mqtt_subscribe/text_sensor/mqtt_subscribe_text_sensor.cpp
@@ -15,7 +15,6 @@ void MQTTSubscribeTextSensor::setup() {
       this->qos_);
 }
 float MQTTSubscribeTextSensor::get_setup_priority() const { return setup_priority::AFTER_CONNECTION; }
-void MQTTSubscribeTextSensor::set_qos(uint8_t qos) { this->qos_ = qos; }
 void MQTTSubscribeTextSensor::dump_config() {
   LOG_TEXT_SENSOR("", "MQTT Subscribe Text Sensor", this);
   ESP_LOGCONFIG(TAG, "  Topic: %s", this->topic_.c_str());
diff --git a/esphome/components/mqtt_subscribe/text_sensor/mqtt_subscribe_text_sensor.h b/esphome/components/mqtt_subscribe/text_sensor/mqtt_subscribe_text_sensor.h
index 8641825fca9..dc02eb5d187 100644
--- a/esphome/components/mqtt_subscribe/text_sensor/mqtt_subscribe_text_sensor.h
+++ b/esphome/components/mqtt_subscribe/text_sensor/mqtt_subscribe_text_sensor.h
@@ -17,7 +17,7 @@ class MQTTSubscribeTextSensor final : public text_sensor::TextSensor, public Com
   void setup() override;
   void dump_config() override;
   float get_setup_priority() const override;
-  void set_qos(uint8_t qos);
+  void set_qos(uint8_t qos) { this->qos_ = qos; }
 
  protected:
   mqtt::MQTTClientComponent *parent_;
diff --git a/esphome/components/nextion/nextion_component_base.h b/esphome/components/nextion/nextion_component_base.h
index 5e84291b168..b66c0b9e4e0 100644
--- a/esphome/components/nextion/nextion_component_base.h
+++ b/esphome/components/nextion/nextion_component_base.h
@@ -66,6 +66,7 @@ class NextionComponentBase {
 #ifdef USE_NEXTION_WAVEFORM
   uint8_t get_wave_channel_id() const { return this->wave_chan_id_; }
   void set_wave_channel_id(uint8_t wave_chan_id) { this->wave_chan_id_ = wave_chan_id; }
+  void set_wave_max_length(int wave_max_length) { this->wave_max_length_ = wave_max_length; }
 
   const std::vector<uint8_t> &get_wave_buffer() const { return this->wave_buffer_; }
   size_t get_wave_buffer_size() const { return this->wave_buffer_.size(); }
@@ -86,12 +87,6 @@ class NextionComponentBase {
   virtual void set_state_from_string(const std::string &state_value, bool publish, bool send_to_nextion){};
   virtual void send_state_to_nextion(){};
   bool get_needs_to_send_update() const { return this->needs_to_send_update_; }
-#ifdef USE_NEXTION_WAVEFORM
-  // Remove before 2026.10.0
-  ESPDEPRECATED("Use get_wave_channel_id() instead. Will be removed in 2026.10.0", "2026.4.0")
-  uint8_t get_wave_chan_id() const { return this->get_wave_channel_id(); }
-  void set_wave_max_length(int wave_max_length) { this->wave_max_length_ = wave_max_length; }
-#endif  // USE_NEXTION_WAVEFORM
 
  protected:
   std::string variable_name_;
diff --git a/esphome/components/number/number.h b/esphome/components/number/number.h
index 579d488cf06..b697e770be0 100644
--- a/esphome/components/number/number.h
+++ b/esphome/components/number/number.h
@@ -28,7 +28,7 @@ class Number;
  */
 class Number : public EntityBase {
  public:
-  float state;
+  float state{};
 
   void publish_state(float state);
 
diff --git a/esphome/components/openthread/openthread.cpp b/esphome/components/openthread/openthread.cpp
index b98f1091724..ae896fcfeea 100644
--- a/esphome/components/openthread/openthread.cpp
+++ b/esphome/components/openthread/openthread.cpp
@@ -227,8 +227,6 @@ void *OpenThreadSrpComponent::pool_alloc_(size_t size) {
   return ptr;
 }
 
-void OpenThreadSrpComponent::set_mdns(esphome::mdns::MDNSComponent *mdns) { this->mdns_ = mdns; }
-
 bool OpenThreadComponent::teardown() {
   switch (this->teardown_stage_) {
     case TeardownStage::TEARDOWN_STAGE_NOT_STARTED: {
diff --git a/esphome/components/openthread/openthread.h b/esphome/components/openthread/openthread.h
index f4c6d0962ae..b83ffdb6af6 100644
--- a/esphome/components/openthread/openthread.h
+++ b/esphome/components/openthread/openthread.h
@@ -90,7 +90,7 @@ extern OpenThreadComponent *global_openthread_component;  // NOLINT(cppcoreguide
 
 class OpenThreadSrpComponent final : public Component {
  public:
-  void set_mdns(esphome::mdns::MDNSComponent *mdns);
+  void set_mdns(esphome::mdns::MDNSComponent *mdns) { this->mdns_ = mdns; }
   // This has to run after the mdns component or else no services are available to advertise
   float get_setup_priority() const override { return this->mdns_->get_setup_priority() - 1.0f; }
   void setup() override;
diff --git a/esphome/components/output/switch/output_switch.cpp b/esphome/components/output/switch/output_switch.cpp
index 7cee2a86398..a21cbc0f6b9 100644
--- a/esphome/components/output/switch/output_switch.cpp
+++ b/esphome/components/output/switch/output_switch.cpp
@@ -6,21 +6,9 @@ namespace esphome::output {
 static const char *const TAG = "output.switch";
 
 void OutputSwitch::dump_config() { LOG_SWITCH("", "Output Switch", this); }
-void OutputSwitch::setup() {
-  bool initial_state = this->get_initial_state_with_restore_mode().value_or(false);
-
-  if (initial_state) {
-    this->turn_on();
-  } else {
-    this->turn_off();
-  }
-}
+void OutputSwitch::setup() { this->control(this->get_initial_state_with_restore_mode().value_or(false)); }
 void OutputSwitch::write_state(bool state) {
-  if (state) {
-    this->output_->turn_on();
-  } else {
-    this->output_->turn_off();
-  }
+  this->output_->set_state(state);
   this->publish_state(state);
 }
 
diff --git a/esphome/components/pca9554/pca9554.h b/esphome/components/pca9554/pca9554.h
index 05e945d1763..cc95f147ac5 100644
--- a/esphome/components/pca9554/pca9554.h
+++ b/esphome/components/pca9554/pca9554.h
@@ -55,6 +55,9 @@ class PCA9554Component final : public Component,
 /// Helper class to expose a PCA9554 pin as an internal input GPIO pin.
 class PCA9554GPIOPin final : public GPIOPin {
  public:
+  // User provided, not "= default": `new(p) PCA9554GPIOPin()` would zero-fill .bss that is already zero.
+  PCA9554GPIOPin() {}
+
   void setup() override;
   void pin_mode(gpio::Flags flags) override;
   bool digital_read() override;
@@ -69,10 +72,10 @@ class PCA9554GPIOPin final : public GPIOPin {
   gpio::Flags get_flags() const override { return this->flags_; }
 
  protected:
-  PCA9554Component *parent_;
-  uint8_t pin_;
-  bool inverted_;
-  gpio::Flags flags_;
+  PCA9554Component *parent_{nullptr};
+  uint8_t pin_{0};
+  bool inverted_{false};
+  gpio::Flags flags_{};
 };
 
 }  // namespace esphome::pca9554
diff --git a/esphome/components/pcf8574/pcf8574.h b/esphome/components/pcf8574/pcf8574.h
index e8f78bae506..9879d6a47eb 100644
--- a/esphome/components/pcf8574/pcf8574.h
+++ b/esphome/components/pcf8574/pcf8574.h
@@ -51,6 +51,9 @@ class PCF8574Component final : public Component,
 /// Helper class to expose a PCF8574 pin as an internal input GPIO pin.
 class PCF8574GPIOPin final : public GPIOPin {
  public:
+  // User provided, not "= default": `new(p) PCF8574GPIOPin()` would zero-fill .bss that is already zero.
+  PCF8574GPIOPin() {}
+
   void setup() override;
   void pin_mode(gpio::Flags flags) override;
   bool digital_read() override;
@@ -65,10 +68,10 @@ class PCF8574GPIOPin final : public GPIOPin {
   gpio::Flags get_flags() const override { return this->flags_; }
 
  protected:
-  PCF8574Component *parent_;
-  uint8_t pin_;
-  bool inverted_;
-  gpio::Flags flags_;
+  PCF8574Component *parent_{nullptr};
+  uint8_t pin_{0};
+  bool inverted_{false};
+  gpio::Flags flags_{};
 };
 
 }  // namespace esphome::pcf8574
diff --git a/esphome/components/pixoo/pixoo.cpp b/esphome/components/pixoo/pixoo.cpp
index 4436b1fb174..aa035be347d 100644
--- a/esphome/components/pixoo/pixoo.cpp
+++ b/esphome/components/pixoo/pixoo.cpp
@@ -120,7 +120,7 @@ void Pixoo::set_pixel_(uint32_t index, Color color) {
 }
 
 void HOT Pixoo::draw_pixel_at(int x, int y, Color color) {
-  if (!this->get_clipping().inside(x, y))
+  if (this->is_point_clipped(x, y))
     return;
   const int side = static_cast<int>(this->model_);
   switch (this->rotation_) {
diff --git a/esphome/components/preferences/syncer.h b/esphome/components/preferences/syncer.h
index 8a809672db4..5092c321479 100644
--- a/esphome/components/preferences/syncer.h
+++ b/esphome/components/preferences/syncer.h
@@ -9,6 +9,9 @@ namespace esphome::preferences {
 
 class IntervalSyncer final : public PollingComponent {
  public:
+  // User provided, not "= default": `new(p) IntervalSyncer()` would zero-fill .bss that is already zero.
+  IntervalSyncer() {}
+
   // Remove before 2027.3.0
   ESPDEPRECATED("Use set_update_interval() instead. Removed in 2027.3.0", "2026.9.0")
   void set_write_interval(uint32_t write_interval) { this->set_update_interval(write_interval); }
diff --git a/esphome/components/remote_base/__init__.py b/esphome/components/remote_base/__init__.py
index 27b6eb9fc82..bf8707ff1e8 100644
--- a/esphome/components/remote_base/__init__.py
+++ b/esphome/components/remote_base/__init__.py
@@ -169,6 +169,12 @@ def request_protocol(name: str) -> None:
     cg.add_define(protocol_define(name))
 
 
+def _request_protocol_if_in_tree(name: str) -> None:
+    """Registry names from external components have no source file here and need no define."""
+    if _protocol_stem(name) in _PROTOCOL_STEMS:
+        request_protocol(name)
+
+
 # Only the protocol sources a configuration uses are compiled
 FILTER_SOURCE_FILES = filter_source_files_from_defines(
     {f"{stem}_protocol.cpp": protocol_define(stem) for stem in _PROTOCOL_STEMS}
@@ -182,7 +188,7 @@ def register_binary_sensor(
 
     def decorator(func: Callable[[MockObj, ConfigType], Any]) -> Callable:
         async def new_func(var: MockObj, config: ConfigType) -> None:
-            request_protocol(name)
+            _request_protocol_if_in_tree(name)
             await coroutine(func)(var, config)
 
         return registerer(new_func)
@@ -200,7 +206,7 @@ def register_trigger(name, type, data_type):
 
     def decorator(func):
         async def new_func(config):
-            request_protocol(name)
+            _request_protocol_if_in_tree(name)
             var = cg.new_Pvariable(config[CONF_TRIGGER_ID])
             await coroutine(func)(var, config)
             await automation.build_automation(var, [(data_type, "x")], config)
@@ -218,7 +224,7 @@ def register_dumper(name, type, schema=None):
 
     def decorator(func):
         async def new_func(config, dumper_id):
-            request_protocol(name)
+            _request_protocol_if_in_tree(name)
             var = cg.new_Pvariable(dumper_id)
             await coroutine(func)(var, config)
             return var
@@ -259,7 +265,7 @@ def register_action(name, type_, schema):
 
     def decorator(func):
         async def new_func(config, action_id, template_arg, args):
-            request_protocol(name)
+            _request_protocol_if_in_tree(name)
             var = cg.new_Pvariable(action_id, template_arg)
             await register_transmittable(var, config)
             if CONF_REPEAT in config:
diff --git a/esphome/components/remote_receiver/__init__.py b/esphome/components/remote_receiver/__init__.py
index 6eaecf7ab00..866e108131e 100644
--- a/esphome/components/remote_receiver/__init__.py
+++ b/esphome/components/remote_receiver/__init__.py
@@ -112,20 +112,21 @@ CONFIG_SCHEMA = remote_base.validate_triggers(
             cv.Required(CONF_PIN): cv.All(pins.internal_gpio_input_pin_schema),
             cv.Optional(CONF_DUMP, default=[]): remote_base.validate_dumpers,
             cv.Optional(CONF_TOLERANCE, default="25%"): validate_tolerance,
+            # pulse ring targets hold one 4 byte entry per pulse; 4000b keeps their 1000 pulses
             cv.SplitDefault(
                 CONF_BUFFER_SIZE,
                 esp32=cv.UNDEFINED,
                 # the pulse ring needs a size; only RMT targets size themselves in setup()
                 **{
-                    f"esp32_{variant.removeprefix('ESP32').lower()}": "1000b"
+                    f"esp32_{variant.removeprefix('ESP32').lower()}": "4000b"
                     for variant in esp32_rmt.VARIANTS_NO_RMT
                 },
-                esp8266="1000b",
-                bk72xx="1000b",
-                ln882x="1000b",
-                rtl87xx="1000b",
-                rp2="1000b",
-            ): cv.All(cv.validate_bytes, cv.int_range(min=64)),
+                esp8266="4000b",
+                bk72xx="4000b",
+                ln882x="4000b",
+                rtl87xx="4000b",
+                rp2="4000b",
+            ): cv.All(cv.validate_bytes, cv.int_range(min=64, max=65535)),
             cv.Optional(CONF_FILTER, default="50us"): cv.All(
                 cv.positive_time_period_microseconds,
                 cv.Range(max=TimePeriod(microseconds=4294967295)),
diff --git a/esphome/components/remote_receiver/remote_receiver.cpp b/esphome/components/remote_receiver/remote_receiver.cpp
index bbcb7ae765b..b3e4649096b 100644
--- a/esphome/components/remote_receiver/remote_receiver.cpp
+++ b/esphome/components/remote_receiver/remote_receiver.cpp
@@ -14,7 +14,7 @@ static void IRAM_ATTR HOT write_value(RemoteReceiverComponentStore *arg, uint32_
   int32_t multiplier = ((int32_t) level << 1) - 1;
   uint32_t buffer_write = arg->buffer_write;
   arg->buffer[buffer_write++] = (int32_t) delta * multiplier;
-  if (buffer_write >= arg->buffer_size) {
+  if (buffer_write >= arg->buffer_entries) {
     buffer_write = 0;
   }
 
@@ -65,8 +65,9 @@ void RemoteReceiverComponent::setup() {
   this->store_.idle_us = this->idle_us_;
   this->store_.filter_us = this->filter_us_;
   this->store_.pin = this->pin_->to_isr();
-  this->store_.buffer = new int32_t[this->buffer_size_];
-  this->store_.buffer_size = this->buffer_size_;
+  // rounded up so a size that is not a multiple of four never holds less than requested
+  this->store_.buffer_entries = (this->buffer_size_ + sizeof(int32_t) - 1) / sizeof(int32_t);
+  this->store_.buffer = new int32_t[this->store_.buffer_entries];
   this->store_.prev_micros = micros();
   this->store_.commit_micros = this->store_.prev_micros;
   this->store_.prev_level = this->pin_->digital_read();
@@ -79,11 +80,11 @@ void RemoteReceiverComponent::dump_config() {
   ESP_LOGCONFIG(
       TAG,
       "Remote Receiver:\n"
-      "  Buffer Size: %" PRIu32 "\n"
+      "  Buffer Size: %" PRIu32 " bytes (%" PRIu32 " pulses)\n"
       "  Tolerance: %" PRIu32 "%s\n"
       "  Filter out pulses shorter than: %" PRIu32 " us\n"
       "  Signal is done after %" PRIu32 " us of no changes",
-      this->buffer_size_, this->tolerance_,
+      this->buffer_size_, this->store_.buffer_entries, this->tolerance_,
       (this->tolerance_mode_ == remote_base::TOLERANCE_MODE_TIME) ? LOG_STR_LITERAL(" us") : LOG_STR_LITERAL("%"),
       this->filter_us_, this->idle_us_);
   LOG_PIN("  Pin: ", this->pin_);
@@ -119,7 +120,7 @@ void RemoteReceiverComponent::loop() {
   while (temp_read != last_index && (uint32_t) std::abs(s.buffer[temp_read]) < this->idle_us_) {
     reserve_size++;
     temp_read++;
-    if (temp_read >= s.buffer_size) {
+    if (temp_read >= s.buffer_entries) {
       temp_read = 0;
     }
   }
@@ -129,7 +130,7 @@ void RemoteReceiverComponent::loop() {
   // read the buffer
   for (uint32_t i = 0; i < reserve_size + 1; i++) {
     this->temp_.push_back((int32_t) s.buffer[s.buffer_read++]);
-    if (s.buffer_read >= s.buffer_size) {
+    if (s.buffer_read >= s.buffer_entries) {
       s.buffer_read = 0;
     }
   }
diff --git a/esphome/components/remote_receiver/remote_receiver.h b/esphome/components/remote_receiver/remote_receiver.h
index e59a8b25573..6f93979b183 100644
--- a/esphome/components/remote_receiver/remote_receiver.h
+++ b/esphome/components/remote_receiver/remote_receiver.h
@@ -30,7 +30,7 @@ struct RemoteReceiverComponentStore {
   uint32_t buffer_read{0};
   volatile uint32_t commit_micros{0};
   volatile uint32_t prev_micros{0};
-  uint32_t buffer_size{1000};
+  uint32_t buffer_entries{0};
   uint32_t filter_us{10};
   uint32_t idle_us{10000};
   ISRInternalGPIOPin pin;
@@ -83,14 +83,14 @@ class RemoteReceiverComponent final : public remote_base::RemoteReceiverBase,
  protected:
 #if defined(USE_ESP32) && SOC_RMT_SUPPORTED
   void decode_rmt_(rmt_symbol_word_t *item, size_t item_count);
+  // log the failed RMT call and mark the component failed
+  void fail_(esp_err_t error, const LogString *reason);
   rmt_channel_handle_t channel_{NULL};
   uint32_t filter_symbols_{0};
   uint32_t receive_symbols_{0};
   bool with_dma_{false};
   uint32_t carrier_frequency_{0};
   uint8_t carrier_duty_percent_{100};
-  esp_err_t error_code_{ESP_OK};
-  std::string error_string_;
 #endif
 
 #if defined(USE_ESP8266) || defined(USE_LIBRETINY) || defined(USE_RP2) || defined(USE_ESP32)
diff --git a/esphome/components/remote_receiver/remote_receiver_rmt.cpp b/esphome/components/remote_receiver/remote_receiver_rmt.cpp
index 4eebbbb16f1..64392aa7eeb 100644
--- a/esphome/components/remote_receiver/remote_receiver_rmt.cpp
+++ b/esphome/components/remote_receiver/remote_receiver_rmt.cpp
@@ -1,5 +1,6 @@
 #include "remote_receiver.h"
 #include "esphome/core/log.h"
+#include "esphome/core/wake.h"
 
 #ifdef USE_ESP32
 #include <soc/soc_caps.h>
@@ -14,25 +15,37 @@ static constexpr uint32_t DEFAULT_BUFFER_SLOTS = 4;
 
 static bool IRAM_ATTR HOT rmt_callback(rmt_channel_handle_t channel, const rmt_rx_done_event_data_t *event, void *arg) {
   RemoteReceiverComponentStore *store = (RemoteReceiverComponentStore *) arg;
-  rmt_rx_done_event_data_t *event_buffer = (rmt_rx_done_event_data_t *) (store->buffer + store->buffer_write);
+  const uint32_t buffer_write = store->buffer_write;
+  rmt_rx_done_event_data_t *event_buffer = (rmt_rx_done_event_data_t *) (store->buffer + buffer_write);
   uint32_t event_size = sizeof(rmt_rx_done_event_data_t);
-  uint32_t next_write = store->buffer_write + event_size + event->num_symbols * sizeof(rmt_symbol_word_t);
+  uint32_t next_write = buffer_write + event_size + event->num_symbols * sizeof(rmt_symbol_word_t);
   if (next_write + event_size + store->receive_size > store->buffer_size) {
     next_write = 0;
   }
   if (store->buffer_read - next_write < event_size + store->receive_size) {
-    next_write = store->buffer_write;
+    next_write = buffer_write;
     store->overflow = true;
   }
   if (event->num_symbols <= store->filter_symbols) {
-    next_write = store->buffer_write;
+    next_write = buffer_write;
   }
   store->error =
       rmt_receive(channel, (uint8_t *) store->buffer + next_write + event_size, store->receive_size, &store->config);
   event_buffer->num_symbols = event->num_symbols;
   event_buffer->received_symbols = event->received_symbols;
+  const bool stored = next_write != buffer_write;
   store->buffer_write = next_write;
-  return false;
+  // a stored frame is decoded, and a failed re-arm reported, on the next loop pass instead of
+  // waiting out the loop interval; filtered noise and dropped frames leave nothing to read
+  BaseType_t task_woken = pdFALSE;
+  if (stored || store->error != ESP_OK)
+    wake_loop_isrsafe(&task_woken);
+  return task_woken != pdFALSE;
+}
+
+void RemoteReceiverComponent::fail_(esp_err_t error, const LogString *reason) {
+  ESP_LOGE(TAG, "RMT driver failed: %s", esp_err_to_name(error));
+  this->mark_failed(reason);
 }
 
 void RemoteReceiverComponent::setup() {
@@ -47,13 +60,8 @@ void RemoteReceiverComponent::setup() {
   channel.flags.with_dma = this->with_dma_;
   esp_err_t error = rmt_new_rx_channel(&channel, &this->channel_);
   if (error != ESP_OK) {
-    this->error_code_ = error;
-    if (error == ESP_ERR_NOT_FOUND) {
-      this->error_string_ = "out of RMT symbol memory";
-    } else {
-      this->error_string_ = "in rmt_new_rx_channel";
-    }
-    this->mark_failed();
+    this->fail_(error,
+                error == ESP_ERR_NOT_FOUND ? LOG_STR("out of RMT symbol memory") : LOG_STR("in rmt_new_rx_channel"));
     return;
   }
   if (this->pin_->get_flags() & gpio::FLAG_PULLUP) {
@@ -63,9 +71,7 @@ void RemoteReceiverComponent::setup() {
   }
   error = rmt_enable(this->channel_);
   if (error != ESP_OK) {
-    this->error_code_ = error;
-    this->error_string_ = "in rmt_enable";
-    this->mark_failed();
+    this->fail_(error, LOG_STR("in rmt_enable"));
     return;
   }
 
@@ -77,9 +83,7 @@ void RemoteReceiverComponent::setup() {
     carrier.flags.polarity_active_low = this->pin_->is_inverted();
     error = rmt_apply_carrier(this->channel_, &carrier);
     if (error != ESP_OK) {
-      this->error_code_ = error;
-      this->error_string_ = "in rmt_apply_carrier";
-      this->mark_failed();
+      this->fail_(error, LOG_STR("in rmt_apply_carrier"));
       return;
     }
   }
@@ -89,9 +93,7 @@ void RemoteReceiverComponent::setup() {
   callbacks.on_recv_done = rmt_callback;
   error = rmt_rx_register_event_callbacks(this->channel_, &callbacks, &this->store_);
   if (error != ESP_OK) {
-    this->error_code_ = error;
-    this->error_string_ = "in rmt_rx_register_event_callbacks";
-    this->mark_failed();
+    this->fail_(error, LOG_STR("in rmt_rx_register_event_callbacks"));
     return;
   }
 
@@ -114,9 +116,7 @@ void RemoteReceiverComponent::setup() {
   error = rmt_receive(this->channel_, (uint8_t *) this->store_.buffer + event_size, this->store_.receive_size,
                       &this->store_.config);
   if (error != ESP_OK) {
-    this->error_code_ = error;
-    this->error_string_ = "in rmt_receive";
-    this->mark_failed();
+    this->fail_(error, LOG_STR("in rmt_receive"));
     return;
   }
 }
@@ -140,18 +140,11 @@ void RemoteReceiverComponent::dump_config() {
       (this->tolerance_mode_ == remote_base::TOLERANCE_MODE_TIME) ? LOG_STR_LITERAL(" us") : LOG_STR_LITERAL("%"),
       this->carrier_frequency_, this->carrier_duty_percent_, this->filter_us_, this->idle_us_);
   LOG_PIN("  Pin: ", this->pin_);
-  if (this->is_failed()) {
-    ESP_LOGE(TAG, "Configuring RMT driver failed: %s (%s)", esp_err_to_name(this->error_code_),
-             this->error_string_.c_str());
-  }
 }
 
 void RemoteReceiverComponent::loop() {
   if (this->store_.error != ESP_OK) {
-    ESP_LOGE(TAG, "Receive error");
-    this->error_code_ = this->store_.error;
-    this->error_string_ = "in rmt_callback";
-    this->mark_failed();
+    this->fail_(this->store_.error, LOG_STR("in rmt_callback"));
   }
   if (this->store_.overflow) {
     ESP_LOGW(TAG, "Buffer overflow");
diff --git a/esphome/components/remote_transmitter/remote_transmitter.h b/esphome/components/remote_transmitter/remote_transmitter.h
index 4db4e80a60e..99e1ce9504d 100644
--- a/esphome/components/remote_transmitter/remote_transmitter.h
+++ b/esphome/components/remote_transmitter/remote_transmitter.h
@@ -141,6 +141,8 @@ class RemoteTransmitterComponent final : public remote_base::RemoteTransmitterBa
 #endif
 
 #if defined(USE_ESP32) && SOC_RMT_SUPPORTED
+  // log the failed RMT call and mark the component failed
+  void fail_(esp_err_t error, const LogString *reason);
   void configure_rmt_();
   void wait_for_rmt_();
 
@@ -156,8 +158,6 @@ class RemoteTransmitterComponent final : public remote_base::RemoteTransmitterBa
   bool eot_level_{false};
   rmt_channel_handle_t channel_{NULL};
   rmt_encoder_handle_t encoder_{NULL};
-  esp_err_t error_code_{ESP_OK};
-  std::string error_string_;
   bool inverted_{false};
   bool non_blocking_{false};
 #endif
diff --git a/esphome/components/remote_transmitter/remote_transmitter_rmt.cpp b/esphome/components/remote_transmitter/remote_transmitter_rmt.cpp
index 3c9a12d472f..6d27be8d472 100644
--- a/esphome/components/remote_transmitter/remote_transmitter_rmt.cpp
+++ b/esphome/components/remote_transmitter/remote_transmitter_rmt.cpp
@@ -51,6 +51,11 @@ static size_t IRAM_ATTR HOT encoder_callback(const void *data, size_t size, size
 }
 #endif
 
+void RemoteTransmitterComponent::fail_(esp_err_t error, const LogString *reason) {
+  ESP_LOGE(TAG, "RMT driver failed: %s", esp_err_to_name(error));
+  this->mark_failed(reason);
+}
+
 void RemoteTransmitterComponent::setup() {
   this->inverted_ = this->pin_->is_inverted();
   this->configure_rmt_();
@@ -67,11 +72,6 @@ void RemoteTransmitterComponent::dump_config() {
   if (this->current_carrier_frequency_ != 0 && this->carrier_duty_percent_ != 100) {
     ESP_LOGCONFIG(TAG, "    Carrier Duty: %u%%", this->carrier_duty_percent_);
   }
-
-  if (this->is_failed()) {
-    ESP_LOGE(TAG, "Configuring RMT driver failed: %s (%s)", esp_err_to_name(this->error_code_),
-             this->error_string_.c_str());
-  }
 }
 
 void RemoteTransmitterComponent::digital_write(bool value) {
@@ -129,13 +129,8 @@ void RemoteTransmitterComponent::configure_rmt_() {
 #endif
     error = rmt_new_tx_channel(&channel, &this->channel_);
     if (error != ESP_OK) {
-      this->error_code_ = error;
-      if (error == ESP_ERR_NOT_FOUND) {
-        this->error_string_ = "out of RMT symbol memory";
-      } else {
-        this->error_string_ = "in rmt_new_tx_channel";
-      }
-      this->mark_failed();
+      this->fail_(error,
+                  error == ESP_ERR_NOT_FOUND ? LOG_STR("out of RMT symbol memory") : LOG_STR("in rmt_new_tx_channel"));
       return;
     }
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0)
@@ -159,9 +154,7 @@ void RemoteTransmitterComponent::configure_rmt_() {
     encoder.min_chunk_size = 1;
     error = rmt_new_simple_encoder(&encoder, &this->encoder_);
     if (error != ESP_OK) {
-      this->error_code_ = error;
-      this->error_string_ = "in rmt_new_simple_encoder";
-      this->mark_failed();
+      this->fail_(error, LOG_STR("in rmt_new_simple_encoder"));
       return;
     }
 #else
@@ -169,18 +162,14 @@ void RemoteTransmitterComponent::configure_rmt_() {
     memset(&encoder, 0, sizeof(encoder));
     error = rmt_new_copy_encoder(&encoder, &this->encoder_);
     if (error != ESP_OK) {
-      this->error_code_ = error;
-      this->error_string_ = "in rmt_new_copy_encoder";
-      this->mark_failed();
+      this->fail_(error, LOG_STR("in rmt_new_copy_encoder"));
       return;
     }
 #endif
 
     error = rmt_enable(this->channel_);
     if (error != ESP_OK) {
-      this->error_code_ = error;
-      this->error_string_ = "in rmt_enable";
-      this->mark_failed();
+      this->fail_(error, LOG_STR("in rmt_enable"));
       return;
     }
     this->digital_write(open_drain || this->inverted_);
@@ -199,9 +188,7 @@ void RemoteTransmitterComponent::configure_rmt_() {
     error = rmt_apply_carrier(this->channel_, &carrier);
   }
   if (error != ESP_OK) {
-    this->error_code_ = error;
-    this->error_string_ = "in rmt_apply_carrier";
-    this->mark_failed();
+    this->fail_(error, LOG_STR("in rmt_apply_carrier"));
     return;
   }
 }
diff --git a/esphome/components/restart/button/restart_button.h b/esphome/components/restart/button/restart_button.h
index 974db0cec48..4baac6472c1 100644
--- a/esphome/components/restart/button/restart_button.h
+++ b/esphome/components/restart/button/restart_button.h
@@ -7,6 +7,9 @@ namespace esphome::restart {
 
 class RestartButton final : public button::Button, public Component {
  public:
+  // User provided, not "= default": `new(p) RestartButton()` would zero-fill .bss that is already zero.
+  RestartButton() {}
+
   void dump_config() override;
 
  protected:
diff --git a/esphome/components/restart/switch/restart_switch.h b/esphome/components/restart/switch/restart_switch.h
index dc9ec8eadcd..03cf03f1662 100644
--- a/esphome/components/restart/switch/restart_switch.h
+++ b/esphome/components/restart/switch/restart_switch.h
@@ -7,6 +7,9 @@ namespace esphome::restart {
 
 class RestartSwitch final : public switch_::Switch, public Component {
  public:
+  // User provided, not "= default": `new(p) RestartSwitch()` would zero-fill .bss that is already zero.
+  RestartSwitch() {}
+
   void dump_config() override;
 
  protected:
diff --git a/esphome/components/rp2/__init__.py b/esphome/components/rp2/__init__.py
index dae7df26c32..a1bbf6a3d66 100644
--- a/esphome/components/rp2/__init__.py
+++ b/esphome/components/rp2/__init__.py
@@ -197,20 +197,20 @@ def _parse_platform_version(value: Any) -> str:
 
 # The default/recommended arduino framework version
 #  - https://github.com/earlephilhower/arduino-pico/releases
-RECOMMENDED_ARDUINO_FRAMEWORK_VERSION = cv.Version(6, 0, 0)
+RECOMMENDED_ARDUINO_FRAMEWORK_VERSION = cv.Version(6, 1, 0)
 
 # The raspberrypi platform version to use for arduino frameworks
 #  - https://github.com/maxgerhardt/platform-raspberrypi/tags
-# develop-branch commit carrying the arduino-pico 6.0.0 / pico-quick-toolchain
-# 5.0.0 (GCC 16.1) update; replace with a release tag when one is cut
-RECOMMENDED_ARDUINO_PLATFORM_VERSION = "9c167c6b8aac4f4cfa6d55a0c4e5b848795150c0"
+# develop-branch commit carrying the arduino-pico 6.1.0 update and the board
+# JSON files it adds; replace with a release tag when one is cut
+RECOMMENDED_ARDUINO_PLATFORM_VERSION = "5d4561a05e3b212660ac6fdd3fbfb328d1988aa1"
 
 
 def _arduino_check_versions(value: ConfigType) -> ConfigType:
     value = value.copy()
     lookups = {
-        "dev": (cv.Version(6, 0, 0), "https://github.com/earlephilhower/arduino-pico"),
-        "latest": (cv.Version(6, 0, 0), None),
+        "dev": (cv.Version(6, 1, 0), "https://github.com/earlephilhower/arduino-pico"),
+        "latest": (cv.Version(6, 1, 0), None),
         "recommended": (RECOMMENDED_ARDUINO_FRAMEWORK_VERSION, None),
     }
 
diff --git a/esphome/components/rp2/boards.py b/esphome/components/rp2/boards.py
index 4b2f9769b01..a9ce11c33dc 100644
--- a/esphome/components/rp2/boards.py
+++ b/esphome/components/rp2/boards.py
@@ -1135,6 +1135,18 @@ RP2_BOARD_PINS = {
         "SS": 5,
         "TX": 0,
     },
+    "soldered_nula_node_rp2040": {
+        "MISO": 16,
+        "MOSI": 19,
+        "RX": 1,
+        "SCK": 18,
+        "SCL": 9,
+        "SCL1": 11,
+        "SDA": 8,
+        "SDA1": 10,
+        "SS": 17,
+        "TX": 0,
+    },
     "soldered_nula_rp2350": {
         "MISO": 2,
         "MOSI": 3,
@@ -2127,6 +2139,12 @@ BOARDS = {
         "mcu": "rp2040",
         "max_pin": 29,
     },
+    "soldered_nula_node_rp2040": {
+        "name": "Soldered Electronics NULA Node",
+        "mcu": "rp2040",
+        "max_pin": 29,
+        "wifi": True,
+    },
     "soldered_nula_rp2350": {
         "name": "Soldered Electronics NULA RP2350",
         "mcu": "rp2350",
diff --git a/esphome/components/rp2/crash_handler.cpp b/esphome/components/rp2/crash_handler.cpp
index a0fea216371..9bcdc8bee4e 100644
--- a/esphome/components/rp2/crash_handler.cpp
+++ b/esphome/components/rp2/crash_handler.cpp
@@ -55,8 +55,7 @@ namespace esphome::rp2 {
 
 static const char *const TAG = "rp2.crash";
 
-// Placed in .noinit so BSS zero-init cannot race with crash_handler_read_and_clear().
-// The valid field is explicitly cleared in crash_handler_read_and_clear() instead.
+// Filled from the watchdog scratch registers on the first read.
 static struct CrashData {
   bool valid;
   uint32_t pc;
@@ -64,11 +63,24 @@ static struct CrashData {
   uint32_t sp;
   uint32_t backtrace[MAX_BACKTRACE];
   uint8_t backtrace_count;
-} s_crash_data __attribute__((section(".noinit")));  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+} s_crash_data;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-bool crash_handler_has_data() { return s_crash_data.valid; }
+// Logger::pre_setup() logs the record before App.pre_setup() reaches
+// arch_init(), so the first caller reads it and later calls are no-ops.
+// The read clears the scratch registers, so it must not run twice, and
+// arch_init() keeps its call so the read precedes watchdog_enable(), which
+// overwrites scratch[4].
+static bool s_crash_data_read = false;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+bool crash_handler_has_data() {
+  crash_handler_read_and_clear();
+  return s_crash_data.valid;
+}
 
 void crash_handler_read_and_clear() {
+  if (s_crash_data_read)
+    return;
+  s_crash_data_read = true;
   s_crash_data.valid = false;
   uint32_t magic = watchdog_hw->scratch[0];
   if ((magic & 0xFFFF0000) == CRASH_MAGIC_SENTINEL && (magic & 0xFFFF) == CRASH_DATA_VERSION) {
@@ -97,7 +109,7 @@ void crash_handler_read_and_clear() {
 // the device crashes again during boot, and allowing the CLI's process_stacktrace
 // to match and decode each address individually.
 void crash_handler_log() {
-  if (!s_crash_data.valid)
+  if (!crash_handler_has_data())
     return;
 
   ESP_LOGE(TAG, "*** CRASH DETECTED ON PREVIOUS BOOT ***");
diff --git a/esphome/components/rp2/crash_handler.h b/esphome/components/rp2/crash_handler.h
index 8c43d9fd3b0..3aec80b63b2 100644
--- a/esphome/components/rp2/crash_handler.h
+++ b/esphome/components/rp2/crash_handler.h
@@ -9,12 +9,13 @@
 namespace esphome::rp2 {
 
 /// Read crash data from watchdog scratch registers and clear them.
+/// Only the first call reads; later calls are no-ops.
 void crash_handler_read_and_clear();
 
 /// Log crash data if a crash was detected on previous boot.
 void crash_handler_log();
 
-/// Returns true if crash data was found this boot.
+/// Returns true if crash data was found this boot, reading it first if needed.
 bool crash_handler_has_data();
 
 }  // namespace esphome::rp2
diff --git a/esphome/components/rp2040_ble/btstack_memory.cpp b/esphome/components/rp2040_ble/btstack_memory.cpp
index 8af57924a2b..699555f623f 100644
--- a/esphome/components/rp2040_ble/btstack_memory.cpp
+++ b/esphome/components/rp2040_ble/btstack_memory.cpp
@@ -20,7 +20,7 @@
 namespace esphome::rp2040_ble {
 namespace {
 
-// Pinned against arduino-pico 6.0.0's prebuilt archives: a framework bump (or
+// Pinned against arduino-pico 6.1.0's prebuilt archives: a framework bump (or
 // a changed ENABLE_* macro) shifting the struct layout must fail the build
 // here, not overrun the pool blocks at runtime. Sizes differ per core
 // architecture (measured from each archive's own storage symbols). GCC only:
diff --git a/esphome/components/rpi_dpi_rgb/rpi_dpi_rgb.cpp b/esphome/components/rpi_dpi_rgb/rpi_dpi_rgb.cpp
index c0afc0607e0..f2f25741f33 100644
--- a/esphome/components/rpi_dpi_rgb/rpi_dpi_rgb.cpp
+++ b/esphome/components/rpi_dpi_rgb/rpi_dpi_rgb.cpp
@@ -101,7 +101,7 @@ int RpiDpiRgb::get_height() {
 }
 
 void RpiDpiRgb::draw_pixel_at(int x, int y, Color color) {
-  if (!this->get_clipping().inside(x, y))
+  if (this->is_point_clipped(x, y))
     return;  // NOLINT
 
   switch (this->rotation_) {
@@ -124,7 +124,7 @@ void RpiDpiRgb::draw_pixel_at(int x, int y, Color color) {
 
   this->draw_pixels_at(x, y, 1, 1, (const uint8_t *) &pixel, display::COLOR_ORDER_RGB, display::COLOR_BITNESS_565, true,
                        0, 0, 0);
-  App.feed_wdt();
+  this->feed_wdt_per_pixel_();
 }
 
 void RpiDpiRgb::dump_config() {
diff --git a/esphome/components/safe_mode/safe_mode.h b/esphome/components/safe_mode/safe_mode.h
index 0633c92a789..903d9eb79fd 100644
--- a/esphome/components/safe_mode/safe_mode.h
+++ b/esphome/components/safe_mode/safe_mode.h
@@ -17,6 +17,9 @@ constexpr uint32_t RTC_KEY = 233825507UL;
 /// SafeModeComponent provides a safe way to recover from repeated boot failures
 class SafeModeComponent final : public Component {
  public:
+  // User provided, not "= default": `new(p) SafeModeComponent()` would zero-fill .bss that is already zero.
+  SafeModeComponent() {}
+
   bool should_enter_safe_mode(uint8_t num_attempts, uint32_t enable_time, uint32_t boot_is_good_after, bool in_flash);
 
   /// Set to true if the next startup will enter safe mode
diff --git a/esphome/components/scd4x/automation.h b/esphome/components/scd4x/automation.h
index 4746c0c879c..e0cc04e2cb7 100644
--- a/esphome/components/scd4x/automation.h
+++ b/esphome/components/scd4x/automation.h
@@ -9,6 +9,10 @@ namespace esphome::scd4x {
 template<typename... Ts>
 class PerformForcedCalibrationAction final : public Action<Ts...>, public Parented<SCD4XComponent> {
  public:
+  // User provided, not "= default": `new(p) PerformForcedCalibrationAction()` would zero-fill .bss that is already
+  // zero.
+  PerformForcedCalibrationAction() {}
+
   void play(const Ts &...x) override {
     if (this->value_.has_value()) {
       this->parent_->perform_forced_calibration(this->value_.value(x...));
diff --git a/esphome/components/sdl/sdl_esphome.cpp b/esphome/components/sdl/sdl_esphome.cpp
index 03fc086021a..a764b74581f 100644
--- a/esphome/components/sdl/sdl_esphome.cpp
+++ b/esphome/components/sdl/sdl_esphome.cpp
@@ -164,7 +164,7 @@ void Sdl::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *
 }
 
 void Sdl::draw_pixel_at(int x, int y, Color color) {
-  if (this->texture_ == nullptr || !this->get_clipping().inside(x, y))
+  if (this->texture_ == nullptr || this->is_point_clipped(x, y))
     return;
 
   if (this->rotation_ == display::DISPLAY_ROTATION_180_DEGREES) {
diff --git a/esphome/components/sds011/sds011.cpp b/esphome/components/sds011/sds011.cpp
index 1c222e5e803..dfc7857266d 100644
--- a/esphome/components/sds011/sds011.cpp
+++ b/esphome/components/sds011/sds011.cpp
@@ -106,8 +106,6 @@ void SDS011Component::loop() {
   }
 }
 
-void SDS011Component::set_rx_mode_only(bool rx_mode_only) { this->rx_mode_only_ = rx_mode_only; }
-
 void SDS011Component::sds011_write_command_(const uint8_t *command_data) {
   this->write_byte(SDS011_MSG_HEAD);
   this->write_byte(SDS011_COMMAND_ID_REQUEST);
diff --git a/esphome/components/sds011/sds011.h b/esphome/components/sds011/sds011.h
index 4f4571ab693..0a896cdc4cd 100644
--- a/esphome/components/sds011/sds011.h
+++ b/esphome/components/sds011/sds011.h
@@ -12,7 +12,7 @@ class SDS011Component final : public Component, public uart::UARTDevice {
   SDS011Component() = default;
 
   /// Manually set the rx-only mode. Defaults to false.
-  void set_rx_mode_only(bool rx_mode_only);
+  void set_rx_mode_only(bool rx_mode_only) { this->rx_mode_only_ = rx_mode_only; }
 
   void set_pm_2_5_sensor(sensor::Sensor *pm_2_5_sensor) { pm_2_5_sensor_ = pm_2_5_sensor; }
   void set_pm_10_0_sensor(sensor::Sensor *pm_10_0_sensor) { pm_10_0_sensor_ = pm_10_0_sensor; }
diff --git a/esphome/components/sendspin/__init__.py b/esphome/components/sendspin/__init__.py
index fda4d4f954c..49bee109361 100644
--- a/esphome/components/sendspin/__init__.py
+++ b/esphome/components/sendspin/__init__.py
@@ -2,7 +2,7 @@ from dataclasses import dataclass, field
 
 from esphome import automation
 import esphome.codegen as cg
-from esphome.components import esp32, network, psram, socket, wifi
+from esphome.components import esp32, mdns, network, psram, socket, wifi
 from esphome.components.const import CONF_MANUFACTURER
 import esphome.config_validation as cv
 from esphome.const import (
@@ -11,6 +11,7 @@ from esphome.const import (
     CONF_FORMAT,
     CONF_HEIGHT,
     CONF_ID,
+    CONF_MDNS,
     CONF_MODEL,
     CONF_NAME,
     CONF_PROJECT,
@@ -281,10 +282,15 @@ async def to_code(config: ConfigType) -> None:
             cg.add(setter(value))
 
     # sendspin-cpp library
-    esp32.add_idf_component(name="sendspin/sendspin-cpp", ref="0.7.2")
+    esp32.add_idf_component(name="sendspin/sendspin-cpp", ref="0.8.0")
 
     cg.add_define("USE_SENDSPIN", True)  # for MDNS
 
+    # Service starts disabled and the hub enables it; always advertised where unsupported
+    if mdns.request_service_enable_disable():
+        mdns_var = await cg.get_variable(CORE.config[CONF_MDNS][CONF_ID])
+        cg.add(var.set_mdns(mdns_var))
+
     data = _get_data()
 
     # The color role is not yet wired up in ESPHome; disable it in the library for now.
diff --git a/esphome/components/sendspin/media_player/sendspin_media_player.cpp b/esphome/components/sendspin/media_player/sendspin_media_player.cpp
index fe0bda6f421..59ead1bb539 100644
--- a/esphome/components/sendspin/media_player/sendspin_media_player.cpp
+++ b/esphome/components/sendspin/media_player/sendspin_media_player.cpp
@@ -97,6 +97,10 @@ void SendspinMediaPlayer::control(const media_player::MediaPlayerCall &call) {
     // Ignore any commands sent before the media player is setup
     return;
   }
+  if (!this->parent_->is_client_running()) {
+    ESP_LOGW(TAG, "Cannot control media player: Sendspin is disabled");
+    return;
+  }
 
   auto volume = call.get_volume();
   if (volume.has_value()) {
diff --git a/esphome/components/sendspin/media_source/sendspin_media_source.cpp b/esphome/components/sendspin/media_source/sendspin_media_source.cpp
index 88ff234e831..c3fb1fe1cbd 100644
--- a/esphome/components/sendspin/media_source/sendspin_media_source.cpp
+++ b/esphome/components/sendspin/media_source/sendspin_media_source.cpp
@@ -45,6 +45,8 @@ bool SendspinMediaSource::can_handle(const std::string &uri) const { return uri.
 
 // THREAD CONTEXT: Main loop (media_source.h documents play_uri as main-loop only)
 bool SendspinMediaSource::play_uri(const std::string &uri) {
+  // The queued request has been delivered, whatever the outcome, so the next stream start may request again
+  this->pending_start_ = false;
   if (!this->is_ready() || this->is_failed() || !this->has_listener()) {
     return false;
   }
@@ -54,6 +56,11 @@ bool SendspinMediaSource::play_uri(const std::string &uri) {
     return false;
   }
 
+  if (!this->parent_->is_client_running()) {
+    ESP_LOGE(TAG, "Cannot play '%s': Sendspin is disabled", uri.c_str());
+    return false;
+  }
+
   if (!uri.starts_with(URI_PREFIX)) {
     ESP_LOGE(TAG, "Invalid URI: '%s'", uri.c_str());
     return false;
@@ -74,7 +81,6 @@ bool SendspinMediaSource::play_uri(const std::string &uri) {
   }
 
   // Tell the orchestrator we're now playing so it routes audio output from us
-  this->pending_start_ = false;
   this->set_state_(media_source::MediaSourceState::PLAYING);
 
   return true;
@@ -82,6 +88,15 @@ bool SendspinMediaSource::play_uri(const std::string &uri) {
 
 // THREAD CONTEXT: Main loop (media_source.h documents handle_command as main-loop only)
 void SendspinMediaSource::handle_command(media_source::MediaSourceCommand command) {
+  if (!this->parent_->is_client_running()) {
+    if (command == media_source::MediaSourceCommand::STOP) {
+      // Nothing is playing, so the orchestrator gets its pipeline back straight away
+      this->on_stream_end();
+    } else {
+      ESP_LOGW(TAG, "Cannot handle command: Sendspin is disabled");
+    }
+    return;
+  }
   switch (command) {
     case media_source::MediaSourceCommand::STOP: {
       if (!this->pending_start_) {
diff --git a/esphome/components/sendspin/sendspin_hub.cpp b/esphome/components/sendspin/sendspin_hub.cpp
index 2cb2b909951..58ec57c7681 100644
--- a/esphome/components/sendspin/sendspin_hub.cpp
+++ b/esphome/components/sendspin/sendspin_hub.cpp
@@ -62,14 +62,26 @@ void SendspinHub::setup() {
   this->client_->add_player(this->player_config_).set_listener(this->player_listener_);
 #endif
 
-  if (!this->client_->start_server()) {
-    ESP_LOGE(TAG, "Failed to start Sendspin server");
-    this->mark_failed();
-    return;
-  }
+#ifndef USE_SENDSPIN_SWITCH
+  this->enabled_ = true;
+#endif
 }
 
-void SendspinHub::loop() { this->client_->loop(); }
+void SendspinHub::loop() {
+  if (this->enabled_.has_value() && this->enabled_.value() != this->client_->is_started() &&
+      !this->status_has_error()) {
+    if (!this->enabled_.value()) {
+      this->client_->stop();
+    } else if (!this->client_->start()) {
+      this->status_set_error(LOG_STR("Failed to start Sendspin client"));
+    }
+  }
+  this->client_->loop();
+
+#ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
+  this->update_mdns_service_();
+#endif
+}
 
 void SendspinHub::dump_config() {
   char mac_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
@@ -96,25 +108,54 @@ void SendspinHub::dump_config() {
 #endif
 }
 
+// THREAD CONTEXT: Main loop (invoked from Sendspin components)
+void SendspinHub::set_enabled(bool enabled) {
+  if (this->status_has_error()) {
+    ESP_LOGE(TAG, "Cannot %s: Sendspin failed to start, reboot to retry",
+             enabled ? LOG_STR_LITERAL("enable") : LOG_STR_LITERAL("disable"));
+    return;
+  }
+  this->enabled_ = enabled;
+}
+
+#ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
+// THREAD CONTEXT: Main loop
+void SendspinHub::update_mdns_service_() {
+  // Synced from loop() because mdns sets up after this hub and only builds its service list then.
+  if (!this->mdns_->is_ready()) {
+    return;
+  }
+  bool advertise = this->client_->is_started();
+  if (advertise == this->mdns_advertised_) {
+    return;
+  }
+  // One attempt per change
+  this->mdns_advertised_ = advertise;
+  if (!this->mdns_->set_service_enabled("_sendspin", "_tcp", advertise)) {
+    ESP_LOGE(TAG, "Failed to %s mDNS service", advertise ? LOG_STR_LITERAL("enable") : LOG_STR_LITERAL("disable"));
+  }
+}
+#endif
+
 // --- Delegating methods ---
 
 // THREAD CONTEXT: Main loop (invoked from Sendspin components)
 void SendspinHub::connect_to_server(const std::string &url) {
-  if (this->is_ready()) {
+  if (this->is_client_running()) {
     this->client_->connect_to(url);
   }
 }
 
 // THREAD CONTEXT: Main loop (invoked from Sendspin components)
 void SendspinHub::disconnect_from_server(sendspin::SendspinGoodbyeReason reason) {
-  if (this->is_ready()) {
+  if (this->is_client_running()) {
     this->client_->disconnect(reason);
   }
 }
 
 // THREAD CONTEXT: Main loop (invoked from Sendspin components)
 void SendspinHub::update_state(sendspin::SendspinClientState state) {
-  if (this->is_ready()) {
+  if (this->is_client_running()) {
     this->client_->update_state(state);
   }
 }
@@ -233,7 +274,7 @@ void SendspinHub::artwork_frame_done(uint8_t slot) {
 // THREAD CONTEXT: Main loop (invoked from ESPHome actions / other components)
 void SendspinHub::send_client_command(sendspin::SendspinControllerCommand command, std::optional<uint8_t> volume,
                                       std::optional<bool> mute) {
-  if (this->is_ready()) {
+  if (this->is_client_running()) {
     sendspin::ClientCommandControllerObject obj = {
         .command = command,
         .volume = volume,
diff --git a/esphome/components/sendspin/sendspin_hub.h b/esphome/components/sendspin/sendspin_hub.h
index c66c7db3ccb..b00fdc436eb 100644
--- a/esphome/components/sendspin/sendspin_hub.h
+++ b/esphome/components/sendspin/sendspin_hub.h
@@ -10,6 +10,10 @@
 #include "esphome/core/preferences.h"
 #include "esphome/core/version.h"
 
+#ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
+#include "esphome/components/mdns/mdns_component.h"
+#endif
+
 #include <sendspin/client.h>
 #include <sendspin/config.h>
 #include <sendspin/types.h>
@@ -93,7 +97,7 @@ class SendspinHub final : public Component,
 
   /// @brief Connects the underlying client to the given Sendspin server.
   ///
-  /// No-op if the hub's client is not ready (e.g. setup() has not completed).
+  /// No-op if the hub's client is not running (see is_client_running()).
   /// Must be called from the main loop thread.
   /// @param url WebSocket URL of the Sendspin server, starting with `ws://` (e.g. `ws://host:port/path`).
   void connect_to_server(const std::string &url);
@@ -101,7 +105,7 @@ class SendspinHub final : public Component,
   /// @brief Disconnects the underlying client from the current server.
   ///
   /// Sends a `client/goodbye` message with the given reason before closing the connection.
-  /// No-op if the hub's client is not ready. Must be called from the main loop thread.
+  /// No-op if the hub's client is not running. Must be called from the main loop thread.
   /// @param reason Reason reported to the server:
   ///   - `ANOTHER_SERVER`: client is switching to another server.
   ///   - `SHUTDOWN`: client is shutting down.
@@ -111,7 +115,7 @@ class SendspinHub final : public Component,
 
   /// @brief Updates the client's reported playback state on the server.
   ///
-  /// No-op if the hub's client is not ready. Must be called from the main loop thread.
+  /// No-op if the hub's client is not running. Must be called from the main loop thread.
   /// @param state New client state:
   ///   - `SYNCHRONIZED`: client is synchronized and playing from the server.
   ///   - `ERROR`: client encountered a playback error.
@@ -126,6 +130,17 @@ class SendspinHub final : public Component,
 
   void set_task_stack_in_psram(bool task_stack_in_psram) { this->task_stack_in_psram_ = task_stack_in_psram; }
 
+  /// @brief Requests the Sendspin client, including the server, the roles and the mDNS advertisement, to start or
+  /// stop.
+  ///
+  /// Applied from the hub's loop(). Stopping blocks until the client is fully stopped; the roles' clear callbacks
+  /// fire from inside that call. With a sendspin switch configured the client stays stopped until the switch has
+  /// called this once. Must be called from the main loop thread.
+  void set_enabled(bool enabled);
+
+  /// @brief Returns whether the Sendspin client is running.
+  bool is_client_running() const { return this->client_ != nullptr && this->client_->is_started(); }
+
   /// @brief Sets the device information reported to the server in the `client/hello` message.
   ///
   /// Each takes a pointer to a string literal emitted by codegen, so it must stay valid for the
@@ -135,6 +150,10 @@ class SendspinHub final : public Component,
   void set_model(const char *model) { this->model_ = model; }
   void set_firmware_version(const char *firmware_version) { this->firmware_version_ = firmware_version; }
 
+#ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
+  void set_mdns(mdns::MDNSComponent *mdns) { this->mdns_ = mdns; }
+#endif
+
   // --- Sendspin role specific methods ---
 
 #ifdef USE_SENDSPIN_ARTWORK
@@ -204,6 +223,11 @@ class SendspinHub final : public Component,
   /// Uses the ethernet MAC if ethernet is configured, otherwise the base MAC (used by wifi).
   static const char *get_client_id_into_buffer(std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf);
 
+#ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
+  /// @brief Keeps the `_sendspin` mDNS service advertised while the client is running.
+  void update_mdns_service_();
+#endif
+
   // --- SendspinClientListener overrides ---
   void on_group_update(const sendspin::GroupUpdateObject &group) override;
 
@@ -282,11 +306,19 @@ class SendspinHub final : public Component,
 
   bool task_stack_in_psram_{false};
 
+  // Requested client state, applied from loop(). Empty until the switch restores its state.
+  std::optional<bool> enabled_;
+
   // Device information sent in the `client/hello` message. Defaults apply when neither the
   // sendspin configuration nor the project information supplies a value.
   const char *manufacturer_{"ESPHome"};
   const char *model_{nullptr};  // nullptr reports the device name instead
   const char *firmware_version_{ESPHOME_VERSION};
+
+#ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
+  mdns::MDNSComponent *mdns_{nullptr};
+  bool mdns_advertised_{false};  // Last state requested from mdns
+#endif
 };
 
 /// @brief Base class for all sendspin subcomponents.
diff --git a/esphome/components/sendspin/switch/__init__.py b/esphome/components/sendspin/switch/__init__.py
new file mode 100644
index 00000000000..63f5f7ad28b
--- /dev/null
+++ b/esphome/components/sendspin/switch/__init__.py
@@ -0,0 +1,31 @@
+import esphome.codegen as cg
+from esphome.components import switch
+import esphome.config_validation as cv
+from esphome.const import ENTITY_CATEGORY_CONFIG
+from esphome.types import ConfigType
+
+from .. import CONF_SENDSPIN_ID, SendspinHub, sendspin_ns
+
+CODEOWNERS = ["@kahrendt"]
+DEPENDENCIES = ["sendspin"]
+
+SendspinSwitch = sendspin_ns.class_("SendspinSwitch", switch.Switch, cg.Component)
+
+CONFIG_SCHEMA = cv.All(
+    switch.switch_schema(
+        SendspinSwitch,
+        block_inverted=True,
+        default_restore_mode="RESTORE_DEFAULT_ON",
+        entity_category=ENTITY_CATEGORY_CONFIG,
+    )
+    .extend({cv.GenerateID(CONF_SENDSPIN_ID): cv.use_id(SendspinHub)})
+    .extend(cv.COMPONENT_SCHEMA),
+    cv.only_on_esp32,
+)
+
+
+async def to_code(config: ConfigType) -> None:
+    var = await switch.new_switch(config)
+    await cg.register_component(var, config)
+    await cg.register_parented(var, config[CONF_SENDSPIN_ID])
+    cg.add_define("USE_SENDSPIN_SWITCH", True)
diff --git a/esphome/components/sendspin/switch/sendspin_switch.cpp b/esphome/components/sendspin/switch/sendspin_switch.cpp
new file mode 100644
index 00000000000..0bf029d4c77
--- /dev/null
+++ b/esphome/components/sendspin/switch/sendspin_switch.cpp
@@ -0,0 +1,26 @@
+#include "sendspin_switch.h"
+
+#ifdef USE_ESP32
+
+#include "esphome/core/log.h"
+
+namespace esphome::sendspin_ {
+
+static const char *const TAG = "sendspin.switch";
+
+void SendspinSwitch::setup() {
+  // The hub waits for this request, so a restore mode without a state still has to answer.
+  this->control(this->get_initial_state_with_restore_mode().value_or(true));
+}
+
+void SendspinSwitch::dump_config() { LOG_SWITCH("", "Sendspin Switch", this); }
+
+// THREAD CONTEXT: Main loop
+void SendspinSwitch::write_state(bool state) {
+  this->parent_->set_enabled(state);
+  this->publish_state(state);
+}
+
+}  // namespace esphome::sendspin_
+
+#endif  // USE_ESP32
diff --git a/esphome/components/sendspin/switch/sendspin_switch.h b/esphome/components/sendspin/switch/sendspin_switch.h
new file mode 100644
index 00000000000..253d952b220
--- /dev/null
+++ b/esphome/components/sendspin/switch/sendspin_switch.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_ESP32
+
+#include "esphome/components/sendspin/sendspin_hub.h"
+#include "esphome/components/switch/switch.h"
+
+namespace esphome::sendspin_ {
+
+/// @brief Switch that starts and stops the Sendspin client through the hub (see SendspinHub::set_enabled()).
+class SendspinSwitch final : public switch_::Switch, public SendspinChild {
+ public:
+  void setup() override;
+  void dump_config() override;
+
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace esphome::sendspin_
+
+#endif  // USE_ESP32
diff --git a/esphome/components/sensor/sensor.cpp b/esphome/components/sensor/sensor.cpp
index 59e011932b1..bee5d7c6d33 100644
--- a/esphome/components/sensor/sensor.cpp
+++ b/esphome/components/sensor/sensor.cpp
@@ -40,10 +40,7 @@ const LogString *state_class_to_string(StateClass state_class) {
   return StateClassStrings::get_log_str(static_cast<uint8_t>(state_class), 0);
 }
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-Sensor::Sensor() : state(NAN), raw_state(NAN) {}
-#pragma GCC diagnostic pop
+Sensor::Sensor() : state(NAN) {}
 
 int8_t Sensor::get_accuracy_decimals() {
   if (this->sensor_flags_.has_accuracy_override)
@@ -66,11 +63,8 @@ StateClass Sensor::get_state_class() {
 }
 
 void Sensor::publish_state(float state) {
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-  this->raw_state = state;
-#pragma GCC diagnostic pop
 #ifdef USE_SENSOR_FILTER
+  this->raw_state_ = state;
   this->raw_callback_.call(state);
 #endif
 
diff --git a/esphome/components/sensor/sensor.h b/esphome/components/sensor/sensor.h
index f4ea4af9851..20288fa88e0 100644
--- a/esphome/components/sensor/sensor.h
+++ b/esphome/components/sensor/sensor.h
@@ -96,18 +96,20 @@ class Sensor : public EntityBase {
 
   /// Getter-syntax for .state.
   float get_state() const { return this->state; }
-  /// Getter-syntax for .raw_state
+  /// Get the last state received by publish_state(), before any filters were applied.
   float get_raw_state() const {
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-    return this->raw_state;
-#pragma GCC diagnostic pop
+#ifdef USE_SENSOR_FILTER
+    return this->raw_state_;
+#else
+    return this->state;  // No filters compiled in, raw == filtered
+#endif
   }
 
   /** Publish a new state to the front-end.
    *
-   * First, the new state will be assigned to the raw_value. Then it's passed through all filters
-   * until it finally lands in the .value member variable and a callback is issued.
+   * The value is passed through the filter chain (when filters are compiled in) before landing in
+   * the `state` member and triggering the state callback. The pre-filter value is available via
+   * get_raw_state().
    *
    * @param state The state as a floating point number.
    */
@@ -137,17 +139,11 @@ class Sensor : public EntityBase {
    */
   float state;
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-  /// @deprecated Use get_raw_state() instead. This member will be removed in ESPHome 2026.10.0.
-  ESPDEPRECATED("Use get_raw_state() instead of .raw_state. Will be removed in 2026.10.0", "2026.4.0")
-  float raw_state;
-#pragma GCC diagnostic pop
-
   void internal_send_state_to_frontend(float state);
 
  protected:
 #ifdef USE_SENSOR_FILTER
+  float raw_state_{NAN};                           ///< The last state passed to publish_state(), before filters.
   LazyCallbackManager<void(float)> raw_callback_;  ///< Storage for raw state callbacks.
 #endif
   LazyCallbackManager<void(float)> callback_;  ///< Storage for filtered state callbacks.
diff --git a/esphome/components/speaker/media_player/__init__.py b/esphome/components/speaker/media_player/__init__.py
index 90eb19d73df..e1808889f4b 100644
--- a/esphome/components/speaker/media_player/__init__.py
+++ b/esphome/components/speaker/media_player/__init__.py
@@ -1,7 +1,5 @@
 """Speaker Media Player Setup."""
 
-import logging
-
 from esphome import automation
 import esphome.codegen as cg
 from esphome.components import (
@@ -33,9 +31,6 @@ from esphome.const import (
     CONF_TASK_STACK_IN_PSRAM,
 )
 
-_LOGGER = logging.getLogger(__name__)
-
-
 AUTO_LOAD = ["audio"]
 DEPENDENCIES = ["network"]
 
@@ -44,7 +39,7 @@ DOMAIN = "media_player"
 
 CONF_ANNOUNCEMENT = "announcement"
 CONF_ANNOUNCEMENT_PIPELINE = "announcement_pipeline"
-CONF_CODEC_SUPPORT_ENABLED = "codec_support_enabled"  # Remove before 2026.10.0
+CONF_CODEC_SUPPORT_ENABLED = "codec_support_enabled"  # Remove before 2027.4.0
 CONF_ENQUEUE = "enqueue"
 CONF_MEDIA_FILE = "media_file"
 CONF_MEDIA_PIPELINE = "media_pipeline"
@@ -103,15 +98,6 @@ def _validate_repeated_speaker(config):
 
 
 def _final_validate(config):
-    # Remove before 2026.10.0
-    if CONF_CODEC_SUPPORT_ENABLED in config:
-        _LOGGER.warning(
-            "'%s' is deprecated and will be removed in 2026.10.0. "
-            "Codec support is now automatically determined from the pipeline "
-            "'format' setting. Set format to 'NONE' to enable all codecs.",
-            CONF_CODEC_SUPPORT_ENABLED,
-        )
-
     # Request codecs based on pipeline formats. Codecs needed by local files are
     # already requested during CONFIG_SCHEMA validation (via audio_files_schema).
     media_player.request_codecs_for_format_configs(
@@ -151,8 +137,12 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_BUFFER_SIZE, default=1000000): cv.int_range(
                 min=4000, max=4000000
             ),
-            # Remove before 2026.10.0
-            cv.Optional(CONF_CODEC_SUPPORT_ENABLED): cv.Any(cv.boolean, cv.string),
+            # Removed in 2026.10.0 - kept to provide helpful error message
+            cv.Optional(CONF_CODEC_SUPPORT_ENABLED): cv.invalid(
+                "The 'codec_support_enabled' option has been removed in ESPHome 2026.10.0.\n"
+                "Codec support is now determined from the pipeline 'format' setting.\n"
+                "Set 'format: NONE' on the pipeline to enable all codecs."
+            ),
             cv.Optional(CONF_FILES): audio_file.audio_files_schema(),
             cv.Optional(CONF_TASK_STACK_IN_PSRAM): psram.validate_task_stack_in_psram,
             cv.Optional(CONF_VOLUME_INCREMENT, default=0.05): cv.percentage,
diff --git a/esphome/components/speaker/media_player/speaker_media_player.cpp b/esphome/components/speaker/media_player/speaker_media_player.cpp
index fe994f440df..9ce50d7b762 100644
--- a/esphome/components/speaker/media_player/speaker_media_player.cpp
+++ b/esphome/components/speaker/media_player/speaker_media_player.cpp
@@ -595,8 +595,11 @@ void SpeakerMediaPlayer::set_mute_state_(bool mute_state) {
 }
 
 void SpeakerMediaPlayer::set_volume_(float volume, bool publish) {
-  // Remap the volume to fit with in the configured limits
-  float bounded_volume = remap<float, float>(volume, 0.0f, 1.0f, this->volume_min_, this->volume_max_);
+  // Remap the volume to fit within the configured limits. An effectively zero volume is passed through as zero so
+  // the speaker silences it, otherwise volume_min would make it audible.
+  float bounded_volume = (volume < SILENT_VOLUME_THRESHOLD)
+                             ? 0.0f
+                             : remap<float, float>(volume, 0.0f, 1.0f, this->volume_min_, this->volume_max_);
 
   if (this->media_speaker_ != nullptr) {
     this->media_speaker_->set_volume(bounded_volume);
@@ -611,13 +614,6 @@ void SpeakerMediaPlayer::set_volume_(float volume, bool publish) {
     this->save_volume_restore_state_();
   }
 
-  // Turn on the mute state if the volume is effectively zero, off otherwise
-  if (volume < 0.001f) {
-    this->set_mute_state_(true);
-  } else {
-    this->set_mute_state_(false);
-  }
-
   this->defer([this, volume]() { this->volume_trigger_.trigger(volume); });
 }
 
diff --git a/esphome/components/speaker/speaker.h b/esphome/components/speaker/speaker.h
index c89b6c588c7..01e9ca042e0 100644
--- a/esphome/components/speaker/speaker.h
+++ b/esphome/components/speaker/speaker.h
@@ -18,6 +18,9 @@
 
 namespace esphome::speaker {
 
+/// Volumes below this are treated as zero
+static constexpr float SILENT_VOLUME_THRESHOLD = 0.001f;
+
 enum State : uint8_t {
   STATE_STOPPED = 0,
   STATE_STARTING,
@@ -65,13 +68,15 @@ class Speaker {
   bool is_running() const { return this->state_ == STATE_RUNNING; }
   bool is_stopped() const { return this->state_ == STATE_STOPPED; }
 
-  // Volume control is handled by a configured audio dac component. Individual speaker components can
-  // override and implement in software if an audio dac isn't available.
+  // Volume and mute are independent: changing one never alters the other's stored state. Volume control is
+  // handled by a configured audio dac component. Individual speaker components can override and implement in
+  // software if an audio dac isn't available.
   virtual void set_volume(float volume) {
     this->volume_ = volume;
 #ifdef USE_AUDIO_DAC
     if (this->audio_dac_ != nullptr) {
       this->audio_dac_->set_volume(volume);
+      this->apply_audio_dac_mute_();
     }
 #endif
   };
@@ -80,13 +85,7 @@ class Speaker {
   virtual void set_mute_state(bool mute_state) {
     this->mute_state_ = mute_state;
 #ifdef USE_AUDIO_DAC
-    if (this->audio_dac_) {
-      if (mute_state) {
-        this->audio_dac_->set_mute_on();
-      } else {
-        this->audio_dac_->set_mute_off();
-      }
-    }
+    this->apply_audio_dac_mute_();
 #endif
   }
   virtual bool get_mute_state() { return this->mute_state_; }
@@ -110,6 +109,23 @@ class Speaker {
   }
 
  protected:
+  /// @brief Whether the output should be silent: muted, or the volume is effectively zero.
+  /// Volume steps from media players can leave a positive value near float epsilon instead of exactly zero.
+  bool is_silent_() const { return this->mute_state_ || this->volume_ < SILENT_VOLUME_THRESHOLD; }
+
+#ifdef USE_AUDIO_DAC
+  /// @brief Uses the audio dac's mute as the silence mechanism, since a dac's minimum volume is often audible.
+  void apply_audio_dac_mute_() {
+    if (this->audio_dac_ == nullptr)
+      return;
+    if (this->is_silent_()) {
+      this->audio_dac_->set_mute_on();
+    } else {
+      this->audio_dac_->set_mute_off();
+    }
+  }
+#endif
+
   State state_{STATE_STOPPED};
   audio::AudioStreamInfo audio_stream_info_;
   float volume_{1.0f};
diff --git a/esphome/components/speaker_source/speaker_source_media_player.cpp b/esphome/components/speaker_source/speaker_source_media_player.cpp
index a33a1a16509..215f3942d58 100644
--- a/esphome/components/speaker_source/speaker_source_media_player.cpp
+++ b/esphome/components/speaker_source/speaker_source_media_player.cpp
@@ -809,8 +809,11 @@ void SpeakerSourceMediaPlayer::set_mute_state_(bool mute_state, bool publish) {
 }
 
 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_);
+  // Remap the volume to fit within the configured limits. An effectively zero volume is passed through as zero so
+  // the speaker silences it, otherwise volume_min would make it audible.
+  float bounded_volume = (volume < speaker::SILENT_VOLUME_THRESHOLD)
+                             ? 0.0f
+                             : remap<float, float>(volume, 0.0f, 1.0f, this->volume_min_, this->volume_max_);
 
   for (auto &ps : this->pipelines_) {
     if (ps.is_configured()) {
@@ -829,15 +832,6 @@ void SpeakerSourceMediaPlayer::set_volume_(float volume, bool publish) {
     }
   }
 
-  // Turn on the mute state if the volume is effectively zero, off otherwise.
-  // Pass publish=false to avoid saving twice.
-  if (volume < 0.001f) {
-    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_();
   }
diff --git a/esphome/components/sprinkler/sprinkler.cpp b/esphome/components/sprinkler/sprinkler.cpp
index 9fd0d9208bb..cdec1581266 100644
--- a/esphome/components/sprinkler/sprinkler.cpp
+++ b/esphome/components/sprinkler/sprinkler.cpp
@@ -546,11 +546,7 @@ void Sprinkler::set_auto_advance(const bool auto_advance) {
   if (this->auto_adv_sw_->state == auto_advance) {
     return;
   }
-  if (auto_advance) {
-    this->auto_adv_sw_->turn_on();
-  } else {
-    this->auto_adv_sw_->turn_off();
-  }
+  this->auto_adv_sw_->control(auto_advance);
 }
 
 void Sprinkler::set_repeat(optional<uint32_t> repeat) {
@@ -573,11 +569,7 @@ void Sprinkler::set_queue_enable(bool queue_enable) {
   if (this->queue_enable_sw_->state == queue_enable) {
     return;
   }
-  if (queue_enable) {
-    this->queue_enable_sw_->turn_on();
-  } else {
-    this->queue_enable_sw_->turn_off();
-  }
+  this->queue_enable_sw_->control(queue_enable);
 }
 
 void Sprinkler::set_reverse(const bool reverse) {
@@ -587,11 +579,7 @@ void Sprinkler::set_reverse(const bool reverse) {
   if (this->reverse_sw_->state == reverse) {
     return;
   }
-  if (reverse) {
-    this->reverse_sw_->turn_on();
-  } else {
-    this->reverse_sw_->turn_off();
-  }
+  this->reverse_sw_->control(reverse);
 }
 
 void Sprinkler::set_standby(const bool standby) {
@@ -601,11 +589,7 @@ void Sprinkler::set_standby(const bool standby) {
   if (this->standby_sw_->state == standby) {
     return;
   }
-  if (standby) {
-    this->standby_sw_->turn_on();
-  } else {
-    this->standby_sw_->turn_off();
-  }
+  this->standby_sw_->control(standby);
 }
 
 uint32_t Sprinkler::valve_run_duration(const size_t valve_number) {
diff --git a/esphome/components/st7701s/st7701s.cpp b/esphome/components/st7701s/st7701s.cpp
index 83f7bc9ce58..47b200c2de6 100644
--- a/esphome/components/st7701s/st7701s.cpp
+++ b/esphome/components/st7701s/st7701s.cpp
@@ -84,7 +84,7 @@ void ST7701S::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8
 }
 
 void ST7701S::draw_pixel_at(int x, int y, Color color) {
-  if (!this->get_clipping().inside(x, y))
+  if (this->is_point_clipped(x, y))
     return;  // NOLINT
 
   switch (this->rotation_) {
@@ -107,7 +107,7 @@ void ST7701S::draw_pixel_at(int x, int y, Color color) {
 
   this->draw_pixels_at(x, y, 1, 1, (const uint8_t *) &pixel, display::COLOR_ORDER_RGB, display::COLOR_BITNESS_565, true,
                        0, 0, 0);
-  App.feed_wdt();
+  this->feed_wdt_per_pixel_();
 }
 
 void ST7701S::write_command_(uint8_t value) {
diff --git a/esphome/components/st7789v/st7789v.cpp b/esphome/components/st7789v/st7789v.cpp
index b3a60af8c33..2e07e24522c 100644
--- a/esphome/components/st7789v/st7789v.cpp
+++ b/esphome/components/st7789v/st7789v.cpp
@@ -152,8 +152,6 @@ void ST7789V::update() {
   this->write_display_data();
 }
 
-void ST7789V::set_model_str(const char *model_str) { this->model_str_ = model_str; }
-
 void ST7789V::write_display_data() {
   uint16_t x1 = this->offset_width_;
   uint16_t x2 = x1 + get_width_internal() - 1;
diff --git a/esphome/components/st7789v/st7789v.h b/esphome/components/st7789v/st7789v.h
index 1b7ba318a6c..4011e607c25 100644
--- a/esphome/components/st7789v/st7789v.h
+++ b/esphome/components/st7789v/st7789v.h
@@ -110,7 +110,7 @@ class ST7789V final : public display::DisplayBuffer,
                       public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,
                                             spi::DATA_RATE_20MHZ> {
  public:
-  void set_model_str(const char *model_str);
+  void set_model_str(const char *model_str) { this->model_str_ = model_str; }
   void set_dc_pin(GPIOPin *dc_pin) { this->dc_pin_ = dc_pin; }
   void set_reset_pin(GPIOPin *reset_pin) { this->reset_pin_ = reset_pin; }
   void set_backlight_pin(GPIOPin *backlight_pin) { this->backlight_pin_ = backlight_pin; }
diff --git a/esphome/components/status/status_binary_sensor.h b/esphome/components/status/status_binary_sensor.h
index 28cf4cd0832..3c25a9e57de 100644
--- a/esphome/components/status/status_binary_sensor.h
+++ b/esphome/components/status/status_binary_sensor.h
@@ -7,6 +7,8 @@ namespace esphome::status {
 
 class StatusBinarySensor final : public binary_sensor::BinarySensor, public PollingComponent {
  public:
+  // User provided, not "= default": `new(p) StatusBinarySensor()` would zero-fill .bss that is already zero.
+  StatusBinarySensor() {}
   void update() override;
 
   void setup() override;
diff --git a/esphome/components/switch/switch.cpp b/esphome/components/switch/switch.cpp
index 8413c7b4936..57e4f222bce 100644
--- a/esphome/components/switch/switch.cpp
+++ b/esphome/components/switch/switch.cpp
@@ -10,7 +10,6 @@ static const char *const TAG = "switch";
 Switch::Switch() : state(false) {}
 
 void Switch::control(bool target_state) {
-  ESP_LOGV(TAG, "'%s' Control: %s", this->get_name().c_str(), ONOFF(target_state));
   if (target_state) {
     this->turn_on();
   } else {
diff --git a/esphome/components/template/alarm_control_panel/template_alarm_control_panel.h b/esphome/components/template/alarm_control_panel/template_alarm_control_panel.h
index 57a99f2830e..5888ce5e29b 100644
--- a/esphome/components/template/alarm_control_panel/template_alarm_control_panel.h
+++ b/esphome/components/template/alarm_control_panel/template_alarm_control_panel.h
@@ -65,9 +65,6 @@ class TemplateAlarmControlPanel final : public alarm_control_panel::AlarmControl
   bool get_requires_code_to_arm() const override { return this->requires_code_to_arm_; }
   bool get_all_sensors_ready() { return this->sensors_ready_; };
   void set_restore_mode(TemplateAlarmControlPanelRestoreMode restore_mode) { this->restore_mode_ = restore_mode; }
-  // Remove before 2026.10.0
-  ESPDEPRECATED("bypass_before_arming() is deprecated and will be removed in 2026.10.0", "2026.4.0")
-  void bypass_before_arming() { this->auto_bypass_sensors_(); }
 
 #ifdef USE_BINARY_SENSOR
   /** Initialize the sensors vector with the specified capacity.
diff --git a/esphome/components/template/binary_sensor/template_binary_sensor.h b/esphome/components/template/binary_sensor/template_binary_sensor.h
index c78a95e0e36..e1a089b44ca 100644
--- a/esphome/components/template/binary_sensor/template_binary_sensor.h
+++ b/esphome/components/template/binary_sensor/template_binary_sensor.h
@@ -8,6 +8,8 @@ namespace esphome::template_ {
 
 class TemplateBinarySensor final : public Component, public binary_sensor::BinarySensor {
  public:
+  // User provided, not "= default": `new(p) TemplateBinarySensor()` would zero-fill .bss that is already zero.
+  TemplateBinarySensor() {}
   template<typename F> void set_template(F &&f) { this->f_.set(std::forward<F>(f)); }
 
   void setup() override;
diff --git a/esphome/components/template/button/template_button.h b/esphome/components/template/button/template_button.h
index f64a85eef07..bd07b2258c1 100644
--- a/esphome/components/template/button/template_button.h
+++ b/esphome/components/template/button/template_button.h
@@ -6,6 +6,9 @@ namespace esphome::template_ {
 
 class TemplateButton final : public button::Button {
  public:
+  // User provided, not "= default": `new(p) TemplateButton()` would zero-fill .bss that is already zero.
+  TemplateButton() {}
+
   // Implements the abstract `press_action` but the `on_press` trigger already handles the press.
   void press_action() override{};
 };
diff --git a/esphome/components/template/cover/template_cover.cpp b/esphome/components/template/cover/template_cover.cpp
index d5e0967e1e3..1bf057da5b5 100644
--- a/esphome/components/template/cover/template_cover.cpp
+++ b/esphome/components/template/cover/template_cover.cpp
@@ -53,8 +53,6 @@ void TemplateCover::loop() {
   if (changed)
     this->publish_state();
 }
-void TemplateCover::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
-void TemplateCover::set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
 float TemplateCover::get_setup_priority() const { return setup_priority::HARDWARE; }
 Trigger<> *TemplateCover::get_open_trigger() { return &this->open_trigger_; }
 Trigger<> *TemplateCover::get_close_trigger() { return &this->close_trigger_; }
@@ -117,10 +115,6 @@ CoverTraits TemplateCover::get_traits() {
 }
 Trigger<float> *TemplateCover::get_position_trigger() { return &this->position_trigger_; }
 Trigger<float> *TemplateCover::get_tilt_trigger() { return &this->tilt_trigger_; }
-void TemplateCover::set_has_stop(bool has_stop) { this->has_stop_ = has_stop; }
-void TemplateCover::set_has_toggle(bool has_toggle) { this->has_toggle_ = has_toggle; }
-void TemplateCover::set_has_position(bool has_position) { this->has_position_ = has_position; }
-void TemplateCover::set_has_tilt(bool has_tilt) { this->has_tilt_ = has_tilt; }
 void TemplateCover::stop_prev_trigger_() {
   if (this->prev_command_trigger_ != nullptr) {
     this->prev_command_trigger_->stop_action();
diff --git a/esphome/components/template/cover/template_cover.h b/esphome/components/template/cover/template_cover.h
index 20c092cda79..d3096ba86f9 100644
--- a/esphome/components/template/cover/template_cover.h
+++ b/esphome/components/template/cover/template_cover.h
@@ -25,12 +25,12 @@ class TemplateCover final : public cover::Cover, public Component {
   Trigger<> *get_toggle_trigger();
   Trigger<float> *get_position_trigger();
   Trigger<float> *get_tilt_trigger();
-  void set_optimistic(bool optimistic);
-  void set_assumed_state(bool assumed_state);
-  void set_has_stop(bool has_stop);
-  void set_has_position(bool has_position);
-  void set_has_tilt(bool has_tilt);
-  void set_has_toggle(bool has_toggle);
+  void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
+  void set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
+  void set_has_stop(bool has_stop) { this->has_stop_ = has_stop; }
+  void set_has_position(bool has_position) { this->has_position_ = has_position; }
+  void set_has_tilt(bool has_tilt) { this->has_tilt_ = has_tilt; }
+  void set_has_toggle(bool has_toggle) { this->has_toggle_ = has_toggle; }
   void set_restore_mode(TemplateCoverRestoreMode restore_mode) { restore_mode_ = restore_mode; }
 
   void setup() override;
diff --git a/esphome/components/template/event/template_event.h b/esphome/components/template/event/template_event.h
index fe83dc9f34b..3d2d9a9efe2 100644
--- a/esphome/components/template/event/template_event.h
+++ b/esphome/components/template/event/template_event.h
@@ -5,6 +5,10 @@
 
 namespace esphome::template_ {
 
-class TemplateEvent final : public Component, public event::Event {};
+class TemplateEvent final : public Component, public event::Event {
+ public:
+  // User provided, not "= default": `new(p) TemplateEvent()` would zero-fill .bss that is already zero.
+  TemplateEvent() {}
+};
 
 }  // namespace esphome::template_
diff --git a/esphome/components/template/lock/template_lock.cpp b/esphome/components/template/lock/template_lock.cpp
index 6e73623ae9b..4a293aab858 100644
--- a/esphome/components/template/lock/template_lock.cpp
+++ b/esphome/components/template/lock/template_lock.cpp
@@ -47,7 +47,6 @@ void TemplateLock::open_latch() {
   this->prev_trigger_ = &this->open_trigger_;
   this->open_trigger_.trigger();
 }
-void TemplateLock::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 float TemplateLock::get_setup_priority() const { return setup_priority::HARDWARE; }
 void TemplateLock::dump_config() {
   LOG_LOCK("", "Template Lock", this);
diff --git a/esphome/components/template/lock/template_lock.h b/esphome/components/template/lock/template_lock.h
index 03e3e86d88e..9b0a1ffe984 100644
--- a/esphome/components/template/lock/template_lock.h
+++ b/esphome/components/template/lock/template_lock.h
@@ -18,7 +18,7 @@ class TemplateLock final : public lock::Lock, public Component {
   Trigger<> *get_lock_trigger() { return &this->lock_trigger_; }
   Trigger<> *get_unlock_trigger() { return &this->unlock_trigger_; }
   Trigger<> *get_open_trigger() { return &this->open_trigger_; }
-  void set_optimistic(bool optimistic);
+  void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
   void loop() override;
 
   float get_setup_priority() const override;
diff --git a/esphome/components/template/select/template_select.h b/esphome/components/template/select/template_select.h
index 5da6d732bd4..1cc28a36d37 100644
--- a/esphome/components/template/select/template_select.h
+++ b/esphome/components/template/select/template_select.h
@@ -23,6 +23,8 @@ void update_lambda(BaseTemplateSelect *sel_comp, const optional<std::string> &va
 template<bool HAS_LAMBDA, bool OPTIMISTIC, bool RESTORE_VALUE, size_t INITIAL_OPTION_INDEX>
 class TemplateSelect : public BaseTemplateSelect {
  public:
+  // User provided, not "= default": `new(p) TemplateSelect()` would zero-fill .bss that is already zero.
+  TemplateSelect() {}
   template<typename F> void set_lambda(F &&f) {
     if constexpr (HAS_LAMBDA) {
       this->f_.set(std::forward<F>(f));
diff --git a/esphome/components/template/sensor/template_sensor.h b/esphome/components/template/sensor/template_sensor.h
index 825a2b4ffaa..68e22372679 100644
--- a/esphome/components/template/sensor/template_sensor.h
+++ b/esphome/components/template/sensor/template_sensor.h
@@ -8,6 +8,8 @@ namespace esphome::template_ {
 
 class TemplateSensor final : public sensor::Sensor, public PollingComponent {
  public:
+  // User provided, not "= default": `new(p) TemplateSensor()` would zero-fill .bss that is already zero.
+  TemplateSensor() {}
   template<typename F> void set_template(F &&f) { this->f_.set(std::forward<F>(f)); }
 
   void update() override;
diff --git a/esphome/components/template/switch/__init__.py b/esphome/components/template/switch/__init__.py
index 37303abb0d7..0b246869363 100644
--- a/esphome/components/template/switch/__init__.py
+++ b/esphome/components/template/switch/__init__.py
@@ -72,8 +72,11 @@ async def to_code(config):
         await automation.build_automation(
             var.get_turn_on_trigger(), [], config[CONF_TURN_ON_ACTION]
         )
-    cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
-    cg.add(var.set_assumed_state(config[CONF_ASSUMED_STATE]))
+    # optimistic_ and assumed_state_ are false in C++; only emit setters to turn them on.
+    if config[CONF_OPTIMISTIC]:
+        cg.add(var.set_optimistic(True))
+    if config[CONF_ASSUMED_STATE]:
+        cg.add(var.set_assumed_state(True))
 
 
 @automation.register_action(
diff --git a/esphome/components/template/switch/template_switch.cpp b/esphome/components/template/switch/template_switch.cpp
index 05288b2d4e0..729db370531 100644
--- a/esphome/components/template/switch/template_switch.cpp
+++ b/esphome/components/template/switch/template_switch.cpp
@@ -29,7 +29,6 @@ void TemplateSwitch::write_state(bool state) {
   if (this->optimistic_)
     this->publish_state(state);
 }
-void TemplateSwitch::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 bool TemplateSwitch::assumed_state() { return this->assumed_state_; }
 float TemplateSwitch::get_setup_priority() const { return setup_priority::HARDWARE - 2.0f; }
 Trigger<> *TemplateSwitch::get_turn_on_trigger() { return &this->turn_on_trigger_; }
@@ -43,17 +42,12 @@ void TemplateSwitch::setup() {
   if (initial_state.has_value()) {
     ESP_LOGD(TAG, "  Restored state %s", ONOFF(initial_state.value()));
     // if it has a value, restore_mode is not "DISABLED", therefore act on the switch:
-    if (initial_state.value()) {
-      this->turn_on();
-    } else {
-      this->turn_off();
-    }
+    this->control(initial_state.value());
   }
 }
 void TemplateSwitch::dump_config() {
   LOG_SWITCH("", "Template Switch", this);
   ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));
 }
-void TemplateSwitch::set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
 
 }  // namespace esphome::template_
diff --git a/esphome/components/template/switch/template_switch.h b/esphome/components/template/switch/template_switch.h
index 1714b4f72b9..6dc073e4b37 100644
--- a/esphome/components/template/switch/template_switch.h
+++ b/esphome/components/template/switch/template_switch.h
@@ -17,8 +17,8 @@ class TemplateSwitch final : public switch_::Switch, public Component {
   template<typename F> void set_state_lambda(F &&f) { this->f_.set(std::forward<F>(f)); }
   Trigger<> *get_turn_on_trigger();
   Trigger<> *get_turn_off_trigger();
-  void set_optimistic(bool optimistic);
-  void set_assumed_state(bool assumed_state);
+  void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
+  void set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
   void loop() override;
 
   float get_setup_priority() const override;
@@ -29,6 +29,7 @@ class TemplateSwitch final : public switch_::Switch, public Component {
   void write_state(bool state) override;
 
   TemplateLambda<bool> f_;
+  // Codegen only emits these setters to turn them on
   bool optimistic_{false};
   bool assumed_state_{false};
   Trigger<> turn_on_trigger_;
diff --git a/esphome/components/template/text_sensor/template_text_sensor.h b/esphome/components/template/text_sensor/template_text_sensor.h
index 0538a7ec211..8f03f78be4f 100644
--- a/esphome/components/template/text_sensor/template_text_sensor.h
+++ b/esphome/components/template/text_sensor/template_text_sensor.h
@@ -9,6 +9,8 @@ namespace esphome::template_ {
 
 class TemplateTextSensor final : public text_sensor::TextSensor, public PollingComponent {
  public:
+  // User provided, not "= default": `new(p) TemplateTextSensor()` would zero-fill .bss that is already zero.
+  TemplateTextSensor() {}
   template<typename F> void set_template(F &&f) { this->f_.set(std::forward<F>(f)); }
 
   void update() override;
diff --git a/esphome/components/template/valve/template_valve.cpp b/esphome/components/template/valve/template_valve.cpp
index 3ebeec12856..50906876399 100644
--- a/esphome/components/template/valve/template_valve.cpp
+++ b/esphome/components/template/valve/template_valve.cpp
@@ -47,8 +47,6 @@ void TemplateValve::loop() {
     this->publish_state();
 }
 
-void TemplateValve::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
-void TemplateValve::set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
 float TemplateValve::get_setup_priority() const { return setup_priority::HARDWARE; }
 
 Trigger<> *TemplateValve::get_open_trigger() { return &this->open_trigger_; }
@@ -111,10 +109,6 @@ ValveTraits TemplateValve::get_traits() {
 
 Trigger<float> *TemplateValve::get_position_trigger() { return &this->position_trigger_; }
 
-void TemplateValve::set_has_stop(bool has_stop) { this->has_stop_ = has_stop; }
-void TemplateValve::set_has_toggle(bool has_toggle) { this->has_toggle_ = has_toggle; }
-void TemplateValve::set_has_position(bool has_position) { this->has_position_ = has_position; }
-
 void TemplateValve::stop_prev_trigger_() {
   if (this->prev_command_trigger_ != nullptr) {
     this->prev_command_trigger_->stop_action();
diff --git a/esphome/components/template/valve/template_valve.h b/esphome/components/template/valve/template_valve.h
index 76c4630aa02..504fdb2fbaf 100644
--- a/esphome/components/template/valve/template_valve.h
+++ b/esphome/components/template/valve/template_valve.h
@@ -23,11 +23,11 @@ class TemplateValve final : public valve::Valve, public Component {
   Trigger<> *get_stop_trigger();
   Trigger<> *get_toggle_trigger();
   Trigger<float> *get_position_trigger();
-  void set_optimistic(bool optimistic);
-  void set_assumed_state(bool assumed_state);
-  void set_has_stop(bool has_stop);
-  void set_has_position(bool has_position);
-  void set_has_toggle(bool has_toggle);
+  void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
+  void set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
+  void set_has_stop(bool has_stop) { this->has_stop_ = has_stop; }
+  void set_has_position(bool has_position) { this->has_position_ = has_position; }
+  void set_has_toggle(bool has_toggle) { this->has_toggle_ = has_toggle; }
   void set_restore_mode(TemplateValveRestoreMode restore_mode) { restore_mode_ = restore_mode; }
 
   void setup() override;
diff --git a/esphome/components/text_sensor/text_sensor.h b/esphome/components/text_sensor/text_sensor.h
index 0e7364bf980..5041ebc4e08 100644
--- a/esphome/components/text_sensor/text_sensor.h
+++ b/esphome/components/text_sensor/text_sensor.h
@@ -29,7 +29,8 @@ class TextSensor : public EntityBase {
  public:
   std::string state;
 
-  TextSensor() = default;
+  // User provided, not "= default": `new(p) TextSensor()` would zero-fill .bss that is already zero.
+  TextSensor() {}
   ~TextSensor() = default;
 
   /// Getter-syntax for .state.
diff --git a/esphome/components/thermostat/thermostat_climate.cpp b/esphome/components/thermostat/thermostat_climate.cpp
index e830d359c64..f64673e13fa 100644
--- a/esphome/components/thermostat/thermostat_climate.cpp
+++ b/esphome/components/thermostat/thermostat_climate.cpp
@@ -1304,8 +1304,6 @@ void ThermostatClimate::set_default_preset(const char *custom_preset) {
   this->default_custom_preset_ = nullptr;
 }
 
-void ThermostatClimate::set_default_preset(climate::ClimatePreset preset) { this->default_preset_ = preset; }
-
 void ThermostatClimate::set_timer_duration_in_sec_(ThermostatClimateTimerIndex timer_index, uint32_t time) {
   uint32_t new_duration_ms = 1000 * (time < this->min_timer_duration_ ? this->min_timer_duration_ : time);
 
diff --git a/esphome/components/thermostat/thermostat_climate.h b/esphome/components/thermostat/thermostat_climate.h
index 4dc2a74d8e5..b7d46eae227 100644
--- a/esphome/components/thermostat/thermostat_climate.h
+++ b/esphome/components/thermostat/thermostat_climate.h
@@ -92,7 +92,7 @@ class ThermostatClimate final : public climate::Climate, public Component {
   void loop() override;
 
   void set_default_preset(const char *custom_preset);
-  void set_default_preset(climate::ClimatePreset preset);
+  void set_default_preset(climate::ClimatePreset preset) { this->default_preset_ = preset; }
   void set_on_boot_restore_from(thermostat::OnBootRestoreFrom on_boot_restore_from) {
     this->on_boot_restore_from_ = on_boot_restore_from;
   }
diff --git a/esphome/components/tinyusb/__init__.py b/esphome/components/tinyusb/__init__.py
index 53c4ab00734..7ad88d3018d 100644
--- a/esphome/components/tinyusb/__init__.py
+++ b/esphome/components/tinyusb/__init__.py
@@ -1,4 +1,4 @@
-from esphome import final_validate as fv
+from esphome import automation, final_validate as fv, pins
 import esphome.codegen as cg
 from esphome.components import esp32
 from esphome.components.esp32 import (
@@ -12,17 +12,22 @@ from esphome.components.esp32 import (
 )
 import esphome.config_validation as cv
 from esphome.const import CONF_HARDWARE_UART, CONF_ID
+from esphome.core import ID
+from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@kbx81"]
 CONFLICTS_WITH = ["usb_host"]
 
+CONF_ON_MOUNT = "on_mount"
+CONF_ON_UNMOUNT = "on_unmount"
 CONF_USB_LANG_ID = "usb_lang_id"
 CONF_USB_MANUFACTURER_STR = "usb_manufacturer_str"
 CONF_USB_PRODUCT_ID = "usb_product_id"
 CONF_USB_PRODUCT_STR = "usb_product_str"
 CONF_USB_SERIAL_STR = "usb_serial_str"
 CONF_USB_VENDOR_ID = "usb_vendor_id"
+CONF_VBUS_MONITOR_PIN = "vbus_monitor_pin"
 
 # Components that provide a USB device class (CDC, HID, MSC, ...) on top of
 # tinyusb. Configuring `tinyusb:` without any of these triggers a 5s hang in
@@ -33,6 +38,20 @@ _USB_CLASS_COMPONENTS = ("usb_cdc_acm",)
 
 tinyusb_ns = cg.esphome_ns.namespace("tinyusb")
 TinyUSB = tinyusb_ns.class_("TinyUSB", cg.Component)
+IsMountedCondition = tinyusb_ns.class_("IsMountedCondition", automation.Condition)
+
+_CALLBACK_AUTOMATIONS = (
+    automation.CallbackAutomation(
+        CONF_ON_MOUNT,
+        "add_on_mount_state_callback",
+        forwarder=automation.TriggerOnTrueForwarder,
+    ),
+    automation.CallbackAutomation(
+        CONF_ON_UNMOUNT,
+        "add_on_mount_state_callback",
+        forwarder=automation.TriggerOnFalseForwarder,
+    ),
+)
 
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
@@ -44,6 +63,18 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_USB_MANUFACTURER_STR, default="ESPHome"): cv.string,
             cv.Optional(CONF_USB_PRODUCT_STR, default="ESPHome"): cv.string,
             cv.Optional(CONF_USB_SERIAL_STR, default=""): cv.string,
+            # esp_tinyusb monitors VBUS on the S31 through a GPIO interrupt and needs
+            # the GPIO ISR service installed first, which would collide with the esp32
+            # platform's own lazy install and disable other interrupts. The other
+            # variants watch the pin in the OTG hardware.
+            cv.Optional(CONF_VBUS_MONITOR_PIN): cv.All(
+                pins.internal_gpio_input_pin_number,
+                esp32.only_on_variant(
+                    unsupported=[VARIANT_ESP32S31], msg_prefix=CONF_VBUS_MONITOR_PIN
+                ),
+            ),
+            cv.Optional(CONF_ON_MOUNT): automation.validate_automation({}),
+            cv.Optional(CONF_ON_UNMOUNT): automation.validate_automation({}),
         }
     ).extend(cv.COMPONENT_SCHEMA),
     esp32.only_on_variant(
@@ -93,9 +124,28 @@ async def to_code(config: ConfigType) -> None:
     cg.add(var.set_usb_desc_product(config[CONF_USB_PRODUCT_STR]))
     if config[CONF_USB_SERIAL_STR]:
         cg.add(var.set_usb_desc_serial(config[CONF_USB_SERIAL_STR]))
+    if (vbus_pin := config.get(CONF_VBUS_MONITOR_PIN)) is not None:
+        cg.add(var.set_vbus_monitor_pin(vbus_pin))
+
+    await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
     add_idf_component(name="espressif/esp_tinyusb", ref="2.2.1")
 
     add_idf_sdkconfig_option("CONFIG_TINYUSB_DESC_USE_ESPRESSIF_VID", False)
     add_idf_sdkconfig_option("CONFIG_TINYUSB_DESC_USE_DEFAULT_PID", False)
     add_idf_sdkconfig_option("CONFIG_TINYUSB_DESC_BCD_DEVICE", 0x0100)
+
+
+@automation.register_condition(
+    "tinyusb.is_mounted",
+    IsMountedCondition,
+    cv.Schema({cv.GenerateID(): cv.use_id(TinyUSB)}),
+)
+async def tinyusb_is_mounted_to_code(
+    config: ConfigType,
+    condition_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren)
diff --git a/esphome/components/tinyusb/tinyusb_component.cpp b/esphome/components/tinyusb/tinyusb_component.cpp
index c8c36f0ffb6..3fab9de0086 100644
--- a/esphome/components/tinyusb/tinyusb_component.cpp
+++ b/esphome/components/tinyusb/tinyusb_component.cpp
@@ -9,6 +9,14 @@ namespace esphome::tinyusb {
 
 static const char *const TAG = "tinyusb";
 
+// Runs on the TinyUSB task: only wake the main loop, which reads the state and runs
+// the automations.
+static void tinyusb_event_cb(tinyusb_event_t *event, void *arg) {
+  if (event->id == TINYUSB_EVENT_ATTACHED || event->id == TINYUSB_EVENT_DETACHED) {
+    static_cast<TinyUSB *>(arg)->enable_loop_soon_any_context();
+  }
+}
+
 void TinyUSB::setup() {
   // Use the device's MAC address as its serial number if no serial number is defined
   if (this->string_descriptor_[SERIAL_NUMBER] == nullptr) {
@@ -21,6 +29,12 @@ void TinyUSB::setup() {
   this->tusb_cfg_ = TINYUSB_DEFAULT_CONFIG();
   this->tusb_cfg_.port = TINYUSB_PORT_FULL_SPEED_0;
   this->tusb_cfg_.phy.skip_setup = false;
+  // Without VBUS monitoring the OTG core only sees a cable pull as the bus going idle
+  // (a suspend), so TinyUSB never reports a detach and stays "mounted".
+  if (this->vbus_monitor_pin_ >= 0) {
+    this->tusb_cfg_.phy.self_powered = true;
+    this->tusb_cfg_.phy.vbus_monitor_io = this->vbus_monitor_pin_;
+  }
   this->tusb_cfg_.descriptor = {
       .device = &this->usb_descriptor_,
       .string = this->string_descriptor_,
@@ -42,11 +56,26 @@ void TinyUSB::setup() {
   }
 #endif
 
+  this->tusb_cfg_.event_cb = tinyusb_event_cb;
+  this->tusb_cfg_.event_arg = this;
   esp_err_t result = tinyusb_driver_install(&this->tusb_cfg_);
   if (result != ESP_OK) {
     ESP_LOGE(TAG, "tinyusb_driver_install failed: %s", esp_err_to_name(result));
     this->mark_failed();
+    return;
   }
+  // loop() only reports mount changes; the mount hooks wake it when one happens.
+  this->disable_loop();
+}
+
+void TinyUSB::loop() {
+  const bool mounted = tud_mounted();
+  if (mounted != this->last_reported_mounted_) {
+    this->last_reported_mounted_ = mounted;
+    ESP_LOGD(TAG, "USB host %s", mounted ? LOG_STR_LITERAL("mounted") : LOG_STR_LITERAL("unmounted"));
+    this->mount_state_callback_.call(mounted);
+  }
+  this->disable_loop();
 }
 
 void TinyUSB::dump_config() {
@@ -56,9 +85,12 @@ void TinyUSB::dump_config() {
                 "  Vendor ID: 0x%04X\n"
                 "  Manufacturer: '%s'\n"
                 "  Product: '%s'\n"
-                "  Serial: '%s'\n",
+                "  Serial: '%s'",
                 this->usb_descriptor_.idProduct, this->usb_descriptor_.idVendor, this->string_descriptor_[MANUFACTURER],
                 this->string_descriptor_[PRODUCT], this->string_descriptor_[SERIAL_NUMBER]);
+  if (this->vbus_monitor_pin_ >= 0) {
+    ESP_LOGCONFIG(TAG, "  VBUS Monitor Pin: GPIO%d", this->vbus_monitor_pin_);
+  }
 }
 
 }  // namespace esphome::tinyusb
diff --git a/esphome/components/tinyusb/tinyusb_component.h b/esphome/components/tinyusb/tinyusb_component.h
index e85fea9d21a..f7f574ec6d5 100644
--- a/esphome/components/tinyusb/tinyusb_component.h
+++ b/esphome/components/tinyusb/tinyusb_component.h
@@ -1,8 +1,11 @@
 #pragma once
 #if defined(USE_ESP32_VARIANT_ESP32P4) || defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3) || \
     defined(USE_ESP32_VARIANT_ESP32S31) || defined(USE_ESP32_VARIANT_ESP32H4)
+#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
 
+#include <utility>
 #include "tinyusb.h"
 #include "tusb.h"
 
@@ -23,9 +26,17 @@ static const char *const DEFAULT_USB_STR = "ESPHome";
 class TinyUSB final : public Component {
  public:
   void setup() override;
+  void loop() override;
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::BUS; }
 
+  /// True while a USB host has enumerated and configured the device.
+  bool is_mounted() const { return tud_mounted(); }
+  /// Called with the new mount state whenever a host mounts or unmounts the device.
+  template<typename F> void add_on_mount_state_callback(F &&callback) {
+    this->mount_state_callback_.add(std::forward<F>(callback));
+  }
+
   void set_usb_desc_product_id(uint16_t product_id) { this->usb_descriptor_.idProduct = product_id; }
   void set_usb_desc_vendor_id(uint16_t vendor_id) { this->usb_descriptor_.idVendor = vendor_id; }
   void set_usb_desc_lang_id(uint16_t lang_id) {
@@ -37,6 +48,8 @@ class TinyUSB final : public Component {
   }
   void set_usb_desc_product(const char *usb_desc_product) { this->string_descriptor_[PRODUCT] = usb_desc_product; }
   void set_usb_desc_serial(const char *usb_desc_serial) { this->string_descriptor_[SERIAL_NUMBER] = usb_desc_serial; }
+  /// Self-powered device: watch VBUS on this GPIO so a cable pull becomes a detach.
+  void set_vbus_monitor_pin(int pin) { this->vbus_monitor_pin_ = static_cast<int8_t>(pin); }
 
  protected:
   char usb_desc_lang_id_[2] = {0x09, 0x04};  // defaults to english
@@ -50,6 +63,11 @@ class TinyUSB final : public Component {
       nullptr,                  // 5: Terminator
   };
 
+  LazyCallbackManager<void(bool)> mount_state_callback_;
+  // Edge-detection baseline for loop(); is_mounted() reads the live state instead.
+  bool last_reported_mounted_{false};
+  int8_t vbus_monitor_pin_{-1};
+
   tinyusb_config_t tusb_cfg_{};
   tusb_desc_device_t usb_descriptor_{
       .bLength = sizeof(tusb_desc_device_t),
@@ -69,6 +87,15 @@ class TinyUSB final : public Component {
   };
 };
 
+template<typename... Ts> class IsMountedCondition final : public Condition<Ts...> {
+ public:
+  explicit IsMountedCondition(TinyUSB *parent) : parent_(parent) {}
+  bool check(const Ts &...) override { return this->parent_->is_mounted(); }
+
+ protected:
+  TinyUSB *parent_;
+};
+
 }  // namespace esphome::tinyusb
 #endif  // USE_ESP32_VARIANT_ESP32P4 || USE_ESP32_VARIANT_ESP32S2 || USE_ESP32_VARIANT_ESP32S3 ||
         // USE_ESP32_VARIANT_ESP32S31 || USE_ESP32_VARIANT_ESP32H4
diff --git a/esphome/components/tsl2561/tsl2561.cpp b/esphome/components/tsl2561/tsl2561.cpp
index 963114b230c..4e4d403488d 100644
--- a/esphome/components/tsl2561/tsl2561.cpp
+++ b/esphome/components/tsl2561/tsl2561.cpp
@@ -145,8 +145,6 @@ float TSL2561Sensor::get_integration_time_ms_() {
 void TSL2561Sensor::set_integration_time(TSL2561IntegrationTime integration_time) {
   this->integration_time_ = integration_time;
 }
-void TSL2561Sensor::set_gain(TSL2561Gain gain) { this->gain_ = gain; }
-void TSL2561Sensor::set_is_cs_package(bool package_cs) { this->package_cs_ = package_cs; }
 
 bool TSL2561Sensor::tsl2561_write_byte(uint8_t a_register, uint8_t value) {
   return this->write_byte(a_register | TSL2561_COMMAND_BIT, value);
diff --git a/esphome/components/tsl2561/tsl2561.h b/esphome/components/tsl2561/tsl2561.h
index 8997d19f53a..0800b87c461 100644
--- a/esphome/components/tsl2561/tsl2561.h
+++ b/esphome/components/tsl2561/tsl2561.h
@@ -51,7 +51,7 @@ class TSL2561Sensor final : public sensor::Sensor, public PollingComponent, publ
    *
    * @param gain The new gain.
    */
-  void set_gain(TSL2561Gain gain);
+  void set_gain(TSL2561Gain gain) { this->gain_ = gain; }
 
   /** The "CS" package of this sensor has a slightly different formula for
    * converting the raw values. Use this setting to indicate that this is a CS
@@ -59,7 +59,7 @@ class TSL2561Sensor final : public sensor::Sensor, public PollingComponent, publ
    *
    * @param package_cs Is this a CS package.
    */
-  void set_is_cs_package(bool package_cs);
+  void set_is_cs_package(bool package_cs) { this->package_cs_ = package_cs; }
 
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)
diff --git a/esphome/components/tsl2591/tsl2591.cpp b/esphome/components/tsl2591/tsl2591.cpp
index 2a5d6a4ee46..d147aae88ab 100644
--- a/esphome/components/tsl2591/tsl2591.cpp
+++ b/esphome/components/tsl2591/tsl2591.cpp
@@ -200,8 +200,6 @@ void TSL2591Component::set_infrared_sensor(sensor::Sensor *infrared_sensor) {
   this->infrared_sensor_ = infrared_sensor;
 }
 
-void TSL2591Component::set_visible_sensor(sensor::Sensor *visible_sensor) { this->visible_sensor_ = visible_sensor; }
-
 void TSL2591Component::set_full_spectrum_sensor(sensor::Sensor *full_spectrum_sensor) {
   this->full_spectrum_sensor_ = full_spectrum_sensor;
 }
@@ -218,8 +216,6 @@ void TSL2591Component::set_integration_time(TSL2591IntegrationTime integration_t
   this->integration_time_ = integration_time;
 }
 
-void TSL2591Component::set_gain(TSL2591ComponentGain gain) { this->component_gain_ = gain; }
-
 void TSL2591Component::set_device_and_glass_attenuation_factors(float device_factor, float glass_attenuation_factor) {
   this->device_factor_ = device_factor;
   this->glass_attenuation_factor_ = glass_attenuation_factor;
@@ -242,10 +238,6 @@ void TSL2591Component::set_integration_time_and_gain(TSL2591IntegrationTime inte
   }
 }
 
-void TSL2591Component::set_power_save_mode(bool enable) { this->power_save_mode_enabled_ = enable; }
-
-void TSL2591Component::set_name(const char *name) { this->name_ = name; }
-
 bool TSL2591Component::is_adc_valid() {
   uint8_t status;
   if (!this->read_byte(TSL2591_COMMAND_BIT | TSL2591_REGISTER_STATUS, &status)) {
diff --git a/esphome/components/tsl2591/tsl2591.h b/esphome/components/tsl2591/tsl2591.h
index 3fde3404124..c65fc5f6e54 100644
--- a/esphome/components/tsl2591/tsl2591.h
+++ b/esphome/components/tsl2591/tsl2591.h
@@ -111,13 +111,13 @@ class TSL2591Component final : public PollingComponent, public i2c::I2CDevice {
    *
    * @param enable Enable or disable power save mode.
    */
-  void set_power_save_mode(bool enable);
+  void set_power_save_mode(bool enable) { this->power_save_mode_enabled_ = enable; }
 
   /** Sets the name for this instance of the device.
    *
    * @param name The user-friendly name.
    */
-  void set_name(const char *name);
+  void set_name(const char *name) { this->name_ = name; }
 
   /** Sets the device and glass attenuation factors.
    *
@@ -235,13 +235,13 @@ class TSL2591Component final : public PollingComponent, public i2c::I2CDevice {
   /** Used by ESPHome framework. */
   void set_infrared_sensor(sensor::Sensor *infrared_sensor);
   /** Used by ESPHome framework. */
-  void set_visible_sensor(sensor::Sensor *visible_sensor);
+  void set_visible_sensor(sensor::Sensor *visible_sensor) { this->visible_sensor_ = visible_sensor; }
   /** Used by ESPHome framework. */
   void set_calculated_lux_sensor(sensor::Sensor *calculated_lux_sensor);
   /** Used by ESPHome framework. Does NOT actually set the value on the device. */
   void set_integration_time(TSL2591IntegrationTime integration_time);
   /** Used by ESPHome framework. Does NOT actually set the value on the device. */
-  void set_gain(TSL2591ComponentGain gain);
+  void set_gain(TSL2591ComponentGain gain) { this->component_gain_ = gain; }
   /** Used by ESPHome framework. */
   void setup() override;
   /** Used by ESPHome framework. */
diff --git a/esphome/components/uart/uart_component_esp_idf.h b/esphome/components/uart/uart_component_esp_idf.h
index d9297bfa34a..b591fbe9686 100644
--- a/esphome/components/uart/uart_component_esp_idf.h
+++ b/esphome/components/uart/uart_component_esp_idf.h
@@ -18,6 +18,8 @@ namespace esphome::uart {
 /// peek byte state (has_peek_/peek_byte_) is not synchronized.
 class IDFUARTComponent final : public UARTComponent, public Component {
  public:
+  // User provided, not "= default": `new(p) IDFUARTComponent()` would zero-fill .bss that is already zero.
+  IDFUARTComponent() {}
   void setup() override;
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::BUS; }
@@ -37,6 +39,12 @@ class IDFUARTComponent final : public UARTComponent, public Component {
 
   uint8_t get_hw_serial_number() { return this->uart_num_; }
 
+  /// Discard everything received so far: the peek cache and the driver's RX buffer.
+  void flush_input() {
+    this->has_peek_ = false;
+    uart_flush_input(this->uart_num_);
+  }
+
   /**
    * Load the UART with the current settings.
    * @param dump_config (Optional, default `true`): True for displaying new settings or
@@ -96,7 +104,7 @@ class IDFUARTComponent final : public UARTComponent, public Component {
   Framing last_good_framing_{};
 
   bool has_peek_{false};
-  uint8_t peek_byte_;
+  uint8_t peek_byte_{0};
   uint32_t flush_timeout_ms_{0};  ///< 0 means wait indefinitely (portMAX_DELAY).
 
 #ifdef USE_UART_WAKE_LOOP_ON_RX
diff --git a/esphome/components/uart_mux/__init__.py b/esphome/components/uart_mux/__init__.py
new file mode 100644
index 00000000000..6c479f0cdd2
--- /dev/null
+++ b/esphome/components/uart_mux/__init__.py
@@ -0,0 +1,84 @@
+from esphome import automation
+import esphome.codegen as cg
+from esphome.components import esp32, uart
+from esphome.components.cdc_acm_uart.bridge import CDCACMUARTBridge
+from esphome.components.esp32 import VARIANT_ESP32P4, VARIANT_ESP32S2, VARIANT_ESP32S3
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+import esphome.final_validate as fv
+from esphome.types import ConfigType
+
+CODEOWNERS = ["@kbx81"]
+DOMAIN = "uart_mux"
+DEPENDENCIES = ["bridge", "uart"]
+MULTI_CONF = True
+
+CONF_BRIDGE_ID = "bridge_id"
+CONF_INITIAL_ROUTE = "initial_route"
+ROUTE_BRIDGE = "bridge"
+ROUTE_LOCAL = "local"
+
+uart_mux_ns = cg.esphome_ns.namespace("uart_mux")
+UARTMux = uart_mux_ns.class_("UARTMux", uart.UARTComponent, cg.Component)
+SelectLocalAction = uart_mux_ns.class_("SelectLocalAction", automation.Action)
+SelectBridgeAction = uart_mux_ns.class_("SelectBridgeAction", automation.Action)
+IsLocalCondition = uart_mux_ns.class_("IsLocalCondition", automation.Condition)
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(UARTMux),
+            cv.Required(CONF_BRIDGE_ID): cv.use_id(CDCACMUARTBridge),
+            cv.Optional(CONF_INITIAL_ROUTE, default=ROUTE_BRIDGE): cv.one_of(
+                ROUTE_BRIDGE, ROUTE_LOCAL, lower=True
+            ),
+        }
+    ).extend(cv.COMPONENT_SCHEMA),
+    esp32.only_on_variant(
+        supported=[VARIANT_ESP32P4, VARIANT_ESP32S2, VARIANT_ESP32S3],
+    ),
+)
+
+
+def _final_validate(config: ConfigType) -> ConfigType:
+    # Two muxes on one bridge would each believe they own the bus.
+    owned = fv.full_config.get().data.setdefault(DOMAIN, set())
+    bridge_id = str(config[CONF_BRIDGE_ID])
+    if bridge_id in owned:
+        raise cv.Invalid(
+            f"The bridge '{bridge_id}' is already routed by another 'uart_mux'; "
+            "each bridge supports one mux.",
+            [CONF_BRIDGE_ID],
+        )
+    owned.add(bridge_id)
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
+async def to_code(config: ConfigType) -> None:
+    bridge = await cg.get_variable(config[CONF_BRIDGE_ID])
+    var = cg.new_Pvariable(config[CONF_ID], bridge)
+    await cg.register_component(var, config)
+    if config[CONF_INITIAL_ROUTE] == ROUTE_LOCAL:
+        cg.add(var.set_start_local(True))
+
+
+UART_MUX_ACTION_SCHEMA = automation.maybe_simple_id(
+    {cv.Required(CONF_ID): cv.use_id(UARTMux)}
+)
+
+
+automation.register_simple_action(
+    "uart_mux.select_local", SelectLocalAction, UART_MUX_ACTION_SCHEMA, synchronous=True
+)
+automation.register_simple_action(
+    "uart_mux.select_bridge",
+    SelectBridgeAction,
+    UART_MUX_ACTION_SCHEMA,
+    synchronous=True,
+)
+automation.register_simple_condition(
+    "uart_mux.is_local", IsLocalCondition, UART_MUX_ACTION_SCHEMA
+)
diff --git a/esphome/components/uart_mux/uart_mux.cpp b/esphome/components/uart_mux/uart_mux.cpp
new file mode 100644
index 00000000000..953e81d5337
--- /dev/null
+++ b/esphome/components/uart_mux/uart_mux.cpp
@@ -0,0 +1,115 @@
+#if defined(USE_ESP32_VARIANT_ESP32P4) || defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+#include "uart_mux.h"
+#include "esphome/core/log.h"
+
+namespace esphome::uart_mux {
+
+static const char *const TAG = "uart_mux";
+
+void UARTMux::setup() {
+  // A failed UART never assigned its port; nothing behind the mux can work.
+  if (this->uart_->is_failed()) {
+    ESP_LOGE(TAG, "UART parent failed; aborting");
+    this->mark_failed();
+    return;
+  }
+
+  this->settings_ = {
+      this->uart_->get_baud_rate(),      this->uart_->get_rx_full_threshold(), this->uart_->get_rx_timeout(),
+      this->uart_->get_rx_buffer_size(), this->uart_->get_data_bits(),         this->uart_->get_stop_bits(),
+      this->uart_->get_parity(),
+  };
+  this->apply_settings_();
+
+  if (this->start_local_) {
+    this->select_local();
+  } else {
+    // loop() only completes hand-offs; the bridge keeps the UART until an action.
+    this->disable_loop();
+  }
+}
+
+void UARTMux::loop() {
+  if (!this->bridge_->is_paused()) {
+    return;
+  }
+  // Bytes that arrived during the hand-off belong to neither owner.
+  this->uart_->flush_input();
+  this->route_ = Route::ROUTE_LOCAL;
+  ESP_LOGD(TAG, "UART routed to local consumers");
+  this->disable_loop();
+}
+
+void UARTMux::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "UART Mux:\n"
+                "  Start local: %s\n"
+                "  Route: %s",
+                YESNO(this->start_local_),
+                this->route_ == Route::ROUTE_LOCAL           ? LOG_STR_LITERAL("local")
+                : this->route_ == Route::ROUTE_PENDING_LOCAL ? LOG_STR_LITERAL("pending local")
+                                                             : LOG_STR_LITERAL("bridge"));
+}
+
+void UARTMux::load_settings(bool dump_config) {
+  if (!this->load_settings_warned_) {
+    this->load_settings_warned_ = true;
+    ESP_LOGW(TAG, "load_settings() ignored; change the framing on the hardware UART instead");
+  }
+  // Undo whatever the caller set on us. Not re-sampled from the live UART, whose
+  // fields carry the host's line coding while the bridge owns the bus.
+  this->apply_settings_();
+}
+
+void UARTMux::apply_settings_() {
+  this->baud_rate_ = this->settings_.baud_rate;
+  this->data_bits_ = this->settings_.data_bits;
+  this->stop_bits_ = this->settings_.stop_bits;
+  this->parity_ = this->settings_.parity;
+  this->rx_full_threshold_ = this->settings_.rx_full_threshold;
+  this->rx_timeout_ = this->settings_.rx_timeout;
+  this->rx_buffer_size_ = this->settings_.rx_buffer_size;
+}
+
+void UARTMux::select_local() {
+  if (this->route_ != Route::ROUTE_BRIDGE) {
+    return;
+  }
+  ESP_LOGD(TAG, "Pausing bridge to route UART locally");
+  this->bridge_->pause();
+  this->route_ = Route::ROUTE_PENDING_LOCAL;
+  this->enable_loop();
+}
+
+void UARTMux::select_bridge() {
+  if (this->route_ == Route::ROUTE_BRIDGE) {
+    return;
+  }
+  // A bridge that failed setup() has no worker tasks; handing it the bus would kill
+  // the UART in both directions.
+  if (this->bridge_->is_failed()) {
+    ESP_LOGW(TAG, "Bridge failed; keeping the UART routed locally");
+    return;
+  }
+  // While the pause is still pending the bridge's RX task may be inside
+  // uart_read_bytes() on this port, and nothing local has run, so flush only a
+  // completed hand-off.
+  if (this->route_ == Route::ROUTE_LOCAL) {
+    this->uart_->flush_input();
+  }
+  this->route_ = Route::ROUTE_BRIDGE;
+  ESP_LOGD(TAG, "UART routed to bridge");
+  this->bridge_->resume();
+  this->disable_loop();
+}
+
+void UARTMux::write_array(const uint8_t *data, size_t len) {
+  if (!this->is_local()) {
+    ESP_LOGV(TAG, "Dropping %zu bytes: UART routed to bridge", len);
+    return;
+  }
+  this->uart_->write_array(data, len);
+}
+
+}  // namespace esphome::uart_mux
+#endif
diff --git a/esphome/components/uart_mux/uart_mux.h b/esphome/components/uart_mux/uart_mux.h
new file mode 100644
index 00000000000..8e32a166434
--- /dev/null
+++ b/esphome/components/uart_mux/uart_mux.h
@@ -0,0 +1,108 @@
+#pragma once
+#if defined(USE_ESP32_VARIANT_ESP32P4) || defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+#include "esphome/components/uart/uart_component.h"
+#include "esphome/components/uart/uart_component_esp_idf.h"
+#include "esphome/components/cdc_acm_uart/bridge/cdc_acm_uart_bridge.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+
+namespace esphome::uart_mux {
+
+/// Shares one hardware UART between a CDC-ACM UART bridge and local consumers. Local
+/// consumers bind to the mux as their UART; it forwards to the hardware UART only
+/// while routed locally and reports the route through is_connected(). Routing is
+/// driven by the select_*() actions, typically from tinyusb's on_mount/on_unmount.
+class UARTMux final : public uart::UARTComponent, public Component {
+ public:
+  explicit UARTMux(cdc_acm_uart::CDCACMUARTBridge *bridge) : uart_(bridge->get_uart_parent()), bridge_(bridge) {}
+
+  void setup() override;
+  void loop() override;
+  void dump_config() override;
+  // Between the hardware UART (BUS) and its consumers (modbus is BUS - 1): the
+  // mirrored framing must exist before anything reads it from us.
+  float get_setup_priority() const override { return setup_priority::BUS - 0.5f; }
+
+  /// Route locally at boot instead of leaving the UART with the bridge.
+  void set_start_local(bool start_local) { this->start_local_ = start_local; }
+
+  /// Pause the bridge and route the UART to local consumers once it has stopped.
+  void select_local();
+  /// Route the UART back to the bridge.
+  void select_bridge();
+  bool is_local() const { return this->route_ == Route::ROUTE_LOCAL; }
+
+  // uart::UARTComponent: forwarded while routed locally, inert otherwise.
+  void write_array(const uint8_t *data, size_t len) override;
+  bool peek_byte(uint8_t *data) override { return this->is_local() && this->uart_->peek_byte(data); }
+  bool read_array(uint8_t *data, size_t len) override { return this->is_local() && this->uart_->read_array(data, len); }
+  size_t available() override { return this->is_local() ? this->uart_->available() : 0; }
+  uart::UARTFlushResult flush() override {
+    return this->is_local() ? this->uart_->flush() : uart::UARTFlushResult::UART_FLUSH_RESULT_ASSUMED_SUCCESS;
+  }
+  bool is_connected() override { return this->is_local(); }
+  // Ignored: the bridge's tasks block inside the driver, and reinstalling it would
+  // pull it out from under them. The framing is the hardware UART's to change.
+  void load_settings(bool dump_config) override;
+  using UARTComponent::load_settings;
+
+ protected:
+  enum class Route : uint8_t {
+    ROUTE_BRIDGE,
+    ROUTE_PENDING_LOCAL,  // pause() requested; the bridge may still be on the bus
+    ROUTE_LOCAL,
+  };
+
+  // The hardware UART's settings as configured. Taken once at setup, before the
+  // bridge can overwrite the live fields with a host's line coding.
+  struct Settings {
+    uint32_t baud_rate;
+    size_t rx_full_threshold;
+    size_t rx_timeout;
+    size_t rx_buffer_size;
+    uint8_t data_bits;
+    uint8_t stop_bits;
+    uart::UARTParityOptions parity;
+  };
+
+  void check_logger_conflict() override {}
+  // Publish settings_ through the UARTComponent getters.
+  void apply_settings_();
+
+  uart::IDFUARTComponent *uart_;
+  cdc_acm_uart::CDCACMUARTBridge *bridge_;
+  Settings settings_{};
+  Route route_{Route::ROUTE_BRIDGE};
+  bool start_local_{false};
+  bool load_settings_warned_{false};
+};
+
+template<typename... Ts> class SelectLocalAction final : public Action<Ts...> {
+ public:
+  explicit SelectLocalAction(UARTMux *parent) : parent_(parent) {}
+  void play(const Ts &...) override { this->parent_->select_local(); }
+
+ protected:
+  UARTMux *parent_;
+};
+
+template<typename... Ts> class SelectBridgeAction final : public Action<Ts...> {
+ public:
+  explicit SelectBridgeAction(UARTMux *parent) : parent_(parent) {}
+  void play(const Ts &...) override { this->parent_->select_bridge(); }
+
+ protected:
+  UARTMux *parent_;
+};
+
+template<typename... Ts> class IsLocalCondition final : public Condition<Ts...> {
+ public:
+  explicit IsLocalCondition(UARTMux *parent) : parent_(parent) {}
+  bool check(const Ts &...) override { return this->parent_->is_local(); }
+
+ protected:
+  UARTMux *parent_;
+};
+
+}  // namespace esphome::uart_mux
+#endif
diff --git a/esphome/components/update/update_entity.h b/esphome/components/update/update_entity.h
index f925d338ff7..96ba6dbd562 100644
--- a/esphome/components/update/update_entity.h
+++ b/esphome/components/update/update_entity.h
@@ -16,7 +16,7 @@ struct UpdateInfo {
   std::string firmware_url;
   std::string md5;
   bool has_progress{false};
-  float progress;
+  float progress{0};
 };
 
 enum UpdateState : uint8_t {
diff --git a/esphome/components/uptime/sensor/uptime_seconds_sensor.h b/esphome/components/uptime/sensor/uptime_seconds_sensor.h
index b0b12954b28..92d475e62ec 100644
--- a/esphome/components/uptime/sensor/uptime_seconds_sensor.h
+++ b/esphome/components/uptime/sensor/uptime_seconds_sensor.h
@@ -7,6 +7,8 @@ namespace esphome::uptime {
 
 class UptimeSecondsSensor final : public sensor::Sensor, public PollingComponent {
  public:
+  // User provided, not "= default": `new(p) UptimeSecondsSensor()` would zero-fill .bss that is already zero.
+  UptimeSecondsSensor() {}
   void update() override;
   void dump_config() override;
 
diff --git a/esphome/components/usb_uart/__init__.py b/esphome/components/usb_uart/__init__.py
index edbf75f70f8..5d0f8be1655 100644
--- a/esphome/components/usb_uart/__init__.py
+++ b/esphome/components/usb_uart/__init__.py
@@ -44,6 +44,7 @@ UART_STOP_BITS_OPTIONS = {
 }
 
 DEFAULT_BAUD_RATE = 9600
+CONF_CLAIM_COMM_INTERFACE = "claim_comm_interface"
 
 
 class Type:
@@ -56,6 +57,7 @@ class Type:
         max_channels: int = 1,
         baud_rate_required: bool = True,
         max_baud: int = 1_000_000,
+        has_comm_interface: bool = False,
     ) -> None:
         self.name = name
         cls = cls or name
@@ -65,6 +67,9 @@ class Type:
         self._max_channels = max_channels
         self.baud_rate_required = baud_rate_required
         self.max_baud = max_baud
+        # True for types that claim the CDC comm (interrupt) interface; only these
+        # accept the claim_comm_interface option.
+        self.has_comm_interface = has_comm_interface
 
     @property
     def max_channels(self) -> int:
@@ -80,11 +85,21 @@ class Type:
 
 
 uart_types = (
-    Type("CDC_ACM", 0, 0, "CdcAcm", 1, baud_rate_required=False),
+    Type(
+        "CDC_ACM", 0, 0, "CdcAcm", 1, baud_rate_required=False, has_comm_interface=True
+    ),
     Type("CH34X", 0x1A86, 0x55D5, "CH34X", 4, max_baud=2_000_000),
     Type("CH340", 0x1A86, 0x7523, "CH34X", 1, max_baud=2_000_000),
     Type("CP210X", 0x10C4, 0xEA60, "CP210X", 3, max_baud=2_000_000),
-    Type("ESP_JTAG", 0x303A, 0x1001, "CdcAcm", 1, baud_rate_required=False),
+    Type(
+        "ESP_JTAG",
+        0x303A,
+        0x1001,
+        "CdcAcm",
+        1,
+        baud_rate_required=False,
+        has_comm_interface=True,
+    ),
     Type("FT232", 0x0403, 0x6001, "FT23XX", 1, max_baud=3_000_000),
     Type("FT2232", 0x0403, 0x6010, "FT23XX", 2, max_baud=12_000_000),
     Type("FT4232", 0x0403, 0x6011, "FT23XX", 4, max_baud=12_000_000),
@@ -95,12 +110,20 @@ uart_types = (
     Type("PL2303GL", 0x067B, 0x23D3, "PL2303", 1, max_baud=6_000_000),
     Type("PL2303GS", 0x067B, 0x23F3, "PL2303", 1, max_baud=6_000_000),
     Type("PL2303GT", 0x067B, 0x23C3, "PL2303", 1, max_baud=6_000_000),
-    Type("STM32_VCP", 0x0483, 0x5740, "CdcAcm", 1, baud_rate_required=False),
+    Type(
+        "STM32_VCP",
+        0x0483,
+        0x5740,
+        "CdcAcm",
+        1,
+        baud_rate_required=False,
+        has_comm_interface=True,
+    ),
 )
 
 
 def channel_schema(type_: "Type") -> cv.Schema:
-    return cv.Schema(
+    schema = cv.Schema(
         {
             cv.Required(CONF_CHANNELS): cv.All(
                 cv.ensure_list(
@@ -139,9 +162,26 @@ def channel_schema(type_: "Type") -> cv.Schema:
                     max=type_.max_channels,
                     msg=f"Device type {type_.name} supports a maximum of {type_.max_channels} channels",
                 ),
-            )
+            ),
         }
     )
+    if type_.has_comm_interface:
+        # The comm (interrupt) interface pins a host hardware channel per device;
+        # disable to save one on channel-poor hosts (some devices may need it
+        # claimed before enabling data flow).
+        schema = schema.extend(
+            {cv.Optional(CONF_CLAIM_COMM_INTERFACE, default=True): cv.boolean}
+        )
+    else:
+        schema = schema.extend(
+            {
+                cv.Optional(CONF_CLAIM_COMM_INTERFACE): cv.invalid(
+                    f"'{CONF_CLAIM_COMM_INTERFACE}' is only supported on device types "
+                    f"that claim the CDC comm interface; {type_.name} never claims it"
+                )
+            }
+        )
+    return schema
 
 
 CONFIG_SCHEMA = cv.ensure_list(
@@ -172,6 +212,9 @@ async def to_code(config: list[ConfigType]) -> None:
 
     for device in config:
         var = await register_usb_client(device)
+        # The C++ default is true; only emit the override
+        if not device.get(CONF_CLAIM_COMM_INTERFACE, True):
+            cg.add(var.set_claim_comm_interface(False))
         for index, channel in enumerate(device[CONF_CHANNELS]):
             chvar = cg.new_Pvariable(channel[CONF_ID], index, channel[CONF_BUFFER_SIZE])
             await cg.register_parented(chvar, var)
diff --git a/esphome/components/usb_uart/usb_uart.cpp b/esphome/components/usb_uart/usb_uart.cpp
index 60b7fe4e9c4..3113f695f60 100644
--- a/esphome/components/usb_uart/usb_uart.cpp
+++ b/esphome/components/usb_uart/usb_uart.cpp
@@ -431,15 +431,20 @@ void USBUartTypeCdcAcm::on_connected() {
     // they enable data flow on the bulk endpoints.
     if (channel->cdc_dev_.interrupt_interface_number != 0xFF &&
         channel->cdc_dev_.interrupt_interface_number != channel->cdc_dev_.bulk_interface_number) {
-      auto err_comm = usb_host_interface_claim(this->handle_, this->device_handle_,
-                                               channel->cdc_dev_.interrupt_interface_number, 0);
-      if (err_comm != ESP_OK) {
-        // Continue anyway: the interface number stays valid for CDC request addressing
-        ESP_LOGW(TAG, "Could not claim comm interface %d: %s", channel->cdc_dev_.interrupt_interface_number,
-                 esp_err_to_name(err_comm));
+      if (!this->claim_comm_interface_) {
+        ESP_LOGD(TAG, "Skipping comm interface %d (claim_comm_interface: false)",
+                 channel->cdc_dev_.interrupt_interface_number);
       } else {
-        ESP_LOGD(TAG, "Claimed comm interface %d", channel->cdc_dev_.interrupt_interface_number);
-        channel->cdc_dev_.interrupt_interface_claimed = true;
+        auto err_comm = usb_host_interface_claim(this->handle_, this->device_handle_,
+                                                 channel->cdc_dev_.interrupt_interface_number, 0);
+        if (err_comm != ESP_OK) {
+          // Continue anyway: the interface number stays valid for CDC request addressing
+          ESP_LOGW(TAG, "Could not claim comm interface %d: %s", channel->cdc_dev_.interrupt_interface_number,
+                   esp_err_to_name(err_comm));
+        } else {
+          ESP_LOGD(TAG, "Claimed comm interface %d", channel->cdc_dev_.interrupt_interface_number);
+          channel->cdc_dev_.interrupt_interface_claimed = true;
+        }
       }
     }
     auto err =
diff --git a/esphome/components/usb_uart/usb_uart.h b/esphome/components/usb_uart/usb_uart.h
index 9d87bf964c0..22563209da3 100644
--- a/esphome/components/usb_uart/usb_uart.h
+++ b/esphome/components/usb_uart/usb_uart.h
@@ -271,12 +271,16 @@ class USBUartComponent : public usb_host::USBClient {
 class USBUartTypeCdcAcm : public USBUartComponent {
  public:
   USBUartTypeCdcAcm(uint16_t vid, uint16_t pid) : USBUartComponent(vid, pid) {}
+  void set_claim_comm_interface(bool claim) { this->claim_comm_interface_ = claim; }
 
  protected:
   virtual std::vector<CdcEps> parse_descriptors(usb_device_handle_t dev_hdl);
   void on_connected() override;
   void on_disconnected() override;
   bool config_step(USBUartChannelBase *channel, uint8_t step, bool reload, bool ok, const uint8_t *response) override;
+  // Each claimed interface pins one host hardware channel per endpoint; skipping
+  // the comm (interrupt) interface frees one on channel-poor hosts (ESP32-S3: 8).
+  bool claim_comm_interface_{true};
 };
 
 class USBUartTypeCP210X : public USBUartTypeCdcAcm {
diff --git a/esphome/components/version/version_text_sensor.h b/esphome/components/version/version_text_sensor.h
index 96f72ad035b..7ff6ac4d352 100644
--- a/esphome/components/version/version_text_sensor.h
+++ b/esphome/components/version/version_text_sensor.h
@@ -7,6 +7,8 @@ namespace esphome::version {
 
 class VersionTextSensor final : public text_sensor::TextSensor, public Component {
  public:
+  // User provided, not "= default": `new(p) VersionTextSensor()` would zero-fill .bss that is already zero.
+  VersionTextSensor() {}
   void set_hide_hash(bool hide_hash) { this->hide_hash_ = hide_hash; }
   void set_hide_timestamp(bool hide_timestamp) { this->hide_timestamp_ = hide_timestamp; }
   void setup() override;
diff --git a/esphome/components/waveshare_epaper/waveshare_epaper.cpp b/esphome/components/waveshare_epaper/waveshare_epaper.cpp
index 14ff5ed53cc..93f23424c01 100644
--- a/esphome/components/waveshare_epaper/waveshare_epaper.cpp
+++ b/esphome/components/waveshare_epaper/waveshare_epaper.cpp
@@ -2183,8 +2183,6 @@ void GDEW029T5::write_lut_(const uint8_t *lut, const uint8_t size) {
   this->end_data_();
 }
 
-void GDEW029T5::set_full_update_every(uint32_t full_update_every) { this->full_update_every_ = full_update_every; }
-
 int GDEW029T5::get_width_internal() { return 128; }
 int GDEW029T5::get_height_internal() { return 296; }
 void GDEW029T5::dump_config() {
@@ -2523,7 +2521,6 @@ void HOT GDEY042T81::display() {
   ESP_LOGD(TAG, "Set the display back to deep sleep");
   this->deep_sleep();
 }
-void GDEY042T81::set_full_update_every(uint32_t full_update_every) { this->full_update_every_ = full_update_every; }
 int GDEY042T81::get_width_internal() { return 400; }
 int GDEY042T81::get_height_internal() { return 300; }
 uint32_t GDEY042T81::idle_timeout_() { return 5000; }
@@ -3156,7 +3153,6 @@ void HOT GDEY0583T81::display() {
   this->deep_sleep();
 }
 
-void GDEY0583T81::set_full_update_every(uint32_t full_update_every) { this->full_update_every_ = full_update_every; }
 int GDEY0583T81::get_width_internal() { return 648; }
 int GDEY0583T81::get_height_internal() { return 480; }
 uint32_t GDEY0583T81::idle_timeout_() { return 5000; }
diff --git a/esphome/components/waveshare_epaper/waveshare_epaper.h b/esphome/components/waveshare_epaper/waveshare_epaper.h
index fa3737238e6..7e16ce3dc30 100644
--- a/esphome/components/waveshare_epaper/waveshare_epaper.h
+++ b/esphome/components/waveshare_epaper/waveshare_epaper.h
@@ -272,7 +272,7 @@ class GDEW029T5 : public WaveshareEPaper {
   void dump_config() override;
 
   void deep_sleep() override;
-  void set_full_update_every(uint32_t full_update_every);
+  void set_full_update_every(uint32_t full_update_every) { this->full_update_every_ = full_update_every; }
 
  protected:
   void init_display_();
@@ -503,7 +503,7 @@ class GDEY042T81 : public WaveshareEPaper {
     this->data(0x01);
   }
 
-  void set_full_update_every(uint32_t full_update_every);
+  void set_full_update_every(uint32_t full_update_every) { this->full_update_every_ = full_update_every; }
 
  protected:
   uint32_t full_update_every_{30};
@@ -695,7 +695,7 @@ class GDEY0583T81 : public WaveshareEPaper {
 
   void deep_sleep() override;
 
-  void set_full_update_every(uint32_t full_update_every);
+  void set_full_update_every(uint32_t full_update_every) { this->full_update_every_ = full_update_every; }
 
  protected:
   int get_width_internal() override;
diff --git a/esphome/components/web_server/web_server.cpp b/esphome/components/web_server/web_server.cpp
index ec536910e54..8b0dfe166fb 100644
--- a/esphome/components/web_server/web_server.cpp
+++ b/esphome/components/web_server/web_server.cpp
@@ -66,9 +66,12 @@ static const char *const TAG = "web_server";
 //   GET  /{domain}/{device_name}/{entity_name} - sub-device state (USE_DEVICES only)
 //   POST /{domain}/{device_name}/{entity_name}/{action} - sub-device action (USE_DEVICES only)
 static UrlMatch match_url(const char *url_ptr, size_t url_len, bool only_domain, bool is_post = false) {
+  // Every path returns this one object so it is built in place; fields are only set once the URL is known valid
+  UrlMatch match{};
+
   // URL must start with '/' and have content after it
   if (url_len < 2 || url_ptr[0] != '/')
-    return UrlMatch{};
+    return match;
 
   const char *p = url_ptr + 1;
   const char *end = url_ptr + url_len;
@@ -90,15 +93,14 @@ static UrlMatch match_url(const char *url_ptr, size_t url_len, bool only_domain,
 
   // Must have domain with trailing slash
   if (!s2)
-    return UrlMatch{};
-
-  UrlMatch match{};
-  match.domain = make_ref(s1, s2);
-  match.valid = true;
-
-  if (only_domain || s2 >= end)
     return match;
 
+  if (only_domain || s2 >= end) {
+    match.domain = make_ref(s1, s2);
+    match.valid = true;
+    return match;
+  }
+
   // Parse remaining segments only when needed
   const char *s3 = next_segment(s2);
   const char *s4 = s3 ? next_segment(s3) : nullptr;
@@ -109,7 +111,7 @@ static UrlMatch match_url(const char *url_ptr, size_t url_len, bool only_domain,
 
   // Reject empty segments
   if (seg2.empty() || (s3 && seg3.empty()) || (s4 && seg4.empty()))
-    return UrlMatch{};
+    return match;
 
   // Interpret based on segment count
   if (!s3) {
@@ -121,28 +123,31 @@ static UrlMatch match_url(const char *url_ptr, size_t url_len, bool only_domain,
     if (is_post) {
       match.id = seg2;
       match.method = seg3;
-      return match;
-    }
+    } else {
 #ifdef USE_DEVICES
-    match.device_name = seg2;
-    match.id = seg3;
+      match.device_name = seg2;
+      match.id = seg3;
 #else
-    return UrlMatch{};  // 3-segment GET not supported without USE_DEVICES
+      return match;  // 3-segment GET not supported without USE_DEVICES
 #endif
+    }
   } else {
     // 3 segments after domain: /{domain}/{device}/{entity}/{action}
 #ifdef USE_DEVICES
     if (!is_post) {
-      return UrlMatch{};  // 4-segment GET not supported (action requires POST)
+      return match;  // 4-segment GET not supported (action requires POST)
     }
     match.device_name = seg2;
     match.id = seg3;
     match.method = seg4;
 #else
-    return UrlMatch{};  // Not supported without USE_DEVICES
+    // Not supported without USE_DEVICES
+    return match;
 #endif
   }
 
+  match.domain = make_ref(s1, s2);
+  match.valid = true;
   return match;
 }
 
@@ -336,12 +341,8 @@ void DeferredUpdateEventSourceList::on_client_disconnect_(DeferredUpdateEventSou
 
 WebServer::WebServer(web_server_base::WebServerBase *base) : base_(base) {}
 
-#ifdef USE_WEBSERVER_CSS_INCLUDE
-void WebServer::set_css_include(const char *css_include) { this->css_include_ = css_include; }
-#endif
-#ifdef USE_WEBSERVER_JS_INCLUDE
-void WebServer::set_js_include(const char *js_include) { this->js_include_ = js_include; }
-#endif
+// Kept out of the callers so the 64 bit division is emitted once
+__attribute__((noinline)) static uint32_t uptime_seconds() { return static_cast<uint32_t>(millis_64() / 1000); }
 
 json::SerializationBuffer<> WebServer::get_config_json() {
   json::JsonBuilder builder;
@@ -350,7 +351,7 @@ json::SerializationBuffer<> WebServer::get_config_json() {
   root[ESPHOME_F("title")] = App.get_friendly_name().empty() ? App.get_name().c_str() : App.get_friendly_name().c_str();
   char comment_buffer[Application::ESPHOME_COMMENT_SIZE_MAX];
   App.get_comment_string(comment_buffer);
-  root[ESPHOME_F("comment")] = comment_buffer;
+  root[ESPHOME_F("comment")] = static_cast<const char *>(comment_buffer);
 #if defined(USE_WEBSERVER_OTA_DISABLED) || !defined(USE_WEBSERVER_OTA)
   root[ESPHOME_F("ota")] = false;  // Note: USE_WEBSERVER_OTA_DISABLED only affects web_server, not captive_portal
 #else
@@ -358,7 +359,7 @@ json::SerializationBuffer<> WebServer::get_config_json() {
 #endif
   root[ESPHOME_F("log")] = this->expose_log_;
   root[ESPHOME_F("lang")] = "en";
-  root[ESPHOME_F("uptime")] = static_cast<uint32_t>(millis_64() / 1000);
+  root[ESPHOME_F("uptime")] = uptime_seconds();
 
   return builder.serialize();
 }
@@ -389,7 +390,7 @@ void WebServer::setup() {
     if (this->events_.empty())
       return;
     char buf[32];
-    auto uptime = static_cast<uint32_t>(millis_64() / 1000);
+    auto uptime = uptime_seconds();
     size_t len = buf_append_printf(buf, sizeof(buf), 0, "{\"uptime\":%" PRIu32 "}", uptime);
     this->events_.try_send_nodefer(buf, len, "ping", millis(), 30000);
   });
@@ -474,7 +475,10 @@ bool WebServer::is_request_origin_allowed_(AsyncWebServerRequest *request, const
   const size_t scheme_sep = origin.find("://");
   if (scheme_sep != std::string::npos) {
     const std::string host = get_request_header(request, "Host");
-    if (!host.empty() && origin.compare(scheme_sep + 3, std::string::npos, host) == 0)
+    // Compare by hand: compare(pos, ...) carries an out_of_range throw path that can never fire here
+    const size_t authority = scheme_sep + 3;
+    if (!host.empty() && origin.size() - authority == host.size() &&
+        memcmp(origin.data() + authority, host.data(), host.size()) == 0)
       return true;
   }
 
@@ -541,7 +545,7 @@ void WebServer::handle_js_request(AsyncWebServerRequest *request) {
 // Helper functions to reduce code size by avoiding macro expansion
 // Build unique id as: {domain}/{device_name}/{entity_name} or {domain}/{entity_name}
 // Uses names (not object_id) to avoid UTF-8 collision issues
-static void set_json_id(JsonObject &root, EntityBase *obj, const char *prefix, JsonDetail start_config) {
+static void set_json_id(JsonObject root, EntityBase *obj, const char *prefix, JsonDetail start_config) {
   const StringRef &name = obj->get_name();
   size_t prefix_len = strlen(prefix);
   size_t name_len = name.size();
@@ -576,7 +580,7 @@ static void set_json_id(JsonObject &root, EntityBase *obj, const char *prefix, J
 #endif
   memcpy(p, name.c_str(), name_len);
   p[name_len] = '\0';
-  root[ESPHOME_F("id")] = id_buf;
+  root[ESPHOME_F("id")] = static_cast<const char *>(id_buf);
 
   if (start_config == DETAIL_ALL) {
     root[ESPHOME_F("domain")] = prefix;
@@ -601,14 +605,13 @@ static void set_json_id(JsonObject &root, EntityBase *obj, const char *prefix, J
 // Keep as separate function even though only used once: reduces code size by ~48 bytes
 // by allowing compiler to share code between template instantiations (bool, float, etc.)
 template<typename T>
-static void set_json_value(JsonObject &root, EntityBase *obj, const char *prefix, const T &value,
-                           JsonDetail start_config) {
+static void set_json_value(JsonObject root, EntityBase *obj, const char *prefix, T value, JsonDetail start_config) {
   set_json_id(root, obj, prefix, start_config);
   root[ESPHOME_F("value")] = value;
 }
 
 template<typename S, typename T>
-static void set_json_icon_state_value(JsonObject &root, EntityBase *obj, const char *prefix, S state, const T &value,
+static void set_json_icon_state_value(JsonObject root, EntityBase *obj, const char *prefix, S state, T value,
                                       JsonDetail start_config) {
   set_json_value(root, obj, prefix, value, start_config);
   root[ESPHOME_F("state")] = state;
@@ -1237,7 +1240,7 @@ json::SerializationBuffer<> WebServer::date_json_(datetime::DateEntity *obj, Jso
   // Format: YYYY-MM-DD (max 10 chars + null)
   char value[12];
   buf_append_printf(value, sizeof(value), 0, "%d-%02d-%02d", obj->year, obj->month, obj->day);
-  set_json_icon_state_value(root, obj, "date", value, value, start_config);
+  set_json_icon_state_value<const char *, const char *>(root, obj, "date", value, value, start_config);
   if (start_config == DETAIL_ALL) {
     this->add_sorting_info_(root, obj);
   }
@@ -1297,7 +1300,7 @@ json::SerializationBuffer<> WebServer::time_json_(datetime::TimeEntity *obj, Jso
   // Format: HH:MM:SS (8 chars + null)
   char value[12];
   buf_append_printf(value, sizeof(value), 0, "%02d:%02d:%02d", obj->hour, obj->minute, obj->second);
-  set_json_icon_state_value(root, obj, "time", value, value, start_config);
+  set_json_icon_state_value<const char *, const char *>(root, obj, "time", value, value, start_config);
   if (start_config == DETAIL_ALL) {
     this->add_sorting_info_(root, obj);
   }
@@ -1358,7 +1361,7 @@ json::SerializationBuffer<> WebServer::datetime_json_(datetime::DateTimeEntity *
   char value[24];
   buf_append_printf(value, sizeof(value), 0, "%d-%02d-%02d %02d:%02d:%02d", obj->year, obj->month, obj->day, obj->hour,
                     obj->minute, obj->second);
-  set_json_icon_state_value(root, obj, "datetime", value, value, start_config);
+  set_json_icon_state_value<const char *, const char *>(root, obj, "datetime", value, value, start_config);
   if (start_config == DETAIL_ALL) {
     this->add_sorting_info_(root, obj);
   }
@@ -2302,7 +2305,7 @@ json::SerializationBuffer<> WebServer::update_json_(update::UpdateEntity *obj, J
   JsonObject root = builder.root();
 
   set_json_icon_state_value(root, obj, "update", json_state_str(update::update_state_to_string(obj->state)),
-                            obj->update_info.latest_version, start_config);
+                            obj->update_info.latest_version.c_str(), start_config);
   if (start_config == DETAIL_ALL) {
     root[ESPHOME_F("current_version")] = obj->update_info.current_version;
     root[ESPHOME_F("title")] = obj->update_info.title;
diff --git a/esphome/components/web_server/web_server.h b/esphome/components/web_server/web_server.h
index 0fbe4ec5515..7aa4ac24a3b 100644
--- a/esphome/components/web_server/web_server.h
+++ b/esphome/components/web_server/web_server.h
@@ -204,14 +204,14 @@ class WebServer final : public Controller, public Component, public AsyncWebHand
    *
    * @param css_url The url to the web server stylesheet.
    */
-  void set_css_url(const char *css_url);
+  void set_css_url(const char *css_url) { this->css_url_ = css_url; }
 
   /** Set the URL to the script that's embedded in the index page. Defaults to
    * https://oi.esphome.io/v1/webserver-v1.min.js
    *
    * @param js_url The url to the web server script.
    */
-  void set_js_url(const char *js_url);
+  void set_js_url(const char *js_url) { this->js_url_ = js_url; }
 #endif
 
 #ifdef USE_WEBSERVER_CSS_INCLUDE
@@ -219,7 +219,7 @@ class WebServer final : public Controller, public Component, public AsyncWebHand
    *
    * @param css_include Local path to web server script.
    */
-  void set_css_include(const char *css_include);
+  void set_css_include(const char *css_include) { this->css_include_ = css_include; }
 #endif
 
 #ifdef USE_WEBSERVER_JS_INCLUDE
@@ -227,7 +227,7 @@ class WebServer final : public Controller, public Component, public AsyncWebHand
    *
    * @param js_include Local path to web server script.
    */
-  void set_js_include(const char *js_include);
+  void set_js_include(const char *js_include) { this->js_include_ = js_include; }
 #endif
 
   /** Determine whether internal components should be displayed on the web server.
@@ -593,7 +593,7 @@ class WebServer final : public Controller, public Component, public AsyncWebHand
 
   web_server_base::WebServerBase *base_;
 #ifdef USE_ESP32
-  AsyncEventSource events_{"/events", this};
+  AsyncEventSource events_{StringRef::from_lit("/events"), this};
 #elif USE_ARDUINO
   DeferredUpdateEventSourceList events_;
 #endif
diff --git a/esphome/components/web_server/web_server_v1.cpp b/esphome/components/web_server/web_server_v1.cpp
index 85a4e80541b..08654e353a9 100644
--- a/esphome/components/web_server/web_server_v1.cpp
+++ b/esphome/components/web_server/web_server_v1.cpp
@@ -69,10 +69,6 @@ void write_row(AsyncResponseStream *stream, EntityBase *obj, const std::string &
   stream->print("</tr>");
 }
 
-void WebServer::set_css_url(const char *css_url) { this->css_url_ = css_url; }
-
-void WebServer::set_js_url(const char *js_url) { this->js_url_ = js_url; }
-
 void WebServer::handle_index_request(AsyncWebServerRequest *request) {
   AsyncResponseStream *stream = request->beginResponseStream(ESPHOME_F("text/html"));
   const auto &title = App.get_name();
diff --git a/esphome/components/web_server_idf/web_server_idf.h b/esphome/components/web_server_idf/web_server_idf.h
index 6469b4c5648..743d296d73a 100644
--- a/esphome/components/web_server_idf/web_server_idf.h
+++ b/esphome/components/web_server_idf/web_server_idf.h
@@ -322,7 +322,7 @@ class AsyncEventSource : public AsyncWebHandler {
   using connect_handler_t = std::function<void(AsyncEventSourceClient *)>;
 
  public:
-  AsyncEventSource(std::string url, esphome::web_server::WebServer *ws) : url_(std::move(url)), web_server_(ws) {}
+  AsyncEventSource(StringRef url, esphome::web_server::WebServer *ws) : url_(url), web_server_(ws) {}
   ~AsyncEventSource() override;
 
   // NOLINTNEXTLINE(readability-identifier-naming)
@@ -352,7 +352,7 @@ class AsyncEventSource : public AsyncWebHandler {
   // Cold path: move sessions from pending_sessions_ into sessions_ and greet each one.
   void __attribute__((noinline, cold)) adopt_pending_sessions_main_loop_();
 
-  std::string url_;
+  StringRef url_;  // Must outlive this object (string literal)
   // Main-loop only. Vector: SSE sessions are 1-5 connections, linear search beats set.
   std::vector<AsyncEventSourceResponse *> sessions_;
   // Httpd-task intake; guarded by pending_mutex_, gated by has_pending_sessions_.
diff --git a/esphome/components/wifi/__init__.py b/esphome/components/wifi/__init__.py
index 81b90766b9e..c22d49e6654 100644
--- a/esphome/components/wifi/__init__.py
+++ b/esphome/components/wifi/__init__.py
@@ -355,7 +355,7 @@ def final_validate(config):
     has_sta = bool(config.get(CONF_NETWORKS, True))
     has_ap = CONF_AP in config
     full_config = fv.full_config.get()
-    has_improv = "esp32_improv" in full_config
+    has_improv = "improv_ble" in full_config
     has_improv_serial = "improv_serial" in full_config
     has_captive_portal = "captive_portal" in full_config
     has_web_server = "web_server" in full_config
@@ -690,7 +690,16 @@ async def to_code(config):
     ):
         cg.add(var.set_reboot_timeout(reboot_timeout))
     if (power_save_mode := config[CONF_POWER_SAVE_MODE]) != "NONE":
-        cg.add(var.set_power_save_mode(power_save_mode))
+        if reasons := CORE.data.get(POWER_SAVE_OFF_REASONS_KEY):
+            _LOGGER.warning(
+                "power_save_mode %s is not applied: %s",
+                power_save_mode,
+                "; ".join(reasons),
+            )
+        else:
+            cg.add(var.set_power_save_mode(power_save_mode))
+    # From here on force_power_save_off() can no longer take effect
+    CORE.data[POWER_SAVE_APPLIED_KEY] = True
     if (
         min_auth_mode := config.get(CONF_MIN_AUTH_MODE)
     ) is not None and min_auth_mode != "WPA2":
@@ -864,6 +873,8 @@ async def wifi_roam_to_code(
 
 KEEP_SCAN_RESULTS_KEY = "wifi_keep_scan_results"
 RUNTIME_POWER_SAVE_KEY = "wifi_runtime_power_save"
+POWER_SAVE_OFF_REASONS_KEY = "wifi_power_save_off_reasons"
+POWER_SAVE_APPLIED_KEY = "wifi_power_save_applied"
 RUNTIME_ROAMING_SUPPRESSION_KEY = "wifi_runtime_roaming_suppression"
 # Keys for listener counts
 IP_STATE_LISTENERS_KEY = "wifi_ip_state_listeners"
@@ -896,6 +907,25 @@ def request_wifi_scan_results_lock() -> None:
     CORE.data[SCAN_RESULTS_LOCK_KEY] = True
 
 
+def force_power_save_off(reason: str) -> None:
+    """Keep the station out of WiFi power save regardless of power_save_mode.
+
+    Components whose platform cannot run power save safely call this from their
+    final validation (FINAL_VALIDATE_SCHEMA), which always runs before any code
+    generation. Every distinct reason is kept; when the configured mode is not
+    NONE, wifi's code generation logs them and skips the mode. Calling it once
+    wifi has generated its code is too late and raises.
+    """
+    if POWER_SAVE_APPLIED_KEY in CORE.data:
+        raise EsphomeError(
+            "wifi.force_power_save_off() must be called from final validation, "
+            "before wifi generates its code"
+        )
+    reasons: list[str] = CORE.data.setdefault(POWER_SAVE_OFF_REASONS_KEY, [])
+    if reason not in reasons:
+        reasons.append(reason)
+
+
 def enable_runtime_power_save_control():
     """Enable runtime WiFi power save control.
 
diff --git a/esphome/components/wifi/wifi_component.cpp b/esphome/components/wifi/wifi_component.cpp
index 5ba36143945..125139ad163 100644
--- a/esphome/components/wifi/wifi_component.cpp
+++ b/esphome/components/wifi/wifi_component.cpp
@@ -37,8 +37,8 @@
 #include "esphome/components/captive_portal/captive_portal.h"
 #endif
 
-#ifdef USE_IMPROV
-#include "esphome/components/esp32_improv/esp32_improv_component.h"
+#ifdef USE_IMPROV_BLE
+#include "esphome/components/improv_ble/improv_ble_component.h"
 #endif
 
 #ifdef USE_IMPROV_SERIAL
@@ -226,7 +226,7 @@ bool CompactString::operator==(const StringRef &other) const {
 /// ┌──────────────────────────────────────────────────────────────────────┐
 /// │        Captive Portal / Improv Mode (AP active, scanning disabled)   │
 /// ├──────────────────────────────────────────────────────────────────────┤
-/// │  When captive_portal or esp32_improv is active, WiFi scanning is     │
+/// │  When captive_portal or improv_ble is active, WiFi scanning is       │
 /// │  disabled because it disrupts AP clients (radio leaves AP channel    │
 /// │  to hop through other channels, causing client disconnections).      │
 /// │                                                                      │
@@ -478,9 +478,9 @@ bool WiFiComponent::needs_full_scan_results_() const {
   }
 #endif
 
-#ifdef USE_IMPROV
+#ifdef USE_IMPROV_BLE
   // BLE improv also needs results during provisioning
-  if (esp32_improv::global_improv_component != nullptr && esp32_improv::global_improv_component->is_active()) {
+  if (improv_ble::global_improv_component != nullptr && improv_ble::global_improv_component->is_active()) {
     return true;
   }
 #endif
@@ -746,10 +746,10 @@ void WiFiComponent::start() {
 #endif
 #endif  // USE_WIFI_AP
   }
-#ifdef USE_IMPROV
-  if (!this->has_sta() && esp32_improv::global_improv_component != nullptr) {
+#ifdef USE_IMPROV_BLE
+  if (!this->has_sta() && improv_ble::global_improv_component != nullptr) {
     if (this->wifi_mode_(true, {}))
-      esp32_improv::global_improv_component->start();
+      improv_ble::global_improv_component->start();
   }
 #endif
   this->wifi_apply_hostname_();
@@ -805,7 +805,7 @@ void WiFiComponent::loop() {
           break;
         }
         // Use longer cooldown when captive portal/improv is active to avoid disrupting user config
-        bool portal_active = this->is_captive_portal_active_() || this->is_esp32_improv_active_();
+        bool portal_active = this->is_captive_portal_active_() || this->is_improv_ble_active_();
         uint32_t cooldown_duration = portal_active ? WIFI_COOLDOWN_WITH_AP_ACTIVE_MS : WIFI_COOLDOWN_DURATION_MS;
         if (now - this->action_started_ > cooldown_duration) {
           // After cooldown we either restarted the adapter because of
@@ -894,12 +894,12 @@ void WiFiComponent::loop() {
     }
 #endif  // USE_WIFI_AP
 
-#ifdef USE_IMPROV
-    if (esp32_improv::global_improv_component != nullptr && !esp32_improv::global_improv_component->is_active() &&
-        !esp32_improv::global_improv_component->should_start()) {
-      if (now - this->last_connected_ > esp32_improv::global_improv_component->get_wifi_timeout()) {
+#ifdef USE_IMPROV_BLE
+    if (improv_ble::global_improv_component != nullptr && !improv_ble::global_improv_component->is_active() &&
+        !improv_ble::global_improv_component->should_start()) {
+      if (now - this->last_connected_ > improv_ble::global_improv_component->get_wifi_timeout()) {
         if (this->wifi_mode_(true, {}))
-          esp32_improv::global_improv_component->start();
+          improv_ble::global_improv_component->start();
       }
     }
 
@@ -1644,9 +1644,9 @@ void WiFiComponent::check_connecting_finished(uint32_t now) {
       ESP_LOGD(TAG, "Disabling AP");
       this->wifi_mode_({}, false);
     }
-#ifdef USE_IMPROV
-    if (this->is_esp32_improv_active_()) {
-      esp32_improv::global_improv_component->stop();
+#ifdef USE_IMPROV_BLE
+    if (this->is_improv_ble_active_()) {
+      improv_ble::global_improv_component->stop();
     }
 #endif
 
@@ -1878,7 +1878,7 @@ WiFiRetryPhase WiFiComponent::determine_next_phase_() {
           return WiFiRetryPhase::RETRY_HIDDEN;
         }
         // Need to scan for captive portal
-      } else if (this->is_esp32_improv_active_()) {
+      } else if (this->is_improv_ble_active_()) {
         // Improv doesn't need scan results
         return WiFiRetryPhase::RETRY_HIDDEN;
       }
@@ -1969,7 +1969,7 @@ bool WiFiComponent::transition_to_phase_(WiFiRetryPhase new_phase) {
       // Skip actual adapter restart if captive portal/improv is active
       // This allows state machine to reset num_retried_ and trigger fresh scan
       // without disrupting the captive portal/improv connection
-      if (!this->is_captive_portal_active_() && !this->is_esp32_improv_active_()) {
+      if (!this->is_captive_portal_active_() && !this->is_improv_ble_active_()) {
         this->restart_adapter();
       } else {
         // Even when skipping full restart, disconnect to clear driver state
@@ -2228,9 +2228,9 @@ bool WiFiComponent::is_captive_portal_active_() {
   return false;
 #endif
 }
-bool WiFiComponent::is_esp32_improv_active_() {
-#ifdef USE_IMPROV
-  return esp32_improv::global_improv_component != nullptr && esp32_improv::global_improv_component->is_active();
+bool WiFiComponent::is_improv_ble_active_() {
+#ifdef USE_IMPROV_BLE
+  return improv_ble::global_improv_component != nullptr && improv_ble::global_improv_component->is_active();
 #else
   return false;
 #endif
diff --git a/esphome/components/wifi/wifi_component.h b/esphome/components/wifi/wifi_component.h
index a0983545fbd..67913796499 100644
--- a/esphome/components/wifi/wifi_component.h
+++ b/esphome/components/wifi/wifi_component.h
@@ -797,7 +797,7 @@ class WiFiComponent final : public Component {
   network::IPAddress wifi_dns_ip_(int num);
 
   bool is_captive_portal_active_();
-  bool is_esp32_improv_active_();
+  bool is_improv_ble_active_();
 
 #ifdef USE_WIFI_FAST_CONNECT
   bool load_fast_connect_settings_(WiFiAP &params);
diff --git a/esphome/const.py b/esphome/const.py
index e1d875f94bf..5ffbf8c49ac 100644
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -352,7 +352,6 @@ CONF_DIRECTION = "direction"
 CONF_DIRECTION_COMMAND_TOPIC = "direction_command_topic"
 CONF_DIRECTION_OUTPUT = "direction_output"
 CONF_DIRECTION_STATE_TOPIC = "direction_state_topic"
-CONF_DISABLE_CRC = "disable_crc"
 CONF_DISABLED = "disabled"
 CONF_DISABLED_BY_DEFAULT = "disabled_by_default"
 CONF_DISCONNECT_DELAY = "disconnect_delay"
@@ -1345,6 +1344,7 @@ DEVICE_CLASS_GARAGE = "garage"
 DEVICE_CLASS_GARAGE_DOOR = "garage_door"
 DEVICE_CLASS_GAS = "gas"
 DEVICE_CLASS_GATE = "gate"
+DEVICE_CLASS_GLASS_BREAK = "glass_break"
 DEVICE_CLASS_HEAT = "heat"
 DEVICE_CLASS_HUMIDITY = "humidity"
 DEVICE_CLASS_IDENTIFY = "identify"
diff --git a/esphome/core/application.cpp b/esphome/core/application.cpp
index 38d3503c2c3..50d1c619595 100644
--- a/esphome/core/application.cpp
+++ b/esphome/core/application.cpp
@@ -11,6 +11,19 @@
 #include <esp_chip_info.h>
 #include <esp_ota_ops.h>
 #include <esp_bootloader_desc.h>
+#include <esp_flash.h>
+#if __has_include(<esp_flash_chips/spi_flash_chip_generic.h>)
+#include <esp_flash_chips/spi_flash_chip_generic.h>  // ESP-IDF 6
+#include <esp_flash_chips/spi_flash_chip_mxic.h>
+#else
+#include <spi_flash_chip_generic.h>
+#include <spi_flash_chip_mxic.h>
+#endif
+// Vendor flash drivers linked next to the generic one; sdkconfig defines each as 1 or not at all
+#define ESPHOME_FLASH_VENDOR_DRIVERS \
+  (CONFIG_SPI_FLASH_SUPPORT_ISSI_CHIP + CONFIG_SPI_FLASH_SUPPORT_MXIC_CHIP + CONFIG_SPI_FLASH_SUPPORT_GD_CHIP + \
+   CONFIG_SPI_FLASH_SUPPORT_WINBOND_CHIP + CONFIG_SPI_FLASH_SUPPORT_BOYA_CHIP + CONFIG_SPI_FLASH_SUPPORT_TH_CHIP + \
+   CONFIG_SPI_FLASH_SUPPORT_MXIC_OPI_CHIP)
 #endif
 #include "esphome/core/version.h"
 #include "esphome/core/hal.h"
@@ -157,8 +170,25 @@ void Application::process_dump_config_() {
     esp_chip_info(&chip_info);
     ESP_LOGI(TAG, "ESP32 Chip: %s rev%d.%d, %d core(s)", ESPHOME_VARIANT, chip_info.revision / 100,
              chip_info.revision % 100, chip_info.cores);
-#if defined(USE_ESP32_VARIANT_ESP32) && (!defined(USE_ESP32_MIN_CHIP_REVISION_SET) || !defined(USE_ESP32_SRAM1_AS_IRAM))
-    static const char *const ESP32_ADVANCED_PATH = "under esp32 > framework > advanced";
+    [[maybe_unused]] static const char *const ESP32_ADVANCED_PATH = "under esp32 > framework > advanced";
+#if ESPHOME_FLASH_VENDOR_DRIVERS > 0
+    {
+      // Only the driver in use earns its IRAM; with several linked at least one is idle
+      const spi_flash_chip_t *flash_driver = esp_flash_default_chip->chip_drv;
+#if ESPHOME_FLASH_VENDOR_DRIVERS > 1
+      constexpr bool idle_driver = true;
+#else
+      const bool idle_driver = flash_driver == &esp_flash_chip_generic;
+#endif
+      if (idle_driver) {
+        const char *value = flash_driver->name;
+#ifdef CONFIG_SPI_FLASH_SUPPORT_MXIC_OPI_CHIP
+        if (flash_driver == &esp_flash_chip_mxic_opi)
+          value = "mxic_opi";
+#endif
+        ESP_LOGW(TAG, "Set flash_chip: %s %s to save IRAM", value, ESP32_ADVANCED_PATH);
+      }
+    }
 #endif
 #if defined(USE_ESP32_VARIANT_ESP32) && !defined(USE_ESP32_MIN_CHIP_REVISION_SET)
     {
diff --git a/esphome/core/application.h b/esphome/core/application.h
index a12cdc4ac88..8ed4c09096a 100644
--- a/esphome/core/application.h
+++ b/esphome/core/application.h
@@ -67,7 +67,7 @@ static constexpr uint32_t TEARDOWN_TIMEOUT_REBOOT_MS = 1000;  // 1 second for qu
 class Application {
  public:
 #ifdef ESPHOME_NAME_ADD_MAC_SUFFIX
-  // Called before Logger::pre_setup() — must not log (global_logger is not yet set).
+  // Runs after Logger::pre_setup() (emitted at EARLY_INIT priority), so the app name is not set yet there.
   /// Pre-setup with MAC suffix: overwrites placeholder in mutable static buffers with actual MAC.
   void pre_setup(char *name, size_t name_len, char *friendly_name, size_t friendly_name_len) {
     arch_init();
@@ -87,7 +87,7 @@ class Application {
     this->friendly_name_ = StringRef(friendly_name, friendly_name_len);
   }
 #else
-  // Called before Logger::pre_setup() — must not log (global_logger is not yet set).
+  // Runs after Logger::pre_setup() (emitted at EARLY_INIT priority), so the app name is not set yet there.
   /// Pre-setup without MAC suffix: StringRef points directly at const string literals in flash.
   void pre_setup(const char *name, size_t name_len, const char *friendly_name, size_t friendly_name_len) {
     arch_init();
@@ -528,7 +528,7 @@ class Application {
 
   // 1-byte members (grouped together to minimize padding)
   uint8_t app_state_{0};
-  bool name_add_mac_suffix_;
+  bool name_add_mac_suffix_{false};
   bool in_loop_{false};
   volatile bool has_pending_enable_loop_requests_{false};
 
diff --git a/esphome/core/automation.h b/esphome/core/automation.h
index ea522a4d2da..5f010521dce 100644
--- a/esphome/core/automation.h
+++ b/esphome/core/automation.h
@@ -608,7 +608,9 @@ template<typename... Ts> class ActionList {
 template<typename... Ts> class Automation {
  public:
   /// Default constructor for use with TriggerForwarder (no Trigger object needed).
-  Automation() = default;
+  // User provided, not "= default": `new(p) Automation()` would zero-fill .bss that is already zero.
+  // constexpr and noexcept keep the rest of the implicit constructor's contract.
+  constexpr Automation() noexcept {}
   explicit Automation(Trigger<Ts...> *trigger) { trigger->set_automation_parent(this); }
 
   void add_action(Action<Ts...> *action) { this->actions_.add_action(action); }
diff --git a/esphome/core/base_automation.h b/esphome/core/base_automation.h
index 276b8aa9728..999b38bd5cf 100644
--- a/esphome/core/base_automation.h
+++ b/esphome/core/base_automation.h
@@ -180,7 +180,9 @@ class ProjectUpdateTrigger : public Trigger<std::string>, public Component {
 
 template<typename... Ts> class DelayAction : public Action<Ts...> {
  public:
-  explicit DelayAction() = default;
+  // User provided, not "= default": `new(p) DelayAction()` would zero-fill .bss that is already zero.
+  // constexpr and noexcept keep the rest of the implicit constructor's contract.
+  constexpr explicit DelayAction() noexcept {}
 
   TEMPLATABLE_VALUE(uint32_t, delay)
 
diff --git a/esphome/core/color.cpp b/esphome/core/color.cpp
index edbc7714720..ba8a594340f 100644
--- a/esphome/core/color.cpp
+++ b/esphome/core/color.cpp
@@ -6,18 +6,13 @@ namespace esphome {
 constinit const Color Color::BLACK(0, 0, 0, 0);
 constinit const Color Color::WHITE(255, 255, 255, 255);
 
-Color Color::gradient(const Color &to_color, uint8_t amnt) {
-  uint8_t inv = 255 - amnt;
-  Color new_color;
-  new_color.r = (uint16_t(this->r) * inv + uint16_t(to_color.r) * amnt) / 255;
-  new_color.g = (uint16_t(this->g) * inv + uint16_t(to_color.g) * amnt) / 255;
-  new_color.b = (uint16_t(this->b) * inv + uint16_t(to_color.b) * amnt) / 255;
-  new_color.w = (uint16_t(this->w) * inv + uint16_t(to_color.w) * amnt) / 255;
-  return new_color;
+Color Color::gradient(const Color &to_color, uint8_t amnt) const {
+  return Color(blend_channel(this->r, to_color.r, amnt), blend_channel(this->g, to_color.g, amnt),
+               blend_channel(this->b, to_color.b, amnt), blend_channel(this->w, to_color.w, amnt));
 }
 
-Color Color::fade_to_white(uint8_t amnt) { return this->gradient(Color::WHITE, amnt); }
+Color Color::fade_to_white(uint8_t amnt) const { return this->gradient(Color::WHITE, amnt); }
 
-Color Color::fade_to_black(uint8_t amnt) { return this->gradient(Color::BLACK, amnt); }
+Color Color::fade_to_black(uint8_t amnt) const { return this->gradient(Color::BLACK, amnt); }
 
 }  // namespace esphome
diff --git a/esphome/core/color.h b/esphome/core/color.h
index 442470623df..c7fd522e1a5 100644
--- a/esphome/core/color.h
+++ b/esphome/core/color.h
@@ -174,9 +174,15 @@ struct Color {
                  uint8_t((uint16_t(b) * 255U / max_rgb)), w);
   }
 
-  Color gradient(const Color &to_color, uint8_t amnt);
-  Color fade_to_white(uint8_t amnt);
-  Color fade_to_black(uint8_t amnt);
+  /// One channel of gradient(): from at amnt 0 to to at amnt 255. Inline so a
+  /// per pixel loop can blend without a call; gradient() itself stays out of
+  /// line so the light effects and fade_to_*() share one copy.
+  static inline uint8_t blend_channel(uint8_t from, uint8_t to, uint8_t amnt) ESPHOME_ALWAYS_INLINE {
+    return (uint16_t(from) * (255 - amnt) + uint16_t(to) * amnt) / 255;
+  }
+  Color gradient(const Color &to_color, uint8_t amnt) const;
+  Color fade_to_white(uint8_t amnt) const;
+  Color fade_to_black(uint8_t amnt) const;
 
   Color lighten(uint8_t delta) { return *this + delta; }
   Color darken(uint8_t delta) { return *this - delta; }
diff --git a/esphome/core/config.py b/esphome/core/config.py
index 67a7b5210ee..8a4eb0fc379 100644
--- a/esphome/core/config.py
+++ b/esphome/core/config.py
@@ -717,9 +717,10 @@ async def to_code(config: ConfigType) -> None:
     cg.add_global(cg.RawExpression("using std::min"))
     cg.add_global(cg.RawExpression("using std::max"))
 
-    # Construct App via placement new — see application.cpp for storage details
+    # Construct App via placement new — see application.cpp for storage details.
+    # No parens: `Application()` would zero-fill storage that is already zero.
     cg.add_global(cg.RawStatement("#include <new>"))
-    cg.add(cg.RawExpression("new (&App) Application()"))
+    cg.add(cg.RawExpression("new (&App) Application"))
     name = config[CONF_NAME]
     friendly_name = config[CONF_FRIENDLY_NAME]
     name_add_mac_suffix = config[CONF_NAME_ADD_MAC_SUFFIX]
diff --git a/esphome/core/defines.h b/esphome/core/defines.h
index 9e62b7f7977..e51928f8d46 100644
--- a/esphome/core/defines.h
+++ b/esphome/core/defines.h
@@ -70,7 +70,6 @@
 #define USE_ESP32_CAMERA_JPEG_CONVERSION
 #define USE_ESP32_HOSTED
 #define USE_ESP32_HOSTED_HTTP_UPDATE
-#define USE_ESP32_IMPROV_STATE_CALLBACK
 #define USE_ESP_NOW_HOSTED
 #define USE_EVENT
 #define USE_FAN
@@ -83,6 +82,7 @@
 #define USE_HTTP_REQUEST_OTA_WATCHDOG_TIMEOUT 8000  // NOLINT
 #define USE_I2S_AUDIO_SPDIF_MODE
 #define USE_IMAGE
+#define USE_IMPROV_BLE_STATE_CALLBACK
 #define USE_INFRARED
 #define USE_IR_RF
 #define USE_JSON
@@ -267,7 +267,7 @@
 #define MAX_API_CONNECTIONS 6
 // The Improv library is not in the Zephyr tidy environment
 #define USE_IMPROV_SERIAL
-#define USE_IMPROV_SERIAL_NEXT_URL
+#define USE_IMPROV_NEXT_URL
 #define USE_MD5
 #define USE_NOISE
 #define USE_SHA256
@@ -393,8 +393,7 @@
 #define USE_ESP32_CAMERA_JPEG_ENCODER
 #define USE_HTTP_REQUEST_RESPONSE
 #define USE_I2C
-#define USE_IMPROV
-#define USE_ESP32_IMPROV_NEXT_URL
+#define USE_IMPROV_BLE
 #define USE_MICROPHONE
 #define USE_PSRAM
 #define USE_SENDSPIN
@@ -402,6 +401,7 @@
 #define USE_SENDSPIN_CONTROLLER
 #define USE_SENDSPIN_METADATA
 #define USE_SENDSPIN_PLAYER
+#define USE_SENDSPIN_SWITCH
 #define USE_SENDSPIN_VISUALIZER
 #define USE_SENDSPIN_PORT 8928  // NOLINT
 #define USE_SOCKET_IMPL_BSD_SOCKETS
@@ -480,6 +480,9 @@
 #define USE_OPENTHREAD
 #define USE_ZIGBEE
 #endif
+#ifndef USE_OPENTHREAD
+#define USE_MDNS_SUPPORTS_ENABLE_DISABLE
+#endif
 #endif
 
 #if defined(USE_ESP32_VARIANT_ESP32S2)
@@ -535,7 +538,7 @@
 // rp2/__init__.py codegen also defines USE_RP2040 as a back-compat alias
 // for external custom components that may still test for it.
 #ifdef USE_RP2
-#define USE_ARDUINO_VERSION_CODE VERSION_CODE(6, 0, 0)
+#define USE_ARDUINO_VERSION_CODE VERSION_CODE(6, 1, 0)
 #define USE_RP2_CRASH_HANDLER
 #define USE_HTTP_REQUEST_RESPONSE
 #define USE_I2C
diff --git a/esphome/core/helpers.h b/esphome/core/helpers.h
index b1f24b25a3d..cfc92932a9d 100644
--- a/esphome/core/helpers.h
+++ b/esphome/core/helpers.h
@@ -242,8 +242,9 @@ template<typename T, size_t N> class StaticVector {
   size_t count_{0};
 
  public:
-  // Default constructor
-  StaticVector() = default;
+  // User provided, not "= default": otherwise `StaticVector<...> x_{}` members
+  // value-initialize and memset data_, defeating the comment above.
+  constexpr StaticVector() noexcept {}
 
   // Iterator range constructor
   template<typename InputIt> StaticVector(InputIt first, InputIt last) {
diff --git a/esphome/espidf/size_summary.py b/esphome/espidf/size_summary.py
index 2be3634c693..d98363dd67e 100644
--- a/esphome/espidf/size_summary.py
+++ b/esphome/espidf/size_summary.py
@@ -9,16 +9,19 @@ byte-identical to PlatformIO's output:
     Flash: [===       ]  48.4% (used 888511 bytes from 1835008 bytes)
 
 The format matches ``script/ci_memory_impact_extract.py`` so CI memory
-analysis works unchanged on native ESP-IDF builds. RAM total is the
-DRAM region size from the linker map; Flash total is taken from
+analysis works unchanged on native ESP-IDF builds. RAM usage comes from
+the DRAM (or unified DIRAM) region of the linker map. Flash used is the
+exact image size matching the ``Total image size`` line: json2
+``total_size`` when present, otherwise derived from the ELF (see
+``_image_size_from_elf``). Flash total is taken from
 ``partitions.csv`` using PlatformIO's rule (first app partition whose
 subtype is ``factory`` or ``ota_0``; see
 ``platform-espressif32/builder/main.py::_update_max_upload_size``).
 
 Structured size data is produced at link time by a CMake POST_BUILD
 custom command (see ``build_gen/espidf.py``) which writes
-``esp_idf_size.json`` next to the ELF. We read that file here rather
-than re-running ``esp_idf_size`` from Python.
+``esp_idf_size.json`` (``--format=json2``, a per-memory-type summary)
+next to the ELF; we read that rather than re-running ``esp_idf_size``.
 """
 
 from __future__ import annotations
@@ -27,6 +30,7 @@ import csv
 import json
 import logging
 from pathlib import Path
+import struct
 
 from esphome.build_helpers.size_summary import print_size_line
 
@@ -69,11 +73,43 @@ def _find_app_partition_size(partitions_csv: Path) -> int:
     raise ValueError(f"No app+factory or app+ota_0 partition in {partitions_csv}")
 
 
-def print_summary(size_json: Path, partitions_csv: Path | None) -> None:
+def _image_size_from_elf(elf: Path) -> int:
+    """Sum the allocated PROGBITS section sizes from an ELF32 file.
+
+    Matches ``esp_idf_size.ng.memorymap._get_image_size`` byte for byte;
+    esptool's ``ELFFile`` filters sections differently and would not.
+    Raises ``ValueError`` for anything but a well-formed ELF32 LE file.
+    """
+    with elf.open("rb") as f:
+        header = f.read(52)  # ELF32 header
+        if len(header) < 52 or header[:6] != b"\x7fELF\x01\x01":
+            raise ValueError(f"{elf} is not a 32-bit little-endian ELF")
+        (e_shoff,) = struct.unpack_from("<I", header, 0x20)  # e_shoff
+        e_shentsize, e_shnum = struct.unpack_from("<HH", header, 0x2E)
+        if e_shentsize < 40:  # sizeof(Elf32_Shdr)
+            raise ValueError(f"{elf} has an invalid section header size")
+        f.seek(e_shoff)
+        table = f.read(e_shnum * e_shentsize)
+    if len(table) < e_shnum * e_shentsize:
+        raise ValueError(f"{elf} has a truncated section header table")
+    total = 0
+    for off in range(0, e_shnum * e_shentsize, e_shentsize):
+        sh_type, sh_flags = struct.unpack_from("<II", table, off + 4)
+        (sh_size,) = struct.unpack_from("<I", table, off + 20)
+        if sh_type == 1 and sh_flags & 0x2:  # SHT_PROGBITS with SHF_ALLOC
+            total += sh_size
+    if total == 0:
+        # A used-0-bytes Flash line would read as a real measurement
+        raise ValueError(f"{elf} has no allocated PROGBITS sections")
+    return total
+
+
+def print_summary(size_json: Path, partitions_csv: Path, firmware_elf: Path) -> None:
     """Print PlatformIO-shaped RAM and Flash one-liners.
 
     Failures are non-fatal: the build has already succeeded, we just couldn't
-    summarize. Logs the cause at debug level.
+    summarize. Anomalies (missing region, unreadable ELF) warn; expected
+    optional inputs (no size json, no partitions.csv) log at debug.
     """
     if not size_json.is_file():
         _LOGGER.debug("Skipping size summary: %s not found", size_json)
@@ -83,20 +119,49 @@ def print_summary(size_json: Path, partitions_csv: Path | None) -> None:
     except (OSError, json.JSONDecodeError) as e:
         _LOGGER.debug("Skipping size summary: %s", e)
         return
-
-    memory_types = data.get("memory_types", {})
-    ram_region = memory_types.get("DRAM") or memory_types.get("DIRAM") or {}
-    ram_used = ram_region.get("used")
-    ram_total = ram_region.get("size")
-    if ram_total and ram_used is not None:
-        print_size_line("RAM", ram_used, ram_total)
-
-    image_size = data.get("image_size")
-    if image_size is None or partitions_csv is None:
+    if not isinstance(data, dict):
+        _LOGGER.warning("Skipping size summary: unexpected json shape in %s", size_json)
         return
+
+    layout = data.get("layout")
+    regions = {
+        entry.get("name"): entry
+        for entry in (layout if isinstance(layout, list) else [])
+        if isinstance(entry, dict)
+    }
+    # Every chip has a DRAM or DIRAM region, so a warning here usually
+    # means the esp_idf_size json schema changed
+    ram_region = regions.get("DRAM") or regions.get("DIRAM")
+    if ram_region is None:
+        _LOGGER.warning("Skipping RAM summary: no DRAM/DIRAM region in %s", size_json)
+    elif (
+        isinstance(ram_total := ram_region.get("total"), int)
+        and ram_total > 0
+        and isinstance(ram_used := ram_region.get("used"), int)
+    ):
+        print_size_line("RAM", ram_used, ram_total)
+    else:
+        _LOGGER.warning(
+            "Skipping RAM summary: unusable region %s in %s", ram_region, size_json
+        )
+
+    # esp-idf-size >= 2.1 (IDF >= 6.0) reports the exact image size in
+    # json2; older 1.x omits it, so derive the same figure from the ELF.
+    flash_used = data.get("total_size")
+    if not (isinstance(flash_used, int) and flash_used > 0):
+        _LOGGER.debug("No total_size in %s, deriving from %s", size_json, firmware_elf)
+        try:
+            flash_used = _image_size_from_elf(firmware_elf)
+        except (OSError, ValueError) as e:
+            # The ELF must be present and well formed after a successful build
+            _LOGGER.warning("Skipping Flash summary: %s", e)
+            return
     try:
         app_size = _find_app_partition_size(partitions_csv)
-    except ValueError as e:
+    except (OSError, ValueError) as e:
         _LOGGER.debug("Skipping Flash summary: %s", e)
         return
-    print_size_line("Flash", image_size, app_size)
+    if app_size <= 0:
+        _LOGGER.debug("Skipping Flash summary: app partition size is 0")
+        return
+    print_size_line("Flash", flash_used, app_size)
diff --git a/esphome/espidf/toolchain.py b/esphome/espidf/toolchain.py
index 986f9dfb8bd..f695bdb7ab4 100644
--- a/esphome/espidf/toolchain.py
+++ b/esphome/espidf/toolchain.py
@@ -542,7 +542,7 @@ def run_compile(config, verbose: bool) -> int:
     if rc == 0:
         size_json = CORE.relative_build_path("build", "esp_idf_size.json")
         partitions = CORE.relative_build_path("partitions.csv")
-        print_summary(size_json, partitions if partitions.is_file() else None)
+        print_summary(size_json, partitions, get_built_elf_path())
     return rc
 
 
@@ -579,6 +579,16 @@ def get_ota_firmware_path() -> Path:
     return build_dir / "firmware.ota.bin"
 
 
+def get_built_elf_path() -> Path:
+    """Path to the ELF idf.py writes directly, ``<build>/<name>.elf``.
+
+    Exists as soon as the build finishes, unlike the ``firmware.elf``
+    copy that ``create_elf_copy`` makes later.
+    """
+    build_dir = CORE.relative_build_path("build")
+    return build_dir / f"{CORE.name}.elf"
+
+
 def get_elf_path() -> Path:
     """Get the path to the firmware ELF file.
 
@@ -706,8 +716,7 @@ def create_elf_copy() -> bool:
     "download ELF" link requests the literal filename ``firmware.elf``
     (PlatformIO convention), so copy it to that name.
     """
-    build_dir = CORE.relative_build_path("build")
-    src_elf = build_dir / f"{CORE.name}.elf"
+    src_elf = get_built_elf_path()
     dst_elf = get_elf_path()
 
     if not src_elf.is_file():
diff --git a/esphome/idf_component.yml b/esphome/idf_component.yml
index b3cd5ee09b5..d12a27221b9 100644
--- a/esphome/idf_component.yml
+++ b/esphome/idf_component.yml
@@ -4,7 +4,7 @@ dependencies:
   esphome/dlms_parser:
     version: 1.1.0
   esphome/esp-audio-libs:
-    version: 4.0.0
+    version: 4.0.1
   esphome/esp-micro-speech-features:
     version: 1.2.3
   esphome/micro-decoder:
@@ -98,7 +98,7 @@ dependencies:
   esp32async/asynctcp:
     version: 3.4.91
   sendspin/sendspin-cpp:
-    version: 0.7.2
+    version: 0.8.0
   lvgl/lvgl:
     version: 9.5.0
   fastled/FastLED:
diff --git a/platformio.ini b/platformio.ini
index 0e334ac5b4c..37504384cbc 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -46,7 +46,7 @@ lib_deps =
     ${common.lib_deps_base}
     https://github.com/dudanov/MideaUART.git#eeea6c3e9b4474f067054592b435be1c4e466815 ; midea
     esphome/noise-c@0.1.30                 ; noise (api, ota)
-    improv/Improv@1.2.7                    ; improv_serial / esp32_improv
+    improv/Improv@1.2.7                    ; improv_serial / improv_ble
     kikuchan98/pngle@1.1.0                 ; online_image
     ; Using the repository directly, otherwise ESP-IDF can't use the library
     https://github.com/bitbank2/JPEGDEC.git#1.8.4    ; online_image
@@ -203,11 +203,11 @@ extra_scripts =
 extends = common:arduino
 board_build.filesystem_size = 0.5m
 
-platform = https://github.com/maxgerhardt/platform-raspberrypi.git#9c167c6b8aac4f4cfa6d55a0c4e5b848795150c0
+platform = https://github.com/maxgerhardt/platform-raspberrypi.git#5d4561a05e3b212660ac6fdd3fbfb328d1988aa1
 platform_packages =
     ; The framework-arduinopico package is no longer published to the PlatformIO
     ; registry, so install the framework straight from the GitHub release
-    earlephilhower/framework-arduinopico@https://github.com/earlephilhower/arduino-pico/releases/download/6.0.0/rp2040-6.0.0.zip
+    earlephilhower/framework-arduinopico@https://github.com/earlephilhower/arduino-pico/releases/download/6.1.0/rp2040-6.1.0.zip
 
 framework = arduino
 lib_deps =
diff --git a/requirements.txt b/requirements.txt
index 79c6c7a4232..700e0da0717 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -7,7 +7,7 @@ PyYAML==6.0.3
 paho-mqtt==1.6.1
 colorama==0.4.6
 tzlocal==5.4.4    # from time
-tzdata>=2026.3  # from time
+tzdata>=2026.4  # from time
 pyserial==3.5
 platformio==6.1.19
 esptool==5.4.0
@@ -27,9 +27,9 @@ bleak==3.0.2
 smpclient==7.2.0
 requests==2.34.2
 py7zr==1.1.3
-platformdirs==4.11.7  # native esp-idf toolchain global cache dir
+platformdirs==4.11.8  # native esp-idf toolchain global cache dir
 ninja==1.13.2  # native esp8266 arduino toolchain build driver
-filelock==3.32.5  # inter-process locks (PlatformIO cache heal, git clone cache); >=3.32 for FileLock(fallback_to_soft=...), older versions silently drop the kwarg
+filelock==3.32.6  # inter-process locks (PlatformIO cache heal, git clone cache); >=3.32 for FileLock(fallback_to_soft=...), older versions silently drop the kwarg
 
 # zstd compression for store_yaml component (stdlib in 3.14+)
 backports.zstd==1.5.0; python_version < "3.14"
diff --git a/requirements_test.txt b/requirements_test.txt
index cd0427f33e1..81208d7cb71 100644
--- a/requirements_test.txt
+++ b/requirements_test.txt
@@ -1,8 +1,8 @@
 pylint==4.0.8
 flake8==7.3.0  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
-ruff==0.16.6  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
+ruff==0.16.7  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
 pyupgrade==3.21.2  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
-prek==0.5.2  # .github/workflows/ci.yml reads this pin
+prek==0.5.3  # .github/workflows/ci.yml reads this pin
 yamlrocks==0.6.1  # used by script/sync_dependency_versions.py
 
 # Unit tests
diff --git a/script/analyze_component_buses.py b/script/analyze_component_buses.py
index 6ddf9c3b3ed..95d4c48e821 100755
--- a/script/analyze_component_buses.py
+++ b/script/analyze_component_buses.py
@@ -98,6 +98,7 @@ ISOLATED_COMPONENTS = {
     "packages": "cannot merge packages",
     "store_yaml": "Embeds the whole merged config in firmware; grouping would make the blob and its secret redaction depend on every grouped component's test config",
     "tinyusb": "Conflicts with usb_host component - cannot be used together",
+    "uart_mux": "Depends on tinyusb which conflicts with usb_host",
     "usb_cdc_acm": "Depends on tinyusb which conflicts with usb_host",
 }
 
diff --git a/script/ci-custom.py b/script/ci-custom.py
index e2b7cd8d376..286dda85b9e 100755
--- a/script/ci-custom.py
+++ b/script/ci-custom.py
@@ -247,6 +247,9 @@ def lint_ext_check(fname):
         "CLAUDE.md",
         "GEMINI.md",
         ".github/copilot-instructions.md",
+        # Symlinks to the shared .agents/skills directory
+        ".claude/skills",
+        ".github/skills",
         # Symlink to the real wifi scan_list.h so the test stub cannot drift
         "tests/integration/fixtures/external_components/wifi/scan_list.h",
     ]
@@ -710,7 +713,7 @@ def lint_constants_usage():
 # Maximum allowed CONF_ constants in esphome/const.py.
 # This file is frozen — new constants go in esphome/components/const/__init__.py.
 # Decrease this number when constants are moved out of const.py.
-CONST_PY_MAX_CONF = 1017
+CONST_PY_MAX_CONF = 1016
 
 
 @lint_content_check(include=["esphome/const.py"])
diff --git a/tests/component_tests/api/config/bare.yaml b/tests/component_tests/api/config/bare.yaml
new file mode 100644
index 00000000000..be5c73f18bc
--- /dev/null
+++ b/tests/component_tests/api/config/bare.yaml
@@ -0,0 +1,12 @@
+---
+esphome:
+  name: test
+
+esp32:
+  board: esp32dev
+
+wifi:
+  ssid: test
+  password: testtest
+
+api:
diff --git a/tests/component_tests/api/config/custom.yaml b/tests/component_tests/api/config/custom.yaml
new file mode 100644
index 00000000000..cdf4038d5d5
--- /dev/null
+++ b/tests/component_tests/api/config/custom.yaml
@@ -0,0 +1,15 @@
+---
+esphome:
+  name: test
+
+esp32:
+  board: esp32dev
+
+wifi:
+  ssid: test
+  password: testtest
+
+api:
+  port: 6054
+  reboot_timeout: 0s
+  batch_delay: 0ms
diff --git a/tests/component_tests/api/config/defaults.yaml b/tests/component_tests/api/config/defaults.yaml
new file mode 100644
index 00000000000..b20fd9b884c
--- /dev/null
+++ b/tests/component_tests/api/config/defaults.yaml
@@ -0,0 +1,15 @@
+---
+esphome:
+  name: test
+
+esp32:
+  board: esp32dev
+
+wifi:
+  ssid: test
+  password: testtest
+
+api:
+  port: 6053
+  reboot_timeout: 15min
+  batch_delay: 100ms
diff --git a/tests/component_tests/api/test_default_setters.py b/tests/component_tests/api/test_default_setters.py
new file mode 100644
index 00000000000..32d35cacb7c
--- /dev/null
+++ b/tests/component_tests/api/test_default_setters.py
@@ -0,0 +1,35 @@
+"""Tests that the api component only emits setters for non default values."""
+
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+
+
+@pytest.mark.parametrize("config_file", ["bare.yaml", "defaults.yaml"])
+def test_default_values_are_not_emitted(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+    config_file: str,
+) -> None:
+    """Port 6053, a 15 min reboot timeout and 100 ms batch delay are C++ initializers.
+
+    Both the schema defaults and the same values written explicitly take the skip path.
+    """
+    main_cpp = generate_main(component_config_path(config_file))
+
+    assert "api_apiserver_id->set_port(" not in main_cpp
+    assert "api_apiserver_id->set_reboot_timeout(" not in main_cpp
+    assert "api_apiserver_id->set_batch_delay(" not in main_cpp
+
+
+def test_custom_values_are_emitted(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+) -> None:
+    """Non default values still reach the C++ setters."""
+    main_cpp = generate_main(component_config_path("custom.yaml"))
+
+    assert "api_apiserver_id->set_port(6054);" in main_cpp
+    assert "api_apiserver_id->set_reboot_timeout(0);" in main_cpp
+    assert "api_apiserver_id->set_batch_delay(0);" in main_cpp
diff --git a/tests/component_tests/bk72xx_ble/config/test_power_save.yaml b/tests/component_tests/bk72xx_ble/config/test_power_save.yaml
new file mode 100644
index 00000000000..87f599c66e8
--- /dev/null
+++ b/tests/component_tests/bk72xx_ble/config/test_power_save.yaml
@@ -0,0 +1,12 @@
+esphome:
+  name: bk-power-save
+
+bk72xx:
+  board: cb2s
+
+wifi:
+  ssid: test
+  password: testtest
+  power_save_mode: high
+
+bk72xx_ble:
diff --git a/tests/component_tests/bk72xx_ble/test_power_save.py b/tests/component_tests/bk72xx_ble/test_power_save.py
new file mode 100644
index 00000000000..6973e6e26f8
--- /dev/null
+++ b/tests/component_tests/bk72xx_ble/test_power_save.py
@@ -0,0 +1,20 @@
+"""bk72xx_ble keeps WiFi power save off: the Beken SDK's MCU sleep does not
+wake up once the station is stopped while the BLE controller runs."""
+
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+
+
+def test_power_save_mode_is_not_applied_with_ble(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    main_cpp = generate_main(component_config_path("test_power_save.yaml"))
+
+    assert "bk72xx_ble::BK72xxBLE" in main_cpp
+    assert "set_power_save_mode(" not in main_cpp
+    assert "power_save_mode HIGH is not applied" in caplog.text
+    assert "issues/18592" in caplog.text
diff --git a/tests/component_tests/esp32/config/file_macro_idf_5_0.yaml b/tests/component_tests/esp32/config/file_macro_idf_5_0.yaml
new file mode 100644
index 00000000000..22ee1e480e6
--- /dev/null
+++ b/tests/component_tests/esp32/config/file_macro_idf_5_0.yaml
@@ -0,0 +1,8 @@
+esphome:
+  name: test
+
+esp32:
+  board: esp32dev
+  framework:
+    type: esp-idf
+    version: 5.0.6
diff --git a/tests/component_tests/esp32/config/flash_chip_gd.yaml b/tests/component_tests/esp32/config/flash_chip_gd.yaml
new file mode 100644
index 00000000000..6d564135c00
--- /dev/null
+++ b/tests/component_tests/esp32/config/flash_chip_gd.yaml
@@ -0,0 +1,9 @@
+esphome:
+  name: test
+
+esp32:
+  board: esp32dev
+  framework:
+    type: esp-idf
+    advanced:
+      flash_chip: gd
diff --git a/tests/component_tests/esp32/config/flash_chip_generic.yaml b/tests/component_tests/esp32/config/flash_chip_generic.yaml
new file mode 100644
index 00000000000..8c7bcf61664
--- /dev/null
+++ b/tests/component_tests/esp32/config/flash_chip_generic.yaml
@@ -0,0 +1,9 @@
+esphome:
+  name: test
+
+esp32:
+  board: esp32dev
+  framework:
+    type: esp-idf
+    advanced:
+      flash_chip: generic
diff --git a/tests/component_tests/esp32/config/flash_chip_mxic_opi_s3.yaml b/tests/component_tests/esp32/config/flash_chip_mxic_opi_s3.yaml
new file mode 100644
index 00000000000..1531e749f20
--- /dev/null
+++ b/tests/component_tests/esp32/config/flash_chip_mxic_opi_s3.yaml
@@ -0,0 +1,10 @@
+esphome:
+  name: test
+
+esp32:
+  variant: esp32s3
+  flash_mode: opi
+  framework:
+    type: esp-idf
+    advanced:
+      flash_chip: mxic_opi
diff --git a/tests/component_tests/esp32/config/flash_mode_opi_s3.yaml b/tests/component_tests/esp32/config/flash_mode_opi_s3.yaml
new file mode 100644
index 00000000000..82262f63493
--- /dev/null
+++ b/tests/component_tests/esp32/config/flash_mode_opi_s3.yaml
@@ -0,0 +1,8 @@
+esphome:
+  name: test
+
+esp32:
+  variant: esp32s3
+  flash_mode: opi
+  framework:
+    type: esp-idf
diff --git a/tests/component_tests/esp32/test_esp32.py b/tests/component_tests/esp32/test_esp32.py
index 2dd2a50c83c..a42d244ac8f 100644
--- a/tests/component_tests/esp32/test_esp32.py
+++ b/tests/component_tests/esp32/test_esp32.py
@@ -10,6 +10,7 @@ from typing import Any
 import pytest
 
 from esphome.components.esp32 import (
+    ESP32_FLASH_CHIPS,
     KEY_FATFS_REQUIRED,
     KEY_MBEDTLS_TLS_EXTRAS_REQUIRED,
     KEY_MBEDTLS_TLS_SERVER_REQUIRED,
@@ -252,6 +253,51 @@ def test_esp32_rejects_unsupported_cli_toolchain(
             r"value must be at most 5 .* @ data\['framework'\]\['advanced'\]\['nvs_encryption'\]\['key_id'\]",
             id="nvs_encryption_key_id_out_of_range",
         ),
+        pytest.param(
+            {
+                "variant": "esp32",
+                "board": "esp32dev",
+                "framework": {
+                    "type": "esp-idf",
+                    "advanced": {"flash_chip": "mxic_opi"},
+                },
+            },
+            r"'flash_chip: mxic_opi' is only supported on ESP32S3 @ data\['framework'\]\['advanced'\]\['flash_chip'\]",
+            id="flash_chip_mxic_opi_only_on_s3",
+        ),
+        pytest.param(
+            {
+                "variant": "esp32s3",
+                "flash_mode": "opi",
+                "framework": {
+                    "type": "esp-idf",
+                    "advanced": {"flash_chip": "gd"},
+                },
+            },
+            r"'flash_chip: gd' does not match 'flash_mode: opi'; octal flash uses mxic_opi @ data\['framework'\]\['advanced'\]\['flash_chip'\]",
+            id="flash_chip_must_match_opi_mode",
+        ),
+        pytest.param(
+            {
+                "variant": "esp32s3",
+                "framework": {
+                    "type": "esp-idf",
+                    "advanced": {"flash_chip": "mxic_opi"},
+                },
+            },
+            r"'flash_chip: mxic_opi' requires 'flash_mode: opi' @ data\['framework'\]\['advanced'\]\['flash_chip'\]",
+            id="flash_chip_mxic_opi_requires_opi_mode",
+        ),
+        pytest.param(
+            {
+                "variant": "esp32",
+                "board": "esp32dev",
+                "flash_mode": "opi",
+                "framework": {"type": "esp-idf"},
+            },
+            r"'flash_mode: opi' is only supported on ESP32S3 @ data\['flash_mode'\]",
+            id="flash_mode_opi_only_on_s3",
+        ),
     ],
 )
 def test_esp32_configuration_errors(
@@ -658,6 +704,27 @@ def test_platformio_arduino_enables_reproducible_build(
     assert sdkconfig.get("CONFIG_APP_REPRODUCIBLE_BUILD") is True
 
 
+@pytest.mark.parametrize(
+    ("config_file", "expected"),
+    [
+        ("reproducible_build.yaml", True),
+        ("reproducible_build_arduino.yaml", True),
+        ("file_macro_idf_5_0.yaml", False),
+    ],
+)
+def test_file_macro_is_basename_only(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+    config_file: str,
+    expected: bool,
+) -> None:
+    """__FILE__ becomes the basename on GCC 12 toolchains; IDF 5.0 (GCC 11) is skipped."""
+    generate_main(component_config_path(config_file))
+
+    assert ("-D__FILE__=__FILE_NAME__" in CORE.build_flags) is expected
+    assert ("-Wno-builtin-macro-redefined" in CORE.build_flags) is expected
+
+
 def test_native_idf_enables_reproducible_build(
     component_config_path: Callable[[str], Path],
 ) -> None:
@@ -683,10 +750,59 @@ def test_flash_mode_sets_sdkconfig_and_pio_option(
     sdkconfig = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS]
     assert sdkconfig.get("CONFIG_ESPTOOLPY_FLASHMODE_QIO") is True
     assert sdkconfig.get("CONFIG_ESPTOOLPY_FLASHFREQ_80M") is True
+    assert sdkconfig.get("CONFIG_ESPTOOLPY_OCT_FLASH") is False
     assert CORE.platformio_options.get("board_build.flash_mode") == "qio"
     assert CORE.platformio_options.get("board_build.f_flash") == "80000000L"
 
 
+@pytest.mark.parametrize(
+    ("config_file", "enabled"),
+    [
+        pytest.param("flash_chip_gd.yaml", "CONFIG_SPI_FLASH_SUPPORT_GD_CHIP", id="gd"),
+        pytest.param("flash_chip_generic.yaml", None, id="generic"),
+        pytest.param(
+            "flash_chip_mxic_opi_s3.yaml",
+            "CONFIG_SPI_FLASH_SUPPORT_MXIC_OPI_CHIP",
+            id="mxic_opi_s3",
+        ),
+    ],
+)
+def test_flash_chip_keeps_one_vendor_driver(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+    config_file: str,
+    enabled: str | None,
+) -> None:
+    """flash_chip enables only the chosen vendor driver."""
+    generate_main(component_config_path(config_file))
+    sdkconfig = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS]
+    vendors = {
+        k: v for k, v in sdkconfig.items() if k.startswith("CONFIG_SPI_FLASH_SUPPORT_")
+    }
+    assert vendors == {flag: flag == enabled for flag in ESP32_FLASH_CHIPS.values()}
+
+
+def test_flash_chip_unset_keeps_idf_defaults(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+) -> None:
+    """Without flash_chip every vendor driver stays at its ESP-IDF default."""
+    generate_main(component_config_path("flash_mode_default.yaml"))
+    sdkconfig = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS]
+    assert not any(key.startswith("CONFIG_SPI_FLASH_SUPPORT_") for key in sdkconfig)
+
+
+def test_flash_mode_opi_enables_octal_flash(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+) -> None:
+    """flash_mode: opi needs the octal flash switch or ESP-IDF ignores the mode."""
+    generate_main(component_config_path("flash_mode_opi_s3.yaml"))
+    sdkconfig = CORE.data[KEY_ESP32][KEY_SDKCONFIG_OPTIONS]
+    assert sdkconfig.get("CONFIG_ESPTOOLPY_FLASHMODE_OPI") is True
+    assert sdkconfig.get("CONFIG_ESPTOOLPY_OCT_FLASH") is True
+
+
 def test_flash_mode_unset_leaves_defaults(
     generate_main: Callable[[str | Path], str],
     component_config_path: Callable[[str], Path],
diff --git a/tests/component_tests/esp32_ble_server/config/improv_only.yaml b/tests/component_tests/esp32_ble_server/config/improv_only.yaml
index 8a5c3ba6383..4239d24b0fe 100644
--- a/tests/component_tests/esp32_ble_server/config/improv_only.yaml
+++ b/tests/component_tests/esp32_ble_server/config/improv_only.yaml
@@ -9,5 +9,5 @@ wifi:
   password: password1
 
 # esp32_ble_server is only auto-loaded here, so it has no services of its own.
-esp32_improv:
+improv_ble:
   authorizer: none
diff --git a/tests/component_tests/esp32_ble_server/test_esp32_ble_server.py b/tests/component_tests/esp32_ble_server/test_esp32_ble_server.py
index 4b7ab79a81c..21a12d9cf2e 100644
--- a/tests/component_tests/esp32_ble_server/test_esp32_ble_server.py
+++ b/tests/component_tests/esp32_ble_server/test_esp32_ble_server.py
@@ -55,7 +55,7 @@ def test_uuid_is_matches_descriptor_short_strings(uuid16) -> None:
 @pytest.mark.parametrize(
     ("config_file", "required"),
     [
-        # Auto-loaded by esp32_improv only: nothing to find until Improv asks for it
+        # Auto-loaded by improv_ble only: nothing to find until Improv asks for it
         ("improv_only.yaml", False),
         # The configuration defines a service clients are meant to connect to
         ("own_service.yaml", True),
diff --git a/tests/component_tests/improv_ble/__init__.py b/tests/component_tests/improv_ble/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/component_tests/improv_ble/config/automations.yaml b/tests/component_tests/improv_ble/config/automations.yaml
new file mode 100644
index 00000000000..d5d97f5cbf3
--- /dev/null
+++ b/tests/component_tests/improv_ble/config/automations.yaml
@@ -0,0 +1,31 @@
+esphome:
+  name: improv-ble-automations
+esp32:
+  variant: esp32
+  framework:
+    type: esp-idf
+logger:
+wifi:
+  ssid: MySSID
+  password: password1
+binary_sensor:
+  - platform: gpio
+    pin: 0
+    id: io0_button
+output:
+  - platform: gpio
+    pin: 2
+    id: built_in_led
+improv_ble:
+  authorizer: io0_button
+  status_indicator: built_in_led
+  on_provisioned:
+    - logger.log: provisioned
+  on_provisioning:
+    - logger.log: provisioning
+  on_start:
+    - logger.log: start
+  on_state:
+    - logger.log: state
+  on_stop:
+    - logger.log: stop
diff --git a/tests/component_tests/improv_ble/config/esp32.yaml b/tests/component_tests/improv_ble/config/esp32.yaml
new file mode 100644
index 00000000000..ed55ef358ae
--- /dev/null
+++ b/tests/component_tests/improv_ble/config/esp32.yaml
@@ -0,0 +1,12 @@
+esphome:
+  name: improv-ble-esp32
+esp32:
+  variant: esp32
+  framework:
+    type: esp-idf
+logger:
+wifi:
+  ssid: MySSID
+  password: password1
+improv_ble:
+  authorizer: none
diff --git a/tests/component_tests/improv_ble/config/esp8266.yaml b/tests/component_tests/improv_ble/config/esp8266.yaml
new file mode 100644
index 00000000000..d32defd6f33
--- /dev/null
+++ b/tests/component_tests/improv_ble/config/esp8266.yaml
@@ -0,0 +1,10 @@
+esphome:
+  name: improv-ble-esp8266
+esp8266:
+  board: nodemcuv2
+logger:
+wifi:
+  ssid: MySSID
+  password: password1
+improv_ble:
+  authorizer: none
diff --git a/tests/component_tests/improv_ble/config/legacy_key.yaml b/tests/component_tests/improv_ble/config/legacy_key.yaml
new file mode 100644
index 00000000000..9491203ca90
--- /dev/null
+++ b/tests/component_tests/improv_ble/config/legacy_key.yaml
@@ -0,0 +1,12 @@
+esphome:
+  name: improv-ble-legacy-key
+esp32:
+  variant: esp32
+  framework:
+    type: esp-idf
+logger:
+wifi:
+  ssid: MySSID
+  password: password1
+esp32_improv:
+  authorizer: none
diff --git a/tests/component_tests/improv_ble/test_improv_ble.py b/tests/component_tests/improv_ble/test_improv_ble.py
new file mode 100644
index 00000000000..02293bdb23b
--- /dev/null
+++ b/tests/component_tests/improv_ble/test_improv_ble.py
@@ -0,0 +1,59 @@
+"""improv_ble is platform neutral; only its BLE server backends are not.
+
+Covers the platform gate (BLE_SERVER_BACKENDS) and the esp32_improv alias that
+keeps pre-rename configurations working.
+"""
+
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+
+from esphome.config import read_config
+from esphome.core import CORE
+
+
+def test_esp32_generates_component(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+) -> None:
+    main_cpp = generate_main(component_config_path("esp32.yaml"))
+    assert "improv_ble::ImprovBLEComponent" in main_cpp
+
+
+def test_legacy_key_routes_to_improv_ble(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    main_cpp = generate_main(component_config_path("legacy_key.yaml"))
+    assert "improv_ble::ImprovBLEComponent" in main_cpp
+    assert "'esp32_improv:' top-level key is deprecated" in caplog.text
+
+
+def test_platform_without_ble_server_rejected(
+    component_config_path: Callable[[str], Path],
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    # AUTO_LOAD finds no backend for esp8266 and pulls in improv_base only, so
+    # the platform gate in CONFIG_SCHEMA is what has to reject the config.
+    CORE.config_path = component_config_path("esp8266.yaml")
+    assert read_config({}) is None
+    assert "only available on" in capsys.readouterr().out
+
+
+def test_automations_emit_renamed_triggers(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+) -> None:
+    main_cpp = generate_main(component_config_path("automations.yaml"))
+    for trigger in (
+        "ImprovBLEProvisionedTrigger",
+        "ImprovBLEProvisioningTrigger",
+        "ImprovBLEStartTrigger",
+        "ImprovBLEStateTrigger",
+        "ImprovBLEStoppedTrigger",
+    ):
+        assert f"improv_ble::{trigger}" in main_cpp
+    assert "set_authorizer" in main_cpp
+    assert "set_status_indicator" in main_cpp
diff --git a/tests/component_tests/mdns/__init__.py b/tests/component_tests/mdns/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/component_tests/mdns/test_service_enable_disable.py b/tests/component_tests/mdns/test_service_enable_disable.py
new file mode 100644
index 00000000000..eacf722f177
--- /dev/null
+++ b/tests/component_tests/mdns/test_service_enable_disable.py
@@ -0,0 +1,70 @@
+"""request_service_enable_disable() only opts in on platforms whose mDNS stack
+can add and remove services after setup, and tells the caller so."""
+
+import pytest
+
+from esphome.components import mdns
+from esphome.const import CONF_DISABLED, PlatformFramework
+from esphome.core import CORE
+from tests.component_tests.types import SetCoreConfigCallable
+
+DEFINE = "USE_MDNS_SUPPORTS_ENABLE_DISABLE"
+
+
+def _defines() -> set[str]:
+    return {define.name for define in CORE.defines}
+
+
+def _set_config(
+    set_core_config: SetCoreConfigCallable,
+    platform_framework: PlatformFramework,
+    config: dict,
+) -> None:
+    set_core_config(platform_framework)
+    CORE.config = config
+
+
+@pytest.mark.parametrize(
+    "platform_framework",
+    [PlatformFramework.ESP32_IDF, PlatformFramework.ESP32_ARDUINO],
+)
+def test_esp32_adds_define_and_keeps_services_stored(
+    set_core_config: SetCoreConfigCallable, platform_framework: PlatformFramework
+) -> None:
+    _set_config(set_core_config, platform_framework, {"mdns": {CONF_DISABLED: False}})
+
+    assert mdns.request_service_enable_disable() is True
+    # Disabled services must stay stored so they can be re-registered later.
+    assert {DEFINE, "USE_MDNS_STORE_SERVICES"} <= _defines()
+
+
+@pytest.mark.parametrize(
+    "platform_framework",
+    [PlatformFramework.ESP8266_ARDUINO, PlatformFramework.RP2_ARDUINO],
+)
+def test_other_platforms_return_false(
+    set_core_config: SetCoreConfigCallable, platform_framework: PlatformFramework
+) -> None:
+    _set_config(set_core_config, platform_framework, {"mdns": {CONF_DISABLED: False}})
+
+    assert mdns.request_service_enable_disable() is False
+    assert DEFINE not in _defines()
+
+
+@pytest.mark.parametrize(
+    "config",
+    [
+        pytest.param({}, id="no_mdns"),
+        pytest.param({"mdns": {CONF_DISABLED: True}}, id="mdns_disabled"),
+        pytest.param(
+            {"mdns": {CONF_DISABLED: False}, "openthread": {}}, id="openthread"
+        ),
+    ],
+)
+def test_esp32_returns_false_when_services_cannot_be_toggled(
+    set_core_config: SetCoreConfigCallable, config: dict
+) -> None:
+    _set_config(set_core_config, PlatformFramework.ESP32_IDF, config)
+
+    assert mdns.request_service_enable_disable() is False
+    assert DEFINE not in _defines()
diff --git a/tests/component_tests/modbus/test_modbus.py b/tests/component_tests/modbus/test_modbus.py
index 0e53c55b50b..1eafb131664 100644
--- a/tests/component_tests/modbus/test_modbus.py
+++ b/tests/component_tests/modbus/test_modbus.py
@@ -33,7 +33,6 @@ def test_server_schema_rejects_address_zero() -> None:
 
 
 def test_client_schema_still_accepts_address_zero() -> None:
-    # Not rejected for clients today, but not supported either: a client broadcast gets no reply and
-    # stalls the hub for the full send-wait.
+    # A client may address 0: writes are broadcast, and reads are allowed with allow_broadcast_read.
     schema = modbus.modbus_device_schema(0x01)
     assert schema({CONF_MODBUS_ID: "hub", CONF_ADDRESS: 0})[CONF_ADDRESS] == 0
diff --git a/tests/component_tests/modbus_client/test_modbus_client.py b/tests/component_tests/modbus_client/test_modbus_client.py
index cab944d825e..fcccae144e0 100644
--- a/tests/component_tests/modbus_client/test_modbus_client.py
+++ b/tests/component_tests/modbus_client/test_modbus_client.py
@@ -7,7 +7,7 @@ guard is a safety property: these tests pin it to every handler slot.
 import pytest
 
 from esphome import config_validation as cv
-from esphome.components import modbus_client
+from esphome.components import modbus, modbus_client
 from esphome.components.modbus_client import (
     CONF_ON_NO_RESPONSE,
     CONF_ON_NOT_SENT,
@@ -126,7 +126,7 @@ def test_on_no_response_retry_lambda_accepted() -> None:
 
 def test_continuous_on_write_pdu_rejected() -> None:
     """A literal write-code PDU with continuous: true is rejected at config time (reads only)."""
-    with pytest.raises(cv.Invalid, match="does not apply to a write PDU"):
+    with pytest.raises(cv.Invalid, match="does not apply to function code"):
         MODBUS_CLIENT_SEND_SCHEMA(
             {
                 CONF_ADDRESS: 0x01,
@@ -185,3 +185,145 @@ def test_multi_conf_no_default_is_set() -> None:
     """
     assert modbus_client.MULTI_CONF is True
     assert modbus_client.MULTI_CONF_NO_DEFAULT is True
+
+
+@pytest.mark.parametrize("key", [CONF_CONTINUOUS, modbus.CONF_ALLOW_BROADCAST_READ])
+def test_send_rejects_read_option_on_static_write_pdu(key: str) -> None:
+    # A read option set true on a static write PDU is refused at validation, naming the key.
+    config = {
+        CONF_ADDRESS: 1,
+        CONF_PDU: [0x06, 0x00, 0x10, 0x00, 0x01],
+        key: True,
+    }
+    with pytest.raises(
+        cv.Invalid, match=f"'{key}: true' does not apply to function code"
+    ):
+        MODBUS_CLIENT_SEND_SCHEMA(config)
+
+
+def test_send_accepts_allow_broadcast_read_on_read_pdu() -> None:
+    # allow_broadcast_read defaults to False and is accepted on a read PDU to address 0.
+    config = MODBUS_CLIENT_SEND_SCHEMA(
+        {CONF_ADDRESS: 0, CONF_PDU: [0x03, 0x00, 0x10, 0x00, 0x02]}
+    )
+    assert config[modbus.CONF_ALLOW_BROADCAST_READ] is False
+    config = MODBUS_CLIENT_SEND_SCHEMA(
+        {
+            CONF_ADDRESS: 0,
+            CONF_PDU: [0x03, 0x00, 0x10, 0x00, 0x02],
+            modbus.CONF_ALLOW_BROADCAST_READ: True,
+        }
+    )
+    assert config[modbus.CONF_ALLOW_BROADCAST_READ] is True
+
+
+def test_send_rejects_write_option_on_static_read_pdu() -> None:
+    # The write-side option is refused on a static read PDU, the mirror of the read-option check.
+    key = modbus.CONF_EXPECT_BROADCAST_WRITE_RESPONSE
+    with pytest.raises(
+        cv.Invalid, match=f"'{key}: true' does not apply to function code"
+    ):
+        MODBUS_CLIENT_SEND_SCHEMA(
+            {CONF_ADDRESS: 0, CONF_PDU: [0x03, 0x00, 0x10, 0x00, 0x02], key: True}
+        )
+
+
+def test_send_accepts_write_option_on_static_write_pdu() -> None:
+    config = MODBUS_CLIENT_SEND_SCHEMA(
+        {
+            CONF_ADDRESS: 0,
+            CONF_PDU: [0x06, 0x00, 0x10, 0x00, 0x01],
+            modbus.CONF_EXPECT_BROADCAST_WRITE_RESPONSE: True,
+        }
+    )
+    assert config[modbus.CONF_EXPECT_BROADCAST_WRITE_RESPONSE] is True
+
+
+def test_write_actions_offer_write_option_only() -> None:
+    # Every write action takes expect_broadcast_write_response and none of the read options.
+    from esphome.components.modbus_client import (
+        _WRITE_MULTIPLE_COILS_SCHEMA,
+        _WRITE_MULTIPLE_REGISTERS_SCHEMA,
+        _WRITE_SINGLE_COIL_SCHEMA,
+        _WRITE_SINGLE_REGISTER_SCHEMA,
+        CONF_START_ADDRESS,
+        CONF_VALUE,
+        CONF_VALUES,
+    )
+
+    write_key = modbus.CONF_EXPECT_BROADCAST_WRITE_RESPONSE
+    base = {CONF_ADDRESS: 0, CONF_START_ADDRESS: 0x10, write_key: True}
+    for schema, extra in (
+        (_WRITE_SINGLE_REGISTER_SCHEMA, {CONF_VALUE: 1}),
+        (_WRITE_SINGLE_COIL_SCHEMA, {CONF_VALUE: True}),
+        (_WRITE_MULTIPLE_REGISTERS_SCHEMA, {CONF_VALUES: [1, 2]}),
+        (_WRITE_MULTIPLE_COILS_SCHEMA, {CONF_VALUES: [True, False]}),
+    ):
+        config = schema({**base, **extra})
+        assert config[write_key] is True
+        assert modbus.CONF_ALLOW_BROADCAST_READ not in config
+        with pytest.raises(cv.Invalid):
+            schema({**base, **extra, modbus.CONF_ALLOW_BROADCAST_READ: True})
+
+
+def test_send_options_follow_the_hub_classification() -> None:
+    # A vendor code is broadcastable, so it takes the write-side flag and refuses the read-side one;
+    # 0x17 is a read for broadcast purposes, so the reverse holds.
+    write_key = modbus.CONF_EXPECT_BROADCAST_WRITE_RESPONSE
+    read_key = modbus.CONF_ALLOW_BROADCAST_READ
+    assert MODBUS_CLIENT_SEND_SCHEMA(
+        {CONF_ADDRESS: 0, CONF_PDU: [0x41, 0x01], write_key: True}
+    )[write_key]
+    with pytest.raises(cv.Invalid, match=f"'{read_key}: true' does not apply"):
+        MODBUS_CLIENT_SEND_SCHEMA(
+            {CONF_ADDRESS: 0, CONF_PDU: [0x41, 0x01], read_key: True}
+        )
+    pdu_0x17 = [0x17, 0x00, 0x10, 0x00, 0x01, 0x00, 0x20, 0x00, 0x01, 0x02, 0x00, 0x01]
+    assert MODBUS_CLIENT_SEND_SCHEMA(
+        {CONF_ADDRESS: 0, CONF_PDU: pdu_0x17, read_key: True}
+    )[read_key]
+    with pytest.raises(cv.Invalid, match=f"'{write_key}: true' does not apply"):
+        MODBUS_CLIENT_SEND_SCHEMA(
+            {CONF_ADDRESS: 0, CONF_PDU: pdu_0x17, write_key: True}
+        )
+
+
+def test_read_write_multiple_offers_allow_broadcast_read_only() -> None:
+    from esphome.components.modbus_client import (
+        _READ_WRITE_MULTIPLE_REGISTERS_SCHEMA,
+        CONF_READ_ADDRESS,
+        CONF_VALUES,
+        CONF_WRITE_ADDRESS,
+    )
+
+    config = _READ_WRITE_MULTIPLE_REGISTERS_SCHEMA(
+        {
+            CONF_ADDRESS: 0,
+            CONF_READ_ADDRESS: 0x10,
+            CONF_WRITE_ADDRESS: 0x20,
+            CONF_VALUES: [1],
+            modbus.CONF_ALLOW_BROADCAST_READ: True,
+        }
+    )
+    assert config[modbus.CONF_ALLOW_BROADCAST_READ] is True
+    assert CONF_CONTINUOUS not in config
+    assert modbus.CONF_EXPECT_BROADCAST_WRITE_RESPONSE not in config
+
+
+@pytest.mark.parametrize(
+    "key",
+    [modbus.CONF_ALLOW_BROADCAST_READ, modbus.CONF_EXPECT_BROADCAST_WRITE_RESPONSE],
+)
+def test_broadcast_options_rejected_on_literal_unicast_address(key: str) -> None:
+    # A broadcast-only option on a literal non-zero address would be silently dropped by the hub.
+    if key == modbus.CONF_ALLOW_BROADCAST_READ:
+        pdu = [0x03, 0x00, 0x10, 0x00, 0x01]
+    else:
+        pdu = [0x06, 0x00, 0x10, 0x00, 0x01]
+    with pytest.raises(cv.Invalid, match="only applies to the broadcast address"):
+        MODBUS_CLIENT_SEND_SCHEMA({CONF_ADDRESS: 1, CONF_PDU: pdu, key: True})
+    # A templated address is not decidable at validation and passes through.
+    config = MODBUS_CLIENT_SEND_SCHEMA(
+        {CONF_ADDRESS: Lambda("return 1;"), CONF_PDU: pdu, key: True}
+    )
+    assert config[key] is True
diff --git a/tests/component_tests/modbus_controller/test_broadcast_address.py b/tests/component_tests/modbus_controller/test_broadcast_address.py
new file mode 100644
index 00000000000..01bdacbf863
--- /dev/null
+++ b/tests/component_tests/modbus_controller/test_broadcast_address.py
@@ -0,0 +1,79 @@
+"""A modbus_controller cannot poll the broadcast address (0) unless allow_broadcast_read says the
+device answers it."""
+
+import pytest
+
+from esphome import config_validation as cv
+from esphome.components import modbus
+from esphome.components.modbus_controller import CONFIG_SCHEMA
+from esphome.const import CONF_ADDRESS
+from esphome.types import ConfigType
+
+
+def _controller(address: int, **extra: object) -> ConfigType:
+    return CONFIG_SCHEMA({modbus.CONF_MODBUS_ID: "bus", CONF_ADDRESS: address, **extra})
+
+
+def test_address_zero_rejected_by_default() -> None:
+    with pytest.raises(cv.Invalid, match="broadcast address"):
+        _controller(0)
+
+
+def test_address_zero_accepted_with_allow_broadcast_read() -> None:
+    config = _controller(0, **{modbus.CONF_ALLOW_BROADCAST_READ: True})
+    assert config[CONF_ADDRESS] == 0
+    assert config[modbus.CONF_ALLOW_BROADCAST_READ] is True
+
+
+def test_allow_broadcast_read_defaults_false() -> None:
+    assert _controller(1)[modbus.CONF_ALLOW_BROADCAST_READ] is False
+
+
+def test_writer_entity_takes_expect_broadcast_write_response() -> None:
+    # The write-side option lives on the writing platforms, not the controller.
+    from esphome.components.modbus_controller.const import CONF_MODBUS_CONTROLLER_ID
+    from esphome.components.modbus_controller.switch import (
+        CONFIG_SCHEMA as SWITCH_SCHEMA,
+    )
+    from esphome.const import CONF_NAME
+
+    key = modbus.CONF_EXPECT_BROADCAST_WRITE_RESPONSE
+    base = {
+        CONF_MODBUS_CONTROLLER_ID: "ctl",
+        CONF_NAME: "Switch",
+        "register_type": "coil",
+        CONF_ADDRESS: 0x20,
+    }
+    assert SWITCH_SCHEMA(base)[key] is False
+    assert SWITCH_SCHEMA({**base, CONF_NAME: "Switch 2", key: True})[key] is True
+    with pytest.raises(cv.Invalid):
+        CONFIG_SCHEMA({modbus.CONF_MODBUS_ID: "bus", CONF_ADDRESS: 1, key: True})
+
+
+def test_allow_broadcast_read_requires_address_zero() -> None:
+    # The option only means something at address 0; elsewhere it would be silently inert.
+    with pytest.raises(cv.Invalid, match="only applies to the broadcast address"):
+        _controller(5, **{modbus.CONF_ALLOW_BROADCAST_READ: True})
+
+
+def test_add_command_options_skips_defaults() -> None:
+    # The setter is only emitted when an option differs from its C++ default.
+    import esphome.codegen as cg
+    from esphome.const import CONF_CONTINUOUS
+
+    var = cg.MockObj("ctl")
+    emitted: list = []
+    original = cg.add
+    cg.add = emitted.append
+    try:
+        modbus.add_command_options(
+            var, "set_read_options", {CONF_CONTINUOUS: False}, direction="read"
+        )
+        assert emitted == []
+        modbus.add_command_options(
+            var, "set_read_options", {CONF_CONTINUOUS: True}, direction="read"
+        )
+        assert len(emitted) == 1
+        assert "set_read_options" in str(emitted[0])
+    finally:
+        cg.add = original
diff --git a/tests/component_tests/modbus_controller/test_custom_pdu.py b/tests/component_tests/modbus_controller/test_custom_pdu.py
index a3a18da07f4..592f6c12bad 100644
--- a/tests/component_tests/modbus_controller/test_custom_pdu.py
+++ b/tests/component_tests/modbus_controller/test_custom_pdu.py
@@ -9,6 +9,7 @@ test cannot: a write-coded custom_pdu polled continuously is rejected there.
 import pytest
 from voluptuous import Invalid, MultipleInvalid
 
+from esphome.components import modbus
 from esphome.components.modbus_controller import (
     ModbusItemBaseSchema,
     validate_custom_pdu_item,
@@ -55,14 +56,21 @@ def test_custom_pdu_rejects_non_byte_values() -> None:
         ModbusItemBaseSchema({CONF_CUSTOM_PDU: [0x0103, 0x002A]})
 
 
-def _controller_full_config(*, continuous: bool) -> Config:
+def _controller_full_config(
+    *, continuous: bool, allow_broadcast_read: bool = False
+) -> Config:
     """A minimal full-config graph with one modbus_controller declaring id 'ctl', enough for the
-    final-validate to resolve the controller (and its continuous flag) from an item's
+    final-validate to resolve the controller (and its option flags) from an item's
     modbus_controller_id."""
     ctl_id = ID("ctl", is_declaration=True)
     config = Config()
     config["modbus_controller"] = [
-        {CONF_ID: ctl_id, CONF_ADDRESS: 1, CONF_CONTINUOUS: continuous}
+        {
+            CONF_ID: ctl_id,
+            CONF_ADDRESS: 0 if allow_broadcast_read else 1,
+            CONF_CONTINUOUS: continuous,
+            modbus.CONF_ALLOW_BROADCAST_READ: allow_broadcast_read,
+        }
     ]
     config.declare_ids.append((ctl_id, ["modbus_controller", 0, CONF_ID]))
     return config
@@ -98,3 +106,64 @@ def test_continuous_read_custom_pdu_allowed(reset_full_config) -> None:
             CONF_CUSTOM_PDU: [0x03, 0x00, 0x2A, 0x00, 0x01],
         }
     )
+
+
+def test_broadcastable_custom_pdu_rejected_under_broadcast_controller(
+    reset_full_config,
+) -> None:
+    """A vendor-coded custom_pdu under an allow_broadcast_read controller would be a real broadcast,
+    never answered, so it is rejected at final validate."""
+    fv.full_config.set(
+        _controller_full_config(continuous=False, allow_broadcast_read=True)
+    )
+    with pytest.raises(Invalid, match="is a real broadcast at address 0"):
+        validate_custom_pdu_item(
+            {
+                CONF_MODBUS_CONTROLLER_ID: ID("ctl"),
+                CONF_CUSTOM_PDU: [0x41, 0x00, 0x03],
+            }
+        )
+
+
+def test_read_custom_pdu_allowed_under_broadcast_controller(reset_full_config) -> None:
+    """A read-coded custom_pdu (0x03) is answered under allow_broadcast_read, so it is fine."""
+    fv.full_config.set(
+        _controller_full_config(continuous=False, allow_broadcast_read=True)
+    )
+    validate_custom_pdu_item(
+        {
+            CONF_MODBUS_CONTROLLER_ID: ID("ctl"),
+            CONF_CUSTOM_PDU: [0x03, 0x00, 0x2A, 0x00, 0x01],
+        }
+    )
+
+
+def test_write_option_rejected_under_unicast_controller(reset_full_config) -> None:
+    """expect_broadcast_write_response on a writer entity whose controller is not at address 0 is
+    rejected at final validate, where the controller's address is known."""
+    from esphome.components.modbus_controller import validate_writer_item
+
+    fv.full_config.set(_controller_full_config(continuous=False))
+    with pytest.raises(
+        Invalid, match="only applies when the 'ctl' modbus_controller is at address 0"
+    ):
+        validate_writer_item(
+            {
+                CONF_MODBUS_CONTROLLER_ID: ID("ctl"),
+                modbus.CONF_EXPECT_BROADCAST_WRITE_RESPONSE: True,
+            }
+        )
+
+
+def test_write_option_allowed_under_broadcast_controller(reset_full_config) -> None:
+    from esphome.components.modbus_controller import validate_writer_item
+
+    fv.full_config.set(
+        _controller_full_config(continuous=False, allow_broadcast_read=True)
+    )
+    validate_writer_item(
+        {
+            CONF_MODBUS_CONTROLLER_ID: ID("ctl"),
+            modbus.CONF_EXPECT_BROADCAST_WRITE_RESPONSE: True,
+        }
+    )
diff --git a/tests/component_tests/ota/test_esphome_ota.py b/tests/component_tests/ota/test_esphome_ota.py
index d3092294dc1..235ad902dbc 100644
--- a/tests/component_tests/ota/test_esphome_ota.py
+++ b/tests/component_tests/ota/test_esphome_ota.py
@@ -319,6 +319,32 @@ def test_encryption_with_captive_portal_does_not_warn(
         fv.full_config.reset(token)
 
 
+@pytest.mark.parametrize("extra", [{}, {"prometheus": {}}])
+def test_encryption_with_web_server_ota_disabled_does_not_warn(
+    caplog: pytest.LogCaptureFixture, extra: dict[str, Any]
+) -> None:
+    """web_server `ota: false` only serves /update while the captive portal is
+    active, on every listener, so there is no plaintext endpoint to warn about."""
+    full_conf = {
+        "web_server": {CONF_OTA: False},
+        **extra,
+        CONF_OTA: [
+            _make_ota_config(port=3232, **{CONF_ENCRYPTION: {CONF_KEY: OTHER_KEY}}),
+            {CONF_PLATFORM: "web_server", CONF_ID: ID("ota_ws", is_manual=False)},
+        ],
+    }
+    token = fv.full_config.set(full_conf)
+    try:
+        with caplog.at_level(logging.WARNING):
+            ota_esphome_final_validate({})
+        assert not any(
+            "OTA encryption does not cover" in record.message
+            for record in caplog.records
+        )
+    finally:
+        fv.full_config.reset(token)
+
+
 def test_password_with_api_key_warns(caplog: pytest.LogCaptureFixture) -> None:
     """A static api key makes the device offer encryption and the CLI take
     it, so the password is dead weight; the config validates with a warning."""
diff --git a/tests/component_tests/remote_receiver/config/receiver_bk72xx.yaml b/tests/component_tests/remote_receiver/config/receiver_bk72xx.yaml
new file mode 100644
index 00000000000..c9c95ed05c3
--- /dev/null
+++ b/tests/component_tests/remote_receiver/config/receiver_bk72xx.yaml
@@ -0,0 +1,9 @@
+esphome:
+  name: test
+
+bk72xx:
+  board: generic-bk7252
+
+remote_receiver:
+  - id: rcvr
+    pin: P6
diff --git a/tests/component_tests/remote_receiver/config/receiver_esp32_c61.yaml b/tests/component_tests/remote_receiver/config/receiver_esp32_c61.yaml
new file mode 100644
index 00000000000..e8930d4e17e
--- /dev/null
+++ b/tests/component_tests/remote_receiver/config/receiver_esp32_c61.yaml
@@ -0,0 +1,12 @@
+esphome:
+  name: test
+
+esp32:
+  board: esp32-c61-devkitc1
+  variant: esp32c61
+  framework:
+    type: esp-idf
+
+remote_receiver:
+  - id: rcvr
+    pin: GPIO4
diff --git a/tests/component_tests/remote_receiver/config/receiver_ln882x.yaml b/tests/component_tests/remote_receiver/config/receiver_ln882x.yaml
new file mode 100644
index 00000000000..8767b546e62
--- /dev/null
+++ b/tests/component_tests/remote_receiver/config/receiver_ln882x.yaml
@@ -0,0 +1,9 @@
+esphome:
+  name: test
+
+ln882x:
+  board: generic-ln882h
+
+remote_receiver:
+  - id: rcvr
+    pin: PA4
diff --git a/tests/component_tests/remote_receiver/config/receiver_rp2.yaml b/tests/component_tests/remote_receiver/config/receiver_rp2.yaml
new file mode 100644
index 00000000000..cfc66786ba2
--- /dev/null
+++ b/tests/component_tests/remote_receiver/config/receiver_rp2.yaml
@@ -0,0 +1,9 @@
+esphome:
+  name: test
+
+rp2:
+  board: rpipicow
+
+remote_receiver:
+  - id: rcvr
+    pin: GPIO4
diff --git a/tests/component_tests/remote_receiver/config/receiver_rtl87xx.yaml b/tests/component_tests/remote_receiver/config/receiver_rtl87xx.yaml
new file mode 100644
index 00000000000..113bece34c5
--- /dev/null
+++ b/tests/component_tests/remote_receiver/config/receiver_rtl87xx.yaml
@@ -0,0 +1,9 @@
+esphome:
+  name: test
+
+rtl87xx:
+  board: generic-rtl8710bn-2mb-788k
+
+remote_receiver:
+  - id: rcvr
+    pin: PA12
diff --git a/tests/component_tests/remote_receiver/config/receiver_with_external_protocol.yaml b/tests/component_tests/remote_receiver/config/receiver_with_external_protocol.yaml
new file mode 100644
index 00000000000..e094e5bd52e
--- /dev/null
+++ b/tests/component_tests/remote_receiver/config/receiver_with_external_protocol.yaml
@@ -0,0 +1,36 @@
+esphome:
+  name: test
+
+esp32:
+  board: esp32dev
+
+logger:
+
+external_components:
+  - source:
+      type: local
+      path: ../external_components
+
+fake_protocol:
+
+remote_receiver:
+  - id: rcvr
+    pin: GPIO4
+    dump:
+      - fake
+      - nec
+    on_fake:
+      then:
+        - remote_transmitter.transmit_fake:
+    on_nec:
+      then:
+        - logger.log: nec
+
+remote_transmitter:
+  pin: GPIO5
+  carrier_duty_percent: 50%
+
+binary_sensor:
+  - platform: remote_receiver
+    name: Fake Input
+    fake:
diff --git a/tests/component_tests/remote_receiver/external_components/fake_protocol/__init__.py b/tests/component_tests/remote_receiver/external_components/fake_protocol/__init__.py
new file mode 100644
index 00000000000..971497aa794
--- /dev/null
+++ b/tests/component_tests/remote_receiver/external_components/fake_protocol/__init__.py
@@ -0,0 +1,39 @@
+"""External component registering a protocol that has no source file in remote_base."""
+
+import esphome.codegen as cg
+from esphome.components import remote_base
+import esphome.config_validation as cv
+from esphome.types import ConfigType
+
+DEPENDENCIES = ["remote_base"]
+
+ns = cg.esphome_ns.namespace("fake_protocol")
+FakeData = ns.struct("FakeData")
+FakeBinarySensor = ns.class_(
+    "FakeBinarySensor", remote_base.RemoteReceiverBinarySensorBase
+)
+FakeTrigger = ns.class_("FakeTrigger", remote_base.RemoteReceiverTrigger)
+FakeAction = ns.class_("FakeAction", remote_base.RemoteTransmitterActionBase)
+FakeDumper = ns.class_("FakeDumper", remote_base.RemoteReceiverDumperBase)
+
+CONFIG_SCHEMA = cv.Schema({})
+
+
+@remote_base.register_binary_sensor("fake", FakeBinarySensor, {})
+def fake_binary_sensor(var: cg.MockObj, config: ConfigType) -> None:
+    pass
+
+
+@remote_base.register_trigger("fake", FakeTrigger, FakeData)
+def fake_trigger(var: cg.MockObj, config: ConfigType) -> None:
+    pass
+
+
+@remote_base.register_dumper("fake", FakeDumper)
+def fake_dumper(var: cg.MockObj, config: ConfigType) -> None:
+    pass
+
+
+@remote_base.register_action("fake", FakeAction, {})
+async def fake_action(var: cg.MockObj, config: ConfigType, args: list) -> None:
+    pass
diff --git a/tests/component_tests/remote_receiver/test_buffer_size.py b/tests/component_tests/remote_receiver/test_buffer_size.py
index 9bfd12d9f55..cc4ea49ccb8 100644
--- a/tests/component_tests/remote_receiver/test_buffer_size.py
+++ b/tests/component_tests/remote_receiver/test_buffer_size.py
@@ -1,8 +1,16 @@
-"""buffer_size reaches the receiver when set, and always on the pulse ring targets."""
+"""buffer_size is bytes on the pulse ring targets and only reaches RMT targets when set."""
 
 from collections.abc import Callable
 from pathlib import Path
 
+import pytest
+
+from esphome.components import remote_receiver
+from esphome.components.esp8266 import gpio as esp8266_gpio  # noqa: F401  registers the pin schema
+from esphome.config_validation import Invalid
+from esphome.const import PlatformFramework
+from tests.component_tests.types import SetCoreConfigCallable
+
 
 def test_explicit_buffer_size_is_passed_through(
     generate_main: Callable[[str | Path], str],
@@ -12,17 +20,29 @@ def test_explicit_buffer_size_is_passed_through(
     assert "rcvr->set_buffer_size(2000);" in main_cpp
 
 
-def test_pulse_ring_target_keeps_a_default(
+@pytest.mark.parametrize(
+    "target", ["esp8266", "rp2", "bk72xx", "rtl87xx", "ln882x", "esp32_c2", "esp32_c61"]
+)
+def test_pulse_ring_default_holds_1000_pulses(
     generate_main: Callable[[str | Path], str],
     component_config_path: Callable[[str], Path],
+    target: str,
 ) -> None:
-    main_cpp = generate_main(component_config_path("receiver_esp8266.yaml"))
-    assert "rcvr->set_buffer_size(1000);" in main_cpp
+    main_cpp = generate_main(component_config_path(f"receiver_{target}.yaml"))
+    assert "rcvr->set_buffer_size(4000);" in main_cpp
 
 
-def test_esp32_variant_without_rmt_keeps_a_default(
-    generate_main: Callable[[str | Path], str],
-    component_config_path: Callable[[str], Path],
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    [("32b", None), ("64b", 64), ("65b", 65), ("65535b", 65535), ("65536b", None)],
+)
+def test_buffer_size_range(
+    set_core_config: SetCoreConfigCallable, value: str, expected: int | None
 ) -> None:
-    main_cpp = generate_main(component_config_path("receiver_esp32_c2.yaml"))
-    assert "rcvr->set_buffer_size(1000);" in main_cpp
+    set_core_config(PlatformFramework.ESP8266_ARDUINO)
+    config = {"pin": "GPIO4", "buffer_size": value}
+    if expected is None:
+        with pytest.raises(Invalid):
+            remote_receiver.CONFIG_SCHEMA(config)
+    else:
+        assert remote_receiver.CONFIG_SCHEMA(config)["buffer_size"] == expected
diff --git a/tests/component_tests/remote_receiver/test_slot_counts.py b/tests/component_tests/remote_receiver/test_slot_counts.py
index 4d69e6d923b..ee79e9a06d5 100644
--- a/tests/component_tests/remote_receiver/test_slot_counts.py
+++ b/tests/component_tests/remote_receiver/test_slot_counts.py
@@ -1,13 +1,16 @@
 """Listener and dumper StaticVector sizes come from codegen slot counts."""
 
-from collections.abc import Callable
+from collections.abc import Callable, Generator
 from pathlib import Path
+import sys
 
 import pytest
 
+from esphome import loader
 from esphome.automation import ACTION_REGISTRY
 from esphome.components import remote_base
 import esphome.config_validation as cv
+from esphome.core import CORE
 
 from ..helpers import get_define_value
 
@@ -74,6 +77,47 @@ def test_every_registry_name_maps_to_a_protocol_source() -> None:
         assert remote_base._protocol_stem(name) in remote_base._PROTOCOL_STEMS, name
 
 
+@pytest.fixture
+def restore_protocol_registries() -> Generator[None]:
+    """Loading an external protocol component adds to module-level registries; undo that.
+
+    The loader caches the component too, so drop it or a second load would skip the
+    decorators and leave the restored registries without the external names.
+    """
+    registries = (
+        remote_base.BINARY_SENSOR_REGISTRY,
+        remote_base.TRIGGER_REGISTRY,
+        remote_base.DUMPER_REGISTRY,
+        ACTION_REGISTRY,
+    )
+    saved = [dict(registry) for registry in registries]
+    yield
+    for registry, entries in zip(registries, saved, strict=True):
+        registry.clear()
+        registry.update(entries)
+    loader._COMPONENT_CACHE.pop("fake_protocol", None)
+    sys.modules.pop("esphome.components.fake_protocol", None)
+
+
+@pytest.mark.usefixtures("restore_protocol_registries")
+def test_external_protocols_register_without_a_remote_base_source(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+) -> None:
+    """An external protocol goes through all four decorators without a source file here, so no define is emitted."""
+    main_cpp = generate_main(
+        component_config_path("receiver_with_external_protocol.yaml")
+    )
+    defines = {define.name for define in CORE.defines}
+    assert "USE_REMOTE_PROTOCOL_NEC" in defines
+    assert "USE_REMOTE_PROTOCOL_FAKE" not in defines
+    for cls in ("FakeBinarySensor", "FakeTrigger", "FakeDumper", "FakeAction"):
+        assert f"fake_protocol::{cls}" in main_cpp, cls
+    # fake and nec dumpers; on_fake and on_nec triggers plus the fake binary sensor
+    assert get_define_value("REMOTE_BASE_DUMPER_COUNT") == "2"
+    assert get_define_value("REMOTE_BASE_LISTENER_COUNT") == "3"
+
+
 def test_request_protocol_rejects_unknown_names() -> None:
     """A misspelled protocol would otherwise surface only as a link error."""
     with pytest.raises(ValueError, match="Unknown remote protocol 'toshiba'"):
diff --git a/tests/component_tests/template/config/switch_defaults.yaml b/tests/component_tests/template/config/switch_defaults.yaml
new file mode 100644
index 00000000000..4387fe07a5b
--- /dev/null
+++ b/tests/component_tests/template/config/switch_defaults.yaml
@@ -0,0 +1,18 @@
+---
+esphome:
+  name: test
+
+esp32:
+  board: esp32dev
+
+logger:
+
+switch:
+  - platform: template
+    id: plain_switch
+    turn_on_action:
+      - logger.log: "on"
+  - platform: template
+    id: enabled_switch
+    optimistic: true
+    assumed_state: true
diff --git a/tests/component_tests/template/test_template_switch.py b/tests/component_tests/template/test_template_switch.py
new file mode 100644
index 00000000000..11c6a9cab87
--- /dev/null
+++ b/tests/component_tests/template/test_template_switch.py
@@ -0,0 +1,17 @@
+"""Tests for the template switch codegen."""
+
+from collections.abc import Callable
+from pathlib import Path
+
+
+def test_default_flags_are_not_emitted(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+) -> None:
+    """Only true optimistic and assumed_state are set; false is the C++ initializer."""
+    main_cpp = generate_main(component_config_path("switch_defaults.yaml"))
+
+    assert "plain_switch->set_optimistic(" not in main_cpp
+    assert "plain_switch->set_assumed_state(" not in main_cpp
+    assert "enabled_switch->set_optimistic(true);" in main_cpp
+    assert "enabled_switch->set_assumed_state(true);" in main_cpp
diff --git a/tests/component_tests/uart_mux/__init__.py b/tests/component_tests/uart_mux/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/component_tests/uart_mux/test_init.py b/tests/component_tests/uart_mux/test_init.py
new file mode 100644
index 00000000000..2221ec56694
--- /dev/null
+++ b/tests/component_tests/uart_mux/test_init.py
@@ -0,0 +1,42 @@
+"""Tests for the uart_mux component's final validation."""
+
+import pytest
+
+from esphome import config_validation as cv
+from esphome.const import CONF_ID, PlatformFramework
+from esphome.core import ID
+from esphome.types import ConfigType
+from tests.component_tests.types import SetCoreConfigCallable
+
+CONF_BRIDGE_ID = "bridge_id"
+
+
+def _set_esp32_s3(set_core_config: SetCoreConfigCallable) -> None:
+    from esphome.components.esp32 import KEY_VARIANT, VARIANT_ESP32S3
+
+    set_core_config(
+        PlatformFramework.ESP32_IDF, platform_data={KEY_VARIANT: VARIANT_ESP32S3}
+    )
+
+
+def _mux_conf(mux_id: str, bridge_id: str) -> ConfigType:
+    return {CONF_ID: ID(mux_id), CONF_BRIDGE_ID: ID(bridge_id)}
+
+
+def test_accepts_one_mux_per_bridge(set_core_config: SetCoreConfigCallable) -> None:
+    _set_esp32_s3(set_core_config)
+    from esphome.components import uart_mux
+
+    uart_mux._final_validate(_mux_conf("mux_0", "bridge_0"))
+    uart_mux._final_validate(_mux_conf("mux_1", "bridge_1"))
+
+
+def test_rejects_two_muxes_on_one_bridge(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    _set_esp32_s3(set_core_config)
+    from esphome.components import uart_mux
+
+    uart_mux._final_validate(_mux_conf("mux_0", "bridge_0"))
+    with pytest.raises(cv.Invalid, match="already routed by another 'uart_mux'"):
+        uart_mux._final_validate(_mux_conf("mux_1", "bridge_0"))
diff --git a/tests/component_tests/wifi/test_power_save_off.py b/tests/component_tests/wifi/test_power_save_off.py
new file mode 100644
index 00000000000..2b4200968a7
--- /dev/null
+++ b/tests/component_tests/wifi/test_power_save_off.py
@@ -0,0 +1,46 @@
+"""Tests for wifi.force_power_save_off(), the hook platforms use to keep the
+station out of power save."""
+
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+
+from esphome.components import wifi
+from esphome.core import CORE, EsphomeError
+
+
+def test_reasons_accumulate_without_duplicates() -> None:
+    """Every caller's reason is kept once; a repeated reason is not duplicated."""
+    wifi.force_power_save_off("first")
+    wifi.force_power_save_off("first")
+    wifi.force_power_save_off("second")
+
+    assert CORE.data[wifi.POWER_SAVE_OFF_REASONS_KEY] == ["first", "second"]
+
+
+def test_forced_off_skips_the_setter_and_warns(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """With a reason recorded, power_save_mode is reported and not applied."""
+    wifi.force_power_save_off("the platform cannot sleep")
+
+    main_cpp = generate_main(component_config_path("custom.yaml"))
+
+    assert "set_power_save_mode(" not in main_cpp
+    assert (
+        "power_save_mode LIGHT is not applied: the platform cannot sleep" in caplog.text
+    )
+
+
+def test_call_after_wifi_codegen_raises(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+) -> None:
+    """Once wifi has generated its code the hook cannot take effect any more."""
+    generate_main(component_config_path("custom.yaml"))
+
+    with pytest.raises(EsphomeError, match="before wifi generates its code"):
+        wifi.force_power_save_off("too late")
diff --git a/tests/components/bk72xx_ble/validate-power-save.bk72xx-ard.yaml b/tests/components/bk72xx_ble/validate-power-save.bk72xx-ard.yaml
new file mode 100644
index 00000000000..20b69b6c64b
--- /dev/null
+++ b/tests/components/bk72xx_ble/validate-power-save.bk72xx-ard.yaml
@@ -0,0 +1,9 @@
+# A wifi power_save_mode other than NONE is forced off with a warning while
+# bk72xx_ble is configured (esphome#18592); this config must still validate.
+packages:
+  bk72xx_ble: !include common.yaml
+
+wifi:
+  ssid: MySSID
+  password: password1
+  power_save_mode: high
diff --git a/tests/components/esp32/test.esp32-idf.yaml b/tests/components/esp32/test.esp32-idf.yaml
index 7f31fe59c6f..5c7cb1d61b8 100644
--- a/tests/components/esp32/test.esp32-idf.yaml
+++ b/tests/components/esp32/test.esp32-idf.yaml
@@ -22,6 +22,7 @@ esp32:
       disable_regi2c_in_iram: true
       disable_fatfs: true
       sram1_as_iram: true
+      flash_chip: gd
   watchdog_timeout: 7s
 
 wifi:
diff --git a/tests/components/esp32/test.esp32-s3-idf.yaml b/tests/components/esp32/test.esp32-s3-idf.yaml
index b9a3b804a8d..5bdf94e8e1d 100644
--- a/tests/components/esp32/test.esp32-s3-idf.yaml
+++ b/tests/components/esp32/test.esp32-s3-idf.yaml
@@ -9,6 +9,7 @@ esp32:
     type: esp-idf
     advanced:
       execute_from_psram: true
+      flash_chip: gd
       disable_libc_locks_in_iram: true  # Test default RAM optimization enabled
       disable_debug_stubs: true
       disable_ocd_aware: true
diff --git a/tests/components/icnt86/common.yaml b/tests/components/icnt86/common.yaml
new file mode 100644
index 00000000000..1537bb8b762
--- /dev/null
+++ b/tests/components/icnt86/common.yaml
@@ -0,0 +1,24 @@
+touchscreen:
+  - platform: icnt86
+    i2c_id: i2c_bus
+    interrupt_pin: ${interrupt_pin_touch}
+    reset_pin: ${reset_pin_touch}
+    display: epaper
+    on_touch:
+      - logger.log:
+          format: Touch at (%d, %d)
+          args: [touch.x, touch.y]
+
+display:
+  - platform: waveshare_epaper
+    id: epaper
+    rotation: 90
+    cs_pin: ${cs_pin_display}
+    dc_pin: ${dc_pin_display}
+    busy_pin: ${busy_pin_display}
+    reset_pin: ${reset_pin_display}
+    model: 2.90inv2-r2
+    pages:
+      - id: icnt86_page
+        lambda: |-
+          it.rectangle(0, 0, it.get_width(), it.get_height());
diff --git a/tests/components/icnt86/test.esp32-idf.yaml b/tests/components/icnt86/test.esp32-idf.yaml
new file mode 100644
index 00000000000..a0b882292a5
--- /dev/null
+++ b/tests/components/icnt86/test.esp32-idf.yaml
@@ -0,0 +1,14 @@
+substitutions:
+  interrupt_pin_touch: GPIO4
+  reset_pin_touch: GPIO32
+  cs_pin_display: GPIO33
+  dc_pin_display: GPIO21
+  busy_pin_display: GPIO27
+  reset_pin_display: GPIO14
+  clk_pin: GPIO25
+  mosi_pin: GPIO26
+
+packages:
+  i2c: !include ../../test_build_components/common/i2c/esp32-idf.yaml
+  spi: !include ../../test_build_components/common/spi/esp32-idf.yaml
+  icnt86: !include common.yaml
diff --git a/tests/components/improv_base/rpc_response_builder_test.cpp b/tests/components/improv_base/rpc_response_builder_test.cpp
index d9d0ad90d88..f7f0eda38c4 100644
--- a/tests/components/improv_base/rpc_response_builder_test.cpp
+++ b/tests/components/improv_base/rpc_response_builder_test.cpp
@@ -52,7 +52,7 @@ TEST(RpcResponseBuilder, GoldenBytes) {
             (std::vector<uint8_t>{0x04, 0x03, 0x02, 'a', 'b', 0xCC}));
 }
 
-// esp32_improv calls finish() and build_rpc_response() with no checksum flag,
+// improv_ble calls finish() and build_rpc_response() with no checksum flag,
 // so the two defaults must agree
 TEST(RpcResponseBuilder, DefaultChecksumFlagMatches) {
   const std::vector<std::string> urls = {"https://example.com"};
diff --git a/tests/components/esp32_improv/common.yaml b/tests/components/improv_ble/common.yaml
similarity index 96%
rename from tests/components/esp32_improv/common.yaml
rename to tests/components/improv_ble/common.yaml
index 7dc2f7b6c73..7605cd6e657 100644
--- a/tests/components/esp32_improv/common.yaml
+++ b/tests/components/improv_ble/common.yaml
@@ -12,7 +12,7 @@ output:
     pin: 2
     id: built_in_led
 
-esp32_improv:
+improv_ble:
   authorizer: io0_button
   authorized_duration: 1min
   status_indicator: built_in_led
diff --git a/tests/components/esp32_improv/test.esp32-c3-idf.yaml b/tests/components/improv_ble/test.esp32-c3-idf.yaml
similarity index 100%
rename from tests/components/esp32_improv/test.esp32-c3-idf.yaml
rename to tests/components/improv_ble/test.esp32-c3-idf.yaml
diff --git a/tests/components/esp32_improv/test.esp32-idf.yaml b/tests/components/improv_ble/test.esp32-idf.yaml
similarity index 100%
rename from tests/components/esp32_improv/test.esp32-idf.yaml
rename to tests/components/improv_ble/test.esp32-idf.yaml
diff --git a/tests/components/improv_serial/common-uart0.yaml b/tests/components/improv_serial/common-uart0.yaml
index 45bf1e5c330..3710cb3bb53 100644
--- a/tests/components/improv_serial/common-uart0.yaml
+++ b/tests/components/improv_serial/common-uart0.yaml
@@ -5,6 +5,6 @@ wifi:
 logger:
   hardware_uart: UART0
 
-# next_url compiles the USE_IMPROV_SERIAL_NEXT_URL branch and add_next_url_
+# next_url compiles the USE_IMPROV_NEXT_URL branch and add_next_url_
 improv_serial:
   next_url: https://example.com/?device_name={{device_name}}&ip_address={{ip_address}}
diff --git a/tests/components/mixer/common.yaml b/tests/components/mixer/common.yaml
index 55e96df4c27..489475c794f 100644
--- a/tests/components/mixer/common.yaml
+++ b/tests/components/mixer/common.yaml
@@ -3,7 +3,7 @@ esphome:
     then:
       - mixer_speaker.apply_ducking:
           id: source_speaker_1_id
-          decibel_reduction: 10
+          decibel_reduction: 255
           duration: 1s
 
 speaker:
diff --git a/tests/components/modbus/modbus_client_hub_test.cpp b/tests/components/modbus/modbus_client_hub_test.cpp
index 18c04f32d5b..3bdfa094e0e 100644
--- a/tests/components/modbus/modbus_client_hub_test.cpp
+++ b/tests/components/modbus/modbus_client_hub_test.cpp
@@ -792,6 +792,261 @@ TEST(ModbusClientHubBroadcast, RefusesReadBroadcast) {
   EXPECT_EQ(device.sent_count_, 0);  // never transmitted
 }
 
+// allow_broadcast_read lifts the refusal for a device that answers address 0: the read is queued, sent,
+// and waits for a reply like a unicast read, so a reply from address 0 completes it with on_response.
+TEST(ModbusClientHubBroadcast, AllowBroadcastReadWaitsAndAcceptsReplyFromZero) {
+  NullUART uart;
+  NoResponseProbeHub hub;
+  hub.set_uart_parent(&uart);
+  hub.setup();
+  BroadcastProbeDevice device(&hub, BROADCAST_ADDRESS);
+
+  const uint8_t read[] = {0x03, 0x00, 0x10, 0x00, 0x02};  // read holding registers 0x0010, count 2
+  ASSERT_TRUE(device.queue_pdu(read, {.allow_broadcast_read = true}));
+  EXPECT_TRUE(hub.queued(0).options.allow_broadcast_read);
+  EXPECT_FALSE(hub.queued(0).fire_and_forget());
+
+  hub.send_next_for_test();
+  EXPECT_EQ(device.sent_count_, 1);
+  EXPECT_TRUE(hub.waiting());  // not fire-and-forget: the reply is expected
+  EXPECT_EQ(hub.entries(), 1u);
+
+  const uint8_t reply[] = {0x03, 0x04, 0x00, 0x01, 0x00, 0x02};
+  hub.receive_frame_for_test(BROADCAST_ADDRESS, reply);
+  EXPECT_EQ(device.response_count_, 1);
+  EXPECT_EQ(device.last_response_size_, sizeof(reply));
+  EXPECT_FALSE(hub.waiting());
+  EXPECT_EQ(hub.entries(), 0u);
+}
+
+// The address-0 read waits like a unicast one, so the reply must come from address 0 too: a reply from
+// another unit id is an unexpected frame and interrupts the transaction as it would for any address.
+TEST(ModbusClientHubBroadcast, AllowBroadcastReadRejectsReplyFromOtherAddress) {
+  NullUART uart;
+  NoResponseProbeHub hub;
+  hub.set_uart_parent(&uart);
+  hub.setup();
+  BroadcastProbeDevice device(&hub, BROADCAST_ADDRESS);
+
+  const uint8_t read[] = {0x03, 0x00, 0x10, 0x00, 0x02};
+  ASSERT_TRUE(device.queue_pdu(read, {.allow_broadcast_read = true}));
+  hub.send_next_for_test();
+  ASSERT_TRUE(hub.waiting());
+
+  const uint8_t reply[] = {0x03, 0x04, 0x00, 0x01, 0x00, 0x02};
+  hub.receive_frame_for_test(0x07, reply);
+  EXPECT_EQ(device.response_count_, 0);
+  EXPECT_EQ(hub.waiting_command().state, FrameState::INTERRUPTED);
+}
+
+// An address-scoped clear must not turn a live address-0 entry back into a fire-and-forget broadcast: a
+// retry granted after the clear is re-sent with the flag intact, so it still waits and gets its terminal.
+TEST(ModbusClientHubBroadcast, AllowBroadcastReadSurvivesClearBeforeRetry) {
+  NullUART uart;
+  NoResponseProbeHub hub;
+  hub.set_uart_parent(&uart);
+  hub.setup();
+  RetryingDevice device(&hub, BROADCAST_ADDRESS, true);
+
+  const uint8_t read[] = {0x03, 0x00, 0x10, 0x00, 0x02};
+  ASSERT_TRUE(device.queue_pdu(read, {.allow_broadcast_read = true}));
+  hub.send_next_for_test();
+  ASSERT_TRUE(hub.waiting());
+
+  hub.clear_tx_queue_for_address(BROADCAST_ADDRESS);
+  EXPECT_EQ(hub.waiting_command().state, FrameState::WAITING_RETIRED);
+  EXPECT_TRUE(hub.waiting_command().options.allow_broadcast_read);
+
+  hub.timeout_waiting();  // retry granted: the entry is READY again
+  ASSERT_EQ(hub.queued_frames(), 1u);
+  EXPECT_FALSE(hub.queued(0).fire_and_forget());
+
+  hub.send_next_for_test();
+  EXPECT_TRUE(hub.waiting());  // the retry still waits for its reply
+  EXPECT_EQ(hub.entries(), 1u);
+}
+
+// The function code check is unchanged by the relaxed address match: a mismatched reply still interrupts.
+TEST(ModbusClientHubBroadcast, AllowBroadcastReadStillRejectsWrongFunctionCode) {
+  NullUART uart;
+  NoResponseProbeHub hub;
+  hub.set_uart_parent(&uart);
+  hub.setup();
+  BroadcastProbeDevice device(&hub, BROADCAST_ADDRESS);
+
+  const uint8_t read[] = {0x03, 0x00, 0x10, 0x00, 0x02};
+  ASSERT_TRUE(device.queue_pdu(read, {.allow_broadcast_read = true}));
+  hub.send_next_for_test();
+  ASSERT_TRUE(hub.waiting());
+
+  const uint8_t wrong_reply[] = {0x04, 0x04, 0x00, 0x01, 0x00, 0x02};
+  hub.receive_frame_for_test(BROADCAST_ADDRESS, wrong_reply);  // right address, wrong function code
+  EXPECT_EQ(device.response_count_, 0);
+  EXPECT_EQ(hub.waiting_command().state, FrameState::INTERRUPTED);
+}
+
+// A silent device leaves the read to the normal send-wait timeout, so on_no_response is delivered.
+TEST(ModbusClientHubBroadcast, AllowBroadcastReadTimesOutLikeUnicast) {
+  NullUART uart;
+  NoResponseProbeHub hub;
+  hub.set_uart_parent(&uart);
+  hub.setup();
+  BroadcastProbeDevice device(&hub, BROADCAST_ADDRESS);
+
+  const uint8_t read[] = {0x03, 0x00, 0x10, 0x00, 0x02};
+  ASSERT_TRUE(device.queue_pdu(read, {.allow_broadcast_read = true}));
+  hub.send_next_for_test();
+  ASSERT_TRUE(hub.waiting());
+
+  hub.timeout_waiting();
+  EXPECT_EQ(device.no_response_count_, 1);
+  EXPECT_EQ(device.response_count_, 0);
+  EXPECT_FALSE(hub.waiting());
+  EXPECT_EQ(hub.entries(), 0u);
+}
+
+// allow_broadcast_read is stripped from a broadcastable code (a write or custom code to address 0 is a real broadcast,
+// still fire-and-forget) and from a unicast frame (nothing to allow).
+TEST(ModbusClientHubBroadcast, AllowBroadcastReadIgnoredForWritesAndUnicast) {
+  NullUART uart;
+  NoResponseProbeHub hub;
+  hub.set_uart_parent(&uart);
+  hub.setup();
+  BroadcastProbeDevice broadcast_device(&hub, BROADCAST_ADDRESS);
+  BroadcastProbeDevice unicast_device(&hub, 0x01);
+
+  const uint8_t write[] = {0x06, 0x00, 0x10, 0x00, 0x01};
+  ASSERT_TRUE(broadcast_device.queue_pdu(write, {.allow_broadcast_read = true}));
+  EXPECT_FALSE(hub.queued(0).options.allow_broadcast_read);
+  EXPECT_TRUE(hub.queued(0).fire_and_forget());
+  hub.send_next_for_test();
+  EXPECT_EQ(broadcast_device.sent_count_, 1);
+  EXPECT_FALSE(hub.waiting());
+  EXPECT_EQ(hub.entries(), 0u);
+
+  const uint8_t custom[] = {0x41, 0x01, 0x02};
+  ASSERT_TRUE(broadcast_device.queue_pdu(custom, {.allow_broadcast_read = true}));
+  EXPECT_FALSE(hub.queued(0).options.allow_broadcast_read);
+  EXPECT_TRUE(hub.queued(0).fire_and_forget());
+  hub.send_next_for_test();
+  EXPECT_FALSE(hub.waiting());
+  EXPECT_EQ(hub.entries(), 0u);
+
+  const uint8_t read[] = {0x03, 0x00, 0x10, 0x00, 0x02};
+  ASSERT_TRUE(unicast_device.queue_pdu(read, {.allow_broadcast_read = true}));
+  EXPECT_FALSE(hub.queued(0).options.allow_broadcast_read);
+  EXPECT_FALSE(hub.queued(0).fire_and_forget());
+}
+
+// expect_broadcast_write_response is the write-side twin: a write to address 0 waits for its reply instead
+// of retiring at transmission, and the reply (from address 0) completes it.
+TEST(ModbusClientHubBroadcast, ExpectBroadcastWriteResponseWaitsAndAcceptsReply) {
+  NullUART uart;
+  NoResponseProbeHub hub;
+  hub.set_uart_parent(&uart);
+  hub.setup();
+  BroadcastProbeDevice device(&hub, BROADCAST_ADDRESS);
+
+  const uint8_t write[] = {0x06, 0x00, 0x10, 0x00, 0x01};
+  ASSERT_TRUE(device.write_single_register(0x0010, 0x0001, {.expect_broadcast_write_response = true}));
+  EXPECT_TRUE(hub.queued(0).options.expect_broadcast_write_response);
+  EXPECT_FALSE(hub.queued(0).fire_and_forget());
+
+  hub.send_next_for_test();
+  EXPECT_EQ(device.sent_count_, 1);
+  EXPECT_TRUE(hub.waiting());
+  EXPECT_EQ(hub.entries(), 1u);
+
+  hub.receive_frame_for_test(BROADCAST_ADDRESS, write);  // the echo, as address 0
+  EXPECT_EQ(device.response_count_, 1);
+  EXPECT_EQ(device.last_response_size_, sizeof(write));
+  EXPECT_FALSE(hub.waiting());
+  EXPECT_EQ(hub.entries(), 0u);
+}
+
+// Two requests for the same address-0 write may disagree on expect_broadcast_write_response (a
+// broadcastable frame is accepted either way), but a write duplicate is refused at its cap of one in
+// flight rather than absorbed, so the queued entry's delivery mode is never changed under it.
+TEST(ModbusClientHubBroadcast, ExpectBroadcastWriteResponseDuplicateRefusedNotMerged) {
+  NullUART uart;
+  NoResponseProbeHub hub;
+  hub.set_uart_parent(&uart);
+  hub.setup();
+  BroadcastProbeDevice device(&hub, BROADCAST_ADDRESS);
+
+  ASSERT_TRUE(device.write_single_register(0x0010, 0x0001));  // fire-and-forget as queued
+  EXPECT_TRUE(hub.queued(0).fire_and_forget());
+  EXPECT_FALSE(device.write_single_register(0x0010, 0x0001, {.expect_broadcast_write_response = true}));
+  EXPECT_EQ(hub.entries(), 1u);
+  EXPECT_TRUE(hub.queued(0).fire_and_forget());  // the refused request left the entry untouched
+
+  hub.send_next_for_test();
+  EXPECT_FALSE(hub.waiting());
+  EXPECT_EQ(hub.entries(), 0u);
+}
+
+// A custom-code poll at address 0 is a fire-and-forget broadcast that a one-shot duplicate downgrades and
+// is absorbed into; if that duplicate wants the reply, the entry waits for it instead of retiring at the
+// send, so the absorbed request still gets its terminal callback.
+TEST(ModbusClientHubBroadcast, ExpectBroadcastWriteResponseMergesIntoDowngradedPoll) {
+  NullUART uart;
+  NoResponseProbeHub hub;
+  hub.set_uart_parent(&uart);
+  hub.setup();
+  BroadcastProbeDevice device(&hub, BROADCAST_ADDRESS);
+
+  const uint8_t custom[] = {0x41, 0x01, 0x02};
+  ASSERT_TRUE(device.queue_pdu(custom, {.continuous = true}));
+  EXPECT_TRUE(hub.queued(0).fire_and_forget());
+  ASSERT_TRUE(device.queue_pdu(custom, {.expect_broadcast_write_response = true}));  // downgrades, absorbed
+  EXPECT_EQ(hub.entries(), 1u);
+  EXPECT_FALSE(hub.queued(0).options.continuous);
+  EXPECT_FALSE(hub.queued(0).fire_and_forget());
+
+  hub.send_next_for_test();
+  EXPECT_TRUE(hub.waiting());
+  hub.receive_frame_for_test(BROADCAST_ADDRESS, custom);
+  EXPECT_EQ(device.response_count_, 1);
+}
+
+// A silent device leaves an expected write response to the normal send-wait timeout.
+TEST(ModbusClientHubBroadcast, ExpectBroadcastWriteResponseTimesOutLikeUnicast) {
+  NullUART uart;
+  NoResponseProbeHub hub;
+  hub.set_uart_parent(&uart);
+  hub.setup();
+  BroadcastProbeDevice device(&hub, BROADCAST_ADDRESS);
+
+  ASSERT_TRUE(device.write_single_coil(0x0010, true, {.expect_broadcast_write_response = true}));
+  hub.send_next_for_test();
+  ASSERT_TRUE(hub.waiting());
+
+  hub.timeout_waiting();
+  EXPECT_EQ(device.no_response_count_, 1);
+  EXPECT_EQ(device.response_count_, 0);
+  EXPECT_FALSE(hub.waiting());
+  EXPECT_EQ(hub.entries(), 0u);
+}
+
+// expect_broadcast_write_response is stripped from a read (allow_broadcast_read is the read-side flag, so
+// the broadcast guard still refuses it) and from a unicast frame (nothing to expect).
+TEST(ModbusClientHubBroadcast, ExpectBroadcastWriteResponseIgnoredForReadsAndUnicast) {
+  NullUART uart;
+  NoResponseProbeHub hub;
+  hub.set_uart_parent(&uart);
+  hub.setup();
+  BroadcastProbeDevice broadcast_device(&hub, BROADCAST_ADDRESS);
+  BroadcastProbeDevice unicast_device(&hub, 0x01);
+
+  const uint8_t read[] = {0x03, 0x00, 0x10, 0x00, 0x02};
+  EXPECT_FALSE(broadcast_device.queue_pdu(read, {.expect_broadcast_write_response = true}));
+  EXPECT_EQ(hub.entries(), 0u);
+
+  ASSERT_TRUE(unicast_device.write_single_register(0x0010, 0x0001, {.expect_broadcast_write_response = true}));
+  EXPECT_FALSE(hub.queued(0).options.expect_broadcast_write_response);
+  EXPECT_FALSE(hub.queued(0).fire_and_forget());
+}
+
 // The counterpart to RefusesReadBroadcast: a custom (user-defined) function code carries no reply the
 // hub knows how to expect, so a broadcast of one is accepted and completes fire-and-forget like a write.
 TEST(ModbusClientHubBroadcast, AcceptsCustomBroadcast) {
diff --git a/tests/components/modbus_client/common.yaml b/tests/components/modbus_client/common.yaml
index 76f7479a5cf..ce2965e449d 100644
--- a/tests/components/modbus_client/common.yaml
+++ b/tests/components/modbus_client/common.yaml
@@ -79,7 +79,8 @@ button:
     name: "Typed Actions"
     on_press:
       - modbus_client.write_single_register:
-          address: 0x01
+          address: !lambda "return 1;"
+          expect_broadcast_write_response: true
           start_address: 0x0102
           value: !lambda "return 42;"
           on_response:
@@ -93,6 +94,7 @@ button:
           start_address: 0x10
           count: 2
           continuous: true
+          allow_broadcast_read: !lambda "return false;"
           on_response:
             then:
               - lambda: 'ESP_LOGI("modbus_client.test", "first=%u n=%u", values[0], (unsigned) values.size());'
diff --git a/tests/components/modbus_client/validate-broadcast.esp32-idf.yaml b/tests/components/modbus_client/validate-broadcast.esp32-idf.yaml
new file mode 100644
index 00000000000..d6a29d7175b
--- /dev/null
+++ b/tests/components/modbus_client/validate-broadcast.esp32-idf.yaml
@@ -0,0 +1,36 @@
+# Config-only: actions that address the broadcast address (0) and wait for a reply, for a device that
+# answers it. Never compiled, so the extra action objects do not inflate the memory-impact baseline.
+packages:
+  modbus: !include ../../test_build_components/common/modbus/esp32-idf.yaml
+
+button:
+  - platform: template
+    name: Broadcast probe
+    on_press:
+      - modbus_client.read_holding_registers:
+          address: 0
+          allow_broadcast_read: true
+          start_address: 0x10
+          count: 1
+          on_response:
+            then:
+              - lambda: 'ESP_LOGI("modbus_client.test", "broadcast read first=%u", values[0]);'
+      - modbus_client.write_single_register:
+          address: 0
+          expect_broadcast_write_response: true
+          start_address: 0x0102
+          value: 42
+          on_response:
+            then:
+              - logger.log: "broadcast write acked"
+      - modbus_client.read_write_multiple_registers:
+          address: 0
+          allow_broadcast_read: true
+          read_address: 0x10
+          read_count: 1
+          write_address: 0x20
+          values: [1]
+      - modbus_client.send:
+          address: 0
+          expect_broadcast_write_response: true
+          pdu: [0x41, 0x01]
diff --git a/tests/components/modbus_controller/common.yaml b/tests/components/modbus_controller/common.yaml
index b9a7610cb73..b488e51f3c8 100644
--- a/tests/components/modbus_controller/common.yaml
+++ b/tests/components/modbus_controller/common.yaml
@@ -6,7 +6,6 @@ modbus_controller:
     on_online:
       then:
         logger.log: "Module Online"
-
 binary_sensor:
   - platform: modbus_controller
     modbus_controller_id: modbus_controller1
diff --git a/tests/components/modbus_controller/validate-broadcast.esp32-idf.yaml b/tests/components/modbus_controller/validate-broadcast.esp32-idf.yaml
new file mode 100644
index 00000000000..49e89eaa20f
--- /dev/null
+++ b/tests/components/modbus_controller/validate-broadcast.esp32-idf.yaml
@@ -0,0 +1,29 @@
+# Config-only: a controller polling the broadcast address (0), for a device that answers it, with a
+# writer entity expecting the reply to its broadcast writes. Never compiled, so the extra entities do
+# not inflate the memory-impact baseline.
+packages:
+  modbus: !include ../../test_build_components/common/modbus/esp32-idf.yaml
+
+modbus_controller:
+  - id: modbus_controller_broadcast
+    address: 0
+    allow_broadcast_read: true
+    modbus_id: modbus_bus
+
+sensor:
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_broadcast
+    id: modbus_broadcast_sensor
+    name: Broadcast Read Sensor
+    register_type: holding
+    address: 0x0010
+    value_type: U_WORD
+
+switch:
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_broadcast
+    id: modbus_broadcast_switch
+    name: Broadcast Write Switch
+    register_type: coil
+    address: 0x20
+    expect_broadcast_write_response: true
diff --git a/tests/components/provisioning/test.esp32-idf.yaml b/tests/components/provisioning/test.esp32-idf.yaml
index baa3aa8f683..4a34539002e 100644
--- a/tests/components/provisioning/test.esp32-idf.yaml
+++ b/tests/components/provisioning/test.esp32-idf.yaml
@@ -1,6 +1,6 @@
 # Exercises the provisioning window: api registers as a provisioning source
 # (encryption enabled, no key), the on_timeout automation, and the wifi (AP +
-# captive portal) and esp32_improv cross-component guards. improv_serial is
+# captive portal) and improv_ble cross-component guards. improv_serial is
 # intentionally NOT gated.
 provisioning:
   timeout: 1min
@@ -26,5 +26,5 @@ binary_sensor:
     pin: 0
     id: io0_button
 
-esp32_improv:
+improv_ble:
   authorizer: io0_button
diff --git a/tests/components/sendspin/common-switch.yaml b/tests/components/sendspin/common-switch.yaml
new file mode 100644
index 00000000000..d332cb0dde0
--- /dev/null
+++ b/tests/components/sendspin/common-switch.yaml
@@ -0,0 +1,6 @@
+packages:
+  sendspin: !include common.yaml
+
+switch:
+  - platform: sendspin
+    name: "Sendspin Enabled"
diff --git a/tests/components/sendspin/test-switch.esp32-idf.yaml b/tests/components/sendspin/test-switch.esp32-idf.yaml
new file mode 100644
index 00000000000..d32c14c054a
--- /dev/null
+++ b/tests/components/sendspin/test-switch.esp32-idf.yaml
@@ -0,0 +1,2 @@
+packages:
+  sendspin: !include common-switch.yaml
diff --git a/tests/components/tinyusb/common.yaml b/tests/components/tinyusb/common.yaml
index 674e89dbe87..32db1999afe 100644
--- a/tests/components/tinyusb/common.yaml
+++ b/tests/components/tinyusb/common.yaml
@@ -6,6 +6,15 @@ tinyusb:
   usb_product_str: ESPHomeTestProduct
   usb_serial_str: ESPHomeTestSerialNumber
   usb_vendor_id: 0x2345
+  on_mount:
+    - logger.log: USB host mounted
+    - if:
+        condition:
+          tinyusb.is_mounted:
+        then:
+          - logger.log: USB host is mounted
+  on_unmount:
+    - logger.log: USB host unmounted
 
 # tinyusb requires at least one USB class companion; usb_cdc_acm satisfies that.
 usb_cdc_acm:
diff --git a/tests/components/tinyusb/test.esp32-p4-idf.yaml b/tests/components/tinyusb/test.esp32-p4-idf.yaml
index dade44d145b..7a37fcf41b8 100644
--- a/tests/components/tinyusb/test.esp32-p4-idf.yaml
+++ b/tests/components/tinyusb/test.esp32-p4-idf.yaml
@@ -1 +1,7 @@
-<<: !include common.yaml
+packages:
+  tinyusb: !include common.yaml
+
+# VBUS monitoring is per variant: the OTG hardware watches the pin here, while the
+# S31 would need the GPIO ISR path and rejects the key.
+tinyusb:
+  vbus_monitor_pin: 4
diff --git a/tests/components/tinyusb/test.esp32-s2-idf.yaml b/tests/components/tinyusb/test.esp32-s2-idf.yaml
index 09b98ada401..67ea24f2c6c 100644
--- a/tests/components/tinyusb/test.esp32-s2-idf.yaml
+++ b/tests/components/tinyusb/test.esp32-s2-idf.yaml
@@ -1,4 +1,10 @@
-<<: !include common.yaml
+packages:
+  tinyusb: !include common.yaml
+
+# VBUS monitoring is per variant: the OTG hardware watches the pin here, while the
+# S31 would need the GPIO ISR path and rejects the key.
+tinyusb:
+  vbus_monitor_pin: 4
 
 # S2 defaults logger to USB_CDC, which conflicts with tinyusb on the shared
 # USB OTG peripheral; route the logger to UART0 so the fixture builds.
diff --git a/tests/components/tinyusb/test.esp32-s3-idf.yaml b/tests/components/tinyusb/test.esp32-s3-idf.yaml
index dade44d145b..7a37fcf41b8 100644
--- a/tests/components/tinyusb/test.esp32-s3-idf.yaml
+++ b/tests/components/tinyusb/test.esp32-s3-idf.yaml
@@ -1 +1,7 @@
-<<: !include common.yaml
+packages:
+  tinyusb: !include common.yaml
+
+# VBUS monitoring is per variant: the OTG hardware watches the pin here, while the
+# S31 would need the GPIO ISR path and rejects the key.
+tinyusb:
+  vbus_monitor_pin: 4
diff --git a/tests/components/uart_mux/common.yaml b/tests/components/uart_mux/common.yaml
new file mode 100644
index 00000000000..3477f78b708
--- /dev/null
+++ b/tests/components/uart_mux/common.yaml
@@ -0,0 +1,44 @@
+tinyusb:
+  id: tinyusb_test
+  on_mount:
+    - uart_mux.select_bridge: mux_0
+  on_unmount:
+    - uart_mux.select_local: mux_0
+  usb_manufacturer_str: ESPHomeTestManufacturer
+  usb_product_id: 0x1234
+  usb_product_str: ESPHomeTestProduct
+  usb_vendor_id: 0x2345
+
+uart:
+  - id: uart_0
+    tx_pin: 14
+    rx_pin: 13
+    baud_rate: 115200
+
+usb_cdc_acm:
+  interfaces:
+    - id: cdc_acm_1
+
+bridge:
+  - platform: cdc_acm_uart
+    id: bridge_0
+    uart_id: uart_0
+    usb_cdc_acm_id: cdc_acm_1
+
+uart_mux:
+  - id: mux_0
+    bridge_id: bridge_0
+    initial_route: local
+
+interval:
+  - interval: 60s
+    then:
+      - if:
+          condition:
+            uart_mux.is_local: mux_0
+          then:
+            - lambda: |-
+                uint8_t byte;
+                if (id(mux_0).available() && id(mux_0).read_byte(&byte)) {
+                  id(mux_0).write_byte(byte);
+                }
diff --git a/tests/components/uart_mux/test.esp32-p4-idf.yaml b/tests/components/uart_mux/test.esp32-p4-idf.yaml
new file mode 100644
index 00000000000..ced6f1158eb
--- /dev/null
+++ b/tests/components/uart_mux/test.esp32-p4-idf.yaml
@@ -0,0 +1,2 @@
+packages:
+  uart_mux: !include common.yaml
diff --git a/tests/components/uart_mux/test.esp32-s2-idf.yaml b/tests/components/uart_mux/test.esp32-s2-idf.yaml
new file mode 100644
index 00000000000..5eaa3b38479
--- /dev/null
+++ b/tests/components/uart_mux/test.esp32-s2-idf.yaml
@@ -0,0 +1,7 @@
+# ESP32-S2 has no USB_SERIAL_JTAG, so the logger defaults to USB_CDC, which shares
+# the USB OTG peripheral with tinyusb. Use a hardware UART for logging instead.
+logger:
+  hardware_uart: UART0
+
+packages:
+  uart_mux: !include common.yaml
diff --git a/tests/components/uart_mux/test.esp32-s3-idf.yaml b/tests/components/uart_mux/test.esp32-s3-idf.yaml
new file mode 100644
index 00000000000..ced6f1158eb
--- /dev/null
+++ b/tests/components/uart_mux/test.esp32-s3-idf.yaml
@@ -0,0 +1,2 @@
+packages:
+  uart_mux: !include common.yaml
diff --git a/tests/components/usb_uart/common.yaml b/tests/components/usb_uart/common.yaml
index 5b23f9d685f..2e41fad1a1b 100644
--- a/tests/components/usb_uart/common.yaml
+++ b/tests/components/usb_uart/common.yaml
@@ -6,6 +6,7 @@ usb_uart:
     type: cdc_acm
     vid: 0x1234
     pid: 0x5678
+    claim_comm_interface: false
     channels:
       - id: channel_0_1
   - id: uart_1
diff --git a/tests/integration/fixtures/sensor_raw_state.yaml b/tests/integration/fixtures/sensor_raw_state.yaml
new file mode 100644
index 00000000000..9c19032028f
--- /dev/null
+++ b/tests/integration/fixtures/sensor_raw_state.yaml
@@ -0,0 +1,53 @@
+esphome:
+  name: test-sensor-raw-state
+
+host:
+api:
+  batch_delay: 0ms  # Disable batching to receive all state updates
+logger:
+  level: DEBUG
+
+# Filters are compiled in for this config (USE_SENSOR_FILTER), so raw storage exists
+sensor:
+  # No filters on this sensor: get_raw_state() must equal state
+  - platform: template
+    name: "No Filter Sensor"
+    id: no_filter_sensor
+    accuracy_decimals: 1
+
+  # Filtered sensor: get_raw_state() must be the pre-filter value
+  - platform: template
+    name: "With Filter Sensor"
+    id: with_filter_sensor
+    accuracy_decimals: 1
+    filters:
+      - multiply: 2.0
+
+button:
+  - platform: template
+    name: "Test No Filter Button"
+    id: test_no_filter_button
+    on_press:
+      - sensor.template.publish:
+          id: no_filter_sensor
+          state: 21.5
+      - delay: 50ms
+      - logger.log:
+          format: "NO_FILTER: state=%.1f raw_state=%.1f"
+          args:
+            - id(no_filter_sensor).state
+            - id(no_filter_sensor).get_raw_state()
+
+  - platform: template
+    name: "Test With Filter Button"
+    id: test_with_filter_button
+    on_press:
+      - sensor.template.publish:
+          id: with_filter_sensor
+          state: 21.5
+      - delay: 50ms
+      - logger.log:
+          format: "WITH_FILTER: state=%.1f raw_state=%.1f"
+          args:
+            - id(with_filter_sensor).state
+            - id(with_filter_sensor).get_raw_state()
diff --git a/tests/integration/fixtures/sensor_raw_state_no_filter.yaml b/tests/integration/fixtures/sensor_raw_state_no_filter.yaml
new file mode 100644
index 00000000000..fec912691f2
--- /dev/null
+++ b/tests/integration/fixtures/sensor_raw_state_no_filter.yaml
@@ -0,0 +1,31 @@
+esphome:
+  name: test-sensor-raw-state-no-filter
+
+host:
+api:
+  batch_delay: 0ms  # Disable batching to receive all state updates
+logger:
+  level: DEBUG
+
+# No sensor in this config has filters, so USE_SENSOR_FILTER is not defined and
+# get_raw_state() falls back to state
+sensor:
+  - platform: template
+    name: "No Filter Sensor"
+    id: no_filter_sensor
+    accuracy_decimals: 1
+
+button:
+  - platform: template
+    name: "Test No Filter Button"
+    id: test_no_filter_button
+    on_press:
+      - sensor.template.publish:
+          id: no_filter_sensor
+          state: 21.5
+      - delay: 50ms
+      - logger.log:
+          format: "NO_FILTER: state=%.1f raw_state=%.1f"
+          args:
+            - id(no_filter_sensor).state
+            - id(no_filter_sensor).get_raw_state()
diff --git a/tests/integration/fixtures/uart_mock_modbus_mesh.yaml b/tests/integration/fixtures/uart_mock_modbus_mesh.yaml
index 69edd614d7a..977cdd359be 100644
--- a/tests/integration/fixtures/uart_mock_modbus_mesh.yaml
+++ b/tests/integration/fixtures/uart_mock_modbus_mesh.yaml
@@ -17,10 +17,10 @@ uart:
   baud_rate: 115200
   port: /dev/null
 
-# Shared 3-bus mesh (see the shared_yaml markers): addr 1 = typed read-only
-# registers, addr 5 = the read/write 0x17 target, addr 2/3 on the second
-# server hub. auto_start everywhere: the controller polls at boot, so the
-# forwarding must already be live or early requests generate warnings.
+# Shared 3-bus mesh (see the shared_yaml markers): addr 1 = typed registers
+# backed by writable globals, addr 5 = the read/write 0x17 target, addr 2/3/6
+# on the second server hub. auto_start everywhere: the controller polls at
+# boot, so the forwarding must already be live or early requests generate warnings.
 # Every test presses Start Scenario, so all merged actions fire in every test.
 uart_mock:
   - id: virtual_uart_server
@@ -64,6 +64,54 @@ globals:
   - id: stored_1
     type: uint16_t
     initial_value: "0"
+  - id: stored_u_word
+    type: uint16_t
+    initial_value: "99"
+  - id: stored_u_word_s
+    type: uint16_t
+    initial_value: "4660"
+  - id: stored_s_word
+    type: int16_t
+    initial_value: "-99"
+  - id: stored_s_word_s
+    type: int16_t
+    initial_value: "-2"
+  - id: stored_u_dword
+    type: uint32_t
+    initial_value: "16909060"
+  - id: stored_s_dword
+    type: int32_t
+    initial_value: "-16909060"
+  - id: stored_u_dword_r
+    type: uint32_t
+    initial_value: "67305985"
+  - id: stored_s_dword_r
+    type: int32_t
+    initial_value: "-67305985"
+  - id: stored_u_qword
+    type: uint64_t
+    initial_value: "72623859790382856"
+  - id: stored_s_qword
+    type: int64_t
+    initial_value: "-72623859790382856"
+  - id: stored_u_qword_r
+    type: uint64_t
+    initial_value: "578437695752307201"
+  - id: stored_s_qword_r
+    type: int64_t
+    initial_value: "-578437695752307201"
+  - id: stored_fp32
+    type: float
+    initial_value: "3.14"
+  - id: stored_fp32_r
+    type: float
+    initial_value: "2.5"
+  - id: stored_bit_2
+    type: bool
+    initial_value: "false"
+  - id: stored_bit_3
+    type: bool
+    initial_value: "true"
 
 modbus:
   - uart_id: virtual_uart_server
@@ -90,6 +138,10 @@ modbus_controller:
     modbus_id: virtual_modbus_client
     id: modbus_controller_3
     update_interval: 1s
+  - address: 6
+    modbus_id: virtual_modbus_client
+    id: modbus_controller_6
+    update_interval: 1s
 
 modbus_server:
   - address: 1
@@ -97,46 +149,60 @@ modbus_server:
     registers:
       - address: 0x01
         value_type: U_WORD
-        read_lambda: return 99;
+        read_lambda: return id(stored_u_word);
+        write_lambda: id(stored_u_word) = x; return true;
       - address: 0x02
         value_type: U_WORD_S
-        read_lambda: return 4660;
+        read_lambda: return id(stored_u_word_s);
+        write_lambda: id(stored_u_word_s) = x; return true;
       - address: 0x03
         value_type: S_WORD
-        read_lambda: return -99;
+        read_lambda: return id(stored_s_word);
+        write_lambda: id(stored_s_word) = x; return true;
       - address: 0x04
         value_type: S_WORD_S
-        read_lambda: return -2;
+        read_lambda: return id(stored_s_word_s);
+        write_lambda: id(stored_s_word_s) = x; return true;
       - address: 0x05
         value_type: U_DWORD
-        read_lambda: return 16909060;
+        read_lambda: return id(stored_u_dword);
+        write_lambda: id(stored_u_dword) = x; return true;
       - address: 0x08
         value_type: S_DWORD
-        read_lambda: return -16909060;
+        read_lambda: return id(stored_s_dword);
+        write_lambda: id(stored_s_dword) = x; return true;
       - address: 0x0B
         value_type: U_DWORD_R
-        read_lambda: return 67305985;
+        read_lambda: return id(stored_u_dword_r);
+        write_lambda: id(stored_u_dword_r) = x; return true;
       - address: 0x0E
         value_type: S_DWORD_R
-        read_lambda: return -67305985;
+        read_lambda: return id(stored_s_dword_r);
+        write_lambda: id(stored_s_dword_r) = x; return true;
       - address: 0x11
         value_type: U_QWORD
-        read_lambda: return 72623859790382856;
+        read_lambda: return id(stored_u_qword);
+        write_lambda: id(stored_u_qword) = x; return true;
       - address: 0x16
         value_type: S_QWORD
-        read_lambda: return -72623859790382856;
+        read_lambda: return id(stored_s_qword);
+        write_lambda: id(stored_s_qword) = x; return true;
       - address: 0x1B
         value_type: U_QWORD_R
-        read_lambda: return 578437695752307201;
+        read_lambda: return id(stored_u_qword_r);
+        write_lambda: id(stored_u_qword_r) = x; return true;
       - address: 0x20
         value_type: S_QWORD_R
-        read_lambda: return -578437695752307201;
+        read_lambda: return id(stored_s_qword_r);
+        write_lambda: id(stored_s_qword_r) = x; return true;
       - address: 0x25
         value_type: FP32
-        read_lambda: return 3.14;
+        read_lambda: return id(stored_fp32);
+        write_lambda: id(stored_fp32) = x; return true;
       - address: 0x28
         value_type: FP32_R
-        read_lambda: return 3.14;
+        read_lambda: return id(stored_fp32_r);
+        write_lambda: id(stored_fp32_r) = x; return true;
   - address: 5
     modbus_id: virtual_modbus_server
     registers:
@@ -165,6 +231,19 @@ modbus_server:
       - address: 0x01
         value_type: U_WORD
         read_lambda: return 929;
+  - address: 6
+    modbus_id: virtual_modbus_server_2
+    bits:
+      - address: 0x00
+        read_lambda: return true;
+      - address: 0x01
+        read_lambda: return false;
+      - address: 0x02
+        read_lambda: return id(stored_bit_2);
+        write_lambda: id(stored_bit_2) = x; return true;
+      - address: 0x03
+        read_lambda: return id(stored_bit_3);
+        write_lambda: id(stored_bit_3) = x; return true;
 
 sensor:
   - platform: modbus_controller
@@ -280,6 +359,183 @@ sensor:
     name: "client_read_1"
     id: client_read_1
 
+# The number schema caps min/max at 16777215 (float32 integer precision), so
+# the large dword/qword baselines cannot be written back through these numbers.
+number:
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_word"
+    address: 0x01
+    register_type: holding
+    value_type: U_WORD
+    min_value: 0
+    max_value: 65535
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_word_s"
+    address: 0x02
+    register_type: holding
+    value_type: U_WORD_S
+    min_value: 0
+    max_value: 65535
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_word"
+    address: 0x03
+    register_type: holding
+    value_type: S_WORD
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_word_s"
+    address: 0x04
+    register_type: holding
+    value_type: S_WORD_S
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_dword"
+    address: 0x05
+    register_type: holding
+    value_type: U_DWORD
+    min_value: 0
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_dword"
+    address: 0x08
+    register_type: holding
+    value_type: S_DWORD
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_dword_r"
+    address: 0x0B
+    register_type: holding
+    value_type: U_DWORD_R
+    min_value: 0
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_dword_r"
+    address: 0x0E
+    register_type: holding
+    value_type: S_DWORD_R
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_qword"
+    address: 0x11
+    register_type: holding
+    value_type: U_QWORD
+    min_value: 0
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_qword"
+    address: 0x16
+    register_type: holding
+    value_type: S_QWORD
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_qword_r"
+    address: 0x1B
+    register_type: holding
+    value_type: U_QWORD_R
+    min_value: 0
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_qword_r"
+    address: 0x20
+    register_type: holding
+    value_type: S_QWORD_R
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_fp32"
+    address: 0x25
+    register_type: holding
+    value_type: FP32
+    min_value: -16777215
+    max_value: 16777215
+    step: 0.01
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_fp32_r"
+    address: 0x28
+    register_type: holding
+    value_type: FP32_R
+    min_value: -16777215
+    max_value: 16777215
+    step: 0.01
+
+# The four bits are read both as coils (FC 0x01) and discrete inputs (FC 0x02);
+# the server serves both from one shared table, so the two views must agree.
+binary_sensor:
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_coil_0"
+    address: 0x00
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_coil_1"
+    address: 0x01
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_coil_2"
+    address: 0x02
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_coil_3"
+    address: 0x03
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_di_0"
+    address: 0x00
+    register_type: discrete_input
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_di_1"
+    address: 0x01
+    register_type: discrete_input
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_di_2"
+    address: 0x02
+    register_type: discrete_input
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_di_3"
+    address: 0x03
+    register_type: discrete_input
+
+# write_bit_2 uses the single-coil write (FC 0x05); write_bit_3 opts into the
+# multiple-coils write (FC 0x0F) so both server write paths are exercised.
+switch:
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "write_bit_2"
+    address: 0x02
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "write_bit_3"
+    address: 0x03
+    register_type: coil
+    use_write_multiple: true
+
 button:
   - platform: template
     name: "Start Scenario"
diff --git a/tests/integration/fixtures/uart_mock_modbus_server_controller_bits.yaml b/tests/integration/fixtures/uart_mock_modbus_server_controller_bits.yaml
deleted file mode 100644
index cb6fc6f0740..00000000000
--- a/tests/integration/fixtures/uart_mock_modbus_server_controller_bits.yaml
+++ /dev/null
@@ -1,147 +0,0 @@
-esphome:
-  name: uart-mock-modbus-srv-bits
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-external_components:
-  - source:
-      type: local
-      path: EXTERNAL_COMPONENT_PATH
-
-# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
-# The actual UART bus used is the uart_mock component below
-uart:
-  baud_rate: 115200
-  port: /dev/null
-
-uart_mock:
-  - id: virtual_uart_server
-    baud_rate: 9600
-    # auto_start must be true for loopback fixtures: the modbus controller
-    # polls on its update_interval immediately at boot, so the uart_mock
-    # forwarding must already be active or early requests are lost and
-    # generate modbus warnings.
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_controller
-              data: !lambda return data;
-  - id: virtual_uart_controller
-    baud_rate: 9600
-    auto_start: true # See comment on virtual_uart_server above
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_server
-              data: !lambda return data;
-
-globals:
-  - id: stored_bit_2
-    type: bool
-    initial_value: "false"
-  - id: stored_bit_3
-    type: bool
-    initial_value: "true"
-
-modbus:
-  - uart_id: virtual_uart_server
-    id: virtual_modbus_server
-    role: server
-  - uart_id: virtual_uart_controller
-    id: virtual_modbus_controller
-    role: client
-    turnaround_time: 10ms
-
-modbus_controller:
-  - address: 1
-    modbus_id: virtual_modbus_controller
-    update_interval: 1s
-    id: modbus_controller_1
-
-modbus_server:
-  - address: 1
-    modbus_id: virtual_modbus_server
-    id: modbus_server_1
-    bits:
-      - address: 0x00
-        read_lambda: return true;
-      - address: 0x01
-        read_lambda: return false;
-      - address: 0x02
-        read_lambda: return id(stored_bit_2);
-        write_lambda: id(stored_bit_2) = x; return true;
-      - address: 0x03
-        read_lambda: return id(stored_bit_3);
-        write_lambda: id(stored_bit_3) = x; return true;
-
-# The same four bits are read both as coils (FC 0x01) and as discrete inputs
-# (FC 0x02): the server serves both from one shared bit table, so the two
-# views must always agree.
-binary_sensor:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_coil_0"
-    address: 0x00
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_coil_1"
-    address: 0x01
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_coil_2"
-    address: 0x02
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_coil_3"
-    address: 0x03
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_di_0"
-    address: 0x00
-    register_type: discrete_input
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_di_1"
-    address: 0x01
-    register_type: discrete_input
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_di_2"
-    address: 0x02
-    register_type: discrete_input
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_di_3"
-    address: 0x03
-    register_type: discrete_input
-
-# write_bit_2 uses the single-coil write (FC 0x05); write_bit_3 opts into the
-# multiple-coils write (FC 0x0F) so both server write paths are exercised.
-switch:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_bit_2"
-    address: 0x02
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_bit_3"
-    address: 0x03
-    register_type: coil
-    use_write_multiple: true
-
-button:
-  - platform: template
-    name: "Start Scenario"
-    id: start_scenario_btn
-    # This test does not have anything to start (mock is autostart)
diff --git a/tests/integration/fixtures/uart_mock_modbus_server_controller_write.yaml b/tests/integration/fixtures/uart_mock_modbus_server_controller_write.yaml
deleted file mode 100644
index 5ade49bd48c..00000000000
--- a/tests/integration/fixtures/uart_mock_modbus_server_controller_write.yaml
+++ /dev/null
@@ -1,371 +0,0 @@
-esphome:
-  name: uart-mock-modbus-srv-write
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-external_components:
-  - source:
-      type: local
-      path: EXTERNAL_COMPONENT_PATH
-
-# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
-# The actual UART bus used is the uart_mock component below
-uart:
-  baud_rate: 115200
-  port: /dev/null
-
-uart_mock:
-  - id: virtual_uart_server
-    baud_rate: 9600
-    # auto_start must be true for loopback fixtures: the modbus controller
-    # polls on its update_interval immediately at boot, so the uart_mock
-    # forwarding must already be active or early requests are lost and
-    # generate modbus warnings.
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_controller
-              data: !lambda return data;
-  - id: virtual_uart_controller
-    baud_rate: 9600
-    auto_start: true # See comment on virtual_uart_server above
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_server
-              data: !lambda return data;
-
-globals:
-  - id: stored_u_word
-    type: uint16_t
-    initial_value: "11"
-  - id: stored_u_word_s
-    type: uint16_t
-    initial_value: "4660"
-  - id: stored_s_word
-    type: int16_t
-    initial_value: "-11"
-  - id: stored_s_word_s
-    type: int16_t
-    initial_value: "-2"
-  - id: stored_u_dword
-    type: uint32_t
-    initial_value: "1001"
-  - id: stored_s_dword
-    type: int32_t
-    initial_value: "-1001"
-  - id: stored_u_dword_r
-    type: uint32_t
-    initial_value: "3003"
-  - id: stored_s_dword_r
-    type: int32_t
-    initial_value: "-3003"
-  - id: stored_u_qword
-    type: uint64_t
-    initial_value: "5005"
-  - id: stored_s_qword
-    type: int64_t
-    initial_value: "-5005"
-  - id: stored_u_qword_r
-    type: uint64_t
-    initial_value: "7007"
-  - id: stored_s_qword_r
-    type: int64_t
-    initial_value: "-7007"
-  - id: stored_fp32
-    type: float
-    initial_value: "1.5"
-  - id: stored_fp32_r
-    type: float
-    initial_value: "2.5"
-
-modbus:
-  - uart_id: virtual_uart_server
-    id: virtual_modbus_server
-    role: server
-  - uart_id: virtual_uart_controller
-    id: virtual_modbus_controller
-    role: client
-    turnaround_time: 10ms
-
-modbus_controller:
-  - address: 1
-    modbus_id: virtual_modbus_controller
-    update_interval: 2s
-    id: modbus_controller_1
-
-modbus_server:
-  - address: 1
-    modbus_id: virtual_modbus_server
-    id: modbus_server_1
-    registers:
-      - address: 0x01
-        value_type: U_WORD
-        read_lambda: return id(stored_u_word);
-        write_lambda: id(stored_u_word) = x; return true;
-      - address: 0x02
-        value_type: U_WORD_S
-        read_lambda: return id(stored_u_word_s);
-        write_lambda: id(stored_u_word_s) = x; return true;
-      - address: 0x03
-        value_type: S_WORD
-        read_lambda: return id(stored_s_word);
-        write_lambda: id(stored_s_word) = x; return true;
-      - address: 0x04
-        value_type: S_WORD_S
-        read_lambda: return id(stored_s_word_s);
-        write_lambda: id(stored_s_word_s) = x; return true;
-      - address: 0x05
-        value_type: U_DWORD
-        read_lambda: return id(stored_u_dword);
-        write_lambda: id(stored_u_dword) = x; return true;
-      - address: 0x08
-        value_type: S_DWORD
-        read_lambda: return id(stored_s_dword);
-        write_lambda: id(stored_s_dword) = x; return true;
-      - address: 0x0B
-        value_type: U_DWORD_R
-        read_lambda: return id(stored_u_dword_r);
-        write_lambda: id(stored_u_dword_r) = x; return true;
-      - address: 0x0E
-        value_type: S_DWORD_R
-        read_lambda: return id(stored_s_dword_r);
-        write_lambda: id(stored_s_dword_r) = x; return true;
-      - address: 0x11
-        value_type: U_QWORD
-        read_lambda: return id(stored_u_qword);
-        write_lambda: id(stored_u_qword) = x; return true;
-      - address: 0x16
-        value_type: S_QWORD
-        read_lambda: return id(stored_s_qword);
-        write_lambda: id(stored_s_qword) = x; return true;
-      - address: 0x1B
-        value_type: U_QWORD_R
-        read_lambda: return id(stored_u_qword_r);
-        write_lambda: id(stored_u_qword_r) = x; return true;
-      - address: 0x20
-        value_type: S_QWORD_R
-        read_lambda: return id(stored_s_qword_r);
-        write_lambda: id(stored_s_qword_r) = x; return true;
-      - address: 0x25
-        value_type: FP32
-        read_lambda: return id(stored_fp32);
-        write_lambda: id(stored_fp32) = x; return true;
-      - address: 0x28
-        value_type: FP32_R
-        read_lambda: return id(stored_fp32_r);
-        write_lambda: id(stored_fp32_r) = x; return true;
-
-sensor:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_word"
-    address: 0x01
-    register_type: holding
-    value_type: U_WORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_word_s"
-    address: 0x02
-    register_type: holding
-    value_type: U_WORD_S
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_word"
-    address: 0x03
-    register_type: holding
-    value_type: S_WORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_word_s"
-    address: 0x04
-    register_type: holding
-    value_type: S_WORD_S
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_dword"
-    address: 0x05
-    register_type: holding
-    value_type: U_DWORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_dword"
-    address: 0x08
-    register_type: holding
-    value_type: S_DWORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_dword_r"
-    address: 0x0B
-    register_type: holding
-    value_type: U_DWORD_R
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_dword_r"
-    address: 0x0E
-    register_type: holding
-    value_type: S_DWORD_R
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_qword"
-    address: 0x11
-    register_type: holding
-    value_type: U_QWORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_qword"
-    address: 0x16
-    register_type: holding
-    value_type: S_QWORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_qword_r"
-    address: 0x1B
-    register_type: holding
-    value_type: U_QWORD_R
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_qword_r"
-    address: 0x20
-    register_type: holding
-    value_type: S_QWORD_R
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_fp32"
-    address: 0x25
-    register_type: holding
-    value_type: FP32
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_fp32_r"
-    address: 0x28
-    register_type: holding
-    value_type: FP32_R
-
-number:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_word"
-    address: 0x01
-    register_type: holding
-    value_type: U_WORD
-    min_value: 0
-    max_value: 65535
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_word_s"
-    address: 0x02
-    register_type: holding
-    value_type: U_WORD_S
-    min_value: 0
-    max_value: 65535
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_word"
-    address: 0x03
-    register_type: holding
-    value_type: S_WORD
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_word_s"
-    address: 0x04
-    register_type: holding
-    value_type: S_WORD_S
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_dword"
-    address: 0x05
-    register_type: holding
-    value_type: U_DWORD
-    min_value: 0
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_dword"
-    address: 0x08
-    register_type: holding
-    value_type: S_DWORD
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_dword_r"
-    address: 0x0B
-    register_type: holding
-    value_type: U_DWORD_R
-    min_value: 0
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_dword_r"
-    address: 0x0E
-    register_type: holding
-    value_type: S_DWORD_R
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_qword"
-    address: 0x11
-    register_type: holding
-    value_type: U_QWORD
-    min_value: 0
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_qword"
-    address: 0x16
-    register_type: holding
-    value_type: S_QWORD
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_qword_r"
-    address: 0x1B
-    register_type: holding
-    value_type: U_QWORD_R
-    min_value: 0
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_qword_r"
-    address: 0x20
-    register_type: holding
-    value_type: S_QWORD_R
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_fp32"
-    address: 0x25
-    register_type: holding
-    value_type: FP32
-    min_value: -16777215
-    max_value: 16777215
-    step: 0.01
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_fp32_r"
-    address: 0x28
-    register_type: holding
-    value_type: FP32_R
-    min_value: -16777215
-    max_value: 16777215
-    step: 0.01
-
-button:
-  - platform: template
-    name: "Start Scenario"
-    id: start_scenario_btn
-    # This test does not have anything to start (mock is autostart)
diff --git a/tests/integration/test_sensor_raw_state.py b/tests/integration/test_sensor_raw_state.py
new file mode 100644
index 00000000000..a178ebf7d4c
--- /dev/null
+++ b/tests/integration/test_sensor_raw_state.py
@@ -0,0 +1,108 @@
+"""Integration tests for Sensor::get_raw_state().
+
+Raw state storage only exists when filters are compiled in (USE_SENSOR_FILTER).
+Without it, get_raw_state() returns state, so both build configurations are covered:
+one fixture with a filtered sensor and one with no filters at all.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import re
+
+from aioesphomeapi import APIClient, EntityInfo
+import pytest
+
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+NO_FILTER_PATTERN = re.compile(r"NO_FILTER: state=([\d.]+) raw_state=([\d.]+)")
+WITH_FILTER_PATTERN = re.compile(r"WITH_FILTER: state=([\d.]+) raw_state=([\d.]+)")
+
+
+async def _press_and_read(
+    client: APIClient,
+    entities: list[EntityInfo],
+    button_object_id: str,
+    future: asyncio.Future[tuple[float, float]],
+    label: str,
+) -> tuple[float, float]:
+    button = next(
+        (e for e in entities if button_object_id in e.object_id.lower()), None
+    )
+    assert button is not None, f"{button_object_id} not found"
+    client.button_command(button.key)
+    try:
+        return await asyncio.wait_for(future, timeout=5.0)
+    except TimeoutError:
+        pytest.fail(f"Timeout waiting for {label} log message")
+
+
+@pytest.mark.asyncio
+async def test_sensor_raw_state(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """With filters compiled in, raw state is stored separately from state."""
+    loop = asyncio.get_running_loop()
+    no_filter_future: asyncio.Future[tuple[float, float]] = loop.create_future()
+    with_filter_future: asyncio.Future[tuple[float, float]] = loop.create_future()
+
+    def check_output(line: str) -> None:
+        if not no_filter_future.done() and (match := NO_FILTER_PATTERN.search(line)):
+            no_filter_future.set_result((float(match.group(1)), float(match.group(2))))
+        if not with_filter_future.done() and (
+            match := WITH_FILTER_PATTERN.search(line)
+        ):
+            with_filter_future.set_result(
+                (float(match.group(1)), float(match.group(2)))
+            )
+
+    async with (
+        run_compiled(yaml_config, line_callback=check_output),
+        api_client_connected() as client,
+    ):
+        entities, _ = await client.list_entities_services()
+
+        state, raw_state = await _press_and_read(
+            client, entities, "test_no_filter_button", no_filter_future, "NO_FILTER"
+        )
+        assert state == 21.5
+        assert raw_state == 21.5
+
+        state, raw_state = await _press_and_read(
+            client,
+            entities,
+            "test_with_filter_button",
+            with_filter_future,
+            "WITH_FILTER",
+        )
+        assert state == 43.0
+        assert raw_state == 21.5
+
+
+@pytest.mark.asyncio
+async def test_sensor_raw_state_no_filter(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Without filters compiled in, get_raw_state() returns state."""
+    loop = asyncio.get_running_loop()
+    no_filter_future: asyncio.Future[tuple[float, float]] = loop.create_future()
+
+    def check_output(line: str) -> None:
+        if not no_filter_future.done() and (match := NO_FILTER_PATTERN.search(line)):
+            no_filter_future.set_result((float(match.group(1)), float(match.group(2))))
+
+    async with (
+        run_compiled(yaml_config, line_callback=check_output),
+        api_client_connected() as client,
+    ):
+        entities, _ = await client.list_entities_services()
+
+        state, raw_state = await _press_and_read(
+            client, entities, "test_no_filter_button", no_filter_future, "NO_FILTER"
+        )
+        assert state == 21.5
+        assert raw_state == 21.5
diff --git a/tests/integration/test_uart_mock_modbus.py b/tests/integration/test_uart_mock_modbus.py
index 232e1fb6543..36aa9a9668c 100644
--- a/tests/integration/test_uart_mock_modbus.py
+++ b/tests/integration/test_uart_mock_modbus.py
@@ -19,23 +19,40 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import Callable
-from dataclasses import dataclass
 
 from aioesphomeapi import ButtonInfo, NumberInfo, SwitchInfo, TextSensorState
 import pytest
 
-from .state_utils import SensorTracker, find_entity, wait_for_state
+from .state_utils import SensorTracker, find_entity, require_entity, wait_for_state
 from .types import APIClientConnectedFactory, RunCompiledFunction
 
 
-@dataclass
-class RegisterTestCase:
-    """Test parameters for a single modbus register write/read round-trip."""
+def _swap16(value: int) -> int:
+    """Byte-swapped view of a 16-bit register as the raw U_WORD wire value."""
+    return ((value & 0xFF) << 8) | (value >> 8)
 
-    initial_value: object
-    write_number_name: str
-    write_value: float
-    post_write_value: object
+
+# Raw U_WORD view of reg_u_word_s's initial 0x1234
+MESH_RAW_U_WORD_S = _swap16(4660)
+
+# Initial values of the mesh fixture's address 1 registers; the
+# server_controller test reads them and the write test uses them as baseline.
+MESH_INITIAL_VALUES: dict[str, object] = {
+    "reg_u_word": 99,
+    "reg_u_word_s": 4660,
+    "reg_s_word": -99,
+    "reg_s_word_s": -2,
+    "reg_u_dword": 16909060,
+    "reg_s_dword": -16909060,
+    "reg_u_dword_r": pytest.approx(67305985),
+    "reg_s_dword_r": pytest.approx(-67305985),
+    "reg_u_qword": pytest.approx(72623859790382856),
+    "reg_s_qword": pytest.approx(-72623859790382856),
+    "reg_u_qword_r": pytest.approx(578437695752307201),
+    "reg_s_qword_r": pytest.approx(-578437695752307201),
+    "reg_fp32": pytest.approx(3.14),
+    "reg_fp32_r": pytest.approx(2.5),
+}
 
 
 # ---------------------------------------------------------------------------
@@ -310,23 +327,7 @@ async def test_uart_mock_modbus_server_controller(
 
     line_callback, error_log_lines, warning_log_lines = _make_modbus_line_callback()
 
-    expected_values = {
-        "reg_u_word": 99,
-        "reg_u_word_s": 4660,
-        "reg_u_word_s_raw": 13330,
-        "reg_s_word": -99,
-        "reg_s_word_s": -2,
-        "reg_u_dword": 16909060,
-        "reg_s_dword": -16909060,
-        "reg_u_dword_r": pytest.approx(67305985),
-        "reg_s_dword_r": pytest.approx(-67305985),
-        "reg_u_qword": pytest.approx(72623859790382856),
-        "reg_s_qword": pytest.approx(-72623859790382856),
-        "reg_u_qword_r": pytest.approx(578437695752307201),
-        "reg_s_qword_r": pytest.approx(-578437695752307201),
-        "reg_fp32": pytest.approx(3.14),
-        "reg_fp32_r": pytest.approx(3.14),
-    }
+    expected_values = MESH_INITIAL_VALUES | {"reg_u_word_s_raw": MESH_RAW_U_WORD_S}
     tracker = SensorTracker(list(expected_values.keys()))
     futures = tracker.expect_all(expected_values)
 
@@ -334,14 +335,12 @@ async def test_uart_mock_modbus_server_controller(
         run_compiled(yaml_config, line_callback=line_callback),
         api_client_connected() as client,
     ):
-        # The controller polls from boot, so the first values can already be in
-        # the states the device sends on connect; matching them there saves
-        # waiting for the next poll
         await tracker.setup_and_start_scenario(client, match_initial_states=True)
         await tracker.await_all(futures)
         _assert_no_modbus_errors(error_log_lines, warning_log_lines)
 
 
+@pytest.mark.shared_yaml("uart_mock_modbus_mesh")
 @pytest.mark.asyncio
 async def test_uart_mock_modbus_server_controller_write(
     yaml_config: str,
@@ -357,51 +356,47 @@ async def test_uart_mock_modbus_server_controller_write(
 
     line_callback, error_log_lines, warning_log_lines = _make_modbus_line_callback()
 
-    register_test_cases: dict[str, RegisterTestCase] = {
-        "reg_u_word": RegisterTestCase(11, "write_u_word", 42, 42),
-        "reg_u_word_s": RegisterTestCase(4660, "write_u_word_s", 17185, 17185),
-        "reg_s_word": RegisterTestCase(-11, "write_s_word", -42, -42),
-        "reg_s_word_s": RegisterTestCase(-2, "write_s_word_s", -257, -257),
-        "reg_u_dword": RegisterTestCase(1001, "write_u_dword", 2002, 2002),
-        "reg_s_dword": RegisterTestCase(-1001, "write_s_dword", -2002, -2002),
-        "reg_u_dword_r": RegisterTestCase(3003, "write_u_dword_r", 4004, 4004),
-        "reg_s_dword_r": RegisterTestCase(-3003, "write_s_dword_r", -4004, -4004),
-        "reg_u_qword": RegisterTestCase(5005, "write_u_qword", 6006, 6006),
-        "reg_s_qword": RegisterTestCase(-5005, "write_s_qword", -6006, -6006),
-        "reg_u_qword_r": RegisterTestCase(7007, "write_u_qword_r", 8008, 8008),
-        "reg_s_qword_r": RegisterTestCase(-7007, "write_s_qword_r", -8008, -8008),
-        "reg_fp32": RegisterTestCase(
-            pytest.approx(1.5, abs=0.01),
-            "write_fp32",
-            3.14,
-            pytest.approx(3.14, abs=0.01),
-        ),
-        "reg_fp32_r": RegisterTestCase(
-            pytest.approx(2.5, abs=0.01),
-            "write_fp32_r",
-            6.28,
-            pytest.approx(6.28, abs=0.01),
-        ),
+    # Per read-back sensor: the number entity to write through and the value;
+    # floats read back within tolerance, everything else exactly
+    register_writes: dict[str, tuple[str, int | float]] = {
+        "reg_u_word": ("write_u_word", 42),
+        "reg_u_word_s": ("write_u_word_s", 17185),
+        "reg_s_word": ("write_s_word", -42),
+        "reg_s_word_s": ("write_s_word_s", -257),
+        "reg_u_dword": ("write_u_dword", 2002),
+        "reg_s_dword": ("write_s_dword", -2002),
+        "reg_u_dword_r": ("write_u_dword_r", 4004),
+        "reg_s_dword_r": ("write_s_dword_r", -4004),
+        "reg_u_qword": ("write_u_qword", 6006),
+        "reg_s_qword": ("write_s_qword", -6006),
+        "reg_u_qword_r": ("write_u_qword_r", 8008),
+        "reg_s_qword_r": ("write_s_qword_r", -8008),
+        "reg_fp32": ("write_fp32", 6.28),
+        "reg_fp32_r": ("write_fp32_r", 9.42),
     }
 
-    tracker = SensorTracker(list(register_test_cases.keys()))
+    tracker = SensorTracker([*register_writes, "reg_u_word_s_raw"])
 
+    # The raw U_WORD view of 0x02 pins the byte swap on the write path: the
+    # round trip through write_u_word_s applies the swap an even number of
+    # times, so only the raw sensor can catch a symmetrically dropped swap.
     # Phase 1: expect initial baseline values
     initial_futures = tracker.expect_all(
-        {name: case.initial_value for name, case in register_test_cases.items()}
+        MESH_INITIAL_VALUES | {"reg_u_word_s_raw": MESH_RAW_U_WORD_S}
     )
     # Phase 2: expect post-write values (registered now so on_state can match them)
     written_futures = tracker.expect_all(
-        {name: case.post_write_value for name, case in register_test_cases.items()}
+        {
+            name: pytest.approx(value, abs=0.01) if isinstance(value, float) else value
+            for name, (_, value) in register_writes.items()
+        }
+        | {"reg_u_word_s_raw": _swap16(register_writes["reg_u_word_s"][1])}
     )
 
     async with (
         run_compiled(yaml_config, line_callback=line_callback),
         api_client_connected() as client,
     ):
-        # The controller polls from boot, so the baseline can already be in the
-        # states the device sends on connect; matching it there saves waiting for
-        # the next poll
         entities = await tracker.setup_and_start_scenario(
             client, match_initial_states=True
         )
@@ -410,19 +405,22 @@ async def test_uart_mock_modbus_server_controller_write(
         # connection is working before issuing writes
         await tracker.await_all(initial_futures, timeout=4.0)
 
-        # Issue write commands for all register types
-        for case in register_test_cases.values():
-            entity = find_entity(entities, case.write_number_name, NumberInfo)
-            assert entity is not None, (
-                f"{case.write_number_name} number entity not found"
-            )
-            client.number_command(entity.key, case.write_value)
+        # Issue write commands for all register types; exact object_id match,
+        # since several write_* names are prefixes of a sibling
+        numbers = {
+            e.object_id.lower(): e for e in entities if isinstance(e, NumberInfo)
+        }
+        for number_name, value in register_writes.values():
+            entity = numbers.get(number_name)
+            assert entity is not None, f"{number_name} number entity not found"
+            client.number_command(entity.key, value)
 
         # Wait for sensors to reflect the written values (round-trip write+read)
         await tracker.await_all(written_futures, timeout=4.0)
         _assert_no_modbus_errors(error_log_lines, warning_log_lines)
 
 
+@pytest.mark.shared_yaml("uart_mock_modbus_mesh")
 @pytest.mark.asyncio
 async def test_uart_mock_modbus_server_controller_bits(
     yaml_config: str,
@@ -468,8 +466,6 @@ async def test_uart_mock_modbus_server_controller_bits(
         run_compiled(yaml_config, line_callback=line_callback),
         api_client_connected() as client,
     ):
-        # The controller polls from boot and binary sensors drop repeats, so the
-        # baseline can arrive only in the states the device sends on connect
         entities = await tracker.setup_and_start_scenario(
             client, match_initial_states=True
         )
@@ -480,8 +476,7 @@ async def test_uart_mock_modbus_server_controller_bits(
 
         # Flip both writable bits: 0x02 false -> true, 0x03 true -> false
         for switch_name, value in (("write_bit_2", True), ("write_bit_3", False)):
-            entity = find_entity(entities, switch_name, SwitchInfo)
-            assert entity is not None, f"{switch_name} switch entity not found"
+            entity = require_entity(entities, switch_name, SwitchInfo)
             client.switch_command(entity.key, value)
 
         # Wait for both read views to reflect the written values
@@ -508,9 +503,6 @@ async def test_uart_mock_modbus_server_controller_multiple(
         run_compiled(yaml_config, line_callback=line_callback),
         api_client_connected() as client,
     ):
-        # The controller polls from boot, so the first values can already be in
-        # the states the device sends on connect; matching them there saves
-        # waiting for the next poll
         await tracker.setup_and_start_scenario(client, match_initial_states=True)
         await tracker.await_all(futures)
         _assert_no_modbus_errors(error_log_lines, warning_log_lines)
diff --git a/tests/unit_tests/build_gen/test_espidf.py b/tests/unit_tests/build_gen/test_espidf.py
index 079f10ddb91..2848d7202df 100644
--- a/tests/unit_tests/build_gen/test_espidf.py
+++ b/tests/unit_tests/build_gen/test_espidf.py
@@ -163,6 +163,18 @@ def test_has_discovered_components_after_configure(tmp_path: Path) -> None:
     assert has_discovered_components()
 
 
+def test_get_project_cmakelists_size_command_uses_json2() -> None:
+    """The POST_BUILD size command uses the cheap json2 format, with --ng
+    only on the 1.x tool bundled with IDF < 6."""
+    content = _render()
+    assert "-m esp_idf_size --ng --format=json2" in content
+
+    CORE.data[KEY_ESP32][KEY_IDF_VERSION] = cv.Version(6, 0, 0)
+    content = _render()
+    assert "--ng" not in content
+    assert "--format=json2" in content
+
+
 def test_get_project_cmakelists_uses_supplied_builtin_components() -> None:
     """A cached list replaces project_description.json and is still filtered
     by EXCLUDE_COMPONENTS."""
diff --git a/tests/unit_tests/components/file/test_image.py b/tests/unit_tests/components/file/test_image.py
index a9c1684db39..727a4c8c1ef 100644
--- a/tests/unit_tests/components/file/test_image.py
+++ b/tests/unit_tests/components/file/test_image.py
@@ -5,8 +5,13 @@ from __future__ import annotations
 from pathlib import Path
 from unittest.mock import patch
 
+import pytest
+
+from esphome import yaml_util
 from esphome.components.file import image as file_image
-from esphome.external_files import RemoteFile
+from esphome.const import CONF_PATH
+from esphome.core import CORE
+from esphome.external_files import RemoteFile, url_cache_key
 from esphome.loader import get_component, get_platform
 
 
@@ -55,6 +60,42 @@ def test_prefetch_files_yields_remote_refs(setup_core: Path) -> None:
     assert files[1].url == "https://example.com/img.png"
 
 
+def test_validated_file_values_hash_alike_across_data_dirs(
+    setup_core: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A CLI and an add-on data dir dump validated image files identically."""
+    url = "https://example.com/img.png"
+    (setup_core / "img.png").touch()
+    dumps: list[str] = []
+    for data_dir in (
+        setup_core / ".esphome",
+        setup_core.parent / f"{setup_core.name}-data",
+    ):
+        monkeypatch.setenv("ESPHOME_DATA_DIR", str(data_dir))
+        with patch("esphome.components.file.image.external_files.download_content"):
+            config = {
+                "remote": file_image.validate_file_shorthand(url),
+                "mdi": file_image.validate_file_shorthand("mdi:home"),
+                "local": file_image.validate_file_shorthand("img.png"),
+                "local_schema": file_image.LOCAL_SCHEMA({CONF_PATH: "img.png"}),
+            }
+        dumps.append(
+            yaml_util.dump(
+                config,
+                sort_keys=True,
+                relative_to=CORE.config_dir,
+                data_dir=CORE.data_dir,
+            )
+        )
+    assert dumps[0] == dumps[1]
+    assert dumps[0].splitlines() == [
+        "local: img.png",
+        "local_schema: img.png",
+        "mdi: .esphome/image/mdi/home.svg",
+        f"remote: .esphome/image/{url_cache_key(url)}",
+    ]
+
+
 def test_extractor_matches_validator_path(setup_core: Path) -> None:
     """The path the validator downloads to equals the extractor's path."""
     with patch(
diff --git a/tests/unit_tests/core/test_config.py b/tests/unit_tests/core/test_config.py
index 8ab3ad5d153..07cff003cdd 100644
--- a/tests/unit_tests/core/test_config.py
+++ b/tests/unit_tests/core/test_config.py
@@ -175,6 +175,27 @@ async def test_core_area_recorded_at_config_load(
     assert CORE.area == expected_area
 
 
+@pytest.mark.asyncio
+async def test_app_is_default_initialized(
+    yaml_file: Callable[[str], Path],
+) -> None:
+    """App is constructed with `new (&App) Application`, no parentheses.
+
+    `Application()` would value-initialize and memset the whole object into
+    storage that is already zero."""
+    result = load_config_from_fixture(yaml_file, "valid_area_device.yaml", FIXTURES_DIR)
+    assert result is not None
+
+    with patch("esphome.core.config.cg") as mock_cg:
+        mock_cg.RawStatement.side_effect = lambda *args, **kwargs: MagicMock()
+        mock_cg.RawExpression.side_effect = lambda *args, **kwargs: MagicMock()
+        await config.to_code(result[CONF_ESPHOME])
+
+    raw_expressions = [c.args[0] for c in mock_cg.RawExpression.call_args_list]
+    assert "new (&App) Application" in raw_expressions
+    assert "new (&App) Application()" not in raw_expressions
+
+
 def test_config_load_without_area_clears_stale_core_area(
     yaml_file: Callable[[str], Path],
 ) -> None:
diff --git a/tests/unit_tests/test_automation.py b/tests/unit_tests/test_automation.py
index a377cf185a8..07ea7533601 100644
--- a/tests/unit_tests/test_automation.py
+++ b/tests/unit_tests/test_automation.py
@@ -1,7 +1,9 @@
 """Tests for esphome.automation module."""
 
-from collections.abc import Generator
-from unittest.mock import AsyncMock, call, patch
+from collections.abc import Callable, Generator
+from functools import partial
+from typing import NamedTuple
+from unittest.mock import AsyncMock, MagicMock, call, patch
 
 import pytest
 
@@ -12,9 +14,18 @@ from esphome.automation import (
     TriggerOnTrueForwarder,
     build_callback_automations,
     has_non_synchronous_actions,
+    register_bare_action,
+    register_bare_condition,
+    register_parented_action,
+    register_parented_condition,
+    register_simple_action,
+    register_simple_condition,
 )
+import esphome.codegen as cg
+from esphome.const import CONF_ID
+from esphome.core import ID
 from esphome.cpp_generator import MockObj, RawExpression
-from esphome.util import RegistryEntry
+from esphome.util import Registry, RegistryEntry
 
 
 def _make_registry(non_synchronous_actions: set[str]) -> dict[str, RegistryEntry]:
@@ -475,3 +486,111 @@ async def test_build_callback_automations_defaults(
     mock_build_callback.assert_called_once_with(
         parent, "add_on_press_callback", [], conf, forwarder=None
     )
+
+
+PARENT_ID = ID("my_component")
+PARENT_OBJ = MockObj("parent", "->")
+NEW_OBJ = MockObj("var", "->")
+ACTION_TYPE = cg.esphome_ns.class_("MyAction")
+CONDITION_TYPE = cg.esphome_ns.class_("MyCondition")
+TEMPLATE_ARG = cg.TemplateArguments()
+
+
+class MockCodegen(NamedTuple):
+    get_variable: AsyncMock
+    new_pvariable: MagicMock
+    register_parented: AsyncMock
+
+
+@pytest.fixture
+def mock_cg() -> Generator[MockCodegen]:
+    """Patch the codegen calls the shared builders make."""
+    with (
+        patch("esphome.codegen.get_variable", new_callable=AsyncMock) as get_variable,
+        patch("esphome.codegen.new_Pvariable") as new_pvariable,
+        patch(
+            "esphome.codegen.register_parented", new_callable=AsyncMock
+        ) as register_parented,
+    ):
+        get_variable.return_value = PARENT_OBJ
+        new_pvariable.return_value = NEW_OBJ
+        yield MockCodegen(get_variable, new_pvariable, register_parented)
+
+
+@pytest.fixture
+def registries() -> Generator[tuple[Registry, Registry]]:
+    """Patch both registries so registrations made by a test do not leak."""
+    actions = Registry()
+    conditions = Registry()
+    with (
+        patch("esphome.automation.ACTION_REGISTRY", actions),
+        patch("esphome.automation.CONDITION_REGISTRY", conditions),
+    ):
+        yield actions, conditions
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("register", "is_action", "ctor_parent", "parented"),
+    [
+        (partial(register_simple_action, synchronous=True), True, True, False),
+        (partial(register_bare_action, synchronous=True), True, False, False),
+        (partial(register_parented_action, synchronous=True), True, False, True),
+        (register_simple_condition, False, True, False),
+        (register_bare_condition, False, False, False),
+        (register_parented_condition, False, False, True),
+    ],
+    ids=[
+        "simple_action",
+        "bare_action",
+        "parented_action",
+        "simple_condition",
+        "bare_condition",
+        "parented_condition",
+    ],
+)
+async def test_shared_builders(
+    registries: tuple[Registry, Registry],
+    mock_cg: MockCodegen,
+    register: Callable[..., None],
+    is_action: bool,
+    ctor_parent: bool,
+    parented: bool,
+) -> None:
+    """Each helper constructs the object and wires the parent the way its C++ shape needs."""
+    actions, conditions = registries
+    type_id = ACTION_TYPE if is_action else CONDITION_TYPE
+    register("my.entry", type_id, {})
+    entry = (actions if is_action else conditions)["my.entry"]
+    assert entry.type_id is type_id
+    config = {CONF_ID: PARENT_ID} if ctor_parent or parented else {}
+
+    result = await entry.fun(config, ID("obj_1"), TEMPLATE_ARG, [])
+
+    assert result is NEW_OBJ
+    if ctor_parent:
+        mock_cg.get_variable.assert_awaited_once_with(PARENT_ID)
+        mock_cg.new_pvariable.assert_called_once_with(
+            ID("obj_1"), TEMPLATE_ARG, PARENT_OBJ
+        )
+    else:
+        mock_cg.get_variable.assert_not_called()
+        mock_cg.new_pvariable.assert_called_once_with(ID("obj_1"), TEMPLATE_ARG)
+    if parented:
+        mock_cg.register_parented.assert_awaited_once_with(NEW_OBJ, PARENT_ID)
+    else:
+        mock_cg.register_parented.assert_not_called()
+
+
+@pytest.mark.parametrize("synchronous", [True, False])
+def test_shared_builders_keep_synchronous_flag(
+    registries: tuple[Registry, Registry], synchronous: bool
+) -> None:
+    """The synchronous flag reaches the registry entry unchanged."""
+    actions, _ = registries
+    register_simple_action("my.simple", ACTION_TYPE, {}, synchronous=synchronous)
+    register_bare_action("my.bare", ACTION_TYPE, {}, synchronous=synchronous)
+    register_parented_action("my.parented", ACTION_TYPE, {}, synchronous=synchronous)
+    assert actions["my.simple"].synchronous is synchronous
+    assert actions["my.bare"].synchronous is synchronous
+    assert actions["my.parented"].synchronous is synchronous
diff --git a/tests/unit_tests/test_espidf_toolchain.py b/tests/unit_tests/test_espidf_toolchain.py
index 9deb27d83cb..bb2aab17a24 100644
--- a/tests/unit_tests/test_espidf_toolchain.py
+++ b/tests/unit_tests/test_espidf_toolchain.py
@@ -638,6 +638,43 @@ def test_run_compile_passes_compile_process_limit(setup_core: Path) -> None:
     mock_run.assert_called_once_with("build", "size", jobs=1)
 
 
+def test_run_compile_passes_size_summary_paths(setup_core: Path) -> None:
+    """print_summary receives the size json, partitions.csv, and the built
+    ELF from get_built_elf_path, which must stay in lockstep with the
+    project() name in the generated CMakeLists."""
+    _setup_build(setup_core)
+    config = {CONF_ESPHOME: {}}
+
+    with (
+        patch.object(toolchain, "need_reconfigure", return_value=False),
+        patch.object(toolchain, "run_idf_py", return_value=0),
+        patch.object(toolchain, "print_summary") as mock_summary,
+    ):
+        assert toolchain.run_compile(config, verbose=False) == 0
+
+    mock_summary.assert_called_once_with(
+        CORE.relative_build_path("build", "esp_idf_size.json"),
+        CORE.relative_build_path("partitions.csv"),
+        CORE.relative_build_path("build", f"{CORE.name}.elf"),
+    )
+
+
+def test_create_elf_copy(setup_core: Path) -> None:
+    """The built <name>.elf is copied to the firmware.elf dashboard name."""
+    _setup_build(setup_core)
+    src = toolchain.get_built_elf_path()
+    src.parent.mkdir(parents=True, exist_ok=True)
+    src.write_bytes(b"elf")
+    assert toolchain.create_elf_copy() is True
+    assert toolchain.get_elf_path().read_bytes() == b"elf"
+
+
+def test_create_elf_copy_missing_source(setup_core: Path) -> None:
+    """A missing built ELF is a warning and False, not a crash."""
+    _setup_build(setup_core)
+    assert toolchain.create_elf_copy() is False
+
+
 def test_run_compile_without_compile_process_limit(setup_core: Path) -> None:
     """When no compile_process_limit is set, no job limit is passed to idf.py."""
     _setup_build(setup_core)
diff --git a/tests/unit_tests/test_size_summary.py b/tests/unit_tests/test_size_summary.py
index 0c0852a191e..245184f2d03 100644
--- a/tests/unit_tests/test_size_summary.py
+++ b/tests/unit_tests/test_size_summary.py
@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
+import struct
+from unittest.mock import patch
 
 import pytest
 
@@ -17,64 +19,106 @@ def _write_size_json(tmp_path: Path, data: dict) -> Path:
     return out
 
 
+def _write_partitions(tmp_path: Path) -> Path:
+    """Drop a partitions.csv with a 0x1C0000 (1835008 byte) app slot."""
+    out = tmp_path / "partitions.csv"
+    out.write_text(
+        "# name, type, subtype, offset, size, flags\n"
+        "app0, app, ota_0, 0x10000, 0x1C0000,\n"
+    )
+    return out
+
+
+def _elf_bytes(sections: list[tuple[int, int, int]], shentsize: int = 40) -> bytes:
+    """Build a minimal ELF32 LE whose section headers carry the given
+    (sh_type, sh_flags, sh_size) triples."""
+    out = bytearray(52)
+    out[0:4] = b"\x7fELF"
+    out[4] = out[5] = 1  # 32-bit, little-endian
+    struct.pack_into("<I", out, 0x20, 52)  # e_shoff
+    struct.pack_into("<HH", out, 0x2E, shentsize, len(sections))
+    for sh_type, sh_flags, sh_size in sections:
+        shdr = bytearray(40)
+        struct.pack_into("<II", shdr, 4, sh_type, sh_flags)
+        struct.pack_into("<I", shdr, 20, sh_size)
+        out += shdr
+    return bytes(out)
+
+
 def _esp32_size_data() -> dict:
-    """Synthetic esp_idf_size.json for the original ESP32 (split IRAM/DRAM)."""
+    """Synthetic json2 for the original ESP32 (split IRAM/DRAM), in the
+    esp-idf-size >= 2.1 shape that carries ``total_size``."""
     return {
-        "image_size": 827455,
-        "memory_types": {
-            "DRAM": {
-                "size": 180736,
+        "version": "1.1",
+        "total_size": 827455,
+        "layout": [
+            {
+                "name": "DRAM",
+                "total": 180736,
                 "used": 47332,
-                "sections": {
-                    ".dram0.bss": {"abbrev_name": ".bss", "size": 30616},
-                    ".dram0.data": {"abbrev_name": ".data", "size": 16716},
+                "free": 133404,
+                "parts": {
+                    ".bss": {"size": 30616},
+                    ".data": {"size": 16716},
                 },
             },
-            "IRAM": {
-                "size": 131072,
+            {
+                "name": "IRAM",
+                "total": 131072,
                 "used": 80351,
-                "sections": {
-                    ".iram0.text": {"abbrev_name": ".text", "size": 79323},
-                    ".iram0.vectors": {"abbrev_name": ".vectors", "size": 1028},
+                "free": 50721,
+                "parts": {
+                    ".text": {"size": 79323},
+                    ".vectors": {"size": 1028},
                 },
             },
-        },
+        ],
     }
 
 
 def _s3_size_data() -> dict:
-    """Synthetic esp_idf_size.json for ESP32-S3 (unified DIRAM)."""
+    """Synthetic json2 for ESP32-S3 (unified DIRAM), in the esp-idf-size 1.x
+    shape without ``total_size``."""
     return {
-        "image_size": 724215,
-        "memory_types": {
-            "DIRAM": {
-                "size": 341760,
+        "version": "1.1",
+        "layout": [
+            {
+                "name": "DIRAM",
+                "total": 341760,
                 "used": 104999,
-                "sections": {
-                    ".iram0.text": {"abbrev_name": ".text", "size": 58051},
-                    ".dram0.bss": {"abbrev_name": ".bss", "size": 27088},
-                    ".dram0.data": {"abbrev_name": ".data", "size": 19708},
-                    ".noinit": {"abbrev_name": ".noinit", "size": 152},
+                "free": 236761,
+                "parts": {
+                    ".text": {"size": 58051},
+                    ".bss": {"size": 27088},
+                    ".data": {"size": 19708},
+                    ".noinit": {"size": 152},
                 },
             },
-            "IRAM": {
-                "size": 16384,
+            {
+                "name": "IRAM",
+                "total": 16384,
                 "used": 16384,
-                "sections": {
-                    ".iram0.text": {"abbrev_name": ".text", "size": 15356},
-                    ".iram0.vectors": {"abbrev_name": ".vectors", "size": 1028},
+                "free": 0,
+                "parts": {
+                    ".text": {"size": 15356},
+                    ".vectors": {"size": 1028},
                 },
             },
-        },
+        ],
     }
 
 
+def _print_summary_ram_only(tmp_path: Path, size_json: Path) -> None:
+    """Call print_summary with no partitions.csv or ELF on disk."""
+    print_summary(size_json, tmp_path / "partitions.csv", tmp_path / "firmware.elf")
+
+
 def test_print_summary_esp32_uses_dram(
     tmp_path: Path, capsys: pytest.CaptureFixture[str]
 ) -> None:
-    """Original ESP32: DRAM has no ``.text``, so RAM = DRAM.used / DRAM.size unchanged."""
+    """Original ESP32: RAM = DRAM.used / DRAM.total."""
     size_json = _write_size_json(tmp_path, _esp32_size_data())
-    print_summary(size_json, partitions_csv=None)
+    _print_summary_ram_only(tmp_path, size_json)
     out = capsys.readouterr().out
     assert "RAM:" in out
     assert "used 47332 bytes from 180736 bytes" in out
@@ -83,63 +127,193 @@ def test_print_summary_esp32_uses_dram(
 def test_print_summary_s3_falls_back_to_diram(
     tmp_path: Path, capsys: pytest.CaptureFixture[str]
 ) -> None:
-    """ESP32-S3 with no DRAM key falls back to DIRAM and reports raw region usage."""
+    """ESP32-S3 with no DRAM entry falls back to DIRAM and reports raw region usage."""
     size_json = _write_size_json(tmp_path, _s3_size_data())
-    print_summary(size_json, partitions_csv=None)
+    _print_summary_ram_only(tmp_path, size_json)
     out = capsys.readouterr().out
     assert "used 104999 bytes from 341760 bytes" in out
 
 
 def test_print_summary_skips_when_diram_total_collapses(
-    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+    caplog: pytest.LogCaptureFixture,
 ) -> None:
     """A zero-size region drops the RAM line rather than divide by zero."""
     size_json = _write_size_json(
         tmp_path,
         {
-            "memory_types": {
-                "DIRAM": {
-                    "size": 0,
-                    "used": 0,
-                    "sections": {},
-                },
-            },
+            "version": "1.1",
+            "layout": [{"name": "DIRAM", "total": 0, "used": 0}],
         },
     )
-    print_summary(size_json, partitions_csv=None)
+    _print_summary_ram_only(tmp_path, size_json)
     out = capsys.readouterr().out
     assert "RAM:" not in out
+    assert "unusable region" in caplog.text
 
 
 def test_print_summary_handles_missing_json(
     tmp_path: Path, capsys: pytest.CaptureFixture[str]
 ) -> None:
     """Missing size json is non-fatal and prints nothing."""
-    print_summary(tmp_path / "does_not_exist.json", partitions_csv=None)
+    _print_summary_ram_only(tmp_path, tmp_path / "does_not_exist.json")
     assert capsys.readouterr().out == ""
 
 
-def test_print_summary_handles_no_memory_types(
-    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+def test_print_summary_handles_no_layout(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+    caplog: pytest.LogCaptureFixture,
 ) -> None:
-    """A size json without ``memory_types`` still doesn't crash."""
-    size_json = _write_size_json(tmp_path, {"image_size": 0})
-    print_summary(size_json, partitions_csv=None)
+    """A size json without ``layout`` warns so schema drift is visible."""
+    size_json = _write_size_json(tmp_path, {"version": "1.1"})
+    _print_summary_ram_only(tmp_path, size_json)
     assert capsys.readouterr().out == ""
-
-
-def test_print_summary_flash_line(
-    tmp_path: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    """A partition table with an app row yields the Flash line in the exact
-    padded shape script/ci_memory_impact_extract.py greps."""
-    size_json = _write_size_json(tmp_path, _esp32_size_data())
-    partitions = tmp_path / "partitions.csv"
-    partitions.write_text(
-        "# name, type, subtype, offset, size, flags\n"
-        "app0, app, ota_0, 0x10000, 0x1C0000,\n"
+    assert any(
+        r.levelname == "WARNING" and "no DRAM/DIRAM region" in r.message
+        for r in caplog.records
     )
-    print_summary(size_json, partitions)
+
+
+def test_print_summary_flash_line_prefers_total_size(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """With ``total_size`` in the json, that figure wins without reading the
+    ELF, in the exact shape script/ci_memory_impact_extract.py greps."""
+    size_json = _write_size_json(tmp_path, _esp32_size_data())
+    partitions = _write_partitions(tmp_path)
+    print_summary(size_json, partitions, tmp_path / "firmware.elf")
     out = capsys.readouterr().out
     assert "Flash: " in out
     assert "(used 827455 bytes from 1835008 bytes)" in out
+
+
+def test_print_summary_flash_line_derives_from_elf(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A 1.x json without ``total_size`` sums the ELF's loadable PROGBITS
+    sections; NOBITS and non-alloc sections are excluded."""
+    size_json = _write_size_json(tmp_path, _s3_size_data())
+    partitions = _write_partitions(tmp_path)
+    firmware_elf = tmp_path / "firmware.elf"
+    firmware_elf.write_bytes(
+        _elf_bytes(
+            [
+                (1, 0x6, 700000),  # PROGBITS, alloc+exec: counted
+                (1, 0x2, 24215),  # PROGBITS, alloc: counted
+                (8, 0x2, 50000),  # NOBITS (.bss): excluded
+                (1, 0x0, 12345),  # PROGBITS, no alloc (.debug_*): excluded
+            ]
+        )
+    )
+    print_summary(size_json, partitions, firmware_elf)
+    out = capsys.readouterr().out
+    assert "(used 724215 bytes from 1835008 bytes)" in out
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        pytest.param([1, 2], id="top_level_list"),
+        pytest.param({"version": "1.1", "layout": None}, id="layout_null"),
+        pytest.param({"version": "1.1", "layout": 7}, id="layout_scalar"),
+    ],
+)
+def test_print_summary_handles_unexpected_shapes(
+    data: object, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A foreign-schema size json degrades to a warning, never a traceback."""
+    size_json = _write_size_json(tmp_path, data)
+    _print_summary_ram_only(tmp_path, size_json)
+    assert capsys.readouterr().out == ""
+
+
+def test_print_summary_skips_flash_on_zero_app_partition(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A zero-size app partition skips the Flash line rather than printing
+    a from-0-bytes figure CI would record."""
+    size_json = _write_size_json(tmp_path, _esp32_size_data())
+    partitions = tmp_path / "partitions.csv"
+    partitions.write_text(
+        "# name, type, subtype, offset, size, flags\napp0, app, ota_0, 0x10000, 0x0,\n"
+    )
+    print_summary(size_json, partitions, tmp_path / "firmware.elf")
+    out = capsys.readouterr().out
+    assert "Flash:" not in out
+
+
+def test_print_summary_skips_flash_on_unreadable_partitions(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """An unreadable partitions.csv is non-fatal (chmod tricks don't work
+    for root in CI containers, so simulate the OSError instead)."""
+    size_json = _write_size_json(tmp_path, _esp32_size_data())
+    partitions = _write_partitions(tmp_path)
+    with patch(
+        "esphome.espidf.size_summary._find_app_partition_size",
+        side_effect=PermissionError("denied"),
+    ):
+        print_summary(size_json, partitions, tmp_path / "firmware.elf")
+    assert "Flash:" not in capsys.readouterr().out
+
+
+def test_print_summary_flash_falls_back_on_bad_total_size(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A zero or non-int total_size falls back to the ELF instead of
+    printing a used-0-bytes line CI would read as a real measurement."""
+    data = _s3_size_data()
+    data["total_size"] = 0
+    size_json = _write_size_json(tmp_path, data)
+    partitions = _write_partitions(tmp_path)
+    firmware_elf = tmp_path / "firmware.elf"
+    firmware_elf.write_bytes(_elf_bytes([(1, 0x2, 4096)]))
+    print_summary(size_json, partitions, firmware_elf)
+    out = capsys.readouterr().out
+    assert "(used 4096 bytes from 1835008 bytes)" in out
+
+
+_GOOD_ELF = _elf_bytes([(1, 0x2, 1024)])
+
+
+@pytest.mark.parametrize(
+    ("elf_bytes", "with_partitions"),
+    [
+        pytest.param(None, True, id="missing_elf"),
+        pytest.param(b"junk", True, id="not_an_elf"),
+        pytest.param(
+            _elf_bytes([(1, 0x2, 1024)], shentsize=0), True, id="bad_shentsize"
+        ),
+        pytest.param(_GOOD_ELF[:60], True, id="truncated_table"),
+        pytest.param(_elf_bytes([]), True, id="no_sections"),
+        pytest.param(_elf_bytes([(8, 0x2, 50000)]), True, id="no_progbits"),
+        pytest.param(_GOOD_ELF, False, id="missing_partitions"),
+    ],
+)
+def test_print_summary_skips_flash_on_bad_input(
+    elf_bytes: bytes | None,
+    with_partitions: bool,
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """An unusable ELF or missing partitions.csv skips the Flash line, not the RAM line."""
+    size_json = _write_size_json(tmp_path, _s3_size_data())
+    firmware_elf = tmp_path / "firmware.elf"
+    if elf_bytes is not None:
+        firmware_elf.write_bytes(elf_bytes)
+    if with_partitions:
+        _write_partitions(tmp_path)
+    print_summary(size_json, tmp_path / "partitions.csv", firmware_elf)
+    out = capsys.readouterr().out
+    assert "RAM:" in out
+    assert "Flash:" not in out
+    # ELF problems warn (anomaly after a successful build); a missing
+    # partitions.csv stays at debug
+    warned = any(
+        r.levelname == "WARNING" and "Skipping Flash summary" in r.message
+        for r in caplog.records
+    )
+    assert warned == with_partitions