[api] Print the dropped action's service with its length

The field can now start as a null StringRef, so the log passes the size and an empty
literal instead of a pointer that may be null.

.github/workflows/ci.yml

@@ -244,20 +244,11 @@ 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:
-          prek-version: ${{ steps.prek.outputs.version }}
+          # Keep in sync with requirements_test.txt.
+          prek-version: "0.4.11"
           # 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 merge the latest dev branch into your
+        to keep it open. Also, please rebase your PR onto the latest dev
         branch to ensure that it's up to date with the latest changes.
 
         Thank you for your contribution!

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

@@ -1,94 +0,0 @@
-# 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,6 +1,7 @@
 ---
 # 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
@@ -10,7 +11,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.16.6
+    rev: v0.16.3
     hooks:
       # Run the linter.
       - id: ruff
@@ -41,7 +42,7 @@ repos:
       - id: pyupgrade
         args: [--py312-plus]
   - repo: https://github.com/adrienverge/yamllint.git
-    rev: v1.38.0
+    rev: v1.37.1
     hooks:
       - id: yamllint
         exclude: ^(\.clang-format|\.clang-tidy)$

AGENTS.md

@@ -840,7 +840,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:

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.6
+RUN uv pip install --no-cache-dir esphome-device-builder==1.14.4
 
 RUN \
     platformio settings set enable_telemetry No \

esphome/api_client.py

@@ -23,7 +23,9 @@ 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/anova/anova.cpp

@@ -13,7 +13,7 @@ void Anova::dump_config() { LOG_CLIMATE("", "Anova BLE Cooker", this); }
 
 void Anova::setup() {
   this->codec_ = make_unique<AnovaCodec>();
-  this->poll_step_ = PollStep::IDLE;
+  this->current_request_ = 0;
 }
 
 void Anova::loop() {
@@ -22,15 +22,6 @@ void Anova::loop() {
   this->disable_loop();
 }
 
-void Anova::write_request_(AnovaPacket *pkt) {
-  auto status =
-      esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
-                               pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
-  if (status) {
-    ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
-  }
-}
-
 void Anova::control(const ClimateCall &call) {
   auto mode_val = call.get_mode();
   if (mode_val.has_value()) {
@@ -47,11 +38,22 @@ void Anova::control(const ClimateCall &call) {
         ESP_LOGW(TAG, "Unsupported mode: %d", mode);
         return;
     }
-    this->write_request_(pkt);
+    auto status =
+        esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                 pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+    if (status) {
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
+    }
   }
   auto target_temp = call.get_target_temperature();
   if (target_temp.has_value()) {
-    this->write_request_(this->codec_->get_set_target_temp_request(*target_temp));
+    auto *pkt = this->codec_->get_set_target_temp_request(*target_temp);
+    auto status =
+        esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                 pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+    if (status) {
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
+    }
   }
 }
 
@@ -60,7 +62,6 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
     case ESP_GATTC_DISCONNECT_EVT: {
       this->current_temperature = NAN;
       this->target_temperature = NAN;
-      this->poll_step_ = PollStep::IDLE;
       this->publish_state();
       break;
     }
@@ -82,8 +83,8 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
     }
     case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
       this->node_state = espbt::ClientState::ESTABLISHED;
-      this->poll_step_ = PollStep::IDLE;
-      this->update();  // begin the first poll cycle immediately
+      this->current_request_ = 0;
+      this->update();
       break;
     }
     case ESP_GATTC_NOTIFY_EVT: {
@@ -100,30 +101,33 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
         this->mode = this->codec_->running_ ? climate::CLIMATE_MODE_HEAT : climate::CLIMATE_MODE_OFF;
       }
       if (this->codec_->has_unit()) {
-        ESP_LOGD(TAG, "Anova units is %s", (this->codec_->unit_ == 'f') ? "fahrenheit" : "celsius");
+        this->fahrenheit_ = (this->codec_->unit_ == 'f');
+        ESP_LOGD(TAG, "Anova units is %s", this->fahrenheit_ ? "fahrenheit" : "celsius");
+        this->current_request_++;
       }
       this->publish_state();
 
-      // Advance the poll cycle to its next request based on the reply we got.
-      switch (this->poll_step_) {
-        case PollStep::SET_UNIT:
-          this->poll_step_ = PollStep::STATUS;
-          this->write_request_(this->codec_->get_read_device_status_request());
-          break;
-        case PollStep::STATUS:
-          this->poll_step_ = PollStep::TARGET;
-          this->write_request_(this->codec_->get_read_target_temp_request());
-          break;
-        case PollStep::TARGET:
-          this->poll_step_ = PollStep::CURRENT;
-          this->write_request_(this->codec_->get_read_current_temp_request());
-          break;
-        case PollStep::CURRENT:
-          this->poll_step_ = PollStep::IDLE;  // full cycle complete
-          break;
-        default:
-          // A reply to an ad-hoc control() write, outside a managed cycle.
-          break;
+      if (this->current_request_ > 1) {
+        AnovaPacket *pkt = nullptr;
+        switch (this->current_request_++) {
+          case 2:
+            pkt = this->codec_->get_read_target_temp_request();
+            break;
+          case 3:
+            pkt = this->codec_->get_read_current_temp_request();
+            break;
+          default:
+            this->current_request_ = 1;
+            break;
+        }
+        if (pkt != nullptr) {
+          auto status =
+              esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                       pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+          if (status) {
+            ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
+          }
+        }
       }
       break;
     }
@@ -132,26 +136,27 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
   }
 }
 
-void Anova::set_unit_of_measurement(const char *unit) { this->want_fahrenheit_ = !strncmp(unit, "f", 1); }
+void Anova::set_unit_of_measurement(const char *unit) { this->fahrenheit_ = !strncmp(unit, "f", 1); }
 
 void Anova::update() {
   if (this->node_state != espbt::ClientState::ESTABLISHED)
     return;
-  if (this->poll_step_ != PollStep::IDLE) {
-    // The previous cycle never finished within a full polling interval -- a
-    // reply was missed or a write failed. Restart the cycle rather than stall;
-    // the polling interval itself acts as the timeout. A late reply from the
-    // abandoned cycle is harmless: state decoding happens on every notify
-    // regardless of step, and each notify sends at most one follow-up request.
-    ESP_LOGW(TAG, "[%s] Poll cycle incomplete (step %u); restarting cycle", this->parent_->address_str(),
-             static_cast<uint8_t>(this->poll_step_));
+
+  if (this->current_request_ < 2) {
+    AnovaPacket *pkt;
+    if (this->current_request_ == 0) {
+      pkt = this->codec_->get_set_unit_request(this->fahrenheit_ ? 'f' : 'c');
+    } else {
+      pkt = this->codec_->get_read_device_status_request();
+    }
+    auto status =
+        esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+                                 pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+    if (status) {
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
+    }
+    this->current_request_++;
   }
-  // Re-assert the configured unit at the start of every poll cycle, then fall
-  // through the status/temperature reads via the notification handler. Always
-  // command the configured unit (want_fahrenheit_) -- never the last value the
-  // device reported, or a drift to 'c' would lock itself in.
-  this->poll_step_ = PollStep::SET_UNIT;
-  this->write_request_(this->codec_->get_set_unit_request(this->want_fahrenheit_ ? 'f' : 'c'));
 }
 
 }  // namespace esphome::anova

esphome/components/anova/anova.h

@@ -37,20 +37,11 @@ class Anova final : public climate::Climate, public esphome::ble_client::BLEClie
   void set_unit_of_measurement(const char *unit);
 
  protected:
-  // A poll cycle re-asserts the configured unit, then reads device state.
-  // Re-asserting every cycle prevents the cooker from silently reverting to
-  // its default (Celsius); previously the unit was only set once on
-  // connection, so a drift persisted (and corrupted the F/C interpretation of
-  // subsequent readings) until the BLE link was re-established.
-  enum class PollStep : uint8_t { SET_UNIT, STATUS, TARGET, CURRENT, IDLE };
-
-  void write_request_(AnovaPacket *pkt);
-
   std::unique_ptr<AnovaCodec> codec_;
   void control(const climate::ClimateCall &call) override;
   uint16_t char_handle_;
-  bool want_fahrenheit_{true};  // configured target unit; never overwritten by device replies
-  PollStep poll_step_{PollStep::IDLE};
+  uint8_t current_request_;
+  bool fahrenheit_;
 };
 
 }  // namespace esphome::anova

esphome/components/api/api.proto

@@ -77,7 +77,6 @@ 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) {}
 }
 
 
@@ -2727,8 +2726,7 @@ enum SerialProxyParity {
   SERIAL_PROXY_PARITY_ODD = 2;
 }
 
-// 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).
+// Configure UART parameters for a serial proxy instance
 message SerialProxyConfigureRequest {
   option (id) = 138;
   option (source) = SOURCE_CLIENT;
@@ -2754,8 +2752,7 @@ message SerialProxyDataReceived {
   bytes data = 2;               // Raw data received from the serial device
 }
 
-// Write data to a serial device. Only the subscribed client may write; writes from
-// others are ignored (since API 1.17).
+// Write data to a serial device
 message SerialProxyWriteRequest {
   option (id) = 140;
   option (source) = SOURCE_CLIENT;
@@ -2766,8 +2763,7 @@ message SerialProxyWriteRequest {
   bytes data = 2;               // Raw data to write to the serial device
 }
 
-// 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).
+// Set modem control pin states (RTS and DTR)
 message SerialProxySetModemPinsRequest {
   option (id) = 141;
   option (source) = SOURCE_CLIENT;
@@ -2806,7 +2802,6 @@ 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 {
@@ -2819,8 +2814,7 @@ enum SerialProxyStatus {
   SERIAL_PROXY_STATUS_INVALID_ARGUMENT = 6; // Invalid instance index or parameter value
 }
 
-// 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).
+// Generic request message for simple serial proxy operations
 message SerialProxyRequest {
   option (id) = 144;
   option (source) = SOURCE_CLIENT;
@@ -2844,29 +2838,6 @@ 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_connection.cpp

@@ -1661,7 +1661,6 @@ 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;
@@ -1674,19 +1673,6 @@ 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");
@@ -1813,7 +1799,7 @@ bool APIConnection::send_hello_response_(const HelloRequest &msg) {
 
   HelloResponse resp;
   resp.api_version_major = 1;
-  resp.api_version_minor = 17;
+  resp.api_version_minor = 16;
   // 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());
@@ -2269,7 +2255,12 @@ bool APIConnection::send_message_(uint32_t payload_size, uint16_t message_type,
   // Capacity reserved above, cannot fail
   (void) shared_buf.resize(write_start + payload_size);
   ProtoWriteBuffer buffer{&shared_buf, write_start};
-  encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
+  uint8_t *end = encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
+#ifdef ESPHOME_DEBUG_API
+  assert(end == shared_buf.data() + shared_buf.size());
+#else
+  (void) end;
+#endif
   return this->send_buffer(ProtoWriteBuffer{&shared_buf}, message_type);
 }
 // encode_to_buffer is defined inline in api_connection.h (ESPHOME_ALWAYS_INLINE)

esphome/components/api/api_connection.h

@@ -244,7 +244,6 @@ 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
 
@@ -346,11 +345,7 @@ class APIConnection final : public APIServerConnectionBase {
   /// Returns false as soon as the TCP buffer is full. Marked nodiscard so we
   /// have no silent failures: every caller must handle (or log) a refusal.
   template<typename T> [[nodiscard]] bool send_message(const T &msg) {
-    if constexpr (T::ESTIMATED_SIZE == 0) {
-      return this->send_message_(0, T::MESSAGE_TYPE, &encode_msg_noop, &msg);
-    } else {
-      return this->send_message_(msg.calculate_size(), T::MESSAGE_TYPE, &proto_encode_msg<T>, &msg);
-    }
+    return this->send_message_(T::calc_size_msg(&msg), T::MESSAGE_TYPE, &T::encode_msg, &msg);
   }
 
   /// Clear the shared write buffer and reserve space for the first message.
@@ -406,16 +401,6 @@ class APIConnection final : public APIServerConnectionBase {
   void process_state_subscriptions_();
 #endif
 
-  // Size thunk — converts void* back to concrete type for direct calculate_size() call
-  template<typename T> static uint32_t calc_size(const void *msg) {
-    return static_cast<const T *>(msg)->calculate_size();
-  }
-
-  // Shared no-op encode thunk for empty messages (ESTIMATED_SIZE == 0)
-  static uint8_t *encode_msg_noop(const void *, ProtoWriteBuffer &buf PROTO_ENCODE_DEBUG_PARAM) {
-    return buf.get_pos();
-  }
-
   // Non-template buffer management for send_message
   bool send_message_(uint32_t payload_size, uint16_t message_type, MessageEncodeFn encode_fn, const void *msg);
 
@@ -434,11 +419,7 @@ class APIConnection final : public APIServerConnectionBase {
   // Hot paths (state/info) go through fill_and_encode_entity_state/info instead.
   // batch_message_type_ is already set by dispatch_message_ before reaching here.
   template<typename T> static uint16_t encode_message_to_buffer(T &msg, APIConnection *conn, uint32_t remaining_size) {
-    if constexpr (T::ESTIMATED_SIZE == 0) {
-      return encode_to_buffer_slow(0, &encode_msg_noop, &msg, conn, remaining_size);
-    } else {
-      return encode_to_buffer_slow(msg.calculate_size(), &proto_encode_msg<T>, &msg, conn, remaining_size);
-    }
+    return encode_to_buffer_slow(T::calc_size_msg(&msg), &T::encode_msg, &msg, conn, remaining_size);
   }
 
   // Non-template core — fills state fields and encodes
@@ -450,7 +431,7 @@ class APIConnection final : public APIServerConnectionBase {
   template<typename T>
   static uint16_t fill_and_encode_entity_state(EntityBase *entity, T &msg, APIConnection *conn,
                                                uint32_t remaining_size) {
-    return fill_and_encode_entity_state(entity, msg, &calc_size<T>, &proto_encode_msg<T>, conn, remaining_size);
+    return fill_and_encode_entity_state(entity, msg, &T::calc_size_msg, &T::encode_msg, conn, remaining_size);
   }
 
   // Non-template core — fills info fields, allocates buffers, and encodes
@@ -462,7 +443,7 @@ class APIConnection final : public APIServerConnectionBase {
   template<typename T>
   static uint16_t fill_and_encode_entity_info(EntityBase *entity, T &msg, APIConnection *conn,
                                               uint32_t remaining_size) {
-    return fill_and_encode_entity_info(entity, msg, &calc_size<T>, &proto_encode_msg<T>, conn, remaining_size);
+    return fill_and_encode_entity_info(entity, msg, &T::calc_size_msg, &T::encode_msg, conn, remaining_size);
   }
 
   // Non-template core — fills device_class, then delegates to fill_and_encode_entity_info
@@ -476,8 +457,8 @@ class APIConnection final : public APIServerConnectionBase {
   static uint16_t fill_and_encode_entity_info_with_device_class(EntityBase *entity, T &msg,
                                                                 StringRef &device_class_field, APIConnection *conn,
                                                                 uint32_t remaining_size) {
-    return fill_and_encode_entity_info_with_device_class(entity, msg, device_class_field, &calc_size<T>,
-                                                         &proto_encode_msg<T>, conn, remaining_size);
+    return fill_and_encode_entity_info_with_device_class(entity, msg, device_class_field, &T::calc_size_msg,
+                                                         &T::encode_msg, conn, remaining_size);
   }
 
 #ifdef USE_VOICE_ASSISTANT

esphome/components/api/api_connection_buffer.h

@@ -46,7 +46,13 @@ inline uint16_t ESPHOME_ALWAYS_INLINE APIConnection::encode_to_buffer(uint32_t c
     return 0;
   }
   ProtoWriteBuffer buffer{&shared_buf, shared_buf.size() - calculated_size};
-  encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
+  uint8_t *end = encode_fn(msg, buffer PROTO_ENCODE_DEBUG_INIT(&shared_buf));
+#ifdef ESPHOME_DEBUG_API
+  // A body that writes fewer bytes than calculate_size() promised would ship stale buffer bytes
+  assert(end == shared_buf.data() + shared_buf.size());
+#else
+  (void) end;
+#endif
 
   return total_calculated_size;
 }

esphome/components/api/api_pb2_dump.cpp

@@ -854,8 +854,6 @@ 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");
   }
@@ -880,16 +878,6 @@ 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 {
@@ -2817,12 +2805,6 @@ 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,17 +712,6 @@ 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,9 +235,6 @@ 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/api/api_server.cpp

@@ -433,8 +433,9 @@ void APIServer::send_homeassistant_action(const HomeassistantActionRequest &call
     // Home Assistant subscribes to actions shortly *after* authenticating, so actions
     // fired right at connection time (on_client_connected, on_time_sync, ...) can
     // arrive before the subscription and are lost - warn instead of failing silently.
-    ESP_LOGW(TAG, "Home Assistant %s '%s' dropped; %s",
-             call.is_event ? LOG_STR_LITERAL("event") : LOG_STR_LITERAL("action"), call.service.c_str(),
+    ESP_LOGW(TAG, "Home Assistant %s '%.*s' dropped; %s",
+             call.is_event ? LOG_STR_LITERAL("event") : LOG_STR_LITERAL("action"),
+             static_cast<int>(call.service.size()), call.service.empty() ? "" : call.service.c_str(),
              this->is_connected() ? LOG_STR_LITERAL("client has not subscribed to actions (yet)")
                                   : LOG_STR_LITERAL("no client connected"));
   }

esphome/components/api/proto.cpp

@@ -214,73 +214,74 @@ void ProtoDecodableMessage::decode(const uint8_t *buffer, size_t length) {
   const uint8_t *ptr = buffer;
   const uint8_t *end = buffer + length;
 
-  while (ptr < end) {
-    // Parse field header - ptr < end guarantees len >= 1
+  // Single-byte varints dominate, so that case advances the cursor inline.
+  auto read_varint = [&](proto_varint_value_t &value) ESPHOME_ALWAYS_INLINE {
+    if (ptr == end)
+      return false;
+    if (*ptr < 0x80) [[likely]] {
+      value = *ptr++;
+      return true;
+    }
     auto res = ProtoVarInt::parse_non_empty(ptr, end - ptr);
-    if (!res.has_value()) {
+    if (!res.has_value())
+      return false;
+    value = res.value;
+    ptr += res.consumed;
+    return true;
+  };
+
+  while (ptr < end) {
+    proto_varint_value_t tag_value;
+    if (!read_varint(tag_value)) {
       ESP_LOGV(TAG, "Invalid field start at offset %ld", (long) (ptr - buffer));
       return;
     }
 
-    uint32_t tag = static_cast<uint32_t>(res.value);
+    uint32_t tag = static_cast<uint32_t>(tag_value);
     uint32_t field_type = tag & WIRE_TYPE_MASK;
-    uint32_t field_id = tag >> 3;
-    ptr += res.consumed;
+    // Length-delimited fields move this past the length prefix
+    const uint8_t *data = ptr;
+    proto_varint_value_t scalar;
 
-    switch (field_type) {
-      case WIRE_TYPE_VARINT: {  // VarInt
-        res = ProtoVarInt::parse(ptr, end - ptr);
-        if (!res.has_value()) {
-          ESP_LOGV(TAG, "Invalid VarInt at offset %ld", (long) (ptr - buffer));
-          return;
-        }
-        if (!this->decode_varint(field_id, res.value)) {
-          ESP_LOGV(TAG, "Cannot decode VarInt field %" PRIu32 " with value %" PRIu64 "!", field_id,
-                   static_cast<uint64_t>(res.value));
-        }
-        ptr += res.consumed;
-        break;
-      }
-      case WIRE_TYPE_LENGTH_DELIMITED: {  // Length-delimited
-        res = ProtoVarInt::parse(ptr, end - ptr);
-        if (!res.has_value()) {
-          ESP_LOGV(TAG, "Invalid Length Delimited at offset %ld", (long) (ptr - buffer));
-          return;
-        }
-        uint32_t field_length = static_cast<uint32_t>(res.value);
-        ptr += res.consumed;
-        if (field_length > static_cast<size_t>(end - ptr)) {
-          ESP_LOGV(TAG, "Out-of-bounds Length Delimited at offset %ld", (long) (ptr - buffer));
-          return;
-        }
-        if (!this->decode_length(field_id, ProtoLengthDelimited(ptr, field_length))) {
-          ESP_LOGV(TAG, "Cannot decode Length Delimited field %" PRIu32 "!", field_id);
-        }
-        ptr += field_length;
-        break;
-      }
-      case WIRE_TYPE_FIXED32: {  // 32-bit
-        if (end - ptr < 4) {
-          ESP_LOGV(TAG, "Out-of-bounds Fixed32-bit at offset %ld", (long) (ptr - buffer));
-          return;
-        }
-        uint32_t val;
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-        // Protobuf fixed32 is little-endian — direct load on LE platforms
-        memcpy(&val, ptr, 4);
-#else
-        val = encode_uint32(ptr[3], ptr[2], ptr[1], ptr[0]);
-#endif
-        if (!this->decode_32bit(field_id, Proto32Bit(val))) {
-          ESP_LOGV(TAG, "Cannot decode 32-bit field %" PRIu32 " with value %" PRIu32 "!", field_id, val);
-        }
-        ptr += 4;
-        break;
-      }
-      default:
-        ESP_LOGV(TAG, "Invalid field type %" PRIu32 " at offset %ld", field_type, (long) (ptr - buffer));
+    if (field_type == WIRE_TYPE_VARINT) [[likely]] {
+      if (!read_varint(scalar)) {
+        ESP_LOGV(TAG, "Invalid VarInt at offset %ld", (long) (ptr - buffer));
         return;
+      }
+    } else {
+      switch (field_type) {
+        case WIRE_TYPE_LENGTH_DELIMITED: {
+          proto_varint_value_t length_value;
+          if (!read_varint(length_value)) {
+            ESP_LOGV(TAG, "Invalid Length Delimited at offset %ld", (long) (ptr - buffer));
+            return;
+          }
+          uint32_t field_length = static_cast<uint32_t>(length_value);
+          if (field_length > static_cast<size_t>(end - ptr)) {
+            ESP_LOGV(TAG, "Out-of-bounds Length Delimited at offset %ld", (long) (ptr - buffer));
+            return;
+          }
+          data = ptr;
+          scalar = field_length;
+          ptr += field_length;
+          break;
+        }
+        case WIRE_TYPE_FIXED32: {
+          if (end - ptr < 4) {
+            ESP_LOGV(TAG, "Out-of-bounds Fixed32-bit at offset %ld", (long) (ptr - buffer));
+            return;
+          }
+          // Byte loads instead of memcpy: ESP-IDF passes -fno-builtin-memcpy, which made this a call
+          scalar = encode_uint32(ptr[3], ptr[2], ptr[1], ptr[0]);
+          ptr += 4;
+          break;
+        }
+        default:
+          ESP_LOGV(TAG, "Invalid field type %" PRIu32 " at offset %ld", field_type, (long) (ptr - buffer));
+          return;
+      }
     }
+    this->decode_field(tag, data, scalar);
   }
 }
 

esphome/components/api/proto.h

@@ -170,40 +170,43 @@ class ProtoVarInt {
 class ProtoMessage;
 class ProtoSize;
 
-class ProtoLengthDelimited {
+/// Case label for decode_field(): the wire tag of a field, so a field that arrives with another wire
+/// type matches no case.
+constexpr uint32_t proto_tag(uint32_t field_id, uint32_t wire_type) { return (field_id << 3) | wire_type; }
+
+/// One decoded field: the payload pointer and a scalar holding the varint or fixed32 value, or the
+/// length of a length-delimited field. The wire type in the tag says which applies; accessors do not check.
+class ProtoFieldValue {
  public:
-  explicit ProtoLengthDelimited(const uint8_t *value, size_t length) : value_(value), length_(length) {}
-  std::string as_string() const { return std::string(reinterpret_cast<const char *>(this->value_), this->length_); }
+  ProtoFieldValue(const uint8_t *data, proto_varint_value_t scalar) : data_(data), scalar_(scalar) {}
 
-  // Direct access to raw data without string allocation
-  const uint8_t *data() const { return this->value_; }
-  size_t size() const { return this->length_; }
+  proto_varint_value_t as_varint() const { return this->scalar_; }
+  // A bool is sent as 0 or 1, so the low word is enough and saves a second compare with 64 bit varints
+  bool as_bool() const { return static_cast<uint32_t>(this->scalar_) != 0; }
 
-  /// Decode the length-delimited data into a message instance.
+  // Length-delimited accessors
+  const uint8_t *data() const { return this->data_; }
+  size_t size() const { return static_cast<size_t>(this->scalar_); }
+  std::string as_string() const { return std::string(reinterpret_cast<const char *>(this->data_), this->size()); }
+  /// Decode the length-delimited payload into a message instance.
   /// Template preserves concrete type so decode() resolves statically.
-  template<typename T> void decode_to_message(T &msg) const;
+  template<typename T> void decode_to_message(T &msg) const { msg.decode(this->data_, this->size()); }
 
- protected:
-  const uint8_t *const value_;
-  const size_t length_;
-};
-
-class Proto32Bit {
- public:
-  explicit Proto32Bit(uint32_t value) : value_(value) {}
-  uint32_t as_fixed32() const { return this->value_; }
-  int32_t as_sfixed32() const { return static_cast<int32_t>(this->value_); }
+  // Fixed32 accessors
+  uint32_t as_fixed32() const { return static_cast<uint32_t>(this->scalar_); }
+  int32_t as_sfixed32() const { return static_cast<int32_t>(this->as_fixed32()); }
   float as_float() const {
     union {
       uint32_t raw;
       float value;
     } s{};
-    s.raw = this->value_;
+    s.raw = this->as_fixed32();
     return s.value;
   }
 
- protected:
-  const uint32_t value_;
+ private:
+  const uint8_t *data_;
+  proto_varint_value_t scalar_;
 };
 
 // NOTE: Proto64Bit class removed - wire type 1 (64-bit fixed) not supported
@@ -252,7 +255,7 @@ class ProtoWriteBuffer {
    *
    * Following https://protobuf.dev/programming-guides/encoding/#structure
    */
-  void encode_field_raw(uint32_t field_id, uint32_t type) { this->encode_varint_raw((field_id << 3) | type); }
+  void encode_field_raw(uint32_t field_id, uint32_t type) { this->encode_varint_raw(proto_tag(field_id, type)); }
   /// Single-pass encode for repeated submessage elements.
   /// Thin template wrapper; all buffer work is in the non-template core.
   template<typename T> void encode_sub_message(uint32_t field_id, const T &value);
@@ -287,19 +290,31 @@ class ProtoWriteBuffer {
   uint8_t *pos_;
 };
 
+// A four byte unaligned store is a memcpy call on ESP-IDF (-fno-builtin-memcpy) and on ARM cores without
+// unaligned access (Cortex-M0+, ARM9), so those targets share one outlined byte store helper per fixed32
+// field. Elsewhere the write inlines to a single store, or on ESP8266 to a few stores that measured
+// faster than a call, so it stays inline.
+#if defined(USE_ESP32) || (defined(__arm__) && !defined(__ARM_FEATURE_UNALIGNED))
+#define PROTO_OUTLINE_FOR_SIZE __attribute__((noinline))
+#define PROTO_FIXED32_BYTE_STORES true
+#else
+#define PROTO_OUTLINE_FOR_SIZE inline
+#define PROTO_FIXED32_BYTE_STORES false
+#endif
+
 // Varint encoding thresholds — used by both proto_encode_* free functions and ProtoSize.
 constexpr uint32_t VARINT_MAX_1_BYTE = 1 << 7;   // 128
 constexpr uint32_t VARINT_MAX_2_BYTE = 1 << 14;  // 16384
 
-/// Static encode helpers for generated encode() functions.
-/// Generated code hoists buffer.pos_ into a local uint8_t *__restrict__ pos,
-/// then calls these methods which take pos by reference. No struct, no overhead.
-/// For sub-messages, pos is synced back to buffer before the call and reloaded after.
+/// Static encode helpers for the generated encode bodies. Each takes the write cursor by value and
+/// returns it advanced, so outlined calls at -Os chain through the return register instead of a
+/// stack slot. Helpers without a _force suffix skip fields holding the proto3 default.
 class ProtoEncode {
  public:
   /// Write a multi-byte varint directly through a pos pointer.
   template<typename T>
-  static inline void encode_varint_raw_loop(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, T value) {
+  [[nodiscard]] static inline uint8_t *encode_varint_raw_loop(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                              T value) {
     do {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
       *pos++ = static_cast<uint8_t>(value | 0x80);
@@ -307,48 +322,49 @@ class ProtoEncode {
     } while (value > 0x7F);
     PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
     *pos++ = static_cast<uint8_t>(value);
+    return pos;
   }
-  static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                             uint32_t value) {
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  encode_varint_raw(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint32_t value) {
     if (value < VARINT_MAX_1_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
       *pos++ = static_cast<uint8_t>(value);
-      return;
+      return pos;
     }
-    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    return encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
   /// Encode a varint that is expected to be 1-2 bytes (e.g. zigzag RSSI, small lengths).
-  static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw_short(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                                   uint32_t value) {
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  encode_varint_raw_short(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint32_t value) {
     if (value < VARINT_MAX_1_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
       *pos++ = static_cast<uint8_t>(value);
-      return;
+      return pos;
     }
     if (value < VARINT_MAX_2_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 2);
       *pos++ = static_cast<uint8_t>(value | 0x80);
       *pos++ = static_cast<uint8_t>(value >> 7);
-      return;
+      return pos;
     }
-    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    return encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
-  static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw_64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                                uint64_t value) {
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  encode_varint_raw_64(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint64_t value) {
     if (value < VARINT_MAX_1_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
       *pos++ = static_cast<uint8_t>(value);
-      return;
+      return pos;
     }
-    encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
+    return encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
   /// Encode a 48-bit MAC address (stored in a uint64) as varint.
   /// Real MAC addresses occupy the full 48 bits (OUI in upper 24), so the
   /// fast path -- any non-zero bit in the top 6 of 48 -- emits exactly 7 bytes
   /// with no per-byte branch. Falls back to the general loop otherwise.
   /// Caller must guarantee value fits in 48 bits (checked in debug builds).
-  static inline void ESPHOME_ALWAYS_INLINE encode_varint_raw_48bit(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                                   uint64_t value) {
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  encode_varint_raw_48bit(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint64_t value) {
 #ifdef ESPHOME_DEBUG_API
     assert(value < (1ULL << (MAC_ADDRESS_SIZE * 8)) && "encode_varint_raw_48bit: value exceeds 48 bits");
 #endif
@@ -363,38 +379,39 @@ class ProtoEncode {
       pos[4] = static_cast<uint8_t>((value >> 28) | 0x80);
       pos[5] = static_cast<uint8_t>((value >> 35) | 0x80);
       pos[6] = static_cast<uint8_t>(value >> 42);
-      pos += 7;
-      return;
+      return pos + 7;
     }
-    encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
+    return encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
   }
-  static inline void ESPHOME_ALWAYS_INLINE encode_field_raw(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                            uint32_t field_id, uint32_t type) {
-    encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, (field_id << 3) | type);
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  encode_field_raw(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, uint32_t type) {
+    return encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, proto_tag(field_id, type));
   }
   /// Write a single precomputed tag byte. Tag must be < 128.
-  static inline void ESPHOME_ALWAYS_INLINE write_raw_byte(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                          uint8_t b) {
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  write_raw_byte(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint8_t b) {
     PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
     *pos++ = b;
+    return pos;
   }
   /// Reserve one byte for later backpatch (e.g., sub-message length).
   /// Advances pos past the reserved byte without writing a value.
-  static inline void ESPHOME_ALWAYS_INLINE reserve_byte(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM) {
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  reserve_byte(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
     PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
-    pos++;
+    return pos + 1;
   }
   /// Write raw bytes to the buffer (no tag, no length prefix).
-  static inline void ESPHOME_ALWAYS_INLINE encode_raw(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                      const void *data, size_t len) {
+  [[nodiscard]] static inline uint8_t *ESPHOME_ALWAYS_INLINE
+  encode_raw(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, const void *data, size_t len) {
     PROTO_ENCODE_CHECK_BOUNDS(pos, len);
     std::memcpy(pos, data, len);
-    pos += len;
+    return pos + len;
   }
   /// Encode tag + 1-byte length + raw string data. For strings with max_data_length < 128.
   /// Tag must be a single-byte varint (< 128). Always encodes (no zero check).
-  static inline void encode_short_string_force(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint8_t tag,
-                                               const StringRef &ref) {
+  [[nodiscard]] static inline uint8_t *encode_short_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                                 uint8_t tag, const StringRef &ref) {
 #ifdef ESPHOME_DEBUG_API
     assert(ref.size() < 128 && "encode_short_string_force: string exceeds max_data_length < 128");
 #endif
@@ -402,137 +419,191 @@ class ProtoEncode {
     pos[0] = tag;
     pos[1] = static_cast<uint8_t>(ref.size());
     std::memcpy(pos + 2, ref.c_str(), ref.size());
-    pos += 2 + ref.size();
+    return pos + 2 + ref.size();
   }
-  /// Write a precomputed tag byte + 32-bit value in one operation.
-  static inline void ESPHOME_ALWAYS_INLINE write_tag_and_fixed32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                                 uint8_t tag, uint32_t value) {
+  /// Write a precomputed tag byte + 32-bit value. Outlined on embedded: one copy beats inline stores per field.
+  [[nodiscard]] static PROTO_OUTLINE_FOR_SIZE uint8_t *write_tag_and_fixed32(
+      uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint8_t tag, uint32_t value) {
     PROTO_ENCODE_CHECK_BOUNDS(pos, 5);
     pos[0] = tag;
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    std::memcpy(pos + 1, &value, 4);
-#else
-    pos[1] = static_cast<uint8_t>(value & 0xFF);
-    pos[2] = static_cast<uint8_t>((value >> 8) & 0xFF);
-    pos[3] = static_cast<uint8_t>((value >> 16) & 0xFF);
-    pos[4] = static_cast<uint8_t>((value >> 24) & 0xFF);
-#endif
-    pos += 5;
+    write_fixed32_le(pos + 1, value);
+    return pos + 5;
   }
-  static inline void encode_string(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                   const char *string, size_t len, bool force = false) {
-    if (len == 0 && !force)
-      return;
-    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 2);  // type 2: Length-delimited string
+  [[nodiscard]] static inline uint8_t *encode_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                           uint32_t field_id, const char *string, size_t len) {
+    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 2);  // type 2: Length-delimited string
     // NOLINTNEXTLINE(readability-inconsistent-ifelse-braces) -- false positive on [[likely]] attribute
     if (len < VARINT_MAX_1_BYTE) [[likely]] {
       PROTO_ENCODE_CHECK_BOUNDS(pos, 1 + len);
       *pos++ = static_cast<uint8_t>(len);
     } else {
-      encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, len);
+      pos = encode_varint_raw_loop(pos PROTO_ENCODE_DEBUG_ARG, len);
       PROTO_ENCODE_CHECK_BOUNDS(pos, len);
     }
     std::memcpy(pos, string, len);
-    pos += len;
+    return pos + len;
   }
-  static inline void encode_string(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                   const std::string &value, bool force = false) {
-    encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, value.data(), value.size(), force);
+  [[nodiscard]] static inline uint8_t *encode_string(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                     uint32_t field_id, const char *string, size_t len) {
+    if (len == 0)
+      return pos;
+    return encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, string, len);
   }
-  static inline void encode_string(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                   const StringRef &ref, bool force = false) {
-    encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, ref.c_str(), ref.size(), force);
+  [[nodiscard]] static inline uint8_t *encode_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                           uint32_t field_id, const std::string &value) {
+    return encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value.data(), value.size());
   }
-  static inline void encode_bytes(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                  const uint8_t *data, size_t len, bool force = false) {
-    encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, reinterpret_cast<const char *>(data), len, force);
+  [[nodiscard]] static inline uint8_t *encode_string(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                     uint32_t field_id, const StringRef &ref) {
+    return encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, ref.c_str(), ref.size());
   }
-  static inline void encode_uint32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                   uint32_t value, bool force = false) {
-    if (value == 0 && !force)
-      return;
-    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
-    encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, value);
+  [[nodiscard]] static inline uint8_t *encode_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                           uint32_t field_id, const StringRef &ref) {
+    return encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, ref.c_str(), ref.size());
   }
-  static inline void encode_uint64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                   uint64_t value, bool force = false) {
-    if (value == 0 && !force)
-      return;
-    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
-    encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
+  [[nodiscard]] static inline uint8_t *encode_bytes(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                    uint32_t field_id, const uint8_t *data, size_t len) {
+    return encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, reinterpret_cast<const char *>(data), len);
   }
-  static inline void encode_bool(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, bool value,
-                                 bool force = false) {
-    if (!value && !force)
-      return;
-    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
+  [[nodiscard]] static inline uint8_t *encode_bytes_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                          uint32_t field_id, const uint8_t *data, size_t len) {
+    return encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, reinterpret_cast<const char *>(data), len);
+  }
+  [[nodiscard]] static inline uint8_t *encode_uint32_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                           uint32_t field_id, uint32_t value) {
+    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
+    return encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, value);
+  }
+  [[nodiscard]] static inline uint8_t *encode_uint32(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                     uint32_t field_id, uint32_t value) {
+    if (value == 0)
+      return pos;
+    return encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
+  }
+  [[nodiscard]] static inline uint8_t *encode_uint64_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                           uint32_t field_id, uint64_t value) {
+    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
+    return encode_varint_raw_64(pos PROTO_ENCODE_DEBUG_ARG, value);
+  }
+  [[nodiscard]] static inline uint8_t *encode_uint64(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                     uint32_t field_id, uint64_t value) {
+    if (value == 0)
+      return pos;
+    return encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
+  }
+  [[nodiscard]] static inline uint8_t *encode_bool_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                         uint32_t field_id, bool value) {
+    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
     PROTO_ENCODE_CHECK_BOUNDS(pos, 1);
     *pos++ = value ? 0x01 : 0x00;
+    return pos;
   }
-  static inline void encode_fixed32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                    uint32_t value, bool force = false) {
-    if (value == 0 && !force)
-      return;
-    encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 5);
+  [[nodiscard]] static inline uint8_t *encode_bool(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                   uint32_t field_id, bool value) {
+    if (!value)
+      return pos;
+    return encode_bool_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
+  }
+  /// Tag + fixed32 for multi-byte tags; single-byte tags use write_tag_and_fixed32.
+  [[nodiscard]] static PROTO_OUTLINE_FOR_SIZE uint8_t *encode_fixed32_force(
+      uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, uint32_t value) {
+    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 5);
     PROTO_ENCODE_CHECK_BOUNDS(pos, 4);
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    std::memcpy(pos, &value, 4);
-    pos += 4;
-#else
-    *pos++ = (value >> 0) & 0xFF;
-    *pos++ = (value >> 8) & 0xFF;
-    *pos++ = (value >> 16) & 0xFF;
-    *pos++ = (value >> 24) & 0xFF;
-#endif
+    write_fixed32_le(pos, value);
+    return pos + 4;
+  }
+  [[nodiscard]] static inline uint8_t *encode_fixed32(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                      uint32_t field_id, uint32_t value) {
+    if (value == 0)
+      return pos;
+    return encode_fixed32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
   }
   // NOTE: Wire type 1 (64-bit fixed: double, fixed64, sfixed64) is intentionally
   // not supported to reduce overhead on embedded systems. All ESPHome devices are
   // 32-bit microcontrollers where 64-bit operations are expensive. If 64-bit support
   // is needed in the future, the necessary encoding/decoding functions must be added.
-  static inline void encode_float(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, float value,
-                                  bool force = false) {
-    uint32_t raw = float_to_raw(value);
-    if (raw == 0 && !force)
-      return;
-    encode_fixed32(pos PROTO_ENCODE_DEBUG_ARG, field_id, raw);
+  [[nodiscard]] static inline uint8_t *encode_float(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                    uint32_t field_id, float value) {
+    return encode_fixed32(pos PROTO_ENCODE_DEBUG_ARG, field_id, float_to_raw(value));
   }
-  static inline void encode_int32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, int32_t value,
-                                  bool force = false) {
+  [[nodiscard]] static inline uint8_t *encode_float_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                          uint32_t field_id, float value) {
+    return encode_fixed32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, float_to_raw(value));
+  }
+  [[nodiscard]] static inline uint8_t *encode_int32_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                          uint32_t field_id, int32_t value) {
     if (value < 0) {
       // negative int32 is always 10 byte long
-      encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value), force);
-      return;
+      return encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value));
     }
-    encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint32_t>(value), force);
+    return encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint32_t>(value));
   }
-  static inline void encode_int64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id, int64_t value,
-                                  bool force = false) {
-    encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value), force);
+  [[nodiscard]] static inline uint8_t *encode_int32(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                    uint32_t field_id, int32_t value) {
+    if (value == 0)
+      return pos;
+    return encode_int32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, value);
   }
