[mlx90614] pec validation (#6689 )

Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com> Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
[network] Improve network::is_connected() to better handle multiple interfaces (#18999 )
2026-09-10 06:48:45 +00:00 · 2026-09-10 16:14:43 +12:00 · 2026-09-10 04:06:44 +00:00 · 2026-09-10 14:11:13 +12:00 · 2026-09-10 14:09:58 +12:00 · 2026-09-10 14:09:49 +12:00
118 changed files with 3866 additions and 1820 deletions
@@ -244,11 +244,20 @@ jobs:
    steps:
      - name: Check out code from GitHub
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
      - name: Read prek version from requirements_test.txt
        id: prek
        # requirements_test.txt is the only place the version is pinned, so a
        # Dependabot bump there is picked up here without a second edit.
        run: |
          if ! version=$(sed -nE 's/^prek==([^[:space:]#]+).*/\1/p' requirements_test.txt) || [ -z "$version" ]; then
            echo "::error::No prek== pin found in requirements_test.txt."
            exit 1
          fi
          echo "version=$version" >> "$GITHUB_OUTPUT"
      - name: Run prek
        uses: j178/prek-action@4e14d07f9231acabce116ccfca13b13dd9755ece # v3.0.0
        with:
-          # Keep in sync with requirements_test.txt.
+          prek-version: ${{ steps.prek.outputs.version }}
          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
@@ -33,7 +33,7 @@ jobs:
        and will be closed if no further activity occurs within 7 days.
        If you are the author of this PR, please leave a comment if you want
-        to keep it open. Also, please rebase your PR onto the latest dev
+        to keep it open. Also, please merge the latest dev branch into your
        branch to ensure that it's up to date with the latest changes.
        Thank you for your contribution!
@@ -0,0 +1,94 @@
 # Keeps pre-commit hook revs in sync with the requirements files.
 #
 # Dependabot only bumps the pins in requirements*.txt. Some of those tools
 # are pinned again as hook revs in .pre-commit-config.yaml. This workflow
 # runs script/sync_dependency_versions.py against the pull request branch
 # and pushes a commit with the revs updated.
 name: Sync dependency versions
 on:
  # pull_request_target rather than pull_request so the App secret is
  # available on Dependabot pull requests (pull_request runs opened by
  # Dependabot only see Dependabot secrets). The job below only touches
  # branches in this repository and only ever executes the script from the
  # base branch checkout, so fork code never runs with the token.
  pull_request_target:
    types: [opened, synchronize, reopened]
    paths:
      - requirements_dev.txt
      - requirements_test.txt
      - .pre-commit-config.yaml
      - script/sync_dependency_versions.py
 # The push to the pull request branch uses the App token minted below, so
 # the workflow's GITHUB_TOKEN does not need any scopes.
 permissions: {}
 concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
  cancel-in-progress: true
 jobs:
  sync:
    name: Sync pinned versions
    runs-on: ubuntu-latest
    # Same-repository branches only: a push to a fork is not possible with
    # this token, and it keeps untrusted heads out of a privileged job.
    if: >-
      github.repository == 'esphome/esphome'
      && github.event.pull_request.head.repo.full_name == github.repository
    steps:
      - name: Generate a token
        id: generate-token
        uses: actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1 # v3.2.0
        with:
          client-id: ${{ vars.ESPHOME_GITHUB_APP_CLIENT_ID }}
          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
          # A push made with the workflow's own GITHUB_TOKEN would not start
          # CI on the new commit; a push with the App token does.
          permission-contents: write  # git push of the sync commit to the pull request branch
      - name: Check out base branch
        # Provides the script that runs below. Deliberately the base branch
        # so the pull request cannot change what executes here.
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          ref: ${{ github.event.pull_request.base.sha }}
          persist-credentials: false
      - name: Check out pull request branch
        # No allow-unsafe-pr-checkout here on purpose: checkout v7 only
        # refuses heads that live in a different repository, and the job
        # condition above already limits runs to same-repository branches.
        # Leaving it off keeps that refusal as a backstop for fork heads.
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          ref: ${{ github.event.pull_request.head.ref }}
          path: pull-request
          token: ${{ steps.generate-token.outputs.token }}
      - name: Set up Python
        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
        with:
          python-version: "3.12"
      - name: Install yamlrocks
        # The script edits YAML through yamlrocks. Take the pin from the
        # base branch requirements so this workflow has no copy of its own.
        run: pip install "$(grep -E '^yamlrocks==' requirements_test.txt | cut -d'#' -f1)"
      - name: Sync pinned versions
        run: python script/sync_dependency_versions.py --root pull-request
      - name: Push changes
        working-directory: pull-request
        run: |
          if git diff --quiet; then
            echo "All pinned versions already match the requirements files."
            exit 0
          fi
          git config user.name "esphome[bot]"
          git config user.email "115708604+esphome[bot]@users.noreply.github.com"
          git commit -am "Sync pinned tool versions with requirements files"
          git push
@@ -1,7 +1,6 @@
 ---
 # See https://pre-commit.com for more information
 # See https://pre-commit.com/hooks.html for more hooks
 ci:
  autoupdate_commit_msg: 'pre-commit: autoupdate'
  autoupdate_schedule: off  # Disabled until ruff versions are synced between deps and pre-commit
@@ -11,7 +10,7 @@ ci:
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    # Ruff version.
-    rev: v0.16.3
+    rev: v0.16.6
    hooks:
      # Run the linter.
      - id: ruff
@@ -42,7 +41,7 @@ repos:
      - id: pyupgrade
        args: [--py312-plus]
  - repo: https://github.com/adrienverge/yamllint.git
-    rev: v1.37.1
+    rev: v1.38.0
    hooks:
      - id: yamllint
        exclude: ^(\.clang-format|\.clang-tidy)$
@@ -553,6 +553,7 @@ file does, and it is the authority when they disagree. The most useful starting
    4.  **Lint:** Run `prek` to ensure code is compliant.
    5.  **Commit:** Commit your changes. There is no strict format for commit messages.
    6.  **Pull Request:** Submit a PR against the `dev` branch. The Pull Request title must start with a `[tag]` prefix. For component work, use the component name (e.g., `[display] Fix bug`, `[abc123] Add new component`); for changes to shared/core code that isn't tied to a single component, use `[core]` (e.g., `[core] Add validator`). Update documentation, examples, and add `CODEOWNERS` entries as needed. Pull requests should always be made using the `.github/PULL_REQUEST_TEMPLATE.md` template - fill out all sections completely without removing any parts of the template.
    7.  **Comments:** When commenting on GitHub PRs or issues, don't tag contributors, especially bots. Avoid referring to list items (e.g. from reviews) with the form #nn - this will be interpreted by GitHub as a reference to issue or PR nn. Keep comments short and exclude irrelevant details, backstories, restatement of previous comments and anything that is already obvious to the reader.
 *   **Documentation Contributions:**
    *   Documentation is hosted in the separate `esphome/esphome.io` repository.
@@ -839,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:
@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
-PROJECT_NUMBER         = 2026.9.0b2
+PROJECT_NUMBER         = 2026.10.0-dev
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -22,7 +22,7 @@ RUN \
    -r /requirements.txt
 # Install the ESPHome Device Builder dashboard.
-RUN uv pip install --no-cache-dir esphome-device-builder==1.14.4
+RUN uv pip install --no-cache-dir esphome-device-builder==1.14.5
 RUN \
    platformio settings set enable_telemetry No \
@@ -23,9 +23,7 @@ from esphome.util import safe_print
 if TYPE_CHECKING:
    from collections.abc import Callable
-    from aioesphomeapi.api_pb2 import (
+    from aioesphomeapi.api_pb2 import SubscribeLogsResponse  # pylint: disable=no-name-in-module
        SubscribeLogsResponse,  # pylint: disable=no-name-in-module
    )
 _LOGGER = logging.getLogger(__name__)
@@ -13,7 +13,7 @@ void Anova::dump_config() { LOG_CLIMATE("", "Anova BLE Cooker", this); }
 void Anova::setup() {
  this->codec_ = make_unique<AnovaCodec>();
-  this->current_request_ = 0;
+  this->poll_step_ = PollStep::IDLE;
 }
 void Anova::loop() {
@@ -22,6 +22,15 @@ 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()) {
@@ -38,22 +47,11 @@ void Anova::control(const ClimateCall &call) {
        ESP_LOGW(TAG, "Unsupported mode: %d", mode);
        return;
    }
-    auto status =
+    this->write_request_(pkt);
        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()) {
-    auto *pkt = this->codec_->get_set_target_temp_request(*target_temp);
+    this->write_request_(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);
    }
  }
 }
@@ -62,6 +60,7 @@ 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;
    }
@@ -83,8 +82,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->current_request_ = 0;
+      this->poll_step_ = PollStep::IDLE;
-      this->update();
+      this->update();  // begin the first poll cycle immediately
      break;
    }
    case ESP_GATTC_NOTIFY_EVT: {
@@ -101,33 +100,30 @@ 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()) {
-        this->fahrenheit_ = (this->codec_->unit_ == 'f');
+        ESP_LOGD(TAG, "Anova units is %s", (this->codec_->unit_ == 'f') ? "fahrenheit" : "celsius");
        ESP_LOGD(TAG, "Anova units is %s", this->fahrenheit_ ? "fahrenheit" : "celsius");
        this->current_request_++;
      }
      this->publish_state();
-      if (this->current_request_ > 1) {
+      // Advance the poll cycle to its next request based on the reply we got.
-        AnovaPacket *pkt = nullptr;
+      switch (this->poll_step_) {
-        switch (this->current_request_++) {
+        case PollStep::SET_UNIT:
-          case 2:
+          this->poll_step_ = PollStep::STATUS;
-            pkt = this->codec_->get_read_target_temp_request();
+          this->write_request_(this->codec_->get_read_device_status_request());
-            break;
+          break;
-          case 3:
+        case PollStep::STATUS:
-            pkt = this->codec_->get_read_current_temp_request();
+          this->poll_step_ = PollStep::TARGET;
-            break;
+          this->write_request_(this->codec_->get_read_target_temp_request());
-          default:
+          break;
-            this->current_request_ = 1;
+        case PollStep::TARGET:
-            break;
+          this->poll_step_ = PollStep::CURRENT;
-        }
+          this->write_request_(this->codec_->get_read_current_temp_request());
-        if (pkt != nullptr) {
+          break;
-          auto status =
+        case PollStep::CURRENT:
-              esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
+          this->poll_step_ = PollStep::IDLE;  // full cycle complete
-                                       pkt->length, pkt->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+          break;
-          if (status) {
+        default:
-            ESP_LOGW(TAG, "[%s] esp_ble_gattc_write_char failed, status=%d", this->parent_->address_str(), status);
+          // A reply to an ad-hoc control() write, outside a managed cycle.
-          }
+          break;
        }
      }
      break;
    }
@@ -136,27 +132,26 @@ 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->fahrenheit_ = !strncmp(unit, "f", 1); }
+void Anova::set_unit_of_measurement(const char *unit) { this->want_fahrenheit_ = !strncmp(unit, "f", 1); }
 void Anova::update() {
  if (this->node_state != espbt::ClientState::ESTABLISHED)
    return;
-
+  if (this->poll_step_ != PollStep::IDLE) {
-  if (this->current_request_ < 2) {
+    // The previous cycle never finished within a full polling interval -- a
-    AnovaPacket *pkt;
+    // reply was missed or a write failed. Restart the cycle rather than stall;
-    if (this->current_request_ == 0) {
+    // the polling interval itself acts as the timeout. A late reply from the
-      pkt = this->codec_->get_set_unit_request(this->fahrenheit_ ? 'f' : 'c');
+    // abandoned cycle is harmless: state decoding happens on every notify
-    } else {
+    // regardless of step, and each notify sends at most one follow-up request.
-      pkt = this->codec_->get_read_device_status_request();
+    ESP_LOGW(TAG, "[%s] Poll cycle incomplete (step %u); restarting cycle", this->parent_->address_str(),
-    }
+             static_cast<uint8_t>(this->poll_step_));
    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
@@ -37,11 +37,20 @@ 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_;
-  uint8_t current_request_;
+  bool want_fahrenheit_{true};  // configured target unit; never overwritten by device replies
-  bool fahrenheit_;
+  PollStep poll_step_{PollStep::IDLE};
 };
 }  // namespace esphome::anova
@@ -9,6 +9,10 @@ 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);
@@ -203,13 +207,12 @@ 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<PowerOffsetCalibration[3]>(po_hash, true);
+    this->power_offset_pref_ = global_preferences->make_preference<OffsetCalibration[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 =
+      auto legacy_power_offset_pref = global_preferences->make_preference<OffsetCalibration[3]>(legacy_po_hash, true);
-          global_preferences->make_preference<PowerOffsetCalibration[3]>(legacy_po_hash, true);
+      OffsetCalibration power_offset_data[3]{};
      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;
@@ -224,20 +227,20 @@ void ATM90E32Component::setup() {
      global_preferences->sync();
    }
-    this->restore_offset_calibrations_();
+    this->restore_offset_calibrations_(OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_VOLTAGE_CURRENT);
-    this->restore_power_offset_calibrations_();
+    this->restore_offset_calibrations_(OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER);
  } 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].voltage_offset_));
+                     static_cast<uint16_t>(this->offset_phase_[phase].first_offset));
      this->write16_(this->current_offset_registers[phase],
-                     static_cast<uint16_t>(this->offset_phase_[phase].current_offset_));
+                     static_cast<uint16_t>(this->offset_phase_[phase].second_offset));
      this->write16_(this->power_offset_registers[phase],
-                     static_cast<uint16_t>(this->power_offset_phase_[phase].active_power_offset));
+                     static_cast<uint16_t>(this->power_offset_phase_[phase].first_offset));
      this->write16_(this->reactive_power_offset_registers[phase],
-                     static_cast<uint16_t>(this->power_offset_phase_[phase].reactive_power_offset));
+                     static_cast<uint16_t>(this->power_offset_phase_[phase].second_offset));
    }
  }
@@ -317,8 +320,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].voltage_offset_, this->offset_phase_[phase].voltage_offset_,
+               this->config_offset_phase_[phase].first_offset, this->offset_phase_[phase].first_offset,
-               this->config_offset_phase_[phase].current_offset_, this->offset_phase_[phase].current_offset_);
+               this->config_offset_phase_[phase].second_offset, this->offset_phase_[phase].second_offset);
    }
    ESP_LOGW(TAG,
             "[CALIBRATION][%s] ===============================================================================", cs);
@@ -335,10 +338,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_power_offset_phase_[phase].active_power_offset,
+               this->config_power_offset_phase_[phase].first_offset, this->power_offset_phase_[phase].first_offset,
-               this->power_offset_phase_[phase].active_power_offset,
+               this->config_power_offset_phase_[phase].second_offset, this->power_offset_phase_[phase].second_offset);
               this->config_power_offset_phase_[phase].reactive_power_offset,
               this->power_offset_phase_[phase].reactive_power_offset);
    }
    ESP_LOGW(TAG,
             "[CALIBRATION][%s] ===============================================================================", cs);
@@ -372,7 +373,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].voltage_offset_, this->offset_phase_[phase].current_offset_);
+               this->offset_phase_[phase].first_offset, this->offset_phase_[phase].second_offset);
    }
    ESP_LOGI(TAG, "[CALIBRATION][%s] ==============================================================\\n", cs);
  }
@@ -385,8 +386,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->power_offset_phase_[phase].active_power_offset,
+               this->power_offset_phase_[phase].first_offset, this->power_offset_phase_[phase].second_offset);
               this->power_offset_phase_[phase].reactive_power_offset);
    }
    ESP_LOGI(TAG, "[CALIBRATION][%s] =====================================================================\n", cs);
  }
@@ -756,36 +756,68 @@ void ATM90E32Component::save_gain_calibration_to_memory_() {
  }
 }
-void ATM90E32Component::save_offset_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;
  const char *cs = this->get_calibration_id_();
-  bool success = this->offset_pref_.save(&this->offset_phase_);
+  const LogString *name = offset_calibration_name(power_offsets);
-  global_preferences->sync();
+  OffsetCalibration(*offsets)[3] = power_offsets ? &this->power_offset_phase_ : &this->offset_phase_;
-  if (success) {
+  ESPPreferenceObject *preference = power_offsets ? &this->power_offset_pref_ : &this->offset_pref_;
-    this->using_saved_calibrations_ = true;
+  bool *has_stored =
-    this->restored_offset_calibration_ = true;
+      power_offsets ? &this->has_stored_power_offset_calibration_ : &this->has_stored_offset_calibration_;
-    for (bool &phase : this->offset_calibration_mismatch_)
+  bool *restored = power_offsets ? &this->restored_power_offset_calibration_ : &this->restored_offset_calibration_;
-      phase = false;
+  bool *mismatches = power_offsets ? this->power_offset_calibration_mismatch_ : this->offset_calibration_mismatch_;
    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);
  }
 }
-void ATM90E32Component::save_power_offset_calibration_to_memory_() {
+  const bool writes_verified = this->verify_offset_writes_(type);
-  const char *cs = this->get_calibration_id_();
+  bool saved = false;
-  bool success = this->power_offset_pref_.save(&this->power_offset_phase_);
+  bool synced = false;
-  global_preferences->sync();
+  if (writes_verified) {
-  if (success) {
+    saved = preference->save(offsets);
-    this->using_saved_calibrations_ = true;
+    synced = global_preferences->sync();
    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);
  }
  if (writes_verified && saved && synced) {
    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;
  }
  if (writes_verified) {
    ESP_LOGE(TAG, "[CALIBRATION][%s] Failed to save %s calibration to memory!", cs, LOG_STR_ARG(name));
  }
  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() {
@@ -803,11 +835,16 @@ 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);
+    this->write_offsets_to_registers_(phase, voltage_offset, current_offset,
                                      OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_VOLTAGE_CURRENT);
    ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |     %6d      |     %6d      |", cs, 'A' + phase, voltage_offset,
             current_offset);
@@ -815,7 +852,8 @@ void ATM90E32Component::run_offset_calibrations() {
  ESP_LOGI(TAG, "[CALIBRATION][%s] ==================================================================\n", cs);
-  this->save_offset_calibration_to_memory_();
+  this->finish_offset_calibration_(previous_offsets, previous_restored, previous_using_saved,
                                   OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_VOLTAGE_CURRENT);
 }
 void ATM90E32Component::run_power_offset_calibrations() {
@@ -834,18 +872,25 @@ 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_power_offsets_to_registers_(phase, active_offset, reactive_offset);
+    this->write_offsets_to_registers_(phase, active_offset, reactive_offset,
                                      OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER);
    ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |       %6d        |        %6d        |", cs, 'A' + phase, active_offset,
             reactive_offset);
  }
  ESP_LOGI(TAG, "[CALIBRATION][%s] =====================================================================\n", cs);
