Derive the registry archive path in one place

Prefer the landed archive while waiting, cap credited bytes, and give the registry wait a deadline
Share the lock wait with the ESP-IDF registry prefetch and trim the docstrings
2026-09-06 04:56:04 +00:00 · 2026-09-05 15:19:57 +02:00 · 2026-09-05 14:59:01 +02:00 · 2026-09-05 14:18:21 +02:00 · 2026-09-05 14:05:37 +02:00 · 2026-09-04 19:05:36 -04:00
166 changed files with 2928 additions and 1176 deletions
@@ -374,8 +374,9 @@ jobs:
      - name: Install apt packages (cached)
        # ccache speeds up the host compiles. A cache hit never touches apt
        # (mirror outages cannot hang the job); the timeout bounds the cold
-        # path. Packages and version must match seed-apt-cache exactly;
-        # libsdl2-dev is unused here and carried only for cache-key parity.
+        # path. Packages and version must match seed-apt-cache exactly.
+        # libsdl2-dev is needed by the headless display tests, which capture
+        # screenshots.
        timeout-minutes: 10
        uses: awalsh128/cache-apt-pkgs-action@553a35bb8ebd9fcabcb1c9451aa4c98e1b4ca8a9 # v1.6.3
        with:
@@ -438,6 +439,16 @@ jobs:
          echo "Bucket ${{ matrix.bucket.name }}: running ${#test_files[@]} integration tests"
          pytest -vv --no-cov --tb=native --durations=30 -n auto --dist worksteal \
            --junitxml=junit-integration.xml "${test_files[@]}"
+      - name: Upload test artifacts
+        # Tests that compare rendered output write the image they actually got here, so a
+        # failure can be looked at without reproducing the whole build locally.
+        if: failure()
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: integration-test-artifacts-${{ matrix.bucket.name }}
+          path: test_artifacts/
+          if-no-files-found: ignore
+          retention-days: 7
      - name: Upload junit timings
        # Consumed by sync-integration-durations.yml through
        # script/update_integration_test_durations.py; only full matrix dev
@@ -137,6 +137,8 @@ config/
 !tests/component_tests/**/config/
 tests/build/
 tests/.esphome/
+# Output kept by failing tests for inspection; uploaded by CI
+test_artifacts/
 /.temp-clang-tidy.cpp
 /.temp/
 .pio/
@@ -496,6 +496,7 @@ esphome/components/sm2335/* @Cossid
 esphome/components/sml/* @alengwenus
 esphome/components/smt100/* @piechade
 esphome/components/sn74hc165/* @jesserockz
+esphome/components/snapshot/* @clydebarrow
 esphome/components/socket/* @esphome/core
 esphome/components/sonoff_d1/* @anatoly-savchenkov
 esphome/components/sound_level/* @kahrendt
@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.

-PROJECT_NUMBER         = 2026.9.0-dev
+PROJECT_NUMBER         = 2026.10.0-dev

 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -22,7 +22,7 @@ RUN \
    -r /requirements.txt

 # Install the ESPHome Device Builder dashboard.
-RUN uv pip install --no-cache-dir esphome-device-builder==1.13.1
+RUN uv pip install --no-cache-dir esphome-device-builder==1.14.0

 RUN \
    platformio settings set enable_telemetry No \
@@ -44,8 +44,7 @@ def get_arduino8266_tools_path() -> Path:
    return tools_cache_path(*ARDUINO8266_TOOLS_CACHE)


-# 3.1.1 rather than 3.1.0: the registry has no package for 3.1.0, and the
-# encoder below cannot name 3.0.0/3.0.1 either (see its docstring)
+# 3.1.1 rather than 3.1.0: the registry has no packages for 3.0.0, 3.0.1 or 3.1.0
 MIN_FRAMEWORK_VERSION = Version(3, 1, 1)


@@ -53,20 +52,16 @@ def framework_package_version(ver: Version) -> str:
    """Map an Arduino core version to its registry package version (3.1.2 ->
    3.30102.0; the leading 3 is the package major).

-    Exact registry names only for cores > 2.6.2 and >= 3.0.2; callers floor
-    at MIN_FRAMEWORK_VERSION.
+    Exact registry names for 3.x cores; callers floor at MIN_FRAMEWORK_VERSION.
    """
    if ver.major > 3:
        raise EsphomeError(
            f"Arduino core {ver} is not supported yet; "
            "the newest known core series is 3.x"
        )
-    if ver <= Version(2, 6, 2):
-        # Cores <= 2.6.2 use the older 1.x/2.x package-major encodings (same
-        # boundary as _format_framework_arduino_version's era guard)
+    if ver.major < 3:
        raise EsphomeError(
-            f"Arduino core {ver} uses an older package encoding than this "
-            "helper implements (newer than 2.6.2)"
+            f"Arduino core {ver} is not supported; ESPHome requires core 3.x"
        )
    return f"3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"

@@ -3,6 +3,7 @@ import logging
 import esphome.codegen as cg
 from esphome.components import web_server_base, wifi
 from esphome.components.web_server_base import CONF_WEB_SERVER_BASE_ID
+from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_AP,
@@ -14,6 +15,7 @@ from esphome.const import (
    PLATFORM_LN882X,
    PLATFORM_RP2,
    PLATFORM_RTL87XX,
+    PlatformFramework,
 )
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
@@ -74,7 +76,17 @@ def _final_validate(config: ConfigType) -> None:
            "Add 'ap:' to your WiFi configuration to enable the captive portal."
        )

-    web_server_base.consume_captive_dns_sockets(config, "captive_portal")
+    # Register socket needs for DNS server and additional HTTP connections
+    # - 1 UDP socket for DNS server
+    # - 3 TCP sockets for captive portal detection probes + configuration requests
+    #   OS captive portal detection makes multiple probe requests that stay in TIME_WAIT.
+    #   Need headroom for actual user configuration requests.
+    #   LRU purging will reclaim idle sockets to prevent exhaustion from repeated attempts.
+    # The listening socket is registered by web_server_base (shared HTTP server).
+    from esphome.components import socket
+
+    socket.consume_sockets(3, "captive_portal")(config)
+    socket.consume_sockets(1, "captive_portal", socket.SocketType.UDP)(config)


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -94,4 +106,16 @@ async def to_code(config: ConfigType) -> None:
    if config[CONF_COMPRESSION] == "gzip":
        cg.add_define("USE_CAPTIVE_PORTAL_GZIP")

-    web_server_base.add_captive_dns_library()
+    if CORE.using_arduino and (CORE.is_esp8266 or CORE.is_libretiny or CORE.is_rp2):
+        cg.add_library("DNSServer", None)
+
+
+# Only compile the ESP-IDF DNS server when using ESP-IDF framework
+FILTER_SOURCE_FILES = filter_source_files_from_platform(
+    {
+        "dns_server_esp32_idf.cpp": {
+            PlatformFramework.ESP32_ARDUINO,
+            PlatformFramework.ESP32_IDF,
+        },
+    }
+)
@@ -102,7 +102,17 @@ void CaptivePortal::start() {
    this->base_->add_handler_without_auth(this);
  }

-  this->dns_.start(wifi::global_wifi_component->wifi_soft_ap_ip());
+  network::IPAddress ip = wifi::global_wifi_component->wifi_soft_ap_ip();
+
+#if defined(USE_ESP32)
+  // Create DNS server instance for ESP-IDF
+  this->dns_server_ = make_unique<DNSServer>();
+  this->dns_server_->start(ip);
+#elif defined(USE_ARDUINO)
+  this->dns_server_ = make_unique<DNSServer>();
+  this->dns_server_->setErrorReplyCode(DNSReplyCode::NoError);
+  this->dns_server_->start(53, ESPHOME_F("*"), ip);
+#endif

  this->initialized_ = true;
  this->active_ = true;
@@ -1,11 +1,16 @@
 #pragma once
 #include "esphome/core/defines.h"
 #ifdef USE_CAPTIVE_PORTAL
+#include <memory>
+#if defined(USE_ESP32)
+#include "dns_server_esp32_idf.h"
+#elif defined(USE_ARDUINO)
+#include <DNSServer.h>
+#endif
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
 #include "esphome/components/web_server_base/web_server_base.h"
-#include "esphome/components/web_server_base/captive_dns.h"

 namespace esphome::captive_portal {

@@ -14,7 +19,17 @@ class CaptivePortal final : public AsyncWebHandler, public Component {
  CaptivePortal(web_server_base::WebServerBase *base);
  void setup() override;
  void dump_config() override;
-  void loop() override { this->dns_.loop(); }
+  void loop() override {
+#if defined(USE_ESP32)
+    if (this->dns_server_ != nullptr) {
+      this->dns_server_->process_next_request();
+    }
+#elif defined(USE_ARDUINO)
+    if (this->dns_server_ != nullptr) {
+      this->dns_server_->processNextRequest();
+    }
+#endif
+  }
  float get_setup_priority() const override;
  void start();
  bool is_active() const { return this->active_; }
@@ -22,7 +37,10 @@ class CaptivePortal final : public AsyncWebHandler, public Component {
    this->active_ = false;
    this->disable_loop();  // Stop processing DNS requests
    this->base_->deinit();
-    this->dns_.stop();
+    if (this->dns_server_ != nullptr) {
+      this->dns_server_->stop();
+      this->dns_server_ = nullptr;
+    }
  }

  bool canHandle(AsyncWebServerRequest *request) const override {
@@ -42,7 +60,9 @@ class CaptivePortal final : public AsyncWebHandler, public Component {
  web_server_base::WebServerBase *base_;
  bool initialized_{false};
  bool active_{false};
-  web_server_base::CaptiveDNS dns_;
+#if defined(USE_ARDUINO) || defined(USE_ESP32)
+  std::unique_ptr<DNSServer> dns_server_{nullptr};
+#endif
 };

 extern CaptivePortal *global_captive_portal;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -1,5 +1,5 @@
 #include "dns_server_esp32_idf.h"
-#if defined(USE_ESP32) && (defined(USE_CAPTIVE_PORTAL) || defined(USE_WEBSERVER_CAPTIVE))
+#ifdef USE_ESP32

 #include "esphome/core/log.h"
 #include "esphome/core/hal.h"
@@ -7,9 +7,9 @@
 #include <lwip/sockets.h>
 #include <lwip/inet.h>

-namespace esphome::web_server_base {
+namespace esphome::captive_portal {

-static const char *const TAG = "web_server_base.dns";
+static const char *const TAG = "captive_portal.dns";

 // DNS constants
 static constexpr uint16_t DNS_PORT = 53;
@@ -202,6 +202,6 @@ void DNSServer::process_next_request() {
  }
 }

-}  // namespace esphome::web_server_base
+}  // namespace esphome::captive_portal

-#endif  // USE_ESP32 && (USE_CAPTIVE_PORTAL || USE_WEBSERVER_CAPTIVE)
+#endif  // USE_ESP32
@@ -1,15 +1,11 @@
 #pragma once
-#include "esphome/core/defines.h"
-// Small DNS server that answers every query with the access point address, so a
-// phone joining the AP opens the captive portal or web_server page on its own.
-// Shared by captive_portal and the web_server AP mode.
-#if defined(USE_ESP32) && (defined(USE_CAPTIVE_PORTAL) || defined(USE_WEBSERVER_CAPTIVE))
+#ifdef USE_ESP32

 #include "esphome/core/helpers.h"
 #include "esphome/components/network/ip_address.h"
 #include "esphome/components/socket/socket.h"

-namespace esphome::web_server_base {
+namespace esphome::captive_portal {

 class DNSServer {
 public:
@@ -31,6 +27,6 @@ class DNSServer {
  uint8_t buffer_[DNS_BUFFER_SIZE];
 };

-}  // namespace esphome::web_server_base
+}  // namespace esphome::captive_portal

-#endif  // USE_ESP32 && (USE_CAPTIVE_PORTAL || USE_WEBSERVER_CAPTIVE)
+#endif  // USE_ESP32
@@ -368,8 +368,8 @@ optional<ClimateDeviceRestoreState> Climate::restore_state_() {
 }

 void Climate::save_state_(const ClimateTraits &traits) {
-#if (defined(USE_ESP32) || (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0))) && \
-    !defined(CLANG_TIDY)
+#if (defined(USE_ESP32) || defined(USE_ESP8266)) && !defined(CLANG_TIDY)
+#pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wclass-memaccess"
 #define TEMP_IGNORE_MEMACCESS
 #endif
@@ -100,7 +100,6 @@ bool CM1106Component::cm1106_write_command_(const uint8_t *command, size_t comma
 void CM1106Component::dump_config() {
  ESP_LOGCONFIG(TAG, "CM1106:");
  LOG_SENSOR("  ", "CO2", this->co2_sensor_);
-  this->check_uart_settings(9600);
  if (this->is_failed()) {
    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
  }
@@ -46,6 +46,14 @@ CONFIG_SCHEMA = (
    .extend(uart.UART_DEVICE_SCHEMA)
 )

+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "cm1106",
+    baud_rate=9600,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+

 async def to_code(config: ConfigType) -> None:
    """Code generation entry point."""
@@ -58,7 +58,6 @@ void CSE7761Component::dump_config() {
    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
  }
  LOG_UPDATE_INTERVAL(this);
-  this->check_uart_settings(38400, 1, uart::UART_CONFIG_PARITY_EVEN, 8);
 }

 void CSE7761Component::update() {
@@ -68,7 +68,13 @@ CONFIG_SCHEMA = (
 )

 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "cse7761", baud_rate=38400, require_rx=True, require_tx=True
+    "cse7761",
+    baud_rate=38400,
+    require_rx=True,
+    require_tx=True,
+    data_bits=8,
+    parity="EVEN",
+    stop_bits=1,
 )


@@ -255,7 +255,6 @@ void CSE7766Component::dump_config() {
  LOG_SENSOR("  ", "Apparent Power", this->apparent_power_sensor_);
  LOG_SENSOR("  ", "Reactive Power", this->reactive_power_sensor_);
  LOG_SENSOR("  ", "Power Factor", this->power_factor_sensor_);
-  this->check_uart_settings(4800, 1, uart::UART_CONFIG_PARITY_EVEN);
 }

 }  // namespace esphome::cse7766
@@ -84,7 +84,12 @@ CONFIG_SCHEMA = (
    .extend(cv.COMPONENT_SCHEMA)
 )
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "cse7766", baud_rate=4800, parity="EVEN", require_rx=True
+    "cse7766",
+    baud_rate=4800,
+    require_rx=True,
+    data_bits=8,
+    parity="EVEN",
+    stop_bits=1,
 )


@@ -26,6 +26,14 @@ CONFIG_SCHEMA = (
    .extend(cv.polling_component_schema("30s"))
 )

+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "daly_bms",
+    baud_rate=9600,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+

 async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
@@ -22,10 +22,7 @@ static const uint8_t DALY_REQUEST_TEMPERATURE = 0x96;

 void DalyBmsComponent::setup() { this->next_request_ = 1; }

-void DalyBmsComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "Daly BMS:");
-  this->check_uart_settings(9600);
-}
+void DalyBmsComponent::dump_config() { ESP_LOGCONFIG(TAG, "Daly BMS:"); }

 void DalyBmsComponent::update() {
  this->trigger_next_ = true;
@@ -22,9 +22,9 @@ void DebugComponent::dump_config() {
  LOG_SENSOR("  ", "Free space on heap", this->free_sensor_);
  LOG_SENSOR("  ", "Largest free heap block", this->block_sensor_);
  LOG_SENSOR("  ", "CPU frequency", this->cpu_frequency_sensor_);
-#if defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)
+#ifdef USE_ESP8266
  LOG_SENSOR("  ", "Heap fragmentation", this->fragmentation_sensor_);
-#endif  // defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)
+#endif  // USE_ESP8266
 #endif  // USE_SENSOR

  char device_info_buffer[DEVICE_INFO_BUFFER_SIZE];
@@ -35,7 +35,7 @@ class DebugComponent final : public PollingComponent {
 #ifdef USE_SENSOR
  void set_free_sensor(sensor::Sensor *free_sensor) { free_sensor_ = free_sensor; }
  void set_block_sensor(sensor::Sensor *block_sensor) { block_sensor_ = block_sensor; }
-#if (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)) || defined(USE_ESP32)
+#if defined(USE_ESP8266) || defined(USE_ESP32)
  void set_fragmentation_sensor(sensor::Sensor *fragmentation_sensor) { fragmentation_sensor_ = fragmentation_sensor; }
 #endif
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
@@ -61,7 +61,7 @@ class DebugComponent final : public PollingComponent {

  sensor::Sensor *free_sensor_{nullptr};
  sensor::Sensor *block_sensor_{nullptr};
-#if (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)) || defined(USE_ESP32)
+#if defined(USE_ESP8266) || defined(USE_ESP32)
  sensor::Sensor *fragmentation_sensor_{nullptr};
 #endif
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
@@ -159,12 +159,10 @@ void DebugComponent::update_platform_() {
    // NOLINTNEXTLINE(readability-static-accessed-through-instance)
    this->block_sensor_->publish_state(ESP.getMaxFreeBlockSize());
  }
-#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)
  if (this->fragmentation_sensor_ != nullptr) {
    // NOLINTNEXTLINE(readability-static-accessed-through-instance)
    this->fragmentation_sensor_->publish_state(ESP.getHeapFragmentation());
  }
-#endif

 #endif
 }
@@ -52,12 +52,9 @@ CONFIG_SCHEMA = {
    ),
    cv.Optional(CONF_FRAGMENTATION): cv.All(
        cv.Any(
-            cv.All(
-                cv.only_on_esp8266,
-                cv.require_framework_version(esp8266_arduino=cv.Version(2, 5, 2)),
-            ),
+            cv.only_on_esp8266,
            cv.only_on_esp32,
-            msg="This feature is only available on ESP8266 (Arduino 2.5.2+) and ESP32",
+            msg="This feature is only available on ESP8266 and ESP32",
        ),
        sensor.sensor_schema(
            unit_of_measurement=UNIT_PERCENT,
@@ -60,7 +60,12 @@ CONFIG_SCHEMA = cv.All(
    ).extend(uart.UART_DEVICE_SCHEMA)
 )
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "dfplayer", baud_rate=9600, require_tx=True
+    "dfplayer",
+    baud_rate=9600,
+    require_tx=True,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
 )


@@ -277,9 +277,6 @@ void DFPlayer::loop() {
    }
  }
 }
-void DFPlayer::dump_config() {
-  ESP_LOGCONFIG(TAG, "DFPlayer:");
-  this->check_uart_settings(9600);
-}
+void DFPlayer::dump_config() { ESP_LOGCONFIG(TAG, "DFPlayer:"); }

 }  // namespace esphome::dfplayer
@@ -100,21 +100,38 @@ void ESP32BLE::disable() {
 #ifdef USE_ESP32_BLE_ADVERTISING
 void ESP32BLE::advertising_start() {
  this->advertising_init_();
-  if (!this->is_active())
+  this->advertising_ref_count_++;
+  this->advertising_refresh();
+}
+
+void ESP32BLE::advertising_stop() {
+  if (this->advertising_ref_count_ == 0)
    return;
-  this->advertising_->start();
+  this->advertising_ref_count_--;
+  this->advertising_refresh();
+}
+
+void ESP32BLE::advertising_refresh() {
+  if (this->advertising_ == nullptr || !this->is_active())
+    return;
+  // Advertise while any component still needs it, otherwise stop
+  if (this->advertising_ref_count_ == 0) {
+    this->advertising_->stop();
+  } else {
+    this->advertising_->start();
+  }
 }

 void ESP32BLE::advertising_set_service_data(const std::vector<uint8_t> &data) {
  this->advertising_init_();
  this->advertising_->set_service_data(data);
-  this->advertising_start();
+  this->advertising_refresh();
 }

 void ESP32BLE::advertising_set_manufacturer_data(const std::vector<uint8_t> &data) {
  this->advertising_init_();
  this->advertising_->set_manufacturer_data(data);
-  this->advertising_start();
+  this->advertising_refresh();
 }

 void ESP32BLE::advertising_set_service_data_and_name(std::span<const uint8_t> data, bool include_name) {
@@ -136,7 +153,7 @@ void ESP32BLE::advertising_set_service_data_and_name(std::span<const uint8_t> da
    this->advertising_->set_service_data(data);
  }

-  this->advertising_start();
+  this->advertising_refresh();
 }

 void ESP32BLE::advertising_register_raw_advertisement_callback(std::function<void(bool)> &&callback) {
@@ -147,13 +164,13 @@ void ESP32BLE::advertising_register_raw_advertisement_callback(std::function<voi
 void ESP32BLE::advertising_add_service_uuid(ESPBTUUID uuid) {
  this->advertising_init_();
  this->advertising_->add_service_uuid(uuid);
-  this->advertising_start();
+  this->advertising_refresh();
 }

 void ESP32BLE::advertising_remove_service_uuid(ESPBTUUID uuid) {
  this->advertising_init_();
  this->advertising_->remove_service_uuid(uuid);
-  this->advertising_start();
+  this->advertising_refresh();
 }
 #endif

@@ -575,6 +592,10 @@ void ESP32BLE::loop_handle_state_transition_not_active_() {
    }

    this->state_ = BLE_COMPONENT_STATE_ACTIVE;
+#ifdef USE_ESP32_BLE_ADVERTISING
+    // Requests made before the stack was up (or before it was re-enabled) take effect now
+    this->advertising_refresh();
+#endif
  }
 }

@@ -114,7 +114,17 @@ class ESP32BLE final : public Component {
  void set_name(const char *name) { this->name_ = name; }

 #ifdef USE_ESP32_BLE_ADVERTISING
+  /** Request advertising on behalf of a component.
+   *
+   * Requests are reference counted: advertising runs until every component that called
+   * advertising_start() has released it again with advertising_stop(). Each component must
+   * pair its calls, so nothing advertises until something actually asks for it.
+   */
  void advertising_start();
