Revert "[api] Match log format types for the clamped version fields"

This reverts commit c212a46757.
[api] Match log format types for the clamped version fields
2026-08-23 22:56:19 +00:00 · 2026-08-19 20:42:08 -05:00 · 2026-08-19 20:41:02 -05:00 · 2026-08-19 20:23:24 -05:00 · 2026-08-19 18:11:21 -05:00 · 2026-08-19 17:47:35 -05:00
204 changed files with 2133 additions and 2640 deletions
@@ -32,7 +32,7 @@ runs:
      # detects the activated venv via ``VIRTUAL_ENV`` so the venv layout
      # downstream jobs rely on is preserved.
      if: steps.cache-venv.outputs.cache-hit != 'true'
-      uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+      uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
      with:
        enable-cache: true
        # Pull request saves land in per-PR scopes nothing else can
@@ -70,6 +70,7 @@ async function isStackedPr(github, context) {
 async function detectMergeBranch(github, context) {
  const labels = new Set();
  const baseRef = context.payload.pull_request.base.ref;
+  const defaultBranch = context.payload.repository.default_branch;

  if (baseRef === 'release') {
    labels.add('merging-to-release');
@@ -78,7 +79,7 @@ async function detectMergeBranch(github, context) {
  } else if (await isStackedPr(github, context)) {
    // GitHub manages the merge order for a stack, so these are not blocked.
    labels.add('stacked-pr');
-  } else if (baseRef !== 'dev') {
+  } else if (baseRef !== defaultBranch) {
    // A chain built by hand: it must not merge until its base branch does.
    labels.add('chained-pr');
  }
@@ -43,14 +43,14 @@ const WITHOUT_SCHEMA = 'CODEOWNERS = ["@esphome/core"]';

 // Builds a fresh context for detectMergeBranch tests instead of mutating the
 // shared CONTEXT fixture above (which other describe blocks rely on).
-function makeMergeContext(baseRef, { stack } = {}) {
+function makeMergeContext(baseRef, { stack, defaultBranch = 'dev' } = {}) {
  const pull_request = { number: 1, base: { ref: baseRef } };
  if (stack !== undefined) {
    pull_request.stack = stack;
  }
  return {
    repo: { owner: 'esphome', repo: 'esphome' },
-    payload: { pull_request }
+    payload: { pull_request, repository: { default_branch: defaultBranch } }
  };
 }

@@ -136,6 +136,21 @@ describe('detectMergeBranch', () => {
    assert.deepEqual(Array.from(labels).sort(), ['chained-pr']);
    assert.equal(state.calls, 1);
  });
+
+  it('base ref matches default branch adds no labels', async () => {
+    const { github } = makeStackGithub({ stack: null });
+    const context = makeMergeContext('other', { defaultBranch: 'other' });
+    const labels = await detectMergeBranch(github, context);
+    assert.deepEqual(Array.from(labels).sort(), []);
+  });
+
+  it('base ref dev when the default branch is main adds chained-pr', async () => {
+    const { github } = makeStackGithub({ stack: null });
+    const context = makeMergeContext('dev', { defaultBranch: 'main' });
+    const labels = await detectMergeBranch(github, context);
+    assert.deepEqual(Array.from(labels).sort(), ['chained-pr']);
+  });
+
 });

 // ---------------------------------------------------------------------------
@@ -29,7 +29,7 @@ jobs:
      - name: Set up uv
        # ``--system`` (below) installs into the setup-python interpreter;
        # no venv is created or restored by this workflow.
-        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pull-request-only workflow: a save could never be shared and
@@ -49,7 +49,7 @@ jobs:
        # detects the activated venv via ``VIRTUAL_ENV`` so downstream jobs
        # that ``. venv/bin/activate`` see an identical layout.
        if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -376,7 +376,7 @@ jobs:
      - name: Set up uv
        # Only needed on cache miss to populate the venv.
        if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -447,8 +447,12 @@ jobs:
      - common
      - determine-jobs
    if: >-
-      (github.event_name == 'push' && github.ref_name == 'dev') ||
-      (github.event_name == 'pull_request' && needs.determine-jobs.outputs.benchmarks == 'true')
+      github.repository == 'esphome/esphome' && (
+        (github.event_name == 'push' && github.ref_name == 'dev') ||
+        (github.event_name == 'pull_request' && needs.determine-jobs.outputs.benchmarks == 'true')
+      )
+    # CodSpeed benchmarks require a CodSpeed account linked to the repository to run
+    # (https://codspeed.io) -- disabled on forks that aren't esphome/esphome itself.
    steps:
      - name: Check out code from GitHub
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -1149,7 +1153,7 @@ jobs:
        # install step (order-of-magnitude faster on cold boots,
        # with its own wheel cache). actions/setup-python still
        # provides the interpreter.
-        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -56,7 +56,7 @@ jobs:

      # Initializes the CodeQL tools for scanning.
      - name: Initialize CodeQL
-        uses: github/codeql-action/init@5595ccaf912efad79be6eef63a5619ff05969be3 # v4.37.6
+        uses: github/codeql-action/init@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7
        with:
          languages: ${{ matrix.language }}
          build-mode: ${{ matrix.build-mode }}
@@ -84,6 +84,6 @@ jobs:
          exit 1

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@5595ccaf912efad79be6eef63a5619ff05969be3 # v4.37.6
+        uses: github/codeql-action/analyze@ff2f1c621b7f889edc0d3c761ac2e6a3f8cdb0dd # v4.37.7
        with:
          category: "/language:${{matrix.language}}"
@@ -14,4 +14,4 @@ jobs:
    permissions:
      issues: write         # issues.lock on closed issues
      pull-requests: write  # issues.lock on closed pull requests
-    uses: esphome/workflows/.github/workflows/lock.yml@9f6577fd37b5cf773ab1b9be929714a0dcd15661  # 2026.7.0
+    uses: esphome/workflows/.github/workflows/lock.yml@0fdd5e311b7e744069166696072a1a9cbc5fbeb6  # 2026.8.1
@@ -16,7 +16,7 @@ jobs:
    # No GITHUB_TOKEN permissions: the reusable workflow mints an ESPHome
    # GitHub App token so the labels, comments and closures come from
    # esphome[bot] instead of github-actions[bot].
-    uses: esphome/workflows/.github/workflows/stale.yml@61fd37a044cad4e9aa4303027b2a61b6a34da855  # main
+    uses: esphome/workflows/.github/workflows/stale.yml@a1c1485ab46ef41a84a6a9d8abd7fa4b7628fd70  # main
    secrets:
      ESPHOME_GITHUB_APP_PRIVATE_KEY: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
    with:
@@ -47,7 +47,7 @@ jobs:
        # setup-python interpreter so subsequent ``prek`` /
        # ``script/run-in-env.py`` steps find the deps without a
        # ``uv run`` prefix.
-        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
        with:
          enable-cache: true
          # Pin uv version so the action does not have to fetch the
@@ -11,7 +11,7 @@ ci:
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    # Ruff version.
-    rev: v0.16.0
+    rev: v0.16.3
    hooks:
      # Run the linter.
      - id: ruff
@@ -763,3 +763,13 @@ The project uses English for non-code content. When drafting documentation, code
 PR descriptions, and similar text, avoid technical jargon. Instead, express concepts in plain English,
 using standard technical terms only when required. Ensure the text is readily comprehensible to a wide
 audience, including non-native English speakers.
+
+## 10. Code Comments
+
+Code comments on individual lines should be used only where necessary to flag issues that may not be obvious
+on a simple reading of the code. Keep them short (e.g. 1 or 2 lines).
+
+Function and method comment blocks may include more detail as required to make
+calling contracts clear and document parameter usage, but should still be kept concise.
+
+Avoid redundancy and repetition; comments should never simply restate what the code already says.
@@ -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.8.1
+PROJECT_NUMBER         = 2026.9.0-dev

 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -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.12.4
+RUN uv pip install --no-cache-dir esphome-device-builder==1.12.0

 RUN \
    platformio settings set enable_telemetry No \
@@ -762,11 +762,9 @@ def _wrap_to_code(name, comp, yaml_util):
    async def wrapped(conf):
        cg.add(cg.LineComment(f"{name}:"))
        if comp.config_schema is not None:
-            # sort_keys: voluptuous fills defaults in set order, so an
-            # unsorted dump would churn main.cpp and relink every run
-            conf_str = yaml_util.dump(conf, sort_keys=True)
+            conf_str = yaml_util.dump(conf)
            conf_str = conf_str.replace("//", "")
-            # remove trailing \ to avoid multi-line comment warning
+            # remove tailing \ to avoid multi-line comment warning
            conf_str = conf_str.replace("\\\n", "\n")
            cg.add(cg.LineComment(indent(conf_str)))
        await coro(conf)
@@ -2734,7 +2732,8 @@ def run_esphome(argv):
                conf_path.name,
            )

-    if config is None:
+    cache_missed = config is None
+    if cache_missed:
        from esphome.config import read_config

        config = read_config(
@@ -2743,26 +2742,25 @@ def run_esphome(argv):
            # Snapshot only needed by `esphome config --no-defaults`.
            snapshot_user_config=getattr(args, "no_defaults", False),
        )
-        # Refresh the cache so the next upload/logs hits the fast path
-        # instead of re-running read_config. Skip when the storage
-        # sidecar is absent (no compile has run): the cache would
-        # never be loaded back, so writing secrets to disk is wasted.
-        if cache_eligible and config is not None:
-            from esphome.compiled_config import save_compiled_config
-            from esphome.storage_json import ext_storage_path
-
-            if ext_storage_path(conf_path.name).exists():
-                save_compiled_config(config)
-    if config is None:
-        return 2
+        if config is None:
+            return 2
    CORE.config = config

    # Fallback for platforms whose validators didn't set the toolchain
    # (only the esp32 component reads esp32.framework.toolchain). All
-    # other platforms only support PlatformIO today.
+    # other platforms only support PlatformIO today. Must run before the
+    # cache refresh below so its sidecar records the same toolchain a
+    # compile would.
    if CORE.toolchain is None:
        CORE.toolchain = Toolchain.PLATFORMIO

+    # Refresh the cache so the next upload/logs hits the fast path
+    # instead of re-running read_config.
+    if cache_eligible and cache_missed:
+        from esphome.compiled_config import save_compiled_config_and_sidecar
+
+        save_compiled_config_and_sidecar(config)
+
    if args.command not in POST_CONFIG_ACTIONS:
        safe_print(f"Unknown command {args.command}")
        return 1
@@ -18,9 +18,9 @@ from pathlib import Path
 from typing import Any

 from esphome.const import __version__ as ESPHOME_VERSION
-from esphome.core import CORE, Lambda
+from esphome.core import CORE, EsphomeError, Lambda
 from esphome.helpers import write_file
-from esphome.storage_json import StorageJSON, ext_storage_path
+from esphome.storage_json import StorageJSON, ext_storage_path, storage_path
 from esphome.types import ConfigType

 _LOGGER = logging.getLogger(__name__)
@@ -65,7 +65,71 @@ def save_compiled_config(config: ConfigType) -> None:
        # non-basic dict key), so every upload/logs pays the slow path.
        _LOGGER.warning("Cannot cache the validated config: %s", err)
    except Exception as err:  # noqa: BLE001  # pylint: disable=broad-except
-        _LOGGER.debug("Skipping compiled config cache write: %s", err)
+        # Likely persistent (permissions, full disk): every upload/logs
+        # pays the slow path until it clears, so surface it.
+        _LOGGER.warning("Skipping compiled config cache write: %s", err)
+
+
+def save_compiled_config_and_sidecar(config: ConfigType) -> None:
+    """Refresh the cache from the upload/logs fallback (CORE.config must be set).
+
+    The cache is only written when a complete sidecar is on disk:
+    load_compiled_config can't use it otherwise, and it holds resolved
+    secrets.
+    """
+    if _refresh_sidecar():
+        save_compiled_config(config)
+
+
+def _refresh_sidecar() -> bool:
+    """Ensure a complete sidecar is on disk; True when one is.
+
+    Writes one (without claiming a build) when missing or wizard-only.
+    Failures are non-fatal; the next upload/logs pays the slow path again.
+    """
+    try:
+        path = storage_path()
+        try:
+            old = StorageJSON.load_strict(path)
+        except Exception as err:  # noqa: BLE001  # pylint: disable=broad-except
+            # Present but unreadable: it may hold a real build's metadata,
+            # and a fresh rewrite would also stop the next compile from
+            # cleaning a possibly incoherent build tree.
+            _LOGGER.warning(
+                "Not caching: storage sidecar %s is unreadable (%s)", path, err
+            )
+            return False
+        if old is not None and old.can_apply_to_core():
+            # Compile-written; nothing to refresh.
+            return True
+        if CORE.build_path is not None and CORE.build_path.exists():
+            # An unvalidated build tree: its absent or mismatched sidecar
+            # is what makes the next compile wipe it, so don't vouch for
+            # a build this run never saw.
+            _LOGGER.warning(
+                "Not caching: build tree %s has no matching sidecar; "
+                "'esphome compile' will settle it",
+                CORE.build_path,
+            )
+            return False
+        new = StorageJSON.from_esphome_core(CORE, old, claim_build=False)
+        if not new.can_apply_to_core():
+            _LOGGER.warning("Not caching: rebuilt storage sidecar is still incomplete")
+            return False
+        new.save(path)
+        return True
+    except (OSError, EsphomeError) as err:
+        # write_file wraps OSError into EsphomeError. Persistent
+        # (unwritable storage dir), so surface that every upload/logs
+        # pays the slow path.
+        _LOGGER.warning("Could not refresh the storage sidecar: %s", err)
+    except Exception:  # noqa: BLE001  # pylint: disable=broad-except
+        # A structural bug; keep the traceback so it isn't mistaken
+        # for the I/O failure above.
+        _LOGGER.warning(
+            "Unexpected error refreshing the storage sidecar", exc_info=True
+        )
+    return False


 def load_compiled_config(conf_path: Path) -> ConfigType | None:
@@ -98,11 +162,8 @@ def load_compiled_config(conf_path: Path) -> ConfigType | None:
        return None

    storage = StorageJSON.load(ext_storage_path(conf_path.name))
-    if storage is None:
-        return None
-    # apply_to_core assumes a real compile wrote the sidecar; wizard-only
-    # sidecars leave both of these unset and can't drive upload/logs.
-    if not storage.core_platform and not storage.target_platform:
+    if storage is None or not storage.can_apply_to_core():
+        _LOGGER.debug("Ignoring compiled config cache: sidecar missing or incomplete")
        return None
    storage.apply_to_core()
    return config
@@ -3,7 +3,7 @@

 namespace esphome::adc {

-static const char *const TAG = "adc.common";
+static const char *const TAG = "adc";

 const LogString *sampling_mode_to_str(SamplingMode mode) {
  switch (mode) {
@@ -6,7 +6,7 @@

 namespace esphome::adc {

-static const char *const TAG = "adc.esp32";
+static const char *const TAG = "adc";

 adc_oneshot_unit_handle_t ADCSensor::shared_adc_handles[2] = {nullptr, nullptr};

@@ -13,7 +13,7 @@ ADC_MODE(ADC_VCC)

 namespace esphome::adc {

-static const char *const TAG = "adc.esp8266";
+static const char *const TAG = "adc";

 void ADCSensor::setup() {
 #ifndef USE_ADC_SENSOR_VCC
@@ -5,7 +5,7 @@

 namespace esphome::adc {

-static const char *const TAG = "adc.libretiny";
+static const char *const TAG = "adc";

 void ADCSensor::setup() {
 #ifndef USE_ADC_SENSOR_VCC
@@ -17,7 +17,7 @@

 namespace esphome::adc {

-static const char *const TAG = "adc.rp2";
+static const char *const TAG = "adc";

 // The on-die temperature sensor sits on the last ADC channel: input 4 on RP2040
 // and RP2350A, but input 8 on RP2350B, which has eight external channels rather
@@ -7,7 +7,7 @@

 namespace esphome::adc {

-static const char *const TAG = "adc.zephyr";
+static const char *const TAG = "adc";

 void ADCSensor::setup() {
  if (!adc_is_ready_dt(this->channel_)) {
@@ -160,11 +160,6 @@ APIConnection::APIConnection(std::unique_ptr<socket::Socket> sock, APIServer *pa
 #else
 #error "No frame helper defined"
 #endif
-#ifdef USE_CAMERA
-  if (camera::Camera::instance() != nullptr) {
-    this->image_reader_ = std::unique_ptr<camera::CameraImageReader>{camera::Camera::instance()->create_image_reader()};
-  }
-#endif
 }

 void APIConnection::start() {
@@ -417,15 +412,15 @@ void APIConnection::finalize_iterator_sync_() {
 }

 void APIConnection::process_iterator_batch_(ComponentIterator &iterator) {
-  // Budget by remaining batch capacity so a pass cannot overfill the batch;
-  // stops early on a refused send and resumes next loop pass
-  size_t batch_size = this->deferred_batch_.size();
-  if (batch_size < MAX_INITIAL_BATCH_SIZE)
-    iterator.try_advance(MAX_INITIAL_BATCH_SIZE - batch_size);
+  size_t initial_size = this->deferred_batch_.size();
+  size_t max_batch = MAX_INITIAL_PER_BATCH;
+  while (!iterator.completed() && (this->deferred_batch_.size() - initial_size) < max_batch) {
+    iterator.advance();
+  }

-  // Flush immediately once enough is queued (not guaranteed every pass);
-  // partial batches go out via the batch timer or finalize_iterator_sync_()
-  if (this->deferred_batch_.size() >= MAX_INITIAL_BATCH_SIZE) {
+  // If the batch is full, process it immediately
+  // Note: iterator.advance() already calls schedule_batch_() via schedule_message_()
+  if (this->deferred_batch_.size() >= max_batch) {
    this->process_batch_();
  }
 }
@@ -1140,6 +1135,7 @@ void APIConnection::try_send_camera_image_() {
  if (!this->image_reader_)
    return;

+  const auto *cam = camera::Camera::instance();
  // Send as many chunks as possible without blocking
  while (this->image_reader_->available()) {
    if (!this->helper_->can_write_without_blocking())
@@ -1149,11 +1145,11 @@ void APIConnection::try_send_camera_image_() {
    bool done = this->image_reader_->available() == to_send;

    CameraImageResponse msg;
-    msg.key = camera::Camera::instance()->get_object_id_hash();
+    msg.key = cam->get_object_id_hash();
    msg.set_data(this->image_reader_->peek_data_buffer(), to_send);
    msg.done = done;
 #ifdef USE_DEVICES
-    msg.device_id = camera::Camera::instance()->get_device_id();
+    msg.device_id = cam->get_device_id();
 #endif

    if (!this->send_message(msg)) {
@@ -1169,15 +1165,19 @@ void APIConnection::try_send_camera_image_() {
 void APIConnection::set_camera_state(std::shared_ptr<camera::CameraImage> image) {
  if (!this->flags_.state_subscription)
    return;
-  if (!this->image_reader_)
+  if (this->image_reader_ && this->image_reader_->available())
    return;
-  if (this->image_reader_->available())
+  if (!image->was_requested_by(esphome::camera::API_REQUESTER) && !image->was_requested_by(esphome::camera::IDLE))
    return;
-  if (image->was_requested_by(esphome::camera::API_REQUESTER) || image->was_requested_by(esphome::camera::IDLE)) {
-    this->image_reader_->set_image(std::move(image));
-    // Try to send immediately to reduce latency
-    this->try_send_camera_image_();
+  if (!this->image_reader_) {
+    // Created on the first image this connection will send, so connections
+    // that never receive one never pay for a reader. Only a registered
+    // camera's listener can reach this, so instance() is non-null here.
+    this->image_reader_ = std::unique_ptr<camera::CameraImageReader>{camera::Camera::instance()->create_image_reader()};
  }
+  this->image_reader_->set_image(std::move(image));
+  // Try to send immediately to reduce latency
+  this->try_send_camera_image_();
 }
 uint16_t APIConnection::try_send_camera_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
  auto *camera = static_cast<camera::Camera *>(entity);
@@ -1752,10 +1752,12 @@ void APIConnection::complete_authentication_() {
 bool APIConnection::send_hello_response_(const HelloRequest &msg) {
  // Copy client name with truncation if needed (set_client_name handles truncation)
  this->helper_->set_client_name(msg.client_info.c_str(), msg.client_info.size());
-  this->client_api_version_major_ = msg.api_version_major;
-  this->client_api_version_minor_ = msg.api_version_minor;
+  this->client_api_version_major_ =
+      static_cast<uint8_t>(std::min<uint32_t>(msg.api_version_major, std::numeric_limits<uint8_t>::max()));
+  this->client_api_version_minor_ =
+      static_cast<uint8_t>(std::min<uint32_t>(msg.api_version_minor, std::numeric_limits<uint8_t>::max()));
  char peername[socket::SOCKADDR_STR_LEN];
-  ESP_LOGV(TAG, "Hello from client: '%s' | %s | API Version %" PRIu16 ".%" PRIu16, this->helper_->get_client_name(),
+  ESP_LOGV(TAG, "Hello from client: '%s' | %s | API Version %u.%u", this->helper_->get_client_name(),
           this->helper_->get_peername_to(peername), this->client_api_version_major_, this->client_api_version_minor_);

  HelloResponse resp;
@@ -2184,7 +2186,7 @@ bool APIConnection::try_to_clear_buffer_slow_(bool log_out_of_space) {
  }
  return false;
 }
-bool APIConnection::send_message_(uint32_t payload_size, uint8_t message_type, MessageEncodeFn encode_fn,
+bool APIConnection::send_message_(uint32_t payload_size, uint16_t message_type, MessageEncodeFn encode_fn,
                                  const void *msg) {
 #ifdef HAS_PROTO_MESSAGE_DUMP
  // Skip dump for log messages (recursive logging risk) and camera frames (high-frequency noise)
@@ -2213,7 +2215,7 @@ uint16_t APIConnection::encode_to_buffer_slow(uint32_t calculated_size, MessageE
                                              APIConnection *conn, uint32_t remaining_size) {
  return encode_to_buffer(calculated_size, encode_fn, msg, conn, remaining_size);
 }
-bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) {
+bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint16_t message_type) {
  const bool is_log_message = (message_type == SubscribeLogsResponse::MESSAGE_TYPE);

  if (!this->try_to_clear_buffer(!is_log_message)) {
@@ -2243,12 +2245,12 @@ void APIConnection::on_fatal_error() {
  this->flags_.remove = true;
 }

-bool APIConnection::schedule_message_front_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size) {
+bool APIConnection::schedule_message_front_(EntityBase *entity, uint16_t message_type, uint8_t estimated_size) {
  this->deferred_batch_.add_item_front(entity, message_type, estimated_size);
  return this->schedule_batch_();
 }

-bool APIConnection::send_message_smart_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
+bool APIConnection::send_message_smart_(EntityBase *entity, uint16_t message_type, uint8_t estimated_size,
                                        uint8_t aux_data_index) {
  if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
    auto &shared_buf = this->parent_->get_shared_buffer_ref();
@@ -53,11 +53,11 @@ void log_dropped_message(const char *tag, int line, const LogString *what);

 // Keepalive timeout in milliseconds
 static constexpr uint32_t KEEPALIVE_TIMEOUT_MS = 60000;
-// Deferred batch size cap during initial state/info sync
-static constexpr size_t MAX_INITIAL_BATCH_SIZE = 34;
+// Maximum number of entities to process in a single batch during initial state/info sending
+static constexpr size_t MAX_INITIAL_PER_BATCH = 34;
 // Verify MAX_MESSAGES_PER_BATCH (defined in api_frame_helper.h) can hold the initial batch
-static_assert(MAX_MESSAGES_PER_BATCH >= MAX_INITIAL_BATCH_SIZE,
-              "MAX_MESSAGES_PER_BATCH must be >= MAX_INITIAL_BATCH_SIZE");
+static_assert(MAX_MESSAGES_PER_BATCH >= MAX_INITIAL_PER_BATCH,
+              "MAX_MESSAGES_PER_BATCH must be >= MAX_INITIAL_PER_BATCH");

 #ifdef USE_BENCHMARK
 class APIConnection;
@@ -326,8 +326,10 @@ class APIConnection final : public APIServerConnectionBase {
  bool is_marked_for_removal() const { return this->flags_.remove; }
  uint8_t get_log_subscription_level() const { return this->flags_.log_subscription; }

-  // Get client API version for feature detection
-  bool client_supports_api_version(uint16_t major, uint16_t minor) const {
+  // Get client API version for feature detection.
+  // Stored versions saturate at 255 (see send_hello_response_), so requesting
+  // a minimum above that can never match.
+  bool client_supports_api_version(uint8_t major, uint8_t minor) const {
    return this->client_api_version_major_ > major ||
           (this->client_api_version_major_ == major && this->client_api_version_minor_ >= minor);
  }
@@ -374,7 +376,7 @@ class APIConnection final : public APIServerConnectionBase {
      return true;
    return this->try_to_clear_buffer_slow_(log_out_of_space);
  }
-  bool send_buffer(ProtoWriteBuffer buffer, uint8_t message_type);
+  bool send_buffer(ProtoWriteBuffer buffer, uint16_t message_type);

  const char *get_name() const { return this->helper_->get_client_name(); }
  /// Get peer name (IP address) into caller-provided buffer, returns buf for convenience
@@ -423,7 +425,7 @@ class APIConnection final : public APIServerConnectionBase {
  }

  // Non-template buffer management for send_message
-  bool send_message_(uint32_t payload_size, uint8_t message_type, MessageEncodeFn encode_fn, const void *msg);
+  bool send_message_(uint32_t payload_size, uint16_t message_type, MessageEncodeFn encode_fn, const void *msg);

  // Core batch encoding logic. ALWAYS_INLINE so encode_fn devirtualizes at hot call sites.
  // Defined in api_connection_buffer.h (needs APIServer complete).
@@ -664,10 +666,9 @@ class APIConnection final : public APIServerConnectionBase {

    struct BatchItem {
      EntityBase *entity;                       // 4 bytes - Entity pointer
-      uint8_t message_type;                     // 1 byte - Message type for protocol and dispatch
+      uint16_t message_type;                    // 2 bytes - Message type for protocol and dispatch
      uint8_t estimated_size;                   // 1 byte - Estimated message size (max 255 bytes)
      uint8_t aux_data_index{AUX_DATA_UNUSED};  // 1 byte - For events: index into entity's event_types
-      // 1 byte padding
    };

    std::vector<BatchItem> items;
@@ -677,7 +678,7 @@ class APIConnection final : public APIServerConnectionBase {
    // connections that do, buffers are released after initial sync anyway

    // Add item to the batch (with deduplication)
-    void add_item(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
+    void add_item(EntityBase *entity, uint16_t message_type, uint8_t estimated_size,
                  uint8_t aux_data_index = AUX_DATA_UNUSED) {
      // Dedup: O(n) scan but optimized for RAM over performance
      // Skip deduplication for events - they are edge-triggered, every occurrence matters
@@ -693,7 +694,7 @@ class APIConnection final : public APIServerConnectionBase {
      this->items.push_back({entity, message_type, estimated_size, aux_data_index});
    }
    // Add item to the front of the batch (for high priority messages like ping)
-    void add_item_front(EntityBase *entity, uint8_t message_type, uint8_t estimated_size) {
+    void add_item_front(EntityBase *entity, uint16_t message_type, uint8_t estimated_size) {
      // Swap to front avoids expensive vector::insert which shifts all elements
      this->items.push_back({entity, message_type, estimated_size, AUX_DATA_UNUSED});
      if (this->items.size() > 1) {
@@ -758,13 +759,15 @@ class APIConnection final : public APIServerConnectionBase {
 #endif
  } flags_{};  // 2 bytes total

-  // 2-byte types immediately after flags_ (no padding between them)
-  uint16_t client_api_version_major_{0};
-  uint16_t client_api_version_minor_{0};
+  // 2-byte type immediately after flags_ (no padding between them)
+  uint16_t batch_message_type_{0};  // Current message type during batch encoding
  // 1-byte types to fill remaining space before next 4-byte boundary
+  // Client API versions are clamped to 255 on receive (see send_hello_response_)
+  uint8_t client_api_version_major_{0};
+  uint8_t client_api_version_minor_{0};
  ActiveIterator active_iterator_{ActiveIterator::NONE};
-  uint8_t batch_message_type_{0};  // Current message type during batch encoding
-  // Total: 2 (flags) + 2 + 2 + 1 + 1 = 8 bytes, aligned to 4-byte boundary
+  // Total: 2 (flags) + 2 + 1 + 1 + 1 + 1 (batch_header_size_ below) = 8 bytes,
+  // aligned to 4-byte boundary

  // Actual header size used by encode_to_buffer for the current message.
  // Read by process_batch_multi_ to pass into MessageInfo.
@@ -813,7 +816,7 @@ class APIConnection final : public APIServerConnectionBase {
  // 2. It's an EventResponse (events are edge-triggered - every occurrence matters)
  // 3. OR: User has opted into immediate sending (should_try_send_immediately = true
  //    AND batch_delay = 0)
-  inline bool should_send_immediately_(uint8_t message_type) const {
+  inline bool should_send_immediately_(uint16_t message_type) const {
    return (
 #ifdef USE_UPDATE
        message_type == UpdateStateResponse::MESSAGE_TYPE ||
@@ -827,11 +830,11 @@ class APIConnection final : public APIServerConnectionBase {
  // Helper method to send a message either immediately or via batching
  // Tries immediate send if should_send_immediately_() returns true and buffer has space
  // Falls back to batching if immediate send fails or isn't applicable
-  bool send_message_smart_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
+  bool send_message_smart_(EntityBase *entity, uint16_t message_type, uint8_t estimated_size,
                           uint8_t aux_data_index = DeferredBatch::AUX_DATA_UNUSED);

  // Helper function to schedule a deferred message with known message type
-  bool schedule_message_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
+  bool schedule_message_(EntityBase *entity, uint16_t message_type, uint8_t estimated_size,
                         uint8_t aux_data_index = DeferredBatch::AUX_DATA_UNUSED) {
    this->deferred_batch_.add_item(entity, message_type, estimated_size, aux_data_index);
    return this->schedule_batch_();
@@ -839,7 +842,7 @@ class APIConnection final : public APIServerConnectionBase {

  // Helper function to schedule a high priority message at the front of the batch
  // Out-of-line: callers (on_shutdown, check_keepalive_) are cold paths
-  bool schedule_message_front_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size);
+  bool schedule_message_front_(EntityBase *entity, uint16_t message_type, uint8_t estimated_size);

  // Helper function to log client messages with name and peername
  void log_client_(int level, const LogString *message);
@@ -36,7 +36,7 @@ static constexpr uint16_t MAX_MESSAGE_SIZE = 32768;  // 32 KiB for ESP32 and oth
 static constexpr uint16_t RX_BUF_NULL_TERMINATOR = 1;

 // Maximum number of messages to batch in a single write operation
-// Must be >= MAX_INITIAL_BATCH_SIZE in api_connection.h (enforced by static_assert there)
+// Must be >= MAX_INITIAL_PER_BATCH in api_connection.h (enforced by static_assert there)
 static constexpr size_t MAX_MESSAGES_PER_BATCH = 34;

 // Max client name length (e.g., "Home Assistant 2026.1.0.dev0" = 28 chars)
@@ -49,16 +49,16 @@ struct ReadPacketBuffer {
 };

 // Packed message info structure to minimize memory usage
-// Note: message_type is uint8_t — all current protobuf message types fit in 8 bits.
-// The noise wire format encodes types as 16-bit, but the high byte is always 0.
-// If message types ever exceed 255, this and encrypt_noise_message_ must be updated.
+// message_type matches the wire formats: noise carries a fixed 16-bit type
+// field, plaintext a type varint. The proto codegen caps message IDs at 16383
+// so the plaintext type varint fits the 2 bytes budgeted in HEADER_PADDING.
 struct MessageInfo {
  uint16_t offset;        // Offset in buffer where message starts
  uint16_t payload_size;  // Size of the message payload
-  uint8_t message_type;   // Message type (0-255)
+  uint16_t message_type;  // Message type (0-16383)
  uint8_t header_size;    // Actual header size used (avoids recomputation in write path)

-  MessageInfo(uint8_t type, uint16_t off, uint16_t size, uint8_t hdr)
+  MessageInfo(uint16_t type, uint16_t off, uint16_t size, uint8_t hdr)
      : offset(off), payload_size(size), message_type(type), header_size(hdr) {}
 };

@@ -173,7 +173,7 @@ class APIFrameHelper {
  }
  // Write a single protobuf message - the hot path (87-100% of all writes).
  // Caller must ensure state is DATA before calling.
-  virtual APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) = 0;
+  virtual APIError write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) = 0;
  // Write multiple protobuf messages in a single batched operation.
  // Caller must ensure state is DATA and messages is not empty.
  // messages contains (message_type, offset, length) for each message in the buffer.
@@ -187,15 +187,15 @@ class APIFrameHelper {
  // Distinguishes protocols via frame_footer_size_ (noise always has a non-zero MAC
  // footer, plaintext has footer=0). If a protocol with a plaintext footer is ever
  // added, this should become a virtual method.
-  uint8_t frame_header_size(uint16_t payload_size, uint8_t message_type) const {
+  uint8_t frame_header_size(uint16_t payload_size, uint16_t message_type) const {
 #if defined(USE_API_NOISE) && defined(USE_API_PLAINTEXT)
    return this->frame_footer_size_
               ? this->frame_header_padding_
-               : static_cast<uint8_t>(1 + ProtoSize::varint16(payload_size) + ProtoSize::varint8(message_type));
+               : static_cast<uint8_t>(1 + ProtoSize::varint16(payload_size) + ProtoSize::varint16(message_type));
 #elif defined(USE_API_NOISE)
    return this->frame_header_padding_;
 #else  // USE_API_PLAINTEXT only
-    return static_cast<uint8_t>(1 + ProtoSize::varint16(payload_size) + ProtoSize::varint8(message_type));
+    return static_cast<uint8_t>(1 + ProtoSize::varint16(payload_size) + ProtoSize::varint16(message_type));
 #endif
  }
  // Get the frame footer size required by this protocol
@@ -490,7 +490,7 @@ APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {
 }
 // Encrypt a single noise message in place and return the encrypted frame length.
 // Returns APIError::OK on success.
-APIError APINoiseFrameHelper::encrypt_noise_message_(uint8_t *buf_start, uint16_t payload_size, uint8_t message_type,
+APIError APINoiseFrameHelper::encrypt_noise_message_(uint8_t *buf_start, uint16_t payload_size, uint16_t message_type,
                                                     uint16_t &encrypted_len_out) {
  // Write noise header
  buf_start[0] = 0x01;  // indicator
@@ -523,7 +523,7 @@ APIError APINoiseFrameHelper::encrypt_noise_message_(uint8_t *buf_start, uint16_
  return APIError::OK;
 }

-APIError APINoiseFrameHelper::write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) {
+APIError APINoiseFrameHelper::write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) {
 #ifdef ESPHOME_DEBUG_API
  assert(this->state_ == State::DATA);
 #endif
@@ -591,18 +591,21 @@ APIError APINoiseFrameHelper::write_frame_(const uint8_t *data, uint16_t len) {
 */
 APIError APINoiseFrameHelper::init_handshake_() {
  int err;
-  memset(&nid_, 0, sizeof(nid_));
-  // const char *proto = "Noise_NNpsk0_25519_ChaChaPoly_SHA256";
-  // err = noise_protocol_name_to_id(&nid_, proto, strlen(proto));
-  nid_.pattern_id = NOISE_PATTERN_NN;
-  nid_.cipher_id = NOISE_CIPHER_CHACHAPOLY;
-  nid_.dh_id = NOISE_DH_CURVE25519;
-  nid_.prefix_id = NOISE_PREFIX_STANDARD;
-  nid_.hybrid_id = NOISE_DH_NONE;
-  nid_.hash_id = NOISE_HASH_SHA256;
-  nid_.modifier_ids[0] = NOISE_MODIFIER_PSK0;
+  // Noise_NNpsk0_25519_ChaChaPoly_SHA256, built on the stack:
+  // noise_handshakestate_new_by_id copies it, so a member would waste
+  // 104 bytes per connection, and a static const would sit in RAM on
+  // ESP8266 (.rodata is DRAM there).
+  const NoiseProtocolId nid = {
+      .prefix_id = NOISE_PREFIX_STANDARD,
+      .pattern_id = NOISE_PATTERN_NN,
+      .modifier_ids = {NOISE_MODIFIER_PSK0},
+      .dh_id = NOISE_DH_CURVE25519,
+      .cipher_id = NOISE_CIPHER_CHACHAPOLY,
+      .hash_id = NOISE_HASH_SHA256,
+      .hybrid_id = NOISE_DH_NONE,
+  };

-  err = noise_handshakestate_new_by_id(&handshake_, &nid_, NOISE_ROLE_RESPONDER);
+  err = noise_handshakestate_new_by_id(&handshake_, &nid, NOISE_ROLE_RESPONDER);
  APIError aerr =
      handle_noise_error_(err, LOG_STR("noise_handshakestate_new_by_id"), APIError::HANDSHAKESTATE_SETUP_FAILED);
  if (aerr != APIError::OK)
@@ -31,7 +31,7 @@ class APINoiseFrameHelper final : public APIFrameHelper {
 #endif
  APIError loop() override;
  APIError read_packet(ReadPacketBuffer *buffer) override;
-  APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) override;
+  APIError write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) override;
  APIError write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) override;

 protected:
@@ -44,7 +44,7 @@ class APINoiseFrameHelper final : public APIFrameHelper {
  APIError state_action_handshake_write_();
  APIError try_read_frame_();
  APIError write_frame_(const uint8_t *data, uint16_t len);
-  APIError encrypt_noise_message_(uint8_t *buf_start, uint16_t payload_size, uint8_t message_type,
+  APIError encrypt_noise_message_(uint8_t *buf_start, uint16_t payload_size, uint16_t message_type,
                                  uint16_t &encrypted_len_out);
  APIError init_handshake_();
  APIError check_handshake_finished_();
@@ -63,9 +63,6 @@ class APINoiseFrameHelper final : public APIFrameHelper {
  // Buffer for noise handshake prologue (released after handshake)
  APIBuffer prologue_;

-  // NoiseProtocolId (size depends on implementation)
-  NoiseProtocolId nid_;
-
  // Group small types together
  // Fixed-size header buffer for noise protocol:
  // 1 byte for indicator + 2 bytes for message size (16-bit value, not varint)
@@ -5,6 +5,7 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "api_pb2.h"
 #include "proto.h"
 #include <cstring>
 #include <cinttypes>
@@ -252,24 +253,21 @@ ESPHOME_ALWAYS_INLINE static inline void encode_varint_16(uint16_t value, uint8_
  *p = static_cast<uint8_t>(value);
 }

-// Encode an 8-bit varint (1-2 bytes) using pre-computed length.
-ESPHOME_ALWAYS_INLINE static inline void encode_varint_8(uint8_t value, uint8_t varint_len, uint8_t *p) {
-  if (varint_len == 2) {
-    *p++ = static_cast<uint8_t>(value | 0x80);
-    *p = static_cast<uint8_t>(value >> 7);
-  } else {
-    *p = value;
-  }
-}
+// The generator rejects message IDs above MAX_MESSAGE_TYPE, so the type varint
+// can never outgrow the 2 bytes HEADER_PADDING budgets for it. Without this
+// bound, write_plaintext_header's header_offset would underflow for the first
+// message in a batch and the header write would land outside the buffer.
+static_assert(1 + 3 + ProtoSize::varint16(MAX_MESSAGE_TYPE) <= APIPlaintextFrameHelper::HEADER_PADDING,
+              "HEADER_PADDING cannot fit the type varint of the largest message ID");

 // Write plaintext header into pre-allocated padding before payload.
 // padding_size: bytes reserved before payload (HEADER_PADDING for first/single msg,
 //               actual header size for contiguous batch messages).
 // Returns the total header length (indicator + varints).
 ESPHOME_ALWAYS_INLINE static inline uint8_t write_plaintext_header(uint8_t *buf_start, uint16_t payload_size,
-                                                                   uint8_t message_type, uint8_t padding_size) {
+                                                                   uint16_t message_type, uint8_t padding_size) {
  uint8_t size_varint_len = ProtoSize::varint16(payload_size);
-  uint8_t type_varint_len = ProtoSize::varint8(message_type);
+  uint8_t type_varint_len = ProtoSize::varint16(message_type);
  uint8_t total_header_len = 1 + size_varint_len + type_varint_len;

  // The header is right-justified within the padding so it sits immediately before payload.
@@ -292,12 +290,12 @@ ESPHOME_ALWAYS_INLINE static inline uint8_t write_plaintext_header(uint8_t *buf_

  // Encode varints directly into buffer using pre-computed lengths
  encode_varint_16(payload_size, size_varint_len, buf_start + header_offset + 1);
-  encode_varint_8(message_type, type_varint_len, buf_start + header_offset + 1 + size_varint_len);
+  encode_varint_16(message_type, type_varint_len, buf_start + header_offset + 1 + size_varint_len);

  return total_header_len;
 }

-APIError APIPlaintextFrameHelper::write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) {
+APIError APIPlaintextFrameHelper::write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) {
 #ifdef ESPHOME_DEBUG_API
  assert(this->state_ == State::DATA);
 #endif
@@ -10,7 +10,8 @@ class APIPlaintextFrameHelper final : public APIFrameHelper {
  // Plaintext header structure (worst case):
  // Pos 0: indicator (0x00)
  // Pos 1-3: payload size varint (up to 3 bytes)
-  // Pos 4-5: message type varint (up to 2 bytes)
+  // Pos 4-5: message type varint (up to 2 bytes; covers message IDs up to
+  //          16383, enforced by the proto codegen)
  // Pos 6+: actual payload data
  static constexpr uint8_t HEADER_PADDING = 1 + 3 + 2;  // indicator + size varint + type varint

@@ -21,7 +22,7 @@ class APIPlaintextFrameHelper final : public APIFrameHelper {
  APIError init() override;
  APIError loop() override;
  APIError read_packet(ReadPacketBuffer *buffer) override;
-  APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) override;
+  APIError write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) override;
  APIError write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) override;
 #ifdef USE_API_NOISE
  // After try_read_frame_ returned PROTOCOL_SWITCH_TO_NOISE: copy out the
@@ -95,17 +95,9 @@ bool ListEntitiesIterator::on_end() { return this->client_->send_list_info_done(
 ListEntitiesIterator::ListEntitiesIterator(APIConnection *client) : client_(client) {}

 #ifdef USE_API_USER_DEFINED_ACTIONS
-// Yield after every Nth service; bounds direct (non-batched) writes per loop pass
-static constexpr uint8_t SERVICE_YIELD_INTERVAL = 3;
-
 bool ListEntitiesIterator::on_service(UserServiceDescriptor *service) {
  auto resp = service->encode_list_service_response();
-  if (!this->client_->send_message(resp))
-    return false;
-  // at_ is this service's index
-  if ((this->at_ + 1) % SERVICE_YIELD_INTERVAL == 0)
-    this->yield_after_step_();
-  return true;
+  return this->client_->send_message(resp);
 }
 #endif

@@ -684,11 +684,6 @@ class ProtoSize {
    return value < VARINT_THRESHOLD_1_BYTE ? 1 : (value < VARINT_THRESHOLD_2_BYTE ? 2 : 3);
  }

-  // Varint encoded length for an 8-bit value (1 or 2 bytes).
-  static constexpr inline uint8_t ESPHOME_ALWAYS_INLINE varint8(uint8_t value) {
-    return value < VARINT_THRESHOLD_1_BYTE ? 1 : 2;
-  }
-
  /**
   * @brief Calculates the size in bytes needed to encode a uint32_t value as a varint
   *
@@ -4,12 +4,9 @@ The platform analog of esp32_ble / rp2040_ble: owns the Beken BDK BLE stack
 bring-up and the controller BLE address. Consumers (bk72xx_ble_tracker) build
 on this component and contain no SDK calls of their own.

-Supported SoCs (BLE 5.x): BK7231N/BK7236 (BLE 5.1), BK7252N/BK7253 (BLE 5.2),
-and any future BLE-5.x SoC. BK7238 (BLE 5.2) is blocked for now: with BLE
-compiled in, the Beken SDK erases the bootloader flash sector at boot because
-LibreTiny's partition table has no BLE bonding entry (esphome#18646,
-libretiny-eu/libretiny#408). Known non-5.x families and BK7238 are rejected in
-to_code. Unknown families are capability-checked at compile time via
+Supported SoCs (BLE 5.x): BK7231N/BK7236 (BLE 5.1), BK7238/BK7252N/BK7253
+(BLE 5.2), and any future BLE-5.x SoC. Known non-5.x families are rejected in
+to_code; unknown families are capability-checked at compile time via
 `__has_include("app_ble.h")`, a header only on the BLE 5.x include path
 (ble_api.h ships for every SoC, so it cannot be the probe). A non-5.x build
 fails with a clear #error.
@@ -68,23 +65,14 @@ def _unsupported_family_message(family: str) -> str | None:
        )
    if family == FAMILY_BK7231Q:
        return "bk72xx_ble does not support BK7231Q: this SoC has no BLE"
-    if family == FAMILY_BK7238:
-        return (
-            "bk72xx_ble is disabled on BK7238: with BLE compiled in, the Beken SDK "
-            "erases the bootloader flash sector at boot and the device can no longer "
-            "start (see https://github.com/esphome/esphome/issues/18646); support "
-            "returns once the LibreTiny partition table fix "
-            "(libretiny-eu/libretiny#408) is released"
-        )
    return None


-def _final_validate(config: ConfigType) -> ConfigType:
+def _final_validate(config: ConfigType) -> None:
    # Warn only: a hard error here would break the validate-only CI fixtures,
    # which run on a BLE 4.2 board. The hard error is raised at codegen.
    if msg := _unsupported_family_message(libretiny.get_libretiny_family()):
        _LOGGER.warning("%s (this configuration cannot compile)", msg)
-    return config


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -125,7 +113,18 @@ async def to_code(config: ConfigType) -> None:
    # BK7231N, but NOT on BK7238 (its BLE stack has no such symbol; the address is
    # derived from the WiFi MAC instead — the BDK's own fallback). Tell the C++
    # which path is available so it doesn't reference a missing symbol.
-    if libretiny.get_libretiny_family() == FAMILY_BK7231N:
+    family = libretiny.get_libretiny_family()
+    if family == FAMILY_BK7231N:
        cg.add_define("BK72XX_BLE_HAS_COMMON_BDADDR")
+    elif family == FAMILY_BK7238:
+        # ESPHome's LibreTiny disables BLE on BK7238 because the SDK can hang at
+        # WiFi STA startup when BLE init runs. This component re-enables BLE, so
+        # warn loudly: BK7238 is accepted but not hardware-verified and may be
+        # WiFi-unstable with BLE on.
+        _LOGGER.warning(
+            "bk72xx_ble on BK7238: enabling BLE is known to risk a WiFi STA startup "
+            "hang on this family and is not yet hardware-verified. Expect possible "
+            "instability."
+        )

    cg.add_define("USE_BK72XX_BLE")
@@ -206,36 +206,32 @@ def validate_scan_parameters(config: ConfigType) -> ConfigType:
    interval = config[CONF_INTERVAL]
    window = config[CONF_WINDOW]

-    # Labels are reused in every error below; the optional one names its key.
-    windows = [("Scan window", window)]
-    if (connection_window := config.get(CONF_CONNECTION_SCAN_WINDOW)) is not None:
-        windows.append((CONF_CONNECTION_SCAN_WINDOW, connection_window))
-
-    for name, value in windows:
-        if value > interval:
-            raise cv.Invalid(
-                f"{name} ({value}) needs to be smaller than scan interval ({interval})"
-            )
+    if window > interval:
+        raise cv.Invalid(
+            f"Scan window ({window}) needs to be smaller than scan interval ({interval})"
+        )

    # BLE scan interval/window are programmed in 0.625 ms units as a 16-bit value; the
    # controller only accepts 2.5 ms .. 10240 ms (0x0004 .. 0x4000). Reject out-of-range
    # values here instead of letting the unit conversion silently overflow.
-    for name, value in (("Scan interval", interval), *windows):
+    for name, value in (("interval", interval), ("window", window)):
        if value.total_microseconds < 2500 or value.total_microseconds > 10_240_000:
-            raise cv.Invalid(f"{name} ({value}) must be between 2.5 ms and 10240 ms")
+            raise cv.Invalid(
+                f"Scan {name} ({value}) must be between 2.5 ms and 10240 ms"
+            )

    # Validate what actually reaches the controller: both values are truncated to
    # whole 0.625 ms units, so a window/interval pair that differs by less than one
    # unit collapses to the same value — silently programming a 100 % duty cycle
    # (radio permanently on) from a config that asked for less.
    interval_units = to_ble_units(interval)
-    for name, value in windows:
-        if to_ble_units(value) == interval_units and value < interval:
-            raise cv.Invalid(
-                f"{name} ({value}) and interval ({interval}) both truncate to "
-                f"{interval_units} x 0.625 ms, which the controller scans at a 100 % duty "
-                f"cycle. Separate them by at least 0.625 ms."
-            )
+    window_units = to_ble_units(window)
+    if window_units == interval_units and window < interval:
+        raise cv.Invalid(
+            f"Scan window ({window}) and interval ({interval}) both truncate to "
+            f"{interval_units} x 0.625 ms, which the controller scans at a 100 % duty "
+            f"cycle. Separate them by at least 0.625 ms."
+        )

    if interval.total_microseconds * 3 > duration.total_microseconds:
        raise cv.Invalid(
@@ -251,14 +247,11 @@ def validate_scan_parameters(config: ConfigType) -> ConfigType:
 # their own; also the fallback for esp32's conditional default.
 DEFAULT_SCAN_WINDOW = "30ms"

-CONF_CONNECTION_SCAN_WINDOW = "connection_scan_window"
-

 def scan_parameters_schema(
    interval_default: str,
    *,
    window_default: str | Callable[[], TimePeriod] = DEFAULT_SCAN_WINDOW,
-    connection_window: bool = False,
 ) -> cv.All:
    """Build the scan_parameters value schema shared by all BLE trackers.

@@ -270,9 +263,7 @@ def scan_parameters_schema(
    can adjust it once sibling keys are resolved). The `active` option
    (default on) is unconditional: active scanning is part of the tracker
    contract — every current proxy client assumes it, so a passive-only
-    tracker must not share this schema. connection_window opts in to the
-    `connection_scan_window` option for trackers that can fall back to a
-    smaller window while a GATT connection is active.
+    tracker must not share this schema.
    """
    schema = {
        cv.Optional(CONF_DURATION, default="5min"): cv.positive_time_period_seconds,
@@ -281,8 +272,6 @@ def scan_parameters_schema(
        cv.Optional(CONF_CONTINUOUS, default=True): cv.boolean,
        cv.Optional(CONF_ACTIVE, default=True): cv.boolean,
    }
-    if connection_window:
-        schema[cv.Optional(CONF_CONNECTION_SCAN_WINDOW)] = cv.positive_time_period
    return cv.All(cv.Schema(schema), validate_scan_parameters)


@@ -20,7 +20,7 @@

 namespace esphome::bluetooth_connection {

-static const char *const TAG = "bluetooth_connection.bluedroid";
+static const char *const TAG = "bluetooth_connection";

 using ble_device_base::FAST_CONN_TIMEOUT;
 using ble_device_base::FAST_MAX_CONN_INTERVAL;
@@ -15,7 +15,7 @@

 namespace esphome::bluetooth_connection {

-static const char *const TAG = "bluetooth_connection.rp2";
+static const char *const TAG = "bluetooth_connection";

 using ble_device_base::ESPBTUUID;
 using ble_device_base::GATT_ERR_NOT_CONNECTED;
@@ -103,7 +103,8 @@ struct CameraImageSpec {
 /** Abstract camera base class. Collaborates with API.
 *  1) API server starts and registers as a listener (add_listener)
 *     to receive new images from the camera.
- *  2) New API client connects and creates a new image reader (create_image_reader).
+ *  2) API connection creates an image reader (create_image_reader) when it receives
+ *     the first image it will send.
 *  3) API connection receives protobuf CameraImageRequest and calls request_image.
 *  3.a) API connection receives protobuf CameraImageRequest and calls start_stream.
 *  4) Camera implementation provides JPEG data in the CameraImage and notifies listeners.
@@ -61,7 +61,7 @@ CONFIG_SCHEMA = cv.All(
 )


-def _final_validate(config: ConfigType) -> ConfigType:
+def _final_validate(config: ConfigType) -> None:
    full_config = fv.full_config.get()
    wifi_conf = full_config.get("wifi")

@@ -88,8 +88,6 @@ def _final_validate(config: ConfigType) -> ConfigType:
    socket.consume_sockets(3, "captive_portal")(config)
    socket.consume_sockets(1, "captive_portal", socket.SocketType.UDP)(config)

-    return config
-

 FINAL_VALIDATE_SCHEMA = _final_validate

@@ -24,6 +24,7 @@ CONF_GYROSCOPE_RANGE = "gyroscope_range"
 CONF_IAQ = "iaq"
 CONF_IGNORE_NOT_FOUND = "ignore_not_found"
 CONF_IS_WRGB = "is_wrgb"
+CONF_LABEL = "label"
 CONF_LIBRETINY = "libretiny"
 CONF_LOOP = "loop"
 CONF_NOX_INDEX = "nox_index"
@@ -37,6 +38,7 @@ CONF_REQUEST_HEADERS = "request_headers"
 CONF_ROWS = "rows"
 CONF_SCAN_PARAMETERS = "scan_parameters"
 CONF_SHA256 = "sha256"
+CONF_SLOT = "slot"
 CONF_STATE_SAVE_INTERVAL = "state_save_interval"
 CONF_STOP_BITS = "stop_bits"
 CONF_TARGET_COUNT = "target_count"
@@ -5,7 +5,7 @@

 namespace esphome::deep_sleep {

-static const char *const TAG = "deep_sleep.bk72xx";
+static const char *const TAG = "deep_sleep";

 #ifdef USE_DEEP_SLEEP_ON_WAKE
 WakeupCause get_wakeup_cause() {
@@ -3,6 +3,7 @@ import re
 from esphome import automation, core
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
+from esphome.components.const import CONF_LABEL
 from esphome.components.number import Number
 from esphome.components.select import Select
 from esphome.components.switch import Switch
@@ -30,7 +31,6 @@ display_menu_base_ns = cg.esphome_ns.namespace("display_menu_base")

 CONF_ROTARY = "rotary"
 CONF_JOYSTICK = "joystick"
-CONF_LABEL = "label"
 CONF_MENU = "menu"
 CONF_BACK = "back"
 CONF_SELECT = "select"
@@ -88,7 +88,7 @@ async def to_code(config):
    cg.add_library("esphome/dsmr_parser", "1.9.0")


-def final_validate(config: ConfigType) -> ConfigType:
+def final_validate(config: ConfigType) -> None:
    full_config = fv.full_config.get()

    for uart_conf in full_config["uart"]:
@@ -102,7 +102,5 @@ def final_validate(config: ConfigType) -> ConfigType:
                )
            break

-    return config
-

 FINAL_VALIDATE_SCHEMA = final_validate
@@ -59,7 +59,7 @@ CONFIG_SCHEMA = (
 )


-def final_validate(config: ConfigType) -> ConfigType:
+def final_validate(config: ConfigType) -> None:
    full_config = fv.full_config.get()

    # Count sensors registered to this hub (IDs are resolved at final_validate stage)
@@ -95,7 +95,7 @@ def final_validate(config: ConfigType) -> ConfigType:
        parity="NONE",
        stop_bits=1,
    )
-    return schema(config)
+    schema(config)


 FINAL_VALIDATE_SCHEMA = final_validate
@@ -68,7 +68,6 @@ PATTERN_CONFIGS = {
    "PULSE": {
        CONF_UNIT_OF_MEASUREMENT: UNIT_PULSES,
        CONF_DEVICE_CLASS: DEVICE_CLASS_ENERGY,
-        CONF_STATE_CLASS: STATE_CLASS_TOTAL_INCREASING,
        CONF_ACCURACY_DECIMALS: 0,
    },
    "PF": {
@@ -79,13 +78,12 @@ PATTERN_CONFIGS = {
    },
 }

-# BASE_SCHEMA intentionally omits state_class and accuracy_decimals defaults.
-# Passing them to sensor_schema() would register them via cv.Optional(key, default=...),
-# making them always present in the validated config dict and preventing
-# apply_tag_defaults from overriding them with the correct per-prefix values.
-# They are injected by apply_tag_defaults below, after running through
-# sensor.validate_state_class() so the value is code-generation-ready.
-BASE_SCHEMA = sensor.sensor_schema(EmonTxSensor).extend(
+# Create a base schema that's flexible for any tag
+BASE_SCHEMA = sensor.sensor_schema(
+    EmonTxSensor,
+    state_class=STATE_CLASS_MEASUREMENT,
+    accuracy_decimals=0,
+).extend(
    {
        cv.GenerateID(CONF_EMONTX_ID): cv.use_id(EmonTx),
        cv.Required(CONF_TAG_NAME): cv.string,
@@ -93,43 +91,34 @@ BASE_SCHEMA = sensor.sensor_schema(EmonTxSensor).extend(
 )


-def _apply_defaults(config: ConfigType, defaults: dict) -> None:
-    """Inject defaults into config, skipping keys already set by the user.
-    state_class values are run through validate_state_class so they are
-    code-generation-ready, matching what sensor_schema() would normally do."""
-    for key, value in defaults.items():
-        if key not in config:
-            if key == CONF_STATE_CLASS:
-                value = sensor.validate_state_class(value)
-            config[key] = value
-
-
 def apply_tag_defaults(config: ConfigType) -> ConfigType:
    """Apply defaults based on tag prefix if applicable, but don't restrict any tags."""
    tag = config[CONF_TAG_NAME]

-    if len(tag) >= 2:
-        tag_upper = tag.upper()
+    # Skip if tag is too short
+    if len(tag) < 2:
+        return config

-        for pattern, pattern_config in PATTERN_CONFIGS.items():
-            if tag_upper.startswith(pattern):
-                _apply_defaults(config, pattern_config)
-                return config
+    # Check if this tag starts with a known prefix
+    tag_upper = tag.upper()

-        # Only apply defaults for known prefixes with numeric indices (e.g. E1, V2, T3)
-        prefix = tag_upper[0]
-        if prefix in SENSOR_CONFIGS and tag[1:].isdigit():
-            _apply_defaults(config, SENSOR_CONFIGS[prefix])
+    for pattern, pattern_config in PATTERN_CONFIGS.items():
+        if tag_upper.startswith(pattern):
+            # Apply pattern defaults if not overridden by user
+            for key, value in pattern_config.items():
+                if key not in config:
+                    config[key] = value
            return config

-    # Fall back to generic defaults for tags with no known prefix
-    _apply_defaults(
-        config,
-        {
-            CONF_STATE_CLASS: STATE_CLASS_MEASUREMENT,
-            CONF_ACCURACY_DECIMALS: 0,
-        },
-    )
+    # Only apply defaults for known prefixes with numeric indices
+    prefix = tag_upper[0]
+    if prefix in SENSOR_CONFIGS and len(tag) > 1 and tag[1:].isdigit():
+        # Apply defaults for known tag types, but only if not overridden by user
+        defaults = SENSOR_CONFIGS[prefix]
+        for key, value in defaults.items():
+            if key not in config:
+                config[key] = value
+
    return config


@@ -153,7 +153,7 @@ def customise_schema(config):
 CONFIG_SCHEMA = customise_schema


-def _final_validate(config):
+def _final_validate(config) -> None:
    spi.final_validate_device_schema(
        "epaper_spi", require_miso=False, require_mosi=True
    )(config)
@@ -170,7 +170,6 @@ def _final_validate(config):
            config[CONF_SHOW_TEST_CARD] = True
    elif CONF_UPDATE_INTERVAL not in config:
        config[CONF_UPDATE_INTERVAL] = update_interval("1min")
-    return config


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -570,6 +570,9 @@ def get_download_types(storage_json):
    the shape stable so the download panel
    doesn't have to special-case per-platform schemas.
    """
+    # No recorded firmware path means nothing was built; no downloads.
+    if storage_json.firmware_bin_path is None:
+        return []
    return [
        {
            "title": "Factory format (Previously Modern)",
@@ -1384,7 +1387,7 @@ def _validate_signed_ota_keys(config: ConfigType) -> ConfigType:
    return config


-def final_validate(config):
+def final_validate(config) -> None:
    # Imported locally to avoid circular import issues
    from esphome.components.psram import DOMAIN as PSRAM_DOMAIN

@@ -1631,8 +1634,6 @@ def final_validate(config):
    if errs:
        raise cv.MultipleInvalid(errs)

-    return config
-

 CONF_SDKCONFIG_OPTIONS = "sdkconfig_options"
 CONF_ENABLE_LWIP_DHCP_SERVER = "enable_lwip_dhcp_server"
@@ -124,15 +124,6 @@ static uint8_t IRAM_ATTR capture_riscv_backtrace(RvExcFrame *frame, uint32_t *ou
 // Version is uint32_t because it would be padded to 4 bytes anyway before the next
 // uint32_t field, so we use the full width rather than wasting 3 bytes of padding.
 static constexpr uint32_t CRASH_DATA_VERSION = 4;
-#if CONFIG_IDF_TARGET_ARCH_XTENSA
-// EXCCAUSE is a 6-bit register; larger recorded values mean the frame's
-// cause/vaddr slots were never written (not a real exception frame).
-static constexpr uint32_t XTENSA_EXCCAUSE_COUNT = XCHAL_EXCCAUSE_NUM;
-#elif CONFIG_IDF_TARGET_ARCH_RISCV
-// Synchronous mcause exception codes are small and have no interrupt bit;
-// anything else in a non-pseudo record is a stale slot.
-static constexpr uint32_t RISCV_EXCEPTION_CAUSE_COUNT = 32;
-#endif
 struct RawCrashData {
  uint32_t version;
  uint32_t magic;
@@ -207,28 +198,10 @@ void crash_handler_clear() {
  s_raw_crash_data.magic = 0;
 }

-// Whether the cause slot was written by a real exception frame.
-static bool cause_slot_was_written() {
-#if CONFIG_IDF_TARGET_ARCH_XTENSA
-  return s_raw_crash_data.cause < XTENSA_EXCCAUSE_COUNT;
-#else
-  return s_raw_crash_data.cause < RISCV_EXCEPTION_CAUSE_COUNT;
-#endif
-}
-
 // Look up the exception cause as a human-readable string.
 // Tables mirror ESP-IDF's panic_arch_fill_info() which uses local static arrays
 // not exposed via any public API.
 static const char *get_exception_reason() {
-  uint8_t exception = s_raw_crash_data.exception;
-  if (exception == PANIC_EXCEPTION_ABORT || exception == PANIC_EXCEPTION_TWDT) {
-    // Abort-class panics carry no cause register
-    return nullptr;
-  }
-  if (!cause_slot_was_written()) {
-    // Garbage from old-build or corrupt records; report just the type
-    return nullptr;
-  }
 #if CONFIG_IDF_TARGET_ARCH_XTENSA
  if (s_raw_crash_data.pseudo_excause) {
    // SoC-level panic: watchdog, cache error, etc.
@@ -381,11 +354,10 @@ static const char *const FAULT_ADDR_REG = "MTVAL";
 static const char *const FAULT_ADDR_REG_LOWER = "mtval";
 #endif

-// Whether the fault address is meaningful: real CPU faults with a validly
-// written frame only.
+// Whether the fault address is meaningful — real CPU faults only, not
+// aborts/watchdogs or SoC-level pseudo exceptions.
 static bool has_fault_addr() {
-  return s_raw_crash_data.exception == PANIC_EXCEPTION_FAULT && !s_raw_crash_data.pseudo_excause &&
-         cause_slot_was_written();
+  return s_raw_crash_data.exception == PANIC_EXCEPTION_FAULT && !s_raw_crash_data.pseudo_excause;
 }

 // The record was captured by a different firmware build (it survives soft
@@ -486,10 +458,6 @@ void crash_handler_log() {
 // into NOINIT memory before the normal panic handler runs.
 //
 extern "C" {
-// Set by IDF's task watchdog (task_wdt.c, no header) before it simulates an
-// abort; weak so builds without the task watchdog still link.
-extern bool g_twdt_isr __attribute__((weak));
-
 // NOLINTBEGIN(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
 // Names are mandated by the --wrap linker mechanism
 extern void __real_esp_panic_handler(panic_info_t *info);
@@ -502,14 +470,6 @@ void IRAM_ATTR __wrap_esp_panic_handler(panic_info_t *info) {
  s_raw_crash_data.exception = (uint8_t) info->exception;
  s_raw_crash_data.pseudo_excause = info->pseudo_excause ? 1 : 0;
  s_raw_crash_data.crashed_core = (uint8_t) info->core;
-  if (g_panic_abort) {
-    // IDF reclassifies to ABORT only inside esp_panic_handler(), after this
-    // wrapper captured info->exception; correct it here. TWDT is our own
-    // distinction (IDF never assigns PANIC_EXCEPTION_TWDT). The abort text is
-    // not stored; the symbolized backtrace already identifies the site.
-    bool is_twdt = &g_twdt_isr != nullptr && g_twdt_isr;
-    s_raw_crash_data.exception = (uint8_t) (is_twdt ? PANIC_EXCEPTION_TWDT : PANIC_EXCEPTION_ABORT);
-  }
  // Zero unconditionally so a null frame doesn't leave stale .noinit data from a previous boot
  s_raw_crash_data.cause = 0;
  s_raw_crash_data.fault_addr = 0;
@@ -527,12 +487,8 @@ void IRAM_ATTR __wrap_esp_panic_handler(panic_info_t *info) {
  // Xtensa: walk the backtrace using the public API
  if (info->frame != nullptr) {
    auto *xt_frame = (XtExcFrame *) info->frame;
-    if (!g_panic_abort) {
-      // Abort-class frames carry no useful cause/vaddr: TWDT task snapshots
-      // never wrote them and abort() traps describe only the synthetic trap.
-      s_raw_crash_data.cause = xt_frame->exccause;
-      s_raw_crash_data.fault_addr = xt_frame->excvaddr;
-    }
+    s_raw_crash_data.cause = xt_frame->exccause;
+    s_raw_crash_data.fault_addr = xt_frame->excvaddr;
    s_raw_crash_data.backtrace_count = walk_xtensa_backtrace(xt_frame, s_raw_crash_data.backtrace, MAX_BACKTRACE);
  }

@@ -554,11 +510,8 @@ void IRAM_ATTR __wrap_esp_panic_handler(panic_info_t *info) {
  // RISC-V: capture MEPC + RA, then scan stack for code addresses
  if (info->frame != nullptr) {
    auto *rv_frame = (RvExcFrame *) info->frame;
-    if (!g_panic_abort) {
-      // See the Xtensa branch: abort-class frames carry no valid cause/vaddr.
-      s_raw_crash_data.cause = rv_frame->mcause;
-      s_raw_crash_data.fault_addr = rv_frame->mtval;
-    }
+    s_raw_crash_data.cause = rv_frame->mcause;
+    s_raw_crash_data.fault_addr = rv_frame->mtval;
    s_raw_crash_data.backtrace_count =
        capture_riscv_backtrace(rv_frame, s_raw_crash_data.backtrace, MAX_BACKTRACE, &s_raw_crash_data.reg_frame_count);
  }
@@ -443,7 +443,7 @@ def validate_connection_slots(max_connections: int) -> None:
    )


-def final_validation(config):
+def final_validation(config) -> None:
    validate_variant(config)
    if (name := config.get(CONF_NAME)) is not None:
        full_config = fv.full_config.get()
@@ -514,8 +514,6 @@ def final_validation(config):
    # For newer chips (C3/S3/etc), different configs are used automatically
    add_idf_sdkconfig_option("CONFIG_BTDM_CTRL_BLE_MAX_CONN", max_connections)

-    return config
-

 FINAL_VALIDATE_SCHEMA = final_validation

@@ -643,28 +643,8 @@ void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_pa
      App.wake_loop_threadsafe();
      return;

-    // Log the result of connection parameter updates: a peer can reject or
-    // never answer an update, and without this the link silently stays on the
-    // old parameters (visible only as unexplained supervision timeouts).
-    case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT: {
-      if (param->update_conn_params.status != ESP_BT_STATUS_SUCCESS) {
-        char mac_s[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-        format_mac_addr_upper(param->update_conn_params.bda, mac_s);
-        ESP_LOGW(TAG, "[%s] Conn param update failed, status=%d", mac_s, param->update_conn_params.status);
-      }
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-      else {
-        char mac_s[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-        format_mac_addr_upper(param->update_conn_params.bda, mac_s);
-        ESP_LOGV(TAG, "[%s] Conn params updated: interval=%u (x1.25ms) latency=%u timeout=%u (x10ms)", mac_s,
-                 param->update_conn_params.conn_int, param->update_conn_params.latency,
-                 param->update_conn_params.timeout);
-      }
-#endif
-      return;
-    }
-
    // Ignore these GAP events as they are not relevant for our use case
+    case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT:
    case ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT:
    case ESP_GAP_BLE_PHY_UPDATE_COMPLETE_EVT:       // BLE 5.0 PHY update complete
    case ESP_GAP_BLE_CHANNEL_SELECT_ALGORITHM_EVT:  // BLE 5.0 channel selection algorithm
@@ -307,7 +307,7 @@ def create_device_information_service(config):
    return config


-def final_validate_config(config):
+def final_validate_config(config) -> None:
    # Validate max_clients does not exceed esp32_ble max_connections
    max_clients = config[CONF_MAX_CLIENTS]
    if max_clients > 1:
@@ -355,7 +355,6 @@ def final_validate_config(config):
            raise cv.Invalid(
                f"Characteristic {char_config[CONF_UUID]} has both a set_value action and a templated value"
            )
-    return config


 def validate_value_type(value_config):
@@ -7,7 +7,6 @@ import logging
 from esphome import automation
 import esphome.codegen as cg
 from esphome.components import ble_device_base, esp32_ble, ota
-from esphome.components.ble_device_base import CONF_CONNECTION_SCAN_WINDOW
 from esphome.components.const import CONF_ON_SCAN_END, CONF_SCAN_PARAMETERS, CONF_WINDOW
 from esphome.components.esp32 import (
    add_idf_sdkconfig_option,
@@ -73,9 +72,8 @@ def _get_required_features() -> set[BLEFeatures]:

 # Slot counters sizing the tracker's StaticVector storage; one request per
 # registered listener or client.
-CLIENT_COUNT_DEFINE = "ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT"
 _request_listener_slot = cg.slot_counter("ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT")
-_request_client_slot = cg.slot_counter(CLIENT_COUNT_DEFINE)
+_request_client_slot = cg.slot_counter("ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT")


 def register_ble_features(features: set[BLEFeatures]) -> None:
@@ -148,7 +146,6 @@ class TrackerData:
    """Per-run validation state, namespaced under DOMAIN in CORE.data."""

    scan_window_defaulted: bool = False
-    connection_window_injected: bool = False


 def _get_data() -> TrackerData:
@@ -177,34 +174,17 @@ def _raise_defaulted_scan_window(config: ConfigType) -> ConfigType:
    honors the window strictly (>= 5.5.5); without the arbiter a full-duty
    scan would starve wifi outright, and a user-set window is never touched.
    Raising to the interval cannot invalidate the already-validated
-    parameters, so no re-validation is needed. The connection window is
-    checked against the window here, after the raise.
+    parameters, so no re-validation is needed.
    """
-    params = config[CONF_SCAN_PARAMETERS]
    if (
        _get_data().scan_window_defaulted
        and config.get(CONF_SOFTWARE_COEXISTENCE)
        and idf_version() >= IDF_SCAN_WINDOW_FIX_VERSION
    ):
+        params = config[CONF_SCAN_PARAMETERS]
        # Copy so the config dump shows a plain value instead of a YAML
        # anchor/alias pair pointing at the interval.
        params[CONF_WINDOW] = copy.copy(params[CONF_INTERVAL])
-        # Arm the connection-time fallback unless the user set one. Injected
-        # after validation; safe because it equals the validated window default.
-        if CONF_CONNECTION_SCAN_WINDOW not in params:
-            params[CONF_CONNECTION_SCAN_WINDOW] = cv.positive_time_period(
-                ble_device_base.DEFAULT_SCAN_WINDOW
-            )
-            _get_data().connection_window_injected = True
-    if (
-        connection_window := params.get(CONF_CONNECTION_SCAN_WINDOW)
-    ) is not None and connection_window > params[CONF_WINDOW]:
-        # A larger value would widen the scan during connections.
-        raise cv.Invalid(
-            f"{CONF_CONNECTION_SCAN_WINDOW} ({connection_window}) needs to be "
-            f"smaller than the scan window ({params[CONF_WINDOW]})",
-            path=[CONF_SCAN_PARAMETERS, CONF_CONNECTION_SCAN_WINDOW],
-        )
    return config


@@ -213,7 +193,7 @@ def _raise_defaulted_scan_window(config: ConfigType) -> ConfigType:
 # window/interval pairs that collapse to the same 0.625 ms unit count.
 # The window default is conditional (see _scan_window_default above).
 SCAN_PARAMETERS_SCHEMA = ble_device_base.scan_parameters_schema(
-    "320ms", window_default=_scan_window_default, connection_window=True
+    "320ms", window_default=_scan_window_default
 )

 # Codegen helpers are owned by ble_device_base; kept under the historical names
@@ -307,25 +287,6 @@ async def to_code(config):
    cg.add(var.set_scan_duration(params[CONF_DURATION]))
    cg.add(var.set_scan_interval(ble_device_base.to_ble_units(params[CONF_INTERVAL])))
    cg.add(var.set_scan_window(ble_device_base.to_ble_units(params[CONF_WINDOW])))
-    if (connection_window := params.get(CONF_CONNECTION_SCAN_WINDOW)) is not None:
-        # Emitted at FINAL so a scan-only build, where the guarded C++ path
-        # compiles out, skips the call entirely.
-        window_units = ble_device_base.to_ble_units(connection_window)
-
-        @coroutine_with_priority(CoroPriority.FINAL)
-        async def _emit_connection_scan_window() -> None:
-            if cg.get_slot_count(CLIENT_COUNT_DEFINE):
-                cg.add(var.set_connection_scan_window(window_units))
-            elif not _get_data().connection_window_injected:
-                # Warn only for a user-set value; the injected default drops silently.
-                _LOGGER.warning(
-                    "'%s' has no effect because this build has no BLE client "
-                    "components (for example bluetooth_proxy with active "
-                    "connections, or ble_client)",
-                    CONF_CONNECTION_SCAN_WINDOW,
-                )
-
-        CORE.add_job(_emit_connection_scan_window)
    cg.add(var.set_scan_active(params[CONF_ACTIVE]))
    cg.add(var.set_scan_continuous(params[CONF_CONTINUOUS]))

@@ -122,9 +122,6 @@ void ESP32BLETracker::loop() {
  // - start_scan_(): scanner_state_ becomes IDLE via set_scanner_state_() in cleanup_scan_state_()
  // - try_promote_discovered_clients_(): client enters DISCOVERED via set_state(), or
  //   connecting client finishes (state change), or scanner reaches RUNNING/IDLE
-  // - connection-window restart: scan_params_ is only written in start_scan_()
-  //   (which changes scanner state via set_scanner_state_()), and
-  //   counts.active/disconnecting only change on client state changes
  //
  // All conditions that affect the logic below are tied to state changes that increment
  // state_version_, so the fast path is safe.
@@ -147,19 +144,6 @@ void ESP32BLETracker::loop() {
      (this->scan_set_param_failed_ && this->scanner_state_ == ScannerState::RUNNING)) {
    this->handle_scanner_failure_();
  }
-
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
-  // The programmed window no longer matches the connection state (typically
-  // the last connection dropped): restart so the right window applies now
-  // instead of at the end of the scan period. Continuous only (a user-started
-  // scan would not restart); !disconnecting matches the restart gate below.
-  if (this->scanner_state_ == ScannerState::RUNNING && this->scan_continuous_ && !counts.disconnecting &&
-      this->scan_params_.scan_window != this->desired_scan_window_(counts.active)) {
-    // Same logical scan period continues: no on_scan_end sweeps for this
-    // restart. Only armed when the stop was issued.
-    this->skip_next_scan_end_ = this->stop_scan_();
-  }
-#endif
  /*

    Avoid starting the scanner if:
@@ -211,23 +195,19 @@ void ESP32BLETracker::stop_scan() {
  // reason at D themselves, and the user-facing stop action is deliberate.
  ESP_LOGV(TAG, "Stopping scan.");
  this->scan_continuous_ = false;
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
-  // The window-change restart is abandoned with continuous scanning.
-  this->skip_next_scan_end_ = false;
-#endif
  this->stop_scan_();
 }

 void ESP32BLETracker::ble_before_disabled_event_handler() { this->stop_scan_(); }

-bool ESP32BLETracker::stop_scan_() {
+void ESP32BLETracker::stop_scan_() {
  if (this->scanner_state_ != ScannerState::RUNNING && this->scanner_state_ != ScannerState::FAILED) {
    // IDLE means there is nothing to stop; STOPPING means a stop is already in
    // flight and will finish on its own. Neither is an error.
    if (this->scanner_state_ != ScannerState::IDLE && this->scanner_state_ != ScannerState::STOPPING) {
      ESP_LOGE(TAG, "Cannot stop scan: %s", this->scanner_state_to_string_(this->scanner_state_));
    }
-    return false;
+    return;
  }
  // Reset timeout state machine when stopping scan
  this->scan_timeout_state_ = ScanTimeoutState::INACTIVE;
@@ -235,9 +215,8 @@ bool ESP32BLETracker::stop_scan_() {
  esp_err_t err = esp_ble_gap_stop_scanning();
  if (err != ESP_OK) {
    ESP_LOGE(TAG, "esp_ble_gap_stop_scanning failed: %d", err);
-    return false;
+    return;
  }
-  return true;
 }

 void ESP32BLETracker::start_scan_(bool first) {
@@ -251,11 +230,16 @@ void ESP32BLETracker::start_scan_(bool first) {
  }
  this->set_scanner_state_(ScannerState::STARTING);
  ESP_LOGV(TAG, "Starting scan, set scanner state to STARTING.");
-  if (!first)
-    this->notify_scan_end_();
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
-  this->skip_next_scan_end_ = false;
+  if (!first) {
+#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
+    for (auto *listener : this->listeners_)
+      listener->on_scan_end();
 #endif
+#ifdef ESPHOME_BLE_DEVICE_BASE_LISTENER_COUNT
+    for (auto *listener : this->neutral_listeners_)
+      listener->on_scan_end();
+#endif
+  }
 #ifdef USE_ESP32_BLE_DEVICE
  this->discovered_log_.clear();
 #endif
@@ -263,17 +247,7 @@ void ESP32BLETracker::start_scan_(bool first) {
  this->scan_params_.own_addr_type = BLE_ADDR_TYPE_PUBLIC;
  this->scan_params_.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL;
  this->scan_params_.scan_interval = this->scan_interval_;
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
-  // Count fresh: an automation can start a scan before loop() refreshes the counts.
-  const uint32_t window = this->desired_scan_window_(this->count_client_states_().active);
-  if (window != this->scan_window_) {
-    // Guarantee the connection airtime instead of scanning wall to wall.
-    ESP_LOGV(TAG, "Connection active, using %" PRIu32 " unit scan window", window);
-  }
-#else
-  const uint32_t window = this->scan_window_;
-#endif
-  this->scan_params_.scan_window = window;
+  this->scan_params_.scan_window = this->scan_window_;

  // Start timeout monitoring in loop() instead of using scheduler
  // This prevents false reboots when the loop is blocked
@@ -434,11 +408,6 @@ void ESP32BLETracker::dump_config() {
                "  Continuous Scanning: %s",
                this->scan_duration_, this->scan_interval_ * 0.625f, this->scan_window_ * 0.625f,
                this->scan_active_ ? "ACTIVE" : "PASSIVE", YESNO(this->scan_continuous_));
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
-  if (this->connection_scan_window_ != 0) {
-    ESP_LOGCONFIG(TAG, "  Connection Scan Window: %.1f ms", this->connection_scan_window_ * 0.625f);
-  }
-#endif
  ESP_LOGCONFIG(TAG,
                "  Scanner State: %s\n"
                "  Connecting: %d, discovered: %d, disconnecting: %d, active: %d",
@@ -518,18 +487,6 @@ void ESP32BLETracker::cleanup_scan_state_(bool is_stop_complete) {
  // Reset timeout state machine instead of cancelling scheduler timeout
  this->scan_timeout_state_ = ScanTimeoutState::INACTIVE;

-  this->notify_scan_end_();
-
-  this->set_scanner_state_(ScannerState::IDLE);
-}
-
-void ESP32BLETracker::notify_scan_end_() {
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
-  // Window-change restart continues the same scan period; the flag stays set
-  // across the stop and is cleared by the restart in start_scan_.
-  if (this->skip_next_scan_end_)
-    return;
-#endif
 #ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
  for (auto *listener : this->listeners_)
    listener->on_scan_end();
@@ -538,6 +495,8 @@ void ESP32BLETracker::notify_scan_end_() {
  for (auto *listener : this->neutral_listeners_)
    listener->on_scan_end();
 #endif
+
+  this->set_scanner_state_(ScannerState::IDLE);
 }

 void ESP32BLETracker::handle_scanner_failure_() {
@@ -575,8 +534,6 @@ void ESP32BLETracker::try_promote_discovered_clients_() {
    }

    ESP_LOGD(TAG, "Promoting client to connect");
-    // A connect ends the scan period a window-change restart was continuing.
-    this->skip_next_scan_end_ = false;
 #ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
    this->update_coex_preference_(true);
 #endif
@@ -169,9 +169,6 @@ class ESP32BLETracker final : public Component,
  void set_scan_duration(uint32_t scan_duration) { scan_duration_ = scan_duration; }
  void set_scan_interval(uint32_t scan_interval) { scan_interval_ = scan_interval; }
  void set_scan_window(uint32_t scan_window) { scan_window_ = scan_window; }
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
-  void set_connection_scan_window(uint32_t scan_window) { connection_scan_window_ = scan_window; }
-#endif
  void set_scan_active(bool scan_active) { scan_active_ = scan_active; }
  bool get_scan_active() const { return scan_active_; }
  void set_scan_continuous(bool scan_continuous) { scan_continuous_ = scan_continuous; }
@@ -229,10 +226,7 @@ class ESP32BLETracker final : public Component,
  ScannerState get_scanner_state() const { return this->scanner_state_; }

 protected:
-  /// Returns true when a stop was issued to the controller.
-  bool stop_scan_();
-  /// Fire on_scan_end on every listener unless a window-change restart suppressed it.
-  void notify_scan_end_();
+  void stop_scan_();
  /// Start a single scan by setting up the parameters and doing some esp-idf calls.
  void start_scan_(bool first);
  /// Called when a `ESP_GAP_BLE_SCAN_RESULT_EVT` event is received.
@@ -319,15 +313,6 @@ class ESP32BLETracker final : public Component,
  uint32_t scan_duration_;
  uint32_t scan_interval_;
  uint32_t scan_window_;
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
-  /// Window used while a GATT connection is active; set by the user, or
-  /// defaulted when the window was raised to full duty (0 = no fallback).
-  uint32_t connection_scan_window_{0};
-  /// The window to scan at for the given number of active GATT connections.
-  uint32_t desired_scan_window_(uint8_t active) const {
-    return (this->connection_scan_window_ != 0 && active > 0) ? this->connection_scan_window_ : this->scan_window_;
-  }
-#endif
  esp_bt_status_t scan_start_failed_{ESP_BT_STATUS_SUCCESS};
  esp_bt_status_t scan_set_param_failed_{ESP_BT_STATUS_SUCCESS};

@@ -345,20 +330,15 @@ class ESP32BLETracker final : public Component,
  /// state_version_ to detect if any state changed since last iteration.
  uint8_t last_processed_version_{0};
  ScannerState scanner_state_{ScannerState::IDLE};
-  // Packed 1-bit flags.
-  bool scan_continuous_ : 1;
-  bool scan_active_ : 1;
+  bool scan_continuous_;
+  bool scan_active_;
 #ifdef USE_OTA_STATE_LISTENER
-  bool scan_continuous_before_ota_ : 1 {false};
-#endif
-  bool ble_was_disabled_ : 1 {true};
-  bool parse_advertisements_ : 1 {false};
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
-  /// Suppress the window-change restart's on_scan_end sweeps (stop and start).
-  bool skip_next_scan_end_ : 1 {false};
+  bool scan_continuous_before_ota_{false};
 #endif
+  bool ble_was_disabled_{true};
+  bool parse_advertisements_{false};
 #ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
-  bool coex_prefer_ble_ : 1 {false};
+  bool coex_prefer_ble_{false};
 #endif
  // Scan timeout state machine
  enum class ScanTimeoutState : uint8_t {
@@ -366,10 +346,10 @@ class ESP32BLETracker final : public Component,
    MONITORING,     // Actively monitoring for timeout
    EXCEEDED_WAIT,  // Timeout exceeded, waiting one loop before reboot
  };
-  ScanTimeoutState scan_timeout_state_{ScanTimeoutState::INACTIVE};
  uint32_t scan_start_time_{0};
  /// Precomputed timeout value: scan_duration_ * 2000
  uint32_t scan_timeout_ms_{0};
+  ScanTimeoutState scan_timeout_state_{ScanTimeoutState::INACTIVE};
 };

 // NOLINTNEXTLINE
@@ -3,7 +3,7 @@ from pathlib import Path

 from esphome import pins
 from esphome.components import esp32
-from esphome.components.const import CONF_USE_PSRAM
+from esphome.components.const import CONF_SLOT, CONF_USE_PSRAM
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_CLK_PIN,
@@ -16,8 +16,10 @@ from esphome.const import (
    CONF_VARIANT,
 )
 from esphome.cpp_generator import add_define
+from esphome.types import ConfigType

 CODEOWNERS = ["@swoboda1337"]
+DEPENDENCIES = ["esp32"]
 # esp32_ble raises the task watchdog around the remote BT controller bring-up
 AUTO_LOAD = ["watchdog"]

@@ -33,7 +35,6 @@ CONF_DATA_READY_PIN = "data_ready_pin"
 CONF_HANDSHAKE_ACTIVE_HIGH = "handshake_active_high"
 CONF_HANDSHAKE_PIN = "handshake_pin"
 CONF_SDIO_FREQUENCY = "sdio_frequency"
-CONF_SLOT = "slot"
 CONF_SPI_MODE = "spi_mode"

 # Shared fields for both transport modes
@@ -125,6 +126,21 @@ CONFIG_SCHEMA = cv.typed_schema(
 )


+def _final_validate(config: ConfigType) -> None:
+    # The esp_hosted releases compatible with older ESP-IDF versions crash at
+    # boot with a heap double free in the SDIO RX path (fixed in esp_hosted
+    # 2.11.0, which requires ESP-IDF 5.3), so reject them at validation time.
+    if (idf_ver := esp32.idf_version()) < cv.Version(5, 3, 0):
+        raise cv.Invalid(
+            f"esp32_hosted requires ESP-IDF 5.3 or newer, got {idf_ver}. "
+            "Remove the framework version from your configuration to use the "
+            "recommended version, or pin a version at or above 5.3."
+        )
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
 def _configure_sdio(config):
    slot = config[CONF_SLOT]
    esp32.add_idf_sdkconfig_option(
@@ -252,18 +268,14 @@ async def to_code(config):
    if config[CONF_USE_PSRAM]:
        esp32.add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_MEMPOOL_PREFER_SPIRAM", True)

-    # Library versions
+    # Library versions; this component set requires ESP-IDF 5.3 or newer,
+    # which is enforced at validation time.
    idf_ver = esp32.idf_version()
    os.environ["ESP_IDF_VERSION"] = f"{idf_ver.major}.{idf_ver.minor}"
-    if idf_ver >= cv.Version(5, 5, 0):
-        esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="1.6.3")
-        esp32.add_idf_component(name="espressif/wifi_remote_over_eppp", ref="0.3.3")
-        esp32.add_idf_component(name="espressif/eppp_link", ref="1.1.5")
-        esp32.add_idf_component(name="espressif/esp_hosted", ref="2.12.12")
-    else:
-        esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="0.13.0")
-        esp32.add_idf_component(name="espressif/eppp_link", ref="0.2.0")
-        esp32.add_idf_component(name="espressif/esp_hosted", ref="2.0.11")
+    esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="1.6.3")
+    esp32.add_idf_component(name="espressif/wifi_remote_over_eppp", ref="0.3.3")
+    esp32.add_idf_component(name="espressif/eppp_link", ref="1.1.5")
+    esp32.add_idf_component(name="espressif/esp_hosted", ref="2.12.12")
    esp32.add_extra_script(
        "post",
        "esp32_hosted.py",
@@ -135,10 +135,6 @@ void Esp32HostedUpdate::setup() {
  // Publish state
  this->status_clear_error();
  this->publish_state();
-  // Defer so the automation runs on the main loop after setup, not during App.setup()
-  if (this->state_ == update::UPDATE_STATE_AVAILABLE && this->update_available_trigger_) {
-    this->defer([this]() { this->update_available_trigger_->trigger(this->update_info_); });
-  }
 #else
  // HTTP mode: check every 10s until network is ready (max 6 attempts)
  // Only if update interval is > 1 minute to avoid redundant checks
@@ -189,8 +185,6 @@ void Esp32HostedUpdate::check() {
    return;
  }

-  const bool was_available = this->state_ == update::UPDATE_STATE_AVAILABLE;
-
  // Compare versions
  if (this->update_info_.latest_version.empty() ||
      this->update_info_.latest_version == this->update_info_.current_version) {
@@ -203,9 +197,6 @@ void Esp32HostedUpdate::check() {
  this->update_info_.progress = 0.0f;
  this->status_clear_error();
  this->publish_state();
-  if (this->state_ == update::UPDATE_STATE_AVAILABLE && !was_available && this->update_available_trigger_) {
-    this->update_available_trigger_->trigger(this->update_info_);
-  }
 #endif
 }

@@ -113,6 +113,9 @@ def get_download_types(storage_json):
    the shape stable so the download panel
    doesn't have to special-case per-platform schemas.
    """
+    # No recorded firmware path means nothing was built; no downloads.
+    if storage_json.firmware_bin_path is None:
+        return []
    return [
        {
            "title": "Standard format",
@@ -118,6 +118,8 @@ static const LogString *get_exception_cause(uint32_t cause) {
 }

 static const LogString *get_reset_reason(uint32_t reason) {
+  if (reason == REASON_WDT_RST)
+    return LOG_STR("Hardware WDT");
  if (reason == REASON_EXCEPTION_RST)
    return LOG_STR("Exception");
  if (reason == REASON_SOFT_WDT_RST)
@@ -160,20 +162,13 @@ void crash_handler_log() {
  if (!is_crash_reason(resetInfo.reason))
    return;

-  ESP_LOGE(TAG, "*** CRASH DETECTED ON PREVIOUS BOOT ***");
-  if (resetInfo.reason == REASON_WDT_RST) {
-    // A hardware WDT reset happens entirely in hardware: the postmortem hook
-    // never runs, so rst_info epc1/exccause and the RTC backtrace are
-    // leftovers from an earlier crash. Don't misattribute them (#18596).
-    ESP_LOGE(TAG, "  Reason: Hardware WDT (no crash state is recorded for hardware WDT resets)");
-    return;
-  }
-
  // Read and filter backtrace from RTC into stack-local buffer (no persistent RAM cost).
  // Both resetInfo and RTC data survive until the next reset, so this can be
  // called multiple times (logger init + API subscribe) with the same result.
  uint32_t backtrace[MAX_BACKTRACE];
  uint8_t bt_count = read_rtc_backtrace(backtrace, MAX_BACKTRACE);
+
+  ESP_LOGE(TAG, "*** CRASH DETECTED ON PREVIOUS BOOT ***");
  // GCC's ROM divide routine triggers IllegalInstruction (exccause=0) at specific
  // ROM addresses instead of IntegerDivideByZero (exccause=6). Patch to match
  // the Arduino core's postmortem handler behavior.
@@ -129,17 +129,14 @@ void on_data_received(const esp_now_recv_info_t *info, const uint8_t *data, int
 ESPNowComponent::ESPNowComponent() { global_esp_now = this; }

 void ESPNowComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "espnow:");
-  // Only report driver details once enabled; with enable_on_boot: false the
-  // Wi-Fi driver is not initialized yet and esp_now_get_version() would crash,
-  // and after a failed enable_() the values would be meaningless.
-  if (this->state_ != ESPNOW_STATE_ENABLED) {
-    // OFF here means enable_() failed; the core logs the FAILED marker separately
-    ESP_LOGCONFIG(TAG, "  %s", this->is_disabled() ? LOG_STR_LITERAL("Disabled") : LOG_STR_LITERAL("Not enabled"));
-    return;
-  }
  uint32_t version = 0;
  esp_now_get_version(&version);
+
+  ESP_LOGCONFIG(TAG, "espnow:");
+  if (this->is_disabled()) {
+    ESP_LOGCONFIG(TAG, "  Disabled");
+    return;
+  }
  char own_addr_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
  format_mac_addr_upper(this->own_address_, own_addr_buf);
  ESP_LOGCONFIG(TAG,
@@ -355,7 +355,7 @@ def _validate(config):
                    "  clk:\n"
                    "    mode: %s\n"
                    "    pin: %s\n"
-                    "Removal scheduled for 2026.9.0.",
+                    "Removal scheduled for 2026.11.0.",
                    config[CONF_CLK_MODE],
                    mode,
                    pin,
@@ -767,7 +767,7 @@ def _final_validate_rmii_pins(config: ConfigType) -> None:
            raise cv.Invalid(error_msg, path=pin_path)


-def _final_validate(config: ConfigType) -> ConfigType:
+def _final_validate(config: ConfigType) -> None:
    """Final validation for Ethernet component."""
    # Allow ethernet + wifi coexistence only when both are declared in network: priority:.
    if "wifi" in fv.full_config.get():
@@ -787,7 +787,6 @@ def _final_validate(config: ConfigType) -> ConfigType:

    _final_validate_spi(config)
    _final_validate_rmii_pins(config)
-    return config


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -60,14 +60,13 @@ CONFIG_SCHEMA = cv.All(
 )


-def _final_validate(config):
+def _final_validate(config) -> None:
    if CORE.is_esp8266 and CONF_RESETS_REQUIRED in config:
        fconfig = full_config.get()
        if not fconfig.get_config_for_path([KEY_ESP8266, CONF_RESTORE_FROM_FLASH]):
            raise cv.Invalid(
                "'resets_required' needs 'restore_from_flash' to be enabled in the  'esp8266' configuration"
            )
-    return config


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -226,7 +226,7 @@ def image_schema(class_: MockObjClass = Image_) -> cv.Schema:
    )


-def validate_image_final(config: ConfigType) -> ConfigType:
+def validate_image_final(config: ConfigType) -> None:
    """Per-entry final validation, shared by file-backed image platforms.

    For LVGL 9 the default byte order for RGB565 images is little-endian, so
@@ -241,7 +241,6 @@ def validate_image_final(config: ConfigType) -> ConfigType:
            )
    else:
        config[CONF_BYTE_ORDER] = "LITTLE_ENDIAN"
-    return config


 async def new_image(config: ConfigType) -> MockObj:
@@ -68,10 +68,10 @@ def _pin_shared_only_with_deep_sleep(pin_num: int) -> bool:
    return any(path and path[0] == "deep_sleep" for path, _, _ in pin_users)


-def _final_validate(config):
+def _final_validate(config) -> None:
    use_interrupt = config[CONF_USE_INTERRUPT]
    if not use_interrupt:
-        return config
+        return

    # Expander pins (e.g. PCF8574, MCP23017) don't support direct interrupt
    # attachment — only internal/native GPIO pins do.
@@ -82,7 +82,7 @@ def _final_validate(config):
            config.get(CONF_NAME, config[CONF_ID]),
        )
        config[CONF_USE_INTERRUPT] = False
-        return config
+        return

    pin_num = config[CONF_PIN][CONF_NUMBER]

@@ -96,7 +96,7 @@ def _final_validate(config):
            config.get(CONF_NAME, config[CONF_ID]),
        )
        config[CONF_USE_INTERRUPT] = False
-        return config
+        return

    # When a pin is shared, interrupts can interfere with other components
    # (e.g., duty_cycle sensor) that need to monitor the pin's state changes.
@@ -120,8 +120,6 @@ def _final_validate(config):
                pin_num,
            )

-    return config
-

 FINAL_VALIDATE_SCHEMA = _final_validate

@@ -163,8 +163,8 @@ CONFIG_SCHEMA = (
 )


-def _final_validate(config: ConfigType) -> ConfigType:
-    return modbus.final_validate_modbus_device("growatt_solar", role="client")(config)
+def _final_validate(config: ConfigType) -> None:
+    modbus.final_validate_modbus_device("growatt_solar", role="client")(config)


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -424,7 +424,7 @@ async def power_action_to_code(config, action_id, template_arg, args):
    return cg.new_Pvariable(action_id, template_arg, paren)


-def _final_validate(config):
+def _final_validate(config) -> None:
    full_config = fv.full_config.get()
    if CONF_LOGGER in full_config:
        _level = "NONE"
@@ -448,7 +448,6 @@ def _final_validate(config):
        raise cv.Invalid(
            f"No WiFi configured, if you want to use haier climate without WiFi add {CONF_WIFI_SIGNAL}: false to climate configuration"
        )
-    return config


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -60,7 +60,7 @@ CONFIG_SCHEMA = cv.Schema(
 )


-def _final_validate(config):
+def _final_validate(config) -> None:
    full_config = fv.full_config.get()
    for switch_type in [CONF_BEEPER, CONF_QUIET_MODE]:
        # Check switches that are only supported for HonClimate
@@ -72,7 +72,6 @@ def _final_validate(config):
                raise cv.Invalid(
                    f"{switch_type} switch is only supported for hon climate"
                )
-    return config


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -217,8 +217,8 @@ CONFIG_SCHEMA = (
 )


-def _final_validate(config: ConfigType) -> ConfigType:
-    return modbus.final_validate_modbus_device("havells_solar", role="client")(config)
+def _final_validate(config: ConfigType) -> None:
+    modbus.final_validate_modbus_device("havells_solar", role="client")(config)


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -16,7 +16,7 @@

 namespace esphome::http_request {

-static const char *const TAG = "http_request.arduino";
+static const char *const TAG = "http_request";
 #ifdef USE_ESP8266
 // ESP8266 Arduino core (WiFiClientSecureBearSSL.cpp) returns -1000 on OOM
 static constexpr int ESP8266_SSL_ERR_OOM = -1000;
@@ -14,7 +14,7 @@

 namespace esphome::http_request {

-static const char *const TAG = "http_request.host";
+static const char *const TAG = "http_request";

 std::shared_ptr<HttpContainer> HttpRequestHost::perform(const std::string &url, const std::string &method,
                                                        const std::string &body,
@@ -16,7 +16,7 @@

 namespace esphome::http_request {

-static const char *const TAG = "http_request.idf";
+static const char *const TAG = "http_request";
 static constexpr uint32_t ERROR_DURATION_MS = 1000;

 void HttpRequestIDF::dump_config() {
@@ -315,7 +315,7 @@ def _validate_config(config: ConfigType) -> ConfigType:
    return config


-def _final_validate(config: ConfigType) -> ConfigType:
+def _final_validate(config: ConfigType) -> None:
    """Validate requirements when using HUB75 display."""
    # Local imports to avoid circular dependencies
    from esphome.components.esp32 import get_esp32_variant
@@ -381,8 +381,6 @@ def _final_validate(config: ConfigType) -> ConfigType:
    if errs:
        raise cv.MultipleInvalid(errs)

-    return config
-

 FINAL_VALIDATE_SCHEMA = cv.Schema(_final_validate)

@@ -9,7 +9,7 @@

 namespace esphome::i2c {

-static const char *const TAG = "i2c.arduino";
+static const char *const TAG = "i2c";

 // Maximum bytes to log in hex format (truncates larger transfers)
 static constexpr size_t I2C_MAX_LOG_BYTES = 32;
@@ -12,7 +12,7 @@

 namespace esphome::i2c {

-static const char *const TAG = "i2c.idf";
+static const char *const TAG = "i2c";

 // Maximum bytes to log in hex format (truncates larger transfers)
 static constexpr size_t I2C_MAX_LOG_BYTES = 32;
@@ -16,7 +16,7 @@

 namespace esphome::i2c {

-static const char *const TAG = "i2c.host";
+static const char *const TAG = "i2c";

 HostI2CBus::~HostI2CBus() {
  if (this->file_descriptor_ != -1) {
@@ -6,7 +6,7 @@

 namespace esphome::i2c {

-static const char *const TAG = "i2c.zephyr";
+static const char *const TAG = "i2c";

 static const char *get_speed(uint32_t dev_config) {
  switch (I2C_SPEED_GET(dev_config)) {
@@ -22,7 +22,7 @@ CONFIG_SCHEMA = (
 )


-def validate_logger(config):
+def validate_logger(config) -> None:
    logger_conf = fv.full_config.get()[CONF_LOGGER]
    if logger_conf[CONF_BAUD_RATE] == 0:
        raise cv.Invalid("improv_serial requires the logger baud_rate to be not 0")
@@ -33,7 +33,6 @@ def validate_logger(config):
        raise cv.Invalid(
            "improv_serial does not support the selected logger hardware_uart"
        )
-    return config


 FINAL_VALIDATE_SCHEMA = validate_logger
@@ -146,13 +146,12 @@ CONFIG_SCHEMA = cv.All(
 )


-def _validate_cpu_frequency(config):
+def _validate_cpu_frequency(config) -> None:
    esp32_config = fv.full_config.get()[PLATFORM_ESP32]
    if esp32_config[CONF_CPU_FREQUENCY] != "240MHZ":
        raise cv.Invalid(
            "Inkplate requires 240MHz CPU frequency (set in esp32 component)"
        )
-    return config


 FINAL_VALIDATE_SCHEMA = _validate_cpu_frequency
@@ -9,7 +9,7 @@ uint32_t temp_single_get_current_temperature(uint32_t *temp_value);

 namespace esphome::internal_temperature {

-static const char *const TAG = "internal_temperature.bk72xx";
+static const char *const TAG = "internal_temperature";

 void InternalTemperatureSensor::update() {
  float temperature = NAN;
@@ -16,7 +16,7 @@ uint8_t temprature_sens_read();

 namespace esphome::internal_temperature {

-static const char *const TAG = "internal_temperature.esp32";
+static const char *const TAG = "internal_temperature";

 void InternalTemperatureSensor::update() {
  float temperature = NAN;
@@ -16,7 +16,7 @@

 namespace esphome::internal_temperature {

-static const char *const TAG = "internal_temperature.rp2";
+static const char *const TAG = "internal_temperature";

 // The on-die temperature sensor sits on the last ADC channel: input 4 on RP2040
 // and RP2350A, but input 8 on RP2350B, which has eight external channels rather
@@ -8,7 +8,7 @@

 namespace esphome::internal_temperature {

-static const char *const TAG = "internal_temperature.zephyr";
+static const char *const TAG = "internal_temperature";

 static const struct device *const DIE_TEMPERATURE_SENSOR = DEVICE_DT_GET_ONE(nordic_nrf_temp);

@@ -336,7 +336,7 @@ def _customise_schema(config):
 CONFIG_SCHEMA = _customise_schema


-def _final_validate(config):
+def _final_validate(config) -> None:
    # IT8951 reads from SPI (DevInfo, VCOM, register reads) so MISO is required.
    spi.final_validate_device_schema("it8951", require_miso=True, require_mosi=True)(
        config
@@ -351,7 +351,6 @@ def _final_validate(config):
                config[CONF_UPDATE_INTERVAL] = update_interval("never")
        else:
            config[CONF_SHOW_TEST_CARD] = True
-    return config


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -89,8 +89,8 @@ CONFIG_SCHEMA = (
 )


-def _final_validate(config: ConfigType) -> ConfigType:
-    return modbus.final_validate_modbus_device("kuntze", role="client")(config)
+def _final_validate(config: ConfigType) -> None:
+    modbus.final_validate_modbus_device("kuntze", role="client")(config)


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -84,7 +84,7 @@ CONFIG_SCHEMA = cv.Schema(
 )


-def final_validate(config: ConfigType) -> ConfigType:
+def final_validate(config: ConfigType) -> None:
    full_config = fv.full_config.get()
    hub_id = config[CONF_LD6002B_ID]

@@ -108,8 +108,6 @@ def final_validate(config: ConfigType) -> ConfigType:
                path=[CONF_WAKE],
            )

-    return config
-

 FINAL_VALIDATE_SCHEMA = final_validate

@@ -105,9 +105,9 @@ CONFIG_SCHEMA = cv.Schema(
 )


-def final_validate(config: ConfigType) -> ConfigType:
+def final_validate(config: ConfigType) -> None:
    if config.get(CONF_AREA_CONFIG) is None:
-        return config
+        return

    full_config = fv.full_config.get()
    hub_id = config[CONF_LD6002B_ID]
@@ -132,8 +132,6 @@ def final_validate(config: ConfigType) -> ConfigType:
            path=[CONF_AREA_CONFIG],
        )

-    return config
-

 FINAL_VALIDATE_SCHEMA = final_validate

@@ -182,6 +182,9 @@ def get_download_types(storage_json: StorageJSON = None):
    the shape stable so the download panel
    doesn't have to special-case per-platform schemas.
    """
+    # No recorded firmware path means nothing was built; no downloads.
+    if storage_json.firmware_bin_path is None:
+        return []
    types = [
        {
            "title": "UF2 package (recommended)",
@@ -279,7 +279,7 @@ def _final_validate(config: ConfigType) -> None:
    """
    data = _get_data()
    if not data.effect_refs and not data.effect_cycle_refs:
-        return config
+        return

    # Drain the lists so we only validate once even though
    # FINAL_VALIDATE_SCHEMA runs for each light platform instance.
@@ -323,8 +323,6 @@ def _final_validate(config: ConfigType) -> None:
                path=[cv.ROOT_CONFIG_PATH] + ref.component_path,
            )

-    return config
-

 FINAL_VALIDATE_SCHEMA = _final_validate

@@ -444,7 +444,7 @@ LVTouchListener::LVTouchListener(uint16_t long_press_time, uint16_t long_press_r
  lv_indev_set_type(this->drv_, LV_INDEV_TYPE_POINTER);
  lv_indev_set_disp(this->drv_, parent->get_disp());
  lv_indev_set_long_press_time(this->drv_, long_press_time);
-  // long press repeat time TBD
+  lv_indev_set_long_press_repeat_time(this->drv_, long_press_repeat_time);
  lv_indev_set_user_data(this->drv_, this);
  lv_indev_set_read_cb(this->drv_, [](lv_indev_t *d, lv_indev_data_t *data) {
    auto *l = static_cast<LVTouchListener *>(lv_indev_get_user_data(d));
@@ -1,3 +1,4 @@
+from esphome.components.const import CONF_LABEL
 import esphome.config_validation as cv
 from esphome.const import CONF_TEXT

@@ -14,8 +15,6 @@ from ..schemas import TEXT_SCHEMA
 from ..types import LvText
 from . import Widget, WidgetType

-CONF_LABEL = "label"
-

 class LabelType(WidgetType):
    def __init__(self):
@@ -34,7 +34,7 @@ CONF_NONVOLATILE_WRITE_DELAY = "nonvolatile_write_delay"
 VOLATILE_CHANNELS = ("A", "B", "C", "D")


-def _validate_nonvolatile(config):
+def _validate_nonvolatile(config) -> None:
    channel = str(config[CONF_CHANNEL])

    # Channels E-H address the nonvolatile registers directly — the mirroring options only
@@ -49,7 +49,7 @@ def _validate_nonvolatile(config):
                f"enabling '{CONF_NONVOLATILE}' or setting '{CONF_NONVOLATILE_WRITE_DELAY}' is only valid for the "
                f"volatile channels A-D; channels E-H are the nonvolatile registers themselves"
            )
-        return config
+        return

    config.setdefault(CONF_NONVOLATILE, True)
    if config[CONF_NONVOLATILE]:
@@ -62,7 +62,6 @@ def _validate_nonvolatile(config):
        raise cv.Invalid(
            f"'{CONF_NONVOLATILE_WRITE_DELAY}' requires '{CONF_NONVOLATILE}: true'"
        )
-    return config


 CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
@@ -62,7 +62,7 @@ def _consume_mdns_sockets(config: ConfigType) -> ConfigType:
    return config


-def _require_network_interface(config: ConfigType) -> ConfigType:
+def _require_network_interface(config: ConfigType) -> None:
    """Require a network interface for mDNS on Arduino/LEAmDNS platforms.

    On ESP8266 and RP2040 the C++ implementation needs at least one IP state
@@ -71,7 +71,7 @@ def _require_network_interface(config: ConfigType) -> ConfigType:
    that never initializes.
    """
    if config.get(CONF_DISABLED) or not (CORE.is_esp8266 or CORE.is_rp2):
-        return config
+        return
    full_config = fv.full_config.get()
    has_wifi = "wifi" in full_config
    has_ethernet = CORE.is_rp2 and "ethernet" in full_config
@@ -81,7 +81,6 @@ def _require_network_interface(config: ConfigType) -> ConfigType:
            "mdns on this platform requires a network interface — "
            f"add a {options} component to your configuration."
        )
-    return config


 CONFIG_SCHEMA = cv.All(
@@ -175,7 +175,7 @@ def _config_schema(config):
    return config


-def _final_validate(config):
+def _final_validate(config) -> None:
    global_config = full_config.get()

    from esphome.components.lvgl import DOMAIN as LVGL_DOMAIN
@@ -183,7 +183,6 @@ def _final_validate(config):
    if not requires_buffer(config) and LVGL_DOMAIN not in global_config:
        # If no drawing methods are configured, and LVGL is not enabled, show a test card
        config[CONF_SHOW_TEST_CARD] = True
-    return config


 CONFIG_SCHEMA = _config_schema
@@ -248,7 +248,7 @@ def _config_schema(config):
 CONFIG_SCHEMA = _config_schema


-def _final_validate(config):
+def _final_validate(config) -> None:
    global_config = full_config.get()

    from esphome.components.lvgl import DOMAIN as LVGL_DOMAIN
@@ -260,7 +260,6 @@ def _final_validate(config):
        config = spi.final_validate_device_schema(
            "mipi_rgb", require_miso=False, require_mosi=True
        )(config)
-    return config


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -143,11 +143,11 @@ def CONFIG_SCHEMA(config: ConfigType) -> ConfigType:


 # Legacy climate-owned hub compatibility. Remove in 2027.2.0.
-def _legacy_final_validate(config: ConfigType) -> ConfigType:
+def _legacy_final_validate(config: ConfigType) -> None:
    if CONF_MITSUBISHI_CN105_ID in config:
-        return config
+        return

-    return uart.final_validate_device_schema(
+    uart.final_validate_device_schema(
        DOMAIN,
        require_rx=True,
        require_tx=True,
@@ -135,10 +135,8 @@ def validate_modbus_register(config):
    return config


-def _final_validate(config: ConfigType) -> ConfigType:
-    return modbus.final_validate_modbus_device("modbus_controller", role="client")(
-        config
-    )
+def _final_validate(config: ConfigType) -> None:
+    modbus.final_validate_modbus_device("modbus_controller", role="client")(config)


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -144,8 +144,8 @@ CONFIG_SCHEMA = cv.All(
 )


-def _final_validate(config: ConfigType) -> ConfigType:
-    return modbus.final_validate_modbus_device("modbus_server", role="server")(config)
+def _final_validate(config: ConfigType) -> None:
+    modbus.final_validate_modbus_device("modbus_server", role="server")(config)


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -10,7 +10,7 @@

 namespace esphome::mqtt {

-static const char *const TAG = "mqtt.idf";
+static const char *const TAG = "mqtt";

 bool MQTTBackendESP32::initialize_() {
  mqtt_cfg_.broker.address.hostname = this->host_.c_str();
@@ -13,7 +13,7 @@

 namespace esphome::nextion {

-static const char *const TAG = "nextion.upload.arduino";
+static const char *const TAG = "nextion.upload";
 static constexpr size_t NEXTION_MAX_RESPONSE_LOG_BYTES = 16;

 // Timeout for display acknowledgment during TFT upload (ms).
@@ -16,7 +16,7 @@

 namespace esphome::nextion {

-static const char *const TAG = "nextion.upload.esp32";
+static const char *const TAG = "nextion.upload";
 static constexpr size_t NEXTION_MAX_RESPONSE_LOG_BYTES = 16;

 // Timeout for display acknowledgment during TFT upload (ms).
@@ -473,6 +473,9 @@ def copy_files() -> None:

 def get_download_types(storage_json: StorageJSON) -> list[dict[str, str]]:
    """Get the download types for the firmware."""
+    # No recorded firmware path means nothing was built; no downloads.
+    if storage_json.firmware_bin_path is None:
+        return []
    types = []
    UF2_PATH = "zephyr/zephyr.uf2"
    DFU_PATH = "firmware.zip"
@@ -62,22 +62,6 @@ def get_sdk_nrf_tools_path() -> Path:
    return path.resolve()


-def _needs_venv_rebuild(
-    env_python_path: Path, sentinel: Path, requirements_hash: str
-) -> bool:
-    """True when a penv must be (re)built.
-
-    Rebuild when the interpreter is not a regular file, which covers a
-    dangling symlink (a cached venv outliving a host interpreter upgrade)
-    and a corrupt restore, or when the sentinel is missing or stale.
-    """
-    return (
-        not env_python_path.is_file()
-        or not sentinel.exists()
-        or sentinel.read_text(encoding="utf-8") != requirements_hash
-    )
-
-
 def _get_python_env_path(version: str) -> Path:
    return get_sdk_nrf_tools_path() / "penvs" / version

@@ -214,7 +198,10 @@ def setup_platformio_python_env() -> None:
        + "\n".join(_PLATFORMIO_PENV_REQUIREMENTS).encode()
        + f"python{sys.version_info.major}.{sys.version_info.minor}".encode()
    ).hexdigest()
-    if _needs_venv_rebuild(env_python_path, sentinel, requirements_hash):
+    if (
+        not sentinel.exists()
+        or sentinel.read_text(encoding="utf-8") != requirements_hash
+    ):
        rmdir(penv_path, msg="Clean up PlatformIO toolchain Python environment")

        create_venv(penv_path, msg="PlatformIO toolchain")
@@ -263,7 +250,10 @@ def check_and_install() -> None:
    env_python_path = get_python_env_executable_path(python_env_path, "python")
    sentinel = python_env_path / ".ready"
    requirements_hash = hashlib.sha256(_REQUIREMENTS.read_bytes()).hexdigest()
-    install_venv = _needs_venv_rebuild(env_python_path, sentinel, requirements_hash)
+    install_venv = (
+        not sentinel.exists()
+        or sentinel.read_text(encoding="utf-8") != requirements_hash
+    )
    if install_venv:
        rmdir(python_env_path, msg=f"Clean up {version} Python environment")

@@ -9,7 +9,7 @@

 namespace esphome::ota {

-static const char *const TAG = "ota.arduino_libretiny";
+static const char *const TAG = "ota";

 std::unique_ptr<ArduinoLibreTinyOTABackend> make_ota_backend() { return make_unique<ArduinoLibreTinyOTABackend>(); }

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
J. Nick Koston	45bde8e38d	Revert "[api] Match log format types for the clamped version fields" This reverts commit `c212a46757`.	2026-08-19 20:42:08 -05:00
J. Nick Koston	c212a46757	[api] Match log format types for the clamped version fields	2026-08-19 20:41:02 -05:00
J. Nick Koston	74948f3f1d	[api] Clamp client API version with std::numeric_limits instead of a literal	2026-08-19 20:23:24 -05:00
J. Nick Koston	d701d70659	[api] Enforce the 16383 message ID cap with a generated constant and static_assert	2026-08-19 18:11:21 -05:00
J. Nick Koston	7d03b07b18	[api] Keep the small-member group at 8 bytes by shrinking client API version fields to uint8_t	2026-08-19 17:47:35 -05:00
J. Nick Koston	a810b05c60	[api] Widen message type storage to uint16_t	2026-08-19 17:37:08 -05:00
Jesse Hills	29404a782c	Merge branch 'beta' into dev	2026-08-20 10:32:46 +12:00
J. Nick KostonandGitHub	185f12266a	[tests] Keep PlatformIO libdeps per xdist worker to stop a compile race (#18524 )	2026-08-19 17:29:10 -05:00
J. Nick KostonandGitHub	0b1065feee	[ci] Stop jobs hanging on apt by restoring the cached apt action and bounding raw apt calls (#18518 )	2026-08-20 09:30:34 +12:00
Clyde StubbsandGitHub	47da743d11	[ai] Add instructions for concise comments (#18522 )	2026-08-19 16:09:12 -05:00
Clyde Stubbs GitHub Claude Sonnet 5 Copilot Autofix powered by AI J. Nick Koston	470226ca03	[image] Restore defaults:/files: support for platform entries (#18032 ) Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com> Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> Co-authored-by: J. Nick Koston <nick@koston.org>	2026-08-19 12:30:12 -05:00
esphome[bot]andGitHub	7b7107556f	Bump bundled esphome-device-builder to 1.12.0 (#18514 )	2026-08-19 12:21:58 -05:00
J. Nick KostonandGitHub	f90b776071	[ci] Key PlatformIO cache on the Python version so a runner image bump does not serve a broken LibreTiny venv (#18512 )	2026-08-19 16:39:01 +00:00
esphome[bot]andGitHub	e26237e57d	Bump bundled esphome-device-builder to 1.11.5 (#18507 )	2026-08-19 00:42:05 -05:00
esphome[bot]andGitHub	d2c3f749ab	Bump bundled esphome-device-builder to 1.11.4 (#18506 )	2026-08-18 23:24:23 -05:00
esphome[bot]andGitHub	b7cc271219	Bump bundled esphome-device-builder to 1.11.3 (#18505 )	2026-08-18 21:57:51 -05:00
dependabot[bot]GitHubdependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	17eed7055b	Bump resvg-py from 0.3.4 to 0.4.0 (#18460 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-08-18 22:22:51 -04:00
dependabot[bot]GitHubdependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	b7121940c8	Update wheel requirement from <0.48,>=0.43 to >=0.43,<0.49 (#18459 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-08-18 22:08:23 -04:00
Jonathan SwobodaandGitHub	07fa16e2e7	[ci] Stop persisting the integration test ccache (#18504 )	2026-08-18 21:38:18 -04:00
Jonathan SwobodaandGitHub	8aa7db15e5	[esp32] Fix ESP32-P4 bootloop on rev3 (v3.x) chips when only variant is set (#18500 )	2026-08-18 21:25:09 -04:00
J. Nick KostonandGitHub	8b637b339b	[vscode] Report the origin of an unexpected exception during validation (#18494 )	2026-08-18 19:37:10 -05:00
J. Nick KostonandGitHub	4f866c563b	[platformio] Give the ccache wrapper a cmd.exe safe path (#18495 )	2026-08-18 19:36:57 -05:00
J. Nick KostonandGitHub	7a999f9a48	[ci] Install requirements_dev.txt when the venv cache misses (#18502 )	2026-08-18 19:06:55 -05:00
esphome[bot]andGitHub	0a88c81d95	Bump aioesphomeapi from 45.11.0 to 45.12.0 (#18501 )	2026-08-18 18:38:23 -05:00
J. Nick KostonandGitHub	804e8fb856	[socket] Remove constant duplicated by the beta merge (#18496 )	2026-08-18 15:44:38 -05:00
Jesse Hills	43939a9199	Merge branch 'beta' into dev	2026-08-19 08:01:33 +12:00
esphome[bot]andGitHub	5c9d050ebe	Bump aioesphomeapi from 45.10.3 to 45.11.0 (#18493 )	2026-08-18 17:02:54 +00:00
Bonne Eggleston GitHub Claude Opus 4.8	285a508e09	[modbus] CRC scan all unknown function codes (#18483 ) Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-08-18 11:09:12 -05:00
J. Nick KostonandGitHub	92f55f721f	[api] Bump noise-c to 0.1.21 (#18484 )	2026-08-18 14:32:37 +00:00
Jonathan SwobodaandGitHub	476d540065	[ci] Fall back to files API when PR diff exceeds GitHub line limit (#18486 )	2026-08-18 10:22:28 -04:00
J. Nick KostonandGitHub	ae730d6357	[ci] Fail the benchmark job when the C++ benchmark build fails (#18480 )	2026-08-18 09:03:33 -05:00
J. Nick KostonandGitHub	9823205ef3	[api] Bump noise-c to 0.1.20 (#18482 )	2026-08-18 09:03:14 -05:00
J. Nick KostonandGitHub	fffa902a1a	[gpio_expander][pcf8574][pca9554][tca9555][pca6416a][pi4ioe5v6408][mcp23016][mcp23xxx_base] Reject unsupported interrupt_pin options (inverted, allow_other_uses) (#18472 )	2026-08-18 13:32:03 +12:00
Jesse HillsandGitHub	463e3833da	[light] Replace rgb_order/is_rgbw/is_wrgb with channel_colors (#18474 )	2026-08-18 13:19:48 +12:00
J. Nick KostonandGitHub	4416aacebb	[socket] Fix multi-second TCP stalls on ESP8266 by yielding to the SYS context (#18455 )	2026-08-18 13:09:29 +12:00
esphome[bot]andGitHub	15a626bcf3	Bump bundled esphome-device-builder to 1.11.2 (#18477 )	2026-08-17 19:16:38 -05:00
J. Nick KostonandGitHub	a347a2e879	[api] Bump noise-c to 0.1.19 (#18473 )	2026-08-17 18:58:11 -05:00
dependabot[bot]andGitHub	7be4566b41	Bump platformdirs from 4.11.2 to 4.11.3 (#18468 ) Signed-off-by: dependabot[bot] <support@github.com>	2026-08-17 18:33:13 -05:00
esphome[bot]andGitHub	96e26c6a5f	Bump bundled esphome-device-builder to 1.11.1 (#18475 )	2026-08-17 17:54:23 -05:00
J. Nick KostonandGitHub	7362c01c67	[core] Replace base64 lookup tables with arithmetic mapping (#18454 )	2026-08-17 16:14:06 -05:00
Jesse HillsandGitHub	e45b4e4938	[core] Make FINAL_VALIDATE_SCHEMA functions return None (#18457 )	2026-08-18 08:26:24 +12:00
J. Nick KostonandGitHub	e32329cc11	[core] Sync pre-commit ruff hook with requirements (0.16.3) (#18469 )	2026-08-17 15:00:37 -05:00
dependabot[bot]andGitHub	199e368fe2	Bump astral-sh/setup-uv from 9.0.0 to 10.0.1 (#18463 ) Signed-off-by: dependabot[bot] <support@github.com>	2026-08-17 14:57:50 -05:00
dependabot[bot]andGitHub	55726120db	Bump esphome/workflows/.github/workflows/lock.yml from 2026.7.0 to 2026.8.1 (#18465 ) Signed-off-by: dependabot[bot] <support@github.com>	2026-08-17 14:47:28 -05:00
dependabot[bot]andGitHub	346ba7e831	Bump github/codeql-action/analyze from 4.37.6 to 4.37.7 (#18467 ) Signed-off-by: dependabot[bot] <support@github.com>	2026-08-17 14:47:18 -05:00
dependabot[bot]andGitHub	9518006724	Bump ruff from 0.16.2 to 0.16.3 (#18458 ) Signed-off-by: dependabot[bot] <support@github.com>	2026-08-17 14:46:04 -05:00
dependabot[bot]andGitHub	3d5f6f692f	Bump filelock from 3.32.2 to 3.32.3 (#18461 ) Signed-off-by: dependabot[bot] <support@github.com>	2026-08-17 14:45:41 -05:00
dependabot[bot]andGitHub	4712c15c75	Bump github/codeql-action/init from 4.37.6 to 4.37.7 (#18466 ) Signed-off-by: dependabot[bot] <support@github.com>	2026-08-17 14:42:24 -05:00
dependabot[bot]andGitHub	9bc72529a6	Bump astral-sh/setup-uv from 9.0.0 to 10.0.1 in /.github/actions/restore-python (#18462 ) Signed-off-by: dependabot[bot] <support@github.com>	2026-08-17 14:42:08 -05:00
dependabot[bot]GitHubdependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	6d20943a9c	Bump esphome/workflows/.github/workflows/stale.yml from 61fd37a044cad4e9aa4303027b2a61b6a34da855 to a1c1485ab46ef41a84a6a9d8abd7fa4b7628fd70 (#18464 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2026-08-17 15:38:06 -04:00
J. Nick KostonandGitHub	a3af82867b	[api] Bump noise-c to 0.1.18 (#18451 )	2026-08-17 14:00:39 -05:00
J. Nick KostonandGitHub	27483a4101	[core] Retry gh CLI calls on transient network errors in CI scripts (#18292 )	2026-08-17 13:15:31 -05:00
J. Nick KostonandGitHub	6d20ebc66b	[socket] Shorten lwip TAG string (#18450 )	2026-08-17 17:18:43 +00:00
J. Nick KostonandGitHub	031a038b49	[deep_sleep] Shorten bk72xx TAG string (#18445 )	2026-08-17 11:56:37 -05:00
J. Nick KostonandGitHub	f6c7434b2a	[i2c] Shorten platform backend TAG strings (#18440 )	2026-08-17 11:54:55 -05:00
J. Nick KostonandGitHub	3d9fecb562	[remote_receiver] Shorten esp32 TAG string (#18447 )	2026-08-17 11:54:52 -05:00
J. Nick KostonandGitHub	ebe93e2c68	[bluetooth_connection] Shorten platform TAG strings (#18449 )	2026-08-17 11:54:35 -05:00
J. Nick KostonandGitHub	1f4fcead38	[nextion] Shorten upload TAG strings (#18448 )	2026-08-17 11:54:29 -05:00
J. Nick KostonandGitHub	1f000ba668	[mqtt] Shorten esp32 backend TAG string (#18446 )	2026-08-17 11:54:17 -05:00
J. Nick KostonandGitHub	e0d28d7f5c	[http_request] Shorten platform backend TAG strings (#18444 )	2026-08-17 11:54:03 -05:00
J. Nick KostonandGitHub	47a58dd799	[internal_temperature] Shorten platform TAG strings (#18443 )	2026-08-17 11:53:56 -05:00
J. Nick KostonandGitHub	37bea1c153	[spi] Shorten platform backend TAG strings (#18442 )	2026-08-17 11:53:48 -05:00
J. Nick KostonandGitHub	d1a7b8df8b	[adc] Shorten platform TAG strings (#18441 )	2026-08-17 11:53:42 -05:00
J. Nick KostonandGitHub	c01f24553c	[uart] Shorten platform backend TAG strings (#18439 )	2026-08-17 11:53:29 -05:00
J. Nick KostonandGitHub	07e8b303b9	[ota] Shorten platform backend TAG strings (#18438 )	2026-08-17 11:52:56 -05:00
esphome[bot]GitHubesphome[bot] <115708604+esphome[bot]@users.noreply.github.com>	ebb0923362	Bump aioesphomeapi from 45.10.2 to 45.10.3 (#18433 ) Co-authored-by: esphome[bot] <115708604+esphome[bot]@users.noreply.github.com>	2026-08-16 22:34:00 -05:00
J. Nick KostonandGitHub	e1c279718f	[ld2420] Drop the setup priority override so setup runs after the UART bus (#18428 )	2026-08-16 21:57:12 -05:00
J. Nick KostonandGitHub	cf764740cf	[api] Create the camera image reader lazily (#18421 )	2026-08-16 21:56:58 -05:00
J. Nick KostonandGitHub	58d549ed4c	[api] Move NoiseProtocolId off the connection object (#18420 )	2026-08-16 21:56:37 -05:00
Jesse Hills	6b22d8068d	Merge branch 'beta' into dev	2026-08-17 11:36:10 +12:00
J. Nick KostonandGitHub	3f01f9895f	[esp32_hosted] Require ESP-IDF 5.3 or newer (#18417 )	2026-08-16 12:44:49 -07:00
J. Nick KostonandGitHub	801a1817b5	[esp32] Split crash handler addr2line hint per core (#18418 )	2026-08-16 12:44:00 -07:00
J. Nick KostonandGitHub	32c76ae828	[core] Skip redundant ESP8266 main loop wake posts from ISR context (#18416 )	2026-08-16 12:43:27 -07:00
J. Nick KostonandGitHub	c664f5fc95	[bk72xx_ble] Fail early with a clear error on non BLE 5.x SoCs (#18406 )	2026-08-16 11:06:22 -07:00
luar123andGitHub	2bc4681fd6	[zigbee] bump esp-zigbee-sdk to 2.0.4 (#18415 )	2026-08-16 13:33:25 -04:00
Jonathan SwobodaandGitHub	646501b0ef	[sensor] Pass NaN through the delta filter again (#18400 )	2026-08-16 12:36:51 -04:00
J. Nick KostonandGitHub	de3e657d8b	[platformio] Skip ccache when the binary on PATH fails to run (#18407 )	2026-08-16 08:42:47 -07:00
esphome[bot]andGitHub	1add726892	Bump bundled esphome-device-builder to 1.11.0 (#18403 )	2026-08-15 13:36:52 -07:00
Samuel SiebandGitHub	5a000cf5e4	[rotary_encoder] account for min and max value when resetting (#18197 )	2026-08-15 11:16:04 -07:00
Joppy FurrandGitHub	6ed676fe32	[lvgl] Restore long_press_repeat_time functionality (#18393 )	2026-08-14 23:14:53 -07:00
esphome[bot]andGitHub	7cceddb8a3	Bump bundled esphome-device-builder to 1.10.0 (#18389 )	2026-08-15 01:48:27 +00:00
J. Nick KostonandGitHub	039b897e7b	[ethernet] Defer clk_mode removal to 2026.11.0 (#18380 )	2026-08-14 18:45:36 -07:00
J. Nick KostonandGitHub	b178f74e5d	[core] Save the validated config cache on the first upload or logs run (#18367 )	2026-08-14 18:45:23 -07:00
Clyde StubbsandGitHub	e5224e22ae	[ci] Compare merge-branch base ref against the default branch (#18385 )	2026-08-15 06:18:22 +10:00
Clyde StubbsandGitHub	be66e8b99c	[ci] Disable CodSpeed benchmarks job outside esphome/esphome (#18372 )	2026-08-15 04:33:47 +10:00
Jesse Hills	4b91c8aff4	Merge branch 'beta' into dev	2026-08-14 23:15:57 +12:00
Karl BeeckenandGitHub	617e2ec1e0	[core] fix PYTHONPATH leak (#18360 )	2026-08-14 17:23:34 +12:00
J. Nick KostonandGitHub	1afac0312d	[core] Restore cv.parse_esphome_version as a deprecated helper (#18366 )	2026-08-14 17:22:22 +12:00
J. Nick KostonandGitHub	b05465145f	[core] Add preference key stability integration test (#18364 )	2026-08-13 21:14:30 -05:00
dependabot[bot]andGitHub	990fc402fd	Bump bleak from 2.1.1 to 3.0.2 (#16246 ) Signed-off-by: dependabot[bot] <support@github.com>	2026-08-13 20:24:02 -05:00
J. Nick KostonandGitHub	dd51624fbb	[core] Partially revert "Hash entity keys from the raw name to fix collisions" (#18361 )	2026-08-13 20:06:48 -05:00
dependabot[bot]andGitHub	45a056e337	Bump platformdirs from 4.11.1 to 4.11.2 (#18363 ) Signed-off-by: dependabot[bot] <support@github.com>	2026-08-13 18:54:51 -05:00
dependabot[bot]andGitHub	37782f7206	Bump prek from 0.4.12 to 0.4.13 (#18362 ) Signed-off-by: dependabot[bot] <support@github.com>	2026-08-13 18:54:37 -05:00
J. Nick KostonandGitHub	945c2458b3	[core] Load component aliases from a generated registry (#18335 )	2026-08-13 13:31:19 -05:00
J. Nick KostonandGitHub	7420d23867	[ota] Retry uploads that fail from network errors (#18332 )	2026-08-13 13:31:06 -05:00
J. Nick KostonandGitHub	191686c5b3	[wifi] Fix ESP8266 crash in cnx_node_search when lwIP transmits after disconnect (#18333 )	2026-08-13 13:30:53 -05:00
J. Nick KostonandGitHub	137351fa8d	[esp32_ble] Silence spurious warnings for local key GAP events (#18359 )	2026-08-13 13:27:01 -05:00
J. Nick KostonandGitHub	db5173697a	[esp32_ble_tracker] Fix missed BLE advertisements with WiFi on ESP-IDF 5.5.5 (#18356 )	2026-08-13 13:22:48 -05:00
Oliver Kleinecke GitHub Oliver Kleineckepre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>	c7940382a9	[const] move CONF_LABEL to components/const (#18354 ) Co-authored-by: Oliver Kleinecke <kleinecke.oliver@googlemail.com> Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>	2026-08-13 14:18:22 -04:00
esphome[bot]andGitHub	87045ab9c0	Bump aioesphomeapi from 45.10.1 to 45.10.2 (#18357 )	2026-08-13 11:14:14 -05:00
Oliver Kleinecke GitHub Oliver Kleinecke	f1c4086778	[const] Move CONF_SLOT to components/const (#18350 ) Co-authored-by: Oliver Kleinecke <p1ngb4ck@users.noreply.github.com>	2026-08-13 23:36:11 +12:00
dependabot[bot]GitHubdependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>Jonathan Swoboda	f337d0acff	Bump pylint from 4.0.6 to 4.0.7 (#18320 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>	2026-08-13 02:13:29 +00:00
J. Nick KostonandGitHub	9cc05b30d4	[web_server_base] Stop deleting the web server on captive portal teardown (#18324 )	2026-08-12 21:09:01 -05:00
Jesse Hills	e0b68c4d6d	Merge branch 'beta' into dev	2026-08-13 14:06:46 +12:00
J. Nick KostonandGitHub	8e624b4117	[core] Retry framework downloads on transient network errors (#18330 )	2026-08-13 12:14:50 +12:00
J. Nick KostonandGitHub	787a909aa4	[core] Don't block logs startup on MQTT IP discovery when addresses are known (#18313 )	2026-08-13 12:11:32 +12:00
J. Nick KostonandGitHub	905485b673	[ld2420] Fix out-of-bounds read when device reports unknown command error (#18322 )	2026-08-13 11:49:34 +12:00
esphome[bot]andGitHub	99677390e0	Bump bundled esphome-device-builder to 1.9.6 (#18328 )	2026-08-12 16:27:14 -05:00
Kevin AhrendtandGitHub	f2121130f9	[sendspin] Bump sendspin-cpp to v0.7.2 (#18316 )	2026-08-12 12:49:54 -04:00
esphome[bot]andGitHub	1a01c34ec4	Bump aioesphomeapi from 45.10.0 to 45.10.1 (#18318 )	2026-08-12 16:33:45 +00:00
J. Nick KostonandGitHub	3c46cc9c35	[usb_uart] Fix uint32_t format specifier warning in pl2303 (#18310 )	2026-08-12 10:59:24 -04:00
Jesse Hills	e192ec8fee	Merge branch 'beta' into dev	2026-08-13 00:29:08 +12:00
Jesse Hills	8a1aa5753d	Bump version to 2026.9.0-dev	2026-08-12 22:53:42 +12:00