Merge pull request #19051 from esphome/bump-2026.9.0b3

2026.9.0b3

.github/workflows/ci.yml

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

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

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

.pre-commit-config.yaml

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

AGENTS.md

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

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2026.10.0-dev
+PROJECT_NUMBER         = 2026.9.0b3
 
 # 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

esphome/api_client.py

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

esphome/build_gen/arduino8266.py

@@ -1,773 +0,0 @@
-"""Build specification for the native ESP8266 Arduino toolchain.
-
-Transliterates the PlatformIO build spec for the Arduino ESP8266 framework
-(``framework-arduinoespressif8266/tools/platformio-build.py`` plus
-``platform-espressif8266/builder/main.py``): the flag sets, defines, and
-linker-script generation deliberately match what PlatformIO produces so the
-binaries stay near-identical between the two toolchains. The ninja emission
-(``write_project``) builds on these pieces.
-
-The ``PIO_FRAMEWORK_ARDUINO_*`` knob defines (lwIP variant, NONOS SDK
-version, MMU layout, exceptions, waveform phase) keep working: they are read
-from the build flags with the same precedence as the PlatformIO builder.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import hashlib
-import logging
-import os
-from pathlib import Path
-import re
-import shlex
-import subprocess
-from typing import TYPE_CHECKING, NamedTuple
-
-from esphome.arduino8266.framework import toolchain_tool
-from esphome.build_helpers.ninja import shell_token as _shell_token
-from esphome.components.esp8266 import build_surgery
-from esphome.core import CORE, EsphomeError
-from esphome.helpers import mkdir_p, write_file_if_changed
-from esphome.platformio.library import lex_build_flags
-
-if TYPE_CHECKING:
-    from esphome.arduino8266.framework import InstalledPaths
-
-_LOGGER = logging.getLogger(__name__)
-
-# Values that land unquoted on generated command lines are shape-checked
-# against these before use. re.ASCII: a Unicode digit or word character
-# (Arabic-Indic numerals) would pass \d/\w and defeat the named error
-_MMU_VALUE_RE = re.compile(r"(?:0[xX][0-9a-fA-F]+|\d+)[uUlL]*", re.ASCII)
-_MMU_HEX_VALUE_RE = re.compile(r"0[xX][0-9a-fA-F]+[uUlL]*", re.ASCII)
-# Only these land in the preprocessed script's ``len =`` fields, which
-# build_surgery's segment parser reads back as hex; the other MMU_* macros
-# (MMU_EXTERNAL_HEAP=128) are consumed by mmu_iram.h and may be decimal
-_MMU_SEGMENT_SIZE_NAMES = ("MMU_IRAM_SIZE", "MMU_ICACHE_SIZE")
-_BOARD_NAME_RE = re.compile(r"[\w.-]+", re.ASCII)
-_F_CPU_RE = re.compile(r"\d+L?", re.ASCII)
-_FLASH_LD_NAME_RE = re.compile(r"[\w.-]+\.ld", re.ASCII)
-
-# Every supported board ships this clock; board_build.f_cpu overrides
-_DEFAULT_F_CPU = "80000000L"
-
-# The SDK linker-script template and the preprocessed copy the build links
-# against; the cache stamp and stderr sidecars derive from the output name
-_COMMON_LD_HEADER = "eagle.app.v6.common.ld.h"
-_COMMON_LD_NAME = "local.eagle.app.v6.common.ld"
-# Testing mode shadows the SDK flash ld with a patched copy under this name
-_TESTING_LD_PREFIX = "testing_"
-
-# The recovery hint for a half-extracted or damaged framework cache
-_CLEAN_HINT = "run 'esphome clean-all' and retry"
-
-
-def _sdk_ld_dir(framework: Path) -> Path:
-    return framework / "tools" / "sdk" / "ld"
-
-
-def _apply_surgery(fn, *args: object) -> str:
-    """Run one build_surgery edit, naming a failed anchor instead of a
-    traceback (the surgery module raises bare RuntimeError so its
-    ``.py.script`` twins stay importable without esphome)."""
-    try:
-        return fn(*args)
-    except RuntimeError as err:
-        raise EsphomeError(str(err)) from err
-
-
-# From platformio-build.py. Knob suffix -> SDK define; the first entry is
-# the default (dicts preserve insertion order). With multiple SDK knobs set
-# (a pathological config) ties break by table order, since upstream's
-# tie-break depends on define order and is not reproducible here.
-_NONOSDK_VERSIONS = {
-    "SDK22x_190703": "NONOSDK22x_190703",
-    "SDK221": "NONOSDK221",
-    "SDK22x_190313": "NONOSDK22x_190313",
-    "SDK22x_191024": "NONOSDK22x_191024",
-    "SDK22x_191105": "NONOSDK22x_191105",
-    "SDK22x_191122": "NONOSDK22x_191122",
-    "SDK305": "NONOSDK305",
-}
-
-
-class _LwipVariant(NamedTuple):
-    """One lwIP build variant: the defines and the prebuilt library that
-    was compiled with them."""
-
-    tcp_mss: int
-    features: int
-    ipv6: int
-    lib: str
-
-
-# Knob define -> variant; first match wins, in insertion order (as in
-# platformio-build.py)
-_LWIP_VARIANTS = {
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_IPV6_LOW_MEMORY": _LwipVariant(
-        536, 1, 1, "lwip6-536-feat"
-    ),
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_IPV6_HIGHER_BANDWIDTH": _LwipVariant(
-        1460, 1, 1, "lwip6-1460-feat"
-    ),
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH": _LwipVariant(
-        1460, 1, 0, "lwip2-1460-feat"
-    ),
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_LOW_MEMORY_LOW_FLASH": _LwipVariant(
-        536, 0, 0, "lwip2-536"
-    ),
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH_LOW_FLASH": _LwipVariant(
-        1460, 0, 0, "lwip2-1460"
-    ),
-}
-# The default is PIO_FRAMEWORK_ARDUINO_LWIP2_LOW_MEMORY's variant: upstream
-# has no branch for that spelling (it is the else), so any listed knob wins
-# over it -- sntp emits LOW_MEMORY while esp8266 always emits
-# HIGHER_BANDWIDTH_LOW_FLASH, and the latter must win as under PlatformIO
-_LWIP_DEFAULT = _LwipVariant(536, 1, 0, "lwip2-536-feat")
-
-# Knob define -> MMU_* defines; first match wins, in insertion order (as
-# in platformio-build.py)
-_MMU_VARIANTS = {
-    "PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM48": (
-        "MMU_IRAM_SIZE=0xC000",
-        "MMU_ICACHE_SIZE=0x4000",
-    ),
-    "PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM48_SECHEAP_SHARED": (
-        "MMU_IRAM_SIZE=0xC000",
-        "MMU_ICACHE_SIZE=0x4000",
-        "MMU_IRAM_HEAP",
-    ),
-    "PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM32_SECHEAP_NOTSHARED": (
-        "MMU_IRAM_SIZE=0x8000",
-        "MMU_ICACHE_SIZE=0x4000",
-        "MMU_SEC_HEAP_SIZE=0x4000",
-        "MMU_SEC_HEAP=0x40108000",
-    ),
-    "PIO_FRAMEWORK_ARDUINO_MMU_EXTERNAL_128K": (
-        "MMU_IRAM_SIZE=0x8000",
-        "MMU_ICACHE_SIZE=0x8000",
-        "MMU_EXTERNAL_HEAP=128",
-    ),
-    # Upstream really does cap the 1024K option's heap knob at 256
-    # (platformio-build.py's MMU_EXTERNAL_1024K branch); transliterated
-    # verbatim
-    "PIO_FRAMEWORK_ARDUINO_MMU_EXTERNAL_1024K": (
-        "MMU_IRAM_SIZE=0x8000",
-        "MMU_ICACHE_SIZE=0x8000",
-        "MMU_EXTERNAL_HEAP=256",
-    ),
-}
-# From platformio-build.py: the invariant framework defines every TU gets
-# (ARDUINO=10805 encodes the IDE compatibility level); the board, flash-mode,
-# knob, and MMU defines are composed around them in _defines_flags, in
-# upstream's order.
-_FRAMEWORK_DEFINES = ("__ets__", "ICACHE_FLASH", "_GNU_SOURCE", "ARDUINO=10805")
-_ARCH_DEFINES = ("ESP8266", "ARDUINO_ARCH_ESP8266")
-
-# Upstream reads these from the board manifest (build.mmu_iram_size etc.);
-# no supported board sets them, so the platformio-build.py defaults are
-# hardcoded here rather than drift
-_MMU_DEFAULT = ("MMU_IRAM_SIZE=0x8000", "MMU_ICACHE_SIZE=0x8000")
-
-# Upstream's CXXFLAGS (-fno-rtti, the -std level, -f(no-)exceptions) and the
-# trailing stdc++/m/c/gcc system libs are composed at emission
-# (write_project) from CORE.cpp_standard and _BuildConfig.exceptions.
-_ASFLAGS = ["-mlongcalls", "-mtext-section-literals"]
-_CFLAGS = [
-    "-std=gnu17",
-    "-Wpointer-arith",
-    "-Wno-implicit-function-declaration",
-    "-Wl,-EL",
-    "-fno-inline-functions",
-    "-nostdlib",
-]
-_CCFLAGS = [
-    "-Os",
-    "-mlongcalls",
-    "-mtext-section-literals",
-    "-falign-functions=4",
-    "-U__STRICT_ANSI__",
-    "-ffunction-sections",
-    "-fdata-sections",
-    "-Wall",
-    "-Werror=return-type",
-    "-free",
-    "-fipa-pta",
-]
-# Upstream's -u _scanf_float is deliberately absent: it is re-added from
-# KEY_SCANF_FLOAT at emission (the remove_float_scanf extra script's job).
-_LINKFLAGS = [
-    "-Os",
-    "-nostdlib",
-    "-Wl,--no-check-sections",
-    "-Wl,-static",
-    "-Wl,--gc-sections",
-    "-Wl,-wrap,system_restart_local",
-    "-Wl,-wrap,spi_flash_read",
-    "-u",
-    "app_entry",
-    "-u",
-    "_printf_float",
-    "-u",
-    "_DebugExceptionVector",
-    "-u",
-    "_DoubleExceptionVector",
-    "-u",
-    "_KernelExceptionVector",
-    "-u",
-    "_NMIExceptionVector",
-    "-u",
-    "_UserExceptionVector",
-]
-_SYSTEM_LIBS_PRE_LWIP = ["hal", "phy", "pp", "net80211"]
-_SYSTEM_LIBS_POST_LWIP = [
-    "wpa",
-    "crypto",
-    "main",
-    "wps",
-    "bearssl",
-    "espnow",
-    "smartconfig",
-    "airkiss",
-    "wpa2",
-]
-
-
-@dataclass
-class _BuildConfig:
-    """Knob-derived build configuration (PIO_FRAMEWORK_ARDUINO_* defines)."""
-
-    nonosdk: str
-    lwip_lib: str
-    exceptions: bool
-    vtables: str
-    fp_in_irom: bool
-    knob_defines: list[str]
-    mmu_defines: list[str]
-
-
-def _lexed_build_flags() -> list[str]:
-    """Shell-lex ``CORE.build_flags`` as PlatformIO's ``ParseFlags`` does,
-    sorted so duplicate defines resolve deterministically.
-
-    Lex once per build; consumers share the tokens.
-    """
-    # The funnel warns and drops empty glued arguments (-D "") itself
-    return lex_build_flags(sorted(CORE.build_flags), "esphome")
-
-
-def _flag_defines(unflags: set[str], tokens: list[str]) -> dict[str, str]:
-    """Map define name -> full ``NAME[=VALUE]`` for every -D build flag.
-
-    ``tokens`` comes from one ``_lexed_build_flags()`` call shared with
-    ``_project_flags``, which already warned about and dropped any bare "-D".
-    """
-    defines: dict[str, str] = {}
-    for tok in tokens:
-        # An unflagged knob must not drive lwIP/SDK/MMU selection while
-        # being absent from the compile line
-        if tok in unflags:
-            continue
-        if tok.startswith("-D"):
-            body = tok[2:]
-            defines[body.split("=", 1)[0]] = body
-    return defines
-
-
-def _resolve_build_config(defines: dict[str, str]) -> _BuildConfig:
-    nonosdk = next(
-        (
-            define
-            for name, define in _NONOSDK_VERSIONS.items()
-            if f"PIO_FRAMEWORK_ARDUINO_ESPRESSIF_{name}" in defines
-        ),
-        next(iter(_NONOSDK_VERSIONS.values())),
-    )
-    # Same compile-line/linked-artifact split as the lwIP knobs below: a
-    # raw NONOSDK* would define a second SDK macro while the link still
-    # resolves against the knob's libraries
-    if raw_sdk := sorted(n for n in defines if n.startswith("NONOSDK")):
-        raise EsphomeError(
-            f"{', '.join(raw_sdk)} are set by the "
-            "PIO_FRAMEWORK_ARDUINO_ESPRESSIF_SDK* knobs; drop the raw "
-            "build flags"
-        )
-
-    lwip = next(
-        (variant for knob, variant in _LWIP_VARIANTS.items() if knob in defines),
-        _LWIP_DEFAULT,
-    )
-
-    # The lwIP triple selects a prebuilt library; a raw override would win
-    # the compile line (user tokens come last here) while the link still
-    # pulls the library built for the knob's values
-    if owned := sorted(
-        n for n in ("TCP_MSS", "LWIP_FEATURES", "LWIP_IPV6") if n in defines
-    ):
-        raise EsphomeError(
-            f"{', '.join(owned)} are set by the PIO_FRAMEWORK_ARDUINO_LWIP2_* "
-            "knobs; drop the raw build flags"
-        )
-    knob_defines = [
-        f"{nonosdk}=1",
-        f"TCP_MSS={lwip.tcp_mss}",
-        f"LWIP_FEATURES={lwip.features}",
-        f"LWIP_IPV6={lwip.ipv6}",
-    ]
-    if "PIO_FRAMEWORK_ARDUINO_WAVEFORM_LOCKED_PHASE" in defines:
-        knob_defines.append("WAVEFORM_LOCKED_PHASE=1")
-
-    # Sorted so the pick is deterministic: the dict is built from a set of
-    # build flags, whose iteration order varies between processes.
-    vtables_knobs = sorted(name for name in defines if name.startswith("VTABLES_IN_"))
-    known_vtables = {"VTABLES_IN_FLASH", "VTABLES_IN_DRAM", "VTABLES_IN_IRAM"}
-    # A typo'd or conflicting knob would otherwise fail obscurely in the
-    # SDK header's #error
-    if unknown := [k for k in vtables_knobs if k not in known_vtables]:
-        raise EsphomeError(f"Unknown VTABLES_IN_* define(s): {', '.join(unknown)}")
-    # A body (e.g. VTABLES_IN_FLASH=0) would split the compile line from the
-    # linker script, which always defines the bare name
-    if valued := [defines[k] for k in vtables_knobs if defines[k] not in (k, f"{k}=1")]:
-        raise EsphomeError(f"VTABLES_IN_* defines take no value: {', '.join(valued)}")
-    if len(vtables_knobs) > 1:
-        raise EsphomeError(
-            f"Conflicting VTABLES_IN_* defines: {', '.join(vtables_knobs)}"
-        )
-    vtables = vtables_knobs[0] if vtables_knobs else "VTABLES_IN_FLASH"
-
-    mmu_knob = next((knob for knob in _MMU_VARIANTS if knob in defines), None)
-    if mmu_knob is not None:
-        if raw := sorted(n for n in defines if n.startswith("MMU_")):
-            # Same compile-line/linker-script split as the no-knob case below
-            fix = (
-                f"drop {mmu_knob} to use the custom sizes"
-                if "PIO_FRAMEWORK_ARDUINO_MMU_CUSTOM" in defines
-                else "drop the raw MMU_* build flags or use "
-                "PIO_FRAMEWORK_ARDUINO_MMU_CUSTOM"
-            )
-            raise EsphomeError(f"{', '.join(raw)} conflict with {mmu_knob}; {fix}")
-        mmu = list(_MMU_VARIANTS[mmu_knob])
-    elif "PIO_FRAMEWORK_ARDUINO_MMU_CUSTOM" in defines:
-        if "MMU_IRAM_SIZE" not in defines or "MMU_ICACHE_SIZE" not in defines:
-            raise EsphomeError(
-                "PIO_FRAMEWORK_ARDUINO_MMU_CUSTOM requires MMU_IRAM_SIZE and "
-                "MMU_ICACHE_SIZE build flags"
-            )
-        for name in _MMU_SEGMENT_SIZE_NAMES:
-            # A bare -Dname would preprocess to len = 1 and fail far away
-            if "=" not in defines[name]:
-                raise EsphomeError(
-                    f"{name} must be a hex literal (e.g. 0x8000), got (no value)"
-                )
-        for name, body in defines.items():
-            if not name.startswith("MMU_") or "=" not in body:
-                # Valueless flags (MMU_IRAM_HEAP) are legitimate switches
-                continue
-            # Every valued MMU_* reaches the linker-script preprocessor; a
-            # bare or non-numeric value would corrupt it and fail far away
-            # in ld. The two segment sizes must additionally be hex:
-            # build_surgery's segment parser cannot read decimal back.
-            value = body.partition("=")[2]
-            rule = (
-                _MMU_HEX_VALUE_RE if name in _MMU_SEGMENT_SIZE_NAMES else _MMU_VALUE_RE
-            )
-            if not rule.fullmatch(value):
-                shape = (
-                    "a hex literal (e.g. 0x8000)"
-                    if name in _MMU_SEGMENT_SIZE_NAMES
-                    else "a numeric literal"
-                )
-                raise EsphomeError(
-                    f"{name} must be {shape}, got {value or '(no value)'}"
-                )
-        # Sorted so build.ninja and the linker-script stamp stay
-        # byte-stable across runs (the flag set has no deterministic
-        # iteration order).
-        mmu = sorted(body for name, body in defines.items() if name.startswith("MMU_"))
-    else:
-        if raw := sorted(n for n in defines if n.startswith("MMU_")):
-            # Unlike PlatformIO (whose defaults win the compile line), user
-            # MMU_* here would win the compile but not the linker script;
-            # refuse them all, like the knob branch above.
-            raise EsphomeError(
-                f"Raw {', '.join(raw)} build flags require "
-                "-DPIO_FRAMEWORK_ARDUINO_MMU_CUSTOM"
-            )
-        mmu = list(_MMU_DEFAULT)
-
-    return _BuildConfig(
-        nonosdk=nonosdk,
-        lwip_lib=lwip.lib,
-        exceptions="PIO_FRAMEWORK_ARDUINO_ENABLE_EXCEPTIONS" in defines,
-        vtables=vtables,
-        fp_in_irom="FP_IN_IROM" in defines,
-        knob_defines=knob_defines,
-        mmu_defines=mmu,
-    )
-
-
-def _pio_option(key: str, default: str) -> str:
-    """A platformio_options value the native build honors (str-normalized).
-
-    core/config.py routes these into ``CORE.platformio_options`` under the
-    arduino toolchain and already collapses a repeated option to its last
-    value (like a later platformio.ini line), so a scalar always arrives.
-    """
-    value = CORE.platformio_options.get(key)
-    if value is None:
-        return default
-    value = str(value).strip()
-    if not value:
-        raise EsphomeError(f"platformio_options {key} is empty")
-    return value
-
-
-def _defines_flags(
-    config: _BuildConfig, flash_mode: str, board: str, board_defines: tuple[str, ...]
-) -> list[str]:
-    r"""The framework/board -D tokens for the compile line.
-
-    The returned tokens already carry shell-level escaping (the board
-    defines embed ``\"``), so they must be emitted unquoted; wrapping
-    them in ``_shell_token`` would deliver literal backslashes to gcc.
-    ``flash_mode`` also lands unquoted: callers pass it pre-validated
-    against ``BUILD_FLASH_MODES`` (cv.one_of at config time, the
-    ``_FLASH_MODES`` check at the emission half's read site).
-    """
-    if not _BOARD_NAME_RE.fullmatch(board):
-        # The name lands unquoted in two -D bodies; reject it by name
-        # instead of corrupting the compile line
-        raise EsphomeError(f"Invalid board name {board!r}")
-    # Every supported board ships 80 MHz; board_build.f_cpu overrides
-    f_cpu = _pio_option("board_build.f_cpu", _DEFAULT_F_CPU)
-    if not _F_CPU_RE.fullmatch(f_cpu):
-        # The value lands unquoted on the compile line; reject by name
-        # instead of corrupting it
-        raise EsphomeError(f"Invalid board_build.f_cpu value {f_cpu!r}")
-    return [
-        f"-D{d}"
-        for d in (
-            f"F_CPU={f_cpu}",
-            *_FRAMEWORK_DEFINES,
-            f'ARDUINO_BOARD=\\"PLATFORMIO_{board.upper()}\\"',
-            f'ARDUINO_BOARD_ID=\\"{board}\\"',
-            f"FLASHMODE_{flash_mode.upper()}",
-            "LWIP_OPEN_SRC",
-            *config.knob_defines,
-            config.vtables,
-            # User-supplied bodies re-quote like every other user token
-            # (a no-op for real MMU values)
-            *(_shell_token(d) for d in config.mmu_defines),
-            *_ARCH_DEFINES,
-            *board_defines,
-        )
-    ]
-
-
-def _unflag_tokens() -> set[str]:
-    """``build_unflags`` entries shell-lexed to tokens, as PlatformIO matches."""
-    # Lexed like _lexed_build_flags reads build_flags, so "-D FOO" removes
-    # -DFOO in both spellings (PlatformIO's ProcessUnFlags parses the same
-    # way) and no bare half can collaterally drop an unrelated token
-    return set(lex_build_flags(list(CORE.build_unflags), "esphome build_unflags"))
-
-
-def _project_flags(
-    unflags: set[str], tokens: list[str]
-) -> tuple[list[str], list[str], list[Path], list[str]]:
-    """Split the ESPHome build flags into compile, linker, -L, and -l lists.
-
-    Plain-form linker flags (``_PLAIN_LINKER_FLAGS``/``_PLAIN_LINKER_PREFIXES``)
-    raise: they would be inert on the ``-c`` compile line.
-    ``compile_flags``/``link_flags`` come back shell-quoted;
-    ``lib_dirs``/``libs`` are raw, quote at emission.
-    """
-    compile_flags: list[str] = []
-    link_flags: list[str] = []
-    lib_dirs: list[Path] = []
-    libs: list[str] = []
-    for tok in tokens:
-        if tok in unflags:
-            continue
-        # _lexed_build_flags warned about and dropped any bare -I/-D/-L/-l
-        if tok.startswith("-Wl,"):
-            link_flags.append(_shell_token(tok))
-        elif tok.startswith("-L"):
-            lib_dirs.append(Path(tok[2:]))
-        elif tok.startswith("-l"):
-            libs.append(tok[2:])
-        else:
-            if tok.startswith(_PLAIN_DRIVER_LINK_PREFIXES):
-                # Driver options with no -Wl, spelling; ld would reject them
-                raise EsphomeError(
-                    f"Link flag {tok} in build_flags is not supported by the "
-                    "native toolchain"
-                )
-            if tok in _PLAIN_LINKER_FLAGS or tok.startswith(_PLAIN_LINKER_PREFIXES):
-                raise EsphomeError(
-                    f"Linker flag {tok} in build_flags is not routed to the "
-                    "link line; use the -Wl, form"
-                )
-            if tok.startswith("-") and not tok.startswith(_COMPILE_FLAG_PREFIXES):
-                # The linker deny lists are not exhaustive; an unlisted
-                # link-only spelling would be inert on the -c compile line,
-                # so at least surface the odd shape
-                _LOGGER.warning(
-                    "Build flag %s is not a recognized compile-flag shape; "
-                    "it is passed to the compile line only",
-                    tok,
-                )
-            compile_flags.append(_shell_token(tok))
-    return compile_flags, link_flags, lib_dirs, libs
-
-
-# Recognized compile-flag shapes: the allow-list feeding the fall-through
-# warning in _project_flags (an unlisted link-only spelling still reaches
-# the compile line, but not silently)
-_COMPILE_FLAG_PREFIXES = (
-    "-D",
-    "-I",
-    "-U",
-    "-W",
-    "-f",
-    "-m",
-    "-O",
-    "-g",
-    "-std=",
-    "-include",
-)
-# Plain-form linker flags rejected by _project_flags: inert on a -c compile
-# line, so the firmware would silently lack the requested link behavior.
-# Best-effort, not exhaustive; see _COMPILE_FLAG_PREFIXES above.
-_PLAIN_LINKER_FLAGS = (
-    "-u",
-    "-e",
-    "-s",
-    "-static",
-    "-nostartfiles",
-    "-nodefaultlibs",
-    "-nostdlib",
-    "-rdynamic",
-)
-_PLAIN_LINKER_PREFIXES = ("-T", "-Xlinker")
-# Driver options, not ld options: -Wl, has no equivalent for these
-_PLAIN_DRIVER_LINK_PREFIXES = ("-fuse-ld=", "--specs=", "-specs=")
-
-
-def _stat_sig(path: Path) -> str:
-    """Size and mtime cache-stamp signature for one input file.
-
-    Absent stays deterministic ("missing": the spawn names it); unreadable
-    forces a cache miss every run rather than pinning the stamp to a
-    constant that can never notice a later edit.
-    """
-    try:
-        st = path.stat()
-        return f"{st.st_size}:{st.st_mtime_ns}"
-    except FileNotFoundError:
-        return "missing"
-    except OSError as err:
-        _LOGGER.warning(
-            "Could not stat %s (%s); regenerating the linker script every "
-            "build. Run 'esphome clean-all' to reinstall the framework.",
-            path,
-            err,
-        )
-        return f"unreadable:{os.urandom(8).hex()}"
-
-
-def _write_note(path: Path, text: str, *, warn: bool = False) -> bool:
-    """Best-effort bookkeeping write; a failure never fails the build.
-
-    ``warn`` marks notes whose loss drops a diagnostic on later cached
-    builds; a lost stamp only costs a cache miss and stays at debug.
-    Returns whether the write persisted, so a lost warn note can veto
-    the cache stamp and keep the diagnostic re-derivable.
-    """
-    try:
-        path.write_text(text, encoding="utf-8")
-    except OSError as err:
-        log = _LOGGER.warning if warn else _LOGGER.debug
-        log("Could not write %s: %s", path, err)
-        return False
-    return True
-
-
-def generate_ld_scripts(
-    paths: InstalledPaths, config: _BuildConfig, flash_ld_name: str
-) -> None:
-    """Generate the common linker script (and testing-mode flash ld copy).
-
-    Runs the same preprocessor invocation as the PlatformIO builder over
-    ``eagle.app.v6.common.ld.h``, then applies ESPHome's surgeries: the wifi
-    rate-table DRAM relocation, and enlarged memory segments in testing mode.
-    """
-    if not _FLASH_LD_NAME_RE.fullmatch(flash_ld_name):
-        # Joined under the SDK and build ld dirs; never a path or traversal
-        raise EsphomeError(f"Invalid flash linker script name {flash_ld_name!r}")
-    framework = paths.framework
-    gcc = toolchain_tool(paths.toolchain, "gcc")
-    ld_dir = CORE.relative_pioenvs_path(CORE.name, "ld")
-    mkdir_p(ld_dir)
-
-    cmd = [str(gcc), "-CC", "-E", "-P", f"-D{config.vtables}"]
-    cmd += [f"-D{d}" for d in config.mmu_defines]
-    if config.fp_in_irom:
-        cmd.append("-DFP_IN_IROM")
-    header = _sdk_ld_dir(framework) / _COMMON_LD_HEADER
-    cmd += [str(header), "-o", "-"]
-
-    # The inputs are the command line (defines + framework version, which is
-    # baked into the paths) plus testing mode; skip the preprocessor spawn on
-    # incremental builds when nothing changed.
-    output = ld_dir / _COMMON_LD_NAME
-    stamp = ld_dir / f".{_COMMON_LD_NAME}.stamp"
-    # Stamp includes the header/gcc stat (catches in-place re-extraction)
-    # and the surgery fingerprint (a build_surgery edit invalidates old
-    # build dirs)
-    stamp_content = (
-        # shlex.join: a spaced path stays one quoted element, so two
-        # different cmd lists can never collide to the same stamp string
-        shlex.join(cmd)
-        + f" testing={CORE.testing_mode}"
-        + f" header={_stat_sig(header)}"
-        + f" gcc={_stat_sig(gcc)}"
-        + f" {build_surgery.surgery_fingerprint()}"
-    )
-
-    stderr_note = ld_dir / f".{_COMMON_LD_NAME}.stderr"
-
-    def _note_digest() -> str:
-        # The note is an output like the script itself; folding its state
-        # into the stamp makes an externally removed or edited note a cache
-        # miss that re-runs -E and re-derives the diagnostic
-        if not stderr_note.is_file():
-            return "none"
-        return hashlib.sha256(stderr_note.read_bytes()).hexdigest()
-
-    def _cached_ld_is_valid() -> bool:
-        # Any damaged cache regenerates; never abort the build over it. The
-        # stamp records the sha256 of the content written, so an externally
-        # edited script regenerates too.
-        try:
-            if not (output.is_file() and stamp.is_file()):
-                return False
-            rest, sep, digest = stamp.read_text(encoding="utf-8").rpartition(
-                " content="
-            )
-            inputs, note_sep, note_digest = rest.rpartition(" note=")
-            return (
-                bool(sep)
-                and bool(note_sep)
-                and inputs == stamp_content
-                and note_digest == _note_digest()
-                and hashlib.sha256(output.read_bytes()).hexdigest() == digest
-            )
-        except (OSError, UnicodeDecodeError):
-            return False
-
-    if not _cached_ld_is_valid():
-        try:
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                check=False,
-                close_fds=False,
-            )
-        except OSError as err:
-            # A half-extracted or half-deleted toolchain cache reaches here
-            raise EsphomeError(f"Could not run {gcc}: {err}; {_CLEAN_HINT}") from err
-        # Localized gcc diagnostics on a non-UTF-8 console must degrade,
-        # not UnicodeDecodeError the build; the script itself (below) is
-        # decoded strictly instead, so a mangled byte can never be cached
-        stderr_text = result.stderr.decode("utf-8", errors="replace")
-        if result.returncode != 0:
-            raise EsphomeError(f"Generating the linker script failed:\n{stderr_text}")
-        note_persisted = True
-        if stderr_text.strip():
-            # Preprocessor warnings on the success path must reach the user
-            # on this and every later cached build (see the re-emit below)
-            _LOGGER.warning("Linker-script preprocessor: %s", stderr_text.strip())
-            note_persisted = _write_note(stderr_note, stderr_text.strip(), warn=True)
-        else:
-            try:
-                stderr_note.unlink(missing_ok=True)
-            except OSError as err:
-                # A kept stale note would re-emit an obsolete diagnostic on
-                # every cache hit; skip the stamp so -E re-derives the truth
-                _LOGGER.warning(
-                    "Could not remove %s (%s); the linker script will "
-                    "regenerate every build until it is removable; %s",
-                    stderr_note,
-                    err,
-                    _CLEAN_HINT,
-                )
-                note_persisted = False
-        try:
-            stdout_text = result.stdout.decode("utf-8")
-        except UnicodeDecodeError as err:
-            # -CC keeps header comments verbatim; a non-UTF-8 byte replaced
-            # with U+FFFD would be cached as valid for the build dir's life
-            raise EsphomeError(
-                f"Preprocessed linker script from {header} is not UTF-8: "
-                f"{err}; {_CLEAN_HINT}"
-            ) from err
-        if "SECTIONS" not in stdout_text:
-            # A degenerate zero-exit run must not be stamped as a good cache
-            raise EsphomeError(
-                f"Generated linker script is missing its SECTIONS block; {_CLEAN_HINT}"
-            )
-        content = _apply_surgery(build_surgery.relocate_ratetable, stdout_text)
-        if CORE.testing_mode:
-            content = _apply_surgery(
-                build_surgery.apply_testing_memory_patches, content, ("iram1_0_seg",)
-            )
-        write_file_if_changed(output, content)
-        if note_persisted:
-            # An unstamped cache re-runs -E next build, re-deriving the
-            # diagnostic the lost note would have re-emitted
-            _write_note(
-                stamp,
-                f"{stamp_content} note={_note_digest()} "
-                f"content={hashlib.sha256(content.encode('utf-8')).hexdigest()}",
-            )
-    elif stderr_note.is_file():
-        # Re-emit cached preprocessor warnings on cache hits
-        try:
-            _LOGGER.warning(
-                "Linker-script preprocessor: %s",
-                stderr_note.read_text(encoding="utf-8"),
-            )
-        except (OSError, UnicodeDecodeError) as err:
-            _LOGGER.warning(
-                "A cached linker-script preprocessor diagnostic exists at %s "
-                "but could not be read: %s",
-                stderr_note,
-                err,
-            )
-
-    if CORE.testing_mode:
-        _generate_testing_flash_ld(framework, ld_dir, flash_ld_name)
-
-
-def _generate_testing_flash_ld(
-    framework: Path, ld_dir: Path, flash_ld_name: str
-) -> None:
-    """A patched copy of the flash ld in the build dir; resolved through the
-    same -L path as the SDK original it shadows."""
-    flash_ld = _sdk_ld_dir(framework) / flash_ld_name
-    try:
-        flash_ld_text = flash_ld.read_text(encoding="utf-8")
-    except OSError as err:
-        # Same half-extracted-cache hazard as the preprocessor spawn
-        raise EsphomeError(f"Could not read {flash_ld}: {err}; {_CLEAN_HINT}") from err
-    patched_flash_ld = _apply_surgery(
-        build_surgery.apply_testing_memory_patches,
-        flash_ld_text,
-        ("dram0_0_seg", "irom0_0_seg"),
-    )
-    write_file_if_changed(
-        ld_dir / f"{_TESTING_LD_PREFIX}{flash_ld_name}", patched_flash_ld
-    )

esphome/components/audio/audio_reader.cpp

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

esphome/components/audio/audio_transfer_buffer.cpp

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

esphome/components/debug/sensor.py

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

esphome/components/debug/text_sensor.py

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

esphome/components/esp32/const.py

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

esphome/components/esphome/ota/ota_esphome.cpp

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

esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp

@@ -118,21 +118,24 @@ void I2SAudioSpeakerBase::loop() {
         break;
       }
 
+      // Still starting up or winding down from a previous run
+      if ((this->tx_handle_ != nullptr) || (this->speaker_task_handle_ != nullptr)) {
+        break;
+      }
+
       if (this->start_i2s_driver(this->audio_stream_info_) != ESP_OK) {
         ESP_LOGE(TAG, "Driver failed to start; retrying in 1 second");
         this->status_momentary_error("driver-failure", 1000);
         break;
       }
 
-      if (this->speaker_task_handle_ == nullptr) {
-        xTaskCreate(I2SAudioSpeakerBase::speaker_task, "speaker_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
-                    &this->speaker_task_handle_);
+      xTaskCreate(I2SAudioSpeakerBase::speaker_task, "speaker_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
+                  &this->speaker_task_handle_);
 
-        if (this->speaker_task_handle_ == nullptr) {
-          ESP_LOGE(TAG, "Task failed to start, retrying in 1 second");
-          this->status_momentary_error("task-failure", 1000);
-          this->stop_i2s_driver_();  // Stops the driver to return the lock; will be reloaded in next attempt
-        }
+      if (this->speaker_task_handle_ == nullptr) {
+        ESP_LOGE(TAG, "Task failed to start, retrying in 1 second");
+        this->status_momentary_error("task-failure", 1000);
+        this->stop_i2s_driver_();  // Stops the driver to return the lock; will be reloaded in next attempt
       }
       break;
     case speaker::STATE_RUNNING:   // Intentional fallthrough
@@ -218,8 +221,8 @@ size_t I2SAudioSpeakerBase::play(const uint8_t *data, size_t length, TickType_t
 }
 
 bool I2SAudioSpeakerBase::has_buffered_data() const {
-  if (this->audio_ring_buffer_.use_count() > 0) {
-    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->audio_ring_buffer_.lock();
+  std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->audio_ring_buffer_.lock();
+  if (temp_ring_buffer != nullptr) {
     return temp_ring_buffer->available() > 0;
   }
   return false;

esphome/components/micro_wake_word/micro_wake_word.cpp

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

esphome/components/microphone/microphone_source.h

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

esphome/components/mipi_dsi/mipi_dsi.cpp

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

esphome/components/mixer/speaker/mixer_speaker.cpp

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

esphome/components/nextion/display.py

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

esphome/components/noise/__init__.py

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

esphome/components/resampler/speaker/resampler_speaker.cpp

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

esphome/components/sendspin/__init__.py

@@ -30,6 +30,7 @@ CONF_SENDSPIN_ID = "sendspin_id"
 CONF_INITIAL_STATIC_DELAY = "initial_static_delay"
 CONF_FIXED_DELAY = "fixed_delay"
 CONF_DECODE_MEMORY = "decode_memory"
+CONF_CODECS = "codecs"
 
 # Matches ARTWORK_MAX_SLOTS in sendspin-cpp.
 MAX_ARTWORK_SLOTS = 4
@@ -44,6 +45,20 @@ CODEC_FORMAT_OPUS = SendspinCodecFormat.enum("OPUS")
 CODEC_FORMAT_PCM = SendspinCodecFormat.enum("PCM")
 CODEC_FORMAT_UNSUPPORTED = SendspinCodecFormat.enum("UNSUPPORTED")
 
+CODEC_FLAC = "flac"
+CODEC_OPUS = "opus"
+CODEC_PCM = "pcm"
+
+CODECS = {
+    CODEC_FLAC: CODEC_FORMAT_FLAC,
+    CODEC_OPUS: CODEC_FORMAT_OPUS,
+    CODEC_PCM: CODEC_FORMAT_PCM,
+}
+
+# Opus only supports 48 kHz audio, so it is left out of the default list at other rates.
+DEFAULT_CODECS = [CODEC_FLAC, CODEC_OPUS, CODEC_PCM]
+OPUS_SAMPLE_RATE = 48000
+
 SendspinImageFormat = sendspin_library_ns.enum("SendspinImageFormat", is_class=True)
 IMAGE_FORMAT_JPEG = SendspinImageFormat.enum("JPEG")
 IMAGE_FORMAT_PNG = SendspinImageFormat.enum("PNG")
@@ -286,16 +301,13 @@ async def to_code(config: ConfigType) -> None:
     if data.player_support:
         cg.add_define("USE_SENDSPIN_PLAYER", True)
 
-        # Configures the player role. We always assume support for 16 bits per sample mono and stereo FLAC, Opus, and PCM at the configured sample rate
-        # (with Opus only supported at 48 kHz since that's the only sample rate it supports). Users can configure the specific formats via the Sendspin server
+        # Configures the player role. Each configured codec is advertised for 16 bits per sample
+        # mono and stereo at the configured sample rate. The order is a preference order, both for
+        # the codecs themselves and for stereo over mono.
         player_cfg = data.player_config
         sample_rate = player_cfg[CONF_SAMPLE_RATE]
 
-        # OPUS only supports 48 kHz audio
-        codecs = [CODEC_FORMAT_FLAC]
-        if sample_rate == 48000:
-            codecs.append(CODEC_FORMAT_OPUS)
-        codecs.append(CODEC_FORMAT_PCM)
+        codecs = player_cfg[CONF_CODECS]
 
         def _audio_format(codec: MockObj, channels: int) -> cg.StructInitializer:
             return cg.StructInitializer(

esphome/components/sendspin/media_source/__init__.py

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

esphome/components/speaker/media_player/audio_pipeline.cpp

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

esphome/components/wifi/__init__.py

@@ -66,14 +66,13 @@ from esphome.const import (
 )
 from esphome.core import (
     CORE,
-    ID,
     CoroPriority,
     EsphomeError,
     HexInt,
     coroutine_with_priority,
 )
 import esphome.final_validate as fv
-from esphome.types import ConfigType, TemplateArgsType
+from esphome.types import ConfigType
 
 from . import wpa2_eap
 
@@ -209,7 +208,6 @@ WiFiEnabledCondition = wifi_ns.class_("WiFiEnabledCondition", Condition)
 WiFiAPActiveCondition = wifi_ns.class_("WiFiAPActiveCondition", Condition)
 WiFiEnableAction = wifi_ns.class_("WiFiEnableAction", automation.Action)
 WiFiDisableAction = wifi_ns.class_("WiFiDisableAction", automation.Action)
-WiFiRoamAction = wifi_ns.class_("WiFiRoamAction", automation.Action)
 WiFiConfigureAction = wifi_ns.class_(
     "WiFiConfigureAction", automation.Action, cg.Component
 )
@@ -822,18 +820,6 @@ async def wifi_disable_to_code(config, action_id, template_arg, args):
     return cg.new_Pvariable(action_id, template_arg)
 
 
-@automation.register_action(
-    "wifi.roam", WiFiRoamAction, cv.Schema({}), synchronous=True
-)
-async def wifi_roam_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> cg.MockObj:
-    return cg.new_Pvariable(action_id, template_arg)
-
-
 KEEP_SCAN_RESULTS_KEY = "wifi_keep_scan_results"
 RUNTIME_POWER_SAVE_KEY = "wifi_runtime_power_save"
 RUNTIME_ROAMING_SUPPRESSION_KEY = "wifi_runtime_roaming_suppression"

esphome/components/wifi/automation.h

@@ -31,11 +31,6 @@ template<typename... Ts> class WiFiDisableAction final : public Action<Ts...> {
   void play(const Ts &...x) override { global_wifi_component->disable(); }
 };
 
-template<typename... Ts> class WiFiRoamAction final : public Action<Ts...> {
- public:
-  void play(const Ts &...x) override { global_wifi_component->force_roam_check(); }
-};
-
 template<typename... Ts> class WiFiConfigureAction final : public Action<Ts...>, public Component {
  public:
   TEMPLATABLE_VALUE(std::string, ssid)

esphome/components/wifi/wifi_component.cpp

@@ -846,18 +846,17 @@ void WiFiComponent::loop() {
           this->notify_connect_state_listeners_();
 #endif
 
-          // Post-connect roaming: check for better AP. A scan may have been started by an
-          // explicit force_roam_check() even when post_connect_roaming_ is disabled, so the
-          // scan must always be consumed here to avoid leaving roaming_state_ stuck.
-          if (this->is_roaming_scan_active()) {
-            if (this->scan_done_) {
-              this->process_roaming_scan_();
+          // Post-connect roaming: check for better AP
+          if (this->post_connect_roaming_) {
+            if (this->is_roaming_scan_active()) {
+              if (this->scan_done_) {
+                this->process_roaming_scan_();
+              }
+              // else: scan in progress, wait
+            } else if (this->roaming_state_ == RoamingState::IDLE && this->roaming_attempts_ < ROAMING_MAX_ATTEMPTS &&
+                       now - this->roaming_last_check_ >= ROAMING_CHECK_INTERVAL && !this->roaming_suppressed_()) {
+              this->check_roaming_(now);
             }
-            // else: scan in progress, wait
-          } else if (this->post_connect_roaming_ && this->roaming_state_ == RoamingState::IDLE &&
-                     this->roaming_attempts_ < ROAMING_MAX_ATTEMPTS &&
-                     now - this->roaming_last_check_ >= ROAMING_CHECK_INTERVAL && !this->roaming_suppressed_()) {
-            this->check_roaming_(now);
           }
         }
         break;
@@ -2464,17 +2463,6 @@ void WiFiComponent::notify_scan_results_listeners_() {
 }
 #endif  // USE_WIFI_SCAN_RESULTS_LISTENERS
 
-void WiFiComponent::force_roam_check() {
-  if (!this->is_connected() || this->roaming_state_ != RoamingState::IDLE || this->roaming_suppressed_()) {
-    ESP_LOGD(TAG, "Roam check requested, but not able to check now");
-    return;
-  }
-  // Reset the attempt counter so a prior run of failed roams doesn't block this explicit request
-  // Note that this re-arms automatic roaming if enabled.
-  this->roaming_attempts_ = 0;
-  this->check_roaming_(millis());
-}
-
 void WiFiComponent::check_roaming_(uint32_t now) {
   // Guard: not for hidden networks (may not appear in scan)
   const WiFiAP *selected = this->get_selected_sta_();
@@ -2496,11 +2484,7 @@ void WiFiComponent::check_roaming_(uint32_t now) {
 
   ESP_LOGD(TAG, "Roam scan (%d dBm, attempt %u/%u)", rssi, this->roaming_attempts_, ROAMING_MAX_ATTEMPTS);
   this->roaming_state_ = RoamingState::SCANNING;
-  if (!this->wifi_scan_start_(this->passive_scan_)) {
-    // Scan failed to start (e.g. busy) - don't get stuck in SCANNING forever
-    ESP_LOGD(TAG, "Roam scan failed to start");
-    this->roaming_state_ = RoamingState::IDLE;
-  }
+  this->wifi_scan_start_(this->passive_scan_);
 }
 
 void WiFiComponent::process_roaming_scan_() {

esphome/components/wifi/wifi_component.h

@@ -565,12 +565,6 @@ class WiFiComponent final : public Component {
   void set_keep_scan_results(bool keep_scan_results) { this->keep_scan_results_ = keep_scan_results; }
   void set_post_connect_roaming(bool enabled) { this->post_connect_roaming_ = enabled; }
 
-  /** Force an immediate post-connect roaming check, bypassing the periodic interval and the
-   * per-connection attempt limit. Does nothing (besides a debug log) if not connected, if a
-   * roam scan or connect is already in progress, or if roaming is currently suppressed.
-   */
-  void force_roam_check();
-
 #ifdef USE_WIFI_CONNECT_TRIGGER
   Trigger<> *get_connect_trigger() { return &this->connect_trigger_; }
 #endif

esphome/const.py

@@ -4,7 +4,7 @@ from enum import Enum
 
 from esphome.enum import StrEnum
 
-__version__ = "2026.10.0-dev"
+__version__ = "2026.9.0b3"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (

esphome/core/static_task.cpp

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

esphome/core/static_task.h

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

esphome/espota2.py

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

esphome/happy_eyeballs.py

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

platformio.ini

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

requirements.txt

@@ -14,7 +14,7 @@ esptool==5.3.1
 click==8.3.3
 aioesphomeapi==46.3.0
 aiohappyeyeballs==2.7.1  # Happy Eyeballs for requests downloads; already pulled in by aioesphomeapi
-zeroconf==0.151.3
+zeroconf==0.151.2
 puremagic==2.2.0
 ruamel.yaml==0.19.1 # dashboard_import
 ruamel.yaml.clib==0.2.15 # dashboard_import
@@ -27,9 +27,9 @@ bleak==3.0.2
 smpclient==7.2.0
 requests==2.34.2
 py7zr==1.1.3
-platformdirs==4.11.7  # native esp-idf toolchain global cache dir
-ninja==1.13.2  # native esp8266 arduino toolchain build driver
-filelock==3.32.5  # inter-process locks (PlatformIO cache heal, git clone cache); >=3.32 for FileLock(fallback_to_soft=...), older versions silently drop the kwarg
+platformdirs==4.11.5  # native esp-idf toolchain global cache dir
+ninja==1.13.0  # native esp8266 arduino toolchain build driver
+filelock==3.32.4  # inter-process locks (PlatformIO cache heal, git clone cache); >=3.32 for FileLock(fallback_to_soft=...), older versions silently drop the kwarg
 
 # esp-idf >= 5.0 requires this
 pyparsing >= 3.3.2

requirements_dev.txt

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

requirements_test.txt

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

script/git-hooks/post-checkout

@@ -14,31 +14,7 @@ top=$(git rev-parse --show-toplevel 2>/dev/null) || exit 0
 [ -x "$top/venv/bin/python" ] && exit 0
 [ -x "$top/script/setup" ] || exit 0
 
-# Every worktree shares the hooks directory of the checkout it was created
-# from, and the script/setup run below is the one from whichever branch was just
-# checked out. Older branches install their own pre-commit hook without checking
-# for a worktree: that moves the shared hook aside as pre-commit.legacy and
-# replaces it with one tied to this worktree's virtual environment, so commits
-# break in every checkout. To rule that out, the hooks directory is copied
-# before script/setup runs and put back exactly as it was afterwards, including
-# removing any file script/setup added.
-hooks=$(git rev-parse --path-format=absolute --git-path hooks 2>/dev/null) || exit 0
-snap=$(mktemp -d "$hooks/.post-checkout.XXXXXX") || exit 0
-cp -p "$hooks"/* "$snap"/ 2>/dev/null
-
 # Clear VIRTUAL_ENV so a checkout made from a shell with an environment already
 # activated still gets its own, rather than having the active one repointed at
 # this working tree.
-env -u VIRTUAL_ENV "$top/script/setup"
-status=$?
-
-for f in "$hooks"/*; do
-  [ -e "$snap/${f##*/}" ] || rm -f "$f"
-done
-# Files are moved rather than copied so a hook that is still running, such as
-# this one, is swapped out atomically instead of being rewritten in place.
-for f in "$snap"/*; do
-  cmp -s "$f" "$hooks/${f##*/}" 2>/dev/null || mv -f "$f" "$hooks/${f##*/}"
-done
-rm -rf "$snap"
-exit $status
+exec env -u VIRTUAL_ENV "$top/script/setup"

script/sync_dependency_versions.py

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

tests/component_tests/sendspin/test_media_source.py

@@ -0,0 +1,90 @@
+"""Validation tests for the sendspin media_source platform.
+
+These cover the codec preference list, whose rejection branches a compile test
+cannot reach: a `test*.yaml` can only assert that a configuration is accepted.
+"""
+
+from typing import Any
+
+import pytest
+
+from esphome import config_validation as cv
+from esphome.components.sendspin import CONF_CODECS, _get_data
+from esphome.components.sendspin.media_source import CONFIG_SCHEMA
+from esphome.const import PlatformFramework
+from esphome.types import ConfigType
+from tests.component_tests.types import SetCoreConfigCallable
+
+
+def _media_source_config(**overrides: Any) -> ConfigType:
+    """Build a minimal valid media source config, allowing field overrides."""
+    config: ConfigType = {
+        "id": "sendspin_media_source",
+        "sendspin_id": "sendspin_hub",
+    }
+    config.update(overrides)
+    return config
+
+
+def test_default_codecs_at_48_khz(set_core_config: SetCoreConfigCallable) -> None:
+    """Every codec is advertised when the sample rate suits all of them."""
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+    config = CONFIG_SCHEMA(_media_source_config())
+
+    assert config[CONF_CODECS] == ["flac", "opus", "pcm"]
+
+
+def test_default_codecs_drop_opus_at_other_rates(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    """Opus only supports 48 kHz, so it leaves the default list at other rates."""
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+    config = CONFIG_SCHEMA(_media_source_config(sample_rate=44100))
+
+    assert config[CONF_CODECS] == ["flac", "pcm"]
+
+
+def test_configured_order_is_preserved(set_core_config: SetCoreConfigCallable) -> None:
+    """The list is a preference order, so it reaches the player role as written."""
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+    CONFIG_SCHEMA(_media_source_config(codecs=["pcm", "flac"]))
+
+    assert _get_data().player_config[CONF_CODECS] == ["pcm", "flac"]
+
+
+def test_empty_codec_list_rejected(set_core_config: SetCoreConfigCallable) -> None:
+    """A player with no codecs at all could never be given a stream."""
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+    with pytest.raises(cv.Invalid, match="length of value must be at least 1"):
+        CONFIG_SCHEMA(_media_source_config(codecs=[]))
+
+
+def test_duplicate_codec_rejected(set_core_config: SetCoreConfigCallable) -> None:
+    """A repeated codec has no meaning in a preference order."""
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+    with pytest.raises(cv.Invalid, match="may only be listed once"):
+        CONFIG_SCHEMA(_media_source_config(codecs=["flac", "flac"]))
+
+
+def test_unknown_codec_rejected(set_core_config: SetCoreConfigCallable) -> None:
+    """Only codecs the player role can decode are accepted."""
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+    with pytest.raises(cv.Invalid, match="Unknown value"):
+        CONFIG_SCHEMA(_media_source_config(codecs=["mp3"]))
+
+
+def test_opus_at_wrong_sample_rate_rejected(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    """Asking for Opus at a rate it cannot handle fails rather than silently
+    dropping the stated preference."""
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+    with pytest.raises(cv.Invalid, match="requires a sample_rate of 48000"):
+        CONFIG_SCHEMA(_media_source_config(codecs=["opus"], sample_rate=44100))

tests/components/sendspin/common-media_source.yaml

@@ -9,3 +9,4 @@ media_source:
     static_delay_adjustable: true
     fixed_delay: 480us
     decode_memory: internal
+    codecs: [pcm, opus, flac]

tests/components/wifi/common.yaml

@@ -14,7 +14,6 @@ esphome:
           condition: wifi.ap_active
           then:
             - logger.log: "WiFi AP is active!"
-      - wifi.roam
 
 wifi:
   networks:

tests/script/test_platformio_install_deps.py

@@ -35,8 +35,8 @@ def _load_script():
 def test_spec_key_collapses_destinations() -> None:
     """Two specs delivering one package share a directory and one key."""
     mod = _load_script()
-    assert mod.spec_key("esphome/noise-c @ 0.1.24") == "noise-c"
-    assert mod.spec_key("esphome/noise-c@0.1.24") == "noise-c"
+    assert mod.spec_key("esphome/noise-c @ 0.1.26") == "noise-c"
+    assert mod.spec_key("esphome/noise-c@0.1.26") == "noise-c"
     assert mod.spec_key("ESP32Async/AsyncTCP @ ^3.4.10") == mod.spec_key(
         "esp32async/asynctcp @ 3.5.0"
     )
@@ -54,23 +54,23 @@ def test_parse_specs_and_cli_args(tmp_path: Path) -> None:
         "[env:a]\n"
         "platform = fake/platform@1\n"
         "lib_deps =\n"
-        "    esphome/noise-c @ 0.1.24\n"
+        "    esphome/noise-c @ 0.1.26\n"
         "    ${common.lib_deps}\n"
         "    internal_lib\n"
         "[env:b]\n"
         "lib_deps =\n"
-        "    esphome/noise-c @ 0.1.24\n"
+        "    esphome/noise-c @ 0.1.26\n"
     )
     mod = _load_script()
     args = Namespace(libraries=True, platforms=True, tools=False)
     libs, platforms, tools = mod.parse_specs(str(ini), args)
     # exact-string duplicates collapse; distinct version pins survive
-    assert libs == ["esphome/noise-c @ 0.1.24"]
+    assert libs == ["esphome/noise-c @ 0.1.26"]
     assert platforms == ["fake/platform@1"]
     assert tools == []
     assert mod.build_cli_args(libs, platforms, tools) == [
         "-l",
-        "esphome/noise-c @ 0.1.24",
+        "esphome/noise-c @ 0.1.26",
         "-p",
         "fake/platform@1",
     ]
@@ -162,13 +162,13 @@ def test_parallel_install_behavior(tmp_path: Path) -> None:
     mod.parallel_install(
         cls,
         [
-            "esphome/noise-c @ 0.1.24",
-            "esphome/noise-c @ 0.1.24",
+            "esphome/noise-c @ 0.1.26",
+            "esphome/noise-c @ 0.1.26",
             "esphome/already @ 1.0",
             "https://x/framework.tar.xz",
         ],
     )
-    assert cls.calls == ["esphome/noise-c @ 0.1.24"]
+    assert cls.calls == ["esphome/noise-c @ 0.1.26"]
     assert cls.lock_events == ["lock", "unlock"]
 
 
@@ -205,7 +205,7 @@ def test_parallel_install_runs_dependency_waves(tmp_path: Path) -> None:
     mod = _load_script()
     cls = _reset_fake(str(tmp_path))
     cls.deps = {
-        "esphome/noise-c @ 0.1.24": [
+        "esphome/noise-c @ 0.1.26": [
             {"owner": "esphome", "name": "libsodium", "version": "^1.0"},
             {"name": "SPI"},
         ],
@@ -213,12 +213,12 @@ def test_parallel_install_runs_dependency_waves(tmp_path: Path) -> None:
             {"owner": "esphome", "name": "libsodium", "version": "^1.0"},
         ],
     }
-    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.24", "esphome/wg @ 1.0"])
+    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.26", "esphome/wg @ 1.0"])
     assert len(cls.calls) == 3  # the shared dep installs exactly once
     assert {mod.spec_key(c) for c in cls.calls} == {"noise-c", "wg", "libsodium"}
     # Wave-1 strings carry no compatibility; the dependency wave does
     compats = dict(cls.compat_calls)
-    assert compats["esphome/noise-c @ 0.1.24"] is None
+    assert compats["esphome/noise-c @ 0.1.26"] is None
     dep_compat = next(v for k, v in cls.compat_calls if "libsodium" in k)
     assert dep_compat is not None  # mirrors pio's install_dependency
 
@@ -229,11 +229,11 @@ def test_dependency_wave_excludes_url_specs(tmp_path: Path) -> None:
     mod = _load_script()
     cls = _reset_fake(str(tmp_path))
     cls.deps = {
-        "esphome/noise-c @ 0.1.24": [
+        "esphome/noise-c @ 0.1.26": [
             {"name": "vendored", "version": "https://github.com/x/y.git"},
         ],
     }
-    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.24"])
+    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.26"])
     assert {mod.spec_key(c) for c in cls.calls} == {"noise-c"}
 
 
@@ -348,13 +348,13 @@ def test_warm_store_still_walks_dependencies(tmp_path: Path) -> None:
     """Already-installed top-level packages still feed the dependency
     wave; a warm store can be missing a transitive dep."""
     mod = _load_script()
-    cls = _reset_fake(str(tmp_path), installed={"esphome/noise-c @ 0.1.24"})
+    cls = _reset_fake(str(tmp_path), installed={"esphome/noise-c @ 0.1.26"})
     cls.deps = {
-        "esphome/noise-c @ 0.1.24": [
+        "esphome/noise-c @ 0.1.26": [
             {"owner": "esphome", "name": "libsodium", "version": "^1.0"},
         ],
     }
-    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.24"])
+    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.26"])
     assert [mod.spec_key(c) for c in cls.calls] == ["libsodium"]
 
 

tests/script/test_sync_dependency_versions.py

@@ -1,219 +0,0 @@
-"""Unit tests for script/sync_dependency_versions.py."""
-
-from pathlib import Path
-import subprocess
-import sys
-
-import pytest
-import yamlrocks
-
-sys.path.insert(0, str((Path(__file__).parent / ".." / ".." / "script").resolve()))
-
-import sync_dependency_versions as sync_mod  # noqa: E402
-
-PRECOMMIT = """\
-# See https://pre-commit.com for more information
-repos:
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    # Ruff version.
-    rev: v0.1.0
-    hooks:
-      - id: ruff
-  - repo: https://github.com/PyCQA/flake8
-    rev: 7.0.0
-    hooks:
-      - id: flake8
-  - repo: https://github.com/asottile/pyupgrade
-    rev: v3.0.0
-    hooks:
-      - id: pyupgrade
-  - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v13.0.1
-    hooks:
-      - id: clang-format
-  - repo: https://github.com/adrienverge/yamllint.git
-    rev: v1.0.0
-    hooks:
-      - id: yamllint
-  - repo: local
-    hooks:
-      - id: pylint
-"""
-
-REQ_TEST = """\
-pylint==4.0.8
-flake8==7.1.0
-ruff==0.2.0  # comment
-pyupgrade==3.0.0
-"""
-
-REQ_DEV = """\
-clang-format==13.0.1
-yamllint==1.0.0
-"""
-
-RUFF_REPO = "https://github.com/astral-sh/ruff-pre-commit"
-DUPLICATE_RUFF_BLOCK = f"  - repo: {RUFF_REPO}\n    rev: v0.3.0\n    hooks: []\n"
-
-EXPECTED_DRIFT = ["ruff: 0.1.0 -> 0.2.0", "flake8: 7.0.0 -> 7.1.0"]
-EXPECTED_PRECOMMIT = PRECOMMIT.replace("rev: v0.1.0", "rev: v0.2.0").replace(
-    "rev: 7.0.0", "rev: 7.1.0"
-)
-
-
-@pytest.fixture
-def root(tmp_path: Path) -> Path:
-    """A fake checkout where ruff (v-prefixed) and flake8 (bare) have drifted."""
-    (tmp_path / ".pre-commit-config.yaml").write_text(PRECOMMIT)
-    (tmp_path / "requirements_test.txt").write_text(REQ_TEST)
-    (tmp_path / "requirements_dev.txt").write_text(REQ_DEV)
-    return tmp_path
-
-
-def _load(text: str) -> object:
-    return yamlrocks.loads(text.encode(), option=yamlrocks.OPT_ROUND_TRIP)
-
-
-@pytest.mark.parametrize(
-    ("requirements", "expected"),
-    [
-        ("prek==0.5.1  # comment\n", "0.5.1"),
-        ("Prek==0.5.1\n", "0.5.1"),
-        ("other==1.0\nprek==0.5.1\n", "0.5.1"),
-        ("prek>=0.5.1\n", None),
-        ("prek-extra==0.5.1\n", None),
-        ("", None),
-    ],
-)
-def test_read_requirement_version(requirements: str, expected: str | None) -> None:
-    assert sync_mod.read_requirement_version(requirements, "prek") == expected
-
-
-def test_find_repo_entry() -> None:
-    entry = sync_mod.find_repo_entry(_load(PRECOMMIT), RUFF_REPO)
-    assert entry["rev"] == "v0.1.0"
-
-
-@pytest.mark.parametrize(
-    ("text", "message"),
-    [
-        ("hooks: []\n", "missing key 'repos'"),
-        ("repos:\n  - rev: 1.0.0\n", "missing key 'repo'"),
-        (PRECOMMIT + DUPLICATE_RUFF_BLOCK, "found 2"),
-        ("repos:\n  - repo: other\n    rev: 1.0.0\n", "found 0"),
-    ],
-)
-def test_find_repo_entry_errors(text: str, message: str) -> None:
-    with pytest.raises(sync_mod.SyncError, match=message):
-        sync_mod.find_repo_entry(_load(text), RUFF_REPO)
-
-
-@pytest.mark.parametrize(
-    ("rev", "expected"),
-    [("v0.1.0", ("v", "0.1.0")), ("7.0.0", ("", "7.0.0")), ("'1.0'", ("", "1.0"))],
-)
-def test_current_rev(rev: str, expected: tuple[str, str]) -> None:
-    doc = _load(f"repos:\n  - repo: {RUFF_REPO}\n    rev: {rev}\n")
-    assert sync_mod.current_rev(doc["repos"][0], RUFF_REPO) == expected
-
-
-@pytest.mark.parametrize(
-    ("block", "message"),
-    [("    hooks: []\n", "has no rev"), ("    rev: 1.0\n", "not a string: 1.0")],
-)
-def test_current_rev_errors(block: str, message: str) -> None:
-    doc = _load(f"repos:\n  - repo: {RUFF_REPO}\n{block}")
-    with pytest.raises(sync_mod.SyncError, match=message):
-        sync_mod.current_rev(doc["repos"][0], RUFF_REPO)
-
-
-def test_sync_reports_without_writing(root: Path) -> None:
-    assert sync_mod.sync(root, write=False) == EXPECTED_DRIFT
-    assert (root / ".pre-commit-config.yaml").read_text() == PRECOMMIT
-
-
-def test_sync_writes_keeps_layout_and_is_idempotent(root: Path) -> None:
-    assert sync_mod.sync(root, write=True) == EXPECTED_DRIFT
-    assert (root / ".pre-commit-config.yaml").read_text() == EXPECTED_PRECOMMIT
-    assert sync_mod.sync(root, write=True) == []
-
-
-def test_sync_does_not_touch_a_config_that_matches(root: Path) -> None:
-    (root / ".pre-commit-config.yaml").write_text(EXPECTED_PRECOMMIT)
-    before = (root / ".pre-commit-config.yaml").stat().st_mtime_ns
-    assert sync_mod.sync(root, write=True) == []
-    assert (root / ".pre-commit-config.yaml").stat().st_mtime_ns == before
-
-
-def test_sync_missing_requirement_pin(root: Path) -> None:
-    (root / "requirements_dev.txt").write_text("")
-    with pytest.raises(sync_mod.SyncError, match="no 'clang-format==' pin"):
-        sync_mod.sync(root, write=True)
-
-
-def test_sync_propagates_config_errors(root: Path) -> None:
-    (root / ".pre-commit-config.yaml").write_text(PRECOMMIT + DUPLICATE_RUFF_BLOCK)
-    with pytest.raises(sync_mod.SyncError, match="found 2"):
-        sync_mod.sync(root, write=True)
-
-
-def test_main_check_reports_drift(
-    root: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    assert sync_mod.main(["--check", "--root", str(root)]) == 1
-    assert capsys.readouterr().out.splitlines() == EXPECTED_DRIFT
-    assert (root / ".pre-commit-config.yaml").read_text() == PRECOMMIT
-
-
-def test_main_writes_then_check_is_clean(
-    root: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    assert sync_mod.main(["--root", str(root)]) == 0
-    assert capsys.readouterr().out.splitlines() == EXPECTED_DRIFT
-    assert sync_mod.main(["--check", "--root", str(root)]) == 0
-    assert capsys.readouterr().out == ""
-
-
-def test_main_reports_sync_error(
-    root: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
-    (root / "requirements_dev.txt").write_text("")
-    assert sync_mod.main(["--root", str(root)]) == 1
-    assert (
-        "error: requirements_dev.txt: no 'clang-format==' pin"
-        in capsys.readouterr().err
-    )
-
-
-def test_main_defaults_to_repo_root(monkeypatch: pytest.MonkeyPatch) -> None:
-    seen: dict[str, object] = {}
-
-    def fake_sync(root: Path, *, write: bool) -> list[str]:
-        seen["root"] = root
-        seen["write"] = write
-        return []
-
-    monkeypatch.setattr(sync_mod, "sync", fake_sync)
-    assert sync_mod.main([]) == 0
-    assert seen == {"root": sync_mod.REPO_ROOT, "write": True}
-
-
-def test_repository_is_in_sync() -> None:
-    """The real checkout must match; a failure here means a rev has drifted.
-
-    Also proves every SYNC_TARGETS entry still resolves in the real files.
-    """
-    assert sync_mod.sync(sync_mod.REPO_ROOT, write=False) == []
-
-
-def test_cli_entry_point(root: Path) -> None:
-    """Run the script the way the workflow does, as a subprocess."""
-    script = Path(sync_mod.__file__)
-    result = subprocess.run(
-        [sys.executable, str(script), "--check", "--root", str(root)],
-        capture_output=True,
-        text=True,
-        check=False,
-    )
-    assert result.returncode == 1
-    assert result.stdout.splitlines() == EXPECTED_DRIFT

tests/unit_tests/test_espota2.py

@@ -416,6 +416,9 @@ def test_perform_ota_no_auth(
         "Update took 14.00 seconds (prepare 2.00, upload 5.00, commit 7.00)"
         in caplog.text
     )
+    # The data phase timeout must outlast the device's 105 s data timeout
+    mock_socket.settimeout.assert_any_call(espota2.DATA_PHASE_TIMEOUT)
+    assert espota2.DATA_PHASE_TIMEOUT > 105.0
 
 
 @pytest.mark.usefixtures("mock_time")

tests/unit_tests/test_platformio_prefetch.py

@@ -1663,7 +1663,7 @@ def test_preinstall_runs_dependency_waves(tmp_path: Path) -> None:
         {"name": "SPI"},
     ]
     m.dependency_to_spec.side_effect = lambda dep: _FakeSpec(name=dep["name"])
-    pf._preinstall(m, [("noise-c@0.1.24", _FakeSpec(name="noise-c"))])
+    pf._preinstall(m, [("noise-c@0.1.26", _FakeSpec(name="noise-c"))])
     assert installed == ["noise-c", "libsodium"]  # dep deduped, SPI left out
     # The dep wave carries its compatibility so _install searches qualified
     dep_call = m._install.call_args_list[-1]
@@ -1683,7 +1683,7 @@ def test_preinstall_dependency_wave_skips_seen_names(tmp_path: Path) -> None:
     m._install.side_effect = lambda spec, skip_dependencies, compatibility=None: (
         installed.append(getattr(spec, "name", str(spec)))
     )
-    pf._preinstall(m, [("noise-c@0.1.24", _FakeSpec(name="noise-c"))])
+    pf._preinstall(m, [("noise-c@0.1.26", _FakeSpec(name="noise-c"))])
     assert installed == ["noise-c"]