Merge branch 'dev' into platformio-prefetch-git-clones

Tighten comments
Keep local .git paths with pio run
2026-09-05 12:36:07 +00:00 · 2026-09-02 05:16:40 -04:00 · 2026-08-31 17:41:13 -04:00 · 2026-08-31 16:49:39 -04:00 · 2026-08-31 16:31:28 -04:00 · 2026-08-31 16:08:57 -04:00
182 changed files with 1105 additions and 3960 deletions
@@ -374,9 +374,8 @@ 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 needed by the headless display tests, which capture
-        # screenshots.
+        # path. Packages and version must match seed-apt-cache exactly;
+        # libsdl2-dev is unused here and carried only for cache-key parity.
        timeout-minutes: 10
        uses: awalsh128/cache-apt-pkgs-action@553a35bb8ebd9fcabcb1c9451aa4c98e1b4ca8a9 # v1.6.3
        with:
@@ -439,16 +438,6 @@ 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,8 +137,6 @@ 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/
@@ -44,16 +44,6 @@ This document provides essential context for AI models interacting with this pro

 ## 4. Coding Conventions & Style Guide

-**Read the developer documentation before writing a component.** https://developers.esphome.io covers the
-component lifecycle, the main loop, and the reasoning behind the rules below in far more depth than this
-file does, and it is the authority when they disagree. The most useful starting points:
-
-*   https://developers.esphome.io/architecture/components/ - component lifecycle, `setup()`, `loop()`,
-    setup priorities, and how a component is registered.
-*   https://developers.esphome.io/architecture/components/advanced/ - choosing between `loop()`,
-    `set_interval`, `set_timeout` and `defer`; waking the loop from another thread; the RAM cost of each.
-*   https://developers.esphome.io/contributing/code/ - contribution rules, public API and breaking changes.
-
 *   **Formatting:**
    *   **Python:** Uses `ruff` and `flake8` for linting and formatting. Configuration is in `pyproject.toml`.
    *   **C++:** Uses `clang-format` for formatting. Configuration is in `.clang-format`.
@@ -152,47 +142,6 @@ file does, and it is the authority when they disagree. The most useful starting
    *   **Indentation:** Use spaces (two per indentation level), not tabs
    *   **Type aliases:** Prefer `using type_t = int;` over `typedef int type_t;`
    *   **Line length:** Wrap lines at no more than 120 characters
-    *   **Timing in `loop()`:** Never call `millis()` in a `loop()` body. The current tick's timestamp is
-        already cached - use `App.get_loop_component_start_time()` (from `esphome/core/application.h`).
-        Only reach for `millis()` when you genuinely need sub-tick resolution inside a long operation.
-    *   **The main loop runs every 16 ms.** A rate-limit gate shorter than that does nothing: the check
-        passes on essentially every pass of the loop, so it costs a comparison and buys nothing. Pick an
-        interval comfortably coarser than 16 ms, or drop the gate entirely and accept running every loop.
-        ```cpp
-        // Bad - a 10ms gate against a 16ms loop never holds anything back
-        static constexpr uint32_t POLL_INTERVAL_MS = 10;
-        const uint32_t now = millis();
-        if (now - this->last_poll_ < POLL_INTERVAL_MS)
-          return;
-        this->last_poll_ = now;
-        ```
-        ```cpp
-        // Good - an interval that actually rate limits, off the cached timestamp
-        static constexpr uint32_t POLL_INTERVAL_MS = 100;
-        const uint32_t now = App.get_loop_component_start_time();
-        if (now - this->last_poll_ < POLL_INTERVAL_MS)
-          return;
-        this->last_poll_ = now;
-        ```
-        Pick the primitive by cadence: under 250 ms use a gated `loop()`; 500 ms and above use
-        `set_interval`. Full reasoning, including why `set_interval` costs more below 500 ms:
-        https://developers.esphome.io/architecture/components/advanced/#quick-rule-of-thumb
-    *   **Don't override a default with the same value:** if a base class method already returns what you
-        want, do not override it. `Component::get_setup_priority()` returns `setup_priority::DATA`, so a
-        component that wants `DATA` should simply leave it alone.
-        ```cpp
-        // Bad - this is exactly what the base class already does
-        float get_setup_priority() const override { return setup_priority::DATA; }
-        ```
-    *   **Logging string literals:** wrap literals passed as `%s` arguments in `LOG_STR_LITERAL()` so they
-        can be stored in flash rather than RAM.
-        ```cpp
-        // Bad
-        ESP_LOGV(TAG, "Key %u %s", key, pressed ? "pressed" : "released");
-
-        // Good
-        ESP_LOGV(TAG, "Key %u %s", key, pressed ? LOG_STR_LITERAL("pressed") : LOG_STR_LITERAL("released"));
-        ```
    *   **Constructor parameters vs setters:** Component properties that are both **required** and **invariant**
        (never change after construction) should be constructor parameters rather than set via setter methods.
        This makes the dependency explicit and prevents use of the object in an incompletely-initialized state.
@@ -613,33 +562,6 @@ file does, and it is the authority when they disagree. The most useful starting
           Use `cg.add_define("MAX_SERVICES", count)` to set the size from Python configuration.
           Like `std::array` but with vector-like API (`push_back()`, `size()`) and no STL reallocation code.

-           **Listener and child-entity registration lists are the most common case, and the most commonly
-           missed.** A `register_*()` method called once per child at code generation time has a count that
-           is known at compile time, so it should never be a `std::vector`. Use `cg.slot_counter()`: it
-           returns a function that each consumer calls once per slot it will occupy, and after every
-           `to_code` has run it emits the define with the final count. When nothing registers, no define is
-           emitted and the storage plus its registration method compile out entirely.
-           ```python
-           # hub component's __init__.py
-           _request_listener_slot = cg.slot_counter("MY_COMPONENT_LISTENER_COUNT")
-
-
-           async def register_listener(hub: MockObj, var: MockObj) -> None:
-               _request_listener_slot()
-               cg.add(hub.register_listener(var))
-           ```
-           ```cpp
-           #ifdef MY_COMPONENT_LISTENER_COUNT
-             void register_listener(MyComponentListener *listener);
-           #endif
-            protected:
-           #ifdef MY_COMPONENT_LISTENER_COUNT
-             StaticVector<MyComponentListener *, MY_COMPONENT_LISTENER_COUNT> listeners_;
-           #endif
-           ```
-           Request slots from `to_code`, not from a job that runs after `CoroPriority.FINAL` - a late
-           request raises rather than silently undercounting.
-
        3. **Runtime-known sizes:** Use `FixedVector` from `esphome/core/helpers.h` when the size is only known at runtime initialization.
           ```cpp
           // Bad - generates STL realloc code (_M_realloc_insert)
@@ -677,25 +599,9 @@ file does, and it is the authority when they disagree. The most useful starting
           ```
           Linear search on small datasets (1-16 elements) is often faster than hashing/tree overhead, but this depends on lookup frequency and access patterns. For frequent lookups in hot code paths, the O(1) vs O(n) complexity difference may still matter even for small datasets. `std::vector` with simple structs is usually fine—it's the heavy containers (`map`, `set`, `unordered_map`) that should be avoided for small datasets unless profiling shows otherwise.

-        5. **Strings set once from configuration:** Use `StringRef` (`esphome/core/string_ref.h`) rather than
-           `std::string`. Code generation passes a string literal that lives in flash for the life of the
-           program, so storing a `std::string` copies it onto the heap for nothing. `StringRef` is a
-           non-owning pointer plus length; it does not copy, and it must only ever refer to storage that
-           outlives it (a string literal, or a buffer owned elsewhere).
-           ```cpp
-           // Bad - heap copy of a literal that is already in flash
-           void set_keys(std::string keys) { this->keys_ = std::move(keys); }
-           std::string keys_;
-           ```
-           ```cpp
-           // Good - no allocation
-           void set_keys(const char *keys) { this->keys_ = StringRef(keys); }
-           StringRef keys_;
-           ```
+        5. **Avoid `std::deque`:** It allocates in 512-byte blocks regardless of element size, guaranteeing at least 512 bytes of RAM usage immediately. This is a major source of crashes on memory-constrained devices.

-        6. **Avoid `std::deque`:** It allocates in 512-byte blocks regardless of element size, guaranteeing at least 512 bytes of RAM usage immediately. This is a major source of crashes on memory-constrained devices.
-
-        7. **Detection:** Look for these patterns in compiler output:
+        6. **Detection:** Look for these patterns in compiler output:
           - Large code sections with STL symbols (vector, map, set)
           - `alloc`, `realloc`, `dealloc` in symbol names
           - `_M_realloc_insert`, `_M_default_append` (vector reallocation)
