[udp] Take the packet size from the copy buffer

The link derives max_packet_size from the span it is given, so a packet larger than the copy buffer cannot be copied into it. Co-Authored-By: Claude Code <noreply@anthropic.com>
[udp] Limit a split packet to the copy buffer
2026-10-23 14:38:52 +00:00 · 2026-10-23 13:28:08 +11:00 · 2026-10-23 13:28:08 +11:00 · 2026-10-23 13:28:08 +11:00 · 2026-10-23 13:28:08 +11:00 · 2026-10-23 13:28:08 +11:00
61 changed files with 3199 additions and 140 deletions
@@ -462,6 +462,8 @@ esphome/components/openthread/* @mrene
 esphome/components/opt3001/* @ccutrer
 esphome/components/ota/* @esphome/core
 esphome/components/output/* @esphome/core
+esphome/components/packet_interface/* @clydebarrow
+esphome/components/packet_interface/packet_transport/* @clydebarrow
 esphome/components/packet_transport/* @clydebarrow
 esphome/components/pca6416a/* @Mat931
 esphome/components/pca9505/* @ajfriesen @ssieb
@@ -682,10 +684,12 @@ esphome/components/tuya/water_heater/* @iago-veiga
 esphome/components/uart/* @esphome/core
 esphome/components/uart/button/* @ssieb
 esphome/components/uart/event/* @eoasmxd
+esphome/components/uart/packet_interface/* @clydebarrow
 esphome/components/uart/packet_transport/* @clydebarrow
 esphome/components/uart_mux/* @kbx81
 esphome/components/uart_tcp/* @Bascht74
 esphome/components/udp/* @clydebarrow
+esphome/components/udp/packet_interface/* @clydebarrow
 esphome/components/ufire_ec/* @pvizeli
 esphome/components/ufire_ise/* @pvizeli
 esphome/components/ufm01/* @ljungqvist
@@ -45,14 +45,15 @@ void HmacSHA256::get_hex(char *output) {
 }

 bool HmacSHA256::equals_bytes(const uint8_t *expected) {
-  return memcmp(this->digest_, expected, SHA256_DIGEST_SIZE) == 0;
+  return constant_time_equals(this->digest_, expected, SHA256_DIGEST_SIZE);
 }

 bool HmacSHA256::equals_hex(const char *expected) {
-  char hex_output[SHA256_DIGEST_SIZE * 2 + 1];
-  this->get_hex(hex_output);
-  hex_output[SHA256_DIGEST_SIZE * 2] = '\0';
-  return strncmp(hex_output, expected, SHA256_DIGEST_SIZE * 2) == 0;
+  uint8_t parsed[SHA256_DIGEST_SIZE];
+  if (parse_hex(expected, SHA256_DIGEST_SIZE * 2, parsed, SHA256_DIGEST_SIZE) != SHA256_DIGEST_SIZE * 2) {
+    return false;
+  }
+  return this->equals_bytes(parsed);
 }

 #elif defined(USE_HMAC_SHA256_MBEDTLS)
@@ -77,14 +78,15 @@ void HmacSHA256::get_hex(char *output) {
 }

 bool HmacSHA256::equals_bytes(const uint8_t *expected) {
-  return memcmp(this->digest_, expected, SHA256_DIGEST_SIZE) == 0;
+  return constant_time_equals(this->digest_, expected, SHA256_DIGEST_SIZE);
 }

 bool HmacSHA256::equals_hex(const char *expected) {
-  char hex_output[SHA256_DIGEST_SIZE * 2 + 1];
-  this->get_hex(hex_output);
-  hex_output[SHA256_DIGEST_SIZE * 2] = '\0';
-  return strncmp(hex_output, expected, SHA256_DIGEST_SIZE * 2) == 0;
+  uint8_t parsed[SHA256_DIGEST_SIZE];
+  if (parse_hex(expected, SHA256_DIGEST_SIZE * 2, parsed, SHA256_DIGEST_SIZE) != SHA256_DIGEST_SIZE * 2) {
+    return false;
+  }
+  return this->equals_bytes(parsed);
 }

 #else
@@ -1,5 +1,6 @@
 #include "download_buffer.h"
 #include "esphome/core/log.h"
+#include <algorithm>
 #include <cstring>

 namespace esphome::online_image {
@@ -34,6 +35,46 @@ size_t DownloadBuffer::read(size_t len) {
  return this->unread_;
 }

+void DownloadSource::compact() {
+  if (this->keep_read_ || this->pos_ == this->start_)
+    return;
+  this->buffer_.read(this->pos_ - this->start_);
+  this->start_ = this->pos_;
+}
+
+int32_t DownloadSource::read(uint8_t *buf, uint32_t len) {
+  const size_t offset = this->pos_ - this->start_;
+  const size_t n = std::min<size_t>(len, this->buffer_.unread() - offset);
+  memcpy(buf, this->buffer_.data(offset), n);
+  this->pos_ += n;
+  return static_cast<int32_t>(n);
+}
+
+bool DownloadSource::seek(uint32_t position) {
+  // Only what is still in the buffer can be read again; a decoder never skips ahead of the download
+  if (position < this->start_ || position > this->start_ + this->buffer_.unread())
+    return false;
+  this->pos_ = position;
+  return true;
+}
+
+bool DownloadBuffer::grow(size_t size) {
+  if (this->size_ >= size)
+    return true;
+  RAMAllocator<uint8_t> allocator;
+  uint8_t *buffer = allocator.allocate(size);
+  if (buffer == nullptr) {
+    ESP_LOGE(TAG, "allocation of %zu bytes failed. Biggest block in heap: %zu Bytes", size,
+             allocator.get_max_free_block_size());
+    return false;
+  }
+  memcpy(buffer, this->buffer_, this->unread_);
+  allocator.deallocate(this->buffer_, this->size_);
+  this->buffer_ = buffer;
+  this->size_ = size;
+  return true;
+}
+
 size_t DownloadBuffer::resize(size_t size) {
  if (this->size_ >= size) {
    // Avoid useless reallocations; if the buffer is big enough, don't reallocate.
@@ -1,5 +1,6 @@
 #pragma once

+#include "esphome/components/runtime_image/image_decoder.h"
 #include "esphome/core/helpers.h"
 #include <cstddef>
 #include <cstdint>
@@ -35,6 +36,8 @@ class DownloadBuffer {

  void reset() { this->unread_ = 0; }
  size_t resize(size_t size);
+  /// Make the buffer at least size bytes, keeping the unread data. Returns false if the allocation failed.
+  bool grow(size_t size);

 protected:
  uint8_t *buffer_;
@@ -43,4 +46,35 @@ class DownloadBuffer {
  size_t unread_;
 };

+/**
+ * @brief Lets a decoder read a download as it arrives, from the download buffer.
+ *
+ * The decoder reads at its own position in the buffer. Bytes it has read stay there until compact() drops
+ * them, and compact() keeps everything while set_keep_read(true) is in effect, so the decoder can seek back
+ * while it reads the headers.
+ */
+class DownloadSource : public runtime_image::DecodeSource {
+ public:
+  explicit DownloadSource(DownloadBuffer &buffer) : buffer_(buffer) {}
+
+  /// Start again at the beginning of a new download, keeping what is read
+  void reset() {
+    this->start_ = 0;
+    this->pos_ = 0;
+    this->keep_read_ = true;
+  }
+  void set_keep_read(bool keep) { this->keep_read_ = keep; }
+  /// Drop the bytes the decoder has read, to make room for more of the download
+  void compact();
+
+  int32_t read(uint8_t *buf, uint32_t len) override;
+  bool seek(uint32_t position) override;
+
+ protected:
+  DownloadBuffer &buffer_;
+  size_t start_{0};  // Position in the download of the first byte in the buffer
+  size_t pos_{0};    // Position in the download the decoder reads next
+  bool keep_read_{true};
+};
+
 }  // namespace esphome::online_image
@@ -22,6 +22,8 @@ DEPENDENCIES = ["http_request"]
 CODEOWNERS = ["@guillempages", "@clydebarrow"]

 CONF_ON_DOWNLOAD_FINISHED = "on_download_finished"
+CONF_ON_DOWNLOAD_STARTED = "on_download_started"
+CONF_ON_DOWNLOAD_PROGRESS = "on_download_progress"
 CONF_UPDATE = "update"

 online_image_ns = cg.esphome_ns.namespace("online_image")
@@ -43,7 +45,9 @@ ONLINE_IMAGE_SCHEMA = (
            cv.Optional(CONF_REQUEST_HEADERS): cv.All(
                cv.Schema({cv.string: cv.templatable(cv.string)})
            ),
+            cv.Optional(CONF_ON_DOWNLOAD_STARTED): automation.validate_automation({}),
            cv.Optional(CONF_ON_DOWNLOAD_FINISHED): automation.validate_automation({}),
+            cv.Optional(CONF_ON_DOWNLOAD_PROGRESS): automation.validate_automation({}),
            cv.Optional(CONF_ON_ERROR): automation.validate_automation({}),
        }
    )
