[http_request] Use a user provided default constructor for OtaHttpRequestComponent

Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
Co-authored-by: J. Nick Koston <nick@koston.org>

.github/workflows/ci.yml

@@ -244,11 +244,20 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Read prek version from requirements_test.txt
+        id: prek
+        # requirements_test.txt is the only place the version is pinned, so a
+        # Dependabot bump there is picked up here without a second edit.
+        run: |
+          if ! version=$(sed -nE 's/^prek==([^[:space:]#]+).*/\1/p' requirements_test.txt) || [ -z "$version" ]; then
+            echo "::error::No prek== pin found in requirements_test.txt."
+            exit 1
+          fi
+          echo "version=$version" >> "$GITHUB_OUTPUT"
       - name: Run prek
         uses: j178/prek-action@4e14d07f9231acabce116ccfca13b13dd9755ece # v3.0.0
         with:
-          # Keep in sync with requirements_test.txt.
-          prek-version: "0.4.11"
+          prek-version: ${{ steps.prek.outputs.version }}
           # This job only runs on pull requests, so nothing ever populates
           # the cache on dev. Every run would miss and then write a per-pull
           # request copy, which is what the old seed-cache job existed to

.github/workflows/stale.yml

@@ -33,7 +33,7 @@ jobs:
         and will be closed if no further activity occurs within 7 days.
 
         If you are the author of this PR, please leave a comment if you want
-        to keep it open. Also, please rebase your PR onto the latest dev
+        to keep it open. Also, please merge the latest dev branch into your
         branch to ensure that it's up to date with the latest changes.
 
         Thank you for your contribution!

.github/workflows/sync-dependency-versions.yml

@@ -0,0 +1,94 @@
+# Keeps pre-commit hook revs in sync with the requirements files.
+#
+# Dependabot only bumps the pins in requirements*.txt. Some of those tools
+# are pinned again as hook revs in .pre-commit-config.yaml. This workflow
+# runs script/sync_dependency_versions.py against the pull request branch
+# and pushes a commit with the revs updated.
+
+name: Sync dependency versions
+
+on:
+  # pull_request_target rather than pull_request so the App secret is
+  # available on Dependabot pull requests (pull_request runs opened by
+  # Dependabot only see Dependabot secrets). The job below only touches
+  # branches in this repository and only ever executes the script from the
+  # base branch checkout, so fork code never runs with the token.
+  pull_request_target:
+    types: [opened, synchronize, reopened]
+    paths:
+      - requirements_dev.txt
+      - requirements_test.txt
+      - .pre-commit-config.yaml
+      - script/sync_dependency_versions.py
+
+# The push to the pull request branch uses the App token minted below, so
+# the workflow's GITHUB_TOKEN does not need any scopes.
+permissions: {}
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  sync:
+    name: Sync pinned versions
+    runs-on: ubuntu-latest
+    # Same-repository branches only: a push to a fork is not possible with
+    # this token, and it keeps untrusted heads out of a privileged job.
+    if: >-
+      github.repository == 'esphome/esphome'
+      && github.event.pull_request.head.repo.full_name == github.repository
+    steps:
+      - name: Generate a token
+        id: generate-token
+        uses: actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1 # v3.2.0
+        with:
+          client-id: ${{ vars.ESPHOME_GITHUB_APP_CLIENT_ID }}
+          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
+          # A push made with the workflow's own GITHUB_TOKEN would not start
+          # CI on the new commit; a push with the App token does.
+          permission-contents: write  # git push of the sync commit to the pull request branch
+
+      - name: Check out base branch
+        # Provides the script that runs below. Deliberately the base branch
+        # so the pull request cannot change what executes here.
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          ref: ${{ github.event.pull_request.base.sha }}
+          persist-credentials: false
+
+      - name: Check out pull request branch
+        # No allow-unsafe-pr-checkout here on purpose: checkout v7 only
+        # refuses heads that live in a different repository, and the job
+        # condition above already limits runs to same-repository branches.
+        # Leaving it off keeps that refusal as a backstop for fork heads.
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          ref: ${{ github.event.pull_request.head.ref }}
+          path: pull-request
+          token: ${{ steps.generate-token.outputs.token }}
+
+      - name: Set up Python
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        with:
+          python-version: "3.12"
+
+      - name: Install yamlrocks
+        # The script edits YAML through yamlrocks. Take the pin from the
+        # base branch requirements so this workflow has no copy of its own.
+        run: pip install "$(grep -E '^yamlrocks==' requirements_test.txt | cut -d'#' -f1)"
+
+      - name: Sync pinned versions
+        run: python script/sync_dependency_versions.py --root pull-request
+
+      - name: Push changes
+        working-directory: pull-request
+        run: |
+          if git diff --quiet; then
+            echo "All pinned versions already match the requirements files."
+            exit 0
+          fi
+          git config user.name "esphome[bot]"
+          git config user.email "115708604+esphome[bot]@users.noreply.github.com"
+          git commit -am "Sync pinned tool versions with requirements files"
+          git push

.pre-commit-config.yaml

@@ -1,7 +1,6 @@
 ---
 # See https://pre-commit.com for more information
 # See https://pre-commit.com/hooks.html for more hooks
-
 ci:
   autoupdate_commit_msg: 'pre-commit: autoupdate'
   autoupdate_schedule: off  # Disabled until ruff versions are synced between deps and pre-commit
@@ -11,7 +10,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.16.3
+    rev: v0.16.6
     hooks:
       # Run the linter.
       - id: ruff
@@ -42,7 +41,7 @@ repos:
       - id: pyupgrade
         args: [--py312-plus]
   - repo: https://github.com/adrienverge/yamllint.git
-    rev: v1.37.1
+    rev: v1.38.0
     hooks:
       - id: yamllint
         exclude: ^(\.clang-format|\.clang-tidy)$

AGENTS.md

@@ -553,6 +553,7 @@ file does, and it is the authority when they disagree. The most useful starting
     4.  **Lint:** Run `prek` to ensure code is compliant.
     5.  **Commit:** Commit your changes. There is no strict format for commit messages.
     6.  **Pull Request:** Submit a PR against the `dev` branch. The Pull Request title must start with a `[tag]` prefix. For component work, use the component name (e.g., `[display] Fix bug`, `[abc123] Add new component`); for changes to shared/core code that isn't tied to a single component, use `[core]` (e.g., `[core] Add validator`). Update documentation, examples, and add `CODEOWNERS` entries as needed. Pull requests should always be made using the `.github/PULL_REQUEST_TEMPLATE.md` template - fill out all sections completely without removing any parts of the template.
+    7.  **Comments:** When commenting on GitHub PRs or issues, don't tag contributors, especially bots. Avoid referring to list items (e.g. from reviews) with the form #nn - this will be interpreted by GitHub as a reference to issue or PR nn. Keep comments short and exclude irrelevant details, backstories, restatement of previous comments and anything that is already obvious to the reader.
 
 *   **Documentation Contributions:**
     *   Documentation is hosted in the separate `esphome/esphome.io` repository.
@@ -628,6 +629,9 @@ file does, and it is the authority when they disagree. The most useful starting
                _request_listener_slot()
                cg.add(hub.register_listener(var))
            ```
+           When several instances each own a list declared at the same size (one per hub of a
+           `MULTI_CONF` component), pass the owning object as the key, `_request_listener_slot(str(hub))`;
+           the define is then the largest count any one key requested instead of the total.
            ```cpp
            #ifdef MY_COMPONENT_LISTENER_COUNT
              void register_listener(MyComponentListener *listener);
@@ -839,7 +843,7 @@ file does, and it is the authority when they disagree. The most useful starting
         cv.rename_key(
             CONF_OLD_KEY, CONF_NEW_KEY, removed_in="2026.6.0", component="my_component"
         ),
