diff --git a/.clang-tidy.hash b/.clang-tidy.hash
index ab526134f8..72a9967590 100644
--- a/.clang-tidy.hash
+++ b/.clang-tidy.hash
@@ -1 +1 @@
-dc8ad5472d9fb44ce1ca29a0601afd65705642799a2819704dfc8459fbaf9815
+075ed2142432dc59883bb52db8ac11270f952851d6400deae080f5468c7cb592
diff --git a/esphome/components/ethernet/ethernet_component.h b/esphome/components/ethernet/ethernet_component.h
index 3a87842315..17c84ee954 100644
--- a/esphome/components/ethernet/ethernet_component.h
+++ b/esphome/components/ethernet/ethernet_component.h
@@ -221,7 +221,7 @@ class EthernetComponent final : public Component {
   int reset_pin_{-1};
   int phy_addr_spi_{-1};
   int clock_speed_;
-  spi_host_device_t interface_{SPI3_HOST};
+  spi_host_device_t interface_{SPI2_HOST};
 #ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
   uint32_t polling_interval_{0};
 #endif
diff --git a/esphome/components/image/__init__.py b/esphome/components/image/__init__.py
index 4a5fcc385e..7db50597e6 100644
--- a/esphome/components/image/__init__.py
+++ b/esphome/components/image/__init__.py
@@ -28,7 +28,6 @@ from esphome.const import (
     CONF_URL,
 )
 from esphome.core import CORE, HexInt
-from esphome.final_validate import full_config
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -676,12 +675,16 @@ def _final_validate(config):
     :param config:
     :return:
     """
-    fv = full_config.get()
-    if "lvgl" in fv and not all(CONF_BYTE_ORDER in x for x in config):
-        config = config.copy()
-        for c in config:
-            if not c.get(CONF_BYTE_ORDER):
-                c[CONF_BYTE_ORDER] = "LITTLE_ENDIAN"
+    config = config.copy()
+    for c in config:
+        if byte_order := c.get(CONF_BYTE_ORDER):
+            if byte_order == "BIG_ENDIAN":
+                _LOGGER.warning(
+                    "The image '%s' is configured with big-endian byte order, little-endian is expected",
+                    c.get(CONF_FILE),
+                )
+        else:
+            c[CONF_BYTE_ORDER] = "LITTLE_ENDIAN"
     return config
 
 
diff --git a/esphome/components/image/image.cpp b/esphome/components/image/image.cpp
index a6f9e35e2e..5b4ed6968c 100644
--- a/esphome/components/image/image.cpp
+++ b/esphome/components/image/image.cpp
@@ -189,7 +189,7 @@ Color Image::get_rgb_pixel_(int x, int y) const {
 }
 Color Image::get_rgb565_pixel_(int x, int y) const {
   const uint8_t *pos = this->data_start_ + (x + y * this->width_) * this->bpp_ / 8;
-  uint16_t rgb565 = encode_uint16(progmem_read_byte(pos), progmem_read_byte(pos + 1));
+  uint16_t rgb565 = encode_uint16(progmem_read_byte(pos + 1), progmem_read_byte(pos));
   auto r = (rgb565 & 0xF800) >> 11;
   auto g = (rgb565 & 0x07E0) >> 5;
   auto b = rgb565 & 0x001F;
diff --git a/esphome/components/mipi_spi/display.py b/esphome/components/mipi_spi/display.py
index 42c7ec2224..364ada9046 100644
--- a/esphome/components/mipi_spi/display.py
+++ b/esphome/components/mipi_spi/display.py
@@ -195,7 +195,7 @@ def model_schema(config):
                     "big_endian", "little_endian", lower=True
                 ),
                 model.option(CONF_COLOR_DEPTH, 16): cv.one_of(*color_depth, lower=True),
-                model.option(CONF_DRAW_ROUNDING, 2): power_of_two,
+                model.option(CONF_DRAW_ROUNDING, 1): power_of_two,
                 model.option(CONF_PIXEL_MODE, DISPLAY_16BIT): cv.one_of(
                     *pixel_modes, lower=True
                 ),
@@ -297,9 +297,9 @@ def _final_validate(config):
 
         buffer_size = color_depth // 8 * width * height // frac
         # Target a buffer size of 20kB, except for large displays, which shouldn't end up here
-        fraction = min(20000.0, buffer_size // 16) / buffer_size
+        fraction = min(20000.0, buffer_size // 4) / buffer_size
         config[CONF_BUFFER_SIZE] = 1.0 / next(
-            x for x in range(2, 17) if fraction >= 1 / x
+            (x for x in range(2, 8) if fraction >= 1 / x), 8
         )
 
 
diff --git a/esphome/components/mipi_spi/mipi_spi.h b/esphome/components/mipi_spi/mipi_spi.h
index 2242be6c17..f292345893 100644
--- a/esphome/components/mipi_spi/mipi_spi.h
+++ b/esphome/components/mipi_spi/mipi_spi.h
@@ -546,13 +546,12 @@ class MipiSpiBuffer : public MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DIS
     }
     // for updates with a small buffer, we repeatedly call the writer_ function, clipping the height to a fraction of
     // the display height,
-    for (this->start_line_ = 0; this->start_line_ < this->get_height_internal();
-         this->start_line_ += this->get_height_internal() / FRACTION) {
+    auto increment = (this->get_height_internal() / FRACTION / ROUNDING) * ROUNDING;
+    for (this->start_line_ = 0; this->start_line_ < this->get_height_internal(); this->start_line_ = this->end_line_) {
 #if ESPHOME_LOG_LEVEL == ESPHOME_LOG_LEVEL_VERBOSE
       auto lap = millis();
 #endif
-      this->end_line_ =
-          clamp_at_most(this->start_line_ + this->get_height_internal() / FRACTION, this->get_height_internal());
+      this->end_line_ = clamp_at_most(this->start_line_ + increment, this->get_height_internal());
       if (this->auto_clear_enabled_) {
         this->clear();
       }
@@ -574,12 +573,13 @@ class MipiSpiBuffer : public MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DIS
       // Some chips require that the drawing window be aligned on certain boundaries
       this->x_low_ = this->x_low_ / ROUNDING * ROUNDING;
       this->y_low_ = this->y_low_ / ROUNDING * ROUNDING;
-      this->x_high_ = (this->x_high_ + ROUNDING) / ROUNDING * ROUNDING - 1;
-      this->y_high_ = (this->y_high_ + ROUNDING) / ROUNDING * ROUNDING - 1;
+      this->x_high_ = round_buffer(this->x_high_ + 1) - 1;
+      this->y_high_ = clamp_at_most(round_buffer(this->y_high_ + 1) - 1, this->end_line_ - 1);
       int w = this->x_high_ - this->x_low_ + 1;
       int h = this->y_high_ - this->y_low_ + 1;
       this->write_to_display_(this->x_low_, this->y_low_, w, h, this->buffer_, this->x_low_,
-                              this->y_low_ - this->start_line_, round_buffer(this->get_width_internal()) - w);
+                              this->y_low_ - this->start_line_,
+                              round_buffer(this->get_width_internal()) - w - this->x_low_);
       // invalidate watermarks
       this->x_low_ = this->get_width_internal();
       this->y_low_ = this->get_height_internal();
diff --git a/esphome/components/wifi/wifi_component.cpp b/esphome/components/wifi/wifi_component.cpp
index 7b31a22ed5..598aee8f66 100644
--- a/esphome/components/wifi/wifi_component.cpp
+++ b/esphome/components/wifi/wifi_component.cpp
@@ -308,6 +308,7 @@ bool CompactString::operator==(const StringRef &other) const {
 /// │  - Roaming fail (RECONNECTING on other AP): counter preserved        │
 /// └──────────────────────────────────────────────────────────────────────┘
 
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_INFO
 // Use if-chain instead of switch to avoid jump table in RODATA (wastes RAM on ESP8266)
 static const LogString *retry_phase_to_log_string(WiFiRetryPhase phase) {
   if (phase == WiFiRetryPhase::INITIAL_CONNECT)
@@ -326,6 +327,7 @@ static const LogString *retry_phase_to_log_string(WiFiRetryPhase phase) {
     return LOG_STR("RESTARTING");
   return LOG_STR("UNKNOWN");
 }
+#endif  // ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_INFO
 
 bool WiFiComponent::went_through_explicit_hidden_phase_() const {
   // If first configured network is marked hidden, we went through EXPLICIT_HIDDEN phase
diff --git a/esphome/components/wireguard/__init__.py b/esphome/components/wireguard/__init__.py
index 4fdb256d0c..e128b8476d 100644
--- a/esphome/components/wireguard/__init__.py
+++ b/esphome/components/wireguard/__init__.py
@@ -137,7 +137,7 @@ async def to_code(config):
     # the '+1' modifier is relative to the device's own address that will
     # be automatically added to the provided list.
     cg.add_build_flag(f"-DCONFIG_WIREGUARD_MAX_SRC_IPS={len(allowed_ips) + 1}")
-    cg.add_library("droscy/esp_wireguard", "0.4.4")
+    cg.add_library("droscy/esp_wireguard", "0.4.5")
 
     await cg.register_component(var, config)
 
diff --git a/esphome/config_validation.py b/esphome/config_validation.py
index e6b0cb7ee2..fbafc5cb07 100644
--- a/esphome/config_validation.py
+++ b/esphome/config_validation.py
@@ -943,7 +943,26 @@ def time_period_in_minutes_(value):
 def update_interval(value):
     if value == "never":
         return TimePeriodMilliseconds(milliseconds=SCHEDULER_DONT_RUN)
-    return positive_time_period_milliseconds(value)
+    result = positive_time_period_milliseconds(value)
+    # 0ms was historically (mis)used as a pseudo-loop() mechanism for
+    # PollingComponents. Under the hood it calls set_interval(0), which
+    # causes Scheduler::call() to spin (WDT reset in the field). Coerce
+    # to 1ms so existing configs keep working at ~1kHz instead of
+    # spinning. Don't hard-fail so configs don't break on upgrade;
+    # authors should migrate to HighFrequencyLoopRequester (C++) for
+    # true run-every-loop behaviour.
+    if result.total_milliseconds == 0:
+        _LOGGER.warning(
+            "update_interval of 0ms is not supported - coercing to 1ms. "
+            "A literal 0ms schedule would spin the main loop (the scheduled "
+            "item would always be due, so the scheduler would never yield "
+            "back) and trigger a watchdog reset. Set update_interval to a "
+            "non-zero value such as 1ms or higher. (Custom C++ components "
+            "that need true run-every-loop behaviour should override loop() "
+            "with HighFrequencyLoopRequester instead.)"
+        )
+        return TimePeriodMilliseconds(milliseconds=1)
+    return result
 
 
 time_period = Any(time_period_str_unit, time_period_str_colon, time_period_dict)
diff --git a/esphome/core/application.h b/esphome/core/application.h
index c5b6a87817..0ecc0999e0 100644
--- a/esphome/core/application.h
+++ b/esphome/core/application.h
@@ -340,6 +340,9 @@ class Application {
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
   /// Wake from ISR (ESP32 and LibreTiny).
   static void IRAM_ATTR wake_loop_isrsafe(BaseType_t *px) { esphome::wake_loop_isrsafe(px); }
+#elif defined(USE_ESP8266)
+  /// Wake from ISR (ESP8266). No task_woken arg — no FreeRTOS. Caller must be IRAM_ATTR.
+  static void IRAM_ATTR ESPHOME_ALWAYS_INLINE wake_loop_isrsafe() { esphome::wake_loop_isrsafe(); }
 #endif
 
   /// Wake from any context (ISR, thread, callback).
diff --git a/esphome/core/base_automation.h b/esphome/core/base_automation.h
index 11133d3973..17f937d10d 100644
--- a/esphome/core/base_automation.h
+++ b/esphome/core/base_automation.h
@@ -205,7 +205,9 @@ template<typename... Ts> class DelayAction : public Action<Ts...>, public Compon
     } else {
       // For delays with arguments, capture by value to preserve argument values
       // Arguments must be copied because original references may be invalid after delay
-      auto f = [this, x...]() { this->play_next_(x...); };
+      // `mutable` is required so captured copies of non-const reference args (e.g. std::string&)
+      // are passed as non-const lvalues to play_next_(const Ts&...) where Ts may be `T&`
+      auto f = [this, x...]() mutable { this->play_next_(x...); };
       App.scheduler.set_timer_common_(this, Scheduler::SchedulerItem::TIMEOUT, Scheduler::NameType::NUMERIC_ID_INTERNAL,
                                       nullptr, static_cast<uint32_t>(InternalSchedulerID::DELAY_ACTION),
                                       this->delay_.value(x...), std::move(f),
diff --git a/esphome/core/scheduler.cpp b/esphome/core/scheduler.cpp
index 168230c274..7e6ad19ac7 100644
--- a/esphome/core/scheduler.cpp
+++ b/esphome/core/scheduler.cpp
@@ -152,7 +152,7 @@ void HOT Scheduler::set_timer_common_(Component *component, SchedulerItem::Type
   // the intended mechanism for running fast in the main loop. Zero-delay
   // timeouts (defer) remain legitimate one-shots and are not affected.
   if (type == SchedulerItem::INTERVAL && delay == 0) [[unlikely]] {
-    ESP_LOGW(TAG, "[%s] set_interval(0) is misuse — coercing to 1ms. Use HighFrequencyLoopRequester instead.",
+    ESP_LOGE(TAG, "[%s] set_interval(0) would spin main loop - coercing to 1ms (use HighFrequencyLoopRequester)",
              component ? LOG_STR_ARG(component->get_component_log_str()) : LOG_STR_LITERAL("?"));
     delay = 1;
   }
diff --git a/esphome/core/wake.h b/esphome/core/wake.h
index 5733ee65f6..77a38d429e 100644
--- a/esphome/core/wake.h
+++ b/esphome/core/wake.h
@@ -77,6 +77,9 @@ void wake_loop_any_context();
 /// Non-ISR: always inline.
 inline void wake_loop_threadsafe() { wake_loop_impl(); }
 
+/// ISR-safe: no task_woken arg because ESP8266 has no FreeRTOS. Caller must be IRAM_ATTR.
+inline void ESPHOME_ALWAYS_INLINE wake_loop_isrsafe() { wake_loop_impl(); }
+
 namespace internal {
 inline void wakeable_delay(uint32_t ms) {
   if (ms == 0) {
diff --git a/platformio.ini b/platformio.ini
index 3897db83e1..e2c7e2b097 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -118,7 +118,7 @@ lib_deps =
     ESP8266HTTPClient                     ; http_request (Arduino built-in)
     ESP8266mDNS                           ; mdns (Arduino built-in)
     DNSServer                             ; captive_portal (Arduino built-in)
-    droscy/esp_wireguard@0.4.4            ; wireguard
+    droscy/esp_wireguard@0.4.5            ; wireguard
     lvgl/lvgl@9.5.0                       ; lvgl
 
 build_flags =
@@ -154,7 +154,7 @@ lib_deps =
     DNSServer                            ; captive_portal (Arduino built-in)
     makuna/NeoPixelBus@2.8.0             ; neopixelbus
     esphome/ESP32-audioI2S@2.3.0         ; i2s_audio
-    droscy/esp_wireguard@0.4.4           ; wireguard
+    droscy/esp_wireguard@0.4.5           ; wireguard
     kahrendt/ESPMicroSpeechFeatures@1.1.0  ; micro_wake_word
 
 build_flags =
@@ -176,7 +176,7 @@ platform_packages =
 framework = espidf
 lib_deps =
     ${common:idf.lib_deps}
-    droscy/esp_wireguard@0.4.4              ; wireguard
+    droscy/esp_wireguard@0.4.5              ; wireguard
     kahrendt/ESPMicroSpeechFeatures@1.1.0   ; micro_wake_word
     tonia/HeatpumpIR@1.0.41                 ; heatpumpir
 build_flags =
@@ -221,7 +221,7 @@ lib_compat_mode = soft
 lib_deps =
     bblanchon/ArduinoJson@7.4.2           ; json
     ESP32Async/ESPAsyncWebServer@3.9.6    ; web_server_base
-    droscy/esp_wireguard@0.4.4            ; wireguard
+    droscy/esp_wireguard@0.4.5            ; wireguard
     lvgl/lvgl@9.5.0                       ; lvgl
 build_flags =
     ${common:arduino.build_flags}
diff --git a/tests/component_tests/mipi_spi/test_final_validate.py b/tests/component_tests/mipi_spi/test_final_validate.py
new file mode 100644
index 0000000000..8c45b47752
--- /dev/null
+++ b/tests/component_tests/mipi_spi/test_final_validate.py
@@ -0,0 +1,185 @@
+"""Tests for the _final_validate buffer size calculation in mipi_spi."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from esphome.components.display import CONF_SHOW_TEST_CARD
+from esphome.components.esp32 import KEY_BOARD, KEY_VARIANT, VARIANT_ESP32
+from esphome.components.mipi_spi.display import CONFIG_SCHEMA, FINAL_VALIDATE_SCHEMA
+from esphome.const import CONF_BUFFER_SIZE, PlatformFramework
+from esphome.types import ConfigType
+from tests.component_tests.types import SetCoreConfigCallable
+
+
+def _validated(config: ConfigType) -> ConfigType:
+    """Run the component config schema followed by the final validation."""
+    config = CONFIG_SCHEMA(config)
+    FINAL_VALIDATE_SCHEMA(config)
+    return config
+
+
+def _custom_config(
+    width: int,
+    height: int,
+    color_depth: str | int | None = None,
+    **extra: Any,
+) -> ConfigType:
+    """Build a minimal valid custom-model config with the given dimensions."""
+    config: ConfigType = {
+        "model": "custom",
+        "dc_pin": 18,
+        "dimensions": {"width": width, "height": height},
+        "init_sequence": [[0xA0, 0x01]],
+    }
+    if color_depth is not None:
+        config["color_depth"] = color_depth
+    config.update(extra)
+    return config
+
+
+# The auto buffer-size selection inside _final_validate targets ~20 kB of
+# pixel buffer. For a buffer of ``depth_bytes * width * height``, it picks the
+# smallest integer ``x`` in range(2, 8) such that
+# ``min(20000, buffer // 4) / buffer >= 1 / x`` (falling back to ``x = 8``).
+# The test cases below cover the full range of possible outcomes (1/4 .. 1/8).
+@pytest.mark.parametrize(
+    ("width", "height", "color_depth", "expected"),
+    [
+        # 16-bit color depth -- buffer = 2 * width * height
+        # 128*160*2 = 40960 B -> fraction = 10240/40960 = 0.25 -> x = 4
+        pytest.param(128, 160, "16bit", 1.0 / 4, id="16bit_tiny"),
+        # 200*224*2 = 89600 B -> fraction = 20000/89600 ≈ 0.2232 -> x = 5
+        pytest.param(200, 224, "16bit", 1.0 / 5, id="16bit_small"),
+        # 240*224*2 = 107520 B -> fraction ≈ 0.1860 -> x = 6
+        pytest.param(240, 224, "16bit", 1.0 / 6, id="16bit_medium"),
+        # 200*320*2 = 128000 B -> fraction = 0.15625 -> x = 7
+        pytest.param(200, 320, "16bit", 1.0 / 7, id="16bit_large"),
+        # 240*320*2 = 153600 B -> fraction ≈ 0.1302 -> default x = 8
+        pytest.param(240, 320, "16bit", 1.0 / 8, id="16bit_xlarge"),
+        # 320*480*2 = 307200 B -> fraction ≈ 0.0651 -> default x = 8
+        pytest.param(320, 480, "16bit", 1.0 / 8, id="16bit_huge"),
+        # 8-bit color depth -- buffer = width * height
+        # 320*240 = 76800 B -> fraction = 19200/76800 = 0.25 -> x = 4
+        pytest.param(320, 240, "8bit", 1.0 / 4, id="8bit_tiny"),
+        # 400*224 = 89600 B -> fraction ≈ 0.2232 -> x = 5
+        pytest.param(400, 224, "8bit", 1.0 / 5, id="8bit_small"),
+        # 480*224 = 107520 B -> fraction ≈ 0.1860 -> x = 6
+        pytest.param(480, 224, "8bit", 1.0 / 6, id="8bit_medium"),
+        # 400*320 = 128000 B -> fraction = 0.15625 -> x = 7
+        pytest.param(400, 320, "8bit", 1.0 / 7, id="8bit_large"),
+        # 480*320 = 153600 B -> fraction ≈ 0.1302 -> default x = 8
+        pytest.param(480, 320, "8bit", 1.0 / 8, id="8bit_xlarge"),
+    ],
+)
+def test_buffer_size_auto_selected(
+    width: int,
+    height: int,
+    color_depth: str,
+    expected: float,
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    """Without PSRAM or an explicit buffer_size, a fraction is chosen from the display size.
+
+    Without any drawing method and without LVGL, final validation also auto-enables
+    ``show_test_card``, which in turn makes the component require a buffer and therefore
+    triggers the buffer-size selection path.
+    """
+    set_core_config(
+        PlatformFramework.ESP32_IDF,
+        platform_data={KEY_BOARD: "esp32dev", KEY_VARIANT: VARIANT_ESP32},
+    )
+
+    config = _validated(_custom_config(width, height, color_depth))
+
+    # Sanity check: final validation should have enabled the test card for us,
+    # which is what causes the buffer-size calculation to actually run.
+    assert config.get(CONF_SHOW_TEST_CARD) is True
+    assert config[CONF_BUFFER_SIZE] == pytest.approx(expected)
+
+
+@pytest.mark.parametrize(
+    "buffer_size",
+    [0.125, 0.25, 0.5, 1.0],
+    ids=["one_eighth", "one_quarter", "half", "full"],
+)
+def test_explicit_buffer_size_is_preserved(
+    buffer_size: float,
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    """An explicitly configured buffer_size is never overridden by final validation."""
+    set_core_config(
+        PlatformFramework.ESP32_IDF,
+        platform_data={KEY_BOARD: "esp32dev", KEY_VARIANT: VARIANT_ESP32},
+    )
+
+    config = _validated(
+        _custom_config(240, 320, "16bit", buffer_size=buffer_size),
+    )
+
+    assert config[CONF_BUFFER_SIZE] == pytest.approx(buffer_size)
+
+
+def test_buffer_size_not_set_when_psram_enabled(
+    set_core_config: SetCoreConfigCallable,
+    set_component_config,
+) -> None:
+    """When PSRAM is enabled the auto buffer-size selection is skipped."""
+    set_core_config(
+        PlatformFramework.ESP32_IDF,
+        platform_data={KEY_BOARD: "esp32dev", KEY_VARIANT: VARIANT_ESP32},
+    )
+    # Presence of the psram domain in the full config is what _final_validate checks.
+    set_component_config("psram", True)
+
+    config = _validated(_custom_config(240, 320, "16bit"))
+
+    assert CONF_BUFFER_SIZE not in config
+
+
+def test_buffer_size_not_set_when_buffer_not_required(
+    set_core_config: SetCoreConfigCallable,
+    set_component_config,
+) -> None:
+    """With LVGL present and no drawing methods, no buffer fraction is chosen.
+
+    LVGL suppresses the automatic show_test_card injection, which means
+    ``requires_buffer`` is False and the early-return branch fires.
+    """
+    set_core_config(
+        PlatformFramework.ESP32_IDF,
+        platform_data={KEY_BOARD: "esp32dev", KEY_VARIANT: VARIANT_ESP32},
+    )
+    set_component_config("lvgl", [])
+
+    config = _validated(_custom_config(240, 320, "16bit"))
+
+    assert CONF_BUFFER_SIZE not in config
+    # And no test card should have been auto-enabled either.
+    assert not config.get(CONF_SHOW_TEST_CARD)
+
+
+def test_buffer_size_selected_when_lvgl_with_test_card(
+    set_core_config: SetCoreConfigCallable,
+    set_component_config,
+) -> None:
+    """LVGL present + an explicit drawing method still triggers buffer sizing.
+
+    When LVGL is enabled, ``show_test_card`` is not injected automatically,
+    but users can still request it explicitly -- in that case ``requires_buffer``
+    is True and the buffer-size heuristic still runs.
+    """
+    set_core_config(
+        PlatformFramework.ESP32_IDF,
+        platform_data={KEY_BOARD: "esp32dev", KEY_VARIANT: VARIANT_ESP32},
+    )
+    set_component_config("lvgl", [])
+
+    # 128x160 @ 16bit -> expected 1/4 (see test_buffer_size_auto_selected).
+    config = _validated(
+        _custom_config(128, 160, "16bit", show_test_card=True),
+    )
+
+    assert config[CONF_BUFFER_SIZE] == pytest.approx(1.0 / 4)
diff --git a/tests/components/ethernet/test.esp32-c3-idf.yaml b/tests/components/ethernet/test.esp32-c3-idf.yaml
new file mode 100644
index 0000000000..b7b95875c6
--- /dev/null
+++ b/tests/components/ethernet/test.esp32-c3-idf.yaml
@@ -0,0 +1,19 @@
+ethernet:
+  type: W5500
+  clk_pin: 6
+  mosi_pin: 7
+  miso_pin: 2
+  cs_pin: 10
+  interrupt_pin: 3
+  reset_pin: 4
+  clock_speed: 10Mhz
+  manual_ip:
+    static_ip: 192.168.178.56
+    gateway: 192.168.178.1
+    subnet: 255.255.255.0
+  domain: .local
+  mac_address: "02:AA:BB:CC:DD:01"
+  on_connect:
+    - logger.log: "Ethernet connected!"
+  on_disconnect:
+    - logger.log: "Ethernet disconnected!"
diff --git a/tests/components/ethernet/test-lan8720.esp32-idf.yaml b/tests/components/ethernet/test.esp32-idf.yaml
similarity index 100%
rename from tests/components/ethernet/test-lan8720.esp32-idf.yaml
rename to tests/components/ethernet/test.esp32-idf.yaml
diff --git a/tests/components/http_request/http_request.yaml b/tests/components/http_request/http_request.yaml
index 13ca5ceba0..ef67671c91 100644
--- a/tests/components/http_request/http_request.yaml
+++ b/tests/components/http_request/http_request.yaml
@@ -45,6 +45,11 @@ esphome:
                   args:
                     - response->status_code
                     - body.c_str()
+              - delay: 1s
+              - logger.log:
+                  format: "After delay, body still: %s"
+                  args:
+                    - body.c_str()
 
 http_request:
   useragent: esphome/tagreader
diff --git a/tests/integration/fixtures/scheduler_interval_zero_coerced.yaml b/tests/integration/fixtures/scheduler_interval_zero_coerced.yaml
new file mode 100644
index 0000000000..13be55d617
--- /dev/null
+++ b/tests/integration/fixtures/scheduler_interval_zero_coerced.yaml
@@ -0,0 +1,27 @@
+esphome:
+  name: sched-interval-zero
+
+host:
+api:
+logger:
+  level: DEBUG
+
+globals:
+  - id: fire_count
+    type: int
+    initial_value: "0"
+
+interval:
+  # Deliberately configure 0ms — this path goes through the C++
+  # Scheduler::set_timer_common_ coercion (not the Python cv.update_interval
+  # path, since interval: doesn't call cv.update_interval — it's an intervals
+  # component schema, not a PollingComponent's update_interval).
+  # Expected: scheduler coerces to 1ms at registration, emits ESP_LOGE,
+  # fires at ~1kHz instead of spinning.
+  - interval: 0ms
+    then:
+      - lambda: |-
+          id(fire_count) += 1;
+          if (id(fire_count) == 50) {
+            ESP_LOGI("test", "ZERO_INTERVAL_50_FIRES_REACHED");
+          }
diff --git a/tests/integration/test_scheduler_interval_zero_coerced.py b/tests/integration/test_scheduler_interval_zero_coerced.py
new file mode 100644
index 0000000000..f71c0f7281
--- /dev/null
+++ b/tests/integration/test_scheduler_interval_zero_coerced.py
@@ -0,0 +1,67 @@
+"""Test that Scheduler::set_timer_common_ coerces interval=0 to 1ms.
+
+Regression test for the scheduler busy-loop when interval=0 was passed
+literally. Without the coercion, Scheduler::call() would spin forever
+because the item's next_execution == now_64 after re-scheduling, failing
+the loop's `> now_64` break condition. The device would fail to yield
+back to the main loop and trigger a WDT reset.
+
+With the coercion, interval=0 becomes interval=1 and the scheduler
+fires at ~1kHz (bounded by the loop), the main loop continues to run,
+and the device stays responsive to API calls.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_scheduler_interval_zero_coerced(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """interval=0ms must be coerced to 1ms and not starve the main loop."""
+    loop = asyncio.get_running_loop()
+    reached_50: asyncio.Future[None] = loop.create_future()
+    coerce_warning: asyncio.Future[None] = loop.create_future()
+
+    def on_log_line(line: str) -> None:
+        if "ZERO_INTERVAL_50_FIRES_REACHED" in line and not reached_50.done():
+            reached_50.set_result(None)
+        if "would spin main loop" in line and not coerce_warning.done():
+            coerce_warning.set_result(None)
+
+    async with (
+        run_compiled(yaml_config, line_callback=on_log_line),
+        api_client_connected() as client,
+    ):
+        # The API-client connection itself is evidence that the main loop
+        # is not starved — if set_interval(0) were spinning we could not
+        # get here at all.
+        device_info = await client.device_info()
+        assert device_info is not None
+        assert device_info.name == "sched-interval-zero"
+
+        # Coerce warning must fire at registration
+        try:
+            await asyncio.wait_for(coerce_warning, timeout=5.0)
+        except TimeoutError:
+            pytest.fail("Expected coerce warning 'would spin main loop' not seen")
+
+        # The coerced 1ms interval should fire 50 times quickly — this
+        # confirms the callback actually runs (not just registered) and the
+        # scheduler yields back to the main loop each time.
+        try:
+            await asyncio.wait_for(reached_50, timeout=5.0)
+        except TimeoutError:
+            pytest.fail(
+                "Coerced interval=0→1ms did not reach 50 fires within 5s, "
+                "which would indicate either the coercion failed or the "
+                "main loop is still being starved."
+            )
diff --git a/tests/unit_tests/test_config_validation.py b/tests/unit_tests/test_config_validation.py
index ac84ce7cc8..f038272d8b 100644
--- a/tests/unit_tests/test_config_validation.py
+++ b/tests/unit_tests/test_config_validation.py
@@ -24,6 +24,7 @@ from esphome.const import (
     PLATFORM_LN882X,
     PLATFORM_RP2040,
     PLATFORM_RTL87XX,
+    SCHEDULER_DONT_RUN,
 )
 from esphome.core import CORE, HexInt, Lambda
 
@@ -765,3 +766,30 @@ def test_percentage_validators__raw_number_above_one_without_percent_sign(
         config_validation.unbounded_percentage(value)
     with pytest.raises(Invalid, match="percent sign"):
         config_validation.unbounded_possibly_negative_percentage(value)
+
+
+def test_update_interval__coerces_zero_to_one_ms(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """update_interval: 0ms must be coerced to 1ms (not rejected) because a
+    literal 0ms schedule causes Scheduler::call() to spin. Coercion keeps
+    existing configs compiling on upgrade while emitting a user-facing
+    warning that directs them to set a non-zero value."""
+    with caplog.at_level("WARNING"):
+        result = config_validation.update_interval("0ms")
+    assert result.total_milliseconds == 1
+    assert "update_interval of 0ms is not supported" in caplog.text
+    assert "1ms" in caplog.text
+
+
+def test_update_interval__preserves_nonzero_values() -> None:
+    """Non-zero update_interval values must pass through unchanged."""
+    assert config_validation.update_interval("1ms").total_milliseconds == 1
+    assert config_validation.update_interval("50ms").total_milliseconds == 50
+    assert config_validation.update_interval("60s").total_milliseconds == 60000
+
+
+def test_update_interval__never_passes_through() -> None:
+    """update_interval: never must still map to SCHEDULER_DONT_RUN."""
+    result = config_validation.update_interval("never")
+    assert result.total_milliseconds == SCHEDULER_DONT_RUN