+  /// Release a request made with advertising_start(); advertising stops at the last release.
+  void advertising_stop();
+  /// Apply the current payload and request count: advertise while requested, otherwise stop.
+  void advertising_refresh();
  void advertising_set_service_data(const std::vector<uint8_t> &data);
  void advertising_set_manufacturer_data(const std::vector<uint8_t> &data);
  void advertising_set_appearance(uint16_t appearance) { this->appearance_ = appearance; }
@@ -226,6 +236,9 @@ class ESP32BLE final : public Component {
  // 1-byte aligned members (grouped together to minimize padding)
  BLEComponentState state_{BLE_COMPONENT_STATE_OFF};  // 1 byte (uint8_t enum)
  bool enable_on_boot_{};                             // 1 byte
+#ifdef USE_ESP32_BLE_ADVERTISING
+  uint8_t advertising_ref_count_{0};  // 1 byte, number of components requesting advertising
+#endif

 #ifdef ESPHOME_ESP32_BLE_EXTENDED_AUTH_PARAMS
  optional<esp_ble_auth_req_t> auth_req_mode_;
@@ -67,6 +67,8 @@ void ESP32BLEBeacon::setup() {
      this->on_advertise_();
    }
  });
+  // A beacon always needs the device to advertise, and never releases the request
+  global_ble->advertising_start();
 }

 void ESP32BLEBeacon::on_advertise_() {
@@ -596,6 +596,18 @@ async def to_code(config):
    cg.add(var.set_parent(parent))
    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
+    # silent until that service asks for advertising.
+    cg.add(
+        var.set_advertising_required(
+            CONF_MANUFACTURER_DATA in config
+            or any(
+                not uuid_is(service_config[CONF_UUID], DEVICE_INFORMATION_SERVICE_UUID)
+                for service_config in config[CONF_SERVICES]
+            )
+        )
+    )
    if CONF_MANUFACTURER_DATA in config:
        cg.add(var.set_manufacturer_data(config[CONF_MANUFACTURER_DATA]))
    for service_config in config[CONF_SERVICES]:
@@ -81,6 +81,7 @@ void BLEServer::loop() {
      if (this->device_information_service_->is_running()) {
        this->state_ = RUNNING;
        this->restart_advertising_();
+        this->request_advertising_();
        ESP_LOGD(TAG, "BLE server setup successfully");
      } else if (this->device_information_service_->is_created()) {
        this->device_information_service_->start();
@@ -98,6 +99,20 @@ void BLEServer::restart_advertising_() {
  }
 }

+void BLEServer::request_advertising_() {
+  if (!this->advertising_required_ || this->advertising_requested_)
+    return;
+  this->advertising_requested_ = true;
+  this->parent_->advertising_start();
+}
+
+void BLEServer::release_advertising_() {
+  if (!this->advertising_requested_)
+    return;
+  this->advertising_requested_ = false;
+  this->parent_->advertising_stop();
+}
+
 BLEService *BLEServer::create_service(ESPBTUUID uuid, bool advertise, uint16_t num_handles) {
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
  char uuid_buf[esp32_ble::UUID_STR_LEN];
@@ -170,7 +185,7 @@ void BLEServer::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t ga
      this->add_client_(param->connect.conn_id);
      // Resume advertising so additional clients can discover and connect
      if (this->client_count_ < this->max_clients_) {
-        this->parent_->advertising_start();
+        this->parent_->advertising_refresh();
      }
      this->dispatch_callbacks_(CallbackType::ON_CONNECT, param->connect.conn_id);
      break;
@@ -178,7 +193,7 @@ void BLEServer::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t ga
    case ESP_GATTS_DISCONNECT_EVT: {
      ESP_LOGD(TAG, "BLE Client disconnected");
      this->remove_client_(param->disconnect.conn_id);
-      this->parent_->advertising_start();
+      this->parent_->advertising_refresh();
      this->dispatch_callbacks_(CallbackType::ON_DISCONNECT, param->disconnect.conn_id);
      break;
    }
@@ -226,6 +241,8 @@ void BLEServer::remove_client_(uint16_t conn_id) {
 }

 void BLEServer::ble_before_disabled_event_handler() {
+  // Advertising is re-requested once the server is running again after BLE is re-enabled
+  this->release_advertising_();
  // Delete all clients
  this->client_count_ = 0;
  // Delete all services
@@ -38,6 +38,13 @@ class BLEServer final : public Component, public Parented<ESP32BLE> {
    this->restart_advertising_();
  }

+  /** 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
+   * request advertising themselves for as long as they need it.
+   */
+  void set_advertising_required(bool required) { this->advertising_required_ = required; }
+
  void set_max_clients(uint8_t max_clients) { this->max_clients_ = max_clients; }
  uint8_t get_max_clients() const { return this->max_clients_; }

@@ -82,6 +89,8 @@ class BLEServer final : public Component, public Parented<ESP32BLE> {
  };

  void restart_advertising_();
+  void request_advertising_();
+  void release_advertising_();

  int8_t find_client_index_(uint16_t conn_id) const;
  void add_client_(uint16_t conn_id);
@@ -93,6 +102,8 @@ class BLEServer final : public Component, public Parented<ESP32BLE> {
  std::vector<uint8_t> manufacturer_data_{};
  esp_gatt_if_t gatts_if_{0};
  bool registered_{false};
+  bool advertising_required_{true};
+  bool advertising_requested_{false};

  uint16_t clients_[USE_ESP32_BLE_MAX_CONNECTIONS]{};
  uint8_t client_count_{0};
@@ -112,6 +112,7 @@ void ESP32ImprovComponent::loop() {
      this->state_callback_.call(this->state_, this->error_state_);
 #endif
    }
+    this->release_advertising_();
    this->incoming_data_.clear();
    return;
  }
@@ -143,8 +144,9 @@ void ESP32ImprovComponent::loop() {
          ESP_LOGV(TAG, "Starting with device name advertising");
          this->advertising_device_name_ = true;
          this->last_name_adv_time_ = App.get_loop_component_start_time();
+          // Set the payload before requesting, so advertising starts exactly once
          esp32_ble::global_ble->advertising_set_service_data_and_name(std::span<const uint8_t>{}, true);
-          esp32_ble::global_ble->advertising_start();
+          this->request_advertising_();

          // Set initial state based on whether we have an authorizer
          this->set_state_(this->get_initial_state_(), false);
@@ -326,6 +328,8 @@ void ESP32ImprovComponent::stop() {
  this->set_timeout("end-service", STOP_ADVERTISING_DELAY, [this] {
    if (this->state_ == improv::STATE_STOPPED || this->service_ == nullptr)
      return;
+    // Release first so removing the service UUID does not restart advertising on the way out
+    this->release_advertising_();
    this->service_->stop();
    this->set_state_(improv::STATE_STOPPED);
  });
@@ -520,6 +524,20 @@ void ESP32ImprovComponent::update_advertising_type_() {
  }
 }

+void ESP32ImprovComponent::request_advertising_() {
+  if (this->advertising_requested_)
+    return;
+  this->advertising_requested_ = true;
+  esp32_ble::global_ble->advertising_start();
+}
+
+void ESP32ImprovComponent::release_advertising_() {
+  if (!this->advertising_requested_)
+    return;
+  this->advertising_requested_ = false;
+  esp32_ble::global_ble->advertising_stop();
+}
+
 improv::State ESP32ImprovComponent::get_initial_state_() const {
 #ifdef USE_BINARY_SENSOR
  // If we have an authorizer, start in awaiting authorization state
@@ -104,8 +104,11 @@ class ESP32ImprovComponent final : public Component, public improv_base::ImprovB
  bool status_indicator_state_{false};
  uint32_t last_name_adv_time_{0};
  bool advertising_device_name_{false};
+  bool advertising_requested_{false};
  void set_status_indicator_state_(bool state);
  void update_advertising_type_();
+  void request_advertising_();
+  void release_advertising_();

  void set_state_(improv::State state, bool update_advertising = true);
  void set_error_(improv::Error error);
@@ -35,7 +35,7 @@ from esphome.platformio.toolchain import copy_ccache_script
 from esphome.storage_json import StorageJSON
 from esphome.types import ConfigType

-from .boards import BOARDS, ESP8266_LD_SCRIPTS, board_ld_script
+from .boards import BOARDS, board_ld_script
 from .const import (
    CONF_EARLY_PIN_INIT,
    CONF_ENABLE_SERIAL,
@@ -43,8 +43,6 @@ from .const import (
    CONF_RESTORE_FROM_FLASH,
    KEY_BOARD,
    KEY_ESP8266,
-    KEY_FLASH_SIZE,
-    KEY_LDSCRIPT,
    KEY_PIN_INITIAL_STATES,
    KEY_SERIAL1_REQUIRED,
    KEY_SERIAL_REQUIRED,
@@ -133,10 +131,6 @@ def _format_framework_arduino_version(ver: cv.Version) -> str:
    # format the given arduino (https://github.com/esp8266/Arduino/releases) version to
    # a PIO platformio/framework-arduinoespressif8266 value
    # List of package versions: https://api.registry.platformio.org/v3/packages/platformio/tool/framework-arduinoespressif8266
-    if ver <= cv.Version(2, 4, 1):
-        return f"~1.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
-    if ver <= cv.Version(2, 6, 2):
-        return f"~2.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
    # Same encoding the native toolchain uses for its package download, so a
    # version bump cannot drift between the two paths.
    from esphome.arduino8266.framework import framework_package_version
@@ -159,11 +153,9 @@ def _format_framework_arduino_version(ver: cv.Version) -> str:
 #  - https://github.com/esp8266/Arduino/releases
 #  - https://api.registry.platformio.org/v3/packages/platformio/tool/framework-arduinoespressif8266
 RECOMMENDED_ARDUINO_FRAMEWORK_VERSION = cv.Version(3, 1, 2)
-# The platformio/espressif8266 version to use for arduino 2 framework versions
+# The platformio/espressif8266 version to use for arduino 3 framework versions
 #  - https://github.com/platformio/platform-espressif8266/releases
 #  - https://api.registry.platformio.org/v3/packages/platformio/platform/espressif8266
-ARDUINO_2_PLATFORM_VERSION = cv.Version(2, 6, 3)
-# for arduino 3 framework versions
 ARDUINO_3_PLATFORM_VERSION = cv.Version(3, 2, 0)
 # for arduino 4 framework versions
 ARDUINO_4_PLATFORM_VERSION = cv.Version(4, 2, 1)
@@ -188,6 +180,14 @@ def _arduino_check_versions(value: ConfigType) -> ConfigType:
        version = cv.Version.parse(cv.version_number(value[CONF_VERSION]))
        source = value.get(CONF_SOURCE, None)

+    if version < cv.Version(3, 0, 0):
+        raise cv.Invalid(
+            f"Arduino framework {version} is no longer supported; ESPHome requires "
+            f"C++20, which needs Arduino core 3.x. Use the recommended version "
+            f"({RECOMMENDED_ARDUINO_FRAMEWORK_VERSION}).",
+            path=[CONF_VERSION],
+        )
+
    value[CONF_VERSION] = str(version)
    value[CONF_SOURCE] = source or _format_framework_arduino_version(version)

@@ -195,12 +195,8 @@ def _arduino_check_versions(value: ConfigType) -> ConfigType:
    if platform_version is None:
        if version >= cv.Version(3, 1, 0):
            platform_version = _parse_platform_version(str(ARDUINO_4_PLATFORM_VERSION))
-        elif version >= cv.Version(3, 0, 0):
-            platform_version = _parse_platform_version(str(ARDUINO_3_PLATFORM_VERSION))
-        elif version >= cv.Version(2, 5, 0):
-            platform_version = _parse_platform_version(str(ARDUINO_2_PLATFORM_VERSION))
        else:
-            platform_version = _parse_platform_version(str(cv.Version(1, 8, 0)))
+            platform_version = _parse_platform_version(str(ARDUINO_3_PLATFORM_VERSION))
    value[CONF_PLATFORM_VERSION] = platform_version

    if version != RECOMMENDED_ARDUINO_FRAMEWORK_VERSION:
@@ -289,29 +285,11 @@ def check_rosetta() -> None:
        )


-def _choose_ld_script(board: str, ver: cv.Version) -> str | None:
-    """The flash ld to pin for this board and core, or None for cores
-    without ld-script support."""
-    board_data = BOARDS[board]
-    ld_scripts = ESP8266_LD_SCRIPTS[board_data[KEY_FLASH_SIZE]]
-    if ver <= cv.Version(2, 3, 0):
-        # No ld script support
-        return None
-    if ver <= cv.Version(2, 4, 2):
-        # Old ld script path; the modern per-board override names do not
-        # exist in this core's SDK, so the override cannot be honored.
-        # Substituting the size default would move _FS_end and the
-        # preferences sector, wiping flash-backed state on flash.
-        if KEY_LDSCRIPT in board_data:
-            raise EsphomeError(
-                f"Board {board} requires its {board_data[KEY_LDSCRIPT]} "
-                f"flash layout, which Arduino core {ver} cannot honor; "
-                "use a core newer than 2.4.2"
-            )
-        return ld_scripts[0]
+def _choose_ld_script(board: str) -> str:
+    """The flash ld to pin for this board."""
    # A per-board override preserves a layout the board shipped with
    # (see d1_wroom_02 in boards.py)
-    return board_ld_script(board_data)
+    return board_ld_script(BOARDS[board])


@coroutine_with_priority(CoroPriority.PLATFORM)
@@ -435,10 +413,9 @@ async def to_code(config: ConfigType) -> None:
    )

    if config[CONF_BOARD] in BOARDS:
-        ld_script = _choose_ld_script(config[CONF_BOARD], ver)
-
-        if ld_script is not None:
-            cg.add_platformio_option("board_build.ldscript", ld_script)
+        cg.add_platformio_option(
+            "board_build.ldscript", _choose_ld_script(config[CONF_BOARD])
+        )

    CORE.add_job(add_pin_initial_states_array)
    CORE.add_job(finalize_waveform_config)
@@ -96,7 +96,6 @@ void HC8Component::dump_config() {
                "  Warmup time: %" PRIu32 " s",
                this->warmup_seconds_);
  LOG_SENSOR("  ", "CO2", this->co2_sensor_);
-  this->check_uart_settings(9600);
 }

 }  // namespace esphome::hc8
@@ -47,6 +47,9 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
    baud_rate=9600,
    require_rx=True,
    require_tx=True,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
 )


@@ -38,7 +38,6 @@ CoverTraits HE60rCover::get_traits() {

 void HE60rCover::dump_config() {
  LOG_COVER("", "HE60R Cover", this);
-  this->check_uart_settings(1200, 1, uart::UART_CONFIG_PARITY_EVEN, 8);
  ESP_LOGCONFIG(TAG,
                "  Open Duration: %.1fs\n"
                "  Close Duration: %.1fs",
@@ -68,8 +68,6 @@ void HrxlMaxsonarWrComponent::check_buffer_() {
 void HrxlMaxsonarWrComponent::dump_config() {
  ESP_LOGCONFIG(TAG, "HRXL MaxSonar WR Sensor:");
  LOG_SENSOR("  ", "Distance", this);
-  // As specified in the sensor's data sheet
-  this->check_uart_settings(9600, 1, esphome::uart::UART_CONFIG_PARITY_NONE, 8);
 }

 }  // namespace esphome::hrxl_maxsonar_wr
@@ -23,6 +23,14 @@ CONFIG_SCHEMA = sensor.sensor_schema(
    state_class=STATE_CLASS_MEASUREMENT,
 ).extend(uart.UART_DEVICE_SCHEMA)

+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "hrxl_maxsonar_wr",
+    baud_rate=9600,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+

 async def to_code(config: ConfigType) -> None:
    var = await sensor.new_sensor(config)
@@ -11,7 +11,6 @@ static const char *const PROTOCOL_NAMES[] = {HYDREON_RGXX_PROTOCOL_LIST(, HYDREO
 static const char *const IGNORE_STRINGS[] = {HYDREON_RGXX_IGNORE_LIST(, HYDREON_RGXX_COMMA)};

 void HydreonRGxxComponent::dump_config() {
-  this->check_uart_settings(9600, 1, esphome::uart::UART_CONFIG_PARITY_NONE, 8);
  ESP_LOGCONFIG(TAG, "hydreon_rgxx:");
  if (this->is_failed()) {
    ESP_LOGE(TAG, "Connection with hydreon_rgxx failed!");
@@ -130,6 +130,14 @@ CONFIG_SCHEMA = cv.All(
    _validate,
 )

+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "hydreon_rgxx",
+    baud_rate=9600,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+

 async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
@@ -26,8 +26,6 @@ void KamstrupKMPComponent::dump_config() {
    LOG_SENSOR("  ", "Custom Sensor", this->custom_sensors_[i]);
    ESP_LOGCONFIG(TAG, "    Command: 0x%04X", this->custom_commands_[i]);
  }
-
-  this->check_uart_settings(1200, 2, uart::UART_CONFIG_PARITY_NONE, 8);
 }

 void KamstrupKMPComponent::update() {
@@ -102,7 +102,13 @@ CONFIG_SCHEMA = (
 )

 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "kamstrup_kmp", baud_rate=1200, require_rx=True, require_tx=True
+    "kamstrup_kmp",
+    baud_rate=1200,
+    require_rx=True,
+    require_tx=True,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=2,
 )


@@ -143,8 +143,6 @@ void MHZ19Component::dump_config() {
  ESP_LOGCONFIG(TAG, "MH-Z19:");
  LOG_SENSOR("  ", "CO2", this->co2_sensor_);
  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
-  this->check_uart_settings(9600);
-
  if (this->abc_boot_logic_ == MHZ19_ABC_ENABLED) {
    ESP_LOGCONFIG(TAG, "  Automatic baseline calibration enabled on boot");
  } else if (this->abc_boot_logic_ == MHZ19_ABC_DISABLED) {
@@ -80,6 +80,14 @@ CONFIG_SCHEMA = (
    .extend(uart.UART_DEVICE_SCHEMA)
 )

+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "mhz19",
+    baud_rate=9600,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+

 async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
@@ -163,10 +163,7 @@ void Mk2PVRouter::publish_value_(const char *tag, const char *val) {
 #endif
 }

-void Mk2PVRouter::dump_config() {
-  ESP_LOGCONFIG(TAG, "Mk2PVRouter:");
-  this->check_uart_settings(BAUD_RATE, 1, uart::UART_CONFIG_PARITY_EVEN, 7);
-}
+void Mk2PVRouter::dump_config() { ESP_LOGCONFIG(TAG, "Mk2PVRouter:"); }

 #ifdef MK2PVROUTER_LISTENER_COUNT
 void Mk2PVRouter::register_mk2pvrouter_listener(Mk2PVRouterListener *listener) {
@@ -43,7 +43,6 @@ class Mk2PVRouter final : public Component, public uart::UARTDevice {

 protected:
  static constexpr size_t CRC_SUFFIX_LEN = 1;
-  static constexpr uint32_t BAUD_RATE = 9600;

  enum class State : uint8_t {
    WAITING_FOR_START,
@@ -209,14 +209,8 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
  http_client.setTimeout(this->tft_upload_http_timeout_);

  bool begin_status = false;
-#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 7, 0)
  http_client.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
-#elif USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 6, 0)
-  http_client.setFollowRedirects(true);
-#endif
-#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 6, 0)
  http_client.setRedirectLimit(3);
-#endif
  begin_status = http_client.begin(*this->get_wifi_client_(), this->tft_url_.c_str());
  if (!begin_status) {
    this->connection_state_.is_updating_ = false;
@@ -16,7 +16,6 @@ void PM1006Component::dump_config() {
  ESP_LOGCONFIG(TAG, "PM1006:");
  LOG_SENSOR("  ", "PM2.5", this->pm_2_5_sensor_);
  LOG_UPDATE_INTERVAL(this);
-  this->check_uart_settings(9600);
 }

 void PM1006Component::update() {
@@ -48,6 +48,9 @@ def validate_interval_uart(config: ConfigType) -> None:
        baud_rate=9600,
        require_rx=True,
        require_tx=interval.total_milliseconds != SCHEDULER_DONT_RUN,
+        data_bits=8,
+        parity="NONE",
+        stop_bits=1,
    )(config)


@@ -46,8 +46,6 @@ void PMSX003Component::dump_config() {
  } else {
    ESP_LOGCONFIG(TAG, "  Mode: passive with sleep/wake cycles");
  }
-
-  this->check_uart_settings(9600);
 }

 void PMSX003Component::loop() {
@@ -302,7 +302,13 @@ CONFIG_SCHEMA = cv.All(
 def final_validate(config: ConfigType) -> None:
    require_tx = config[CONF_UPDATE_INTERVAL] > cv.time_period("0s")
    schema = uart.final_validate_device_schema(
-        "pmsx003", baud_rate=9600, require_rx=True, require_tx=require_tx
+        "pmsx003",
+        baud_rate=9600,
+        require_rx=True,
+        require_tx=require_tx,
+        data_bits=8,
+        parity="NONE",
+        stop_bits=1,
    )
    schema(config)

@@ -41,6 +41,14 @@ CONFIG_SCHEMA = cv.All(
    .extend(uart.UART_DEVICE_SCHEMA)
 )

+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "pylontech",
+    baud_rate=115200,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+

 async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
@@ -33,7 +33,6 @@ static const uint8_t ASCII_LF = 0x0A;
 PylontechComponent::PylontechComponent() {}

 void PylontechComponent::dump_config() {
-  this->check_uart_settings(115200, 1, esphome::uart::UART_CONFIG_PARITY_NONE, 8);
  ESP_LOGCONFIG(TAG, "pylontech:");
  if (this->is_failed()) {
    ESP_LOGE(TAG, "Connection with pylontech failed!");
@@ -4,11 +4,7 @@ from esphome import automation, pins
 import esphome.codegen as cg
 from esphome.components import esp32, esp32_rmt, remote_base
 from esphome.components.libretiny import get_libretiny_family
-from esphome.components.libretiny.const import (
-    FAMILY_BK7231N,
-    FAMILY_BK7238,
-    FAMILY_RTL8720C,
-)
+from esphome.components.libretiny.const import FAMILY_BK7238, FAMILY_RTL8720C
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
@@ -49,7 +45,9 @@ DigitalWriteAction = remote_transmitter_ns.class_(
 )


-_NON_BLOCKING_LIBRETINY_FAMILIES = (FAMILY_RTL8720C, FAMILY_BK7231N, FAMILY_BK7238)
+# Keep in sync with the USE_LIBRETINY_VARIANT_RTL8720C / REMOTE_TRANSMITTER_BK_PWM gates in
+# remote_transmitter.h, which decide where set_non_blocking() is declared
+_NON_BLOCKING_LIBRETINY_FAMILIES = (FAMILY_RTL8720C, FAMILY_BK7238)


 def _validate_non_blocking_platform(value: bool) -> bool:
@@ -59,9 +57,7 @@ def _validate_non_blocking_platform(value: bool) -> bool:
        return cv.boolean(value)
    if CORE.is_libretiny and get_libretiny_family() in _NON_BLOCKING_LIBRETINY_FAMILIES:
        return cv.boolean(value)
-    raise cv.Invalid(
-        "non_blocking is only supported on ESP32, RTL8720C, BK7231N and BK7238"
-    )
+    raise cv.Invalid("non_blocking is only supported on ESP32, RTL8720C and BK7238")


 MULTI_CONF = True
@@ -12,10 +12,11 @@
 #endif  // SOC_RMT_SUPPORTED
 #endif  // USE_ESP32

-// The BK7231N-style PWM block (hardware shadow-load duty updates) enables the ISR-driven
-// transmitter on these families; family-level proxy for the SDK's CFG_SOC_NAME gate.
-// See remote_transmitter_bk72xx.cpp.
-#if defined(USE_LIBRETINY_VARIANT_BK7231N) || defined(USE_LIBRETINY_VARIANT_BK7238)
+// Enables the ISR-driven transmitter on Beken. Gated on BK7238 alone: the shadow-load PWM
+// block is shared with BK7231N, but LibreTiny builds that family against an older BDK whose
+// PWM driver has no pwm_init_param()/pwm_start(). See remote_transmitter_bk72xx.cpp.
+// Keep in sync with _NON_BLOCKING_LIBRETINY_FAMILIES in __init__.py.
+#ifdef USE_LIBRETINY_VARIANT_BK7238
 #define REMOTE_TRANSMITTER_BK_PWM
 #endif

@@ -9,10 +9,13 @@
 // with the core's fixes for type-name collisions between the two
 #include <ArduinoPrivate.h>

-// Only the BK7231N-style PWM block (shadow registers with a hardware CFG_UPDATA load bit)
-// supports glitch-free per-edge duty updates; older SoCs compile the generic bit-bang
-// implementation (remote_transmitter.cpp) instead, and this file compiles to nothing.
-// REMOTE_TRANSMITTER_BK_PWM is set per-family in remote_transmitter.h.
+// Needs the BK7231N-style PWM block (shadow registers with a hardware CFG_UPDATA load bit)
+// for glitch-free per-edge duty updates, and an SDK exposing pwm_init_param()/pwm_start().
+// BK7231N has the block but LibreTiny builds it against an older BDK offering only the
+// sddev_control API (CMD_PWM_INIT_PARAM), so it stays on the generic bit-bang path until
+// someone can add and validate that path on real hardware. Every other Beken SoC lacks the
+// block. REMOTE_TRANSMITTER_BK_PWM is set per-family in remote_transmitter.h; when it is
+// unset this file compiles to nothing and remote_transmitter.cpp is used instead.

 namespace esphome::remote_transmitter {

@@ -3,11 +3,11 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"

-// Envelope chain shared by the LibreTiny families that pace transmission from a hardware
-// timer interrupt: RTL8720C (gtimer) and the BK7231N-style PWM block (BKTIMER1). Everything
-// platform-specific sits behind five hooks implemented in the per-family files -- carrier
-// setup, duty writes, one-shot arming and timer stop. Families without a usable timer keep
-// the generic bit-bang implementation and compile none of this.
+// Envelope chain shared by the LibreTiny families that pace transmission from a hardware timer
+// interrupt: RTL8720C (gtimer) and BK7238 (BKTIMER1). Everything platform-specific sits behind
+// five hooks implemented in the per-family files -- carrier setup, duty writes, one-shot arming
+// and timer stop. Families without a usable timer keep the generic bit-bang implementation and
+// compile none of this.
 #if defined(USE_LIBRETINY_VARIANT_RTL8720C) || defined(REMOTE_TRANSMITTER_BK_PWM)

 namespace esphome::remote_transmitter {
@@ -1 +1,254 @@
+import esphome.codegen as cg
+
 CODEOWNERS = ["@clydebarrow"]
+
+SDL_KeyCode = cg.global_ns.enum("SDL_KeyCode")
+
+SDL_KEYS = (
+    "SDLK_UNKNOWN",
+    "SDLK_RETURN",
+    "SDLK_ESCAPE",
+    "SDLK_BACKSPACE",
+    "SDLK_TAB",
+    "SDLK_SPACE",
+    "SDLK_EXCLAIM",
+    "SDLK_QUOTEDBL",
+    "SDLK_HASH",
+    "SDLK_PERCENT",
+    "SDLK_DOLLAR",
+    "SDLK_AMPERSAND",
+    "SDLK_QUOTE",
+    "SDLK_LEFTPAREN",
+    "SDLK_RIGHTPAREN",
+    "SDLK_ASTERISK",
+    "SDLK_PLUS",
+    "SDLK_COMMA",
+    "SDLK_MINUS",
+    "SDLK_PERIOD",
+    "SDLK_SLASH",
+    "SDLK_0",
+    "SDLK_1",
+    "SDLK_2",
+    "SDLK_3",
+    "SDLK_4",
+    "SDLK_5",
+    "SDLK_6",
+    "SDLK_7",
+    "SDLK_8",
+    "SDLK_9",
+    "SDLK_COLON",
+    "SDLK_SEMICOLON",
+    "SDLK_LESS",
+    "SDLK_EQUALS",
+    "SDLK_GREATER",
+    "SDLK_QUESTION",
+    "SDLK_AT",
+    "SDLK_LEFTBRACKET",
+    "SDLK_BACKSLASH",
+    "SDLK_RIGHTBRACKET",
+    "SDLK_CARET",
+    "SDLK_UNDERSCORE",
+    "SDLK_BACKQUOTE",
+    "SDLK_a",
+    "SDLK_b",
+    "SDLK_c",
+    "SDLK_d",
+    "SDLK_e",
+    "SDLK_f",
+    "SDLK_g",
+    "SDLK_h",
+    "SDLK_i",
+    "SDLK_j",
+    "SDLK_k",
+    "SDLK_l",
+    "SDLK_m",
+    "SDLK_n",
+    "SDLK_o",
+    "SDLK_p",
+    "SDLK_q",
+    "SDLK_r",
+    "SDLK_s",
+    "SDLK_t",
+    "SDLK_u",
+    "SDLK_v",
+    "SDLK_w",
+    "SDLK_x",
+    "SDLK_y",
+    "SDLK_z",
+    "SDLK_CAPSLOCK",
+    "SDLK_F1",
+    "SDLK_F2",
+    "SDLK_F3",
+    "SDLK_F4",
+    "SDLK_F5",
+    "SDLK_F6",
+    "SDLK_F7",
+    "SDLK_F8",
+    "SDLK_F9",
+    "SDLK_F10",
+    "SDLK_F11",
+    "SDLK_F12",
+    "SDLK_PRINTSCREEN",
+    "SDLK_SCROLLLOCK",
+    "SDLK_PAUSE",
+    "SDLK_INSERT",
+    "SDLK_HOME",
+    "SDLK_PAGEUP",
+    "SDLK_DELETE",
+    "SDLK_END",
+    "SDLK_PAGEDOWN",
+    "SDLK_RIGHT",
+    "SDLK_LEFT",
+    "SDLK_DOWN",
+    "SDLK_UP",
+    "SDLK_NUMLOCKCLEAR",
+    "SDLK_KP_DIVIDE",
+    "SDLK_KP_MULTIPLY",
+    "SDLK_KP_MINUS",
+    "SDLK_KP_PLUS",
+    "SDLK_KP_ENTER",
+    "SDLK_KP_1",
+    "SDLK_KP_2",
+    "SDLK_KP_3",
+    "SDLK_KP_4",
+    "SDLK_KP_5",
+    "SDLK_KP_6",
+    "SDLK_KP_7",
+    "SDLK_KP_8",
+    "SDLK_KP_9",
+    "SDLK_KP_0",
+    "SDLK_KP_PERIOD",
+    "SDLK_APPLICATION",
+    "SDLK_POWER",
+    "SDLK_KP_EQUALS",
+    "SDLK_F13",
+    "SDLK_F14",
+    "SDLK_F15",
+    "SDLK_F16",
+    "SDLK_F17",
+    "SDLK_F18",
+    "SDLK_F19",
+    "SDLK_F20",
+    "SDLK_F21",
+    "SDLK_F22",
+    "SDLK_F23",
+    "SDLK_F24",
+    "SDLK_EXECUTE",
+    "SDLK_HELP",
+    "SDLK_MENU",
+    "SDLK_SELECT",
+    "SDLK_STOP",
+    "SDLK_AGAIN",
+    "SDLK_UNDO",
+    "SDLK_CUT",
+    "SDLK_COPY",
+    "SDLK_PASTE",
+    "SDLK_FIND",
+    "SDLK_MUTE",
+    "SDLK_VOLUMEUP",
+    "SDLK_VOLUMEDOWN",
+    "SDLK_KP_COMMA",
+    "SDLK_KP_EQUALSAS400",
+    "SDLK_ALTERASE",
+    "SDLK_SYSREQ",
+    "SDLK_CANCEL",
+    "SDLK_CLEAR",
+    "SDLK_PRIOR",
+    "SDLK_RETURN2",
+    "SDLK_SEPARATOR",
+    "SDLK_OUT",
+    "SDLK_OPER",
+    "SDLK_CLEARAGAIN",
+    "SDLK_CRSEL",
+    "SDLK_EXSEL",
+    "SDLK_KP_00",
+    "SDLK_KP_000",
+    "SDLK_THOUSANDSSEPARATOR",
+    "SDLK_DECIMALSEPARATOR",
+    "SDLK_CURRENCYUNIT",
+    "SDLK_CURRENCYSUBUNIT",
+    "SDLK_KP_LEFTPAREN",
+    "SDLK_KP_RIGHTPAREN",
+    "SDLK_KP_LEFTBRACE",
+    "SDLK_KP_RIGHTBRACE",
+    "SDLK_KP_TAB",
+    "SDLK_KP_BACKSPACE",
+    "SDLK_KP_A",
+    "SDLK_KP_B",
+    "SDLK_KP_C",
+    "SDLK_KP_D",
+    "SDLK_KP_E",
+    "SDLK_KP_F",
+    "SDLK_KP_XOR",
+    "SDLK_KP_POWER",
+    "SDLK_KP_PERCENT",
+    "SDLK_KP_LESS",
+    "SDLK_KP_GREATER",
+    "SDLK_KP_AMPERSAND",
+    "SDLK_KP_DBLAMPERSAND",
+    "SDLK_KP_VERTICALBAR",
+    "SDLK_KP_DBLVERTICALBAR",
+    "SDLK_KP_COLON",
+    "SDLK_KP_HASH",
+    "SDLK_KP_SPACE",
+    "SDLK_KP_AT",
+    "SDLK_KP_EXCLAM",
+    "SDLK_KP_MEMSTORE",
+    "SDLK_KP_MEMRECALL",
+    "SDLK_KP_MEMCLEAR",
+    "SDLK_KP_MEMADD",
+    "SDLK_KP_MEMSUBTRACT",
+    "SDLK_KP_MEMMULTIPLY",
+    "SDLK_KP_MEMDIVIDE",
+    "SDLK_KP_PLUSMINUS",
+    "SDLK_KP_CLEAR",
+    "SDLK_KP_CLEARENTRY",
+    "SDLK_KP_BINARY",
+    "SDLK_KP_OCTAL",
+    "SDLK_KP_DECIMAL",
+    "SDLK_KP_HEXADECIMAL",
+    "SDLK_LCTRL",
+    "SDLK_LSHIFT",
+    "SDLK_LALT",
+    "SDLK_LGUI",
+    "SDLK_RCTRL",
+    "SDLK_RSHIFT",
+    "SDLK_RALT",
+    "SDLK_RGUI",
+    "SDLK_MODE",
+    "SDLK_AUDIONEXT",
+    "SDLK_AUDIOPREV",
+    "SDLK_AUDIOSTOP",
+    "SDLK_AUDIOPLAY",
+    "SDLK_AUDIOMUTE",
+    "SDLK_MEDIASELECT",
+    "SDLK_WWW",
+    "SDLK_MAIL",
+    "SDLK_CALCULATOR",
+    "SDLK_COMPUTER",
+    "SDLK_AC_SEARCH",
+    "SDLK_AC_HOME",
+    "SDLK_AC_BACK",
+    "SDLK_AC_FORWARD",
+    "SDLK_AC_STOP",
+    "SDLK_AC_REFRESH",
+    "SDLK_AC_BOOKMARKS",
+    "SDLK_BRIGHTNESSDOWN",
+    "SDLK_BRIGHTNESSUP",
+    "SDLK_DISPLAYSWITCH",
+    "SDLK_KBDILLUMTOGGLE",
+    "SDLK_KBDILLUMDOWN",
+    "SDLK_KBDILLUMUP",
+    "SDLK_EJECT",
+    "SDLK_SLEEP",
+    "SDLK_APP1",
+    "SDLK_APP2",
+    "SDLK_AUDIOREWIND",
+    "SDLK_AUDIOFASTFORWARD",
+    "SDLK_SOFTLEFT",
+    "SDLK_SOFTRIGHT",
+    "SDLK_CALL",
+    "SDLK_ENDCALL",
+)
+
+SDL_KEYMAP = {key: getattr(SDL_KeyCode, key) for key in SDL_KEYS}
@@ -7,262 +7,15 @@ from esphome.core import Lambda
 from esphome.cpp_generator import ExpressionStatement, RawExpression
 from esphome.types import ConfigType

-from .display import CONF_SDL_ID, Sdl
+from . import SDL_KEYMAP
+from .display import CONF_SDL_ID, Sdl, headless_final_validate

 CODEOWNERS = ["@bdm310"]

 STATE_ARG = "state"

-SDL_KeyCode = cg.global_ns.enum("SDL_KeyCode")
+FINAL_VALIDATE_SCHEMA = headless_final_validate("binary_sensor")

-SDL_KEYS = (
-    "SDLK_UNKNOWN",
-    "SDLK_RETURN",
-    "SDLK_ESCAPE",
-    "SDLK_BACKSPACE",
-    "SDLK_TAB",
-    "SDLK_SPACE",
-    "SDLK_EXCLAIM",
-    "SDLK_QUOTEDBL",
-    "SDLK_HASH",
-    "SDLK_PERCENT",
-    "SDLK_DOLLAR",
-    "SDLK_AMPERSAND",
-    "SDLK_QUOTE",
-    "SDLK_LEFTPAREN",
-    "SDLK_RIGHTPAREN",
-    "SDLK_ASTERISK",
-    "SDLK_PLUS",
-    "SDLK_COMMA",
-    "SDLK_MINUS",
-    "SDLK_PERIOD",
-    "SDLK_SLASH",
-    "SDLK_0",
-    "SDLK_1",
-    "SDLK_2",
-    "SDLK_3",
-    "SDLK_4",
-    "SDLK_5",
-    "SDLK_6",
-    "SDLK_7",
-    "SDLK_8",
-    "SDLK_9",
-    "SDLK_COLON",
-    "SDLK_SEMICOLON",
-    "SDLK_LESS",
-    "SDLK_EQUALS",
-    "SDLK_GREATER",
-    "SDLK_QUESTION",
-    "SDLK_AT",
-    "SDLK_LEFTBRACKET",
-    "SDLK_BACKSLASH",
-    "SDLK_RIGHTBRACKET",
-    "SDLK_CARET",
-    "SDLK_UNDERSCORE",
-    "SDLK_BACKQUOTE",
-    "SDLK_a",
-    "SDLK_b",
-    "SDLK_c",
-    "SDLK_d",
-    "SDLK_e",
-    "SDLK_f",
-    "SDLK_g",
-    "SDLK_h",
-    "SDLK_i",
-    "SDLK_j",
-    "SDLK_k",
-    "SDLK_l",
-    "SDLK_m",
-    "SDLK_n",
-    "SDLK_o",
-    "SDLK_p",
-    "SDLK_q",
-    "SDLK_r",
-    "SDLK_s",
-    "SDLK_t",
-    "SDLK_u",
-    "SDLK_v",
-    "SDLK_w",
-    "SDLK_x",
-    "SDLK_y",
-    "SDLK_z",
-    "SDLK_CAPSLOCK",
-    "SDLK_F1",
-    "SDLK_F2",
-    "SDLK_F3",
-    "SDLK_F4",
-    "SDLK_F5",
-    "SDLK_F6",
-    "SDLK_F7",
-    "SDLK_F8",
-    "SDLK_F9",
-    "SDLK_F10",
-    "SDLK_F11",
-    "SDLK_F12",
-    "SDLK_PRINTSCREEN",
-    "SDLK_SCROLLLOCK",
-    "SDLK_PAUSE",
-    "SDLK_INSERT",
-    "SDLK_HOME",
-    "SDLK_PAGEUP",
-    "SDLK_DELETE",
-    "SDLK_END",
-    "SDLK_PAGEDOWN",
-    "SDLK_RIGHT",
-    "SDLK_LEFT",
-    "SDLK_DOWN",
-    "SDLK_UP",
-    "SDLK_NUMLOCKCLEAR",
-    "SDLK_KP_DIVIDE",
-    "SDLK_KP_MULTIPLY",
-    "SDLK_KP_MINUS",
-    "SDLK_KP_PLUS",
-    "SDLK_KP_ENTER",
-    "SDLK_KP_1",
-    "SDLK_KP_2",
-    "SDLK_KP_3",
-    "SDLK_KP_4",
-    "SDLK_KP_5",
-    "SDLK_KP_6",
-    "SDLK_KP_7",
-    "SDLK_KP_8",
-    "SDLK_KP_9",
-    "SDLK_KP_0",
-    "SDLK_KP_PERIOD",
-    "SDLK_APPLICATION",
-    "SDLK_POWER",
-    "SDLK_KP_EQUALS",
-    "SDLK_F13",
-    "SDLK_F14",
-    "SDLK_F15",
-    "SDLK_F16",
-    "SDLK_F17",
-    "SDLK_F18",
-    "SDLK_F19",
-    "SDLK_F20",
-    "SDLK_F21",
-    "SDLK_F22",
-    "SDLK_F23",
-    "SDLK_F24",
-    "SDLK_EXECUTE",
-    "SDLK_HELP",
-    "SDLK_MENU",
-    "SDLK_SELECT",
-    "SDLK_STOP",
-    "SDLK_AGAIN",
-    "SDLK_UNDO",
-    "SDLK_CUT",
-    "SDLK_COPY",
-    "SDLK_PASTE",
-    "SDLK_FIND",
-    "SDLK_MUTE",
-    "SDLK_VOLUMEUP",
-    "SDLK_VOLUMEDOWN",
-    "SDLK_KP_COMMA",
-    "SDLK_KP_EQUALSAS400",
-    "SDLK_ALTERASE",
-    "SDLK_SYSREQ",
-    "SDLK_CANCEL",
-    "SDLK_CLEAR",
-    "SDLK_PRIOR",
-    "SDLK_RETURN2",
-    "SDLK_SEPARATOR",
-    "SDLK_OUT",
-    "SDLK_OPER",
-    "SDLK_CLEARAGAIN",
-    "SDLK_CRSEL",
-    "SDLK_EXSEL",
-    "SDLK_KP_00",
-    "SDLK_KP_000",
-    "SDLK_THOUSANDSSEPARATOR",
-    "SDLK_DECIMALSEPARATOR",
-    "SDLK_CURRENCYUNIT",
-    "SDLK_CURRENCYSUBUNIT",
-    "SDLK_KP_LEFTPAREN",
-    "SDLK_KP_RIGHTPAREN",
-    "SDLK_KP_LEFTBRACE",
-    "SDLK_KP_RIGHTBRACE",
-    "SDLK_KP_TAB",
-    "SDLK_KP_BACKSPACE",
-    "SDLK_KP_A",
-    "SDLK_KP_B",
-    "SDLK_KP_C",
-    "SDLK_KP_D",
-    "SDLK_KP_E",
-    "SDLK_KP_F",
-    "SDLK_KP_XOR",
-    "SDLK_KP_POWER",
-    "SDLK_KP_PERCENT",
-    "SDLK_KP_LESS",
-    "SDLK_KP_GREATER",
-    "SDLK_KP_AMPERSAND",
-    "SDLK_KP_DBLAMPERSAND",
-    "SDLK_KP_VERTICALBAR",
-    "SDLK_KP_DBLVERTICALBAR",
-    "SDLK_KP_COLON",
-    "SDLK_KP_HASH",
-    "SDLK_KP_SPACE",
-    "SDLK_KP_AT",
-    "SDLK_KP_EXCLAM",
-    "SDLK_KP_MEMSTORE",
-    "SDLK_KP_MEMRECALL",
-    "SDLK_KP_MEMCLEAR",
-    "SDLK_KP_MEMADD",
-    "SDLK_KP_MEMSUBTRACT",
-    "SDLK_KP_MEMMULTIPLY",
-    "SDLK_KP_MEMDIVIDE",
-    "SDLK_KP_PLUSMINUS",
-    "SDLK_KP_CLEAR",
-    "SDLK_KP_CLEARENTRY",
-    "SDLK_KP_BINARY",
-    "SDLK_KP_OCTAL",
-    "SDLK_KP_DECIMAL",
-    "SDLK_KP_HEXADECIMAL",
-    "SDLK_LCTRL",
-    "SDLK_LSHIFT",
-    "SDLK_LALT",
-    "SDLK_LGUI",
-    "SDLK_RCTRL",
-    "SDLK_RSHIFT",
-    "SDLK_RALT",
-    "SDLK_RGUI",
-    "SDLK_MODE",
-    "SDLK_AUDIONEXT",
-    "SDLK_AUDIOPREV",
-    "SDLK_AUDIOSTOP",
-    "SDLK_AUDIOPLAY",
-    "SDLK_AUDIOMUTE",
-    "SDLK_MEDIASELECT",
-    "SDLK_WWW",
-    "SDLK_MAIL",
-    "SDLK_CALCULATOR",
-    "SDLK_COMPUTER",
-    "SDLK_AC_SEARCH",
-    "SDLK_AC_HOME",
-    "SDLK_AC_BACK",
-    "SDLK_AC_FORWARD",
-    "SDLK_AC_STOP",
-    "SDLK_AC_REFRESH",
-    "SDLK_AC_BOOKMARKS",
-    "SDLK_BRIGHTNESSDOWN",
-    "SDLK_BRIGHTNESSUP",
-    "SDLK_DISPLAYSWITCH",
-    "SDLK_KBDILLUMTOGGLE",
-    "SDLK_KBDILLUMDOWN",
-    "SDLK_KBDILLUMUP",
-    "SDLK_EJECT",
-    "SDLK_SLEEP",
-    "SDLK_APP1",
-    "SDLK_APP2",
-    "SDLK_AUDIOREWIND",
-    "SDLK_AUDIOFASTFORWARD",
-    "SDLK_SOFTLEFT",
-    "SDLK_SOFTRIGHT",
-    "SDLK_CALL",
-    "SDLK_ENDCALL",
-)
-
-SDL_KEYMAP = {key: getattr(SDL_KeyCode, key) for key in SDL_KEYS}

 CONFIG_SCHEMA = (
    binary_sensor.binary_sensor_schema(BinarySensor)
@@ -4,6 +4,7 @@ from typing import Any

 import esphome.codegen as cg
 from esphome.components import display
+from esphome.components.snapshot import Snapshot, register_snapshot
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_DIMENSIONS,
@@ -16,14 +17,21 @@ from esphome.const import (
    CONF_Y,
    PLATFORM_HOST,
 )
+import esphome.final_validate as fv
 from esphome.types import ConfigType

+from . import SDL_KEYMAP
+
+AUTO_LOAD = ["snapshot"]
+
 sdl_ns = cg.esphome_ns.namespace("sdl")
-Sdl = sdl_ns.class_("Sdl", display.Display, cg.Component)
+Sdl = sdl_ns.class_("Sdl", display.Display, cg.Component, Snapshot)
 sdl_window_flags = cg.global_ns.enum("SDL_WindowFlags")


 CONF_CENTERED_ON_DISPLAY = "centered_on_display"
+CONF_HEADLESS = "headless"
+CONF_SNAPSHOT_KEY = "snapshot_key"
 CONF_SDL_OPTIONS = "sdl_options"
 CONF_SDL_ID = "sdl_id"
 CONF_WINDOW_OPTIONS = "window_options"
@@ -67,12 +75,29 @@ def _validate_position(config: dict) -> dict:
    raise cv.Invalid("Must specify either 'x' and 'y' or 'centered_on_display'")


+def _validate_headless(config: ConfigType) -> ConfigType:
+    if not config[CONF_HEADLESS]:
+        return config
+    if CONF_WINDOW_OPTIONS in config:
+        raise cv.Invalid(
+            f"'{CONF_WINDOW_OPTIONS}' has no effect when '{CONF_HEADLESS}' is set - there is no window"
+        )
+    if CONF_SNAPSHOT_KEY in config:
+        raise cv.Invalid(
+            f"'{CONF_SNAPSHOT_KEY}' cannot be used when '{CONF_HEADLESS}' is set - "
+            f"there is no keyboard. Use the 'snapshot.take' action instead"
+        )
+    return config
+
+
 CONFIG_SCHEMA = cv.All(
    display.FULL_DISPLAY_SCHEMA.extend(
        cv.Schema(
            {
                cv.GenerateID(): cv.declare_id(Sdl),
                cv.Optional(CONF_SDL_OPTIONS, default=""): get_sdl_options,
+                cv.Optional(CONF_HEADLESS, default=False): cv.boolean,
+                cv.Optional(CONF_SNAPSHOT_KEY): cv.enum(SDL_KEYMAP),
                cv.Required(CONF_DIMENSIONS): cv.Any(
                    cv.dimensions,
                    cv.Schema(
@@ -99,16 +124,42 @@ CONFIG_SCHEMA = cv.All(
            }
        )
    ),
+    _validate_headless,
    cv.only_on(PLATFORM_HOST),
 )


+def headless_final_validate(platform: str) -> cv.Schema:
+    """Build a FINAL_VALIDATE_SCHEMA rejecting a platform whose sdl display is headless.
+
+    Mouse and keyboard platforms are driven by window events, so under a headless display they
+    would never report anything.
+    """
+
+    def validate_display(display_config: ConfigType) -> ConfigType:
+        if display_config.get(CONF_HEADLESS):
+            raise cv.Invalid(
+                f"The sdl {platform} platform needs a window, but its display has "
+                f"'{CONF_HEADLESS}' set"
+            )
+        return display_config
+
+    return cv.Schema(
+        {cv.Required(CONF_SDL_ID): fv.id_declaration_match_schema(validate_display)},
+        extra=cv.ALLOW_EXTRA,
+    )
+
+
 async def to_code(config: ConfigType) -> None:
    for option in config[CONF_SDL_OPTIONS].split():
        cg.add_build_flag(option)
    cg.add_build_flag("-DSDL_BYTEORDER=4321")
    var = cg.new_Pvariable(config[CONF_ID])
    await display.register_display(var, config)
+    await register_snapshot(var, config)
+    cg.add(var.set_headless(config[CONF_HEADLESS]))
+    if (key := config.get(CONF_SNAPSHOT_KEY)) is not None:
+        cg.add(var.set_snapshot_key(key))

    dimensions = config[CONF_DIMENSIONS]
    if isinstance(dimensions, dict):
@@ -2,8 +2,17 @@
 #include "sdl_esphome.h"
 #include "esphome/components/display/display_color_utils.h"

+#include <cstdlib>
+
 namespace esphome::sdl {

+namespace {
+
+// Key under which each window keeps a pointer back to its Sdl instance.
+constexpr const char *const WINDOW_DATA_KEY = "esphome_sdl";
+
+}  // namespace
+
 int Sdl::get_width() {
  switch (this->rotation_) {
    case display::DISPLAY_ROTATION_90_DEGREES:
@@ -28,17 +37,96 @@ int Sdl::get_height() {
  }
 }

-void Sdl::setup() {
-  SDL_Init(SDL_INIT_VIDEO);
-  this->window_ = SDL_CreateWindow(App.get_name().c_str(), this->pos_x_, this->pos_y_, this->width_, this->height_,
-                                   this->window_options_);
-  this->renderer_ = SDL_CreateRenderer(this->window_, -1, SDL_RENDERER_SOFTWARE);
-  SDL_RenderSetLogicalSize(this->renderer_, this->width_, this->height_);
+void Sdl::destroy_renderer_() {
+  // Reverse order of creation: the renderer refers to the window or surface it was made from.
+  if (this->shot_target_ != nullptr) {
+    SDL_DestroyTexture(this->shot_target_);
+    this->shot_target_ = nullptr;
+  }
+  if (this->texture_ != nullptr) {
+    SDL_DestroyTexture(this->texture_);
+    this->texture_ = nullptr;
+  }
+  if (this->renderer_ != nullptr) {
+    SDL_DestroyRenderer(this->renderer_);
+    this->renderer_ = nullptr;
+  }
+  if (this->window_ != nullptr) {
+    SDL_DestroyWindow(this->window_);
+    this->window_ = nullptr;
+  }
+  if (this->surface_ != nullptr) {
+    SDL_FreeSurface(this->surface_);
+    this->surface_ = nullptr;
+  }
+}
+
+bool Sdl::setup_failed_(const char *what) {
+  ESP_LOGE(TAG, "%s: %s", what, SDL_GetError());
+  // Give back whatever was created before the failure. Without this a half set up display leaves an
+  // empty window on screen for the life of the process, still registered as an event target.
+  this->destroy_renderer_();
+  return false;
+}
+
+bool Sdl::setup_renderer_() {
+  SDL_SetMainReady();
+  if (this->headless_) {
+    // SDL_INIT_VIDEO is deliberately not requested: a software renderer bound to a surface needs no
+    // video device, so this works on a machine with no display server at all.
+    if (SDL_Init(0) != 0)
+      return this->setup_failed_("SDL_Init failed");
+    this->surface_ = SDL_CreateRGBSurfaceWithFormat(0, this->width_, this->height_, 16, SDL_PIXELFORMAT_RGB565);
+    if (this->surface_ == nullptr)
+      return this->setup_failed_("Could not create offscreen surface");
+    this->renderer_ = SDL_CreateSoftwareRenderer(this->surface_);
+  } else {
+    if (SDL_Init(SDL_INIT_VIDEO) != 0)
+      return this->setup_failed_("SDL_Init failed");
+    this->window_ = SDL_CreateWindow(App.get_name().c_str(), this->pos_x_, this->pos_y_, this->width_, this->height_,
+                                     this->window_options_);
+    if (this->window_ == nullptr)
+      return this->setup_failed_("Could not create window");
+    // Lets loop() find the display an event belongs to, so one display does not act on another's
+    // input when several windows are open.
+    SDL_SetWindowData(this->window_, WINDOW_DATA_KEY, this);
+    this->renderer_ = SDL_CreateRenderer(this->window_, -1, SDL_RENDERER_SOFTWARE);
+  }
+  if (this->renderer_ == nullptr)
+    return this->setup_failed_("Could not create renderer");
+  if (SDL_RenderSetLogicalSize(this->renderer_, this->width_, this->height_) != 0)
+    return this->setup_failed_("Could not set renderer logical size");
  this->texture_ =
      SDL_CreateTexture(this->renderer_, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_STATIC, this->width_, this->height_);
-  SDL_SetTextureBlendMode(this->texture_, SDL_BLENDMODE_BLEND);
+  if (this->texture_ == nullptr)
+    return this->setup_failed_("Could not create texture");
+  // The texture has no alpha channel, so blending is pointless. Headless it would also force a
+  // different software blit path onto the 16 bit target surface.
+  if (SDL_SetTextureBlendMode(this->texture_, this->headless_ ? SDL_BLENDMODE_NONE : SDL_BLENDMODE_BLEND) != 0)
+    return this->setup_failed_("Could not set texture blend mode");
+  return true;
 }
+
+void Sdl::setup() {
+  if (!this->setup_renderer_()) {
+    this->mark_failed();
+    return;
+  }
+  if (this->headless_) {
+    // Nothing generates events, so there is nothing for loop() to do.
+    this->disable_loop();
+  } else if (this->snapshot_key_ != 0) {
+    this->add_key_listener(this->snapshot_key_, [this](bool down) {
+      if (down && !this->take_snapshot(nullptr)) {
+        ESP_LOGW(TAG, "snapshot key did not write a file");
+      }
+    });
+  }
+}
+
 void Sdl::update() {
+  if (this->texture_ == nullptr)
+    return;
  this->do_update_();
  if ((this->x_high_ < this->x_low_) || (this->y_high_ < this->y_low_))
    return;
@@ -51,12 +139,19 @@ void Sdl::update() {
 }

 void Sdl::redraw_(SDL_Rect &rect) {
+  // Nothing to present when headless - a snapshot blits the whole texture when it needs it, so
+  // doing it here as well would just burn CPU. draw_pixels_at() calls this on every partial
+  // update, so it is worth skipping.
+  if (this->headless_)
+    return;
  SDL_RenderCopy(this->renderer_, this->texture_, &rect, &rect);
  SDL_RenderPresent(this->renderer_);
 }

 void Sdl::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
                         display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
+  if (this->texture_ == nullptr)
+    return;
  SDL_Rect rect{x_start, y_start, w, h};
  if (this->rotation_ != display::DISPLAY_ROTATION_0_DEGREES || bitness != display::COLOR_BITNESS_565 || big_endian) {
    Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
@@ -69,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->get_clipping().inside(x, y))
+  if (this->texture_ == nullptr || !this->get_clipping().inside(x, y))
    return;

  if (this->rotation_ == display::DISPLAY_ROTATION_180_DEGREES) {
@@ -104,61 +199,148 @@ void Sdl::process_key(uint32_t keycode, bool down) {
    callback->second(down);
 }

+Sdl *Sdl::instance_for_window_(uint32_t window_id) {
+  SDL_Window *window = SDL_GetWindowFromID(window_id);
+  if (window == nullptr)
+    return nullptr;
+  return static_cast<Sdl *>(SDL_GetWindowData(window, WINDOW_DATA_KEY));
+}
+
+void Sdl::handle_event_(const SDL_Event &event) {
+  switch (event.type) {
+    case SDL_MOUSEBUTTONDOWN:
+    case SDL_MOUSEBUTTONUP:
+      if (event.button.button == 1) {
+        this->mouse_x = event.button.x;
+        this->mouse_y = event.button.y;
+        this->mouse_down = event.button.state != 0;
+      }
+      break;
+
+    case SDL_MOUSEMOTION:
+      if (event.motion.state & 1) {
+        this->mouse_x = event.motion.x;
+        this->mouse_y = event.motion.y;
+        this->mouse_down = true;
+      } else {
+        this->mouse_down = false;
+      }
+      break;
+
+    case SDL_KEYDOWN:
+      // Ignore auto-repeat, otherwise holding a key floods the listeners.
+      if (event.key.repeat != 0)
+        break;
+      ESP_LOGD(TAG, "keydown %d", event.key.keysym.sym);
+      this->process_key(event.key.keysym.sym, true);
+      break;
+
+    case SDL_KEYUP:
+      ESP_LOGD(TAG, "keyup %d", event.key.keysym.sym);
+      this->process_key(event.key.keysym.sym, false);
+      break;
+
+    case SDL_WINDOWEVENT:
+      switch (event.window.event) {
+        case SDL_WINDOWEVENT_SIZE_CHANGED:
+        case SDL_WINDOWEVENT_EXPOSED:
+        case SDL_WINDOWEVENT_RESIZED: {
+          SDL_Rect rect{0, 0, this->width_, this->height_};
+          this->redraw_(rect);
+          break;
+        }
+        default:
+          break;
+      }
+      break;
+
+    default:
+      break;
+  }
+}
+
 void Sdl::loop() {
  SDL_Event e;
-  if (SDL_PollEvent(&e)) {
-    switch (e.type) {
-      case SDL_QUIT:
-        exit(0);
+  // Take everything that is waiting, not one event per loop. A touch drag produces a burst of
+  // motion events, and consuming them one at a time lets the queue grow without bound, so the
+  // pointer ends up acting on input from further and further in the past. Draining collapses a
+  // burst to the position it ended at, which is the one the user is asking for anyway.
+  while (SDL_PollEvent(&e)) {
+    if (e.type == SDL_QUIT)
+      exit(0);

+    // Events carry the window they happened in, so send each one to the display that owns it.
+    uint32_t window_id;
+    switch (e.type) {
      case SDL_MOUSEBUTTONDOWN:
      case SDL_MOUSEBUTTONUP:
-        if (e.button.button == 1) {
-          this->mouse_x = e.button.x;
-          this->mouse_y = e.button.y;
-          this->mouse_down = e.button.state != 0;
-        }
+        window_id = e.button.windowID;
        break;
-
      case SDL_MOUSEMOTION:
-        if (e.motion.state & 1) {
-          this->mouse_x = e.button.x;
-          this->mouse_y = e.button.y;
-          this->mouse_down = true;
-        } else {
-          this->mouse_down = false;
-        }
+        window_id = e.motion.windowID;
        break;
-
      case SDL_KEYDOWN:
-        ESP_LOGD(TAG, "keydown %d", e.key.keysym.sym);
-        this->process_key(e.key.keysym.sym, true);
-        break;
-
      case SDL_KEYUP:
-        ESP_LOGD(TAG, "keyup %d", e.key.keysym.sym);
-        this->process_key(e.key.keysym.sym, false);
+        window_id = e.key.windowID;
        break;
-
      case SDL_WINDOWEVENT:
-        switch (e.window.event) {
-          case SDL_WINDOWEVENT_SIZE_CHANGED:
-          case SDL_WINDOWEVENT_EXPOSED:
-          case SDL_WINDOWEVENT_RESIZED: {
-            SDL_Rect rect{0, 0, this->width_, this->height_};
-            this->redraw_(rect);
-            break;
-          }
-          default:
-            break;
-        }
+        window_id = e.window.windowID;
        break;
-
      default:
+        // Anything else, including the touch events SDL reports alongside the mouse events it
+        // synthesises from them, is not used here.
        ESP_LOGV(TAG, "Event %d", e.type);
-        break;
+        continue;
+    }
+
+    Sdl *target = instance_for_window_(window_id);
+    if (target == nullptr) {
+      // Nothing to route this to: the window has gone, or it is not one of ours. Say so, otherwise
+      // input that stops working leaves no trace at all.
+      ESP_LOGV(TAG, "Event %d for unknown window %u", e.type, window_id);
+      continue;
+    }
+    target->handle_event_(e);
+  }
+}
+
+bool Sdl::capture_bgr(uint8_t *dest, size_t row_stride) {
+  if (this->texture_ == nullptr || this->renderer_ == nullptr) {
+    ESP_LOGE(TAG, "Snapshot requested but SDL is not set up");
+    return false;
+  }
+  if (this->shot_target_ == nullptr) {
+    this->shot_target_ = SDL_CreateTexture(this->renderer_, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_TARGET,
+                                           this->width_, this->height_);
+    if (this->shot_target_ == nullptr) {
+      ESP_LOGE(TAG, "Could not create capture texture: %s", SDL_GetError());
+      return false;
+    }
+    SDL_SetTextureBlendMode(this->shot_target_, SDL_BLENDMODE_NONE);
+  }
+
+  // Render into an offscreen target first. SDL_RenderReadPixels works in physical output pixels and
+  // ignores the logical size, so reading straight off a resizable window would read more pixels than
+  // there is room for.
+  // Every step is checked: a failed clear or copy would otherwise be read back as a blank or stale
+  // picture, written out, and reported as a snapshot that worked.
+  bool ok = false;
+  if (SDL_SetRenderTarget(this->renderer_, this->shot_target_) == 0) {
+    ok = SDL_SetRenderDrawColor(this->renderer_, 0, 0, 0, SDL_ALPHA_OPAQUE) == 0 &&
+         SDL_RenderClear(this->renderer_) == 0 &&
+         SDL_RenderCopy(this->renderer_, this->texture_, nullptr, nullptr) == 0 &&
+         SDL_RenderReadPixels(this->renderer_, nullptr, SDL_PIXELFORMAT_BGR24, dest, static_cast<int>(row_stride)) == 0;
+    if (SDL_SetRenderTarget(this->renderer_, nullptr) != 0) {
+      // Stuck rendering into shot_target_ from here on, so there's no point continuing.
+      ESP_LOGE(TAG, "Could not restore the render target: %s", SDL_GetError());
+      this->mark_failed();
+      return false;
    }
  }
+  if (!ok) {
+    ESP_LOGE(TAG, "Could not capture the screen: %s", SDL_GetError());
+  }
+  return ok;
 }

 }  // namespace esphome::sdl
@@ -1,10 +1,12 @@
 #pragma once

 #ifdef USE_HOST
+#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/log.h"
 #include "esphome/core/application.h"
 #include "esphome/components/display/display.h"
+#include "esphome/components/snapshot/snapshot.h"
 #define SDL_MAIN_HANDLED
 #include "SDL.h"
 #include <map>
@@ -13,7 +15,7 @@ namespace esphome::sdl {

 constexpr static const char *const TAG = "sdl";

-class Sdl final : public display::Display {
+class Sdl final : public display::Display, public snapshot::Snapshot {
 public:
  display::DisplayType get_display_type() override { return display::DISPLAY_TYPE_COLOR; }
  void update() override;
@@ -32,6 +34,9 @@ class Sdl final : public display::Display {
    this->pos_x_ = pos_x;
    this->pos_y_ = pos_y;
  }
+  void set_headless(bool headless) { this->headless_ = headless; }
+  void set_snapshot_key(int32_t keycode) { this->snapshot_key_ = keycode; }
+
  int get_width() override;
  int get_height() override;
  float get_setup_priority() const override { return setup_priority::HARDWARE; }
@@ -51,20 +56,40 @@ class Sdl final : public display::Display {
  int get_width_internal() override { return this->width_; }
  int get_height_internal() override { return this->height_; }
  void redraw_(SDL_Rect &rect);
+  bool setup_renderer_();
+  /// Release the window, surface, renderer and textures, and forget them.
+  void destroy_renderer_();
+  /// Log an SDL failure during setup, release anything already created, and return false.
+  bool setup_failed_(const char *what);
+  int snapshot_width() override { return this->width_; }
+  int snapshot_height() override { return this->height_; }
+  bool capture_bgr(uint8_t *dest, size_t row_stride) override;
+  void handle_event_(const SDL_Event &event);
+  /// The display owning the given window, or nullptr if it is not one of ours.
+  static Sdl *instance_for_window_(uint32_t window_id);
+  SDL_Renderer *renderer_{};
+  SDL_Window *window_{};
+  SDL_Texture *texture_{};
+  // Offscreen render target used when headless. SDL_CreateSoftwareRenderer only borrows the
+  // surface, and the renderer goes back to using it as its output whenever the capture target is
+  // released, so it has to stay alive as long as the renderer does.
+  SDL_Surface *surface_{};
+  // Capture target, created on first snapshot.
+  SDL_Texture *shot_target_{};
+  std::map<int32_t, CallbackManager<void(bool)>> key_callbacks_{};
  int width_{};
  int height_{};
  uint32_t window_options_{0};
  int32_t pos_x_{SDL_WINDOWPOS_UNDEFINED};
  int32_t pos_y_{SDL_WINDOWPOS_UNDEFINED};
-  SDL_Renderer *renderer_{};
-  SDL_Window *window_{};
-  SDL_Texture *texture_{};
+  int32_t snapshot_key_{0};
  uint16_t x_low_{0};
  uint16_t y_low_{0};
  uint16_t x_high_{0};
  uint16_t y_high_{0};
-  std::map<int32_t, CallbackManager<void(bool)>> key_callbacks_{};
+  bool headless_{false};
 };
+
 }  // namespace esphome::sdl

 #endif
@@ -4,10 +4,12 @@ import esphome.config_validation as cv
 from esphome.const import CONF_ID
 from esphome.types import ConfigType

-from ..display import CONF_SDL_ID, Sdl, sdl_ns
+from ..display import CONF_SDL_ID, Sdl, headless_final_validate, sdl_ns

 SdlTouchscreen = sdl_ns.class_("SdlTouchscreen", touchscreen.Touchscreen)

+FINAL_VALIDATE_SCHEMA = headless_final_validate("touchscreen")
+

 CONFIG_SCHEMA = touchscreen.TOUCHSCREEN_SCHEMA.extend(
    {
@@ -31,6 +31,7 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
    require_tx=True,
    require_rx=True,
    baud_rate=115200,
+    data_bits=8,
    parity="NONE",
    stop_bits=1,
 )
@@ -33,8 +33,6 @@ void MR60FDA2Component::dump_config() {

 // Initialisation functions
 void MR60FDA2Component::setup() {
-  this->check_uart_settings(115200);
-
  this->current_frame_locate_ = LOCATE_FRAME_HEADER;
  this->current_frame_id_ = 0;
  this->current_frame_len_ = 0;
@@ -130,17 +130,26 @@ SerialProxyResult SerialProxy::configure(api::APIConnection *api_connection, uin
    return SerialProxyResult::SERIAL_PROXY_RESULT_NOT_SUPPORTED;
  }

-  // Apply validated parameters
-  uart_comp->set_baud_rate(baudrate);
-  uart_comp->set_stop_bits(stop_bits);
-  uart_comp->set_data_bits(data_size);
-
-  // Map parity value to UARTParityOptions
+  // Skip a no-op reconfigure. Clients routinely re-send identical settings on every
+  // port open, and on a USB UART each apply is a CDC SET_LINE_CODING control transfer.
+  // Some bridges watch line-coding changes as a signalling channel (a magic baud
+  // sequence to enter a bootloader, say), so redundant applies are not harmless.
  static const uart::UARTParityOptions PARITY_MAP[] = {
      uart::UART_CONFIG_PARITY_NONE,
      uart::UART_CONFIG_PARITY_EVEN,
      uart::UART_CONFIG_PARITY_ODD,
  };
+  if (uart_comp->get_baud_rate() == baudrate && uart_comp->get_stop_bits() == stop_bits &&
+      uart_comp->get_data_bits() == data_size && uart_comp->get_parity() == PARITY_MAP[parity]) {
+    ESP_LOGV(TAG, "Settings unchanged, skipping reconfigure [%" PRIu32 "]", this->instance_index_);
+    return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
+  }
+
+  // Apply validated parameters
+  uart_comp->set_baud_rate(baudrate);
+  uart_comp->set_stop_bits(stop_bits);
+  uart_comp->set_data_bits(data_size);
+
  uart_comp->set_parity(PARITY_MAP[parity]);

  // load_settings() is available on ESP8266 and ESP32 platforms
@@ -68,7 +68,13 @@ CONFIG_SCHEMA = (
 )

 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "smt100", baud_rate=9600, require_rx=True, require_tx=True
+    "smt100",
+    baud_rate=9600,
+    require_rx=True,
+    require_tx=True,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
 )


@@ -65,7 +65,6 @@ void SMT100Component::dump_config() {
  LOG_SENSOR(TAG, "Temperature", this->temperature_sensor_);
  LOG_SENSOR(TAG, "Moisture", this->moisture_sensor_);
  LOG_UPDATE_INTERVAL(this);
-  this->check_uart_settings(9600);
 }

 int SMT100Component::readline_(int readch, char *buffer, int len) {
@@ -0,0 +1,76 @@
+"""Shared support for writing what a display is showing out to an image file.
+
+The component itself has no configuration. It provides the ``snapshot.take`` action and the C++
+base class behind it, so any display that can hand over its pixels - the in memory display in this
+component, or an SDL window - saves files the same way, under the same directory, with the same
+rules about names.
+"""
+
+from dataclasses import dataclass
+
+from esphome import automation
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+from esphome.core import CORE, ID
+from esphome.cpp_generator import MockObj
+from esphome.types import ConfigType, TemplateArgsType
+
+CODEOWNERS = ["@clydebarrow"]
+
+DOMAIN = "snapshot"
+
+CONF_FILENAME = "filename"
+
+snapshot_ns = cg.esphome_ns.namespace("snapshot")
+Snapshot = snapshot_ns.class_("Snapshot")
+SnapshotAction = snapshot_ns.class_("SnapshotAction", automation.Action)
+
+
+@automation.register_action(
+    "snapshot.take",
+    SnapshotAction,
+    automation.maybe_simple_id(
+        {
+            cv.GenerateID(): cv.use_id(Snapshot),
+            cv.Optional(CONF_FILENAME): cv.templatable(cv.string),
+        }
+    ),
+    synchronous=True,
+)
+async def snapshot_take_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_ID])
+    if (filename := config.get(CONF_FILENAME)) is not None:
+        cg.add(var.set_filename(await cg.templatable(filename, args, cg.std_string)))
+    return var
+
+
+@dataclass
+class SnapshotData:
+    directory_defined: bool = False
+
+
+def _get_data() -> SnapshotData:
+    if DOMAIN not in CORE.data:
+        CORE.data[DOMAIN] = SnapshotData()
+    return CORE.data[DOMAIN]
+
+
+async def register_snapshot(var: MockObj, config: ConfigType) -> None:
+    """Set up a component so that the snapshot action can write its picture to a file."""
+    data = _get_data()
+    # Only once, however many displays there are: two defines that say the same thing do not
+    # compare equal, so asking for this per display repeats the line in defines.h.
+    if not data.directory_defined:
+        data.directory_defined = True
+        cg.add_define(
+            "ESPHOME_SNAPSHOT_DIR",
+            (CORE.data_dir / "snapshots" / CORE.name).as_posix(),
+        )
+    cg.add(var.set_snapshot_prefix(str(config[CONF_ID])))
@@ -0,0 +1,61 @@
+import esphome.codegen as cg
+from esphome.components import display
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_DIMENSIONS,
+    CONF_HEIGHT,
+    CONF_ID,
+    CONF_LAMBDA,
+    CONF_WIDTH,
+    PLATFORM_HOST,
+)
+from esphome.types import ConfigType
+
+from .. import Snapshot, register_snapshot, snapshot_ns
+
+# The base class and the file writing live in the parent component, which nothing else in a
+# configuration using only this platform would pull in.
+AUTO_LOAD = ["snapshot"]
+
+SnapshotDisplay = snapshot_ns.class_(
+    "SnapshotDisplay", display.DisplayBuffer, cg.Component, Snapshot
+)
+
+CONFIG_SCHEMA = cv.All(
+    display.FULL_DISPLAY_SCHEMA.extend(
+        cv.Schema(
+            {
+                cv.GenerateID(): cv.declare_id(SnapshotDisplay),
+                cv.Required(CONF_DIMENSIONS): cv.Any(
+                    cv.dimensions,
+                    cv.Schema(
+                        {
+                            cv.Required(CONF_WIDTH): cv.positive_not_null_int,
+                            cv.Required(CONF_HEIGHT): cv.positive_not_null_int,
+                        }
+                    ),
+                ),
+            }
+        )
+    ),
+    cv.only_on(PLATFORM_HOST),
+)
+
+
+async def to_code(config: ConfigType) -> None:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await display.register_display(var, config)
+    await register_snapshot(var, config)
+
+    dimensions = config[CONF_DIMENSIONS]
+    if isinstance(dimensions, dict):
+        cg.add(var.set_dimensions(dimensions[CONF_WIDTH], dimensions[CONF_HEIGHT]))
+    else:
+        (width, height) = dimensions
+        cg.add(var.set_dimensions(width, height))
+
+    if lamb := config.get(CONF_LAMBDA):
+        lambda_ = await cg.process_lambda(
+            lamb, [(display.DisplayRef, "it")], return_type=cg.void
+        )
+        cg.add(var.set_writer(lambda_))
@@ -0,0 +1,80 @@
+#ifdef USE_HOST
+#include "snapshot_display.h"
+#include "esphome/components/display/display_color_utils.h"
+#include "esphome/core/log.h"
+
+#include <cstring>
+
+namespace esphome::snapshot {
+
+static const char *const TAG = "snapshot.display";
+
+namespace {
+
+/// Spread a channel that only goes up to `max` over the whole 0 to 255 range, so that the
+/// brightest value stays the brightest. This is the same arithmetic SDL uses, which is what makes
+/// a picture taken here come out identical to the same picture taken from an SDL window.
+constexpr uint8_t expand_channel(uint16_t value, uint16_t max) { return static_cast<uint8_t>(value * 255 / max); }
+
+constexpr uint16_t RED_MAX = 0x1F;
+constexpr uint16_t GREEN_MAX = 0x3F;
+constexpr uint16_t BLUE_MAX = 0x1F;
+
+}  // namespace
+
+void SnapshotDisplay::setup() {
+  this->init_internal_(static_cast<uint32_t>(this->width_) * this->height_ * 2);
+  if (this->buffer_ == nullptr) {
+    this->mark_failed(LOG_STR("Could not allocate display buffer"));
+  }
+}
+
+void SnapshotDisplay::dump_config() { LOG_DISPLAY("", "Snapshot", this); }
+
+void SnapshotDisplay::draw_absolute_pixel_internal(int x, int y, Color color) {
+  if (this->buffer_ == nullptr || x < 0 || x >= this->width_ || y < 0 || y >= this->height_)
+    return;
+  this->pixels_()[y * this->width_ + x] = display::ColorUtil::color_to_565(color, display::COLOR_ORDER_RGB);
+}
+
+void SnapshotDisplay::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr,
+                                     display::ColorOrder order, display::ColorBitness bitness, bool big_endian,
+                                     int x_offset, int y_offset, int x_pad) {
+  if (this->buffer_ == nullptr)
+    return;
+  // Anything that is not already laid out the way the buffer is, or that would reach outside it,
+  // goes through the base class, which turns it into one call per pixel with the bounds checked.
+  const bool copyable = this->rotation_ == display::DISPLAY_ROTATION_0_DEGREES &&
+                        bitness == display::COLOR_BITNESS_565 && !big_endian && x_start >= 0 && y_start >= 0 &&
+                        x_start + w <= this->width_ && y_start + h <= this->height_;
+  if (!copyable) {
+    DisplayBuffer::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
+    return;
+  }
+  const size_t stride = static_cast<size_t>(x_offset) + w + x_pad;
+  const uint8_t *src = ptr + (stride * y_offset + x_offset) * 2;
+  for (int y = 0; y != h; y++) {
+    memcpy(&this->pixels_()[(y_start + y) * this->width_ + x_start], src + y * stride * 2, w * 2);
+  }
+}
+
+bool SnapshotDisplay::capture_bgr(uint8_t *dest, size_t row_stride) {
+  if (this->buffer_ == nullptr) {
+    ESP_LOGE(TAG, "Snapshot requested but there is no buffer to read");
+    return false;
+  }
+  const uint16_t *src = this->pixels_();
+  for (int y = 0; y != this->height_; y++) {
+    uint8_t *out = dest + y * row_stride;
+    for (int x = 0; x != this->width_; x++) {
+      const uint16_t pixel = *src++;
+      *out++ = expand_channel(pixel & BLUE_MAX, BLUE_MAX);
+      *out++ = expand_channel((pixel >> 5) & GREEN_MAX, GREEN_MAX);
+      *out++ = expand_channel(pixel >> 11, RED_MAX);
+    }
+  }
+  return true;
+}
+
+}  // namespace esphome::snapshot
+#endif
@@ -0,0 +1,48 @@
+#pragma once
+
+#ifdef USE_HOST
+#include "esphome/components/display/display_buffer.h"
+#include "esphome/components/snapshot/snapshot.h"
+#include "esphome/core/component.h"
+
+namespace esphome::snapshot {
+
+/// A display with nowhere to show anything: it keeps the picture in memory, where the snapshot
+/// action can pick it up. That makes it a way to see what a configuration draws on a machine with
+/// no screen, and to check the result in a test.
+class SnapshotDisplay final : public display::DisplayBuffer, public Snapshot {
+ public:
+  void setup() override;
+  void update() override { this->do_update_(); }
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::HARDWARE; }
+  display::DisplayType get_display_type() override { return display::DISPLAY_TYPE_COLOR; }
+
+  void set_dimensions(uint16_t width, uint16_t height) {
+    this->width_ = width;
+    this->height_ = height;
+  }
+
+  void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
+                      display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
+
+ protected:
+  void draw_absolute_pixel_internal(int x, int y, Color color) override;
+  int get_width_internal() override { return this->width_; }
+  int get_height_internal() override { return this->height_; }
+
+  int snapshot_width() override { return this->width_; }
+  int snapshot_height() override { return this->height_; }
+  bool capture_bgr(uint8_t *dest, size_t row_stride) override;
+
+  /// The picture, one 16 bit RGB565 value per pixel, topmost row first. Owned by DisplayBuffer as
+  /// a byte pointer; this is the same memory seen as what is actually stored in it.
+  uint16_t *pixels_() { return reinterpret_cast<uint16_t *>(this->buffer_); }
+
+  int width_{};
+  int height_{};
+};
+
+}  // namespace esphome::snapshot
+
+#endif
@@ -0,0 +1,248 @@
+#ifdef USE_HOST
+#include "snapshot.h"
+#include "esphome/core/log.h"
+
+#include <fcntl.h>
+#include <strings.h>
+#include <unistd.h>
+#include <cctype>
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+#include <ctime>
+#include <filesystem>
+#include <memory>
+
+namespace esphome::snapshot {
+
+namespace {
+
+constexpr const char *const TAG = "snapshot";
+
+// Longest name we will build a path from. NAME_MAX is 255 and we may append a collision suffix.
+constexpr size_t MAX_NAME_LENGTH = 200;
+// Give up rather than spin forever if every candidate name is taken.
+constexpr unsigned MAX_NAME_ATTEMPTS = 1000;
+// A BMP file header followed by a BITMAPINFOHEADER, which is where the pixels start.
+constexpr size_t BMP_HEADER_SIZE = 54;
+constexpr size_t BMP_INFO_HEADER_SIZE = 40;
+constexpr int BMP_BITS_PER_PIXEL = 24;
+
+/// True if the name already ends in ".bmp". The comparison ignores case, so "shot.BMP" is left
+/// alone rather than turned into "shot.BMP.bmp".
+bool has_bmp_suffix(const std::string &name) {
+  return name.size() >= 4 && strcasecmp(name.c_str() + name.size() - 4, ".bmp") == 0;
+}
+
+/// Reduce a user supplied name to a single safe path component. Everything outside the allowed set
+/// is replaced, so "..", "/" and absolute paths cannot escape the snapshot directory.
+/// Returns an empty string if nothing usable is left.
+std::string sanitise_filename(const char *const name, bool *name_changed) {
+  std::string result;
+  bool all_dots = true;
+  bool changed = false;
+  for (const char *p = name; *p != '\0'; p++) {
+    if (result.size() >= MAX_NAME_LENGTH) {
+      changed = true;
+      break;
+    }
+    char c = *p;
+    if (!(std::isalnum(static_cast<unsigned char>(c)) || c == '.' || c == '_' || c == '-')) {
+      c = '_';
+      changed = true;
+    }
+    if (c != '.')
+      all_dots = false;
+    result.push_back(c);
+  }
+  if (all_dots) {
+    *name_changed = true;
+    return "";
+  }
+  if (!has_bmp_suffix(result))
+    result += ".bmp";
+  *name_changed = changed;
+  return result;
+}
+
+/// Insert "-<attempt>" before the file extension, e.g. "shot.bmp" -> "shot-1.bmp".
+std::string add_suffix(const std::string &name, unsigned attempt) {
+  char suffix[12];
+  snprintf(suffix, sizeof(suffix), "-%u", attempt);
+  auto dot = name.rfind('.');
+  if (dot == std::string::npos)
+    return name + suffix;
+  return name.substr(0, dot) + suffix + name.substr(dot);
+}
+
+/// Directory snapshots are written to. The environment variable lets a test redirect output
+/// without rebuilding, matching how the host platform handles ESPHOME_PREFDIR.
+const char *snapshot_dir() {
+  const char *dir = getenv("ESPHOME_SNAPSHOT_DIR");  // NOLINT(concurrency-mt-unsafe)
+  return dir != nullptr && dir[0] != '\0' ? dir : ESPHOME_SNAPSHOT_DIR;
+}
+
+/// Store a value in as many bytes, least significant first, and step the pointer past it.
+/// BMP is a little endian format whatever the machine writing it uses.
+void put_le(uint8_t *&dest, uint32_t value, size_t bytes) {
+  for (size_t i = 0; i != bytes; i++)
+    *dest++ = static_cast<uint8_t>(value >> (8 * i));
+}
+
+/// The number of bytes one row of `width` pixels takes up in the file. Rows are padded out to a
+/// multiple of four bytes.
+size_t bmp_row_size(int width) { return (static_cast<size_t>(width) * 3 + 3) & ~size_t{3}; }
+
+/// Write pixels out as a 24 bit BMP. The rows given start with the topmost and are `row_stride`
+/// bytes apart, which must leave room for a whole padded row; a BMP holds its rows the other way
+/// up, so they go out last first.
+bool write_bmp(FILE *file, const uint8_t *pixels, int width, int height, size_t row_stride) {
+  const size_t row_size = bmp_row_size(width);
+  const size_t pixel_bytes = row_size * height;
+
+  uint8_t header[BMP_HEADER_SIZE];
+  uint8_t *pos = header;
+  *pos++ = 'B';
+  *pos++ = 'M';
+  put_le(pos, static_cast<uint32_t>(BMP_HEADER_SIZE + pixel_bytes), 4);
+  put_le(pos, 0, 4);  // reserved
+  put_le(pos, BMP_HEADER_SIZE, 4);
+  put_le(pos, BMP_INFO_HEADER_SIZE, 4);
+  put_le(pos, static_cast<uint32_t>(width), 4);
+  put_le(pos, static_cast<uint32_t>(height), 4);
+  put_le(pos, 1, 2);  // one plane
+  put_le(pos, BMP_BITS_PER_PIXEL, 2);
+  put_le(pos, 0, 4);  // not compressed
+  put_le(pos, static_cast<uint32_t>(pixel_bytes), 4);
+  put_le(pos, 0, 4);  // pixels per metre across, unspecified
+  put_le(pos, 0, 4);  // pixels per metre down, unspecified
+  put_le(pos, 0, 4);  // no palette
+  put_le(pos, 0, 4);  // so no palette entry matters more than another
+
+  if (fwrite(header, 1, sizeof(header), file) != sizeof(header))
+    return false;
+  for (int y = height - 1; y >= 0; y--) {
+    if (fwrite(pixels + static_cast<size_t>(y) * row_stride, 1, row_size, file) != row_size)
+      return false;
+  }
+  return true;
+}
+
+/// Reserve a name in the snapshot directory and write the picture to it.
+/// With `exact` set the given name is the only one tried; otherwise a number is added on
+/// collision. Returns true if a file was written.
+bool write_snapshot_file(const uint8_t *pixels, int width, int height, size_t row_stride, const std::string &name,
+                         bool exact) {
+  const std::string dir = snapshot_dir();
+  std::error_code ec;
+  std::filesystem::create_directories(dir, ec);
+  if (ec) {
+    ESP_LOGE(TAG, "Could not create snapshot directory %s: %s", dir.c_str(), ec.message().c_str());
+    return false;
+  }
+
+  // O_EXCL guarantees we never write over a file that is already there.
+  std::string path;
+  int fd = -1;
+  for (unsigned attempt = 0; attempt < MAX_NAME_ATTEMPTS; attempt++) {
+    path = dir + "/" + (attempt == 0 ? name : add_suffix(name, attempt));
+    fd = ::open(path.c_str(), O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW, 0644);
+    if (fd >= 0)
+      break;
+    if (errno != EEXIST) {
+      ESP_LOGE(TAG, "Could not create %s: %s", path.c_str(), strerror(errno));
+      return false;
+    }
+    if (exact) {
+      // The caller asked for this exact name, so silently writing somewhere else would be worse
+      // than failing - a test asserting on the path would pick up a stale file.
+      ESP_LOGE(TAG, "Snapshot %s already exists, not overwriting", path.c_str());
+      return false;
+    }
+  }
+  if (fd < 0) {
+    ESP_LOGE(TAG, "Could not find an unused name for %s in %s", name.c_str(), dir.c_str());
+    return false;
+  }
+
+  FILE *file = fdopen(fd, "wb");
+  if (file == nullptr) {
+    ESP_LOGE(TAG, "Could not open %s: %s", path.c_str(), strerror(errno));
+    ::close(fd);
+    ::unlink(path.c_str());
+    return false;
+  }
+  bool ok = write_bmp(file, pixels, width, height, row_stride);
+  int saved_errno = ok ? 0 : errno;
+  // Closing can fail in its own right - the last of the data is still on its way out.
+  if (fclose(file) != 0) {
+    if (ok)
+      saved_errno = errno;
+    ok = false;
+  }
+  if (!ok) {
+    ESP_LOGE(TAG, "Could not write %s: %s", path.c_str(), strerror(saved_errno));
+    // Leave no truncated file behind - it would block a retry under the same name.
+    ::unlink(path.c_str());
+    return false;
+  }
+  ESP_LOGI(TAG, "Snapshot written to %s", path.c_str());
+  return true;
+}
+
+}  // namespace
+
+// helper function since ESP_LOGW is disallowed in a header file
+void Snapshot::log_action_failed() { ESP_LOGW(TAG, "snapshot.take did not write a file"); }
+
+bool Snapshot::take_snapshot(const char *filename) {
+  const int width = this->snapshot_width();
+  const int height = this->snapshot_height();
+  if (width <= 0 || height <= 0) {
+    ESP_LOGE(TAG, "Snapshot requested but the display is %dx%d", width, height);
+    return false;
+  }
+
+  std::string name;
+  bool exact = false;
+  if (filename != nullptr) {
+    bool name_changed = false;
+    name = sanitise_filename(filename, &name_changed);
+    exact = !name.empty();
+    if (name_changed) {
+      ESP_LOGW(TAG, "Requested snapshot name '%s' is not an acceptable file name, using '%s' instead", filename,
+               name.empty() ? "a name made from the time" : name.c_str());
+    }
+  }
+  if (name.empty()) {
+    struct timespec now {};
+    if (clock_gettime(CLOCK_REALTIME, &now) != 0)
+      now = {};
+    struct tm tm_buf {};
+    if (localtime_r(&now.tv_sec, &tm_buf) == nullptr)
+      tm_buf = {};
+    char stamp[32]{};
+    // ::strftime to be sure of the one from <ctime>; display has an unrelated member of that name
+    if (::strftime(stamp, sizeof(stamp), "%Y%m%d-%H%M%S", &tm_buf) == 0)
+      snprintf(stamp, sizeof(stamp), "unknown-time");
+    char buffer[MAX_NAME_LENGTH];
+    int written =
+        snprintf(buffer, sizeof(buffer), "%s-%s-%03ld.bmp", this->snapshot_prefix_, stamp, now.tv_nsec / 1000000);
+    if (written < 0 || static_cast<size_t>(written) >= sizeof(buffer)) {
+      ESP_LOGW(TAG, "Could not build a timestamped snapshot name, using a fallback");
+      snprintf(buffer, sizeof(buffer), "snapshot.bmp");
+    }
+    name = buffer;
+  }
+
+  // Rows are padded out to a multiple of four bytes, as the file wants them, so each one can be
+  // written straight from the buffer. Zeroed on allocation, which is what the padding must be.
+  const size_t row_stride = bmp_row_size(width);
+  auto pixels = std::make_unique<uint8_t[]>(row_stride * height);
+  if (!this->capture_bgr(pixels.get(), row_stride))
+    return false;
+  return write_snapshot_file(pixels.get(), width, height, row_stride, name, exact);
+}
+
+}  // namespace esphome::snapshot
+#endif
@@ -0,0 +1,72 @@
+#pragma once
+
+#ifdef USE_HOST
+#include "esphome/core/automation.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+// Directory snapshots are written to. Normally set by codegen to a folder under .esphome; the
+// fallback keeps the component compiling for static analysis, where no defines.h is generated.
+#ifndef ESPHOME_SNAPSHOT_DIR
+#define ESPHOME_SNAPSHOT_DIR "."
+#endif
+
+namespace esphome::snapshot {
+
+/// Base for anything that can hand over the picture it is showing so it can be written to a file.
+///
+/// A subclass says how big the picture is and fills in the pixels. Everything else - picking a
+/// name, staying inside the snapshot directory, not writing over anything, and encoding the file -
+/// is done here, so every component that can take a snapshot behaves the same way.
+class Snapshot {
+ public:
+  virtual ~Snapshot() = default;
+
+  /// Set the word generated names start with. Codegen passes the component id, so with more than
+  /// one display in a device it is clear which one a file came from.
+  void set_snapshot_prefix(const char *prefix) { this->snapshot_prefix_ = prefix; }
+
+  /// Write the current picture to a BMP file in the snapshot directory.
+  ///
+  /// Pass nullptr to have a name made up from the prefix and the current time. A file that is
+  /// already there is never written over. Returns true if a file was written.
+  bool take_snapshot(const char *filename);
+
+  /// Log that an action-triggered snapshot did not write a file.
+  static void log_action_failed();
+
+ protected:
+  /// Width of the picture in pixels.
+  virtual int snapshot_width() = 0;
+  /// Height of the picture in pixels.
+  virtual int snapshot_height() = 0;
+  /// Fill in the picture: three bytes per pixel in blue, green, red order, topmost row first, with
+  /// `row_stride` bytes from the start of one row to the start of the next. Returns false, having
+  /// logged why, if the picture could not be read.
+  virtual bool capture_bgr(uint8_t *dest, size_t row_stride) = 0;
+
+  const char *snapshot_prefix_{"snapshot"};
+};
+
+template<typename... Ts> class SnapshotAction final : public Action<Ts...>, public Parented<Snapshot> {
+ public:
+  TEMPLATABLE_VALUE(std::string, filename)
+
+ protected:
+  void play(const Ts &...x) override {
+    bool ok;
+    if (this->filename_.has_value()) {
+      ok = this->parent_->take_snapshot(this->filename_.value(x...).c_str());
+    } else {
+      ok = this->parent_->take_snapshot(nullptr);
+    }
+    if (!ok)
+      this->parent_->log_action_failed();
+  }
+};
+
+}  // namespace esphome::snapshot
+
+#endif
@@ -33,7 +33,13 @@ CONFIG_SCHEMA = (
 )

 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "t6615", baud_rate=19200, require_rx=True, require_tx=True
+    "t6615",
+    baud_rate=19200,
+    require_rx=True,
+    require_tx=True,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
 )


@@ -88,7 +88,6 @@ void T6615Component::query_ppm_() {
 void T6615Component::dump_config() {
  ESP_LOGCONFIG(TAG, "T6615:");
  LOG_SENSOR("  ", "CO2", this->co2_sensor_);
-  this->check_uart_settings(19200);
 }

 }  // namespace esphome::t6615
@@ -35,6 +35,22 @@ CONFIG_SCHEMA = (
 )


+def _final_validate(config: ConfigType) -> ConfigType:
+    # Historical mode runs at 1200 baud, standard mode at 9600 baud.
+    baud_rate = 1200 if config[CONF_HISTORICAL_MODE] else 9600
+    uart.final_validate_device_schema(
+        "teleinfo",
+        baud_rate=baud_rate,
+        data_bits=7,
+        parity="EVEN",
+        stop_bits=1,
+    )(config)
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
 async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID], config[CONF_HISTORICAL_MODE])
    await cg.register_component(var, config)
@@ -184,10 +184,7 @@ void TeleInfo::publish_value_(const std::string &tag, const std::string &val) {
    element->publish_val(val);
  }
 }
-void TeleInfo::dump_config() {
-  ESP_LOGCONFIG(TAG, "TeleInfo:");
-  this->check_uart_settings(baud_rate_, 1, uart::UART_CONFIG_PARITY_EVEN, 7);
-}
+void TeleInfo::dump_config() { ESP_LOGCONFIG(TAG, "TeleInfo:"); }
 TeleInfo::TeleInfo(bool historical_mode) {
  if (historical_mode) {
    /*
@@ -195,11 +192,9 @@ TeleInfo::TeleInfo(bool historical_mode) {
     */
    checksum_area_end_ = 2;
    separator_ = 0x20;
-    baud_rate_ = 1200;
  } else {
    checksum_area_end_ = 1;
    separator_ = 0x9;
-    baud_rate_ = 9600;
  }
 }
 void TeleInfo::register_teleinfo_listener(TeleInfoListener *listener) { teleinfo_listeners_.push_back(listener); }
@@ -31,7 +31,6 @@ class TeleInfo final : public PollingComponent, public uart::UARTDevice {
  std::vector<TeleInfoListener *> teleinfo_listeners_{};

 protected:
-  uint32_t baud_rate_;
  int checksum_area_end_;
  int separator_;
  char buf_[MAX_BUF_SIZE];
@@ -36,8 +36,6 @@ cover::CoverTraits Tormatic::get_traits() {

 void Tormatic::dump_config() {
  LOG_COVER("", "Tormatic Cover", this);
-  this->check_uart_settings(9600, 1, uart::UART_CONFIG_PARITY_NONE, 8);
-
  ESP_LOGCONFIG(TAG,
                "  Open Duration: %.1fs\n"
                "  Close Duration: %.1fs",
@@ -3,6 +3,7 @@
 #include <vector>
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "uart_component.h"

@@ -66,6 +67,7 @@ class UARTDevice {
  }

  /// Check that the configuration of the UART bus matches the provided values and otherwise print a warning
+  ESPDEPRECATED("Use uart.final_validate_device_schema() in Python instead. Removed in 2027.3.0", "2026.9.0")
  void check_uart_settings(uint32_t baud_rate, uint8_t stop_bits = 1,
                           UARTParityOptions parity = UART_CONFIG_PARITY_NONE, uint8_t data_bits = 8);

@@ -30,6 +30,7 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
    require_tx=True,
    require_rx=True,
    baud_rate=2400,
+    data_bits=8,
    parity="EVEN",
    stop_bits=1,
 )
@@ -213,7 +213,6 @@ void UFM01Component::dump_config() {
  LOG_BINARY_SENSOR("  ", "Empty Tube", this->empty_tube_binary_sensor_);
  LOG_BINARY_SENSOR("  ", "Flow Rate Out Of Range", this->flow_rate_out_of_range_binary_sensor_);
 #endif
-  this->check_uart_settings(2400, 1, uart::UART_CONFIG_PARITY_EVEN, 8);
 }

 void UFM01Component::on_active_frame_(uint8_t data[FRAME_SIZE]) {
@@ -50,7 +50,7 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
    require_tx=True,
    require_rx=True,
    data_bits=8,
-    parity=None,
+    parity="NONE",
    stop_bits=1,
 )

@@ -29,8 +29,6 @@ void UponorSmatrixComponent::dump_config() {
  }
 #endif

-  this->check_uart_settings(19200);
-
  if (!this->unknown_devices_.empty()) {
    ESP_LOGCONFIG(TAG, "  Detected unknown device addresses:");
    for (auto device_address : this->unknown_devices_) {
@@ -29,6 +29,14 @@ CONFIG_SCHEMA = uart.UART_DEVICE_SCHEMA.extend(
    }
 )

+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "vbus",
+    baud_rate=9600,
+    data_bits=8,
+    parity="NONE",
+    stop_bits=1,
+)
+

 async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
@@ -11,10 +11,7 @@ static const char *const TAG = "vbus";
 // Maximum bytes to log in verbose hex output (16 frames * 4 bytes = 64 bytes typical)
 static constexpr size_t VBUS_MAX_LOG_BYTES = 64;

-void VBus::dump_config() {
-  ESP_LOGCONFIG(TAG, "VBus:");
-  check_uart_settings(9600);
-}
+void VBus::dump_config() { ESP_LOGCONFIG(TAG, "VBus:"); }

 static void septet_spread(uint8_t *data, int start, int count, uint8_t septet) {
  for (int i = 0; i < count; i++, septet >>= 1) {
@@ -12,7 +12,6 @@ from esphome.components.logger import request_log_listener
 from esphome.components.web_server_base import CONF_WEB_SERVER_BASE_ID
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_AP,
    CONF_AUTH,
    CONF_COMPRESSION,
    CONF_CSS_INCLUDE,
@@ -24,19 +23,15 @@ from esphome.const import (
    CONF_JS_URL,
    CONF_LOCAL,
    CONF_LOG,
-    CONF_MANUAL_IP,
    CONF_NAME,
-    CONF_NETWORKS,
    CONF_OTA,
    CONF_PASSWORD,
    CONF_PORT,
-    CONF_STATIC_IP,
    CONF_TYPE,
    CONF_USERNAME,
    CONF_VERSION,
    CONF_WEB_SERVER,
    CONF_WEB_SERVER_ID,
-    CONF_WIFI,
    PLATFORM_BK72XX,
    PLATFORM_ESP32,
    PLATFORM_ESP8266,
@@ -51,23 +46,7 @@ from esphome.types import ConfigType

 _LOGGER = logging.getLogger(__name__)

-
-def AUTO_LOAD() -> list[str]:
-    # No config parameter on purpose: that would make this a late (dynamic) auto-load and
-    # ota.web_server's dependency on web_server_base would not be satisfied in time.
-    auto_load = ["json", "web_server_base"]
-    # The AP mode DNS server (web_server_base/dns_server_esp32_idf) uses socket; only
-    # configs with a WiFi access point can end up in AP mode. CORE.raw_config is set
-    # after package merging, so a wifi block from a package is visible here.
-    wifi = CORE.raw_config.get(CONF_WIFI) if CORE.raw_config else None
-    if (
-        CORE.is_esp32
-        and wifi is not None
-        and (not isinstance(wifi, dict) or CONF_AP in wifi)
-    ):
-        auto_load.append("socket")
-    return auto_load
-
+AUTO_LOAD = ["json", "web_server_base"]

 AUTH_TYPE_BASIC = "basic"
 AUTH_TYPE_DIGEST = "digest"
@@ -226,6 +205,9 @@ def _final_validate_sorting(config: ConfigType) -> None:
        )


+FINAL_VALIDATE_SCHEMA = _final_validate_sorting
+
+
 def _consume_web_server_sockets(config: ConfigType) -> ConfigType:
    """Register socket needs for web_server component."""
    from esphome.components import socket
@@ -352,95 +334,6 @@ async def add_entity_config(entity: MockObj, config: ConfigType) -> None:
    )


-def wifi_is_ap_only(wifi_config: ConfigType | None) -> bool:
-    """AP only: an access point and no network to join, so the device is only ever reached
-    through its own AP."""
-    return (
-        wifi_config is not None
-        and CONF_AP in wifi_config
-        and not wifi_config.get(CONF_NETWORKS)
-    )
-
-
-def serve_local(config: ConfigType, wifi_config: ConfigType | None) -> bool:
-    """Embed the interface unless ``local:`` says otherwise; AP only WiFi has no internet
-    for the hosted page. Version 1 has no local mode."""
-    if (local := config.get(CONF_LOCAL)) is not None:
-        return local
-    return config[CONF_VERSION] != 1 and wifi_is_ap_only(wifi_config)
-
-
-def serve_captive(config: ConfigType, full_config: ConfigType) -> bool:
-    """web_server runs its own captive portal while the AP is up: embedded interface plus
-    an access point, unless captive_portal (which owns that role) is configured. Only on
-    port 80: the OS captive portal probes and the DHCP portal URI always use port 80, so
-    a portal on another port could never be discovered."""
-    wifi_config = full_config.get(CONF_WIFI)
-    return (
-        "captive_portal" not in full_config
-        and config[CONF_PORT] == 80
-        and wifi_config is not None
-        and CONF_AP in wifi_config
-        and serve_local(config, wifi_config)
-    )
-
-
-def _final_validate_ap_mode(config: ConfigType) -> None:
-    full_config = fv.full_config.get()
-    wifi_config = full_config.get(CONF_WIFI)
-    captive = serve_captive(config, full_config)
-    local = serve_local(config, wifi_config)
-    if captive:
-        web_server_base.consume_captive_dns_sockets(config, "web_server")
-    # Surface behavior that the config does not spell out.
-    if local and CONF_LOCAL not in config:
-        _LOGGER.info(
-            "WiFi is AP only: embedding the web interface in the firmware "
-            "(local: true, roughly 13 KB of flash for version 2, 78 KB for version 3)%s. "
-            "Set 'local: false' to load it from the internet instead.",
-            " and serving it as a captive portal on the access point"
-            if captive
-            else "",
-        )
-    elif captive:
-        _LOGGER.info(
-            "web_server will act as a captive portal while the %saccess point is active.",
-            "" if wifi_is_ap_only(wifi_config) else "fallback ",
-        )
-    if not wifi_is_ap_only(wifi_config):
-        return
-    if not local:
-        _LOGGER.warning(
-            "WiFi is AP only and the web_server interface is loaded from the internet, "
-            "which browsers on the access point usually cannot reach; the page stays "
-            "blank. %s so the interface is embedded in the firmware.",
-            "Remove 'local: false'"
-            if config.get(CONF_LOCAL) is False
-            else "Migrate to version 2 or 3",
-        )
-    elif config[CONF_PORT] != 80:
-        ap_ip = "192.168.4.1"
-        if (manual_ip := wifi_config[CONF_AP].get(CONF_MANUAL_IP)) is not None:
-            ap_ip = str(manual_ip[CONF_STATIC_IP])
-        _LOGGER.warning(
-            "WiFi is AP only and web_server uses port %d. The interface cannot open "
-            "automatically on the access point (captive portal detection only works on "
-            "port 80); open http://%s:%d/ manually, or remove 'port:' to use 80.",
-            config[CONF_PORT],
-            ap_ip,
-            config[CONF_PORT],
-        )
-
-
-def _final_validate(config: ConfigType) -> None:
-    # Called one after the other rather than via cv.All: these return None.
-    _final_validate_sorting(config)
-    _final_validate_ap_mode(config)
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
 def build_index_html(config: ConfigType) -> str:
    html = "<!DOCTYPE html><html><head><meta charset=UTF-8><link rel=icon href=data:>"
    css_include = config.get(CONF_CSS_INCLUDE)
@@ -541,12 +434,8 @@ async def to_code(config: ConfigType) -> None:
        with path.open(encoding="utf-8") as js_file:
            add_resource_as_progmem("JS_INCLUDE", js_file.read())
    cg.add(var.set_include_internal(config[CONF_INCLUDE_INTERNAL]))
-    if serve_local(config, CORE.config.get(CONF_WIFI)):
+    if CONF_LOCAL in config and config[CONF_LOCAL]:
        cg.add_define("USE_WEBSERVER_LOCAL")
-    if serve_captive(config, CORE.config):
-        # AP mode: DNS server plus redirect of unknown URLs so phones open the interface
-        cg.add_define("USE_WEBSERVER_CAPTIVE")
-        web_server_base.add_captive_dns_library()
    if config[CONF_COMPRESSION] == "gzip":
        cg.add_define("USE_WEBSERVER_GZIP")

@@ -44,10 +44,6 @@
 #include "esphome/components/radio_frequency/radio_frequency.h"
 #endif

-#ifdef USE_WEBSERVER_CAPTIVE
-#include "esphome/components/wifi/wifi_component.h"
-#endif
-
 #ifdef USE_WEBSERVER_LOCAL
 #if USE_WEBSERVER_VERSION == 2
 #include "server_index_v2.h"
@@ -338,15 +334,7 @@ void DeferredUpdateEventSourceList::on_client_disconnect_(DeferredUpdateEventSou
 }
 #endif

-#ifdef USE_WEBSERVER_CAPTIVE
-WebServer *global_web_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-#endif
-
-WebServer::WebServer(web_server_base::WebServerBase *base) : base_(base) {
-#ifdef USE_WEBSERVER_CAPTIVE
-  global_web_server = this;
-#endif
-}
+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; }
@@ -392,11 +380,6 @@ void WebServer::setup() {
  this->base_->add_handler(&this->events_);
 #endif
  this->base_->add_handler(this);
-#ifdef USE_WEBSERVER_CAPTIVE
-  // Not-found fallback (outside the auth middleware): the OS captive portal probes hit
-  // arbitrary URLs and must get the redirect without credentials.
-  this->base_->get_server()->onNotFound([this](AsyncWebServerRequest *request) { this->handle_not_found_(request); });
-#endif

  // OTA is now handled by the web_server OTA platform

@@ -412,52 +395,16 @@ void WebServer::setup() {
  });
 }
 void WebServer::loop() {
-  bool keep_looping = this->events_.loop();
-#ifdef USE_WEBSERVER_CAPTIVE
-  this->dns_.loop();
-  keep_looping |= this->dns_.is_running();
-#endif
-  // No SSE clients connected (and no captive DNS to serve); stop looping until a new client connects via
+  // No SSE clients connected; stop looping until a new client connects via
  // enable_loop_soon_any_context(). This is safe because:
  // - set_interval/set_timeout/defer run via the Scheduler, independent of loop()
  // - deferrable_send_state early-outs when no clients are connected
  // - try_send_nodefer (log, ping) iterates sessions which are empty
  // - REST API handlers use defer() which runs via the Scheduler
-  if (!keep_looping)
+  if (!this->events_.loop())
    this->disable_loop();
 }

-#ifdef USE_WEBSERVER_CAPTIVE
-void WebServer::start_captive() {
-  // CaptiveDNS::start() no-ops too; this guard just avoids repeating the log and enable_loop
-  if (this->dns_.is_running())
-    return;
-  network::IPAddress ip = wifi::global_wifi_component->wifi_soft_ap_ip();
-  this->dns_.start(ip);
-  this->enable_loop();
-  char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
-  ESP_LOGI(TAG, "AP mode: serving the web interface as captive portal at http://%s/", ip.str_to(ip_buf));
-}
-
-void WebServer::end_captive() { this->dns_.stop(); }
-
-void WebServer::handle_not_found_(AsyncWebServerRequest *request) {
-  // OS captive portal probe (or any other unknown page) while the AP is up: send the browser
-  // to the real page. A redirect rather than the page itself, because the interface resolves
-  // its /events and REST paths relative to the page URL.
-  if (this->dns_.is_running() && request->method() == HTTP_GET) {
-    // Captive mode requires port 80 (enforced at validation), so no port suffix is needed.
-    char location[7 + network::IP_ADDRESS_BUFFER_SIZE + 1];
-    size_t pos = buf_append_str(location, sizeof(location), 0, "http://");
-    wifi::global_wifi_component->wifi_soft_ap_ip().str_to(location + pos);
-    buf_append_str(location, sizeof(location), strlen(location), "/");
-    request->redirect(location);
-    return;
-  }
-  request->send(404);
-}
-#endif
-
 #ifdef USE_LOGGER
 void WebServer::on_log(uint8_t level, const char *tag, const char *message, size_t message_len) {
  (void) level;
@@ -4,9 +4,6 @@

 #include "esphome/components/json/json_util.h"
 #include "esphome/components/web_server_base/web_server_base.h"
-#ifdef USE_WEBSERVER_CAPTIVE
-#include "esphome/components/web_server_base/captive_dns.h"
-#endif
 #ifdef USE_WEBSERVER
 #include "esphome/core/component.h"
 #include "esphome/core/controller.h"
@@ -279,18 +276,6 @@ class WebServer final : public Controller, public Component, public AsyncWebHand
  /// Handle an index request under '/'.
  void handle_index_request(AsyncWebServerRequest *request);

-#ifdef USE_WEBSERVER_CAPTIVE
-  /** AP mode: run a DNS server that answers every name with the AP address and redirect any
-   * unknown URL to the interface, so a phone joining the AP opens it through the OS captive
-   * portal check. Started and ended by the wifi component with the access point. start may run
-   * before setup() (wifi sets up first): safe because enable_loop() is a no-op before setup;
-   * nothing but the DNS server may be touched, in particular not base_ or the handlers.
-   */
-  void start_captive();
-  void end_captive();
-  bool is_captive() const { return this->dns_.is_running(); }
-#endif
-
  /// Return the webserver configuration as JSON.
  json::SerializationBuffer<> get_config_json();

@@ -612,10 +597,6 @@ class WebServer final : public Controller, public Component, public AsyncWebHand
 #elif USE_ARDUINO
  DeferredUpdateEventSourceList events_;
 #endif
-#ifdef USE_WEBSERVER_CAPTIVE
-  void handle_not_found_(AsyncWebServerRequest *request);
-  web_server_base::CaptiveDNS dns_;
-#endif

 #if USE_WEBSERVER_VERSION == 1
  const char *css_url_{nullptr};
@@ -715,9 +696,5 @@ class WebServer final : public Controller, public Component, public AsyncWebHand
 #endif
 };

-#ifdef USE_WEBSERVER_CAPTIVE
-extern WebServer *global_web_server;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-#endif
-
 }  // namespace esphome::web_server
 #endif
@@ -1,9 +1,8 @@
 from pathlib import Path

 import esphome.codegen as cg
-from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, PlatformFramework
+from esphome.const import CONF_ID
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
 from esphome.helpers import copy_file_if_changed
@@ -27,22 +26,6 @@ WebServerBase = web_server_base_ns.class_("WebServerBase")
 CONF_WEB_SERVER_BASE_ID = "web_server_base_id"


-def consume_captive_dns_sockets(config: ConfigType, name: str) -> None:
-    """Register the sockets a captive portal needs on top of the shared HTTP server:
-    1 UDP socket for the DNS server and 3 TCP sockets for the OS captive portal probes,
-    which make several requests that linger in TIME_WAIT."""
-    from esphome.components import socket
-
-    socket.consume_sockets(3, name)(config)
-    socket.consume_sockets(1, name, socket.SocketType.UDP)(config)
-
-
-def add_captive_dns_library() -> None:
-    """Pull in the Arduino DNSServer library used by CaptiveDNS off ESP32."""
-    if CORE.using_arduino and (CORE.is_esp8266 or CORE.is_libretiny or CORE.is_rp2):
-        cg.add_library("DNSServer", None)
-
-
 def _consume_web_server_base_sockets(config: ConfigType) -> ConfigType:
    """Register the shared listening socket for the HTTP server.

@@ -98,15 +81,3 @@ async def to_code(config: ConfigType) -> None:
            cg.add_platformio_option("extra_scripts", ["pre:fix_rp2040_hash.py"])
        # https://github.com/ESP32Async/ESPAsyncWebServer/blob/main/library.json
        cg.add_library("ESP32Async/ESPAsyncWebServer", "3.9.6")
-
-
-# The DNS server used for captive portals on ESP32; other platforms use the Arduino
-# DNSServer library. Its source is also guarded by USE_CAPTIVE_PORTAL / USE_WEBSERVER_CAPTIVE.
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "dns_server_esp32_idf.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP32_IDF,
-        },
-    }
-)
@@ -1,58 +0,0 @@
-#pragma once
-#include "esphome/core/defines.h"
-// DNS server that answers every name with the access point address, so a phone joining the
-// AP runs its captive portal check against the device. Shared by captive_portal and the
-// web_server AP mode; hides the ESP32 (own implementation) vs Arduino (DNSServer library) split.
-#if defined(USE_CAPTIVE_PORTAL) || defined(USE_WEBSERVER_CAPTIVE)
-#include <memory>
-
-#include "esphome/components/network/ip_address.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/progmem.h"
-#if defined(USE_ESP32)
-#include "dns_server_esp32_idf.h"
-#elif defined(USE_ARDUINO)
-#include <DNSServer.h>
-#endif
-
-namespace esphome::web_server_base {
-
-// The server object only exists while running, so an idle owner (AP not up) pays one pointer.
-class CaptiveDNS {
- public:
-  void start(const network::IPAddress &ip) {
-    if (this->dns_server_ != nullptr)
-      return;
-    this->dns_server_ = make_unique<DNSServer>();
-#if defined(USE_ESP32)
-    this->dns_server_->start(ip);
-#elif defined(USE_ARDUINO)
-    this->dns_server_->setErrorReplyCode(DNSReplyCode::NoError);
-    this->dns_server_->start(53, ESPHOME_F("*"), ip);
-#endif
-  }
-  void stop() {
-    if (this->dns_server_ == nullptr)
-      return;
-    this->dns_server_->stop();
-    this->dns_server_ = nullptr;
-  }
-  /// Answer one pending query; call from the owner's loop() while running.
-  void loop() {
-    if (this->dns_server_ == nullptr)
-      return;
-#if defined(USE_ESP32)
-    this->dns_server_->process_next_request();
-#elif defined(USE_ARDUINO)
-    this->dns_server_->processNextRequest();
-#endif
-  }
-  bool is_running() const { return this->dns_server_ != nullptr; }
-
- protected:
-  // ESP32: web_server_base::DNSServer from dns_server_esp32_idf.h; Arduino: the library class.
-  std::unique_ptr<DNSServer> dns_server_;
-};
-
-}  // namespace esphome::web_server_base
-#endif  // USE_CAPTIVE_PORTAL || USE_WEBSERVER_CAPTIVE
@@ -325,9 +325,9 @@ StringRef AsyncWebServerRequest::url_to(std::span<char, URL_BUF_SIZE> buffer) co
  return StringRef(buffer.data(), decoded_len);
 }

-void AsyncWebServerRequest::redirect(const char *url) {
+void AsyncWebServerRequest::redirect(const std::string &url) {
  httpd_resp_set_status(*this, "302 Found");
-  httpd_resp_set_hdr(*this, "Location", url);
+  httpd_resp_set_hdr(*this, "Location", url.c_str());
  httpd_resp_set_hdr(*this, "Connection", "close");
  httpd_resp_send(*this, nullptr, 0);
 }
@@ -126,8 +126,7 @@ class AsyncWebServerRequest {
  void requestAuthentication() const;
 #endif

-  void redirect(const char *url);
-  void redirect(const std::string &url) { this->redirect(url.c_str()); }
+  void redirect(const std::string &url);

  inline void ESPHOME_ALWAYS_INLINE send(AsyncWebServerResponse *response) {
    httpd_resp_send(*this, response->get_content_data(), response->get_content_size());
@@ -36,9 +36,6 @@
 #ifdef USE_CAPTIVE_PORTAL
 #include "esphome/components/captive_portal/captive_portal.h"
 #endif
-#ifdef USE_WEBSERVER_CAPTIVE
-#include "esphome/components/web_server/web_server.h"
-#endif

 #ifdef USE_IMPROV
 #include "esphome/components/esp32_improv/esp32_improv_component.h"
@@ -744,9 +741,9 @@ void WiFiComponent::start() {
    if (captive_portal::global_captive_portal != nullptr) {
      this->wifi_sta_pre_setup_();
      this->start_scanning();
+      captive_portal::global_captive_portal->start();
    }
 #endif
-    this->start_ap_portal_();
 #endif  // USE_WIFI_AP
  }
 #ifdef USE_IMPROV
@@ -807,8 +804,8 @@ void WiFiComponent::loop() {
          this->check_connecting_finished(now);
          break;
        }
-        // Use longer cooldown when a portal/improv is active to avoid disrupting a user on the AP
-        bool portal_active = this->is_ap_portal_active_() || this->is_esp32_improv_active_();
+        // 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_();
        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
@@ -885,11 +882,13 @@ void WiFiComponent::loop() {
        ESP_LOGI(TAG, "Starting fallback AP");
        this->setup_ap_config_();
 #ifdef USE_CAPTIVE_PORTAL
-        // Reset so we force one full scan after captive portal starts
-        // (previous scans were filtered because captive portal wasn't active yet)
-        this->has_completed_scan_after_captive_portal_start_ = false;
+        if (captive_portal::global_captive_portal != nullptr) {
+          // Reset so we force one full scan after captive portal starts
+          // (previous scans were filtered because captive portal wasn't active yet)
+          this->has_completed_scan_after_captive_portal_start_ = false;
+          captive_portal::global_captive_portal->start();
+        }
 #endif
-        this->start_ap_portal_();
      }
    }
 #endif  // USE_WIFI_AP
@@ -1636,8 +1635,10 @@ void WiFiComponent::check_connecting_finished(uint32_t now) {
    this->retry_phase_ = WiFiRetryPhase::INITIAL_CONNECT;
    this->num_retried_ = 0;
    if (this->has_ap()) {
-#ifdef USE_WIFI_AP
-      this->end_ap_portal_();
+#ifdef USE_CAPTIVE_PORTAL
+      if (this->is_captive_portal_active_()) {
+        captive_portal::global_captive_portal->end();
+      }
 #endif
      ESP_LOGD(TAG, "Disabling AP");
      this->wifi_mode_({}, false);
@@ -1964,10 +1965,10 @@ bool WiFiComponent::transition_to_phase_(WiFiRetryPhase new_phase) {
      break;

    case WiFiRetryPhase::RESTARTING_ADAPTER:
-      // Skip actual adapter restart if a portal/improv is active
+      // 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 portal/improv connection
-      if (!this->is_ap_portal_active_() && !this->is_esp32_improv_active_()) {
+      // without disrupting the captive portal/improv connection
+      if (!this->is_captive_portal_active_() && !this->is_esp32_improv_active_()) {
        this->restart_adapter();
      } else {
        // Even when skipping full restart, disconnect to clear driver state
@@ -2226,38 +2227,6 @@ bool WiFiComponent::is_captive_portal_active_() {
  return false;
 #endif
 }
-
-bool WiFiComponent::is_ap_portal_active_() {
-#ifdef USE_WEBSERVER_CAPTIVE
-  if (web_server::global_web_server->is_captive())
-    return true;
-#endif
-  return this->is_captive_portal_active_();
-}
-
-#ifdef USE_WIFI_AP
-// global_web_server needs no null check: codegen always instantiates WebServer when
-// USE_WEBSERVER_CAPTIVE is defined, and the constructor assigns the global.
-void WiFiComponent::start_ap_portal_() {
-#ifdef USE_CAPTIVE_PORTAL
-  if (captive_portal::global_captive_portal != nullptr)
-    captive_portal::global_captive_portal->start();
-#endif
-#ifdef USE_WEBSERVER_CAPTIVE
-  web_server::global_web_server->start_captive();
-#endif
-}
-
-void WiFiComponent::end_ap_portal_() {
-#ifdef USE_CAPTIVE_PORTAL
-  if (this->is_captive_portal_active_())
-    captive_portal::global_captive_portal->end();
-#endif
-#ifdef USE_WEBSERVER_CAPTIVE
-  web_server::global_web_server->end_captive();
-#endif
-}
-#endif  // USE_WIFI_AP
 bool WiFiComponent::is_esp32_improv_active_() {
 #ifdef USE_IMPROV
  return esp32_improv::global_improv_component != nullptr && esp32_improv::global_improv_component->is_active();
@@ -40,11 +40,6 @@
 #include <ESP8266WiFi.h>
 #include <ESP8266WiFiType.h>

-#if defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE < VERSION_CODE(2, 4, 0)
-extern "C" {
-#include <user_interface.h>
-};
-#endif
 #endif

 #ifdef USE_RP2
@@ -796,12 +791,6 @@ class WiFiComponent final : public Component {
  network::IPAddress wifi_dns_ip_(int num);

  bool is_captive_portal_active_();
-  /// captive_portal or the web_server AP mode is serving a user on the access point
-  bool is_ap_portal_active_();
-#ifdef USE_WIFI_AP
-  void start_ap_portal_();
-  void end_ap_portal_();
-#endif
  bool is_esp32_improv_active_();

 #ifdef USE_WIFI_FAST_CONNECT
@@ -21,7 +21,6 @@ extern "C" {
 #include "lwip/apps/sntp.h"
 #include "lwip/netif.h"  // struct netif
 #include <AddrList.h>
-#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0)
 #include "LwipDhcpServer.h"
 #if USE_ARDUINO_VERSION_CODE < VERSION_CODE(3, 1, 0)
 #include <ESP8266WiFi.h>
@@ -30,7 +29,6 @@ extern "C" {
 #define wifi_softap_set_dhcps_lease_time(time) dhcpSoftAP.set_dhcps_lease_time(time)
 #define wifi_softap_set_dhcps_offer_option(offer, mode) dhcpSoftAP.set_dhcps_offer_option(offer, mode)
 #endif
-#endif
 }

 #include "esphome/core/application.h"
@@ -293,7 +291,6 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
    conf.bssid_set = 0;
  }

-#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 4, 0)
  if (ap.password_.empty()) {
    conf.threshold.authmode = AUTH_OPEN;
  } else {
@@ -310,7 +307,6 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
    }
  }
  conf.threshold.rssi = -127;
-#endif

  ETS_UART_INTR_DISABLE();
  bool ret = wifi_station_set_config_current(&conf);
@@ -602,7 +598,6 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
 #endif
      break;
    }
-#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 4, 0)
    case EVENT_OPMODE_CHANGED: {
      auto it = event->event_info.opmode_changed;
      ESP_LOGV(TAG, "Changed Mode old=%s new=%s", LOG_STR_ARG(get_op_mode_str(it.old_opmode)),
@@ -620,7 +615,6 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
 #endif
      break;
    }
-#endif
    default:
      break;
  }
@@ -705,7 +699,6 @@ bool WiFiComponent::wifi_scan_start_(bool passive) {
  config.bssid = nullptr;
  config.channel = 0;
  config.show_hidden = 1;
-#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 4, 0)
  config.scan_type = passive ? WIFI_SCAN_TYPE_PASSIVE : WIFI_SCAN_TYPE_ACTIVE;
  // Use shorter dwell times for roaming scans - we only need to detect strong
  // nearby APs, not do a thorough survey. This also reduces off-channel time
@@ -724,7 +717,6 @@ bool WiFiComponent::wifi_scan_start_(bool passive) {
    config.scan_time.active.min = roaming ? SCAN_ACTIVE_MIN_ROAMING_MS : SCAN_ACTIVE_MIN_DEFAULT_MS;
    config.scan_time.active.max = roaming ? SCAN_ACTIVE_MAX_ROAMING_MS : SCAN_ACTIVE_MAX_DEFAULT_MS;
  }
-#endif
  bool ret = wifi_station_scan(&config, &WiFiComponent::s_wifi_scan_done_callback);
  if (!ret) {
    ESP_LOGV(TAG, "wifi_station_scan failed");
@@ -830,7 +822,7 @@ bool WiFiComponent::wifi_ap_ip_config_(const optional<ManualIP> &manual_ip) {
    return false;
  }

-#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0) && USE_ARDUINO_VERSION_CODE < VERSION_CODE(3, 1, 0)
+#if USE_ARDUINO_VERSION_CODE < VERSION_CODE(3, 1, 0)
  dhcpSoftAP.begin(&info);
 #endif

@@ -1130,16 +1130,10 @@ bool WiFiComponent::wifi_ap_ip_config_(const optional<ManualIP> &manual_ip) {
    return false;
  }

-#if (defined(USE_CAPTIVE_PORTAL) || defined(USE_WEBSERVER_CAPTIVE)) && ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 0)
-  // Configure DHCP Option 114 (Captive Portal URI) if captive portal or the web_server AP
-  // mode is enabled. This provides a standards-compliant way for clients to discover the portal
-#ifdef USE_WEBSERVER_CAPTIVE
-  // web_server AP mode always serves the portal when compiled in
-  const bool has_portal = true;
-#else
-  const bool has_portal = captive_portal::global_captive_portal != nullptr;
-#endif
-  if (has_portal) {
+#if defined(USE_CAPTIVE_PORTAL) && ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 4, 0)
+  // Configure DHCP Option 114 (Captive Portal URI) if captive portal is enabled
+  // This provides a standards-compliant way for clients to discover the captive portal
+  if (captive_portal::global_captive_portal != nullptr) {
    // Buffer must be static - dhcps_set_option_info stores pointer, doesn't copy
    static char captive_portal_uri[24];        // "http://" (7) + IPv4 max (15) + null
    memcpy(captive_portal_uri, "http://", 7);  // NOLINT(bugprone-not-null-terminated-result) - str_to null-terminates
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
J. Nick Koston	ff50ffa154	Derive the registry archive path in one place	2026-09-05 15:19:57 +02:00
J. Nick Koston	c31e02fa0c	Prefer the landed archive while waiting, cap credited bytes, and give the registry wait a deadline	2026-09-05 14:59:01 +02:00
J. Nick Koston	562e5079d1	Share the lock wait with the ESP-IDF registry prefetch and trim the docstrings	2026-09-05 14:18:21 +02:00
J. Nick Koston	a875016b1a	Show the other downloader's progress while a prefetch job waits on its lock	2026-09-05 14:05:37 +02:00
dependabot[bot]anddependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	d1829c495d	Bump prek from 0.5.0 to 0.5.1 (#18977 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-09-04 19:05:36 -04:00
dependabot[bot]anddependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	ce87bf9b17	Bump platformdirs from 4.11.5 to 4.11.7 (#18976 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-09-04 19:05:26 -04:00
Jesse Hills	51ea97deff	[esp32_ble] Reference count BLE advertising (#18943 )	2026-09-05 08:38:55 +12:00
dependabot[bot]anddependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	ab800dc09d	Bump filelock from 3.32.4 to 3.32.5 (#18963 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-09-03 17:19:29 -04:00
J. Nick Kostonandpre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>	f65ab5629e	[esp8266] Drop Arduino framework versions before 3.0.0 (#18917 ) to Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>	2026-09-03 15:16:36 -04:00
esphome[bot]esphome[bot] <115708604+esphome[bot]@users.noreply.github.com>Jonathan Swoboda	b84532d254	Bump bundled esphome-device-builder to 1.14.0 (#18960 ) Co-authored-by: esphome[bot] <115708604+esphome[bot]@users.noreply.github.com> Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>	2026-09-03 12:15:06 +00:00
Keith Burzinski	6b11636491	[remote_transmitter] Fix BK7231N build by limiting the PWM path to BK7238 (#18958 )	2026-09-03 08:12:36 -04:00
Jesse Hills	2bb98f2d64	Merge branch 'beta' into dev	2026-09-03 14:07:41 +12:00
Jesse Hills	25c29fd9e0	Merge pull request #18957 from esphome/bump-2026.9.0b1 2026.9.0b1	2026-09-03 14:07:19 +12:00
Jesse Hills	f3c786c784	Bump version to 2026.10.0-dev	2026-09-03 13:07:21 +12:00
dependabot[bot]anddependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2250430999	Bump zeroconf from 0.151.2 to 0.151.3 (#18951 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-09-02 20:56:51 -04:00
dependabot[bot]anddependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	d1068d582f	Bump ninja from 1.13.0 to 1.13.2 (#18952 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-09-02 20:56:42 -04:00
Jesse Hills	567a981078	Bump version to 2026.9.0b1	2026-09-03 12:16:25 +12:00
Jesse Hills	81ecb87253	Bump version to 2026.10.0-dev	2026-09-03 12:11:56 +12:00
Clyde Stubbs Claude Opus 5 Jesse Hills	f0e2eb96bd	[snapshot][SDL] Display headless mode and snapshots (#17917 ) Co-authored-by: Claude Opus 5 <noreply@anthropic.com> Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>	2026-09-03 09:39:32 +12:00
Keith Burzinskiandpuddly	567f7f9196	[serial_proxy] Skip no-op reconfigure requests (#18953 ) Co-authored-by: puddly <32534428+puddly@users.noreply.github.com>	2026-09-02 15:01:23 -05:00
Jesse Hills	ecbde8ddf4	[uart] Migrate check_uart_settings to final validation (#18940 )	2026-09-03 07:25:08 +12:00