-  static inline void encode_sint32(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                   int32_t value, bool force = false) {
-    encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag32(value), force);
+  [[nodiscard]] static inline uint8_t *encode_int64(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                    uint32_t field_id, int64_t value) {
+    return encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value));
   }
-  static inline void encode_sint64(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, uint32_t field_id,
-                                   int64_t value, bool force = false) {
-    encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag64(value), force);
+  [[nodiscard]] static inline uint8_t *encode_int64_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                          uint32_t field_id, int64_t value) {
+    return encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, static_cast<uint64_t>(value));
   }
-  /// Sub-message encoding: sync pos to buffer, delegate, get pos from return value.
+  [[nodiscard]] static inline uint8_t *encode_sint32(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                     uint32_t field_id, int32_t value) {
+    return encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag32(value));
+  }
+  [[nodiscard]] static inline uint8_t *encode_sint32_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                           uint32_t field_id, int32_t value) {
+    return encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag32(value));
+  }
+  [[nodiscard]] static inline uint8_t *encode_sint64(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                     uint32_t field_id, int64_t value) {
+    return encode_uint64(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag64(value));
+  }
+  [[nodiscard]] static inline uint8_t *encode_sint64_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                           uint32_t field_id, int64_t value) {
+    return encode_uint64_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, encode_zigzag64(value));
+  }
+  /// Sub-message encoding: sync pos to buffer, delegate, read the cursor back.
   template<typename T>
-  static inline void encode_sub_message(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM, ProtoWriteBuffer &buffer,
-                                        uint32_t field_id, const T &value) {
+  [[nodiscard]] static inline uint8_t *encode_sub_message(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                          ProtoWriteBuffer &buffer, uint32_t field_id, const T &value) {
     buffer.set_pos(pos);
     buffer.encode_sub_message(field_id, value);
-    pos = buffer.get_pos();
+    return buffer.get_pos();
   }
   template<typename T>
-  static inline void encode_optional_sub_message(uint8_t *__restrict__ &pos PROTO_ENCODE_DEBUG_PARAM,
-                                                 ProtoWriteBuffer &buffer, uint32_t field_id, const T &value) {
+  [[nodiscard]] static inline uint8_t *encode_optional_sub_message(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                                   ProtoWriteBuffer &buffer, uint32_t field_id,
+                                                                   const T &value) {
     buffer.set_pos(pos);
     buffer.encode_optional_sub_message(field_id, value);
-    pos = buffer.get_pos();
+    return buffer.get_pos();
+  }
+
+ private:
+  /// Unaligned little endian store of four bytes: byte stores where the outlined helper lives (ESP-IDF, ARM
+  /// without unaligned access), otherwise a memcpy the compiler folds into one store. Callers bounds check
+  /// and advance the cursor themselves.
+  static inline void ESPHOME_ALWAYS_INLINE write_fixed32_le(uint8_t *__restrict__ pos, uint32_t value) {
+    if constexpr (PROTO_FIXED32_BYTE_STORES) {
+      // Spelled out so the outlined helper does not itself become a memcpy call
+      pos[0] = static_cast<uint8_t>(value);
+      pos[1] = static_cast<uint8_t>(value >> 8);
+      pos[2] = static_cast<uint8_t>(value >> 16);
+      pos[3] = static_cast<uint8_t>(value >> 24);
+    } else {
+      const uint32_t le = convert_little_endian(value);
+      __builtin_memcpy(pos, &le, 4);
+    }
   }
 };
+#undef PROTO_OUTLINE_FOR_SIZE
+#undef PROTO_FIXED32_BYTE_STORES
 
 #ifdef HAS_PROTO_MESSAGE_DUMP
 /**
@@ -624,11 +695,12 @@ class DumpBuffer {
 
 class ProtoMessage {
  public:
-  // Non-virtual defaults for messages with no fields.
-  // Concrete message classes hide these with their own implementations.
-  // All call sites use templates to preserve the concrete type, so virtual
-  // dispatch is not needed. This eliminates per-message vtable entries for
-  // encode/calculate_size, saving ~1.3 KB of flash across all message types.
+  // Non-virtual defaults for messages with no fields; generated classes hide all four. The
+  // static encode_msg/calc_size_msg take const void * so &T::encode_msg needs no thunk.
+  static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {
+    return buffer.get_pos();
+  }
+  static uint32_t calc_size_msg(const void *self) { return 0; }
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const { return buffer.get_pos(); }
   uint32_t calculate_size() const { return 0; }
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -663,10 +735,10 @@ class ProtoDecodableMessage : public ProtoMessage {
 
  protected:
   ~ProtoDecodableMessage() = default;
-  virtual bool decode_varint(uint32_t field_id, proto_varint_value_t value) { return false; }
-  virtual bool decode_length(uint32_t field_id, ProtoLengthDelimited value) { return false; }
-  virtual bool decode_32bit(uint32_t field_id, Proto32Bit value) { return false; }
-  // NOTE: decode_64bit removed - wire type 1 not supported
+  /// Store one decoded field; \p scalar is the varint or fixed32 value, or the length of the
+  /// length-delimited payload at \p data. An unknown field or wrong wire type matches no case and is skipped.
+  /// Three register arguments keep the decode loop free of spills.
+  virtual void decode_field(uint32_t tag, const uint8_t *data, proto_varint_value_t scalar) {}
 };
 
 class ProtoSize {
@@ -792,7 +864,7 @@ class ProtoSize {
    * @return The number of bytes needed to encode the field ID and wire type
    */
   static constexpr uint32_t field(uint32_t field_id, uint32_t type) {
-    uint32_t tag = (field_id << 3) | (type & WIRE_TYPE_MASK);
+    uint32_t tag = proto_tag(field_id, type & WIRE_TYPE_MASK);
     return varint(tag);
   }
 
@@ -876,24 +948,14 @@ class ProtoSize {
 
 // Implementation of methods that depend on ProtoSize being fully defined
 
-// Encode thunk — converts void* back to concrete type for direct encode() call
-template<typename T> uint8_t *proto_encode_msg(const void *msg, ProtoWriteBuffer &buf PROTO_ENCODE_DEBUG_PARAM) {
-  return static_cast<const T *>(msg)->encode(buf PROTO_ENCODE_DEBUG_ARG);
-}
-
 // Thin template wrapper; delegates to non-template core in proto.cpp.
 template<typename T> inline void ProtoWriteBuffer::encode_sub_message(uint32_t field_id, const T &value) {
-  this->encode_sub_message(field_id, &value, &proto_encode_msg<T>);
+  this->encode_sub_message(field_id, &value, &T::encode_msg);
 }
 
 // Thin template wrapper; delegates to non-template core.
 template<typename T> inline void ProtoWriteBuffer::encode_optional_sub_message(uint32_t field_id, const T &value) {
-  this->encode_optional_sub_message(field_id, value.calculate_size(), &value, &proto_encode_msg<T>);
-}
-
-// Template decode_to_message - preserves concrete type so decode() resolves statically
-template<typename T> void ProtoLengthDelimited::decode_to_message(T &msg) const {
-  msg.decode(this->value_, this->length_);
+  this->encode_optional_sub_message(field_id, T::calc_size_msg(&value), &value, &T::encode_msg);
 }
 
 template<typename T> const char *proto_enum_to_string(T value);

esphome/components/atm90e32/atm90e32.cpp

@@ -9,10 +9,6 @@ namespace esphome::atm90e32 {
 
 static const char *const TAG = "atm90e32";
 
-static const LogString *offset_calibration_name(bool power_offsets) {
-  return power_offsets ? LOG_STR("Power offset") : LOG_STR("Offset");
-}
-
 static uint32_t pref_hash(const char *prefix, const char *name_space) {
   auto hash = fnv1_hash(prefix);
   return fnv1_hash_extend(hash, name_space);
@@ -207,12 +203,13 @@ void ATM90E32Component::setup() {
 
     // Initialize flash storage for power offset calibrations
     uint32_t po_hash = pref_hash("_power_offset_calibration_", cs);
-    this->power_offset_pref_ = global_preferences->make_preference<OffsetCalibration[3]>(po_hash, true);
+    this->power_offset_pref_ = global_preferences->make_preference<PowerOffsetCalibration[3]>(po_hash, true);
     bool migrated_power_offset = false;
     if (has_distinct_legacy_namespace) {
       uint32_t legacy_po_hash = pref_hash("_power_offset_calibration_", legacy_cs);
-      auto legacy_power_offset_pref = global_preferences->make_preference<OffsetCalibration[3]>(legacy_po_hash, true);
-      OffsetCalibration power_offset_data[3]{};
+      auto legacy_power_offset_pref =
+          global_preferences->make_preference<PowerOffsetCalibration[3]>(legacy_po_hash, true);
+      PowerOffsetCalibration power_offset_data[3]{};
       int migration_status =
           migrate_legacy_pref_if_needed(this->power_offset_pref_, legacy_power_offset_pref, &power_offset_data);
       migrated_power_offset = migration_status > 0;
@@ -227,20 +224,20 @@ void ATM90E32Component::setup() {
       global_preferences->sync();
     }
 
-    this->restore_offset_calibrations_(OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_VOLTAGE_CURRENT);
-    this->restore_offset_calibrations_(OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER);
+    this->restore_offset_calibrations_();
+    this->restore_power_offset_calibrations_();
   } else {
     ESP_LOGI(TAG, "[CALIBRATION][%s] Power & Voltage/Current offset calibration is disabled. Using config file values.",
              cs);
     for (uint8_t phase = 0; phase < 3; ++phase) {
       this->write16_(this->voltage_offset_registers[phase],
-                     static_cast<uint16_t>(this->offset_phase_[phase].first_offset));
+                     static_cast<uint16_t>(this->offset_phase_[phase].voltage_offset_));
       this->write16_(this->current_offset_registers[phase],
-                     static_cast<uint16_t>(this->offset_phase_[phase].second_offset));
+                     static_cast<uint16_t>(this->offset_phase_[phase].current_offset_));
       this->write16_(this->power_offset_registers[phase],
-                     static_cast<uint16_t>(this->power_offset_phase_[phase].first_offset));
+                     static_cast<uint16_t>(this->power_offset_phase_[phase].active_power_offset));
       this->write16_(this->reactive_power_offset_registers[phase],
-                     static_cast<uint16_t>(this->power_offset_phase_[phase].second_offset));
+                     static_cast<uint16_t>(this->power_offset_phase_[phase].reactive_power_offset));
     }
   }
 
@@ -320,8 +317,8 @@ void ATM90E32Component::log_calibration_status_() {
              cs);
     for (uint8_t phase = 0; phase < 3; ++phase) {
       ESP_LOGW(TAG, "[CALIBRATION][%s] |   %c   |  %6d  | %6d  |  %6d  | %6d  |", cs, 'A' + phase,
-               this->config_offset_phase_[phase].first_offset, this->offset_phase_[phase].first_offset,
-               this->config_offset_phase_[phase].second_offset, this->offset_phase_[phase].second_offset);
+               this->config_offset_phase_[phase].voltage_offset_, this->offset_phase_[phase].voltage_offset_,
+               this->config_offset_phase_[phase].current_offset_, this->offset_phase_[phase].current_offset_);
     }
     ESP_LOGW(TAG,
              "[CALIBRATION][%s] ===============================================================================", cs);
@@ -338,8 +335,10 @@ void ATM90E32Component::log_calibration_status_() {
              cs);
     for (uint8_t phase = 0; phase < 3; ++phase) {
       ESP_LOGW(TAG, "[CALIBRATION][%s] |   %c   |  %6d  | %6d  |  %6d  | %6d  |", cs, 'A' + phase,
-               this->config_power_offset_phase_[phase].first_offset, this->power_offset_phase_[phase].first_offset,
-               this->config_power_offset_phase_[phase].second_offset, this->power_offset_phase_[phase].second_offset);
+               this->config_power_offset_phase_[phase].active_power_offset,
+               this->power_offset_phase_[phase].active_power_offset,
+               this->config_power_offset_phase_[phase].reactive_power_offset,
+               this->power_offset_phase_[phase].reactive_power_offset);
     }
     ESP_LOGW(TAG,
              "[CALIBRATION][%s] ===============================================================================", cs);
@@ -373,7 +372,7 @@ void ATM90E32Component::log_calibration_status_() {
     ESP_LOGI(TAG, "[CALIBRATION][%s] --------------------------------------------------------------", cs);
     for (uint8_t phase = 0; phase < 3; phase++) {
       ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |     %6d      |     %6d      |", cs, 'A' + phase,
-               this->offset_phase_[phase].first_offset, this->offset_phase_[phase].second_offset);
+               this->offset_phase_[phase].voltage_offset_, this->offset_phase_[phase].current_offset_);
     }
     ESP_LOGI(TAG, "[CALIBRATION][%s] ==============================================================\\n", cs);
   }
@@ -386,7 +385,8 @@ void ATM90E32Component::log_calibration_status_() {
     ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
     for (uint8_t phase = 0; phase < 3; phase++) {
       ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |       %6d        |        %6d        |", cs, 'A' + phase,
-               this->power_offset_phase_[phase].first_offset, this->power_offset_phase_[phase].second_offset);
+               this->power_offset_phase_[phase].active_power_offset,
+               this->power_offset_phase_[phase].reactive_power_offset);
     }
     ESP_LOGI(TAG, "[CALIBRATION][%s] =====================================================================\n", cs);
   }
@@ -756,68 +756,36 @@ void ATM90E32Component::save_gain_calibration_to_memory_() {
   }
 }
 