@@ -496,7 +496,6 @@ 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.10.0-dev
+PROJECT_NUMBER         = 2026.9.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
@@ -125,45 +125,30 @@ design is optimal or that it will not change.
 ## OTA update encryption

 The `esphome` OTA platform optionally encrypts updates with the same Noise
-`NNpsk0` pattern the native API uses; one key protects the device. A device
-whose `api:` block has an encryption key, static in the YAML or provisioned at
-runtime, compiles in the transport and offers it on every OTA connection once
-it holds a key, so an uploader presenting that key gets the guarantees below
-even without an `ota: encryption:` block; only that block makes the device
-require encryption. The guarantees are: the firmware image is confidential in
-transit, the uploader is authenticated by the pre-shared key, and the plaintext
-negotiation preceding the handshake is bound into the handshake prologue, so
-stripping or tampering with it fails the first MAC. With `ota: encryption:`
-configured both ends fail closed with no override: the device refuses
+`NNpsk0` pattern the native API uses; one key protects the device. With an
+`encryption:` block configured the guarantees are: the firmware image is
+confidential in transit, the uploader is authenticated by the pre-shared key,
+and the plaintext negotiation preceding the handshake is bound into the
+handshake prologue, so stripping or tampering with it fails the first MAC.
+Both ends fail closed with no override: a device built with a key refuses
 plaintext uploads, and the CLI refuses to send plaintext when a key is
-configured. Without that block the CLI tries a static api key when the device
-offers and, until 2027.3.0, falls back to plaintext with a warning when the
-offer is missing or the handshake fails; a runtime provisioned key never
-reaches the CLI, so those uploads stay plaintext.
+configured.

-Defeating any of that without the key is in scope: a device that requires
-encryption accepting a plaintext or downgraded upload, getting past the MAC,
-or recovering image contents from captured traffic.
+Defeating any of that without the key is in scope: a keyed device accepting a
+plaintext or downgraded upload, getting past the MAC, or recovering image
+contents from captured traffic.

 The following are **not** vulnerabilities, by design:

- Plaintext OTA on a device with no `ota: encryption:` block, including one
-  that offers encryption because it has an api key. That is the documented
-  default, authenticated (if at all) by the OTA password. An uploader that
-  takes the offer skips the password; the key authenticates it.
- The CLI plaintext fallback until 2027.3.0: without `ota: encryption:` an
-  active attacker who strips the offer or breaks the handshake can make a
-  keyed CLI upload plaintext, with the pre-existing plaintext exposure. A
-  device that requires encryption still refuses that upload.
- The enablement window: firmware built with a static api key already offers
-  encryption, so turning on `ota: encryption:` is itself an encrypted upload.
-  Older firmware needs one last plaintext upload of an offering build, with
-  the pre-existing plaintext exposure.
- The web OTA `/update` endpoint alongside encryption. The `web_server` OTA
-  platform keeps it always reachable and validation warns about that
-  combination; `captive_portal:` auto-loads that platform only for the
-  fallback AP window, which is the intended recovery path, so that alone is
-  not warned about.
+- Plaintext OTA on a device with no `encryption:` block. That is the
+  documented default, authenticated (if at all) by the OTA password.
+- The enablement window: turning encryption on takes one last upload of the
+  encryption-enabled firmware over the existing plaintext channel, with the
+  pre-existing plaintext exposure.
+- The web OTA `/update` endpoint alongside encryption. The `web_server`
+  component keeps it always reachable, and `captive_portal:` auto-loads it
+  for the fallback AP window; validation warns about both combinations, and
+  the operator keeps the recovery path.
 - CLI retry behavior on transport or MAC failures; every attempt renegotiates
  a fresh handshake with fresh ephemerals, so retrying does not weaken
  authentication.
@@ -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.14.0
+RUN uv pip install --no-cache-dir esphome-device-builder==1.13.1

 RUN \
    platformio settings set enable_telemetry No \
@@ -1325,19 +1325,6 @@ def _choose_ota_platform(config: ConfigType, requested: str | None) -> str:
    return CONF_WEB_SERVER


-def _static_api_encryption_key(config: ConfigType) -> str | None:
-    """The api encryption key when it is fixed in the YAML; None when there is
-    none, when it is provisioned at runtime, or when it is the reserved all
-    zeros key."""
-    from esphome.components.noise import is_reserved_key
-
-    api_conf = config.get(CONF_API) or {}
-    key = (api_conf.get(CONF_ENCRYPTION) or {}).get(CONF_KEY)
-    if not key or is_reserved_key(key):
-        return None
-    return str(key)
-
-
 def _upload_via_native_api(
    config: ConfigType, network_devices: list[str], args: ArgsProtocol
 ) -> tuple[int, str | None]:
@@ -1354,7 +1341,6 @@ def _upload_via_native_api(
    # Fail closed: an encryption block whose key did not resolve must never
    # fall back to a plaintext upload
    noise_psk = None
-    plaintext_fallback = False
    if (encryption_conf := ota_conf.get(CONF_ENCRYPTION)) is not None:
        noise_psk = encryption_conf.get(CONF_KEY)
        if not noise_psk:
@@ -1365,11 +1351,6 @@ def _upload_via_native_api(
        # Ensure the key is a string, as required by the underlying OTA implementation.
        # It arrives here as a SensitiveStr which aioesphomeapi rejects.
        noise_psk = str(noise_psk)
-    elif api_key := _static_api_encryption_key(config):
-        # Remove before 2027.3.0: without an ota block the api key is tried
-        # when the device offers encryption, falling back to plaintext
-        noise_psk = api_key
-        plaintext_fallback = True

    def check_partition_access(option_string: str) -> None:
        if not ota_conf.get("allow_partition_access"):
@@ -1401,13 +1382,7 @@ def _upload_via_native_api(
        _validate_bootloader_binary(binary)

    return espota2.run_ota(
-        network_devices,
-        remote_port,
-        password,
-        binary,
-        ota_type,
-        noise_psk,
-        plaintext_fallback=plaintext_fallback,
+        network_devices, remote_port, password, binary, ota_type, noise_psk
    )


@@ -44,7 +44,8 @@ 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 packages for 3.0.0, 3.0.1 or 3.1.0
+# 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)
 MIN_FRAMEWORK_VERSION = Version(3, 1, 1)


@@ -52,16 +53,20 @@ 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 for 3.x cores; callers floor at MIN_FRAMEWORK_VERSION.
+    Exact registry names only for cores > 2.6.2 and >= 3.0.2; 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.major < 3:
+    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)
        raise EsphomeError(
-            f"Arduino core {ver} is not supported; ESPHome requires core 3.x"
+            f"Arduino core {ver} uses an older package encoding than this "
+            "helper implements (newer than 2.6.2)"
        )
    return f"3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"

@@ -14,7 +14,6 @@ from esphome.components.noise import (  # noqa: F401
    ENCRYPTION_SCHEMA,
    decode_encryption_key,
    encryption_schema,
-    new_psk_progmem,
    validate_encryption_key,
 )
 from esphome.config_helpers import filter_source_files_from_defines, get_logger_level
@@ -590,7 +589,8 @@ async def to_code(config: ConfigType) -> None:

    if (encryption_config := config.get(CONF_ENCRYPTION, None)) is not None:
        if key := encryption_config.get(CONF_KEY):
-            cg.add(var.set_noise_psk(new_psk_progmem(config[CONF_ID], key)))
+            decoded = decode_encryption_key(key)
+            cg.add(var.set_noise_psk(list(decoded)))
            cg.add_define("USE_API_NOISE_PSK_FROM_YAML")
        else:
            # No key provided, but encryption desired
@@ -548,7 +548,7 @@ APIError APINoiseFrameHelper::write_frame_(const uint8_t *data, uint16_t len) {
 * @return 0 on success, -1 on error (check errno)
 */
 APIError APINoiseFrameHelper::init_handshake_() {
-  int err = this->handshake_.init(this->ctx_, prologue_.data(), prologue_.size());
+  int err = this->handshake_.init(this->ctx_.get_psk(), prologue_.data(), prologue_.size());
  APIError aerr = handle_noise_error_(err, LOG_STR("noise_handshake_init"), APIError::HANDSHAKESTATE_SETUP_FAILED);
  if (aerr != APIError::OK)
    return aerr;
@@ -583,17 +583,11 @@ bool APIServer::update_noise_psk_(const SavedNoisePsk &new_psk, const LogString
 }

 bool APIServer::load_and_apply_noise_psk_() {
-#ifdef USE_API_NOISE_PSK_FROM_YAML
-  return false;
-#else
-  // Load into a temp so a failed read cannot disturb the key in use
-  SavedNoisePsk loaded{};
-  if (!this->noise_pref_.load(&loaded))
+  SavedNoisePsk saved{};
+  if (!this->noise_pref_.load(&saved))
    return false;
-  this->saved_psk_ = loaded;
-  this->noise_ctx_.set_psk(this->saved_psk_.psk.data());
+  this->set_noise_psk(saved.psk);
  return true;
-#endif
 }

 bool APIServer::save_noise_psk(noise::psk_t psk, bool make_active) {
@@ -603,7 +597,8 @@ bool APIServer::save_noise_psk(noise::psk_t psk, bool make_active) {
  ESP_LOGW(TAG, "Key set in YAML");
  return false;
 #else
-  if (this->saved_psk_.psk == psk) {
+  auto &old_psk = this->noise_ctx_.get_psk();
+  if (std::equal(old_psk.begin(), old_psk.end(), psk.begin())) {
    ESP_LOGW(TAG, "New PSK matches old");
    return true;
  }
@@ -78,8 +78,7 @@ class APIServer final : public Component,
 #ifdef USE_API_NOISE
  bool save_noise_psk(noise::psk_t psk, bool make_active = true);
  bool clear_noise_psk(bool make_active = true);
-  /// psk points at 32 bytes that live in flash for the life of the program
-  void set_noise_psk(const uint8_t *psk) { this->noise_ctx_.set_psk(psk); }
+  void set_noise_psk(noise::psk_t psk) { this->noise_ctx_.set_psk(psk); }
  noise::NoiseContext &get_noise_ctx() { return this->noise_ctx_; }
 #endif  // USE_API_NOISE

@@ -359,9 +358,6 @@ class APIServer final : public Component,

 #ifdef USE_API_NOISE
  noise::NoiseContext noise_ctx_;
-#ifndef USE_API_NOISE_PSK_FROM_YAML
-  SavedNoisePsk saved_psk_{};  // backs noise_ctx_ for a runtime provisioned key
-#endif
  ESPPreferenceObject noise_pref_;
 #endif  // USE_API_NOISE
 };
@@ -368,8 +368,8 @@ optional<ClimateDeviceRestoreState> Climate::restore_state_() {
 }

 void Climate::save_state_(const ClimateTraits &traits) {
-#if (defined(USE_ESP32) || defined(USE_ESP8266)) && !defined(CLANG_TIDY)
-#pragma GCC diagnostic push
+#if (defined(USE_ESP32) || (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0))) && \
+    !defined(CLANG_TIDY)
 #pragma GCC diagnostic ignored "-Wclass-memaccess"
 #define TEMP_IGNORE_MEMACCESS
 #endif
@@ -100,6 +100,7 @@ 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,14 +46,6 @@ 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,6 +58,7 @@ 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,13 +68,7 @@ CONFIG_SCHEMA = (
 )

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


@@ -255,6 +255,7 @@ 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,12 +84,7 @@ CONFIG_SCHEMA = (
    .extend(cv.COMPONENT_SCHEMA)
 )
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "cse7766",
-    baud_rate=4800,
-    require_rx=True,
-    data_bits=8,
-    parity="EVEN",
-    stop_bits=1,
+    "cse7766", baud_rate=4800, parity="EVEN", require_rx=True
 )


@@ -26,14 +26,6 @@ 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,7 +22,10 @@ static const uint8_t DALY_REQUEST_TEMPERATURE = 0x96;

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

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

 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_);
-#ifdef USE_ESP8266
+#if defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)
  LOG_SENSOR("  ", "Heap fragmentation", this->fragmentation_sensor_);
-#endif  // USE_ESP8266
+#endif  // defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)
 #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) || defined(USE_ESP32)
+#if (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)) || 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) || defined(USE_ESP32)
+#if (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)) || defined(USE_ESP32)
  sensor::Sensor *fragmentation_sensor_{nullptr};
 #endif
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
@@ -159,10 +159,12 @@ 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,9 +52,12 @@ CONFIG_SCHEMA = {
    ),
    cv.Optional(CONF_FRAGMENTATION): cv.All(
        cv.Any(
-            cv.only_on_esp8266,
+            cv.All(
+                cv.only_on_esp8266,
+                cv.require_framework_version(esp8266_arduino=cv.Version(2, 5, 2)),
+            ),
            cv.only_on_esp32,
-            msg="This feature is only available on ESP8266 and ESP32",
+            msg="This feature is only available on ESP8266 (Arduino 2.5.2+) and ESP32",
        ),
        sensor.sensor_schema(
            unit_of_measurement=UNIT_PERCENT,
@@ -60,12 +60,7 @@ CONFIG_SCHEMA = cv.All(
    ).extend(uart.UART_DEVICE_SCHEMA)
 )
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "dfplayer",
-    baud_rate=9600,
-    require_tx=True,
-    data_bits=8,
-    parity="NONE",
-    stop_bits=1,
+    "dfplayer", baud_rate=9600, require_tx=True
 )


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

 }  // namespace esphome::dfplayer
@@ -100,38 +100,21 @@ void ESP32BLE::disable() {
 #ifdef USE_ESP32_BLE_ADVERTISING
 void ESP32BLE::advertising_start() {
  this->advertising_init_();
-  this->advertising_ref_count_++;
-  this->advertising_refresh();
-}
-
-void ESP32BLE::advertising_stop() {
-  if (this->advertising_ref_count_ == 0)
+  if (!this->is_active())
    return;
-  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();
-  }
+  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_refresh();
+  this->advertising_start();
 }

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

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

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

 void ESP32BLE::advertising_register_raw_advertisement_callback(std::function<void(bool)> &&callback) {
@@ -164,13 +147,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_refresh();
+  this->advertising_start();
 }

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

@@ -592,10 +575,6 @@ 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,17 +114,7 @@ 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; }
@@ -236,9 +226,6 @@ 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,8 +67,6 @@ 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,18 +596,6 @@ 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,7 +81,6 @@ 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();
@@ -99,20 +98,6 @@ 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];
@@ -185,7 +170,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_refresh();
+        this->parent_->advertising_start();
      }
      this->dispatch_callbacks_(CallbackType::ON_CONNECT, param->connect.conn_id);
      break;
@@ -193,7 +178,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_refresh();
+      this->parent_->advertising_start();
      this->dispatch_callbacks_(CallbackType::ON_DISCONNECT, param->disconnect.conn_id);
      break;
    }
@@ -241,8 +226,6 @@ 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,13 +38,6 @@ 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_; }

@@ -89,8 +82,6 @@ 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);
@@ -102,8 +93,6 @@ 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,7 +112,6 @@ void ESP32ImprovComponent::loop() {
      this->state_callback_.call(this->state_, this->error_state_);
 #endif
    }
-    this->release_advertising_();
    this->incoming_data_.clear();
    return;
  }
@@ -144,9 +143,8 @@ 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);
-          this->request_advertising_();
+          esp32_ble::global_ble->advertising_start();

          // Set initial state based on whether we have an authorizer
          this->set_state_(this->get_initial_state_(), false);
@@ -328,8 +326,6 @@ 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);
  });
@@ -524,20 +520,6 @@ 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,11 +104,8 @@ 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, board_ld_script
+from .boards import BOARDS, ESP8266_LD_SCRIPTS, board_ld_script
 from .const import (
    CONF_EARLY_PIN_INIT,
    CONF_ENABLE_SERIAL,
@@ -43,6 +43,8 @@ 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,
@@ -131,6 +133,10 @@ 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
@@ -153,9 +159,11 @@ 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 3 framework versions
+# The platformio/espressif8266 version to use for arduino 2 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)
@@ -180,14 +188,6 @@ 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,8 +195,12 @@ 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))
-        else:
+        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)))
    value[CONF_PLATFORM_VERSION] = platform_version

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


-def _choose_ld_script(board: str) -> str:
-    """The flash ld to pin for this board."""
+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]
    # A per-board override preserves a layout the board shipped with
    # (see d1_wroom_02 in boards.py)
-    return board_ld_script(BOARDS[board])
+    return board_ld_script(board_data)


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

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

    CORE.add_job(add_pin_initial_states_array)
    CORE.add_job(finalize_waveform_config)
@@ -1,9 +1,13 @@
 import logging

 import esphome.codegen as cg
-from esphome.components.noise import encryption_schema, is_reserved_key, new_psk_progmem
+from esphome.components.noise import (
+    decode_encryption_key,
+    encryption_schema,
+    is_reserved_key,
+)
 from esphome.components.ota import BASE_OTA_SCHEMA, OTAComponent, ota_to_code
-from esphome.config_helpers import filter_source_files_from_defines, merge_config
+from esphome.config_helpers import merge_config
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_API,
@@ -37,8 +41,7 @@ DEPENDENCIES = ["network"]


 def AUTO_LOAD(config: ConfigType) -> list[str]:
-    """Auto-load noise only when encryption is configured. The api key offer
-    path inherits noise from the api component's own AUTO_LOAD."""
+    """Auto-load noise only when encryption is configured."""
    base = ["sha256", "socket"]
    # A falsy config is a tooling probe for the maximal set (None from
    # dependency resolution, {} from the components-graph platform probe);