-  this->save_power_offset_calibration_to_memory_();
+  this->finish_offset_calibration_(previous_offsets, previous_restored, previous_using_saved,
                                   OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER);
 }
 void ATM90E32Component::write_gains_to_registers_() {
@@ -859,35 +904,26 @@ void ATM90E32Component::write_gains_to_registers_() {
  this->write16_(ATM90E32_REGISTER_CFGREGACCEN, 0x0000);
 }
-void ATM90E32Component::write_offsets_to_registers_(uint8_t phase, int16_t voltage_offset, int16_t current_offset) {
+void ATM90E32Component::write_offsets_to_registers_(uint8_t phase, int16_t first_offset, int16_t second_offset,
-  // Save to runtime
+                                                    OffsetCalibrationType type) {
-  this->offset_phase_[phase].voltage_offset_ = voltage_offset;
+  const bool power_offsets = type == OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER;
-  this->phase_[phase].voltage_offset_ = voltage_offset;
+  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;
  }
-  // Save to flash-storable struct
+  const uint16_t *first_registers = power_offsets ? this->power_offset_registers : this->voltage_offset_registers;
-  this->offset_phase_[phase].current_offset_ = current_offset;
+  const uint16_t *second_registers =
-  this->phase_[phase].current_offset_ = current_offset;
+      power_offsets ? this->reactive_power_offset_registers : this->current_offset_registers;
  // Write to registers
  this->write16_(ATM90E32_REGISTER_CFGREGACCEN, 0x55AA);
-  this->write16_(voltage_offset_registers[phase], static_cast<uint16_t>(voltage_offset));
+  this->write16_(first_registers[phase], static_cast<uint16_t>(first_offset));
-  this->write16_(current_offset_registers[phase], static_cast<uint16_t>(current_offset));
+  this->write16_(second_registers[phase], static_cast<uint16_t>(second_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);
 }
@@ -947,89 +983,78 @@ 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_() {
+void ATM90E32Component::restore_offset_calibrations_(OffsetCalibrationType type) {
  const bool power_offsets = type == OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER;
  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)
-    this->config_offset_phase_[i] = this->offset_phase_[i];
+    (*config_offsets)[i] = (*offsets)[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 (auto &phase : this->offset_phase_) {
+    for (const auto &phase : *offsets) {
-      if (phase.voltage_offset_ != 0 || phase.current_offset_ != 0) {
+      if (phase.first_offset != 0 || phase.second_offset != 0) {
        all_zero = false;
        break;
      }
    }
  }
-  if (have_data && !all_zero) {
+  *has_stored = have_data && !all_zero;
-    this->restored_offset_calibration_ = true;
+  *restored = false;
-    for (uint8_t phase = 0; phase < 3; phase++) {
+  for (uint8_t phase = 0; phase < 3; phase++) {
-      auto &offset = this->offset_phase_[phase];
+    mismatches[phase] = false;
-      bool mismatch = false;
+    if (*has_stored) {
-      if (this->has_config_voltage_offset_[phase] &&
+      mismatches[phase] =
-          offset.voltage_offset_ != this->config_offset_phase_[phase].voltage_offset_)
+          (has_first[phase] && (*offsets)[phase].first_offset != (*config_offsets)[phase].first_offset) ||
-        mismatch = true;
+          (has_second[phase] && (*offsets)[phase].second_offset != (*config_offsets)[phase].second_offset);
      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 {
+  }
  if (!*has_stored) {
    for (uint8_t phase = 0; phase < 3; phase++)
-      this->offset_phase_[phase] = this->config_offset_phase_[phase];
+      (*offsets)[phase] = (*config_offsets)[phase];
-    ESP_LOGW(TAG, "[CALIBRATION][%s] No stored offset calibrations found. Using default values.", cs);
+    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++) {
-    write_offsets_to_registers_(phase, this->offset_phase_[phase].voltage_offset_,
+    this->write_offsets_to_registers_(phase, (*offsets)[phase].first_offset, (*offsets)[phase].second_offset, type);
                                this->offset_phase_[phase].current_offset_);
  }
-}
+  const bool initial_values_verified = this->verify_offset_writes_(type);
-
+  if (initial_values_verified) {
-void ATM90E32Component::restore_power_offset_calibrations_() {
+    const auto state = resolve_offset_restore_state(*has_stored, true, false);
-  const char *cs = this->get_calibration_id_();
+    *restored = state.restored;
-  for (uint8_t i = 0; i < 3; ++i)
+    ESP_LOGI(TAG, "[CALIBRATION][%s] %s calibration values verified.", cs, LOG_STR_ARG(name));
-    this->config_power_offset_phase_[i] = this->power_offset_phase_[i];
+    return;
  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 (have_data && !all_zero) {
+  this->using_saved_calibrations_ = false;
-    this->restored_power_offset_calibration_ = true;
+  for (uint8_t phase = 0; phase < 3; phase++)
-    for (uint8_t phase = 0; phase < 3; ++phase) {
+    mismatches[phase] = false;
-      auto &offset = this->power_offset_phase_[phase];
+  for (uint8_t phase = 0; phase < 3; phase++) {
-      bool mismatch = false;
+    (*offsets)[phase] = (*config_offsets)[phase];
-      if (this->has_config_active_power_offset_[phase] &&
+    this->write_offsets_to_registers_(phase, (*offsets)[phase].first_offset, (*offsets)[phase].second_offset, type);
-          offset.active_power_offset != this->config_power_offset_phase_[phase].active_power_offset)
+  }
-        mismatch = true;
+  const auto state = resolve_offset_restore_state(*has_stored, false, this->verify_offset_writes_(type));
-      if (this->has_config_reactive_power_offset_[phase] &&
+  *restored = state.restored;
-          offset.reactive_power_offset != this->config_power_offset_phase_[phase].reactive_power_offset)
+  if (state.values_verified) {
-        mismatch = true;
+    ESP_LOGE(TAG, "[CALIBRATION][%s] %s calibration restore failed verification; config values verified.", cs,
-      if (mismatch)
+             LOG_STR_ARG(name));
        this->power_offset_calibration_mismatch_[phase] = true;
    }
  } else {
-    for (uint8_t phase = 0; phase < 3; ++phase)
+    ESP_LOGE(TAG, "[CALIBRATION][%s] %s calibration restore and config fallback both failed verification.", cs,
-      this->power_offset_phase_[phase] = this->config_power_offset_phase_[phase];
+             LOG_STR_ARG(name));
    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);
  }
 }
@@ -1084,14 +1109,14 @@ void ATM90E32Component::clear_gain_calibrations() {
 void ATM90E32Component::clear_offset_calibrations() {
  const char *cs = this->get_calibration_id_();
-  if (!this->restored_offset_calibration_) {
+  if (!this->has_stored_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].voltage_offset_, this->offset_phase_[phase].current_offset_);
+               this->offset_phase_[phase].first_offset, this->offset_phase_[phase].second_offset);
    }
    ESP_LOGI(TAG, "[CALIBRATION][%s] ==============================================================\n", cs);
    return;
@@ -1104,10 +1129,11 @@ 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].voltage_offset_ : 0;
+        this->has_config_voltage_offset_[phase] ? this->config_offset_phase_[phase].first_offset : 0;
    int16_t current_offset =
-        this->has_config_current_offset_[phase] ? this->config_offset_phase_[phase].current_offset_ : 0;
+        this->has_config_current_offset_[phase] ? this->config_offset_phase_[phase].second_offset : 0;
-    this->write_offsets_to_registers_(phase, voltage_offset, current_offset);
+    this->write_offsets_to_registers_(phase, voltage_offset, current_offset,
                                      OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_VOLTAGE_CURRENT);
    ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |     %6d      |     %6d      |", cs, 'A' + phase, voltage_offset,
             current_offset);
  }
@@ -1117,6 +1143,7 @@ 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;
@@ -1126,15 +1153,14 @@ void ATM90E32Component::clear_offset_calibrations() {
 void ATM90E32Component::clear_power_offset_calibrations() {
  const char *cs = this->get_calibration_id_();
-  if (!this->restored_power_offset_calibration_) {
+  if (!this->has_stored_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].active_power_offset,
+               this->power_offset_phase_[phase].first_offset, this->power_offset_phase_[phase].second_offset);
               this->power_offset_phase_[phase].reactive_power_offset);
    }
    ESP_LOGI(TAG, "[CALIBRATION][%s] =====================================================================\n", cs);
    return;
@@ -1147,20 +1173,21 @@ 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].active_power_offset : 0;
+        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]
+    int16_t reactive_offset =
-                                  ? this->config_power_offset_phase_[phase].reactive_power_offset
+        this->has_config_reactive_power_offset_[phase] ? this->config_power_offset_phase_[phase].second_offset : 0;
-                                  : 0;
+    this->write_offsets_to_registers_(phase, active_offset, reactive_offset,
-    this->write_power_offsets_to_registers_(phase, active_offset, reactive_offset);
+                                      OffsetCalibrationType::OFFSET_CALIBRATION_TYPE_POWER);
    ESP_LOGI(TAG, "[CALIBRATION][%s] |   %c   |       %6d        |        %6d        |", cs, 'A' + phase, active_offset,
             reactive_offset);
  }
  ESP_LOGI(TAG, "[CALIBRATION][%s] =====================================================================\n", cs);
-  PowerOffsetCalibration zero_power_offsets[3]{{0, 0}, {0, 0}, {0, 0}};
+  OffsetCalibration 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;
@@ -1215,6 +1242,31 @@ 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);
@@ -13,6 +13,40 @@
 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> {
@@ -71,19 +105,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].voltage_offset_ = offset;
+    this->offset_phase_[phase].first_offset = offset;
    this->has_config_voltage_offset_[phase] = true;
  }
  void set_current_offset(uint8_t phase, int16_t offset) {
-    this->offset_phase_[phase].current_offset_ = offset;
+    this->offset_phase_[phase].second_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].active_power_offset = offset;
+    this->power_offset_phase_[phase].first_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].reactive_power_offset = offset;
+    this->power_offset_phase_[phase].second_offset = offset;
    this->has_config_reactive_power_offset_[phase] = true;
  }
  void set_freq_sensor(sensor::Sensor *freq_sensor) { freq_sensor_ = freq_sensor; }
@@ -171,16 +205,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_();
+  void restore_offset_calibrations_(OffsetCalibrationType type);
  void restore_power_offset_calibrations_();
  void restore_gain_calibrations_();
  void save_offset_calibration_to_memory_();
  void save_gain_calibration_to_memory_();
-  void save_power_offset_calibration_to_memory_();
+  void finish_offset_calibration_(const OffsetCalibration (&previous)[3], bool previous_restored,
-  void write_offsets_to_registers_(uint8_t phase, int16_t voltage_offset, int16_t current_offset);
+                                  bool previous_using_saved, OffsetCalibrationType type);
-  void write_power_offsets_to_registers_(uint8_t phase, int16_t p_offset, int16_t q_offset);
+  void write_offsets_to_registers_(uint8_t phase, int16_t first_offset, int16_t second_offset,
                                   OffsetCalibrationType type);
  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_();
@@ -219,19 +253,10 @@ class ATM90E32Component final : public PollingComponent,
    uint32_t cumulative_reverse_active_energy_{0};
  } phase_[3];
-  struct OffsetCalibration {
+  OffsetCalibration offset_phase_[3];
    int16_t voltage_offset_{0};
    int16_t current_offset_{0};
  } offset_phase_[3];
  OffsetCalibration config_offset_phase_[3];
-
+  OffsetCalibration power_offset_phase_[3];
-  struct PowerOffsetCalibration {
+  OffsetCalibration config_power_offset_phase_[3];
    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};
@@ -265,6 +290,8 @@ 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};
@@ -313,9 +313,10 @@ 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) {
+  } else if (result == micro_mp3::MP3_STREAM_INFO_READY || result == micro_mp3::MP3_STREAM_INFO_CHANGED) {
-    // First successful header parse: capture stream info and resize the output buffer to fit one full frame.
+    // Header parsed: capture stream info and resize the output buffer to fit one full frame.
-    // microMP3 always outputs 16-bit PCM.
+    // 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.
    this->audio_stream_info_ =
        audio::AudioStreamInfo(16, this->mp3_decoder_->get_channels(), this->mp3_decoder_->get_sample_rate());
    this->free_buffer_required_ =
@@ -58,6 +58,9 @@ 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;
  }