-void ATM90E32Component::finish_offset_calibration_(const OffsetCalibration (&previous)[3], bool previous_restored,
-                                                   bool previous_using_saved, OffsetCalibrationType type) {
-  const bool power_offsets = type == OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER;
+void ATM90E32Component::save_offset_calibration_to_memory_() {
   const char *cs = this->get_calibration_id_();
-  const LogString *name = offset_calibration_name(power_offsets);
-  OffsetCalibration(*offsets)[3] = power_offsets ? &this->power_offset_phase_ : &this->offset_phase_;
-  ESPPreferenceObject *preference = power_offsets ? &this->power_offset_pref_ : &this->offset_pref_;
-  bool *has_stored =
-      power_offsets ? &this->has_stored_power_offset_calibration_ : &this->has_stored_offset_calibration_;
-  bool *restored = power_offsets ? &this->restored_power_offset_calibration_ : &this->restored_offset_calibration_;
-  bool *mismatches = power_offsets ? this->power_offset_calibration_mismatch_ : this->offset_calibration_mismatch_;
-
-  const bool writes_verified = this->verify_offset_writes_(type);
-  bool saved = false;
-  bool synced = false;
-  if (writes_verified) {
-    saved = preference->save(offsets);
-    synced = global_preferences->sync();
-  }
-
-  if (writes_verified && saved && synced) {
+  bool success = this->offset_pref_.save(&this->offset_phase_);
+  global_preferences->sync();
+  if (success) {
     this->using_saved_calibrations_ = true;
-    *has_stored = true;
-    *restored = true;
-    for (uint8_t phase = 0; phase < 3; phase++)
-      mismatches[phase] = false;
-    ESP_LOGI(TAG, "[CALIBRATION][%s] %s calibration saved to memory. %s calibration completed and verified.", cs,
-             LOG_STR_ARG(name), LOG_STR_ARG(name));
-    return;
+    this->restored_offset_calibration_ = true;
+    for (bool &phase : this->offset_calibration_mismatch_)
+      phase = false;
+    ESP_LOGI(TAG, "[CALIBRATION][%s] Offset calibration saved to memory.", cs);
+  } else {
+    this->using_saved_calibrations_ = false;
+    ESP_LOGE(TAG, "[CALIBRATION][%s] Failed to save offset calibration to memory!", cs);
   }
+}
 
-  if (writes_verified) {
-    ESP_LOGE(TAG, "[CALIBRATION][%s] Failed to save %s calibration to memory!", cs, LOG_STR_ARG(name));
+void ATM90E32Component::save_power_offset_calibration_to_memory_() {
+  const char *cs = this->get_calibration_id_();
+  bool success = this->power_offset_pref_.save(&this->power_offset_phase_);
+  global_preferences->sync();
+  if (success) {
+    this->using_saved_calibrations_ = true;
+    this->restored_power_offset_calibration_ = true;
+    for (bool &phase : this->power_offset_calibration_mismatch_)
+      phase = false;
+    ESP_LOGI(TAG, "[CALIBRATION][%s] Power offset calibration saved to memory.", cs);
+  } else {
+    this->using_saved_calibrations_ = false;
+    ESP_LOGE(TAG, "[CALIBRATION][%s] Failed to save power offset calibration to memory!", cs);
   }
-
-  for (uint8_t phase = 0; phase < 3; phase++) {
-    this->write_offsets_to_registers_(phase, previous[phase].first_offset, previous[phase].second_offset, type);
-  }
-  const bool rollback_verified = this->verify_offset_writes_(type);
-
-  bool rollback_persisted = false;
-  if (writes_verified) {
-    OffsetCalibration rollback[3]{};
-    prepare_offset_rollback(previous, previous_restored, rollback);
-    const bool rollback_saved = preference->save(&rollback);
-    const bool rollback_synced = global_preferences->sync();
-    rollback_persisted = rollback_saved && rollback_synced;
-    if (!rollback_saved || !rollback_synced) {
-      ESP_LOGE(TAG, "[CALIBRATION][%s] Failed to persist restored %s calibration values!", cs, LOG_STR_ARG(name));
-    }
-  }
-
-  *restored = previous_restored;
-  if (rollback_persisted)
-    *has_stored = previous_restored;
-  this->using_saved_calibrations_ = previous_using_saved;
-  if (!rollback_verified) {
-    ESP_LOGE(TAG, "[CALIBRATION][%s] %s calibration failed; rollback readback verification failed.", cs,
-             LOG_STR_ARG(name));
-    return;
-  }
-  ESP_LOGE(TAG, "[CALIBRATION][%s] %s calibration failed; previous values restored.", cs, LOG_STR_ARG(name));
 }
 
 void ATM90E32Component::run_offset_calibrations() {
@@ -835,16 +803,11 @@ void ATM90E32Component::run_offset_calibrations() {
   ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_voltage | offset_current |", cs);
   ESP_LOGI(TAG, "[CALIBRATION][%s] ------------------------------------------------------------------", cs);
 
-  OffsetCalibration previous_offsets[3] = {this->offset_phase_[0], this->offset_phase_[1], this->offset_phase_[2]};
-  const bool previous_restored = this->restored_offset_calibration_;
-  const bool previous_using_saved = this->using_saved_calibrations_;
-
   for (uint8_t phase = 0; phase < 3; phase++) {
     int16_t voltage_offset = calibrate_offset(phase, true);
     int16_t current_offset = calibrate_offset(phase, false);
 
-    this->write_offsets_to_registers_(phase, voltage_offset, current_offset,
-                                      OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_VOLTAGE_CURRENT);
+    this->write_offsets_to_registers_(phase, voltage_offset, current_offset);
 
     ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |     %6d      |     %6d      |", cs, 'A' + phase, voltage_offset,
              current_offset);
@@ -852,8 +815,7 @@ void ATM90E32Component::run_offset_calibrations() {
 
   ESP_LOGI(TAG, "[CALIBRATION][%s] ==================================================================\n", cs);
 
-  this->finish_offset_calibration_(previous_offsets, previous_restored, previous_using_saved,
-                                   OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_VOLTAGE_CURRENT);
+  this->save_offset_calibration_to_memory_();
 }
 
 void ATM90E32Component::run_power_offset_calibrations() {
@@ -872,25 +834,18 @@ void ATM90E32Component::run_power_offset_calibrations() {
   ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_active_power | offset_reactive_power |", cs);
   ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
 
-  OffsetCalibration previous_offsets[3] = {this->power_offset_phase_[0], this->power_offset_phase_[1],
-                                           this->power_offset_phase_[2]};
-  const bool previous_restored = this->restored_power_offset_calibration_;
-  const bool previous_using_saved = this->using_saved_calibrations_;
-
   for (uint8_t phase = 0; phase < 3; ++phase) {
     int16_t active_offset = calibrate_power_offset(phase, false);
     int16_t reactive_offset = calibrate_power_offset(phase, true);
 
-    this->write_offsets_to_registers_(phase, active_offset, reactive_offset,
-                                      OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER);
+    this->write_power_offsets_to_registers_(phase, active_offset, reactive_offset);
 
     ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |       %6d        |        %6d        |", cs, 'A' + phase, active_offset,
              reactive_offset);
   }
   ESP_LOGI(TAG, "[CALIBRATION][%s] =====================================================================\n", cs);
 
-  this->finish_offset_calibration_(previous_offsets, previous_restored, previous_using_saved,
-                                   OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER);
+  this->save_power_offset_calibration_to_memory_();
 }
 
 void ATM90E32Component::write_gains_to_registers_() {
@@ -904,26 +859,35 @@ void ATM90E32Component::write_gains_to_registers_() {
   this->write16_(ATM90E32_REGISTER_CFGREGACCEN, 0x0000);
 }
 
-void ATM90E32Component::write_offsets_to_registers_(uint8_t phase, int16_t first_offset, int16_t second_offset,
-                                                    OffsetCalibrationType type) {
-  const bool power_offsets = type == OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER;
-  OffsetCalibration &offsets = power_offsets ? this->power_offset_phase_[phase] : this->offset_phase_[phase];
-  offsets.first_offset = first_offset;
-  offsets.second_offset = second_offset;
-  if (power_offsets) {
-    this->phase_[phase].active_power_offset_ = first_offset;
-    this->phase_[phase].reactive_power_offset_ = second_offset;
-  } else {
-    this->phase_[phase].voltage_offset_ = first_offset;
-    this->phase_[phase].current_offset_ = second_offset;
-  }
+void ATM90E32Component::write_offsets_to_registers_(uint8_t phase, int16_t voltage_offset, int16_t current_offset) {
+  // Save to runtime
+  this->offset_phase_[phase].voltage_offset_ = voltage_offset;
+  this->phase_[phase].voltage_offset_ = voltage_offset;
 
-  const uint16_t *first_registers = power_offsets ? this->power_offset_registers : this->voltage_offset_registers;
-  const uint16_t *second_registers =
-      power_offsets ? this->reactive_power_offset_registers : this->current_offset_registers;
+  // Save to flash-storable struct
+  this->offset_phase_[phase].current_offset_ = current_offset;
+  this->phase_[phase].current_offset_ = current_offset;
+
+  // Write to registers
   this->write16_(ATM90E32_REGISTER_CFGREGACCEN, 0x55AA);
-  this->write16_(first_registers[phase], static_cast<uint16_t>(first_offset));
-  this->write16_(second_registers[phase], static_cast<uint16_t>(second_offset));
+  this->write16_(voltage_offset_registers[phase], static_cast<uint16_t>(voltage_offset));
+  this->write16_(current_offset_registers[phase], static_cast<uint16_t>(current_offset));
+  this->write16_(ATM90E32_REGISTER_CFGREGACCEN, 0x0000);
+}
+
+void ATM90E32Component::write_power_offsets_to_registers_(uint8_t phase, int16_t p_offset, int16_t q_offset) {
+  // Save to runtime
+  this->phase_[phase].active_power_offset_ = p_offset;
+  this->phase_[phase].reactive_power_offset_ = q_offset;
+
+  // Save to flash-storable struct
+  this->power_offset_phase_[phase].active_power_offset = p_offset;
+  this->power_offset_phase_[phase].reactive_power_offset = q_offset;
+
+  // Write to registers
+  this->write16_(ATM90E32_REGISTER_CFGREGACCEN, 0x55AA);
+  this->write16_(this->power_offset_registers[phase], static_cast<uint16_t>(p_offset));
+  this->write16_(this->reactive_power_offset_registers[phase], static_cast<uint16_t>(q_offset));
   this->write16_(ATM90E32_REGISTER_CFGREGACCEN, 0x0000);
 }
 
@@ -983,78 +947,89 @@ void ATM90E32Component::restore_gain_calibrations_() {
   ESP_LOGW(TAG, "[CALIBRATION][%s] No stored gain calibrations found. Using config file values.", cs);
 }
 
-void ATM90E32Component::restore_offset_calibrations_(OffsetCalibrationType type) {
-  const bool power_offsets = type == OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER;
+void ATM90E32Component::restore_offset_calibrations_() {
   const char *cs = this->get_calibration_id_();
-  const LogString *name = power_offsets ? LOG_STR("power offset") : LOG_STR("offset");
-  OffsetCalibration(*offsets)[3] = power_offsets ? &this->power_offset_phase_ : &this->offset_phase_;
-  OffsetCalibration(*config_offsets)[3] =
-      power_offsets ? &this->config_power_offset_phase_ : &this->config_offset_phase_;
-  ESPPreferenceObject *preference = power_offsets ? &this->power_offset_pref_ : &this->offset_pref_;
-  bool *has_stored =
-      power_offsets ? &this->has_stored_power_offset_calibration_ : &this->has_stored_offset_calibration_;
-  bool *restored = power_offsets ? &this->restored_power_offset_calibration_ : &this->restored_offset_calibration_;
-  bool *mismatches = power_offsets ? this->power_offset_calibration_mismatch_ : this->offset_calibration_mismatch_;
-  const bool *has_first = power_offsets ? this->has_config_active_power_offset_ : this->has_config_voltage_offset_;
-  const bool *has_second = power_offsets ? this->has_config_reactive_power_offset_ : this->has_config_current_offset_;
-
   for (uint8_t i = 0; i < 3; ++i)
-    (*config_offsets)[i] = (*offsets)[i];
+    this->config_offset_phase_[i] = this->offset_phase_[i];
+
+  bool have_data = this->offset_pref_.load(&this->offset_phase_);
 
-  const bool have_data = preference->load(offsets);
   bool all_zero = true;
   if (have_data) {
-    for (const auto &phase : *offsets) {
-      if (phase.first_offset != 0 || phase.second_offset != 0) {
+    for (auto &phase : this->offset_phase_) {
+      if (phase.voltage_offset_ != 0 || phase.current_offset_ != 0) {
         all_zero = false;
         break;
       }
     }
   }
 
-  *has_stored = have_data && !all_zero;
-  *restored = false;
+  if (have_data && !all_zero) {
+    this->restored_offset_calibration_ = true;
+    for (uint8_t phase = 0; phase < 3; phase++) {
+      auto &offset = this->offset_phase_[phase];
+      bool mismatch = false;
+      if (this->has_config_voltage_offset_[phase] &&
+          offset.voltage_offset_ != this->config_offset_phase_[phase].voltage_offset_)
+        mismatch = true;
+      if (this->has_config_current_offset_[phase] &&
+          offset.current_offset_ != this->config_offset_phase_[phase].current_offset_)
+        mismatch = true;
+      if (mismatch)
+        this->offset_calibration_mismatch_[phase] = true;
+    }
+  } else {
+    for (uint8_t phase = 0; phase < 3; phase++)
+      this->offset_phase_[phase] = this->config_offset_phase_[phase];
+    ESP_LOGW(TAG, "[CALIBRATION][%s] No stored offset calibrations found. Using default values.", cs);
+  }
+
   for (uint8_t phase = 0; phase < 3; phase++) {
-    mismatches[phase] = false;
-    if (*has_stored) {
-      mismatches[phase] =
-          (has_first[phase] && (*offsets)[phase].first_offset != (*config_offsets)[phase].first_offset) ||
-          (has_second[phase] && (*offsets)[phase].second_offset != (*config_offsets)[phase].second_offset);
+    write_offsets_to_registers_(phase, this->offset_phase_[phase].voltage_offset_,
+                                this->offset_phase_[phase].current_offset_);
+  }
+}
+
+void ATM90E32Component::restore_power_offset_calibrations_() {
+  const char *cs = this->get_calibration_id_();
+  for (uint8_t i = 0; i < 3; ++i)
+    this->config_power_offset_phase_[i] = this->power_offset_phase_[i];
+
+  bool have_data = this->power_offset_pref_.load(&this->power_offset_phase_);
+
+  bool all_zero = true;
+  if (have_data) {
+    for (auto &phase : this->power_offset_phase_) {
+      if (phase.active_power_offset != 0 || phase.reactive_power_offset != 0) {
+        all_zero = false;
+        break;
+      }
     }
   }
 
-  if (!*has_stored) {
-    for (uint8_t phase = 0; phase < 3; phase++)
-      (*offsets)[phase] = (*config_offsets)[phase];
-    ESP_LOGW(TAG, "[CALIBRATION][%s] No stored %s calibrations found. Using default values.", cs, LOG_STR_ARG(name));
-  }
-
-  for (uint8_t phase = 0; phase < 3; phase++) {
-    this->write_offsets_to_registers_(phase, (*offsets)[phase].first_offset, (*offsets)[phase].second_offset, type);
-  }
-  const bool initial_values_verified = this->verify_offset_writes_(type);
-  if (initial_values_verified) {
-    const auto state = resolve_offset_restore_state(*has_stored, true, false);
-    *restored = state.restored;
-    ESP_LOGI(TAG, "[CALIBRATION][%s] %s calibration values verified.", cs, LOG_STR_ARG(name));
-    return;
-  }
-
-  this->using_saved_calibrations_ = false;
-  for (uint8_t phase = 0; phase < 3; phase++)
-    mismatches[phase] = false;
-  for (uint8_t phase = 0; phase < 3; phase++) {
-    (*offsets)[phase] = (*config_offsets)[phase];
-    this->write_offsets_to_registers_(phase, (*offsets)[phase].first_offset, (*offsets)[phase].second_offset, type);
-  }
-  const auto state = resolve_offset_restore_state(*has_stored, false, this->verify_offset_writes_(type));
-  *restored = state.restored;
-  if (state.values_verified) {
-    ESP_LOGE(TAG, "[CALIBRATION][%s] %s calibration restore failed verification; config values verified.", cs,
-             LOG_STR_ARG(name));
+  if (have_data && !all_zero) {
+    this->restored_power_offset_calibration_ = true;
+    for (uint8_t phase = 0; phase < 3; ++phase) {
+      auto &offset = this->power_offset_phase_[phase];
+      bool mismatch = false;
+      if (this->has_config_active_power_offset_[phase] &&
+          offset.active_power_offset != this->config_power_offset_phase_[phase].active_power_offset)
+        mismatch = true;
+      if (this->has_config_reactive_power_offset_[phase] &&
+          offset.reactive_power_offset != this->config_power_offset_phase_[phase].reactive_power_offset)
+        mismatch = true;
+      if (mismatch)
+        this->power_offset_calibration_mismatch_[phase] = true;
+    }
   } else {
-    ESP_LOGE(TAG, "[CALIBRATION][%s] %s calibration restore and config fallback both failed verification.", cs,
-             LOG_STR_ARG(name));
+    for (uint8_t phase = 0; phase < 3; ++phase)
+      this->power_offset_phase_[phase] = this->config_power_offset_phase_[phase];
+    ESP_LOGW(TAG, "[CALIBRATION][%s] No stored power offsets found. Using default values.", cs);
+  }
+
+  for (uint8_t phase = 0; phase < 3; ++phase) {
+    write_power_offsets_to_registers_(phase, this->power_offset_phase_[phase].active_power_offset,
+                                      this->power_offset_phase_[phase].reactive_power_offset);
   }
 }
 
@@ -1109,14 +1084,14 @@ void ATM90E32Component::clear_gain_calibrations() {
 
 void ATM90E32Component::clear_offset_calibrations() {
   const char *cs = this->get_calibration_id_();
-  if (!this->has_stored_offset_calibration_) {
+  if (!this->restored_offset_calibration_) {
     ESP_LOGI(TAG, "[CALIBRATION][%s] No stored offset calibrations to clear. Current values:", cs);
     ESP_LOGI(TAG, "[CALIBRATION][%s] --------------------------------------------------------------", cs);
     ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_voltage | offset_current |", cs);
     ESP_LOGI(TAG, "[CALIBRATION][%s] --------------------------------------------------------------", cs);
     for (uint8_t phase = 0; phase < 3; phase++) {
       ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |     %6d      |     %6d      |", cs, 'A' + phase,
-               this->offset_phase_[phase].first_offset, this->offset_phase_[phase].second_offset);
+               this->offset_phase_[phase].voltage_offset_, this->offset_phase_[phase].current_offset_);
     }
     ESP_LOGI(TAG, "[CALIBRATION][%s] ==============================================================\n", cs);
     return;
@@ -1129,11 +1104,10 @@ void ATM90E32Component::clear_offset_calibrations() {
 
   for (uint8_t phase = 0; phase < 3; phase++) {
     int16_t voltage_offset =
-        this->has_config_voltage_offset_[phase] ? this->config_offset_phase_[phase].first_offset : 0;
+        this->has_config_voltage_offset_[phase] ? this->config_offset_phase_[phase].voltage_offset_ : 0;
     int16_t current_offset =
-        this->has_config_current_offset_[phase] ? this->config_offset_phase_[phase].second_offset : 0;
-    this->write_offsets_to_registers_(phase, voltage_offset, current_offset,
-                                      OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_VOLTAGE_CURRENT);
+        this->has_config_current_offset_[phase] ? this->config_offset_phase_[phase].current_offset_ : 0;
+    this->write_offsets_to_registers_(phase, voltage_offset, current_offset);
     ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |     %6d      |     %6d      |", cs, 'A' + phase, voltage_offset,
              current_offset);
   }
@@ -1143,7 +1117,6 @@ void ATM90E32Component::clear_offset_calibrations() {
   this->offset_pref_.save(&zero_offsets);  // Clear stored values in flash
   global_preferences->sync();
 
-  this->has_stored_offset_calibration_ = false;
   this->restored_offset_calibration_ = false;
   for (bool &phase : this->offset_calibration_mismatch_)
     phase = false;
@@ -1153,14 +1126,15 @@ void ATM90E32Component::clear_offset_calibrations() {
 
 void ATM90E32Component::clear_power_offset_calibrations() {
   const char *cs = this->get_calibration_id_();
-  if (!this->has_stored_power_offset_calibration_) {
+  if (!this->restored_power_offset_calibration_) {
     ESP_LOGI(TAG, "[CALIBRATION][%s] No stored power offsets to clear. Current values:", cs);
     ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
     ESP_LOGI(TAG, "[CALIBRATION][%s] | Phase | offset_active_power | offset_reactive_power |", cs);
     ESP_LOGI(TAG, "[CALIBRATION][%s] ---------------------------------------------------------------------", cs);
     for (uint8_t phase = 0; phase < 3; phase++) {
       ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |       %6d        |        %6d        |", cs, 'A' + phase,
-               this->power_offset_phase_[phase].first_offset, this->power_offset_phase_[phase].second_offset);
+               this->power_offset_phase_[phase].active_power_offset,
+               this->power_offset_phase_[phase].reactive_power_offset);
     }
     ESP_LOGI(TAG, "[CALIBRATION][%s] =====================================================================\n", cs);
     return;
@@ -1173,21 +1147,20 @@ void ATM90E32Component::clear_power_offset_calibrations() {
 
   for (uint8_t phase = 0; phase < 3; phase++) {
     int16_t active_offset =
-        this->has_config_active_power_offset_[phase] ? this->config_power_offset_phase_[phase].first_offset : 0;
-    int16_t reactive_offset =
-        this->has_config_reactive_power_offset_[phase] ? this->config_power_offset_phase_[phase].second_offset : 0;
-    this->write_offsets_to_registers_(phase, active_offset, reactive_offset,
-                                      OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER);
+        this->has_config_active_power_offset_[phase] ? this->config_power_offset_phase_[phase].active_power_offset : 0;
+    int16_t reactive_offset = this->has_config_reactive_power_offset_[phase]
+                                  ? this->config_power_offset_phase_[phase].reactive_power_offset
+                                  : 0;
+    this->write_power_offsets_to_registers_(phase, active_offset, reactive_offset);
     ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |       %6d        |        %6d        |", cs, 'A' + phase, active_offset,
              reactive_offset);
   }
   ESP_LOGI(TAG, "[CALIBRATION][%s] =====================================================================\n", cs);
 
-  OffsetCalibration zero_power_offsets[3]{{0, 0}, {0, 0}, {0, 0}};
+  PowerOffsetCalibration zero_power_offsets[3]{{0, 0}, {0, 0}, {0, 0}};
   this->power_offset_pref_.save(&zero_power_offsets);
   global_preferences->sync();
 
-  this->has_stored_power_offset_calibration_ = false;
   this->restored_power_offset_calibration_ = false;
   for (bool &phase : this->power_offset_calibration_mismatch_)
     phase = false;
@@ -1242,31 +1215,6 @@ bool ATM90E32Component::verify_gain_writes_() {
   return success;  // Return true if all writes were successful, false otherwise
 }
 
-bool ATM90E32Component::verify_offset_writes_(OffsetCalibrationType type) {
-  const bool power_offsets = type == OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER;
-  const char *cs = this->get_calibration_id_();
-  const LogString *name = offset_calibration_name(power_offsets);
-  const LogString *first_name = power_offsets ? LOG_STR("active") : LOG_STR("voltage");
-  const LogString *second_name = power_offsets ? LOG_STR("reactive") : LOG_STR("current");
-  const OffsetCalibration *offsets = power_offsets ? this->power_offset_phase_ : this->offset_phase_;
-  const uint16_t *first_registers = power_offsets ? this->power_offset_registers : this->voltage_offset_registers;
-  const uint16_t *second_registers =
-      power_offsets ? this->reactive_power_offset_registers : this->current_offset_registers;
-  bool success = true;
-  for (uint8_t phase = 0; phase < 3; phase++) {
-    const uint16_t first = this->read16_(first_registers[phase]);
-    const uint16_t second = this->read16_(second_registers[phase]);
-    if (!offset_register_value_matches(first, offsets[phase].first_offset) ||
-        !offset_register_value_matches(second, offsets[phase].second_offset)) {
-      ESP_LOGE(TAG, "[CALIBRATION][%s] %s readback failed for Phase %s: %s %d/%d, %s %d/%d.", cs, LOG_STR_ARG(name),
-               phase_labels[phase], LOG_STR_ARG(first_name), static_cast<int16_t>(first), offsets[phase].first_offset,
-               LOG_STR_ARG(second_name), static_cast<int16_t>(second), offsets[phase].second_offset);
-      success = false;
-    }
-  }
-  return success;
-}
-
 #ifdef USE_TEXT_SENSOR
 void ATM90E32Component::check_phase_status() {
   uint16_t state0 = this->read16_(ATM90E32_REGISTER_EMMSTATE0);

esphome/components/atm90e32/atm90e32.h

@@ -13,40 +13,6 @@
 
 namespace esphome::atm90e32 {
 
-inline bool offset_register_value_matches(uint16_t actual, int16_t expected) {
-  return actual == static_cast<uint16_t>(expected);
-}
-
-struct OffsetCalibration {
-  int16_t first_offset{0};
-  int16_t second_offset{0};
-};
-
-static_assert(sizeof(OffsetCalibration[3]) == 12, "Offset calibration preference layout must remain compatible");
-
-enum class OffsetCalibrationType : uint8_t {
-  OFFSET_CALIBRATION_TYPE_VOLTAGE_CURRENT,
-  OFFSET_CALIBRATION_TYPE_POWER,
-};
-
-struct OffsetRestoreState {
-  bool restored;
-  bool values_verified;
-};
-
-inline OffsetRestoreState resolve_offset_restore_state(bool has_stored_values, bool initial_values_verified,
-                                                       bool fallback_values_verified) {
-  if (initial_values_verified)
-    return {has_stored_values, true};
-  return {false, fallback_values_verified};
-}
-
-inline void prepare_offset_rollback(const OffsetCalibration (&previous)[3], bool had_stored_values,
-                                    OffsetCalibration (&rollback)[3]) {
-  for (uint8_t phase = 0; phase < 3; phase++)
-    rollback[phase] = had_stored_values ? previous[phase] : OffsetCalibration{};
-}
-
 class ATM90E32Component final : public PollingComponent,
                                 public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_HIGH,
                                                       spi::CLOCK_PHASE_TRAILING, spi::DATA_RATE_1MHZ> {
@@ -105,19 +71,19 @@ class ATM90E32Component final : public PollingComponent,
     this->has_config_current_gain_[phase] = true;
   }
   void set_voltage_offset(uint8_t phase, int16_t offset) {
-    this->offset_phase_[phase].first_offset = offset;
+    this->offset_phase_[phase].voltage_offset_ = offset;
     this->has_config_voltage_offset_[phase] = true;
   }
   void set_current_offset(uint8_t phase, int16_t offset) {
-    this->offset_phase_[phase].second_offset = offset;
+    this->offset_phase_[phase].current_offset_ = offset;
     this->has_config_current_offset_[phase] = true;
   }
   void set_active_power_offset(uint8_t phase, int16_t offset) {
-    this->power_offset_phase_[phase].first_offset = offset;
+    this->power_offset_phase_[phase].active_power_offset = offset;
     this->has_config_active_power_offset_[phase] = true;
   }
   void set_reactive_power_offset(uint8_t phase, int16_t offset) {
-    this->power_offset_phase_[phase].second_offset = offset;
+    this->power_offset_phase_[phase].reactive_power_offset = offset;
     this->has_config_reactive_power_offset_[phase] = true;
   }
   void set_freq_sensor(sensor::Sensor *freq_sensor) { freq_sensor_ = freq_sensor; }
@@ -205,16 +171,16 @@ class ATM90E32Component final : public PollingComponent,
   float get_chip_temperature_();
   bool get_publish_interval_flag_() { return publish_interval_flag_; };
   void set_publish_interval_flag_(bool flag) { publish_interval_flag_ = flag; };
-  void restore_offset_calibrations_(OffsetCalibrationType type);
+  void restore_offset_calibrations_();
+  void restore_power_offset_calibrations_();
   void restore_gain_calibrations_();
+  void save_offset_calibration_to_memory_();
   void save_gain_calibration_to_memory_();
-  void finish_offset_calibration_(const OffsetCalibration (&previous)[3], bool previous_restored,
-                                  bool previous_using_saved, OffsetCalibrationType type);
-  void write_offsets_to_registers_(uint8_t phase, int16_t first_offset, int16_t second_offset,
-                                   OffsetCalibrationType type);
+  void save_power_offset_calibration_to_memory_();
+  void write_offsets_to_registers_(uint8_t phase, int16_t voltage_offset, int16_t current_offset);
+  void write_power_offsets_to_registers_(uint8_t phase, int16_t p_offset, int16_t q_offset);
   void write_gains_to_registers_();
   bool verify_gain_writes_();
-  bool verify_offset_writes_(OffsetCalibrationType type);
   bool validate_spi_read_(uint16_t expected, const char *context = nullptr);
   void log_calibration_status_();
   const char *get_calibration_id_();
@@ -253,10 +219,19 @@ class ATM90E32Component final : public PollingComponent,
     uint32_t cumulative_reverse_active_energy_{0};
   } phase_[3];
 
-  OffsetCalibration offset_phase_[3];
+  struct OffsetCalibration {
+    int16_t voltage_offset_{0};
+    int16_t current_offset_{0};
+  } offset_phase_[3];
+
   OffsetCalibration config_offset_phase_[3];
-  OffsetCalibration power_offset_phase_[3];
-  OffsetCalibration config_power_offset_phase_[3];
+
+  struct PowerOffsetCalibration {
+    int16_t active_power_offset{0};
+    int16_t reactive_power_offset{0};
+  } power_offset_phase_[3];
+
+  PowerOffsetCalibration config_power_offset_phase_[3];
 
   struct GainCalibration {
     uint16_t voltage_gain{1};
@@ -290,8 +265,6 @@ class ATM90E32Component final : public PollingComponent,
   bool enable_offset_calibration_{false};
   bool enable_gain_calibration_{false};
   const char *instance_id_{nullptr};
-  bool has_stored_offset_calibration_{false};
-  bool has_stored_power_offset_calibration_{false};
   bool restored_offset_calibration_{false};
   bool restored_power_offset_calibration_{false};
   bool restored_gain_calibration_{false};

esphome/components/audio/audio_decoder.cpp

@@ -313,10 +313,9 @@ FileDecoderState AudioDecoder::decode_mp3_() {
       this->output_transfer_buffer_->increase_buffer_length(
           this->audio_stream_info_.value().frames_to_bytes(samples_decoded));
     }
-  } else if (result == micro_mp3::MP3_STREAM_INFO_READY || result == micro_mp3::MP3_STREAM_INFO_CHANGED) {
-    // Header parsed: capture stream info and resize the output buffer to fit one full frame.
-    // microMP3 always outputs 16-bit PCM. MP3_STREAM_INFO_CHANGED is handled identically: despite its
-    // negative value it is documented as recoverable, so it must not reach the catch-all below.
+  } else if (result == micro_mp3::MP3_STREAM_INFO_READY) {
+    // First successful header parse: capture stream info and resize the output buffer to fit one full frame.
+    // microMP3 always outputs 16-bit PCM.
     this->audio_stream_info_ =
         audio::AudioStreamInfo(16, this->mp3_decoder_->get_channels(), this->mp3_decoder_->get_sample_rate());
     this->free_buffer_required_ =

esphome/components/audio/audio_reader.cpp

@@ -58,9 +58,6 @@ esp_err_t AudioReader::add_sink(const std::weak_ptr<ring_buffer::RingBuffer> &ou
   if (current_audio_file_ != nullptr) {
     // A transfer buffer isn't ncessary for a local file
     this->file_ring_buffer_ = output_ring_buffer.lock();
-    if (this->file_ring_buffer_ == nullptr) {
-      return ESP_ERR_INVALID_STATE;
-    }
     return ESP_OK;
   }
 

esphome/components/audio/audio_transfer_buffer.cpp

@@ -51,14 +51,14 @@ void AudioTransferBuffer::increase_buffer_length(size_t bytes) { this->buffer_le
 
 void AudioTransferBuffer::clear_buffered_data() {
   this->buffer_length_ = 0;
-  if (this->ring_buffer_ != nullptr) {
+  if (this->ring_buffer_.use_count() > 0) {
     this->ring_buffer_->reset();
   }
 }
 
 void AudioSinkTransferBuffer::clear_buffered_data() {
   this->buffer_length_ = 0;
-  if (this->ring_buffer_ != nullptr) {
+  if (this->ring_buffer_.use_count() > 0) {
     this->ring_buffer_->reset();
   }
 #ifdef USE_SPEAKER
@@ -69,7 +69,7 @@ void AudioSinkTransferBuffer::clear_buffered_data() {
 }
 
 bool AudioTransferBuffer::has_buffered_data() const {
-  if (this->ring_buffer_ != nullptr) {
+  if (this->ring_buffer_.use_count() > 0) {
     return ((this->ring_buffer_->available() > 0) || (this->available() > 0));
   }
   return (this->available() > 0);
@@ -144,7 +144,7 @@ size_t AudioSourceTransferBuffer::transfer_data_from_source(TickType_t ticks_to_
   size_t bytes_to_read = AudioTransferBuffer::free();
   size_t bytes_read = 0;
   if (bytes_to_read > 0) {
-    if (this->ring_buffer_ != nullptr) {
+    if (this->ring_buffer_.use_count() > 0) {
       bytes_read = this->ring_buffer_->read((void *) this->get_buffer_end(), bytes_to_read, ticks_to_wait);
     }
 
@@ -161,7 +161,7 @@ size_t AudioSinkTransferBuffer::transfer_data_to_sink(TickType_t ticks_to_wait,
       bytes_written = this->speaker_->play(this->data_start_, this->available(), ticks_to_wait);
     } else
 #endif
-        if (this->ring_buffer_ != nullptr) {
+        if (this->ring_buffer_.use_count() > 0) {
       bytes_written =
           this->ring_buffer_->write_without_replacement((void *) this->data_start_, this->available(), ticks_to_wait);
     } else if (this->sink_callback_ != nullptr) {
@@ -186,7 +186,7 @@ bool AudioSinkTransferBuffer::has_buffered_data() const {
     return (this->speaker_->has_buffered_data() || (this->available() > 0));
   }
 #endif
-  if (this->ring_buffer_ != nullptr) {
+  if (this->ring_buffer_.use_count() > 0) {
     return ((this->ring_buffer_->available() > 0) || (this->available() > 0));
   }
   return (this->available() > 0);

esphome/components/ble_client/automation.h

@@ -22,23 +22,6 @@ class Automation {
   static const char *const TAG;
 };
 
-// Base for nodes that never read the parent's services.
-// The parent releases its services only once every node reports Established, so a node that never
-// reports it keeps that memory allocated for the life of the connection.
-class BLEClientServicelessNode : public BLEClientNode {
- public:
-  // Final so that Established is always reported on SEARCH_CMPL, before the derived node sees the event.
-  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) final {
-    if (event == ESP_GATTC_SEARCH_CMPL_EVT)
-      this->node_state = espbt::ClientState::ESTABLISHED;
-    this->on_gattc_event(event, gattc_if, param);
-  }
-
- protected:
-  // Derived nodes handle GATT events here rather than by overriding the handler above.
-  virtual void on_gattc_event(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) {}
-};
-
 // implement on_connect automation.
 class BLEClientConnectTrigger final : public Trigger<>, public BLEClientNode {
  public:
@@ -78,7 +61,7 @@ class BLEClientDisconnectTrigger final : public Trigger<>, public BLEClientNode
   }
 };
 
-class BLEClientPasskeyRequestTrigger final : public Trigger<>, public BLEClientServicelessNode {
+class BLEClientPasskeyRequestTrigger final : public Trigger<>, public BLEClientNode {
  public:
   explicit BLEClientPasskeyRequestTrigger(BLEClient *parent) { parent->register_ble_node(this); }
   void loop() override {}
@@ -88,7 +71,7 @@ class BLEClientPasskeyRequestTrigger final : public Trigger<>, public BLEClientS
   }
 };
 
-class BLEClientPasskeyNotificationTrigger final : public Trigger<uint32_t>, public BLEClientServicelessNode {
+class BLEClientPasskeyNotificationTrigger final : public Trigger<uint32_t>, public BLEClientNode {
  public:
   explicit BLEClientPasskeyNotificationTrigger(BLEClient *parent) { parent->register_ble_node(this); }
   void loop() override {}
@@ -99,7 +82,7 @@ class BLEClientPasskeyNotificationTrigger final : public Trigger<uint32_t>, publ
   }
 };
 
-class BLEClientNumericComparisonRequestTrigger final : public Trigger<uint32_t>, public BLEClientServicelessNode {
+class BLEClientNumericComparisonRequestTrigger final : public Trigger<uint32_t>, public BLEClientNode {
  public:
   explicit BLEClientNumericComparisonRequestTrigger(BLEClient *parent) { parent->register_ble_node(this); }
   void loop() override {}
@@ -332,17 +315,19 @@ template<typename... Ts> class BLEClientRemoveBondAction final : public Action<T
   BLEClient *parent_{nullptr};
 };
 
-template<typename... Ts> class BLEClientConnectAction final : public Action<Ts...>, public BLEClientServicelessNode {
+template<typename... Ts> class BLEClientConnectAction final : public Action<Ts...>, public BLEClientNode {
  public:
   BLEClientConnectAction(BLEClient *ble_client) {
     ble_client->register_ble_node(this);
     ble_client_ = ble_client;
   }
-  void on_gattc_event(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) override {
+  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                           esp_ble_gattc_cb_param_t *param) override {
     if (this->num_running_ == 0)
       return;
     switch (event) {
       case ESP_GATTC_SEARCH_CMPL_EVT:
+        this->node_state = espbt::ClientState::ESTABLISHED;
         this->parent()->run_later([this]() { this->play_next_tuple_(this->var_); });
         break;
       // if the connection is closed, terminate the automation chain.
@@ -379,13 +364,14 @@ template<typename... Ts> class BLEClientConnectAction final : public Action<Ts..
   std::tuple<Ts...> var_{};
 };
 
-template<typename... Ts> class BLEClientDisconnectAction final : public Action<Ts...>, public BLEClientServicelessNode {
+template<typename... Ts> class BLEClientDisconnectAction final : public Action<Ts...>, public BLEClientNode {
  public:
   BLEClientDisconnectAction(BLEClient *ble_client) {
     ble_client->register_ble_node(this);
     ble_client_ = ble_client;
   }
-  void on_gattc_event(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) override {
+  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                           esp_ble_gattc_cb_param_t *param) override {
     if (this->num_running_ == 0)
       return;
     switch (event) {

esphome/components/dallas_temp/dallas_temp.cpp

@@ -6,7 +6,6 @@ namespace esphome::dallas_temp {
 static const char *const TAG = "dallas.temp.sensor";
 
 static const uint8_t DALLAS_MODEL_DS18S20 = 0x10;
-static const uint8_t DALLAS_MODEL_DS18B20 = 0x28;
 static const uint8_t DALLAS_COMMAND_START_CONVERSION = 0x44;
 static const uint8_t DALLAS_COMMAND_READ_SCRATCH_PAD = 0xBE;
 static const uint8_t DALLAS_COMMAND_WRITE_SCRATCH_PAD = 0x4E;
@@ -155,14 +154,7 @@ float DallasTemperatureSensor::get_temp_c_() {
     default:
       break;
   }
-  // undocumented test for powerup measurement of 85
-  // https://github.com/cpetrich/counterfeit_DS18B20#solution-to-the-85-c-problem
-  if ((this->address_ & 0xff) == DALLAS_MODEL_DS18B20) {
-    if ((temp == 85 * 16) && (this->scratch_pad_[6] == 0xc)) {
-      ESP_LOGD(TAG, "dropping reading caused by sensor reset");
-      return NAN;
-    }
-  }
+
   return temp / 16.0f;
 }
 

esphome/components/debug/debug_esp32.cpp

@@ -66,15 +66,11 @@ const char *DebugComponent::get_reset_reason_(std::span<char, RESET_REASON_BUFFE
 
   unsigned reason = esp_reset_reason();
   if (reason < sizeof(RESET_REASONS) / sizeof(RESET_REASONS[0])) {
-    if (reason == ESP_RST_SW || reason == ESP_RST_WDT) {
-      // On some ESP32-S3 configurations (e.g. SPIRAM with fetch-instructions/rodata),
-      // esp_restart() intermittently produces RTCWDT_RTC_RST (ESP_RST_WDT) instead of
-      // ESP_RST_SW. Check the stored reboot source for both reset reasons so a software
-      // reboot that ends up as WDT still reports the correct source.
+    if (reason == ESP_RST_SW) {
       auto pref = global_preferences->make_preference(REBOOT_MAX_LEN,
                                                       fnv1_hash_extend(fnv1_hash(REBOOT_KEY), App.get_name().c_str()));
       char reboot_source[REBOOT_MAX_LEN]{};
-      if (pref.load(&reboot_source) && reboot_source[0] != '\0') {
+      if (pref.load(&reboot_source)) {
         reboot_source[REBOOT_MAX_LEN - 1] = '\0';
         snprintf(buf, size, "Reboot request from %s", reboot_source);
       } else {

esphome/components/debug/sensor.py

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

esphome/components/debug/text_sensor.py

@@ -9,7 +9,11 @@ from esphome.const import (
 )
 from esphome.types import ConfigType
 
-from . import CONF_DEBUG_ID, FILTER_SOURCE_FILES, DebugComponent  # noqa: F401  pylint: disable=unused-import
+from . import (  # noqa: F401  pylint: disable=unused-import
+    CONF_DEBUG_ID,
+    FILTER_SOURCE_FILES,
+    DebugComponent,
+)
 
 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->defer_sleep_();
+        this->next_enter_deep_sleep_ = true;
         return false;
       }
     }

esphome/components/deep_sleep/deep_sleep_component.cpp

@@ -17,7 +17,6 @@ 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);
@@ -46,7 +45,7 @@ void DeepSleepComponent::loop() {
 
 void DeepSleepComponent::begin_sleep(bool manual) {
   if (this->prevent_ && !manual) {
-    this->defer_sleep_();
+    this->next_enter_deep_sleep_ = true;
     return;
   }
 

esphome/components/deep_sleep/deep_sleep_component.h

@@ -190,11 +190,6 @@ 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->defer_sleep_();
+    this->next_enter_deep_sleep_ = true;
     return false;
   }
   return true;

esphome/components/es7210/es7210.cpp

@@ -153,14 +153,13 @@ bool ES7210::configure_mic_gain_() {
   ES7210_ERROR_CHECK(this->es7210_update_reg_bit_(ES7210_MIC2_GAIN_REG44, 0x0f, regv));
 
   // Configure mic 3
-  // 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->es7210_update_reg_bit_(ES7210_CLOCK_OFF_REG01, 0x0b, 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, 0x15, 0x00));
+  ES7210_ERROR_CHECK(this->es7210_update_reg_bit_(ES7210_CLOCK_OFF_REG01, 0x0b, 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/const.py

@@ -3,11 +3,18 @@ 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 KEY_ESP32, KEY_FLASH_SIZE, KEY_IDF_VERSION, KEY_VARIANT  # noqa: F401  # pylint: disable=unused-import
+from esphome.const import (  # noqa: F401  # pylint: disable=unused-import
+    KEY_ESP32,
+    KEY_FLASH_SIZE,
+    KEY_IDF_VERSION,
+    KEY_VARIANT,
+)
 
 # Back compat for external components only; in-tree callers import it
 # from esphome.espidf directly.
-from esphome.espidf import variant_to_idf_target  # noqa: F401  # pylint: disable=unused-import
+from esphome.espidf import (  # noqa: F401  # pylint: disable=unused-import
+    variant_to_idf_target,
+)
 
 KEY_BOARD = "board"
 KEY_SDKCONFIG_OPTIONS = "sdkconfig_options"

esphome/components/esphome/ota/ota_esphome.cpp

@@ -41,10 +41,7 @@ const noise::NoiseContext &ESPHomeOTAComponent::noise_context_() const {
 #endif
 static constexpr uint16_t OTA_BLOCK_SIZE = 8192;
 static constexpr uint32_t OTA_SOCKET_TIMEOUT_HANDSHAKE = 20000;  // milliseconds for initial handshake
-// Milliseconds for data transfer. Covers the lwIP retransmit run seen in
-// practice for a lost chunk ack (1.5 + 3 + 6 + 12 + 24 + 48 s); the CLI waits
-// longer (espota2.DATA_PHASE_TIMEOUT) so the device is free before it retries
-static constexpr uint32_t OTA_SOCKET_TIMEOUT_DATA = 105000;
+static constexpr uint32_t OTA_SOCKET_TIMEOUT_DATA = 90000;       // milliseconds for data transfer
 
 // Single-instance pointer — multi-port configs are rejected in final_validate.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)

esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp

@@ -91,14 +91,7 @@ void I2SAudioSpeakerBase::loop() {
     this->speaker_task_handle_ = nullptr;
 
     this->stop_i2s_driver_();
-    // ALL_BITS includes COMMAND_START. Take the bits from the clear itself, not from the snapshot at
-    // the top of loop(): the audio source's task can raise a start at any point above, including
-    // during stop_i2s_driver_(), and nothing would ever re-issue it.
-    const EventBits_t bits_before_clear = xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::ALL_BITS);
-    if (bits_before_clear & SpeakerEventGroupBits::COMMAND_START) {
-      ESP_LOGD(TAG, "Start requested while stopping; keeping the request");
-      xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::COMMAND_START);
-    }
+    xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::ALL_BITS);
     this->status_clear_error();
 
     this->on_task_stopped();
@@ -118,24 +111,21 @@ void I2SAudioSpeakerBase::loop() {
         break;
       }
 
-      // Still starting up or winding down from a previous run
-      if ((this->tx_handle_ != nullptr) || (this->speaker_task_handle_ != nullptr)) {
-        break;
-      }
-
       if (this->start_i2s_driver(this->audio_stream_info_) != ESP_OK) {
         ESP_LOGE(TAG, "Driver failed to start; retrying in 1 second");
         this->status_momentary_error("driver-failure", 1000);
         break;
       }
 
-      xTaskCreate(I2SAudioSpeakerBase::speaker_task, "speaker_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
-                  &this->speaker_task_handle_);
-
       if (this->speaker_task_handle_ == nullptr) {
-        ESP_LOGE(TAG, "Task failed to start, retrying in 1 second");
-        this->status_momentary_error("task-failure", 1000);
-        this->stop_i2s_driver_();  // Stops the driver to return the lock; will be reloaded in next attempt
+        xTaskCreate(I2SAudioSpeakerBase::speaker_task, "speaker_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
+                    &this->speaker_task_handle_);
+
+        if (this->speaker_task_handle_ == nullptr) {
+          ESP_LOGE(TAG, "Task failed to start, retrying in 1 second");
+          this->status_momentary_error("task-failure", 1000);
+          this->stop_i2s_driver_();  // Stops the driver to return the lock; will be reloaded in next attempt
+        }
       }
       break;
     case speaker::STATE_RUNNING:   // Intentional fallthrough
@@ -221,8 +211,8 @@ size_t I2SAudioSpeakerBase::play(const uint8_t *data, size_t length, TickType_t
 }
 
 bool I2SAudioSpeakerBase::has_buffered_data() const {
-  std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->audio_ring_buffer_.lock();
-  if (temp_ring_buffer != nullptr) {
+  if (this->audio_ring_buffer_.use_count() > 0) {
+    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->audio_ring_buffer_.lock();
     return temp_ring_buffer->available() > 0;
   }
   return false;

esphome/components/logger/logger_esp32.cpp

@@ -3,10 +3,8 @@
 
 #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>
 
 #ifdef USE_LOGGER_UART_SELECTION_USB_SERIAL_JTAG
 #include <driver/usb_serial_jtag.h>
@@ -17,10 +15,8 @@
 #include <driver/usb_serial_jtag_vfs.h>
 #endif
 #endif
-#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 "esp_idf_version.h"
 #include "freertos/FreeRTOS.h"
 
 #include <fcntl.h>
@@ -80,22 +76,12 @@ void init_uart(uart_port_t uart_num, uint32_t baud_rate, int tx_buffer_size) {
   uart_config.parity = UART_PARITY_DISABLE;
   uart_config.stop_bits = UART_STOP_BITS_1;
   uart_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
-#if SOC_UART_SUPPORT_XTAL_CLK
-  uart_config.source_clk = UART_SCLK_XTAL;
-#else
   uart_config.source_clk = UART_SCLK_DEFAULT;
-#endif
   uart_param_config(uart_num, &uart_config);
   // The logger only writes to UART, never reads, so use the minimum RX buffer.
   // 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/widgets/keyboard.py

@@ -15,7 +15,6 @@ from ..defines import (
 from ..types import LvCompound, LvType
 from . import Widget, WidgetType, get_widgets
 from .buttonmatrix import CONF_BUTTONMATRIX
-from .label import CONF_LABEL
 from .textarea import CONF_TEXTAREA, lv_textarea_t
 
 CONF_KEYBOARD = "keyboard"
@@ -50,7 +49,7 @@ class KeyboardType(WidgetType):
         )
 
     def get_uses(self):
-        return CONF_KEYBOARD, CONF_TEXTAREA, CONF_BUTTONMATRIX, CONF_LABEL
+        return CONF_KEYBOARD, CONF_TEXTAREA, CONF_BUTTONMATRIX
 
     async def to_code(self, w: Widget, config: dict):
         add_lv_use("KEY_LISTENER")

esphome/components/lvgl/widgets/qrcode.py

@@ -10,7 +10,6 @@ from ..types import lv_obj_t
 from . import Widget, WidgetType
 from .canvas import CONF_CANVAS
 from .img import CONF_IMAGE
-from .label import CONF_LABEL
 
 CONF_QRCODE = "qrcode"
 CONF_DARK_COLOR = "dark_color"
@@ -42,7 +41,7 @@ class QrCodeType(WidgetType):
         )
 
     def get_uses(self):
-        return CONF_CANVAS, CONF_IMAGE, CONF_LABEL
+        return CONF_CANVAS, CONF_IMAGE
 
     async def to_code(self, w: Widget, config):
         await w.set_property(

esphome/components/lvgl/widgets/tabview.py

@@ -28,7 +28,6 @@ from ..types import LV_EVENT, LvType, ObjUpdateAction, lv_obj_t, lv_obj_t_ptr
 from . import Widget, WidgetType, add_widgets, get_widgets, set_obj_properties
 from .button import button_spec
 from .buttonmatrix import CONF_BUTTONMATRIX, buttonmatrix_spec
-from .label import CONF_LABEL
 from .obj import obj_spec
 
 CONF_TABVIEW = "tabview"
@@ -75,7 +74,7 @@ class TabviewType(WidgetType):
         )
 
     def get_uses(self):
-        return CONF_BUTTONMATRIX, TYPE_FLEX, CONF_BUTTON, CONF_LABEL
+        return CONF_BUTTONMATRIX, TYPE_FLEX, CONF_BUTTON
 
     async def to_code(self, w: Widget, config: dict):
         await w.set_property(

esphome/components/micro_wake_word/micro_wake_word.cpp

@@ -129,7 +129,7 @@ void MicroWakeWord::setup() {
       return;
     }
     std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-    if (temp_ring_buffer != nullptr) {
+    if (this->ring_buffer_.use_count() > 1) {
       // Producer-only write: never touches consumer state. If the buffer is full, ask the inference task
       // to drain it - reset() is a consumer operation and must run on the inference task's thread.
       // Disable partial writes so audio chunks are either fully accepted or rejected and handled below.
@@ -446,9 +446,9 @@ void MicroWakeWord::loop() {
     xEventGroupClearBits(this->event_group_, EventGroupBits::TASK_STOPPING);
   }
 
-  // Retries on a subsequent loop if the task is still running on the other core
-  if ((event_group_bits & EventGroupBits::TASK_STOPPED) && this->inference_task_.deallocate()) {
+  if ((event_group_bits & EventGroupBits::TASK_STOPPED)) {
     ESP_LOGD(TAG, "Inference task is finished, freeing task resources");
+    this->inference_task_.deallocate();
     xEventGroupClearBits(this->event_group_, ALL_BITS);
     xQueueReset(this->detection_queue_);
     this->set_state_(State::STOPPED);

esphome/components/microphone/microphone_source.h

@@ -48,7 +48,7 @@ class MicrophoneSource final {
   template<typename F> void add_data_callback(F &&data_callback) {
     this->mic_->add_data_callback([this, data_callback](const std::vector<uint8_t> &data) {
       if (this->enabled_ || this->passive_) {
-        if (this->processed_samples_ == nullptr) {
+        if (this->processed_samples_.use_count() == 0) {
           // Create vector if its unused
           this->processed_samples_ = std::make_shared<std::vector<uint8_t>>();
         }

esphome/components/mixer/speaker/mixer_speaker.cpp

@@ -218,7 +218,7 @@ size_t SourceSpeaker::play(const uint8_t *data, size_t length, TickType_t ticks_
   }
   size_t bytes_written = 0;
   std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-  if (temp_ring_buffer != nullptr) {
+  if (temp_ring_buffer.use_count() > 0) {
     // Only write to the ring buffer if the reference is valid
     bytes_written = temp_ring_buffer->write_without_replacement(data, length, ticks_to_wait);
     if (bytes_written > 0) {
@@ -250,14 +250,14 @@ esp_err_t SourceSpeaker::start_() {
   // avoids unnecessary single-frame splices.
   const size_t ring_buffer_size =
       (this->audio_stream_info_.ms_to_bytes(this->buffer_duration_ms_) / bytes_per_frame) * bytes_per_frame;
-  if (this->audio_source_ == nullptr) {
+  if (this->audio_source_.use_count() == 0) {
     std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-    if (temp_ring_buffer == nullptr) {
+    if (!temp_ring_buffer) {
       temp_ring_buffer = ring_buffer::RingBuffer::create(ring_buffer_size);
       this->ring_buffer_ = temp_ring_buffer;
     }
 
-    if (temp_ring_buffer == nullptr) {
+    if (!temp_ring_buffer) {
       return ESP_ERR_NO_MEM;
     }
 
@@ -278,7 +278,7 @@ void SourceSpeaker::stop() { this->send_command_(SOURCE_SPEAKER_COMMAND_STOP); }
 void SourceSpeaker::finish() { this->send_command_(SOURCE_SPEAKER_COMMAND_FINISH); }
 
 bool SourceSpeaker::has_buffered_data() const {
-  return ((this->audio_source_ != nullptr) && this->audio_source_->has_buffered_data());
+  return ((this->audio_source_.use_count() > 0) && this->audio_source_->has_buffered_data());
 }
 
 void SourceSpeaker::set_mute_state(bool mute_state) {
@@ -382,8 +382,8 @@ void MixerSpeaker::loop() {
     ESP_LOGV(TAG, "Stopping");
     xEventGroupClearBits(this->event_group_, MIXER_TASK_STATE_STOPPING);
   }
-  // Retries on a subsequent loop if the task is still running on the other core
-  if ((event_group_bits & MIXER_TASK_STATE_STOPPED) && this->task_.deallocate()) {
+  if (event_group_bits & MIXER_TASK_STATE_STOPPED) {
+    this->task_.deallocate();
     ESP_LOGD(TAG, "Stopped");
     xEventGroupClearBits(this->event_group_, MIXER_TASK_ALL_BITS);
     this->all_stopped_since_ms_ = 0;
@@ -496,7 +496,7 @@ void MixerSpeaker::audio_mixer_task(void *params) {
         if (speaker->is_running() && !speaker->get_pause_state()) {
           // Speaker is running and not paused, so it possibly can provide audio data
           std::shared_ptr<audio::RingBufferAudioSource> audio_source = speaker->get_audio_source().lock();
-          if (audio_source == nullptr) {
+          if (audio_source.use_count() == 0) {
             // No audio source allocated, so skip processing this speaker
             continue;
           }

esphome/components/mlx90614/mlx90614.cpp

@@ -26,129 +26,44 @@ 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 (std::isnan(this->emissivity_)) {
+  if (!this->write_emissivity_()) {
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    this->mark_failed();
     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_() {
-  // 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) {
+  if (std::isnan(this->emissivity_))
     return true;
-  }
-
-  return this->write_register_(MLX90614_EMISSIVITY, desired_emissivity);
-}
-
-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;
-
-  // 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);
+  uint16_t value = (uint16_t) (this->emissivity_ * 65535);
+  if (!this->write_bytes_(MLX90614_EMISSIVITY, 0)) {
     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);
+  if (!this->write_bytes_(MLX90614_EMISSIVITY, value)) {
     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;
-  }
-
+  delay(10);
   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];
+bool MLX90614Component::write_bytes_(uint8_t reg, uint16_t data) {
+  uint8_t buf[5];
   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;
+  buf[2] = data & 0xFF;
+  buf[3] = data >> 8;
+  buf[4] = crc8(buf, 4, 0x00, 0x07, true);
+  return this->write_bytes(reg, buf + 2, 3);
 }
 
 void MLX90614Component::dump_config() {
   ESP_LOGCONFIG(TAG, "MLX90614:");
   LOG_I2C_DEVICE(this);
-  if (this->emissivity_write_attempts_ != 0) {
-    ESP_LOGW(TAG, "  Emissivity not written yet, will retry");
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
   LOG_SENSOR("  ", "Ambient", this->ambient_sensor_);
@@ -156,41 +71,33 @@ void MLX90614Component::dump_config() {
 }
 
 void MLX90614Component::update() {
-  // 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 emissivity[3];
+  if (this->read_register(MLX90614_EMISSIVITY, emissivity, 3) != i2c::ERROR_OK) {
+    this->status_set_warning();
+    return;
   }
+  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,18 +18,13 @@ 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_register_(uint8_t reg, uint16_t data);
-  i2c::ErrorCode read_register_(uint8_t reg, uint16_t &data);
+  bool write_bytes_(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/mqtt/mqtt_light.cpp

@@ -67,9 +67,6 @@ void MQTTJSONLightComponent::send_discovery(JsonObject root, mqtt::SendDiscovery
   if (traits.supports_color_mode(ColorMode::RGB_COLD_WARM_WHITE))
     color_modes.add(ESPHOME_F("rgbww"));
 
-  if (traits.supports_color_capability(ColorCapability::BRIGHTNESS))
-    root[ESPHOME_F("brightness")] = true;
-
   if (traits.supports_color_mode(ColorMode::COLOR_TEMPERATURE) ||
       traits.supports_color_mode(ColorMode::COLD_WARM_WHITE)) {
     root[MQTT_MIN_MIREDS] = traits.get_min_mireds();

esphome/components/network/util.h

@@ -26,34 +26,30 @@ namespace esphome::network {
 
 /// Return whether the node is connected to the network (through wifi, eth, ...)
 ESPHOME_ALWAYS_INLINE inline bool is_connected() {
-  // With a single interface enabled the checks below collapse to `if (x) return true; return false;`, which
-  // clang-tidy wants folded into one return. Keep the per-interface form so every enabled interface is checked.
-  // NOLINTBEGIN(readability-simplify-boolean-expr)
 #ifdef USE_ETHERNET
   if (ethernet::global_eth_component != nullptr && ethernet::global_eth_component->is_connected())
     return true;
 #endif
 
 #ifdef USE_MODEM
-  if (modem::global_modem_component != nullptr && modem::global_modem_component->is_connected())
-    return true;
+  if (modem::global_modem_component != nullptr)
+    return modem::global_modem_component->is_connected();
 #endif
 
 #ifdef USE_WIFI
-  if (wifi::global_wifi_component != nullptr && wifi::global_wifi_component->is_connected())
-    return true;
+  if (wifi::global_wifi_component != nullptr)
+    return wifi::global_wifi_component->is_connected();
 #endif
 
 #ifdef USE_OPENTHREAD
-  if (openthread::global_openthread_component != nullptr && openthread::global_openthread_component->is_connected())
-    return true;
+  if (openthread::global_openthread_component != nullptr)
+    return openthread::global_openthread_component->is_connected();
 #endif
 
 #ifdef USE_HOST
   return true;  // Assume it's connected
 #endif
   return false;
-  // NOLINTEND(readability-simplify-boolean-expr)
 }
 
 /// Return whether the network is disabled: every configured interface with a

esphome/components/nextion/display.py

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

esphome/components/noise/__init__.py

@@ -88,12 +88,12 @@ def encryption_schema(config: ConfigType | None) -> ConfigType:
 
 async def to_code(config: ConfigType) -> None:
     cg.add_define("USE_NOISE")
-    cg.add_library("esphome/noise-c", "0.1.26")
+    cg.add_library("esphome/noise-c", "0.1.24")
     # noise-c depends on libsodium, but declaring it here too lets the
     # library manager see the full set up front instead of discovering
     # libsodium only after noise-c has downloaded, so the two can download
     # in parallel. The version must match noise-c's library.json.
-    cg.add_library("esphome/libsodium", "1.10021.8")
+    cg.add_library("esphome/libsodium", "1.10021.6")
     # Enable optimized memzero/memcmp in libsodium instead of volatile byte loops
     cg.add_build_flag("-DHAVE_WEAK_SYMBOLS=1")
     cg.add_build_flag("-DHAVE_INLINE_ASM=1")

esphome/components/resampler/speaker/resampler_speaker.cpp

@@ -153,8 +153,8 @@ void ResamplerSpeaker::loop() {
     ESP_LOGV(TAG, "Stopping");
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::STATE_STOPPING);
   }
-  // Retries on a subsequent loop if the task is still running on the other core
-  if ((event_group_bits & ResamplingEventGroupBits::STATE_STOPPED) && this->task_.deallocate()) {
+  if (event_group_bits & ResamplingEventGroupBits::STATE_STOPPED) {
+    this->task_.deallocate();
     ESP_LOGD(TAG, "Stopped");
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::ALL_BITS);
   }
@@ -235,7 +235,7 @@ size_t ResamplerSpeaker::play(const uint8_t *data, size_t length, TickType_t tic
     bytes_written = this->output_speaker_->play(data, length, ticks_to_wait);
   } else {
     std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-    if (temp_ring_buffer != nullptr) {
+    if (temp_ring_buffer) {
       // Only write to the ring buffer if the reference is valid
       bytes_written = temp_ring_buffer->write_without_replacement(data, length, ticks_to_wait);
     } else {
@@ -299,7 +299,7 @@ bool ResamplerSpeaker::has_buffered_data() const {
   bool has_ring_buffer_data = false;
   if (this->requires_resampling_()) {
     std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-    if (temp_ring_buffer != nullptr) {
+    if (temp_ring_buffer) {
       has_ring_buffer_data = (temp_ring_buffer->available() > 0);
     }
   }
@@ -342,7 +342,7 @@ void ResamplerSpeaker::resample_task(void *params) {
       std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = ring_buffer::RingBuffer::create(
           this_resampler->audio_stream_info_.ms_to_bytes(this_resampler->buffer_duration_ms_));
 
-      if (temp_ring_buffer == nullptr) {
+      if (!temp_ring_buffer) {
         err = ESP_ERR_NO_MEM;
       } else {
         this_resampler->ring_buffer_ = temp_ring_buffer;

esphome/components/rf_bridge/rf_bridge.cpp

@@ -18,16 +18,6 @@ void RFBridgeComponent::ack_() {
 }
 
 bool RFBridgeComponent::parse_bridge_byte_(uint8_t byte) {
-  if (this->bucket_frame_candidate_ && byte == RF_CODE_START) {
-    // A queued next frame proves the trailing 0x55 really was the bucket
-    // frame's terminator: Portisch builds pulse entries from alternating
-    // signal edges, so the two level bits inside one pulse byte are always
-    // opposite — 0xAA (two high-level nibbles) cannot occur in pulse data.
-    // Finalize before this byte starts the new frame, so back-to-back
-    // deliveries are split even when loop() never observed a quiet gap
-    // between them.
-    this->finish_bucket_frame_();
-  }
   size_t at = this->rx_buffer_.size();
   this->rx_buffer_.push_back(byte);
   const uint8_t *raw = &this->rx_buffer_[0];
@@ -94,21 +84,26 @@ bool RFBridgeComponent::parse_bridge_byte_(uint8_t byte) {
       break;
     }
     case RF_CODE_RFIN_BUCKET: {
-      if (at == 2) {
-        // The count byte: Portisch sends at most 7 buckets + sync, so 0 or
-        // >8 cannot be a genuine capture — reject before it can occupy the
-        // buffer for a full frame timeout.
-        return byte != 0 && byte <= B1_MAX_BUCKET_COUNT;
+      if (byte != RF_CODE_STOP) {
+        return true;
       }
-      // 0x55 is legal DATA inside a B1 frame: bucket durations are sent
-      // with only their HIGH byte masked to 7 bits, so a duration such as
-      // 0x0155 puts a raw 0x55 low byte inside the table — the first 0x55
-      // must therefore not end the capture. The header declares the table
-      // length (raw[2] pairs), so a 0x55 there is always data; one at or
-      // past the first pulse index is a terminator CANDIDATE, confirmed
-      // once the UART goes quiet (finish_bucket_frame_ in loop()).
-      this->bucket_frame_candidate_ = byte == RF_CODE_STOP && at >= 3 + static_cast<size_t>(raw[2]) * 2;
-      return true;
+
+      uint8_t buckets = raw[2] << 1;
+      std::string str;
+      char next_byte[3];  // 2 hex chars + null
+
+      for (uint32_t i = 0; i <= at; i++) {
+        buf_append_printf(next_byte, sizeof(next_byte), 0, "%02X", raw[i]);
+        str += next_byte;
+        if ((i > 3) && buckets) {
+          buckets--;
+        }
+        if ((i < 3) || (buckets % 2) || (i == at - 1)) {
+          str += " ";
+        }
+      }
+      ESP_LOGI(TAG, "Received RFBridge Bucket: %s", str.c_str());
+      break;
     }
     default:
       ESP_LOGW(TAG, "Unknown action: 0x%02X", action);
@@ -124,47 +119,6 @@ bool RFBridgeComponent::parse_bridge_byte_(uint8_t byte) {
   return false;
 }
 
-void RFBridgeComponent::finish_bucket_frame_() {
-  if (this->rx_buffer_.size() < 4) {
-    // The candidate flag requires a header + non-empty bucket table, so
-    // this cannot happen while flag and buffer stay consistent; guard the
-    // raw[2] / size-1 reads against any future divergence anyway.
-    this->rx_buffer_.clear();
-    this->bucket_frame_candidate_ = false;
-    return;
-  }
-  const uint8_t *raw = this->rx_buffer_.data();
-  const size_t at = this->rx_buffer_.size() - 1;
-
-  uint8_t buckets = raw[2] << 1;
-  std::string str;
-  char next_byte[3];  // 2 hex chars + null
-
-  for (uint32_t i = 0; i <= at; i++) {
-    buf_append_printf(next_byte, sizeof(next_byte), 0, "%02X", raw[i]);
-    str += next_byte;
-    if ((i > 3) && buckets) {
-      buckets--;
-    }
-    if ((i < 3) || (buckets % 2) || (i == at - 1)) {
-      str += " ";
-    }
-  }
-  ESP_LOGI(TAG, "Received RFBridge Bucket: %s", str.c_str());
-
-  // Deliberately NOT ACKed: Portisch's B1 command handler leaves its
-  // last_sniffing_command at the previous mode (RF_CODE_RFIN), and its
-  // host-ACK handler re-arms sniffing from that stale value — so ACKing a
-  // bucket delivery silently reverts the radio to standard sniffing and
-  // ends bucket capture. Its delivery path is fire-and-forget and never
-  // waits for a host ACK. Stock Itead firmware never sends B1 frames, so
-  // suppressing this ACK cannot change stock-firmware behavior.
-  // https://github.com/esphome/esphome/issues/17682
-
-  this->rx_buffer_.clear();
-  this->bucket_frame_candidate_ = false;
-}
-
 void RFBridgeComponent::write_byte_str_(const std::string &codes) {
   uint8_t code;
   int size = codes.length();
@@ -176,31 +130,12 @@ void RFBridgeComponent::write_byte_str_(const std::string &codes) {
 
 void RFBridgeComponent::loop() {
   const uint32_t now = App.get_loop_component_start_time();
-  size_t avail = this->available();
-  if (avail == 0 && this->bucket_frame_candidate_ && now - this->last_bridge_byte_ > BUCKET_CANDIDATE_QUIET_MS) {
-    // The trailing 0x55 was followed by UART quiet, so it really was the
-    // frame terminator and not an interior data byte.
-    this->finish_bucket_frame_();
-    this->last_bridge_byte_ = now;
-  }
-  const bool receiving_bucket = this->rx_buffer_.size() >= 2 && this->rx_buffer_[1] == RF_CODE_RFIN_BUCKET;
-  if (receiving_bucket) {
-    // Never declare an in-progress bucket frame dead while its continuation
-    // bytes are already queued: a stalled loop() otherwise discards a live
-    // frame that the UART buffer proves is still arriving.
-    if (avail == 0 && now - this->last_bridge_byte_ > BUCKET_FRAME_TIMEOUT_MS) {
-      ESP_LOGD(TAG, "Discarding incomplete RFBridge Bucket frame (%u bytes)",
-               static_cast<unsigned>(this->rx_buffer_.size()));
-      this->rx_buffer_.clear();
-      this->bucket_frame_candidate_ = false;
-      this->last_bridge_byte_ = now;
-    }
-  } else if (now - this->last_bridge_byte_ > 50) {
+  if (now - this->last_bridge_byte_ > 50) {
     this->rx_buffer_.clear();
-    this->bucket_frame_candidate_ = false;
     this->last_bridge_byte_ = now;
   }
 
+  size_t avail = this->available();
   while (avail > 0) {
     uint8_t buf[64];
     size_t to_read = std::min(avail, sizeof(buf));
@@ -211,14 +146,12 @@ void RFBridgeComponent::loop() {
     for (size_t i = 0; i < to_read; i++) {
       if (this->rx_buffer_.size() > MAX_RX_BUFFER_SIZE) {
         this->rx_buffer_.clear();
-        this->bucket_frame_candidate_ = false;
       }
       if (this->parse_bridge_byte_(buf[i])) {
         ESP_LOGVV(TAG, "Parsed: 0x%02X", buf[i]);
         this->last_bridge_byte_ = now;
       } else {
         this->rx_buffer_.clear();
-        this->bucket_frame_candidate_ = false;
       }
     }
   }

esphome/components/rf_bridge/rf_bridge.h

@@ -30,17 +30,6 @@ static const uint8_t RF_CODE_BEEP = 0xC0;
 static const uint8_t RF_CODE_STOP = 0x55;
 static const uint8_t RF_DEBOUNCE = 200;
 static const size_t MAX_RX_BUFFER_SIZE = 512;
-// ~10 byte times at 19200 baud: long enough to prove the UART went quiet
-// after a possible bucket-frame terminator, short enough to finish well
-// before the next radio capture can be delivered.
-static const uint32_t BUCKET_CANDIDATE_QUIET_MS = 5;
-// Portisch drains a B1 frame's header, bucket table, and pulse data as
-// separate UART writes, so an in-progress bucket frame tolerates a longer
-// inter-region gap than the generic 50 ms inter-byte timeout.
-static const uint32_t BUCKET_FRAME_TIMEOUT_MS = 250;
-// Portisch's uart_put_RF_buckets sends at most 7 buckets plus the sync
-// bucket, so a B1 count byte above 8 (or 0) is malformed for any protocol.
-static const uint8_t B1_MAX_BUCKET_COUNT = 8;
 
 struct RFBridgeData {
   uint16_t sync;
@@ -78,12 +67,10 @@ class RFBridgeComponent final : public uart::UARTDevice, public Component {
   void ack_();
   void decode_();
   bool parse_bridge_byte_(uint8_t byte);
-  void finish_bucket_frame_();
   void write_byte_str_(const std::string &codes);
 
   std::vector<uint8_t> rx_buffer_;
   uint32_t last_bridge_byte_{0};
-  bool bucket_frame_candidate_{false};
 
   CallbackManager<void(RFBridgeData)> data_callback_;
   CallbackManager<void(RFBridgeAdvancedData)> advanced_data_callback_;

esphome/components/sendspin/__init__.py

@@ -6,17 +6,12 @@ from esphome.components import esp32, network, psram, socket, wifi
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BUFFER_SIZE,
-    CONF_ESPHOME,
     CONF_FORMAT,
     CONF_HEIGHT,
     CONF_ID,
-    CONF_MODEL,
-    CONF_NAME,
-    CONF_PROJECT,
     CONF_SAMPLE_RATE,
     CONF_SOURCE,
     CONF_TASK_STACK_IN_PSRAM,
-    CONF_VERSION,
     CONF_WIDTH,
 )
 from esphome.core import CORE, ID
@@ -32,18 +27,9 @@ DOMAIN = "sendspin"
 CONF_DISPLAY_OFFSET = "display_offset"
 CONF_SENDSPIN_ID = "sendspin_id"
 
-CONF_FIRMWARE_VERSION = "firmware_version"
-CONF_MANUFACTURER = "manufacturer"
-
-# An empty device information string would be sent to the server as an empty value rather than
-# falling back, so reject it instead of silently substituting the fallback. The 127 byte cap keeps
-# the length prefix of a protobuf string field to a single byte, matching `esphome: project:`.
-DEVICE_INFO_STRING = cv.All(cv.string_strict, cv.Length(min=1), cv.ByteLength(max=127))
-
 CONF_INITIAL_STATIC_DELAY = "initial_static_delay"
 CONF_FIXED_DELAY = "fixed_delay"
 CONF_DECODE_MEMORY = "decode_memory"
-CONF_CODECS = "codecs"
 
 # Matches ARTWORK_MAX_SLOTS in sendspin-cpp.
 MAX_ARTWORK_SLOTS = 4
@@ -58,20 +44,6 @@ CODEC_FORMAT_OPUS = SendspinCodecFormat.enum("OPUS")
 CODEC_FORMAT_PCM = SendspinCodecFormat.enum("PCM")
 CODEC_FORMAT_UNSUPPORTED = SendspinCodecFormat.enum("UNSUPPORTED")
 
-CODEC_FLAC = "flac"
-CODEC_OPUS = "opus"
-CODEC_PCM = "pcm"
-
-CODECS = {
-    CODEC_FLAC: CODEC_FORMAT_FLAC,
-    CODEC_OPUS: CODEC_FORMAT_OPUS,
-    CODEC_PCM: CODEC_FORMAT_PCM,
-}
-
-# Opus only supports 48 kHz audio, so it is left out of the default list at other rates.
-DEFAULT_CODECS = [CODEC_FLAC, CODEC_OPUS, CODEC_PCM]
-OPUS_SAMPLE_RATE = 48000
-
 SendspinImageFormat = sendspin_library_ns.enum("SendspinImageFormat", is_class=True)
 IMAGE_FORMAT_JPEG = SendspinImageFormat.enum("JPEG")
 IMAGE_FORMAT_PNG = SendspinImageFormat.enum("PNG")
@@ -211,9 +183,6 @@ CONFIG_SCHEMA = cv.All(
         {
             cv.GenerateID(): cv.declare_id(SendspinHub),
             cv.Optional(CONF_TASK_STACK_IN_PSRAM): psram.validate_task_stack_in_psram,
-            cv.Optional(CONF_MANUFACTURER): DEVICE_INFO_STRING,
-            cv.Optional(CONF_MODEL): DEVICE_INFO_STRING,
-            cv.Optional(CONF_FIRMWARE_VERSION): DEVICE_INFO_STRING,
         }
     ),
     cv.only_on_esp32,
@@ -264,22 +233,6 @@ async def to_code(config: ConfigType) -> None:
         cg.add(var.set_task_stack_in_psram(True))
         psram.request_external_task_stack()
 
-    # Device information for the server's client/hello message. Falls back to the project
-    # information, which is written as `manufacturer.model`. Anything still unset keeps the
-    # default the hub itself applies: the ESPHome name and version.
-    project = CORE.config[CONF_ESPHOME].get(CONF_PROJECT, {})
-    project_manufacturer, _, project_model = project.get(CONF_NAME, "").partition(".")
-    for value, setter in (
-        (config.get(CONF_MANUFACTURER) or project_manufacturer, var.set_manufacturer),
-        (config.get(CONF_MODEL) or project_model, var.set_model),
-        (
-            config.get(CONF_FIRMWARE_VERSION) or project.get(CONF_VERSION),
-            var.set_firmware_version,
-        ),
-    ):
-        if value:
-            cg.add(setter(value))
-
     # sendspin-cpp library
     esp32.add_idf_component(name="sendspin/sendspin-cpp", ref="0.7.2")
 
@@ -333,13 +286,16 @@ async def to_code(config: ConfigType) -> None:
     if data.player_support:
         cg.add_define("USE_SENDSPIN_PLAYER", True)
 
-        # Configures the player role. Each configured codec is advertised for 16 bits per sample
-        # mono and stereo at the configured sample rate. The order is a preference order, both for
-        # the codecs themselves and for stereo over mono.
+        # Configures the player role. We always assume support for 16 bits per sample mono and stereo FLAC, Opus, and PCM at the configured sample rate
+        # (with Opus only supported at 48 kHz since that's the only sample rate it supports). Users can configure the specific formats via the Sendspin server
         player_cfg = data.player_config
         sample_rate = player_cfg[CONF_SAMPLE_RATE]
 
-        codecs = [CODECS[codec] for codec in player_cfg[CONF_CODECS]]
+        # OPUS only supports 48 kHz audio
+        codecs = [CODEC_FORMAT_FLAC]
+        if sample_rate == 48000:
+            codecs.append(CODEC_FORMAT_OPUS)
+        codecs.append(CODEC_FORMAT_PCM)
 
         def _audio_format(codec: MockObj, channels: int) -> cg.StructInitializer:
             return cg.StructInitializer(

esphome/components/sendspin/media_source/__init__.py

@@ -13,16 +13,11 @@ from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType
 
 from .. import (
-    CODEC_OPUS,
-    CODECS,
-    CONF_CODECS,
     CONF_DECODE_MEMORY,
     CONF_FIXED_DELAY,
     CONF_INITIAL_STATIC_DELAY,
     CONF_SENDSPIN_ID,
-    DEFAULT_CODECS,
     MEMORY_LOCATIONS,
-    OPUS_SAMPLE_RATE,
     SendspinHub,
     register_player_config,
     request_controller_support,
@@ -54,32 +49,10 @@ DisableStaticDelayAdjustmentAction = sendspin_ns.class_(
 )
 
 
-def _resolve_codecs(config: ConfigType) -> ConfigType:
-    """Validate the codec preference list, filling in the default when it is not set."""
-    sample_rate = config[CONF_SAMPLE_RATE]
-    if (codecs := config.get(CONF_CODECS)) is None:
-        config[CONF_CODECS] = [
-            codec
-            for codec in DEFAULT_CODECS
-            if codec != CODEC_OPUS or sample_rate == OPUS_SAMPLE_RATE
-        ]
-        return config
-
-    if len(set(codecs)) != len(codecs):
-        raise cv.Invalid("Each codec may only be listed once", path=[CONF_CODECS])
-    if CODEC_OPUS in codecs and sample_rate != OPUS_SAMPLE_RATE:
-        raise cv.Invalid(
-            f"Codec '{CODEC_OPUS}' requires a {CONF_SAMPLE_RATE} of {OPUS_SAMPLE_RATE}",
-            path=[CONF_CODECS],
-        )
-    return config
-
-
 def _register(config: ConfigType) -> ConfigType:
     request_controller_support()
     register_player_config(
         {
-            CONF_CODECS: config[CONF_CODECS],
             CONF_SAMPLE_RATE: config[CONF_SAMPLE_RATE],
             CONF_BUFFER_SIZE: config[CONF_BUFFER_SIZE],
             CONF_INITIAL_STATIC_DELAY: config[CONF_INITIAL_STATIC_DELAY],
@@ -112,13 +85,9 @@ CONFIG_SCHEMA = cv.All(
                 min=16000, max=96000
             ),
             cv.Optional(CONF_DECODE_MEMORY): cv.one_of(*MEMORY_LOCATIONS, lower=True),
-            cv.Optional(CONF_CODECS): cv.All(
-                cv.ensure_list(cv.enum(CODECS, lower=True)), cv.Length(min=1)
-            ),
         }
     ),
     cv.only_on_esp32,
-    _resolve_codecs,
     _register,
 )
 

esphome/components/sendspin/sendspin_hub.cpp

@@ -76,12 +76,8 @@ void SendspinHub::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "Sendspin Hub:\n"
                 "  Client ID: %s\n"
-                "  Manufacturer: %s\n"
-                "  Model: %s\n"
-                "  Firmware version: %s\n"
                 "  Task stack in PSRAM: %s",
-                get_client_id_into_buffer(mac_buf), this->manufacturer_, this->get_product_name_(),
-                this->firmware_version_, YESNO(this->task_stack_in_psram_));
+                get_client_id_into_buffer(mac_buf), YESNO(this->task_stack_in_psram_));
 
 #ifdef USE_SENDSPIN_ARTWORK
   // Slot indices come from the order the image platform entries were declared, so the log is the
@@ -131,19 +127,15 @@ const char *SendspinHub::get_client_id_into_buffer(std::span<char, MAC_ADDRESS_P
   return get_mac_address_pretty_into_buffer(buf);
 }
 
-const char *SendspinHub::get_product_name_() const {
-  return this->model_ != nullptr ? this->model_ : App.get_name().c_str();
-}
-
 sendspin::SendspinClientConfig SendspinHub::build_client_config_() {
   sendspin::SendspinClientConfig config;
 
   char mac_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
   config.client_id = SendspinHub::get_client_id_into_buffer(mac_buf);
   config.name = App.get_friendly_name();
-  config.product_name = this->get_product_name_();
-  config.manufacturer = this->manufacturer_;
-  config.software_version = this->firmware_version_;
+  config.product_name = App.get_name();
+  config.manufacturer = "ESPHome";
+  config.software_version = ESPHOME_VERSION;
   config.httpd_psram_stack = this->task_stack_in_psram_;
 
   return config;

esphome/components/sendspin/sendspin_hub.h

@@ -8,7 +8,6 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
-#include "esphome/core/version.h"
 
 #include <sendspin/client.h>
 #include <sendspin/config.h>
@@ -126,15 +125,6 @@ class SendspinHub final : public Component,
 
   void set_task_stack_in_psram(bool task_stack_in_psram) { this->task_stack_in_psram_ = task_stack_in_psram; }
 
-  /// @brief Sets the device information reported to the server in the `client/hello` message.
-  ///
-  /// Each takes a pointer to a string literal emitted by codegen, so it must stay valid for the
-  /// lifetime of the hub. Only called for values the configuration overrides; anything left alone
-  /// keeps the default described on the member below.
-  void set_manufacturer(const char *manufacturer) { this->manufacturer_ = manufacturer; }
-  void set_model(const char *model) { this->model_ = model; }
-  void set_firmware_version(const char *firmware_version) { this->firmware_version_ = firmware_version; }
-
   // --- Sendspin role specific methods ---
 
 #ifdef USE_SENDSPIN_ARTWORK
@@ -197,9 +187,6 @@ class SendspinHub final : public Component,
   /// @brief Builds the SendspinClientConfig from ESPHome configuration and platform info.
   sendspin::SendspinClientConfig build_client_config_();
 
-  /// @brief Returns the product name reported to the server: the configured model, or the device name.
-  const char *get_product_name_() const;
-
   /// @brief Writes the active network interface's MAC into @p buf and returns its data pointer.
   /// Uses the ethernet MAC if ethernet is configured, otherwise the base MAC (used by wifi).
   static const char *get_client_id_into_buffer(std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf);
@@ -281,12 +268,6 @@ class SendspinHub final : public Component,
   CallbackManager<void(const sendspin::GroupUpdateObject &)> group_update_callbacks_{};
 
   bool task_stack_in_psram_{false};
-
-  // Device information sent in the `client/hello` message. Defaults apply when neither the
-  // sendspin configuration nor the project information supplies a value.
-  const char *manufacturer_{"ESPHome"};
-  const char *model_{nullptr};  // nullptr reports the device name instead
-  const char *firmware_version_{ESPHOME_VERSION};
 };
 
 /// @brief Base class for all sendspin subcomponents.

esphome/components/serial_proxy/__init__.py

@@ -30,7 +30,6 @@ MULTI_CONF = True
 
 serial_proxy_ns = cg.esphome_ns.namespace("serial_proxy")
 SerialProxy = serial_proxy_ns.class_("SerialProxy", cg.Component, uart.UARTDevice)
-SerialProxyTap = serial_proxy_ns.class_("SerialProxyTap")
 
 api_enums_ns = cg.esphome_ns.namespace("api").namespace("enums")
 SerialProxyPortType = api_enums_ns.enum("SerialProxyPortType")

esphome/components/serial_proxy/serial_proxy.cpp

@@ -29,57 +29,26 @@ void SerialProxy::setup() {
 #ifdef USE_API
   // instance_index_ is fixed at registration time; pre-set it so loop() only needs to update data
   this->outgoing_msg_.instance = this->instance_index_;
-#endif
-#ifdef USE_SERIAL_PROXY_TAP
-  // A tap sets itself up before this runs (its setup priority is higher), so it may
-  // already be waiting on the port -- a boot-time handshake with the device, say. Leaving
-  // the loop enabled is what lets that finish; without it the tap would stall until a
-  // client happened to subscribe.
-  if (this->tap_ != nullptr && this->tap_->tap_needs_port()) {
-    return;
-  }
 #endif
   // No subscriber at startup; disable loop until a client subscribes
   this->disable_loop();
 }
 
-#ifdef USE_SERIAL_PROXY_TAP
-void SerialProxy::reset_mode_() {
-  // The mode belongs to a session, not to the port. Carrying a departed client's choice
-  // over to the next one would inject protocol bytes into a stream that never asked for
-  // them -- a firmware upload, or any client built before this request existed and so
-  // unable to turn it off. Guessing RAW is the safe direction: a client that wanted
-  // protocol handling and did not ask for it merely sends its own acknowledgements.
-  if (this->mode_ == api::enums::SERIAL_PROXY_MODE_RAW) {
-    return;
-  }
-  ESP_LOGD(TAG, "Session ended, returning serial proxy [%" PRIu32 "] to RAW mode", this->instance_index_);
-  this->mode_ = api::enums::SERIAL_PROXY_MODE_RAW;
-}
-#endif
-
 void SerialProxy::loop() {
 #ifdef USE_API
-  // Detect subscriber disconnect
-  if (this->api_connection_ != nullptr && (this->api_connection_->is_marked_for_removal() ||
-                                           !this->api_connection_->is_connection_setup() || !api_is_connected())) {
-    ESP_LOGW(TAG, "Subscriber disconnected");
-    this->api_connection_ = nullptr;
-    this->reset_mode_();
-  }
-
-  // With no subscriber there is normally nothing to do, but a tap may still need the port
-  // read -- it does its protocol work precisely while nobody else is listening.
+  // Safety check — loop should only run when subscribed, but guard against races
   if (this->api_connection_ == nullptr) [[unlikely]] {
-#ifdef USE_SERIAL_PROXY_TAP
-    if (this->tap_ == nullptr || !this->tap_->tap_needs_port()) {
-      this->disable_loop();
-      return;
-    }
-#else
     this->disable_loop();
     return;
-#endif
+  }
+
+  // Detect subscriber disconnect
+  if (this->api_connection_->is_marked_for_removal() || !this->api_connection_->is_connection_setup() ||
+      !api_is_connected()) {
+    ESP_LOGW(TAG, "Subscriber disconnected");
+    this->api_connection_ = nullptr;
+    this->disable_loop();
+    return;
   }
 
   // Read available data from UART and forward to subscribed client
@@ -100,54 +69,11 @@ void __attribute__((noinline)) SerialProxy::read_and_send_(size_t available) {
   if (!this->read_array(buffer, to_read))
     return;
 
-#ifdef USE_SERIAL_PROXY_TAP
-  // Before forwarding, so a tap that answers the device (an acknowledgement, say) is not
-  // waiting on the network round trip to a subscriber that may not even exist.
-  if (this->tap_observing_()) {
-    this->tap_->on_device_rx(buffer, to_read);
-  }
-#endif
-
-  if (this->api_connection_ == nullptr) {
-    return;
-  }
   this->outgoing_msg_.set_data(buffer, to_read);
   this->api_connection_->send_serial_proxy_data(this->outgoing_msg_);
 }
 #endif
 
-#ifdef USE_SERIAL_PROXY_TAP
-
-bool SerialProxy::tap_observing_() const {
-  if (this->tap_ == nullptr) {
-    return false;
-  }
-  // With no subscriber, a tap doing its own protocol work (the boot-time handshake with
-  // the device, say) is served regardless of mode -- nobody has chosen one yet. Once a
-  // subscriber holds the port, the mode alone decides, so RAW stays inert.
-  if (this->api_connection_ == nullptr && this->tap_->tap_needs_port()) {
-    return true;
-  }
-  // Otherwise the mode decides. RAW must be inert: a client that flips to RAW before
-  // flashing firmware is entitled to a byte pipe with nothing injecting protocol bytes
-  // into it, and "the tap turned out not to recognise the stream" is not good enough.
-  return this->mode_ == api::enums::SERIAL_PROXY_MODE_PROTOCOL;
-}
-
-void SerialProxy::tap_pump() {
-#ifdef USE_API
-  // Nothing would consume the bytes; leave them in the FIFO
-  if (!this->tap_observing_() && this->api_connection_ == nullptr) {
-    return;
-  }
-  const size_t available = this->available();
-  if (available > 0) {
-    this->read_and_send_(available);
-  }
-#endif
-}
-#endif
-
 void SerialProxy::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "Serial Proxy [%" PRIu32 "]:\n"
@@ -166,9 +92,8 @@ void SerialProxy::dump_config() {
 SerialProxyResult SerialProxy::configure(api::APIConnection *api_connection, uint32_t baudrate, bool flow_control,
                                          uint8_t parity, uint8_t stop_bits, uint8_t data_size) {
 #ifdef USE_API
-  if (!this->is_subscriber_(api_connection)) {
-    ESP_LOGW(TAG, "Ignoring configure request from client without port subscription [%" PRIu32 "]",
-             this->instance_index_);
+  if (this->port_claimed_by_other_(api_connection)) {
+    ESP_LOGW(TAG, "Ignoring configure request from client without port access [%" PRIu32 "]", this->instance_index_);
     return SerialProxyResult::SERIAL_PROXY_RESULT_PORT_IN_USE;
   }
 #endif
@@ -234,80 +159,24 @@ SerialProxyResult SerialProxy::configure(api::APIConnection *api_connection, uin
   return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
 }
 
-SerialProxyResult SerialProxy::set_mode_from_client(api::APIConnection *api_connection,
-                                                    api::enums::SerialProxyMode mode) {
-#ifdef USE_API
-  // Only the live subscriber may change the mode, so the mode cannot outlive a session
-  if (!this->is_subscriber_(api_connection)) {
-    ESP_LOGW(TAG, "Ignoring mode request from client without port subscription [%" PRIu32 "]", this->instance_index_);
-    return SerialProxyResult::SERIAL_PROXY_RESULT_PORT_IN_USE;
-  }
-#endif
-  // Values come from a remote client
-  if (mode != api::enums::SERIAL_PROXY_MODE_RAW && mode != api::enums::SERIAL_PROXY_MODE_PROTOCOL) {
-    ESP_LOGW(TAG, "Invalid mode: %" PRIu32, static_cast<uint32_t>(mode));
-    return SerialProxyResult::SERIAL_PROXY_RESULT_INVALID_ARGUMENT;
-  }
-  // PROTOCOL on a port with no tap would be a silent no-op; refuse so the client knows
-#ifdef USE_SERIAL_PROXY_TAP
-  const bool has_tap = this->tap_ != nullptr;
-#else
-  const bool has_tap = false;
-#endif
-  if (mode == api::enums::SERIAL_PROXY_MODE_PROTOCOL && !has_tap) {
-    ESP_LOGW(TAG, "No tap on serial proxy [%" PRIu32 "]; PROTOCOL mode unavailable", this->instance_index_);
-    return SerialProxyResult::SERIAL_PROXY_RESULT_NOT_SUPPORTED;
-  }
-  ESP_LOGD(TAG, "Serial proxy [%" PRIu32 "] mode set to %s", this->instance_index_,
-           mode == api::enums::SERIAL_PROXY_MODE_PROTOCOL ? LOG_STR_LITERAL("PROTOCOL") : LOG_STR_LITERAL("RAW"));
-#ifdef USE_SERIAL_PROXY_TAP
-  const bool leaving_protocol_mode =
-      this->mode_ != api::enums::SERIAL_PROXY_MODE_RAW && mode == api::enums::SERIAL_PROXY_MODE_RAW;
-  this->mode_ = mode;
-
-  // Only for an explicit client request, not for reset_mode_() at the end of a session:
-  // an ordinary disconnect says nothing about the device, whereas a client deliberately
-  // asking for raw bytes usually precedes changing what the device is.
-  if (leaving_protocol_mode && this->tap_ != nullptr) {
-    this->tap_->on_protocol_disabled();
-  }
-#endif
-  return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
-}
-
 void SerialProxy::write_from_client(api::APIConnection *api_connection, const uint8_t *data, size_t len) {
 #ifdef USE_API
-  // Bytes from anyone but the live subscriber would interleave with the subscriber's
-  // traffic -- or with an active tap's -- on the wire
-  if (!this->is_subscriber_(api_connection)) {
-    if (this->api_connection_ != nullptr) {
-      ESP_LOGW(TAG, "Ignoring write from client that does not hold serial proxy [%" PRIu32 "]", this->instance_index_);
-    } else {
-      // A legacy client streaming writes without subscribing would flood WARN, one per
-      // request; writes are the only high-rate, unacknowledged operation, so keep this
-      // visible without drowning the log
-      ESP_LOGV(TAG, "Ignoring write from client without port subscription [%" PRIu32 "]", this->instance_index_);
-    }
+  // Bytes from a client other than the live subscriber would interleave with the
+  // subscriber's traffic on the wire
+  if (this->port_claimed_by_other_(api_connection)) {
+    ESP_LOGW(TAG, "Ignoring write from client without port access [%" PRIu32 "]", this->instance_index_);
     return;
   }
 #endif
   if (data == nullptr || len == 0)
     return;
   this->write_array(data, len);
-
-#ifdef USE_SERIAL_PROXY_TAP
-  // After the write, so the tap observes the same ordering the device does
-  if (this->tap_observing_()) {
-    this->tap_->on_client_tx(data, len);
-  }
-#endif
 }
 
 SerialProxyResult SerialProxy::set_modem_pins(api::APIConnection *api_connection, uint32_t line_states) {
 #ifdef USE_API
-  if (!this->is_subscriber_(api_connection)) {
-    ESP_LOGW(TAG, "Ignoring modem pin request from client without port subscription [%" PRIu32 "]",
-             this->instance_index_);
+  if (this->port_claimed_by_other_(api_connection)) {
+    ESP_LOGW(TAG, "Ignoring modem pin request from client without port access [%" PRIu32 "]", this->instance_index_);
     return SerialProxyResult::SERIAL_PROXY_RESULT_PORT_IN_USE;
   }
 #endif
@@ -341,8 +210,8 @@ uint32_t SerialProxy::get_modem_pins() const {
 SerialProxyResult SerialProxy::flush_port(api::APIConnection *api_connection) {
 #ifdef USE_API
   // Flushing stalls the port, so it gets the same ownership check as writes
-  if (!this->is_subscriber_(api_connection)) {
-    ESP_LOGW(TAG, "Ignoring flush from client without port subscription [%" PRIu32 "]", this->instance_index_);
+  if (this->port_claimed_by_other_(api_connection)) {
+    ESP_LOGW(TAG, "Ignoring flush from client without port access [%" PRIu32 "]", this->instance_index_);
     return SerialProxyResult::SERIAL_PROXY_RESULT_PORT_IN_USE;
   }
 #endif
@@ -361,6 +230,11 @@ SerialProxyResult SerialProxy::flush_port(api::APIConnection *api_connection) {
 }
 
 #ifdef USE_API
+bool SerialProxy::port_claimed_by_other_(api::APIConnection *api_connection) const {
+  return this->api_connection_ != nullptr && this->api_connection_ != api_connection &&
+         this->api_connection_->is_connection_setup();
+}
+
 SerialProxyResult SerialProxy::serial_proxy_request(api::APIConnection *api_connection,
                                                     api::enums::SerialProxyRequestType type) {
   switch (type) {
@@ -378,10 +252,6 @@ SerialProxyResult SerialProxy::serial_proxy_request(api::APIConnection *api_conn
           return SerialProxyResult::SERIAL_PROXY_RESULT_PORT_IN_USE;
         }
         ESP_LOGW(TAG, "Previous subscriber disconnected; taking over subscription");
-        // End the dead client's session before starting the new one, so its mode
-        // cannot leak into a session that never asked for it
-        this->api_connection_ = nullptr;
-        this->reset_mode_();
       }
       this->api_connection_ = api_connection;
       this->enable_loop();
@@ -394,15 +264,7 @@ SerialProxyResult SerialProxy::serial_proxy_request(api::APIConnection *api_conn
         return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
       }
       this->api_connection_ = nullptr;
-      this->reset_mode_();
-#ifdef USE_SERIAL_PROXY_TAP
-      // Keep the loop alive for a tap that still needs the port (mirrors loop())
-      if (this->tap_ == nullptr || !this->tap_->tap_needs_port()) {
-        this->disable_loop();
-      }
-#else
       this->disable_loop();
-#endif
       ESP_LOGV(TAG, "API connection unsubscribed from serial proxy [%" PRIu32 "]", this->instance_index_);
       return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
     default:

esphome/components/serial_proxy/serial_proxy.h

@@ -26,7 +26,6 @@ class APIConnection;
 namespace enums {
 enum SerialProxyPortType : uint32_t;
 enum SerialProxyRequestType : uint32_t;
-enum SerialProxyMode : uint32_t;
 }  // namespace enums
 }  // namespace esphome::api
 
@@ -53,36 +52,6 @@ enum class SerialProxyResult : uint8_t {
 /// Maximum bytes to read from UART in a single loop iteration
 inline constexpr size_t SERIAL_PROXY_MAX_READ_SIZE = 256;
 
-#ifdef USE_SERIAL_PROXY_TAP
-/// Observes a port's traffic without owning it, and may inject bytes of its own.
-///
-/// This exists so protocol-aware behaviour can be layered onto a plain byte pipe without
-/// the pipe knowing anything about the protocol: the tap is compiled in only when some
-/// component asks for one, so a proxy carrying an RS485 meter pays nothing for it.
-///
-/// A tap is an observer, never a gatekeeper -- it cannot suppress or alter the bytes
-/// flowing in either direction, so a misbehaving tap cannot corrupt the stream.
-class SerialProxyTap {
- public:
-  /// Bytes read from the device, before they are forwarded to any subscriber.
-  virtual void on_device_rx(const uint8_t *data, size_t len) = 0;
-
-  /// Bytes a subscriber sent towards the device, after they have been written.
-  virtual void on_client_tx(const uint8_t *data, size_t len) = 0;
-
-  /// True when the port must keep reading even with no subscriber attached, so a tap can
-  /// do its own protocol work while nobody is listening. Honoured only while no
-  /// subscriber holds the port; with one attached, the port mode alone decides.
-  virtual bool tap_needs_port() const = 0;
-
-  /// A client explicitly turned protocol handling off for this port. Distinct from the
-  /// automatic reset when a session ends: this one means a client intends to do something
-  /// else with the device -- reflash it, most likely -- so anything the tap believes about
-  /// it should be treated as suspect.
-  virtual void on_protocol_disabled() = 0;
-};
-#endif
-
 class SerialProxy final : public uart::UARTDevice, public Component {
  public:
   void setup() override;
@@ -108,9 +77,6 @@ class SerialProxy final : public uart::UARTDevice, public Component {
   /// Get the port type
   api::enums::SerialProxyPortType get_port_type() const { return this->port_type_; }
 
-  /// Handle a mode change requested by an API client
-  SerialProxyResult set_mode_from_client(api::APIConnection *api_connection, api::enums::SerialProxyMode mode);
-
   /// Configure UART parameters and apply them
   /// @param api_connection The API connection requesting the change
   /// @param baudrate Baud rate in bits per second
@@ -155,67 +121,13 @@ class SerialProxy final : public uart::UARTDevice, public Component {
   /// Set the DTR GPIO pin (from YAML configuration)
   void set_dtr_pin(GPIOPin *pin) { this->dtr_pin_ = pin; }
 
-#ifdef USE_SERIAL_PROXY_TAP
-  /// Attach a traffic observer. At most one, set once at setup time.
-  void set_tap(SerialProxyTap *tap) { this->tap_ = tap; }
-
-  /// Write bytes originating from the tap rather than from a client. Bypasses the
-  /// subscriber ownership check, but only while the tap is being served bytes -- so a
-  /// port in RAW mode with a subscriber attached stays inert. Returns false when the
-  /// bytes were dropped for that reason.
-  bool write_from_tap(const uint8_t *data, size_t len) {
-    if (!this->tap_observing_()) {
-      return false;
-    }
-    this->write_array(data, len);
-    return true;
-  }
-
-  /// Whether the tap is currently being served bytes. Can flip false with no callback
-  /// (a subscriber attaching in RAW mode, say), so a tap should check before starting
-  /// protocol work and when a reply seems overdue.
-  bool tap_is_observed() const { return this->tap_observing_(); }
-
-  /// Resume reading after a tap's needs change. loop() disables itself when there is
-  /// neither a subscriber nor a tap that wants the port, so a tap starting fresh work
-  /// must ask for it back. Must be called from the main loop.
-  void tap_request_port() { this->enable_loop(); }
-
-  /// Whether the underlying device is present. On a USB UART this tracks enumeration, so
-  /// a tap can notice the device being unplugged and plugged back in.
-  bool is_device_connected() const { return this->parent_->is_connected(); }
-
-  /// Run one read-and-dispatch cycle immediately. Lets a tap make progress before the
-  /// main loop is running -- during setup, for instance, while a component is still
-  /// blocking on can_proceed(). Must not be called from on_device_rx() or
-  /// on_client_tx(): each nested cycle costs a 256-byte stack frame.
-  void tap_pump();
-#endif
-
  protected:
 #ifdef USE_API
-  /// Read from UART, hand the bytes to any tap, and forward them to a subscriber
-  /// (slow path with a 256-byte stack buffer)
+  /// Read from UART and send to API client (slow path with 256-byte stack buffer)
   void read_and_send_(size_t available);
 
-  /// True when the given connection is the live subscriber. Every port operation
-  /// (write, configure, modem pins, flush, mode) requires this, so an unsubscribed
-  /// client can never share the wire with the subscriber or an active tap.
-  bool is_subscriber_(api::APIConnection *api_connection) const { return this->api_connection_ == api_connection; }
-#endif
-
-#ifdef USE_SERIAL_PROXY_TAP
-  /// Return the port to RAW when a subscriber goes away, so the mode never outlives it
-  void reset_mode_();
-#else
-  /// Without a tap, PROTOCOL is refused, so the mode is fixed at RAW and there is
-  /// nothing to reset
-  void reset_mode_() {}
-#endif
-
-#ifdef USE_SERIAL_PROXY_TAP
-  /// True when the tap should be shown the traffic passing through this port
-  bool tap_observing_() const;
+  /// True when a live subscriber other than the given connection holds the port
+  bool port_claimed_by_other_(api::APIConnection *api_connection) const;
 #endif
 
   /// Instance index for identifying this proxy in API messages
@@ -235,11 +147,6 @@ class SerialProxy final : public uart::UARTDevice, public Component {
   /// Port type
   api::enums::SerialProxyPortType port_type_{};
 
-#ifdef USE_SERIAL_PROXY_TAP
-  /// How the bytes passing through are treated; zero is SERIAL_PROXY_MODE_RAW
-  api::enums::SerialProxyMode mode_{};
-#endif
-
   /// Optional GPIO pins for modem control
   GPIOPin *rts_pin_{nullptr};
   GPIOPin *dtr_pin_{nullptr};
@@ -247,10 +154,6 @@ class SerialProxy final : public uart::UARTDevice, public Component {
   /// Current modem pin states
   bool rts_state_{false};
   bool dtr_state_{false};
-
-#ifdef USE_SERIAL_PROXY_TAP
-  SerialProxyTap *tap_{nullptr};
-#endif
 };
 
 }  // namespace esphome::serial_proxy

esphome/components/speaker/media_player/audio_pipeline.cpp

@@ -202,15 +202,8 @@ AudioPipelineState AudioPipeline::process_state() {
     if (!this->is_playing_) {
       // The tasks have been stopped for two ``process_state`` calls in a row, so delete the tasks
       if (this->read_task_.is_created() || this->decode_task_.is_created()) {
-        // Both are attempted every time; a task that is still running on the other core is freed by a
-        // subsequent call, and freeing an already freed task succeeds without doing anything
-        bool read_task_freed = this->read_task_.deallocate();
-        bool decode_task_freed = this->decode_task_.deallocate();
-        if (!read_task_freed || !decode_task_freed) {
-          // A task is still running on the other core, so keep the pipeline in its current state and try
-          // again on the next call
-          return AudioPipelineState::PLAYING;
-        }
+        this->read_task_.deallocate();
+        this->decode_task_.deallocate();
         if (this->hard_stop_) {
           // Stop command was sent, so immediately end the playback
           this->speaker_->stop();
@@ -322,17 +315,17 @@ void AudioPipeline::read_task(void *params) {
       if (err == ESP_OK) {
         size_t file_ring_buffer_size = this_pipeline->buffer_size_;
 
-        std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this_pipeline->raw_file_ring_buffer_.lock();
+        std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer;
 
-        if (temp_ring_buffer == nullptr) {
+        if (!this_pipeline->raw_file_ring_buffer_.use_count()) {
           temp_ring_buffer = ring_buffer::RingBuffer::create(file_ring_buffer_size);
           this_pipeline->raw_file_ring_buffer_ = temp_ring_buffer;
         }
 
-        if (temp_ring_buffer == nullptr) {
+        if (!this_pipeline->raw_file_ring_buffer_.use_count()) {
           err = ESP_ERR_NO_MEM;
         } else {
-          err = reader->add_sink(temp_ring_buffer);
+          reader->add_sink(this_pipeline->raw_file_ring_buffer_);
         }
       }
 
@@ -403,9 +396,7 @@ void AudioPipeline::decode_task(void *params) {
           make_unique<audio::AudioDecoder>(this_pipeline->transfer_buffer_size_, this_pipeline->transfer_buffer_size_);
 
       esp_err_t err = decoder->start(this_pipeline->current_audio_file_type_);
-      if (err == ESP_OK) {
-        err = decoder->add_source(this_pipeline->raw_file_ring_buffer_);
-      }
+      decoder->add_source(this_pipeline->raw_file_ring_buffer_);
 
       if (err != ESP_OK) {
         // Send specific error message

esphome/components/template/binary_sensor/__init__.py

@@ -2,13 +2,7 @@ from esphome import automation
 import esphome.codegen as cg
 from esphome.components import binary_sensor
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_CONDITION,
-    CONF_DEVICE_CLASS,
-    CONF_ID,
-    CONF_LAMBDA,
-    CONF_STATE,
-)
+from esphome.const import CONF_CONDITION, CONF_ID, CONF_LAMBDA, CONF_STATE
 from esphome.cpp_generator import LambdaExpression
 
 from .. import template_ns
@@ -18,11 +12,7 @@ TemplateBinarySensor = template_ns.class_(
 )
 
 CONFIG_SCHEMA = (
-    cv.with_visibility(
-        binary_sensor.binary_sensor_schema(TemplateBinarySensor),
-        cv.Visibility.UI,
-        CONF_DEVICE_CLASS,
-    )
+    binary_sensor.binary_sensor_schema(TemplateBinarySensor)
     .extend(
         {
             cv.Exclusive(CONF_LAMBDA, CONF_CONDITION): cv.returning_lambda,

esphome/components/template/button/__init__.py

@@ -1,14 +1,10 @@
 from esphome.components import button
-import esphome.config_validation as cv
-from esphome.const import CONF_DEVICE_CLASS
 
 from .. import template_ns
 
 TemplateButton = template_ns.class_("TemplateButton", button.Button)
 
-CONFIG_SCHEMA = cv.with_visibility(
-    button.button_schema(TemplateButton), cv.Visibility.UI, CONF_DEVICE_CLASS
-)
+CONFIG_SCHEMA = button.button_schema(TemplateButton)
 
 
 async def to_code(config):

esphome/components/template/cover/__init__.py

@@ -6,7 +6,6 @@ from esphome.const import (
     CONF_ASSUMED_STATE,
     CONF_CLOSE_ACTION,
     CONF_CURRENT_OPERATION,
-    CONF_DEVICE_CLASS,
     CONF_ID,
     CONF_LAMBDA,
     CONF_OPEN_ACTION,
@@ -39,11 +38,7 @@ CONF_HAS_POSITION = "has_position"
 CONF_TOGGLE_ACTION = "toggle_action"
 
 CONFIG_SCHEMA = (
-    cv.with_visibility(
-        cover.cover_schema(TemplateCover),
-        cv.Visibility.UI,
-        CONF_DEVICE_CLASS,
-    )
+    cover.cover_schema(TemplateCover)
     .extend(
         {
             cv.Optional(CONF_LAMBDA): cv.returning_lambda,

esphome/components/template/event/__init__.py

@@ -1,7 +1,7 @@
 import esphome.codegen as cg
 from esphome.components import event
 import esphome.config_validation as cv
-from esphome.const import CONF_DEVICE_CLASS, CONF_EVENT_TYPES
+from esphome.const import CONF_EVENT_TYPES
 
 from .. import template_ns
 
@@ -9,9 +9,7 @@ CODEOWNERS = ["@nohat"]
 
 TemplateEvent = template_ns.class_("TemplateEvent", event.Event, cg.Component)
 
-CONFIG_SCHEMA = cv.with_visibility(
-    event.event_schema(TemplateEvent), cv.Visibility.UI, CONF_DEVICE_CLASS
-).extend(
+CONFIG_SCHEMA = event.event_schema(TemplateEvent).extend(
     {
         cv.Required(CONF_EVENT_TYPES): cv.ensure_list(cv.string_strict),
     }

esphome/components/template/number/__init__.py

@@ -3,7 +3,6 @@ import esphome.codegen as cg
 from esphome.components import number
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_DEVICE_CLASS,
     CONF_ID,
     CONF_INITIAL_VALUE,
     CONF_LAMBDA,
@@ -13,7 +12,6 @@ from esphome.const import (
     CONF_RESTORE_VALUE,
     CONF_SET_ACTION,
     CONF_STEP,
-    CONF_UNIT_OF_MEASUREMENT,
 )
 
 from .. import template_ns
@@ -48,12 +46,7 @@ def validate(config):
 
 
 CONFIG_SCHEMA = cv.All(
-    cv.with_visibility(
-        number.number_schema(TemplateNumber),
-        cv.Visibility.UI,
-        CONF_DEVICE_CLASS,
-        CONF_UNIT_OF_MEASUREMENT,
-    )
+    number.number_schema(TemplateNumber)
     .extend(
         {
             cv.Required(CONF_MAX_VALUE): cv.float_,

esphome/components/template/sensor/__init__.py

@@ -2,16 +2,7 @@ from esphome import automation
 import esphome.codegen as cg
 from esphome.components import sensor
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ACCURACY_DECIMALS,
-    CONF_DEVICE_CLASS,
-    CONF_FORCE_UPDATE,
-    CONF_ID,
-    CONF_LAMBDA,
-    CONF_STATE,
-    CONF_STATE_CLASS,
-    CONF_UNIT_OF_MEASUREMENT,
-)
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_STATE
 
 from .. import template_ns
 
@@ -20,14 +11,9 @@ TemplateSensor = template_ns.class_(
 )
 
 CONFIG_SCHEMA = (
-    cv.with_visibility(
-        sensor.sensor_schema(TemplateSensor, accuracy_decimals=1),
-        cv.Visibility.UI,
-        CONF_UNIT_OF_MEASUREMENT,
-        CONF_ACCURACY_DECIMALS,
-        CONF_DEVICE_CLASS,
-        CONF_STATE_CLASS,
-        CONF_FORCE_UPDATE,
+    sensor.sensor_schema(
+        TemplateSensor,
+        accuracy_decimals=1,
     )
     .extend(
         {

esphome/components/template/switch/__init__.py

@@ -4,7 +4,6 @@ from esphome.components import switch
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ASSUMED_STATE,
-    CONF_DEVICE_CLASS,
     CONF_ID,
     CONF_LAMBDA,
     CONF_OPTIMISTIC,
@@ -32,11 +31,7 @@ def validate(config):
 
 
 CONFIG_SCHEMA = cv.All(
-    cv.with_visibility(
-        switch.switch_schema(TemplateSwitch),
-        cv.Visibility.UI,
-        CONF_DEVICE_CLASS,
-    )
+    switch.switch_schema(TemplateSwitch)
     .extend(
         {
             cv.Optional(CONF_LAMBDA): cv.returning_lambda,

esphome/components/template/text_sensor/__init__.py

@@ -3,7 +3,7 @@ import esphome.codegen as cg
 from esphome.components import text_sensor
 from esphome.components.text_sensor import TextSensorPublishAction
 import esphome.config_validation as cv
-from esphome.const import CONF_DEVICE_CLASS, CONF_ID, CONF_LAMBDA, CONF_STATE
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_STATE
 
 from .. import template_ns
 
@@ -12,11 +12,7 @@ TemplateTextSensor = template_ns.class_(
 )
 
 CONFIG_SCHEMA = (
-    cv.with_visibility(
-        text_sensor.text_sensor_schema(),
-        cv.Visibility.UI,
-        CONF_DEVICE_CLASS,
-    )
+    text_sensor.text_sensor_schema()
     .extend(
         {
             cv.GenerateID(): cv.declare_id(TemplateTextSensor),

esphome/components/template/valve/__init__.py

@@ -6,7 +6,6 @@ from esphome.const import (
     CONF_ASSUMED_STATE,
     CONF_CLOSE_ACTION,
     CONF_CURRENT_OPERATION,
-    CONF_DEVICE_CLASS,
     CONF_ID,
     CONF_LAMBDA,
     CONF_OPEN_ACTION,
@@ -37,11 +36,7 @@ CONF_HAS_POSITION = "has_position"
 CONF_TOGGLE_ACTION = "toggle_action"
 
 CONFIG_SCHEMA = (
-    cv.with_visibility(
-        valve.valve_schema(TemplateValve),
-        cv.Visibility.UI,
-        CONF_DEVICE_CLASS,
-    )
+    valve.valve_schema(TemplateValve)
     .extend(
         {
             cv.Optional(CONF_LAMBDA): cv.returning_lambda,

esphome/components/tuya/tuya.cpp

@@ -1,13 +1,10 @@
 #include "tuya.h"
+#include "esphome/components/network/util.h"
 #include "esphome/core/gpio.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
 
-#ifdef USE_NETWORK
-#include "esphome/components/network/util.h"
-#endif
-
 #ifdef USE_WIFI
 #include "esphome/components/wifi/wifi_component.h"
 #endif
@@ -25,14 +22,6 @@ static const int MAX_RETRIES = 5;
 // Max bytes to log for datapoint values (larger values are truncated)
 static constexpr size_t MAX_DATAPOINT_LOG_BYTES = 16;
 
-static bool network_is_connected() {
-#ifdef USE_NETWORK
-  return network::is_connected();
-#else
-  return false;
-#endif
-}
-
 void Tuya::setup() {
   this->set_interval("heartbeat", 15000, [this] { this->send_empty_command_(TuyaCommandType::HEARTBEAT); });
   if (this->status_pin_ != nullptr) {
@@ -565,14 +554,14 @@ void Tuya::send_empty_command_(TuyaCommandType command) {
 }
 
 void Tuya::set_status_pin_() {
-  bool is_network_ready = network_is_connected() && remote_is_connected();
+  bool is_network_ready = network::is_connected() && remote_is_connected();
   this->status_pin_->digital_write(is_network_ready);
 }
 
 uint8_t Tuya::get_wifi_status_code_() {
   uint8_t status = 0x02;
 
-  if (network_is_connected()) {
+  if (network::is_connected()) {
     status = 0x03;
 
     // Protocol version 3 also supports specifying when connected to "the cloud"

esphome/components/udp/__init__.py

@@ -1,4 +1,5 @@
-from typing import Any
+from collections.abc import Callable
+from typing import Any, NoReturn
 
 from esphome import automation
 from esphome.automation import Trigger
@@ -47,10 +48,17 @@ UDP_SCHEMA = cv.Schema(
 )
 
 
+def is_relocated(option: str) -> Callable[[Any], NoReturn]:
+    def validator(value: Any) -> NoReturn:
+        raise cv.Invalid(
+            f"The '{option}' option should now be configured in the 'packet_transport' component"
+        )
+
+    return validator
+
+
 RELOCATED = {
-    cv.Optional(x): cv.invalid(
-        f"The '{x}' option should now be configured in the 'packet_transport' component"
-    )
+    cv.Optional(x): is_relocated(x)
     for x in (
         CONF_PROVIDERS,
         CONF_ENCRYPTION,

esphome/components/zigbee/time/zigbee_time_zephyr.cpp

@@ -1,7 +1,6 @@
 #include "zigbee_time_zephyr.h"
 #if defined(USE_ZIGBEE) && defined(USE_NRF52) && defined(USE_TIME)
 #include "esphome/core/log.h"
-#include "esphome/core/application.h"
 
 namespace esphome::zigbee {
 
@@ -48,7 +47,6 @@ void ZigbeeTime::set_epoch_time(uint32_t epoch) {
     this->synchronize_epoch_(epoch);
     this->has_time_ = true;
   });
-  App.wake_loop_threadsafe();
 }
 
 void ZigbeeTime::zcl_device_cb_(zb_bufid_t bufid) {

esphome/components/zigbee/zigbee_esp32.cpp

@@ -49,8 +49,7 @@ void ZigbeeComponent::factory_reset() {
 
 void ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(ezb_bdb_comm_mode_mask_t mode) {
   if (!esp_zigbee_lock_acquire(10 / portTICK_PERIOD_MS)) {
-    global_zigbee->set_timeout("zb_init", 100, [mode]() { ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(mode); });
-    App.wake_loop_threadsafe();
+    global_zigbee->set_timeout("zb_init", 10, [mode]() { ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(mode); });
     return;
   }
   if (ezb_bdb_start_top_level_commissioning(mode) != EZB_ERR_NONE) {
@@ -89,7 +88,6 @@ bool ZigbeeComponent::app_signal_handler(const ezb_app_signal_t *app_signal) {
         global_zigbee->set_timeout("zb_init", 1000, []() {
           ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(EZB_BDB_MODE_INITIALIZATION);
         });
-        App.wake_loop_threadsafe();
       }
     } break;
     case EZB_BDB_SIGNAL_STEERING: {
@@ -115,7 +113,6 @@ bool ZigbeeComponent::app_signal_handler(const ezb_app_signal_t *app_signal) {
             ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(EZB_BDB_MODE_NETWORK_STEERING);
           });
         }
-        App.wake_loop_threadsafe();
       }
     } break;
     case EZB_ZDO_SIGNAL_LEAVE: {

esphome/components/zigbee/zigbee_zephyr.cpp

@@ -1,10 +1,10 @@
 #include "zigbee_zephyr.h"
 #if defined(USE_ZIGBEE) && defined(USE_NRF52)
 #include "esphome/core/log.h"
-#include "esphome/core/application.h"
 #include <zephyr/settings/settings.h>
 #include <zephyr/storage/flash_map.h>
 #include "esphome/core/hal.h"
+#include "esphome/core/wake.h"
 
 extern "C" {
 #include <zboss_api.h>
@@ -120,7 +120,7 @@ void ZigbeeComponent::zcl_device_cb(zb_bufid_t bufid) {
   /* Set default response value. */
   p_device_cb_param->status = RET_OK;
 
-  App.wake_loop_threadsafe();
+  esphome::wake_loop_threadsafe();
 
   // endpoints are enumerated from 1
   if (global_zigbee->callbacks_.size() >= endpoint) {
@@ -138,7 +138,6 @@ void ZigbeeComponent::on_join_(bool factory_new) {
     ESP_LOGD(TAG, "Joined the network");
     this->join_cb_.call(factory_new);
   });
-  App.wake_loop_threadsafe();
 }
 
 void ZigbeeComponent::on_start_() {
@@ -146,7 +145,6 @@ void ZigbeeComponent::on_start_() {
     ESP_LOGD(TAG, "Started zigbee stack");
     this->start_cb_.call();
   });
-  App.wake_loop_threadsafe();
 }
 
 #ifdef USE_ZIGBEE_WIPE_ON_BOOT

esphome/config_validation.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from contextlib import contextmanager, suppress
-import copy
 from datetime import datetime
 from ipaddress import (
     AddressValueError,
@@ -420,37 +419,6 @@ class Required(vol.Required):
         self.visibility: Visibility | None = visibility
 
 
-def with_visibility(schema: Schema, visibility: Visibility, *keys: str) -> Schema:
-    """Return a copy of ``schema`` with the given ``keys`` re-marked at ``visibility``.
-
-    Lets a platform override the editor :class:`Visibility` of fields it
-    inherits from a shared schema builder — without that builder needing a
-    visibility parameter of its own. The canonical use is a ``template``
-    platform promoting the value metadata its user is expected to define
-    (``device_class``, ``unit_of_measurement``, …) onto the main form:
-
-        CONFIG_SCHEMA = cv.with_visibility(
-            sensor.sensor_schema(TemplateSensor),
-            cv.Visibility.UI,
-            CONF_DEVICE_CLASS, CONF_UNIT_OF_MEASUREMENT,
-        )
-
-    The original marker's key, default and validator are preserved; only the
-    visibility changes, and the input ``schema`` is left untouched. Raises if
-    a requested key is not present so typos fail at schema-build time.
-    """
-    wanted = {str(k) for k in keys}
-    overrides = {}
-    for marker, validator in schema.schema.items():
-        if str(marker) in wanted:
-            marker = copy.copy(marker)
-            marker.visibility = visibility
-            overrides[marker] = validator
-    if missing := wanted - {str(m) for m in overrides}:
-        raise ValueError(f"with_visibility: keys not in schema: {sorted(missing)}")
-    return schema.extend(overrides)
-
-
 class FinalExternalInvalid(Invalid):
     """Represents an invalid value in the final validation phase where the path should not be prepended."""
 

esphome/core/defines.h

@@ -181,7 +181,6 @@
 #define USE_SENSOR
 #define USE_SENSOR_FILTER
 #define USE_SERIAL_PROXY
-#define USE_SERIAL_PROXY_TAP
 #define USE_SETUP_PRIORITY_OVERRIDE
 #define USE_STATUS_LED
 #define USE_STATUS_SENSOR

esphome/core/static_task.cpp

@@ -40,31 +40,16 @@ bool StaticTask::create(TaskFunction_t fn, const char *name, uint32_t stack_size
   return true;
 }
 
-bool StaticTask::destroy() {
-  if (this->handle_ == nullptr) {
-    return true;
+void StaticTask::destroy() {
+  if (this->handle_ != nullptr) {
+    TaskHandle_t handle = this->handle_;
+    this->handle_ = nullptr;
+    vTaskDelete(handle);
   }
-
-  // Suspending takes the task off the ready and event lists, so nothing can schedule it again. It only asks
-  // the other core to yield though, so the task may still be running on it for a moment.
-  vTaskSuspend(this->handle_);
-  if (eTaskGetState(this->handle_) != eSuspended) {
-    // The task is still running on the other core and using its stack. Deleting it now would only put it on
-    // the termination list and return, so the caller has to try again once it has been swapped out.
-    return false;
-  }
-
-  // The task cannot run again, so the delete completes right away instead of being left to the idle task.
-  TaskHandle_t handle = this->handle_;
-  this->handle_ = nullptr;
-  vTaskDelete(handle);
-  return true;
 }
 
-bool StaticTask::deallocate() {
-  if (!this->destroy()) {
-    return false;
-  }
+void StaticTask::deallocate() {
+  this->destroy();
   if (this->stack_buffer_ != nullptr) {
     RAMAllocator<StackType_t> allocator(this->use_psram_ ? RAMAllocator<StackType_t>::ALLOC_EXTERNAL
                                                          : RAMAllocator<StackType_t>::ALLOC_INTERNAL);
@@ -72,7 +57,6 @@ bool StaticTask::deallocate() {
     this->stack_buffer_ = nullptr;
     this->stack_size_ = 0;
   }
-  return true;
 }
 
 }  // namespace esphome

esphome/core/static_task.h

@@ -11,7 +11,6 @@ namespace esphome {
 
 /** Helper for FreeRTOS static task management.
  * Bundles TaskHandle_t, StaticTask_t, and the stack buffer into one object with create/destroy methods.
- * Call destroy() and deallocate() from another task: a task cannot free the stack it is still running on.
  */
 class StaticTask {
  public:
@@ -24,7 +23,7 @@ class StaticTask {
   /// @brief Allocate stack and create task.
   /// @param fn         Task function
   /// @param name       Task name (for debug)
-  /// @param stack_size Stack size in bytes (StackType_t is a byte on ESP-IDF)
+  /// @param stack_size Stack size in StackType_t words
   /// @param param      Parameter passed to task function
   /// @param priority   FreeRTOS task priority
   /// @param use_psram  If true, allocate stack in PSRAM; otherwise internal RAM
@@ -32,17 +31,11 @@ class StaticTask {
   bool create(TaskFunction_t fn, const char *name, uint32_t stack_size, void *param, UBaseType_t priority,
               bool use_psram);
 
-  /// @brief Delete the task, keeping the stack buffer allocated for reuse by a subsequent create() call.
-  /// The task must have finished its work and parked itself, either suspended or blocked indefinitely: it is
-  /// suspended here so that it cannot be scheduled again, and it is given no chance to clean up.
-  /// @return true if the task was deleted; false if it is still running on another core, in which case the
-  /// caller should try again later.
-  bool destroy();
+  /// @brief Delete the task but keep the stack buffer allocated for reuse by a subsequent create() call.
+  void destroy();
 
-  /// @brief Delete the task (if created) and free the stack buffer.
-  /// @return true if the stack buffer was freed; false if the task is still running on another core, in
-  /// which case the caller should try again later.
-  bool deallocate();
+  /// @brief Delete the task (if running) and free the stack buffer.
+  void deallocate();
 
  protected:
   TaskHandle_t handle_{nullptr};

esphome/core/string_ref.h

@@ -22,6 +22,10 @@ namespace esphome {
  * pointer.  When it is default constructed, it has empty string.  You can freely copy or move around this struct, but
  * never free its pointer.  str() function can be used to export the content as std::string. StringRef is adopted from
  * <https://github.com/nghttp2/nghttp2/blob/29cbf8b83ff78faf405d1086b16adc09a8772eca/src/template.h#L376>
+ *
+ * A StringRef may carry a null pointer while its length is zero (the generated api messages start their encode only
+ * string fields that way). Every member treats that as the empty string; only c_str() hands the null pointer on, so
+ * callers that print or copy through c_str() must check empty() first.
  */
 class StringRef {
  public:
@@ -78,7 +82,7 @@ class StringRef {
 
   /// True if the view begins with the given prefix (std::string::starts_with-like)
   bool starts_with(const StringRef &prefix) const {
-    return len_ >= prefix.len_ && std::memcmp(base_, prefix.base_, prefix.len_) == 0;
+    return len_ >= prefix.len_ && (prefix.len_ == 0 || std::memcmp(base_, prefix.base_, prefix.len_) == 0);
   }
   bool starts_with(const char *prefix) const { return this->starts_with(StringRef(prefix)); }
   bool starts_with(const std::string &prefix) const { return this->starts_with(StringRef(prefix)); }
@@ -92,14 +96,15 @@ class StringRef {
     return actual;
   }
 
-  std::string str() const { return std::string(base_, len_); }
+  std::string str() const { return std::string(base_, len_); }  // fine for {nullptr, 0}: nothing is read
   const uint8_t *byte() const { return reinterpret_cast<const uint8_t *>(base_); }
 
   operator std::string() const { return str(); }
 
   /// Compare (compatible with std::string::compare)
   int compare(const StringRef &other) const {
-    int result = std::memcmp(base_, other.base_, std::min(len_, other.len_));
+    size_type common = std::min(len_, other.len_);
+    int result = common == 0 ? 0 : std::memcmp(base_, other.base_, common);
     if (result != 0)
       return result;
     if (len_ < other.len_)
@@ -258,7 +263,14 @@ inline double stod(const StringRef &str, size_t *pos = nullptr) {
 
 #ifdef USE_JSON
 // NOLINTNEXTLINE(readability-identifier-naming)
-inline void convertToJson(const StringRef &src, JsonVariant dst) { dst.set(src.c_str()); }
+inline void convertToJson(const StringRef &src, JsonVariant dst) {
+  // Bounded by the view length; a null, empty view becomes "" rather than JSON null
+  if (src.empty()) {
+    dst.set("");
+    return;
+  }
+  dst.set(JsonString(src.c_str(), src.size()));
+}
 #endif  // USE_JSON
 
 }  // namespace esphome

esphome/espota2.py

@@ -96,10 +96,6 @@ UPLOAD_BUFFER_SIZE = UPLOAD_BLOCK_SIZE * 8
 # across the addresses on top of that.
 EXTRA_UPLOAD_ATTEMPTS = 2
 UPLOAD_RETRY_DELAY = 5.0
-# Data phase timeout; must stay longer than the device's OTA_SOCKET_TIMEOUT_DATA
-# (105 s) so a stalled session is gone before a retry, and long enough for lwIP
-# to get a lost chunk ack through after the retransmit run seen in practice
-DATA_PHASE_TIMEOUT = 160.0
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -698,7 +694,8 @@ def perform_ota(
 
     _LOGGER.info("Handshake complete")
 
-    sock.settimeout(DATA_PHASE_TIMEOUT)
+    # Timeout must match device-side OTA_SOCKET_TIMEOUT_DATA to prevent premature failures
+    sock.settimeout(90.0)
 
     if extended_proto:
         send_check(sock, ota_type, "ota type")
@@ -857,7 +854,7 @@ def run_ota_impl_(
     # clean up a half-open connection (its handshake watchdog runs at 20s);
     # moving on to the next address family stays immediate. Known limitation:
     # a silent mid-transfer drop with no reset can wedge the device until its
-    # 105s data timeout, which outlasts this budget; the retries target the
+    # 90s data timeout, which outlasts this budget; the retries target the
     # common failures where the device resets or closes the link promptly.
     total_attempts = len(res) + EXTRA_UPLOAD_ATTEMPTS
     last_error = ""

esphome/happy_eyeballs.py

@@ -69,7 +69,10 @@ def _make_create_connection() -> Callable[..., socket.socket]:
 
     from aiohappyeyeballs import start_connection
     from urllib3.exceptions import LocationParseError
-    from urllib3.util.connection import _set_socket_options, allowed_gai_family  # noqa: PLC2701
+    from urllib3.util.connection import (  # noqa: PLC2701
+        _set_socket_options,
+        allowed_gai_family,
+    )
     from urllib3.util.timeout import _DEFAULT_TIMEOUT  # noqa: PLC2701
 
     from esphome import async_thread

esphome/platformio/library.py

@@ -616,15 +616,11 @@ def _make_registry_client() -> Any:
     elsewhere, not by the PlatformIO registry.
     """
     from platformio.package.manager._registry import PackageManagerRegistryMixin
-    from platformio.registry.client import RegistryClient
 
     class _Registry(PackageManagerRegistryMixin):
         def __init__(self) -> None:
+            self._registry_client = None
             self.pkg_type = "library"
-            self._registry_client = RegistryClient()
-            # The probe sleeps ~500 ms per lookup (see runner.patch_registry_private_packages);
-            # instance-level so the ESPHome process never patches PlatformIO's class
-            self._registry_client.allowed_private_packages = lambda: False
 
         @staticmethod
         def is_system_compatible(value: Any, custom_system: Any = None) -> bool:

esphome/platformio/prefetch.py

@@ -951,10 +951,8 @@ def main(argv: list[str]) -> int:
     """Subprocess entry point: ``prefetch <build_dir> <env_name>``."""
     from esphome.core import CORE
     from esphome.log import setup_log
-    from esphome.platformio.runner import patch_registry_private_packages
 
     signal.signal(signal.SIGTERM, _sigterm)
-    patch_registry_private_packages()
     raw_level = os.environ.get("ESPHOME_PREFETCH_LOG_LEVEL")
     try:
         level = int(raw_level) if raw_level is not None else logging.INFO

esphome/platformio/runner.py

@@ -2,8 +2,7 @@
 
 Invoked via ``python -m esphome.platformio.runner`` instead of
 ``python -m platformio`` so that the patches (incremental rebuild
-preservation, download retries, skipping the private-package probe) apply
-inside the subprocess. Running
+preservation, download retries) apply inside the subprocess. Running
 PlatformIO in a subprocess keeps its ``sys.path`` mutations and other
 global state from leaking into the ESPHome process.
 """
@@ -106,16 +105,6 @@ def patch_file_downloader() -> None:
     FileDownloader.__init__ = patched_init
 
 
-def patch_registry_private_packages() -> None:
-    """Skip PlatformIO's private-package probe; it sleeps ~500 ms per lookup.
-
-    ESPHome never uses private packages, so the answer is always False.
-    """
-    from platformio.registry.client import RegistryClient
-
-    RegistryClient.allowed_private_packages = staticmethod(lambda: False)  # type: ignore[method-assign]
-
-
 _IGNORE_LIB_WARNINGS = "(?:Hash|Update)"
 # Regex patterns matched against each line of PlatformIO output. Lines that
 # match are dropped by RedirectText before they reach the parent process.
@@ -163,7 +152,6 @@ FILTER_PLATFORMIO_LINES = [
 def main() -> int:
     patch_structhash()
     patch_file_downloader()
-    patch_registry_private_packages()
 
     # Wrap stdout/stderr with RedirectText before PlatformIO runs:
     #

platformio.ini

@@ -45,7 +45,7 @@ lib_deps_base =
 lib_deps =
     ${common.lib_deps_base}
     https://github.com/dudanov/MideaUART.git#eeea6c3e9b4474f067054592b435be1c4e466815 ; midea
-    esphome/noise-c@0.1.26                 ; noise (api, ota)
+    esphome/noise-c@0.1.24                 ; noise (api, ota)
     improv/Improv@1.2.7                    ; improv_serial / esp32_improv
     kikuchan98/pngle@1.1.0                 ; online_image
     ; Using the repository directly, otherwise ESP-IDF can't use the library
@@ -244,7 +244,7 @@ lib_deps =
     ${common:idf-component-libs.lib_deps}
     ESP32Async/ESPAsyncWebServer@3.9.6    ; web_server_base
     droscy/esp_wireguard@0.4.5            ; wireguard
-    esphome/noise-c@0.1.26                ; noise (api, ota)
+    esphome/noise-c@0.1.24                ; noise (api, ota)
     ESP32Async/AsyncTCP@3.4.5             ; async_tcp
     DNSServer                             ; captive_portal
     heman/AsyncMqttClient-esphome@2.0.0   ; mqtt
@@ -641,7 +641,7 @@ build_unflags =
 extends = common
 platform = platformio/native
 lib_deps =
-    esphome/noise-c@0.1.26  ; used by noise (api, ota)
+    esphome/noise-c@0.1.24  ; used by noise (api, ota)
     lvgl/lvgl@9.5.0         ; lvgl
 build_flags =
     ${common.build_flags}

requirements.txt

@@ -10,9 +10,9 @@ tzlocal==5.4.4    # from time
 tzdata>=2026.3  # from time
 pyserial==3.5
 platformio==6.1.19
-esptool==5.4.0
+esptool==5.3.1
 click==8.3.3
-aioesphomeapi==46.4.0
+aioesphomeapi==46.3.0
 aiohappyeyeballs==2.7.1  # Happy Eyeballs for requests downloads; already pulled in by aioesphomeapi
 zeroconf==0.151.3
 puremagic==2.2.0

requirements_dev.txt

@@ -1,4 +1,4 @@
 # Useful stuff when working in a development environment
-clang-format==13.0.1  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
+clang-format==13.0.1  # also change in .pre-commit-config.yaml and Dockerfile when updating
 clang-tidy==22.1.8
-yamllint==1.38.0  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
+yamllint==1.38.0  # also change in .pre-commit-config.yaml when updating

requirements_test.txt

@@ -1,9 +1,8 @@
 pylint==4.0.8
-flake8==7.3.0  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
-ruff==0.16.6  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
-pyupgrade==3.21.2  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
-prek==0.5.2  # .github/workflows/ci.yml reads this pin
-yamlrocks==0.6.1  # used by script/sync_dependency_versions.py
+flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
+ruff==0.16.5  # also change in .pre-commit-config.yaml when updating
+pyupgrade==3.21.2  # also change in .pre-commit-config.yaml when updating
+prek==0.5.1  # also change in .github/workflows/ci.yml when updating
 
 # Unit tests
 pytest==9.1.1

script/api_protobuf/api_protobuf.py

@@ -28,6 +28,11 @@ class WireType(IntEnum):
     END_GROUP = 4  # groups (deprecated)
     FIXED32 = 5  # fixed32, sfixed32, float
 
+    @property
+    def cpp_name(self) -> str:
+        """The matching constant in proto.h."""
+        return f"WIRE_TYPE_{self.name}"
+
 
 # Generate with
 # protoc --python_out=script/api_protobuf -I esphome/components/api/ api_options.proto
@@ -126,9 +131,10 @@ def camel_to_snake(name: str) -> str:
     return re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1).lower()
 
 
-def force_str(force: bool) -> str:
-    """Convert a boolean force value to string format for C++ code."""
-    return str(force).lower()
+def _encode_call(func: str, *args: str, force: bool = False) -> str:
+    """Emit one ProtoEncode call; every helper takes the cursor and returns it advanced."""
+    suffix = "_force" if force else ""
+    return f"pos = ProtoEncode::{func}{suffix}({', '.join(('pos', *args))});"
 
 
 class TypeInfo(ABC):
@@ -223,55 +229,39 @@ class TypeInfo(ABC):
     def class_member(self) -> str:
         return f"{self.cpp_type} {self.field_name}{{{self.default_value}}};"
 
-    @property
-    def decode_varint_content(self) -> str:
-        content = self.decode_varint
-        if content is None:
-            return None
-        return f"case {self.number}: this->{self.field_name} = {content}; break;"
+    def decode_case(self, body: str) -> str:
+        """Emit one decode_field() case, keyed on the field's wire tag."""
+        return f"case proto_tag({self.number}, {self.wire_type.cpp_name}):\n" + indent(
+            f"{body}\nbreak;"
+        )
 
-    decode_varint = None
+    # Expression that reads this field from `value`; None when the type is never decoded.
+    decode_expr: str | None = None
+
+    def _decode_store(self, expr: str) -> str:
+        return f"this->{self.field_name} = {expr};"
 
     @property
-    def decode_length_content(self) -> str:
-        content = self.decode_length
-        if content is None:
-            return None
-        return f"case {self.number}: this->{self.field_name} = {content}; break;"
-
-    decode_length = None
-
-    @property
-    def decode_32bit_content(self) -> str:
-        content = self.decode_32bit
-        if content is None:
-            return None
-        return f"case {self.number}: this->{self.field_name} = {content}; break;"
-
-    decode_32bit = None
-
-    @property
-    def decode_64bit_content(self) -> str:
-        content = self.decode_64bit
-        if content is None:
-            return None
-        return f"case {self.number}: this->{self.field_name} = {content}; break;"
-
-    decode_64bit = None
+    def decode_content(self) -> str | None:
+        """The decode_field() case for this field, or None when it is never decoded."""
+        expr = self.decode_expr
+        return None if expr is None else self.decode_case(self._decode_store(expr))
 
     # Mapping from encode_func to raw encode expression template.
     # When a forced field has a single-byte tag, the code generator emits
     # write_raw_byte(tag) + raw encode instead of the full encode_* method,
     # eliminating the zero-check branch and encode_field_raw indirection.
     # {value} is replaced with the actual field expression.
-    RAW_ENCODE_MAP: dict[str, str] = {
-        "encode_uint32": "ProtoEncode::encode_varint_raw(pos, {value});",
-        "encode_uint64": "ProtoEncode::encode_varint_raw_64(pos, {value});",
-        "encode_sint32": "ProtoEncode::encode_varint_raw_short(pos, encode_zigzag32({value}));",
-        "encode_sint64": "ProtoEncode::encode_varint_raw_64(pos, encode_zigzag64({value}));",
-        "encode_int64": "ProtoEncode::encode_varint_raw_64(pos, static_cast<uint64_t>({value}));",
-        "encode_bool": "ProtoEncode::write_raw_byte(pos, {value} ? 0x01 : 0x00);",
+    RAW_ENCODE_MAP: dict[str, tuple[str, str]] = {
+        "encode_uint32": ("encode_varint_raw", "{value}"),
+        "encode_uint64": ("encode_varint_raw_64", "{value}"),
+        "encode_sint32": ("encode_varint_raw_short", "encode_zigzag32({value})"),
+        "encode_sint64": ("encode_varint_raw_64", "encode_zigzag64({value})"),
+        "encode_int64": ("encode_varint_raw_64", "static_cast<uint64_t>({value})"),
+        "encode_bool": ("write_raw_byte", "{value} ? 0x01 : 0x00"),
     }
+    # Fixed32 value expression for the shared tag+fixed32 writer; None for other wire types
+    fixed32_value_template: str | None = None
 
     def _encode_with_precomputed_tag(self, value_expr: str) -> str | None:
         """Try to emit a precomputed-tag encode for a field.
@@ -288,12 +278,17 @@ class TypeInfo(ABC):
             return None
         max_val = self.max_value
         # Only use RAW_ENCODE_MAP for forced fields or fields with max_value
-        raw_expr = None
+        raw = None
         if self.force or max_val is not None:
-            raw_expr = self.RAW_ENCODE_MAP.get(self.encode_func)
-        if raw_expr is None:
+            raw = self.RAW_ENCODE_MAP.get(self.encode_func)
+        if raw is None:
             return None
-        body = f"ProtoEncode::write_raw_byte(pos, {tag});\n{raw_expr.format(value=value_expr)}"
+        func, arg = raw
+        body = (
+            _encode_call("write_raw_byte", str(tag))
+            + "\n"
+            + _encode_call(func, arg.format(value=value_expr))
+        )
         if self.force:
             return body
         # Non-forced with max_value: inline zero-check + raw encode
@@ -314,23 +309,44 @@ class TypeInfo(ABC):
             return None
         # When max_len < 128, length varint is always 1 byte
         len_encode = (
-            f"ProtoEncode::write_raw_byte(pos, static_cast<uint8_t>({len_expr}));"
+            _encode_call("write_raw_byte", f"static_cast<uint8_t>({len_expr})")
             if max_len is not None and max_len < 128
-            else f"ProtoEncode::encode_varint_raw(pos, {len_expr});"
+            else _encode_call("encode_varint_raw", len_expr)
         )
+        return "\n".join(
+            (
+                _encode_call("write_raw_byte", str(tag)),
+                len_encode,
+                _encode_call("encode_raw", data_expr, len_expr),
+            )
+        )
+
+    def _encode_fixed32_with_precomputed_tag(self, value: str) -> str | None:
+        """Single-byte tag fixed32 write, or None for other types and multi-byte tags."""
+        tag = self.calculate_tag()
+        if self.fixed32_value_template is None or tag >= 128:
+            return None
+        value_expr = self.fixed32_value_template.format(value=value)
+        if self.force:
+            return _encode_call("write_tag_and_fixed32", str(tag), value_expr)
         return (
-            f"ProtoEncode::write_raw_byte(pos, {tag});\n"
-            f"{len_encode}\n"
-            f"ProtoEncode::encode_raw(pos, {data_expr}, {len_expr});"
+            f"if (uint32_t raw = {value_expr}; raw != 0) [[likely]] {{\n"
+            f"  {_encode_call('write_tag_and_fixed32', str(tag), 'raw')}\n"
+            "}"
         )
 
     @property
     def encode_content(self) -> str:
-        if result := self._encode_with_precomputed_tag(f"this->{self.field_name}"):
+        value = f"this->{self.field_name}"
+        if result := self._encode_with_precomputed_tag(value):
             return result
-        if self.force:
-            return f"ProtoEncode::{self.encode_func}(pos, {self.number}, this->{self.field_name}, true);"
-        return f"ProtoEncode::{self.encode_func}(pos, {self.number}, this->{self.field_name});"
+        if result := self._encode_fixed32_with_precomputed_tag(value):
+            return result
+        return _encode_call(self.encode_func, str(self.number), value, force=self.force)
+
+    def encode_element(self, number: int, element: str) -> str:
+        """Encode one element of a repeated field; elements are always written."""
+        return _encode_call(self.encode_func, str(number), element, force=True)
 
     encode_func = None
 
@@ -550,17 +566,17 @@ def create_field_type_info(
         # For messages that decode (SOURCE_CLIENT or SOURCE_BOTH), use pointer
         # for zero-copy access to the receive buffer
         if needs_decode:
-            return PointerToBytesBufferType(field, None)
+            return PointerToBytesBufferType(field, needs_decode)
 
         # For SOURCE_SERVER (encode only), explicit annotation is still needed
         if get_field_opt(field, pb.pointer_to_buffer, False):
-            return PointerToBytesBufferType(field, None)
+            return PointerToBytesBufferType(field, needs_decode)
 
         return BytesType(field, needs_decode, needs_encode)
 
     # Special handling for string fields - use StringRef for zero-copy
     if field.type == 9:
-        return PointerToStringBufferType(field, None)
+        return PointerToStringBufferType(field, needs_decode)
 
     validate_field_type(field.type, field.name)
     if field.type == 11:
@@ -605,7 +621,6 @@ class DoubleType(FixedSizeTypeMixin, TypeInfo):
     # Unsupported but defined for completeness
     cpp_type = "double"
     default_value = "0.0"
-    decode_64bit = "value.as_double()"
     encode_func = "encode_double"
     wire_type = WireType.FIXED64  # Uses wire type 1 according to protobuf spec
 
@@ -631,10 +646,12 @@ class DoubleType(FixedSizeTypeMixin, TypeInfo):
 class FloatType(FixedSizeTypeMixin, TypeInfo):
     cpp_type = "float"
     default_value = "0.0f"
-    decode_32bit = "value.as_float()"
+    decode_expr = "value.as_float()"
     encode_func = "encode_float"
     wire_type = WireType.FIXED32  # Uses wire type 5
 
+    fixed32_value_template = "float_to_raw({value})"
+
     def dump(self, name: str) -> str:
         o = f'snprintf(buffer, sizeof(buffer), "%g", {name});\n'
         o += "out.append(buffer);"
@@ -658,7 +675,7 @@ class Int64Type(VarintTypeMixin, TypeInfo):
     cpp_type = "int64_t"
     _varint_max_bits = 64
     default_value = "0"
-    decode_varint = "static_cast<int64_t>(value)"
+    decode_expr = "static_cast<int64_t>(value.as_varint())"
     encode_func = "encode_int64"
     wire_type = WireType.VARINT  # Uses wire type 0
 
@@ -679,7 +696,7 @@ class UInt64Type(VarintTypeMixin, TypeInfo):
     cpp_type = "uint64_t"
     _varint_max_bits = 64
     default_value = "0"
-    decode_varint = "value"
+    decode_expr = "value.as_varint()"
     encode_func = "encode_uint64"
     wire_type = WireType.VARINT  # Uses wire type 0
 
@@ -697,11 +714,11 @@ class UInt64Type(VarintTypeMixin, TypeInfo):
         return self._get_simple_size_calculation(name, force, "uint64")
 
     @property
-    def RAW_ENCODE_MAP(self) -> dict[str, str]:  # noqa: N802
+    def RAW_ENCODE_MAP(self) -> dict[str, tuple[str, str]]:  # noqa: N802
         if self.mac_address:
             return {
                 **TypeInfo.RAW_ENCODE_MAP,
-                "encode_uint64": "ProtoEncode::encode_varint_raw_48bit(pos, {value});",
+                "encode_uint64": ("encode_varint_raw_48bit", "{value}"),
             }
         return TypeInfo.RAW_ENCODE_MAP
 
@@ -714,7 +731,7 @@ class Int32Type(VarintTypeMixin, TypeInfo):
     cpp_type = "int32_t"
     _varint_max_bits = 64  # int32 is sign-extended to 64 bits in protobuf
     default_value = "0"
-    decode_varint = "static_cast<int32_t>(value)"
+    decode_expr = "static_cast<int32_t>(value.as_varint())"
     encode_func = "encode_int32"
     wire_type = WireType.VARINT  # Uses wire type 0
 
@@ -734,7 +751,6 @@ class Int32Type(VarintTypeMixin, TypeInfo):
 class Fixed64Type(FixedSizeTypeMixin, TypeInfo):
     cpp_type = "uint64_t"
     default_value = "0"
-    decode_64bit = "value.as_fixed64()"
     encode_func = "encode_fixed64"
     wire_type = WireType.FIXED64  # Uses wire type 1
 
@@ -760,7 +776,7 @@ class Fixed64Type(FixedSizeTypeMixin, TypeInfo):
 class Fixed32Type(FixedSizeTypeMixin, TypeInfo):
     cpp_type = "uint32_t"
     default_value = "0"
-    decode_32bit = "value.as_fixed32()"
+    decode_expr = "value.as_fixed32()"
     encode_func = "encode_fixed32"
     wire_type = WireType.FIXED32  # Uses wire type 5
 
@@ -769,15 +785,7 @@ class Fixed32Type(FixedSizeTypeMixin, TypeInfo):
         o += "out.append(buffer);"
         return o
 
-    @property
-    def encode_content(self) -> str:
-        tag = self.calculate_tag()
-        if self.force and tag < 128:
-            # Emit combined tag+value write: precomputed tag + direct memcpy
-            return f"ProtoEncode::write_tag_and_fixed32(pos, {tag}, this->{self.field_name});"
-        if self.force:
-            return f"ProtoEncode::{self.encode_func}(pos, {self.number}, this->{self.field_name}, true);"
-        return f"ProtoEncode::{self.encode_func}(pos, {self.number}, this->{self.field_name});"
+    fixed32_value_template = "{value}"
 
     def get_size_calculation(self, name: str, force: bool = False) -> str:
         field_id_size = self.calculate_field_id_size()
@@ -797,7 +805,7 @@ class BoolType(VarintTypeMixin, TypeInfo):
     _varint_max_bits = 1
     cpp_type = "bool"
     default_value = "false"
-    decode_varint = "value != 0"
+    decode_expr = "value.as_bool()"
     encode_func = "encode_bool"
     wire_type = WireType.VARINT  # Uses wire type 0
 
@@ -817,7 +825,7 @@ class StringType(TypeInfo):
     default_value = ""
     reference_type = "std::string &"
     const_reference_type = "const std::string &"
-    decode_length = "value.as_string()"
+    decode_expr = "value.as_string()"
     encode_func = "encode_string"
     wire_type = WireType.LENGTH_DELIMITED  # Uses wire type 2
 
@@ -851,9 +859,12 @@ class StringType(TypeInfo):
             f"this->{self.field_name}_ref_.size()",
         ):
             return result
-        if self.force:
-            return f"ProtoEncode::encode_string(pos, {self.number}, this->{self.field_name}_ref_, true);"
-        return f"ProtoEncode::encode_string(pos, {self.number}, this->{self.field_name}_ref_);"
+        return _encode_call(
+            "encode_string",
+            str(self.number),
+            f"this->{self.field_name}_ref_",
+            force=self.force,
+        )
 
     def dump(self, name):
         # If name is 'it', this is a repeated field element - always use string
@@ -929,6 +940,9 @@ class MessageType(TypeInfo):
     def can_use_dump_field(cls) -> bool:
         return False
 
+    def encode_element(self, number: int, element: str) -> str:
+        return _encode_call("encode_sub_message", "buffer", str(number), element)
+
     @property
     def cpp_type(self) -> str:
         return self._field.type_name[1:]
@@ -951,15 +965,9 @@ class MessageType(TypeInfo):
     @property
     def encode_content(self) -> str:
         # Sub-message encoding needs buffer for backpatch/sync
-        return f"ProtoEncode::{self.encode_func}(pos, buffer, {self.number}, this->{self.field_name});"
-
-    @property
-    def decode_length(self) -> str:
-        # Override to return None for message types because we can't use template-based
-        # decoding when the specific message type isn't known at compile time.
-        # Instead, we use the non-template decode_to_message() method which allows
-        # runtime polymorphism through virtual function calls.
-        return None
+        return _encode_call(
+            self.encode_func, "buffer", str(self.number), f"this->{self.field_name}"
+        )
 
     @property
     def public_content(self) -> list[str]:
@@ -976,19 +984,14 @@ class MessageType(TypeInfo):
         )
 
     @property
-    def decode_length_content(self) -> str:
-        # Custom decode that doesn't use templates
+    def decode_content(self) -> str:
+        body = f"value.decode_to_message(this->{self.field_name});"
         if self._track_presence:
             # decode_to_message() cannot report failure, so setting the flag
             # afterwards only documents intent; a status-returning decode could
             # gate it for real without touching callers.
-            return (
-                f"case {self.number}:\n"
-                f"      value.decode_to_message(this->{self.field_name});\n"
-                f"      this->has_{self.name} = true;\n"
-                f"      break;"
-            )
-        return f"case {self.number}: value.decode_to_message(this->{self.field_name}); break;"
+            body += f"\nthis->has_{self.name} = true;"
+        return self.decode_case(body)
 
     def dump(self, name: str) -> str:
         return f"{name}.dump_to(out);"
@@ -1027,7 +1030,7 @@ class BytesType(TypeInfo):
     reference_type = "std::string &"
     const_reference_type = "const std::string &"
     encode_func = "encode_bytes"
-    decode_length = "value.as_string()"
+    decode_expr = "value.as_string()"
     wire_type = WireType.LENGTH_DELIMITED  # Uses wire type 2
 
     @property
@@ -1058,9 +1061,13 @@ class BytesType(TypeInfo):
             f"this->{self.field_name}_ptr_", f"this->{self.field_name}_len_"
         ):
             return result
-        if self.force:
-            return f"ProtoEncode::encode_bytes(pos, {self.number}, this->{self.field_name}_ptr_, this->{self.field_name}_len_, true);"
-        return f"ProtoEncode::encode_bytes(pos, {self.number}, this->{self.field_name}_ptr_, this->{self.field_name}_len_);"
+        return _encode_call(
+            "encode_bytes",
+            str(self.number),
+            f"this->{self.field_name}_ptr_",
+            f"this->{self.field_name}_len_",
+            force=self.force,
+        )
 
     def dump(self, name: str) -> str:
         ptr_dump = f"format_hex_pretty(this->{self.field_name}_ptr_, this->{self.field_name}_len_)"
@@ -1127,16 +1134,12 @@ class PointerToBufferTypeBase(TypeInfo):
     def can_use_dump_field(cls) -> bool:
         return False
 
+    # Only here to make needs_decode required: the null string default keys off it, so a call
+    # site must not fall back on the base class default
     def __init__(
-        self, field: descriptor.FieldDescriptorProto, size: int | None = None
+        self, field: descriptor.FieldDescriptorProto, needs_decode: bool
     ) -> None:
-        super().__init__(field)
-        self.array_size = 0
-
-    @property
-    def decode_length(self) -> str | None:
-        # This is handled in decode_length_content
-        return None
+        super().__init__(field, needs_decode)
 
     @property
     def wire_type(self) -> WireType:
@@ -1170,17 +1173,20 @@ class PointerToBytesBufferType(PointerToBufferTypeBase):
             f"this->{self.field_name}", f"this->{self.field_name}_len"
         ):
             return result
-        if self.force:
-            return f"ProtoEncode::encode_bytes(pos, {self.number}, this->{self.field_name}, this->{self.field_name}_len, true);"
-        return f"ProtoEncode::encode_bytes(pos, {self.number}, this->{self.field_name}, this->{self.field_name}_len);"
+        return _encode_call(
+            "encode_bytes",
+            str(self.number),
+            f"this->{self.field_name}",
+            f"this->{self.field_name}_len",
+            force=self.force,
+        )
 
     @property
-    def decode_length_content(self) -> str | None:
-        return f"""case {self.number}: {{
-      this->{self.field_name} = value.data();
-      this->{self.field_name}_len = value.size();
-      break;
-    }}"""
+    def decode_content(self) -> str:
+        return self.decode_case(
+            f"this->{self.field_name} = value.data();\n"
+            f"this->{self.field_name}_len = value.size();",
+        )
 
     def dump(self, name: str) -> str:
         return (
@@ -1214,34 +1220,53 @@ class PointerToStringBufferType(PointerToBufferTypeBase):
     def can_use_dump_field(cls) -> bool:
         return True
 
+    @property
+    def _starts_null(self) -> bool:
+        """A field that is only encoded, and skipped when empty, never has its pointer read
+        before it is set, so it can default to a null StringRef and the message constructs as
+        one zero fill. Any encode path that copies unconditionally must check this."""
+        return not self._needs_decode and not self.force
+
     @property
     def public_content(self) -> list[str]:
+        if self._starts_null:
+            return [
+                f"StringRef {self.field_name}{{nullptr, 0}};  // null until set, encode only"
+            ]
         return [f"StringRef {self.field_name}{{}};"]
 
     @property
     def encode_content(self) -> str:
         max_len = self.max_data_length
         if max_len is not None and max_len < 128 and self.force:
+            assert not self._starts_null, (
+                "unconditional copy of a field that may start null"
+            )
             tag = self.calculate_tag()
             if tag < 128:
-                return f"ProtoEncode::encode_short_string_force(pos, {tag}, this->{self.field_name});"
+                return _encode_call(
+                    "encode_short_string_force", str(tag), f"this->{self.field_name}"
+                )
         if result := self._encode_bytes_with_precomputed_tag(
             f"this->{self.field_name}.c_str()",
             f"this->{self.field_name}.size()",
         ):
+            assert not self._starts_null, (
+                "unconditional copy of a field that may start null"
+            )
             return result
-        if self.force:
-            return f"ProtoEncode::encode_string(pos, {self.number}, this->{self.field_name}, true);"
-        return (
-            f"ProtoEncode::encode_string(pos, {self.number}, this->{self.field_name});"
+        return _encode_call(
+            "encode_string",
+            str(self.number),
+            f"this->{self.field_name}",
+            force=self.force,
         )
 
     @property
-    def decode_length_content(self) -> str | None:
-        return f"""case {self.number}: {{
-      this->{self.field_name} = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
-      break;
-    }}"""
+    def decode_content(self) -> str:
+        return self.decode_case(
+            f"this->{self.field_name} = StringRef(value.data(), value.size());",
+        )
 
     def dump(self, name: str) -> str:
         # Not used since we use dump_field, but required by abstract base class
@@ -1310,14 +1335,13 @@ class PackedBufferTypeInfo(TypeInfo):
         ]
 
     @property
-    def decode_length_content(self) -> str:
+    def decode_content(self) -> str:
         """Store pointer to buffer and calculate count of packed varints."""
-        return f"""case {self.number}: {{
-      this->{self.field_name}_data_ = value.data();
-      this->{self.field_name}_length_ = value.size();
-      this->{self.field_name}_count_ = count_packed_varints(value.data(), value.size());
-      break;
-    }}"""
+        return self.decode_case(
+            f"this->{self.field_name}_data_ = value.data();\n"
+            f"this->{self.field_name}_length_ = value.size();\n"
+            f"this->{self.field_name}_count_ = count_packed_varints(value.data(), value.size());",
+        )
 
     @property
     def encode_content(self) -> str:
@@ -1402,17 +1426,11 @@ class FixedArrayBytesType(TypeInfo):
         ]
 
     @property
-    def decode_length_content(self) -> str:
-        o = f"case {self.number}: {{\n"
-        o += "  const std::string &data_str = value.as_string();\n"
-        o += f"  this->{self.field_name}_len = data_str.size();\n"
-        o += f"  if (this->{self.field_name}_len > {self.array_size}) {{\n"
-        o += f"    this->{self.field_name}_len = {self.array_size};\n"
-        o += "  }\n"
-        o += f"  memcpy(this->{self.field_name}, data_str.data(), this->{self.field_name}_len);\n"
-        o += "  break;\n"
-        o += "}"
-        return o
+    def decode_content(self) -> str:
+        return self.decode_case(
+            f"this->{self.field_name}_len = std::min<size_t>(value.size(), {self.array_size});\n"
+            f"memcpy(this->{self.field_name}, value.data(), this->{self.field_name}_len);",
+        )
 
     @property
     def encode_content(self) -> str:
@@ -1421,9 +1439,13 @@ class FixedArrayBytesType(TypeInfo):
             f"this->{self.field_name}", f"this->{self.field_name}_len", max_len=max_len
         ):
             return result
-        if self.force:
-            return f"ProtoEncode::encode_bytes(pos, {self.number}, this->{self.field_name}, this->{self.field_name}_len, true);"
-        return f"ProtoEncode::encode_bytes(pos, {self.number}, this->{self.field_name}, this->{self.field_name}_len);"
+        return _encode_call(
+            "encode_bytes",
+            str(self.number),
+            f"this->{self.field_name}",
+            f"this->{self.field_name}_len",
+            force=self.force,
+        )
 
     def dump(self, name: str) -> str:
         return f"out.append(format_hex_pretty({name}, {name}_len));"
@@ -1471,7 +1493,7 @@ class UInt32Type(VarintTypeMixin, TypeInfo):
     cpp_type = "uint32_t"
     _varint_max_bits = 32
     default_value = "0"
-    decode_varint = "value"
+    decode_expr = "value.as_varint()"
     encode_func = "encode_uint32"
     wire_type = WireType.VARINT  # Uses wire type 0
 
@@ -1494,13 +1516,21 @@ class UInt32Type(VarintTypeMixin, TypeInfo):
 class EnumType(VarintTypeMixin, TypeInfo):
     _varint_max_bits = 32
 
+    def encode_element(self, number: int, element: str) -> str:
+        return _encode_call(
+            self.encode_func,
+            str(number),
+            f"static_cast<uint32_t>({element})",
+            force=True,
+        )
+
     @property
     def cpp_type(self) -> str:
         return f"enums::{self._field.type_name[1:]}"
 
     @property
-    def decode_varint(self) -> str:
-        return f"static_cast<{self.cpp_type}>(value)"
+    def decode_expr(self) -> str:
+        return f"static_cast<{self.cpp_type}>(value.as_varint())"
 
     default_value = ""
     wire_type = WireType.VARINT  # Uses wire type 0
@@ -1520,9 +1550,9 @@ class EnumType(VarintTypeMixin, TypeInfo):
     @property
     def encode_content(self) -> str:
         value_expr = f"static_cast<uint32_t>(this->{self.field_name})"
-        if self.force:
-            return f"ProtoEncode::{self.encode_func}(pos, {self.number}, {value_expr}, true);"
-        return f"ProtoEncode::{self.encode_func}(pos, {self.number}, {value_expr});"
+        return _encode_call(
+            self.encode_func, str(self.number), value_expr, force=self.force
+        )
 
     def dump(self, name: str) -> str:
         return f"out.append_p(proto_enum_to_string<{self.cpp_type}>({name}));"
@@ -1547,7 +1577,7 @@ class EnumType(VarintTypeMixin, TypeInfo):
 class SFixed32Type(FixedSizeTypeMixin, TypeInfo):
     cpp_type = "int32_t"
     default_value = "0"
-    decode_32bit = "value.as_sfixed32()"
+    decode_expr = "value.as_sfixed32()"
     encode_func = "encode_sfixed32"
     wire_type = WireType.FIXED32  # Uses wire type 5
 
@@ -1573,7 +1603,6 @@ class SFixed32Type(FixedSizeTypeMixin, TypeInfo):
 class SFixed64Type(FixedSizeTypeMixin, TypeInfo):
     cpp_type = "int64_t"
     default_value = "0"
-    decode_64bit = "value.as_sfixed64()"
     encode_func = "encode_sfixed64"
     wire_type = WireType.FIXED64  # Uses wire type 1
 
@@ -1600,7 +1629,7 @@ class SInt32Type(VarintTypeMixin, TypeInfo):
     cpp_type = "int32_t"
     _varint_max_bits = 32  # zigzag encoding keeps it 32-bit
     default_value = "0"
-    decode_varint = "decode_zigzag32(static_cast<uint32_t>(value))"
+    decode_expr = "decode_zigzag32(static_cast<uint32_t>(value.as_varint()))"
     encode_func = "encode_sint32"
     wire_type = WireType.VARINT  # Uses wire type 0
 
@@ -1621,7 +1650,7 @@ class SInt64Type(VarintTypeMixin, TypeInfo):
     cpp_type = "int64_t"
     _varint_max_bits = 64
     default_value = "0"
-    decode_varint = "decode_zigzag64(value)"
+    decode_expr = "decode_zigzag64(value.as_varint())"
     encode_func = "encode_sint64"
     wire_type = WireType.VARINT  # Uses wire type 0
 
@@ -1701,9 +1730,9 @@ def _generate_inline_encode_block(
 
     lines = []
     lines.append(f"auto &sub_msg = {element};")
-    lines.append(f"ProtoEncode::write_raw_byte(pos, {tag});")
+    lines.append(_encode_call("write_raw_byte", str(tag)))
     lines.append("uint8_t *len_pos = pos;")
-    lines.append("ProtoEncode::reserve_byte(pos);")
+    lines.append(_encode_call("reserve_byte"))
 
     # Generate inline field encoding for each sub-message field
     for field in sub_desc.field:
@@ -1774,18 +1803,11 @@ class FixedArrayRepeatedType(TypeInfo):
 
     def _encode_element(self, element: str) -> str:
         """Helper to generate encode statement for a single element."""
-        if isinstance(self._ti, EnumType):
-            return f"ProtoEncode::{self._ti.encode_func}(pos, {self.number}, static_cast<uint32_t>({element}), true);"
-        # Repeated message elements use encode_sub_message (force=true is default)
-        if isinstance(self._ti, MessageType):
-            if _is_inline_encode(self._ti.cpp_type):
-                return _generate_inline_encode_block(
-                    self.number, self._ti.cpp_type, element
-                )
-            return f"ProtoEncode::encode_sub_message(pos, buffer, {self.number}, {element});"
-        return (
-            f"ProtoEncode::{self._ti.encode_func}(pos, {self.number}, {element}, true);"
-        )
+        if isinstance(self._ti, MessageType) and _is_inline_encode(self._ti.cpp_type):
+            return _generate_inline_encode_block(
+                self.number, self._ti.cpp_type, element
+            )
+        return self._ti.encode_element(self.number, element)
 
     @property
     def cpp_type(self) -> str:
@@ -2079,55 +2101,23 @@ class RepeatedTypeInfo(TypeInfo):
         return self._ti.wire_type
 
     @property
-    def decode_varint_content(self) -> str:
-        # Pointer fields don't support decoding
-        if self._use_pointer:
-            return None
-        content = self._ti.decode_varint
-        if content is None:
-            return None
-        return (
-            f"case {self.number}: this->{self.field_name}.push_back({content}); break;"
-        )
+    def decode_expr(self) -> str | None:
+        return self._ti.decode_expr
+
+    def _decode_store(self, expr: str) -> str:
+        return f"this->{self.field_name}.push_back({expr});"
 
     @property
-    def decode_length_content(self) -> str:
+    def decode_content(self) -> str | None:
         # Pointer fields don't support decoding
         if self._use_pointer:
             return None
-        content = self._ti.decode_length
-        if content is None and isinstance(self._ti, MessageType):
-            # Special handling for non-template message decoding
-            return f"case {self.number}: this->{self.field_name}.emplace_back(); value.decode_to_message(this->{self.field_name}.back()); break;"
-        if content is None:
-            return None
-        return (
-            f"case {self.number}: this->{self.field_name}.push_back({content}); break;"
-        )
-
-    @property
-    def decode_32bit_content(self) -> str:
-        # Pointer fields don't support decoding
-        if self._use_pointer:
-            return None
-        content = self._ti.decode_32bit
-        if content is None:
-            return None
-        return (
-            f"case {self.number}: this->{self.field_name}.push_back({content}); break;"
-        )
-
-    @property
-    def decode_64bit_content(self) -> str:
-        # Pointer fields don't support decoding
-        if self._use_pointer:
-            return None
-        content = self._ti.decode_64bit
-        if content is None:
-            return None
-        return (
-            f"case {self.number}: this->{self.field_name}.push_back({content}); break;"
-        )
+        if isinstance(self._ti, MessageType):
+            return self.decode_case(
+                f"this->{self.field_name}.emplace_back();\n"
+                f"value.decode_to_message(this->{self.field_name}.back());"
+            )
+        return super().decode_content
 
     @property
     def _ti_is_bool(self) -> bool:
@@ -2135,15 +2125,7 @@ class RepeatedTypeInfo(TypeInfo):
         return isinstance(self._ti, BoolType)
 
     def _encode_element_call(self, element: str) -> str:
-        """Helper to generate encode call for a single element."""
-        if isinstance(self._ti, EnumType):
-            return f"ProtoEncode::{self._ti.encode_func}(pos, {self.number}, static_cast<uint32_t>({element}), true);"
-        # Repeated message elements use encode_sub_message (force=true is default)
-        if isinstance(self._ti, MessageType):
-            return f"ProtoEncode::encode_sub_message(pos, buffer, {self.number}, {element});"
-        return (
-            f"ProtoEncode::{self._ti.encode_func}(pos, {self.number}, {element}, true);"
-        )
+        return self._ti.encode_element(self.number, element)
 
     @property
     def encode_content(self) -> str:
@@ -2152,7 +2134,7 @@ class RepeatedTypeInfo(TypeInfo):
             # Special handling for const char* elements (when container_no_template contains "const char")
             if "const char" in self._container_no_template:
                 o = f"for (const char *it : *this->{self.field_name}) {{\n"
-                o += f"  ProtoEncode::{self._ti.encode_func}(pos, {self.number}, it, strlen(it), true);\n"
+                o += f"  {_encode_call(self._ti.encode_func, str(self.number), 'it', 'strlen(it)', force=True)}\n"
             else:
                 o = f"for (const auto &it : *this->{self.field_name}) {{\n"
                 o += f"  {self._encode_element_call('it')}\n"
@@ -2538,10 +2520,7 @@ def build_message_type(
 ) -> tuple[str, str, str]:
     public_content: list[str] = []
     protected_content: list[str] = []
-    decode_varint: list[str] = []
-    decode_length: list[str] = []
-    decode_32bit: list[str] = []
-    decode_64bit: list[str] = []
+    decode: list[str] = []
     encode: list[str] = []
     dump: list[str] = []
     size_calc: list[str] = []
@@ -2670,22 +2649,8 @@ def build_message_type(
             if field.options.HasExtension(pb.field_ifdef):
                 field_ifdef = field.options.Extensions[pb.field_ifdef]
 
-            if ti.decode_varint_content:
-                decode_varint.extend(
-                    wrap_with_ifdef(ti.decode_varint_content, field_ifdef)
-                )
-            if ti.decode_length_content:
-                decode_length.extend(
-                    wrap_with_ifdef(ti.decode_length_content, field_ifdef)
-                )
-            if ti.decode_32bit_content:
-                decode_32bit.extend(
-                    wrap_with_ifdef(ti.decode_32bit_content, field_ifdef)
-                )
-            if ti.decode_64bit_content:
-                decode_64bit.extend(
-                    wrap_with_ifdef(ti.decode_64bit_content, field_ifdef)
-                )
+            if case := ti.decode_content:
+                decode.extend(wrap_with_ifdef(case, field_ifdef))
         if ti.dump_content:
             # Check for field_ifdef option for dump as well
             field_ifdef = None
@@ -2695,49 +2660,15 @@ def build_message_type(
             dump.extend(wrap_with_ifdef(ti.dump_content, field_ifdef))
 
     cpp = ""
-    if decode_varint:
-        o = f"bool {desc.name}::decode_varint(uint32_t field_id, proto_varint_value_t value) {{\n"
-        o += "  switch (field_id) {\n"
-        o += indent("\n".join(decode_varint), "    ") + "\n"
-        o += "    default: return false;\n"
+    if decode:
+        o = f"void {desc.name}::decode_field(uint32_t tag, const uint8_t *data, proto_varint_value_t scalar) {{\n"
+        o += "  const ProtoFieldValue value(data, scalar);\n"
+        o += "  switch (tag) {\n"
+        o += indent("\n".join(decode), "    ") + "\n"
         o += "  }\n"
-        o += "  return true;\n"
         o += "}\n"
         cpp += o
-        prot = "bool decode_varint(uint32_t field_id, proto_varint_value_t value) override;"
-        protected_content.insert(0, prot)
-    if decode_length:
-        o = f"bool {desc.name}::decode_length(uint32_t field_id, ProtoLengthDelimited value) {{\n"
-        o += "  switch (field_id) {\n"
-        o += indent("\n".join(decode_length), "    ") + "\n"
-        o += "    default: return false;\n"
-        o += "  }\n"
-        o += "  return true;\n"
-        o += "}\n"
-        cpp += o
-        prot = "bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;"
-        protected_content.insert(0, prot)
-    if decode_32bit:
-        o = f"bool {desc.name}::decode_32bit(uint32_t field_id, Proto32Bit value) {{\n"
-        o += "  switch (field_id) {\n"
-        o += indent("\n".join(decode_32bit), "    ") + "\n"
-        o += "    default: return false;\n"
-        o += "  }\n"
-        o += "  return true;\n"
-        o += "}\n"
-        cpp += o
-        prot = "bool decode_32bit(uint32_t field_id, Proto32Bit value) override;"
-        protected_content.insert(0, prot)
-    if decode_64bit:
-        o = f"bool {desc.name}::decode_64bit(uint32_t field_id, Proto64Bit value) {{\n"
-        o += "  switch (field_id) {\n"
-        o += indent("\n".join(decode_64bit), "    ") + "\n"
-        o += "    default: return false;\n"
-        o += "  }\n"
-        o += "  return true;\n"
-        o += "}\n"
-        cpp += o
-        prot = "bool decode_64bit(uint32_t field_id, Proto64Bit value) override;"
+        prot = "void decode_field(uint32_t tag, const uint8_t *data, proto_varint_value_t scalar) override;"
         protected_content.insert(0, prot)
 
     # Generate custom decode() override for messages with FixedVector fields
@@ -2784,28 +2715,36 @@ def build_message_type(
             )
             for line in encode
         ]
-        o = f"{speed_attr}uint8_t *{desc.name}::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {{\n"
+        o = f"{speed_attr}uint8_t *{desc.name}::encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) {{\n"
+        o += f"  const auto &msg = *static_cast<const {desc.name} *>(self);\n"
         o += "  uint8_t *__restrict__ pos = buffer.get_pos();\n"
-        o += indent("\n".join(encode_debug)) + "\n"
+        o += indent("\n".join(encode_debug)).replace("this->", "msg.") + "\n"
         o += "  return pos;\n"
         o += "}\n"
         cpp += o
-        prot = (
-            "uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;"
+        public_content.append(
+            "static uint8_t *encode_msg(const void *self, ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM);"
+        )
+        public_content.append(
+            "uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {\n"
+            "  return encode_msg(this, buffer PROTO_ENCODE_DEBUG_ARG);\n"
+            "}"
         )
-        public_content.append(prot)
     # If no fields to encode or message doesn't need encoding, the default implementation in ProtoMessage will be used
 
     # Add calculate_size method only if this message needs encoding and has fields
     if needs_encode and size_calc and not is_inline_only:
-        o = f"{speed_attr}uint32_t {desc.name}::calculate_size() const {{\n"
+        o = f"{speed_attr}uint32_t {desc.name}::calc_size_msg(const void *self) {{\n"
+        o += f"  const auto &msg = *static_cast<const {desc.name} *>(self);\n"
         o += "  uint32_t size = 0;\n"
-        o += indent("\n".join(size_calc)) + "\n"
+        o += indent("\n".join(size_calc)).replace("this->", "msg.") + "\n"
         o += "  return size;\n"
         o += "}\n"
         cpp += o
-        prot = "uint32_t calculate_size() const;"
-        public_content.append(prot)
+        public_content.append("static uint32_t calc_size_msg(const void *self);")
+        public_content.append(
+            "uint32_t calculate_size() const { return calc_size_msg(this); }"
+        )
     # If no fields to calculate size for or message doesn't need encoding, the default implementation in ProtoMessage will be used
 
     # dump_to method declaration in header

script/git-hooks/post-checkout

@@ -1,72 +1,20 @@
 #!/bin/sh
 # Prepare the dev environment for a new checkout or worktree.
 #
-# Installed into the git hooks directory by script/setup.py. Deliberately tiny
-# and self-contained: it stays valid on branches where the setup script does not
-# exist, and simply does nothing there.
+# Installed into the git hooks directory by script/setup. Deliberately tiny and
+# self-contained: it stays valid on branches where script/setup does not exist,
+# and simply does nothing there.
 
 # $3 is 1 for a branch checkout, 0 for a file checkout.
 [ "$3" = "1" ] || exit 0
 
 top=$(git rev-parse --show-toplevel 2>/dev/null) || exit 0
 
-# This also runs on ordinary branch switches, where there is nothing to do. Both
-# layouts are checked because git for Windows runs hooks under its own bundled
-# shell, where the environment lives in venv/Scripts rather than venv/bin.
+# This also runs on ordinary branch switches, where there is nothing to do.
 [ -x "$top/venv/bin/python" ] && exit 0
-[ -f "$top/venv/Scripts/python.exe" ] && exit 0
-
-# Branches from before the setup script moved to Python carry only the shell
-# entry point, so whichever one the checked out branch has is used.
-py=
-if [ -f "$top/script/setup.py" ]; then
-  # The interpreter goes by different names across platforms, and on Windows
-  # "python3" is often a stub that opens the app store instead of running
-  # anything, so each candidate is tried before it is used. Doing nothing is the
-  # right outcome when none of them work.
-  for candidate in "python3" "python" "py -3"; do
-    # Unquoted on purpose: the launcher candidate is a command plus a flag.
-    if $candidate -c "" >/dev/null 2>&1; then
-      py=$candidate
-      break
-    fi
-  done
-  [ -n "$py" ] || exit 0
-elif ! [ -x "$top/script/setup" ]; then
-  exit 0
-fi
-
-# Every worktree shares the hooks directory of the checkout it was created
-# from, and the setup script run below is the one from whichever branch was just
-# checked out. Older branches install their own pre-commit hook without checking
-# for a worktree: that moves the shared hook aside as pre-commit.legacy and
-# replaces it with one tied to this worktree's virtual environment, so commits
-# break in every checkout. To rule that out, the hooks directory is copied
-# before the setup script runs and put back exactly as it was afterwards,
-# including removing any file the setup script added.
-hooks=$(git rev-parse --path-format=absolute --git-path hooks 2>/dev/null) || exit 0
-snap=$(mktemp -d "$hooks/.post-checkout.XXXXXX") || exit 0
-cp -p "$hooks"/* "$snap"/ 2>/dev/null
+[ -x "$top/script/setup" ] || exit 0
 
 # Clear VIRTUAL_ENV so a checkout made from a shell with an environment already
 # activated still gets its own, rather than having the active one repointed at
 # this working tree.
-unset VIRTUAL_ENV
-if [ -n "$py" ]; then
-  # Unquoted on purpose, as above.
-  $py "$top/script/setup.py"
-else
-  "$top/script/setup"
-fi
-status=$?
-
-for f in "$hooks"/*; do
-  [ -e "$snap/${f##*/}" ] || rm -f "$f"
-done
-# Files are moved rather than copied so a hook that is still running, such as
-# this one, is swapped out atomically instead of being rewritten in place.
-for f in "$snap"/*; do
-  cmp -s "$f" "$hooks/${f##*/}" 2>/dev/null || mv -f "$f" "$hooks/${f##*/}"
-done
-rm -rf "$snap"
-exit $status
+exec env -u VIRTUAL_ENV "$top/script/setup"

script/helpers.py

@@ -1104,10 +1104,6 @@ def get_components_per_integration_fixture() -> dict[str, set[str]]:
 
 
 _TEST_FUNC_RE = re.compile(r"async def (test_\w+)")
-# Any usage form (decorator, pytestmark assignment or list element); only
-# test_*.py files are scanned, so the marker docs elsewhere cannot false-hit
-_SHARED_YAML_USE_RE = re.compile(r"\bmark\.shared_yaml")
-_SHARED_YAML_ARG_RE = re.compile(r"\(\s*[\"'](\w+)[\"']\s*\)")
 
 
 @cache
@@ -1127,19 +1123,6 @@ def get_fixture_to_test_files() -> dict[str, frozenset[str]]:
         for func in _TEST_FUNC_RE.findall(content):
             base_name = func.replace("test_", "").partition("[")[0]
             result.setdefault(base_name, set()).add(rel_path)
-        # Shared fixtures are named by marker, not by a test function; each
-        # decorator must carry a string literal or its fixture would silently
-        # map to no tests
-        for use in _SHARED_YAML_USE_RE.finditer(content):
-            arg = _SHARED_YAML_ARG_RE.match(content, use.end())
-            if arg is None:
-                line = content.count("\n", 0, use.start()) + 1
-                raise ValueError(
-                    f"{rel_path}:{line}: shared_yaml marker must take a "
-                    "single-line string literal so CI test selection can map "
-                    "its fixture"
-                )
-            result.setdefault(arg.group(1), set()).add(rel_path)
 
     return {k: frozenset(v) for k, v in result.items()}
 

script/setup

@@ -1,7 +1,71 @@
 #!/usr/bin/env bash
-# Set up ESPHome dev environment.
-#
-# The work is done by setup.py, which script/setup.bat also runs, so the Unix
-# and Windows entry points share one implementation.
+# Set up ESPHome dev environment
 
-exec python3 "$(dirname "$0")/setup.py" "$@"
+set -e
+
+cd "$(dirname "$0")/.."
+if [ -n "$VIRTUAL_ENV" ]; then
+  # A virtual environment is already active (e.g. the devcontainer's pre-provisioned
+  # esphome-venv). Install into it rather than creating a ./venv in the workspace.
+  venv_state=active
+elif [ -x venv/bin/python ]; then
+  # Reuse the environment from an earlier run, so this script can be run again
+  # at any time to pick up dependency changes.
+  venv_state=reused
+  source venv/bin/activate
+else
+  venv_state=created
+  # --clear replaces a partial environment left behind by an interrupted run.
+  if [ -x "$(command -v uv)" ]; then
+    uv venv --clear --seed venv
+  else
+    python3 -m venv --clear venv
+  fi
+  source venv/bin/activate
+fi
+
+if ! [ -x "$(command -v uv)" ]; then
+  python3 -m pip install uv
+fi
+
+uv pip install setuptools wheel
+uv pip install -e ".[dev,test]" --config-settings editable_mode=compat
+
+# A worktree shares one git hooks directory with the main checkout it was
+# created from, so hooks are installed from the main checkout only. Installing
+# from a worktree would point the shared hook at that worktree's virtual
+# environment, breaking it for everyone once the worktree is removed.
+git_dir="$(git rev-parse --absolute-git-dir 2>/dev/null || true)"
+common_dir="$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null || true)"
+if [ -n "$common_dir" ] && [ "$git_dir" = "$common_dir" ]; then
+  # --overwrite replaces any hook already in place. Without it, prek finds a
+  # previously installed pre-commit hook, moves it aside to
+  # .git/hooks/pre-commit.legacy and keeps calling it, so every commit would
+  # run both tools.
+  prek install --overwrite
+
+  # Prepares the virtual environment for new checkouts and worktrees. Installed
+  # once here, it covers every worktree created from this checkout.
+  if [ -d "$common_dir/hooks" ]; then
+    cp script/git-hooks/post-checkout "$common_dir/hooks/post-checkout"
+    chmod +x "$common_dir/hooks/post-checkout"
+  fi
+fi
+
+mkdir -p .temp
+
+echo
+echo
+case "$venv_state" in
+  created)
+    echo "Virtual environment created at ./venv. Run 'source venv/bin/activate' to use it."
+    ;;
+  reused)
+    echo "Dependencies updated in the existing ./venv. Run 'source venv/bin/activate' to use it."
+    ;;
+  active)
+    echo "Dependencies installed into the active virtual environment:"
+    echo "  $VIRTUAL_ENV"
+    echo "It is already active in this shell, so no 'source venv/bin/activate' is needed."
+    ;;
+esac

script/setup.bat

@@ -1 +1,28 @@
-@python "%~dp0setup.py" %*
+@echo off
+
+if defined VIRTUAL_ENV goto :install
+
+echo Starting the Virtual Environment
+python -m venv venv
+call venv/Scripts/activate
+echo Running the Virtual Environment
+
+:install
+
+echo Installing required packages...
+
+python.exe -m pip install --upgrade pip
+
+pip3 install -r requirements.txt -r requirements_test.txt -r requirements_dev.txt
+pip3 install setuptools wheel
+pip3 install -e ".[dev,test]" --config-settings editable_mode=compat
+
+rem --overwrite replaces any hook already in place. Without it, prek finds a
+rem previously installed pre-commit hook, moves it aside to
+rem .git/hooks/pre-commit.legacy and keeps calling it, so every commit would
+rem run both tools.
+prek install --overwrite
+
+echo .
+echo .
+echo Virtual environment created. Run 'venv/Scripts/activate' to use it.

script/setup.py

@@ -1,222 +0,0 @@
-#!/usr/bin/env python3
-"""Set up the ESPHome development environment.
-
-Shared implementation behind script/setup and script/setup.bat, so the Unix and
-Windows entry points cannot drift apart. Uses only the standard library: it runs
-before any dependency has been installed.
-"""
-
-import os
-from pathlib import Path
-import shutil
-import subprocess
-import sys
-import sysconfig
-
-MIN_PYTHON = (3, 12)
-
-ROOT = Path(__file__).resolve().parent.parent
-DEFAULT_VENV = ROOT / "venv"
-POST_CHECKOUT_HOOK = ROOT / "script" / "git-hooks" / "post-checkout"
-
-# State of the environment the dependencies end up in, used for the closing
-# message.
-VENV_ACTIVE = "active"
-VENV_REUSED = "reused"
-VENV_CREATED = "created"
-
-
-def bin_dir(venv: Path) -> Path:
-    """Return the directory holding a virtual environment's executables.
-
-    The "venv" scheme resolves to bin on Unix and Scripts on Windows, so the
-    layout does not have to be hardcoded here.
-    """
-    base = str(venv)
-    return Path(
-        sysconfig.get_path("scripts", "venv", vars={"base": base, "platbase": base})
-    )
-
-
-def venv_python(venv: Path) -> Path:
-    """Return the path to a virtual environment's interpreter."""
-    name = "python.exe" if os.name == "nt" else "python"
-    return bin_dir(venv) / name
-
-
-def run(command: list[str], env: dict[str, str] | None = None) -> None:
-    """Run a command, aborting the whole script if it fails."""
-    print(f"+ {' '.join(command)}", flush=True)
-    result = subprocess.run(command, cwd=ROOT, env=env, check=False)
-    if result.returncode != 0:
-        # Some tools fail without printing anything, so name the step that broke.
-        print(
-            f"Failed with exit code {result.returncode}: {command[0]}", file=sys.stderr
-        )
-        raise SystemExit(result.returncode)
-
-
-def git_output(*args: str) -> str:
-    """Return the trimmed output of a git command, or "" if it cannot be run."""
-    try:
-        result = subprocess.run(
-            ["git", *args], cwd=ROOT, capture_output=True, text=True, check=False
-        )
-    except OSError:
-        # Git is not required to install the dependencies, only to install hooks.
-        return ""
-    if result.returncode != 0:
-        return ""
-    return result.stdout.strip()
-
-
-def create_venv(venv: Path) -> None:
-    """Create a virtual environment, replacing anything already at the path."""
-    # --clear replaces a partial environment left behind by an interrupted run.
-    if (uv := shutil.which("uv")) is not None:
-        run([uv, "venv", "--clear", "--seed", str(venv)])
-    else:
-        run([sys.executable, "-m", "venv", "--clear", str(venv)])
-
-
-def venv_environment(venv: Path) -> dict[str, str]:
-    """Return the environment child processes need to target a virtual env.
-
-    Equivalent to sourcing the environment's activate script: tools such as uv
-    and prek pick the environment up from VIRTUAL_ENV and PATH.
-    """
-    env = dict(os.environ)
-    env["VIRTUAL_ENV"] = str(venv)
-    env.pop("PYTHONHOME", None)
-    path = str(bin_dir(venv))
-    # An empty entry would be appended if PATH is unset, and on Unix that means
-    # the working directory is searched for executables.
-    if existing := env.get("PATH"):
-        path = os.pathsep.join([path, existing])
-    env["PATH"] = path
-    return env
-
-
-def find_uv(venv: Path, env: dict[str, str]) -> str:
-    """Return the path to uv, installing it into the environment if needed."""
-    if (uv := shutil.which("uv", path=env["PATH"])) is not None:
-        return uv
-    run([str(venv_python(venv)), "-m", "pip", "install", "uv"], env=env)
-    if (uv := shutil.which("uv", path=env["PATH"])) is not None:
-        return uv
-    raise SystemExit("uv could not be installed, aborting.")
-
-
-def install_dependencies(venv: Path, env: dict[str, str]) -> None:
-    """Install ESPHome and its development dependencies into the environment."""
-    uv = find_uv(venv, env)
-    run([uv, "pip", "install", "setuptools", "wheel"], env=env)
-    # The dev and test extras pull in requirements_dev.txt and
-    # requirements_test.txt, and the package itself pulls in requirements.txt,
-    # so this single install covers every requirements file.
-    run(
-        [
-            uv,
-            "pip",
-            "install",
-            "-e",
-            ".[dev,test]",
-            "--config-settings",
-            "editable_mode=compat",
-        ],
-        env=env,
-    )
-
-
-def install_git_hooks(env: dict[str, str]) -> None:
-    """Install the git hooks, but only when run from the main checkout.
-
-    A worktree shares one git hooks directory with the main checkout it was
-    created from. Installing from a worktree would point the shared hook at that
-    worktree's virtual environment, breaking it for everyone once the worktree is
-    removed.
-    """
-    git_dir = git_output("rev-parse", "--absolute-git-dir")
-    common_dir = git_output("rev-parse", "--path-format=absolute", "--git-common-dir")
-    if not git_dir or not common_dir or Path(git_dir) != Path(common_dir):
-        return
-
-    prek = shutil.which("prek", path=env["PATH"])
-    if prek is None:
-        raise SystemExit("prek was not installed, aborting.")
-    # --overwrite replaces any hook already in place. Without it, prek finds a
-    # previously installed pre-commit hook, moves it aside to
-    # .git/hooks/pre-commit.legacy and keeps calling it, so every commit would
-    # run both tools.
-    run([prek, "install", "--overwrite"], env=env)
-
-    # Prepares the virtual environment for new checkouts and worktrees. Installed
-    # once here, it covers every worktree created from this checkout.
-    hooks_dir = Path(common_dir) / "hooks"
-    if hooks_dir.is_dir():
-        installed = hooks_dir / "post-checkout"
-        shutil.copyfile(POST_CHECKOUT_HOOK, installed)
-        installed.chmod(0o755)
-
-
-def activate_hint() -> str:
-    """Return the command that activates the environment this script creates."""
-    activate = bin_dir(DEFAULT_VENV).relative_to(ROOT) / "activate"
-    if os.name == "nt":
-        return str(activate)
-    return f"source {activate.as_posix()}"
-
-
-def report(state: str, venv: Path) -> None:
-    """Print the closing message for the environment that was set up."""
-    location = f"./{DEFAULT_VENV.name}"
-    print()
-    print()
-    if state == VENV_ACTIVE:
-        print("Dependencies installed into the active virtual environment:")
-        print(f"  {venv}")
-        print(
-            f"It is already active in this shell, so no '{activate_hint()}' is needed."
-        )
-    elif state == VENV_REUSED:
-        print(
-            f"Dependencies updated in the existing {location}. "
-            f"Run '{activate_hint()}' to use it."
-        )
-    else:
-        print(
-            f"Virtual environment created at {location}. "
-            f"Run '{activate_hint()}' to use it."
-        )
-
-
-def main() -> None:
-    """Set up the development environment."""
-    if sys.version_info < MIN_PYTHON:
-        raise SystemExit(
-            f"ESPHome needs Python {MIN_PYTHON[0]}.{MIN_PYTHON[1]} or newer, "
-            f"but this is Python {sys.version.split()[0]}."
-        )
-
-    # A virtual environment that is already active (for example the
-    # devcontainer's pre-provisioned esphome-venv) is installed into rather than
-    # creating a ./venv in the workspace.
-    if active := os.environ.get("VIRTUAL_ENV"):
-        state, venv = VENV_ACTIVE, Path(active)
-    elif venv_python(DEFAULT_VENV).is_file():
-        # Reuse the environment from an earlier run, so this script can be run
-        # again at any time to pick up dependency changes.
-        state, venv = VENV_REUSED, DEFAULT_VENV
-    else:
-        state, venv = VENV_CREATED, DEFAULT_VENV
-        create_venv(venv)
-
-    env = venv_environment(venv)
-    install_dependencies(venv, env)
-    install_git_hooks(env)
-    (ROOT / ".temp").mkdir(exist_ok=True)
-    report(state, venv)
-
-
-if __name__ == "__main__":
-    main()

script/sync_dependency_versions.py

@@ -1,164 +0,0 @@
-#!/usr/bin/env python3
-"""Keep pre-commit hook revs in sync with the requirements files.
-
-Dependabot only bumps the ``package==version`` pins in ``requirements*.txt``.
-Some of those tools are pinned a second time as hook ``rev`` values in
-``.pre-commit-config.yaml``. This script treats the requirements files as
-the source of truth and rewrites the revs to match, editing the config
-through yamlrocks so comments and layout survive.
-
-Run without arguments to apply the changes in place, or with ``--check`` to
-only report drift (exit status 1 when anything is out of sync).
-"""
-
-from __future__ import annotations
-
-import argparse
-from dataclasses import dataclass
-from pathlib import Path
-import re
-import sys
-from typing import Any
-
-import yamlrocks
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-PRECOMMIT_CONFIG = ".pre-commit-config.yaml"
-
-
-class SyncError(Exception):
-    """A pin could not be located in a requirements file or the config."""
-
-
-@dataclass(frozen=True)
-class SyncTarget:
-    """A requirements pin and the pre-commit repo whose rev mirrors it."""
-
-    package: str
-    requirements_file: str
-    repo: str
-
-
-SYNC_TARGETS: tuple[SyncTarget, ...] = (
-    SyncTarget(
-        "ruff", "requirements_test.txt", "https://github.com/astral-sh/ruff-pre-commit"
-    ),
-    SyncTarget("flake8", "requirements_test.txt", "https://github.com/PyCQA/flake8"),
-    SyncTarget(
-        "pyupgrade", "requirements_test.txt", "https://github.com/asottile/pyupgrade"
-    ),
-    SyncTarget(
-        "clang-format",
-        "requirements_dev.txt",
-        "https://github.com/pre-commit/mirrors-clang-format",
-    ),
-    SyncTarget(
-        "yamllint",
-        "requirements_dev.txt",
-        "https://github.com/adrienverge/yamllint.git",
-    ),
-)
-
-
-def read_requirement_version(requirements: str, package: str) -> str | None:
-    """Return the ``==`` pin for ``package`` or None when it is not pinned."""
-    pattern = re.compile(
-        rf"^{re.escape(package)}==(?P<version>[^\s#]+)",
-        re.MULTILINE | re.IGNORECASE,
-    )
-    match = pattern.search(requirements)
-    return match.group("version") if match else None
-
-
-def find_repo_entry(doc: Any, repo: str) -> Any:
-    """Return the single ``- repo:`` block for ``repo`` in a pre-commit doc."""
-    try:
-        entries = [entry for entry in doc["repos"] if entry["repo"] == repo]
-    except KeyError as err:
-        raise SyncError(f"malformed pre-commit config, missing key {err}") from None
-    if len(entries) != 1:
-        raise SyncError(
-            f"expected exactly one block for repo {repo}, found {len(entries)}"
-        )
-    return entries[0]
-
-
-def current_rev(entry: Any, repo: str) -> tuple[str, str]:
-    """Split the block's rev into its tag prefix (``v`` or empty) and version."""
-    if "rev" not in entry:
-        raise SyncError(f"repo {repo} has no rev")
-    rev = entry["rev"]
-    if not isinstance(rev, str):
-        # A rev such as ``1.0`` parses as a number and cannot be compared or
-        # rewritten safely; quote it in the config instead.
-        raise SyncError(f"rev of repo {repo} is not a string: {rev!r}")
-    prefix = "v" if rev.startswith("v") else ""
-    return prefix, rev.removeprefix("v")
-
-
-def sync(root: Path, *, write: bool) -> list[str]:
-    """Bring every hook rev in line with its requirements pin.
-
-    Returns one description per rev that was (or, when ``write`` is False,
-    would be) changed. Raises SyncError when a pin cannot be found, which
-    means SYNC_TARGETS has gone stale and needs updating by hand.
-    """
-    config_path = root / PRECOMMIT_CONFIG
-    doc = yamlrocks.loads(config_path.read_bytes(), option=yamlrocks.OPT_ROUND_TRIP)
-    requirements: dict[str, str] = {}
-    changes: list[str] = []
-    for target in SYNC_TARGETS:
-        if target.requirements_file not in requirements:
-            requirements[target.requirements_file] = (
-                root / target.requirements_file
-            ).read_text()
-        version = read_requirement_version(
-            requirements[target.requirements_file], target.package
-        )
-        if version is None:
-            raise SyncError(
-                f"{target.requirements_file}: no '{target.package}==' pin found"
-            )
-
-        entry = find_repo_entry(doc, target.repo)
-        prefix, current = current_rev(entry, target.repo)
-        if current == version:
-            continue
-        changes.append(f"{target.package}: {current} -> {version}")
-        entry["rev"] = f"{prefix}{version}"
-
-    if changes and write:
-        config_path.write_bytes(doc.to_yaml())
-    return changes
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    parser.add_argument(
-        "--check",
-        action="store_true",
-        help="report drift without modifying any file; exit 1 if out of sync",
-    )
-    parser.add_argument(
-        "--root",
-        type=Path,
-        default=REPO_ROOT,
-        help="repository checkout to operate on (default: this checkout)",
-    )
-    args = parser.parse_args(argv)
-
-    try:
-        changes = sync(args.root, write=not args.check)
-    except SyncError as err:
-        print(f"error: {err}", file=sys.stderr)
-        return 1
-
-    for change in changes:
-        print(change)
-    if args.check and changes:
-        return 1
-    return 0
-
-
-if __name__ == "__main__":  # pragma: no cover
-    sys.exit(main())

sdkconfig.defaults

@@ -17,8 +17,6 @@ CONFIG_ESP_TASK_WDT_INIT=y
 CONFIG_ESP_TASK_WDT_PANIC=y
 CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0=n
 CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1=n
-CONFIG_FREERTOS_USE_TICKLESS_IDLE=y
-CONFIG_PM_ENABLE=y
 
 # esp32_ble
 CONFIG_BT_ENABLED=y

tests/benchmarks/components/api/bench_proto_proxy.cpp

@@ -249,7 +249,7 @@ static APIBuffer build_infrared_rf_transmit_wire() {
   std::memcpy(bytes + len, packed, packed_len);
   len += packed_len;
   // field 6: modulation = 1 (non-zero so it's actually emitted and exercises
-  // decode_varint for this field, matching the documented layout above).
+  // decode_field for this field, matching the documented layout above).
   put_byte(0x30);
   put_varint(1);