@@ -96,9 +100,17 @@ automation.register_apply_action(


 _CALLBACK_AUTOMATIONS = (
+    automation.CallbackAutomation(
+        CONF_ON_DOWNLOAD_STARTED, "add_on_download_started_callback"
+    ),
    automation.CallbackAutomation(
        CONF_ON_DOWNLOAD_FINISHED, "add_on_finished_callback", [(bool, "cached")]
    ),
+    automation.CallbackAutomation(
+        CONF_ON_DOWNLOAD_PROGRESS,
+        "add_on_progress_callback",
+        [(float, "progress"), (cg.size_t, "bytes_read")],
+    ),
    automation.CallbackAutomation(CONF_ON_ERROR, "add_on_error_callback"),
 )

@@ -4,6 +4,7 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include <algorithm>
+#include <cmath>
 #include <cstdio>

 ESPHOME_LOG_TAG(TAG, "online_image");
@@ -15,6 +16,11 @@ static const char *const IF_MODIFIED_SINCE_HEADER_NAME = "if-modified-since";

 namespace esphome::online_image {

+// Time one loop pass may spend reading, and decoding a JPEG as it downloads
+static constexpr uint32_t PASS_BUDGET_MS = 20;
+// Shortest time between two on_download_progress calls
+static constexpr uint32_t PROGRESS_INTERVAL_MS = 100;
+
 OnlineImage::OnlineImage(const std::string &url, int width, int height, runtime_image::ImageFormat format,
                         image::ImageType type, image::Transparency transparency, image::Image *placeholder,
                         uint32_t buffer_size, bool is_big_endian)
@@ -140,8 +146,12 @@ void OnlineImage::update() {
    return;
  }

-  // JPEG requires the complete image in the download buffer before decoding
-  if (format == runtime_image::JPEG && total_size > this->download_buffer_.size() &&
+  // A JPEG of known size is decoded as it arrives, so the download buffer only has to hold its headers.
+  // Otherwise the decoder needs the complete image in the buffer.
+  this->streaming_ = total_size > 0 && total_size <= INT32_MAX && this->decoder_supports_source();
+  this->stream_started_ = false;
+  this->source_.reset();
+  if (!this->streaming_ && format == runtime_image::JPEG && total_size > this->download_buffer_.size() &&
      this->download_buffer_.resize(total_size) == 0) {
    // resize() logged the failed allocation; the next update() allocates the configured buffer again
    this->end_connection_();
@@ -152,6 +162,8 @@ void OnlineImage::update() {
  ESP_LOGI(TAG, "Downloading image (Size: %zu)", total_size);
  this->start_time_ = millis();
  this->last_data_time_ = this->start_time_;
+  this->download_started_callback_.call();
+  this->report_progress_(true);
  this->enable_loop();
 }

@@ -169,6 +181,11 @@ void OnlineImage::loop() {
    return;
  }

+  if (this->streaming_) {
+    this->loop_stream_();
+    return;
+  }
+
  // Check if download is complete — use decoder's format-specific completion check
  // to handle both known content-length and chunked transfer encoding
  if (this->is_decode_finished() || (this->downloader_->content_length > 0 &&
@@ -179,15 +196,22 @@ void OnlineImage::loop() {
  }

  // Download and decode more data
-  size_t available = this->download_buffer_.free_capacity();
-  if (available > 0) {
-    // Download in chunks to avoid blocking
-    available = std::min(available, this->download_buffer_initial_size_);
-    auto len = this->downloader_->read(this->download_buffer_.append(), available);
-
-    if (len > 0) {
-      this->last_data_time_ = App.get_loop_component_start_time();
+  if (this->download_buffer_.free_capacity() > 0) {
+    const uint32_t now = App.get_loop_component_start_time();
+    size_t received = 0;
+    int len;
+    do {
+      len = this->downloader_->read(this->download_buffer_.append(),
+                                    std::min(this->download_buffer_.free_capacity(), READ_CHUNK));
+      if (len <= 0)
+        break;
      this->download_buffer_.write(len);
+      received += len;
+    } while (this->download_buffer_.free_capacity() != 0 && millis() - now < PASS_BUDGET_MS);
+
+    if (received > 0) {
+      this->last_data_time_ = now;
+      this->report_progress_(false);

      // Feed data to decoder
      auto consumed = this->feed_data(this->download_buffer_.data(), this->download_buffer_.unread());
@@ -255,6 +279,114 @@ void OnlineImage::loop() {
  }
 }

+void OnlineImage::loop_stream_() {
+  const uint32_t now = App.get_loop_component_start_time();
+  const size_t total = this->downloader_->content_length;
+  if (this->stream_started_)
+    this->source_.compact();
+
+  if (this->downloader_->get_bytes_read() < total) {
+    if (this->download_buffer_.free_capacity() == 0) {
+      // compact() already ran, so a full buffer means the decoder read nothing in the last pass
+      if (now - this->last_data_time_ >= this->parent_->get_timeout()) {
+        ESP_LOGE(TAG, "Image does not fit in the %zu byte download buffer; increase buffer_size",
+                 this->download_buffer_.size());
+        this->fail_download_();
+        return;
+      }
+    } else {
+      int len;
+      do {
+        len = this->downloader_->read(this->download_buffer_.append(),
+                                      std::min(this->download_buffer_.free_capacity(), READ_CHUNK));
+        if (len <= 0)
+          break;
+        this->last_data_time_ = now;
+        this->download_buffer_.write(len);
+        this->report_progress_(false);
+      } while (this->downloader_->get_bytes_read() < total && this->download_buffer_.free_capacity() != 0 &&
+               millis() - now < PASS_BUDGET_MS);
+      if (len < 0) {
+        ESP_LOGE(TAG, "Error downloading image: %d", len);
+        this->fail_download_();
+        return;
+      } else if (now - this->last_data_time_ >= this->parent_->get_timeout()) {
+        ESP_LOGE(TAG, "No data received for %" PRIu32 " ms", this->parent_->get_timeout());
+        this->fail_download_();
+        return;
+      }
+    }
+  }
+  const bool arrived = this->downloader_->get_bytes_read() >= total;
+
+  if (!this->stream_started_) {
+    // The decoder reads the headers when it opens the image, so wait until they are in the buffer
+    if (!arrived && this->download_buffer_.free_capacity() != 0)
+      return;
+    const int err = this->begin_source(&this->source_);
+    if (err != 0) {
+      // Headers cut short by a full buffer fail to parse, or make the decoder seek past the buffer. Such an image
+      // still decodes once it is all in memory, as it did before JPEG images were decoded as they download.
+      if (!arrived && (err == runtime_image::DECODE_ERROR_INVALID_TYPE || err == runtime_image::DECODE_ERROR_READ)) {
+        ESP_LOGW(TAG,
+                 "The image headers do not fit the %zu byte download buffer, so the whole image is downloaded "
+                 "before it is decoded; increase buffer_size to decode it as it downloads",
+                 this->download_buffer_.size());
+        // grow() logs a failed allocation
+        if (this->download_buffer_.grow(total)) {
+          this->streaming_ = false;
+        } else {
+          this->fail_download_();
+        }
+        return;
+      }
+      ESP_LOGE(TAG, "Error decoding image: %s", runtime_image::decode_error_to_string(err));
+      this->fail_download_();
+      return;
+    }
+    this->source_.set_keep_read(false);
+    this->stream_started_ = true;
+    // Opening the image and allocating its buffer is enough for one pass
+    return;
+  }
+
+  do {
+    const int result = this->decode_step();
+    if (result == runtime_image::DECODE_STEP_MORE)
+      continue;
+    if (result == runtime_image::DECODE_STEP_DONE) {
+      this->finish_download_();
+    } else if (result == runtime_image::DECODE_STEP_NEED_DATA) {
+      if (!arrived)
+        return;
+      // JPEGDEC only waits for bytes short of the size it was given, so this guards against a hang
+      ESP_LOGE(TAG, "Download ended before the image was complete");
+      this->fail_download_();
+    } else {
+      ESP_LOGE(TAG, "Error decoding image: %s", runtime_image::decode_error_to_string(result));
+      this->fail_download_();
+    }
+    return;
+  } while (millis() - now < PASS_BUDGET_MS);
+}
+
+void OnlineImage::report_progress_(bool force) {
+  const uint32_t now = App.get_loop_component_start_time();
+  const size_t bytes = this->downloader_->get_bytes_read();
+  const size_t total = this->downloader_->content_length;
+  // The last bytes are always reported, so a progress bar reaches 100%
+  if (!force && now - this->last_progress_time_ < PROGRESS_INTERVAL_MS && (total == 0 || bytes < total))
+    return;
+  this->last_progress_time_ = now;
+  const float progress = total > 0 ? std::min(100.0f, bytes * 100.0f / total) : NAN;
+  this->download_progress_callback_.call(progress, bytes);
+}
+
+void OnlineImage::fail_download_() {
+  this->end_connection_();
+  this->download_error_callback_.call();
+}
+
 void OnlineImage::finish_download_() {
  // Must be read before end_decode() ends the decoding session
  bool decoder_finished = this->is_decode_finished();
@@ -288,6 +420,8 @@ void OnlineImage::end_connection_() {
    this->downloader_ = nullptr;
  }
  this->download_buffer_.reset();
+  this->streaming_ = false;
+  this->stream_started_ = false;
  this->disable_loop();
 }

@@ -16,6 +16,10 @@ using t_http_codes = enum {
  HTTP_CODE_NOT_FOUND = 404,
 };

+/// Largest download read(). A read() blocks until it has every byte it asked for, so this bounds how long one loop
+/// pass waits on a slow link.
+static constexpr size_t READ_CHUNK = 1460;
+
 /**
 * @brief Download an image from a given URL, and decode it using the specified decoder.
 * The image will then be stored in a buffer, so that it can be re-displayed without the
@@ -70,9 +74,17 @@ class OnlineImage final : public PollingComponent,
   */
  void release();

+  /// Called when the server has accepted the request and the image starts to download
+  template<typename F> void add_on_download_started_callback(F &&callback) {
+    this->download_started_callback_.add(std::forward<F>(callback));
+  }
  template<typename F> void add_on_finished_callback(F &&callback) {
    this->download_finished_callback_.add(std::forward<F>(callback));
  }
+  /// Called with the percentage downloaded (NAN when the server did not send the size) and the bytes read so far
+  template<typename F> void add_on_progress_callback(F &&callback) {
+    this->download_progress_callback_.add(std::forward<F>(callback));
+  }
  template<typename F> void add_on_error_callback(F &&callback) {
    this->download_error_callback_.add(std::forward<F>(callback));
  }
@@ -81,12 +93,20 @@ class OnlineImage final : public PollingComponent,
  bool validate_url_(const std::string &url);
  void end_connection_();
  void finish_download_();
+  /// loop() for a JPEG that is decoded as it downloads
+  void loop_stream_();
+  void fail_download_();
+  /// Reports download progress, at most every PROGRESS_INTERVAL_MS unless force is set
+  void report_progress_(bool force);

  CallbackManager<void(bool)> download_finished_callback_{};
  CallbackManager<void()> download_error_callback_{};
+  LazyCallbackManager<void()> download_started_callback_{};
+  LazyCallbackManager<void(float, size_t)> download_progress_callback_{};

  std::shared_ptr<http_request::HttpContainer> downloader_{nullptr};
  DownloadBuffer download_buffer_;
+  DownloadSource source_{download_buffer_};
  /**
   * This is the *initial* size of the download buffer, not the current size.
   * The download buffer can be resized at runtime; the download_buffer_initial_size_
@@ -109,6 +129,9 @@ class OnlineImage final : public PollingComponent,

  uint32_t start_time_{0};
  uint32_t last_data_time_{0};
+  uint32_t last_progress_time_{0};
+  bool streaming_{false};       // The decoder reads the download itself, as it arrives
+  bool stream_started_{false};  // The decoder has read the headers
 };

 }  // namespace esphome::online_image
@@ -0,0 +1,56 @@
+from typing import Any
+
+import esphome.codegen as cg
+from esphome.components.const import CONF_MAX_PACKET_SIZE
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+from esphome.cpp_generator import MockObj, MockObjClass
+from esphome.types import ConfigType
+
+CODEOWNERS = ["@clydebarrow"]
+DOMAIN = "packet_interface"
+IS_PLATFORM_COMPONENT = True
+
+CONF_PACKET_INTERFACE = "packet_interface"
+
+packet_interface_ns = cg.esphome_ns.namespace("packet_interface")
+PacketInterface = packet_interface_ns.class_("PacketInterface", cg.Component)
+
+__all__ = [
+    "CONF_MAX_PACKET_SIZE",
+    "CONF_PACKET_INTERFACE",
+    "PacketInterface",
+    "new_packet_interface",
+    "packet_interface_ns",
+    "packet_interface_schema",
+]
+
+
+def packet_interface_schema(
+    class_: MockObjClass,
+    default_max_packet_size: int,
+    max_packet_size_limit: int = 4096,
+) -> cv.Schema:
+    """Schema for a link platform."""
+    return cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(class_),
+            cv.Optional(
+                CONF_MAX_PACKET_SIZE, default=default_max_packet_size
+            ): cv.int_range(16, max_packet_size_limit),
+        }
+    ).extend(cv.COMPONENT_SCHEMA)
+
+
+async def new_packet_interface(config: ConfigType, *args: Any) -> MockObj:
+    """Create the link layer.
+
+    The link's constructor takes its maximum packet size, usually as a std::span over a buffer that code generation
+    sized from the configuration, so the two cannot differ.
+
+    Returns the link layer; applications reach the top layer with PacketInterface::top().
+    """
+    var = cg.new_Pvariable(config[CONF_ID], *args)
+    cg.add(var.set_name(config[CONF_ID].id))
+    await cg.register_component(var, config)
+    return var
@@ -0,0 +1,173 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <span>
+#include <vector>
+
+namespace esphome::packet_interface {
+
+/**
+ * A buffer class that efficiently represents a composite buffer with three sections:
+ * - pre_buffer: A pointer to uint8_t data with a length
+ * - mid_buffer: A reference to another PacketBuffer (optional)
+ * - post_buffer: A pointer to uint8_t data with a length
+ *
+ * This allows efficient zero-copy composition of buffers without allocating new memory.
+ *
+ * WARNING: PacketBuffer holds raw pointers to data. The user must ensure that the data remains valid
+ * for the lifetime of the PacketBuffer instance. Storing PacketBuffer instances beyond the scope of the data they
+ * reference will lead to dangling pointers and undefined behavior, so to keep a packet, copy it with copy_to() into a
+ * buffer allocated in setup().
+ */
+class PacketBuffer {
+ public:
+  PacketBuffer() = default;
+
+  // Disable copy semantics - PacketBuffer contains pointers and copying would create dangling references
+  PacketBuffer(const PacketBuffer &) = delete;
+  PacketBuffer &operator=(const PacketBuffer &) = delete;
+
+  // Enable move semantics
+  PacketBuffer(PacketBuffer &&) = default;
+  PacketBuffer &operator=(PacketBuffer &&) = default;
+
+  /**
+   * Construct from a single buffer.
+   */
+  PacketBuffer(const uint8_t *data, size_t length) : pre_buffer_(data), pre_length_(length) {}
+
+  /**
+   * Construct from a vector.
+   */
+  explicit PacketBuffer(const std::vector<uint8_t> &vec) : pre_buffer_(vec.data()), pre_length_(vec.size()) {}
+  // A temporary vector would leave the buffer dangling
+  explicit PacketBuffer(std::vector<uint8_t> &&) = delete;
+
+  /**
+   * Construct with pre and post buffers.
+   */
+  PacketBuffer(const uint8_t *pre_data, size_t pre_length, const uint8_t *post_data, size_t post_length)
+      : pre_buffer_(pre_data), pre_length_(pre_length), post_buffer_(post_data), post_length_(post_length) {}
+
+  /**
+   * Construct with pre, mid, and post buffers.
+   */
+  PacketBuffer(const uint8_t *pre_data, size_t pre_length, const PacketBuffer *mid_buffer, const uint8_t *post_data,
+               size_t post_length)
+      : pre_buffer_(pre_data),
+        pre_length_(pre_length),
+        mid_buffer_(mid_buffer),
+        post_buffer_(post_data),
+        post_length_(post_length) {}
+
+  /**
+   * Get the total size of the buffer.
+   */
+  size_t size() const {
+    size_t total = this->pre_length_ + this->post_length_;
+    if (this->mid_buffer_ != nullptr) {
+      total += this->mid_buffer_->size();
+    }
+    return total;
+  }
+
+  /**
+   * Check if the buffer is empty.
+   */
+  bool empty() const { return this->size() == 0; }
+
+  /**
+   * Check if all the data is held in the pre-buffer, so it can be read as one span.
+   */
+  bool is_contiguous() const { return this->mid_buffer_ == nullptr && this->post_length_ == 0; }
+
+  /**
+   * Get the data as one span. Only valid when is_contiguous() is true.
+   */
+  std::span<const uint8_t> as_span() const { return {this->pre_buffer_, this->pre_length_}; }
+
+  /**
+   * Access a byte at a specific position.
+   * @param index The position to access
+   * @return The byte at the specified position, or 0 past the end
+   */
+  uint8_t operator[](size_t index) const {
+    if (index < this->pre_length_) {
+      return this->pre_buffer_[index];
+    }
+    index -= this->pre_length_;
+
+    if (this->mid_buffer_ != nullptr) {
+      size_t mid_size = this->mid_buffer_->size();
+      if (index < mid_size) {
+        return (*this->mid_buffer_)[index];
+      }
+      index -= mid_size;
+    }
+
+    return index < this->post_length_ ? this->post_buffer_[index] : 0;
+  }
+
+  /**
+   * Copy data from the buffer to a destination pointer.
+   * @param dest Destination pointer
+   * @param count Number of bytes to copy
+   * @param offset Offset in the source buffer to start copying from
+   * @return Number of bytes actually copied
+   */
+  size_t copy_to(uint8_t *dest, size_t count, size_t offset = 0) const {
+    size_t total_size = this->size();
+    if (offset >= total_size) {
+      return 0;
+    }
+
+    size_t available = total_size - offset;
+    size_t to_copy = count < available ? count : available;
+    size_t copied = 0;
+
+    // Copy from pre_buffer
+    if (offset < this->pre_length_) {
+      size_t pre_offset = offset;
+      size_t pre_available = this->pre_length_ - pre_offset;
+      size_t pre_copy = to_copy < pre_available ? to_copy : pre_available;
+      std::memcpy(dest, this->pre_buffer_ + pre_offset, pre_copy);
+      copied += pre_copy;
+      dest += pre_copy;
+      offset += pre_copy;
+    }
+
+    // Copy from mid_buffer
+    size_t mid_size = this->mid_buffer_ != nullptr ? this->mid_buffer_->size() : 0;
+    if (copied < to_copy && offset < this->pre_length_ + mid_size) {
+      size_t mid_offset = offset - this->pre_length_;
+      size_t mid_available = mid_size - mid_offset;
+      size_t mid_copy = (to_copy - copied) < mid_available ? (to_copy - copied) : mid_available;
+      this->mid_buffer_->copy_to(dest, mid_copy, mid_offset);
+      copied += mid_copy;
+      dest += mid_copy;
+      offset += mid_copy;
+    }
+
+    // Copy from post_buffer
+    if ((copied < to_copy) && (this->post_length_ > 0)) {
+      size_t post_offset = offset - this->pre_length_ - mid_size;
+      size_t post_available = this->post_length_ - post_offset;
+      size_t post_copy = (to_copy - copied) < post_available ? (to_copy - copied) : post_available;
+      std::memcpy(dest, this->post_buffer_ + post_offset, post_copy);
+      copied += post_copy;
+    }
+
+    return copied;
+  }
+
+ private:
+  const uint8_t *pre_buffer_{nullptr};
+  size_t pre_length_{0};
+  const PacketBuffer *mid_buffer_{nullptr};
+  const uint8_t *post_buffer_{nullptr};
+  size_t post_length_{0};
+};
+
+}  // namespace esphome::packet_interface
@@ -0,0 +1,39 @@
+#include "packet_interface.h"
+#include "esphome/core/log.h"
+
+namespace esphome::packet_interface {
+
+ESPHOME_LOG_TAG(TAG, "packet_interface");
+
+// Packets in a row that cannot be understood before the mismatch is logged
+static constexpr uint8_t MISMATCH_COUNT = 10;
+
+void PacketInterface::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "Packet Interface '%s':\n"
+                "  Max Packet Size: %zu",
+                this->name_, this->get_max_packet_size());
+}
+
+void PacketInterface::on_receive_from_interface_(const PacketBuffer &data, const PacketMetaData &meta_data) {
+#ifdef ESPHOME_LOG_HAS_VERBOSE
+  static constexpr size_t LOG_BYTES = 24;
+  uint8_t head[LOG_BYTES];
+  size_t len = data.copy_to(head, LOG_BYTES);
+  ESP_LOGV_HEX(TAG, head, len, LOG_BYTES, "%s: received %zu bytes %s", this->name_, data.size());
+#endif
+  this->callback_.call(data, meta_data);
+}
+
+void PacketInterface::note_received_(bool understood) {
+  if (understood) {
+    this->not_understood_count_ = 0;
+  } else if (this->not_understood_count_ < MISMATCH_COUNT) {
+    this->not_understood_count_++;
+    if (this->not_understood_count_ == MISMATCH_COUNT) {
+      ESP_LOGW(TAG, "%s: %u packets in a row could not be understood; check that both ends have the same layers",
+               this->name_, MISMATCH_COUNT);
+    }
+  }
+}
+}  // namespace esphome::packet_interface
@@ -0,0 +1,149 @@
+#pragma once
+
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <utility>
+
+#include "esphome/core/string_ref.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/component.h"
+#include "packet_buffer.h"
+
+namespace esphome::packet_interface {
+
+/// The room left for a packet of \p size bytes after \p used bytes, or 0 if it is too small.
+constexpr size_t remaining_packet_size(size_t size, size_t used) { return size > used ? size - used : 0; }
+
+/// What a stack of layers provides, as bits of PacketInterface::get_capabilities().
+enum Capability : uint8_t {
+  CAPABILITY_ENCRYPTION = 1 << 0,
+  CAPABILITY_RELIABILITY = 1 << 1,
+  CAPABILITY_SESSION = 1 << 2,
+  CAPABILITY_ADDRESSING = 1 << 3,
+  CAPABILITY_FRAGMENTATION = 1 << 4,
+};
+
+/**
+ * A struct to hold metadata about a packet.
+ * @param info Additional information about the packet
+ * @param source_address With an addressing layer, the sender of a received packet; 0 if not known
+ * @param destination_address With an addressing layer, the destination of a packet; when sending, 0 uses the
+ * configured destination
+ * @param rssi The RSSI of the packet
+ * @param snr The SNR of the packet
+ * @param mac_address The MAC address of the sender/receiver
+ */
+class PacketMetaData {
+ public:
+  StringRef info{};
+  uint16_t source_address{0};
+  uint16_t destination_address{0};
+  float rssi{NAN};
+  float snr{NAN};
+  uint8_t mac_address[MAC_ADDRESS_SIZE]{};
+};
+/**
+ * A class that will transport data to and from an abstract channel.
+ *
+ * The operations defined are:
+ *
+ * Transmit: the function send_to_interface() takes a PacketBuffer of bytes, and returns when all data is
+ * written or buffered for transmission.
+ *
+ * Receive: The callbacks for an instance of this class are called with currently received data.
+ */
+class PacketInterface : public Component {
+ public:
+  /**
+   *
+   * Method to be implemented by child classes to send data to the interface.
+   *
+   * @param data The data to be sent
+   * @param meta_data Metadata about the packet to be sent
+   * @return True if the data was queued for transmission, false if it could not be sent
+   */
+  virtual bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) = 0;
+
+  /// The largest packet this layer accepts; fixed when the layer is constructed.
+  size_t get_max_packet_size() const { return this->max_packet_size_; }
+  /// How many packets send_to_interface() would accept now, so a layer above can tell before sending a series.
+  virtual size_t get_send_capacity() const { return SIZE_MAX; }
+  /// The capabilities of this layer and every layer below it.
+  uint8_t get_capabilities() const { return this->capabilities_; }
+  bool has_capability(Capability capability) const { return (this->capabilities_ & capability) != 0; }
+  /**
+   * With CAPABILITY_SESSION, the callback is called with true when the peer can be reached, including after it
+   * restarts, and with false when it is lost. The session layer is always the top layer, so register on top().
+   * A reliability layer calls it with false when it resets the link and discards data, which the session layer above
+   * reports as the session lost.
+   */
+  template<typename F> void add_on_session_state_callback(F &&callback) {
+    this->session_callback_.add(std::forward<F>(callback));
+  }
+
+  /// The topmost layer stacked on this one, or this one if nothing is stacked on it.
+  PacketInterface *top() {
+    PacketInterface *layer = this;
+    while (layer->upper_ != nullptr)
+      layer = layer->upper_;
+    return layer;
+  }
+  /// Name shown in log messages; a layer takes the name of the link it is stacked on.
+  void set_name(const char *name) { this->name_ = name; }
+  const char *get_name() const { return this->name_; }
+
+  /**
+   * Add a listener that will be called when data is received.
+   *
+   * @param callback The callback to be called when data is received.
+   */
+  template<typename F> void add_packet_interface_listener(F &&callback) {
+    this->callback_.add(std::forward<F>(callback));
+  }
+
+  void dump_config() override;
+
+ protected:
+  /// @param max_packet_size The largest packet the layer accepts, set from the layer below or the layer's own buffer
+  explicit PacketInterface(size_t max_packet_size) : max_packet_size_(max_packet_size) {}
+
+  virtual ~PacketInterface() = default;
+  /**
+   * This function should be called by implementing classes with received data to be passed to any listeners.
+   *
+   * @param data The received data
+   * @param meta_data Metadata about the received packet
+   */
+  void on_receive_from_interface_(const PacketBuffer &data, const PacketMetaData &meta_data);
+  /**
+   * Called by a layer for each received packet it understood, or could not make sense of. A run of packets that
+   * cannot be understood usually means the peer has different layers configured, which is logged once per run.
+   */
+  void note_received_(bool understood);
+  /// Called by a layer's constructor to record itself as the layer above \p lower, adding its own capability.
+  void stack_on_(PacketInterface *lower, Capability capability) {
+    lower->upper_ = this;
+    this->inherit_from_(lower, capability);
+  }
+  /// Takes the name and capabilities of `lower` without becoming its top, for one of several stacks on a link.
+  void inherit_from_(PacketInterface *lower, Capability capability) {
+    this->name_ = lower->name_;
+    this->capabilities_ = lower->capabilities_ | capability;
+    // A link that has a session of its own, such as TCP, reports it to whatever is stacked above, as does a
+    // reliability layer that discards data; the session layer handles the latter itself
+    if ((lower->has_capability(CAPABILITY_SESSION) || lower->has_capability(CAPABILITY_RELIABILITY)) &&
+        capability != CAPABILITY_SESSION) {
+      lower->add_on_session_state_callback([this](bool connected) { this->session_callback_.call(connected); });
+    }
+  }
+
+  LazyCallbackManager<void(const PacketBuffer &, const PacketMetaData &)> callback_;
+  LazyCallbackManager<void(bool)> session_callback_;
+  PacketInterface *upper_{nullptr};
+  const char *name_{""};
+  const size_t max_packet_size_;
+  uint8_t capabilities_{0};
+  uint8_t not_understood_count_{0};
+};
+}  // namespace esphome::packet_interface
@@ -0,0 +1,28 @@
+import esphome.codegen as cg
+from esphome.components.packet_transport import (
+    PacketTransport,
+    new_packet_transport,
+    transport_schema,
+)
+import esphome.config_validation as cv
+from esphome.types import ConfigType
+
+from .. import CONF_PACKET_INTERFACE, PacketInterface, packet_interface_ns
+
+CODEOWNERS = ["@clydebarrow"]
+DEPENDENCIES = ["packet_interface"]
+
+PacketInterfaceTransport = packet_interface_ns.class_(
+    "PacketInterfaceTransport", PacketTransport
+)
+
+CONFIG_SCHEMA = transport_schema(PacketInterfaceTransport).extend(
+    {
+        cv.GenerateID(CONF_PACKET_INTERFACE): cv.use_id(PacketInterface),
+    }
+)
+
+
+async def to_code(config: ConfigType) -> None:
+    interface = await cg.get_variable(config[CONF_PACKET_INTERFACE])
+    await new_packet_transport(config, interface)
@@ -0,0 +1,29 @@
+#include "packet_interface_transport.h"
+#include "esphome/core/log.h"
+
+namespace esphome::packet_interface {
+
+ESPHOME_LOG_TAG(TAG, "packet_interface.transport");
+
+void PacketInterfaceTransport::setup() {
+  PacketTransport::setup();
+  this->interface_ = this->interface_->top();
+  this->interface_->add_packet_interface_listener(
+      [this](const PacketBuffer &data, const PacketMetaData &) { this->receive_(data); });
+}
+
+void PacketInterfaceTransport::receive_(const PacketBuffer &data) {
+  // Packet interface layers deliver packets in one piece
+  if (!data.is_contiguous()) {
+    ESP_LOGW(TAG, "Packet split across buffers is not supported");
+    return;
+  }
+  this->process_(data.as_span());
+}
+
+void PacketInterfaceTransport::send_packet(const std::vector<uint8_t> &buf) const {
+  if (!this->interface_->send_to_interface(PacketBuffer(buf), {}))
+    ESP_LOGD(TAG, "Failed to send packet of %zu bytes", buf.size());
+}
+
+}  // namespace esphome::packet_interface
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "esphome/components/packet_interface/packet_interface.h"
+#include "esphome/components/packet_transport/packet_transport.h"
+
+namespace esphome::packet_interface {
+
+/**
+ * A transport protocol adapter that bridges PacketInterface to PacketTransport.
+ * This allows packet_transport functionality to be used with any PacketInterface implementation.
+ */
+class PacketInterfaceTransport : public packet_transport::PacketTransport {
+ public:
+  explicit PacketInterfaceTransport(PacketInterface *interface) : interface_(interface) {}
+
+  void setup() override;
+
+  float get_setup_priority() const override { return setup_priority::PROCESSOR; }
+
+ protected:
+  // implementing PacketTransport virtual methods
+  size_t get_max_packet_size() override { return this->interface_->top()->get_max_packet_size(); }
+  void send_packet(const std::vector<uint8_t> &buf) const override;
+  void receive_(const PacketBuffer &data);
+
+  PacketInterface *interface_;
+};
+
+}  // namespace esphome::packet_interface
@@ -205,8 +205,10 @@ async def register_packet_transport(var: MockObj, config: ConfigType) -> set[str
    return providers


-async def new_packet_transport(config: ConfigType) -> tuple[MockObj, set[str]]:
-    var = cg.new_Pvariable(config[CONF_ID])
+async def new_packet_transport(
+    config: ConfigType, *args: Any
+) -> tuple[MockObj, set[str]]:
+    var = cg.new_Pvariable(config[CONF_ID], *args)
    cg.add(var.set_platform_name(config[CONF_PLATFORM]))
    providers = await register_packet_transport(var, config)
    return var, providers
@@ -547,9 +547,11 @@ void PacketTransport::dump_config() {
  ESP_LOGCONFIG(TAG,
                "Packet Transport:\n"
                "  Platform: %s\n"
+                "  Max Packet Size: %zu\n"
                "  Encrypted: %s\n"
                "  Ping-pong: %s",
-                this->platform_name_, YESNO(this->is_encrypted_()), YESNO(this->ping_pong_enable_));
+                this->platform_name_, this->get_max_packet_size(), YESNO(this->is_encrypted_()),
+                YESNO(this->ping_pong_enable_));
 #ifdef USE_SENSOR
  for (const auto &sensor : this->sensors_) {
    ESP_LOGCONFIG(TAG, "  Sensor: %s", sensor.id);
@@ -138,7 +138,7 @@ int HOT JpegDecoder::decode(uint8_t *buffer, size_t size) {
  const int err = this->start_();
  if (err != 0)
    return err;
-  if (!this->jpeg_.decode(0, 0, 0))
+  if (!this->jpeg_.decode(0, 0, this->scale_option_()))
    return this->fail_();
  this->decoded_bytes_ = size;
  this->jpeg_.close();
@@ -165,10 +165,28 @@ int JpegDecoder::start_() {
  } else {
    this->jpeg_.setPixelType(RGB8888);
  }
-  if (!this->set_size(this->jpeg_.getWidth(), this->jpeg_.getHeight())) {
+  const int width = this->jpeg_.getWidth();
+  const int height = this->jpeg_.getHeight();
+  if (!this->set_size(width, height)) {
    return DECODE_ERROR_OUT_OF_MEMORY;
  }
-  if (this->direct_rgb565_ && !this->prepare_rgb565_scaling_(this->jpeg_.getWidth(), this->jpeg_.getHeight())) {
+  // JPEGDEC can decode at 1/2, 1/4 or 1/8 size for much less work. Use the smallest size that still has at least as
+  // many pixels as the buffer, so a large image shown small is not decoded in full only to be thrown away.
+  const int buffer_width = this->image_->get_buffer_width();
+  const int buffer_height = this->image_->get_buffer_height();
+  this->scale_ = 1;
+  while (this->scale_ < JPEG_SCALE_EIGHTH && width / (this->scale_ * 2) >= buffer_width &&
+         height / (this->scale_ * 2) >= buffer_height) {
+    this->scale_ *= 2;
+  }
+  const int decoded_width = (width + this->scale_ - 1) / this->scale_;
+  const int decoded_height = (height + this->scale_ - 1) / this->scale_;
+  this->x_scale_ = static_cast<double>(buffer_width) / decoded_width;
+  this->y_scale_ = static_cast<double>(buffer_height) / decoded_height;
+  if (this->scale_ != 1) {
+    ESP_LOGD(TAG, "Decoding at 1/%d size, %d x %d", this->scale_, decoded_width, decoded_height);
+  }
+  if (this->direct_rgb565_ && !this->prepare_rgb565_scaling_(decoded_width, decoded_height)) {
    return DECODE_ERROR_OUT_OF_MEMORY;
  }
  return 0;
@@ -252,7 +270,7 @@ int JpegDecoder::begin_source(DecodeSource *source) {
    this->source_ = nullptr;
    return err;
  }
-  if (!this->jpeg_.decodeBegin(0, 0, 0))
+  if (!this->jpeg_.decodeBegin(0, 0, this->scale_option_()))
    return this->fail_();
  return 0;
 }
@@ -31,12 +31,16 @@ class JpegDecoder : public ImageDecoder {
  int HOT decode_step() override;

  bool uses_direct_rgb565() const { return this->direct_rgb565_; }
+  /// JPEGDEC decodes the image at 1/get_scale() of its size: 1, 2, 4 or 8
+  int get_scale() const { return this->scale_; }
  void draw_rgb565(int x, int y, int w, int h, const uint8_t *pixels);

 protected:
  bool prepare_rgb565_scaling_(int width, int height);
  /// Set up an opened image for decoding. Returns 0, or a DecodeError.
  int start_();
+  /// The JPEGDEC option for scale_: JPEG_SCALE_HALF, _QUARTER and _EIGHTH are the divisors themselves
+  int scale_option_() const { return this->scale_ == 1 ? 0 : this->scale_; }
  /// The DecodeError for a failed read of the source or JPEGDEC's last error, closing the image
  int fail_();

@@ -49,6 +53,7 @@ class JpegDecoder : public ImageDecoder {
  FixedVector<uint16_t> y_boundaries_{};
  int source_width_{0};
  int source_height_{0};
+  int scale_{1};                   // JPEGDEC decodes at 1/scale_ of the image size
  DecodeSource *source_{nullptr};  // Set while a begin_source() decode is in progress
  bool direct_rgb565_{false};
  bool source_failed_{false};
@@ -19,6 +19,52 @@ static constexpr uint8_t LOG_LEVEL_TO_SYSLOG_SEVERITY[] PROGMEM = {
    7   // VERY_VERBOSE
 };

+static constexpr char SECRET_BEGIN[] = ESPHOME_LOG_SECRET_BEGIN;
+static constexpr char SECRET_END[] = ESPHOME_LOG_SECRET_END;
+static constexpr size_t SECRET_BEGIN_LEN = sizeof(SECRET_BEGIN) - 1;
+static constexpr size_t SECRET_END_LEN = sizeof(SECRET_END) - 1;
+
+static bool starts_with_marker(const char *message, size_t remaining, const char *marker, size_t marker_len) {
+  return message[0] == '\033' && remaining >= marker_len && memcmp(message, marker, marker_len) == 0;
+}
+
+static size_t append_bytes(char *buf, size_t size, size_t pos, const char *data, size_t len) {
+  if (pos >= size) {
+    return size;
+  }
+  size_t n = std::min(len, size - pos - 1);
+  memcpy(buf + pos, data, n);
+  pos += n;
+  buf[pos] = '\0';
+  return pos;
+}
+
+size_t append_redacted_message(char *buf, size_t size, size_t pos, const char *message, size_t len) {
+  if (memchr(message, '\033', len) == nullptr) {
+    return append_bytes(buf, size, pos, message, len);
+  }
+  size_t i = 0;
+  while (i < len) {
+    if (starts_with_marker(message + i, len - i, SECRET_BEGIN, SECRET_BEGIN_LEN)) {
+      pos = buf_append_str(buf, size, pos, "[redacted]");
+      i += SECRET_BEGIN_LEN;
+      while (i < len && !starts_with_marker(message + i, len - i, SECRET_END, SECRET_END_LEN)) {
+        i++;
+      }
+      if (i < len) {
+        i += SECRET_END_LEN;
+      }
+      continue;
+    }
+    size_t start = i;
+    while (i < len && !starts_with_marker(message + i, len - i, SECRET_BEGIN, SECRET_BEGIN_LEN)) {
+      i++;
+    }
+    pos = append_bytes(buf, size, pos, message + start, i - start);
+  }
+  return pos;
+}
+
 void Syslog::setup() {
  logger::global_logger->add_log_callback(
      this, [](void *self, uint8_t level, const char *tag, const char *message, size_t message_len) {
@@ -71,16 +117,15 @@ void Syslog::log_(const int level, const char *tag, const char *message, size_t
    } else {
      offset = buf_append_str(packet, sizeof(packet), offset, "-");
    }
-    offset = buf_append_printf(packet, sizeof(packet), offset, " %s %s - - - %.*s", App.get_name().c_str(), tag,
-                               (int) len, message);
+    offset = buf_append_printf(packet, sizeof(packet), offset, " %s %s - - - ", App.get_name().c_str(), tag);
  } else {
    // RFC 3164 has no NILVALUE. If the clock is invalid, omit TIMESTAMP so a relay can add it.
    if (now.is_valid()) {
      offset += now.strftime(packet + offset, sizeof(packet) - offset, "%b %e %H:%M:%S ");
    }
-    offset = buf_append_printf(packet, sizeof(packet), offset, "%s %s: %.*s", App.get_name().c_str(), tag, (int) len,
-                               message);
+    offset = buf_append_printf(packet, sizeof(packet), offset, "%s %s: ", App.get_name().c_str(), tag);
  }
+  offset = append_redacted_message(packet, sizeof(packet), offset, message, len);
  // Clamp to exclude null terminator position if buffer was filled
  if (offset >= sizeof(packet)) {
    offset = sizeof(packet) - 1;
@@ -12,6 +12,10 @@ enum SyslogFormat : uint8_t {
  SYSLOG_FORMAT_RFC5424,
 };

+/// Append len bytes of message to buf at pos, replacing every LOG_SECRET() region with "[redacted]".
+/// Returns the new position, capped at size like the other buf_append helpers.
+size_t append_redacted_message(char *buf, size_t size, size_t pos, const char *message, size_t len);
+
 class Syslog final : public Component, public Parented<udp::UDPComponent> {
 public:
  Syslog(int level, time::RealTimeClock *time) : log_level_(level), time_(time) {}
@@ -0,0 +1,36 @@
+import esphome.codegen as cg
+from esphome.components import packet_interface, uart
+from esphome.components.packet_interface import (
+    CONF_MAX_PACKET_SIZE,
+    packet_interface_schema,
+)
+from esphome.const import CONF_ID
+from esphome.types import ConfigType
+
+from .. import uart_ns
+
+CODEOWNERS = ["@clydebarrow"]
+
+DEPENDENCIES = ["uart"]
+
+UartPacketInterface = uart_ns.class_(
+    "UartPacketInterface",
+    packet_interface.PacketInterface,
+    uart.UARTDevice,
+)
+
+CONFIG_SCHEMA = packet_interface_schema(UartPacketInterface, 508).extend(
+    uart.UART_DEVICE_SCHEMA
+)
+
+
+async def to_code(config: ConfigType) -> None:
+    # The receive buffer's size is known here, so it is a static array rather than allocated at run time
+    rx_buffer = f"{config[CONF_ID].id}__rx_buffer"
+    cg.add_global(
+        cg.RawStatement(f"static uint8_t {rx_buffer}[{config[CONF_MAX_PACKET_SIZE]}];")
+    )
+    var = await packet_interface.new_packet_interface(
+        config, cg.RawExpression(rx_buffer)
+    )
+    await uart.register_uart_device(var, config)
@@ -0,0 +1,82 @@
+#include "esphome/core/log.h"
+#include "uart_packet_interface.h"
+
+namespace esphome::uart {
+
+using packet_interface::PacketBuffer;
+using packet_interface::PacketMetaData;
+
+ESPHOME_LOG_TAG(TAG, "uart.packet_interface");
+
+static constexpr uint8_t FLAG_BYTE = 0x7E;
+static constexpr uint8_t CONTROL_BYTE = 0x7D;
+static constexpr uint8_t ESCAPE_XOR = 0x20;
+// Raw bytes escaped and written per UART write
+static constexpr size_t TX_CHUNK_SIZE = 32;
+
+void UartPacketInterface::loop() {
+  this->read_available([this](uint8_t byte) { this->handle_rx_byte_(byte); });
+}
+
+void UartPacketInterface::handle_rx_byte_(uint8_t byte) {
+  if (byte == FLAG_BYTE) {
+    // A flag that ends a frame also starts the next, so an unfinished frame cannot hide the one after it
+    if (this->rx_started_ && this->rx_length_ != 0)
+      this->on_receive_from_interface_(PacketBuffer(this->rx_buffer_.data(), this->rx_length_), {});
+    this->rx_started_ = true;
+    this->rx_length_ = 0;
+    this->rx_control_ = false;
+    return;
+  }
+  if (!this->rx_started_)
+    return;
+  if (byte == CONTROL_BYTE) {
+    this->rx_control_ = true;
+    return;
+  }
+  if (this->rx_control_) {
+    byte ^= ESCAPE_XOR;
+    this->rx_control_ = false;
+  }
+  if (this->rx_length_ >= this->rx_buffer_.size()) {
+    ESP_LOGD(TAG, "Packet too large, discarding");
+    this->rx_started_ = false;
+    this->rx_length_ = 0;
+    return;
+  }
+  this->rx_buffer_[this->rx_length_++] = byte;
+}
+
+bool UartPacketInterface::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
+  size_t size = data.size();
+  if (size == 0)
+    return true;
+  if (size > this->max_packet_size_) {
+    ESP_LOGW(TAG, "Packet of %zu bytes is larger than %zu", size, this->max_packet_size_);
+    return false;
+  }
+  uint8_t raw[TX_CHUNK_SIZE]{};
+  // Every byte may be escaped, plus a flag byte at each end
+  uint8_t out[TX_CHUNK_SIZE * 2 + 2];
+  size_t out_len = 0;
+  out[out_len++] = FLAG_BYTE;
+  for (size_t offset = 0; offset < size;) {
+    size_t count = data.copy_to(raw, TX_CHUNK_SIZE, offset);
+    offset += count;
+    for (size_t i = 0; i != count; i++) {
+      uint8_t byte = raw[i];
+      if (byte == FLAG_BYTE || byte == CONTROL_BYTE) {
+        out[out_len++] = CONTROL_BYTE;
+        byte ^= ESCAPE_XOR;
+      }
+      out[out_len++] = byte;
+    }
+    if (offset == size)
+      out[out_len++] = FLAG_BYTE;
+    this->write_array(out, out_len);
+    out_len = 0;
+  }
+  return true;
+}
+
+}  // namespace esphome::uart
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <span>
+
+#include "esphome/components/packet_interface/packet_interface.h"
+#include "esphome/components/uart/uart.h"
+
+namespace esphome::uart {
+
+/**
+ * A packet interface for sending and receiving framed packets over a UART connection.
+ * Uses simple byte-stuffing framing with FLAG_BYTE and CONTROL_BYTE.
+ * The protocol wraps data between FLAG_BYTEs.
+ * Any occurrence of FLAG_BYTE or CONTROL_BYTE in the data is escaped by emitting CONTROL_BYTE followed by the byte
+ * XORed with 0x20.
+ */
+class UartPacketInterface : public packet_interface::PacketInterface, public UARTDevice {
+ public:
+  /// @param rx_buffer Holds the unescaped data being received; its size is the largest packet, and it must outlive
+  /// the link
+  explicit UartPacketInterface(std::span<uint8_t> rx_buffer)
+      : packet_interface::PacketInterface(rx_buffer.size()), rx_buffer_(rx_buffer) {}
+
+  void loop() override;
+  bool send_to_interface(const packet_interface::PacketBuffer &data,
+                         const packet_interface::PacketMetaData &meta_data) override;
+
+ protected:
+  void handle_rx_byte_(uint8_t byte);
+  const std::span<uint8_t> rx_buffer_;
+  size_t rx_length_{0};
+  bool rx_started_{};
+  bool rx_control_{};
+};
+
+}  // namespace esphome::uart
@@ -6,6 +6,10 @@ namespace esphome::uart {

 ESPHOME_LOG_TAG(TAG, "uart_transport");

+static constexpr uint16_t MAX_PACKET_SIZE = 508;
+static constexpr uint8_t FLAG_BYTE = 0x7E;
+static constexpr uint8_t CONTROL_BYTE = 0x7D;
+
 void UARTTransport::loop() {
  PacketTransport::loop();

@@ -78,4 +82,5 @@ void UARTTransport::send_packet(const std::vector<uint8_t> &buf) const {
  this->parent_->write_byte(FLAG_BYTE);
 }

+size_t UARTTransport::get_max_packet_size() { return MAX_PACKET_SIZE; }
 }  // namespace esphome::uart
@@ -16,9 +16,6 @@ namespace esphome::uart {
 * Any occurrence of FLAG_BYTE or CONTROL_BYTE in the data is escaped by emitting CONTROL_BYTE followed by the byte
 * XORed with 0x20.
 */
-static const uint16_t MAX_PACKET_SIZE = 508;
-static const uint8_t FLAG_BYTE = 0x7E;
-static const uint8_t CONTROL_BYTE = 0x7D;

 class UARTTransport final : public packet_transport::PacketTransport, public UARTDevice {
 public:
@@ -29,7 +26,7 @@ class UARTTransport final : public packet_transport::PacketTransport, public UAR
  void write_byte_(uint8_t byte) const;
  void send_packet(const std::vector<uint8_t> &buf) const override;
  bool should_send() override { return true; };
-  size_t get_max_packet_size() override { return MAX_PACKET_SIZE; }
+  size_t get_max_packet_size() override;
  std::vector<uint8_t> receive_buffer_{};
  bool rx_started_{};
  bool rx_control_{};
@@ -0,0 +1,40 @@
+import esphome.codegen as cg
+from esphome.components import packet_interface
+from esphome.components.packet_interface import (
+    CONF_MAX_PACKET_SIZE,
+    new_packet_interface,
+    packet_interface_schema,
+)
+from esphome.const import CONF_ID
+from esphome.types import ConfigType
+
+from .. import CONF_UDP_ID, UDP_SCHEMA, udp_ns
+
+CODEOWNERS = ["@clydebarrow"]
+
+DEPENDENCIES = ["udp"]
+
+# Size of the receive buffer of the udp component
+MAX_PACKET_SIZE = 508
+
+UdpPacketInterface = udp_ns.class_(
+    "UdpPacketInterface",
+    packet_interface.PacketInterface,
+)
+
+CONFIG_SCHEMA = packet_interface_schema(
+    UdpPacketInterface, MAX_PACKET_SIZE, MAX_PACKET_SIZE
+).extend(UDP_SCHEMA)
+
+
+async def to_code(config: ConfigType) -> None:
+    udp_var = await cg.get_variable(config[CONF_UDP_ID])
+    cg.add(udp_var.set_should_listen())
+    # The udp component sends to its addresses through its broadcast socket
+    cg.add(udp_var.set_should_broadcast())
+    # The copy buffer's size is known here, so it is a static array rather than allocated at run time
+    tx_buffer = f"{config[CONF_ID].id}__tx_buffer"
+    cg.add_global(
+        cg.RawStatement(f"static uint8_t {tx_buffer}[{config[CONF_MAX_PACKET_SIZE]}];")
+    )
+    await new_packet_interface(config, udp_var, cg.RawExpression(tx_buffer))
@@ -0,0 +1,43 @@
+#include "udp_packet_interface.h"
+#ifdef USE_NETWORK
+#include "esphome/components/network/util.h"
+#include "esphome/core/log.h"
+
+namespace esphome::udp {
+
+using packet_interface::PacketBuffer;
+using packet_interface::PacketMetaData;
+
+ESPHOME_LOG_TAG(TAG, "udp.packet_interface");
+
+void UdpPacketInterface::setup() {
+  this->parent_->add_listener([this](std::span<const uint8_t> data) { this->receive_(data); });
+}
+
+void UdpPacketInterface::receive_(std::span<const uint8_t> data) {
+  if (data.size() > this->max_packet_size_) {
+    ESP_LOGV(TAG, "%s: Packet of %zu bytes is larger than %zu, dropped", this->name_, data.size(),
+             this->max_packet_size_);
+    return;
+  }
+  this->on_receive_from_interface_(PacketBuffer(data.data(), data.size()), {});
+}
+
+bool UdpPacketInterface::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
+  size_t size = data.size();
+  if (size > this->max_packet_size_) {
+    ESP_LOGW(TAG, "%s: Packet of %zu bytes is larger than %zu", this->name_, size, this->max_packet_size_);
+    return false;
+  }
+  if (!network::is_connected())
+    return false;
+  if (data.is_contiguous()) {
+    auto span = data.as_span();
+    return this->parent_->send_packet(span.data(), span.size());
+  }
+  data.copy_to(this->tx_buffer_.data(), size);
+  return this->parent_->send_packet(this->tx_buffer_.data(), size);
+}
+
+}  // namespace esphome::udp
+#endif
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+// udp_component.h declares nothing without USE_NETWORK
+#ifdef USE_NETWORK
+#include <span>
+
+#include "esphome/components/packet_interface/packet_interface.h"
+#include "../udp_component.h"
+
+namespace esphome::udp {
+
+/**
+ * A packet interface link over UDP: each packet is one datagram, sent to every address of the UDP component.
+ *
+ * Every datagram received on the listen port is passed up, from any sender, so on a shared network an addressing
+ * or encryption layer is needed to tell the peer's packets from others.
+ */
+class UdpPacketInterface : public packet_interface::PacketInterface {
+ public:
+  /// @param tx_buffer Joins packets split across buffers; its size is the largest packet, and it must outlive the link
+  UdpPacketInterface(UDPComponent *udp_component, std::span<uint8_t> tx_buffer)
+      : packet_interface::PacketInterface(tx_buffer.size()), parent_(udp_component), tx_buffer_(tx_buffer) {}
+
+  void setup() override;
+  bool send_to_interface(const packet_interface::PacketBuffer &data,
+                         const packet_interface::PacketMetaData &meta_data) override;
+
+ protected:
+  void receive_(std::span<const uint8_t> data);
+
+  UDPComponent *parent_;
+  const std::span<uint8_t> tx_buffer_;
+};
+}  // namespace esphome::udp
+#endif
@@ -1,12 +1,9 @@
-#include "esphome/core/log.h"
 #include "esphome/core/application.h"
 #include "esphome/components/network/util.h"
 #include "udp_transport.h"

 namespace esphome::udp {

-ESPHOME_LOG_TAG(TAG, "udp_transport");
-
 bool UDPTransport::should_send() { return network::is_connected(); }
 void UDPTransport::setup() {
  PacketTransport::setup();
@@ -205,18 +205,25 @@ void UDPComponent::set_poll_warning_(PollStep step, const LogString *what) {
 }

 void UDPComponent::loop() {
-  if (this->should_listen_) {
-    std::array<uint8_t, MAX_PACKET_SIZE> buf;
-    for (;;) {
-      if (!this->listen_socket_->ready())
-        break;
-      auto len = this->listen_socket_->read(buf.data(), buf.size());
-      if (len <= 0)
-        break;
-      size_t packet_len = static_cast<size_t>(len);
-      ESP_LOGV(TAG, "Received packet of length %zu", packet_len);
-      this->packet_listeners_.call(std::span<const uint8_t>(buf.data(), packet_len));
+  if (!this->should_listen_) {
+    this->disable_loop();
+    return;
+  }
+  // One byte more than the largest packet, as a read cuts a longer datagram to fit and so cannot report it
+  std::array<uint8_t, MAX_PACKET_SIZE + 1> buf;
+  for (;;) {
+    if (!this->listen_socket_->ready())
+      break;
+    auto len = this->listen_socket_->read(buf.data(), buf.size());
+    if (len <= 0)
+      break;
+    size_t packet_len = static_cast<size_t>(len);
+    if (packet_len > MAX_PACKET_SIZE) {
+      ESP_LOGV(TAG, "Packet longer than %zu bytes dropped", MAX_PACKET_SIZE);
+      continue;
    }
+    ESP_LOGV(TAG, "Received packet of length %zu", packet_len);
+    this->packet_listeners_.call(std::span<const uint8_t>(buf.data(), packet_len));
  }
 }

@@ -239,9 +246,10 @@ void UDPComponent::dump_config() {
                YESNO(this->should_broadcast_), YESNO(this->should_listen_));
 }

-void UDPComponent::send_packet(const uint8_t *data, size_t size) {
+bool UDPComponent::send_packet(const uint8_t *data, size_t size) {
  if (this->is_failed())
-    return;  // a send socket may be missing
+    return false;  // a send socket may be missing
+  bool sent = true;
  for (const auto &entry : this->sockaddrs_) {
 #ifdef USE_UDP_IPV6_SEND
    const bool v6 = entry.sa.sa_family == AF_INET6;
@@ -256,11 +264,23 @@ void UDPComponent::send_packet(const uint8_t *data, size_t size) {
    socket::UDPSendSocket *sock = this->broadcast_socket_.get();
    socklen_t sockaddr_size = sizeof(sockaddr_in);
 #endif
+    if (sock == nullptr) {
+      ESP_LOGW(TAG, "Broadcast socket not initialized");
+      return false;
+    }
    auto result = sock->sendto(data, size, 0, &entry.sa, sockaddr_size);
    if (result < 0) {
-      ESP_LOGW(TAG, "sendto() error %d", errno);
+      // lwIP refuses a packet with ENOMEM while the destination's ARP lookup is pending and its queue is full;
+      // the packet can be sent again later
+      if (errno == ENOMEM) {
+        ESP_LOGV(TAG, "sendto() out of memory");
+      } else {
+        ESP_LOGW(TAG, "sendto() error %d", errno);
+      }
+      sent = false;
    }
  }
+  return sent;
 }
 }  // namespace esphome::udp

@@ -35,8 +35,9 @@ class UDPComponent final : public Component {
  void setup() override;
  void loop() override;
  void dump_config() override;
-  void send_packet(const uint8_t *data, size_t size);
-  void send_packet(const std::vector<uint8_t> &buf) { this->send_packet(buf.data(), buf.size()); }
+  /// Returns false if the packet could not be sent to every destination.
+  bool send_packet(const uint8_t *data, size_t size);
+  bool send_packet(const std::vector<uint8_t> &buf) { return this->send_packet(buf.data(), buf.size()); }
  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; };

 protected:
@@ -53,7 +54,7 @@ class UDPComponent final : public Component {
  bool network_poll_();
  void set_poll_warning_(PollStep step, const LogString *what);

-  CallbackManager<void(std::span<const uint8_t>)> packet_listeners_{};
+  LazyCallbackManager<void(std::span<const uint8_t>)> packet_listeners_{};
  std::unique_ptr<socket::UDPSendSocket> broadcast_socket_ = nullptr;
  std::unique_ptr<socket::UDPSocket> listen_socket_ = nullptr;
 #ifdef USE_UDP_IPV6_SEND
@@ -29,12 +29,14 @@ class HashBase {
  void get_hex(char *output) { format_hex_to(output, this->get_size() * 2 + 1, this->digest_, this->get_size()); }

  /// Compare the hash against a provided byte-encoded hash
-  bool equals_bytes(const uint8_t *expected) { return memcmp(this->digest_, expected, this->get_size()) == 0; }
+  bool equals_bytes(const uint8_t *expected) { return constant_time_equals(this->digest_, expected, this->get_size()); }

-  /// Compare the hash against a provided hex-encoded hash
+  /// Compare the hash against a provided hex-encoded hash of get_size() * 2 characters, which need not be
+  /// null-terminated
  bool equals_hex(const char *expected) {
    uint8_t parsed[32];  // Fixed size for max hash (SHA256 = 32 bytes)
-    if (!parse_hex(expected, parsed, this->get_size())) {
+    const size_t size = this->get_size();
+    if (parse_hex(expected, size * 2, parsed, size) != size * 2) {
      return false;
    }
    return this->equals_bytes(parsed);
@@ -1112,6 +1112,16 @@ template<typename T> constexpr T convert_little_endian(T val) {
 #endif
 }

+/// Compare len bytes of a and b in a time that does not depend on where they first differ.
+/// Use this for digests, passwords and tokens, where memcmp's early exit leaks how many bytes matched.
+inline bool constant_time_equals(const uint8_t *a, const uint8_t *b, size_t len) {
+  volatile uint8_t diff = 0;
+  for (size_t i = 0; i < len; i++) {
+    diff = diff | (a[i] ^ b[i]);
+  }
+  return diff == 0;
+}
+
 ///@}

 /// @name Strings
@@ -188,6 +188,8 @@ def load_component_yaml_configs(components: list[str], tests_dir: Path) -> dict:

    The ``esphome:`` key is special: its sub-keys are merged into the
    existing esphome config (e.g. to add ``areas:`` or ``devices:``).
+    A list, such as the entries of a platform component, is extended, so
+    several directories can each add their own entries to one key.
    Keys already present in the base config (e.g. ``host:``, ``logger:``)
    are protected by ``setdefault`` in the caller.

@@ -213,6 +215,9 @@ def load_component_yaml_configs(components: list[str], tests_dir: Path) -> dict:
                    for sub_key, sub_value in value.items():
                        esphome_extra.setdefault(sub_key, sub_value)
                    continue
+                if isinstance(value, list) and isinstance(merged.get(key), list):
+                    merged[key] = merged[key] + value
+                    continue
                merged.setdefault(key, value)
    return merged

@@ -0,0 +1,39 @@
+#include <gtest/gtest.h>
+
+#include <cstdint>
+
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+
+TEST(ConstantTimeEquals, EqualBuffers) {
+  const uint8_t a[] = {0x00, 0x01, 0x7F, 0x80, 0xFF};
+  const uint8_t b[] = {0x00, 0x01, 0x7F, 0x80, 0xFF};
+  EXPECT_TRUE(constant_time_equals(a, b, sizeof(a)));
+}
+
+TEST(ConstantTimeEquals, FirstByteDiffers) {
+  const uint8_t a[] = {0x00, 0x01, 0x02, 0x03};
+  const uint8_t b[] = {0x10, 0x01, 0x02, 0x03};
+  EXPECT_FALSE(constant_time_equals(a, b, sizeof(a)));
+}
+
+TEST(ConstantTimeEquals, LastByteDiffers) {
+  const uint8_t a[] = {0x00, 0x01, 0x02, 0x03};
+  const uint8_t b[] = {0x00, 0x01, 0x02, 0x13};
+  EXPECT_FALSE(constant_time_equals(a, b, sizeof(a)));
+}
+
+TEST(ConstantTimeEquals, SingleBitDifference) {
+  const uint8_t a[] = {0xAA, 0xAA};
+  const uint8_t b[] = {0xAA, 0xAB};
+  EXPECT_FALSE(constant_time_equals(a, b, sizeof(a)));
+}
+
+TEST(ConstantTimeEquals, ZeroLengthIsEqual) {
+  const uint8_t a[] = {0x01};
+  const uint8_t b[] = {0x02};
+  EXPECT_TRUE(constant_time_equals(a, b, 0));
+}
+
+}  // namespace esphome
@@ -0,0 +1,54 @@
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <cstring>
+
+#include "esphome/core/hash_base.h"
+
+namespace esphome {
+
+// A four byte "hash" whose digest is set directly, so the compare helpers can be tested on their own
+class FixedHash : public HashBase {
+ public:
+  void init() override {}
+  void add(const uint8_t *data, size_t len) override {}
+  void calculate() override {}
+  size_t get_size() const override { return 4; }
+  void set_digest(const uint8_t *digest) { memcpy(this->digest_, digest, 4); }
+};
+
+static const uint8_t DIGEST[] = {0xDE, 0xAD, 0xBE, 0xEF};
+
+TEST(HashBaseEquals, BytesMatch) {
+  FixedHash hash;
+  hash.set_digest(DIGEST);
+  EXPECT_TRUE(hash.equals_bytes(DIGEST));
+  const uint8_t other[] = {0xDE, 0xAD, 0xBE, 0xEE};
+  EXPECT_FALSE(hash.equals_bytes(other));
+}
+
+TEST(HashBaseEquals, HexMatchEitherCase) {
+  FixedHash hash;
+  hash.set_digest(DIGEST);
+  EXPECT_TRUE(hash.equals_hex("deadbeef"));
+  EXPECT_TRUE(hash.equals_hex("DEADBEEF"));
+  EXPECT_FALSE(hash.equals_hex("deadbeee"));
+}
+
+TEST(HashBaseEquals, HexWithoutTerminatorOnlyReadsDigestLength) {
+  FixedHash hash;
+  hash.set_digest(DIGEST);
+  // The expected digest sits in a larger buffer with no terminator after it, as in the OTA auth buffer
+  const char buffer[] = {'d', 'e', 'a', 'd', 'b', 'e', 'e', 'f', 'z', 'z', 'z', 'z'};
+  EXPECT_TRUE(hash.equals_hex(buffer));
+}
+
+TEST(HashBaseEquals, ShortOrInvalidHexRejected) {
+  FixedHash hash;
+  hash.set_digest(DIGEST);
+  EXPECT_FALSE(hash.equals_hex("deadbee"));
+  EXPECT_FALSE(hash.equals_hex(""));
+  EXPECT_FALSE(hash.equals_hex("deadbeeg"));
+}
+
+}  // namespace esphome
@@ -19,6 +19,11 @@ image:
        } else {
          ESP_LOGD("online_image", "Cache miss: fresh download");
        }
+    on_download_started:
+      - logger.log: Download started
+    on_download_progress:
+      lambda: |-
+        ESP_LOGD("online_image", "Downloaded %.0f%% (%zu bytes)", progress, bytes_read);
  - platform: online_image
    id: online_binary_transparent_image
    url: http://www.libpng.org/pub/png/img_png/pnglogo-blk-tiny.png
@@ -2,6 +2,7 @@

 #include <algorithm>
 #include <array>
+#include <cmath>
 #include <cstdint>
 #include <cstring>
 #include <memory>
@@ -27,6 +28,9 @@ class FakeContainer : public http_request::HttpContainer {
  }

  int read(uint8_t *buf, size_t max_len) override {
+    this->largest_read = std::max(this->largest_read, max_len);
+    if (this->read_error_)
+      return -1;
    size_t len = std::min(max_len, this->available_ - this->bytes_read_);
    std::memcpy(buf, this->body_.data() + this->bytes_read_, len);
    this->bytes_read_ += len;
@@ -42,13 +46,21 @@ class FakeContainer : public http_request::HttpContainer {
  }

  void set_content_length(size_t length) { this->content_length = length; }
+  /// Make every read from now on fail, like a dropped connection
+  void fail_reads() { this->read_error_ = true; }
+  /// Let len more bytes of the body arrive
+  void deliver(size_t len) { this->available_ = std::min(this->body_.size(), this->available_ + len); }
  void add_response_header(const std::string &name, const std::string &value) {
    this->response_headers_.push_back({name, value});
  }

+  /// The most bytes any one read() asked for
+  size_t largest_read{0};
+
 protected:
  std::vector<uint8_t> body_;
  size_t available_;
+  bool read_error_{false};
 };

 class FakeHttpRequest : public http_request::HttpRequestComponent {
@@ -123,13 +135,173 @@ static constexpr std::array<uint8_t, 69> PNG_1X1{
    0x0C, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9C, 0x63, 0xF8, 0xCF, 0xC0, 0x00, 0x00, 0x03, 0x01, 0x01, 0x00, 0xC9,
    0xFE, 0x92, 0xEF, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82};

+// 8x8 progressive JPEG, 521 bytes
+static const uint8_t JPEG_PROGRESSIVE[] = {
+    0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,
+    0x00, 0xFF, 0xDB, 0x00, 0x43, 0x00, 0x10, 0x0B, 0x0C, 0x0E, 0x0C, 0x0A, 0x10, 0x0E, 0x0D, 0x0E, 0x12, 0x11, 0x10,
+    0x13, 0x18, 0x28, 0x1A, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23, 0x25, 0x1D, 0x28, 0x3A, 0x33, 0x3D, 0x3C, 0x39, 0x33,
+    0x38, 0x37, 0x40, 0x48, 0x5C, 0x4E, 0x40, 0x44, 0x57, 0x45, 0x37, 0x38, 0x50, 0x6D, 0x51, 0x57, 0x5F, 0x62, 0x67,
+    0x68, 0x67, 0x3E, 0x4D, 0x71, 0x79, 0x70, 0x64, 0x78, 0x5C, 0x65, 0x67, 0x63, 0xFF, 0xDB, 0x00, 0x43, 0x01, 0x11,
+    0x12, 0x12, 0x18, 0x15, 0x18, 0x2F, 0x1A, 0x1A, 0x2F, 0x63, 0x42, 0x38, 0x42, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+    0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0xFF, 0xC2, 0x00, 0x11, 0x08, 0x00, 0x08, 0x00, 0x08, 0x03, 0x01, 0x22, 0x00,
+    0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xFF, 0xC4, 0x00, 0x15, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0xFF, 0xC4, 0x00, 0x15, 0x01, 0x01, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0xFF, 0xDA, 0x00, 0x0C, 0x03,
+    0x01, 0x00, 0x02, 0x10, 0x03, 0x10, 0x00, 0x00, 0x01, 0x94, 0x05, 0x3F, 0xFF, 0xC4, 0x00, 0x14, 0x10, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08,
+    0x01, 0x01, 0x00, 0x01, 0x05, 0x02, 0x7F, 0xFF, 0xC4, 0x00, 0x14, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01, 0x03, 0x01, 0x01, 0x3F,
+    0x01, 0x7F, 0xFF, 0xC4, 0x00, 0x14, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01, 0x02, 0x01, 0x01, 0x3F, 0x01, 0x7F, 0xFF, 0xC4, 0x00,
+    0x14, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xFF, 0xDA, 0x00, 0x08, 0x01, 0x01, 0x00, 0x06, 0x3F, 0x02, 0x7F, 0xFF, 0xC4, 0x00, 0x14, 0x10, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01,
+    0x01, 0x00, 0x01, 0x3F, 0x21, 0x7F, 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x10, 0x0B, 0xFF, 0xC4, 0x00, 0x14, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01, 0x03, 0x01, 0x01, 0x3F, 0x10, 0x7F, 0xFF, 0xC4, 0x00,
+    0x14, 0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xFF, 0xDA, 0x00, 0x08, 0x01, 0x02, 0x01, 0x01, 0x3F, 0x10, 0x7F, 0xFF, 0xC4, 0x00, 0x14, 0x10, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x08, 0x01,
+    0x01, 0x00, 0x01, 0x3F, 0x10, 0x7F, 0xFF, 0xD9,
+};
+
+// 48x40 4:2:0 JPEG (quality 95), 2344 bytes: three rows of 16 pixel MCUs, with the scan starting at byte 609
+static const uint8_t JPEG_48X40[] = {
+    0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,
+    0x00, 0xFF, 0xDB, 0x00, 0x43, 0x00, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02,
+    0x02, 0x02, 0x04, 0x03, 0x02, 0x02, 0x02, 0x02, 0x05, 0x04, 0x04, 0x03, 0x04, 0x06, 0x05, 0x06, 0x06, 0x06, 0x05,
+    0x06, 0x06, 0x06, 0x07, 0x09, 0x08, 0x06, 0x07, 0x09, 0x07, 0x06, 0x06, 0x08, 0x0B, 0x08, 0x09, 0x0A, 0x0A, 0x0A,
+    0x0A, 0x0A, 0x06, 0x08, 0x0B, 0x0C, 0x0B, 0x0A, 0x0C, 0x09, 0x0A, 0x0A, 0x0A, 0xFF, 0xDB, 0x00, 0x43, 0x01, 0x02,
+    0x02, 0x02, 0x02, 0x02, 0x02, 0x05, 0x03, 0x03, 0x05, 0x0A, 0x07, 0x06, 0x07, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
+    0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
+    0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A,
+    0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0x28, 0x00, 0x30, 0x03, 0x01, 0x22, 0x00,
+    0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
+    0x0B, 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00,
+    0x00, 0x01, 0x7D, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+    0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33, 0x62,
+    0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37,
+    0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A,
+    0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85,
+    0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
+    0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
+    0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
+    0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F, 0x01, 0x00,
+    0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
+    0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04,
+    0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31,
+    0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 0x09,
+    0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A,
+    0x26, 0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
+    0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75,
+    0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
+    0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,
+    0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8,
+    0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9,
+    0xFA, 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 0x00, 0x3F, 0x00, 0xFC, 0xAA, 0xB8, 0xB7,
+    0xD3, 0xB5, 0xD8, 0x1E, 0xD6, 0xD1, 0xA5, 0x5B, 0x4B, 0x46, 0x10, 0xC1, 0x06, 0xA1, 0x29, 0x69, 0x25, 0xB7, 0xC2,
+    0xC6, 0x0C, 0x71, 0x26, 0x5E, 0x50, 0x15, 0x5D, 0xB6, 0x9C, 0x9E, 0x00, 0xC1, 0x67, 0x67, 0x4D, 0xCF, 0x84, 0xF7,
+    0x57, 0xA6, 0xDA, 0x08, 0x52, 0xF5, 0xE5, 0xBA, 0xB8, 0x7B, 0x5B, 0x68, 0xEE, 0x2F, 0x66, 0x89, 0xB7, 0xB7, 0x9B,
+    0xE5, 0x9C, 0x23, 0xAA, 0xFE, 0xF7, 0x68, 0x11, 0x9E, 0x5D, 0x18, 0x12, 0x48, 0x56, 0x5C, 0x9F, 0x57, 0xB6, 0xF8,
+    0x33, 0xF0, 0xE2, 0x5B, 0xFB, 0xCF, 0xF4, 0x51, 0x0C, 0xC6, 0x64, 0x30, 0x49, 0x71, 0x7C, 0xE2, 0x16, 0x90, 0x2E,
+    0xF4, 0x72, 0xEA, 0xE0, 0x34, 0x81, 0x77, 0x93, 0x9C, 0x07, 0xC2, 0x93, 0xB9, 0x61, 0xC0, 0xD3, 0xF0, 0x17, 0xC1,
+    0xBF, 0x03, 0xCD, 0xE1, 0xAD, 0x42, 0x3F, 0x0A, 0xD8, 0xC7, 0x2D, 0xAC, 0x36, 0xCB, 0xF6, 0x79, 0x22, 0x69, 0x84,
+    0xC4, 0x93, 0x29, 0x2A, 0x89, 0xB9, 0x00, 0x50, 0x62, 0x7C, 0xFF, 0x00, 0x16, 0xD9, 0x65, 0x00, 0x16, 0x65, 0x07,
+    0xFA, 0x5B, 0x36, 0xE2, 0xAC, 0xBF, 0x2D, 0x55, 0x79, 0x29, 0xB5, 0x26, 0x9B, 0xA9, 0x18, 0xB5, 0x15, 0x36, 0x9B,
+    0x53, 0xD1, 0xCA, 0x10, 0x93, 0x69, 0xB6, 0x94, 0x27, 0x16, 0xAF, 0x19, 0x29, 0xB8, 0xBB, 0x3F, 0x9A, 0xE1, 0x1E,
+    0x2A, 0xCB, 0x9E, 0x79, 0x4A, 0x92, 0x84, 0xDA, 0xD6, 0xED, 0xA4, 0xED, 0x7A, 0x72, 0xB5, 0xAC, 0xF6, 0xEB, 0xAD,
+    0xD5, 0x97, 0x91, 0xC9, 0x4D, 0xA4, 0xE9, 0xD7, 0x56, 0x45, 0x66, 0xD3, 0x9D, 0x85, 0xB1, 0x86, 0x59, 0x7E, 0xD9,
+    0x7E, 0xA0, 0xE0, 0xA8, 0x02, 0x17, 0x02, 0x3C, 0x36, 0x59, 0x18, 0xE2, 0x42, 0x1D, 0x40, 0x56, 0x0A, 0x77, 0x30,
+    0xAE, 0xFA, 0x56, 0xD4, 0xA4, 0x8A, 0xD9, 0xAD, 0xD6, 0x38, 0x1D, 0x7F, 0x77, 0x77, 0x1C, 0xB2, 0x4C, 0x22, 0x8C,
+    0x2B, 0xF3, 0x14, 0x64, 0x45, 0x85, 0x52, 0x47, 0x92, 0x7E, 0xF2, 0x0F, 0x34, 0x1D, 0xBC, 0x56, 0xDE, 0x85, 0xF0,
+    0x4B, 0xE1, 0x0A, 0xE9, 0xB0, 0xDB, 0x2D, 0x8C, 0x4C, 0xCD, 0x74, 0xF1, 0x42, 0x96, 0x93, 0xCF, 0xF6, 0x54, 0x0C,
+    0xB3, 0x44, 0x03, 0xAA, 0x6C, 0x49, 0x10, 0x87, 0x00, 0x88, 0xC2, 0xEE, 0x66, 0x6F, 0x9B, 0xAB, 0x57, 0xA4, 0x68,
+    0xDF, 0x0A, 0x3E, 0x1B, 0xDA, 0xE9, 0xDF, 0xD9, 0x96, 0xFE, 0x03, 0xB2, 0x8E, 0xD9, 0x8A, 0xDD, 0xC1, 0x77, 0x14,
+    0x97, 0x50, 0x2E, 0xE3, 0x20, 0x62, 0xA0, 0x33, 0x0C, 0xC6, 0x58, 0x48, 0x36, 0x6D, 0xC1, 0x20, 0xA2, 0x2B, 0x00,
+    0xB5, 0xF1, 0x99, 0xCF, 0x19, 0x65, 0x79, 0xAD, 0x0C, 0x3C, 0x2B, 0x61, 0xF9, 0x28, 0xD6, 0x52, 0x97, 0x35, 0x95,
+    0xD4, 0x61, 0x28, 0x5B, 0x99, 0xB8, 0xA9, 0xA9, 0x47, 0xD9, 0x3A, 0x69, 0xA9, 0xC6, 0x51, 0x52, 0x6A, 0x0D, 0x4A,
+    0x74, 0xA9, 0xC3, 0xFA, 0x7F, 0xC3, 0xFE, 0x25, 0xC1, 0x4E, 0xAE, 0x26, 0x2E, 0x13, 0x71, 0x5C, 0x8D, 0xFB, 0xB1,
+    0xD6, 0xEA, 0x6F, 0xF9, 0xAF, 0xBE, 0xB7, 0x4B, 0x55, 0x1D, 0x75, 0x4C, 0xF3, 0xDF, 0x05, 0xD9, 0xF8, 0x7B, 0xC3,
+    0xBA, 0xB5, 0xF1, 0xBC, 0x8D, 0x63, 0xDF, 0x1C, 0x32, 0x88, 0x1A, 0xF3, 0x74, 0x73, 0x89, 0x15, 0xC4, 0x8A, 0x25,
+    0x66, 0xDC, 0xAA, 0x98, 0x60, 0x06, 0x7F, 0xBD, 0xF2, 0x81, 0xF3, 0x36, 0xFE, 0x9D, 0xAF, 0x78, 0x8F, 0x54, 0xD3,
+    0xAD, 0xA6, 0x9E, 0xC5, 0xE5, 0x9C, 0x96, 0xDC, 0xB7, 0xE8, 0x84, 0x47, 0xFB, 0xB4, 0x54, 0x42, 0x0F, 0x03, 0xF8,
+    0xD7, 0xE5, 0x39, 0x60, 0xF8, 0x04, 0x79, 0x7B, 0xE3, 0xF4, 0x9F, 0x85, 0x5F, 0x08, 0xBE, 0x0D, 0x2C, 0x57, 0xCE,
+    0x6C, 0xA5, 0x2B, 0xA8, 0x08, 0x20, 0x82, 0x04, 0xB9, 0xB8, 0x82, 0x43, 0x28, 0x72, 0x55, 0xD5, 0x83, 0xB9, 0x05,
+    0xC2, 0x44, 0x55, 0x77, 0x8C, 0xFC, 0xEC, 0xD8, 0xCB, 0xE7, 0xBE, 0x9B, 0xE0, 0x5F, 0xC3, 0x9D, 0x32, 0xD4, 0x45,
+    0x26, 0x8B, 0x2C, 0x93, 0xC0, 0xF3, 0x95, 0x49, 0xEE, 0x2E, 0x0C, 0x26, 0x26, 0x31, 0xC9, 0xF3, 0xED, 0x95, 0x96,
+    0x32, 0xEC, 0x10, 0xE1, 0xB8, 0x60, 0x3A, 0x90, 0x1B, 0x3F, 0x9E, 0x66, 0x58, 0xFC, 0x14, 0x31, 0x15, 0xFD, 0x9C,
+    0x79, 0x57, 0x3A, 0x92, 0x84, 0x1C, 0x3D, 0xC9, 0xCD, 0x27, 0x6D, 0x12, 0xE5, 0xE7, 0xA6, 0xD5, 0x4D, 0x64, 0x93,
+    0xD1, 0x45, 0xC6, 0xAD, 0xE7, 0x2F, 0xE9, 0xEE, 0x17, 0xE3, 0x0C, 0x0A, 0xE1, 0x9C, 0x37, 0x34, 0x67, 0x2B, 0x73,
+    0x2B, 0xB4, 0xBA, 0x49, 0xF4, 0x72, 0x57, 0x51, 0xDD, 0x24, 0x9B, 0x5A, 0x36, 0x9A, 0x49, 0x1E, 0x15, 0xA7, 0x7E,
+    0xCE, 0xF6, 0x89, 0x6A, 0x96, 0x43, 0x55, 0xB5, 0xB3, 0xB6, 0xB8, 0x96, 0x2B, 0x9B, 0x78, 0xA0, 0xB4, 0x9E, 0xE5,
+    0x61, 0x90, 0xE0, 0xC2, 0xEC, 0x61, 0x91, 0x47, 0xCC, 0xDB, 0xF1, 0x80, 0xC0, 0x98, 0xD4, 0xE5, 0xDC, 0x64, 0xEC,
+    0x7C, 0x29, 0xFD, 0x98, 0x6C, 0xAF, 0xEC, 0xF5, 0x76, 0xB7, 0xF1, 0x36, 0x9A, 0x5D, 0x6F, 0x96, 0xE1, 0x74, 0xB5,
+    0xD3, 0x44, 0x91, 0xA8, 0x45, 0x0C, 0xE2, 0x3D, 0xAC, 0x85, 0xF9, 0x3B, 0x5B, 0x19, 0x8A, 0x43, 0x1F, 0xCA, 0x50,
+    0x9D, 0x87, 0xD2, 0x0F, 0xC2, 0x1F, 0x89, 0x4F, 0x6D, 0x04, 0x0F, 0xE1, 0x61, 0xAA, 0xEE, 0xB4, 0x8E, 0x56, 0xFB,
+    0x06, 0xAF, 0x04, 0xF3, 0x40, 0x9B, 0x55, 0x4E, 0xCB, 0x66, 0x91, 0xCB, 0x18, 0xC2, 0x88, 0xB6, 0xB1, 0x65, 0x60,
+    0xA4, 0x6E, 0xDC, 0xA4, 0x9E, 0xAF, 0xE1, 0xBF, 0xC2, 0x2F, 0x89, 0xA9, 0xE1, 0xFB, 0x8D, 0x6E, 0xC2, 0x3B, 0x4B,
+    0x30, 0xD7, 0x60, 0xDA, 0x41, 0x2D, 0xCC, 0x6C, 0x2E, 0x49, 0xF3, 0x1E, 0x42, 0x19, 0x5D, 0x58, 0x3C, 0x8A, 0x81,
+    0x82, 0xB8, 0x0C, 0xC9, 0xF2, 0xE5, 0x8F, 0x03, 0x8F, 0x36, 0xE3, 0x8A, 0x98, 0xCC, 0x14, 0xAB, 0x62, 0x2B, 0xC2,
+    0x34, 0xA2, 0xA5, 0x78, 0x37, 0x42, 0x12, 0x70, 0x8C, 0x62, 0xD2, 0x6D, 0x72, 0x7B, 0xAF, 0x9B, 0xDD, 0xFD, 0xE5,
+    0x4E, 0x79, 0x49, 0x45, 0x73, 0xA9, 0x72, 0x2F, 0xF0, 0x73, 0x83, 0xF8, 0xCE, 0xB4, 0x33, 0xE8, 0x3F, 0xAE, 0x42,
+    0xF7, 0x76, 0xB3, 0x83, 0x57, 0xE5, 0x95, 0xBE, 0xCE, 0x8F, 0x7B, 0xDE, 0xD7, 0x4B, 0x6B, 0x9C, 0x1E, 0x8D, 0xF0,
+    0x56, 0x7B, 0xDD, 0x26, 0x34, 0x5F, 0x1F, 0xDB, 0x9D, 0x37, 0x53, 0xB8, 0x96, 0xED, 0xA0, 0x16, 0xB1, 0xC9, 0x2C,
+    0x8B, 0xF2, 0x26, 0x58, 0x89, 0x37, 0xEE, 0x04, 0xB2, 0x97, 0x54, 0x2D, 0x88, 0xC0, 0x60, 0x0B, 0x03, 0x5E, 0x9B,
+    0x67, 0xFB, 0x36, 0xE9, 0x31, 0x2D, 0x9C, 0x37, 0x9E, 0x32, 0x84, 0x5D, 0x2C, 0x4A, 0xD6, 0xAD, 0x73, 0x63, 0x28,
+    0x36, 0xAA, 0x53, 0xF7, 0x90, 0x29, 0x8E, 0x5C, 0x92, 0xBE, 0x41, 0xDC, 0xC0, 0xB3, 0x2B, 0x46, 0x32, 0x4B, 0x96,
+    0x35, 0xAD, 0x1F, 0xC2, 0xDF, 0x89, 0x17, 0xF6, 0xB6, 0xFA, 0xB5, 0xED, 0xB8, 0xB7, 0x8E, 0x78, 0x66, 0x96, 0x09,
+    0x6C, 0x6E, 0x23, 0x32, 0x28, 0x08, 0xE8, 0xF2, 0xBA, 0xF9, 0x86, 0x48, 0xC0, 0x68, 0xFE, 0x63, 0xC8, 0x23, 0x82,
+    0xCC, 0xA5, 0x4A, 0xFA, 0x66, 0x8F, 0xF0, 0x37, 0xE2, 0x6D, 0xE5, 0xC9, 0x3A, 0x87, 0x86, 0xB4, 0xFB, 0x28, 0xAE,
+    0x61, 0x0F, 0x0B, 0x59, 0xDF, 0xC0, 0xD1, 0xAC, 0xE0, 0x24, 0x41, 0x42, 0xC4, 0x49, 0x1B, 0x10, 0x21, 0x50, 0xC0,
+    0x09, 0x11, 0x8B, 0xEE, 0x6E, 0x71, 0xE2, 0xE2, 0x78, 0xBB, 0x33, 0xFA, 0xC5, 0x1A, 0xB4, 0xEA, 0xC6, 0x74, 0xD2,
+    0x8C, 0x24, 0xA5, 0x2A, 0x3C, 0xB5, 0x2E, 0xB9, 0x9B, 0x71, 0x97, 0x34, 0xE0, 0xAA, 0x54, 0x93, 0x71, 0x56, 0x49,
+    0xB9, 0xC6, 0x4E, 0x9A, 0x9B, 0xD3, 0xFA, 0x7F, 0x81, 0xB8, 0xD6, 0xAC, 0xDD, 0x6F, 0x65, 0x8D, 0x82, 0x77, 0x85,
+    0x95, 0xE1, 0x7D, 0x1C, 0xD2, 0x8B, 0x7A, 0x27, 0xA2, 0xF4, 0xED, 0xEE, 0x9E, 0x67, 0xE0, 0x8F, 0x81, 0x37, 0xBA,
+    0xEF, 0x87, 0x67, 0xBF, 0x8F, 0xC4, 0xD2, 0xDD, 0x4F, 0x05, 0xA8, 0x61, 0x7B, 0x1E, 0x9E, 0xE1, 0x8C, 0xEA, 0xF3,
+    0x18, 0x99, 0xA3, 0xDE, 0x76, 0x66, 0x36, 0x2A, 0x30, 0xFB, 0x9B, 0x0F, 0xC3, 0x1C, 0xA3, 0x76, 0x4B, 0xFB, 0x3B,
+    0xE8, 0xBA, 0x66, 0xBF, 0x0E, 0x93, 0xFD, 0xAB, 0x23, 0xD9, 0xA5, 0xCE, 0x62, 0xF3, 0x34, 0xEB, 0x7F, 0x29, 0x0A,
+    0xA7, 0x04, 0x48, 0xF2, 0x79, 0x82, 0x42, 0x1D, 0x46, 0x4B, 0xA9, 0x1B, 0xD1, 0xBE, 0x52, 0x54, 0xD7, 0xA8, 0xF8,
+    0x33, 0xE1, 0xAF, 0xC4, 0xA8, 0x24, 0xD6, 0x6D, 0xED, 0xBC, 0x0A, 0xD3, 0x5A, 0x5C, 0xC4, 0xDF, 0x64, 0x17, 0x97,
+    0x36, 0xF0, 0x65, 0x52, 0x39, 0xD4, 0x23, 0x22, 0x9D, 0xD8, 0x64, 0x83, 0x04, 0x85, 0x38, 0xEF, 0xB8, 0x49, 0x91,
+    0xBB, 0xFF, 0x00, 0x0A, 0xDF, 0xE3, 0x77, 0x84, 0xAC, 0xD3, 0x4A, 0xBC, 0xF0, 0x3A, 0x5A, 0x5B, 0x4F, 0x72, 0x5E,
+    0xD7, 0x53, 0x8E, 0xE2, 0x12, 0x6D, 0xC6, 0x40, 0x20, 0x47, 0xE6, 0x3E, 0x71, 0x26, 0x70, 0x24, 0xE4, 0xB4, 0x63,
+    0x2A, 0xC0, 0xE0, 0x7E, 0x71, 0x98, 0x71, 0x35, 0x5C, 0x4E, 0x69, 0x5A, 0xBD, 0x7C, 0x7A, 0x9C, 0xE3, 0xC9, 0xCF,
+    0x38, 0x46, 0x8D, 0xA4, 0xDC, 0x63, 0x38, 0x4A, 0xE9, 0xED, 0x5A, 0x4E, 0x4A, 0x6D, 0xF3, 0xCA, 0x2D, 0xB9, 0x4D,
+    0xD3, 0x77, 0x8C, 0x7F, 0xA8, 0xF8, 0x53, 0x8D, 0x31, 0x32, 0xC8, 0xA9, 0xDB, 0x15, 0x04, 0x9F, 0xB4, 0xD2, 0xF4,
+    0xD3, 0xF8, 0xA5, 0x77, 0xCD, 0xB3, 0x49, 0x6C, 0xB4, 0xEA, 0x97, 0x46, 0x78, 0x45, 0xC4, 0x16, 0x5A, 0xDD, 0xA5,
+    0xA6, 0x8D, 0xA7, 0xEA, 0x77, 0x4A, 0x54, 0x47, 0x3C, 0x31, 0x41, 0x20, 0x06, 0x68, 0x00, 0x9A, 0x4F, 0x2A, 0x40,
+    0x5D, 0x5F, 0x69, 0xF3, 0x15, 0xCB, 0x32, 0x96, 0xDC, 0xC0, 0x90, 0xA5, 0xF0, 0xBD, 0xAF, 0xC3, 0x96, 0x83, 0x51,
+    0xB8, 0xD6, 0xA7, 0x48, 0xD2, 0xE8, 0x2B, 0x2C, 0x2D, 0x6B, 0xF6, 0xA4, 0x55, 0x8E, 0x45, 0x5F, 0xBA, 0x54, 0x2A,
+    0x36, 0x77, 0x12, 0x72, 0xE5, 0x9C, 0x14, 0x3B, 0x63, 0x6C, 0x62, 0x8A, 0x2B, 0xDE, 0xCD, 0x70, 0x74, 0xA7, 0x92,
+    0xE2, 0x31, 0x35, 0x2D, 0x29, 0x54, 0xBB, 0x97, 0xBB, 0x18, 0xF3, 0x38, 0x52, 0xA5, 0x38, 0xDF, 0x92, 0x31, 0x7E,
+    0xEB, 0x9B, 0x6A, 0xCD, 0x6B, 0xEF, 0x7C, 0x6E, 0x52, 0x7F, 0xE1, 0xF7, 0x0E, 0x54, 0x96, 0x1B, 0x3D, 0x52, 0x86,
+    0xF0, 0x73, 0x4B, 0xEE, 0x92, 0xD6, 0xD6, 0xBF, 0xC2, 0x8D, 0x9F, 0x0B, 0xDE, 0xEB, 0xF3, 0x69, 0x6B, 0x06, 0x9B,
+    0xA9, 0x5B, 0xE9, 0xF6, 0x6F, 0x76, 0x1E, 0x45, 0x8E, 0xE1, 0x54, 0xC8, 0xCD, 0xF3, 0x28, 0x8B, 0x1C, 0x9E, 0x25,
+    0x55, 0xDA, 0xA5, 0x58, 0x80, 0xCA, 0x46, 0x42, 0xA8, 0xF4, 0x1B, 0xEB, 0xBB, 0xBB, 0x8B, 0x69, 0xAF, 0xA5, 0x8E,
+    0xD0, 0x49, 0x25, 0x9C, 0x37, 0x73, 0xE9, 0xD7, 0xF2, 0x14, 0x8E, 0x55, 0x91, 0x64, 0x90, 0x46, 0xA8, 0xF9, 0x50,
+    0x57, 0x73, 0x2E, 0xE0, 0x55, 0xF6, 0x87, 0x45, 0x20, 0x2E, 0xC7, 0x28, 0xAF, 0xCD, 0x78, 0xA6, 0xA5, 0x5C, 0x26,
+    0x33, 0x01, 0x35, 0x2E, 0x67, 0x52, 0x35, 0xA0, 0xEE, 0x93, 0x56, 0x70, 0x4F, 0x48, 0xDB, 0x95, 0x6B, 0x76, 0xF4,
+    0xB4, 0xA5, 0x27, 0x29, 0x29, 0x35, 0x16, 0xBF, 0xA8, 0x7C, 0x3E, 0x92, 0xF6, 0x98, 0xA8, 0x5B, 0x4B, 0xC5, 0xDB,
+    0x5E, 0x8E, 0x4F, 0x7D, 0xFA, 0xDB, 0x57, 0xB2, 0x56, 0xD6, 0xED, 0xF7, 0x3E, 0x10, 0xB2, 0x82, 0xF6, 0xC2, 0xF2,
+    0xF3, 0x4E, 0xD4, 0xAF, 0xEE, 0x5A, 0xCA, 0xCE, 0xD2, 0xF1, 0xA7, 0xB8, 0x9D, 0xD4, 0x42, 0x8C, 0xF2, 0x3C, 0x8E,
+    0x42, 0x02, 0x24, 0xFD, 0xDA, 0x96, 0x60, 0xAD, 0xB0, 0xC9, 0x0E, 0x00, 0xC8, 0xC8, 0xEA, 0xEE, 0x12, 0x7B, 0x09,
+    0x6C, 0x6E, 0xCE, 0xA2, 0x0B, 0xAA, 0x32, 0xD9, 0xB9, 0x49, 0x66, 0xDF, 0x74, 0xCC, 0x31, 0x1B, 0xE4, 0xE6, 0x63,
+    0xF2, 0x91, 0x95, 0x42, 0x15, 0x8B, 0x7D, 0xE0, 0xAC, 0xB4, 0x51, 0x5F, 0x33, 0x3A, 0xD8, 0x8C, 0x46, 0x7A, 0x9C,
+    0xA6, 0xD7, 0x2C, 0x13, 0x49, 0x25, 0x6E, 0x6A, 0x73, 0xE4, 0x84, 0x9E, 0x9A, 0xC9, 0x29, 0x24, 0x9E, 0xE9, 0x42,
+    0x11, 0x8D, 0xA2, 0x9C, 0x5F, 0xF5, 0x37, 0x0D, 0x36, 0xF8, 0x7E, 0x9A, 0xEC, 0xE5, 0xE5, 0x7E, 0x67, 0x77, 0x7B,
+    0x7A, 0xBF, 0x5E, 0xB7, 0x3F, 0xFF, 0xD9,
+};
+
 static void set_loop_time(uint32_t now) { LoopBlockingGuard clock(nullptr, LOG_STR("test"), now); }

 class OnlineImageDownloadEnd : public ::testing::Test {
 protected:
-  std::unique_ptr<OnlineImage> make_image_(runtime_image::ImageFormat format) {
+  std::unique_ptr<OnlineImage> make_image_(runtime_image::ImageFormat format, uint32_t buffer_size = 256) {
    auto img = std::make_unique<OnlineImage>("http://example.com/image", 0, 0, format, image::IMAGE_TYPE_RGB,
-                                             image::TRANSPARENCY_OPAQUE, nullptr, 256);
+                                             image::TRANSPARENCY_OPAQUE, nullptr, buffer_size);
    img->set_parent(&this->http_);
    return img;
  }
@@ -286,4 +458,294 @@ TEST_F(OnlineImageDownloadEnd, JpegBufferAllocationFailureReportsError) {
  EXPECT_EQ(this->finished_, 0);
 }

+// The JPEG decoded with all of it in memory at once, to compare the downloaded images with
+static std::vector<uint8_t> reference_jpeg_pixels() {
+  runtime_image::RuntimeImage ref(runtime_image::JPEG, image::IMAGE_TYPE_RGB, image::TRANSPARENCY_OPAQUE);
+  std::vector<uint8_t> data(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40));
+  EXPECT_TRUE(ref.begin_decode(data.size()));
+  EXPECT_EQ(ref.feed_data(data.data(), data.size()), static_cast<int>(data.size()));
+  EXPECT_TRUE(ref.end_decode());
+  return std::vector<uint8_t>(ref.get_data_start(), ref.get_data_start() + ref.get_width_stride() * ref.get_height());
+}
+
+static std::vector<uint8_t> image_pixels(OnlineImage &image) {
+  return std::vector<uint8_t>(image.get_data_start(),
+                              image.get_data_start() + image.get_width_stride() * image.get_height());
+}
+
+// A JPEG of known size is decoded as it arrives, so a buffer smaller than the file only has to hold the headers
+TEST_F(OnlineImageDownloadEnd, JpegDecodesThroughASmallBuffer) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  // Bytes after the image are never needed. Waiting for the whole file before decoding would read them all.
+  std::vector<uint8_t> body(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40));
+  body.resize(body.size() + 8192, 0);
+  auto container = std::make_shared<FakeContainer>(body, body.size(), false);
+  container->add_response_header("etag", "\"abc\"");
+  this->start_(*image, container);
+
+  for (int i = 0; i < 100 && this->finished_ + this->errors_ == 0; i++)
+    image->loop();
+
+  ASSERT_EQ(this->finished_, 1);
+  EXPECT_LT(container->get_bytes_read(), body.size()) << "the image was not decoded as it arrived";
+  EXPECT_EQ(this->errors_, 0);
+  ASSERT_EQ(image->get_width(), 48);
+  ASSERT_EQ(image->get_height(), 40);
+  EXPECT_EQ(image_pixels(*image), reference_jpeg_pixels());
+
+  // A complete image is cached
+  this->http_.next = std::make_shared<FakeContainer>(std::vector<uint8_t>{}, 0, false);
+  image->update();
+  EXPECT_TRUE(this->http_.sent_header("if-none-match"));
+}
+
+// A read() waits for every byte it asks for, so a large buffer is filled a little at a time rather than in one
+// read that blocks the loop until the whole buffer has arrived
+TEST_F(OnlineImageDownloadEnd, JpegReadsInSmallPiecesWithALargeBuffer) {
+  auto image = this->make_image_(runtime_image::JPEG, 65536);
+  auto container =
+      std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)), 0, false);
+  this->start_(*image, container);
+
+  for (int i = 0; i < 100 && this->finished_ + this->errors_ == 0; i++) {
+    container->deliver(sizeof(JPEG_48X40));
+    image->loop();
+  }
+
+  ASSERT_EQ(this->finished_, 1);
+  EXPECT_EQ(this->errors_, 0);
+  EXPECT_LE(container->largest_read, READ_CHUNK);
+  EXPECT_EQ(image_pixels(*image), reference_jpeg_pixels());
+}
+
+// A downloaded PNG is read a little at a time too
+TEST_F(OnlineImageDownloadEnd, PngReadsInSmallPiecesWithALargeBuffer) {
+  auto image = this->make_image_(runtime_image::PNG, 65536);
+  std::vector<uint8_t> png(PNG_1X1.begin(), PNG_1X1.end());
+  auto container = std::make_shared<FakeContainer>(png, png.size(), false);
+  this->start_(*image, container);
+
+  for (int i = 0; i < 100 && this->finished_ + this->errors_ == 0; i++)
+    image->loop();
+
+  ASSERT_EQ(this->finished_, 1);
+  EXPECT_EQ(this->errors_, 0);
+  EXPECT_LE(container->largest_read, READ_CHUNK);
+}
+
+// A slow link: the decoder waits part way through the image for the rest to arrive
+TEST_F(OnlineImageDownloadEnd, JpegWaitsForASlowDownload) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  auto container =
+      std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)), 1024, false);
+  this->start_(*image, container);
+
+  int passes = 0;
+  for (; passes < 1000 && this->finished_ + this->errors_ == 0; passes++) {
+    image->loop();
+    if (passes == 5) {
+      EXPECT_EQ(this->finished_, 0) << "the image cannot be finished before the rest of it arrives";
+    }
+    container->deliver(40);
+  }
+
+  ASSERT_EQ(this->finished_, 1);
+  EXPECT_EQ(this->errors_, 0);
+  EXPECT_GT(passes, 10);
+  EXPECT_EQ(image_pixels(*image), reference_jpeg_pixels());
+}
+
+// A download that stops part way through times out rather than waiting for ever
+TEST_F(OnlineImageDownloadEnd, JpegDownloadThatStopsTimesOut) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  auto container =
+      std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)), 1500, false);
+  set_loop_time(1000);
+  this->start_(*image, container);
+
+  for (int i = 0; i < 10; i++)
+    image->loop();
+  EXPECT_EQ(this->errors_, 0) << "still within the timeout";
+
+  set_loop_time(1000 + this->http_.get_timeout());
+  image->loop();
+  EXPECT_EQ(this->errors_, 1);
+  EXPECT_EQ(this->finished_, 0);
+}
+
+// Headers that do not fit the download buffer cannot be read as the image arrives, so the whole image is
+// downloaded first, keeping the bytes already read
+TEST_F(OnlineImageDownloadEnd, JpegHeadersLargerThanTheBufferDownloadTheWholeImage) {
+  auto image = this->make_image_(runtime_image::JPEG, 256);
+  auto container = std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)),
+                                                   sizeof(JPEG_48X40), false);
+  this->start_(*image, container);
+
+  for (int i = 0; i < 100 && this->finished_ + this->errors_ == 0; i++) {
+    image->loop();
+    container->deliver(256);
+  }
+
+  ASSERT_EQ(this->finished_, 1);
+  EXPECT_EQ(this->errors_, 0);
+  EXPECT_EQ(container->get_bytes_read(), sizeof(JPEG_48X40));
+  EXPECT_EQ(image_pixels(*image), reference_jpeg_pixels());
+}
+
+// The pass that opens the image does not decode any of it
+TEST_F(OnlineImageDownloadEnd, JpegOpensInAPassOfItsOwn) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  auto container = std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)),
+                                                   sizeof(JPEG_48X40), false);
+  this->start_(*image, container);
+
+  image->loop();
+  EXPECT_EQ(this->finished_ + this->errors_, 0);
+  for (int i = 0; i < 100 && this->finished_ + this->errors_ == 0; i++)
+    image->loop();
+  EXPECT_EQ(this->finished_, 1);
+}
+
+// A progressive JPEG is refused while it downloads, without blaming the buffer size
+TEST_F(OnlineImageDownloadEnd, JpegProgressiveReportsError) {
+  auto image = this->make_image_(runtime_image::JPEG, 256);
+  std::vector<uint8_t> body(JPEG_PROGRESSIVE, JPEG_PROGRESSIVE + sizeof(JPEG_PROGRESSIVE));
+  auto container = std::make_shared<FakeContainer>(body, 256, false);
+  this->start_(*image, container);
+
+  for (int i = 0; i < 10 && this->finished_ + this->errors_ == 0; i++)
+    image->loop();
+
+  EXPECT_EQ(this->errors_, 1);
+  EXPECT_EQ(this->finished_, 0);
+}
+
+// on_download_started fires once the server has accepted the request, before the first progress report, and not
+// for a response that has no image to download
+TEST_F(OnlineImageDownloadEnd, StartedFiresOnlyWhenTheDownloadBegins) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  std::vector<std::string> events;
+  image->add_on_download_started_callback([&events]() { events.emplace_back("started"); });
+  image->add_on_progress_callback([&events](float, size_t) { events.emplace_back("progress"); });
+  this->start_(*image,
+               std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)),
+                                               sizeof(JPEG_48X40), false));
+  ASSERT_GE(events.size(), 2u);
+  EXPECT_EQ(events[0], "started");
+  EXPECT_EQ(events[1], "progress");
+  for (int i = 0; i < 100 && this->finished_ + this->errors_ == 0; i++)
+    image->loop();
+  EXPECT_EQ(std::count(events.begin(), events.end(), std::string("started")), 1);
+
+  for (int status : {304, 404}) {
+    events.clear();
+    auto container = std::make_shared<FakeContainer>(std::vector<uint8_t>{}, 0, false);
+    container->status_code = status;
+    this->http_.next = container;
+    image->update();
+    EXPECT_TRUE(events.empty()) << "HTTP " << status;
+  }
+}
+
+// Progress starts at 0, is reported at most every 100 ms, and always reaches 100%
+TEST_F(OnlineImageDownloadEnd, ProgressIsReportedAsTheImageDownloads) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  std::vector<float> reports;
+  image->add_on_progress_callback([&reports](float progress, size_t) { reports.push_back(progress); });
+  auto container =
+      std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)), 100, false);
+  uint32_t now = 1000;
+  set_loop_time(now);
+  this->start_(*image, container);
+  ASSERT_EQ(reports.size(), 1u);
+  EXPECT_EQ(reports[0], 0.0f);
+
+  int passes = 0;
+  for (; passes < 1000 && this->finished_ + this->errors_ == 0; passes++) {
+    now += 50;
+    set_loop_time(now);
+    container->deliver(100);
+    image->loop();
+  }
+
+  ASSERT_EQ(this->finished_, 1);
+  EXPECT_EQ(reports.back(), 100.0f);
+  EXPECT_TRUE(std::is_sorted(reports.begin(), reports.end()));
+  // A report every 100 ms of a 50 ms loop, plus the start and the end
+  EXPECT_LE(reports.size(), static_cast<size_t>(passes / 2 + 2));
+  EXPECT_GT(reports.size(), 3u);
+}
+
+// Without a Content-Length the percentage is unknown, but the bytes read are still reported
+TEST_F(OnlineImageDownloadEnd, ProgressOfAChunkedDownloadHasNoPercentage) {
+  auto image = this->make_image_(runtime_image::PNG);
+  std::vector<std::pair<float, size_t>> reports;
+  image->add_on_progress_callback(
+      [&reports](float progress, size_t bytes_read) { reports.emplace_back(progress, bytes_read); });
+  auto container =
+      std::make_shared<FakeContainer>(std::vector<uint8_t>(PNG_1X1.begin(), PNG_1X1.end()), PNG_1X1.size(), true);
+  set_loop_time(1000);
+  this->start_(*image, container);
+  set_loop_time(2000);
+  for (int i = 0; i < 10 && this->finished_ + this->errors_ == 0; i++)
+    image->loop();
+
+  ASSERT_GE(reports.size(), 2u);
+  EXPECT_TRUE(std::isnan(reports.back().first));
+  EXPECT_EQ(reports.back().second, PNG_1X1.size());
+}
+
+// Scan data that cannot be decoded fails the download part way through
+TEST_F(OnlineImageDownloadEnd, JpegDecodeErrorFailsTheDownload) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  std::vector<uint8_t> body(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40));
+  std::fill(body.begin() + 700, body.end() - 2, 0xFE);
+  auto container = std::make_shared<FakeContainer>(body, 1024, false);
+  this->start_(*image, container);
+
+  for (int i = 0; i < 100 && this->finished_ + this->errors_ == 0; i++) {
+    image->loop();
+    container->deliver(256);
+  }
+
+  EXPECT_EQ(this->errors_, 1);
+  EXPECT_EQ(this->finished_, 0);
+}
+
+// A read that fails part way through the download ends it with an error
+TEST_F(OnlineImageDownloadEnd, JpegReadErrorFailsTheDownload) {
+  auto image = this->make_image_(runtime_image::JPEG, 1024);
+  auto container =
+      std::make_shared<FakeContainer>(std::vector<uint8_t>(JPEG_48X40, JPEG_48X40 + sizeof(JPEG_48X40)), 1024, false);
+  this->start_(*image, container);
+  for (int i = 0; i < 5; i++)
+    image->loop();
+  ASSERT_EQ(this->errors_, 0);
+
+  container->fail_reads();
+  image->loop();
+  EXPECT_EQ(this->errors_, 1);
+  EXPECT_EQ(this->finished_, 0);
+}
+
+TEST(DownloadBufferGrow, KeepsTheUnreadData) {
+  DownloadBuffer buffer(16);
+  std::memcpy(buffer.append(), "abcdef", 6);
+  buffer.write(6);
+  buffer.read(2);
+
+  ASSERT_TRUE(buffer.grow(64));
+  EXPECT_EQ(buffer.size(), 64u);
+  ASSERT_EQ(buffer.unread(), 4u);
+  EXPECT_EQ(std::memcmp(buffer.data(), "cdef", 4), 0);
+
+  // A failed allocation leaves the buffer as it was
+  EXPECT_FALSE(buffer.grow(SIZE_MAX / 2));
+  EXPECT_EQ(buffer.size(), 64u);
+  EXPECT_EQ(std::memcmp(buffer.data(), "cdef", 4), 0);
+  // Growing to a smaller size changes nothing
+  EXPECT_TRUE(buffer.grow(8));
+  EXPECT_EQ(buffer.size(), 64u);
+}
+
 }  // namespace esphome::online_image::testing