@@ -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_.use_count() > 0) {
+  if (this->ring_buffer_ != nullptr) {
    this->ring_buffer_->reset();
  }
 }
 void AudioSinkTransferBuffer::clear_buffered_data() {
  this->buffer_length_ = 0;
-  if (this->ring_buffer_.use_count() > 0) {
+  if (this->ring_buffer_ != nullptr) {
    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_.use_count() > 0) {
+  if (this->ring_buffer_ != nullptr) {
    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_.use_count() > 0) {
+    if (this->ring_buffer_ != nullptr) {
      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_.use_count() > 0) {
+        if (this->ring_buffer_ != nullptr) {
      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_.use_count() > 0) {
+  if (this->ring_buffer_ != nullptr) {
    return ((this->ring_buffer_->available() > 0) || (this->available() > 0));
  }
  return (this->available() > 0);
@@ -22,6 +22,23 @@ 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:
@@ -61,7 +78,7 @@ class BLEClientDisconnectTrigger final : public Trigger<>, public BLEClientNode
  }
 };
-class BLEClientPasskeyRequestTrigger final : public Trigger<>, public BLEClientNode {
+class BLEClientPasskeyRequestTrigger final : public Trigger<>, public BLEClientServicelessNode {
 public:
  explicit BLEClientPasskeyRequestTrigger(BLEClient *parent) { parent->register_ble_node(this); }
  void loop() override {}
@@ -71,7 +88,7 @@ class BLEClientPasskeyRequestTrigger final : public Trigger<>, public BLEClientN
  }
 };
-class BLEClientPasskeyNotificationTrigger final : public Trigger<uint32_t>, public BLEClientNode {
+class BLEClientPasskeyNotificationTrigger final : public Trigger<uint32_t>, public BLEClientServicelessNode {
 public:
  explicit BLEClientPasskeyNotificationTrigger(BLEClient *parent) { parent->register_ble_node(this); }
  void loop() override {}
@@ -82,7 +99,7 @@ class BLEClientPasskeyNotificationTrigger final : public Trigger<uint32_t>, publ
  }
 };
-class BLEClientNumericComparisonRequestTrigger final : public Trigger<uint32_t>, public BLEClientNode {
+class BLEClientNumericComparisonRequestTrigger final : public Trigger<uint32_t>, public BLEClientServicelessNode {
 public:
  explicit BLEClientNumericComparisonRequestTrigger(BLEClient *parent) { parent->register_ble_node(this); }
  void loop() override {}
@@ -315,19 +332,17 @@ template<typename... Ts> class BLEClientRemoveBondAction final : public Action<T
  BLEClient *parent_{nullptr};
 };
-template<typename... Ts> class BLEClientConnectAction final : public Action<Ts...>, public BLEClientNode {
+template<typename... Ts> class BLEClientConnectAction final : public Action<Ts...>, public BLEClientServicelessNode {
 public:
  BLEClientConnectAction(BLEClient *ble_client) {
    ble_client->register_ble_node(this);
    ble_client_ = ble_client;
  }
-  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+  void on_gattc_event(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) override {
                           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.
@@ -364,14 +379,13 @@ template<typename... Ts> class BLEClientConnectAction final : public Action<Ts..
  std::tuple<Ts...> var_{};
 };
-template<typename... Ts> class BLEClientDisconnectAction final : public Action<Ts...>, public BLEClientNode {
+template<typename... Ts> class BLEClientDisconnectAction final : public Action<Ts...>, public BLEClientServicelessNode {
 public:
  BLEClientDisconnectAction(BLEClient *ble_client) {
    ble_client->register_ble_node(this);
    ble_client_ = ble_client;
  }
-  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+  void on_gattc_event(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) override {
                           esp_ble_gattc_cb_param_t *param) override {
    if (this->num_running_ == 0)
      return;
    switch (event) {
@@ -6,6 +6,7 @@ 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;
@@ -154,7 +155,14 @@ 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;
 }
@@ -66,11 +66,15 @@ 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) {
+    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.
      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)) {
+      if (pref.load(&reboot_source) && reboot_source[0] != '\0') {
        reboot_source[REBOOT_MAX_LEN - 1] = '\0';
        snprintf(buf, size, "Reboot request from %s", reboot_source);
      } else {
@@ -23,11 +23,7 @@ from esphome.const import (
 )
 from esphome.types import ConfigType
-from . import (  # noqa: F401  pylint: disable=unused-import
+from . import CONF_DEBUG_ID, FILTER_SOURCE_FILES, DebugComponent  # noqa: F401  pylint: disable=unused-import
    CONF_DEBUG_ID,
    FILTER_SOURCE_FILES,
    DebugComponent,
 )
 DEPENDENCIES = ["debug"]
@@ -9,11 +9,7 @@ from esphome.const import (
 )
 from esphome.types import ConfigType
-from . import (  # noqa: F401  pylint: disable=unused-import
+from . import CONF_DEBUG_ID, FILTER_SOURCE_FILES, DebugComponent  # noqa: F401  pylint: disable=unused-import
    CONF_DEBUG_ID,
    FILTER_SOURCE_FILES,
    DebugComponent,
 )
 DEPENDENCIES = ["debug"]
@@ -3,18 +3,11 @@ import esphome.codegen as cg
 # Re-exported for the many esp32-side users; defined in esphome.const
 # and esphome.espidf so the upload/logs fast path can use them without
 # importing this package.
-from esphome.const import (  # noqa: F401  # pylint: disable=unused-import
+from esphome.const import KEY_ESP32, KEY_FLASH_SIZE, KEY_IDF_VERSION, KEY_VARIANT  # 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 (  # noqa: F401  # pylint: disable=unused-import
+from esphome.espidf import variant_to_idf_target  # noqa: F401  # pylint: disable=unused-import
    variant_to_idf_target,
 )
 KEY_BOARD = "board"
 KEY_SDKCONFIG_OPTIONS = "sdkconfig_options"
@@ -41,7 +41,10 @@ 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
-static constexpr uint32_t OTA_SOCKET_TIMEOUT_DATA = 90000;       // milliseconds for data transfer
+// 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;
 // Single-instance pointer — multi-port configs are rejected in final_validate.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
@@ -91,7 +91,14 @@ void I2SAudioSpeakerBase::loop() {
    this->speaker_task_handle_ = nullptr;
    this->stop_i2s_driver_();
-    xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::ALL_BITS);
+    // 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);
    }
    this->status_clear_error();
    this->on_task_stopped();
@@ -111,21 +118,24 @@ 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;
      }
-      if (this->speaker_task_handle_ == nullptr) {
+      xTaskCreate(I2SAudioSpeakerBase::speaker_task, "speaker_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
-        xTaskCreate(I2SAudioSpeakerBase::speaker_task, "speaker_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
+                  &this->speaker_task_handle_);
                    &this->speaker_task_handle_);
-        if (this->speaker_task_handle_ == nullptr) {
+      if (this->speaker_task_handle_ == nullptr) {
-          ESP_LOGE(TAG, "Task failed to start, retrying in 1 second");
+        ESP_LOGE(TAG, "Task failed to start, retrying in 1 second");
-          this->status_momentary_error("task-failure", 1000);
+        this->status_momentary_error("task-failure", 1000);
-          this->stop_i2s_driver_();  // Stops the driver to return the lock; will be reloaded in next attempt
+        this->stop_i2s_driver_();  // Stops the driver to return the lock; will be reloaded in next attempt
        }
      }
      break;
    case speaker::STATE_RUNNING:   // Intentional fallthrough
@@ -211,8 +221,8 @@ size_t I2SAudioSpeakerBase::play(const uint8_t *data, size_t length, TickType_t
 }
 bool I2SAudioSpeakerBase::has_buffered_data() const {
-  if (this->audio_ring_buffer_.use_count() > 0) {
+  std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->audio_ring_buffer_.lock();
-    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->audio_ring_buffer_.lock();
+  if (temp_ring_buffer != nullptr) {
    return temp_ring_buffer->available() > 0;
  }
  return false;
@@ -5,6 +5,7 @@
 #include <esp_log.h>
 #include <driver/uart.h>
 #include <soc/soc_caps.h>
 #ifdef USE_LOGGER_UART_SELECTION_USB_SERIAL_JTAG
 #include <driver/usb_serial_jtag.h>
@@ -76,7 +77,11 @@ 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).
@@ -15,6 +15,7 @@ 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"
@@ -49,7 +50,7 @@ class KeyboardType(WidgetType):
        )
    def get_uses(self):
-        return CONF_KEYBOARD, CONF_TEXTAREA, CONF_BUTTONMATRIX
+        return CONF_KEYBOARD, CONF_TEXTAREA, CONF_BUTTONMATRIX, CONF_LABEL
    async def to_code(self, w: Widget, config: dict):
        add_lv_use("KEY_LISTENER")
@@ -10,6 +10,7 @@ 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"
@@ -41,7 +42,7 @@ class QrCodeType(WidgetType):
        )
    def get_uses(self):
-        return CONF_CANVAS, CONF_IMAGE
+        return CONF_CANVAS, CONF_IMAGE, CONF_LABEL
    async def to_code(self, w: Widget, config):
        await w.set_property(
@@ -28,6 +28,7 @@ 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"
@@ -74,7 +75,7 @@ class TabviewType(WidgetType):
        )
    def get_uses(self):
-        return CONF_BUTTONMATRIX, TYPE_FLEX, CONF_BUTTON
+        return CONF_BUTTONMATRIX, TYPE_FLEX, CONF_BUTTON, CONF_LABEL
    async def to_code(self, w: Widget, config: dict):
        await w.set_property(
@@ -129,7 +129,7 @@ void MicroWakeWord::setup() {
      return;
    }
    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-    if (this->ring_buffer_.use_count() > 1) {
+    if (temp_ring_buffer != nullptr) {
      // 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);
  }
-  if ((event_group_bits & EventGroupBits::TASK_STOPPED)) {
+  // 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()) {
    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);
@@ -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_.use_count() == 0) {
+        if (this->processed_samples_ == nullptr) {
          // Create vector if its unused
          this->processed_samples_ = std::make_shared<std::vector<uint8_t>>();
        }
@@ -35,8 +35,8 @@ void MipiDsi::setup() {
      .bus_id = 0,  // index from 0, specify the DSI host to use
      .num_data_lanes =
          this->lanes_,  // Number of data lanes to use, can't set a value that exceeds the chip's capability
-      .phy_clk_src = MIPI_DSI_PHY_CLK_SRC_DEFAULT,  // Clock source for the DPHY
+      // phy_clk_src left at 0 to enable runtime auto-select.
-      .lane_bit_rate_mbps = this->lane_bit_rate_,   // Bit rate of the data lanes, in Mbps
+      .lane_bit_rate_mbps = this->lane_bit_rate_,  // Bit rate of the data lanes, in Mbps
  };
  auto err = esp_lcd_new_dsi_bus(&bus_config, &this->bus_handle_);
  if (err != ESP_OK) {
@@ -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.use_count() > 0) {
+  if (temp_ring_buffer != nullptr) {
    // 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_.use_count() == 0) {
+  if (this->audio_source_ == nullptr) {
    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-    if (!temp_ring_buffer) {
+    if (temp_ring_buffer == nullptr) {
      temp_ring_buffer = ring_buffer::RingBuffer::create(ring_buffer_size);
      this->ring_buffer_ = temp_ring_buffer;
    }
-    if (!temp_ring_buffer) {
+    if (temp_ring_buffer == nullptr) {
      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_.use_count() > 0) && this->audio_source_->has_buffered_data());
+  return ((this->audio_source_ != nullptr) && 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);
  }
-  if (event_group_bits & MIXER_TASK_STATE_STOPPED) {
+  // Retries on a subsequent loop if the task is still running on the other core
-    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.use_count() == 0) {
+          if (audio_source == nullptr) {
            // No audio source allocated, so skip processing this speaker
            continue;
          }
@@ -26,44 +26,129 @@ static const uint8_t MLX90614_ID4 = 0x3F;
 static const char *const TAG = "mlx90614";
 // The EEPROM cell has a limited number of write cycles, so stop retrying after a few failures
 static constexpr uint8_t EMISSIVITY_WRITE_ATTEMPTS = 3;
 // SMBus packet error code: CRC-8 with polynomial 0x07, MSB first
 static uint8_t crc8_pec(const uint8_t *data, uint8_t len) { return crc8(data, len, 0x00, 0x07, true); }
 void MLX90614Component::setup() {
-  if (!this->write_emissivity_()) {
+  if (std::isnan(this->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_() {
-  if (std::isnan(this->emissivity_))
+  // Skip the write when the EEPROM already holds the desired value to save write cycles
  uint16_t current_emissivity;
  if (this->read_register_(MLX90614_EMISSIVITY, current_emissivity) != i2c::ERROR_OK) {
    return false;
  }
  const auto desired_emissivity = static_cast<uint16_t>(this->emissivity_ * 0xFFFF);
  if (current_emissivity == desired_emissivity) {
    return true;
  uint16_t value = (uint16_t) (this->emissivity_ * 65535);
  if (!this->write_bytes_(MLX90614_EMISSIVITY, 0)) {
    return false;
  }
-  delay(10);
+
-  if (!this->write_bytes_(MLX90614_EMISSIVITY, value)) {
+  return this->write_register_(MLX90614_EMISSIVITY, desired_emissivity);
    return false;
  }
  delay(10);
  return true;
 }
-bool MLX90614Component::write_bytes_(uint8_t reg, uint16_t data) {
+bool MLX90614Component::write_register_(uint8_t reg, uint16_t data) {
  // The PEC covers the whole write transaction: SLA+W, command, data low, data high
  uint8_t buf[5];
  buf[0] = this->address_ << 1;
  buf[1] = reg;
-  buf[2] = data & 0xFF;
+
-  buf[3] = data >> 8;
+  // See datasheet 8.3.3.1 EEPROM write sequence
-  buf[4] = crc8(buf, 4, 0x00, 0x07, true);
+  // 1. Write 0x0000 into the cell of interest (erases the cell)
-  return this->write_bytes(reg, buf + 2, 3);
+  buf[2] = buf[3] = 0;
  buf[4] = crc8_pec(buf, 4);
  auto ec = this->write_register(reg, buf + 2, 3);
  if (ec != i2c::ERROR_OK) {
    ESP_LOGW(TAG, "Can't erase register 0x%02X, error %d", reg, ec);
    return false;
  }
  // 2. Wait at least 5ms
  delay(10);
  // 3. Write the new value
  if (data != 0) {
    buf[2] = data & 0xFF;
    buf[3] = data >> 8;
    buf[4] = crc8_pec(buf, 4);
    ec = this->write_register(reg, buf + 2, 3);
    if (ec != i2c::ERROR_OK) {
      ESP_LOGW(TAG, "Can't write register 0x%02X, error %d", reg, ec);
      return false;
    }
    // 4. Wait at least 5ms
    delay(10);
  }
  // 5. Read back to confirm the value was stored
  uint16_t read_back;
  ec = this->read_register_(reg, read_back);
  if (ec != i2c::ERROR_OK) {
    ESP_LOGW(TAG, "Can't check register 0x%02X value, error %d", reg, ec);
    return false;
  }
  if (read_back != data) {
    ESP_LOGW(TAG, "Read back mismatch on register 0x%02X. Expected 0x%04X, got 0x%04X", reg, data, read_back);
    return false;
  }
  return true;
 }
 i2c::ErrorCode MLX90614Component::read_register_(uint8_t reg, uint16_t &data) {
  // The PEC covers the whole read transaction: SLA+W, command, SLA+R, data low, data high
  uint8_t buf[6];
  buf[0] = this->address_ << 1;
  buf[1] = reg;
  buf[2] = (this->address_ << 1) | 0x01;
  const auto ec = this->read_register(reg, buf + 3, 3);
  if (ec != i2c::ERROR_OK) {
    ESP_LOGW(TAG, "i2c read error %d", ec);
    return ec;
  }
  const auto expected_pec = crc8_pec(buf, 5);
  if (buf[5] != expected_pec) {
    ESP_LOGW(TAG, "i2c CRC error. Expected 0x%02X, got 0x%02X", expected_pec, buf[5]);
    return i2c::ERROR_CRC;
  }
  data = encode_uint16(buf[4], buf[3]);
  return i2c::ERROR_OK;
 }
 void MLX90614Component::dump_config() {
  ESP_LOGCONFIG(TAG, "MLX90614:");
  LOG_I2C_DEVICE(this);
-  if (this->is_failed()) {
+  if (this->emissivity_write_attempts_ != 0) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGW(TAG, "  Emissivity not written yet, will retry");
  }
  LOG_UPDATE_INTERVAL(this);
  LOG_SENSOR("  ", "Ambient", this->ambient_sensor_);
@@ -71,33 +156,41 @@ void MLX90614Component::dump_config() {
 }
 void MLX90614Component::update() {
-  uint8_t emissivity[3];
+  // Temperature reads run regardless of the emissivity state so a failure still shows up as NAN
-  if (this->read_register(MLX90614_EMISSIVITY, emissivity, 3) != i2c::ERROR_OK) {
+  this->try_write_emissivity_();
-    this->status_set_warning();
+
-    return;
+  // Publishes NAN on a bus or CRC failure so a stuck reading is visible instead of silently stale
  auto publish_sensor = [this](sensor::Sensor *sensor, uint8_t reg) {
    if (sensor == nullptr) {
      return i2c::ERROR_OK;
    }
    uint16_t raw;
    const auto ec = this->read_register_(reg, raw);
    if (ec != i2c::ERROR_OK) {
      sensor->publish_state(NAN);
      return ec;
    }
    // Bit 15 set means the device flagged the reading as invalid
    const float temperature = (raw & 0x8000) ? NAN : raw * 0.02f - 273.15f;
    ESP_LOGD(TAG, "'%s': Got temperature=%.1f°C", sensor->get_name().c_str(), temperature);
    sensor->publish_state(temperature);
    return ec;
  };
  const auto object_ec = publish_sensor(this->object_sensor_, MLX90614_TEMPERATURE_OBJECT_1);
  const auto ambient_ec = publish_sensor(this->ambient_sensor_, MLX90614_TEMPERATURE_AMBIENT);
  if (object_ec != i2c::ERROR_OK || ambient_ec != i2c::ERROR_OK) {
    this->status_set_warning(LOG_STR("Failed to read some sensors"));
  } else if (this->emissivity_write_failed_) {
    this->status_set_warning(LOG_STR("Failed to write emissivity"));
  } else if (this->emissivity_write_attempts_ != 0) {
    this->status_set_warning(LOG_STR("Failed to write emissivity, will retry"));
  } else {
    this->status_clear_warning();
  }
  uint8_t raw_object[3];
  if (this->read_register(MLX90614_TEMPERATURE_OBJECT_1, raw_object, 3) != i2c::ERROR_OK) {
    this->status_set_warning();
    return;
  }
  uint8_t raw_ambient[3];
  if (this->read_register(MLX90614_TEMPERATURE_AMBIENT, raw_ambient, 3) != i2c::ERROR_OK) {
    this->status_set_warning();
    return;
  }
  float ambient = raw_ambient[1] & 0x80 ? NAN : encode_uint16(raw_ambient[1], raw_ambient[0]) * 0.02f - 273.15f;
  float object = raw_object[1] & 0x80 ? NAN : encode_uint16(raw_object[1], raw_object[0]) * 0.02f - 273.15f;
  ESP_LOGD(TAG, "Got Temperature=%.1f°C Ambient=%.1f°C", object, ambient);
  if (this->ambient_sensor_ != nullptr && !std::isnan(ambient))
    this->ambient_sensor_->publish_state(ambient);
  if (this->object_sensor_ != nullptr && !std::isnan(object))
    this->object_sensor_->publish_state(object);
  this->status_clear_warning();
 }
 }  // namespace esphome::mlx90614
@@ -18,13 +18,18 @@ class MLX90614Component final : public PollingComponent, public i2c::I2CDevice {
  void set_emissivity(float emissivity) { emissivity_ = emissivity; }
 protected:
  void try_write_emissivity_();
  bool write_emissivity_();
-  bool write_bytes_(uint8_t reg, uint16_t data);
+  bool write_register_(uint8_t reg, uint16_t data);
  i2c::ErrorCode read_register_(uint8_t reg, uint16_t &data);
  sensor::Sensor *ambient_sensor_{nullptr};
  sensor::Sensor *object_sensor_{nullptr};
  float emissivity_{NAN};
  // Remaining attempts to program the emissivity EEPROM cell, bounded to limit cell wear
  uint8_t emissivity_write_attempts_{0};
  bool emissivity_write_failed_{false};
 };
 }  // namespace esphome::mlx90614
@@ -67,6 +67,9 @@ 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();
@@ -26,30 +26,34 @@ 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)
+  if (modem::global_modem_component != nullptr && modem::global_modem_component->is_connected())
-    return modem::global_modem_component->is_connected();
+    return true;
 #endif
 #ifdef USE_WIFI
-  if (wifi::global_wifi_component != nullptr)
+  if (wifi::global_wifi_component != nullptr && wifi::global_wifi_component->is_connected())
-    return wifi::global_wifi_component->is_connected();
+    return true;
 #endif
 #ifdef USE_OPENTHREAD
-  if (openthread::global_openthread_component != nullptr)
+  if (openthread::global_openthread_component != nullptr && openthread::global_openthread_component->is_connected())
-    return openthread::global_openthread_component->is_connected();
+    return true;
 #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
@@ -14,12 +14,7 @@ from esphome.const import (
 )
 from esphome.core import CORE, TimePeriod
-from . import (  # noqa: F401  pylint: disable=unused-import
+from . import FILTER_SOURCE_FILES, Nextion, nextion_ns, nextion_ref  # 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,
@@ -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.24")
+    cg.add_library("esphome/noise-c", "0.1.26")
    # 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.6")
+    cg.add_library("esphome/libsodium", "1.10021.8")
    # 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")
@@ -153,8 +153,8 @@ void ResamplerSpeaker::loop() {
    ESP_LOGV(TAG, "Stopping");
    xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::STATE_STOPPING);
  }
-  if (event_group_bits & ResamplingEventGroupBits::STATE_STOPPED) {
+  // Retries on a subsequent loop if the task is still running on the other core
-    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) {
+    if (temp_ring_buffer != nullptr) {
      // 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) {
+    if (temp_ring_buffer != nullptr) {
      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) {
+      if (temp_ring_buffer == nullptr) {
        err = ESP_ERR_NO_MEM;
      } else {
        this_resampler->ring_buffer_ = temp_ring_buffer;
@@ -18,6 +18,16 @@ 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];
@@ -84,26 +94,21 @@ bool RFBridgeComponent::parse_bridge_byte_(uint8_t byte) {
      break;
    }
    case RF_CODE_RFIN_BUCKET: {
-      if (byte != RF_CODE_STOP) {
+      if (at == 2) {
-        return true;
+        // 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;
      }
-
+      // 0x55 is legal DATA inside a B1 frame: bucket durations are sent
-      uint8_t buckets = raw[2] << 1;
+      // with only their HIGH byte masked to 7 bits, so a duration such as
-      std::string str;
+      // 0x0155 puts a raw 0x55 low byte inside the table — the first 0x55
-      char next_byte[3];  // 2 hex chars + null
+      // 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
-      for (uint32_t i = 0; i <= at; i++) {
+      // past the first pulse index is a terminator CANDIDATE, confirmed
-        buf_append_printf(next_byte, sizeof(next_byte), 0, "%02X", raw[i]);
+      // once the UART goes quiet (finish_bucket_frame_ in loop()).
-        str += next_byte;
+      this->bucket_frame_candidate_ = byte == RF_CODE_STOP && at >= 3 + static_cast<size_t>(raw[2]) * 2;
-        if ((i > 3) && buckets) {
+      return true;
          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);
@@ -119,6 +124,47 @@ 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();
@@ -130,12 +176,31 @@ void RFBridgeComponent::write_byte_str_(const std::string &codes) {
 void RFBridgeComponent::loop() {
  const uint32_t now = App.get_loop_component_start_time();
-  if (now - this->last_bridge_byte_ > 50) {
+  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) {
    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));
@@ -146,12 +211,14 @@ 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;
      }
    }
  }
@@ -30,6 +30,17 @@ 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;
@@ -67,10 +78,12 @@ 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_;
@@ -30,6 +30,7 @@ CONF_SENDSPIN_ID = "sendspin_id"
 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
@@ -44,6 +45,20 @@ 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")
@@ -286,16 +301,13 @@ async def to_code(config: ConfigType) -> None:
    if data.player_support:
        cg.add_define("USE_SENDSPIN_PLAYER", True)
-        # 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
+        # Configures the player role. Each configured codec is advertised for 16 bits per sample
-        # (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
+        # mono and stereo at the configured sample rate. The order is a preference order, both for
        # the codecs themselves and for stereo over mono.
        player_cfg = data.player_config
        sample_rate = player_cfg[CONF_SAMPLE_RATE]
-        # OPUS only supports 48 kHz audio
+        codecs = [CODECS[codec] for codec in player_cfg[CONF_CODECS]]
        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(
@@ -13,11 +13,16 @@ 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,
@@ -49,10 +54,32 @@ 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],
@@ -85,9 +112,13 @@ 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,
 )
@@ -202,8 +202,15 @@ 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()) {
-        this->read_task_.deallocate();
+        // Both are attempted every time; a task that is still running on the other core is freed by a
-        this->decode_task_.deallocate();
+        // 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;
        }
        if (this->hard_stop_) {
          // Stop command was sent, so immediately end the playback
          this->speaker_->stop();
@@ -315,17 +322,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;
+        std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this_pipeline->raw_file_ring_buffer_.lock();
-        if (!this_pipeline->raw_file_ring_buffer_.use_count()) {
+        if (temp_ring_buffer == nullptr) {
          temp_ring_buffer = ring_buffer::RingBuffer::create(file_ring_buffer_size);
          this_pipeline->raw_file_ring_buffer_ = temp_ring_buffer;
        }
-        if (!this_pipeline->raw_file_ring_buffer_.use_count()) {
+        if (temp_ring_buffer == nullptr) {
          err = ESP_ERR_NO_MEM;
        } else {
-          reader->add_sink(this_pipeline->raw_file_ring_buffer_);
+          err = reader->add_sink(temp_ring_buffer);
        }
      }
@@ -396,7 +403,9 @@ 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_);
-      decoder->add_source(this_pipeline->raw_file_ring_buffer_);
+      if (err == ESP_OK) {
        err = decoder->add_source(this_pipeline->raw_file_ring_buffer_);
      }
      if (err != ESP_OK) {
        // Send specific error message
@@ -2,7 +2,13 @@ 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_ID, CONF_LAMBDA, CONF_STATE
+from esphome.const import (
    CONF_CONDITION,
    CONF_DEVICE_CLASS,
    CONF_ID,
    CONF_LAMBDA,
    CONF_STATE,
 )
 from esphome.cpp_generator import LambdaExpression
 from .. import template_ns
@@ -12,7 +18,11 @@ TemplateBinarySensor = template_ns.class_(
 )
 CONFIG_SCHEMA = (
-    binary_sensor.binary_sensor_schema(TemplateBinarySensor)
+    cv.with_visibility(
        binary_sensor.binary_sensor_schema(TemplateBinarySensor),
        cv.Visibility.UI,
        CONF_DEVICE_CLASS,
    )
    .extend(
        {
            cv.Exclusive(CONF_LAMBDA, CONF_CONDITION): cv.returning_lambda,
@@ -1,10 +1,14 @@
 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 = button.button_schema(TemplateButton)
+CONFIG_SCHEMA = cv.with_visibility(
    button.button_schema(TemplateButton), cv.Visibility.UI, CONF_DEVICE_CLASS
 )
 async def to_code(config):
@@ -6,6 +6,7 @@ from esphome.const import (
    CONF_ASSUMED_STATE,
    CONF_CLOSE_ACTION,
    CONF_CURRENT_OPERATION,
    CONF_DEVICE_CLASS,
    CONF_ID,
    CONF_LAMBDA,
    CONF_OPEN_ACTION,
@@ -38,7 +39,11 @@ CONF_HAS_POSITION = "has_position"
 CONF_TOGGLE_ACTION = "toggle_action"
 CONFIG_SCHEMA = (
-    cover.cover_schema(TemplateCover)
+    cv.with_visibility(
        cover.cover_schema(TemplateCover),
        cv.Visibility.UI,
        CONF_DEVICE_CLASS,
    )
    .extend(
        {
            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
@@ -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_EVENT_TYPES
+from esphome.const import CONF_DEVICE_CLASS, CONF_EVENT_TYPES
 from .. import template_ns
@@ -9,7 +9,9 @@ CODEOWNERS = ["@nohat"]
 TemplateEvent = template_ns.class_("TemplateEvent", event.Event, cg.Component)
-CONFIG_SCHEMA = event.event_schema(TemplateEvent).extend(
+CONFIG_SCHEMA = cv.with_visibility(
    event.event_schema(TemplateEvent), cv.Visibility.UI, CONF_DEVICE_CLASS
 ).extend(
    {
        cv.Required(CONF_EVENT_TYPES): cv.ensure_list(cv.string_strict),
    }
@@ -3,6 +3,7 @@ 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,
@@ -12,6 +13,7 @@ from esphome.const import (
    CONF_RESTORE_VALUE,
    CONF_SET_ACTION,
    CONF_STEP,
    CONF_UNIT_OF_MEASUREMENT,
 )
 from .. import template_ns
@@ -46,7 +48,12 @@ def validate(config):
 CONFIG_SCHEMA = cv.All(
-    number.number_schema(TemplateNumber)
+    cv.with_visibility(
        number.number_schema(TemplateNumber),
        cv.Visibility.UI,
        CONF_DEVICE_CLASS,
        CONF_UNIT_OF_MEASUREMENT,
    )
    .extend(
        {
            cv.Required(CONF_MAX_VALUE): cv.float_,
@@ -2,7 +2,16 @@ 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_ID, CONF_LAMBDA, CONF_STATE
+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 .. import template_ns
@@ -11,9 +20,14 @@ TemplateSensor = template_ns.class_(
 )
 CONFIG_SCHEMA = (
-    sensor.sensor_schema(
+    cv.with_visibility(
-        TemplateSensor,
+        sensor.sensor_schema(TemplateSensor, accuracy_decimals=1),
-        accuracy_decimals=1,
+        cv.Visibility.UI,
        CONF_UNIT_OF_MEASUREMENT,
        CONF_ACCURACY_DECIMALS,
        CONF_DEVICE_CLASS,
        CONF_STATE_CLASS,
        CONF_FORCE_UPDATE,
    )
    .extend(
        {
@@ -4,6 +4,7 @@ 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,
@@ -31,7 +32,11 @@ def validate(config):
 CONFIG_SCHEMA = cv.All(
-    switch.switch_schema(TemplateSwitch)
+    cv.with_visibility(
        switch.switch_schema(TemplateSwitch),
        cv.Visibility.UI,
        CONF_DEVICE_CLASS,
    )
    .extend(
        {
            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
@@ -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_ID, CONF_LAMBDA, CONF_STATE
+from esphome.const import CONF_DEVICE_CLASS, CONF_ID, CONF_LAMBDA, CONF_STATE
 from .. import template_ns
@@ -12,7 +12,11 @@ TemplateTextSensor = template_ns.class_(
 )
 CONFIG_SCHEMA = (
-    text_sensor.text_sensor_schema()
+    cv.with_visibility(
        text_sensor.text_sensor_schema(),
        cv.Visibility.UI,
        CONF_DEVICE_CLASS,
    )
    .extend(
        {
            cv.GenerateID(): cv.declare_id(TemplateTextSensor),
@@ -6,6 +6,7 @@ from esphome.const import (
    CONF_ASSUMED_STATE,
    CONF_CLOSE_ACTION,
    CONF_CURRENT_OPERATION,
    CONF_DEVICE_CLASS,
    CONF_ID,
    CONF_LAMBDA,
    CONF_OPEN_ACTION,
@@ -36,7 +37,11 @@ CONF_HAS_POSITION = "has_position"
 CONF_TOGGLE_ACTION = "toggle_action"
 CONFIG_SCHEMA = (
-    valve.valve_schema(TemplateValve)
+    cv.with_visibility(
        valve.valve_schema(TemplateValve),
        cv.Visibility.UI,
        CONF_DEVICE_CLASS,
    )
    .extend(
        {
            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
@@ -1,10 +1,13 @@
 #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
@@ -22,6 +25,14 @@ 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) {
@@ -554,14 +565,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"
@@ -1,5 +1,4 @@
-from collections.abc import Callable
+from typing import Any
 from typing import Any, NoReturn
 from esphome import automation
 from esphome.automation import Trigger
@@ -48,17 +47,10 @@ 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): is_relocated(x)
+    cv.Optional(x): cv.invalid(
        f"The '{x}' option should now be configured in the 'packet_transport' component"
    )
    for x in (
        CONF_PROVIDERS,
        CONF_ENCRYPTION,
@@ -66,13 +66,14 @@ from esphome.const import (
 )
 from esphome.core import (
    CORE,
    ID,
    CoroPriority,
    EsphomeError,
    HexInt,
    coroutine_with_priority,
 )
 import esphome.final_validate as fv
-from esphome.types import ConfigType
+from esphome.types import ConfigType, TemplateArgsType
 from . import wpa2_eap
@@ -208,6 +209,7 @@ WiFiEnabledCondition = wifi_ns.class_("WiFiEnabledCondition", Condition)
 WiFiAPActiveCondition = wifi_ns.class_("WiFiAPActiveCondition", Condition)
 WiFiEnableAction = wifi_ns.class_("WiFiEnableAction", automation.Action)
 WiFiDisableAction = wifi_ns.class_("WiFiDisableAction", automation.Action)
 WiFiRoamAction = wifi_ns.class_("WiFiRoamAction", automation.Action)
 WiFiConfigureAction = wifi_ns.class_(
    "WiFiConfigureAction", automation.Action, cg.Component
 )
@@ -820,6 +822,18 @@ async def wifi_disable_to_code(config, action_id, template_arg, args):
    return cg.new_Pvariable(action_id, template_arg)
@automation.register_action(
    "wifi.roam", WiFiRoamAction, cv.Schema({}), synchronous=True
 )
 async def wifi_roam_to_code(
    config: ConfigType,
    action_id: ID,
    template_arg: cg.TemplateArguments,
    args: TemplateArgsType,
 ) -> cg.MockObj:
    return cg.new_Pvariable(action_id, template_arg)
 KEEP_SCAN_RESULTS_KEY = "wifi_keep_scan_results"
 RUNTIME_POWER_SAVE_KEY = "wifi_runtime_power_save"
 RUNTIME_ROAMING_SUPPRESSION_KEY = "wifi_runtime_roaming_suppression"
@@ -31,6 +31,11 @@ template<typename... Ts> class WiFiDisableAction final : public Action<Ts...> {
  void play(const Ts &...x) override { global_wifi_component->disable(); }
 };
 template<typename... Ts> class WiFiRoamAction final : public Action<Ts...> {
 public:
  void play(const Ts &...x) override { global_wifi_component->force_roam_check(); }
 };
 template<typename... Ts> class WiFiConfigureAction final : public Action<Ts...>, public Component {
 public:
  TEMPLATABLE_VALUE(std::string, ssid)
@@ -846,17 +846,18 @@ void WiFiComponent::loop() {
          this->notify_connect_state_listeners_();
 #endif
-          // Post-connect roaming: check for better AP
+          // Post-connect roaming: check for better AP. A scan may have been started by an
-          if (this->post_connect_roaming_) {
+          // explicit force_roam_check() even when post_connect_roaming_ is disabled, so the
-            if (this->is_roaming_scan_active()) {
+          // scan must always be consumed here to avoid leaving roaming_state_ stuck.
-              if (this->scan_done_) {
+          if (this->is_roaming_scan_active()) {
-                this->process_roaming_scan_();
+            if (this->scan_done_) {
-              }
+              this->process_roaming_scan_();
              // else: scan in progress, wait
            } else if (this->roaming_state_ == RoamingState::IDLE && this->roaming_attempts_ < ROAMING_MAX_ATTEMPTS &&
                       now - this->roaming_last_check_ >= ROAMING_CHECK_INTERVAL && !this->roaming_suppressed_()) {
              this->check_roaming_(now);
            }
            // else: scan in progress, wait
          } else if (this->post_connect_roaming_ && this->roaming_state_ == RoamingState::IDLE &&
                     this->roaming_attempts_ < ROAMING_MAX_ATTEMPTS &&
                     now - this->roaming_last_check_ >= ROAMING_CHECK_INTERVAL && !this->roaming_suppressed_()) {
            this->check_roaming_(now);
          }
        }
        break;
@@ -2463,6 +2464,17 @@ void WiFiComponent::notify_scan_results_listeners_() {
 }
 #endif  // USE_WIFI_SCAN_RESULTS_LISTENERS
 void WiFiComponent::force_roam_check() {
  if (!this->is_connected() || this->roaming_state_ != RoamingState::IDLE || this->roaming_suppressed_()) {
    ESP_LOGD(TAG, "Roam check requested, but not able to check now");
    return;
  }
  // Reset the attempt counter so a prior run of failed roams doesn't block this explicit request
  // Note that this re-arms automatic roaming if enabled.
  this->roaming_attempts_ = 0;
  this->check_roaming_(millis());
 }
 void WiFiComponent::check_roaming_(uint32_t now) {
  // Guard: not for hidden networks (may not appear in scan)
  const WiFiAP *selected = this->get_selected_sta_();
@@ -2484,7 +2496,11 @@ void WiFiComponent::check_roaming_(uint32_t now) {
  ESP_LOGD(TAG, "Roam scan (%d dBm, attempt %u/%u)", rssi, this->roaming_attempts_, ROAMING_MAX_ATTEMPTS);
  this->roaming_state_ = RoamingState::SCANNING;
-  this->wifi_scan_start_(this->passive_scan_);
+  if (!this->wifi_scan_start_(this->passive_scan_)) {
    // Scan failed to start (e.g. busy) - don't get stuck in SCANNING forever
    ESP_LOGD(TAG, "Roam scan failed to start");
    this->roaming_state_ = RoamingState::IDLE;
  }
 }
 void WiFiComponent::process_roaming_scan_() {
@@ -565,6 +565,12 @@ class WiFiComponent final : public Component {
  void set_keep_scan_results(bool keep_scan_results) { this->keep_scan_results_ = keep_scan_results; }
  void set_post_connect_roaming(bool enabled) { this->post_connect_roaming_ = enabled; }
  /** Force an immediate post-connect roaming check, bypassing the periodic interval and the
   * per-connection attempt limit. Does nothing (besides a debug log) if not connected, if a
   * roam scan or connect is already in progress, or if roaming is currently suppressed.
   */
  void force_roam_check();
 #ifdef USE_WIFI_CONNECT_TRIGGER
  Trigger<> *get_connect_trigger() { return &this->connect_trigger_; }
 #endif
@@ -4,6 +4,7 @@ from __future__ import annotations
 from collections.abc import Callable
 from contextlib import contextmanager, suppress
 import copy
 from datetime import datetime
 from ipaddress import (
    AddressValueError,
@@ -419,6 +420,37 @@ 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."""
@@ -4,7 +4,7 @@ from enum import Enum
 from esphome.enum import StrEnum
-__version__ = "2026.9.0b2"
+__version__ = "2026.10.0-dev"
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (
@@ -40,16 +40,31 @@ bool StaticTask::create(TaskFunction_t fn, const char *name, uint32_t stack_size
  return true;
 }
-void StaticTask::destroy() {
+bool StaticTask::destroy() {
-  if (this->handle_ != nullptr) {
+  if (this->handle_ == nullptr) {
-    TaskHandle_t handle = this->handle_;
+    return true;
    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;
 }
-void StaticTask::deallocate() {
+bool StaticTask::deallocate() {
-  this->destroy();
+  if (!this->destroy()) {
    return false;
  }
  if (this->stack_buffer_ != nullptr) {
    RAMAllocator<StackType_t> allocator(this->use_psram_ ? RAMAllocator<StackType_t>::ALLOC_EXTERNAL
                                                         : RAMAllocator<StackType_t>::ALLOC_INTERNAL);
@@ -57,6 +72,7 @@ void StaticTask::deallocate() {
    this->stack_buffer_ = nullptr;
    this->stack_size_ = 0;
  }
  return true;
 }
 }  // namespace esphome
@@ -11,6 +11,7 @@ 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:
@@ -23,7 +24,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 StackType_t words
+  /// @param stack_size Stack size in bytes (StackType_t is a byte on ESP-IDF)
  /// @param param      Parameter passed to task function
  /// @param priority   FreeRTOS task priority
  /// @param use_psram  If true, allocate stack in PSRAM; otherwise internal RAM
@@ -31,11 +32,17 @@ 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 but keep the stack buffer allocated for reuse by a subsequent create() call.
+  /// @brief Delete the task, keeping the stack buffer allocated for reuse by a subsequent create() call.
-  void destroy();
+  /// 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 (if running) and free the stack buffer.
+  /// @brief Delete the task (if created) and free the stack buffer.
-  void deallocate();
+  /// @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();
 protected:
  TaskHandle_t handle_{nullptr};
@@ -96,6 +96,10 @@ 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__)
@@ -694,8 +698,7 @@ def perform_ota(
    _LOGGER.info("Handshake complete")
-    # Timeout must match device-side OTA_SOCKET_TIMEOUT_DATA to prevent premature failures
+    sock.settimeout(DATA_PHASE_TIMEOUT)
    sock.settimeout(90.0)
    if extended_proto:
        send_check(sock, ota_type, "ota type")
@@ -854,7 +857,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
-    # 90s data timeout, which outlasts this budget; the retries target the
+    # 105s 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 = ""
@@ -69,10 +69,7 @@ def _make_create_connection() -> Callable[..., socket.socket]:
    from aiohappyeyeballs import start_connection
    from urllib3.exceptions import LocationParseError
-    from urllib3.util.connection import (  # noqa: PLC2701
+    from urllib3.util.connection import _set_socket_options, allowed_gai_family  # noqa: PLC2701
        _set_socket_options,
        allowed_gai_family,
    )
    from urllib3.util.timeout import _DEFAULT_TIMEOUT  # noqa: PLC2701
    from esphome import async_thread
@@ -616,11 +616,15 @@ 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:
@@ -951,8 +951,10 @@ 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
@@ -2,7 +2,8 @@
 Invoked via ``python -m esphome.platformio.runner`` instead of
 ``python -m platformio`` so that the patches (incremental rebuild
-preservation, download retries) apply inside the subprocess. Running
+preservation, download retries, skipping the private-package probe) apply
 inside the subprocess. Running
 PlatformIO in a subprocess keeps its ``sys.path`` mutations and other
 global state from leaking into the ESPHome process.
 """
@@ -105,6 +106,16 @@ 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.
@@ -152,6 +163,7 @@ FILTER_PLATFORMIO_LINES = [
 def main() -> int:
    patch_structhash()
    patch_file_downloader()
    patch_registry_private_packages()
    # Wrap stdout/stderr with RedirectText before PlatformIO runs:
    #
@@ -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.24                 ; noise (api, ota)
+    esphome/noise-c@0.1.26                 ; 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.24                ; noise (api, ota)
+    esphome/noise-c@0.1.26                ; 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.24  ; used by noise (api, ota)
+    esphome/noise-c@0.1.26  ; used by noise (api, ota)
    lvgl/lvgl@9.5.0         ; lvgl
 build_flags =
    ${common.build_flags}
@@ -10,11 +10,11 @@ tzlocal==5.4.4    # from time
 tzdata>=2026.3  # from time
 pyserial==3.5
 platformio==6.1.19
-esptool==5.3.1
+esptool==5.4.0
 click==8.3.3
 aioesphomeapi==46.3.0
 aiohappyeyeballs==2.7.1  # Happy Eyeballs for requests downloads; already pulled in by aioesphomeapi
-zeroconf==0.151.2
+zeroconf==0.151.3
 puremagic==2.2.0
 ruamel.yaml==0.19.1 # dashboard_import
 ruamel.yaml.clib==0.2.15 # dashboard_import
@@ -27,9 +27,9 @@ bleak==3.0.2
 smpclient==7.2.0
 requests==2.34.2
 py7zr==1.1.3
-platformdirs==4.11.5  # native esp-idf toolchain global cache dir
+platformdirs==4.11.7  # native esp-idf toolchain global cache dir
-ninja==1.13.0  # native esp8266 arduino toolchain build driver
+ninja==1.13.2  # native esp8266 arduino toolchain build driver
-filelock==3.32.4  # inter-process locks (PlatformIO cache heal, git clone cache); >=3.32 for FileLock(fallback_to_soft=...), older versions silently drop the kwarg
+filelock==3.32.5  # inter-process locks (PlatformIO cache heal, git clone cache); >=3.32 for FileLock(fallback_to_soft=...), older versions silently drop the kwarg
 # esp-idf >= 5.0 requires this
 pyparsing >= 3.3.2
@@ -1,4 +1,4 @@
 # Useful stuff when working in a development environment
-clang-format==13.0.1  # also change in .pre-commit-config.yaml and Dockerfile when updating
+clang-format==13.0.1  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
 clang-tidy==22.1.8
-yamllint==1.38.0  # also change in .pre-commit-config.yaml when updating
+yamllint==1.38.0  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
@@ -1,8 +1,9 @@
 pylint==4.0.8
-flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
+flake8==7.3.0  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
-ruff==0.16.5  # also change in .pre-commit-config.yaml when updating
+ruff==0.16.6  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
-pyupgrade==3.21.2  # also change in .pre-commit-config.yaml when updating
+pyupgrade==3.21.2  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
-prek==0.5.0  # also change in .github/workflows/ci.yml when updating
+prek==0.5.2  # .github/workflows/ci.yml reads this pin
 yamlrocks==0.6.1  # used by script/sync_dependency_versions.py
 # Unit tests
 pytest==9.1.1
@@ -1,20 +1,72 @@
 #!/bin/sh
 # Prepare the dev environment for a new checkout or worktree.
 #
-# Installed into the git hooks directory by script/setup. Deliberately tiny and
+# Installed into the git hooks directory by script/setup.py. Deliberately tiny
-# self-contained: it stays valid on branches where script/setup does not exist,
+# and self-contained: it stays valid on branches where the setup script does not
-# and simply does nothing there.
+# 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.
+# 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.
 [ -x "$top/venv/bin/python" ] && exit 0
-[ -x "$top/script/setup" ] || 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
 # 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.
-exec env -u VIRTUAL_ENV "$top/script/setup"
+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
@@ -1104,6 +1104,10 @@ 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
@@ -1123,6 +1127,19 @@ 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()}
@@ -1,71 +1,7 @@
 #!/usr/bin/env bash
-# Set up ESPHome dev environment
+# 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 -e
+exec python3 "$(dirname "$0")/setup.py" "$@"
 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
@@ -1,28 +1 @@
-@echo off
+@python "%~dp0setup.py" %*
 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.
@@ -0,0 +1,222 @@
 #!/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()
@@ -0,0 +1,164 @@
 #!/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())
@@ -0,0 +1,32 @@
 esphome:
  name: test-keyboard-no-label
 esp32:
  board: esp32dev
  framework:
    type: esp-idf
 spi:
  - id: spi_bus
    clk_pin: GPIO18
    mosi_pin: GPIO23
 display:
  - platform: mipi_spi
    spi_id: spi_bus
    model: st7789v
    id: tft_display
    dimensions:
      width: 240
      height: 320
    cs_pin: GPIO22
    dc_pin: GPIO21
    auto_clear_enabled: false
    invert_colors: false
    update_interval: never
 lvgl:
  displays: tft_display
  widgets:
    - keyboard:
        id: keyboard_widget
@@ -0,0 +1,34 @@
 esphome:
  name: test-qrcode-no-label
 esp32:
  board: esp32dev
  framework:
    type: esp-idf
 spi:
  - id: spi_bus
    clk_pin: GPIO18
    mosi_pin: GPIO23
 display:
  - platform: mipi_spi
    spi_id: spi_bus
    model: st7789v
    id: tft_display
    dimensions:
      width: 240
      height: 320
    cs_pin: GPIO22
    dc_pin: GPIO21
    auto_clear_enabled: false
    invert_colors: false
    update_interval: never
 lvgl:
  displays: tft_display
  widgets:
    - qrcode:
        id: qr_widget
        size: 100
        text: "esphome.io"
@@ -0,0 +1,35 @@
 esphome:
  name: test-tabview-no-label
 esp32:
  board: esp32dev
  framework:
    type: esp-idf
 spi:
  - id: spi_bus
    clk_pin: GPIO18
    mosi_pin: GPIO23
 display:
  - platform: mipi_spi
    spi_id: spi_bus
    model: st7789v
    id: tft_display
    dimensions:
      width: 240
      height: 320
    cs_pin: GPIO22
    dc_pin: GPIO21
    auto_clear_enabled: false
    invert_colors: false
    update_interval: never
 lvgl:
  displays: tft_display
  widgets:
    - tabview:
        id: tabview_widget
        tabs:
          - name: "Tab 1"
            id: tab_1
@@ -0,0 +1,32 @@
 """Widgets whose LVGL C implementation creates or references labels
 internally (tab titles, key legends, the QR canvas fallback) must declare
 the label dependency in ``get_uses()``. Otherwise a config that contains
 no ``label`` widget of its own compiles LVGL without ``LV_USE_LABEL`` and
 fails at C compile time with undefined ``lv_label_*`` symbols.
 """
 from __future__ import annotations
 from collections.abc import Callable
 from pathlib import Path
 import pytest
 from esphome.components.lvgl import defines as df
@pytest.mark.parametrize(
    "yaml_file",
    [
        "qrcode_no_label.yaml",
        "keyboard_no_label.yaml",
        "tabview_no_label.yaml",
    ],
 )
 def test_label_less_config_enables_lv_use_label(
    generate_main: Callable[[str | Path], str],
    component_config_path: Callable[[str], Path],
    yaml_file: str,
 ) -> None:
    generate_main(component_config_path(yaml_file))
    assert "LV_USE_LABEL" in df.get_defines()
@@ -0,0 +1,90 @@
 """Validation tests for the sendspin media_source platform.
 These cover the codec preference list, whose rejection branches a compile test
 cannot reach: a `test*.yaml` can only assert that a configuration is accepted.
 """
 from typing import Any
 import pytest
 from esphome import config_validation as cv
 from esphome.components.sendspin import CONF_CODECS, _get_data
 from esphome.components.sendspin.media_source import CONFIG_SCHEMA
 from esphome.const import PlatformFramework
 from esphome.types import ConfigType
 from tests.component_tests.types import SetCoreConfigCallable
 def _media_source_config(**overrides: Any) -> ConfigType:
    """Build a minimal valid media source config, allowing field overrides."""
    config: ConfigType = {
        "id": "sendspin_media_source",
        "sendspin_id": "sendspin_hub",
    }
    config.update(overrides)
    return config
 def test_default_codecs_at_48_khz(set_core_config: SetCoreConfigCallable) -> None:
    """Every codec is advertised when the sample rate suits all of them."""
    set_core_config(PlatformFramework.ESP32_IDF)
    config = CONFIG_SCHEMA(_media_source_config())
    assert config[CONF_CODECS] == ["flac", "opus", "pcm"]
 def test_default_codecs_drop_opus_at_other_rates(
    set_core_config: SetCoreConfigCallable,
 ) -> None:
    """Opus only supports 48 kHz, so it leaves the default list at other rates."""
    set_core_config(PlatformFramework.ESP32_IDF)
    config = CONFIG_SCHEMA(_media_source_config(sample_rate=44100))
    assert config[CONF_CODECS] == ["flac", "pcm"]
 def test_configured_order_is_preserved(set_core_config: SetCoreConfigCallable) -> None:
    """The list is a preference order, so it reaches the player role as written."""
    set_core_config(PlatformFramework.ESP32_IDF)
    CONFIG_SCHEMA(_media_source_config(codecs=["pcm", "flac"]))
    assert _get_data().player_config[CONF_CODECS] == ["pcm", "flac"]
 def test_empty_codec_list_rejected(set_core_config: SetCoreConfigCallable) -> None:
    """A player with no codecs at all could never be given a stream."""
    set_core_config(PlatformFramework.ESP32_IDF)
    with pytest.raises(cv.Invalid, match="length of value must be at least 1"):
        CONFIG_SCHEMA(_media_source_config(codecs=[]))
 def test_duplicate_codec_rejected(set_core_config: SetCoreConfigCallable) -> None:
    """A repeated codec has no meaning in a preference order."""
    set_core_config(PlatformFramework.ESP32_IDF)
    with pytest.raises(cv.Invalid, match="may only be listed once"):
        CONFIG_SCHEMA(_media_source_config(codecs=["flac", "flac"]))
 def test_unknown_codec_rejected(set_core_config: SetCoreConfigCallable) -> None:
    """Only codecs the player role can decode are accepted."""
    set_core_config(PlatformFramework.ESP32_IDF)
    with pytest.raises(cv.Invalid, match="Unknown value"):
        CONFIG_SCHEMA(_media_source_config(codecs=["mp3"]))
 def test_opus_at_wrong_sample_rate_rejected(
    set_core_config: SetCoreConfigCallable,
 ) -> None:
    """Asking for Opus at a rate it cannot handle fails rather than silently
    dropping the stated preference."""
    set_core_config(PlatformFramework.ESP32_IDF)
    with pytest.raises(cv.Invalid, match="requires a sample_rate of 48000"):
        CONFIG_SCHEMA(_media_source_config(codecs=["opus"], sample_rate=44100))
@@ -0,0 +1,76 @@
 """The template platforms surface value-describing metadata on the main form.
 Hardware platforms get sensible defaults for unit/device_class/etc., so those
 fields fall through to the editor's advanced disclosure. A ``template`` entity
 has no such defaults -- the user is expected to define them -- so the template
 platforms pass ``visibility=cv.Visibility.UI`` to promote them onto the form.
 """
 from __future__ import annotations
 import importlib
 import pytest
 import esphome.config_validation as cv
 def _markers(schema: cv.Schema) -> dict[str, object]:
    s = schema
    if hasattr(s, "validators"):
        # cv.All -> the schema is the first validator.
        s = s.validators[0]
    return {str(k): k for k in s.schema}
@pytest.mark.parametrize(
    ("platform", "fields"),
    [
        (
            "sensor",
            [
                "unit_of_measurement",
                "accuracy_decimals",
                "device_class",
                "state_class",
                "force_update",
            ],
        ),
        ("binary_sensor", ["device_class"]),
        ("switch", ["device_class"]),
        ("cover", ["device_class"]),
        ("button", ["device_class"]),
        ("valve", ["device_class"]),
        ("event", ["device_class"]),
        ("text_sensor", ["device_class"]),
        ("number", ["device_class", "unit_of_measurement"]),
    ],
 )
 def test_template_metadata_is_ui(platform: str, fields: list[str]) -> None:
    mod = importlib.import_module(f"esphome.components.template.{platform}")
    markers = _markers(mod.CONFIG_SCHEMA)
    for field in fields:
        assert markers[field].visibility is cv.Visibility.UI, f"{platform}.{field}"
 def test_template_sensor_promotion_preserves_defaults() -> None:
    """Promoting to UI must not drop the fields' defaults."""
    from esphome.components.template.sensor import CONFIG_SCHEMA
    markers = _markers(CONFIG_SCHEMA)
    assert markers["accuracy_decimals"].default() == 1
    assert markers["force_update"].default() is False
 def test_hardware_platform_metadata_not_promoted() -> None:
    """Without ``visibility=`` the builders leave metadata unset.
    Unset markers fall through to the consumer's ``Optional`` default of
    advanced, so hardware platforms are unaffected by the template promotion.
    """
    from esphome.components import binary_sensor, sensor
    hw_sensor = _markers(sensor.sensor_schema(device_class="temperature"))
    assert hw_sensor["device_class"].visibility is None
    hw_bs = _markers(binary_sensor.binary_sensor_schema(device_class="motion"))
    assert hw_bs["device_class"].visibility is None
@@ -0,0 +1,5 @@
 from tests.testing_helpers import ComponentManifestOverride
 def override_manifest(manifest: ComponentManifestOverride) -> None:
    manifest.dependencies = manifest.dependencies + ["sensor", "spi"]
@@ -0,0 +1,62 @@
 #include <gtest/gtest.h>
 #include "esphome/components/atm90e32/atm90e32.h"
 namespace esphome::atm90e32::testing {
 TEST(ATM90E32OffsetRegisterVerification, AcceptsExactSignedReadback) {
  EXPECT_TRUE(offset_register_value_matches(0x007B, 123));
  EXPECT_TRUE(offset_register_value_matches(0xFF85, -123));
 }
 TEST(ATM90E32OffsetRegisterVerification, RejectsMismatchedReadback) {
  EXPECT_FALSE(offset_register_value_matches(0x007C, 123));
  EXPECT_FALSE(offset_register_value_matches(0xFF84, -123));
 }
 TEST(ATM90E32OffsetRestoreState, ReportsVerifiedStoredValuesAsRestored) {
  const auto state = resolve_offset_restore_state(true, true, false);
  EXPECT_TRUE(state.restored);
  EXPECT_TRUE(state.values_verified);
 }
 TEST(ATM90E32OffsetRestoreState, ReportsVerifiedConfigFallbackAsNotRestored) {
  const auto state = resolve_offset_restore_state(true, false, true);
  EXPECT_FALSE(state.restored);
  EXPECT_TRUE(state.values_verified);
 }
 TEST(ATM90E32OffsetRestoreState, ReportsFailedConfigFallbackAsUnverified) {
  const auto state = resolve_offset_restore_state(true, false, false);
  EXPECT_FALSE(state.restored);
  EXPECT_FALSE(state.values_verified);
 }
 TEST(ATM90E32OffsetRestoreState, ReportsConfigWithoutStoredValuesAsNotRestored) {
  const auto state = resolve_offset_restore_state(false, true, false);
  EXPECT_FALSE(state.restored);
  EXPECT_TRUE(state.values_verified);
 }
 TEST(ATM90E32OffsetPersistence, RollsBackStoredValuesOrZeroSentinel) {
  const OffsetCalibration previous[3]{{1, -1}, {2, -2}, {3, -3}};
  OffsetCalibration rollback[3]{};
  prepare_offset_rollback(previous, true, rollback);
  for (uint8_t phase = 0; phase < 3; phase++) {
    EXPECT_EQ(rollback[phase].first_offset, previous[phase].first_offset);
    EXPECT_EQ(rollback[phase].second_offset, previous[phase].second_offset);
  }
  prepare_offset_rollback(previous, false, rollback);
  for (const auto &phase : rollback) {
    EXPECT_EQ(phase.first_offset, 0);
    EXPECT_EQ(phase.second_offset, 0);
  }
 }
 }  // namespace esphome::atm90e32::testing
@@ -0,0 +1,29 @@
 # Tuya without any network component (no wifi/ethernet/api), as used on
 # serial-only or BLE-only Tuya MCU boards. Regression test for
 # https://github.com/esphome/esphome/issues/18942
 substitutions:
  status_pin: P6
 packages:
  uart: !include ../../test_build_components/common/uart/bk72xx-ard.yaml
 tuya:
  status_pin: ${status_pin}
 binary_sensor:
  - platform: tuya
    id: tuya_presence
    sensor_datapoint: 101
 sensor:
  - platform: tuya
    id: tuya_light_intensity
    sensor_datapoint: 103
 number:
  - platform: tuya
    id: tuya_far_detection
    number_datapoint: 109
    min_value: 0
    max_value: 600
    step: 1
@@ -14,6 +14,7 @@ esphome:
          condition: wifi.ap_active
          then:
            - logger.log: "WiFi AP is active!"
      - wifi.roam
 wifi:
  networks:
@@ -21,6 +21,13 @@ The `yaml_config` fixture automatically loads YAML configurations based on the t
 - The fixture file must exist or the test will fail with a clear error message
 - The fixture automatically injects a dynamic port number into the API configuration
 Tests marked `@pytest.mark.shared_yaml("name")` load `fixtures/name.yaml` instead
 of the test-named file and compile it in a shared, hash-keyed build directory, so
 the whole group pays one full compile and each test only a relink. The marker
 argument must be a single-line string literal (CI test selection maps fixtures to
 test files by scanning for it), and marked tests must hand the `yaml_config`
 content to `run_compiled` unmodified.
 ### Key Fixtures
 - `run_compiled` - Combines write, compile, and run operations into a single context manager
@@ -4,17 +4,22 @@ from __future__ import annotations
 import asyncio
 from collections.abc import AsyncGenerator, Callable, Generator
-from contextlib import AbstractAsyncContextManager, asynccontextmanager
+from contextlib import AbstractAsyncContextManager, asynccontextmanager, suppress
 import fcntl
 from functools import cache
 import hashlib
 import logging
 import os
 from pathlib import Path
 import platform
 import re
 import shutil
 import signal
 import socket
 import subprocess
 import sys
 import tempfile
 import time
 from typing import TextIO
 from aioesphomeapi import APIClient, APIConnectionError, LogParser, ReconnectLogic
@@ -23,7 +28,13 @@ import pytest_asyncio
 import esphome.config
 from esphome.core import CORE
-from esphome.helpers import get_usable_cpu_count
+from esphome.helpers import (
    get_usable_cpu_count,
    read_file,
    rmtree,
    write_file,
    write_file_if_changed,
 )
 from esphome.platformio.toolchain import get_idedata
 from .const import (
@@ -56,6 +67,21 @@ import pty  # not available on Windows
 pytest.register_assert_rewrite("tests.integration.entity_utils")
 def pytest_configure(config: pytest.Config) -> None:
    config.addinivalue_line(
        "markers",
        "shared_yaml(name): load fixtures/<name>.yaml and compile it in a shared, "
        "hash-keyed incremental build directory",
    )
 FIXTURES_DIR = Path(__file__).parent / "fixtures"
 REPO_ROOT = Path(__file__).resolve().parent.parent.parent
 # CI caches parts of this path; keep in sync with ci.yml integration-tests.
 INTEGRATION_TESTS_ROOT = Path.home() / ".esphome-integration-tests"
 def _get_platformio_env(cache_dir: Path) -> dict[str, str]:
    """Get environment variables for PlatformIO with shared cache."""
    env = os.environ.copy()
@@ -78,7 +104,7 @@ def _get_platformio_env(cache_dir: Path) -> dict[str, str]:
        )
    # Compile with THIS tree's esphome sources, not wherever the venv's editable
    # install points (which may be a different git worktree or checkout).
-    repo_root = str(Path(__file__).resolve().parent.parent.parent)
+    repo_root = str(REPO_ROOT)
    existing = env.get("PYTHONPATH")
    env["PYTHONPATH"] = f"{repo_root}{os.pathsep}{existing}" if existing else repo_root
    return env
@@ -88,8 +114,7 @@ def _get_platformio_env(cache_dir: Path) -> dict[str, str]:
 def shared_platformio_cache() -> Generator[Path]:
    """Initialize a shared PlatformIO cache for all integration tests."""
    # Use a dedicated directory for integration tests to avoid conflicts.
-    # CI caches parts of this path; keep in sync with ci.yml integration-tests.
+    test_cache_dir = INTEGRATION_TESTS_ROOT
    test_cache_dir = Path.home() / ".esphome-integration-tests"
    cache_dir = test_cache_dir / "platformio"
    # Use a lock file in the home directory to ensure only one process initializes the cache
@@ -112,7 +137,9 @@ def shared_platformio_cache() -> Generator[Path]:
                init_dir = Path(tmpdir)
                fixture_path = Path(__file__).parent / "fixtures" / "cache_init.yaml"
                config_path = init_dir / "cache_init.yaml"
-                config_path.write_text(fixture_path.read_text())
+                config_path.write_text(
                    fixture_path.read_text(encoding="utf-8"), encoding="utf-8"
                )
                # Run compilation to populate the cache
                # We must succeed here to avoid race conditions where multiple
@@ -162,13 +189,6 @@ def integration_test_dir() -> Generator[Path]:
        yield Path(tmpdir)
@pytest.fixture
 def isolated_preferences(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
    """Host preferences persist per device name; give the test its own so a
    provisioned key never leaks into another run."""
    monkeypatch.setenv("ESPHOME_PREFDIR", str(tmp_path / "prefs"))
@pytest.fixture
 def reserved_tcp_port() -> Generator[tuple[int, socket.socket]]:
    """Reserve an unused TCP port by holding the socket open."""
@@ -188,21 +208,29 @@ def unused_tcp_port(reserved_tcp_port: tuple[int, socket.socket]) -> int:
    return reserved_tcp_port[0]
@pytest.fixture(autouse=True)
 def isolated_preferences(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> Path:
    """Give every test its own host prefs dir; prefs are keyed only by device
    name, which tests sharing a fixture also share."""
    prefdir = tmp_path / "prefs"
    monkeypatch.setenv("ESPHOME_PREFDIR", str(prefdir))
    return prefdir
@pytest_asyncio.fixture
 async def yaml_config(request: pytest.FixtureRequest, unused_tcp_port: int) -> str:
    """Load YAML configuration based on test name."""
-    # Get the test function name
+    shared_name = _shared_yaml_name(request)
-    test_name: str = request.node.name
+    # Base test name: test_ prefix and any parametrization stripped
-    # Extract the base test name (remove test_ prefix and any parametrization)
+    base_name = shared_name or request.node.name.replace("test_", "").partition("[")[0]
    base_name = test_name.replace("test_", "").partition("[")[0]
    # Load the fixture file
-    fixture_path = Path(__file__).parent / "fixtures" / f"{base_name}.yaml"
+    fixture_path = FIXTURES_DIR / f"{base_name}.yaml"
    if not fixture_path.exists():
        raise FileNotFoundError(f"Fixture file not found: {fixture_path}")
    loop = asyncio.get_running_loop()
-    content = await loop.run_in_executor(None, fixture_path.read_text)
+    content = await loop.run_in_executor(None, read_file, fixture_path)
    # Replace the port in the config if it contains api section
    if "api:" in content:
@@ -226,11 +254,13 @@ async def yaml_config(request: pytest.FixtureRequest, unused_tcp_port: int) -> s
    # Replace external component path placeholder if present
    if "EXTERNAL_COMPONENT_PATH" in content:
-        external_components_path = str(
+        external_components_path = str(FIXTURES_DIR / "external_components")
            Path(__file__).parent / "fixtures" / "external_components"
        )
        content = content.replace("EXTERNAL_COMPONENT_PATH", external_components_path)
    if shared_name is not None:
        # _compile verifies the marked test compiles this content unmodified
        request.node._shared_yaml_content = content
    return content
@@ -240,24 +270,218 @@ async def write_yaml_config(
 ) -> AsyncGenerator[ConfigWriter]:
    """Write YAML configuration to a file."""
    # Get the test name for default filename
-    test_name = request.node.name
+    base_name = request.node.name.replace("test_", "").partition("[")[0]
    base_name = test_name.replace("test_", "").split("[")[0]
    async def _write_config(content: str, filename: str | None = None) -> Path:
        if filename is None:
            filename = f"{base_name}.yaml"
        config_path = integration_test_dir / filename
        loop = asyncio.get_running_loop()
-        await loop.run_in_executor(None, config_path.write_text, content)
+        await loop.run_in_executor(None, write_file, config_path, content)
        return config_path
    yield _write_config
 # Deliberately not CI-cached (ci.yml caches only platformio/ subpaths); stale
 # dirs for a fixture are pruned when its content hash changes.
 SHARED_BUILDS_ROOT = INTEGRATION_TESTS_ROOT / "builds"
 # In the dir name (not just the hash) so pruning stays inside this checkout
 _REPO_KEY = hashlib.sha256(str(REPO_ROOT).encode()).hexdigest()[:8]
 # Give a contended shared build lock time for a full cold compile ahead of us
 _SHARED_LOCK_TIMEOUT_S = 900
 _SHARED_LOCK_POLL_S = 0.1
 _SHARED_LOCK_REPORT_S = 30
 # Reclaims dirs orphaned by fixture renames or deleted checkouts
 _STALE_BUILD_MAX_AGE_S = 30 * 24 * 3600
 # ELF path per shared build dir; constant once compiled, so resolve it only once
 _shared_elf_paths: dict[Path, Path] = {}
 # Dirs this process already swept; pruning is session-scoped work
 _pruned_dirs: set[Path] = set()
 def _shared_yaml_name(request: pytest.FixtureRequest) -> str | None:
    """Name passed to the shared_yaml marker, or None when unmarked."""
    marker = request.node.get_closest_marker("shared_yaml")
    if marker is None:
        return None
    # Exactly one \w+ positional arg: the name doubles as a build dir
    # component, and CI test selection (script/helpers.py) parses the same shape
    if (
        len(marker.args) != 1
        or marker.kwargs
        or not re.fullmatch(r"\w+", str(marker.args[0]))
    ):
        raise ValueError(
            "shared_yaml marker requires exactly one \\w+ fixture name literal"
        )
    return marker.args[0]
 def _shared_build_prefix(name: str) -> str:
    return f"{name}-{_REPO_KEY}-"
@cache
 def _shared_build_dir(name: str) -> Path:
    """Dir keyed by checkout and fixture source, before per-test injections."""
    key = hashlib.sha256((FIXTURES_DIR / f"{name}.yaml").read_bytes()).hexdigest()[:16]
    return SHARED_BUILDS_ROOT / (_shared_build_prefix(name) + key)
 def _read_stamp(stamp: Path, shared_dir: Path) -> Path | None:
    """ELF path recorded by the last completed compile, or None."""
    try:
        text = stamp.read_text(encoding="utf-8").strip()
    except FileNotFoundError:
        return None
    except OSError as err:
        print(f"Cannot read {stamp}: {err}")
        return None
    if not text:
        print(f"Ignoring empty stamp {stamp}")
        return None
    built = Path(text)
    # Never trust a stamp pointing outside its own build dir as an unlink target
    if shared_dir.resolve() in built.resolve().parents:
        return built
    print(f"Ignoring stamp {stamp} pointing outside {shared_dir}")
    return None
 def _unused_since(stale: Path, cutoff: float) -> bool:
    """Whether a build dir looks untouched since cutoff; unknown counts as used."""
    # Newest of the .built stamp (rewritten by every completed compile) and the
    # dir itself (freshened by a worker claiming the dir before locking)
    newest: float | None = None
    for probe in (stale / ".built", stale):
        try:
            mtime = probe.stat().st_mtime
        except FileNotFoundError:
            continue
        except NotADirectoryError:
            return True  # a stray file where a dir should be; reclaimable
        except OSError as err:
            print(f"Cannot age-probe {stale}: {err}")
            return False  # unknown never authorizes deletion
        newest = mtime if newest is None else max(newest, mtime)
    return newest is not None and newest < cutoff
 def _prune_stale_builds(name: str, keep: Path) -> None:
    """Remove outdated build dirs (blocking, run in executor): this checkout's
    other dirs for the fixture, plus anything untouched for 30 days. Tolerates
    other workers pruning the same dirs concurrently."""
    cutoff = time.time() - _STALE_BUILD_MAX_AGE_S
    prefix = _shared_build_prefix(name)
    for stale in SHARED_BUILDS_ROOT.iterdir():
        if stale == keep:
            continue
        same_fixture = stale.name.startswith(prefix)
        if not same_fixture and not _unused_since(stale, cutoff):
            continue
        # Creating .lock bumps the dir mtime, so remember whether the re-probe
        # under the lock can trust it
        lock_preexisting = (stale / ".lock").exists()
        try:
            lock_file = (stale / ".lock").open("w")
        except FileNotFoundError:
            continue  # pruned by another worker meanwhile
        except NotADirectoryError:
            print(f"Removing stray file {stale}")
            stale.unlink(missing_ok=True)
            continue
        except OSError as err:
            print(f"Cannot prune {stale}: {err}")
            continue
        with lock_file:
            try:
                fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
            except BlockingIOError:
                continue  # still in use by another run
            # Re-probe under the lock: a worker freshens its dir before
            # locking, so a just-claimed dir no longer looks unused. A dir
            # whose .lock we just created cannot be held by anyone, and our
            # own open bumped its mtime, so its pre-open probe stands
            if (
                lock_preexisting
                and not same_fixture
                and not _unused_since(stale, cutoff)
            ):
                continue
            # rmtree tolerates races; a leftover partial tree only costs a
            # rebuild, since the ELF is deleted before every compile
            try:
                rmtree(stale)
            except OSError as err:
                print(f"Failed to prune {stale}: {err}")
 async def _run_esphome_compile(
    config_path: Path, cwd: Path, env: dict[str, str]
 ) -> None:
    """Run `esphome compile`, retrying up to 3 times on a segfault."""
    max_retries = 3
    for attempt in range(max_retries):
        # Compile using subprocess, inheriting stdout/stderr to show progress
        proc = await asyncio.create_subprocess_exec(
            sys.executable,
            "-m",
            "esphome",
            "compile",
            str(config_path),
            cwd=cwd,
            stdout=None,  # Inherit stdout
            stderr=None,  # Inherit stderr
            stdin=asyncio.subprocess.DEVNULL,
            # Start in a new process group to isolate signal handling
            start_new_session=True,
            env=env,
            close_fds=False,
        )
        await proc.wait()
        if proc.returncode == 0:
            break
        if proc.returncode == -11 and attempt < max_retries - 1:
            # Segfault (-11 = SIGSEGV), retry
            print(
                f"Compilation segfaulted (attempt {attempt + 1}/{max_retries}), retrying..."
            )
            await asyncio.sleep(1)  # Brief pause before retry
            continue
        raise RuntimeError(
            f"Failed to compile {config_path}, return code: {proc.returncode}. "
            f"Run with 'pytest -s' to see compilation output."
        )
 def _resolve_compiled_binary(config_path: Path) -> Path:
    """Load the config to learn the compiled ELF path (blocking, run in executor)."""
    CORE.reset()  # Reset CORE state between test runs
    CORE.config_path = config_path
    config = esphome.config.read_config(
        {"command": "compile", "config": str(config_path)}
    )
    if config is None:
        raise RuntimeError(f"Failed to read config from {config_path}")
    idedata = get_idedata(config)
    binary_path = Path(idedata.firmware_elf_path)
    if not binary_path.exists():
        raise RuntimeError(f"Compiled binary not found at {binary_path}")
    return binary_path
@pytest_asyncio.fixture
 async def compile_esphome(
    integration_test_dir: Path,
    shared_platformio_cache: Path,
    request: pytest.FixtureRequest,
 ) -> AsyncGenerator[CompileFunction]:
    """Compile an ESPHome configuration and return the binary path."""
@@ -265,66 +489,96 @@ async def compile_esphome(
        # Use the shared PlatformIO cache for faster compilation
        # This avoids re-downloading dependencies for each test
        env = _get_platformio_env(shared_platformio_cache)
        # Retry compilation up to 3 times if we get a segfault
        max_retries = 3
        for attempt in range(max_retries):
            # Compile using subprocess, inheriting stdout/stderr to show progress
            proc = await asyncio.create_subprocess_exec(
                sys.executable,
                "-m",
                "esphome",
                "compile",
                str(config_path),
                cwd=integration_test_dir,
                stdout=None,  # Inherit stdout
                stderr=None,  # Inherit stderr
                stdin=asyncio.subprocess.DEVNULL,
                # Start in a new process group to isolate signal handling
                start_new_session=True,
                env=env,
                close_fds=False,
            )
            await proc.wait()
            if proc.returncode == 0:
                # Success!
                break
            if proc.returncode == -11 and attempt < max_retries - 1:
                # Segfault (-11 = SIGSEGV), retry
                print(
                    f"Compilation segfaulted (attempt {attempt + 1}/{max_retries}), retrying..."
                )
                await asyncio.sleep(1)  # Brief pause before retry
                continue
            # Other error or final retry
            raise RuntimeError(
                f"Failed to compile {config_path}, return code: {proc.returncode}. "
                f"Run with 'pytest -s' to see compilation output."
            )
        # Load the config to get idedata (blocking call, must use executor)
        loop = asyncio.get_running_loop()
-        def _read_config_and_get_binary():
+        name = _shared_yaml_name(request)
-            CORE.reset()  # Reset CORE state between test runs
+        if name is None:
-            CORE.config_path = config_path
+            await _run_esphome_compile(config_path, integration_test_dir, env)
-            config = esphome.config.read_config(
+            return await loop.run_in_executor(
-                {"command": "compile", "config": str(config_path)}
+                None, _resolve_compiled_binary, config_path
            )
            if config is None:
                raise RuntimeError(f"Failed to read config from {config_path}")
-            # Get the compiled binary path
+        # Shared fixture: build in a hash-keyed dir so tests sharing a config
-            idedata = get_idedata(config)
+        # pay one full compile and later only a main.cpp (port) rebuild + relink
-            return Path(idedata.firmware_elf_path)
+        shared_dir = _shared_build_dir(name)
-
+        shared_dir.mkdir(parents=True, exist_ok=True)
-        binary_path = await loop.run_in_executor(None, _read_config_and_get_binary)
+        # Freshen the dir before locking so a concurrent age sweep, which
-
+        # re-probes under the lock, never reaps a dir a worker just claimed;
-        if not binary_path.exists():
+        # if a peer reaped it already, the guarded lock open recreates it
-            raise RuntimeError(f"Compiled binary not found at {binary_path}")
+        with suppress(FileNotFoundError):
-
+            os.utime(shared_dir)
-        return binary_path
+        if shared_dir not in _pruned_dirs:
            _pruned_dirs.add(shared_dir)
            await loop.run_in_executor(None, _prune_stale_builds, name, shared_dir)
        shared_config = shared_dir / f"{name}.yaml"
        private_binary = integration_test_dir / f"{name}.elf"
        content = await loop.run_in_executor(None, read_file, config_path)
        if content != getattr(request.node, "_shared_yaml_content", None):
            # The dir is keyed by the fixture source; a mutated config would be
            # cached under a hash that does not describe it
            raise RuntimeError(
                "shared_yaml tests must compile the yaml_config content unmodified"
            )
        # flock serializes concurrent xdist workers; closing the fd releases it.
        # Hand-rolled rather than filelock.FileLock: non-blocking retries keep
        # the wait cancellable, while a blocking acquire in an executor thread
        # would survive test cancellation holding the fd
        try:
            lock_file = (shared_dir / ".lock").open("w")
        except FileNotFoundError:
            # A peer run pruning divergent hashes reaped the dir between our
            # mkdir and this open; recreate it and pay a full rebuild
            shared_dir.mkdir(parents=True, exist_ok=True)
            lock_file = (shared_dir / ".lock").open("w")
        with lock_file:
            start = time.monotonic()
            last_report = start
            while True:
                try:
                    fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
                    break
                except BlockingIOError:
                    now = time.monotonic()
                    if now - start > _SHARED_LOCK_TIMEOUT_S:
                        raise RuntimeError(
                            f"Timed out waiting for the {shared_dir} lock"
                        ) from None
                    if now - last_report >= _SHARED_LOCK_REPORT_S:
                        last_report = now
                        print(
                            f"Waited {now - start:.0f}s for another worker's "
                            f"build of {shared_dir.name}"
                        )
                    await asyncio.sleep(_SHARED_LOCK_POLL_S)
            # .built carries the ELF path of the last completed compile, so
            # later workers skip the config re-read in _resolve_compiled_binary
            stamp = shared_dir / ".built"
            if (built := _shared_elf_paths.get(shared_dir)) is None:
                built = await loop.run_in_executor(None, _read_stamp, stamp, shared_dir)
            # Delete the ELF before compiling: whatever exists afterwards is
            # this compile's output, so no staleness check is ever needed.
            # With no usable stamp, sweep any leftover at the known layout
            if built is not None:
                built.unlink(missing_ok=True)
            else:
                # Layout-agnostic: ESPHOME_BUILD_PATH can move the build tree
                for leftover in shared_dir.rglob("program"):
                    if leftover.is_file():
                        leftover.unlink()
            await loop.run_in_executor(
                None, write_file_if_changed, shared_config, content
            )
            await _run_esphome_compile(shared_config, shared_dir, env)
            if built is None or not built.exists():
                built = await loop.run_in_executor(
                    None, _resolve_compiled_binary, shared_config
                )
            _shared_elf_paths[shared_dir] = built
            await loop.run_in_executor(None, write_file, stamp, str(built))
            # Copy out before unlocking: another worker may relink firmware.elf
            # while this test is still running its private copy
            await loop.run_in_executor(None, shutil.copy2, built, private_binary)
        return private_binary
    yield _compile
@@ -1,58 +0,0 @@
 esphome:
  name: test-batch-window-filters
 host:
 api:
  batch_delay: 0ms  # Disable batching to receive all state updates
 logger:
  level: DEBUG
 # Template sensor that we'll use to publish values
 sensor:
  - platform: template
    name: "Source Sensor"
    id: source_sensor
    accuracy_decimals: 2
  # Batch window filters (window_size == send_every) - use streaming filters
  - platform: copy
    source_id: source_sensor
    name: "Min Sensor"
    id: min_sensor
    filters:
      - min:
          window_size: 5
          send_every: 5
          send_first_at: 1
  - platform: copy
    source_id: source_sensor
    name: "Max Sensor"
    id: max_sensor
    filters:
      - max:
          window_size: 5
          send_every: 5
          send_first_at: 1
  - platform: copy
    source_id: source_sensor
    name: "Moving Avg Sensor"
    id: moving_avg_sensor
    filters:
      - sliding_window_moving_average:
          window_size: 5
          send_every: 5
          send_first_at: 1
 # Button to trigger publishing test values
 button:
  - platform: template
    name: "Publish Values Button"
    id: publish_button
    on_press:
      - lambda: |-
          // Publish 10 values: 1.0, 2.0, ..., 10.0
          for (int i = 1; i <= 10; i++) {
            id(source_sensor).publish_state(float(i));
          }
@@ -1,111 +0,0 @@
 esphome:
  name: uart-mock-modbus-cli-rw
 host:
 api:
 logger:
  level: VERBOSE
 external_components:
  - source:
      type: local
      path: EXTERNAL_COMPONENT_PATH
 # Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
 # The actual UART bus used is the uart_mock component below
 uart:
  baud_rate: 115200
  port: /dev/null
 # Two virtual buses looped back to each other: the client's transmissions reach the server and the
 # server's replies reach the client. auto_start so forwarding is active before the button fires.
 uart_mock:
  - id: virtual_uart_server
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_client
              data: !lambda return data;
  - id: virtual_uart_client
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_server
              data: !lambda return data;
 globals:
  - id: stored_1
    type: uint16_t
    initial_value: "0"
 modbus:
  - uart_id: virtual_uart_server
    id: virtual_modbus_server
    role: server
  - uart_id: virtual_uart_client
    id: virtual_modbus_client
    role: client
    turnaround_time: 10ms
 modbus_server:
  - address: 1
    modbus_id: virtual_modbus_server
    registers:
      # Writable + readable register: the read publishes what it returns, so the test can confirm the
      # write half of the 0x17 ran before the read half (Modbus 6.17).
      - address: 0x01
        value_type: U_WORD
        read_lambda: |-
          id(srv_read_1).publish_state(id(stored_1));
          return id(stored_1);
        write_lambda: |-
          id(stored_1) = x;
          id(srv_write_1).publish_state(x);
          return true;
      # Read-only register, returned together with 0x01 by the 2-register read half.
      - address: 0x02
        value_type: U_WORD
        read_lambda: return 0x00AA;
 sensor:
  # Server-side observations.
  - platform: template
    name: "srv_write_1"
    id: srv_write_1
  - platform: template
    name: "srv_read_1"
    id: srv_read_1
  # Client-side read-back: the values the client's on_response received.
  - platform: template
    name: "client_read_0"
    id: client_read_0
  - platform: template
    name: "client_read_1"
    id: client_read_1
 button:
  - platform: template
    name: "Start Scenario"
    id: start_scenario_btn
    on_press:
      # FC 0x17: write reg 0x0001 = 0x1234, then read regs 0x0001..0x0002 back in the same transaction.
      - modbus_client.read_write_multiple_registers:
          address: 0x01
          read_address: 0x0001
          read_count: 2
          write_address: 0x0001
          values: [0x1234]
          on_response:
            then:
              - lambda: |-
                  // values is the read-back block: reg 0x0001 (must be the just-written 0x1234) and reg 0x0002.
                  if (values.size() >= 2) {
                    id(client_read_0).publish_state(values[0]);
                    id(client_read_1).publish_state(values[1]);
                  }
@@ -1,88 +0,0 @@
 esphome:
  name: uart-mock-modbus-custom-pdu
 host:
 api:
 logger:
  level: VERBOSE
 external_components:
  - source:
      type: local
      path: EXTERNAL_COMPONENT_PATH
 # Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
 # The actual UART bus used is the uart_mock component below
 uart:
  baud_rate: 115200
  port: /dev/null
 uart_mock:
  - id: virtual_uart_server
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_controller
              data: !lambda return data;
  - id: virtual_uart_controller
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_server
              data: !lambda return data;
 modbus:
  - uart_id: virtual_uart_server
    id: virtual_modbus_server
    role: server
  - uart_id: virtual_uart_controller
    id: virtual_modbus_controller
    role: client
    turnaround_time: 10ms
 modbus_controller:
  - address: 1
    modbus_id: virtual_modbus_controller
    id: modbus_controller_1
    update_interval: 1s
 modbus_server:
  - address: 1
    modbus_id: virtual_modbus_server
    id: modbus_server_1
    registers:
      - address: 0x01
        value_type: U_WORD
        read_lambda: return 259;
 sensor:
  # Plain read to confirm the controller <-> server link is up.
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "plain_read"
    address: 0x01
    register_type: holding
    value_type: U_WORD
  # Custom PDU: read holding register 0x0001, count 1. The PDU is
  # {function code, address hi, address lo, count hi, count lo}; the device
  # address and CRC are added by the hub. The lambda parses the response payload
  # (the register value, big-endian).
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "custom_read"
    custom_pdu: [0x03, 0x00, 0x01, 0x00, 0x01]
    lambda: |-
      if (data.size() < 2) return {};
      return (float) ((data[0] << 8) | data[1]);
 button:
  - platform: template
    name: "Start Scenario"
    id: start_scenario_btn
    # This test does not have anything to start (mock is autostart)
@@ -1,106 +0,0 @@
 esphome:
  name: uart-mock-modbus-dep-buffer
 host:
 api:
 logger:
  level: VERBOSE
 external_components:
  - source:
      type: local
      path: EXTERNAL_COMPONENT_PATH
 # Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
 # The actual UART bus used is the uart_mock component below
 uart:
  baud_rate: 115200
  port: /dev/null
 uart_mock:
  - id: virtual_uart_server
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_controller
              data: !lambda return data;
  - id: virtual_uart_controller
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_server
              data: !lambda return data;
 globals:
  - id: reg10
    type: uint16_t
    initial_value: "0"
 modbus:
  - uart_id: virtual_uart_server
    id: virtual_modbus_server
    role: server
  - uart_id: virtual_uart_controller
    id: virtual_modbus_controller
    role: client
    turnaround_time: 10ms
 modbus_controller:
  - address: 1
    modbus_id: virtual_modbus_controller
    id: modbus_controller_1
    update_interval: 1s
 modbus_server:
  - address: 1
    modbus_id: virtual_modbus_server
    id: modbus_server_1
    registers:
      - address: 0x10
        value_type: U_WORD
        read_lambda: return id(reg10);
        write_lambda: |-
          id(reg10) = x;
          return true;
 # A number whose write_lambda uses the DEPRECATED buffer parameter (fills `payload` with a legacy raw
 # frame as words: device address + function code + data) instead of the new item->write_* API. The write
 # must still land with its legacy semantics, and the one-time deprecation warning must fire only once per
 # entity no matter how many writes happen.
 number:
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "buf_number"
    id: buf_number
    address: 0x10
    register_type: holding
    value_type: U_WORD
    min_value: 0
    max_value: 1000
    step: 1
    write_lambda: |-
      // Legacy raw frame as words: [addr 0x01 | fc 0x06], register 0x0010, value.
      payload.push_back(0x0106);
      payload.push_back(0x0010);
      payload.push_back((uint16_t) x);
      return {};
 # Reports the server-side register so the test can observe that the deprecated buffer write landed.
 sensor:
  - platform: template
    name: "written_value"
    id: written_value
    update_interval: 0.5s
    lambda: "return id(reg10);"
 button:
  - platform: template
    name: "Start Scenario"
    id: start_scenario_btn
    # The test drives the writes via number_command; the mock is autostart.
@@ -1,95 +0,0 @@
 esphome:
  name: uart-mock-modbus-lambda-invert
 host:
 api:
 logger:
  level: VERBOSE
 external_components:
  - source:
      type: local
      path: EXTERNAL_COMPONENT_PATH
 # Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
 # The actual UART bus used is the uart_mock component below
 uart:
  baud_rate: 115200
  port: /dev/null
 uart_mock:
  - id: virtual_uart_server
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_controller
              data: !lambda return data;
  - id: virtual_uart_controller
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_server
              data: !lambda return data;
 globals:
  - id: reg40
    type: uint16_t
    initial_value: "5"
 modbus:
  - uart_id: virtual_uart_server
    id: virtual_modbus_server
    role: server
  - uart_id: virtual_uart_controller
    id: virtual_modbus_controller
    role: client
    turnaround_time: 10ms
 modbus_controller:
  - address: 1
    modbus_id: virtual_modbus_controller
    id: modbus_controller_1
    update_interval: 1s
 modbus_server:
  - address: 1
    modbus_id: virtual_modbus_server
    id: modbus_server_1
    registers:
      - address: 0x40
        value_type: U_WORD
        read_lambda: return id(reg40);
        write_lambda: id(reg40) = x; return true;
 # An active-low holding switch: the write_lambda inverts the wire value, but the entity must still
 # report the REQUESTED state. assumed_state keeps the register unpolled, so the published state comes
 # only from write_state() - turning ON writes 0x0000 yet the switch shows ON.
 switch:
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "invert_switch"
    register_type: holding
    address: 0x40
    assumed_state: true
    write_lambda: |-
      return !x;
 sensor:
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "reg_40"
    address: 0x40
    register_type: holding
    value_type: U_WORD
 button:
  - platform: template
    name: "Start Scenario"
    id: start_scenario_btn
    # This test does not have anything to start (mock is autostart)
@@ -1,97 +0,0 @@
 esphome:
  name: uart-mock-modbus-lambda-write
 host:
 api:
 logger:
  level: VERBOSE
 external_components:
  - source:
      type: local
      path: EXTERNAL_COMPONENT_PATH
 # Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
 # The actual UART bus used is the uart_mock component below
 uart:
  baud_rate: 115200
  port: /dev/null
 uart_mock:
  - id: virtual_uart_server
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_controller
              data: !lambda return data;
  - id: virtual_uart_controller
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_server
              data: !lambda return data;
 globals:
  - id: reg30
    type: uint16_t
    initial_value: "0"
 modbus:
  - uart_id: virtual_uart_server
    id: virtual_modbus_server
    role: server
  - uart_id: virtual_uart_controller
    id: virtual_modbus_controller
    role: client
    turnaround_time: 10ms
 modbus_controller:
  - address: 1
    modbus_id: virtual_modbus_controller
    id: modbus_controller_1
    update_interval: 1s
 modbus_server:
  - address: 1
    modbus_id: virtual_modbus_server
    id: modbus_server_1
    registers:
      - address: 0x30
        value_type: U_WORD
        read_lambda: return id(reg30);
        write_lambda: id(reg30) = x; return true;
 # A COIL-type switch (assumed_state, write-only) whose write_lambda ignores its own coil type and instead
 # drives a HOLDING-REGISTER write on the mock server through the entity itself: `item` IS the command, so
 # item->write_single_register() sends a register write from a coil entity (cross-type). Returning nothing
 # (an empty optional) tells the write path the lambda already dispatched the frame - no default coil write.
 switch:
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "cross_switch"
    register_type: coil
    address: 0x00
    assumed_state: true
    write_lambda: |-
      item->write_single_register(0x30, x ? 1234 : 0);
      return {};
 sensor:
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "reg_30"
    address: 0x30
    register_type: holding
    value_type: U_WORD
 button:
  - platform: template
    name: "Start Scenario"
    id: start_scenario_btn
    # This test does not have anything to start (mock is autostart)
@@ -0,0 +1,233 @@
 esphome:
  name: uart-mock-modbus-loopback
 host:
 api:
 logger:
  level: VERBOSE
 external_components:
  - source:
      type: local
      path: EXTERNAL_COMPONENT_PATH
 # Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
 # The actual UART bus used is the uart_mock component below
 uart:
  baud_rate: 115200
  port: /dev/null
 # Shared loopback fixture (see the shared_yaml markers in the test file);
 # register spaces are disjoint so each test only observes its own entities.
 uart_mock:
  - id: virtual_uart_server
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_controller
              data: !lambda return data;
  - id: virtual_uart_controller
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_server
              data: !lambda return data;
 globals:
  - id: reg10
    type: uint16_t
    initial_value: "100"
  - id: reg11
    type: uint16_t
    initial_value: "200"
  - id: reg12
    type: uint16_t
    initial_value: "300"
  - id: reg13
    type: uint16_t
    initial_value: "0xABCD"
  - id: reg30
    type: uint16_t
    initial_value: "0"
  - id: reg40
    type: uint16_t
    initial_value: "5"
  - id: reg50
    type: uint16_t
    initial_value: "0"
 modbus:
  - uart_id: virtual_uart_server
    id: virtual_modbus_server
    role: server
  - uart_id: virtual_uart_controller
    id: virtual_modbus_controller
    role: client
    turnaround_time: 10ms
 modbus_controller:
  - address: 1
    modbus_id: virtual_modbus_controller
    id: modbus_controller_1
    update_interval: 1s
 modbus_server:
  - address: 1
    modbus_id: virtual_modbus_server
    registers:
      - address: 0x01
        value_type: U_WORD
        read_lambda: return 259;
      - address: 0x10
        value_type: U_WORD
        read_lambda: return id(reg10);
        write_lambda: id(reg10) = x; return true;
      - address: 0x11
        value_type: U_WORD
        read_lambda: return id(reg11);
        write_lambda: id(reg11) = x; return true;
      - address: 0x12
        value_type: U_WORD
        read_lambda: return id(reg12);
        write_lambda: id(reg12) = x; return true;
      - address: 0x13
        value_type: U_WORD
        read_lambda: return id(reg13);
      - address: 0x30
        value_type: U_WORD
        read_lambda: return id(reg30);
        write_lambda: id(reg30) = x; return true;
      - address: 0x40
        value_type: U_WORD
        read_lambda: return id(reg40);
        write_lambda: id(reg40) = x; return true;
      - address: 0x50
        value_type: U_WORD
        read_lambda: return id(reg50);
        write_lambda: id(reg50) = x; return true;
 # Byte-based offset: 2 bytes -> register 0x11 (the old code folded it in as a
 # register count, hitting 0x12). assumed_state keeps the switch write-only.
 switch:
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "offset_switch"
    register_type: holding
    address: 0x10
    offset: 2
    assumed_state: true
  # Reading switch, byte offset 6 -> register 0x13; the pre-fix resolution (0x16)
  # would draw ILLEGAL_DATA_ADDRESS and never publish.
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "read_offset_switch"
    register_type: holding
    address: 0x10
    offset: 6
    bitmask: 0x1
  # Coil switch whose write_lambda dispatches a holding-register write via `item`;
  # returning an empty optional suppresses the default coil write.
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "cross_switch"
    register_type: coil
    address: 0x00
    assumed_state: true
    write_lambda: |-
      item->write_single_register(0x30, x ? 1234 : 0);
      return {};
  # Active-low: the write_lambda inverts the wire value but the entity must still
  # report the requested state (assumed_state keeps the register unpolled).
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "invert_switch"
    register_type: holding
    address: 0x40
    assumed_state: true
    write_lambda: |-
      return !x;
 # Uses the deprecated buffer parameter (legacy raw frame as words); the write
 # must land and the deprecation warning must fire only once per entity.
 number:
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "buf_number"
    id: buf_number
    address: 0x50
    register_type: holding
    value_type: U_WORD
    min_value: 0
    max_value: 1000
    step: 1
    write_lambda: |-
      // Legacy raw frame as words: [addr 0x01 | fc 0x06], register 0x0050, value.
      payload.push_back(0x0106);
      payload.push_back(0x0050);
      payload.push_back((uint16_t) x);
      return {};
 sensor:
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "plain_read"
    address: 0x01
    register_type: holding
    value_type: U_WORD
  # Custom PDU: read holding register 0x0001; device address and CRC are added
  # by the hub. The lambda parses the big-endian register value.
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "custom_read"
    custom_pdu: [0x03, 0x00, 0x01, 0x00, 0x01]
    lambda: |-
      if (data.size() < 2) return {};
      return (float) ((data[0] << 8) | data[1]);
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "reg_10"
    address: 0x10
    register_type: holding
    value_type: U_WORD
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "reg_11"
    address: 0x11
    register_type: holding
    value_type: U_WORD
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "reg_12"
    address: 0x12
    register_type: holding
    value_type: U_WORD
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "reg_30"
    address: 0x30
    register_type: holding
    value_type: U_WORD
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "reg_40"
    address: 0x40
    register_type: holding
    value_type: U_WORD
  # Reports the server-side register so the test can observe that the deprecated buffer write landed.
  - platform: template
    name: "written_value"
    id: written_value
    update_interval: 0.5s
    lambda: "return id(reg50);"
 button:
  - platform: template
    name: "Start Scenario"
    id: start_scenario_btn
    # Nothing to start (mock is autostart); tests drive entities directly
@@ -1,5 +1,5 @@
 esphome:
-  name: uart-mock-modbus-server-contro
+  name: uart-mock-modbus-mesh
 host:
 api:
@@ -17,13 +17,14 @@ uart:
  baud_rate: 115200
  port: /dev/null
 # Shared 3-bus mesh (see the shared_yaml markers): addr 1 = typed read-only
 # registers, addr 5 = the read/write 0x17 target, addr 2/3 on the second
 # server hub. auto_start everywhere: the controller polls at boot, so the
 # forwarding must already be live or early requests generate warnings.
 # Every test presses Start Scenario, so all merged actions fire in every test.
 uart_mock:
  - id: virtual_uart_server
    baud_rate: 9600
    # auto_start must be true for loopback fixtures: the modbus controller
    # polls on its update_interval immediately at boot, so the uart_mock
    # forwarding must already be active or early requests are lost and
    # generate modbus warnings.
    auto_start: true
    debug:
    on_tx:
@@ -31,35 +32,68 @@ uart_mock:
          - uart_mock.inject_rx:
              id: virtual_uart_controller
              data: !lambda return data;
-  - id: virtual_uart_controller
+          - uart_mock.inject_rx:
              id: virtual_uart_server_2
              data: !lambda return data;
  - id: virtual_uart_server_2
    baud_rate: 9600
-    auto_start: true # See comment on virtual_uart_server above
+    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_server
              data: !lambda return data;
          - uart_mock.inject_rx:
              id: virtual_uart_controller
              data: !lambda return data;
  - id: virtual_uart_controller
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_server
              data: !lambda return data;
          - uart_mock.inject_rx:
              id: virtual_uart_server_2
              data: !lambda return data;
 globals:
  - id: stored_1
    type: uint16_t
    initial_value: "0"
 modbus:
  - uart_id: virtual_uart_server
    id: virtual_modbus_server
    role: server
  - uart_id: virtual_uart_server_2
    id: virtual_modbus_server_2
    role: server
  - uart_id: virtual_uart_controller
-    id: virtual_modbus_controller
+    id: virtual_modbus_client
    role: client
    turnaround_time: 10ms
 modbus_controller:
  - address: 1
-    modbus_id: virtual_modbus_controller
+    modbus_id: virtual_modbus_client
    id: modbus_controller_1
    update_interval: 1s
  - address: 2
    modbus_id: virtual_modbus_client
    id: modbus_controller_2
    update_interval: 1s
  - address: 3
    modbus_id: virtual_modbus_client
    id: modbus_controller_3
    update_interval: 1s
 modbus_server:
  - address: 1
    modbus_id: virtual_modbus_server
    id: modbus_server_1
    registers:
      - address: 0x01
        value_type: U_WORD
@@ -103,6 +137,34 @@ modbus_server:
      - address: 0x28
        value_type: FP32_R
        read_lambda: return 3.14;
  - address: 5
    modbus_id: virtual_modbus_server
    registers:
      # Writable + readable register: srv_write_1 plus the client's read-back
      # confirm the write half of the 0x17 ran before the read half (Modbus 6.17).
      - address: 0x01
        value_type: U_WORD
        read_lambda: return id(stored_1);
        write_lambda: |-
          id(stored_1) = x;
          id(srv_write_1).publish_state(x);
          return true;
      # Read-only register, returned together with 0x01 by the 2-register read half.
      - address: 0x02
        value_type: U_WORD
        read_lambda: return 0x00AA;
  - address: 2
    modbus_id: virtual_modbus_server_2
    registers:
      - address: 0x01
        value_type: U_WORD
        read_lambda: return 919;
  - address: 3
    modbus_id: virtual_modbus_server_2
    registers:
      - address: 0x01
        value_type: U_WORD
        read_lambda: return 929;
 sensor:
  - platform: modbus_controller
@@ -195,9 +257,46 @@ sensor:
    address: 0x28
    register_type: holding
    value_type: FP32_R
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_2
    name: "multi_reg_a"
    address: 0x01
    register_type: holding
    value_type: U_WORD
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_3
    name: "multi_reg_b"
    address: 0x01
    register_type: holding
    value_type: U_WORD
  # client_read_write observations, server- and client-side.
  - platform: template
    name: "srv_write_1"
    id: srv_write_1
  - platform: template
    name: "client_read_0"
    id: client_read_0
  - platform: template
    name: "client_read_1"
    id: client_read_1
 button:
  - platform: template
    name: "Start Scenario"
    id: start_scenario_btn
-    # This test does not have anything to start (mock is autostart)
+    on_press:
      # FC 0x17: write reg 0x0001 = 0x1234, then read regs 0x0001..0x0002 back in the same transaction.
      - modbus_client.read_write_multiple_registers:
          address: 5
          read_address: 0x0001
          read_count: 2
          write_address: 0x0001
          values: [0x1234]
          on_response:
            then:
              - lambda: |-
                  // values is the read-back block: reg 0x0001 (must be the just-written 0x1234) and reg 0x0002.
                  if (values.size() >= 2) {
                    id(client_read_0).publish_state(values[0]);
                    id(client_read_1).publish_state(values[1]);
                  }
@@ -1,138 +0,0 @@
 esphome:
  name: uart-mock-modbus-reg-offset
 host:
 api:
 logger:
  level: VERBOSE
 external_components:
  - source:
      type: local
      path: EXTERNAL_COMPONENT_PATH
 # Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
 # The actual UART bus used is the uart_mock component below
 uart:
  baud_rate: 115200
  port: /dev/null
 uart_mock:
  - id: virtual_uart_server
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_controller
              data: !lambda return data;
  - id: virtual_uart_controller
    baud_rate: 9600
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_server
              data: !lambda return data;
 globals:
  - id: reg10
    type: uint16_t
    initial_value: "100"
  - id: reg11
    type: uint16_t
    initial_value: "200"
  - id: reg12
    type: uint16_t
    initial_value: "300"
  - id: reg13
    type: uint16_t
    initial_value: "0xABCD"
 modbus:
  - uart_id: virtual_uart_server
    id: virtual_modbus_server
    role: server
  - uart_id: virtual_uart_controller
    id: virtual_modbus_controller
    role: client
    turnaround_time: 10ms
 modbus_controller:
  - address: 1
    modbus_id: virtual_modbus_controller
    id: modbus_controller_1
    update_interval: 1s
 modbus_server:
  - address: 1
    modbus_id: virtual_modbus_server
    id: modbus_server_1
    registers:
      - address: 0x10
        value_type: U_WORD
        read_lambda: return id(reg10);
        write_lambda: id(reg10) = x; return true;
      - address: 0x11
        value_type: U_WORD
        read_lambda: return id(reg11);
        write_lambda: id(reg11) = x; return true;
      - address: 0x12
        value_type: U_WORD
        read_lambda: return id(reg12);
        write_lambda: id(reg12) = x; return true;
      - address: 0x13
        value_type: U_WORD
        read_lambda: return id(reg13);
        write_lambda: id(reg13) = x; return true;
 # A holding-register switch at 0x10 with a 2-BYTE offset. offset is byte-based, so the write must target
 # register 0x10 + 2/2 = 0x11. The old (pre-fix) behavior folded offset into the address as a register
 # count, hitting 0x12 instead. assumed_state keeps the switch write-only so it does not read any register.
 switch:
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "offset_switch"
    register_type: holding
    address: 0x10
    offset: 2
    assumed_state: true
  # A holding-register switch that READS its state. Byte offset 6 -> register 0x10 + 6/2 = 0x13. Post-fix
  # the switch itself resolves to 0x13 (the even byte offset folds into the address as whole registers) and
  # joins the 0x10..0x13 range, so no separate 0x13 sensor is needed. Pre-fix the whole byte offset folds
  # into the address (0x16), where the server answers ILLEGAL_DATA_ADDRESS and the switch never publishes.
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "read_offset_switch"
    register_type: holding
    address: 0x10
    offset: 6
    bitmask: 0x1
 sensor:
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "reg_10"
    address: 0x10
    register_type: holding
    value_type: U_WORD
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "reg_11"
    address: 0x11
    register_type: holding
    value_type: U_WORD
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "reg_12"
    address: 0x12
    register_type: holding
    value_type: U_WORD
 button:
  - platform: template
    name: "Start Scenario"
    id: start_scenario_btn
    # This test does not have anything to start (mock is autostart)
@@ -1,124 +0,0 @@
 esphome:
  name: uart-mock-modbus-server-test
 host:
 api:
 logger:
  level: VERBOSE
 external_components:
  - source:
      type: local
      path: EXTERNAL_COMPONENT_PATH
 # Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
 # The actual UART bus used is the uart_mock component below
 uart:
  baud_rate: 115200
  port: /dev/null
 uart_mock:
  - id: virtual_uart_dev
    baud_rate: 9600
    rx_full_threshold: 120
    rx_timeout: 2
    auto_start: false
    debug:
    injections:
      - delay: 100ms
        inject_rx: [0x01, 0x03, 0x00, 0x03, 0x00, 0x01, 0x74, 0x0A] #  Read holding register 3 on device 1 (basic_read)
      - delay: 100ms
        #  Read holding register 7 on device 2
        #  Reply from device 2
        #  Read holding register 5 on device 1 (read_after_peer_response)
        inject_rx:
          [
            0x02,
            0x03,
            0x00,
            0x07,
            0x00,
            0x01,
            0x35,
            0xF8,
            0x02,
            0x03,
            0x02,
            0x00,
            0xF0,
            0xFC,
            0x00,
            0x01,
            0x03,
            0x00,
            0x05,
            0x00,
            0x01,
            0x94,
            0x0B,
          ]
      - delay: 100ms
        inject_rx: [0x02, 0x03, 0x00, 0x07, 0x00, 0x01, 0x35, 0xF8] #  Read holding register 7 on device 2, with no response
      - delay: 100ms
        #  Read holding register 7 on device 2, with no response
        #  Read holding register A on device 1 (read_after_peer_timeout)
        inject_rx:
          [
            0x02,
            0x03,
            0x00,
            0x07,
            0x00,
            0x01,
            0x35,
            0xF8,
            0x01,
            0x03,
            0x00,
            0x0A,
            0x00,
            0x01,
            0xA4,
            0x08,
          ]
 modbus:
  uart_id: virtual_uart_dev
  role: server
 modbus_server:
  - address: 1
    registers:
      - address: 0x03
        value_type: U_WORD
        read_lambda: |-
          id(basic_read).publish_state(1);
          return 1;
      - address: 0x05
        value_type: U_WORD
        read_lambda: |-
          id(read_after_peer_response).publish_state(1);
          return 1;
      - address: 0x0A
        value_type: U_WORD
        read_lambda: |-
          id(read_after_peer_timeout).publish_state(1);
          return 1;
 sensor:
  - platform: template
    name: "basic_read"
    id: basic_read
  - platform: template
    name: "read_after_peer_response"
    id: read_after_peer_response
  - platform: template
    name: "read_after_peer_timeout"
    id: read_after_peer_timeout
 button:
  - platform: template
    name: "Start Scenario"
    id: start_scenario_btn
    on_press:
      - lambda: "id(virtual_uart_dev).start_scenario();"
@@ -1,116 +0,0 @@
 esphome:
  name: uart-mock-modbus-server-mult
 host:
 api:
 logger:
  level: VERBOSE
 external_components:
  - source:
      type: local
      path: EXTERNAL_COMPONENT_PATH
 # Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
 # The actual UART bus used is the uart_mock component below
 uart:
  baud_rate: 115200
  port: /dev/null
 uart_mock:
  - id: virtual_uart_server
    baud_rate: 9600
    # auto_start must be true for loopback fixtures: the modbus controller
    # polls on its update_interval immediately at boot, so the uart_mock
    # forwarding must already be active or early requests are lost and
    # generate modbus warnings.
    auto_start: true
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_controller
              data: !lambda return data;
          - uart_mock.inject_rx:
              id: virtual_uart_server_2
              data: !lambda return data;
  - id: virtual_uart_server_2
    baud_rate: 9600
    auto_start: true # See comment on virtual_uart_server above
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_server
              data: !lambda return data;
          - uart_mock.inject_rx:
              id: virtual_uart_controller
              data: !lambda return data;
  - id: virtual_uart_controller
    baud_rate: 9600
    auto_start: true # See comment on virtual_uart_server above
    debug:
    on_tx:
      - then:
          - uart_mock.inject_rx:
              id: virtual_uart_server
              data: !lambda return data;
          - uart_mock.inject_rx:
              id: virtual_uart_server_2
              data: !lambda return data;
 modbus:
  - uart_id: virtual_uart_server
    id: virtual_modbus_server
    role: server
  - uart_id: virtual_uart_server_2
    id: virtual_modbus_server_2
    role: server
  - uart_id: virtual_uart_controller
    id: virtual_modbus_client
    role: client
    turnaround_time: 10ms
 modbus_controller:
  - address: 1
    modbus_id: virtual_modbus_client
    update_interval: 1s
    id: modbus_controller_1
  - address: 2
    modbus_id: virtual_modbus_client
    update_interval: 1s
    id: modbus_controller_2
 modbus_server:
  - address: 1
    modbus_id: virtual_modbus_server
    registers:
      - address: 0x01
        value_type: U_WORD
        read_lambda: return 919;
  - address: 2
    modbus_id: virtual_modbus_server_2
    registers:
      - address: 0x01
        value_type: U_WORD
        read_lambda: return 929;
 sensor:
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_1
    name: "reg_u_word"
    address: 0x01
    register_type: holding
    value_type: U_WORD
  - platform: modbus_controller
    modbus_controller_id: modbus_controller_2
    name: "reg_u_word_2"
    address: 0x01
    register_type: holding
    value_type: U_WORD
 button:
  - platform: template
    name: "Start Scenario"
    id: start_scenario_btn
    # This test does not have anything to start (mock is autostart)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Anton Sergunov Jonathan Swoboda Jesse Hills	05f7d5e4f1	[mlx90614] pec validation (#6689 ) Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com> Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>	2026-09-10 16:14:43 +12:00
Robin ThoniandJesse Hills	ddbd89dd2a	[network] Improve `network::is_connected()` to better handle multiple interfaces (#18999 ) Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>	2026-09-10 04:06:44 +00:00
Jesse Hills	5ed59af920	[template] Surface value metadata on template entity forms (#17545 )	2026-09-10 14:11:13 +12:00
Jesse Hills	4868b498cf	[ci] Ask stale PR authors to merge dev instead of rebasing (#19064 )	2026-09-10 14:09:58 +12:00
Jesse Hills	c66fa81208	[core] Consolidate setup scripts into a cross-platform setup.py (#18856 )	2026-09-10 14:09:49 +12:00
esphome[bot]	58ca345684	[ci] Refresh integration test durations (#19049 )	2026-09-09 13:42:09 -04:00
Remco van Essen	fd598057ef	[sendspin] Fix codec enum codegen when codecs is not set (#19055 )	2026-09-09 08:22:23 -04:00
Jesse Hills	ef7279341f	Merge branch 'beta' into dev	2026-09-09 12:18:55 +12:00
Jesse Hills	69f2a7d556	Merge pull request #19051 from esphome/bump-2026.9.0b3 2026.9.0b3	2026-09-09 12:18:36 +12:00
Jesse Hills	008677298a	Bump version to 2026.9.0b3	2026-09-09 09:54:44 +12:00
Kevin AhrendtandJesse Hills	d2bc056f0a	[sendspin] Add codec preference list to the media source (#19047 ) Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>	2026-09-09 09:54:42 +12:00
J. Nick Koston	42fffd16fe	[esphome][core] Give a lost OTA chunk ack time to be retransmitted (#19041 )	2026-09-09 09:54:42 +12:00
J. Nick Koston	9c16aba6f7	[noise] Bump noise-c to 0.1.26 and libsodium to 1.10021.8 (#19030 )	2026-09-09 09:54:42 +12:00
Kevin Ahrendt	ac79173f4a	[i2s_audio] Fix spurious driver failure (#19045 )	2026-09-09 09:54:42 +12:00
Kevin Ahrendt	0a1e2acbcb	[audio][i2s_audio][micro_wake_word][microphone][mixer][resampler][speaker] Replace use_count() checks with lock and null test (#19046 )	2026-09-09 09:54:42 +12:00
Kevin AhrendtandCopilot Autofix powered by AI	9b6facb20d	[core] Fix use-after-free when deleting a running StaticTask (#19048 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-09-09 09:54:42 +12:00
esphome[bot]	f89b9e704c	Bump bundled esphome-device-builder to 1.14.5 (#19040 )	2026-09-09 09:54:42 +12:00
Johnandpre-commit-ci-lite[bot]	f8b2e53609	[atm90e32] Verify offset calibration writes (#18701 ) Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>	2026-09-09 09:54:42 +12:00
raykholo	7660dd7fa7	[anova] Re-assert temperature unit on every poll cycle (#17141 )	2026-09-09 09:54:42 +12:00
Bryan Li Bryan Li Claude Fable 5	c3ce07755f	[rf_bridge] Fix bucket sniffing with Portisch firmware (#17683 ) Co-authored-by: Bryan Li <bryanli@Bryans-MacBook-Pro.local> Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-09-09 09:54:42 +12:00
Gytis	f8a4cfa945	[lvgl] Add missing label dependency to qrcode, keyboard and tabview (#18387 )	2026-09-09 09:54:42 +12:00
J. Nick Koston	866ddb6e57	[core] Skip PlatformIO's private-package authorization probe (#18823 )	2026-09-09 09:54:42 +12:00
Jonathan Swoboda	ca864c22b4	[tuya] Build without a network component (#18948 )	2026-09-09 09:54:42 +12:00
Jesse Hills	c9729244af	[udp] Use cv.invalid for relocated packet_transport options (#19032 )	2026-09-09 09:54:42 +12:00
Davide D M	442e4a1ec2	[debug] Check reboot source pref on ESP_RST_WDT and guard against empty source (#17537 )	2026-09-09 09:54:41 +12:00
Pieter ViljoenandJesse Hills	199acdf522	[ble_client] Report Established from nodes that never read services (#17920 ) Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>	2026-09-09 09:54:41 +12:00
Samuel SiebandSamuel Sieb	9340863652	[dallas_temp] filter 85 temp from sensor reset (#17877 ) Co-authored-by: Samuel Sieb <samuel@sieb.net>	2026-09-09 09:54:41 +12:00
AndreKR	d5cff6e9df	[logger] Fix garbled stack traces (#17939 )	2026-09-09 09:54:41 +12:00
Ryan Ronnander	e7f45a0d31	[mqtt] Restore brightness flag in light discovery (#18950 )	2026-09-09 09:54:41 +12:00
mipa87andClaude	628ebe23ec	[audio] Do not treat MP3_STREAM_INFO_CHANGED as a fatal decoder error (#19028 ) Co-authored-by: Claude <noreply@anthropic.com>	2026-09-09 09:54:41 +12:00
mipa87 Claude pre-commit-ci-lite[bot]	823d79c948	[i2s_audio] Keep a start request that arrives while the speaker task stops (#19027 ) Co-authored-by: Claude <noreply@anthropic.com> Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>	2026-09-09 09:54:41 +12:00
Kevin AhrendtandJesse Hills	b947094f45	[sendspin] Add codec preference list to the media source (#19047 ) Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>	2026-09-09 09:31:18 +12:00
J. Nick Koston	6c5ab89d5f	[esphome][core] Give a lost OTA chunk ack time to be retransmitted (#19041 )	2026-09-09 09:08:16 +12:00
J. Nick Koston	8f511a365a	[noise] Bump noise-c to 0.1.26 and libsodium to 1.10021.8 (#19030 )	2026-09-09 09:07:06 +12:00
Kevin Ahrendt	006f31af93	[i2s_audio] Fix spurious driver failure (#19045 )	2026-09-09 09:05:02 +12:00
Kevin Ahrendt	5bb112f407	[audio][i2s_audio][micro_wake_word][microphone][mixer][resampler][speaker] Replace use_count() checks with lock and null test (#19046 )	2026-09-09 09:04:34 +12:00
dependabot[bot]	4ab9298ab3	Bump esptool from 5.3.1 to 5.4.0 (#19023 )	2026-09-08 22:11:36 +02:00
Kevin AhrendtandCopilot Autofix powered by AI	3926612281	[core] Fix use-after-free when deleting a running StaticTask (#19048 ) Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-09-09 07:46:17 +12:00
J. Nick Koston	1ce0bed3f6	[core] Share compiled binaries across modbus integration tests (#18945 )	2026-09-08 18:10:45 +02:00
esphome[bot]	f91486305f	Bump bundled esphome-device-builder to 1.14.5 (#19040 )	2026-09-08 15:21:48 +02:00
Johnandpre-commit-ci-lite[bot]	f191d5e0c3	[atm90e32] Verify offset calibration writes (#18701 ) Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>	2026-09-08 20:02:49 +12:00
Jesse Hills	227ca90aad	[core] Restore the shared git hooks after post-checkout runs script/setup (#19036 )	2026-09-08 20:00:08 +12:00
Jesse Hills	1700a40b7c	[core] Restore the shared git hooks after post-checkout runs script/setup (#19036 )	2026-09-08 19:59:55 +12:00
raykholo	28588310e7	[anova] Re-assert temperature unit on every poll cycle (#17141 )	2026-09-08 18:57:33 +12:00
Bryan Li Bryan Li Claude Fable 5	10a9baff74	[rf_bridge] Fix bucket sniffing with Portisch firmware (#17683 ) Co-authored-by: Bryan Li <bryanli@Bryans-MacBook-Pro.local> Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-09-08 18:36:42 +12:00
Gytis	a23f7bb569	[lvgl] Add missing label dependency to qrcode, keyboard and tabview (#18387 )	2026-09-08 18:31:30 +12:00
J. Nick Koston	53075e4139	[core] Skip PlatformIO's private-package authorization probe (#18823 )	2026-09-08 16:42:30 +12:00
Jonathan Swoboda	5722ccba37	[tuya] Build without a network component (#18948 )	2026-09-08 16:36:04 +12:00
Jesse Hills	94e5c3839d	[udp] Use cv.invalid for relocated packet_transport options (#19032 )	2026-09-08 16:17:22 +12:00
Davide D M	574762f078	[debug] Check reboot source pref on ESP_RST_WDT and guard against empty source (#17537 )	2026-09-08 13:59:05 +12:00
Pieter ViljoenandJesse Hills	d34ffaf392	[ble_client] Report Established from nodes that never read services (#17920 ) Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>	2026-09-08 01:57:50 +00:00
Samuel SiebandSamuel Sieb	e6aa575f2e	[dallas_temp] filter 85 temp from sensor reset (#17877 ) Co-authored-by: Samuel Sieb <samuel@sieb.net>	2026-09-08 13:27:49 +12:00
AndreKR	639ce609bf	[logger] Fix garbled stack traces (#17939 )	2026-09-08 13:13:51 +12:00
Ryan Ronnander	62eafc477d	[mqtt] Restore brightness flag in light discovery (#18950 )	2026-09-08 13:09:02 +12:00
mipa87andClaude	56c3361b9a	[audio] Do not treat MP3_STREAM_INFO_CHANGED as a fatal decoder error (#19028 ) Co-authored-by: Claude <noreply@anthropic.com>	2026-09-08 12:13:03 +12:00
mipa87 Claude pre-commit-ci-lite[bot]	50ca381198	[i2s_audio] Keep a start request that arrives while the speaker task stops (#19027 ) Co-authored-by: Claude <noreply@anthropic.com> Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>	2026-09-08 12:10:55 +12:00
dependabot[bot]	89a56298c2	Bump prek from 0.5.1 to 0.5.2 (#19021 ) Signed-off-by: dependabot[bot] <support@github.com>	2026-09-08 00:00:28 +00:00
dependabot[bot]esphome[bot]Jesse Hills	390742cf9b	Bump ruff from 0.16.5 to 0.16.6 (#19022 ) Co-authored-by: esphome[bot] <115708604+esphome[bot]@users.noreply.github.com> Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com> Signed-off-by: dependabot[bot] <support@github.com>	2026-09-07 23:47:46 +00:00
Jesse Hillsandpre-commit-ci-lite[bot]	5e37872da2	[ci] Sync pre-commit revs and prek version from requirements files (#19026 ) Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>	2026-09-08 10:32:18 +12:00
Jesse Hills	d34d3994e1	Merge branch 'beta' into dev	2026-09-07 12:50:44 +12:00
Jesse Hills	d58b37faa1	[esp32_hosted] Add ESP-NOW-over-hosted shim for the ESP32-P4 (#17712 )	2026-09-07 10:29:20 +12:00
J. Nick Koston	8966567be0	[core] Show the other downloader's progress while a prefetch job waits on its lock (#18983 )	2026-09-07 10:28:31 +12:00
J. Nick Koston	20c7dcb1dd	[mdns] Guard LEAmDNS main loop calls against lwIP re-entrancy on ESP8266 (#18990 )	2026-09-07 10:26:44 +12:00
J. Nick Koston	688af60cbf	[noise] Bump noise-c to 0.1.24 and libsodium to 1.10021.6 (#18989 )	2026-09-07 10:12:52 +12:00
esphome[bot]	9c00f13606	Bump bundled esphome-device-builder to 1.14.4 (#19006 )	2026-09-06 22:05:16 +00:00
J. Nick Koston	833dd0e812	[ota] Offer encryption with the api key so enabling it works over OTA (#18979 )	2026-09-06 23:59:40 +02:00
Ricardo Sanz	8e1044e8ea	[climate][template] New template climate component (#14455 )	2026-09-06 14:03:07 -07:00
esphome[bot]	e5200db6fd	Bump bundled esphome-device-builder to 1.14.3 (#18996 )	2026-09-06 09:28:02 +02:00
elwin loomis Claude Opus 5 Clyde Stubbs	e3dd2f44a4	[mipi_dsi] Let IDF pick the DPHY PLL reference clock (#18984 ) Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com> Co-authored-by: Clyde Stubbs <2366188+clydebarrow@users.noreply.github.com>	2026-09-05 21:08:21 +00:00
esphome[bot]	3ef7460fca	Bump bundled esphome-device-builder to 1.14.2 (#18988 )	2026-09-05 15:25:58 +00:00
Clyde Stubbs pre-commit-ci-lite[bot]Claude	ae187f81f2	[wifi] Allow a forced roam check (#17349 ) Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com> Co-authored-by: Claude <noreply@anthropic.com>	2026-09-05 21:44:37 +10:00
esphome[bot]	84f78831f9	Bump bundled esphome-device-builder to 1.14.1 (#18981 )	2026-09-05 13:07:15 +02:00
Keith Burzinski	13dbbcaa32	[usb_uart] Keep the comm interface number valid when its claim fails (#18968 )	2026-09-05 13:00:25 +02:00
Clyde Stubbs	b66822d9bd	[ai] Advice to agents to limit verbiage (#18980 )	2026-09-05 12:21:47 +02:00
dependabot[bot]	d1829c495d	Bump prek from 0.5.0 to 0.5.1 (#18977 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-09-04 19:05:36 -04:00
dependabot[bot]	ce87bf9b17	Bump platformdirs from 4.11.5 to 4.11.7 (#18976 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-09-04 19:05:26 -04:00
Jesse Hills	51ea97deff	[esp32_ble] Reference count BLE advertising (#18943 )	2026-09-05 08:38:55 +12:00
dependabot[bot]	ab800dc09d	Bump filelock from 3.32.4 to 3.32.5 (#18963 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-09-03 17:19:29 -04:00
J. Nick Kostonandpre-commit-ci-lite[bot]	f65ab5629e	[esp8266] Drop Arduino framework versions before 3.0.0 (#18917 ) to Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>	2026-09-03 15:16:36 -04:00
esphome[bot]andJonathan Swoboda	b84532d254	Bump bundled esphome-device-builder to 1.14.0 (#18960 ) Co-authored-by: esphome[bot] <115708604+esphome[bot]@users.noreply.github.com> Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>	2026-09-03 12:15:06 +00:00
Keith Burzinski	6b11636491	[remote_transmitter] Fix BK7231N build by limiting the PWM path to BK7238 (#18958 )	2026-09-03 08:12:36 -04:00
Jesse Hills	2bb98f2d64	Merge branch 'beta' into dev	2026-09-03 14:07:41 +12:00
Jesse Hills	f3c786c784	Bump version to 2026.10.0-dev	2026-09-03 13:07:21 +12:00
dependabot[bot]	2250430999	Bump zeroconf from 0.151.2 to 0.151.3 (#18951 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-09-02 20:56:51 -04:00
dependabot[bot]	d1068d582f	Bump ninja from 1.13.0 to 1.13.2 (#18952 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-09-02 20:56:42 -04:00