-        cv.Schema({ ... }),
+        cv.Schema({...}),
     )
     ```
     For other deprecations, warn manually during validation:

CODEOWNERS

@@ -100,6 +100,7 @@ esphome/components/bmp581_i2c/* @danielkent-net @kahrendt
 esphome/components/bmp581_spi/* @danielkent-net @kahrendt
 esphome/components/bp1658cj/* @Cossid
 esphome/components/bp5758d/* @Cossid
+esphome/components/bridge/* @kbx81
 esphome/components/bthome_mithermometer/* @nagyrobi
 esphome/components/button/* @esphome/core
 esphome/components/bytebuffer/* @clydebarrow
@@ -111,6 +112,8 @@ esphome/components/captive_portal/* @esphome/core
 esphome/components/cc1101/* @gabest11 @lygris
 esphome/components/ccs811/* @habbie
 esphome/components/cd74hc4067/* @asoehlke
+esphome/components/cdc_acm_uart/* @kbx81
+esphome/components/cdc_acm_uart/bridge/* @kbx81
 esphome/components/ch422g/* @clydebarrow @jesterret
 esphome/components/ch423/* @dwmw2
 esphome/components/chsc6x/* @kkosik20

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2026.9.0b5
+PROJECT_NUMBER         = 2026.10.0-dev
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

docker/Dockerfile

@@ -22,7 +22,7 @@ RUN \
     -r /requirements.txt
 
 # Install the ESPHome Device Builder dashboard.
-RUN uv pip install --no-cache-dir esphome-device-builder==1.14.9
+RUN uv pip install --no-cache-dir esphome-device-builder==1.14.7
 
 RUN \
     platformio settings set enable_telemetry No \

esphome/api_client.py

@@ -23,9 +23,7 @@ from esphome.util import safe_print
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from aioesphomeapi.api_pb2 import (
-        SubscribeLogsResponse,  # pylint: disable=no-name-in-module
-    )
+    from aioesphomeapi.api_pb2 import SubscribeLogsResponse  # pylint: disable=no-name-in-module
 
 
 _LOGGER = logging.getLogger(__name__)

esphome/components/api/__init__.py

@@ -350,9 +350,10 @@ CONFIG_SCHEMA = cv.All(
                 ln882x=5,  # Moderate RAM
                 nrf52=4,  # ~256KB RAM, BSD sockets, Thread (single HA controller)
             ): cv.int_range(min=1, max=20),
-            # Max queued messages per connection, and 2 KB of backlog per slot up
-            # to 64 KB (a lone message is exempt), before the connection is dropped
+            # Maximum queued send buffers per connection before dropping connection
+            # Each buffer uses ~8-12 bytes overhead plus actual message size
             # Platform defaults based on available RAM and typical message rates:
+            # CONF_MAX_SEND_QUEUE defaults are power of 2 for efficient modulo
             cv.SplitDefault(
                 CONF_MAX_SEND_QUEUE,
                 esp8266=4,  # Limited RAM, need to fail fast

esphome/components/api/api.proto

@@ -77,6 +77,7 @@ service APIConnection {
   rpc serial_proxy_set_modem_pins(SerialProxySetModemPinsRequest) returns (void) {}
   rpc serial_proxy_get_modem_pins(SerialProxyGetModemPinsRequest) returns (void) {}
   rpc serial_proxy_request(SerialProxyRequest) returns (void) {}
+  rpc serial_proxy_set_mode(SerialProxySetModeRequest) returns (void) {}
 }
 
 
@@ -2726,7 +2727,8 @@ enum SerialProxyParity {
   SERIAL_PROXY_PARITY_ODD = 2;
 }
 
-// Configure UART parameters for a serial proxy instance
+// Configure UART parameters for a serial proxy instance. Only the subscribed client may
+// configure the port; others are refused with PORT_IN_USE (since API 1.17).
 message SerialProxyConfigureRequest {
   option (id) = 138;
   option (source) = SOURCE_CLIENT;
@@ -2752,7 +2754,8 @@ message SerialProxyDataReceived {
   bytes data = 2;               // Raw data received from the serial device
 }
 
-// Write data to a serial device
+// Write data to a serial device. Only the subscribed client may write; writes from
+// others are ignored (since API 1.17).
 message SerialProxyWriteRequest {
   option (id) = 140;
   option (source) = SOURCE_CLIENT;
@@ -2763,7 +2766,8 @@ message SerialProxyWriteRequest {
   bytes data = 2;               // Raw data to write to the serial device
 }
 
-// Set modem control pin states (RTS and DTR)
+// Set modem control pin states (RTS and DTR). Only the subscribed client may set them;
+// others are refused with PORT_IN_USE (since API 1.17).
 message SerialProxySetModemPinsRequest {
   option (id) = 141;
   option (source) = SOURCE_CLIENT;
@@ -2802,6 +2806,7 @@ enum SerialProxyRequestType {
   // error the device answers with INVALID_ARGUMENT.
   SERIAL_PROXY_REQUEST_TYPE_CONFIGURE = 3;      // Acknowledges a SerialProxyConfigureRequest
   SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS = 4; // Acknowledges a SerialProxySetModemPinsRequest
+  SERIAL_PROXY_REQUEST_TYPE_SET_MODE = 5;       // Acknowledges a SerialProxySetModeRequest (since API 1.17)
 }
 
 enum SerialProxyStatus {
@@ -2814,7 +2819,8 @@ enum SerialProxyStatus {
   SERIAL_PROXY_STATUS_INVALID_ARGUMENT = 6; // Invalid instance index or parameter value
 }
 
-// Generic request message for simple serial proxy operations
+// Generic request message for simple serial proxy operations. FLUSH requires an active
+// subscription; it is refused with PORT_IN_USE otherwise (since API 1.17).
 message SerialProxyRequest {
   option (id) = 144;
   option (source) = SOURCE_CLIENT;
@@ -2838,6 +2844,29 @@ message SerialProxyRequestResponse {
   string error_message = 4;            // Additional detail on failure (optional)
 }
 
+// How a port treats the bytes passing through it. RAW is a plain byte pipe; PROTOCOL
+// activates the port's protocol-aware tap (if one is configured), letting it observe
+// traffic and inject protocol bytes such as acknowledgements. Which protocol the tap
+// speaks is a property of the device configuration, discoverable from the tap
+// component's own API surface. A client that is about to flash firmware selects RAW
+// first, which definitively disables that injection.
+enum SerialProxyMode {
+  SERIAL_PROXY_MODE_RAW = 0;
+  SERIAL_PROXY_MODE_PROTOCOL = 1;
+}
+
+// Only the subscribed client may change the mode; any other caller -- including one that
+// never subscribed -- is refused with PORT_IN_USE. PROTOCOL is refused with NOT_SUPPORTED
+// when the port has no protocol-aware tap configured.
+message SerialProxySetModeRequest {
+  option (id) = 152;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_SERIAL_PROXY";
+
+  uint32 instance = 1;
+  SerialProxyMode mode = 2;
+}
+
 // ==================== BLUETOOTH CONNECTION PARAMS ====================
 message BluetoothSetConnectionParamsRequest {
   option (id) = 145;

esphome/components/api/api_buffer.cpp

@@ -1,37 +1,20 @@
 #include "api_buffer.h"
-#ifdef ESPHOME_DEBUG_API
-#include "esphome/core/log.h"
-#endif
+#include <new>
 
 namespace esphome::api {
 
-#ifdef ESPHOME_DEBUG_API
-void APIBuffer::debug_check_drop_(size_t drop) const {
-  if (drop > this->size_) {
-    ESP_LOGE("api.buffer", "drop_front: drop=%zu size=%u", drop, this->size_);
-    abort();
-  }
-}
-#endif
-
 bool APIBuffer::grow_(size_t n) {
-  if (n > MAX_SIZE)
+  // nothrow (no zero-fill) so OOM is reportable; plain new aborts instead
+  // (NEW_OOM_ABORT on ESP8266 Arduino, exception stub on ESP-IDF).
+  // RAMAllocator is no fit here: unique_ptr needs delete[]-compatible memory.
+  std::unique_ptr<uint8_t[]> new_data(new (std::nothrow) uint8_t[n]);
+  if (new_data == nullptr)
     return false;
-  // realloc extends in place when it can, avoiding the copy
-  uint8_t *grown = RAMAllocator<uint8_t>().reallocate(this->data_.get(), n);
-  if (grown == nullptr)
-    return false;
-  (void) this->data_.release();  // realloc already freed or reused the old block
-  this->data_.reset(grown);
+  if (this->size_)
+    std::memcpy(new_data.get(), this->data_.get(), this->size_);
+  this->data_ = std::move(new_data);
   this->capacity_ = n;
   return true;
 }
 
-uint8_t *APIBuffer::append(size_t n) {
-  const size_t old_size = this->size_;
-  if (!this->resize(old_size + n))
-    return nullptr;
-  return this->data_.get() + old_size;
-}
-
 }  // namespace esphome::api

esphome/components/api/api_buffer.h

@@ -25,7 +25,6 @@ namespace esphome::api {
 /// writes in debug builds.
 class APIBuffer {
  public:
-  static constexpr size_t MAX_SIZE = UINT16_MAX;  // API frames carry 16 bit lengths
   void clear() { this->size_ = 0; }
   /// Returns false if allocation fails; the buffer is left unchanged.
   [[nodiscard]] inline bool reserve(size_t n) ESPHOME_ALWAYS_INLINE { return n <= this->capacity_ || this->grow_(n); }
@@ -37,19 +36,9 @@ class APIBuffer {
   [[nodiscard]] inline bool reserve_and_resize(size_t reserve_size, size_t new_size) ESPHOME_ALWAYS_INLINE {
     if (!this->reserve(std::max(reserve_size, new_size)))
       return false;
-    this->size_ = static_cast<uint16_t>(new_size);
+    this->size_ = new_size;
     return true;
   }
-  /// Grow by n bytes; returns the new bytes, or nullptr on allocation failure.
-  [[nodiscard]] uint8_t *append(size_t n);
-  /// Drop the first `drop` bytes, sliding the rest down. Precondition: drop <= size().
-  void drop_front(size_t drop) {
-#ifdef ESPHOME_DEBUG_API
-    this->debug_check_drop_(drop);
-#endif
-    this->size_ -= drop;
-    std::memmove(this->data_.get(), this->data_.get() + drop, this->size_);
-  }
   uint8_t *data() { return this->data_.get(); }
   const uint8_t *data() const { return this->data_.get(); }
   size_t size() const { return this->size_; }
@@ -66,14 +55,9 @@ class APIBuffer {
 
  protected:
   bool grow_(size_t n);
-#ifdef ESPHOME_DEBUG_API
-  void debug_check_drop_(size_t drop) const;
-#endif
-  // RAMAllocator: PSRAM when available, and it reports failure where
-  // new (std::nothrow) still aborts on ESP-IDF without exceptions
-  RAMUniquePtr<uint8_t[]> data_;
-  uint16_t size_{0};
-  uint16_t capacity_{0};
+  std::unique_ptr<uint8_t[]> data_;
+  size_t size_{0};
+  size_t capacity_{0};
 };
 
 }  // namespace esphome::api

esphome/components/api/api_connection.cpp

@@ -364,10 +364,7 @@ void APIConnection::check_keepalive_(uint32_t now) {
     ESP_LOGVV(TAG, "Sending keepalive PING");
     PingRequest req;
     this->flags_.sent_ping = this->send_message(req);
-    if (this->flags_.sent_ping) {
-      // Quiet for a keepalive period and the ping is on its way: a one-off stall's storage can go
-      this->helper_->release_overflow_buffer();
-    } else {
+    if (!this->flags_.sent_ping) {
       // If we can't send the ping request directly (tx_buffer full),
       // schedule it at the front of the batch so it will be sent with priority
       ESP_LOGW(TAG, "Buffer full, ping queued");
@@ -1664,6 +1661,7 @@ void APIConnection::on_serial_proxy_request(const SerialProxyRequest &msg) {
       break;
     case enums::SERIAL_PROXY_REQUEST_TYPE_CONFIGURE:
     case enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS:
+    case enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODE:
       // Response-only discriminators; never valid in a request
       ESP_LOGW(TAG, "Response-only serial proxy request type: %" PRIu32, static_cast<uint32_t>(msg.type));
       status = enums::SERIAL_PROXY_STATUS_INVALID_ARGUMENT;
@@ -1676,6 +1674,19 @@ void APIConnection::on_serial_proxy_request(const SerialProxyRequest &msg) {
   send_serial_proxy_ack(this, msg.instance, msg.type, status);
 }
 
+void APIConnection::on_serial_proxy_set_mode_request(const SerialProxySetModeRequest &msg) {
+  auto &proxies = App.get_serial_proxies();
+  if (msg.instance >= proxies.size()) {
+    ESP_LOGW(TAG, "Serial proxy instance %" PRIu32 " out of range", msg.instance);
+    send_serial_proxy_ack(this, msg.instance, enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODE,
+                          enums::SERIAL_PROXY_STATUS_INVALID_ARGUMENT);
+    return;
+  }
+  serial_proxy::SerialProxyResult result = proxies[msg.instance]->set_mode_from_client(this, msg.mode);
+  send_serial_proxy_ack(this, msg.instance, enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODE,
+                        serial_proxy_result_to_status(result));
+}
+
 void APIConnection::send_serial_proxy_data(const SerialProxyDataReceived &msg) {
   if (!this->send_message(msg)) {
     ESP_LOGV(TAG, "Serial proxy data dropped, TCP buffer full");
@@ -1802,7 +1813,7 @@ bool APIConnection::send_hello_response_(const HelloRequest &msg) {
 
   HelloResponse resp;
   resp.api_version_major = 1;
-  resp.api_version_minor = 16;
+  resp.api_version_minor = 17;
   // Send only the version string - the client only logs this for debugging and doesn't use it otherwise
   resp.server_info = ESPHOME_VERSION_REF;
   resp.name = StringRef(App.get_name());

esphome/components/api/api_connection.h

@@ -244,6 +244,7 @@ class APIConnection final : public APIServerConnectionBase {
   void on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &msg);
   void on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &msg);
   void on_serial_proxy_request(const SerialProxyRequest &msg);
+  void on_serial_proxy_set_mode_request(const SerialProxySetModeRequest &msg);
   void send_serial_proxy_data(const SerialProxyDataReceived &msg);
 #endif
 

esphome/components/api/api_frame_helper.cpp

@@ -171,7 +171,7 @@ APIError APIFrameHelper::write_raw_iov_(const struct iovec *iov, int iovcnt, uin
     return APIError::OK;
 
   // Queue unsent data into overflow buffer
-  if (!this->overflow_buf_.enqueue_iov(iov, iovcnt, total_write_len, sent)) {
+  if (!this->overflow_buf_.enqueue_iov(iov, iovcnt, total_write_len, static_cast<uint16_t>(sent))) {
     HELPER_LOG("Overflow buffer full or out of memory, dropping connection");
     this->state_ = State::FAILED;
     return APIError::SOCKET_WRITE_FAILED;

esphome/components/api/api_frame_helper.h

@@ -219,10 +219,7 @@ class APIFrameHelper {
     if (this->rx_buf_len_ == 0) {
       this->rx_buf_.release();
     }
-    this->release_overflow_buffer();
   }
-  // Free the send backlog storage once it has drained
-  void release_overflow_buffer() { this->overflow_buf_.release(); }
 
  protected:
   // Drain backlogged overflow data to the socket and handle errors.

esphome/components/api/api_frame_helper_noise.cpp

@@ -67,15 +67,15 @@ APIError APINoiseFrameHelper::init() {
   }
 
   // init prologue
-  uint8_t *dst = prologue_.append(PROLOGUE_INIT_LEN);
-  if (dst == nullptr) [[unlikely]] {
+  size_t old_size = prologue_.size();
+  if (!prologue_.resize(old_size + PROLOGUE_INIT_LEN)) [[unlikely]] {
     state_ = State::FAILED;
     return APIError::OUT_OF_MEMORY;
   }
 #ifdef USE_ESP8266
-  memcpy_P(dst, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
+  memcpy_P(prologue_.data() + old_size, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
 #else
-  std::memcpy(dst, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
+  std::memcpy(prologue_.data() + old_size, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
 #endif
 
   state_ = State::CLIENT_HELLO;
@@ -272,17 +272,17 @@ APIError APINoiseFrameHelper::state_action_client_hello_() {
     return handle_handshake_frame_error_(aerr);
   }
   // ignore contents, may be used in future for flags
-  // Append 2 size bytes + frame data to the prologue
+  // Resize for: existing prologue + 2 size bytes + frame data
+  size_t old_size = this->prologue_.size();
   size_t rx_size = this->rx_buf_.size();
-  uint8_t *dst = this->prologue_.append(2 + rx_size);
-  if (dst == nullptr) [[unlikely]] {
+  if (!this->prologue_.resize(old_size + 2 + rx_size)) [[unlikely]] {
     state_ = State::FAILED;
     return APIError::OUT_OF_MEMORY;
   }
-  dst[0] = (uint8_t) (rx_size >> 8);
-  dst[1] = (uint8_t) rx_size;
+  this->prologue_[old_size] = (uint8_t) (rx_size >> 8);
+  this->prologue_[old_size + 1] = (uint8_t) rx_size;
   if (rx_size > 0) {
-    std::memcpy(dst + 2, this->rx_buf_.data(), rx_size);
+    std::memcpy(this->prologue_.data() + old_size + 2, this->rx_buf_.data(), rx_size);
   }
 
   state_ = State::SERVER_HELLO;

esphome/components/api/api_overflow_buffer.cpp

@@ -1,91 +1,98 @@
 #include "api_overflow_buffer.h"
 #ifdef USE_API
 #include <cstring>
+#include <new>
 
 namespace esphome::api {
 
+APIOverflowBuffer::~APIOverflowBuffer() {
+  for (auto *entry : this->queue_) {
+    if (entry != nullptr)
+      Entry::destroy(entry);
+  }
+}
+
 ssize_t APIOverflowBuffer::try_drain(socket::Socket *socket) {
-  // Nested call from inside socket->write(); see draining_
+  // socket->write() can re-enter this function: a log message emitted from an
+  // lwip callback during the write goes out over the API and lands back in the
+  // frame helper's write/drain path. If a nested drain ran here it would send
+  // and free the entry the outer drain is still holding, causing a double free.
+  // Report "no progress" instead; the outer drain keeps draining, and the
+  // nested send is enqueued behind the existing backlog.
   if (this->draining_)
     return 0;
 
+  // RAII so the flag is cleared on every return path
   struct DrainGuard {
-    APIOverflowBuffer &owner;
-    ~DrainGuard() { this->owner.draining_ = false; }
-  } guard{*this};
-  this->draining_ = true;
+    explicit DrainGuard(bool &flag) : flag_(flag) { flag_ = true; }
+    ~DrainGuard() { this->flag_ = false; }
+    bool &flag_;
+  } guard(this->draining_);
 
   while (this->count_ > 0) {
-    uint8_t *msg = this->buf_.data() + this->head_;
-    size_t len = msg[0] | (msg[1] << 8);
+    Entry *front = this->queue_[this->head_];
 
-    ssize_t sent = socket->write(msg + LEN_PREFIX, len);
-    if (sent <= 0)
-      return sent;
-    if (static_cast<size_t>(sent) < len) {
-      // Step past the sent bytes and rewrite the prefix there; it lands on bytes already sent
-      this->head_ += sent;
-      len -= sent;
-      msg += sent;
-      msg[0] = len;
-      msg[1] = len >> 8;
+    ssize_t sent = socket->write(front->current_data(), front->remaining());
+
+    if (sent <= 0) {
+      // -1 = error (caller checks errno for EWOULDBLOCK vs hard error)
+      // 0 = nothing sent (treat as no progress)
       return sent;
     }
-    this->head_ += LEN_PREFIX + len;
+
+    if (static_cast<uint16_t>(sent) < front->remaining()) {
+      // Partially sent, update offset and stop
+      front->offset += static_cast<uint16_t>(sent);
+      return sent;
+    }
+
+    // Entry fully sent — unlink it before freeing so a freed pointer is never
+    // reachable from the queue
+    this->queue_[this->head_] = nullptr;
+    this->head_ = (this->head_ + 1) % API_MAX_SEND_QUEUE;
     this->count_--;
+    Entry::destroy(front);
   }
 
-  this->head_ = 0;
-  if (this->release_when_drained_) {
-    this->release_when_drained_ = false;
-    this->buf_.release();
-  } else {
-    this->buf_.clear();
-  }
-  return 0;
+  return 0;  // All drained
 }
 
-bool APIOverflowBuffer::enqueue_iov(const struct iovec *iov, int iovcnt, size_t total_len, size_t skip) {
+bool APIOverflowBuffer::enqueue_iov(const struct iovec *iov, int iovcnt, uint16_t total_len, uint16_t skip) {
   if (this->count_ >= API_MAX_SEND_QUEUE)
     return false;
 
-  const size_t new_len = total_len - skip;
-  const size_t new_bytes = LEN_PREFIX + new_len;
-  const size_t live = this->buf_.size() - this->head_;
-  // A lone message is only bound by the buffer; refusing it would just drop the connection
-  if (live + new_bytes > (this->count_ > 0 ? MAX_BYTES : MAX_LONE_BYTES))
+  uint16_t buffer_size = total_len - skip;
+  // nothrow: a failed allocation returns nullptr so the connection is dropped
+  // cleanly instead of plain new's crash or abort on OOM
+  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
+  auto *data = new (std::nothrow) uint8_t[buffer_size];
+  if (data == nullptr)
+    return false;
+  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
+  auto *entry = new (std::nothrow) Entry{data, buffer_size, 0};
+  if (entry == nullptr) {
+    delete[] data;
     return false;
-
-  if (this->buf_.size() + new_bytes > this->buf_.capacity()) {
-    // Storage would move under an outer drain's write()
-    if (this->draining_)
-      return false;
-    if (this->head_ > 0) {
-      // Reclaim the sent prefix before growing
-      this->buf_.drop_front(this->head_);
-      this->head_ = 0;
-    }
-    if (!this->buf_.reserve(reserve_for(live + new_bytes)))
-      return false;
   }
 
-  uint8_t *dst = this->buf_.append(new_bytes);
-  if (dst == nullptr)
-    return false;
-  dst[0] = new_len;
-  dst[1] = new_len >> 8;
-  dst += LEN_PREFIX;
-  for (const struct iovec *end = iov + iovcnt; iov != end; iov++) {
-    if (skip >= iov->iov_len) {
-      skip -= iov->iov_len;
+  uint16_t to_skip = skip;
+  uint16_t write_pos = 0;
+
+  for (int i = 0; i < iovcnt; i++) {
+    if (to_skip >= iov[i].iov_len) {
+      to_skip -= static_cast<uint16_t>(iov[i].iov_len);
     } else {
-      const size_t len = iov->iov_len - skip;
-      std::memcpy(dst, static_cast<const uint8_t *>(iov->iov_base) + skip, len);
-      dst += len;
-      skip = 0;
+      const uint8_t *src = reinterpret_cast<uint8_t *>(iov[i].iov_base) + to_skip;
+      uint16_t len = static_cast<uint16_t>(iov[i].iov_len) - to_skip;
+      std::memcpy(entry->data + write_pos, src, len);
+      write_pos += len;
+      to_skip = 0;
     }
   }
 
+  // Publish only after the copy completes so a half-built entry is never reachable
+  this->queue_[this->tail_] = entry;
+  this->tail_ = (this->tail_ + 1) % API_MAX_SEND_QUEUE;
   this->count_++;
   return true;
 }

esphome/components/api/api_overflow_buffer.h

@@ -1,6 +1,5 @@
 #pragma once
-#include <algorithm>
-#include <cstddef>
+#include <array>
 #include <cstdint>
 #include <sys/types.h>
 
@@ -9,57 +8,71 @@
 
 #include "esphome/components/socket/headers.h"
 #include "esphome/components/socket/socket.h"
-#include "api_buffer.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome::api {
 
-/// TCP send backlog, only used when the socket send buffer is full.
-/// One contiguous buffer per connection, allocated on the first stall and
-/// kept at its high-water mark so a lossy link does not churn the heap.
-/// Messages are stored as a 2 byte length prefix plus payload.
-/// API_MAX_SEND_QUEUE bounds queued messages and, at 2 KB per slot, queued
-/// bytes; exceeding either fails the connection.
+/// Circular queue of heap-allocated byte buffers used as a TCP send backlog.
+///
+/// Under normal operation this buffer is **never used** — data goes straight
+/// from the frame helper to the socket.  It only fills when the LWIP TCP
+/// send buffer is full (slow client, congested network, heavy logging).
+/// The queue drains automatically on subsequent write/loop calls once the
+/// socket becomes writable again.
+///
+/// Capacity is compile-time-fixed via API_MAX_SEND_QUEUE (set from Python
+/// config).  If the queue fills completely the connection is marked failed.
 class APIOverflowBuffer {
  public:
+  /// A single heap-allocated send-backlog entry.
+  /// Lifetime is manually managed — see destroy().
+  struct Entry {
+    uint8_t *data;
+    uint16_t size;    // Total size of the buffer
+    uint16_t offset;  // Current send offset within the buffer
+
+    uint16_t remaining() const { return this->size - this->offset; }
+    const uint8_t *current_data() const { return this->data + this->offset; }
+
+    /// Free this entry and its data buffer.
+    static ESPHOME_ALWAYS_INLINE void destroy(Entry *entry) {
+      delete[] entry->data;
+      delete entry;  // NOLINT(cppcoreguidelines-owning-memory)
+    }
+  };
+
+  ~APIOverflowBuffer();
+
   /// True when no backlogged data is waiting.
   bool empty() const { return this->count_ == 0; }
 
-  /// Drain queued messages to the socket.
-  /// Returns bytes written, 0 for a re-entrant call, -1 on error (check errno
-  /// for EWOULDBLOCK); callers only need to act on -1.
+  /// True when the queue has no room for another entry.
+  bool full() const { return this->count_ >= API_MAX_SEND_QUEUE; }
+
+  /// Number of entries currently queued.
+  uint8_t count() const { return this->count_; }
+
+  /// Try to drain queued data to the socket.
+  /// Returns bytes-written > 0 on success/partial, 0 if all drained or no progress,
+  /// -1 on error (caller must check errno to distinguish EWOULDBLOCK from hard errors).
+  /// Callers only need to act on -1; 0 and positive values both mean "no error".
+  /// Frees entries as they are fully sent.
   ssize_t try_drain(socket::Socket *socket);
 
-  /// Queue iov data from byte offset `skip` as one message.
-  /// Returns false when a limit is hit, allocation fails, or storage would move
-  /// during a drain; the caller should fail the connection.
-  bool enqueue_iov(const struct iovec *iov, int iovcnt, size_t total_len, size_t skip);
-
-  /// Free the retained storage, now if empty, otherwise once it has drained.
-  void release() {
-    if (this->count_ == 0) {
-      this->buf_.release();
-    } else {
-      this->release_when_drained_ = true;
-    }
-  }
+  /// Enqueue unsent IOV data into the backlog.
+  /// Copies iov data starting at byte offset `skip` into a new entry.
+  /// Returns false if the queue is full or allocation fails (caller should fail the connection).
+  bool enqueue_iov(const struct iovec *iov, int iovcnt, uint16_t total_len, uint16_t skip);
 
  protected:
-  static constexpr size_t LEN_PREFIX = 2;
-  static constexpr size_t BYTES_PER_SLOT = 2048;
-  // Reserve in 256 byte steps so a creeping high-water mark settles quickly
-  static constexpr size_t GROW_QUANTUM = 256;
-  // Lone message ceiling, rounded down so reserve_for() never exceeds the buffer limit
-  static constexpr size_t MAX_LONE_BYTES = APIBuffer::MAX_SIZE & ~(GROW_QUANTUM - 1);
-  static constexpr size_t MAX_BYTES = std::min(API_MAX_SEND_QUEUE * BYTES_PER_SLOT, MAX_LONE_BYTES);
-  static constexpr size_t reserve_for(size_t want) { return (want + GROW_QUANTUM - 1) & ~(GROW_QUANTUM - 1); }
-
-  APIBuffer buf_;
-  uint16_t head_{0};  // offset of the front message's length prefix; bytes before it are sent
+  std::array<Entry *, API_MAX_SEND_QUEUE> queue_{};
+  uint8_t head_{0};
+  uint8_t tail_{0};
   uint8_t count_{0};
-  // socket->write() can re-enter the send path (log from an lwip callback):
-  // a nested drain makes no progress and a nested enqueue never moves storage
-  bool draining_ : 1 {false};
-  bool release_when_drained_ : 1 {false};
+  // Guards against re-entrant drains: socket->write() can re-enter the API
+  // send path (e.g. a log message emitted from an lwip callback), and a nested
+  // drain would free the entry the outer drain is still holding.
+  bool draining_{false};
 };
 
 }  // namespace esphome::api

esphome/components/api/api_pb2.cpp

@@ -4253,6 +4253,19 @@ uint32_t SerialProxyRequestResponse::calculate_size() const {
   size += ProtoSize::calc_length(1, this->error_message.size());
   return size;
 }
+bool SerialProxySetModeRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
+  switch (field_id) {
+    case 1:
+      this->instance = value;
+      break;
+    case 2:
+      this->mode = static_cast<enums::SerialProxyMode>(value);
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
 #endif
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
 bool BluetoothSetConnectionParamsRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {

esphome/components/api/api_pb2.h

@@ -356,6 +356,7 @@ enum SerialProxyRequestType : uint32_t {
   SERIAL_PROXY_REQUEST_TYPE_FLUSH = 2,
   SERIAL_PROXY_REQUEST_TYPE_CONFIGURE = 3,
   SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS = 4,
+  SERIAL_PROXY_REQUEST_TYPE_SET_MODE = 5,
 };
 enum SerialProxyStatus : uint32_t {
   SERIAL_PROXY_STATUS_OK = 0,
@@ -366,6 +367,10 @@ enum SerialProxyStatus : uint32_t {
   SERIAL_PROXY_STATUS_PORT_IN_USE = 5,
   SERIAL_PROXY_STATUS_INVALID_ARGUMENT = 6,
 };
+enum SerialProxyMode : uint32_t {
+  SERIAL_PROXY_MODE_RAW = 0,
+  SERIAL_PROXY_MODE_PROTOCOL = 1,
+};
 #endif
 
 }  // namespace enums
@@ -3403,6 +3408,22 @@ class SerialProxyRequestResponse final : public ProtoMessage {
 
  protected:
 };
+class SerialProxySetModeRequest final : public ProtoDecodableMessage {
+ public:
+  static constexpr uint16_t MESSAGE_TYPE = 152;
+  static constexpr uint8_t ESTIMATED_SIZE = 6;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const LogString *message_name() const override { return LOG_STR("serial_proxy_set_mode_request"); }
+#endif
+  uint32_t instance{0};
+  enums::SerialProxyMode mode{};
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, proto_varint_value_t value) override;
+};
 #endif
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
 class BluetoothSetConnectionParamsRequest final : public ProtoDecodableMessage {

esphome/components/api/api_pb2_dump.cpp

@@ -854,6 +854,8 @@ template<> const char *proto_enum_to_string<enums::SerialProxyRequestType>(enums
       return ESPHOME_PSTR("SERIAL_PROXY_REQUEST_TYPE_CONFIGURE");
     case enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS:
       return ESPHOME_PSTR("SERIAL_PROXY_REQUEST_TYPE_SET_MODEM_PINS");
+    case enums::SERIAL_PROXY_REQUEST_TYPE_SET_MODE:
+      return ESPHOME_PSTR("SERIAL_PROXY_REQUEST_TYPE_SET_MODE");
     default:
       return ESPHOME_PSTR("UNKNOWN");
   }
@@ -878,6 +880,16 @@ template<> const char *proto_enum_to_string<enums::SerialProxyStatus>(enums::Ser
       return ESPHOME_PSTR("UNKNOWN");
   }
 }
+template<> const char *proto_enum_to_string<enums::SerialProxyMode>(enums::SerialProxyMode value) {
+  switch (value) {
+    case enums::SERIAL_PROXY_MODE_RAW:
+      return ESPHOME_PSTR("SERIAL_PROXY_MODE_RAW");
+    case enums::SERIAL_PROXY_MODE_PROTOCOL:
+      return ESPHOME_PSTR("SERIAL_PROXY_MODE_PROTOCOL");
+    default:
+      return ESPHOME_PSTR("UNKNOWN");
+  }
+}
 #endif
 
 const char *HelloRequest::dump_to(DumpBuffer &out) const {
@@ -2805,6 +2817,12 @@ const char *SerialProxyRequestResponse::dump_to(DumpBuffer &out) const {
   dump_field(out, ESPHOME_PSTR("error_message"), this->error_message);
   return out.c_str();
 }
+const char *SerialProxySetModeRequest::dump_to(DumpBuffer &out) const {
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxySetModeRequest"));
+  dump_field(out, ESPHOME_PSTR("instance"), this->instance);
+  dump_field(out, ESPHOME_PSTR("mode"), static_cast<enums::SerialProxyMode>(this->mode));
+  return out.c_str();
+}
 #endif
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
 const char *BluetoothSetConnectionParamsRequest::dump_to(DumpBuffer &out) const {

esphome/components/api/api_pb2_service.cpp

@@ -712,6 +712,17 @@ void APIConnection::read_message_(uint32_t msg_size, uint32_t msg_type, const ui
       this->on_device_capabilities_request();
       break;
     }
+#ifdef USE_SERIAL_PROXY
+    case SerialProxySetModeRequest::MESSAGE_TYPE: {
+      SerialProxySetModeRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      this->log_receive_message_(LOG_STR("on_serial_proxy_set_mode_request"), msg);
+#endif
+      this->on_serial_proxy_set_mode_request(msg);
+      break;
+    }
+#endif
     default:
       break;
   }

esphome/components/api/api_pb2_service.h

@@ -235,6 +235,9 @@ class APIServerConnectionBase {
   void on_serial_proxy_request(const SerialProxyRequest &value){};
 #endif
 
+#ifdef USE_SERIAL_PROXY
+  void on_serial_proxy_set_mode_request(const SerialProxySetModeRequest &value){};
+#endif
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
   void on_bluetooth_set_connection_params_request(const BluetoothSetConnectionParamsRequest &value){};
 #endif

esphome/components/binary_sensor/__init__.py

@@ -452,9 +452,7 @@ _BINARY_SENSOR_SCHEMA = (
             cv.Optional(
                 CONF_DEVICE_CLASS, visibility=cv.Visibility.ADVANCED
             ): validate_device_class,
-            cv.Optional(
-                CONF_FILTERS, visibility=cv.Visibility.ADVANCED
-            ): validate_filters,
+            cv.Optional(CONF_FILTERS): validate_filters,
             cv.Optional(CONF_ON_PRESS): automation.validate_automation({}),
             cv.Optional(CONF_ON_RELEASE): automation.validate_automation({}),
             cv.Optional(CONF_ON_CLICK): cv.All(

esphome/components/bk72xx_ble/__init__.py

@@ -23,7 +23,7 @@ public ble_api.h.
 import logging
 
 import esphome.codegen as cg
-from esphome.components import libretiny, wifi
+from esphome.components import libretiny
 from esphome.components.libretiny.const import (
     FAMILY_BK7231N,
     FAMILY_BK7231Q,
@@ -84,15 +84,6 @@ def _final_validate(config: ConfigType) -> None:
     # which run on a BLE 4.2 board. The hard error is raised at codegen.
     if msg := _unsupported_family_message(libretiny.get_libretiny_family()):
         _LOGGER.warning("%s (this configuration cannot compile)", msg)
-    # Any wifi power_save_mode other than NONE also arms the Beken SDK's MCU
-    # sleep. With the BLE controller running, that sleep never wakes up once the
-    # station is stopped (adapter restart after failed roams, wifi.disable): the
-    # device is dead until a power cycle (esphome#18592). Keep power save off
-    # until LibreTiny ships the SDK-side fix (libretiny-eu/libretiny#414).
-    wifi.force_power_save_off(
-        "with BLE running, the Beken SDK's MCU sleep halts the device once the "
-        "station is stopped (https://github.com/esphome/esphome/issues/18592)"
-    )
 
 
 FINAL_VALIDATE_SCHEMA = _final_validate

esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.cpp

@@ -45,7 +45,15 @@ void BluedroidGattClient::setup() {
 
 void BluedroidGattClient::loop() {
   if (!esp32_ble::global_ble->is_active()) {
-    // ble_before_disabled_event_handler() settles the slot.
+    // Stack down: no CLOSE_EVT will come. Settle a live link so the consumer
+    // frees its slot, then re-register the app on the next enable.
+    auto down_st = this->state();
+    if (down_st != ClientState::IDLE && down_st != ClientState::INIT) {
+      this->release_services();
+      this->set_idle_();
+      this->listener_->on_connection_state(false, 0, ble_device_base::GATT_ERR_NOT_CONNECTED);
+    }
+    this->set_state(ClientState::INIT);
     return;
   }
   auto st = this->state();
@@ -57,7 +65,7 @@ void BluedroidGattClient::loop() {
       ESP_LOGE(TAG, "gattc app register failed: app_id=%d code=%d", this->app_id, ret);
       this->mark_failed();
     }
-    // Do not wait for REG_EVT; connect() rejects until it lands.
+    // Do not wait for REG_EVT; a dropped event must not wedge the slot.
     this->set_idle_();
   } else if (st == ClientState::DISCONNECTING || this->disconnect_pending()) {
     // The one teardown safety net: a lost CLOSE_EVT, or a scheduled
@@ -70,8 +78,8 @@ void BluedroidGattClient::loop() {
       this->listener_->on_connection_state(false, 0, ESP_GATT_CONN_TIMEOUT);
     }
   } else {
-    // The loop stays on while a link exists (pre-started search flush); it
-    // settles only back at IDLE.
+    // The loop stays on while a link exists (stack-down watch, pre-started
+    // search flush); it settles only back at IDLE.
     this->deliver_pending_search_();
     if (this->state() == ClientState::IDLE) {
       this->disable_loop();
@@ -79,22 +87,6 @@ void BluedroidGattClient::loop() {
   }
 }
 
-// Stack down: no CLOSE_EVT will come. Settle a live link so the consumer
-// frees its slot, then register the app again on the next enable.
-void BluedroidGattClient::ble_before_disabled_event_handler() {
-  auto st = this->state();
-  if (st != ClientState::IDLE && st != ClientState::INIT) {
-    this->release_services();
-    this->set_idle_();
-    this->listener_->on_connection_state(false, 0, ble_device_base::GATT_ERR_NOT_CONNECTED);
-  }
-  // The interface belongs to the torn-down stack.
-  this->gattc_if_ = ESP_GATT_IF_NONE;
-  this->set_state(ClientState::INIT);
-  // An idle slot runs no loop; the INIT branch must run to register again.
-  this->enable_loop();
-}
-
 void BluedroidGattClient::dump_config() {
   ESP_LOGCONFIG(TAG, "Bluedroid GATT client %d", this->connection_index_);
   if (this->is_failed()) {
@@ -105,11 +97,6 @@ void BluedroidGattClient::dump_config() {
 // ---- contract ops ----
 
 int BluedroidGattClient::connect(uint64_t address, uint8_t addr_type) {
-  if (this->gattc_if_ == ESP_GATT_IF_NONE) {
-    // Bluedroid drops an open on an unknown interface without any event.
-    ESP_LOGW(TAG, "[%d] Connect rejected, GATT app not registered", this->connection_index_);
-    return ble_device_base::GATT_ERR_NOT_CONNECTED;
-  }
   // Only from idle: clobbering DISCONNECTING would open a new link the
   // stale CLOSE_EVT then tears down.
   if (this->state() != ClientState::IDLE) {

esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.h

@@ -56,7 +56,6 @@ class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public
   void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) override;
   void connect() override;
   void disconnect() override;
-  void ble_before_disabled_event_handler() override;
   bool wants_parsed_advertisements() override { return false; }
   void on_scan_end() override {}
   bool parse_device(const ble_device_base::ESPBTDevice &device) override { return false; }

esphome/components/bridge/__init__.py

@@ -0,0 +1,4 @@
+CODEOWNERS = ["@kbx81"]
+DOMAIN = "bridge"
+
+IS_PLATFORM_COMPONENT = True

esphome/components/cdc_acm_uart/__init__.py

@@ -0,0 +1 @@
+CODEOWNERS = ["@kbx81"]

esphome/components/cdc_acm_uart/bridge/__init__.py

@@ -0,0 +1,114 @@
+from esphome import pins
+import esphome.codegen as cg
+from esphome.components import esp32, uart, usb_cdc_acm
+from esphome.components.bridge import DOMAIN as BRIDGE_DOMAIN
+from esphome.components.esp32 import VARIANT_ESP32P4, VARIANT_ESP32S2, VARIANT_ESP32S3
+import esphome.config_validation as cv
+from esphome.const import CONF_DEBUG, CONF_ID, CONF_UART_ID
+import esphome.final_validate as fv
+from esphome.types import ConfigType
+
+CODEOWNERS = ["@kbx81"]
+DEPENDENCIES = ["tinyusb", "uart", "usb_cdc_acm"]
+
+CONF_DTR_PIN = "dtr_pin"
+CONF_RTS_PIN = "rts_pin"
+CONF_USB_CDC_ACM_ID = "usb_cdc_acm_id"
+
+cdc_acm_uart_ns = cg.esphome_ns.namespace("cdc_acm_uart")
+CDCACMUARTBridge = cdc_acm_uart_ns.class_("CDCACMUARTBridge", cg.Component)
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(CDCACMUARTBridge),
+            cv.Required(CONF_UART_ID): cv.use_id(uart.IDFUARTComponent),
+            cv.Required(CONF_USB_CDC_ACM_ID): cv.use_id(usb_cdc_acm.USBCDCACMInstance),
+            cv.Optional(CONF_DTR_PIN): pins.gpio_output_pin_schema,
+            cv.Optional(CONF_RTS_PIN): pins.gpio_output_pin_schema,
+        }
+    ).extend(cv.COMPONENT_SCHEMA),
+    # Narrower than usb_cdc_acm's variant list on purpose: S31/H4 untested on
+    # hardware; extend once verified.
+    esp32.only_on_variant(
+        supported=[VARIANT_ESP32P4, VARIANT_ESP32S2, VARIANT_ESP32S3],
+    ),
+)
+
+
+def _subtree_references_uart(node: object, uart_id: str) -> bool:
+    """Return True if any dict in the subtree has a uart_id entry naming this bus."""
+    if isinstance(node, dict):
+        return any(
+            (key == CONF_UART_ID and str(value) == uart_id)
+            or _subtree_references_uart(value, uart_id)
+            for key, value in node.items()
+        )
+    if isinstance(node, list):
+        return any(_subtree_references_uart(item, uart_id) for item in node)
+    return False
+
+
+def _reject_debug(uart_conf: ConfigType) -> ConfigType:
+    # The worker tasks use the IDF driver directly, so the uart debugger never sees
+    # bridge traffic and its dummy_receiver would drain RX bytes on the main loop.
+    if CONF_DEBUG in uart_conf:
+        raise cv.Invalid(
+            "A bridged UART cannot use 'debug'; the bridge bypasses the UART "
+            "component's read/write path.",
+            [CONF_DEBUG],
+        )
+    return uart_conf
+
+
+def _final_validate(config: ConfigType) -> ConfigType:
+    full_config = fv.full_config.get()
+    # Bridges of any platform must own their interfaces exclusively; shared ring
+    # buffers and overwritten callbacks would corrupt both streams silently. The
+    # seen-set is keyed on the bridge domain so future platforms share it.
+    # Other components bind either interface through the same uart_id key (the CDC
+    # instance is itself a uart::UARTComponent) and would race the worker tasks.
+    # Bare `id:` references (a uart.write action) cannot be distinguished; not caught.
+    data = full_config.data.setdefault(BRIDGE_DOMAIN, {})
+    for conf_key, label in (
+        (CONF_UART_ID, "UART"),
+        (CONF_USB_CDC_ACM_ID, "USB CDC-ACM interface"),
+    ):
+        owned_id = str(config[conf_key])
+        used = data.setdefault(conf_key, set())
+        if owned_id in used:
+            raise cv.Invalid(
+                f"The {label} '{owned_id}' is already bridged by another 'bridge' "
+                f"instance; each bridge requires its own {label}.",
+                [conf_key],
+            )
+        used.add(owned_id)
+        for domain, domain_conf in full_config.items():
+            if domain == BRIDGE_DOMAIN:
+                continue
+            if _subtree_references_uart(domain_conf, owned_id):
+                raise cv.Invalid(
+                    f"The {label} '{owned_id}' is also used by '{domain}'; a bridge "
+                    f"requires exclusive use of its {label}.",
+                    [conf_key],
+                )
+
+    fv.id_declaration_match_schema(_reject_debug)(config[CONF_UART_ID])
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
+async def to_code(config: ConfigType) -> None:
+    uart_component = await cg.get_variable(config[CONF_UART_ID])
+    usb_cdc = await cg.get_variable(config[CONF_USB_CDC_ACM_ID])
+    var = cg.new_Pvariable(config[CONF_ID], uart_component, usb_cdc)
+    await cg.register_component(var, config)
+
+    if dtr_pin_config := config.get(CONF_DTR_PIN):
+        dtr_pin = await cg.gpio_pin_expression(dtr_pin_config)
+        cg.add(var.set_dtr_pin(dtr_pin))
+    if rts_pin_config := config.get(CONF_RTS_PIN):
+        rts_pin = await cg.gpio_pin_expression(rts_pin_config)
+        cg.add(var.set_rts_pin(rts_pin))

esphome/components/cdc_acm_uart/bridge/cdc_acm_uart_bridge.cpp

@@ -0,0 +1,468 @@
+#if defined(USE_ESP32_VARIANT_ESP32P4) || defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+#include "cdc_acm_uart_bridge.h"
+#include "esphome/core/application.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+#include <algorithm>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/ringbuf.h"
+#include "driver/uart.h"
+#include "soc/soc_caps.h"
+
+namespace esphome::cdc_acm_uart {
+
+static const char *const TAG = "cdc_acm_uart";
+
+static constexpr size_t UART_TASK_STACK_SIZE = 4096;
+static constexpr size_t RINGBUF_RETRY_CHUNK_SIZE = 64;
+static constexpr uint32_t LOG_THROTTLE_MS = 1000;
+static constexpr uint32_t UART_RELOAD_SETTLE_MS = 20;
+// Above the default priority but below the USB/Wi-Fi system tasks.
+static constexpr UBaseType_t TASK_PRIORITY = 4;
+
+static bool should_log_now(uint32_t *last_ms, uint32_t interval_ms) {
+  uint32_t now = millis();
+  if ((now - *last_ms) >= interval_ms) {
+    *last_ms = now;
+    return true;
+  }
+  return false;
+}
+
+static bool ringbuf_send_with_retry(RingbufHandle_t ringbuf, const uint8_t *data, size_t len, uint32_t *log_ms) {
+  if (len == 0) {
+    return true;
+  }
+
+  if (xRingbufferSend(ringbuf, data, len, pdMS_TO_TICKS(1)) == pdTRUE) {
+    return true;
+  }
+
+  size_t offset = 0;
+  while (offset < len) {
+    size_t chunk = std::min(RINGBUF_RETRY_CHUNK_SIZE, len - offset);
+    if (xRingbufferSend(ringbuf, data + offset, chunk, pdMS_TO_TICKS(1)) != pdTRUE) {
+      if (should_log_now(log_ms, LOG_THROTTLE_MS)) {
+        ESP_LOGW(TAG, "USB TX buffer full; some data is lost");
+      }
+      return false;
+    }
+    offset += chunk;
+  }
+  return true;
+}
+
+void CDCACMUARTBridge::setup() {
+  // Line state starts deasserted (no host yet); active-low DTR#/RTS# wiring is
+  // handled by configuring the pins inverted, so deasserted idles HIGH.
+  if (this->dtr_pin_ != nullptr) {
+    this->dtr_pin_->setup();
+    this->dtr_pin_->digital_write(false);
+  }
+
+  if (this->rts_pin_ != nullptr) {
+    this->rts_pin_->setup();
+    this->rts_pin_->digital_write(false);
+  }
+
+  // A failed UART never assigned its port number, so the worker tasks would run
+  // against an indeterminate port.
+  if (this->uart_parent_->is_failed()) {
+    ESP_LOGE(TAG, "UART parent failed; aborting");
+    this->mark_failed();
+    return;
+  }
+
+  this->configured_baud_rate_ = this->uart_parent_->get_baud_rate();
+  this->configured_parity_ = this->uart_parent_->get_parity();
+  this->configured_stop_bits_ = this->uart_parent_->get_stop_bits();
+  this->configured_data_bits_ = this->uart_parent_->get_data_bits();
+
+  // usb_cdc_acm sets up first (priority IO > HARDWARE). Any interface failing marks
+  // the hub failed, and a failed hub no longer runs loop(), so line coding and line
+  // state events would never reach this bridge even if its own interface is healthy.
+  if (this->usb_cdc_parent_->get_parent()->is_failed()) {
+    ESP_LOGE(TAG, "USB CDC ACM failed; aborting");
+    this->mark_failed();
+    return;
+  }
+
+  // Per-instance task names (keyed on the CDC interface number) keep task dumps
+  // unambiguous with multiple bridges.
+  char tx_task_name[] = "cdc_uart_tx_0";
+  char rx_task_name[] = "cdc_uart_rx_0";
+  const char itf_char = format_hex_char(this->usb_cdc_parent_->get_itf());
+  tx_task_name[sizeof(tx_task_name) - 2] = itf_char;
+  rx_task_name[sizeof(rx_task_name) - 2] = itf_char;
+
+  xTaskCreate(uart_tx_task_fn, tx_task_name, UART_TASK_STACK_SIZE, this, TASK_PRIORITY, &this->uart_tx_task_handle_);
+  if (this->uart_tx_task_handle_ == nullptr) {
+    ESP_LOGE(TAG, "Failed to create UART TX task");
+    this->mark_failed();
+    return;
+  }
+
+  xTaskCreate(uart_rx_task_fn, rx_task_name, UART_TASK_STACK_SIZE, this, TASK_PRIORITY, &this->uart_rx_task_handle_);
+  if (this->uart_rx_task_handle_ == nullptr) {
+    ESP_LOGE(TAG, "Failed to create UART RX task");
+    vTaskDelete(this->uart_tx_task_handle_);
+    this->uart_tx_task_handle_ = nullptr;
+    this->mark_failed();
+    return;
+  }
+
+  // Only register callbacks once both tasks exist, so a failed setup never drives
+  // DTR/RTS from a dead bridge.
+  this->usb_cdc_parent_->set_line_state_callback([this](bool dtr, bool rts) { this->set_line_state(dtr, rts); });
+  this->usb_cdc_parent_->set_line_coding_callback([this](uint32_t, uint8_t, uint8_t, uint8_t) {
+    this->host_coding_seen_ = true;
+    // Another component owns the UART's framing while paused; resume() re-syncs.
+    if (this->paused_ == 0) {
+      this->set_line_coding();
+    }
+  });
+
+  // Release the workers only now: until here a failed setup may still delete the TX
+  // task, which is safe only while it is parked and owns nothing in the driver.
+  xTaskNotifyGive(this->uart_tx_task_handle_);
+  xTaskNotifyGive(this->uart_rx_task_handle_);
+
+  // loop() only services line-coding reloads; stay off the main loop until one is
+  // scheduled.
+  this->disable_loop();
+}
+
+void CDCACMUARTBridge::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "CDC-ACM UART Bridge:\n"
+                "  UART Bus: %u\n"
+                "  USB CDC Interface: %u",
+                this->uart_parent_->get_hw_serial_number(), this->usb_cdc_parent_->get_itf());
+  LOG_PIN("  DTR Pin: ", this->dtr_pin_);
+  LOG_PIN("  RTS Pin: ", this->rts_pin_);
+}
+
+void CDCACMUARTBridge::on_shutdown() {
+  // The UART (BUS) shuts down after this component (HARDWARE) and deletes its driver,
+  // freeing the ring buffer and mutexes the worker tasks block on. Suspending the
+  // tasks unlinks them from those objects first.
+  if (this->uart_rx_task_handle_ != nullptr) {
+    vTaskSuspend(this->uart_rx_task_handle_);
+  }
+  if (this->uart_tx_task_handle_ != nullptr) {
+    vTaskSuspend(this->uart_tx_task_handle_);
+  }
+}
+
+void CDCACMUARTBridge::loop() {
+  switch (this->state_) {
+    case MainState::MAIN_STATE_RELOAD_PENDING:
+      if ((App.get_loop_component_start_time() - this->reload_requested_at_) < UART_RELOAD_SETTLE_MS) {
+        return;
+      }
+      // Deliberately not gated on tx_idle_(): a host that re-codes the line mid-stream
+      // wants the new framing now, and its own in-flight bytes are its concern.
+      // apply_settings_live() rewrites the framing registers without reinstalling the
+      // driver, so the worker tasks blocked inside it are undisturbed.
+      this->uart_parent_->apply_settings_live();
+      this->state_ = MainState::MAIN_STATE_RUNNING;
+      break;
+    case MainState::MAIN_STATE_PAUSING:
+    case MainState::MAIN_STATE_RESUMING:
+      // Let a host write that was in flight drain, FIFO included, before a reload
+      // flushes the FIFOs and truncates it.
+      if (!this->tx_idle_()) {
+        return;
+      }
+      if (this->state_ == MainState::MAIN_STATE_PAUSING) {
+        this->restore_configured_framing_();
+        this->state_ = MainState::MAIN_STATE_PAUSED;
+      } else {
+        this->finish_resume_();
+      }
+      break;
+    default:
+      break;
+  }
+  this->disable_loop();
+}
+
+void CDCACMUARTBridge::set_line_coding() {
+  if (!this->sync_host_framing_()) {
+    return;
+  }
+  // Coalesce rapid line-coding updates from the host.
+  this->reload_requested_at_ = App.get_loop_component_start_time();
+  this->state_ = MainState::MAIN_STATE_RELOAD_PENDING;
+  // Main-loop context (via USBCDCACMInstance::process_events_).
+  this->enable_loop();
+}
+
+bool CDCACMUARTBridge::sync_host_framing_() {
+  // usb_cdc_acm has already translated the wire coding onto the CDC instance (main
+  // loop); mirror it here so the framing translation has a single source of truth.
+  bool changed = false;
+
+  // Reject 0 (the CDC B0/hang-up encoding; older IDF revisions divide by the rate)
+  // and rates above the SoC ceiling. Anything in between is the driver's call,
+  // matching what a YAML-configured UART accepts.
+  const uint32_t baud = this->usb_cdc_parent_->get_baud_rate();
+  if (baud == 0 || baud > SOC_UART_BITRATE_MAX) {
+    ESP_LOGW(TAG, "Ignoring unsupported baud rate %" PRIu32 " from host; keeping %" PRIu32, baud,
+             this->uart_parent_->get_baud_rate());
+  } else if (this->uart_parent_->get_baud_rate() != baud) {
+    this->uart_parent_->set_baud_rate(baud);
+    changed = true;
+  }
+
+  const uint8_t stop_bits = this->usb_cdc_parent_->get_stop_bits();
+  if (this->uart_parent_->get_stop_bits() != stop_bits) {
+    this->uart_parent_->set_stop_bits(stop_bits);
+    changed = true;
+  }
+
+  const auto parity = this->usb_cdc_parent_->get_parity();
+  if (this->uart_parent_->get_parity() != parity) {
+    this->uart_parent_->set_parity(parity);
+    changed = true;
+  }
+
+  // USB CDC permits data-bit counts the UART cannot represent (up to 16).
+  const uint8_t data_bits = this->usb_cdc_parent_->get_data_bits();
+  if (data_bits < 5 || data_bits > 8) {
+    ESP_LOGW(TAG, "Ignoring unsupported data bits %u from host; keeping %u", data_bits,
+             this->uart_parent_->get_data_bits());
+  } else if (this->uart_parent_->get_data_bits() != data_bits) {
+    this->uart_parent_->set_data_bits(data_bits);
+    changed = true;
+  }
+
+  if (changed) {
+    ESP_LOGV(TAG, "Line coding: baud=%" PRIu32 ", data_bits=%u, stop_bits=%u, parity=%u",
+             this->uart_parent_->get_baud_rate(), this->uart_parent_->get_data_bits(),
+             this->uart_parent_->get_stop_bits(), static_cast<uint8_t>(this->uart_parent_->get_parity()));
+  }
+  return changed;
+}
+
+void CDCACMUARTBridge::pause() {
+  if (this->state_ == MainState::MAIN_STATE_PAUSING || this->state_ == MainState::MAIN_STATE_PAUSED) {
+    return;
+  }
+  this->paused_ = 1;
+  // A null RX task means setup() has not completed (or failed): nothing to stop, and
+  // the framing snapshot does not exist yet. Should setup() run later, the RX task
+  // starts parked.
+  if (this->uart_rx_task_handle_ == nullptr) {
+    this->state_ = MainState::MAIN_STATE_PAUSED;
+    return;
+  }
+  // Drops a coalesced host reload or a pending resume; loop() restores the framing
+  // once any host write in flight has drained.
+  this->state_ = MainState::MAIN_STATE_PAUSING;
+  this->enable_loop();
+}
+
+void CDCACMUARTBridge::resume() {
+  if (this->state_ != MainState::MAIN_STATE_PAUSING && this->state_ != MainState::MAIN_STATE_PAUSED) {
+    return;
+  }
+  if (this->uart_rx_task_handle_ == nullptr) {
+    this->paused_ = 0;
+    this->state_ = MainState::MAIN_STATE_RUNNING;
+    return;
+  }
+  // A restore still waiting on the TX side is moot: the host's framing is kept.
+  if (!this->tx_idle_()) {
+    this->state_ = MainState::MAIN_STATE_RESUMING;
+    this->enable_loop();
+    return;
+  }
+  this->finish_resume_();
+  this->disable_loop();
+}
+
+void CDCACMUARTBridge::finish_resume_() {
+  // Take the bus back at a known framing before either task runs again: the host's
+  // if it ever sent one, else the YAML framing (the other owner may have changed it).
+  if (this->host_coding_seen_) {
+    this->sync_host_framing_();
+    this->uart_parent_->apply_settings_live();
+  } else {
+    this->restore_configured_framing_();
+  }
+  this->paused_ = 0;
+  this->state_ = MainState::MAIN_STATE_RUNNING;
+  this->drive_line_state_();
+  xTaskNotifyGive(this->uart_rx_task_handle_);
+}
+
+bool CDCACMUARTBridge::tx_idle_() {
+  const auto uart_num = static_cast<uart_port_t>(this->uart_parent_->get_hw_serial_number());
+  return this->tx_busy_ == 0 && uart_wait_tx_done(uart_num, 0) == ESP_OK;
+}
+
+void CDCACMUARTBridge::restore_configured_framing_() {
+  // Always applied: the cached settings can lead the hardware by a pending reload,
+  // so they are no proof of what is live.
+  this->uart_parent_->set_baud_rate(this->configured_baud_rate_);
+  this->uart_parent_->set_parity(this->configured_parity_);
+  this->uart_parent_->set_stop_bits(this->configured_stop_bits_);
+  this->uart_parent_->set_data_bits(this->configured_data_bits_);
+  this->uart_parent_->apply_settings_live();
+}
+
+void CDCACMUARTBridge::set_line_state(bool dtr, bool rts) {
+  ESP_LOGV(TAG, "Line state: DTR=%d, RTS=%d", dtr, rts);
+  this->host_dtr_ = dtr;
+  this->host_rts_ = rts;
+  // Frozen while paused: a host opening the port must not reset a peer that another
+  // component is talking to.
+  if (this->paused_ == 0) {
+    this->drive_line_state_();
+  }
+}
+
+void CDCACMUARTBridge::drive_line_state_() {
+  if (this->dtr_pin_ != nullptr) {
+    this->dtr_pin_->digital_write(this->host_dtr_);
+  }
+  if (this->rts_pin_ != nullptr) {
+    this->rts_pin_->digital_write(this->host_rts_);
+  }
+}
+
+void CDCACMUARTBridge::uart_rx_task_fn(void *arg) {
+  auto *bridge = static_cast<CDCACMUARTBridge *>(arg);
+  bridge->uart_rx_task_();
+}
+
+void CDCACMUARTBridge::uart_tx_task_fn(void *arg) {
+  auto *bridge = static_cast<CDCACMUARTBridge *>(arg);
+  bridge->uart_tx_task_();
+}
+
+void CDCACMUARTBridge::uart_rx_task_() {
+  TaskHandle_t usb_tx_handle = this->usb_cdc_parent_->get_tx_task_handle();
+  RingbufHandle_t usb_tx_ringbuf = this->usb_cdc_parent_->get_tx_ringbuf();
+  uart_port_t uart_num = static_cast<uart_port_t>(this->uart_parent_->get_hw_serial_number());
+  // Back-dated so a problem within the first LOG_THROTTLE_MS of uptime still logs.
+  uint32_t tx_full_log_ms = millis() - LOG_THROTTLE_MS;
+  uint32_t err_log_ms = millis() - LOG_THROTTLE_MS;
+
+  uint8_t *data = this->uart_rx_buffer_.data();
+  const size_t buf_size = this->uart_rx_buffer_.size();
+
+  // Released by setup() once both tasks exist.
+  ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+
+  while (true) {
+    if (this->paused_ != 0) {
+      // Parked until resume() notifies; nothing is read, so the other owner sees
+      // every byte.
+      this->rx_parked_ = 1;
+      ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+      this->rx_parked_ = 0;
+      continue;
+    }
+
+    // Block until at least one byte is available from UART.
+    int total_rx_size = uart_read_bytes(uart_num, data, 1, pdMS_TO_TICKS(UART_RX_WAIT_MS));
+    if (total_rx_size < 0) {
+      if (should_log_now(&err_log_ms, LOG_THROTTLE_MS)) {
+        ESP_LOGE(TAG, "UART read failed: %d", total_rx_size);
+      }
+      vTaskDelay(pdMS_TO_TICKS(10));
+      continue;
+    }
+    if (total_rx_size == 0) {
+      continue;
+    }
+    // pause() landed during the read: don't forward a byte to a host that is gone.
+    if (this->paused_ != 0) {
+      continue;
+    }
+
+    // Drain the currently buffered burst without waiting.
+    while (true) {
+      int rx_data_size = uart_read_bytes(uart_num, data + total_rx_size, buf_size - total_rx_size, 0);
+      if (rx_data_size < 0) {
+        if (should_log_now(&err_log_ms, LOG_THROTTLE_MS)) {
+          ESP_LOGE(TAG, "UART read failed: %d", rx_data_size);
+        }
+        break;
+      }
+      if (rx_data_size == 0) {
+        break;
+      }
+      ESP_LOGV(TAG, "UART RX: %d bytes", rx_data_size);
+      total_rx_size += rx_data_size;
+      if (total_rx_size >= (int) buf_size) {
+        break;
+      }
+    }
+
+    ringbuf_send_with_retry(usb_tx_ringbuf, data, total_rx_size, &tx_full_log_ms);
+
+    ESP_LOGV(TAG, "UART RX: waking up USB TX task");
+    xTaskNotifyGive(usb_tx_handle);
+  }
+}
+
+void CDCACMUARTBridge::uart_tx_task_() {
+  RingbufHandle_t usb_rx_ringbuf = this->usb_cdc_parent_->get_rx_ringbuf();
+  uart_port_t uart_num = static_cast<uart_port_t>(this->uart_parent_->get_hw_serial_number());
+  uint8_t *data_to_uart = this->uart_tx_buffer_.data();
+  const size_t buf_size = this->uart_tx_buffer_.size();
+  size_t rx_size;
+  // Back-dated so a problem within the first LOG_THROTTLE_MS of uptime still logs.
+  uint32_t err_log_ms = millis() - LOG_THROTTLE_MS;
+  uint32_t drop_log_ms = millis() - LOG_THROTTLE_MS;
+
+  // Released by setup() once both tasks exist.
+  ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
+
+  while (true) {
+    ESP_LOGV(TAG, "Waiting for data to send to UART");
+    esp_err_t ret = usb_cdc_acm::ringbuf_read_bytes(usb_rx_ringbuf, data_to_uart, buf_size, &rx_size, portMAX_DELAY);
+
+    if (ret != ESP_OK) {
+      if (should_log_now(&err_log_ms, LOG_THROTTLE_MS)) {
+        ESP_LOGE(TAG, "USB RX RingBuf read failed");
+      }
+      // Yield: this task runs above the main loop, so a persistent failure must not
+      // become a tight loop.
+      vTaskDelay(pdMS_TO_TICKS(10));
+      continue;
+    }
+
+    // Another component owns the UART; host bytes must not interleave with its traffic.
+    // tx_busy_ goes up before the check so is_paused() cannot miss a write in flight.
+    this->tx_busy_ = 1;
+    if (this->paused_ != 0) {
+      this->tx_busy_ = 0;
+      if (should_log_now(&drop_log_ms, LOG_THROTTLE_MS)) {
+        ESP_LOGW(TAG, "Paused; dropping %zu bytes from host", rx_size);
+      }
+      continue;
+    }
+
+    ESP_LOGV(TAG, "Sending %zu bytes to UART", rx_size);
+    // Signed: uart_write_bytes() returns -1 on error.
+    int xfer_size = uart_write_bytes(uart_num, data_to_uart, rx_size);
+    this->tx_busy_ = 0;
+
+    if (xfer_size < 0) {
+      if (should_log_now(&err_log_ms, LOG_THROTTLE_MS)) {
+        ESP_LOGE(TAG, "UART write failed: %d", xfer_size);
+      }
+    } else if (static_cast<size_t>(xfer_size) != rx_size) {
+      ESP_LOGW(TAG, "UART write incomplete (%d/%zu bytes)", xfer_size, rx_size);
+    }
+  }
+}
+
+}  // namespace esphome::cdc_acm_uart
+#endif

esphome/components/cdc_acm_uart/bridge/cdc_acm_uart_bridge.h

@@ -0,0 +1,117 @@
+#pragma once
+#if defined(USE_ESP32_VARIANT_ESP32P4) || defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
+#include "esphome/components/uart/uart_component_esp_idf.h"
+#include "esphome/components/usb_cdc_acm/usb_cdc_acm.h"
+#include "esphome/core/component.h"
+
+#include <array>
+#include <atomic>
+#include "sdkconfig.h"
+
+namespace esphome::cdc_acm_uart {
+
+class CDCACMUARTBridge final : public Component {
+ public:
+  // Upper bound on the RX task's blocking read, so pause() takes effect without
+  // aborting the read. Arriving bytes still unblock it immediately.
+  static constexpr uint32_t UART_RX_WAIT_MS = 250;
+
+  CDCACMUARTBridge(uart::IDFUARTComponent *uart_parent, usb_cdc_acm::USBCDCACMInstance *usb_cdc_parent)
+      : uart_parent_(uart_parent), usb_cdc_parent_(usb_cdc_parent) {}
+
+  void setup() override;
+  void loop() override;
+  void dump_config() override;
+  void on_shutdown() override;
+  float get_setup_priority() const override { return setup_priority::HARDWARE; }
+
+  void set_dtr_pin(GPIOPin *dtr_pin) { this->dtr_pin_ = dtr_pin; }
+  void set_rts_pin(GPIOPin *rts_pin) { this->rts_pin_ = rts_pin; }
+
+  void set_line_coding();
+  void set_line_state(bool dtr, bool rts);
+
+  /**
+   * Stop forwarding in both directions and hand the UART back to its configured
+   * framing, so another component may use the bus. Main-loop only. The RX task parks
+   * within UART_RX_WAIT_MS (a byte it was already reading is discarded). A host write
+   * already in flight is allowed to drain first, which at low baud rates can take
+   * seconds; the framing is restored only after that, so poll is_paused() rather than
+   * waiting a fixed interval. Host bytes not yet written to the UART are discarded.
+   * The DTR/RTS outputs hold their state while paused and follow the host again on
+   * resume().
+   */
+  void pause();
+  /**
+   * Re-apply the host's line coding and line state, then resume forwarding. Main-loop
+   * only. Deferred until any host write still draining has finished, so the reload
+   * never truncates it.
+   */
+  void resume();
+  /// True once both worker tasks are off the bus and the configured framing is restored.
+  /// With no RX task (setup() failed or has not run) there is nothing to wait for.
+  bool is_paused() const {
+    return this->state_ == MainState::MAIN_STATE_PAUSED &&
+           (this->uart_rx_task_handle_ == nullptr || this->rx_parked_ != 0);
+  }
+
+ protected:
+  static void uart_rx_task_fn(void *arg);
+  static void uart_tx_task_fn(void *arg);
+  void uart_rx_task_();
+  void uart_tx_task_();
+  void restore_configured_framing_();
+  // True when the TX task has no write in flight and the UART TX FIFO has drained.
+  bool tx_idle_();
+  void finish_resume_();
+  void drive_line_state_();
+  // Copy the host's line coding onto the UART settings; true if anything changed.
+  bool sync_host_framing_();
+
+  TaskHandle_t uart_rx_task_handle_{nullptr};
+  TaskHandle_t uart_tx_task_handle_{nullptr};
+
+  GPIOPin *dtr_pin_{nullptr};
+  GPIOPin *rts_pin_{nullptr};
+
+  uint32_t reload_requested_at_{0};
+
+  // Worker staging, each sized to the CDC ring buffer it feeds or drains.
+  std::array<uint8_t, CONFIG_TINYUSB_CDC_TX_BUFSIZE> uart_rx_buffer_{};
+  std::array<uint8_t, CONFIG_TINYUSB_CDC_RX_BUFSIZE> uart_tx_buffer_{};
+
+  uart::IDFUARTComponent *uart_parent_;
+  usb_cdc_acm::USBCDCACMInstance *usb_cdc_parent_;
+
+  // YAML framing, captured at setup; the host's line coding overwrites the UART's
+  // settings, so pause() needs the original to restore.
+  uint32_t configured_baud_rate_{0};
+  uart::UARTParityOptions configured_parity_{uart::UART_CONFIG_PARITY_NONE};
+  uint8_t configured_stop_bits_{0};
+  uint8_t configured_data_bits_{0};
+
+  // Written on the main loop, read by both worker tasks. uint8_t rather than bool:
+  // GCC on Xtensa emits an out-of-line call for atomic<bool>.
+  std::atomic<uint8_t> paused_{0};
+  // Raised by the RX task while parked and by the TX task around each UART write, so
+  // the pause hand-off knows when the bus is actually free.
+  std::atomic<uint8_t> rx_parked_{0};
+  std::atomic<uint8_t> tx_busy_{0};
+  // Main-loop state; paused_ mirrors it for the worker tasks.
+  enum class MainState : uint8_t {
+    MAIN_STATE_RUNNING,
+    MAIN_STATE_RELOAD_PENDING,  // host line coding debounced, forwarding continues
+    MAIN_STATE_PAUSING,         // waiting for TX idle to restore the configured framing
+    MAIN_STATE_PAUSED,
+    MAIN_STATE_RESUMING,  // resume() requested while a host write still drains
+  };
+  MainState state_{MainState::MAIN_STATE_RUNNING};
+  // Host line state, recorded even while paused so resume() can re-drive the pins.
+  bool host_dtr_{false};
+  bool host_rts_{false};
+  // True once the host has sent any line coding; resume() then re-syncs to it.
+  bool host_coding_seen_{false};
+};
+
+}  // namespace esphome::cdc_acm_uart
+#endif

esphome/components/const/__init__.py

@@ -30,6 +30,7 @@ CONF_KEYS = "keys"
 CONF_LABEL = "label"
 CONF_LIBRETINY = "libretiny"
 CONF_LOOP = "loop"
+CONF_MANUFACTURER = "manufacturer"
 CONF_NOX_INDEX = "nox_index"
 CONF_ON_PACKET = "on_packet"
 CONF_ON_RECEIVE = "on_receive"

esphome/components/coolix/climate.py

@@ -1,5 +1,5 @@
 import esphome.codegen as cg
-from esphome.components import climate_ir
+from esphome.components import climate_ir, remote_base
 from esphome.types import ConfigType
 
 AUTO_LOAD = ["climate_ir"]
@@ -12,4 +12,5 @@ CONFIG_SCHEMA = climate_ir.climate_ir_with_receiver_schema(CoolixClimate)
 
 
 async def to_code(config: ConfigType) -> None:
+    remote_base.request_protocol("coolix")  # used from C++
     await climate_ir.new_climate_ir(config)

esphome/components/debug/sensor.py

@@ -23,11 +23,7 @@ from esphome.const import (
 )
 from esphome.types import ConfigType
 
-from . import (  # noqa: F401  pylint: disable=unused-import
-    CONF_DEBUG_ID,
-    FILTER_SOURCE_FILES,
-    DebugComponent,
-)
+from . import CONF_DEBUG_ID, FILTER_SOURCE_FILES, DebugComponent  # noqa: F401  pylint: disable=unused-import
 
 DEPENDENCIES = ["debug"]
 

esphome/components/debug/text_sensor.py

@@ -9,11 +9,7 @@ from esphome.const import (
 )
 from esphome.types import ConfigType
 
-from . import (  # noqa: F401  pylint: disable=unused-import
-    CONF_DEBUG_ID,
-    FILTER_SOURCE_FILES,
-    DebugComponent,
-)
+from . import CONF_DEBUG_ID, FILTER_SOURCE_FILES, DebugComponent  # noqa: F401  pylint: disable=unused-import
 
 DEPENDENCIES = ["debug"]
 

esphome/components/deep_sleep/deep_sleep_bk72xx.cpp

@@ -44,7 +44,7 @@ bool DeepSleepComponent::prepare_to_sleep_() {
           this->status_set_warning();
           ESP_LOGV(TAG, "Waiting for pin to switch state to enter deep sleep...");
         }
-        this->next_enter_deep_sleep_ = true;
+        this->defer_sleep_();
         return false;
       }
     }

esphome/components/deep_sleep/deep_sleep_component.cpp

@@ -17,6 +17,7 @@ void DeepSleepComponent::setup() {
 
 void DeepSleepComponent::schedule_sleep_() {
   this->next_enter_deep_sleep_ = false;
+  this->disable_loop();
   const optional<uint32_t> run_duration = get_run_duration_();
   if (run_duration.has_value()) {
     ESP_LOGI(TAG, "Scheduling in %" PRIu32 " ms", *run_duration);
@@ -45,7 +46,7 @@ void DeepSleepComponent::loop() {
 
 void DeepSleepComponent::begin_sleep(bool manual) {
   if (this->prevent_ && !manual) {
-    this->next_enter_deep_sleep_ = true;
+    this->defer_sleep_();
     return;
   }
 

esphome/components/deep_sleep/deep_sleep_component.h

@@ -190,6 +190,11 @@ class DeepSleepComponent final : public Component {
   void schedule_sleep_();
   bool should_teardown_();
 
+  void defer_sleep_() {
+    this->next_enter_deep_sleep_ = true;
+    this->enable_loop();
+  }
+
 #ifdef USE_BK72XX
   bool pin_prevents_sleep_(WakeUpPinItem &pin_item) const;
   bool get_real_pin_state_(InternalGPIOPin &pin) const { return (pin.digital_read() ^ pin.is_inverted()); }

esphome/components/deep_sleep/deep_sleep_esp32.cpp

@@ -100,7 +100,7 @@ bool DeepSleepComponent::prepare_to_sleep_() {
       this->status_set_warning();
       ESP_LOGW(TAG, "Waiting for wakeup pin state change");
     }
-    this->next_enter_deep_sleep_ = true;
+    this->defer_sleep_();
     return false;
   }
   return true;

esphome/components/es7210/es7210.cpp

@@ -153,13 +153,14 @@ bool ES7210::configure_mic_gain_() {
   ES7210_ERROR_CHECK(this->es7210_update_reg_bit_(ES7210_MIC2_GAIN_REG44, 0x0f, regv));
 
   // Configure mic 3
-  ES7210_ERROR_CHECK(this->es7210_update_reg_bit_(ES7210_CLOCK_OFF_REG01, 0x0b, 0x00));
+  // MIC3 uses the ADC3/4 and MIC3/4 clock domains (bits 2 and 4), not the MIC1/2 domains.
+  ES7210_ERROR_CHECK(this->es7210_update_reg_bit_(ES7210_CLOCK_OFF_REG01, 0x15, 0x00));
   ES7210_ERROR_CHECK(this->write_byte(ES7210_MIC34_POWER_REG4C, 0x00));
   ES7210_ERROR_CHECK(this->es7210_update_reg_bit_(ES7210_MIC3_GAIN_REG45, 0x10, 0x10));
   ES7210_ERROR_CHECK(this->es7210_update_reg_bit_(ES7210_MIC3_GAIN_REG45, 0x0f, regv));
 
   // Configure mic 4
-  ES7210_ERROR_CHECK(this->es7210_update_reg_bit_(ES7210_CLOCK_OFF_REG01, 0x0b, 0x00));
+  ES7210_ERROR_CHECK(this->es7210_update_reg_bit_(ES7210_CLOCK_OFF_REG01, 0x15, 0x00));
   ES7210_ERROR_CHECK(this->write_byte(ES7210_MIC34_POWER_REG4C, 0x00));
   ES7210_ERROR_CHECK(this->es7210_update_reg_bit_(ES7210_MIC4_GAIN_REG46, 0x10, 0x10));
   ES7210_ERROR_CHECK(this->es7210_update_reg_bit_(ES7210_MIC4_GAIN_REG46, 0x0f, regv));

esphome/components/esp32/__init__.py

@@ -189,6 +189,13 @@ PSRAM_XIP_VARIANTS = {
     VARIANT_ESP32S31,
 }
 
+# Variants whose ROM exports a full-format vsnprintf but no vasprintf
+# (esp32c6.rom.newlib-normal.ld). There, the newlib printf engine is only
+# linked because esp_http_client calls vasprintf; see vasprintf_stubs.cpp.
+# The other variants either export both (classic ESP32, nano-format only) or
+# neither, so the engine is already in the image and the wrap saves nothing.
+ROM_VSNPRINTF_WITHOUT_VASPRINTF_VARIANTS = {VARIANT_ESP32C6}
+
 # NVS encryption (HMAC peripheral scheme) is only available on variants that
 # expose the HMAC peripheral (SOC_HMAC_SUPPORTED in soc_caps.h). The original
 # ESP32 and ESP32-C2 do not have it. New variants with an HMAC peripheral
@@ -1732,6 +1739,8 @@ CONF_DISABLE_USB_SERIAL_JTAG_SECONDARY = "disable_usb_serial_jtag_secondary"
 CONF_DISABLE_DEV_NULL_VFS = "disable_dev_null_vfs"
 CONF_DISABLE_MBEDTLS_PEER_CERT = "disable_mbedtls_peer_cert"
 CONF_DISABLE_MBEDTLS_PKCS7 = "disable_mbedtls_pkcs7"
+CONF_DISABLE_MBEDTLS_TLS_SERVER = "disable_mbedtls_tls_server"
+CONF_DISABLE_MBEDTLS_TLS_EXTRAS = "disable_mbedtls_tls_extras"
 CONF_DISABLE_REGI2C_IN_IRAM = "disable_regi2c_in_iram"
 CONF_DISABLE_FATFS = "disable_fatfs"
 CONF_ADC_ONESHOT_IN_IRAM = "adc_oneshot_in_iram"
@@ -1746,6 +1755,8 @@ KEY_VFS_TERMIOS_REQUIRED = "vfs_termios_required"
 KEY_USB_SERIAL_JTAG_SECONDARY_REQUIRED = "usb_serial_jtag_secondary_required"
 KEY_MBEDTLS_PEER_CERT_REQUIRED = "mbedtls_peer_cert_required"
 KEY_MBEDTLS_PKCS7_REQUIRED = "mbedtls_pkcs7_required"
+KEY_MBEDTLS_TLS_SERVER_REQUIRED = "mbedtls_tls_server_required"
+KEY_MBEDTLS_TLS_EXTRAS_REQUIRED = "mbedtls_tls_extras_required"
 KEY_FATFS_REQUIRED = "fatfs_required"
 KEY_MBEDTLS_SHA512_REQUIRED = "mbedtls_sha512_required"
 KEY_ADC_ONESHOT_IRAM_REQUIRED = "adc_oneshot_iram_required"
@@ -1830,6 +1841,30 @@ def require_mbedtls_pkcs7() -> None:
     CORE.data[KEY_ESP32][KEY_MBEDTLS_PKCS7_REQUIRED] = True
 
 
+def require_mbedtls_tls_server() -> None:
+    """Mark that the mbedTLS server-side TLS/DTLS handshake is required.
+
+    Call this from components that accept TLS connections (OpenThread's DTLS
+    commissioner does). This prevents CONFIG_MBEDTLS_TLS_CLIENT_ONLY from
+    being selected.
+    """
+    CORE.data[KEY_ESP32][KEY_MBEDTLS_TLS_SERVER_REQUIRED] = True
+
+
+def require_mbedtls_tls_extras(options: Iterable[str] | None = None) -> None:
+    """Mark TLS features disabled by ``disable_mbedtls_tls_extras`` as required.
+
+    ``options`` names the entries of ``MBEDTLS_TLS_EXTRA_OPTIONS`` to keep;
+    omit it to keep all of them. Call this from components that need AES-CCM,
+    deterministic ECDSA signing, static RSA/ECDH key exchange, TLS
+    renegotiation or session tickets, or that run a TLS client against
+    servers ESPHome cannot vet (wpa_supplicant's EAP client). A user-supplied
+    sdkconfig_options value is never overridden either.
+    """
+    required = CORE.data[KEY_ESP32].setdefault(KEY_MBEDTLS_TLS_EXTRAS_REQUIRED, set())
+    required.update(MBEDTLS_TLS_EXTRA_OPTIONS if options is None else options)
+
+
 def require_mbedtls_sha512() -> None:
     """Mark that mbedTLS SHA-384/SHA-512 support is required by a component.
 
@@ -1987,6 +2022,8 @@ FRAMEWORK_SCHEMA = cv.Schema(
                 cv.Optional(CONF_DISABLE_DEV_NULL_VFS, default=True): cv.boolean,
                 cv.Optional(CONF_DISABLE_MBEDTLS_PEER_CERT, default=True): cv.boolean,
                 cv.Optional(CONF_DISABLE_MBEDTLS_PKCS7, default=True): cv.boolean,
+                cv.Optional(CONF_DISABLE_MBEDTLS_TLS_SERVER, default=True): cv.boolean,
+                cv.Optional(CONF_DISABLE_MBEDTLS_TLS_EXTRAS, default=True): cv.boolean,
                 cv.Optional(CONF_DISABLE_REGI2C_IN_IRAM, default=True): cv.boolean,
                 cv.Optional(CONF_ADC_ONESHOT_IN_IRAM, default=False): cv.boolean,
                 cv.Optional(CONF_DISABLE_FATFS, default=True): cv.boolean,
@@ -2302,6 +2339,69 @@ async def _reconcile_certificate_bundle_sdkconfig() -> None:
         set_idf_sdkconfig_default("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN", True)
 
 
+# TLS features an HTTPS/MQTT client talking to a modern server never
+# negotiates. Static RSA and static ECDH key exchange have no forward secrecy
+# and are gone in TLS 1.3, renegotiation is deprecated, esp-tls never enables
+# session tickets, AES-CCM ciphersuites are not offered by web servers, and
+# deterministic ECDSA only matters when signing with a private key. Together
+# they cost ~10 KB of flash whenever TLS is linked (http_request, mqtt).
+# wpa_supplicant's EAP client is a second TLS client that talks to RADIUS
+# servers ESPHome cannot vet, and a failed EAP handshake leaves the device
+# off the network, so the wifi component re-enables all of these when eap is
+# configured.
+# The EC public key parsing extras stay enabled: they decide whether a peer
+# certificate with a compressed point or explicit curve parameters parses,
+# which no component can know ahead of time.
+MBEDTLS_TLS_EXTRA_OPTIONS = (
+    "CONFIG_MBEDTLS_KEY_EXCHANGE_RSA",
+    "CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA",
+    "CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_RSA",
+    "CONFIG_MBEDTLS_SSL_RENEGOTIATION",
+    "CONFIG_MBEDTLS_CLIENT_SSL_SESSION_TICKETS",
+    "CONFIG_MBEDTLS_SERVER_SSL_SESSION_TICKETS",
+    "CONFIG_MBEDTLS_CCM_C",
+    "CONFIG_MBEDTLS_ECDSA_DETERMINISTIC",
+)
+
+# Members of the mbedTLS "TLS Protocol Role" Kconfig choice. Setting one
+# member is only valid when the user has not already chosen another.
+MBEDTLS_TLS_ROLE_OPTIONS = (
+    "CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT",
+    "CONFIG_MBEDTLS_TLS_SERVER_ONLY",
+    "CONFIG_MBEDTLS_TLS_CLIENT_ONLY",
+    "CONFIG_MBEDTLS_TLS_DISABLED",
+)
+
+
+@coroutine_with_priority(CoroPriority.FINAL)
+async def _reconcile_mbedtls_tls_sdkconfig(
+    disable_tls_server: bool, disable_tls_extras: bool
+) -> None:
+    """Trim mbedTLS to what a TLS client needs unless a component asked otherwise.
+
+    Runs at FINAL priority so every require_mbedtls_tls_server() and
+    require_mbedtls_tls_extras() call has happened. Only the server-side
+    handshake (~7 KB) is a separate option; nothing in ESPHome accepts TLS
+    connections, but OpenThread's DTLS commissioner does. A user-supplied
+    sdkconfig_options value always wins; for the TLS role choice, any member
+    the user set leaves the whole choice alone so the pair cannot conflict.
+    """
+    data = CORE.data[KEY_ESP32]
+    sdkconfig = data[KEY_SDKCONFIG_OPTIONS]
+    if (
+        disable_tls_server
+        and not data.get(KEY_MBEDTLS_TLS_SERVER_REQUIRED, False)
+        and not any(option in sdkconfig for option in MBEDTLS_TLS_ROLE_OPTIONS)
+    ):
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_TLS_CLIENT_ONLY", True)
+        add_idf_sdkconfig_option("CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT", False)
+    if disable_tls_extras:
+        required = data.get(KEY_MBEDTLS_TLS_EXTRAS_REQUIRED, set())
+        for option in MBEDTLS_TLS_EXTRA_OPTIONS:
+            if option not in required:
+                set_idf_sdkconfig_default(option, False)
+
+
 @coroutine_with_priority(CoroPriority.FINAL)
 async def _reconcile_network_sdkconfig() -> None:
     """Reconcile WiFi/Ethernet/Bluetooth/coexistence sdkconfig flags.
@@ -2566,6 +2666,17 @@ async def to_code(config):
         else:
             for symbol in ("vprintf", "printf", "fprintf", "vfprintf"):
                 cg.add_build_flag(f"-Wl,--wrap={symbol}")
+            # esp_http_client calls vasprintf, which on the ESP32-C6 is the only
+            # reference to newlib's full printf engine (~20 KB: _svfprintf_r,
+            # _dtoa_r and their helpers); every other caller resolves to the
+            # ROM. See vasprintf_stubs.cpp. The --undefined flag is needed
+            # because libsrc.a is scanned before the IDF libraries that
+            # reference the symbol, so the stub would otherwise never be pulled
+            # from the archive.
+            if variant in ROM_VSNPRINTF_WITHOUT_VASPRINTF_VARIANTS:
+                cg.add_define("USE_ESP32_VASPRINTF_STUB")
+                cg.add_build_flag("-Wl,--wrap=vasprintf")
+                cg.add_build_flag("-Wl,--undefined=__wrap_vasprintf")
     else:
         cg.add_build_flag("-DUSE_ARDUINO")
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ARDUINO")
@@ -2991,6 +3102,13 @@ async def to_code(config):
     # FINAL priority: runs after every require_certificate_bundle() call
     CORE.add_job(_reconcile_certificate_bundle_sdkconfig)
 
+    # FINAL priority: runs after every require_mbedtls_tls_*() call
+    CORE.add_job(
+        _reconcile_mbedtls_tls_sdkconfig,
+        advanced[CONF_DISABLE_MBEDTLS_TLS_SERVER],
+        advanced[CONF_DISABLE_MBEDTLS_TLS_EXTRAS],
+    )
+
     # FINAL: require_*() calls can come from to_code at or below this priority, so an
     # inline read would be iteration-order-dependent; reconcile once after every job ran.
     CORE.add_job(

esphome/components/esp32/const.py

@@ -3,18 +3,11 @@ import esphome.codegen as cg
 # Re-exported for the many esp32-side users; defined in esphome.const
 # and esphome.espidf so the upload/logs fast path can use them without
 # importing this package.
-from esphome.const import (  # noqa: F401  # pylint: disable=unused-import
-    KEY_ESP32,
-    KEY_FLASH_SIZE,
-    KEY_IDF_VERSION,
-    KEY_VARIANT,
-)
+from esphome.const import KEY_ESP32, KEY_FLASH_SIZE, KEY_IDF_VERSION, KEY_VARIANT  # noqa: F401  # pylint: disable=unused-import
 
 # Back compat for external components only; in-tree callers import it
 # from esphome.espidf directly.
-from esphome.espidf import (  # noqa: F401  # pylint: disable=unused-import
-    variant_to_idf_target,
-)
+from esphome.espidf import variant_to_idf_target  # noqa: F401  # pylint: disable=unused-import
 
 KEY_BOARD = "board"
 KEY_SDKCONFIG_OPTIONS = "sdkconfig_options"

esphome/components/esp32/vasprintf_stubs.cpp

@@ -0,0 +1,53 @@
+/*
+ * Linker wrap stub for vasprintf() on variants whose ROM exports a
+ * full-format vsnprintf() but no vasprintf() (ESP32-C6, newlib only).
+ *
+ * On those chips every snprintf/vsnprintf call in the image resolves to
+ * the ROM, so the newlib printf engine (_svfprintf_r, _dtoa_r and their
+ * helpers, ~20 KB) is not linked at all until something references a
+ * printf-family function the ROM lacks. esp_http_client does exactly that
+ * through vasprintf() in its header and auth helpers, so adding
+ * http_request to a build costs the whole engine on top of the HTTP and
+ * TLS code itself.
+ *
+ * This stub reimplements vasprintf() on top of the ROM vsnprintf(), which
+ * keeps the engine out of the image. It is only compiled in when codegen
+ * defines USE_ESP32_VASPRINTF_STUB, which is gated on the variant's ROM
+ * linker script and on the same newlib condition as printf_stubs.cpp.
+ */
+
+#include "esphome/core/defines.h"
+
+#if defined(USE_ESP_IDF) && defined(USE_ESP32_VASPRINTF_STUB)
+
+#include <cstdarg>
+#include <cstdio>
+#include <cstdlib>
+
+namespace esphome::esp32 {}
+
+// NOLINTBEGIN(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
+extern "C" {
+
+int __wrap_vasprintf(char **strp, const char *fmt, va_list ap) {
+  va_list ap_copy;
+  va_copy(ap_copy, ap);
+  int len = vsnprintf(nullptr, 0, fmt, ap_copy);
+  va_end(ap_copy);
+  if (len < 0) {
+    return len;
+  }
+  // vasprintf's contract is a malloc'd buffer the caller releases with free()
+  char *buf = static_cast<char *>(malloc(static_cast<size_t>(len) + 1));  // NOLINT(cppcoreguidelines-no-malloc)
+  if (buf == nullptr) {
+    return -1;
+  }
+  vsnprintf(buf, static_cast<size_t>(len) + 1, fmt, ap);
+  *strp = buf;
+  return len;
+}
+
+}  // extern "C"
+// NOLINTEND(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
+
+#endif  // USE_ESP_IDF && USE_ESP32_VASPRINTF_STUB

esphome/components/esp32_ble/ble.cpp

@@ -83,23 +83,18 @@ void ESP32BLE::setup() {
   }
 }
 
-// Queue the transition for loop(). A pending transition the other way is
-// cancelled instead, since nothing was torn down or brought up yet; any other
-// state is already there or on its way.
-void ESP32BLE::request_state_(bool enable) {
-  if (enable) {
-    if (this->state_ == BLE_COMPONENT_STATE_DISABLED) {
-      this->state_ = BLE_COMPONENT_STATE_ENABLE;
-    } else if (this->state_ == BLE_COMPONENT_STATE_DISABLE) {
-      this->state_ = BLE_COMPONENT_STATE_ACTIVE;
-    }
-  } else {
-    if (this->state_ == BLE_COMPONENT_STATE_ACTIVE) {
-      this->state_ = BLE_COMPONENT_STATE_DISABLE;
-    } else if (this->state_ == BLE_COMPONENT_STATE_ENABLE) {
-      this->state_ = BLE_COMPONENT_STATE_DISABLED;
-    }
-  }
+void ESP32BLE::enable() {
+  if (this->state_ != BLE_COMPONENT_STATE_DISABLED)
+    return;
+
+  this->state_ = BLE_COMPONENT_STATE_ENABLE;
+}
+
+void ESP32BLE::disable() {
+  if (this->state_ == BLE_COMPONENT_STATE_DISABLED)
+    return;
+
+  this->state_ = BLE_COMPONENT_STATE_DISABLE;
 }
 
 #ifdef USE_ESP32_BLE_ADVERTISING
@@ -585,11 +580,7 @@ void ESP32BLE::loop_handle_state_transition_not_active_() {
       this->mark_failed();
       return;
     }
-    this->drain_ble_events_();
-    // A status callback may have asked for BLE back; the stack is down now, so
-    // that request becomes a bring-up.
-    this->state_ =
-        this->state_ == BLE_COMPONENT_STATE_ACTIVE ? BLE_COMPONENT_STATE_ENABLE : BLE_COMPONENT_STATE_DISABLED;
+    this->state_ = BLE_COMPONENT_STATE_DISABLED;
   } else if (this->state_ == BLE_COMPONENT_STATE_ENABLE) {
     ESP_LOGD(TAG, "Enabling");
     this->state_ = BLE_COMPONENT_STATE_OFF;

esphome/components/esp32_ble/ble.h

@@ -102,8 +102,8 @@ class ESP32BLE final : public Component {
   }
   uint32_t get_advertising_cycle_time() const { return this->advertising_cycle_time_; }
 
-  void enable() { this->request_state_(true); }
-  void disable() { this->request_state_(false); }
+  void enable();
+  void disable();
   ESPHOME_ALWAYS_INLINE bool is_active() { return this->state_ == BLE_COMPONENT_STATE_ACTIVE; }
   void setup() override;
   void loop() override;
@@ -176,15 +176,6 @@ class ESP32BLE final : public Component {
 
   bool ble_setup_();
   bool ble_dismantle_();
-  void request_state_(bool enable);
-  // Drop what the old stack queued; the next stack reuses the same interface ids.
-  void drain_ble_events_() {
-    BLEEvent *ble_event;
-    while ((ble_event = this->ble_events_.pop()) != nullptr) {
-      this->ble_event_pool_.release(ble_event);
-    }
-    this->ble_events_.get_and_reset_dropped_count();
-  }
   bool ble_pre_setup_();
 #ifdef USE_ESP32_BLE_ADVERTISING
   void advertising_init_();

esphome/components/esp32_ble_client/ble_client_base.cpp

@@ -42,7 +42,7 @@ void BLEClientBase::set_state(espbt::ClientState st) {
 
 void BLEClientBase::loop() {
   if (!esp32_ble::global_ble->is_active()) {
-    // ble_before_disabled_event_handler() resets the client.
+    this->set_state(espbt::ClientState::INIT);
     return;
   }
   if (this->state() == espbt::ClientState::INIT) {
@@ -72,21 +72,6 @@ void BLEClientBase::loop() {
 
 float BLEClientBase::get_setup_priority() const { return setup_priority::AFTER_BLUETOOTH; }
 
-void BLEClientBase::ble_before_disabled_event_handler() {
-  auto st = this->state();
-  if (st != espbt::ClientState::IDLE && st != espbt::ClientState::INIT) {
-    // No CLOSE_EVT will come: free the services and settle the link.
-    this->release_services();
-    this->set_idle_();
-    this->on_disconnect_complete(ESP_GATT_CONN_TERMINATE_LOCAL_HOST);
-  }
-  // The interface belongs to the torn-down stack.
-  this->gattc_if_ = ESP_GATT_IF_NONE;
-  this->set_state(espbt::ClientState::INIT);
-  // An idle client runs no loop; the INIT branch must run to register again.
-  this->enable_loop();
-}
-
 void BLEClientBase::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "  Address: %s\n"
@@ -108,10 +93,6 @@ bool BLEClientBase::parse_device(const espbt::ESPBTDevice &device) {
     return false;
   if (this->state() != espbt::ClientState::IDLE)
     return false;
-  // Not registered on this stack yet; promoting now would stop the scan for a
-  // connect that connect() rejects anyway.
-  if (this->gattc_if_ == ESP_GATT_IF_NONE)
-    return false;
 
   this->log_event_("Found device");
   if (ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG)
@@ -136,15 +117,6 @@ void BLEClientBase::connect() {
              this->connection_index_, this->address_str_);
     return;
   }
-  if (this->gattc_if_ == ESP_GATT_IF_NONE) {
-    // Bluedroid drops an open on an unknown interface without any event.
-    this->log_warning_("Connect rejected, GATT app not registered");
-    // INIT stays so loop() still registers; only a promoted client goes back.
-    if (this->state() == espbt::ClientState::DISCOVERED) {
-      this->set_state(espbt::ClientState::IDLE);
-    }
-    return;
-  }
   ESP_LOGI(TAG, "[%d] [%s] 0x%02x Connecting", this->connection_index_, this->address_str_, this->remote_addr_type_);
   this->paired_ = false;
   // A registration whose event never arrived must not block this connection's release.
@@ -227,10 +199,7 @@ void BLEClientBase::release_services() {
 #ifndef CONFIG_BT_GATTC_CACHE_NVS_FLASH
   // Only the cache clean makes the stack's database unsafe to walk.
   this->services_released_ = true;
-  // A stack on its way down frees its own cache.
-  if (esp32_ble::global_ble->is_active()) {
-    esp_ble_gattc_cache_clean(this->remote_bda_);
-  }
+  esp_ble_gattc_cache_clean(this->remote_bda_);
 #endif
 }
 

esphome/components/esp32_ble_client/ble_client_base.h

@@ -41,7 +41,6 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
   void connect() override;
   esp_err_t pair();
   void disconnect() override;
-  void ble_before_disabled_event_handler() override;
   void unconditional_disconnect();
   void release_services();
 
@@ -115,7 +114,7 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
 #endif
 
   // Group 3: 4-byte types
-  int gattc_if_{ESP_GATT_IF_NONE};
+  int gattc_if_;
   esp_gatt_status_t status_{ESP_GATT_OK};
 
   // Group 4: Arrays
@@ -140,7 +139,7 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
   uint8_t pending_notify_regs_{0};
   bool auto_connect_{false};
   bool paired_{false};
-  // Set by release_services() on RAM-cache builds; the stack's GATT database must not be walked after it
+  // Set only when release_services() cleans the stack's GATT cache, which no API may then walk
   bool services_released_{false};
   // 8 bytes used, no padding
 
@@ -156,11 +155,10 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
   void log_connection_params_(const char *param_type);
   void handle_connection_result_(esp_err_t ret);
   /// Hook called once a connection has been fully torn down (after release_services() and
-  /// set_idle_()): CLOSE_EVT, the DISCONNECTING safety timeout, or the BLE stack going down.
+  /// set_idle_()), from both the CLOSE_EVT handler and the DISCONNECTING safety timeout.
   /// Subclasses with extra per-connection accounting (e.g. bluetooth_proxy slot state)
-  /// override this to release that state. `reason` is the controller reason code,
-  /// ESP_GATT_CONN_TIMEOUT for the safety timeout, or ESP_GATT_CONN_TERMINATE_LOCAL_HOST
-  /// for the stack going down.
+  /// override this to release that state. `reason` is the controller reason code, or
+  /// ESP_GATT_CONN_TIMEOUT for the safety-timeout path.
   virtual void on_disconnect_complete(esp_err_t reason) {}
   /// Transition to IDLE and reset conn_id — call when the connection is fully dead.
   void set_idle_() {

esphome/components/esp32_ble_server/__init__.py

@@ -3,6 +3,7 @@ import encodings
 from esphome import automation
 import esphome.codegen as cg
 from esphome.components import esp32_ble
+from esphome.components.const import CONF_MANUFACTURER
 from esphome.components.esp32 import request_bluetooth
 from esphome.components.esp32_ble import BTLoggers, bt_uuid
 import esphome.config_validation as cv
@@ -41,7 +42,6 @@ CONF_DESCRIPTORS = "descriptors"
 CONF_ENDIANNESS = "endianness"
 CONF_FIRMWARE_VERSION = "firmware_version"
 CONF_INDICATE = "indicate"
-CONF_MANUFACTURER = "manufacturer"
 CONF_MANUFACTURER_DATA = "manufacturer_data"
 CONF_MAX_CLIENTS = "max_clients"
 CONF_ON_WRITE = "on_write"

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -62,11 +62,6 @@ void ESP32BLETracker::on_ota_global_state(ota::OTAState state, float progress, u
     for (auto *client : this->clients_) {
       client->disconnect();
     }
-#ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
-    // The OTA transfer blocks the main loop, so the revert in loop() cannot run. No
-    // active-connection gate here: every client was just told to disconnect.
-    this->update_coex_preference_(false);
-#endif
 #endif
   } else if ((state == ota::OTA_ERROR || state == ota::OTA_ABORT) && this->scan_continuous_before_ota_) {
     this->scan_continuous_before_ota_ = false;
@@ -79,11 +74,11 @@ void ESP32BLETracker::on_ota_global_state(ota::OTAState state, float progress, u
 
 void ESP32BLETracker::loop() {
   if (!this->parent_->is_active()) {
+    this->ble_was_disabled_ = true;
     return;
-  }
-  if (this->ble_was_disabled_) {
+  } else if (this->ble_was_disabled_) {
     this->ble_was_disabled_ = false;
-    // First start after boot or after the stack came back.
+    // If the BLE stack was disabled, we need to start the scan again.
     if (this->scan_continuous_) {
       this->start_scan();
     }
@@ -223,27 +218,7 @@ void ESP32BLETracker::stop_scan() {
   this->stop_scan_();
 }
 
-void ESP32BLETracker::ble_before_disabled_event_handler() {
-  // Tell the controller to stop; a scan still starting has nothing to stop yet.
-  if (this->scanner_state_ == ScannerState::RUNNING || this->scanner_state_ == ScannerState::FAILED) {
-    this->stop_scan_();
-  }
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
-  for (auto *client : this->clients_) {
-    client->ble_before_disabled_event_handler();
-  }
-  this->skip_next_scan_end_ = false;
-#endif
-  // The stop above never completes (stack torn down, events dropped); settle
-  // here so start_scan_() sees IDLE once the stack is back.
-  if (this->scanner_state_ != ScannerState::IDLE) {
-    this->cleanup_scan_state_(true);
-  }
-  // A failure latched by the old stack must not be handled against the next.
-  this->scan_start_failed_ = ESP_BT_STATUS_SUCCESS;
-  this->scan_set_param_failed_ = ESP_BT_STATUS_SUCCESS;
-  this->ble_was_disabled_ = true;
-}
+void ESP32BLETracker::ble_before_disabled_event_handler() { this->stop_scan_(); }
 
 bool ESP32BLETracker::stop_scan_() {
   if (this->scanner_state_ != ScannerState::RUNNING && this->scanner_state_ != ScannerState::FAILED) {

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -113,9 +113,6 @@ class ESPBTClient : public ESPBTDeviceListener {
   virtual void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) = 0;
   virtual void connect() = 0;
   virtual void disconnect() = 0;
-  /// Called right before the BLE stack is dismantled. Nothing in flight will
-  /// complete, and the GATT app must register again once the stack is back.
-  virtual void ble_before_disabled_event_handler() {}
   bool disconnect_pending() const { return this->want_disconnect_; }
   void cancel_pending_disconnect() { this->want_disconnect_ = false; }
 

esphome/components/esp8266_pwm/esp8266_pwm.h

@@ -29,7 +29,7 @@ class ESP8266PWM final : public output::FloatOutput, public Component {
   void write_state(float state) override;
 
   InternalGPIOPin *pin_;
-  float frequency_{1000.0};  // Keep in sync with DEFAULT_FREQUENCY in output.py
+  float frequency_{1000.0};
   /// Cache last output level for dynamic frequency updating
   float last_output_{0.0};
 };

esphome/components/esp8266_pwm/output.py

@@ -22,10 +22,6 @@ ESP8266PWM = esp8266_pwm_ns.class_("ESP8266PWM", output.FloatOutput, cg.Componen
 SetFrequencyAction = esp8266_pwm_ns.class_("SetFrequencyAction", automation.Action)
 validate_frequency = cv.All(cv.frequency, cv.float_range(min=1.0e-6))
 
-# Schema default that also matches the C++ initializer in esp8266_pwm.h; codegen
-# skips the setter when the config equals it.
-DEFAULT_FREQUENCY = 1000.0
-
 CONFIG_SCHEMA = cv.All(
     output.FLOAT_OUTPUT_SCHEMA.extend(
         {
@@ -33,7 +29,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Required(CONF_PIN): cv.All(
                 pins.internal_gpio_output_pin_schema, valid_pwm_pin
             ),
-            cv.Optional(CONF_FREQUENCY, default=DEFAULT_FREQUENCY): validate_frequency,
+            cv.Optional(CONF_FREQUENCY, default="1kHz"): validate_frequency,
         }
     ).extend(cv.COMPONENT_SCHEMA),
     cv.require_framework_version(
@@ -52,9 +48,7 @@ async def to_code(config: ConfigType) -> None:
     pin = await cg.gpio_pin_expression(config[CONF_PIN])
     cg.add(var.set_pin(pin))
 
-    # Skip the setter when the config matches the C++ initializer (DEFAULT_FREQUENCY).
-    if (frequency := config[CONF_FREQUENCY]) != DEFAULT_FREQUENCY:
-        cg.add(var.set_frequency(frequency))
+    cg.add(var.set_frequency(config[CONF_FREQUENCY]))
 
 
 @automation.register_action(

esphome/components/esphome/ota/ota_esphome.cpp

@@ -842,14 +842,7 @@ bool ESPHomeOTAComponent::handle_auth_send_() {
     const size_t hex_size = hasher.get_size() * 2;
     const size_t nonce_len = hasher.get_size() / 4;
     const size_t auth_buf_size = 1 + 3 * hex_size;
-    // Internal RAM first: 128 of these bytes go straight into the hardware SHA engine
-    this->auth_buf_ =
-        RAMAllocator<uint8_t>(RAMAllocator<uint8_t>::PREFER_INTERNAL).make_unique_array_for_overwrite(auth_buf_size);
-    if (!this->auth_buf_) {
-      this->log_auth_warning_(LOG_STR("No memory"));
-      this->send_error_and_cleanup_(ota::OTA_RESPONSE_ERROR_UNKNOWN);
-      return false;
-    }
+    this->auth_buf_ = std::make_unique<uint8_t[]>(auth_buf_size);
     this->auth_buf_pos_ = 0;
 
     char *buf = reinterpret_cast<char *>(this->auth_buf_.get() + 1);

esphome/components/esphome/ota/ota_esphome.h

@@ -145,13 +145,13 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
 
 #ifdef USE_OTA_PASSWORD
   std::string password_;
-  RAMUniquePtr<uint8_t[]> auth_buf_;
+  std::unique_ptr<uint8_t[]> auth_buf_;
 #endif  // USE_OTA_PASSWORD
 #ifdef USE_OTA_ENCRYPTION
 #ifndef USE_OTA_ENCRYPTION_FROM_API
   noise::NoiseContext noise_ctx_;
 #endif
-  RAMUniquePtr<NoiseSession> noise_;
+  std::unique_ptr<NoiseSession> noise_;
 #endif  // USE_OTA_ENCRYPTION
 
   socket::ListenSocket *server_{nullptr};

esphome/components/esphome/ota/ota_esphome_noise.cpp

@@ -7,6 +7,7 @@
 #include "esphome/core/log.h"
 
 #include <cstring>
+#include <new>
 
 #ifdef USE_ESP8266
 #include <pgmspace.h>
@@ -42,8 +43,9 @@ ESPHomeOTAComponent::NoiseSession::~NoiseSession() {
 bool ESPHomeOTAComponent::noise_start_session_(uint8_t server_feature_flags) {
   // A provisioned key cleared between the offer and here is not guarded: the
   // session runs on the zero key load_psk fills in and fails the client's MAC.
-  // Default placement, PSRAM first where present: the session only lives for one upload
-  this->noise_ = RAMAllocator<NoiseSession>().make_unique();
+  // Default-init: the frame buffer is written before it is read
+  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
+  this->noise_ = std::unique_ptr<NoiseSession>(new (std::nothrow) NoiseSession);
   static constexpr size_t PROLOGUE_ACK_LEN = 2;  // OTA_RESPONSE_OK + version
   static constexpr size_t PROLOGUE_CLIENT_FEATURES_LEN = 1;
   static constexpr size_t PROLOGUE_FEATURE_ACK_LEN = 2;  // OTA_RESPONSE_FEATURE_FLAGS + server flags

esphome/components/ethernet/__init__.py

@@ -420,9 +420,7 @@ def _validate(config: ConfigType) -> ConfigType:
 BASE_SCHEMA = cv.Schema(
     {
         cv.GenerateID(): cv.declare_id(EthernetComponent),
-        cv.Optional(
-            CONF_MANUAL_IP, visibility=cv.Visibility.ADVANCED
-        ): MANUAL_IP_SCHEMA,
+        cv.Optional(CONF_MANUAL_IP): MANUAL_IP_SCHEMA,
         cv.Optional(CONF_DOMAIN, default=".local"): cv.domain_name,
         cv.Optional(CONF_USE_ADDRESS): cv.string_strict,
         cv.Optional(CONF_MAC_ADDRESS): cv.mac_address,

esphome/components/ethernet/w5500_custom_spi.cpp

@@ -6,21 +6,17 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
 #include <cstring>
+#include <new>
 
 namespace esphome::ethernet {
 
 namespace {
 
-// Context returned by init() and handed back to read/write/deinit. There is one W5500 per device, so a
-// single static instance replaces a heap allocation that could fail. It is always clear when init() runs:
-// esp_eth_mac_new_w5500() calls deinit() on every failure after init() succeeded, and nothing else
-// uninstalls the driver
+// Per-device context returned by init() and handed back to read/write/deinit.
 struct W5500CustomSpiContext {
   spi_device_handle_t handle;
   SemaphoreHandle_t lock;
 };
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) - intentional mutable state
-W5500CustomSpiContext w5500_context{};
 
 // Transfers up to the ESP32 SPI hardware FIFO size (64 bytes) stay on the polling path; larger
 // transfers (the frame payloads) use the blocking, DMA-backed transmit.
@@ -29,20 +25,23 @@ constexpr uint32_t W5500_SPI_LOCK_TIMEOUT_MS = 50;
 
 void *w5500_custom_spi_init(const void *spi_config) {
   const auto *config = static_cast<const eth_w5500_config_t *>(spi_config);
-  auto *ctx = &w5500_context;
+  auto *ctx = new (std::nothrow) W5500CustomSpiContext{};
+  if (ctx == nullptr) {
+    return nullptr;
+  }
   // The W5500 SPI frame carries the 16-bit address in the command phase and the 8-bit control
   // byte in the address phase; mirror what the stock driver configures.
   spi_device_interface_config_t devcfg = *config->spi_devcfg;
   devcfg.command_bits = 16;
   devcfg.address_bits = 8;
   if (spi_bus_add_device(config->spi_host_id, &devcfg, &ctx->handle) != ESP_OK) {
-    ctx->handle = nullptr;
+    delete ctx;
     return nullptr;
   }
   ctx->lock = xSemaphoreCreateMutex();
   if (ctx->lock == nullptr) {
     spi_bus_remove_device(ctx->handle);
-    ctx->handle = nullptr;
+    delete ctx;
     return nullptr;
   }
   return ctx;
@@ -52,7 +51,7 @@ esp_err_t w5500_custom_spi_deinit(void *spi_ctx) {
   auto *ctx = static_cast<W5500CustomSpiContext *>(spi_ctx);
   spi_bus_remove_device(ctx->handle);
   vSemaphoreDelete(ctx->lock);
-  *ctx = {};
+  delete ctx;
   return ESP_OK;
 }
 

esphome/components/file/image.py

@@ -42,7 +42,7 @@ from esphome.const import (
     CONF_TYPE,
     CONF_URL,
 )
-from esphome.core import HexInt
+from esphome.core import CORE, HexInt
 from esphome.cpp_generator import MockObj, MockObjClass
 from esphome.external_files import RemoteFile
 from esphome.types import ConfigType
@@ -76,18 +76,16 @@ def compute_local_image_path(value: str | ConfigType) -> Path:
     return external_files.compute_local_file_path(DOMAIN, url)
 
 
-def local_path(value: Path | ConfigType) -> Path:
-    # cv.file_ has already resolved the path against the config dir.
-    return value[CONF_PATH] if isinstance(value, dict) else value
+def local_path(value: str | ConfigType) -> str:
+    value = value[CONF_PATH] if isinstance(value, dict) else value
+    return str(CORE.relative_config_path(value))
 
 
-def download_file(url: str, path: Path) -> Path:
+def download_file(url: str, path: Path) -> str:
     # The shared NETWORK_TIMEOUT applies; a per-caller timeout would be
     # silently ignored on a per-run memo hit anyway (memos key by path).
     external_files.download_content(url, path)
-    # Keep the Path: config-hash normalizes Path values under the data dir,
-    # which a str would dump verbatim and break the CLI/add-on comparison.
-    return path
+    return str(path)
 
 
 def _gh_svg_url_path(mdi_id: str, source: str) -> tuple[str, Path]:
@@ -95,13 +93,13 @@ def _gh_svg_url_path(mdi_id: str, source: str) -> tuple[str, Path]:
     return MDI_SOURCES[source] + mdi_id + ".svg", base_dir / f"{mdi_id}.svg"
 
 
-def download_gh_svg(value: str | ConfigType, source: str) -> Path:
+def download_gh_svg(value: str | ConfigType, source: str) -> str:
     mdi_id = value[CONF_ICON] if isinstance(value, dict) else value
     url, path = _gh_svg_url_path(mdi_id, source)
     return download_file(url, path)
 
 
-def download_image(value: str | ConfigType) -> Path:
+def download_image(value: str | ConfigType) -> str:
     value = value[CONF_URL] if isinstance(value, dict) else value
     return download_file(value, compute_local_image_path(value))
 
@@ -149,7 +147,7 @@ def _extract_entry_ref(entry: ConfigType) -> RemoteFile | None:
 PREFETCH_FILES = external_files.single_stage_prefetch(_extract_entry_ref)
 
 
-def validate_file_shorthand(value: Any) -> Path:
+def validate_file_shorthand(value: Any) -> str:
     value = cv.string_strict(value)
     if (remote := _parse_remote_shorthand(value)) is not None:
         return download_file(remote.url, remote.path)
@@ -167,7 +165,7 @@ LOCAL_SCHEMA = cv.All(
 
 
 def mdi_schema(source: str) -> cv.All:
-    def validate_mdi(value: ConfigType) -> Path:
+    def validate_mdi(value: ConfigType) -> str:
         return download_gh_svg(value, source)
 
     return cv.All(

esphome/components/gpio/switch/__init__.py

@@ -15,13 +15,9 @@ CONFIG_SCHEMA = (
     .extend(
         {
             cv.Required(CONF_PIN): pins.gpio_output_pin_schema,
+            cv.Optional(CONF_INTERLOCK): cv.ensure_list(cv.use_id(switch.Switch)),
             cv.Optional(
-                CONF_INTERLOCK, visibility=cv.Visibility.ADVANCED
-            ): cv.ensure_list(cv.use_id(switch.Switch)),
-            cv.Optional(
-                CONF_INTERLOCK_WAIT_TIME,
-                default="0ms",
-                visibility=cv.Visibility.ADVANCED,
+                CONF_INTERLOCK_WAIT_TIME, default="0ms"
             ): cv.positive_time_period_milliseconds,
         }
     )

esphome/components/http_request/ota/ota_http_request.h

@@ -23,6 +23,9 @@ enum OtaHttpRequestError : uint8_t {
 
 class OtaHttpRequestComponent final : public ota::OTAComponent, public Parented<HttpRequestComponent> {
  public:
+  // User provided, not "= default": `new(p) OtaHttpRequestComponent()` would zero-fill .bss that is already zero.
+  OtaHttpRequestComponent() {}
+
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
 

esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp

@@ -53,13 +53,6 @@ void I2SAudioSpeakerBase::dump_config() {
 void I2SAudioSpeakerBase::loop() {
   uint32_t event_group_bits = xEventGroupGetBits(this->event_group_);
 
-  // A stop that arrives while stopped cancels any start that has not been processed yet
-  constexpr uint32_t stop_bits = SpeakerEventGroupBits::COMMAND_STOP | SpeakerEventGroupBits::COMMAND_STOP_GRACEFULLY;
-  if ((event_group_bits & stop_bits) && (this->state_ == speaker::STATE_STOPPED)) {
-    xEventGroupClearBits(this->event_group_, stop_bits | SpeakerEventGroupBits::COMMAND_START);
-    event_group_bits &= ~(stop_bits | SpeakerEventGroupBits::COMMAND_START);
-  }
-
   if ((event_group_bits & SpeakerEventGroupBits::COMMAND_START) && (this->state_ == speaker::STATE_STOPPED)) {
     this->state_ = speaker::STATE_STARTING;
     xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::COMMAND_START);
@@ -246,6 +239,8 @@ void I2SAudioSpeakerBase::start() {
   if ((this->state_ == speaker::STATE_STARTING) || (this->state_ == speaker::STATE_RUNNING))
     return;
 
+  // Mark STARTING immediately to avoid transient STOPPED observations before loop() processes COMMAND_START.
+  this->state_ = speaker::STATE_STARTING;
   xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::COMMAND_START);
 }
 
@@ -254,10 +249,11 @@ void I2SAudioSpeakerBase::stop() { this->stop_(false); }
 void I2SAudioSpeakerBase::finish() { this->stop_(true); }
 
 void I2SAudioSpeakerBase::stop_(bool wait_on_empty) {
-  if (!this->is_ready() || this->is_failed())
+  if (this->is_failed())
+    return;
+  if (this->state_ == speaker::STATE_STOPPED)
     return;
 
-  // Always set the bit, even when stopped, so loop() can cancel a start that is still pending
   if (wait_on_empty) {
     xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::COMMAND_STOP_GRACEFULLY);
   } else {

esphome/components/infrared/infrared.cpp

@@ -59,11 +59,6 @@ void Infrared::setup() {
   // Set up traits based on configuration
   this->traits_.set_supports_transmitter(this->has_transmitter());
   this->traits_.set_supports_receiver(this->has_receiver());
-
-  // Register as listener for received IR data
-  if (this->receiver_ != nullptr) {
-    this->receiver_->register_listener(this);
-  }
 }
 
 void Infrared::dump_config() {

esphome/components/infrared/infrared.h

@@ -119,7 +119,8 @@ class Infrared : public Component, public EntityBase, public remote_base::Remote
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::AFTER_CONNECTION; }
 
-  /// Set the remote receiver component
+  /// Set the remote receiver component; the listener registration happens from codegen, see
+  /// remote_base.attach_receiver
   void set_receiver(remote_base::RemoteReceiverBase *receiver) { this->receiver_ = receiver; }
   /// Set the remote transmitter component
   void set_transmitter(remote_base::RemoteTransmitterBase *transmitter) { this->transmitter_ = transmitter; }

esphome/components/ir_rf_proxy/infrared.py

@@ -3,7 +3,12 @@
 from typing import Any
 
 import esphome.codegen as cg
-from esphome.components import infrared, remote_receiver, remote_transmitter
+from esphome.components import (
+    infrared,
+    remote_base,
+    remote_receiver,
+    remote_transmitter,
+)
 from esphome.components.const import CONF_RECEIVER_FREQUENCY
 import esphome.config_validation as cv
 from esphome.const import CONF_CARRIER_DUTY_PERCENT, CONF_FREQUENCY
@@ -82,8 +87,7 @@ async def to_code(config: dict[str, Any]) -> None:
 
     # Link receiver if specified
     if CONF_REMOTE_RECEIVER_ID in config:
-        receiver = await cg.get_variable(config[CONF_REMOTE_RECEIVER_ID])
-        cg.add(var.set_receiver(receiver))
+        await remote_base.attach_receiver(var, config, CONF_REMOTE_RECEIVER_ID)
 
     # Set receiver demodulation frequency if specified (metadata only, no hardware effect)
     if CONF_RECEIVER_FREQUENCY in config:

esphome/components/ir_rf_proxy/ir_rf_proxy.cpp

@@ -97,10 +97,6 @@ void RfProxy::setup() {
 
   // remote_transmitter/receiver always uses OOK (on-off keying)
   this->traits_.add_supported_modulation(radio_frequency::RadioFrequencyModulation::RADIO_FREQUENCY_MODULATION_OOK);
-
-  if (this->receiver_ != nullptr) {
-    this->receiver_->register_listener(this);
-  }
 }
 
 void RfProxy::dump_config() {

esphome/components/ir_rf_proxy/ir_rf_proxy.h

@@ -56,7 +56,8 @@ class RfProxy final : public radio_frequency::RadioFrequency {
 
   /// Set the remote transmitter component
   void set_transmitter(remote_base::RemoteTransmitterBase *transmitter) { this->transmitter_ = transmitter; }
-  /// Set the remote receiver component
+  /// Set the remote receiver component; the listener registration happens from codegen, see
+  /// remote_base.attach_receiver
   void set_receiver(remote_base::RemoteReceiverBase *receiver) { this->receiver_ = receiver; }
 
   /// Set the fixed carrier frequency in Hz (metadata: advertised via traits, does not tune hardware)

esphome/components/ir_rf_proxy/radio_frequency.py

@@ -1,7 +1,12 @@
 """Radio Frequency platform implementation using remote_base (remote_transmitter/receiver)."""
 
 import esphome.codegen as cg
-from esphome.components import radio_frequency, remote_receiver, remote_transmitter
+from esphome.components import (
+    radio_frequency,
+    remote_base,
+    remote_receiver,
+    remote_transmitter,
+)
 import esphome.config_validation as cv
 from esphome.const import CONF_CARRIER_DUTY_PERCENT, CONF_FREQUENCY
 import esphome.final_validate as fv
@@ -66,5 +71,4 @@ async def to_code(config: ConfigType) -> None:
         cg.add(var.set_transmitter(transmitter))
 
     if CONF_REMOTE_RECEIVER_ID in config:
-        receiver = await cg.get_variable(config[CONF_REMOTE_RECEIVER_ID])
-        cg.add(var.set_receiver(receiver))
+        await remote_base.attach_receiver(var, config, CONF_REMOTE_RECEIVER_ID)

esphome/components/light/__init__.py

@@ -340,10 +340,6 @@ RESTORE_MODES = {
     "RESTORE_AND_ON": LightRestoreMode.LIGHT_RESTORE_AND_ON,
 }
 
-# Schema default that also matches the C++ initializer in light_state.h; codegen
-# skips the setter when the config equals it.
-DEFAULT_FLASH_TRANSITION_LENGTH = "0s"
-
 LIGHT_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
@@ -391,7 +387,7 @@ BRIGHTNESS_ONLY_LIGHT_SCHEMA = LIGHT_SCHEMA.extend(
             CONF_DEFAULT_TRANSITION_LENGTH, default="1s"
         ): cv.positive_time_period_milliseconds,
         cv.Optional(
-            CONF_FLASH_TRANSITION_LENGTH, default=DEFAULT_FLASH_TRANSITION_LENGTH
+            CONF_FLASH_TRANSITION_LENGTH, default="0s"
         ): cv.positive_time_period_milliseconds,
         cv.Optional(CONF_EFFECTS): validate_effects(MONOCHROMATIC_EFFECTS),
     }
@@ -506,12 +502,9 @@ async def setup_light_core_(light_var, config, output_var):
         default_transition_length := config.get(CONF_DEFAULT_TRANSITION_LENGTH)
     ) is not None:
         cg.add(light_var.set_default_transition_length(default_transition_length))
-    # Skip the setter when the config matches the C++ initializer.
     if (
         flash_transition_length := config.get(CONF_FLASH_TRANSITION_LENGTH)
-    ) is not None and flash_transition_length != cv.time_period(
-        DEFAULT_FLASH_TRANSITION_LENGTH
-    ):
+    ) is not None:
         cg.add(light_var.set_flash_transition_length(flash_transition_length))
     if (gamma_correct := config.get(CONF_GAMMA_CORRECT)) is not None:
         cg.add(light_var.set_gamma_correct(gamma_correct))
@@ -521,8 +514,7 @@ async def setup_light_core_(light_var, config, output_var):
     effects = await cg.build_registry_list(
         EFFECTS_REGISTRY, config.get(CONF_EFFECTS, [])
     )
-    if effects:
-        cg.add(light_var.add_effects(effects))
+    cg.add(light_var.add_effects(effects))
 
     for conf in config.get(CONF_ON_TURN_ON, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], light_var)

esphome/components/light/light_state.h

@@ -356,7 +356,7 @@ class LightState : public EntityBase, public Component {
   /// Default transition length for all transitions in ms.
   uint32_t default_transition_length_{};
   /// Transition length to use for flash transitions.
-  uint32_t flash_transition_length_{};  // Keep in sync with DEFAULT_FLASH_TRANSITION_LENGTH in __init__.py
+  uint32_t flash_transition_length_{};
   /// Gamma correction factor for the light.
   float gamma_correct_{};
 #ifdef USE_LIGHT_GAMMA_LUT

esphome/components/logger/__init__.py

@@ -362,13 +362,12 @@ async def to_code(config: ConfigType) -> None:
     # pre_setup() switches on uart_ to decide which hardware to initialize
     # (e.g. UART0 vs USB_SERIAL_JTAG). Without this, uart_ is still the
     # default UART_SELECTION_UART0 and the wrong hardware gets initialized.
-    # uart_ is UART0 in C++ except on LibreTiny where it is DEFAULT; skip the
-    # setter when the config matches it.
-    cpp_default_uart = DEFAULT if CORE.is_libretiny else UART0
-    if (
-        hardware_uart := config.get(CONF_HARDWARE_UART)
-    ) is not None and hardware_uart != cpp_default_uart:
-        cg.add(log.set_uart_selection(HARDWARE_UART_TO_UART_SELECTION[hardware_uart]))
+    if CONF_HARDWARE_UART in config:
+        cg.add(
+            log.set_uart_selection(
+                HARDWARE_UART_TO_UART_SELECTION[config[CONF_HARDWARE_UART]]
+            )
+        )
     # pre_setup() sets global_logger and must run before any other code
     # that may call ESP_LOG* (e.g. setup_preferences contains ESP_LOGVV).
     cg.add(log.pre_setup())

esphome/components/logger/logger.h

@@ -352,10 +352,10 @@ class Logger final : public Component {
   // Group smaller types together at the end
   uint8_t current_level_{ESPHOME_LOG_LEVEL_VERY_VERBOSE};
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2) || defined(USE_ZEPHYR)
-  UARTSelection uart_{UART_SELECTION_UART0};  // Must match cpp_default_uart in __init__.py
+  UARTSelection uart_{UART_SELECTION_UART0};
 #endif
 #ifdef USE_LIBRETINY
-  UARTSelection uart_{UART_SELECTION_DEFAULT};  // Must match cpp_default_uart in __init__.py
+  UARTSelection uart_{UART_SELECTION_DEFAULT};
 #endif
 #if defined(USE_ESP32) || defined(USE_HOST) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
   bool main_task_recursion_guard_{false};

esphome/components/logger/logger_esp32.cpp

@@ -3,6 +3,7 @@
 
 #include "esphome/components/esp32/crash_handler.h"
 #include <esp_log.h>
+#include <esp_idf_version.h>
 
 #include <driver/uart.h>
 #include <soc/soc_caps.h>
@@ -16,8 +17,10 @@
 #include <driver/usb_serial_jtag_vfs.h>
 #endif
 #endif
-
-#include "esp_idf_version.h"
+#if defined(CONFIG_PM_ENABLE) && defined(CONFIG_FREERTOS_USE_TICKLESS_IDLE) && \
+    (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0))
+#include "esp_sleep.h"
+#endif
 #include "freertos/FreeRTOS.h"
 
 #include <fcntl.h>
@@ -87,6 +90,12 @@ void init_uart(uart_port_t uart_num, uint32_t baud_rate, int tx_buffer_size) {
   // ESP-IDF requires rx_buffer_size > UART_HW_FIFO_LEN (128 bytes).
   const int min_rx_buffer_size = UART_HW_FIFO_LEN(uart_num) + 1;
   uart_driver_install(uart_num, min_rx_buffer_size, tx_buffer_size, 0, nullptr, 0);
+#if defined(CONFIG_PM_ENABLE) && defined(CONFIG_FREERTOS_USE_TICKLESS_IDLE) && \
+    (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0))
+  // Always flush before going to light sleep. Could be disabled for devices
+  // without TOP_PD or if source_clk = UART_SCLK_RTC
+  esp_sleep_set_console_uart_handling_mode(ESP_SLEEP_ALWAYS_FLUSH_UART);
+#endif
 }
 
 void Logger::pre_setup() {

esphome/components/lvgl/automation.py

@@ -14,7 +14,7 @@ from esphome.const import (
     CONF_TIMEOUT,
 )
 from esphome.core import Lambda
-from esphome.cpp_generator import TemplateArguments, get_variable
+from esphome.cpp_generator import StaticCastExpression, TemplateArguments, get_variable
 from esphome.cpp_types import nullptr
 
 from .defines import (
@@ -30,7 +30,6 @@ from .defines import (
     CONF_SHOW_SNOW,
     CONF_TOP_LAYER,
     PARTS,
-    StaticCastExpression,
     add_warning,
     get_focused_widgets,
     get_options,

esphome/components/lvgl/defines.py

@@ -10,12 +10,7 @@ from typing import Any
 from esphome import codegen as cg, config_validation as cv
 from esphome.const import CONF_ITEMS
 from esphome.core import CORE, ID, Lambda
-from esphome.cpp_generator import (
-    CallExpression,
-    LambdaExpression,
-    MockObj,
-    MockObjClass,
-)
+from esphome.cpp_generator import MockObj, StaticCastExpression, call_lambda
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
 from esphome.types import Expression, SafeExpType
 
@@ -157,17 +152,6 @@ def get_refreshed_widgets() -> set:
     return _get_data(KEY_REFRESHED_WIDGETS, set())
 
 
-class StaticCastExpression(Expression):
-    __slots__ = ("type", "exp")
-
-    def __init__(self, type: Any, exp: SafeExpType):
-        self.type = str(type)
-        self.exp = cg.safe_exp(exp)
-
-    def __str__(self):
-        return f"static_cast<{self.type}>({self.exp})"
-
-
 def add_define(macro: str, value="1"):
     lv_defines = get_defines()
     value = str(value)
@@ -192,31 +176,6 @@ def addr(arg) -> MockObj:
     return MockObj(f"&{arg}")
 
 
-def call_lambda(lamb: LambdaExpression) -> Expression:
-    """
-    Given a lambda, either reduce to a simple expression or call it, possibly with parameters
-    from the surrounding context
-    :param lamb:
-    :return:
-    """
-    expr = lamb.content.strip()
-    if expr.startswith("return") and expr.endswith(";"):
-        # Convert a lambda returning a simple expression to just that expression
-        expr = cg.RawExpression(expr[6:-1].strip())
-        # Don't cast if the return type is a class
-        if isinstance(lamb.return_type, MockObjClass):
-            return expr
-        return StaticCastExpression(lamb.return_type, expr)
-    # If lambda has parameters, call it with their names
-    # Parameter names come from hardcoded component code (like "x", "it", "event")
-    # not from user input, so they're safe to use directly
-    if lamb.parameters and lamb.parameters.parameters:
-        return CallExpression(
-            lamb, *[MockObj(x.id) for x in lamb.parameters.parameters]
-        )
-    return CallExpression(lamb)
-
-
 class LValidator:
     """
     A validator for a particular type used in LVGL. Usable in configs as a validator, also

esphome/components/lvgl/lv_validation.py

@@ -16,7 +16,7 @@ from esphome.const import (
     CONF_VALUE,
 )
 from esphome.core import CORE, ID, Lambda
-from esphome.cpp_generator import MockObj
+from esphome.cpp_generator import MockObj, StaticCastExpression, call_lambda
 from esphome.cpp_types import ESPTime, int32, uint32
 from esphome.helpers import cpp_string_escape
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
@@ -33,9 +33,7 @@ from .defines import (
     LV_FONTS,
     LValidator,
     LvConstant,
-    StaticCastExpression,
     add_lv_use,
-    call_lambda,
     get_esphome_fonts_used,
     get_lv_fonts_used,
     get_lv_images_used,

esphome/components/lvgl/widgets/__init__.py

@@ -16,7 +16,7 @@ from esphome.const import (
 )
 from esphome.core import ID, EsphomeError, TimePeriod
 from esphome.coroutine import FakeAwaitable
-from esphome.cpp_generator import MockObj
+from esphome.cpp_generator import MockObj, call_lambda
 from esphome.schema_extractors import EnableSchemaExtraction
 from esphome.types import Expression
 
@@ -42,7 +42,6 @@ from ..defines import (
     STATES,
     LValidator,
     add_lv_use,
-    call_lambda,
     get_styles_used,
     get_theme_widget_map,
     get_widget_map,

esphome/components/lvgl/widgets/lv_list.py

@@ -227,7 +227,6 @@ LIST_ID_SCHEMA = cv.Schema({cv.Required(CONF_ID): cv.use_id(lv_list_t)})
 )
 async def list_add_text_to_code(config, action_id, template_arg, args):
     widgets = await get_widgets(config)
-    await _wait_list_triggers_completed()
 
     async def do_add_text(w: Widget):
         text = await lv_text.process(config[CONF_TEXT])
@@ -371,7 +370,6 @@ async def list_add_to_code(config, action_id, template_arg, args):
     _register_lv_uses(w_type_name, w_conf)
     _register_dynamic_widget_style_uses(w_conf)
     widgets = await get_widgets(config)
-    await _wait_list_triggers_completed()
 
     async def do_add(w: Widget):
         index = None
@@ -505,7 +503,6 @@ LIST_REMOVE_SCHEMA = LIST_ID_SCHEMA.extend(
 )
 async def list_remove_to_code(config, action_id, template_arg, args):
     widgets = await get_widgets(config)
-    await _wait_list_triggers_completed()
 
     async def do_remove(w: Widget):
         index = await lv_int.process(config[CONF_INDEX])
@@ -539,7 +536,6 @@ async def list_remove_to_code(config, action_id, template_arg, args):
 )
 async def list_clear_to_code(config, action_id, template_arg, args):
     widgets = await get_widgets(config)
-    await _wait_list_triggers_completed()
 
     async def do_clear(w: Widget):
         await _wait_list_triggers_completed()

esphome/components/midea/climate.py

@@ -1,6 +1,6 @@
 from esphome import automation
 import esphome.codegen as cg
-from esphome.components import climate, remote_transmitter, sensor, uart
+from esphome.components import climate, remote_base, remote_transmitter, sensor, uart
 from esphome.components.climate import ClimateMode, ClimatePreset, ClimateSwingMode
 from esphome.components.remote_base import CONF_TRANSMITTER_ID
 import esphome.config_validation as cv
@@ -280,6 +280,7 @@ async def to_code(config):
     cg.add(var.set_response_timeout(config[CONF_TIMEOUT].total_milliseconds))
     cg.add(var.set_request_attempts(config[CONF_NUM_ATTEMPTS]))
     if CONF_TRANSMITTER_ID in config:
+        remote_base.request_protocol("midea")  # ir_transmitter.h uses it from C++
         cg.add_define("USE_REMOTE_TRANSMITTER")
         transmitter_ = await cg.get_variable(config[CONF_TRANSMITTER_ID])
         cg.add(var.set_transmitter(transmitter_))

esphome/components/midea_ir/climate.py

@@ -1,5 +1,5 @@
 import esphome.codegen as cg
-from esphome.components import climate_ir
+from esphome.components import climate_ir, remote_base
 import esphome.config_validation as cv
 from esphome.const import CONF_USE_FAHRENHEIT
 from esphome.types import ConfigType
@@ -19,5 +19,9 @@ CONFIG_SCHEMA = climate_ir.climate_ir_with_receiver_schema(MideaIR).extend(
 
 
 async def to_code(config: ConfigType) -> None:
+    # midea_ir uses MideaProtocol from C++ and auto-loads coolix, whose coolix.cpp uses
+    # CoolixProtocol even when no coolix climate is configured
+    remote_base.request_protocol("midea")
+    remote_base.request_protocol("coolix")
     var = await climate_ir.new_climate_ir(config)
     cg.add(var.set_fahrenheit(config[CONF_USE_FAHRENHEIT]))

esphome/components/mipi_dsi/mipi_dsi.cpp

@@ -35,8 +35,8 @@ void MipiDsi::setup() {
       .bus_id = 0,  // index from 0, specify the DSI host to use
       .num_data_lanes =
           this->lanes_,  // Number of data lanes to use, can't set a value that exceeds the chip's capability
-      .phy_clk_src = MIPI_DSI_PHY_CLK_SRC_DEFAULT,  // Clock source for the DPHY
-      .lane_bit_rate_mbps = this->lane_bit_rate_,   // Bit rate of the data lanes, in Mbps
+      // phy_clk_src left at 0 to enable runtime auto-select.
+      .lane_bit_rate_mbps = this->lane_bit_rate_,  // Bit rate of the data lanes, in Mbps
   };
   auto err = esp_lcd_new_dsi_bus(&bus_config, &this->bus_handle_);
   if (err != ESP_OK) {

esphome/components/mlx90614/mlx90614.cpp

@@ -26,44 +26,129 @@ static const uint8_t MLX90614_ID4 = 0x3F;
 
 static const char *const TAG = "mlx90614";
 
+// The EEPROM cell has a limited number of write cycles, so stop retrying after a few failures
+static constexpr uint8_t EMISSIVITY_WRITE_ATTEMPTS = 3;
+
+// SMBus packet error code: CRC-8 with polynomial 0x07, MSB first
+static uint8_t crc8_pec(const uint8_t *data, uint8_t len) { return crc8(data, len, 0x00, 0x07, true); }
+
 void MLX90614Component::setup() {
-  if (!this->write_emissivity_()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
-    this->mark_failed();
+  if (std::isnan(this->emissivity_)) {
     return;
   }
+  this->emissivity_write_attempts_ = EMISSIVITY_WRITE_ATTEMPTS;
+  this->try_write_emissivity_();
+  if (this->emissivity_write_attempts_ != 0) {
+    this->status_set_warning(LOG_STR("Failed to write emissivity, will retry"));
+  }
+}
+
+void MLX90614Component::try_write_emissivity_() {
+  if (this->emissivity_write_attempts_ == 0) {
+    return;
+  }
+  if (this->write_emissivity_()) {
+    this->emissivity_write_attempts_ = 0;
+    return;
+  }
+  if (--this->emissivity_write_attempts_ == 0) {
+    ESP_LOGE(TAG, "Giving up on writing emissivity after %u attempts", EMISSIVITY_WRITE_ATTEMPTS);
+    this->emissivity_write_failed_ = true;
+  }
 }
 
 bool MLX90614Component::write_emissivity_() {
-  if (std::isnan(this->emissivity_))
+  // Skip the write when the EEPROM already holds the desired value to save write cycles
+  uint16_t current_emissivity;
+  if (this->read_register_(MLX90614_EMISSIVITY, current_emissivity) != i2c::ERROR_OK) {
+    return false;
+  }
+
+  const auto desired_emissivity = static_cast<uint16_t>(this->emissivity_ * 0xFFFF);
+  if (current_emissivity == desired_emissivity) {
     return true;
-  uint16_t value = (uint16_t) (this->emissivity_ * 65535);
-  if (!this->write_bytes_(MLX90614_EMISSIVITY, 0)) {
-    return false;
   }
-  delay(10);
-  if (!this->write_bytes_(MLX90614_EMISSIVITY, value)) {
-    return false;
-  }
-  delay(10);
-  return true;
+
+  return this->write_register_(MLX90614_EMISSIVITY, desired_emissivity);
 }
 
-bool MLX90614Component::write_bytes_(uint8_t reg, uint16_t data) {
+bool MLX90614Component::write_register_(uint8_t reg, uint16_t data) {
+  // The PEC covers the whole write transaction: SLA+W, command, data low, data high
   uint8_t buf[5];
   buf[0] = this->address_ << 1;
   buf[1] = reg;
-  buf[2] = data & 0xFF;
-  buf[3] = data >> 8;
-  buf[4] = crc8(buf, 4, 0x00, 0x07, true);
-  return this->write_bytes(reg, buf + 2, 3);
+
+  // See datasheet 8.3.3.1 EEPROM write sequence
+  // 1. Write 0x0000 into the cell of interest (erases the cell)
+  buf[2] = buf[3] = 0;
+  buf[4] = crc8_pec(buf, 4);
+  auto ec = this->write_register(reg, buf + 2, 3);
+  if (ec != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Can't erase register 0x%02X, error %d", reg, ec);
+    return false;
+  }
+
+  // 2. Wait at least 5ms
+  delay(10);
+
+  // 3. Write the new value
+  if (data != 0) {
+    buf[2] = data & 0xFF;
+    buf[3] = data >> 8;
+    buf[4] = crc8_pec(buf, 4);
+    ec = this->write_register(reg, buf + 2, 3);
+    if (ec != i2c::ERROR_OK) {
+      ESP_LOGW(TAG, "Can't write register 0x%02X, error %d", reg, ec);
+      return false;
+    }
+    // 4. Wait at least 5ms
+    delay(10);
+  }
+
+  // 5. Read back to confirm the value was stored
+  uint16_t read_back;
+  ec = this->read_register_(reg, read_back);
+  if (ec != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Can't check register 0x%02X value, error %d", reg, ec);
+    return false;
+  }
+
+  if (read_back != data) {
+    ESP_LOGW(TAG, "Read back mismatch on register 0x%02X. Expected 0x%04X, got 0x%04X", reg, data, read_back);
+    return false;
+  }
+
+  return true;
+}
+
+i2c::ErrorCode MLX90614Component::read_register_(uint8_t reg, uint16_t &data) {
+  // The PEC covers the whole read transaction: SLA+W, command, SLA+R, data low, data high
+  uint8_t buf[6];
+  buf[0] = this->address_ << 1;
+  buf[1] = reg;
+  buf[2] = (this->address_ << 1) | 0x01;
+
+  const auto ec = this->read_register(reg, buf + 3, 3);
+  if (ec != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "i2c read error %d", ec);
+    return ec;
+  }
+
+  const auto expected_pec = crc8_pec(buf, 5);
+  if (buf[5] != expected_pec) {
+    ESP_LOGW(TAG, "i2c CRC error. Expected 0x%02X, got 0x%02X", expected_pec, buf[5]);
+    return i2c::ERROR_CRC;
+  }
+
+  data = encode_uint16(buf[4], buf[3]);
+  return i2c::ERROR_OK;
 }
 
 void MLX90614Component::dump_config() {
   ESP_LOGCONFIG(TAG, "MLX90614:");
   LOG_I2C_DEVICE(this);
-  if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+  if (this->emissivity_write_attempts_ != 0) {
+    ESP_LOGW(TAG, "  Emissivity not written yet, will retry");
   }
   LOG_UPDATE_INTERVAL(this);
   LOG_SENSOR("  ", "Ambient", this->ambient_sensor_);
@@ -71,33 +156,41 @@ void MLX90614Component::dump_config() {
 }
 
 void MLX90614Component::update() {
-  uint8_t emissivity[3];
-  if (this->read_register(MLX90614_EMISSIVITY, emissivity, 3) != i2c::ERROR_OK) {
-    this->status_set_warning();
-    return;
+  // Temperature reads run regardless of the emissivity state so a failure still shows up as NAN
+  this->try_write_emissivity_();
+
+  // Publishes NAN on a bus or CRC failure so a stuck reading is visible instead of silently stale
+  auto publish_sensor = [this](sensor::Sensor *sensor, uint8_t reg) {
+    if (sensor == nullptr) {
+      return i2c::ERROR_OK;
+    }
+
+    uint16_t raw;
+    const auto ec = this->read_register_(reg, raw);
+    if (ec != i2c::ERROR_OK) {
+      sensor->publish_state(NAN);
+      return ec;
+    }
+
+    // Bit 15 set means the device flagged the reading as invalid
+    const float temperature = (raw & 0x8000) ? NAN : raw * 0.02f - 273.15f;
+    ESP_LOGD(TAG, "'%s': Got temperature=%.1f°C", sensor->get_name().c_str(), temperature);
+    sensor->publish_state(temperature);
+    return ec;
+  };
+
+  const auto object_ec = publish_sensor(this->object_sensor_, MLX90614_TEMPERATURE_OBJECT_1);
+  const auto ambient_ec = publish_sensor(this->ambient_sensor_, MLX90614_TEMPERATURE_AMBIENT);
+
+  if (object_ec != i2c::ERROR_OK || ambient_ec != i2c::ERROR_OK) {
+    this->status_set_warning(LOG_STR("Failed to read some sensors"));
+  } else if (this->emissivity_write_failed_) {
+    this->status_set_warning(LOG_STR("Failed to write emissivity"));
+  } else if (this->emissivity_write_attempts_ != 0) {
+    this->status_set_warning(LOG_STR("Failed to write emissivity, will retry"));
+  } else {
+    this->status_clear_warning();
   }
-  uint8_t raw_object[3];
-  if (this->read_register(MLX90614_TEMPERATURE_OBJECT_1, raw_object, 3) != i2c::ERROR_OK) {
-    this->status_set_warning();
-    return;
-  }
-
-  uint8_t raw_ambient[3];
-  if (this->read_register(MLX90614_TEMPERATURE_AMBIENT, raw_ambient, 3) != i2c::ERROR_OK) {
-    this->status_set_warning();
-    return;
-  }
-
-  float ambient = raw_ambient[1] & 0x80 ? NAN : encode_uint16(raw_ambient[1], raw_ambient[0]) * 0.02f - 273.15f;
-  float object = raw_object[1] & 0x80 ? NAN : encode_uint16(raw_object[1], raw_object[0]) * 0.02f - 273.15f;
-
-  ESP_LOGD(TAG, "Got Temperature=%.1f°C Ambient=%.1f°C", object, ambient);
-
-  if (this->ambient_sensor_ != nullptr && !std::isnan(ambient))
-    this->ambient_sensor_->publish_state(ambient);
-  if (this->object_sensor_ != nullptr && !std::isnan(object))
-    this->object_sensor_->publish_state(object);
-  this->status_clear_warning();
 }
 
 }  // namespace esphome::mlx90614

esphome/components/mlx90614/mlx90614.h

@@ -18,13 +18,18 @@ class MLX90614Component final : public PollingComponent, public i2c::I2CDevice {
   void set_emissivity(float emissivity) { emissivity_ = emissivity; }
 
  protected:
+  void try_write_emissivity_();
   bool write_emissivity_();
 
-  bool write_bytes_(uint8_t reg, uint16_t data);
+  bool write_register_(uint8_t reg, uint16_t data);
+  i2c::ErrorCode read_register_(uint8_t reg, uint16_t &data);
 
   sensor::Sensor *ambient_sensor_{nullptr};
   sensor::Sensor *object_sensor_{nullptr};
 
   float emissivity_{NAN};
+  // Remaining attempts to program the emissivity EEPROM cell, bounded to limit cell wear
+  uint8_t emissivity_write_attempts_{0};
+  bool emissivity_write_failed_{false};
 };
 }  // namespace esphome::mlx90614

esphome/components/modbus/__init__.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from collections.abc import Callable
 import logging
 from typing import Any, Literal, NamedTuple
 
@@ -49,8 +48,6 @@ ModbusServerDevice = modbus_ns.class_("ModbusServerDevice")
 CommandOptions = modbus_ns.struct("CommandOptions")
 MULTI_CONF = True
 
-CONF_ALLOW_BROADCAST_READ = "allow_broadcast_read"
-CONF_EXPECT_BROADCAST_WRITE_RESPONSE = "expect_broadcast_write_response"
 CONF_ROLE = "role"
 CONF_MODBUS_ID = "modbus_id"
 CONF_SEND_WAIT_TIME = "send_wait_time"
@@ -59,28 +56,6 @@ CONF_TURNAROUND_TIME = "turnaround_time"
 MODBUS_ROLES = ["client", "server"]
 
 
-# The write (mutating) function codes, matching modbus::helpers::is_function_code_write(). 0x17
-# (read/write multiple) is included: it mutates, so the hub treats it as a write despite its read half.
-_WRITE_FUNCTION_CODES = frozenset({0x05, 0x06, 0x0F, 0x10, 0x16, 0x17})
-
-# Codes the hub refuses at address 0; keep in sync with modbus::helpers::is_function_code_broadcastable().
-_NON_BROADCASTABLE_FUNCTION_CODES = frozenset(
-    {0x01, 0x02, 0x03, 0x04, 0x14, 0x15, 0x17, 0x18}
-)
-
-
-def is_function_code_write(function_code: int) -> bool:
-    """True if the Modbus function code writes (mutates). The exception bit (0x80) is masked off first,
-    so an exception-flagged code still classifies by its base code (the runtime hub never queues one:
-    queue_pdu() refuses them). Keep in sync with modbus::helpers::is_function_code_write()."""
-    return function_code & 0x7F in _WRITE_FUNCTION_CODES
-
-
-def is_function_code_broadcastable(function_code: int) -> bool:
-    """True if the hub accepts the function code at address 0 without allow_broadcast_read."""
-    return function_code & 0x7F not in _NON_BROADCASTABLE_FUNCTION_CODES
-
-
 class _CommandOption(NamedTuple):
     """One per-command option forwarded to the hub (modbus::CommandOptions)."""
 
@@ -89,47 +64,14 @@ class _CommandOption(NamedTuple):
     validator: Any  # the static (non-templatable) validator for the key
     cpp_type: Any  # the C++ type the value is generated as
     default: Any
-    # Function codes the hub honours the option on; it is stripped from any other.
-    applies_to: Callable[[int], bool]
-    requires_broadcast_address: bool = False
 
 
-def _not_write(function_code: int) -> bool:
-    return not is_function_code_write(function_code)
-
-
-def _not_broadcastable(function_code: int) -> bool:
-    return not is_function_code_broadcastable(function_code)
-
-
-# Per-direction command options, single-sourced so the schema, setters and applicability rule cannot
-# drift; the C++ side adds the matching field per the rules on CommandOptions (modbus.h).
+# Per-direction command options. Single-sourcing the schema and the setter generation here keeps
+# them from drifting; the C++ side must add the matching field per the rules documented on
+# CommandOptions (modbus.h).
 _COMMAND_OPTIONS: dict[str, list[_CommandOption]] = {
-    "read": [
-        _CommandOption(
-            CONF_CONTINUOUS, "continuous", cv.boolean, bool, False, _not_write
-        ),
-        _CommandOption(
-            CONF_ALLOW_BROADCAST_READ,
-            "allow_broadcast_read",
-            cv.boolean,
-            bool,
-            False,
-            _not_broadcastable,
-            requires_broadcast_address=True,
-        ),
-    ],
-    "write": [
-        _CommandOption(
-            CONF_EXPECT_BROADCAST_WRITE_RESPONSE,
-            "expect_broadcast_write_response",
-            cv.boolean,
-            bool,
-            False,
-            is_function_code_broadcastable,
-            requires_broadcast_address=True,
-        ),
-    ],
+    "read": [_CommandOption(CONF_CONTINUOUS, "continuous", cv.boolean, bool, False)],
+    "write": [],
 }
 
 
@@ -140,75 +82,32 @@ def _command_options(direction: str) -> list[_CommandOption]:
         raise ValueError(f"unknown command-options direction {direction!r}") from None
 
 
-def broadcast_only_option_keys() -> list[str]:
-    return [
-        option.conf_key
-        for options in _COMMAND_OPTIONS.values()
-        for option in options
-        if option.requires_broadcast_address
-    ]
+# The write (mutating) function codes, matching modbus::helpers::is_function_code_write(). 0x17
+# (read/write multiple) is included: it mutates, so the hub treats it as a write despite its read half.
+_WRITE_FUNCTION_CODES = frozenset({0x05, 0x06, 0x0F, 0x10, 0x16, 0x17})
 
 
-def reject_broadcast_options_for_unicast(
-    address_key: str,
-) -> Callable[[ConfigType], ConfigType]:
-    """Reject a broadcast-only option set true on a literal address other than 0."""
-
-    def validator(config: ConfigType) -> ConfigType:
-        address = config.get(address_key)
-        if not isinstance(address, int) or address == BROADCAST_ADDRESS:
-            return config
-        for key in broadcast_only_option_keys():
-            if config.get(key) is True:
-                raise cv.Invalid(
-                    f"'{key}' only applies to the broadcast address; set '{address_key}: 0' or "
-                    f"remove the option.",
-                    path=[key],
-                )
-        return config
-
-    return validator
-
-
-def reject_inapplicable_command_options(
-    pdu_key: str,
-) -> Callable[[ConfigType], ConfigType]:
-    """Reject an option set true that the hub would strip from a literal PDU's function code."""
-
-    def validator(config: ConfigType) -> ConfigType:
-        pdu = config[pdu_key]
-        if not isinstance(pdu, list):
-            return config
-        for direction in _COMMAND_OPTIONS:
-            for option in _command_options(direction):
-                if config.get(option.conf_key) is True and not option.applies_to(
-                    pdu[0]
-                ):
-                    raise cv.Invalid(
-                        f"'{option.conf_key}: true' does not apply to function code "
-                        f"0x{pdu[0]:02X}",
-                        path=[option.conf_key],
-                    )
-        return config
-
-    return validator
+def is_function_code_write(function_code: int) -> bool:
+    """True if the Modbus function code writes (mutates). The exception bit (0x80) is masked off first,
+    so an exception-flagged code still classifies by its base code (the runtime hub never queues one:
+    queue_pdu() refuses them). Keep in sync with modbus::helpers::is_function_code_write()."""
+    return function_code & 0x7F in _WRITE_FUNCTION_CODES
 
 
 def command_options_schema(
-    *,
-    direction: Literal["read", "write"],
-    templatable: bool = False,
-    function_code: int | None = None,
+    *, direction: Literal["read", "write"], templatable: bool = False
 ) -> dict[cv.Optional, Any]:
-    """Schema fragment for the per-command options of one direction; `function_code` (a typed
-    action's fixed code) leaves out the options that do not apply to it.
+    """Schema fragment for the per-command options a component forwards to the hub
+    (modbus::CommandOptions). Extend this into any schema that queues commands. Keys are
+    direction-specific so a schema never offers an option the hub would strip (e.g.
+    continuous on a write); the write side has no options yet. For actions (templatable=True the
+    keys also accept lambdas), register the values with register_templatable_command_options().
     """
     return {
         cv.Optional(option.conf_key, default=option.default): (
             cv.templatable(option.validator) if templatable else option.validator
         )
         for option in _command_options(direction)
-        if function_code is None or option.applies_to(function_code)
     }
 
 
@@ -231,25 +130,6 @@ def command_options_expression(
     )
 
 
-def add_command_options(
-    var: MockObj,
-    setter: str,
-    config: ConfigType,
-    *,
-    direction: Literal["read", "write"],
-) -> None:
-    """Emit `var.<setter>(<options>)` for a config validated with command_options_schema() of the
-    same direction, skipped when every option is at its C++ default."""
-    if all(
-        config.get(option.conf_key, option.default) == option.default
-        for option in _command_options(direction)
-    ):
-        return
-    cg.add(
-        getattr(var, setter)(command_options_expression(config, direction=direction))
-    )
-
-
 async def register_templatable_command_options(
     var: MockObj, config: ConfigType, args: TemplateArgsType, direction: str
 ) -> None:

esphome/components/modbus/modbus.cpp

@@ -832,7 +832,7 @@ void ModbusClientHub::send_next_frame_() {
   }
 
   cmd->sent();
-  if (cmd->fire_and_forget()) {
+  if (cmd->frame.address() == BROADCAST_ADDRESS) {
     // A broadcast (address 0) is never answered (Modbus 4.1), so it is fire-and-forget: on_sent above
     // reports the transmission, and the entry then retires with no terminal callback instead of
     // occupying the waiting slot until the send-wait timeout expires. The turnaround delay already
@@ -1074,6 +1074,11 @@ bool ModbusClientHub::queue_pdu(uint8_t address, std::span<const uint8_t> pdu, M
     return false;
   }
 
+  if (address == BROADCAST_ADDRESS && !helpers::is_function_code_broadcastable(pdu[0])) {
+    ESP_LOGW(TAG, "Broadcast refused for function 0x%X: a broadcast (address 0) is never answered", pdu[0]);
+    return false;
+  }
+
   // Normalize the caller's options in place (the param is a by-value copy) so everything stored or
   // merged below carries effective options, never the raw request.
   // continuous is ignored for every mutating code (re-writing a value forever is never intended).
@@ -1081,24 +1086,6 @@ bool ModbusClientHub::queue_pdu(uint8_t address, std::span<const uint8_t> pdu, M
     ESP_LOGW(TAG, "continuous is ignored for a mutating function (0x%X, address %" PRIu8 ")", pdu[0], address);
     options.continuous = false;
   }
-  if (address != BROADCAST_ADDRESS) {
-    options.allow_broadcast_read = false;
-    options.expect_broadcast_write_response = false;
-  } else {
-    const bool broadcastable = helpers::is_function_code_broadcastable(pdu[0]);
-    if (options.allow_broadcast_read && broadcastable) {
-      ESP_LOGV(TAG, "allow_broadcast_read is ignored for function 0x%X: it is broadcastable", pdu[0]);
-      options.allow_broadcast_read = false;
-    }
-    if (options.expect_broadcast_write_response && !broadcastable) {
-      ESP_LOGV(TAG, "expect_broadcast_write_response is ignored for function 0x%X: it is not broadcastable", pdu[0]);
-      options.expect_broadcast_write_response = false;
-    }
-    if (!broadcastable && !options.allow_broadcast_read) {
-      ESP_LOGW(TAG, "Broadcast refused for function 0x%X: a broadcast (address 0) is never answered", pdu[0]);
-      return false;
-    }
-  }
 
   // A duplicate of a live entry with the same owner is not queued twice; it resolves against that
   // entry: anonymous -> dropped; continuous incoming -> convert the entry to a poll; one-shot onto a
@@ -1139,7 +1126,6 @@ bool ModbusClientHub::queue_pdu(uint8_t address, std::span<const uint8_t> pdu, M
       ESP_LOGV(TAG, "Frame already active for %" PRIu8 ", request absorbed (pending %" PRIu8 ")", address,
                item.pending);
     }
-    item.options.expect_broadcast_write_response |= options.expect_broadcast_write_response;
     return true;
   }
 

esphome/components/modbus/modbus.h

@@ -111,15 +111,11 @@ enum class FrameState : uint8_t {
 // Per-command send options. Append-only; pass via designated initializers ({.continuous = true}).
 // A new field reaches the queue with no plumbing but arrives inert until it defines three rules:
 // normalization in queue_pdu(), a merge rule for duplicate absorption, and teardown in
-// retire()/silent_retire(). Bit-packed: stored per entry, controller and writer entity, passed by value.
+// retire()/silent_retire().
 struct CommandOptions {
   // A continuous poll lives in the queue until cancelled or failed; ignored for mutating codes.
-  bool continuous : 1 {false};
-  // Wait for the reply to a read sent to address 0, for a device that answers the broadcast address.
-  bool allow_broadcast_read : 1 {false};
-  bool expect_broadcast_write_response : 1 {false};
+  bool continuous{false};
 };
-static_assert(sizeof(CommandOptions) == 1, "CommandOptions must stay one byte");
 
 struct ModbusDeviceCommand {
   ModbusClientDevice *device;
@@ -162,10 +158,6 @@ struct ModbusDeviceCommand {
     this->pending = 0;
     this->device = nullptr;
   }
-  bool fire_and_forget() const {
-    return this->frame.address() == BROADCAST_ADDRESS && !this->options.allow_broadcast_read &&
-           !this->options.expect_broadcast_write_response;
-  }
   // Fire-and-forget completion for a broadcast (address 0): the frame was transmitted (on_sent already
   // fired), but a broadcast is never answered (Modbus 4.1), so the entry retires with no terminal callback.
   void complete_broadcast() {
@@ -199,8 +191,7 @@ struct ModbusDeviceCommand {
     } else if (!this->waiting_state()) {  // an already-retired shell stays put; off the wire -> RETIRED
       this->state = FrameState::RETIRED;
     }
-    // Only continuous ends with the clear; the delivery flags must survive for a granted retry.
-    this->options.continuous = false;
+    this->options = {};  // reset every option
   }
 
   // True while the entry is still waiting for a response
@@ -543,27 +534,27 @@ class ModbusClientDevice {
     return this->queue_pdu(
         helpers::create_read_pdu(FunctionCode::READ_DISCRETE_INPUTS, start_address, number_of_inputs), options);
   }
-  bool write_single_register(uint16_t start_address, uint16_t value, CommandOptions options = {}) {
-    return this->queue_pdu(helpers::create_write_single_register_pdu(start_address, value), options);
+  bool write_single_register(uint16_t start_address, uint16_t value) {
+    return this->queue_pdu(helpers::create_write_single_register_pdu(start_address, value));
   }
-  bool write_single_coil(uint16_t address, bool value, CommandOptions options = {}) {
-    return this->queue_pdu(helpers::create_write_single_coil_pdu(address, value), options);
+  bool write_single_coil(uint16_t address, bool value) {
+    return this->queue_pdu(helpers::create_write_single_coil_pdu(address, value));
   }
-  bool write_multiple_registers(uint16_t start_address, std::span<const uint16_t> values, CommandOptions options = {}) {
+  bool write_multiple_registers(uint16_t start_address, std::span<const uint16_t> values) {
     // Empty goes to the full-size builder so the rejection log names this method's limit, not the small one's.
     if (!values.empty() && values.size() <= helpers::MAX_FEW_REGISTERS)
-      return this->queue_pdu(helpers::create_write_few_registers_pdu(start_address, values), options);
-    return this->queue_pdu(helpers::create_write_registers_pdu(start_address, values), options);
+      return this->queue_pdu(helpers::create_write_few_registers_pdu(start_address, values));
+    return this->queue_pdu(helpers::create_write_registers_pdu(start_address, values));
   }
   /// Note: std::vector<bool> cannot bind to std::span<const bool>; use a contiguous bool container or the packed
   /// overload.
-  bool write_multiple_coils(uint16_t start_address, std::span<const bool> values, CommandOptions options = {}) {
-    return this->queue_pdu(helpers::create_write_coils_pdu(start_address, values), options);
+  bool write_multiple_coils(uint16_t start_address, std::span<const bool> values) {
+    return this->queue_pdu(helpers::create_write_coils_pdu(start_address, values));
   }
   /// Packed variant: a PackedBits view (the same layout on_read_coils() delivers), so
   /// read-modify-write needs no unpack/repack.
-  bool write_multiple_coils(uint16_t start_address, PackedBits bits, CommandOptions options = {}) {
-    return this->queue_pdu(helpers::create_write_coils_pdu(start_address, bits), options);
+  bool write_multiple_coils(uint16_t start_address, PackedBits bits) {
+    return this->queue_pdu(helpers::create_write_coils_pdu(start_address, bits));
   }
   /// FC 0x17: the read-back is delivered through on_read_holding_registers(), and a device exception
   /// (typically a rejected write half) arrives there too via its status - one callback handles both

esphome/components/modbus_client/__init__.py

@@ -7,6 +7,7 @@ from esphome.components import modbus
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ADDRESS,
+    CONF_CONTINUOUS,
     CONF_COUNT,
     CONF_ID,
     CONF_ON_ERROR,
@@ -157,6 +158,24 @@ _ACTION_BASE_SCHEMA = cv.Schema(
 )
 
 
+def _no_continuous_on_write(config: ConfigType) -> ConfigType:
+    """Reject `continuous: true` on a static write PDU: continuous polling only applies to reads.
+    Only the fully-static case is decidable here; the hub strips the flag from mutating PDUs at
+    runtime, so a templated pdu or continuous falls through to that backstop."""
+    pdu = config[CONF_PDU]
+    if (
+        isinstance(pdu, list)
+        and config.get(CONF_CONTINUOUS) is True
+        and modbus.is_function_code_write(pdu[0])
+    ):
+        raise cv.Invalid(
+            f"'{CONF_CONTINUOUS}: true' does not apply to a write PDU (function code "
+            f"0x{pdu[0]:02X}); continuous polling only applies to reads",
+            path=[CONF_CONTINUOUS],
+        )
+    return config
+
+
 MODBUS_CLIENT_SEND_SCHEMA = cv.All(
     _ACTION_BASE_SCHEMA.extend(
         {
@@ -167,12 +186,10 @@ MODBUS_CLIENT_SEND_SCHEMA = cv.All(
                 )
             ),
             **modbus.command_options_schema(direction="read", templatable=True),
-            **modbus.command_options_schema(direction="write", templatable=True),
             cv.Optional(CONF_ON_RESPONSE): _handler_schema(),
         }
     ),
-    modbus.reject_inapplicable_command_options(CONF_PDU),
-    modbus.reject_broadcast_options_for_unicast(CONF_ADDRESS),
+    _no_continuous_on_write,
 )
 
 
@@ -244,7 +261,8 @@ async def register_client_action(
             var.get_not_sent_trigger(), [(_PDU_SPAN, "request")], not_sent_conf
         )
     # Wire any command options the action's schema opted into (e.g. continuous on reads). Pass the
-    # matching direction so a write action never generates a read option's setter.
+    # matching direction so a write action never generates a read option's setter; the write side
+    # has no options yet, so this is a no-op there.
     await modbus.register_templatable_command_options(
         var, config, args, command_direction
     )
@@ -261,8 +279,6 @@ async def modbus_client_send_to_code(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     template_ = await cg.templatable(config[CONF_PDU], args, _PDU_BUFFER)
     cg.add(var.set_pdu(template_))
-    # The read set is wired by register_client_action() below.
-    await modbus.register_templatable_command_options(var, config, args, "write")
     return await register_client_action(
         var,
         config,
@@ -337,7 +353,6 @@ def _read_schema(max_count: int) -> cv.All:
             }
         ),
         _no_address_overflow(CONF_COUNT),
-        modbus.reject_broadcast_options_for_unicast(CONF_ADDRESS),
     )
 
 
@@ -349,35 +364,21 @@ def _write_multiple_schema(item: Callable[[Any], Any], max_values: int) -> cv.Al
                 cv.Required(CONF_VALUES): cv.templatable(
                     cv.All(cv.ensure_list(item), cv.Length(min=1, max=max_values))
                 ),
-                **modbus.command_options_schema(direction="write", templatable=True),
             }
         ),
         _no_address_overflow(CONF_VALUES),
-        modbus.reject_broadcast_options_for_unicast(CONF_ADDRESS),
     )
 
 
 _READ_REGISTERS_SCHEMA = _read_schema(modbus.MAX_NUM_OF_REGISTERS_TO_READ)
 
-_WRITE_SINGLE_REGISTER_SCHEMA = cv.All(
-    _TYPED_ACTION_SCHEMA.extend(
-        {
-            cv.Required(CONF_VALUE): cv.templatable(cv.hex_uint16_t),
-            **modbus.command_options_schema(direction="write", templatable=True),
-        }
-    ),
-    modbus.reject_broadcast_options_for_unicast(CONF_ADDRESS),
+_WRITE_SINGLE_REGISTER_SCHEMA = _TYPED_ACTION_SCHEMA.extend(
+    {cv.Required(CONF_VALUE): cv.templatable(cv.hex_uint16_t)}
 )
 
 # A coil is one bit, so the value is a boolean - the wire only carries 0x0000 or 0xFF00.
-_WRITE_SINGLE_COIL_SCHEMA = cv.All(
-    _TYPED_ACTION_SCHEMA.extend(
-        {
-            cv.Required(CONF_VALUE): cv.templatable(cv.boolean),
-            **modbus.command_options_schema(direction="write", templatable=True),
-        }
-    ),
-    modbus.reject_broadcast_options_for_unicast(CONF_ADDRESS),
+_WRITE_SINGLE_COIL_SCHEMA = _TYPED_ACTION_SCHEMA.extend(
+    {cv.Required(CONF_VALUE): cv.templatable(cv.boolean)}
 )
 
 
@@ -541,15 +542,10 @@ _READ_WRITE_MULTIPLE_REGISTERS_SCHEMA = cv.All(
                     cv.Length(min=1, max=modbus.MAX_NUM_OF_REGISTERS_TO_WRITE_RW),
                 )
             ),
-            # 0x17 counts as a read at address 0, so it takes allow_broadcast_read only.
-            **modbus.command_options_schema(
-                direction="read", templatable=True, function_code=0x17
-            ),
         }
     ),
     _no_address_overflow(CONF_READ_COUNT, CONF_READ_ADDRESS),
     _no_address_overflow(CONF_VALUES, CONF_WRITE_ADDRESS),
-    modbus.reject_broadcast_options_for_unicast(CONF_ADDRESS),
 )
 
 

esphome/components/modbus_client/modbus_client.h

@@ -85,36 +85,18 @@ template<typename... Ts> class ClientActionBase : public Action<Ts...>, public m
 /// builds its static struct; declaring the values here instead of per action means a new read option
 /// costs one TEMPLATABLE_VALUE plus one field below, and every read action picks it up.
 /// The read/write split mirrors _COMMAND_OPTIONS in the modbus component's Python
-/// (command_options_schema(direction="read") adds exactly these keys); WriteCommandOptions is the twin.
+/// (command_options_schema(direction="read") adds exactly these keys). When a write-side option
+/// arrives it gets a WriteCommandOptions twin, so write actions never carry read-only members.
 template<typename... Ts> class ReadCommandOptions {
  public:
   // Poll: re-queue after each success until downgraded (replay with false) or failed. The hub strips
   // it for mutating function codes at the door (see modbus::CommandOptions).
   TEMPLATABLE_VALUE(bool, continuous)
-  TEMPLATABLE_VALUE(bool, allow_broadcast_read)
 
  protected:
   /// The options for this send, with every templatable value resolved against the action's arguments.
   modbus::CommandOptions command_options_(const Ts &...x) const {
-    return {.continuous = this->continuous_.value(x...),
-            .allow_broadcast_read = this->allow_broadcast_read_.value(x...)};
-  }
-};
-
-/// The write-side per-command options (command_options_schema(direction="write") adds exactly these keys).
-template<typename... Ts> class WriteCommandOptions {
- public:
-  TEMPLATABLE_VALUE(bool, expect_broadcast_write_response)
-
- protected:
-  /// Resolves every write option into `options`, so send's merge of both sets stays exhaustive.
-  void apply_write_command_options_(modbus::CommandOptions &options, const Ts &...x) const {
-    options.expect_broadcast_write_response = this->expect_broadcast_write_response_.value(x...);
-  }
-  modbus::CommandOptions write_command_options_(const Ts &...x) const {
-    modbus::CommandOptions options{};
-    this->apply_write_command_options_(options, x...);
-    return options;
+    return {.continuous = this->continuous_.value(x...)};
   }
 };
 
@@ -125,11 +107,8 @@ template<typename... Ts> class WriteCommandOptions {
 /// modbus::helpers::create_*_pdu() builders and return it directly (smaller builder results convert).
 /// A PduBuffer drops bytes past modbus::MAX_PDU_SIZE without reporting it (the hub's oversize check
 /// cannot fire - that limit is the capacity), so an over-long lambda-built PDU is silently truncated.
-/// A raw PDU may be a read or a write, so this action carries both option sets.
 template<typename... Ts>
-class ModbusClientSendAction : public ClientActionBase<Ts...>,
-                               public ReadCommandOptions<Ts...>,
-                               public WriteCommandOptions<Ts...> {
+class ModbusClientSendAction : public ClientActionBase<Ts...>, public ReadCommandOptions<Ts...> {
  public:
   TEMPLATABLE_VALUE(modbus::helpers::PduBuffer, pdu)
 
@@ -137,11 +116,7 @@ class ModbusClientSendAction : public ClientActionBase<Ts...>,
     return &this->response_trigger_;
   }
 
-  void play(const Ts &...x) override {
-    modbus::CommandOptions options = this->command_options_(x...);
-    this->apply_write_command_options_(options, x...);
-    this->send_or_resolve_(this->pdu_.value(x...), options);
-  }
+  void play(const Ts &...x) override { this->send_or_resolve_(this->pdu_.value(x...), this->command_options_(x...)); }
 
   void on_response(std::span<const uint8_t> request_pdu, std::span<const uint8_t> response_pdu) override {
     this->response_trigger_.trigger(request_pdu, response_pdu);
@@ -243,8 +218,7 @@ template<typename... Ts> class ReadBitsAction : public TypedClientActionBase<Ts.
 
 /// modbus_client.write_single_register: on_response is the acknowledgement (the ack only echoes the
 /// request, so it carries no arguments).
-template<typename... Ts>
-class WriteSingleRegisterAction : public TypedClientActionBase<Ts...>, public WriteCommandOptions<Ts...> {
+template<typename... Ts> class WriteSingleRegisterAction : public TypedClientActionBase<Ts...> {
  public:
   TEMPLATABLE_VALUE(uint16_t, start_address)
   TEMPLATABLE_VALUE(uint16_t, value)
@@ -253,8 +227,7 @@ class WriteSingleRegisterAction : public TypedClientActionBase<Ts...>, public Wr
 
   void play(const Ts &...x) override {
     this->send_or_resolve_(
-        modbus::helpers::create_write_single_register_pdu(this->start_address_.value(x...), this->value_.value(x...)),
-        this->write_command_options_(x...));
+        modbus::helpers::create_write_single_register_pdu(this->start_address_.value(x...), this->value_.value(x...)));
   }
   void on_write_single_register(uint16_t address, uint16_t value, modbus::ResponseStatus status) override {
     if (modbus::succeeded(status))
@@ -267,8 +240,7 @@ class WriteSingleRegisterAction : public TypedClientActionBase<Ts...>, public Wr
 
 /// modbus_client.write_single_coil: on_response is the acknowledgement (no arguments). A coil holds one
 /// bit, so the value is a bool - the wire only ever carries 0x0000 or 0xFF00.
-template<typename... Ts>
-class WriteSingleCoilAction : public TypedClientActionBase<Ts...>, public WriteCommandOptions<Ts...> {
+template<typename... Ts> class WriteSingleCoilAction : public TypedClientActionBase<Ts...> {
  public:
   TEMPLATABLE_VALUE(uint16_t, start_address)
   TEMPLATABLE_VALUE(bool, value)
@@ -277,8 +249,7 @@ class WriteSingleCoilAction : public TypedClientActionBase<Ts...>, public WriteC
 
   void play(const Ts &...x) override {
     this->send_or_resolve_(
-        modbus::helpers::create_write_single_coil_pdu(this->start_address_.value(x...), this->value_.value(x...)),
-        this->write_command_options_(x...));
+        modbus::helpers::create_write_single_coil_pdu(this->start_address_.value(x...), this->value_.value(x...)));
   }
   void on_write_single_coil(uint16_t address, bool value, modbus::ResponseStatus status) override {
     if (modbus::succeeded(status))
@@ -293,8 +264,7 @@ class WriteSingleCoilAction : public TypedClientActionBase<Ts...>, public WriteC
 /// A `values:` list is emitted as a flash array and sent straight from there; only a lambda builds a
 /// vector, and only when it runs. Same split as canbus's send action, and for the same reason: a static
 /// list must not allocate on every play().
-template<typename... Ts>
-class WriteMultipleRegistersAction : public TypedClientActionBase<Ts...>, public WriteCommandOptions<Ts...> {
+template<typename... Ts> class WriteMultipleRegistersAction : public TypedClientActionBase<Ts...> {
  public:
   TEMPLATABLE_VALUE(uint16_t, start_address)
 
@@ -318,13 +288,11 @@ class WriteMultipleRegistersAction : public TypedClientActionBase<Ts...>, public
     // the empty PDU then resolves via on_not_sent like any refused send.
     if (this->len_ >= 0) {
       this->send_or_resolve_(modbus::helpers::create_write_registers_pdu(
-                                 start, std::span<const uint16_t>(this->values_.data, static_cast<size_t>(this->len_))),
-                             this->write_command_options_(x...));
+          start, std::span<const uint16_t>(this->values_.data, static_cast<size_t>(this->len_))));
       return;
     }
     const std::vector<uint16_t> values = this->values_.func(x...);
-    this->send_or_resolve_(modbus::helpers::create_write_registers_pdu(start, std::span<const uint16_t>(values)),
-                           this->write_command_options_(x...));
+    this->send_or_resolve_(modbus::helpers::create_write_registers_pdu(start, std::span<const uint16_t>(values)));
   }
   void on_write_multiple_registers(uint16_t start_address, std::span<const uint16_t> registers,
                                    modbus::ResponseStatus status) override {
@@ -345,8 +313,7 @@ class WriteMultipleRegistersAction : public TypedClientActionBase<Ts...>, public
 /// A `values:` list is packed into wire layout at code-generation time and stored in flash, so play()
 /// neither allocates nor packs. A lambda returns std::vector<bool> - already a bit per coil rather than
 /// a byte - and is packed into a stack buffer on the way to the builder.
-template<typename... Ts>
-class WriteMultipleCoilsAction : public TypedClientActionBase<Ts...>, public WriteCommandOptions<Ts...> {
+template<typename... Ts> class WriteMultipleCoilsAction : public TypedClientActionBase<Ts...> {
  public:
   TEMPLATABLE_VALUE(uint16_t, start_address)
 
@@ -367,16 +334,13 @@ class WriteMultipleCoilsAction : public TypedClientActionBase<Ts...>, public Wri
     const uint16_t start = this->start_address_.value(x...);
     if (this->count_ >= 0) {
       const auto count = static_cast<uint16_t>(this->count_);
-      this->send_or_resolve_(
-          modbus::helpers::create_write_coils_pdu(
-              start, modbus::PackedBits(std::span<const uint8_t>(this->values_.packed, modbus::packed_bit_bytes(count)),
-                                        count)),
-          this->write_command_options_(x...));
+      this->send_or_resolve_(modbus::helpers::create_write_coils_pdu(
+          start,
+          modbus::PackedBits(std::span<const uint8_t>(this->values_.packed, modbus::packed_bit_bytes(count)), count)));
       return;
     }
     // The builder packs and bound-checks; an over-long set is rejected and logged there.
-    this->send_or_resolve_(modbus::helpers::create_write_coils_pdu(start, this->values_.func(x...)),
-                           this->write_command_options_(x...));
+    this->send_or_resolve_(modbus::helpers::create_write_coils_pdu(start, this->values_.func(x...)));
   }
   void on_write_multiple_coils(uint16_t start_address, modbus::PackedBits bits,
                                modbus::ResponseStatus status) override {
@@ -395,8 +359,7 @@ class WriteMultipleCoilsAction : public TypedClientActionBase<Ts...>, public Wri
 
 /// modbus_client.read_write_multiple_registers (FC 0x17): writes one register block and reads another back in
 /// one transaction (write first, per Modbus 6.17). on_response delivers the read-back words as `values`.
-template<typename... Ts>
-class ReadWriteMultipleRegistersAction : public TypedClientActionBase<Ts...>, public ReadCommandOptions<Ts...> {
+template<typename... Ts> class ReadWriteMultipleRegistersAction : public TypedClientActionBase<Ts...> {
  public:
   TEMPLATABLE_VALUE(uint16_t, read_address)
   TEMPLATABLE_VALUE(uint16_t, read_count)
@@ -422,15 +385,13 @@ class ReadWriteMultipleRegistersAction : public TypedClientActionBase<Ts...>, pu
     // An out-of-range read/write count builds an empty PDU (the builder logs why), resolving via on_not_sent.
     if (this->len_ >= 0) {
       this->send_or_resolve_(modbus::helpers::create_read_write_multiple_registers_pdu(
-                                 read_start, read_count, write_start,
-                                 std::span<const uint16_t>(this->values_.data, static_cast<size_t>(this->len_))),
-                             this->command_options_(x...));
+          read_start, read_count, write_start,
+          std::span<const uint16_t>(this->values_.data, static_cast<size_t>(this->len_))));
       return;
     }
     const std::vector<uint16_t> values = this->values_.func(x...);
     this->send_or_resolve_(modbus::helpers::create_read_write_multiple_registers_pdu(
-                               read_start, read_count, write_start, std::span<const uint16_t>(values)),
-                           this->command_options_(x...));
+        read_start, read_count, write_start, std::span<const uint16_t>(values)));
   }
   // The 0x17 response carries only the read block, so the hub dispatch delivers it as a holding-register read.
   void on_read_registers(modbus::EntityType entity_type, uint16_t start_address, std::span<const uint16_t> registers,

esphome/components/modbus_controller/__init__.py

@@ -103,20 +103,12 @@ def _warn_removed_options(config: ConfigType) -> ConfigType:
 
 
 def _reject_broadcast_address(config: ConfigType) -> ConfigType:
-    """Address 0 is rejected unless allow_broadcast_read, which in turn requires address 0."""
-    if config[modbus.CONF_ALLOW_BROADCAST_READ]:
-        if config.get(CONF_ADDRESS) != modbus.BROADCAST_ADDRESS:
-            raise cv.Invalid(
-                f"'{modbus.CONF_ALLOW_BROADCAST_READ}' only applies to the broadcast address; "
-                f"set 'address: 0' or remove the option.",
-                [modbus.CONF_ALLOW_BROADCAST_READ],
-            )
-        return config
+    """A modbus_controller polls one device, so its address cannot be the broadcast address (0):
+    a broadcast is never answered (Modbus 4.1), so no register could ever read back."""
     modbus.reject_broadcast_address(
         config.get(CONF_ADDRESS),
         "a modbus_controller device address",
-        "Assign the unit address of the device you want to poll, or set allow_broadcast_read if "
-        "it answers address 0.",
+        "Assign the unit address of the device you want to poll.",
         [CONF_ADDRESS],
     )
     return config
@@ -354,52 +346,12 @@ def _reject_continuous_write_custom_pdu(config: ConfigType) -> None:
         )
 
 
-def _reject_broadcastable_custom_pdu(config: ConfigType) -> None:
-    """A broadcastable custom_pdu under an address-0 controller is a real broadcast, never answered."""
-    pdu = config.get(CONF_CUSTOM_PDU)
-    if pdu is None or not modbus.is_function_code_broadcastable(pdu[0]):
-        return
-    fconf = fv.full_config.get()
-    path = fconf.get_path_for_id(config[CONF_MODBUS_CONTROLLER_ID])[:-1]
-    controller = fconf.get_config_for_path(path)
-    if (
-        controller.get(CONF_ADDRESS) == modbus.BROADCAST_ADDRESS
-        and controller.get(modbus.CONF_ALLOW_BROADCAST_READ) is True
-    ):
-        raise cv.Invalid(
-            f"a '{CONF_CUSTOM_PDU}' with function code 0x{pdu[0] & 0x7F:02X} is a real broadcast at "
-            f"address 0 and is never answered, so it can't be polled through the "
-            f"'{controller[CONF_ID]}' modbus_controller; use a read function code.",
-            [CONF_CUSTOM_PDU],
-        )
-
-
 def validate_custom_pdu_item(config: ConfigType) -> None:
-    """Final-validate for the platforms that accept custom_pdu."""
+    """Final-validate for the read platforms that accept custom_pdu (sensor, binary_sensor,
+    text_sensor): migrate the deprecated custom_command, then reject a write-coded custom_pdu under a
+    continuously-polling controller."""
     migrate_custom_command(config)
     _reject_continuous_write_custom_pdu(config)
-    _reject_broadcastable_custom_pdu(config)
-
-
-def _reject_write_option_off_broadcast(config: ConfigType) -> None:
-    if not any(config.get(key) is True for key in modbus.broadcast_only_option_keys()):
-        return
-    fconf = fv.full_config.get()
-    path = fconf.get_path_for_id(config[CONF_MODBUS_CONTROLLER_ID])[:-1]
-    controller = fconf.get_config_for_path(path)
-    if controller.get(CONF_ADDRESS) != modbus.BROADCAST_ADDRESS:
-        raise cv.Invalid(
-            f"'{modbus.CONF_EXPECT_BROADCAST_WRITE_RESPONSE}' only applies when the "
-            f"'{controller[CONF_ID]}' modbus_controller is at address 0; remove the option.",
-            [modbus.CONF_EXPECT_BROADCAST_WRITE_RESPONSE],
-        )
-
-
-def validate_writer_item(config: ConfigType) -> None:
-    """Final-validate for the writer platforms (number, output, select, switch)."""
-    if CONF_CUSTOM_PDU in config or CONF_CUSTOM_COMMAND in config:
-        validate_custom_pdu_item(config)
-    _reject_write_option_off_broadcast(config)
 
 
 def _final_validate(config: ConfigType) -> None:
@@ -496,7 +448,11 @@ async def to_code(config: ConfigType) -> None:
     await cg.register_component(var, config)
     cg.add(var.set_max_cmd_retries(config[CONF_MAX_CMD_RETRIES]))
     cg.add(var.set_offline_skip_updates(config[CONF_OFFLINE_SKIP_UPDATES]))
-    modbus.add_command_options(var, "set_read_options", config, direction="read")
+    cg.add(
+        var.set_read_options(
+            modbus.command_options_expression(config, direction="read")
+        )
+    )
     await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
 

esphome/components/modbus_controller/modbus_controller.cpp

@@ -24,7 +24,7 @@ void WriterDevice::warn_write_buffer_deprecated(const LogString *platform, uint1
 bool WriterDevice::send_raw_frame_deprecated(std::span<const uint8_t> frame) {
   if (frame.empty())
     return false;
-  return this->parent_->queue_pdu(frame[0], frame.subspan(1), this, this->write_options_);
+  return this->parent_->queue_pdu(frame[0], frame.subspan(1), this);
 }
 
 void ControllerDevice::set_controller(ModbusController *controller) {
@@ -234,13 +234,10 @@ void ModbusCommandItem::on_sent(std::span<const uint8_t> request_pdu) {
   // (frame[0]), which may differ from this controller's. (unqueue_command() is a no-op for a poll.)
   // A custom polling command sends its PDU to this controller's own address, so only a factory custom
   // command (a raw frame staged in payload) can carry a different address byte.
-  // An address-0 read with allow_broadcast_read is answered, so it keeps its terminal callback.
   uint8_t wire_address = this->address_;
   if (this->function_code_ == FunctionCode::CUSTOM && !this->payload.empty())
     wire_address = this->payload.data()[0];
-  const bool answered = this->controller_->read_options().allow_broadcast_read &&
-                        !modbus::helpers::is_function_code_broadcastable(request_pdu[0]);
-  if (wire_address == modbus::BROADCAST_ADDRESS && !answered)
+  if (wire_address == modbus::BROADCAST_ADDRESS)
     this->controller_->unqueue_command(this);
 }
 
@@ -288,8 +285,8 @@ void ModbusController::queue_command(ModbusCommandItem command) {
   this->one_shot_command_items_.push_back(make_unique<ModbusCommandItem>(std::move(command)));
   // A refused frame gets no terminal callback (see the hub contract), so reclaim the item here.
   auto &item = this->one_shot_command_items_.back();
-  // One-shots never poll, so only the broadcast flag is passed (the hub strips it from writes).
-  if (!item->send({.allow_broadcast_read = this->read_options_.allow_broadcast_read})) {
+  // We intentionally do not pass read_options_ here, because one-shot commands are usually writes, and are non-polling.
+  if (!item->send()) {
     // The caller (e.g. a write entity) has usually already published optimistically - surface the loss.
     ESP_LOGW(TAG, "Command refused by hub: type=0x%X address=0x%X", static_cast<uint8_t>(item->register_type()),
              item->register_address());
@@ -343,7 +340,7 @@ void ModbusController::update() {
   if (this->can_send()) {
     for (auto &poll : this->polling_devices_) {
       ESP_LOGVV(TAG, "Updating range 0x%X", poll.register_address());
-      // read_options_ carries the controller's read-side flags (the offline probe above sends them too).
+      // read_options_ carries the controller's continuous flag (the offline probe above sends it too).
       // A refusal is already logged by the hub; note the affected range for controller-level diagnostics.
       if (!poll.queue(this->read_options_)) {
         ESP_LOGD(TAG, "Poll refused by hub for range 0x%X", poll.register_address());

esphome/components/modbus_controller/modbus_controller.h

@@ -280,11 +280,10 @@ class ControllerDevice : protected modbus::ModbusClientDevice {
 
   void notify_online_(std::span<const uint8_t> request_pdu);
 
-  /// Write-path state for WriterEntity's forwarders, packed into the base's tail padding. The warn flag
-  /// leaves in 2027.3.0.
-  bool dispatched_ : 1 {false};
-  bool write_buffer_deprecated_warned_ : 1 {false};
-  modbus::CommandOptions write_options_{};
+  /// Write-path state owned by WriterEntity's forwarders, stored here so both bools land in the base's
+  /// tail padding instead of adding a word to every writer entity. The warn flag leaves in 2027.3.0.
+  bool dispatched_{false};
+  bool write_buffer_deprecated_warned_{false};
   ModbusController *controller_{nullptr};
 };
 
@@ -306,8 +305,6 @@ class WriterDevice final : public ControllerDevice {
   bool dispatched() const { return this->dispatched_; }
   void set_dispatched() { this->dispatched_ = true; }
   void clear_dispatched() { this->dispatched_ = false; }
-  modbus::CommandOptions write_options() const { return this->write_options_; }
-  void set_write_options(modbus::CommandOptions options) { this->write_options_ = options; }
   /// Warn once per entity that filling the write_lambda buffer parameter is deprecated (the entity is now the
   /// command - call a write helper / queue_pdu() on `item` instead). The buffer parameter is removed in 2027.3.0.
   void warn_write_buffer_deprecated(const LogString *platform, uint16_t address);
@@ -329,29 +326,27 @@ class WriterEntity {
   /// Whether the lambda called a request helper since the last clear_dispatched_(). Deliberately records
   /// the call, not the hub's accept/refuse: a refused lambda write must not fall through to the default write.
   bool dispatched() const { return this->device_.dispatched(); }
-  void set_write_options(modbus::CommandOptions options) { this->device_.set_write_options(options); }
   bool write_single_register(uint16_t address, uint16_t value) {
     this->device_.set_dispatched();
-    return this->device_.write_single_register(address, value, this->device_.write_options());
+    return this->device_.write_single_register(address, value);
   }
   bool write_single_coil(uint16_t address, bool value) {
     this->device_.set_dispatched();
-    return this->device_.write_single_coil(address, value, this->device_.write_options());
+    return this->device_.write_single_coil(address, value);
   }
   bool write_multiple_registers(uint16_t address, std::span<const uint16_t> values) {
     this->device_.set_dispatched();
-    return this->device_.write_multiple_registers(address, values, this->device_.write_options());
+    return this->device_.write_multiple_registers(address, values);
   }
   bool write_multiple_coils(uint16_t address, std::span<const bool> values) {
     this->device_.set_dispatched();
-    return this->device_.write_multiple_coils(address, values, this->device_.write_options());
+    return this->device_.write_multiple_coils(address, values);
   }
   bool write_multiple_coils(uint16_t address, modbus::PackedBits bits) {
     this->device_.set_dispatched();
-    return this->device_.write_multiple_coils(address, bits, this->device_.write_options());
+    return this->device_.write_multiple_coils(address, bits);
   }
-  bool queue_pdu(std::span<const uint8_t> pdu) { return this->queue_pdu(pdu, this->device_.write_options()); }
-  bool queue_pdu(std::span<const uint8_t> pdu, modbus::CommandOptions options) {
+  bool queue_pdu(std::span<const uint8_t> pdu, modbus::CommandOptions options = {}) {
     this->device_.set_dispatched();
     return this->device_.queue_pdu(pdu, options);
   }

esphome/components/modbus_controller/number/__init__.py

@@ -1,5 +1,5 @@
 import esphome.codegen as cg
-from esphome.components import modbus, number
+from esphome.components import number
 from esphome.components.modbus.helpers import (
     MODBUS_WRITE_REGISTER_TYPE,
     SENSOR_VALUE_TYPE,
@@ -23,8 +23,8 @@ from .. import (
     add_modbus_base_properties,
     modbus_calc_properties,
     modbus_controller_ns,
+    validate_custom_pdu_item,
     validate_range_reuse_migration,
-    validate_writer_item,
 )
 from ..const import (
     CONF_BITMASK,
@@ -84,7 +84,6 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_STEP, default=1): cv.positive_float,
             cv.Optional(CONF_MULTIPLY, default=1.0): cv.float_,
             cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean,
-            **modbus.command_options_schema(direction="write"),
         }
     ),
     validate_min_max,
@@ -92,7 +91,7 @@ CONFIG_SCHEMA = cv.All(
     validate_range_reuse_migration,
 )
 
-FINAL_VALIDATE_SCHEMA = validate_writer_item
+FINAL_VALIDATE_SCHEMA = validate_custom_pdu_item
 
 
 async def to_code(config: ConfigType) -> None:
@@ -123,7 +122,6 @@ async def to_code(config: ConfigType) -> None:
     cg.add(parent.add_sensor_item(var))
     await add_modbus_base_properties(var, config, ModbusNumber)
     cg.add(var.set_use_write_mutiple(config[CONF_USE_WRITE_MULTIPLE]))
-    modbus.add_command_options(var, "set_write_options", config, direction="write")
     if CONF_WRITE_LAMBDA in config:
         template_ = await cg.process_lambda(
             config[CONF_WRITE_LAMBDA],

esphome/components/modbus_controller/output/__init__.py

@@ -1,7 +1,7 @@
 import logging
 
 import esphome.codegen as cg
-from esphome.components import modbus, output
+from esphome.components import output
 from esphome.components.modbus.helpers import (
     SENSOR_VALUE_TYPE,
     PduBuffer,
@@ -18,7 +18,6 @@ from .. import (
     modbus_calc_properties,
     modbus_controller_ns,
     reject_odd_holding_write_offset,
-    validate_writer_item,
 )
 from ..const import (
     CONF_CUSTOM_COMMAND,
@@ -80,7 +79,6 @@ CONFIG_SCHEMA = cv.All(
                     ),
                     cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda,
                     cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean,
-                    **modbus.command_options_schema(direction="write"),
                 }
             ),
             "holding": cv.All(
@@ -100,7 +98,6 @@ CONFIG_SCHEMA = cv.All(
                         cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda,
                         cv.Optional(CONF_MULTIPLY, default=1.0): cv.float_,
                         cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean,
-                        **modbus.command_options_schema(direction="write"),
                     }
                 ),
                 reject_odd_holding_write_offset,
@@ -114,9 +111,6 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-FINAL_VALIDATE_SCHEMA = validate_writer_item
-
-
 async def to_code(config: ConfigType) -> None:
     byte_offset = modbus_calc_properties(config)
     # Binary Output
@@ -159,7 +153,6 @@ async def to_code(config: ConfigType) -> None:
     await output.register_output(var, config)
     parent = await cg.get_variable(config[CONF_MODBUS_CONTROLLER_ID])
     cg.add(var.set_use_write_mutiple(config[CONF_USE_WRITE_MULTIPLE]))
-    modbus.add_command_options(var, "set_write_options", config, direction="write")
     cg.add(var.set_parent(parent))
     if write_template:
         cg.add(var.set_write_template(write_template))

esphome/components/modbus_controller/select/__init__.py

@@ -2,7 +2,7 @@ from collections.abc import Callable
 from typing import Any
 
 import esphome.codegen as cg
-from esphome.components import modbus, select
+from esphome.components import select
 from esphome.components.modbus.helpers import SENSOR_VALUE_TYPE, RegisterValues
 import esphome.config_validation as cv
 from esphome.const import CONF_ADDRESS, CONF_ID, CONF_LAMBDA, CONF_OPTIMISTIC
@@ -15,7 +15,6 @@ from .. import (
     modbus_controller_ns,
     validate_range_reuse_migration,
     validate_skip_updates_deprecated,
-    validate_writer_item,
 )
 from ..const import (
     CONF_FORCE_NEW_RANGE,
@@ -78,7 +77,6 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_REGISTER_COUNT): cv.positive_int,
             cv.Required(CONF_OPTIONSMAP): ensure_option_map(),
             cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean,
-            **modbus.command_options_schema(direction="write"),
             cv.Optional(CONF_OPTIMISTIC, default=False): cv.boolean,
             cv.Optional(CONF_LAMBDA): cv.returning_lambda,
             cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda,
@@ -88,9 +86,6 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-FINAL_VALIDATE_SCHEMA = validate_writer_item
-
-
 async def to_code(config: ConfigType) -> None:
     options_map = config[CONF_OPTIONSMAP]
 
@@ -109,7 +104,6 @@ async def to_code(config: ConfigType) -> None:
     cg.add(parent.add_sensor_item(var))
     cg.add(var.set_parent(parent))
     cg.add(var.set_use_write_mutiple(config[CONF_USE_WRITE_MULTIPLE]))
-    modbus.add_command_options(var, "set_write_options", config, direction="write")
     cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
 
     if CONF_LAMBDA in config:

esphome/components/modbus_controller/switch/__init__.py

@@ -1,5 +1,5 @@
 import esphome.codegen as cg
-from esphome.components import modbus, switch
+from esphome.components import switch
 from esphome.components.modbus.helpers import MODBUS_REGISTER_TYPE, PduBuffer
 import esphome.config_validation as cv
 from esphome.const import CONF_ADDRESS, CONF_ASSUMED_STATE, CONF_ID
@@ -13,9 +13,9 @@ from .. import (
     modbus_calc_properties,
     modbus_controller_ns,
     reject_odd_holding_write_offset,
+    validate_custom_pdu_item,
     validate_modbus_register,
     validate_range_reuse_migration,
-    validate_writer_item,
 )
 from ..const import (
     CONF_BITMASK,
@@ -51,7 +51,6 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_ASSUMED_STATE, default=False): cv.boolean,
             cv.Optional(CONF_REGISTER_TYPE): cv.enum(MODBUS_REGISTER_TYPE),
             cv.Optional(CONF_USE_WRITE_MULTIPLE, default=False): cv.boolean,
-            **modbus.command_options_schema(direction="write"),
             cv.Optional(CONF_WRITE_LAMBDA): cv.returning_lambda,
         }
     ),
@@ -60,7 +59,7 @@ CONFIG_SCHEMA = cv.All(
     validate_range_reuse_migration,
 )
 
-FINAL_VALIDATE_SCHEMA = validate_writer_item
+FINAL_VALIDATE_SCHEMA = validate_custom_pdu_item
 
 
 async def to_code(config: ConfigType) -> None:
@@ -79,7 +78,6 @@ async def to_code(config: ConfigType) -> None:
     paren = await cg.get_variable(config[CONF_MODBUS_CONTROLLER_ID])
     cg.add(var.set_parent(paren))
     cg.add(var.set_use_write_mutiple(config[CONF_USE_WRITE_MULTIPLE]))
-    modbus.add_command_options(var, "set_write_options", config, direction="write")
     assumed_state = config[CONF_ASSUMED_STATE]
     cg.add(var.set_assumed_state(assumed_state))
     if not assumed_state:

esphome/components/nextion/display.py

@@ -14,12 +14,7 @@ from esphome.const import (
 )
 from esphome.core import CORE, TimePeriod
 
-from . import (  # noqa: F401  pylint: disable=unused-import
-    FILTER_SOURCE_FILES,
-    Nextion,
-    nextion_ns,
-    nextion_ref,
-)
+from . import FILTER_SOURCE_FILES, Nextion, nextion_ns, nextion_ref  # noqa: F401  pylint: disable=unused-import
 from .base_component import (
     CONF_AUTO_WAKE_ON_TOUCH,
     CONF_COMMAND_SPACING,

esphome/components/nextion/nextion.cpp

@@ -13,11 +13,6 @@ namespace esphome::nextion {
 
 static const char *const TAG = "nextion";
 
-// A user entity may be named sleep_wake too; only the internal NO_RESULT command clears the sleeping flag
-static bool is_sleep_wake_command(const NextionComponentBase *component) {
-  return component->get_queue_type() == NextionQueueType::NO_RESULT && component->get_variable_name() == "sleep_wake";
-}
-
 // Nextion command terminator: three consecutive 0xFF bytes (per Nextion Instruction Set v1.1).
 static constexpr uint8_t COMMAND_DELIMITER[3] = {0xFF, 0xFF, 0xFF};
 static constexpr size_t DELIMITER_SIZE = sizeof(COMMAND_DELIMITER);
@@ -168,17 +163,6 @@ bool Nextion::check_connect_() {
 #endif  // USE_NEXTION_CONFIG_SKIP_CONNECTION_HANDSHAKE
 }
 
-// NO_RESULT components are owned by their entry; every other component is a user entity. Entry and
-// component storage comes from RAMAllocator, so delete is not valid for either.
-void Nextion::release_queue_entry_(NextionQueue *nb) {
-  if (nb->component != nullptr && nb->component->get_queue_type() == NextionQueueType::NO_RESULT) {
-    nb->component->~NextionComponentBase();
-    RAMAllocator<NextionComponentBase>().deallocate(nb->component, 1);
-  }
-  nb->~NextionQueue();
-  RAMAllocator<NextionQueue>().deallocate(nb, 1);
-}
-
 void Nextion::reset_(bool reset_nextion) {
   uint8_t d;
 
@@ -186,12 +170,15 @@ void Nextion::reset_(bool reset_nextion) {
     this->read_byte(&d);
   }
   for (auto *entry : this->nextion_queue_) {
-    this->release_queue_entry_(entry);
+    if (entry->component != nullptr && entry->component->get_queue_type() == NextionQueueType::NO_RESULT) {
+      delete entry->component;  // NOLINT(cppcoreguidelines-owning-memory)
+    }
+    delete entry;  // NOLINT(cppcoreguidelines-owning-memory)
   }
   this->nextion_queue_.clear();
 #ifdef USE_NEXTION_WAVEFORM
   for (auto *entry : this->waveform_queue_) {
-    this->release_queue_entry_(entry);
+    delete entry;  // NOLINT(cppcoreguidelines-owning-memory)
   }
   this->waveform_queue_.clear();
 #endif  // USE_NEXTION_WAVEFORM
@@ -434,9 +421,6 @@ bool Nextion::remove_from_q_(bool report_empty) {
   NextionQueue *nb = this->nextion_queue_.front();
   if (!nb || !nb->component) {
     ESP_LOGE(TAG, "Invalid queue");
-    if (nb != nullptr) {
-      this->release_queue_entry_(nb);
-    }
     this->nextion_queue_.pop_front();
     return false;
   }
@@ -444,10 +428,13 @@ bool Nextion::remove_from_q_(bool report_empty) {
 
   ESP_LOGN(TAG, "Removed: %s", component->get_variable_name().c_str());
 
-  if (is_sleep_wake_command(component)) {
-    this->is_sleeping_ = false;
+  if (component->get_queue_type() == NextionQueueType::NO_RESULT) {
+    if (component->get_variable_name() == "sleep_wake") {
+      this->is_sleeping_ = false;
+    }
+    delete component;  // NOLINT(cppcoreguidelines-owning-memory)
   }
-  this->release_queue_entry_(nb);
+  delete nb;  // NOLINT(cppcoreguidelines-owning-memory)
   this->nextion_queue_.pop_front();
   return true;
 }
@@ -557,7 +544,7 @@ void Nextion::process_nextion_commands_() {
           ESP_LOGW(TAG, "Invalid waveform ID %d/ch %d", component->get_component_id(),
                    component->get_wave_channel_id());
           ESP_LOGN(TAG, "Remove waveform ID %d/ch %d", component->get_component_id(), component->get_wave_channel_id());
-          this->release_queue_entry_(nb);
+          delete nb;  // NOLINT(cppcoreguidelines-owning-memory)
           this->waveform_queue_.pop();
         }
 #else   // USE_NEXTION_WAVEFORM
@@ -660,9 +647,6 @@ void Nextion::process_nextion_commands_() {
         NextionQueue *nb = this->nextion_queue_.front();
         if (!nb || !nb->component) {
           ESP_LOGE(TAG, "Invalid queue entry");
-          if (nb != nullptr) {
-            this->release_queue_entry_(nb);
-          }
           this->nextion_queue_.pop_front();
           return;
         }
@@ -676,7 +660,7 @@ void Nextion::process_nextion_commands_() {
           component->set_state_from_string(to_process, true, false);
         }
 
-        this->release_queue_entry_(nb);
+        delete nb;  // NOLINT(cppcoreguidelines-owning-memory)
         this->nextion_queue_.pop_front();
 
         break;
@@ -703,9 +687,6 @@ void Nextion::process_nextion_commands_() {
         NextionQueue *nb = this->nextion_queue_.front();
         if (!nb || !nb->component) {
           ESP_LOGE(TAG, "Invalid queue");
-          if (nb != nullptr) {
-            this->release_queue_entry_(nb);
-          }
           this->nextion_queue_.pop_front();
           return;
         }
@@ -722,7 +703,7 @@ void Nextion::process_nextion_commands_() {
           component->set_state_from_int(value, true, false);
         }
 
-        this->release_queue_entry_(nb);
+        delete nb;  // NOLINT(cppcoreguidelines-owning-memory)
         this->nextion_queue_.pop_front();
 
         break;
@@ -909,7 +890,7 @@ void Nextion::process_nextion_commands_() {
         ESP_LOGN(TAG, "Send waveform: component id %d, waveform id %d, size %zu", component->get_component_id(),
                  component->get_wave_channel_id(), buffer_to_send);
         component->clear_wave_buffer(buffer_to_send);
-        this->release_queue_entry_(nb);
+        delete nb;  // NOLINT(cppcoreguidelines-owning-memory)
         this->waveform_queue_.pop();
 #else   // USE_NEXTION_WAVEFORM
         ESP_LOGW(TAG, "Waveform transmit ready but waveform not enabled");
@@ -939,10 +920,14 @@ void Nextion::purge_stale_queue_entries_() {
         ESP_LOGV(TAG, "Remove old queue '%s':'%s'", component->get_queue_type_string(),
                  component->get_variable_name().c_str());
 
-        if (is_sleep_wake_command(component)) {
-          this->is_sleeping_ = false;
+        if (component->get_queue_type() == NextionQueueType::NO_RESULT) {
+          if (component->get_variable_name() == "sleep_wake") {
+            this->is_sleeping_ = false;
+          }
+          delete component;  // NOLINT(cppcoreguidelines-owning-memory)
         }
-        this->release_queue_entry_(*it);
+
+        delete *it;  // NOLINT(cppcoreguidelines-owning-memory)
         it = this->nextion_queue_.erase(it);
 
       } else {
@@ -1094,34 +1079,6 @@ uint16_t Nextion::recv_ret_string_(std::string &response, uint32_t timeout, bool
   return response.length();
 }
 
-// Allocates a queue entry owning a bare NO_RESULT component; nullptr when the queue is full or memory is out
-NextionQueue *Nextion::make_no_result_entry_(const std::string &variable_name) {
-#ifdef USE_NEXTION_MAX_QUEUE_SIZE
-  if (this->max_queue_size_ > 0 && this->nextion_queue_.size() >= this->max_queue_size_) {
-    ESP_LOGW(TAG, "Queue full (%zu), drop: %s", this->nextion_queue_.size(), variable_name.c_str());
-    return nullptr;
-  }
-#endif
-
-  auto *nextion_queue = RAMAllocator<nextion::NextionQueue>().allocate(1);
-  if (nextion_queue == nullptr) {
-    ESP_LOGW(TAG, "Queue alloc failed");
-    return nullptr;
-  }
-  new (nextion_queue) nextion::NextionQueue;
-
-  nextion_queue->component = RAMAllocator<nextion::NextionComponentBase>().allocate(1);
-  if (nextion_queue->component == nullptr) {
-    ESP_LOGW(TAG, "Component alloc failed");
-    this->release_queue_entry_(nextion_queue);
-    return nullptr;
-  }
-  new (nextion_queue->component) nextion::NextionComponentBase;
-  nextion_queue->component->set_variable_name(variable_name);
-  nextion_queue->queue_time = App.get_loop_component_start_time();
-  return nextion_queue;
-}
-
 /**
  * @brief Add a command to the Nextion queue that expects no response.
  *
@@ -1133,11 +1090,36 @@ NextionQueue *Nextion::make_no_result_entry_(const std::string &variable_name) {
  * @param variable_name Name of the variable or component associated with the command.
  */
 void Nextion::add_no_result_to_queue_(const std::string &variable_name) {
-  auto *nextion_queue = this->make_no_result_entry_(variable_name);
-  if (nextion_queue == nullptr)
+#ifdef USE_NEXTION_MAX_QUEUE_SIZE
+  if (this->max_queue_size_ > 0 && this->nextion_queue_.size() >= this->max_queue_size_) {
+    ESP_LOGW(TAG, "Queue full (%zu), drop: %s", this->nextion_queue_.size(), variable_name.c_str());
     return;
+  }
+#endif
+
+  RAMAllocator<nextion::NextionQueue> allocator;
+  nextion::NextionQueue *nextion_queue = allocator.allocate(1);
+  if (nextion_queue == nullptr) {
+    ESP_LOGW(TAG, "Queue alloc failed");
+    return;
+  }
+  new (nextion_queue) nextion::NextionQueue();
+
+  // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
+  nextion_queue->component = new (std::nothrow) nextion::NextionComponentBase;
+  if (nextion_queue->component == nullptr) {
+    ESP_LOGW(TAG, "Component alloc failed");
+    nextion_queue->~NextionQueue();
+    allocator.deallocate(nextion_queue, 1);
+    return;
+  }
+  nextion_queue->component->set_variable_name(variable_name);
+
+  nextion_queue->queue_time = App.get_loop_component_start_time();
+
   this->nextion_queue_.push_back(nextion_queue);
-  ESP_LOGN(TAG, "Queue NORESULT: %s", variable_name.c_str());
+
+  ESP_LOGN(TAG, "Queue NORESULT: %s", nextion_queue->component->get_variable_name().c_str());
 }
 
 /**
@@ -1171,10 +1153,32 @@ void Nextion::add_no_result_to_queue_with_command_(const std::string &variable_n
 #ifdef USE_NEXTION_COMMAND_SPACING
 void Nextion::add_no_result_to_queue_with_pending_command_(const std::string &variable_name,
                                                            const std::string &command) {
-  auto *nextion_queue = this->make_no_result_entry_(variable_name);
-  if (nextion_queue == nullptr)
+#ifdef USE_NEXTION_MAX_QUEUE_SIZE
+  if (this->max_queue_size_ > 0 && this->nextion_queue_.size() >= this->max_queue_size_) {
+    ESP_LOGW(TAG, "Queue full (%zu), drop: %s", this->nextion_queue_.size(), variable_name.c_str());
     return;
+  }
+#endif
+
+  RAMAllocator<nextion::NextionQueue> allocator;
+  nextion::NextionQueue *nextion_queue = allocator.allocate(1);
+  if (nextion_queue == nullptr) {
+    ESP_LOGW(TAG, "Queue alloc failed");
+    return;
+  }
+  new (nextion_queue) nextion::NextionQueue();
+
+  nextion_queue->component = new (std::nothrow) nextion::NextionComponentBase;
+  if (nextion_queue->component == nullptr) {
+    ESP_LOGW(TAG, "Component alloc failed");
+    nextion_queue->~NextionQueue();
+    allocator.deallocate(nextion_queue, 1);
+    return;
+  }
+  nextion_queue->component->set_variable_name(variable_name);
+  nextion_queue->queue_time = App.get_loop_component_start_time();
   nextion_queue->pending_command = command;  // Store command for retry
+
   this->nextion_queue_.push_back(nextion_queue);
   ESP_LOGVV(TAG, "Queue with pending command: %s", variable_name.c_str());
 }
@@ -1308,7 +1312,7 @@ void Nextion::add_to_get_queue(NextionComponentBase *component) {
     ESP_LOGW(TAG, "Queue alloc failed");
     return;
   }
-  new (nextion_queue) nextion::NextionQueue;
+  new (nextion_queue) nextion::NextionQueue();
 
   nextion_queue->component = component;
   nextion_queue->queue_time = App.get_loop_component_start_time();
@@ -1330,7 +1334,7 @@ void Nextion::add_to_get_queue(NextionComponentBase *component) {
   if (this->send_command_(command)) {
     this->nextion_queue_.push_back(nextion_queue);
   } else {
-    this->release_queue_entry_(nextion_queue);
+    delete nextion_queue;  // NOLINT(cppcoreguidelines-owning-memory)
   }
 #endif  // USE_NEXTION_COMMAND_SPACING
 }
@@ -1351,14 +1355,14 @@ void Nextion::add_addt_command_to_queue(NextionComponentBase *component) {
     ESP_LOGW(TAG, "Queue alloc failed");
     return;
   }
-  new (nextion_queue) nextion::NextionQueue;
+  new (nextion_queue) nextion::NextionQueue();
 
   nextion_queue->component = component;
   nextion_queue->queue_time = App.get_loop_component_start_time();
 
   if (!this->waveform_queue_.push(nextion_queue)) {
     ESP_LOGW(TAG, "Waveform queue full, drop");
-    this->release_queue_entry_(nextion_queue);
+    delete nextion_queue;  // NOLINT(cppcoreguidelines-owning-memory)
     return;
   }
   if (this->waveform_queue_.size() == 1)

esphome/components/nextion/nextion.h

@@ -1469,8 +1469,6 @@ class Nextion final : public NextionBase, public PollingComponent, public uart::
   void all_components_send_state_(bool force_update = false);
   uint32_t comok_sent_ = 0;
   bool remove_from_q_(bool report_empty = true);
-  void release_queue_entry_(NextionQueue *nb);
-  NextionQueue *make_no_result_entry_(const std::string &variable_name);
 
   /**
    * @brief Status flags for Nextion display state management