@@ -129,41 +132,12 @@ def ota_esphome_final_validate(config: ConfigType) -> None:
        _validate_no_password_with_encryption(ota_conf)
        if (encryption_conf := ota_conf.get(CONF_ENCRYPTION)) is not None:
            _resolve_encryption_key(encryption_conf, api_conf)
-        elif CONF_PASSWORD in ota_conf and (
-            _api_static_key(api_conf) is not None or _api_runtime_key(api_conf)
-        ):
-            _LOGGER.warning(
-                "'%s' %s wastes significant flash and RAM (about 3.5 KB and 60 "
-                "bytes plus the password on the heap): the device already offers "
-                "encryption with the '%s' %s %s, which authenticates any uploader "
-                "that takes it, and a password only matters for uploaders without "
-                "encryption support; remove '%s' and add '%s' under '%s' so "
-                "uploads use the key and encryption is required",
-                CONF_OTA,
-                CONF_PASSWORD,
-                CONF_API,
-                CONF_ENCRYPTION,
-                CONF_KEY,
-                CONF_PASSWORD,
-                CONF_ENCRYPTION,
-                CONF_OTA,
-            )
-    # The captive_portal auto-loads the web_server ota platform too, but that
-    # endpoint only exists while the fallback AP is active and is the intended
-    # recovery path, so it does not warn unless the web_server component is
-    # configured as well
-    captive_portal_only = (
-        CONF_CAPTIVE_PORTAL in full_conf and CONF_WEB_SERVER not in full_conf
-    )
-    if (
-        not captive_portal_only
-        and any(conf.get(CONF_PLATFORM) == CONF_WEB_SERVER for conf in full_ota_conf)
-        and any(
-            CONF_ENCRYPTION in conf
-            for conf in merged_ota_esphome_configs_by_port.values()
-        )
+    if any(
+        conf.get(CONF_PLATFORM) == CONF_WEB_SERVER for conf in full_ota_conf
+    ) and any(
+        CONF_ENCRYPTION in conf for conf in merged_ota_esphome_configs_by_port.values()
    ):
-        _warn_web_server_ota()
+        _warn_web_server_ota(full_conf)

    full_conf[CONF_OTA] = new_ota_conf
    fv.full_config.set(full_conf)
@@ -178,30 +152,25 @@ def ota_esphome_final_validate(config: ConfigType) -> None:
        )


-def _warn_web_server_ota() -> None:
+def _warn_web_server_ota(full_conf: ConfigType) -> None:
    """The web_server ota platform accepts the same image over plaintext HTTP
    with basic auth, bypassing the encryption; warn rather than fail so the
    operator keeps the recovery path."""
-    _LOGGER.warning(
-        "OTA encryption does not cover the %s OTA platform; its "
-        "plaintext /update endpoint accepts the same image",
-        CONF_WEB_SERVER,
-    )
-
-
-def _api_runtime_key(api_conf: ConfigType) -> bool:
-    """True when the api key is provisioned at runtime: an encryption block
-    with no key at all."""
-    return CONF_ENCRYPTION in api_conf and not api_conf[CONF_ENCRYPTION].get(CONF_KEY)
-
-
-def _api_static_key(api_conf: ConfigType) -> str | None:
-    """The api key when fixed at build time; None for a runtime provisioned
-    or all-zeros key, neither can seed the encryption offer."""
-    key = api_conf.get(CONF_ENCRYPTION, {}).get(CONF_KEY)
-    if not key or is_reserved_key(key):
-        return None
-    return key
+    if CONF_CAPTIVE_PORTAL in full_conf and CONF_WEB_SERVER not in full_conf:
+        # The captive_portal auto-load: the endpoint only exists while the
+        # fallback AP is active
+        _LOGGER.warning(
+            "OTA encryption does not cover the %s OTA platform (auto-loaded "
+            "by captive_portal); the plaintext /update endpoint stays "
+            "reachable while the fallback AP is active",
+            CONF_WEB_SERVER,
+        )
+    else:
+        _LOGGER.warning(
+            "OTA encryption does not cover the %s OTA platform; its "
+            "plaintext /update endpoint accepts the same image",
+            CONF_WEB_SERVER,
+        )


 def _resolve_encryption_key(encryption_conf: ConfigType, api_conf: ConfigType) -> None:
@@ -298,9 +267,15 @@ CONFIG_SCHEMA = cv.All(
 FINAL_VALIDATE_SCHEMA = ota_esphome_final_validate


-FILTER_SOURCE_FILES = filter_source_files_from_defines(
-    {"ota_esphome_noise.cpp": "USE_OTA_ENCRYPTION"}
-)
+def FILTER_SOURCE_FILES() -> list[str]:
+    """Filter out the noise transport when no ota entry configures encryption."""
+    for ota_conf in CORE.config.get(CONF_OTA, []):
+        if (
+            ota_conf.get(CONF_PLATFORM) == CONF_ESPHOME
+            and ota_conf.get(CONF_ENCRYPTION) is not None
+        ):
+            return []
+    return ["ota_esphome_noise.cpp"]


@coroutine_with_priority(CoroPriority.OTA_UPDATES)
@@ -321,26 +296,11 @@ async def to_code(config: ConfigType) -> None:
    if config.get(CONF_ALLOW_PARTITION_ACCESS):
        cg.add_define("USE_OTA_PARTITIONS")

-    api_conf = CORE.config.get(CONF_API) or {}
-    from_api = False
    if (encryption_conf := config.get(CONF_ENCRYPTION)) is not None:
        # A missing key was resolved from the api component in final validate.
        key = encryption_conf[CONF_KEY]
-    else:
-        # An api key alone makes the device offer encryption while still
-        # accepting plaintext, so the upload that adds the block is encrypted.
-        # A key provisioned at runtime lives in the api server; the offer then
-        # uses whatever key it holds, so it follows provisioning and rotation.
-        key = _api_static_key(api_conf)
-        from_api = key is None and _api_runtime_key(api_conf)
-    if key is not None or from_api:
        cg.add_define("USE_OTA_ENCRYPTION")
-        if encryption_conf is not None:
-            cg.add_define("USE_OTA_ENCRYPTION_REQUIRED")
-        if from_api:
-            cg.add_define("USE_OTA_ENCRYPTION_FROM_API")
-        else:
-            cg.add(var.set_noise_psk(new_psk_progmem(config[CONF_ID], key)))
+        cg.add(var.set_noise_psk(list(decode_encryption_key(key))))

    # Build flag so lwip_fast_select.c (a .c file that can't include defines.h) sees it.
    cg.add_build_flag("-DUSE_OTA_PLATFORM_ESPHOME")
@@ -97,24 +97,18 @@ void ESPHomeOTAComponent::dump_config() {
  ESP_LOGCONFIG(TAG,
                "Over-The-Air updates:\n"
                "  Address: %s:%u\n"
-                "  Version: %d"
-#ifdef USE_OTA_ENCRYPTION_REQUIRED
-                "\n  Encryption: required"
-#elif defined(USE_OTA_ENCRYPTION) && !defined(USE_OTA_ENCRYPTION_FROM_API)
-                "\n  Encryption: offered, plaintext accepted"
-#endif
-                ,
+                "  Version: %d",
                network::get_use_address_to(addr_buf), this->port_, USE_OTA_VERSION);
-#ifdef USE_OTA_ENCRYPTION_FROM_API
-  ESP_LOGCONFIG(TAG, "  Encryption: offered %s, plaintext accepted",
-                this->noise_context_().has_psk() ? LOG_STR_LITERAL("with the api key")
-                                                 : LOG_STR_LITERAL("once the api key is provisioned"));
-#endif
 #ifdef USE_OTA_PASSWORD
  if (!this->password_.empty()) {
    ESP_LOGCONFIG(TAG, "  Password configured");
  }
 #endif
+#ifdef USE_OTA_ENCRYPTION
+  if (this->noise_ctx_.has_psk()) {
+    ESP_LOGCONFIG(TAG, "  Encryption configured");
+  }
+#endif
 #ifdef USE_OTA_PARTITIONS
  ESP_LOGCONFIG(TAG,
                "  Partition access allowed\n"
@@ -156,6 +150,10 @@ void ESPHomeOTAComponent::loop() {
  this->handle_handshake_();
 }

+static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_COMPRESSION = 0x01;
+static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_SHA256_AUTH = 0x02;
+static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL = 0x04;
+static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_NOISE = 0x08;
 static constexpr uint8_t SERVER_FEATURE_SUPPORTS_COMPRESSION = 0x01;
 static constexpr uint8_t SERVER_FEATURE_SUPPORTS_PARTITION_ACCESS = 0x02;
 static constexpr uint8_t SERVER_FEATURE_SUPPORTS_NOISE = 0x04;
@@ -243,10 +241,12 @@ void ESPHomeOTAComponent::handle_handshake_() {
      this->ota_features_ = this->handshake_buf_[0];
      ESP_LOGV(TAG, "Features: 0x%02X", this->ota_features_);

-#ifdef USE_OTA_ENCRYPTION_REQUIRED
-      // Fail closed: an explicit `ota: encryption:` block means the client must
-      // negotiate encryption; refuse plaintext uploads
-      if ((this->ota_features_ & CLIENT_NOISE_FEATURES) != CLIENT_NOISE_FEATURES) {
+#ifdef USE_OTA_ENCRYPTION
+      // Fail closed: with a PSK configured the client must negotiate encryption
+      // (which requires the extended protocol); refuse plaintext uploads.
+      static constexpr uint8_t NOISE_REQUIRED_FEATURES =
+          CLIENT_FEATURE_SUPPORTS_NOISE | CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL;
+      if (this->noise_ctx_.has_psk() && (this->ota_features_ & NOISE_REQUIRED_FEATURES) != NOISE_REQUIRED_FEATURES) {
        ESP_LOGW(TAG, "Client does not support encryption");
        this->send_error_and_cleanup_(ota::OTA_RESPONSE_ERROR_ENCRYPTION_REQUIRED);
        return;
@@ -261,7 +261,8 @@ void ESPHomeOTAComponent::handle_handshake_() {
      // Compose the feature-ack response. When the client negotiates the extended protocol we emit
      // a 2-byte response (marker + server feature flags); otherwise we emit the single-byte
      // legacy response.
-      if (this->extended_proto_()) {
+      this->extended_proto_ = (this->ota_features_ & CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL) != 0;
+      if (this->extended_proto_) {
        static_assert(HANDSHAKE_BUF_SIZE >= 2, "handshake_buf_ must hold the 2-byte extended-protocol feature ack");
        this->handshake_buf_[0] = ota::OTA_RESPONSE_FEATURE_FLAGS;
        this->handshake_buf_[1] = (supports_compression ? SERVER_FEATURE_SUPPORTS_COMPRESSION : 0);
@@ -269,8 +270,7 @@ void ESPHomeOTAComponent::handle_handshake_() {
        this->handshake_buf_[1] |= SERVER_FEATURE_SUPPORTS_PARTITION_ACCESS;
 #endif
 #ifdef USE_OTA_ENCRYPTION
-        // A runtime provisioned key may not exist yet; offer only with a key
-        if (this->noise_context_().has_psk()) {
+        if (this->noise_ctx_.has_psk()) {
          this->handshake_buf_[1] |= SERVER_FEATURE_SUPPORTS_NOISE;
        }
 #endif
@@ -284,15 +284,15 @@ void ESPHomeOTAComponent::handle_handshake_() {
    case OTAState::FEATURE_ACK: {
      static constexpr size_t STANDARD_PROTO_ACK_SIZE = 1;
      static constexpr size_t EXTENDED_PROTO_ACK_SIZE = 2;
-      const size_t ack_size = this->extended_proto_() ? EXTENDED_PROTO_ACK_SIZE : STANDARD_PROTO_ACK_SIZE;
+      const size_t ack_size = this->extended_proto_ ? EXTENDED_PROTO_ACK_SIZE : STANDARD_PROTO_ACK_SIZE;
      if (!this->try_write_(ack_size, LOG_STR("ack feature"))) {
        return;
      }
 #ifdef USE_OTA_ENCRYPTION
-      // The client took the encryption offer: the rest of the session runs
-      // inside the noise transport, which also authenticates it. Nothing to
-      // do until its first handshake frame arrives.
-      if (this->noise_context_().has_psk() && (this->ota_features_ & CLIENT_NOISE_FEATURES) == CLIENT_NOISE_FEATURES) {
+      // With a PSK configured the rest of the session runs inside the noise
+      // transport; the client sends the first handshake frame next, so there
+      // is nothing to do until data arrives.
+      if (this->noise_ctx_.has_psk()) {
        // handshake_buf_ still holds the feature ack composed above; a
        // would-block re-entry lands here without rebuilding it
        if (!this->noise_start_session_(this->handshake_buf_[1])) {
@@ -412,7 +412,7 @@ void ESPHomeOTAComponent::handle_data_() {
  // Acknowledge auth OK - 1 byte
  this->data_write_byte_(ota::OTA_RESPONSE_AUTH_OK);

-  if (this->extended_proto_()) {
+  if (this->extended_proto_) {
    // Read ota type, 1 byte
    if (!this->data_readall_(buf, 1)) {
      this->log_read_error_(LOG_STR("OTA type"));
@@ -7,9 +7,6 @@
 #ifdef USE_OTA_ENCRYPTION
 #include "esphome/components/noise/noise_handshake.h"
 #endif
-#ifdef USE_OTA_ENCRYPTION_FROM_API
-#include "esphome/components/api/api_server.h"
-#endif
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/preferences.h"
@@ -47,9 +44,8 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
  }
 #endif  // USE_OTA_PASSWORD

-#if defined(USE_OTA_ENCRYPTION) && !defined(USE_OTA_ENCRYPTION_FROM_API)
-  /// psk points at 32 bytes that live in flash for the life of the program
-  void set_noise_psk(const uint8_t *psk) { this->noise_ctx_.set_psk(psk); }
+#ifdef USE_OTA_ENCRYPTION
+  void set_noise_psk(noise::psk_t psk) { this->noise_ctx_.set_psk(psk); }
 #endif

  /// Manually set the port OTA should listen on
@@ -89,19 +85,9 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
    bool writing{false};    // a produced handshake frame is still being flushed
    uint8_t frame_buf[noise::FRAME_HEADER_SIZE + 1 + noise::MAX_HANDSHAKE_SIZE];
  };
-  // The key the offer and the handshake use: the api server's live context
-  // for a runtime provisioned key, otherwise the component's own
-  inline const noise::NoiseContext &noise_context_() const {
-#ifdef USE_OTA_ENCRYPTION_FROM_API
-    return api::global_api_server->get_noise_ctx();
-#else
-    return this->noise_ctx_;
-#endif
-  }
  bool noise_start_session_(uint8_t server_feature_flags);
  bool handle_noise_handshake_();
  bool noise_try_read_frame_();
-  size_t noise_frame_payload_len_(const uint8_t *header, size_t min_len, size_t max_len);
  bool noise_try_write_frame_();
  void noise_send_reject_(const LogString *reason);
  ssize_t noise_decrypt_(uint8_t *buf, size_t len);
@@ -158,9 +144,7 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
  std::unique_ptr<uint8_t[]> auth_buf_;
 #endif  // USE_OTA_PASSWORD
 #ifdef USE_OTA_ENCRYPTION
-#ifndef USE_OTA_ENCRYPTION_FROM_API
  noise::NoiseContext noise_ctx_;
-#endif
  std::unique_ptr<NoiseSession> noise_;
 #endif  // USE_OTA_ENCRYPTION

@@ -182,16 +166,6 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
                "OTA_BUFFER_SIZE must fit a full encrypted data frame");
 #endif
  static constexpr uint8_t MAGIC_BYTES[5] = {0x6C, 0x26, 0xF7, 0x5C, 0x45};
-  static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_COMPRESSION = 0x01;
-  static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_SHA256_AUTH = 0x02;
-  static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL = 0x04;
-  static constexpr uint8_t CLIENT_FEATURE_SUPPORTS_NOISE = 0x08;
-  // Noise needs the extended protocol: the prologue binds the 2-byte feature ack
-  static constexpr uint8_t CLIENT_NOISE_FEATURES =
-      CLIENT_FEATURE_SUPPORTS_NOISE | CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL;
-  // Derived from the feature byte rather than stored, which keeps the
-  // trailing byte members at a multiple of four
-  inline bool extended_proto_() const { return (this->ota_features_ & CLIENT_FEATURE_SUPPORTS_EXTENDED_PROTOCOL) != 0; }
 #ifdef USE_OTA_PARTITIONS
  uint32_t running_app_offset_{0};
  size_t running_app_size_{0};
@@ -205,6 +179,7 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
  uint8_t auth_buf_pos_{0};
  uint8_t auth_type_{0};  // Store auth type to know which hasher to use
 #endif                    // USE_OTA_PASSWORD
+  bool extended_proto_{false};
 };

 }  // namespace esphome
@@ -3,7 +3,6 @@
 #ifdef USE_OTA_ENCRYPTION
 #include "esphome/components/noise/noise.h"
 #include "esphome/components/ota/ota_backend.h"
-#include "esphome/core/hal.h"
 #include "esphome/core/log.h"

 #include <cstring>
@@ -42,15 +41,23 @@ ESPHomeOTAComponent::NoiseSession::~NoiseSession() {
 */
 bool ESPHomeOTAComponent::noise_start_session_(uint8_t server_feature_flags) {
  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
-  // Default-init: the frame buffer is always written before it is read, so
-  // skip zeroing its 132 bytes
-  this->noise_ = std::unique_ptr<NoiseSession>(new (std::nothrow) NoiseSession);
+  this->noise_ = std::unique_ptr<NoiseSession>(new (std::nothrow) NoiseSession());
+  if (this->noise_ == nullptr) {
+    ESP_LOGW(TAG, "Session allocation failed");
+    this->cleanup_connection_();
+    return false;
+  }
+
  static constexpr size_t PROLOGUE_ACK_LEN = 2;  // OTA_RESPONSE_OK + version
  static constexpr size_t PROLOGUE_CLIENT_FEATURES_LEN = 1;
  static constexpr size_t PROLOGUE_FEATURE_ACK_LEN = 2;  // OTA_RESPONSE_FEATURE_FLAGS + server flags
  uint8_t prologue[OTA_NOISE_PROLOGUE_INIT_LEN + sizeof(MAGIC_BYTES) + PROLOGUE_ACK_LEN + PROLOGUE_CLIENT_FEATURES_LEN +
                   PROLOGUE_FEATURE_ACK_LEN];
-  progmem_memcpy(prologue, OTA_NOISE_PROLOGUE_INIT, OTA_NOISE_PROLOGUE_INIT_LEN);
+#ifdef USE_ESP8266
+  memcpy_P(prologue, OTA_NOISE_PROLOGUE_INIT, OTA_NOISE_PROLOGUE_INIT_LEN);
+#else
+  std::memcpy(prologue, OTA_NOISE_PROLOGUE_INIT, OTA_NOISE_PROLOGUE_INIT_LEN);
+#endif
  uint8_t *p = prologue + OTA_NOISE_PROLOGUE_INIT_LEN;
  // Magic bytes, already validated in MAGIC_READ
  std::memcpy(p, MAGIC_BYTES, sizeof(MAGIC_BYTES));
@@ -64,14 +71,9 @@ bool ESPHomeOTAComponent::noise_start_session_(uint8_t server_feature_flags) {
  *p++ = ota::OTA_RESPONSE_FEATURE_FLAGS;
  *p++ = server_feature_flags;

-  // Never run the handshake with the all-zeros provisioning key: a static key
-  // is always present, a runtime provisioned one may not be yet
-  const noise::NoiseContext &ctx = this->noise_context_();
-  int err = this->noise_ == nullptr ? NOISE_ERROR_NO_MEMORY
-            : !ctx.has_psk()        ? NOISE_ERROR_PSK_REQUIRED
-                                    : this->noise_->handshake.init(ctx, prologue, sizeof(prologue));
+  int err = this->noise_->handshake.init(this->noise_ctx_.get_psk(), prologue, sizeof(prologue));
  if (err != 0) {
-    ESP_LOGW(TAG, "Session init: %d", err);
+    ESP_LOGW(TAG, "Handshake init: %s", LOG_STR_ARG(noise::noise_err_to_logstr(err)));
    this->cleanup_connection_();
    return false;
  }
@@ -103,16 +105,14 @@ bool ESPHomeOTAComponent::handle_noise_handshake_() {
        s.frame_pos = 0;
        s.frame_len = 0;
        if (s.frame_buf[noise::FRAME_HEADER_SIZE] != noise::HANDSHAKE_STATUS_OK) {
-          ESP_LOGV(TAG, "Bad handshake error byte: %u", s.frame_buf[noise::FRAME_HEADER_SIZE]);
+          ESP_LOGW(TAG, "Bad handshake error byte: %u", s.frame_buf[noise::FRAME_HEADER_SIZE]);
          this->cleanup_connection_();
          return false;
        }
        int err = s.handshake.read_message(s.frame_buf + noise::FRAME_HEADER_SIZE + 1, payload_len - 1);
        if (err != 0) {
-          // A MAC failure here almost always means the uploader has a different key
-          const LogString *reason = noise::reject_reason_for(err);
-          ESP_LOGW(TAG, "Handshake read: %s (%d)", LOG_STR_ARG(reason), err);
-          this->noise_send_reject_(reason);
+          ESP_LOGW(TAG, "Handshake read: %s", LOG_STR_ARG(noise::noise_err_to_logstr(err)));
+          this->noise_send_reject_(noise::reject_reason_for(err));
          this->cleanup_connection_();
          return false;
        }
@@ -123,7 +123,7 @@ bool ESPHomeOTAComponent::handle_noise_handshake_() {
        int err =
            s.handshake.write_message(s.frame_buf + noise::FRAME_HEADER_SIZE + 1, noise::MAX_HANDSHAKE_SIZE, msg_len);
        if (err != 0) {
-          ESP_LOGW(TAG, "Handshake write: %d", err);
+          ESP_LOGW(TAG, "Handshake write: %s", LOG_STR_ARG(noise::noise_err_to_logstr(err)));
          this->cleanup_connection_();
          return false;
        }
@@ -138,7 +138,7 @@ bool ESPHomeOTAComponent::handle_noise_handshake_() {
      case noise::NoiseResponderHandshake::Action::ACTION_SPLIT: {
        int err = s.handshake.split(s.send_cipher, s.recv_cipher);
        if (err != 0) {
-          ESP_LOGW(TAG, "Handshake split: %d", err);
+          ESP_LOGW(TAG, "Handshake split: %s", LOG_STR_ARG(noise::noise_err_to_logstr(err)));
          this->cleanup_connection_();
          return false;
        }
@@ -154,41 +154,33 @@ bool ESPHomeOTAComponent::handle_noise_handshake_() {
  }
 }

-/// Payload length from a frame header, or 0 (logged) when the indicator or
-/// the length is out of range. Callers pass min_len >= 1 so 0 is never valid.
-size_t ESPHomeOTAComponent::noise_frame_payload_len_(const uint8_t *header, size_t min_len, size_t max_len) {
-  const size_t payload_len = encode_uint16(header[1], header[2]);
-  if (header[0] != noise::FRAME_INDICATOR || payload_len < min_len || payload_len > max_len) {
-    ESP_LOGW(TAG, "Bad frame: 0x%02X, %zu bytes", header[0], payload_len);
-    return 0;
-  }
-  return payload_len;
-}
-
 /// Non-blocking read of one handshake frame into the session buffer.
 bool ESPHomeOTAComponent::noise_try_read_frame_() {
  NoiseSession &s = *this->noise_;
-  while (true) {
-    // The header first, then the body once the header says how long it is
-    const uint16_t want = s.frame_len == 0 ? noise::FRAME_HEADER_SIZE : s.frame_len;
-    if (s.frame_pos < want) {
-      ssize_t read = this->client_->read(s.frame_buf + s.frame_pos, want - s.frame_pos);
-      if (!this->handle_read_error_(read, LOG_STR("read noise"))) {
-        return false;
-      }
-      s.frame_pos += read;
-      continue;
+  while (s.frame_pos < noise::FRAME_HEADER_SIZE) {
+    ssize_t read = this->client_->read(s.frame_buf + s.frame_pos, noise::FRAME_HEADER_SIZE - s.frame_pos);
+    if (!this->handle_read_error_(read, LOG_STR("read noise header"))) {
+      return false;
    }
-    if (s.frame_len != 0) {
-      return true;
-    }
-    const size_t payload_len = this->noise_frame_payload_len_(s.frame_buf, 1, 1 + noise::MAX_HANDSHAKE_SIZE);
-    if (payload_len == 0) {
+    s.frame_pos += read;
+  }
+  if (s.frame_len == 0) {
+    const uint16_t payload_len = encode_uint16(s.frame_buf[1], s.frame_buf[2]);
+    if (s.frame_buf[0] != noise::FRAME_INDICATOR || payload_len < 1 || payload_len > 1 + noise::MAX_HANDSHAKE_SIZE) {
+      ESP_LOGW(TAG, "Bad handshake frame: 0x%02X, %u bytes", s.frame_buf[0], payload_len);
      this->cleanup_connection_();
      return false;
    }
    s.frame_len = noise::FRAME_HEADER_SIZE + payload_len;
  }
+  while (s.frame_pos < s.frame_len) {
+    ssize_t read = this->client_->read(s.frame_buf + s.frame_pos, s.frame_len - s.frame_pos);
+    if (!this->handle_read_error_(read, LOG_STR("read noise frame"))) {
+      return false;
+    }
+    s.frame_pos += read;
+  }
+  return true;
 }

 /// Non-blocking write of the pending session-buffer frame.
@@ -222,7 +214,7 @@ ssize_t ESPHomeOTAComponent::noise_decrypt_(uint8_t *buf, size_t len) {
  noise_buffer_set_inout(mbuf, buf, len, len);
  int err = noise_cipherstate_decrypt(this->noise_->recv_cipher, &mbuf);
  if (err != 0) {
-    ESP_LOGW(TAG, "Decrypt: %d", err);
+    ESP_LOGW(TAG, "Decrypt: %s", LOG_STR_ARG(noise::noise_err_to_logstr(err)));
    return -1;
  }
  return mbuf.size;
@@ -237,8 +229,9 @@ ssize_t ESPHomeOTAComponent::noise_read_frame_blocking_(uint8_t *buf, size_t min
  if (!this->readall_(header, sizeof(header))) {
    return -1;
  }
-  const size_t ciphertext_len = this->noise_frame_payload_len_(header, min_ciphertext, max_ciphertext);
-  if (ciphertext_len == 0) {
+  const size_t ciphertext_len = encode_uint16(header[1], header[2]);
+  if (header[0] != noise::FRAME_INDICATOR || ciphertext_len < min_ciphertext || ciphertext_len > max_ciphertext) {
+    ESP_LOGW(TAG, "Bad frame: 0x%02X, %zu bytes", header[0], ciphertext_len);
    return -1;
  }
  if (!this->readall_(buf, ciphertext_len)) {
@@ -274,7 +267,7 @@ bool ESPHomeOTAComponent::noise_write_byte_(uint8_t byte) {
  noise_buffer_set_inout(mbuf, frame + noise::FRAME_HEADER_SIZE, 1, 1 + noise::MAC_SIZE);
  int err = noise_cipherstate_encrypt(this->noise_->send_cipher, &mbuf);
  if (err != 0) {
-    ESP_LOGW(TAG, "Encrypt: %d", err);
+    ESP_LOGW(TAG, "Encrypt: %s", LOG_STR_ARG(noise::noise_err_to_logstr(err)));
    return false;
  }
  noise::write_frame_header(frame, mbuf.size);
@@ -96,6 +96,7 @@ 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,9 +47,6 @@ 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,6 +38,7 @@ 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,6 +68,8 @@ 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,14 +23,6 @@ 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,6 +11,7 @@ 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,14 +130,6 @@ 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,6 +26,8 @@ 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,13 +102,7 @@ CONFIG_SCHEMA = (
 )

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


@@ -143,6 +143,8 @@ 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,14 +80,6 @@ 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,7 +163,10 @@ void Mk2PVRouter::publish_value_(const char *tag, const char *val) {
 #endif
 }

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

 #ifdef MK2PVROUTER_LISTENER_COUNT
 void Mk2PVRouter::register_mk2pvrouter_listener(Mk2PVRouterListener *listener) {
@@ -43,6 +43,7 @@ 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,8 +209,14 @@ 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;
@@ -5,8 +5,6 @@ from typing import Any
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_KEY
-from esphome.core import ID
-from esphome.cpp_generator import MockObj
 from esphome.types import ConfigType

 CODEOWNERS = ["@esphome/core"]
@@ -63,15 +61,6 @@ ENCRYPTION_SCHEMA = cv.Schema(
 )


-def new_psk_progmem(parent_id: ID, key: str) -> MockObj:
-    """Emit the decoded key as a PROGMEM array; the component keeps a pointer
-    so the key never occupies RAM."""
-    return cg.progmem_array(
-        ID(f"{parent_id.id}_psk", is_declaration=True, type=cg.uint8),
-        list(decode_encryption_key(key)),
-    )
-
-
 def encryption_schema(config: ConfigType | None) -> ConfigType:
    # A bare `encryption:` block is valid; a missing key means the consumer
    # falls back to its keyless behavior (api provisioning, ota inheriting
@@ -1,6 +1,5 @@
 #include "noise.h"
 #ifdef USE_NOISE
-#include "esphome/core/hal.h"
 #include "esphome/core/log.h"

 #include <algorithm>
@@ -16,23 +15,6 @@ namespace esphome::noise {

 static const char *const TAG = "noise";

-void NoiseContext::set_psk(const uint8_t *psk) {
-  this->psk_ = psk;
-  psk_t copy;
-  this->load_psk(copy);
-  if (is_all_zeros(copy)) {
-    this->psk_ = nullptr;
-  }
-}
-
-void NoiseContext::load_psk(psk_t &out) const {
-  if (this->psk_ == nullptr) {
-    out.fill(0);
-    return;
-  }
-  progmem_memcpy(out.data(), this->psk_, out.size());
-}
-
 const LogString *noise_err_to_logstr(int err) {
  if (err == NOISE_ERROR_NO_MEMORY)
    return LOG_STR("NO_MEMORY");
@@ -23,16 +23,16 @@ class NoiseContext {
    }
    return acc == 0;
  }
-  /// psk points at 32 bytes that outlive the context: a PROGMEM array from
-  /// codegen, or RAM owned by the caller for a runtime provisioned key.
-  /// The all-zeros key counts as no key.
-  void set_psk(const uint8_t *psk);
-  /// Copy the key out (flash-aware on ESP8266); all zeros when none is set.
-  void load_psk(psk_t &out) const;
-  bool has_psk() const { return this->psk_ != nullptr; }
+  void set_psk(psk_t psk) {
+    this->psk_ = psk;
+    this->has_psk_ = !is_all_zeros(psk);
+  }
+  const psk_t &get_psk() const { return this->psk_; }
+  bool has_psk() const { return this->has_psk_; }

 protected:
-  const uint8_t *psk_{nullptr};
+  psk_t psk_{};
+  bool has_psk_{false};
 };

 /// Convert a noise error code to a readable error
@@ -20,7 +20,7 @@ NoiseResponderHandshake::~NoiseResponderHandshake() {
  }
 }

-int NoiseResponderHandshake::init(const NoiseContext &ctx, const uint8_t *prologue, size_t prologue_len) {
+int NoiseResponderHandshake::init(const psk_t &psk, const uint8_t *prologue, size_t prologue_len) {
  if (this->handshake_ != nullptr) {
    noise_handshakestate_free(this->handshake_);
    this->handshake_ = nullptr;
@@ -44,9 +44,6 @@ int NoiseResponderHandshake::init(const NoiseContext &ctx, const uint8_t *prolog
    HANDSHAKE_STEP_LOG("noise_handshakestate_new_by_id", err);
    return err;
  }
-  // noise-c keeps its own copy, so the key only passes through the stack here
-  psk_t psk;
-  ctx.load_psk(psk);
  err = noise_handshakestate_set_pre_shared_key(this->handshake_, psk.data(), psk.size());
  if (err != 0) {
    HANDSHAKE_STEP_LOG("noise_handshakestate_set_pre_shared_key", err);
@@ -36,9 +36,9 @@ class NoiseResponderHandshake {
  NoiseResponderHandshake(const NoiseResponderHandshake &) = delete;
  NoiseResponderHandshake &operator=(const NoiseResponderHandshake &) = delete;

-  /// Create and start the handshake with the context's PSK and the prologue.
-  /// A repeated call frees the previous handshake state and starts over.
-  [[nodiscard]] int init(const NoiseContext &ctx, const uint8_t *prologue, size_t prologue_len);
+  /// Create and start the handshake with the given PSK and prologue. A
+  /// repeated call frees the previous handshake state and starts over.
+  [[nodiscard]] int init(const psk_t &psk, const uint8_t *prologue, size_t prologue_len);
  /// ACTION_FAILED is the catch-all: returned before init(), after split()
  /// has released the state, and when noise-c reports a failed handshake.
  [[nodiscard]] Action action() const;
@@ -16,6 +16,7 @@ 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,9 +48,6 @@ 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,6 +46,8 @@ void PMSX003Component::dump_config() {
  } else {
    ESP_LOGCONFIG(TAG, "  Mode: passive with sleep/wake cycles");
  }
+
+  this->check_uart_settings(9600);
 }

 void PMSX003Component::loop() {
@@ -302,13 +302,7 @@ 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,
-        data_bits=8,
-        parity="NONE",
-        stop_bits=1,
+        "pmsx003", baud_rate=9600, require_rx=True, require_tx=require_tx
    )
    schema(config)

@@ -41,14 +41,6 @@ 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,6 +33,7 @@ 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,7 +4,11 @@ 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_BK7238, FAMILY_RTL8720C
+from esphome.components.libretiny.const import (
+    FAMILY_BK7231N,
+    FAMILY_BK7238,
+    FAMILY_RTL8720C,
+)
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
@@ -45,9 +49,7 @@ DigitalWriteAction = remote_transmitter_ns.class_(
 )


-# 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)
+_NON_BLOCKING_LIBRETINY_FAMILIES = (FAMILY_RTL8720C, FAMILY_BK7231N, FAMILY_BK7238)


 def _validate_non_blocking_platform(value: bool) -> bool:
@@ -57,7 +59,9 @@ 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 and BK7238")
+    raise cv.Invalid(
+        "non_blocking is only supported on ESP32, RTL8720C, BK7231N and BK7238"
+    )


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

-// 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
+// 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)
 #define REMOTE_TRANSMITTER_BK_PWM
 #endif

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

 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 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.
+// 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.
 #if defined(USE_LIBRETINY_VARIANT_RTL8720C) || defined(REMOTE_TRANSMITTER_BK_PWM)

 namespace esphome::remote_transmitter {
@@ -1,254 +1 @@
-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,15 +7,262 @@ from esphome.core import Lambda
 from esphome.cpp_generator import ExpressionStatement, RawExpression
 from esphome.types import ConfigType

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

 CODEOWNERS = ["@bdm310"]

 STATE_ARG = "state"

-FINAL_VALIDATE_SCHEMA = headless_final_validate("binary_sensor")
+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}

 CONFIG_SCHEMA = (
    binary_sensor.binary_sensor_schema(BinarySensor)
@@ -4,7 +4,6 @@ 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,
@@ -17,21 +16,14 @@ 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, Snapshot)
+Sdl = sdl_ns.class_("Sdl", display.Display, cg.Component)
 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"
@@ -75,29 +67,12 @@ 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(
@@ -124,42 +99,16 @@ 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,17 +2,8 @@
 #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:
@@ -37,96 +28,17 @@ int Sdl::get_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");
+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_);
  this->texture_ =
      SDL_CreateTexture(this->renderer_, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_STATIC, this->width_, this->height_);
-  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;
+  SDL_SetTextureBlendMode(this->texture_, SDL_BLENDMODE_BLEND);
 }
-
-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;
@@ -139,19 +51,12 @@ 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);
@@ -164,7 +69,7 @@ void Sdl::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *
 }

 void Sdl::draw_pixel_at(int x, int y, Color color) {
-  if (this->texture_ == nullptr || !this->get_clipping().inside(x, y))
+  if (!this->get_clipping().inside(x, y))
    return;

  if (this->rotation_ == display::DISPLAY_ROTATION_180_DEGREES) {
@@ -199,148 +104,61 @@ 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;
-  // 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;
+  if (SDL_PollEvent(&e)) {
    switch (e.type) {
+      case SDL_QUIT:
+        exit(0);
+
      case SDL_MOUSEBUTTONDOWN:
      case SDL_MOUSEBUTTONUP:
-        window_id = e.button.windowID;
+        if (e.button.button == 1) {
+          this->mouse_x = e.button.x;
+          this->mouse_y = e.button.y;
+          this->mouse_down = e.button.state != 0;
+        }
        break;
+
      case SDL_MOUSEMOTION:
-        window_id = e.motion.windowID;
+        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;
+        }
        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:
-        window_id = e.key.windowID;
+        ESP_LOGD(TAG, "keyup %d", e.key.keysym.sym);
+        this->process_key(e.key.keysym.sym, false);
        break;
+
      case SDL_WINDOWEVENT:
-        window_id = e.window.windowID;
+        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;
+        }
        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);
-        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;
+        break;
    }
  }
-  if (!ok) {
-    ESP_LOGE(TAG, "Could not capture the screen: %s", SDL_GetError());
-  }
-  return ok;
 }

 }  // namespace esphome::sdl
@@ -1,12 +1,10 @@
 #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>
@@ -15,7 +13,7 @@ namespace esphome::sdl {

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

-class Sdl final : public display::Display, public snapshot::Snapshot {
+class Sdl final : public display::Display {
 public:
  display::DisplayType get_display_type() override { return display::DISPLAY_TYPE_COLOR; }
  void update() override;
@@ -34,9 +32,6 @@ class Sdl final : public display::Display, public snapshot::Snapshot {
    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; }
@@ -56,40 +51,20 @@ class Sdl final : public display::Display, public snapshot::Snapshot {
  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};
-  int32_t snapshot_key_{0};
+  SDL_Renderer *renderer_{};
+  SDL_Window *window_{};
+  SDL_Texture *texture_{};
  uint16_t x_low_{0};
  uint16_t y_low_{0};
  uint16_t x_high_{0};
  uint16_t y_high_{0};
-  bool headless_{false};
+  std::map<int32_t, CallbackManager<void(bool)>> key_callbacks_{};
 };
-
 }  // namespace esphome::sdl

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

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

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

-FINAL_VALIDATE_SCHEMA = headless_final_validate("touchscreen")
-

 CONFIG_SCHEMA = touchscreen.TOUCHSCREEN_SCHEMA.extend(
    {
@@ -31,7 +31,6 @@ 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,6 +33,8 @@ 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,26 +130,17 @@ SerialProxyResult SerialProxy::configure(api::APIConnection *api_connection, uin
    return SerialProxyResult::SERIAL_PROXY_RESULT_NOT_SUPPORTED;
  }

-  // 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);

+  // Map parity value to UARTParityOptions
+  static const uart::UARTParityOptions PARITY_MAP[] = {
+      uart::UART_CONFIG_PARITY_NONE,
+      uart::UART_CONFIG_PARITY_EVEN,
+      uart::UART_CONFIG_PARITY_ODD,
+  };
  uart_comp->set_parity(PARITY_MAP[parity]);

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

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


@@ -65,6 +65,7 @@ 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) {
@@ -1,76 +0,0 @@
-"""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])))
@@ -1,61 +0,0 @@
-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_))
@@ -1,80 +0,0 @@
-#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
@@ -1,48 +0,0 @@
-#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
@@ -1,248 +0,0 @@
-#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
@@ -1,72 +0,0 @@
-#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,13 +33,7 @@ CONFIG_SCHEMA = (
 )

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


@@ -88,6 +88,7 @@ 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,22 +35,6 @@ 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,7 +184,10 @@ void TeleInfo::publish_value_(const std::string &tag, const std::string &val) {
    element->publish_val(val);
  }
 }
-void TeleInfo::dump_config() { ESP_LOGCONFIG(TAG, "TeleInfo:"); }
+void TeleInfo::dump_config() {
+  ESP_LOGCONFIG(TAG, "TeleInfo:");
+  this->check_uart_settings(baud_rate_, 1, uart::UART_CONFIG_PARITY_EVEN, 7);
+}
 TeleInfo::TeleInfo(bool historical_mode) {
  if (historical_mode) {
    /*
@@ -192,9 +195,11 @@ 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,6 +31,7 @@ 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,6 +36,8 @@ 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,7 +3,6 @@
 #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"

@@ -67,7 +66,6 @@ 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,7 +30,6 @@ 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,6 +213,7 @@ 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,6 +29,8 @@ 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,14 +29,6 @@ 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,7 +11,10 @@ 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:"); }
+void VBus::dump_config() {
+  ESP_LOGCONFIG(TAG, "VBus:");
+  check_uart_settings(9600);
+}

 static void septet_spread(uint8_t *data, int start, int count, uint8_t septet) {
  for (int i = 0; i < count; i++, septet >>= 1) {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
J. Nick Koston	421c5e5d32	Merge branch 'dev' into platformio-prefetch-git-clones	2026-09-02 05:16:40 -04:00
J. Nick Koston	ab59822c1f	Tighten comments	2026-08-31 17:41:13 -04:00
J. Nick Koston	fa5180bd51	Keep local .git paths with pio run	2026-08-31 16:49:39 -04:00
J. Nick Koston	8582bf194a	Classify .git URLs before the scheme exclusion, restore the name fallback	2026-08-31 16:31:28 -04:00
J. Nick Koston	328e83ad64	Simplify: one custom-name rule in _uri_jobs, ordering owned by the pool	2026-08-31 16:08:57 -04:00
J. Nick Koston	6877513195	Classify VCS URIs positively and pin the clone floor	2026-08-31 15:39:01 -04:00
J. Nick Koston	03104b894b	Gate derived-name lib clones out of the pool, widen it for clones, pin the wiring	2026-08-31 14:19:16 -05:00
J. Nick Koston	26a308a82d	Address review: name the clones-first ordering, harden the name fallback	2026-08-31 13:54:18 -05:00
J. Nick Koston	938f598709	Merge branch 'dev' into platformio-prefetch-git-clones # Conflicts: # esphome/platformio/prefetch.py	2026-08-31 13:23:59 -05:00
J. Nick Koston	2b4a196cf8	Merge branch 'dev' into platformio-prefetch-git-clones	2026-08-28 14:26:22 -05:00
J. Nick Koston	3f65f5c12c	Use the computed name for download candidates too	2026-08-27 15:26:29 -05:00
J. Nick Koston	7cc892ea14	Pin PackageSpec git URL normalization in the contract test	2026-08-27 15:23:11 -05:00
J. Nick Koston	9e4bec7e49	[core] Clone git PlatformIO packages in parallel in the prefetch	2026-08-27 15:09:03 -05:00