@@ -0,0 +1,14 @@
+# A list, so the uart entries of other test directories are joined to it
+uart:
+  - id: bridge_test_bus
+    port: /dev/ttyUSB0
+    baud_rate: 9600
+
+packet_interface:
+  - platform: uart
+    id: bridge_test_link
+    uart_id: bridge_test_bus
+
+packet_transport:
+  - platform: packet_interface
+    packet_interface: bridge_test_link
@@ -0,0 +1,29 @@
+wifi:
+  ssid: MySSID
+  password: password1
+
+udp:
+  - id: packet_interface_udp
+
+packet_interface:
+  - platform: uart
+    id: packet_interface_uart
+    max_packet_size: 256
+  - platform: udp
+    id: packet_interface_network
+    udp_id: packet_interface_udp
+
+sensor:
+  - platform: template
+    id: packet_interface_sensor
+    lambda: return 1.0;
+
+packet_transport:
+  - platform: packet_interface
+    packet_interface: packet_interface_uart
+    sensors:
+      - packet_interface_sensor
+  - platform: packet_interface
+    packet_interface: packet_interface_network
+    sensors:
+      - packet_interface_sensor
@@ -0,0 +1,238 @@
+#include <gtest/gtest.h>
+#include <vector>
+#include <cstdint>
+#include "esphome/components/packet_interface/packet_buffer.h"
+
+namespace esphome::packet_interface::testing {
+
+// Copies a packet into a vector, for comparing in tests
+static std::vector<uint8_t> to_vector(const esphome::packet_interface::PacketBuffer &data) {
+  std::vector<uint8_t> result(data.size());
+  data.copy_to(result.data(), result.size());
+  return result;
+}
+
+// Test default constructor
+TEST(PacketBufferTest, DefaultConstructor) {
+  PacketBuffer buffer;
+  EXPECT_EQ(buffer.size(), 0);
+  EXPECT_TRUE(buffer.empty());
+}
+
+// Test single buffer constructor
+TEST(PacketBufferTest, SingleBufferConstructor) {
+  uint8_t data[] = {0x01, 0x02, 0x03, 0x04};
+  PacketBuffer buffer(data, 4);
+  EXPECT_EQ(buffer.size(), 4);
+  EXPECT_FALSE(buffer.empty());
+  EXPECT_EQ(buffer[0], 0x01);
+  EXPECT_EQ(buffer[3], 0x04);
+}
+
+// Test vector constructor
+TEST(PacketBufferTest, VectorConstructor) {
+  std::vector<uint8_t> vec = {0x10, 0x20, 0x30};
+  PacketBuffer buffer(vec);
+  EXPECT_EQ(buffer.size(), 3);
+  EXPECT_EQ(buffer[0], 0x10);
+  EXPECT_EQ(buffer[1], 0x20);
+  EXPECT_EQ(buffer[2], 0x30);
+}
+
+// Test pre and post buffer constructor
+TEST(PacketBufferTest, PrePostConstructor) {
+  uint8_t pre[] = {0x01, 0x02};
+  uint8_t post[] = {0x03, 0x04, 0x05};
+  PacketBuffer buffer(pre, 2, post, 3);
+  EXPECT_EQ(buffer.size(), 5);
+  EXPECT_EQ(buffer[0], 0x01);
+  EXPECT_EQ(buffer[1], 0x02);
+  EXPECT_EQ(buffer[2], 0x03);
+  EXPECT_EQ(buffer[3], 0x04);
+  EXPECT_EQ(buffer[4], 0x05);
+}
+
+// Test pre, mid, and post buffer constructor
+TEST(PacketBufferTest, PreMidPostConstructor) {
+  uint8_t pre[] = {0x01};
+  std::vector<uint8_t> mid_vec = {0x02, 0x03, 0x04};
+  PacketBuffer mid_buffer(mid_vec);
+  uint8_t post[] = {0x05, 0x06};
+
+  PacketBuffer buffer(pre, 1, &mid_buffer, post, 2);
+  EXPECT_EQ(buffer.size(), 6);
+  EXPECT_EQ(buffer[0], 0x01);
+  EXPECT_EQ(buffer[1], 0x02);
+  EXPECT_EQ(buffer[2], 0x03);
+  EXPECT_EQ(buffer[3], 0x04);
+  EXPECT_EQ(buffer[4], 0x05);
+  EXPECT_EQ(buffer[5], 0x06);
+}
+
+// Test nested mid buffers
+TEST(PacketBufferTest, NestedMidBuffers) {
+  uint8_t data1[] = {0x01};
+  uint8_t data2[] = {0x02, 0x03};
+  uint8_t data3[] = {0x04};
+
+  PacketBuffer inner(data2, 2);
+  PacketBuffer middle(data1, 1, &inner, data3, 1);
+
+  uint8_t pre[] = {0x00};
+  uint8_t post[] = {0x05};
+  PacketBuffer outer(pre, 1, &middle, post, 1);
+
+  EXPECT_EQ(outer.size(), 6);
+  EXPECT_EQ(outer[0], 0x00);
+  EXPECT_EQ(outer[1], 0x01);
+  EXPECT_EQ(outer[2], 0x02);
+  EXPECT_EQ(outer[3], 0x03);
+  EXPECT_EQ(outer[4], 0x04);
+  EXPECT_EQ(outer[5], 0x05);
+}
+
+// Test indexing operator
+TEST(PacketBufferTest, IndexingOperator) {
+  uint8_t data[] = {0xAA, 0xBB, 0xCC, 0xDD};
+  PacketBuffer buffer(data, 4);
+  EXPECT_EQ(buffer[0], 0xAA);
+  EXPECT_EQ(buffer[1], 0xBB);
+  EXPECT_EQ(buffer[2], 0xCC);
+  EXPECT_EQ(buffer[3], 0xDD);
+}
+
+// Test copy_to method
+TEST(PacketBufferTest, CopyTo) {
+  uint8_t data[] = {0x01, 0x02, 0x03, 0x04, 0x05};
+  PacketBuffer buffer(data, 5);
+
+  uint8_t dest[5] = {0};
+  size_t copied = buffer.copy_to(dest, 5);
+
+  EXPECT_EQ(copied, 5);
+  for (int i = 0; i < 5; i++) {
+    EXPECT_EQ(dest[i], data[i]);
+  }
+}
+
+// Test copy_to with offset
+TEST(PacketBufferTest, CopyToWithOffset) {
+  uint8_t data[] = {0x01, 0x02, 0x03, 0x04, 0x05};
+  PacketBuffer buffer(data, 5);
+
+  uint8_t dest[3] = {0};
+  size_t copied = buffer.copy_to(dest, 3, 2);  // Copy 3 bytes starting from offset 2
+
+  EXPECT_EQ(copied, 3);
+  EXPECT_EQ(dest[0], 0x03);
+  EXPECT_EQ(dest[1], 0x04);
+  EXPECT_EQ(dest[2], 0x05);
+}
+
+// Test copy_to with partial copy
+TEST(PacketBufferTest, CopyToPartial) {
+  uint8_t data[] = {0x01, 0x02, 0x03};
+  PacketBuffer buffer(data, 3);
+
+  uint8_t dest[5] = {0};
+  size_t copied = buffer.copy_to(dest, 5);  // Request more than available
+
+  EXPECT_EQ(copied, 3);  // Only 3 bytes copied
+}
+
+// Test copy_to from composite buffer
+TEST(PacketBufferTest, CopyToComposite) {
+  uint8_t pre[] = {0x01, 0x02};
+  uint8_t mid[] = {0x03, 0x04, 0x05};
+  uint8_t post[] = {0x06};
+
+  PacketBuffer mid_buffer(mid, 3);
+  PacketBuffer buffer(pre, 2, &mid_buffer, post, 1);
+
+  uint8_t dest[6] = {0};
+  size_t copied = buffer.copy_to(dest, 6);
+
+  EXPECT_EQ(copied, 6);
+  EXPECT_EQ(dest[0], 0x01);
+  EXPECT_EQ(dest[1], 0x02);
+  EXPECT_EQ(dest[2], 0x03);
+  EXPECT_EQ(dest[3], 0x04);
+  EXPECT_EQ(dest[4], 0x05);
+  EXPECT_EQ(dest[5], 0x06);
+}
+
+// Test copying from an offset past the mid buffer
+TEST(PacketBufferTest, CopyToOffsetPastMid) {
+  uint8_t pre[] = {0x01, 0x02};
+  uint8_t mid_data[] = {0x03};
+  uint8_t post[] = {0x04, 0x05, 0x06};
+  PacketBuffer mid(mid_data, 1);
+  PacketBuffer buffer(pre, 2, &mid, post, 3);
+
+  uint8_t dest[4]{};
+  ASSERT_EQ(buffer.copy_to(dest, 4, 4), 2);
+  EXPECT_EQ(dest[0], 0x05);
+  EXPECT_EQ(dest[1], 0x06);
+}
+
+// Test single span access
+TEST(PacketBufferTest, ContiguousSpan) {
+  uint8_t data[] = {0x10, 0x20, 0x30, 0x40};
+  PacketBuffer buffer(data, 4);
+
+  ASSERT_TRUE(buffer.is_contiguous());
+  auto span = buffer.as_span();
+  EXPECT_EQ(span.data(), data);
+  EXPECT_EQ(span.size(), 4);
+
+  uint8_t post[] = {0x50};
+  PacketBuffer split(data, 4, post, 1);
+  EXPECT_FALSE(split.is_contiguous());
+
+  PacketBuffer nested(nullptr, 0, &buffer, nullptr, 0);
+  EXPECT_FALSE(nested.is_contiguous());
+}
+
+// Test indexing past the end
+TEST(PacketBufferTest, IndexPastEnd) {
+  uint8_t pre[] = {0x01};
+  uint8_t post[] = {0x02};
+  PacketBuffer buffer(pre, 1, post, 1);
+  EXPECT_EQ(buffer[1], 0x02);
+  EXPECT_EQ(buffer[2], 0);
+  EXPECT_EQ(PacketBuffer()[0], 0);
+}
+
+// Test empty buffer operations
+TEST(PacketBufferTest, EmptyBuffer) {
+  PacketBuffer buffer;
+
+  EXPECT_TRUE(buffer.empty());
+  EXPECT_EQ(buffer.size(), 0);
+
+  uint8_t dest[10] = {0xFF};
+  size_t copied = buffer.copy_to(dest, 10);
+  EXPECT_EQ(copied, 0);
+  EXPECT_EQ(dest[0], 0xFF);  // Unchanged
+
+  std::vector<uint8_t> vec = to_vector(buffer);
+  EXPECT_EQ(vec.size(), 0);
+}
+
+// Test large buffer
+TEST(PacketBufferTest, LargeBuffer) {
+  std::vector<uint8_t> large_vec(1000);
+  for (size_t i = 0; i < large_vec.size(); i++) {
+    large_vec[i] = static_cast<uint8_t>(i % 256);
+  }
+
+  PacketBuffer buffer(large_vec);
+
+  EXPECT_EQ(buffer.size(), 1000);
+  EXPECT_EQ(buffer[0], 0);
+  EXPECT_EQ(buffer[255], 255);
+  EXPECT_EQ(buffer[256], 0);
+  EXPECT_EQ(buffer[999], 231);  // 999 % 256 = 231
+}
+
+}  // namespace esphome::packet_interface::testing
@@ -0,0 +1,92 @@
+#include <gtest/gtest.h>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+#include "esphome/components/packet_interface/packet_transport/packet_interface_transport.h"
+#include "esphome/core/application.h"
+
+namespace esphome::packet_interface::transport_testing {
+
+using Packet = std::vector<uint8_t>;
+
+// A link layer that records what is sent, and passes injected packets to its listeners
+class FakeInterface : public PacketInterface {
+ public:
+  explicit FakeInterface(size_t max_packet_size = 512) : PacketInterface(max_packet_size) {}
+  bool send_to_interface(const PacketBuffer &data, const PacketMetaData &) override {
+    Packet packet(data.size());
+    data.copy_to(packet.data(), packet.size());
+    this->sent.push_back(packet);
+    return true;
+  }
+  void deliver(const PacketBuffer &data) { this->on_receive_from_interface_(data, {}); }
+
+  std::vector<Packet> sent;
+};
+
+// A layer stacked on a link, which the bridge must use in place of the link
+class FakeLayer : public FakeInterface {
+ public:
+  explicit FakeLayer(PacketInterface *lower) : FakeInterface(lower->get_max_packet_size()) {
+    this->stack_on_(lower, CAPABILITY_ENCRYPTION);
+  }
+};
+
+class TestBridge : public PacketInterfaceTransport {
+ public:
+  using PacketInterfaceTransport::PacketInterfaceTransport;
+  using PacketInterfaceTransport::send_packet;
+  using packet_transport::PacketTransport::ping_keys_;
+};
+
+// A packet_transport ping packet; with an encryption key set, process_() stores the sender's key
+static Packet ping_packet(const char *hostname, uint32_t key) {
+  Packet packet{0x48, 0x50, static_cast<uint8_t>(strlen(hostname))};
+  packet.insert(packet.end(), hostname, hostname + strlen(hostname));
+  for (int shift = 0; shift != 32; shift += 8)
+    packet.push_back(static_cast<uint8_t>(key >> shift));
+  return packet;
+}
+
+// Each test replaces App with a fresh one, which the transport's setup() reads the device name from
+class PacketInterfaceTransportTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    App.~Application();
+    new (&App) Application();
+    static char name[] = "bridge-tests";
+    static char friendly_name[] = "";
+    App.pre_setup(name, sizeof(name) - 1, friendly_name, 0);
+    this->bridge_.set_encryption_key(std::vector<uint8_t>(32, 0xAA));
+    this->bridge_.setup();
+  }
+  void TearDown() override {
+    App.~Application();
+    new (&App) Application();  // later tests and the test listener use App
+  }
+
+  FakeInterface link_;
+  FakeLayer layer_{&this->link_};
+  TestBridge bridge_{&this->link_};
+};
+
+TEST_F(PacketInterfaceTransportTest, SendsThroughTopOfStack) {
+  this->bridge_.send_packet({1, 2, 3});
+  EXPECT_EQ(this->layer_.sent, (std::vector<Packet>{{1, 2, 3}}));
+  EXPECT_TRUE(this->link_.sent.empty());
+}
+
+TEST_F(PacketInterfaceTransportTest, PacketInOneBufferReachesTransport) {
+  Packet ping = ping_packet("requester", 0xDEADBEEF);
+  this->layer_.deliver(PacketBuffer(ping));
+  ASSERT_EQ(this->bridge_.ping_keys_.size(), 1u);
+  EXPECT_EQ(this->bridge_.ping_keys_["requester"], 0xDEADBEEFu);
+}
+
+TEST_F(PacketInterfaceTransportTest, PacketSplitAcrossBuffersDropped) {
+  Packet ping = ping_packet("requester", 0xDEADBEEF);
+  this->layer_.deliver(PacketBuffer(ping.data(), 4, ping.data() + 4, ping.size() - 4));
+  EXPECT_TRUE(this->bridge_.ping_keys_.empty());
+}
+
+}  // namespace esphome::packet_interface::transport_testing
@@ -0,0 +1,3 @@
+packages:
+  uart: !include ../../test_build_components/common/uart/esp32-idf.yaml
+  packet_interface: !include common.yaml
@@ -3,12 +3,14 @@ wifi:
  password: password1

 udp:
-  listen_address: 239.0.60.53
-  addresses: ["239.0.60.53"]
+  - id: transport_udp_component
+    listen_address: 239.0.60.53
+    addresses: ["239.0.60.53"]

 packet_transport:
  - platform: udp
    id: transport_udp
+    udp_id: transport_udp_component
    update_interval: 5s
    encryption: "our key goes here"
    rolling_code_enable: true
@@ -3,10 +3,13 @@

 #include <algorithm>
 #include <array>
+#include <cstdlib>
 #include <cstring>
+#include <utility>
 #include <vector>

 #include "esphome/components/runtime_image/image_decoder.h"
+#include "esphome/components/runtime_image/jpeg_decoder.h"
 #include "esphome/components/runtime_image/runtime_image.h"

 namespace esphome::runtime_image::testing {
@@ -377,6 +380,12 @@ TEST(RuntimeImageDecoder, JpegDecoderStaysWarmAcrossDecodes) {
  EXPECT_EQ(pixel_bytes(img), first_pixels) << "reused decoder must reproduce identical pixels";
 }

+// The RGB565 word at (x, y) of a decoded image, in its own byte order
+static uint16_t rgb565_word(const TestableRuntimeImage &img, int x, int y) {
+  const uint8_t *p = img.get_data_start() + (y * img.get_width() + x) * 2;
+  return p[0] | (p[1] << 8);
+}
+
 // JPEGDEC's colour conversion differs by one step between its SIMD and scalar builds, so each
 // channel is checked within one step; the byte order is still exact
 static void expect_rgb565_near(uint16_t actual, uint16_t expected, const char *order, size_t pixel) {
@@ -386,16 +395,12 @@ static void expect_rgb565_near(uint16_t actual, uint16_t expected, const char *o
 }

 TEST(RuntimeImageDecoder, JpegDecodesDirectlyToScaledRgb565WithBothByteOrders) {
-  // Halving the 8x8 gradient keeps its even rows and columns. The words are JPEGDEC's output for those
-  // pixels, red in the top five bits: a decode of the fixture with PIL gives (51, 7, 30) for source
-  // pixel (2, 0), which is word 0x3803 here.
-  static const uint16_t EXPECTED[4 * 4] = {
-      0x0000, 0x3803, 0x8008, 0xB80B, 0x0203, 0x3A07, 0x81EC, 0xBA0F,
-      0x03E7, 0x3C0B, 0x83F0, 0xBC13, 0x05EC, 0x3E0F, 0x85F4, 0xBE17,
-  };
+  // Halving the 8x8 gradient makes JPEGDEC decode it at half size, which averages each 2x2 block of pixels
+  TestableRuntimeImage full(JPEG, image::IMAGE_TYPE_RGB565, false, 8, 8);
  TestableRuntimeImage rgb565_little_endian(JPEG, image::IMAGE_TYPE_RGB565, false, 4, 4);
  TestableRuntimeImage rgb565_big_endian(JPEG, image::IMAGE_TYPE_RGB565, true, 4, 4);

+  ASSERT_TRUE(decode_all(full, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));
  ASSERT_TRUE(decode_all(rgb565_little_endian, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));
  ASSERT_TRUE(decode_all(rgb565_big_endian, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));
  ASSERT_EQ(rgb565_little_endian.get_width(), 4);
@@ -405,9 +410,45 @@ TEST(RuntimeImageDecoder, JpegDecodesDirectlyToScaledRgb565WithBothByteOrders) {

  const uint8_t *little = rgb565_little_endian.get_data_start();
  const uint8_t *big = rgb565_big_endian.get_data_start();
-  for (size_t i = 0; i < 4 * 4; i++) {
-    expect_rgb565_near(little[i * 2] | (little[i * 2 + 1] << 8), EXPECTED[i], "little-endian", i);
-    expect_rgb565_near((big[i * 2] << 8) | big[i * 2 + 1], EXPECTED[i], "big-endian", i);
+  for (int row = 0; row < 4; row++) {
+    for (int col = 0; col < 4; col++) {
+      int red = 0;
+      int green = 0;
+      int blue = 0;
+      for (int dy = 0; dy < 2; dy++) {
+        for (int dx = 0; dx < 2; dx++) {
+          const uint16_t word = rgb565_word(full, col * 2 + dx, row * 2 + dy);
+          red += word >> 11;
+          green += (word >> 5) & 0x3F;
+          blue += word & 0x1F;
+        }
+      }
+      const uint16_t expected = ((red + 2) / 4) << 11 | ((green + 2) / 4) << 5 | (blue + 2) / 4;
+      const size_t i = row * 4 + col;
+      expect_rgb565_near(little[i * 2] | (little[i * 2 + 1] << 8), expected, "little-endian", i);
+      expect_rgb565_near((big[i * 2] << 8) | big[i * 2 + 1], expected, "big-endian", i);
+    }
+  }
+}
+
+// The generic draw() path gets JPEGDEC's half size RGB8888 output. It must match the half size RGB565 decode checked
+// above. A full size RGB8888 decode is no reference: JPEGDEC's x86 SSE code writes it with red and blue swapped.
+TEST(RuntimeImageDecoder, JpegDecodesToScaledRgb) {
+  TestableRuntimeImage rgb565(JPEG, image::IMAGE_TYPE_RGB565, false, 4, 4);
+  TestableRuntimeImage rgb(JPEG, image::IMAGE_TYPE_RGB, false, 4, 4);
+  ASSERT_TRUE(decode_all(rgb565, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));
+  ASSERT_TRUE(decode_all(rgb, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));
+  ASSERT_EQ(static_cast<JpegDecoder *>(rgb.decoder())->get_scale(), 2);
+
+  for (int row = 0; row < 4; row++) {
+    for (int col = 0; col < 4; col++) {
+      const uint16_t word = rgb565_word(rgb565, col, row);
+      const Color pixel = rgb.get_pixel(col, row);
+      // RGB565 keeps the top 5 or 6 bits of each channel
+      EXPECT_LE(std::abs(pixel.r - ((word >> 11) << 3)), 8) << "pixel " << col << "," << row << " red";
+      EXPECT_LE(std::abs(pixel.g - (((word >> 5) & 0x3F) << 2)), 4) << "pixel " << col << "," << row << " green";
+      EXPECT_LE(std::abs(pixel.b - ((word & 0x1F) << 3)), 8) << "pixel " << col << "," << row << " blue";
+    }
  }
 }

@@ -415,10 +456,15 @@ TEST(RuntimeImageDecoder, JpegDecodesDirectlyToScaledRgb565WithBothByteOrders) {
 // prepare_rgb565_scaling_ rounds: source n covers targets ceil(n * target / source) up to the next start
 static uint16_t scaled_boundary(int n, int source, int target) { return (n * target + source - 1) / source; }

-// The RGB565 word at (x, y) of a decoded image, in its own byte order
-static uint16_t rgb565_word(const TestableRuntimeImage &img, int x, int y) {
-  const uint8_t *p = img.get_data_start() + (y * img.get_width() + x) * 2;
-  return p[0] | (p[1] << 8);
+// JPEGDEC decodes at the smallest of full, 1/2, 1/4 and 1/8 size that still covers the buffer
+TEST(RuntimeImageDecoder, JpegDecodesAtTheSmallestSizeThatCoversTheBuffer) {
+  for (auto [size, scale] :
+       {std::pair{8, 1}, std::pair{5, 1}, std::pair{4, 2}, std::pair{3, 2}, std::pair{2, 4}, std::pair{1, 8}}) {
+    TestableRuntimeImage img(JPEG, image::IMAGE_TYPE_RGB565, false, size, size);
+    ASSERT_TRUE(decode_all(img, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));
+    EXPECT_EQ(img.get_width(), size);
+    EXPECT_EQ(static_cast<JpegDecoder *>(img.decoder())->get_scale(), scale) << size << "x" << size;
+  }
 }

 // Every scaled direct decode must equal the unscaled one sampled through the boundary table,
@@ -427,7 +473,8 @@ TEST(RuntimeImageDecoder, JpegDirectRgb565ScalesBySourcePixelSpans) {
  TestableRuntimeImage full(JPEG, image::IMAGE_TYPE_RGB565, false, 8, 8);
  ASSERT_TRUE(decode_all(full, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));

-  for (int size : {4, 6, 16}) {
+  // Sizes JPEGDEC cannot reach by scaling, so the full size decode is spread over the buffer
+  for (int size : {5, 6, 16}) {
    TestableRuntimeImage scaled(JPEG, image::IMAGE_TYPE_RGB565, false, size, size);
    ASSERT_TRUE(decode_all(scaled, JPEG_GRADIENT, sizeof(JPEG_GRADIENT)));
    ASSERT_EQ(scaled.get_width(), size);
@@ -5,6 +5,7 @@
 #include <vector>

 #include "esphome/components/runtime_image/image_decoder.h"
+#include "esphome/components/runtime_image/jpeg_decoder.h"
 #include "esphome/components/runtime_image/runtime_image.h"

 #ifdef USE_RUNTIME_IMAGE_JPEG
@@ -178,6 +179,7 @@ class SourceImage : public RuntimeImage {
  explicit SourceImage(image::ImageType type = image::IMAGE_TYPE_RGB, int width = 0, int height = 0)
      : RuntimeImage(JPEG, type, image::TRANSPARENCY_OPAQUE, nullptr, false, width, height) {}
  size_t decoded_bytes() const { return this->decoded_bytes_; }
+  int scale() const { return static_cast<const JpegDecoder *>(this->decoder_.get())->get_scale(); }
 };

 /// The file in memory; fails reads once fail_at bytes have been read
@@ -291,6 +293,23 @@ TEST(JpegSourceDecode, SteppedDirectRgb565MatchesFedDecode) {
  EXPECT_EQ(pixels(stepped), pixels(fed));
 }

+// decodeBegin() is given the same reduced scale as decode(), and decodeRows() keeps it for every step
+TEST(JpegSourceDecode, SteppedScaledDecodeMatchesFedDecode) {
+  for (auto type : {image::IMAGE_TYPE_RGB565, image::IMAGE_TYPE_RGB}) {
+    // 24x20 is half of 48x40, so JPEGDEC decodes at 1/2 size
+    SourceImage fed(type, 24, 20);
+    ASSERT_TRUE(decode_fed(fed));
+    ASSERT_EQ(fed.scale(), 2);
+
+    SourceImage stepped(type, 24, 20);
+    MemorySource source(JPEG_ROWS, sizeof(JPEG_ROWS));
+    int steps;
+    ASSERT_EQ(decode_stepped(stepped, source, steps), DECODE_STEP_DONE);
+    ASSERT_EQ(stepped.scale(), 2);
+    EXPECT_EQ(pixels(stepped), pixels(fed)) << "image type " << type;
+  }
+}
+
 TEST(JpegSourceDecode, WaitsForDataThatHasNotArrived) {
  SourceImage fed;
  ASSERT_TRUE(decode_fed(fed));
@@ -0,0 +1,41 @@
+#include <gtest/gtest.h>
+
+#include <cstring>
+#include <string>
+
+#include "esphome/components/syslog/esphome_syslog.h"
+#include "esphome/core/log.h"
+
+namespace esphome::syslog::testing {
+
+static std::string redact(const char *message) {
+  char buf[128];
+  size_t pos = append_redacted_message(buf, sizeof(buf), 0, message, strlen(message));
+  return std::string(buf, pos);
+}
+
+TEST(SyslogRedactedMessage, PlainMessageUnchanged) {
+  EXPECT_EQ(redact("WiFi connected to 'home'"), "WiFi connected to 'home'");
+}
+
+TEST(SyslogRedactedMessage, SecretReplaced) {
+  EXPECT_EQ(redact("Password=" LOG_SECRET("'hunter2'") " ok"), "Password=[redacted] ok");
+}
+
+TEST(SyslogRedactedMessage, MultipleSecrets) {
+  EXPECT_EQ(redact("SSID=" LOG_SECRET("home") " PSK=" LOG_SECRET("hunter2")), "SSID=[redacted] PSK=[redacted]");
+}
+
+TEST(SyslogRedactedMessage, UnterminatedSecretDropsRest) {
+  EXPECT_EQ(redact("key=" ESPHOME_LOG_SECRET_BEGIN "abc"), "key=[redacted]");
+}
+
+TEST(SyslogRedactedMessage, AppendsAtOffsetAndCaps) {
+  char buf[16] = "pre:";
+  size_t pos = append_redacted_message(buf, sizeof(buf), 4, "0123456789abcdef", 16);
+  EXPECT_EQ(pos, sizeof(buf) - 1);
+  EXPECT_EQ(std::string(buf, pos), "pre:0123456789a");
+  EXPECT_EQ(buf[pos], '\0');
+}
+
+}  // namespace esphome::syslog::testing
@@ -0,0 +1,6 @@
+from tests.testing_helpers import ComponentManifestOverride
+
+
+def override_manifest(manifest: ComponentManifestOverride) -> None:
+    # benchmark.yaml configures a uart packet_interface, whose to_code waits on the uart bus variable.
+    manifest.enable_codegen()
@@ -0,0 +1,9 @@
+packet_interface:
+  - platform: uart
+    uart_id: uart_packet_interface_bus
+
+# A list, so the uart entries of other test directories are joined to it
+uart:
+  - id: uart_packet_interface_bus
+    port: /dev/ttyUSB0
+    baud_rate: 9600
@@ -25,7 +25,10 @@ class MockUARTComponent : public UARTComponent {
  // consider using StaticVector or FixedVector from esphome/core/helpers.h instead.
  std::vector<uint8_t> written_data;

-  void write_array(const uint8_t *data, size_t len) override { written_data.assign(data, data + len); }
+  void write_array(const uint8_t *data, size_t len) override {
+    written_data.insert(written_data.end(), data, data + len);
+  }
+  void clear() { written_data.clear(); }

  MOCK_METHOD(bool, read_array, (uint8_t *data, size_t len), (override));
  MOCK_METHOD(bool, peek_byte, (uint8_t *data), (override));
@@ -0,0 +1,402 @@
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <vector>
+#include <cstdint>
+#include <cstring>
+#include "esphome/components/uart/packet_interface/uart_packet_interface.h"
+#include "esphome/components/packet_interface/packet_buffer.h"
+#include "esphome/components/uart/uart_component.h"
+#include "common.h"
+
+namespace esphome::uart::testing {
+
+// Copies a packet into a vector, for comparing in tests
+static std::vector<uint8_t> to_vector(const esphome::packet_interface::PacketBuffer &data) {
+  std::vector<uint8_t> result(data.size());
+  data.copy_to(result.data(), result.size());
+  return result;
+}
+
+using packet_interface::PacketBuffer;
+using packet_interface::PacketMetaData;
+
+// Test fixture
+class UartPacketInterfaceTest : public ::testing::Test {
+ protected:
+  MockUARTComponent uart_{};
+  // As large as the default max_packet_size; tests only make it smaller
+  uint8_t rx_buffer_[512]{};
+  UartPacketInterface interface_{this->rx_buffer_};
+  std::vector<std::vector<uint8_t>> received_packets_;
+
+  void SetUp() override {
+    received_packets_.clear();
+    interface_.set_uart_parent(&uart_);
+    interface_.setup();
+
+    interface_.add_packet_interface_listener(
+        [this](const PacketBuffer &data, const PacketMetaData &meta) { received_packets_.push_back(to_vector(data)); });
+  }
+};
+
+// Feed bytes to the interface through the mocked UART and run its loop
+static void feed(MockUARTComponent &uart, UartPacketInterface &interface, const std::vector<uint8_t> &bytes) {
+  size_t read_pos = 0;
+  EXPECT_CALL(uart, available()).WillRepeatedly(Invoke([&bytes, &read_pos]() { return bytes.size() - read_pos; }));
+  EXPECT_CALL(uart, read_array(_, _)).WillRepeatedly(Invoke([&bytes, &read_pos](uint8_t *data, size_t len) {
+    if (len > bytes.size() - read_pos)
+      return false;
+    std::memcpy(data, bytes.data() + read_pos, len);
+    read_pos += len;
+    return true;
+  }));
+  interface.loop();
+}
+
+// Test basic frame sending
+TEST_F(UartPacketInterfaceTest, SendSimpleFrame) {
+  std::vector<uint8_t> data = {0x01, 0x02, 0x03};
+  PacketBuffer buffer(data);
+
+  // Set up the mock to accumulate bytes
+  ASSERT_EQ(uart_.written_data.size(), 0);
+  interface_.send_to_interface(buffer, {});
+  // Verify the accumulated bytes
+  ASSERT_EQ(uart_.written_data.size(), 5);
+
+  std::vector<uint8_t> expected = {0x7E, 0x01, 0x02, 0x03, 0x7E};
+  EXPECT_EQ(uart_.written_data, expected);
+}
+// Test byte stuffing for FLAG_BYTE
+TEST_F(UartPacketInterfaceTest, SendWithFlagByteStuffing) {
+  std::vector<uint8_t> data = {0x01, 0x7E, 0x03};
+  PacketBuffer buffer(data);
+
+  uart_.clear();
+  interface_.send_to_interface(buffer, {});
+
+  // Should escape 0x7E as 0x7D 0x5E
+  std::vector<uint8_t> expected = {0x7E, 0x01, 0x7D, 0x5E, 0x03, 0x7E};
+  EXPECT_EQ(uart_.written_data, expected);
+}
+
+// Test byte stuffing for CONTROL_BYTE
+TEST_F(UartPacketInterfaceTest, SendWithControlByteStuffing) {
+  std::vector<uint8_t> data = {0x01, 0x7D, 0x03};
+  PacketBuffer buffer(data);
+
+  uart_.clear();
+  interface_.send_to_interface(buffer, {});
+
+  // Should escape 0x7D as 0x7D 0x5D
+  std::vector<uint8_t> expected = {0x7E, 0x01, 0x7D, 0x5D, 0x03, 0x7E};
+  EXPECT_EQ(uart_.written_data, expected);
+}
+
+// Test sending empty frame
+TEST_F(UartPacketInterfaceTest, SendEmptyFrame) {
+  std::vector<uint8_t> data = {};
+  PacketBuffer buffer(data);
+
+  interface_.send_to_interface(buffer, {});
+
+  // Empty data should return without sending
+  EXPECT_EQ(uart_.written_data.size(), 0);
+}
+
+// Test receiving simple frame
+TEST_F(UartPacketInterfaceTest, ReceiveSimpleFrame) {
+  std::vector<uint8_t> frame_data = {0x7E, 0x01, 0x02, 0x03, 0x7E};
+  size_t read_pos = 0;
+
+  EXPECT_CALL(uart_, available()).WillRepeatedly(Invoke([&frame_data, &read_pos]() {
+    return frame_data.size() - read_pos;
+  }));
+
+  EXPECT_CALL(uart_, read_array(_, _)).WillRepeatedly(Invoke([&frame_data, &read_pos](uint8_t *data, size_t len) {
+    if (len > frame_data.size() - read_pos)
+      return false;
+    std::memcpy(data, frame_data.data() + read_pos, len);
+    read_pos += len;
+    return true;
+  }));
+
+  interface_.loop();
+
+  ASSERT_EQ(received_packets_.size(), 1);
+  std::vector<uint8_t> expected = {0x01, 0x02, 0x03};
+  EXPECT_EQ(received_packets_[0], expected);
+}
+
+// Test receiving frame with FLAG_BYTE escape
+TEST_F(UartPacketInterfaceTest, ReceiveFrameWithFlagEscape) {
+  std::vector<uint8_t> frame_data = {0x7E, 0x01, 0x7D, 0x5E, 0x03, 0x7E};
+  size_t read_pos = 0;
+
+  EXPECT_CALL(uart_, available()).WillRepeatedly(Invoke([&frame_data, &read_pos]() {
+    return frame_data.size() - read_pos;
+  }));
+
+  EXPECT_CALL(uart_, read_array(_, _)).WillRepeatedly(Invoke([&frame_data, &read_pos](uint8_t *data, size_t len) {
+    if (len > frame_data.size() - read_pos)
+      return false;
+    std::memcpy(data, frame_data.data() + read_pos, len);
+    read_pos += len;
+    return true;
+  }));
+
+  interface_.loop();
+
+  ASSERT_EQ(received_packets_.size(), 1);
+  std::vector<uint8_t> expected = {0x01, 0x7E, 0x03};  // 0x7E unescaped
+  EXPECT_EQ(received_packets_[0], expected);
+}
+
+// Test receiving frame with CONTROL_BYTE escape
+TEST_F(UartPacketInterfaceTest, ReceiveFrameWithControlEscape) {
+  std::vector<uint8_t> frame_data = {0x7E, 0x01, 0x7D, 0x5D, 0x03, 0x7E};
+  size_t read_pos = 0;
+
+  EXPECT_CALL(uart_, available()).WillRepeatedly(Invoke([&frame_data, &read_pos]() {
+    return frame_data.size() - read_pos;
+  }));
+
+  EXPECT_CALL(uart_, read_array(_, _)).WillRepeatedly(Invoke([&frame_data, &read_pos](uint8_t *data, size_t len) {
+    if (len > frame_data.size() - read_pos)
+      return false;
+    std::memcpy(data, frame_data.data() + read_pos, len);
+    read_pos += len;
+    return true;
+  }));
+
+  interface_.loop();
+
+  ASSERT_EQ(received_packets_.size(), 1);
+  std::vector<uint8_t> expected = {0x01, 0x7D, 0x03};  // 0x7D unescaped
+  EXPECT_EQ(received_packets_[0], expected);
+}
+
+// Test receiving multiple frames
+TEST_F(UartPacketInterfaceTest, ReceiveMultipleFrames) {
+  std::vector<uint8_t> frame_data = {0x7E, 0x01, 0x02, 0x7E, 0x7E, 0x03, 0x04, 0x7E};
+  size_t read_pos = 0;
+
+  EXPECT_CALL(uart_, available()).WillRepeatedly(Invoke([&frame_data, &read_pos]() {
+    return frame_data.size() - read_pos;
+  }));
+
+  EXPECT_CALL(uart_, read_array(_, _)).WillRepeatedly(Invoke([&frame_data, &read_pos](uint8_t *data, size_t len) {
+    if (len > frame_data.size() - read_pos)
+      return false;
+    std::memcpy(data, frame_data.data() + read_pos, len);
+    read_pos += len;
+    return true;
+  }));
+
+  interface_.loop();
+
+  ASSERT_EQ(received_packets_.size(), 2) << "Expected 2 packets, got " << received_packets_.size();
+  std::vector<uint8_t> expected1 = {0x01, 0x02};
+  std::vector<uint8_t> expected2 = {0x03, 0x04};
+  auto pkt0 = received_packets_[0];
+  auto pkt1 = received_packets_[1];
+  EXPECT_EQ(pkt0, expected1) << "Packet 0 size: " << pkt0.size();
+  EXPECT_EQ(pkt1, expected2) << "Packet 1 size: " << pkt1.size();
+}
+
+// Test receiving empty frame (back-to-back flags)
+TEST_F(UartPacketInterfaceTest, ReceiveEmptyFrame) {
+  std::vector<uint8_t> frame_data = {0x7E, 0x7E};
+  size_t read_pos = 0;
+
+  EXPECT_CALL(uart_, available()).WillRepeatedly(Invoke([&frame_data, &read_pos]() {
+    return frame_data.size() - read_pos;
+  }));
+
+  EXPECT_CALL(uart_, read_array(_, _)).WillRepeatedly(Invoke([&frame_data, &read_pos](uint8_t *data, size_t len) {
+    if (len > frame_data.size() - read_pos)
+      return false;
+    std::memcpy(data, frame_data.data() + read_pos, len);
+    read_pos += len;
+    return true;
+  }));
+
+  interface_.loop();
+
+  // Empty frames should not be delivered
+  EXPECT_EQ(received_packets_.size(), 0);
+}
+
+// Test data before first flag is ignored
+TEST_F(UartPacketInterfaceTest, IgnoreDataBeforeFirstFlag) {
+  std::vector<uint8_t> frame_data = {0xFF, 0xFF, 0x7E, 0x01, 0x02, 0x7E};
+  size_t read_pos = 0;
+
+  EXPECT_CALL(uart_, available()).WillRepeatedly(Invoke([&frame_data, &read_pos]() {
+    return frame_data.size() - read_pos;
+  }));
+
+  EXPECT_CALL(uart_, read_array(_, _)).WillRepeatedly(Invoke([&frame_data, &read_pos](uint8_t *data, size_t len) {
+    if (len > frame_data.size() - read_pos)
+      return false;
+    std::memcpy(data, frame_data.data() + read_pos, len);
+    read_pos += len;
+    return true;
+  }));
+
+  interface_.loop();
+
+  ASSERT_EQ(received_packets_.size(), 1);
+  std::vector<uint8_t> expected = {0x01, 0x02};
+  EXPECT_EQ(received_packets_[0], expected);
+}
+
+// Test oversized packet is discarded
+TEST_F(UartPacketInterfaceTest, OversizedPacketDiscarded) {
+  uint8_t small_buffer[10]{};
+  UartPacketInterface interface(small_buffer);
+  interface.set_uart_parent(&this->uart_);
+  std::vector<std::vector<uint8_t>> received;
+  interface.add_packet_interface_listener(
+      [&received](const PacketBuffer &data, const PacketMetaData &) { received.push_back(to_vector(data)); });
+
+  // Create a packet larger than buffer
+  std::vector<uint8_t> frame_data = {0x7E};
+  for (int i = 0; i < 15; i++) {
+    frame_data.push_back(0xAA);
+  }
+  frame_data.push_back(0x7E);
+
+  feed(this->uart_, interface, frame_data);
+
+  // Oversized packet should be discarded
+  EXPECT_TRUE(received.empty());
+}
+
+// Test round-trip (send and receive)
+TEST_F(UartPacketInterfaceTest, RoundTrip) {
+  std::vector<uint8_t> original = {0x01, 0x7E, 0x7D, 0x03};
+  PacketBuffer send_buffer(original);
+
+  // Send
+  interface_.send_to_interface(send_buffer, {});
+
+  // Prepare to receive - use the written data as frame data
+  std::vector<uint8_t> frame_data = uart_.written_data;
+  size_t read_pos = 0;
+
+  EXPECT_CALL(uart_, available()).WillRepeatedly(Invoke([&frame_data, &read_pos]() {
+    return frame_data.size() - read_pos;
+  }));
+
+  EXPECT_CALL(uart_, read_array(_, _)).WillRepeatedly(Invoke([&frame_data, &read_pos](uint8_t *data, size_t len) {
+    if (len > frame_data.size() - read_pos)
+      return false;
+    std::memcpy(data, frame_data.data() + read_pos, len);
+    read_pos += len;
+    return true;
+  }));
+
+  // Receive
+  interface_.loop();
+
+  ASSERT_EQ(received_packets_.size(), 1);
+  EXPECT_EQ(received_packets_[0], original);
+}
+
+// Test all bytes can be transmitted (0x00 to 0xFF)
+TEST_F(UartPacketInterfaceTest, AllByteValues) {
+  std::vector<uint8_t> data;
+  data.reserve(256);
+  for (int i = 0; i != 256; i++) {
+    data.push_back(static_cast<uint8_t>(i));
+  }
+  PacketBuffer send_buffer(data);
+
+  // Send
+  interface_.send_to_interface(send_buffer, {});
+
+  // Prepare to receive - use the written data as frame data
+  std::vector<uint8_t> frame_data = uart_.written_data;
+  size_t read_pos = 0;
+
+  EXPECT_CALL(uart_, available()).WillRepeatedly(Invoke([&frame_data, &read_pos]() {
+    return frame_data.size() - read_pos;
+  }));
+
+  EXPECT_CALL(uart_, read_array(_, _)).WillRepeatedly(Invoke([&frame_data, &read_pos](uint8_t *data, size_t len) {
+    if (len > frame_data.size() - read_pos)
+      return false;
+    std::memcpy(data, frame_data.data() + read_pos, len);
+    read_pos += len;
+    return true;
+  }));
+
+  // Receive
+  interface_.loop();
+
+  ASSERT_EQ(received_packets_.size(), 1);
+  EXPECT_EQ(received_packets_[0], data);
+}
+
+// The buffer passed to the constructor is the largest packet, for receiving and sending alike
+TEST_F(UartPacketInterfaceTest, ReceiveLimitedToBuffer) {
+  uint8_t small_buffer[4]{};
+  UartPacketInterface interface(small_buffer);
+  interface.set_uart_parent(&this->uart_);
+  std::vector<std::vector<uint8_t>> received;
+  interface.add_packet_interface_listener(
+      [&received](const PacketBuffer &data, const PacketMetaData &) { received.push_back(to_vector(data)); });
+  // The first packet is longer than the buffer and is dropped; the next one fits
+  feed(this->uart_, interface, {0x7E, 1, 2, 3, 4, 5, 6, 0x7E, 7, 8, 0x7E});
+  EXPECT_EQ(received, (std::vector<std::vector<uint8_t>>{{7, 8}}));
+}
+
+// Test a packet larger than max_packet_size is not sent
+TEST_F(UartPacketInterfaceTest, OversizedPacketNotSent) {
+  uint8_t small_buffer[4]{};
+  UartPacketInterface interface(small_buffer);
+  interface.set_uart_parent(&this->uart_);
+  std::vector<uint8_t> data = {0x01, 0x02, 0x03, 0x04, 0x05};
+  PacketBuffer buffer(data);
+
+  EXPECT_FALSE(interface.send_to_interface(buffer, {}));
+  EXPECT_EQ(uart_.written_data.size(), 0);
+}
+
+// Test a composite buffer longer than one write chunk is framed correctly
+TEST_F(UartPacketInterfaceTest, SendCompositeAcrossChunks) {
+  std::vector<uint8_t> pre(40, 0x7E);
+  std::vector<uint8_t> mid_data = {0x11, 0x22};
+  std::vector<uint8_t> post(30, 0x33);
+  PacketBuffer mid(mid_data);
+  PacketBuffer buffer(pre.data(), pre.size(), &mid, post.data(), post.size());
+
+  ASSERT_TRUE(interface_.send_to_interface(buffer, {}));
+
+  std::vector<uint8_t> expected = {0x7E};
+  for (size_t i = 0; i != pre.size(); i++) {
+    expected.push_back(0x7D);
+    expected.push_back(0x5E);
+  }
+  expected.insert(expected.end(), mid_data.begin(), mid_data.end());
+  expected.insert(expected.end(), post.begin(), post.end());
+  expected.push_back(0x7E);
+  EXPECT_EQ(uart_.written_data, expected);
+}
+
+// Test one flag between frames both ends the first and starts the second
+TEST_F(UartPacketInterfaceTest, SharedFlagBetweenFrames) {
+  feed(uart_, interface_, {0x7E, 0x01, 0x7E, 0x02, 0x03, 0x7E});
+
+  EXPECT_EQ(received_packets_, (std::vector<std::vector<uint8_t>>{{0x01}, {0x02, 0x03}}));
+}
+
+// Test an unfinished frame does not hide the frame after it
+TEST_F(UartPacketInterfaceTest, UnfinishedFrameDoesNotHideNext) {
+  feed(uart_, interface_, {0x7E, 0xAA, 0x7E, 0x01, 0x02, 0x7E});
+
+  EXPECT_EQ(received_packets_, (std::vector<std::vector<uint8_t>>{{0xAA}, {0x01, 0x02}}));
+}
+
+}  // namespace esphome::uart::testing
@@ -0,0 +1,6 @@
+from tests.testing_helpers import ComponentManifestOverride
+
+
+def override_manifest(manifest: ComponentManifestOverride) -> None:
+    # benchmark.yaml configures a udp packet_interface, whose to_code waits on the udp component variable.
+    manifest.enable_codegen()
@@ -0,0 +1,5 @@
+udp:
+  addresses: ["192.168.1.255"]
+
+packet_interface:
+  - platform: udp
@@ -0,0 +1,78 @@
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <vector>
+
+#include "esphome/components/udp/packet_interface/udp_packet_interface.h"
+
+#ifdef USE_NETWORK
+
+namespace esphome::udp::testing {
+
+// Copies a packet into a vector, for comparing in tests
+static std::vector<uint8_t> to_vector(const esphome::packet_interface::PacketBuffer &data) {
+  std::vector<uint8_t> result(data.size());
+  data.copy_to(result.data(), result.size());
+  return result;
+}
+
+using packet_interface::PacketBuffer;
+using packet_interface::PacketMetaData;
+using Packet = std::vector<uint8_t>;
+
+// The copy buffer is a base, so it is set up before the link's constructor sees it
+struct UdpBufferStorage {
+  uint8_t tx_buffer_storage[8]{};
+};
+
+class TestUdp : public UdpBufferStorage, public UdpPacketInterface {
+ public:
+  explicit TestUdp(UDPComponent *udp) : UdpPacketInterface(udp, this->tx_buffer_storage) {
+    this->add_packet_interface_listener(
+        [this](const PacketBuffer &data, const PacketMetaData &) { this->received.push_back(to_vector(data)); });
+  }
+  using UdpPacketInterface::receive_;
+
+  std::vector<Packet> received;
+};
+
+// The udp component is not set up, so it has no destinations and a send does nothing
+class UdpPacketInterfaceTest : public ::testing::Test {
+ protected:
+  UDPComponent udp_;
+  TestUdp link_{&this->udp_};
+};
+
+TEST_F(UdpPacketInterfaceTest, ReceivedPacketsUpToMaxPassedUp) {
+  Packet packet{1, 2, 3, 4, 5, 6, 7, 8};
+  this->link_.receive_(packet);
+  Packet oversized{1, 2, 3, 4, 5, 6, 7, 8, 9};
+  this->link_.receive_(oversized);
+  EXPECT_EQ(this->link_.received, std::vector<Packet>{packet});
+}
+
+TEST_F(UdpPacketInterfaceTest, SendsContiguousAndSplitPackets) {
+  this->link_.setup();
+  Packet packet{1, 2, 3, 4};
+  EXPECT_TRUE(this->link_.send_to_interface(PacketBuffer(packet), {}));
+  uint8_t header = 0;
+  PacketBuffer body(packet);
+  EXPECT_TRUE(this->link_.send_to_interface(PacketBuffer(&header, 1, &body, nullptr, 0), {}));
+  // A packet split across buffers is joined in the copy buffer before it is sent
+  const auto *storage = this->link_.tx_buffer_storage;
+  EXPECT_EQ(Packet(storage, storage + 5), (Packet{0, 1, 2, 3, 4}));
+}
+
+TEST_F(UdpPacketInterfaceTest, OversizedPacketNotSent) {
+  this->link_.setup();
+  Packet packet{1, 2, 3, 4, 5, 6, 7, 8, 9};
+  EXPECT_FALSE(this->link_.send_to_interface(PacketBuffer(packet), {}));
+  uint8_t header = 0;
+  Packet body_data{1, 2, 3, 4, 5, 6, 7, 8};
+  PacketBuffer body(body_data);
+  EXPECT_FALSE(this->link_.send_to_interface(PacketBuffer(&header, 1, &body, nullptr, 0), {}));
+}
+
+}  // namespace esphome::udp::testing
+
+#endif
@@ -58,8 +58,30 @@ The `InitialStateHelper` class solves a common problem in integration tests: whe
 - Provides debug logging to track state reception (use `--log-cli-level=DEBUG`)
 - Safe for concurrent use with multiple entity types

-**Future work:**
-Consider converting existing integration tests to use `InitialStateHelper` for more reliable state tracking and to eliminate race conditions related to initial state broadcasts.
+#### Subscribing after the initial states (`state_utils.py`)
+
+`subscribe_after_initial_states()` does the `InitialStateHelper` setup in one call: it subscribes, waits
+for every entity's connect time state, and fails the test with the entities still missing on timeout.
+It returns a `StateSubscription` with `initial_states` (by key) and a `waiter`, a `StateWaiter` that sees
+every later state. `waiter.next_state(key=..., state_type=...)` arms a wait for the next matching state;
+call it before sending the command. `press_and_wait()` presses a button and returns the next state of a
+type, from one entity when `key=` is given:
+
+```python
+from .state_utils import press_and_wait, subscribe_after_initial_states
+
+entities, _ = await client.list_entities_services()
+sub = await subscribe_after_initial_states(client, entities)
+
+state = await press_and_wait(client, entities, sub.waiter, "set_position", CoverState)
+assert state.position == pytest.approx(0.5, abs=0.01)
+
+next_light = sub.waiter.next_state(key=light.key, state_type=LightState)
+client.light_command(key=light.key, state=True)
+assert (await next_light).state is True
+```
+
+Pass `on_state=` as well when the test also needs to collect every state.

 #### Entity Lookup Helpers (`state_utils.py`)

@@ -203,46 +225,24 @@ async def test_my_sensor(

 ##### State Subscription Pattern

-**Recommended: Using InitialStateHelper**
+**Recommended: Using subscribe_after_initial_states**

-When an API client connects, ESPHome automatically sends the current state of all entities. The `InitialStateHelper` (from `state_utils.py`) handles this by swallowing these initial states and only forwarding subsequent state changes to your test callback:
+When an API client connects, ESPHome automatically sends the current state of all entities.
+`subscribe_after_initial_states()` (from `state_utils.py`) swallows these initial states and only forwards
+subsequent state changes, to your callback and to the returned `waiter`:

 ```python
-from .state_utils import InitialStateHelper
+from .state_utils import subscribe_after_initial_states

-# Track state changes with futures
-loop = asyncio.get_running_loop()
-states: dict[int, EntityState] = {}
-state_future: asyncio.Future[EntityState] = loop.create_future()
-
-
-def on_state(state: EntityState) -> None:
-    """This callback only receives NEW state changes, not initial states."""
-    states[state.key] = state
-    # Check for specific condition using isinstance
-    if isinstance(state, SensorState) and state.state == expected_value:
-        if not state_future.done():
-            state_future.set_result(state)
-
-
-# Get entities and set up state synchronization
 entities, services = await client.list_entities_services()
-initial_state_helper = InitialStateHelper(entities)
+sub = await subscribe_after_initial_states(client, entities)

-# Subscribe with the wrapper that filters initial states
-client.subscribe_states(initial_state_helper.on_state_wrapper(on_state))
-
-# Wait for all initial states to be broadcast; on timeout this fails the test
-# and lists the entities that never sent one
-await initial_state_helper.wait_for_initial_states()
-
-# Now perform your test actions - on_state will only receive new changes
-# ... trigger state changes ...
-
-# Wait for expected state; on timeout the test fails and shows the states received
-result = await wait_or_fail(
-    state_future, 5.0, "Expected state not received", states=states
+# Arm the wait before the action that produces the state
+expected = sub.waiter.expect(
+    lambda s: isinstance(s, SensorState) and s.state == expected_value
 )
+# ... trigger state changes ...
+result = await expected
 ```

 **Legacy: Manual State Tracking**
@@ -386,38 +386,34 @@ async with run_compiled(yaml_config, line_callback=on_log_line):
    # Test implementation
 ```

-Example using futures for specific log patterns:
+To wait for log lines, use `LineWaiter` (`log_utils.py`) instead of a hand written
+callback with one future per pattern:
 ```python
 import re

-loop = asyncio.get_running_loop()
-connected_future = loop.create_future()
-service_future = loop.create_future()
+from .log_utils import LineWaiter

-# Patterns to match
-connected_pattern = re.compile(r"Client .* connected from")
-service_pattern = re.compile(r"Service called")
+log = LineWaiter()
+# Arm expectations before the action that logs them; any number may be pending.
+connected = log.expect(re.compile(r"Client .* connected from"))
+value = log.expect(re.compile(r"value=(\d+)"))

-
-def check_output(line: str) -> None:
-    """Check log output for expected messages."""
-    if not connected_future.done() and connected_pattern.search(line):
-        connected_future.set_result(True)
-    elif not service_future.done() and service_pattern.search(line):
-        service_future.set_result(True)
-
-
-async with run_compiled(yaml_config, line_callback=check_output):
+async with run_compiled(yaml_config, line_callback=log.callback):
    async with api_client_connected() as client:
-        # Wait for specific log message
-        await asyncio.wait_for(connected_future, timeout=5.0)
-
-        # Do test actions...
-
-        # Wait for service log
-        await asyncio.wait_for(service_future, timeout=5.0)
+        await log.wait(connected)
+        match = await log.wait(value, timeout=5.0, msg="no value logged")
+        assert match.group(1) == "42"
+        assert log.count("Service called") == 1
 ```

+- `expect(pattern)` only matches lines that arrive after the call. A `str` matches as a
+  substring and resolves to the line; a compiled regex is searched and resolves to its match.
+  Each expectation resolves on the next matching line, so two armed for the same text both
+  resolve on its first occurrence: arm the second after the first resolves, or use `count`.
+- `wait(future)` fails the test on timeout with the pattern and the last 20 log lines.
+- `wait_for(*needles)` also matches lines seen before the call, but only one may be pending.
+- `count(pattern)` counts the lines seen so far.
+
 **Note**: Tests that monitor log messages typically have fewer race conditions compared to state-based testing, making them more reliable. However, be aware that the host platform currently does not have a thread-safe logger, so logging from threads will not work correctly.

 ##### Timeout Handling
@@ -3,23 +3,47 @@
 from __future__ import annotations

 import asyncio
+import re
+from typing import Any, overload
+
+from .wait_utils import wait_or_fail
+
+type LinePattern = str | re.Pattern[str]
+type LineMatch = str | re.Match[str]
+
+
+def _match(pattern: LinePattern, line: str) -> LineMatch | None:
+    """Return ``line`` if a str pattern is in it, or the search match of a regex."""
+    if isinstance(pattern, str):
+        return line if pattern in line else None
+    return pattern.search(line)


 class LineWaiter:
-    """Collects log lines and lets a test await one containing all needles.
+    """Collects log lines and lets a test await lines that match.

    Pass ``callback`` as ``run_compiled``'s ``line_callback``; the callback runs
-    on the test's own event loop, so futures are resolved directly. Only one
-    ``wait_for`` may be outstanding at a time (tests await sequentially).
+    on the test's own event loop, so futures are resolved directly. ``wait_for``
+    also matches lines seen before the call, and only one may be outstanding at a
+    time. ``expect`` matches only later lines, and any number may be armed at once;
+    each resolves on the next matching line, so two armed for the same text both
+    resolve on its first occurrence. Arm the second after the first, or use ``count``.
    """

    def __init__(self) -> None:
        self.lines: list[str] = []
        self._needles: tuple[str, ...] = ()
        self._future: asyncio.Future | None = None
+        self._expectations: dict[asyncio.Future[Any], LinePattern] = {}

    def callback(self, line: str) -> None:
        self.lines.append(line)
+        for future, pattern in list(self._expectations.items()):
+            if future.done():
+                del self._expectations[future]
+            elif (match := _match(pattern, line)) is not None:
+                future.set_result(match)
+                del self._expectations[future]
        if (
            self._future is not None
            and not self._future.done()
@@ -46,3 +70,38 @@ class LineWaiter:
        finally:
            self._future = None
            self._needles = ()
+
+    @overload
+    def expect(self, pattern: str) -> asyncio.Future[str]: ...  # noqa: E704
+
+    @overload
+    def expect(self, pattern: re.Pattern[str]) -> asyncio.Future[re.Match[str]]: ...  # noqa: E704
+
+    def expect(self, pattern: LinePattern) -> asyncio.Future[LineMatch]:
+        """Arm a wait for the next line matching ``pattern``; earlier lines never match.
+
+        A str matches as a substring and resolves to the line; a compiled regex is
+        searched and resolves to its match. Arm it before the action that logs the line.
+        """
+        future: asyncio.Future[LineMatch] = asyncio.get_running_loop().create_future()
+        self._expectations[future] = pattern
+        return future
+
+    async def wait[T: str | re.Match[str]](
+        self,
+        future: asyncio.Future[T],
+        timeout: float = 5.0,
+        msg: str = "log line not seen",
+    ) -> T:
+        """Await a future from ``expect``; on timeout fail with its pattern and the last lines."""
+        return await wait_or_fail(
+            future,
+            timeout,
+            msg,
+            pattern=self._expectations.get(future),
+            lines=self.lines,
+        )
+
+    def count(self, pattern: LinePattern) -> int:
+        """Return how many lines seen so far match ``pattern``."""
+        return sum(_match(pattern, line) is not None for line in self.lines)
@@ -4,6 +4,7 @@ from __future__ import annotations

 import asyncio
 from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
 import logging
 from typing import TypeVar

@@ -100,6 +101,22 @@ class StateWaiter:
        self._waiters.append(entry)
        return self._wait(entry, timeout, label)

+    def next_state[T: EntityState](
+        self,
+        key: int | None = None,
+        state_type: type[T] = EntityState,
+        timeout: float = 5.0,
+    ) -> Awaitable[T]:
+        """Arm a wait for the next ``state_type`` state, for entity ``key`` if given.
+
+        Like :meth:`expect`, call it before sending the command and await the result afterwards.
+        """
+        return self.expect(
+            lambda s: isinstance(s, state_type) and (key is None or s.key == key),
+            timeout,
+            state_type.__name__ if key is None else f"{state_type.__name__} key={key}",
+        )
+
    async def _wait(
        self,
        entry: tuple[Callable[[EntityState], bool], asyncio.Future[EntityState]],
@@ -402,6 +419,58 @@ class InitialStateHelper:
        )


+@dataclass(frozen=True, slots=True)
+class StateSubscription:
+    """A state subscription that is past the connect time states."""
+
+    initial_states: dict[int, EntityState]
+    waiter: StateWaiter
+
+
+async def subscribe_after_initial_states(
+    client: APIClient,
+    entities: list[EntityInfo],
+    on_state: Callable[[EntityState], None] | None = None,
+    timeout: float = 5.0,
+) -> StateSubscription:
+    """Subscribe to states and wait until every entity has sent its connect time state.
+
+    Later states go to ``on_state`` (if given) and to the returned ``waiter``. The connect time
+    states are kept in ``initial_states`` by key. Fails the test listing the entities still missing.
+    """
+    helper = InitialStateHelper(entities)
+    waiter = StateWaiter()
+
+    def forward(state: EntityState) -> None:
+        waiter.on_state(state)
+        if on_state is not None:
+            on_state(state)
+
+    client.subscribe_states(helper.on_state_wrapper(forward))
+    await helper.wait_for_initial_states(timeout)
+    return StateSubscription(helper.initial_states, waiter)
+
+
+async def press_and_wait[T: EntityState](
+    client: APIClient,
+    entities: list[EntityInfo],
+    waiter: StateWaiter,
+    button: str,
+    state_type: type[T],
+    *,
+    key: int | None = None,
+    timeout: float = 5.0,
+) -> T:
+    """Press the button whose object_id contains ``button`` and return the next ``state_type`` state.
+
+    Pass the entity's ``key`` when the fixture has more than one entity of that type.
+    """
+    btn = require_entity(entities, button, ButtonInfo)
+    next_state = waiter.next_state(key=key, state_type=state_type, timeout=timeout)
+    client.button_command(btn.key)
+    return await next_state
+
+
 class SensorStateCollector:
    """Collects sensor, binary sensor, and text sensor state updates with wait helpers.

@@ -74,3 +74,19 @@ def test_populate_dependency_config_populates_defaults() -> None:
        register_platform_fn=lambda domain: None,
    )
    assert config["ok"] == {"default": 1}
+
+
+def test_load_component_yaml_configs_extends_lists(tmp_path: Path) -> None:
+    """Several directories can each add entries to one platform component."""
+    (tmp_path / "first").mkdir()
+    (tmp_path / "first" / "benchmark.yaml").write_text(
+        "uart:\n  port: /dev/a\npacket_interface:\n  - platform: uart\n"
+    )
+    (tmp_path / "second").mkdir()
+    (tmp_path / "second" / "benchmark.yaml").write_text(
+        "uart:\n  port: /dev/b\npacket_interface:\n  - platform: udp\n"
+    )
+    merged = build_helpers.load_component_yaml_configs(["first", "second"], tmp_path)
+    assert merged["packet_interface"] == [{"platform": "uart"}, {"platform": "udp"}]
+    # Other values are taken from the first directory that sets them
+    assert merged["uart"] == {"port": "/dev/a"}
@@ -0,0 +1,81 @@
+"""Tests for the integration test LineWaiter."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+
+import pytest
+
+from tests.integration.log_utils import LineWaiter
+
+
+@pytest.mark.asyncio
+async def test_expect_matches_only_later_lines() -> None:
+    waiter = LineWaiter()
+    waiter.callback("[I][app]: ready")
+    ready = waiter.expect("ready")
+    value = waiter.expect(re.compile(r"value=(\d+)"))
+    assert not ready.done()
+
+    waiter.callback("[D][x]: value=42")
+    waiter.callback("[I][app]: ready again")
+    assert await waiter.wait(ready) == "[I][app]: ready again"
+    match = await waiter.wait(value)
+    assert isinstance(match, re.Match)
+    assert match.group(1) == "42"
+    # wait_for still matches lines seen before the call.
+    assert await waiter.wait_for("app", "ready") == "[I][app]: ready"
+
+
+@pytest.mark.asyncio
+async def test_wait_timeout_reports_pattern_and_lines() -> None:
+    waiter = LineWaiter()
+    for i in range(30):
+        waiter.callback(f"line {i}")
+    future = waiter.expect("never")
+    with pytest.raises(pytest.fail.Exception) as err:
+        await waiter.wait(future, 0.01, "boot message missing")
+    message = str(err.value)
+    assert message.startswith("boot message missing (after 0.01s)")
+    assert "pattern: 'never'" in message
+    assert "lines (last 20 of 30):" in message
+    assert message.endswith("line 29")
+    assert future.cancelled()
+    # The cancelled expectation is dropped on the next line.
+    waiter.callback("never")
+    assert not waiter._expectations
+
+
+def test_count() -> None:
+    waiter = LineWaiter()
+    for line in ("tick 1", "tock", "tick 2"):
+        waiter.callback(line)
+    assert waiter.count("tick") == 2
+    assert waiter.count(re.compile(r"t\w+k$")) == 1
+    assert waiter.count("missing") == 0
+
+
+@pytest.mark.asyncio
+async def test_expect_resolves_from_callback_while_waiting() -> None:
+    waiter = LineWaiter()
+    first = waiter.expect("first")
+    second = waiter.expect("second")
+    loop = asyncio.get_running_loop()
+    loop.call_soon(waiter.callback, "second")
+    loop.call_soon(waiter.callback, "first")
+    assert await waiter.wait(first) == "first"
+    assert await waiter.wait(second) == "second"
+
+
+@pytest.mark.asyncio
+async def test_line_waiter_expectations_share_a_matching_line() -> None:
+    waiter = LineWaiter()
+    first = waiter.expect("tick")
+    second = waiter.expect("tick")
+    waiter.callback("tick 1")
+    assert first.result() == second.result() == "tick 1"
+    third = waiter.expect("tick")
+    waiter.callback("tick 2")
+    assert third.result() == "tick 2"
+    assert waiter.count("tick") == 2
@@ -0,0 +1,108 @@
+"""Tests for the state subscription helpers in tests/integration/state_utils.py."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+
+from aioesphomeapi import ButtonInfo, EntityState, SensorInfo, SensorState, SwitchState
+import pytest
+
+from tests.integration.state_utils import (
+    StateSubscription,
+    StateWaiter,
+    press_and_wait,
+    subscribe_after_initial_states,
+)
+
+ENTITIES = [
+    SensorInfo(object_id="temp", key=1),
+    SensorInfo(object_id="humidity", key=2),
+    ButtonInfo(object_id="set_temp", key=3),
+]
+
+
+class FakeClient:
+    """Records the state callback and button presses."""
+
+    def __init__(self) -> None:
+        self.callback: Callable[[EntityState], None] | None = None
+        self.pressed: list[int] = []
+
+    def subscribe_states(self, callback: Callable[[EntityState], None]) -> None:
+        self.callback = callback
+
+    def button_command(self, key: int) -> None:
+        self.pressed.append(key)
+        self.callback(SensorState(key=1, state=42.0))
+
+
+async def _subscribe(client: FakeClient, **kwargs: object) -> StateSubscription:
+    task = asyncio.create_task(
+        subscribe_after_initial_states(client, ENTITIES, **kwargs)
+    )
+    await asyncio.sleep(0)
+    client.callback(SensorState(key=1, state=1.0))
+    client.callback(SensorState(key=2, state=2.0))
+    return await task
+
+
+@pytest.mark.asyncio
+async def test_subscribe_swallows_initial_states_and_forwards_later_ones() -> None:
+    client = FakeClient()
+    received: list[EntityState] = []
+    sub = await _subscribe(client, on_state=received.append)
+    assert sub.initial_states[1].state == 1.0
+    assert sub.initial_states[2].state == 2.0
+    assert received == []
+
+    next_state = sub.waiter.next_state(key=2, state_type=SensorState)
+    client.callback(SensorState(key=1, state=3.0))
+    client.callback(SensorState(key=2, state=4.0))
+    assert (await next_state).state == 4.0
+    assert [s.state for s in received] == [3.0, 4.0]
+
+
+@pytest.mark.asyncio
+async def test_subscribe_timeout_lists_missing_entities() -> None:
+    client = FakeClient()
+    task = asyncio.create_task(
+        subscribe_after_initial_states(client, ENTITIES, timeout=0.01)
+    )
+    await asyncio.sleep(0)
+    client.callback(SensorState(key=1, state=1.0))
+    with pytest.raises(pytest.fail.Exception, match=r"still_waiting[\s\S]*humidity"):
+        await task
+
+
+@pytest.mark.asyncio
+async def test_next_state_filters_by_type_and_times_out() -> None:
+    waiter = StateWaiter()
+    next_switch = waiter.next_state(state_type=SwitchState)
+    waiter.on_state(SensorState(key=1, state=1.0))
+    waiter.on_state(SwitchState(key=5, state=True))
+    assert (await next_switch).key == 5
+    with pytest.raises(TimeoutError, match="SwitchState key=9"):
+        await waiter.next_state(key=9, state_type=SwitchState, timeout=0.01)
+
+
+@pytest.mark.asyncio
+async def test_press_and_wait_presses_button_and_returns_state() -> None:
+    client = FakeClient()
+    sub = await _subscribe(client)
+    state = await press_and_wait(client, ENTITIES, sub.waiter, "set_temp", SensorState)
+    assert client.pressed == [3]
+    assert state.state == 42.0
+
+
+@pytest.mark.asyncio
+async def test_press_and_wait_waits_for_the_given_key() -> None:
+    client = FakeClient()
+    sub = await _subscribe(client)
+    pending = asyncio.ensure_future(
+        press_and_wait(client, ENTITIES, sub.waiter, "set_temp", SensorState, key=2)
+    )
+    await asyncio.sleep(0)
+    assert not pending.done()  # the press published key 1
+    client.callback(SensorState(key=2, state=55.0))
+    assert (await pending).state == 55.0
@@ -0,0 +1,36 @@
+"""Unit tests for the packet_interface component."""
+
+import pytest
+
+from esphome import config_validation as cv
+from esphome.components import packet_interface
+from esphome.components.packet_interface import CONF_MAX_PACKET_SIZE
+from esphome.components.uart import packet_interface as uart_packet_interface
+from esphome.components.udp import packet_interface as udp_packet_interface
+
+
+@pytest.mark.parametrize(
+    ("schema", "default", "limit"),
+    [
+        (uart_packet_interface.CONFIG_SCHEMA, 508, 4096),
+        (udp_packet_interface.CONFIG_SCHEMA, 508, 508),
+    ],
+)
+def test_platform_max_packet_size(
+    setup_core, schema: cv.Schema, default: int, limit: int
+) -> None:
+    """Each platform has its own default and upper limit for max_packet_size."""
+    assert schema({})[CONF_MAX_PACKET_SIZE] == default
+    assert schema({CONF_MAX_PACKET_SIZE: limit})[CONF_MAX_PACKET_SIZE] == limit
+    with pytest.raises(cv.Invalid):
+        schema({CONF_MAX_PACKET_SIZE: limit + 1})
+    with pytest.raises(cv.Invalid):
+        schema({CONF_MAX_PACKET_SIZE: 15})
+
+
+def test_schema_default(setup_core) -> None:
+    """packet_interface_schema applies the default it is given."""
+    schema = packet_interface.packet_interface_schema(
+        packet_interface.PacketInterface, 100
+    )
+    assert schema({})[CONF_MAX_PACKET_SIZE] == 100
Author	SHA1	Message	Date
clydebarrowandClaude Code	929aac8fac	[udp] Take the packet size from the copy buffer The link derives max_packet_size from the span it is given, so a packet larger than the copy buffer cannot be copied into it. Co-Authored-By: Claude Code <noreply@anthropic.com>	2026-10-23 13:28:08 +11:00
clydebarrowandClaude Opus 5.5	11cc5bb008	[udp] Limit a split packet to the copy buffer The copy buffer is sized by code generation to max_packet_size, but set_max_packet_size() can raise the limit afterwards, and copying a split packet would then overflow it. The link now takes the buffer as a span and refuses a split packet larger than it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-23 13:28:08 +11:00
clydebarrowandClaude Opus 5.5	2d6be6c27a	[udp] Drop datagrams longer than the receive buffer A read cuts a datagram longer than the buffer to fit, so a 600 byte datagram arrived as a valid looking 508 byte packet. The buffer is now one byte longer, and a read that fills it is dropped. The split packet test also checks the bytes joined in the copy buffer. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-23 13:28:08 +11:00
clydebarrowandClaude Opus 5.5	bfa6e68039	[packet_interface] Fix clang-tidy findings in tests Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-23 13:28:08 +11:00
clydebarrowandClaude Opus 5.5	c39566f312	[udp] Keep the copy buffer in static memory Code generation declares the UDP link's buffer for packets split across buffers as a static array of max_packet_size bytes, so it is not allocated at run time. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-23 13:28:08 +11:00
clydebarrowandClaude Opus 5.5	5197140f2c	[packet_interface] Use a local to_vector() in tests Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-23 13:28:08 +11:00
clydebarrowandClaude Opus 5.5	ee0c6a412e	[udp] Fixes from code review - Enforce max_packet_size on send and receive - Copy split packets into a buffer allocated in setup, not on the stack - Add unit tests for the link's send and receive paths - Explain why the broadcast socket is always enabled Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-23 13:28:08 +11:00
clydebarrowandClaude Opus 5.5	373c6398b2	[udp] Add UDP packet interface link Each packet is one UDP datagram, using the settings of the udp component. The udp component now reports whether a packet was sent, and an ENOMEM refusal from lwIP is logged at verbose level as the packet can be sent again. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-23 13:28:08 +11:00
Clyde Stubbs Claude Opus 5.5 J. Nick Koston	8156de9613	[packet_interface] Add packet interface component (#21037 ) Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: J. Nick Koston <nick@home-assistant.io>	2026-10-23 13:28:03 +11:00
Jonathan Swoboda	89c2cdb592	[core][hmac_sha256] Compare digests in constant time (#21443 )	2026-10-22 22:24:30 -04:00
Jonathan Swoboda	cb57148178	[syslog] Redact LOG_SECRET values before sending a message (#21444 )	2026-10-22 22:13:30 -04:00
Clyde StubbsandClaude Opus 5.5	dcfad5c439	[runtime_image] Decode at the smallest possible JPEGDEC scale (#21386 ) Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-23 12:57:05 +11:00
Clyde StubbsandClaude Opus 5.5	e08cbc5661	[online_image] Add on_download_started and on_download_progress (#21355 ) Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-23 12:38:13 +11:00
Clyde StubbsandClaude Opus 5.5	2b183be544	[online_image] Decode a JPEG as it downloads (#21342 ) Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-23 12:38:13 +11:00
J. Nick Koston	6a18470ccb	[tests] Let LineWaiter wait for several log patterns at once (#21153 )	2026-10-22 15:05:30 -10:00
J. Nick Koston	e9aaf84ee5	[tests] Add helpers to subscribe after initial states and wait for the next state (#21151 )	2026-10-22 15:05:04 -10:00