[core] Optimize base64 decoding fast path

[tas58xx] Improve TAS5805M audio performance and use GPIO1 for TAS5825M faults (#20319 )
Bump aioesphomeapi from 46.6.0 to 46.7.0 (#20317 )
2026-10-22 13:56:10 +00:00 · 2026-10-08 00:20:39 +00:00 · 2026-10-07 13:57:46 -10:00 · 2026-10-07 13:31:24 -10:00 · 2026-10-08 12:22:07 +13:00 · 2026-10-08 12:15:20 +13:00
267 changed files with 1272 additions and 6348 deletions
@@ -893,20 +893,14 @@ jobs:
      matrix:
        include:
          - id: clang-tidy
-            name: Run script/clang-tidy for ESP32 IDF 1/5
-            options: --environment esp32-idf-tidy --split-num 5 --split-at 1
+            name: Run script/clang-tidy for ESP32 IDF 1/3
+            options: --environment esp32-idf-tidy --split-num 3 --split-at 1
          - id: clang-tidy
-            name: Run script/clang-tidy for ESP32 IDF 2/5
-            options: --environment esp32-idf-tidy --split-num 5 --split-at 2
+            name: Run script/clang-tidy for ESP32 IDF 2/3
+            options: --environment esp32-idf-tidy --split-num 3 --split-at 2
          - id: clang-tidy
-            name: Run script/clang-tidy for ESP32 IDF 3/5
-            options: --environment esp32-idf-tidy --split-num 5 --split-at 3
-          - id: clang-tidy
-            name: Run script/clang-tidy for ESP32 IDF 4/5
-            options: --environment esp32-idf-tidy --split-num 5 --split-at 4
-          - id: clang-tidy
-            name: Run script/clang-tidy for ESP32 IDF 5/5
-            options: --environment esp32-idf-tidy --split-num 5 --split-at 5
+            name: Run script/clang-tidy for ESP32 IDF 3/3
+            options: --environment esp32-idf-tidy --split-num 3 --split-at 3

    steps:
      - name: Check out code from GitHub
@@ -15,6 +15,8 @@ on:
  # base branch checkout, so fork code never runs with the token.
  pull_request_target:
    types: [opened, synchronize, reopened]
+    branches:
+      - dev
    paths:
      - requirements_dev.txt
      - requirements_test.txt
@@ -568,7 +568,7 @@ esphome/components/tca9555/* @mobrembski
 esphome/components/tcl112/* @glmnet
 esphome/components/tcp_uart/* @Bascht74
 esphome/components/tee501/* @Stock-M
-esphome/components/teleinfo/* @0hax @FredM67
+esphome/components/teleinfo/* @0hax
 esphome/components/tem3200/* @bakerkj
 esphome/components/template/alarm_control_panel/* @grahambrown11 @hwstar
 esphome/components/template/datetime/* @rfdarter
@@ -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
+PROJECT_NUMBER         = 2026.11.0-dev

 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -22,7 +22,7 @@ RUN \
    -r /requirements.txt

 # Install the ESPHome Device Builder dashboard.
-RUN uv pip install --no-cache-dir esphome-device-builder==1.25.0
+RUN uv pip install --no-cache-dir esphome-device-builder==1.21.0

 RUN \
    platformio settings set enable_telemetry No \
@@ -7,7 +7,6 @@ import importlib
 import logging
 import os
 from pathlib import Path
-import platform
 import re
 import sys
 import time
@@ -55,7 +54,7 @@ from esphome.const import (
 )
 from esphome.core import CORE, EsphomeError, coroutine
 from esphome.enum import StrEnum
-from esphome.helpers import IS_MACOS, get_bool_env, indent, is_ip_address
+from esphome.helpers import get_bool_env, indent, is_ip_address
 from esphome.log import AnsiFore, color, setup_log
 from esphome.stacktrace import LogLineProcessor
 from esphome.types import ConfigType
@@ -1312,9 +1311,9 @@ def _choose_ota_platform(config: ConfigType, requested: str | None) -> str:
    # platform's final-validate hook merges duplicates anyway.
    available: dict[str, None] = {}
    for ota_item in config.get(CONF_OTA, []):
-        ota_platform = ota_item.get(CONF_PLATFORM)
-        if ota_platform in (CONF_ESPHOME, CONF_WEB_SERVER):
-            available[ota_platform] = None
+        platform = ota_item.get(CONF_PLATFORM)
+        if platform in (CONF_ESPHOME, CONF_WEB_SERVER):
+            available[platform] = None

    if not available:
        raise EsphomeError(
@@ -1946,10 +1945,7 @@ def run_multiple_configs(
        safe_print()

        cmd = command_builder(f)
-        # The parent already logged the Intel macOS warning; children skip it.
-        rc = run_external_process(
-            *cmd, env={**os.environ, _INTEL_MACOS_WARNED_ENV: "1"}
-        )
+        rc = run_external_process(*cmd)

        if rc == 0:
            print_bar(f"[{color(AnsiFore.BOLD_GREEN, 'SUCCESS')}] {str(f)}")
@@ -2618,27 +2614,6 @@ def _warn_if_source_tree_mismatch() -> None:
    )


-_INTEL_MACOS_REMOVAL = "2027.6.0"
-_INTEL_MACOS_WARNED_ENV = "ESPHOME_INTEL_MACOS_WARNED"
-
-
-def _warn_if_intel_macos() -> None:
-    """Warn that Intel (x86_64) Python on macOS loses support by _INTEL_MACOS_REMOVAL."""
-    if (
-        not IS_MACOS
-        or platform.machine() != "x86_64"
-        or _INTEL_MACOS_WARNED_ENV in os.environ
-    ):
-        return
-    _LOGGER.warning(
-        "Support for Intel Macs will end in ESPHome %s or earlier. The Python "
-        "packages ESPHome depends on have stopped publishing Intel macOS builds, "
-        "so future releases will not install on this machine. On an Apple "
-        "Silicon Mac, switch to a native arm64 Python.",
-        _INTEL_MACOS_REMOVAL,
-    )
-
-
 def run_esphome(argv):
    from esphome.address_cache import AddressCache

@@ -2658,7 +2633,6 @@ def run_esphome(argv):

    setup_log(log_level=args.log_level)
    _warn_if_source_tree_mismatch()
-    _warn_if_intel_macos()

    if args.command in PRE_CONFIG_ACTIONS:
        try:
@@ -49,9 +49,9 @@ class FrameworkRelease(NamedTuple):
 # Arduino core version -> its build in esphome-libs/arduino-esp8266
 FRAMEWORK_RELEASES: dict[Version, FrameworkRelease] = {
    Version(3, 1, 2): FrameworkRelease(
-        "3.1.2-esphome.3",
-        "3af533a85163804e164500a5b254dc23b922080e25ecb7dc37b3dd8ac84651db",
-        37185650,
+        "3.1.2-esphome.1",
+        "e80751e3123676b967143e39c61f2d8693946db4c7806f2a83dcaaf797ecd582",
+        37189311,
    ),
 }

@@ -672,20 +672,52 @@ XorCondition = cg.esphome_ns.class_("XorCondition", Condition)


@register_condition("and", AndCondition, validate_condition_list)
+async def and_condition_to_code(
+    config: ConfigType,
+    condition_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    conditions = await build_condition_list(config, template_arg, args)
+    return cg.new_Pvariable(
+        condition_id, cg.TemplateArguments(len(conditions), *template_arg), conditions
+    )
+
+
+@register_condition("or", OrCondition, validate_condition_list)
+async def or_condition_to_code(
+    config: ConfigType,
+    condition_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    conditions = await build_condition_list(config, template_arg, args)
+    return cg.new_Pvariable(
+        condition_id, cg.TemplateArguments(len(conditions), *template_arg), conditions
+    )
+
+
@register_condition("all", AndCondition, validate_condition_list)
-@register_condition("or", OrCondition, validate_condition_list)
+async def all_condition_to_code(
+    config: ConfigType,
+    condition_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    conditions = await build_condition_list(config, template_arg, args)
+    return cg.new_Pvariable(
+        condition_id, cg.TemplateArguments(len(conditions), *template_arg), conditions
+    )
+
+
@register_condition("any", OrCondition, validate_condition_list)
-@register_condition("xor", XorCondition, validate_condition_list)
-async def condition_group_to_code(
+async def any_condition_to_code(
    config: ConfigType,
    condition_id: ID,
    template_arg: cg.TemplateArguments,
    args: TemplateArgsType,
 ) -> MockObj:
    conditions = await build_condition_list(config, template_arg, args)
-    # A group of one is that condition for and, or and xor; skip the wrapper.
-    if len(conditions) == 1:
-        return conditions[0]
    return cg.new_Pvariable(
        condition_id, cg.TemplateArguments(len(conditions), *template_arg), conditions
    )
@@ -702,6 +734,19 @@ async def not_condition_to_code(
    return cg.new_Pvariable(condition_id, template_arg, condition)


+@register_condition("xor", XorCondition, validate_condition_list)
+async def xor_condition_to_code(
+    config: ConfigType,
+    condition_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    conditions = await build_condition_list(config, template_arg, args)
+    return cg.new_Pvariable(
+        condition_id, cg.TemplateArguments(len(conditions), *template_arg), conditions
+    )
+
+
@register_condition("lambda", LambdaCondition, cv.returning_lambda)
 async def lambda_condition_to_code(
    config: ConfigType,
@@ -54,7 +54,6 @@ from esphome.components.esp8266.const import (
    KEY_ESP8266,
    KEY_FLASH_SIZE,
    KEY_SCANF_FLOAT,
-    THROW_STUBS_HEADER,
 )
 from esphome.core import CORE, EsphomeError
 from esphome.framework_helpers import get_project_cxx_compile_flags
@@ -1057,7 +1056,7 @@ def write_project(paths: InstalledPaths, ccache: str | None) -> bool:
    cxx = (toolchain_tool(paths.toolchain, "g++"),)
    lines = [
        *tool_lines((toolchain_tool(paths.toolchain, "gcc"),), cxx, ccache),
-        *compile_rule_lines(ccache),
+        *compile_rule_lines(),
        *ar_rule_lines(toolchain_tool(paths.toolchain, "ar")),
        *pch_rule_lines(),
        "rule link",
@@ -1088,8 +1087,32 @@ def write_project(paths: InstalledPaths, ccache: str | None) -> bool:
    if "USE_ESP8266_WAVEFORM_STUBS" in flag_defines:
        core_exclude |= _CORE_EXCLUDE_WAVEFORM

-    # esp8266/__init__ pins build_src_flags (the throw_stubs force-include), as on
-    # the PlatformIO path; -include paths resolve against the source root
+    archives = []
+    # variant_dir existence was already enforced with the include dirs
+    variant_sources = collect_sources(variant_dir)
+    if variant_sources:
+        objs = compile_edges(lines, variant_sources, variant_dir, "variant")
+        lines.append(f"build libFrameworkArduinoVariant.a: ar {' '.join(objs)}")
+        archives.append("libFrameworkArduinoVariant.a")
+
+    core_objs = compile_edges(
+        lines, collect_sources(core_dir, core_exclude), core_dir, "core"
+    )
+    if not core_objs:
+        # An empty archive would link into a wall of undefined references
+        # (app_entry, the exception vectors) far from the cause
+        raise EsphomeError(
+            f"{_INCOMPLETE_INSTALL}: no core sources in {core_dir}; {_CLEAN_HINT}"
+        )
+    lines.append(f"build libFrameworkArduino.a: ar {' '.join(core_objs)}")
+    archives.append("libFrameworkArduino.a")
+
+    lib_archives, direct_objs = library_edges(lines, libraries)
+    archives += lib_archives
+
+    # One source of truth with the PlatformIO path: esp8266/__init__ pins
+    # build_src_flags (the throw_stubs force-include); -include paths
+    # resolve against the source root
    src_other: list[str] = []
    src_includes: list[str] = []
    src_it = iter(
@@ -1108,45 +1131,7 @@ def write_project(paths: InstalledPaths, ccache: str | None) -> bool:
            src_includes.append(tok[len("-include") :])
        else:
            src_other.append(_shell_token(tok))
-    # The throw stubs abort: none anywhere with exceptions on, else the core and
-    # libraries get them too (src keeps them after its pch include)
-    if config.exceptions:
-        src_includes = [h for h in src_includes if h != THROW_STUBS_HEADER]
    include_flags = [f"-include {_q(src_dir / h)}" for h in src_includes]
-    framework_flags = ""
-    if THROW_STUBS_HEADER in src_includes:
-        stubs_flag = include_flags[src_includes.index(THROW_STUBS_HEADER)]
-        lines.append(f"frameworkflags = {stubs_flag}")
-        framework_flags = "$frameworkflags"
-    archives = []
-    # variant_dir existence was already enforced with the include dirs
-    variant_sources = collect_sources(variant_dir)
-    if variant_sources:
-        objs = compile_edges(
-            lines, variant_sources, variant_dir, "variant", flags=framework_flags
-        )
-        lines.append(f"build libFrameworkArduinoVariant.a: ar {' '.join(objs)}")
-        archives.append("libFrameworkArduinoVariant.a")
-
-    core_objs = compile_edges(
-        lines,
-        collect_sources(core_dir, core_exclude),
-        core_dir,
-        "core",
-        flags=framework_flags,
-    )
-    if not core_objs:
-        # An empty archive would link into a wall of undefined references
-        # (app_entry, the exception vectors) far from the cause
-        raise EsphomeError(
-            f"{_INCOMPLETE_INSTALL}: no core sources in {core_dir}; {_CLEAN_HINT}"
-        )
-    lines.append(f"build libFrameworkArduino.a: ar {' '.join(core_objs)}")
-    archives.append("libFrameworkArduino.a")
-
-    lib_archives, direct_objs = library_edges(lines, libraries, framework_flags)
-    archives += lib_archives
-
    # One shared variable instead of repeating the flags line on every src
    # edge (hundreds of edges in a real project)
    lines.append(f"srcflags = {' '.join(src_other + include_flags)}")
@@ -240,7 +240,7 @@ def write_project(compilers: HostCompilers, ccache: str | None) -> bool:

    lines = [
        *tool_lines(compilers.cc, compilers.cxx, ccache),
-        *compile_rule_lines(ccache),
+        *compile_rule_lines(),
        *pch_rule_lines(),
        "rule link",
        "  command = $cxx -o $out $linkflags @$out.rsp $archives $libdirflags $libflags",
@@ -74,40 +74,33 @@ def tool_lines(
        # path gets
        f"python = {_q(strip_win_long_path_prefix(sys.executable))}",
        f"buildtool = {_q(_BUILD_TOOL)}",
-        *([f"ccache = {_q(ccache)}"] if ccache else []),
+        f"ccache = {_q(ccache) if ccache else ''}",
        "",
    ]


-def compile_rule_lines(ccache: str | None) -> list[str]:
-    """The compile rules; ``$own_includes`` is empty unless an edge sets it.
-
-    ``ccache`` is the launcher ``tool_lines`` was given; the same test here
-    keeps the variable and the rules in step. It is spliced in rather than
-    left as an empty variable: a leading space on the command line makes
-    CreateProcess fail on Windows.
-    """
-    launcher = "$ccache " if ccache else ""
+def compile_rule_lines() -> list[str]:
+    """The compile rules; ``$own_includes`` is empty unless an edge sets it."""
    return [
        "rule c",
-        f"  command = {launcher}$cc -MMD -MF $out.d $own_includes $cflags $flags -c $in -o $out",
+        "  command = $ccache $cc -MMD -MF $out.d $own_includes $cflags $flags -c $in -o $out",
        "  depfile = $out.d",
        "  deps = gcc",
        "  description = CC $out",
        "rule cxx",
-        f"  command = {launcher}$cxx -MMD -MF $out.d $own_includes $cxxflags $flags -c $in -o $out",
+        "  command = $ccache $cxx -MMD -MF $out.d $own_includes $cxxflags $flags -c $in -o $out",
        "  depfile = $out.d",
        "  deps = gcc",
        "  description = CXX $out",
        "rule aspp",
-        f"  command = {launcher}$cc -MMD -MF $out.d -x assembler-with-cpp $own_includes $asflags $flags -c $in -o $out",
+        "  command = $ccache $cc -MMD -MF $out.d -x assembler-with-cpp $own_includes $asflags $flags -c $in -o $out",
        "  depfile = $out.d",
        "  deps = gcc",
        "  description = AS $out",
        # Plain assembler, as SCons's ASCOM: no preprocessor, so no
        # depfile and no $flags (defines/includes) either
        "rule asm",
-        f"  command = {launcher}$cc -x assembler $asflags -c $in -o $out",
+        "  command = $ccache $cc -x assembler $asflags -c $in -o $out",
        "  description = AS $out",
    ]

@@ -214,12 +207,10 @@ def compile_edges(


 def library_edges(
-    lines: list[str], libraries: list[ArduinoLibrary], extra_flags: str = ""
+    lines: list[str], libraries: list[ArduinoLibrary]
 ) -> tuple[list[str], list[str]]:
    """Emit every library's compile and archive edges.

-    ``extra_flags`` (raw ninja text) precede each library's own flags.
-
    Returns the archive names and the objects that link directly. A
    library's own include dirs lead its compile lines, as PlatformIO searched
    them first: the include path is one global list, so another library's
@@ -241,7 +232,7 @@ def library_edges(
            lib.sources,
            common_parent(lib.sources),
            f"lib/{lib.name}",
-            flags=" ".join(filter(None, [extra_flags, *map(_shell_token, lib.flags)])),
+            flags=" ".join(_shell_token(f) for f in lib.flags),
            own_includes=" ".join(f"-I{_q(d)}" for d in lib.include_dirs),
        )
        if not lib.lib_archive:
@@ -81,8 +81,6 @@ service APIConnection {
  rpc subscribe_serial_proxy_identity(SubscribeSerialProxyIdentityRequest) returns (void) {}
  rpc serial_proxy_request(SerialProxyRequest) returns (void) {}
  rpc serial_proxy_set_mode(SerialProxySetModeRequest) returns (void) {}
-
-  rpc sendspin_pairing_token(SendspinPairingTokenRequest) returns (SendspinPairingTokenResponse) {}
 }


@@ -400,14 +398,6 @@ message WizardCapabilities {
  bool configured = 1;
 }

-message SendspinCapabilities {
-  // Bitmask of the Sendspin features this device supports
-  uint32 feature_flags = 1;
-  // The Sendspin client_id: base64url of the client's static public key, 43 characters.
-  // Empty until the Sendspin client has started once since boot.
-  string client_id = 2 [(max_data_length) = 43];
-}
-
 message DeviceCapabilitiesResponse {
  option (id) = 150;
  option (source) = SOURCE_SERVER;
@@ -418,7 +408,6 @@ message DeviceCapabilitiesResponse {
  repeated SerialProxyInfo serial_proxies = 4
      [(field_ifdef) = "USE_SERIAL_PROXY", (fixed_array_size_define) = "SERIAL_PROXY_COUNT"];
  WizardCapabilities wizard = 5 [(field_ifdef) = "USE_API_WIZARD"];
-  SendspinCapabilities sendspin = 6 [(field_ifdef) = "USE_SENDSPIN"];
 }

 // ==================== DEVICE WIZARD ====================
@@ -447,7 +436,7 @@ message DeviceWizardRequest {
 //   {"version": 1,
 //    "pages": [{"title": "...", "description": "...",
 //      "entities": [{"key": 123, "device_id": 456, "description": "..."}],
-//      "inputs": [{"key": 789, "description": "...", "multiple": true, "max_length": 1023,
+//      "inputs": [{"key": 789, "description": "...",
 //        "entity_filters": [{"integration": "...", "domain": ["..."],
 //                            "device_class": ["..."], "supported_features": ["..."]}]}]}]}
 //
@@ -471,14 +460,6 @@ message DeviceWizardRequest {
 // an entity matches a filter when it satisfies every field that is set, and an entity
 // that matches any one of the filters is accepted.
 //
-// An input with "multiple": true lets the user pick several entities. The client sends
-// them in one WizardInputSetRequest as a comma separated list with no spaces
-// ("calendar.a,calendar.b"); the device also accepts spaces around each id and stores the
-// list without them. "max_length" (only on a multiple input, 255 when left out) is the
-// longest list in bytes the device accepts. The version stays 1: a client that does not
-// know "multiple" ignores it, shows a single picker and sends one entity id, which a
-// multiple input accepts.
-//
 // The device keeps the entity id of an input in RAM only and does not store it across
 // restarts. The client therefore stores the choice itself and, after every connection
 // and before it sends SubscribeHomeAssistantStatesRequest, sends a WizardInputSetRequest
@@ -487,20 +468,17 @@ message DeviceWizardResponse {
  option (id) = 157;
  option (source) = SOURCE_SERVER;
  option (ifdef) = "USE_API_WIZARD";
+  // Not logged: the data is in flash, which ESP8266 cannot read for a dump
+  option (log) = false;

  // The data is in flash, and the device sends it from there
-  bytes data = 1 [(pointer_to_buffer) = true, (progmem) = true];
+  bytes data = 1 [(pointer_to_buffer) = true];
 }

 // Sets the entity id of a wizard input (see WizardInputField.key). Clients send
 // this only when DeviceCapabilitiesResponse.wizard.configured is set. There is no
-// reply. The device ignores a request whose key matches no input. A single input is
-// ignored when the entity_id is empty, longer than 255 bytes or has no '.'. A multiple
-// input takes a comma separated list ("calendar.a,calendar.b"); the client sends no
-// spaces, the device trims spaces around each id and stores the list without them. The
-// whole request is ignored when any id is empty or has no '.', or when the list without
-// spaces does not fit the input's max_length (255 by default). Otherwise it keeps the id
-// or list in RAM,
+// reply. The device ignores a request whose key matches no input or whose entity_id
+// is empty, longer than 255 bytes or has no '.'. Otherwise it keeps the id in RAM,
 // not across restarts, and when the input belongs to a homeassistant platform entity
 // it subscribes to that entity's state. Clients send this for every input right
 // after connecting, before SubscribeHomeAssistantStatesRequest. A request that
@@ -512,7 +490,7 @@ message WizardInputSetRequest {
  option (ifdef) = "USE_API_WIZARD_INPUTS";

  fixed32 key = 1;
-  string entity_id = 2 [(max_data_length) = 4095];
+  string entity_id = 2 [(max_data_length) = 255];
 }

 message ListEntitiesRequest {
@@ -3046,15 +3024,12 @@ enum SerialProxyIdentityFlag {
                                             // IDs below are empty
 }

-// The descriptor fields of a USB device as seen by the host stack, and the port's index
-// among those a vendor driver exposes on the interface
+// The descriptor fields of a USB device as seen by the host stack
 message UsbDeviceDescriptor {
  uint32 vendor_id = 1;
  uint32 product_id = 2;
  uint32 bcd_device = 3;
-  uint32 interface_number = 4;  // bInterfaceNumber the port is bound through
-  uint32 interface_class = 5;   // bInterfaceClass of that interface
-  uint32 port_number = 6;
+  uint32 interface_number = 4;   // bInterfaceNumber the host driver binds to
 }

 // The identity of the device behind a port. Identifies one physical device among others of
@@ -3096,34 +3071,3 @@ message BluetoothSetConnectionParamsResponse {
  uint64 address = 1;
  int32 error = 2;
 }
-
-// ==================== SENDSPIN ====================
-enum SendspinPairingTokenStatus {
-  // The Sendspin client has not started yet, so the token does not exist yet. Ask again later.
-  SENDSPIN_PAIRING_TOKEN_STATUS_NOT_READY = 0;
-  SENDSPIN_PAIRING_TOKEN_STATUS_OK = 1;
-  // The device has no API encryption key, so it will not send the token. Ask again once a key is set.
-  SENDSPIN_PAIRING_TOKEN_STATUS_ENCRYPTION_REQUIRED = 2;
-  // Sendspin is turned off and has not started since boot, so the token does not exist yet.
-  SENDSPIN_PAIRING_TOKEN_STATUS_DISABLED = 3;
-  // The Sendspin client failed to start, and will not start until the device reboots.
-  SENDSPIN_PAIRING_TOKEN_STATUS_FAILED = 4;
-}
-
-// Requests the Sendspin pairing token, which a Sendspin server uses to pair with this device
-message SendspinPairingTokenRequest {
-  option (id) = 159;
-  option (source) = SOURCE_CLIENT;
-  option (ifdef) = "USE_SENDSPIN";
-  // Empty
-}
-
-message SendspinPairingTokenResponse {
-  option (id) = 160;
-  option (source) = SOURCE_SERVER;
-  option (ifdef) = "USE_SENDSPIN";
-
-  SendspinPairingTokenStatus status = 1;
-  // The pairing token (Sendspin pairing.md "Pairing Token"). Set only when status is OK.
-  string token = 2 [(max_data_length) = 127];
-}
@@ -48,9 +48,6 @@
 #ifdef USE_ZWAVE_PROXY
 #include "esphome/components/zwave_proxy/zwave_proxy.h"
 #endif
-#if defined(USE_SENDSPIN) && defined(USE_ESP_IDF)
-#include "esphome/components/sendspin/sendspin_hub.h"
-#endif
 #ifdef USE_WATER_HEATER
 #include "esphome/components/water_heater/water_heater.h"
 #endif
@@ -1405,40 +1402,6 @@ void APIConnection::on_z_wave_proxy_request(const ZWaveProxyRequest &msg) {
 }
 #endif

-#if defined(USE_SENDSPIN) && defined(USE_ESP_IDF)
-bool APIConnection::send_sendspin_pairing_token_response_() {
-  SendspinPairingTokenResponse resp;
-#ifdef USE_API_NOISE
-  // has_psk() stands in for "this session proved the key": with a key active, plaintext and zero-key sessions
-  // never reach hello, and activating a key closes every session opened before it.
-  if (!this->parent_->get_noise_ctx().has_psk()) {
-    resp.status = enums::SENDSPIN_PAIRING_TOKEN_STATUS_ENCRYPTION_REQUIRED;
-    return this->send_message(resp);
-  }
-  auto token = sendspin_::global_sendspin_hub->get_pairing_token();
-  if (token.has_value()) {
-    resp.status = enums::SENDSPIN_PAIRING_TOKEN_STATUS_OK;
-    resp.token = StringRef(*token);
-  } else if (sendspin_::global_sendspin_hub->status_has_error()) {
-    resp.status = enums::SENDSPIN_PAIRING_TOKEN_STATUS_FAILED;
-  } else if (sendspin_::global_sendspin_hub->is_disabled()) {
-    resp.status = enums::SENDSPIN_PAIRING_TOKEN_STATUS_DISABLED;
-  } else {
-    resp.status = enums::SENDSPIN_PAIRING_TOKEN_STATUS_NOT_READY;
-  }
-#else
-  resp.status = enums::SENDSPIN_PAIRING_TOKEN_STATUS_ENCRYPTION_REQUIRED;
-#endif
-  return this->send_message(resp);
-}
-
-void APIConnection::on_sendspin_pairing_token_request() {
-  if (!this->send_sendspin_pairing_token_response_()) {
-    this->on_fatal_error();
-  }
-}
-#endif
-
 #ifdef USE_ALARM_CONTROL_PANEL
 bool APIConnection::send_alarm_control_panel_state(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel) {
  return this->send_message_smart_(a_alarm_control_panel, AlarmControlPanelStateResponse::MESSAGE_TYPE,
@@ -1909,7 +1872,7 @@ bool APIConnection::send_hello_response_(const HelloRequest &msg) {

  HelloResponse resp;
  resp.api_version_major = 1;
-  resp.api_version_minor = 19;
+  resp.api_version_minor = 18;
  // Send only the version string - the client only logs this for debugging and doesn't use it otherwise
  resp.server_info = ESPHOME_VERSION_REF;
  resp.name = StringRef(App.get_name());
@@ -2125,10 +2088,6 @@ bool APIConnection::send_device_capabilities_response_() {
 #endif
 #ifdef USE_API_WIZARD
  resp.wizard.configured = true;
-#endif
-#if defined(USE_SENDSPIN) && defined(USE_ESP_IDF)
-  resp.sendspin.feature_flags = sendspin_::global_sendspin_hub->get_feature_flags();
-  resp.sendspin.client_id = sendspin_::global_sendspin_hub->get_client_id();
 #endif
  return this->send_message(resp);
 }
@@ -223,10 +223,6 @@ class APIConnection final : public APIServerConnectionBase {
  void on_z_wave_proxy_request(const ZWaveProxyRequest &msg);
 #endif

-#if defined(USE_SENDSPIN) && defined(USE_ESP_IDF)
-  void on_sendspin_pairing_token_request();
-#endif
-
 #ifdef USE_ALARM_CONTROL_PANEL
  bool send_alarm_control_panel_state(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel);
  void on_alarm_control_panel_command_request(const AlarmControlPanelCommandRequest &msg);
@@ -427,6 +423,9 @@ class APIConnection final : public APIServerConnectionBase {
  bool send_ping_response_();
  bool send_device_info_response_();
  bool send_device_capabilities_response_();
+#ifdef USE_API_WIZARD
+  bool send_device_wizard_response_();
+#endif
 #ifdef USE_API_NOISE
  bool send_noise_encryption_set_key_response_(const NoiseEncryptionSetKeyRequest &msg);
 #endif
@@ -436,9 +435,6 @@ class APIConnection final : public APIServerConnectionBase {
 #ifdef USE_VOICE_ASSISTANT
  bool send_voice_assistant_get_configuration_response_(const VoiceAssistantConfigurationRequest &msg);
 #endif
-#if defined(USE_SENDSPIN) && defined(USE_ESP_IDF)
-  bool send_sendspin_pairing_token_response_();
-#endif

 #ifdef USE_CAMERA
  void try_send_camera_image_();
@@ -122,9 +122,4 @@ extend google.protobuf.FieldOptions {
    // to true when the field arrives, so an all-default submessage can be told apart
    // from an absent one (e.g. a UTC ParsedTimezone, which is all zeros).
    optional bool track_presence = 50020 [default=false];
-
-    // progmem: The pointer_to_buffer bytes field points into flash (PROGMEM).
-    // The generated encode and dump copy it with progmem_memcpy, as ESP8266
-    // cannot read flash with ordinary loads.
-    optional bool progmem = 50021 [default=false];
 }
@@ -152,7 +152,10 @@ void OutgoingConnectionManager::loop(APIServer *server) {

 void OutgoingConnectionManager::try_dial_(APIServer *server, uint32_t now) {
  if (!network::is_connected()) {
-    return;  // still WAITING with the wait elapsed, so the next loop rechecks
+    // Flips within seconds of boot; recheck fast so a deep sleep wake
+    // window is not spent waiting
+    this->schedule_wait_(now, NETWORK_RETRY_MS);
+    return;
  }
  struct sockaddr_storage addr;
  socklen_t addr_len = this->target_sockaddr_(&addr);
@@ -194,6 +197,7 @@ void OutgoingConnectionManager::try_dial_(APIServer *server, uint32_t now) {
  }
  this->state_ = DialState::DIAL_STATE_CONNECTING;
  this->state_ts_ = now;
+  this->last_poll_ = now;
 }

 void OutgoingConnectionManager::poll_connect_(APIServer *server, uint32_t now) {
@@ -202,6 +206,10 @@ void OutgoingConnectionManager::poll_connect_(APIServer *server, uint32_t now) {
    this->schedule_retry_(now);
    return;
  }
+  if (now - this->last_poll_ < CONNECT_POLL_INTERVAL_MS) {
+    return;
+  }
+  this->last_poll_ = now;
  int err = 0;
  switch (socket::poll_connect(*this->dial_socket_, err)) {
    case socket::ConnectPollResult::CONNECT_POLL_RESULT_PENDING:
@@ -59,6 +59,8 @@ class OutgoingConnectionManager {
  static constexpr uint32_t BACKOFF_MIN_MS = 5000;
  static constexpr uint32_t BACKOFF_MAX_MS = 300000;
  static constexpr uint32_t CONNECT_TIMEOUT_MS = 10000;
+  static constexpr uint32_t CONNECT_POLL_INTERVAL_MS = 250;
+  static constexpr uint32_t NETWORK_RETRY_MS = 500;
  static constexpr uint32_t PRECONDITION_RETRY_MS = 5000;
  // A deep sleep wake window is too short to spend on the delay, so those
  // builds dial out as soon as the target is gone
@@ -102,6 +104,7 @@ class OutgoingConnectionManager {
  uint32_t backoff_{BACKOFF_MIN_MS};
  uint32_t wait_{BOOT_WAIT_MS};
  uint32_t state_ts_{0};
+  uint32_t last_poll_{0};

  // Byte-aligned types last
 #ifndef API_OUTGOING_CONNECTION_HOST
@@ -306,21 +306,6 @@ uint32_t WizardCapabilities::calc_size_msg(const void *self) {
  return size;
 }
 #endif
-#ifdef USE_SENDSPIN
-uint8_t *SendspinCapabilities::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
-  const auto &msg = *static_cast<const SendspinCapabilities *>(self);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.feature_flags);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.client_id);
-  return pos;
-}
-uint32_t SendspinCapabilities::calc_size_msg(const void *self) {
-  const auto &msg = *static_cast<const SendspinCapabilities *>(self);
-  uint32_t size = 0;
-  size += ProtoSize::calc_uint32(1, msg.feature_flags);
-  size += !msg.client_id.empty() ? 2 + msg.client_id.size() : 0;
-  return size;
-}
-#endif
 uint8_t *DeviceCapabilitiesResponse::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
  const auto &msg = *static_cast<const DeviceCapabilitiesResponse *>(self);
 #ifdef USE_BLUETOOTH_PROXY
@@ -339,9 +324,6 @@ uint8_t *DeviceCapabilitiesResponse::encode_msg(const void *self, uint8_t *__res
 #endif
 #ifdef USE_API_WIZARD
  pos = ProtoEncode::encode_optional_sub_message(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.wizard);
-#endif
-#ifdef USE_SENDSPIN
-  pos = ProtoEncode::encode_optional_sub_message(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.sendspin);
 #endif
  return pos;
 }
@@ -364,16 +346,13 @@ uint32_t DeviceCapabilitiesResponse::calc_size_msg(const void *self) {
 #endif
 #ifdef USE_API_WIZARD
  size += ProtoSize::calc_message(1, msg.wizard.calculate_size());
-#endif
-#ifdef USE_SENDSPIN
-  size += ProtoSize::calc_message(1, msg.sendspin.calculate_size());
 #endif
  return size;
 }
 #ifdef USE_API_WIZARD
 uint8_t *DeviceWizardResponse::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
  const auto &msg = *static_cast<const DeviceWizardResponse *>(self);
-  pos = ProtoEncode::encode_progmem_bytes(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.data, msg.data_len);
+  pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.data, msg.data_len);
  return pos;
 }
 uint32_t DeviceWizardResponse::calc_size_msg(const void *self) {
@@ -4177,8 +4156,6 @@ uint8_t *UsbDeviceDescriptor::encode_msg(const void *self, uint8_t *__restrict__
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.product_id);
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.bcd_device);
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.interface_number);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.interface_class);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.port_number);
  return pos;
 }
 uint32_t UsbDeviceDescriptor::calc_size_msg(const void *self) {
@@ -4188,8 +4165,6 @@ uint32_t UsbDeviceDescriptor::calc_size_msg(const void *self) {
  size += ProtoSize::calc_uint32(1, msg.product_id);
  size += ProtoSize::calc_uint32(1, msg.bcd_device);
  size += ProtoSize::calc_uint32(1, msg.interface_number);
-  size += ProtoSize::calc_uint32(1, msg.interface_class);
-  size += ProtoSize::calc_uint32(1, msg.port_number);
  return size;
 }
 uint8_t *SerialProxyIdentity::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
@@ -4254,22 +4229,6 @@ uint32_t BluetoothSetConnectionParamsResponse::calc_size_msg(const void *self) {
  return size;
 }
 #endif
-#ifdef USE_SENDSPIN
-uint8_t *SendspinPairingTokenResponse::encode_msg(const void *self,
-                                                  uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
-  const auto &msg = *static_cast<const SendspinPairingTokenResponse *>(self);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(msg.status));
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.token);
-  return pos;
-}
-uint32_t SendspinPairingTokenResponse::calc_size_msg(const void *self) {
-  const auto &msg = *static_cast<const SendspinPairingTokenResponse *>(self);
-  uint32_t size = 0;
-  size += msg.status ? 2 : 0;
-  size += !msg.token.empty() ? 2 + msg.token.size() : 0;
-  return size;
-}
-#endif
 #ifndef HAS_PROTO_MESSAGE_DUMP
 static_assert(!std::is_polymorphic_v<HelloRequest>, "decodable messages carry no vtable");
 static_assert(!std::is_polymorphic_v<DisconnectRequest>, "decodable messages carry no vtable");
@@ -383,15 +383,6 @@ enum SerialProxyIdentityFlag : uint32_t {
  SERIAL_PROXY_IDENTITY_FLAG_CONNECTED = 1,
  SERIAL_PROXY_IDENTITY_FLAG_ERROR = 2,
 };
-#ifdef USE_SENDSPIN
-enum SendspinPairingTokenStatus : uint32_t {
-  SENDSPIN_PAIRING_TOKEN_STATUS_NOT_READY = 0,
-  SENDSPIN_PAIRING_TOKEN_STATUS_OK = 1,
-  SENDSPIN_PAIRING_TOKEN_STATUS_ENCRYPTION_REQUIRED = 2,
-  SENDSPIN_PAIRING_TOKEN_STATUS_DISABLED = 3,
-  SENDSPIN_PAIRING_TOKEN_STATUS_FAILED = 4,
-};
-#endif

 }  // namespace enums

@@ -746,28 +737,10 @@ class WizardCapabilities final : public ProtoMessage {
 protected:
 };
 #endif
-#ifdef USE_SENDSPIN
-class SendspinCapabilities final : public ProtoMessage {
- public:
-  uint32_t feature_flags{0};
-  StringRef client_id{nullptr, 0};  // null until set, encode only
-  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
-    return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
-  }
-  static uint32_t calc_size_msg(const void *self);
-  uint32_t calculate_size() const { return calc_size_msg(this); }
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *dump_to(DumpBuffer &out) const override;
-#endif
-
- protected:
-};
-#endif
 class DeviceCapabilitiesResponse final : public ProtoMessage {
 public:
  static constexpr uint16_t MESSAGE_TYPE = 150;
-  static constexpr uint8_t ESTIMATED_SIZE = 136;
+  static constexpr uint8_t ESTIMATED_SIZE = 119;
 #ifdef HAS_PROTO_MESSAGE_DUMP
  const LogString *message_name() const override { return LOG_STR("device_capabilities_response"); }
 #endif
@@ -785,9 +758,6 @@ class DeviceCapabilitiesResponse final : public ProtoMessage {
 #endif
 #ifdef USE_API_WIZARD
  WizardCapabilities wizard{};
-#endif
-#ifdef USE_SENDSPIN
-  SendspinCapabilities sendspin{};
 #endif
  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -4084,8 +4054,6 @@ class UsbDeviceDescriptor final : public ProtoMessage {
  uint32_t product_id{0};
  uint32_t bcd_device{0};
  uint32_t interface_number{0};
-  uint32_t interface_class{0};
-  uint32_t port_number{0};
  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
    return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -4170,28 +4138,5 @@ class BluetoothSetConnectionParamsResponse final : public ProtoMessage {
 protected:
 };
 #endif
-#ifdef USE_SENDSPIN
-class SendspinPairingTokenResponse final : public ProtoMessage {
- public:
-  static constexpr uint16_t MESSAGE_TYPE = 160;
-  static constexpr uint8_t ESTIMATED_SIZE = 11;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const LogString *message_name() const override { return LOG_STR("sendspin_pairing_token_response"); }
-#endif
-  enums::SendspinPairingTokenStatus status{};
-  StringRef token{nullptr, 0};  // null until set, encode only
-  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
-  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
-    return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
-  }
-  static uint32_t calc_size_msg(const void *self);
-  uint32_t calculate_size() const { return calc_size_msg(this); }
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *dump_to(DumpBuffer &out) const override;
-#endif
-
- protected:
-};
-#endif

 }  // namespace esphome::api
@@ -114,26 +114,15 @@ template<typename T> static void dump_field(DumpBuffer &out, const char *field_n
  out.append("\n");
 }

-// Bytes shown by a bytes field dump: 160 bytes is 480 chars with separators, to fit a typical log buffer
-static constexpr size_t DUMP_BYTES_MAX = 160;
-
 // Helper for bytes fields - uses stack buffer to avoid heap allocation
+// Buffer sized for 160 bytes of data (480 chars with separators) to fit typical log buffer
 // field_name is a PROGMEM pointer (flash on ESP8266, regular pointer on other platforms)
 static void dump_bytes_field(DumpBuffer &out, const char *field_name, const uint8_t *data, size_t len, int indent = 2) {
-  char hex_buf[format_hex_pretty_size(DUMP_BYTES_MAX)];
+  char hex_buf[format_hex_pretty_size(160)];
  append_field_prefix(out, field_name, indent);
  format_hex_pretty_to(hex_buf, data, len);
  out.append(hex_buf).append("\n");
 }
-
-// Helper for bytes fields in flash: copies the shown bytes out with progmem_memcpy first
-static void dump_progmem_bytes_field(DumpBuffer &out, const char *field_name, const uint8_t *data, size_t len,
-                                     int indent = 2) {
-  uint8_t data_buf[DUMP_BYTES_MAX];
-  len = std::min(len, sizeof(data_buf));
-  progmem_memcpy(data_buf, data, len);
-  dump_bytes_field(out, field_name, data_buf, len, indent);
-}
 #pragma GCC diagnostic pop

 template<> const char *proto_enum_to_string<enums::DisconnectReason>(enums::DisconnectReason value) {
@@ -928,25 +917,6 @@ template<> const char *proto_enum_to_string<enums::SerialProxyIdentityFlag>(enum
      return ESPHOME_PSTR("UNKNOWN");
  }
 }
-#ifdef USE_SENDSPIN
-template<>
-const char *proto_enum_to_string<enums::SendspinPairingTokenStatus>(enums::SendspinPairingTokenStatus value) {
-  switch (value) {
-    case enums::SENDSPIN_PAIRING_TOKEN_STATUS_NOT_READY:
-      return ESPHOME_PSTR("SENDSPIN_PAIRING_TOKEN_STATUS_NOT_READY");
-    case enums::SENDSPIN_PAIRING_TOKEN_STATUS_OK:
-      return ESPHOME_PSTR("SENDSPIN_PAIRING_TOKEN_STATUS_OK");
-    case enums::SENDSPIN_PAIRING_TOKEN_STATUS_ENCRYPTION_REQUIRED:
-      return ESPHOME_PSTR("SENDSPIN_PAIRING_TOKEN_STATUS_ENCRYPTION_REQUIRED");
-    case enums::SENDSPIN_PAIRING_TOKEN_STATUS_DISABLED:
-      return ESPHOME_PSTR("SENDSPIN_PAIRING_TOKEN_STATUS_DISABLED");
-    case enums::SENDSPIN_PAIRING_TOKEN_STATUS_FAILED:
-      return ESPHOME_PSTR("SENDSPIN_PAIRING_TOKEN_STATUS_FAILED");
-    default:
-      return ESPHOME_PSTR("UNKNOWN");
-  }
-}
-#endif

 const char *HelloRequest::dump_to(DumpBuffer &out) const {
  MessageDumpHelper helper(out, ESPHOME_PSTR("HelloRequest"));
@@ -1115,14 +1085,6 @@ const char *WizardCapabilities::dump_to(DumpBuffer &out) const {
  return out.c_str();
 }
 #endif
-#ifdef USE_SENDSPIN
-const char *SendspinCapabilities::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, ESPHOME_PSTR("SendspinCapabilities"));
-  dump_field(out, ESPHOME_PSTR("feature_flags"), this->feature_flags);
-  dump_field(out, ESPHOME_PSTR("client_id"), this->client_id);
-  return out.c_str();
-}
-#endif
 const char *DeviceCapabilitiesResponse::dump_to(DumpBuffer &out) const {
  MessageDumpHelper helper(out, ESPHOME_PSTR("DeviceCapabilitiesResponse"));
 #ifdef USE_BLUETOOTH_PROXY
@@ -1151,18 +1113,13 @@ const char *DeviceCapabilitiesResponse::dump_to(DumpBuffer &out) const {
  out.append(2, ' ').append_p(ESPHOME_PSTR("wizard")).append(": ");
  this->wizard.dump_to(out);
  out.append("\n");
-#endif
-#ifdef USE_SENDSPIN
-  out.append(2, ' ').append_p(ESPHOME_PSTR("sendspin")).append(": ");
-  this->sendspin.dump_to(out);
-  out.append("\n");
 #endif
  return out.c_str();
 }
 #ifdef USE_API_WIZARD
 const char *DeviceWizardResponse::dump_to(DumpBuffer &out) const {
  MessageDumpHelper helper(out, ESPHOME_PSTR("DeviceWizardResponse"));
-  dump_progmem_bytes_field(out, ESPHOME_PSTR("data"), this->data, this->data_len);
+  dump_bytes_field(out, ESPHOME_PSTR("data"), this->data, this->data_len);
  return out.c_str();
 }
 #endif
@@ -2943,8 +2900,6 @@ const char *UsbDeviceDescriptor::dump_to(DumpBuffer &out) const {
  dump_field(out, ESPHOME_PSTR("product_id"), this->product_id);
  dump_field(out, ESPHOME_PSTR("bcd_device"), this->bcd_device);
  dump_field(out, ESPHOME_PSTR("interface_number"), this->interface_number);
-  dump_field(out, ESPHOME_PSTR("interface_class"), this->interface_class);
-  dump_field(out, ESPHOME_PSTR("port_number"), this->port_number);
  return out.c_str();
 }
 const char *SerialProxyIdentity::dump_to(DumpBuffer &out) const {
@@ -2978,14 +2933,6 @@ const char *BluetoothSetConnectionParamsResponse::dump_to(DumpBuffer &out) const
  return out.c_str();
 }
 #endif
-#ifdef USE_SENDSPIN
-const char *SendspinPairingTokenResponse::dump_to(DumpBuffer &out) const {
-  MessageDumpHelper helper(out, ESPHOME_PSTR("SendspinPairingTokenResponse"));
-  dump_field(out, ESPHOME_PSTR("status"), static_cast<enums::SendspinPairingTokenStatus>(this->status));
-  dump_field(out, ESPHOME_PSTR("token"), this->token);
-  return out.c_str();
-}
-#endif

 }  // namespace esphome::api

@@ -751,15 +751,6 @@ void APIConnection::read_message_(uint32_t msg_size, uint32_t msg_type, const ui
      this->on_wizard_input_set_request(msg);
      break;
    }
-#endif
-#ifdef USE_SENDSPIN
-    case 159 /* SendspinPairingTokenRequest is empty */: {
-#ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_sendspin_pairing_token_request"));
-#endif
-      this->on_sendspin_pairing_token_request();
-      break;
-    }
 #endif
    default:
      break;
@@ -252,10 +252,6 @@ class APIServerConnectionBase {
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
  void on_bluetooth_set_connection_params_request(const BluetoothSetConnectionParamsRequest &value){};
 #endif
-
-#ifdef USE_SENDSPIN
-  void on_sendspin_pairing_token_request(){};
-#endif
 };

 }  // namespace esphome::api
@@ -13,78 +13,53 @@ namespace esphome::api {

 static const char *const TAG = "api.wizard";

-#ifdef USE_API_WIZARD_INPUTS
-#ifdef USE_API_WIZARD_MULTIPLE_INPUTS
-// Walks the comma separated entity ids in value, without the spaces around each. Returns the length they take joined
-// by ',', or 0 when one is empty or has no '.'. Writes the joined list to out unless it is nullptr.
-static size_t wizard_join_entity_ids(const char *value, size_t length, char *out) {
-  size_t joined = 0;
-  const char *end = value + length;
-  while (true) {
-    const char *comma = static_cast<const char *>(memchr(value, ',', end - value));
-    const char *id_end = comma != nullptr ? comma : end;
-    while (value < id_end && *value == ' ')
-      value++;
-    while (id_end > value && id_end[-1] == ' ')
-      id_end--;
-    size_t id_length = id_end - value;
-    if (id_length == 0 || memchr(value, '.', id_length) == nullptr)
-      return 0;
-    if (joined != 0) {
-      if (out != nullptr)
-        out[joined] = ',';
-      joined++;
-    }
-    if (out != nullptr)
-      memcpy(out + joined, value, id_length);
-    joined += id_length;
-    if (comma == nullptr)
-      return joined;
-    value = comma + 1;
-  }
+uint8_t *wizard_encode_response(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
+  const auto &msg = *static_cast<const DeviceWizardResponse *>(self);
+  if (msg.data_len == 0)
+    return pos;
+  pos = ProtoEncode::encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, 1, 2);  // type 2: Length-delimited
+  pos = ProtoEncode::encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, msg.data_len);
+  PROTO_ENCODE_CHECK_BOUNDS(pos, msg.data_len);
+  progmem_memcpy(pos, msg.data, msg.data_len);
+  return pos + msg.data_len;
 }
-#endif  // USE_API_WIZARD_MULTIPLE_INPUTS

+#ifdef USE_API_WIZARD_INPUTS
 static bool wizard_entity_id_valid(const char *entity_id, size_t length) {
  return length > 0 && length < WIZARD_ENTITY_ID_BUFFER_SIZE && memchr(entity_id, '.', length) != nullptr;
 }

 const char *wizard_set_input(const WizardInputSetRequest &msg) {
-  const char *value = msg.entity_id.c_str();
-  const size_t length = msg.entity_id.size();
+  if (!wizard_entity_id_valid(msg.entity_id.c_str(), msg.entity_id.size())) {
+    ESP_LOGW(TAG, "Ignoring an invalid entity id for wizard input");
+    return nullptr;
+  }
  for (size_t i = 0; i < API_WIZARD_INPUT_COUNT; i++) {
    // The table is in flash, which ESP8266 can only read through progmem_memcpy
    WizardInputEntry entry;
    progmem_memcpy(&entry, &API_WIZARD_INPUTS[i], sizeof(entry));
    if (entry.key != msg.key)
      continue;
-#ifdef USE_API_WIZARD_MULTIPLE_INPUTS
-    if (entry.size != 0) {
-      // Two passes, validate and measure then write, so a rejected request leaves the buffer unchanged
-      const size_t joined = wizard_join_entity_ids(value, length, nullptr);
-      if (joined == 0 || joined >= entry.size)
-        break;
-      wizard_join_entity_ids(value, length, entry.entity_id);
-      entry.entity_id[joined] = '\0';
-      return entry.entity_id;
-    }
-#endif
-    if (!wizard_entity_id_valid(value, length))
-      break;
-    memcpy(entry.entity_id, value, length);
-    entry.entity_id[length] = '\0';
+    memcpy(entry.entity_id, msg.entity_id.c_str(), msg.entity_id.size());
+    entry.entity_id[msg.entity_id.size()] = '\0';
    return entry.entity_id;
  }
-  ESP_LOGW(TAG, "Ignoring an entity id for an unknown wizard input, or one that is not valid");
+  ESP_LOGW(TAG, "Ignoring an entity id for an unknown wizard input");
  return nullptr;
 }
 #endif  // USE_API_WIZARD_INPUTS

-void APIConnection::on_device_wizard_request() {
+bool APIConnection::send_device_wizard_response_() {
  DeviceWizardResponse resp;
  resp.data = API_WIZARD_DATA;
  resp.data_len = API_WIZARD_DATA_SIZE;
-  if (!this->send_message(resp)) {
+  // Not send_message: the data is in flash, so wizard_encode_response copies it out
+  return this->send_message_(DeviceWizardResponse::calc_size_msg(&resp), DeviceWizardResponse::MESSAGE_TYPE,
+                             &wizard_encode_response, &resp);
+}
+
+void APIConnection::on_device_wizard_request() {
+  if (!this->send_device_wizard_response_()) {
    this->on_fatal_error();
  }
 }
@@ -6,9 +6,6 @@

 #include <cstddef>
 #include <cstdint>
-#ifdef USE_API_WIZARD_MULTIPLE_INPUTS
-#include <cstring>
-#endif

 #include "esphome/core/hal.h"
 #include "proto.h"
@@ -25,14 +22,15 @@ static constexpr size_t WIZARD_ENTITY_ID_BUFFER_SIZE = 256;
 /// (components/api/wizard.py) and kept in flash. API_WIZARD_DATA_SIZE bytes long.
 extern const uint8_t API_WIZARD_DATA[] PROGMEM;

+/// Encodes a DeviceWizardResponse like the generated encoder would. The data is in flash, which ESP8266 can only read
+/// with progmem_memcpy, so the generated encoder (a plain memcpy) cannot be used. Plain memcpy elsewhere.
+uint8_t *wizard_encode_response(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
+
 #ifdef USE_API_WIZARD_INPUTS
 /// Where the entity id of an input is kept, found by the key the client uses for it.
 struct WizardInputEntry {
  uint32_t key;     // FNV-1 hash of the ESPHome id of the input
-  char *entity_id;  // RAM buffer, WIZARD_ENTITY_ID_BUFFER_SIZE bytes or size, shared with the homeassistant entity
-#ifdef USE_API_WIZARD_MULTIPLE_INPUTS
-  uint16_t size;  // Buffer size of a multiple input, 0 for a single input
-#endif
+  char *entity_id;  // RAM buffer of WIZARD_ENTITY_ID_BUFFER_SIZE bytes, shared with the homeassistant entity
 };

 /// The inputs of the wizard, in flash. API_WIZARD_INPUT_COUNT entries long.
@@ -50,34 +48,9 @@ const char *wizard_set_input(const WizardInputSetRequest &msg);
 class WizardInput {
 public:
  explicit WizardInput(const char *entity_id) : entity_id_(entity_id) {}
-  /// The Home Assistant entity ID, empty until the wizard sets one. For a multiple input this is the whole
-  /// comma separated list, which homeassistant.action data can use as it is.
+  /// The Home Assistant entity ID, empty until the wizard sets one.
  StringRef entity_id() const { return StringRef(this->entity_id_); }
  bool has_entity_id() const { return this->entity_id_[0] != '\0'; }
-#ifdef USE_API_WIZARD_MULTIPLE_INPUTS
-  /// The number of entity IDs in the list, 0 until the wizard sets one.
-  size_t entity_id_count() const {
-    if (!this->has_entity_id())
-      return 0;
-    size_t count = 1;
-    for (const char *p = this->entity_id_; (p = strchr(p, ',')) != nullptr; p++)
-      count++;
-    return count;
-  }
-  /// Call callback(StringRef) for each entity ID in the list, in order. The StringRef points into the list and is
-  /// not null terminated, so print it with "%.*s".
-  template<typename F> void for_each_entity_id(F &&callback) const {
-    // The device stores the list without spaces or empty entries
-    const char *start = this->entity_id_;
-    while (*start != '\0') {
-      const char *end = strchr(start, ',');
-      if (end == nullptr)
-        end = start + strlen(start);
-      callback(StringRef(start, end - start));
-      start = *end == ',' ? end + 1 : end;
-    }
-  }
-#endif

 protected:
  const char *entity_id_;
@@ -3,7 +3,6 @@
 #include "api_pb2_defines.h"
 #include "api_buffer.h"
 #include "esphome/core/component.h"
-#include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/progmem.h"
@@ -466,21 +465,6 @@ class ProtoEncode {
                                                          uint32_t field_id, const uint8_t *data, size_t len) {
    return encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, reinterpret_cast<const char *>(data), len);
  }
-  /// encode_bytes for data in flash (PROGMEM), which ESP8266 can only read with progmem_memcpy.
-  [[nodiscard]] static inline uint8_t *encode_progmem_bytes(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                            uint32_t field_id, const uint8_t *data, size_t len) {
-    if (len == 0)
-      return pos;
-    return encode_progmem_bytes_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, data, len);
-  }
-  [[nodiscard]] static inline uint8_t *encode_progmem_bytes_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
-                                                                  uint32_t field_id, const uint8_t *data, size_t len) {
-    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 2);  // type 2: Length-delimited
-    pos = encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, len);
-    PROTO_ENCODE_CHECK_BOUNDS(pos, len);
-    progmem_memcpy(pos, data, len);
-    return pos + len;
-  }
  [[nodiscard]] static inline uint8_t *encode_uint32_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
                                                           uint32_t field_id, uint32_t value) {
    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
@@ -6,6 +6,7 @@ Home Assistant shows the wizard when the device is added. See api_wizard.h for t
 from collections.abc import Callable
 import importlib
 import json
+from types import ModuleType
 from typing import Any

 from esphome import automation
@@ -19,8 +20,6 @@ from esphome.const import (
    CONF_ENTITY_ID,
    CONF_ID,
    CONF_INTERNAL,
-    CONF_MAX_LENGTH,
-    CONF_MULTIPLE,
    CONF_NAME,
    CONF_PAGES,
    CONF_PLATFORM,
@@ -28,12 +27,7 @@ from esphome.const import (
 )
 from esphome.core import CORE, ID
 import esphome.final_validate as fv
-from esphome.helpers import (
-    fnv1_hash,
-    fnv1_hash_object_id,
-    fnv1a_32bit_hash,
-    zstd_module,
-)
+from esphome.helpers import fnv1_hash, fnv1_hash_object_id, fnv1a_32bit_hash
 from esphome.types import ConfigType

 API_DOMAIN = "api"
@@ -52,10 +46,6 @@ WizardInput = _API.class_("WizardInput")
 WIZARD_ENTITY_ID_BUFFER_SIZE = (
    256  # api_wizard.h; Home Assistant entity IDs are at most 255 bytes
 )
-WIZARD_ENTITY_ID_MAX_LENGTH = WIZARD_ENTITY_ID_BUFFER_SIZE - 1
-# The value of a multiple input fits one WizardInputSetRequest, which the device accepts up to 8 KiB on ESP8266;
-# api.proto max_data_length documents the same value
-WIZARD_MULTIPLE_MAX_LENGTH = 4095
 # One API message must fit APIBuffer::MAX_SIZE (65535) together with the largest frame header (7 bytes,
 # Noise) and footer (16 bytes, Noise MAC)
 WIZARD_RESPONSE_MAX_SIZE = 65535 - 7 - 16
@@ -111,21 +101,6 @@ WIZARD_ENTITY_SCHEMA = cv.Schema(
 )


-def _validate_multiple(conf: ConfigType) -> ConfigType:
-    if conf[CONF_MULTIPLE] and CONF_ENTITY in conf:
-        raise cv.Invalid(
-            "A linked input follows the state of exactly one Home Assistant entity, so multiple "
-            "is only for standalone inputs (id)",
-            path=[CONF_MULTIPLE],
-        )
-    if CONF_MAX_LENGTH in conf and not conf[CONF_MULTIPLE]:
-        raise cv.Invalid(
-            "max_length only applies to an input with multiple: true",
-            path=[CONF_MAX_LENGTH],
-        )
-    return conf
-
-
 # An input is either standalone (id declares a new WizardInput) or linked to a homeassistant entity that has no
 # entity_id of its own: Home Assistant sets it
 WIZARD_INPUT_SCHEMA = cv.All(
@@ -134,10 +109,6 @@ WIZARD_INPUT_SCHEMA = cv.All(
            cv.Optional(CONF_ID): cv.declare_id(WizardInput),
            cv.Optional(CONF_ENTITY): cv.use_id(cg.EntityBase),
            cv.Optional(CONF_DESCRIPTION): _wizard_text(WIZARD_DESCRIPTION_MAX_LENGTH),
-            cv.Optional(CONF_MULTIPLE, default=False): cv.boolean,
-            cv.Optional(CONF_MAX_LENGTH): cv.int_range(
-                min=WIZARD_ENTITY_ID_MAX_LENGTH, max=WIZARD_MULTIPLE_MAX_LENGTH
-            ),
            cv.Optional(CONF_TARGET): cv.Schema(
                {
                    cv.Required(CONF_ENTITY): cv.All(
@@ -148,7 +119,6 @@ WIZARD_INPUT_SCHEMA = cv.All(
        }
    ),
    cv.has_exactly_one_key(CONF_ID, CONF_ENTITY),
-    _validate_multiple,
 )

 WIZARD_PAGE_SCHEMA = cv.All(
@@ -273,8 +243,6 @@ def _wizard_defines(wizard: ConfigType) -> set[str]:
        defines.add("USE_API_WIZARD_LINKED_INPUTS")
    if any(CONF_ID in conf for conf in inputs):
        defines.add("USE_API_WIZARD_STANDALONE_INPUTS")
-    if any(conf.get(CONF_MULTIPLE) for conf in inputs):
-        defines.add("USE_API_WIZARD_MULTIPLE_INPUTS")
    return defines


@@ -383,6 +351,14 @@ automation.register_apply_condition(
 )


+def zstd_module() -> ModuleType:
+    """The zstd module: the standard library one from Python 3.14, otherwise the backport."""
+    try:
+        return importlib.import_module("compression.zstd")
+    except ImportError:
+        return importlib.import_module("backports.zstd")
+
+
 def _entity_document(conf: ConfigType, config: fv.FinalValidateConfig) -> ConfigType:
    """An entity of the device that the page shows, keyed as ListEntitiesResponse keys it."""
    _, declaration = _wizard_input_declaration(config, conf[CONF_ID])
@@ -398,10 +374,6 @@ def _input_document(conf: ConfigType, config: fv.FinalValidateConfig) -> ConfigT
    document: ConfigType = {"key": fnv1_hash(_wizard_input_id(conf).id)}
    if description := conf.get(CONF_DESCRIPTION):
        document[CONF_DESCRIPTION] = description
-    if conf.get(CONF_MULTIPLE):
-        document["multiple"] = True
-    if (max_length := conf.get(CONF_MAX_LENGTH)) is not None:
-        document["max_length"] = max_length
    if filters := _wizard_input_filters(conf, config):
        document["entity_filters"] = [dict(entity_filter) for entity_filter in filters]
    return document
@@ -415,7 +387,7 @@ def wizard_document(wizard: ConfigType, config: fv.FinalValidateConfig) -> Confi
        {"version": 1,
         "pages": [{"title": "...", "description": "...",
           "entities": [{"key": 123, "device_id": 456, "description": "..."}],
-           "inputs": [{"key": 789, "description": "...", "multiple": true, "max_length": 1023,
+           "inputs": [{"key": 789, "description": "...",
             "entity_filters": [{"integration": "...", "domain": ["..."],
                                 "device_class": ["..."], "supported_features": ["..."]}]}]}]}

@@ -427,14 +399,6 @@ def wizard_document(wizard: ConfigType, config: fv.FinalValidateConfig) -> Confi
      the device it belongs to (esphome/core/config.py), and is left out for the main device.
    - An input key is the FNV-1 hash of the ESPHome id of the input, or of the linked entity. A linked
      entity must not set entity_id, as that is a static entry kept apart from the ones the wizard sets.
-    - multiple means the user may pick several entities. The client sends them in one
-      WizardInputSetRequest as a comma separated list ("calendar.a,calendar.b") with no spaces; the
-      device trims spaces around each id and stores the list without them. The whole request is
-      ignored when any id is empty or has no '.', or when the list without spaces does not fit
-      max_length (only on a multiple input, 255 when left out). A single input is ignored when the id
-      is empty, longer than 255 bytes or has no '.'. The version stays 1: a client that does not know
-      multiple ignores it, shows a single picker and sends one entity id, which a multiple input
-      accepts.
    - entity_filters are the filters of the input, or the default filters of a linked switch,
      number, text, select or button.
    """
@@ -480,15 +444,14 @@ async def to_code(wizard: ConfigType) -> None:
        input_id = _wizard_input_id(conf)
        # Every buffer starts empty, until the wizard sets it. A linked homeassistant entity uses it as its entity id.
        buffer = _wizard_buffer_name(input_id)
-        size = conf.get(CONF_MAX_LENGTH, WIZARD_ENTITY_ID_MAX_LENGTH) + 1
-        cg.add_global(cg.RawStatement(f'static char {buffer}[{size}] = "";'))
+        cg.add_global(
+            cg.RawStatement(
+                f'static char {buffer}[{WIZARD_ENTITY_ID_BUFFER_SIZE}] = "";'
+            )
+        )
        if CONF_ID in conf:
            cg.new_Pvariable(input_id, cg.RawExpression(buffer))
-        key = fnv1_hash(input_id.id)
-        if conf[CONF_MULTIPLE]:
-            entries.append(cg.RawExpression(f"{{{key}u, {buffer}, {size}}}"))
-        else:
-            entries.append(cg.RawExpression(f"{{{key}u, {buffer}}}"))
+        entries.append(cg.RawExpression(f"{{{fnv1_hash(input_id.id)}u, {buffer}}}"))
    if entries:
        cg.extern_progmem_array(
            "esphome::api::API_WIZARD_INPUTS",
@@ -391,7 +391,7 @@ async def to_code(config: ConfigType) -> None:
    # Adds a define and IDF component for legacy `audio_decoder.cpp`.
    if data.flac_support:
        cg.add_define("USE_AUDIO_FLAC_SUPPORT")
-        add_idf_component(name="esphome/micro-flac", ref="0.3.0")
+        add_idf_component(name="esphome/micro-flac", ref="0.2.0")
        _emit_memory_pair(
            data.flac.buffer_memory,
            "CONFIG_MICRO_FLAC_PREFER_PSRAM",
@@ -20,7 +20,7 @@ constexpr uint8_t bl0906_checksum(const uint8_t address, const DataPacket *data)

 void BL0906::loop() {
  while (this->available())
-    this->read();
+    this->flush();

  if (this->current_stage_ == STAGE_IDLE) {
    // Woken up between cycles to drain the action queue. Go back to sleep.
@@ -92,7 +92,7 @@ void BL0906::advance_stage_() {

 void BL0906::setup() {
  while (this->available())
-    this->read();
+    this->flush();
  this->write_array(USR_WRPROT_WITABLE, sizeof(USR_WRPROT_WITABLE));
  // Calibration (1: register address; 2: value before calibration; 3: value after calibration)
  this->bias_correction_(BL0906_RMSOS_1, 0.01600, 0);  // Calibration current_1
@@ -382,7 +382,7 @@ void BluedroidGattClient::set_disconnecting_() {

 esp_err_t BluedroidGattClient::update_conn_params_(uint16_t min_interval, uint16_t max_interval, uint16_t latency,
                                                   uint16_t timeout, const char *param_type) {
-  esp_ble_conn_update_params_t conn_params = {};
+  esp_ble_conn_update_params_t conn_params = {{0}};
  memcpy(conn_params.bda, this->remote_bda_, sizeof(esp_bd_addr_t));
  conn_params.min_int = min_interval;
  conn_params.max_int = max_interval;
@@ -19,9 +19,6 @@ CONF_REMOTE_TRANSMISSION_REQUEST = "remote_transmission_request"
 CONF_CANBUS_ID = "canbus_id"
 CONF_BIT_RATE = "bit_rate"
 CONF_ON_FRAME = "on_frame"
-CONF_MAX_FRAMES_PER_LOOP = "max_frames_per_loop"
-DEFAULT_MAX_FRAMES_PER_LOOP = 50  # Keep in sync with max_frames_per_loop_ in canbus.h
-DEFAULT_BIT_RATE = "125KBPS"  # Keep in sync with bit_rate_ in canbus.h


 def validate_id(config: ConfigType) -> ConfigType:
@@ -89,13 +86,8 @@ CANBUS_SCHEMA = cv.Schema(
    {
        cv.GenerateID(): cv.declare_id(CanbusComponent),
        cv.Required(CONF_CAN_ID): cv.int_range(min=0, max=0x1FFFFFFF),
-        cv.Optional(CONF_BIT_RATE, default=DEFAULT_BIT_RATE): cv.enum(
-            CAN_SPEEDS, upper=True
-        ),
+        cv.Optional(CONF_BIT_RATE, default="125KBPS"): cv.enum(CAN_SPEEDS, upper=True),
        cv.Optional(CONF_USE_EXTENDED_ID, default=False): cv.boolean,
-        cv.Optional(
-            CONF_MAX_FRAMES_PER_LOOP, default=DEFAULT_MAX_FRAMES_PER_LOOP
-        ): cv.positive_not_null_int,
        cv.Optional(CONF_ON_FRAME): automation.validate_automation(
            {
                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(CanbusTrigger),
@@ -116,13 +108,9 @@ CANBUS_SCHEMA.add_extra(validate_id)

 async def setup_canbus_core_(var: MockObj, config: ConfigType) -> None:
    await cg.register_component(var, config)
-    cg.add(var.set_can_id(config[CONF_CAN_ID]))
-    if config[CONF_USE_EXTENDED_ID]:
-        cg.add(var.set_use_extended_id(True))
-    if (bit_rate := config[CONF_BIT_RATE]) != DEFAULT_BIT_RATE:
-        cg.add(var.set_bitrate(CAN_SPEEDS[bit_rate]))
-    if (max_frames := config[CONF_MAX_FRAMES_PER_LOOP]) != DEFAULT_MAX_FRAMES_PER_LOOP:
-        cg.add(var.set_max_frames_per_loop(max_frames))
+    cg.add(var.set_can_id([config[CONF_CAN_ID]]))
+    cg.add(var.set_use_extended_id([config[CONF_USE_EXTENDED_ID]]))
+    cg.add(var.set_bitrate(CAN_SPEEDS[config[CONF_BIT_RATE]]))

    for conf in config.get(CONF_ON_FRAME, []):
        can_id = conf[CONF_CAN_ID]
@@ -67,18 +67,16 @@ void Canbus::add_trigger(CanbusTrigger *trigger) {

 void Canbus::loop() {
  struct CanFrame can_message;
-  uint32_t message_counter = 0;
-  for (; message_counter < this->max_frames_per_loop_; message_counter++) {
-    if (this->read_message(&can_message) != canbus::ERROR_OK) {
-      break;
-    }
-
+  // read all messages until queue is empty
+  int message_counter = 0;
+  while (this->read_message(&can_message) == canbus::ERROR_OK) {
+    message_counter++;
    if (can_message.use_extended_id) {
-      ESP_LOGD(TAG, "received can message (#%" PRIu32 ") extended can_id=0x%" PRIx32 " size=%d", message_counter + 1,
+      ESP_LOGD(TAG, "received can message (#%d) extended can_id=0x%" PRIx32 " size=%d", message_counter,
               can_message.can_id, can_message.can_data_length_code);
    } else {
-      ESP_LOGD(TAG, "received can message (#%" PRIu32 ") std can_id=0x%" PRIx32 " size=%d", message_counter + 1,
-               can_message.can_id, can_message.can_data_length_code);
+      ESP_LOGD(TAG, "received can message (#%d) std can_id=0x%" PRIx32 " size=%d", message_counter, can_message.can_id,
+               can_message.can_data_length_code);
    }

    std::vector<uint8_t> data;
@@ -102,12 +100,6 @@ void Canbus::loop() {
      }
    }
  }
-
-  if (message_counter == this->max_frames_per_loop_) {
-    ESP_LOGW(TAG,
-             "Reached max_frames_per_loop=%" PRIu32 ", deferring remaining CAN frames. Some frames might be dropped",
-             this->max_frames_per_loop_);
-  }
 }

 }  // namespace esphome::canbus
@@ -78,7 +78,6 @@ class Canbus : public Component {
  void set_can_id(uint32_t can_id) { this->can_id_ = can_id; }
  void set_use_extended_id(bool use_extended_id) { this->use_extended_id_ = use_extended_id; }
  void set_bitrate(CanSpeed bit_rate) { this->bit_rate_ = bit_rate; }
-  void set_max_frames_per_loop(uint32_t max_frames_per_loop) { this->max_frames_per_loop_ = max_frames_per_loop; }

  void add_trigger(CanbusTrigger *trigger);
  /**
@@ -97,9 +96,8 @@ class Canbus : public Component {
  template<typename... Ts> friend class CanbusSendAction;
  std::vector<CanbusTrigger *> triggers_{};
  uint32_t can_id_;
-  uint32_t max_frames_per_loop_{50};  // Keep in sync with DEFAULT_MAX_FRAMES_PER_LOOP in __init__.py
-  CanSpeed bit_rate_{CAN_125KBPS};    // Keep in sync with DEFAULT_BIT_RATE in __init__.py
-  bool use_extended_id_{false};
+  bool use_extended_id_;
+  CanSpeed bit_rate_;
  CallbackManager<void(uint32_t can_id, bool extended_id, bool rtr, const std::vector<uint8_t> &data)>
      callback_manager_{};

@@ -13,7 +13,6 @@ from esphome.const import (
    CONF_VALUE,
    CONF_WAIT_TIME,
 )
-from esphome.core import ID

 CODEOWNERS = ["@lygris", "@gabest11"]
 DEPENDENCIES = ["spi"]
@@ -384,7 +383,10 @@ def validate_raw_data(value):
 SEND_PACKET_ACTION_SCHEMA = cv.maybe_simple_value(
    {
        cv.GenerateID(): cv.use_id(CC1101Component),
-        cv.Required(CONF_DATA): cv.templatable(validate_raw_data),
+        # TX FIFO size
+        cv.Required(CONF_DATA): cv.templatable(
+            cv.All(validate_raw_data, cv.Length(max=64))
+        ),
    },
    key=CONF_DATA,
 )
@@ -399,17 +401,13 @@ SEND_PACKET_ACTION_SCHEMA = cv.maybe_simple_value(
 async def send_packet_action_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])
-    data = config[CONF_DATA]
-    if isinstance(data, bytes):
-        data = list(data)
-    if cg.is_template(data):
-        templ = await cg.templatable(data, args, cg.std_vector.template(cg.uint8))
-        cg.add(var.set_data_template(templ))
-    else:
-        # Generate static array in flash to avoid RAM copy
-        arr_id = ID(f"{action_id}_data", is_declaration=True, type=cg.uint8)
-        arr = cg.static_const_array(arr_id, cg.ArrayInitializer(*data))
-        cg.add(var.set_data_static(arr, len(data)))
+    await automation.templatable_bytes(
+        config[CONF_DATA],
+        args,
+        var.set_data_template,
+        var.set_data_static,
+        "cc1101_data",
+    )
    return var


@@ -3,10 +3,16 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include <cmath>
+#include <cstring>
+
+#ifdef USE_ESP32
+#include <esp_memory_utils.h>
+#endif

 namespace esphome::cc1101 {

 static const char *const TAG = "cc1101";
+static constexpr size_t TX_FIFO_SIZE = 64;

 static void split_float(float value, int mbits, uint8_t &e, uint32_t &m) {
  int e_tmp;
@@ -253,17 +259,11 @@ void CC1101Component::dump_config() {
 }

 void CC1101Component::begin_tx() {
-  // Read the mode before the PKTCTRL0 write below overwrites it in state_
-  const bool packet_mode = this->state_.PKT_FORMAT == static_cast<uint8_t>(PacketFormat::PACKET_FORMAT_FIFO);
  // Ensure Packet Format is 3 (Async Serial)
  this->write_(Register::PKTCTRL0, 0x32);
  ESP_LOGV(TAG, "Beginning TX sequence");
  if (this->gdo0_pin_ != nullptr) {
-    // setup() only attaches the interrupt in packet mode. In async serial mode the pin may be
-    // shared with remote_receiver, and detaching here would remove the receiver's interrupt.
-    if (packet_mode) {
-      this->gdo0_pin_->detach_interrupt();
-    }
+    this->gdo0_pin_->detach_interrupt();
    this->gdo0_pin_->pin_mode(gpio::FLAG_OUTPUT);
  }
  // Transition through IDLE to bypass CCA (Clear Channel Assessment) which can
@@ -385,18 +385,32 @@ void CC1101Component::read_(Register reg, uint8_t *buffer, size_t length) {
  this->disable();
 }

-CC1101Error CC1101Component::transmit_packet(const std::vector<uint8_t> &packet) {
+CC1101Error CC1101Component::transmit_packet(const uint8_t *data, size_t len) {
  if (this->state_.PKT_FORMAT != static_cast<uint8_t>(PacketFormat::PACKET_FORMAT_FIFO)) {
    return CC1101Error::PARAMS;
  }
+  const bool variable = this->state_.LENGTH_CONFIG == static_cast<uint8_t>(LengthConfig::LENGTH_CONFIG_VARIABLE);
+  // In variable length mode the FIFO also holds the length byte
+  if (len + (variable ? 1 : 0) > TX_FIFO_SIZE) {
+    ESP_LOGE(TAG, "Packet of %u bytes does not fit the TX FIFO", static_cast<unsigned>(len));
+    return CC1101Error::PARAMS;
+  }

  // Write packet
  this->enter_idle_();
  this->strobe_(Command::FTX);
-  if (this->state_.LENGTH_CONFIG == static_cast<uint8_t>(LengthConfig::LENGTH_CONFIG_VARIABLE)) {
-    this->write_(Register::FIFO, static_cast<uint8_t>(packet.size()));
+  if (variable) {
+    this->write_(Register::FIFO, static_cast<uint8_t>(len));
  }
-  this->write_(Register::FIFO, packet.data(), packet.size());
+#ifdef USE_ESP32
+  // SPI DMA cannot read flash or unaligned buffers; stage them here so the driver does not allocate a copy
+  alignas(4) uint8_t staged[TX_FIFO_SIZE];
+  if (len != 0 && (!esp_ptr_dma_capable(data) || (reinterpret_cast<uintptr_t>(data) & 3) != 0)) {
+    std::memcpy(staged, data, len);
+    data = staged;
+  }
+#endif
+  this->write_(Register::FIFO, data, len);

  // Calibrate PLL
  if (!this->enter_calibrated_(State::FSTXON, Command::FSTXON)) {
@@ -89,7 +89,10 @@ class CC1101Component final : public Component,
  void set_whitening(bool value);

  // Packet mode operations
-  CC1101Error transmit_packet(const std::vector<uint8_t> &packet);
+  CC1101Error transmit_packet(const std::vector<uint8_t> &packet) {
+    return this->transmit_packet(packet.data(), packet.size());
+  }
+  CC1101Error transmit_packet(const uint8_t *data, size_t len);
  void register_listener(CC1101Listener *listener) { this->listeners_.push_back(listener); }
  Trigger<std::vector<uint8_t>, float, float, uint8_t> *get_packet_trigger() { return &this->packet_trigger_; }

@@ -131,27 +134,11 @@ class CC1101Component final : public Component,

 // Action Wrappers
 template<typename... Ts> class SendPacketAction final : public Action<Ts...>, public Parented<CC1101Component> {
- public:
-  void set_data_template(std::function<std::vector<uint8_t>(Ts...)> func) { this->data_func_ = func; }
-  void set_data_static(const uint8_t *data, size_t len) {
-    this->data_static_ = data;
-    this->data_static_len_ = len;
-  }
+  TEMPLATABLE_BYTES(data)

  void play(const Ts &...x) override {
-    if (this->data_func_) {
-      auto data = this->data_func_(x...);
-      this->parent_->transmit_packet(data);
-    } else if (this->data_static_ != nullptr) {
-      std::vector<uint8_t> data(this->data_static_, this->data_static_ + this->data_static_len_);
-      this->parent_->transmit_packet(data);
-    }
+    this->data_.visit([this](const uint8_t *data, size_t len) { this->parent_->transmit_packet(data, len); }, x...);
  }
-
- protected:
-  std::function<std::vector<uint8_t>(Ts...)> data_func_{};
-  const uint8_t *data_static_{nullptr};
-  size_t data_static_len_{0};
 };

 }  // namespace esphome::cc1101
@@ -1,3 +1,5 @@
+import logging
+
 import esphome.codegen as cg
 from esphome.components import sensor
 import esphome.config_validation as cv
@@ -16,6 +18,8 @@ from esphome.const import (
 from esphome.core.entity_helpers import inherit_property_from
 from esphome.types import ConfigType

+_LOGGER = logging.getLogger(__name__)
+
 CODEOWNERS = ["@Cat-Ion", "@kahrendt"]

 combination_ns = cg.esphome_ns.namespace("combination")
@@ -71,19 +75,33 @@ KALMAN_SOURCE_SCHEMA = cv.Schema(
 )


+def _migrate_coeffecient(config: ConfigType) -> ConfigType:
+    """Migrate deprecated 'coeffecient' spelling to 'coefficient'."""
+    if CONF_COEFFECIENT in config:
+        if CONF_COEFFICIENT in config:
+            raise cv.Invalid(
+                f"Cannot specify both '{CONF_COEFFICIENT}' and '{CONF_COEFFECIENT}'"
+            )
+        _LOGGER.warning(
+            "'%s' is deprecated, use '%s' instead. Will be removed in 2026.12.0",
+            CONF_COEFFECIENT,
+            CONF_COEFFICIENT,
+        )
+        config[CONF_COEFFICIENT] = config.pop(CONF_COEFFECIENT)
+    elif CONF_COEFFICIENT not in config:
+        raise cv.Invalid(f"'{CONF_COEFFICIENT}' is a required option")
+    return config
+
+
 LINEAR_SOURCE_SCHEMA = cv.All(
-    cv.rename_key(
-        CONF_COEFFECIENT,
-        CONF_COEFFICIENT,
-        removed_in="2026.12.0",
-        component="combination",
-    ),
    cv.Schema(
        {
            cv.Required(CONF_SOURCE): cv.use_id(sensor.Sensor),
-            cv.Required(CONF_COEFFICIENT): cv.templatable(cv.float_),
+            cv.Optional(CONF_COEFFICIENT): cv.templatable(cv.float_),
+            cv.Optional(CONF_COEFFECIENT): cv.templatable(cv.float_),
        }
    ),
+    _migrate_coeffecient,
 )

 SENSOR_ONLY_SOURCE_SCHEMA = cv.Schema(
@@ -34,15 +34,6 @@ void DebugComponent::dump_config() {
  this->free_heap_ = get_free_heap_();
  ESP_LOGD(TAG, "Free Heap Size: %" PRIu32 " bytes", this->free_heap_);

-  uint32_t uptime = static_cast<uint32_t>(millis_64() / 1000);
-  uint32_t days = uptime / 86400;
-  uptime -= days * 86400;
-  uint32_t hours = uptime / 3600;
-  uptime -= hours * 3600;
-  uint32_t minutes = uptime / 60;
-  uptime -= minutes * 60;
-  ESP_LOGD(TAG, "Uptime: %" PRIu32 "d %02" PRIu32 "h %02" PRIu32 "m %02" PRIu32 "s", days, hours, minutes, uptime);
-
  pos = get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>(device_info_buffer), pos);

 #ifdef USE_TEXT_SENSOR
@@ -208,7 +208,6 @@ def _final_validate(config) -> None:
        else:
            # If no drawing methods are configured, and LVGL is not enabled, show a test card
            config[CONF_SHOW_TEST_CARD] = True
-            config[CONF_UPDATE_INTERVAL] = update_interval("1min")
    elif CONF_UPDATE_INTERVAL not in config:
        config[CONF_UPDATE_INTERVAL] = update_interval("1min")

@@ -1099,7 +1099,7 @@ ARDUINO_PLATFORM_VERSION_LOOKUP = {
 # See: https://github.com/pioarduino/esp-idf/releases
 ARDUINO_IDF_VERSION_LOOKUP = {
    cv.Version(4, 0, 0, "alpha1"): cv.Version(6, 0, 1),
-    cv.Version(3, 3, 12): cv.Version(5, 5, 6),
+    cv.Version(3, 3, 12): cv.Version(5, 5, 5),
    cv.Version(3, 3, 11): cv.Version(5, 5, 5),
    cv.Version(3, 3, 10): cv.Version(5, 5, 5),
    cv.Version(3, 3, 9): cv.Version(5, 5, 4),
@@ -1123,9 +1123,9 @@ ARDUINO_IDF_VERSION_LOOKUP = {
 # The default/recommended esp-idf framework version
 #  - https://github.com/espressif/esp-idf/releases
 ESP_IDF_FRAMEWORK_VERSION_LOOKUP = {
-    "recommended": cv.Version(5, 5, 6),
-    "latest": cv.Version(5, 5, 6),
-    "dev": cv.Version(5, 5, 6),
+    "recommended": cv.Version(5, 5, 5),
+    "latest": cv.Version(5, 5, 5),
+    "dev": cv.Version(5, 5, 5),
 }

 ESP_IDF_PLATFORM_VERSION_LOOKUP = {
@@ -1135,7 +1135,6 @@ ESP_IDF_PLATFORM_VERSION_LOOKUP = {
    cv.Version(
        6, 0, 0
    ): "https://github.com/pioarduino/platform-espressif32.git#prep_IDF6",
-    cv.Version(5, 5, 6): cv.Version(55, 3, 312),
    cv.Version(5, 5, 5): cv.Version(55, 3, 312),
    cv.Version(5, 5, 4): cv.Version(55, 3, 39),
    cv.Version(5, 5, 3, "1"): cv.Version(55, 3, 37),
@@ -2926,11 +2925,6 @@ async def to_code(config):
    # produce reproducible outputs and downstream tooling can reuse artifacts.
    add_idf_sdkconfig_option("CONFIG_APP_REPRODUCIBLE_BUILD", True)

-    # Static destructors never run, so skip registering them. See atexit_stubs.cpp.
-    # --undefined: libsrc.a is scanned before the IDF libraries that also register them.
-    cg.add_build_flag("-Wl,--wrap=__cxa_atexit")
-    cg.add_build_flag("-Wl,--undefined=__wrap___cxa_atexit")
-
    if conf[CONF_TYPE] == FRAMEWORK_ESP_IDF:
        cg.add_build_flag("-DUSE_ESP_IDF")
        cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ESP_IDF")
@@ -3080,10 +3074,6 @@ async def to_code(config):
    # Increase freertos tick speed from 100Hz to 1kHz so that delay() resolution is 1ms
    add_idf_sdkconfig_option("CONFIG_FREERTOS_HZ", 1000)

-    # Main loop wakes use notification index 1; index 0 stays free for ESP-IDF waits
-    # such as pthread_join(), which a stray main-loop wake would otherwise end early.
-    add_idf_sdkconfig_option("CONFIG_FREERTOS_TASK_NOTIFICATION_ARRAY_ENTRIES", 2)
-
    # Place non-ISR FreeRTOS functions into flash instead of IRAM
    # This saves up to 8KB of IRAM. ISR-safe functions (FromISR variants) stay in IRAM.
    # In ESP-IDF 6.0 this becomes the default and CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH
@@ -1,20 +0,0 @@
-/*
- * Linker wrap stub for __cxa_atexit().
- *
- * GCC registers the destructor of every global and function local static
- * object with __cxa_atexit(). The firmware never returns from main or calls
- * exit(), so these destructors never run, but the first registration links
- * newlib's exit handler tables (about 400 bytes of RAM on ESP32).
- */
-
-#include "esphome/core/defines.h"
-
-#ifdef USE_ESP32
-
-namespace esphome::esp32 {}
-
-// NOLINTBEGIN(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
-extern "C" int __wrap___cxa_atexit(void (*)(void *), void *, void *) { return 0; }
-// NOLINTEND(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
-
-#endif  // USE_ESP32
@@ -531,9 +531,6 @@ void IRAM_ATTR __wrap_esp_panic_handler(panic_info_t *info) {
  // Xtensa: walk the backtrace using the public API
  if (info->frame != nullptr) {
    auto *xt_frame = (XtExcFrame *) info->frame;
-    // IDF leaves addr unset for SoC-level panics (cache error, interrupt WDT)
-    if (info->pseudo_excause)
-      s_raw_crash_data.pc = xt_frame->pc;
    if (!g_panic_abort) {
      // Abort-class frames carry no useful cause/vaddr: TWDT task snapshots
      // never wrote them and abort() traps describe only the synthetic trap.
@@ -150,8 +150,6 @@ void BLEClientBase::connect() {
  // A registration whose event never arrived must not block this connection's release.
  this->services_released_ = false;
  this->pending_notify_regs_ = 0;
-  // A CONNECT_EVT seen while idle can leave the id of a link this attempt does not own.
-  this->conn_id_ = UNSET_CONN_ID;
  // Enable loop for state processing
  this->enable_loop();
  // Immediately transition to CONNECTING to prevent duplicate connection attempts
@@ -300,7 +298,7 @@ void BLEClientBase::log_warning_(const char *message) {

 esp_err_t BLEClientBase::update_conn_params_(uint16_t min_interval, uint16_t max_interval, uint16_t latency,
                                             uint16_t timeout, const char *param_type) {
-  esp_ble_conn_update_params_t conn_params = {};
+  esp_ble_conn_update_params_t conn_params = {{0}};
  memcpy(conn_params.bda, this->remote_bda_, sizeof(esp_bd_addr_t));
  conn_params.min_int = min_interval;
  conn_params.max_int = max_interval;
@@ -352,6 +350,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
      if (!this->check_addr(param->open.remote_bda))
        return false;
      this->log_gattc_lifecycle_event_("OPEN");
+      // conn_id was already set in ESP_GATTC_CONNECT_EVT
      this->service_count_ = 0;

      // ESP-IDF's BLE stack may send ESP_GATTC_OPEN_EVT after esp_ble_gattc_open() returns an
@@ -363,24 +362,19 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
        break;
      }

-      const bool open_failed = param->open.status != ESP_GATT_OK && param->open.status != ESP_GATT_ALREADY_OPEN;
-      // Bluedroid reports a failed open as DISCONNECT_EVT then a failing OPEN_EVT, with no CONNECT_EVT,
-      // so DISCONNECTING with no id is expected for a failure. Anything else means a bad assumption
-      // about how the ESP BT stack works, so log it.
-      const bool expected_failure =
-          open_failed && this->state() == espbt::ClientState::DISCONNECTING && this->conn_id_ == UNSET_CONN_ID;
-      if (this->state() != espbt::ClientState::CONNECTING && !expected_failure) {
+      if (this->state() != espbt::ClientState::CONNECTING) {
+        // This should not happen but lets log it in case it does
+        // because it means we have a bad assumption about how the
+        // ESP BT stack works.
        ESP_LOGE(TAG, "[%d] [%s] ESP_GATTC_OPEN_EVT in %s state (status=%d)", this->connection_index_,
                 this->address_str_, espbt::client_state_to_string(this->state()), param->open.status);
      }
-      if (open_failed) {
+      if (param->open.status != ESP_GATT_OK && param->open.status != ESP_GATT_ALREADY_OPEN) {
        this->log_gattc_warning_("Connection open", param->open.status);
        // Connection was never established so CLOSE_EVT may not follow
        this->set_idle_();
        break;
      }
-      // An open on a link that is already up sends no CONNECT_EVT, so take the id here.
-      this->conn_id_ = param->open.conn_id;
      if (this->want_disconnect_) {
        // Disconnect was requested after connecting started,
        // but before the connection was established. Now that we have
@@ -53,7 +53,6 @@ from .const import (
    KEY_SERIAL1_REQUIRED,
    KEY_SERIAL_REQUIRED,
    KEY_WAVEFORM_REQUIRED,
-    THROW_STUBS_HEADER,
    enable_serial,
    enable_serial1,
    esp8266_ns,
@@ -115,37 +114,9 @@ _validate_toolchain = cv.toolchain_enum(_TOOLCHAINS)
 _resolve_toolchain = cv.resolve_toolchain("ESP8266", _TOOLCHAINS, Toolchain.ARDUINO)


-# Known boards keyed by spelling with case and "-" / "_" folded away
-_FOLDED_BOARDS = {board.lower().replace("-", "_"): board for board in BOARDS}
-
-
-def _resolve_board(config: ConfigType) -> ConfigType:
-    """Fix a misspelled board, else build an unknown one with PlatformIO."""
-    board = config[CONF_BOARD]
-    if board in BOARDS:
-        return config
-    if canonical := _FOLDED_BOARDS.get(board.lower().replace("-", "_")):
-        _LOGGER.warning(
-            "Board '%s' is not a known ESP8266 board; using '%s'", board, canonical
-        )
-        return {**config, CONF_BOARD: canonical}
-    if CORE.toolchain is None and CONF_TOOLCHAIN not in config:
-        return {**config, CONF_TOOLCHAIN: Toolchain.PLATFORMIO}
-    return config
-
-
 def _warn_platformio_toolchain(config: ConfigType) -> ConfigType:
    # Remove before 2027.4.0
-    if not CORE.using_toolchain_platformio:
-        return config
-    if config[CONF_BOARD] not in BOARDS:
-        _LOGGER.warning(
-            "Board '%s' is not supported by the native 'arduino' toolchain, so it "
-            "builds with the deprecated 'platformio' toolchain, which will be "
-            "removed in ESPHome 2027.4.0",
-            config[CONF_BOARD],
-        )
-    else:
+    if CORE.using_toolchain_platformio:
        _LOGGER.warning(
            "The 'platformio' toolchain for ESP8266 is deprecated and will be "
            "removed in ESPHome 2027.4.0; the native 'arduino' toolchain is the "
@@ -358,7 +329,6 @@ CONFIG_SCHEMA = cv.All(
            ): _validate_toolchain,
        }
    ),
-    _resolve_board,
    _resolve_toolchain,
    _warn_platformio_toolchain,
    _validate_native_toolchain,
@@ -478,9 +448,11 @@ async def to_code(config: ConfigType) -> None:

    # Force-include inline std::__throw_* overrides so GCC dead-strips the unused
    # libstdc++ error message strings (e.g. "basic_string::_M_create") from DRAM.
-    # See throw_stubs.h. The native build generator reads this option, also
-    # passes it to the core and libraries, and drops it with exceptions on.
-    cg.add_platformio_option("build_src_flags", f"-include {THROW_STUBS_HEADER}")
+    # See throw_stubs.h. Unconditional: the native build generator reads
+    # the same option, keeping one source of truth.
+    cg.add_platformio_option(
+        "build_src_flags", "-include esphome/components/esp8266/throw_stubs.h"
+    )

    # In testing mode, fake larger memory to allow linking grouped component tests
    # Real ESP8266 hardware only has 32KB IRAM and ~80KB RAM, but for CI testing
@@ -17,8 +17,6 @@ KEY_SERIAL_REQUIRED = "serial_required"
 KEY_SERIAL1_REQUIRED = "serial1_required"
 # Set for the native (non-PlatformIO) toolchain's build generator
 KEY_SCANF_FLOAT = "scanf_float"
-# Force-included std::__throw_* overrides, relative to the src dir
-THROW_STUBS_HEADER = "esphome/components/esp8266/throw_stubs.h"
 # Per-board flash-layout override consumed by board_ld_script()
 KEY_LDSCRIPT = "ldscript"
 # Crash-decode tools, resolved once per run by __init__
@@ -15,8 +15,7 @@
 * unused, dead-strip the load, and drop the string entirely -- no LTO needed.
 * Behavior is identical to today: a bare abort() (the message was never
 * printed). This header MUST be force-included before <string>, so it is
- * wired up via build_src_flags "-include ..." in this component's __init__.py;
- * the native toolchain also force-includes it into the core and libraries.
+ * wired up via build_src_flags "-include ..." in this component's __init__.py.
 *
 * Note: this defines functions in namespace std (technically UB). It is safe
 * here because the definitions match the existing abort() behavior exactly.
@@ -37,6 +37,7 @@ void GreeClimate::transmit_state() {
  remote_state[1] = this->temperature_();

  if (model == GREE_YAN) {
+    remote_state[2] = 0x20;  // bits 0..3 always 0000, bits 4..7 TURBO, LIGHT, HEALTH, X-FAN
    remote_state[3] = 0x50;  // bits 4..7 always 0101
    remote_state[4] = this->vertical_swing_();
  }
@@ -60,6 +61,7 @@ void GreeClimate::transmit_state() {
  }

  if (model == GREE_YAA || model == GREE_YAC || model == GREE_YAC1FB9) {
+    remote_state[2] = 0x20;  // bits 0..3 always 0000, bits 4..7 TURBO, LIGHT, HEALTH, X-FAN
    remote_state[3] = 0x50;  // bits 4..7 always 0101
    remote_state[6] = 0x20;  // YAA1FB, FAA1FB1, YB1F2 bits 4..7 always 0010

@@ -76,12 +76,6 @@ static constexpr uint8_t GREE_PRESET_NONE = 0x00;
 static constexpr uint8_t GREE_PRESET_SLEEP = 0x01;
 static constexpr uint8_t GREE_PRESET_SLEEP_BIT = 0x80;

-// Mode bits stored in remote_state[2] bits 4..7 for YAN/YAA/YAC/YAC1FB9.
-static constexpr uint8_t GREE_MODE_BIT_TURBO = 0x10;
-static constexpr uint8_t GREE_MODE_BIT_LIGHT = 0x20;
-static constexpr uint8_t GREE_MODE_BIT_HEALTH = 0x40;
-static constexpr uint8_t GREE_MODE_BIT_XFAN = 0x80;
-
 // Model codes
 enum Model : uint8_t { GREE_GENERIC, GREE_YAN, GREE_YAA, GREE_YAC, GREE_YAC1FB9, GREE_YX1FF, GREE_YAG };

@@ -109,7 +103,7 @@ class GreeClimate final : public climate_ir::ClimateIR {
  uint8_t preset_();

  Model model_{};
-  uint8_t mode_bits_{GREE_MODE_BIT_LIGHT};  // The display light is on until a switch says otherwise
+  uint8_t mode_bits_{0};  // Combined mode bits for remote_state[2]
 };

 }  // namespace esphome::gree
@@ -17,22 +17,12 @@ CONF_HEALTH = "health"
 CONF_XFAN = "xfan"
 CONF_GREE_ID = "gree_id"

-# Switch configurations: (config_key, display_name, mode_bit, icon)
+# Switch configurations: (config_key, display_name, bit_mask, icon)
 SWITCH_CONFIGS = (
-    (
-        CONF_TURBO,
-        "Gree Turbo Switch",
-        gree_ns.GREE_MODE_BIT_TURBO,
-        "mdi:car-turbocharger",
-    ),
-    (CONF_LIGHT, "Gree Light Switch", gree_ns.GREE_MODE_BIT_LIGHT, "mdi:led-outline"),
-    (CONF_HEALTH, "Gree Health Switch", gree_ns.GREE_MODE_BIT_HEALTH, "mdi:pine-tree"),
-    (
-        CONF_XFAN,
-        "Gree X-FAN Switch",
-        gree_ns.GREE_MODE_BIT_XFAN,
-        "mdi:wall-sconce-flat",
-    ),
+    (CONF_TURBO, "Gree Turbo Switch", 0x10, "mdi:car-turbocharger"),
+    (CONF_LIGHT, "Gree Light Switch", 0x20, "mdi:led-outline"),
+    (CONF_HEALTH, "Gree Health Switch", 0x40, "mdi:pine-tree"),
+    (CONF_XFAN, "Gree X-FAN Switch", 0x80, "mdi:wall-sconce-flat"),
 )

 SUPPORTED_MODELS = {
@@ -49,10 +39,7 @@ CONFIG_SCHEMA = cv.Schema(
            cv.Optional(key): switch.switch_schema(
                GreeModeBitSwitch,
                icon=icon,
-                # The display light was on before the switches existed, so it stays on by default
-                default_restore_mode="RESTORE_DEFAULT_ON"
-                if key == CONF_LIGHT
-                else "RESTORE_DEFAULT_OFF",
+                default_restore_mode="RESTORE_DEFAULT_OFF",
                device_class=DEVICE_CLASS_SWITCH,
                entity_category=ENTITY_CATEGORY_CONFIG,
            )
@@ -187,18 +187,15 @@ void HeatpumpIRClimate::transmit_state() {
    swing_h_cmd = HDIR_SWING;
  }

-  // MitsubishiMSCHeatpumpIR only knows FAN_1..FAN_3 and sends anything else as auto,
-  // so low/medium/high have to start at FAN_1 there instead of FAN_2.
-  const bool three_speed_fan = this->protocol_ == PROTOCOL_MITSUBISHI_MSC;
  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_AUTO)) {
    case climate::CLIMATE_FAN_LOW:
-      fan_speed_cmd = three_speed_fan ? FAN_1 : FAN_2;
+      fan_speed_cmd = FAN_2;
      break;
    case climate::CLIMATE_FAN_MEDIUM:
-      fan_speed_cmd = three_speed_fan ? FAN_2 : FAN_3;
+      fan_speed_cmd = FAN_3;
      break;
    case climate::CLIMATE_FAN_HIGH:
-      fan_speed_cmd = three_speed_fan ? FAN_3 : FAN_4;
+      fan_speed_cmd = FAN_4;
      break;
    case climate::CLIMATE_FAN_AUTO:
    default:
@@ -18,8 +18,6 @@ namespace esphome::improv_serial {

 static const char *const TAG = "improv_serial";

-static constexpr uint32_t WIFI_CONNECT_TIMEOUT_ID = 0;
-
 void ImprovSerialComponent::setup() {
  global_improv_serial_component = this;
 #ifdef USE_IMPROV_SERIAL_UART
@@ -75,7 +73,7 @@ void ImprovSerialComponent::loop() {
      wifi::global_wifi_component->save_wifi_sta(this->connecting_sta_.get_ssid(),
                                                 this->connecting_sta_.get_password());
      this->connecting_sta_ = {};
-      this->cancel_timeout(WIFI_CONNECT_TIMEOUT_ID);
+      this->cancel_timeout("wifi-connect-timeout");
      this->set_state_(improv::STATE_PROVISIONED);

      this->send_settings_response_(improv::WIFI_SETTINGS);
@@ -304,7 +302,7 @@ bool ImprovSerialComponent::parse_improv_payload_(improv::ImprovCommand &command
      ESP_LOGD(TAG, "Received settings: SSID=%s, password=" LOG_SECRET("%s"), command.ssid.c_str(),
               command.password.c_str());

-      this->set_timeout(WIFI_CONNECT_TIMEOUT_ID, switching ? WIFI_SWITCH_TIMEOUT_MS : WIFI_CONNECT_TIMEOUT_MS,
+      this->set_timeout("wifi-connect-timeout", switching ? WIFI_SWITCH_TIMEOUT_MS : WIFI_CONNECT_TIMEOUT_MS,
                        [this]() { this->on_wifi_connect_timeout_(); });
 #else
      // No Wi-Fi support compiled in; there is nothing to provision.
@@ -491,9 +491,6 @@ async def component_to_code(config):
        # Not enabled on RTL87xx/LN882x — costs more heap than it saves there.
        cg.add_build_flag("-DconfigSUPPORT_STATIC_ALLOCATION=1")

-    # Static destructors never run, so skip registering them. See atexit_stubs.cpp.
-    cg.add_build_flag("-Wl,--wrap=__cxa_atexit")
-
    # LN882x: a zero-size allocation must not trip the SDK's assert (see ln882x_zero_malloc.c).
    if config[CONF_COMPONENT_ID] == COMPONENT_LN882X:
        cg.add_build_flag("-Wl,--wrap=pvPortMalloc")
@@ -1,20 +0,0 @@
-/*
- * Linker wrap stub for __cxa_atexit().
- *
- * GCC registers the destructor of every global and function local static
- * object with __cxa_atexit(). The firmware never returns from main or calls
- * exit(), so these destructors never run, but the first registration links
- * newlib's exit handler tables.
- */
-
-#include "esphome/core/defines.h"
-
-#ifdef USE_LIBRETINY
-
-namespace esphome::libretiny {}
-
-// NOLINTBEGIN(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
-extern "C" int __wrap___cxa_atexit(void (*)(void *), void *, void *) { return 0; }
-// NOLINTEND(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp,readability-identifier-naming)
-
-#endif  // USE_LIBRETINY
@@ -4,8 +4,6 @@

 namespace esphome::mcp23xxx_base {

-void IRAM_ATTR mcp23xxx_gpio_intr(Component *arg) { arg->enable_loop_soon_any_context(); }
-
 template<uint8_t N> void MCP23XXXGPIOPin<N>::setup() {
  this->pin_mode(flags_);
  // When interrupt_pin is configured, pin_mode() already auto-enables CHANGE
@@ -8,10 +8,6 @@ namespace esphome::mcp23xxx_base {

 enum MCP23XXXInterruptMode : uint8_t { MCP23XXX_NO_INTERRUPT = 0, MCP23XXX_CHANGE, MCP23XXX_RISING, MCP23XXX_FALLING };

-// Not a template member: GCC 10 (ESP8266) ignores section attributes on template instantiations, leaving the
-// ISR in flash.
-void IRAM_ATTR mcp23xxx_gpio_intr(Component *arg);
-
 template<uint8_t N> class MCP23XXXBase : public Component, public gpio_expander::CachedGpioExpander<uint8_t, N> {
 public:
  virtual void pin_mode(uint8_t pin, gpio::Flags flags);
@@ -39,8 +35,7 @@ template<uint8_t N> class MCP23XXXBase : public Component, public gpio_expander:
  void setup_interrupt_pin_() {
    if (this->interrupt_pin_ != nullptr) {
      this->interrupt_pin_->setup();
-      this->interrupt_pin_->attach_interrupt(&mcp23xxx_gpio_intr, static_cast<Component *>(this),
-                                             gpio::INTERRUPT_FALLING_EDGE);
+      this->interrupt_pin_->attach_interrupt(&MCP23XXXBase::gpio_intr, this, gpio::INTERRUPT_FALLING_EDGE);
      this->set_invalidate_on_read_(false);
    }
    // Disable loop until an input pin is configured via pin_mode()
@@ -48,6 +43,7 @@ template<uint8_t N> class MCP23XXXBase : public Component, public gpio_expander:
    // For polling mode, loop is re-enabled when pin_mode() registers an input pin
    this->disable_loop();
  }
+  static void IRAM_ATTR gpio_intr(MCP23XXXBase *arg) { arg->enable_loop_soon_any_context(); }

  // read a given register
  virtual bool read_reg(uint8_t reg, uint8_t *value) = 0;
@@ -235,7 +235,7 @@ async def to_code(config: ConfigType) -> None:
                ethernet.request_ethernet_ip_state_listener()

    if CORE.is_esp32:
-        add_idf_component(name="espressif/mdns", ref="1.14.0")
+        add_idf_component(name="espressif/mdns", ref="1.12.0")
        # ESPHome only advertises; the browse APIs are unused
        add_idf_sdkconfig_option("CONFIG_MDNS_ENABLE_BROWSE", False)
        # The mdns console CLI is never used by ESPHome
@@ -20,10 +20,6 @@
 #ifdef USE_DASHBOARD_IMPORT
 #include "esphome/components/dashboard_import/dashboard_import.h"
 #endif
-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-#include "esphome/components/ethernet/ethernet_component.h"
-#include "esphome/components/wifi/wifi_component.h"
-#endif

 namespace esphome::mdns {

@@ -43,45 +39,6 @@ MDNS_STATIC_CONST_CHAR(SERVICE_TCP, "_tcp");
 // Wrap build-time defines into flash storage
 MDNS_STATIC_CONST_CHAR(VALUE_VERSION, ESPHOME_VERSION);

-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-MDNS_STATIC_CONST_CHAR(NETWORK_WIFI, "wifi");
-MDNS_STATIC_CONST_CHAR(NETWORK_ETHERNET, "ethernet");
-
-// Same order as the default route in NetworkComponent::loop()
-const char *MDNSComponent::connected_network_() const {
-  const bool ethernet = ethernet::global_eth_component->is_connected();
-  const bool wifi = wifi::global_wifi_component->is_connected();
-#ifdef USE_NETWORK_PRIMARY_INTERFACE_WIFI
-  if (wifi)
-    return NETWORK_WIFI;
-#endif
-  if (ethernet)
-    return NETWORK_ETHERNET;
-  if (wifi)
-    return NETWORK_WIFI;
-  return nullptr;
-}
-
-void MDNSComponent::update_network_txt_() {
-  if (this->network_txt_ == nullptr)
-    return;
-  // With no interface connected, keep the last value instead of flapping to wifi
-  const char *network = this->connected_network_();
-  if (network == nullptr || network == this->network_txt_)
-    return;
-  if (!this->publish_network_txt_(network)) {
-    // The _esphomelib service is missing, so a retry would fail too
-    this->network_txt_ = nullptr;
-    return;
-  }
-  ESP_LOGD(TAG, "Network TXT: %s", network);
-  this->network_txt_ = network;
-#ifdef USE_MDNS_STORE_SERVICES
-  this->network_record_->value = MDNS_STR(network);
-#endif
-}
-#endif
-
 void MDNSComponent::setup_buffers_and_register_(PlatformRegisterFn platform_register) {
 #ifdef USE_MDNS_STORE_SERVICES
  auto &services = this->services_;
@@ -203,15 +160,7 @@ void MDNSComponent::compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUN

    txt_records.push_back({MDNS_STR(TXT_BOARD), MDNS_STR(VALUE_BOARD)});

-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-    const char *network = this->connected_network_();
-    this->network_txt_ = network != nullptr ? network : NETWORK_WIFI;
-    txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(this->network_txt_)});
-#ifdef USE_MDNS_STORE_SERVICES
-    // services is services_ here, which never reallocates
-    this->network_record_ = &txt_records.back();
-#endif
-#elif defined(USE_WIFI)
+#if defined(USE_WIFI)
    MDNS_STATIC_CONST_CHAR(NETWORK_WIFI, "wifi");
    txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(NETWORK_WIFI)});
 #elif defined(USE_ETHERNET)
@@ -32,12 +32,6 @@
 #define USE_MDNS_DEVICE_INFO_TXT
 #endif

-// With both wifi and ethernet, the _esphomelib "network" TXT value follows the connected interface.
-// OpenThread hands its services to the SRP client once, so it keeps the fixed value.
-#if defined(USE_API) && defined(USE_WIFI) && defined(USE_ETHERNET) && !defined(USE_OPENTHREAD)
-#define USE_MDNS_DYNAMIC_NETWORK_TXT
-#endif
-
 namespace esphome::mdns {

 // Helper struct that identifies strings that may be stored in flash storage (similar to LogString)
@@ -156,22 +150,6 @@ class MDNSComponent final : public Component

  void setup_buffers_and_register_(PlatformRegisterFn platform_register);

-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-  static constexpr uint32_t NETWORK_TXT_CHECK_INTERVAL_MS = 1000;
-  /// The first connected interface in network: priority order ("ethernet" or "wifi"), else nullptr.
-  const char *connected_network_() const;
-  /// Check the connected interface and publish a changed "network" TXT value.
-  void update_network_txt_();
-  /// Platform-specific: replace the "network" TXT value of the registered _esphomelib service.
-  bool publish_network_txt_(const char *network);
-  /// Advertised value; nullptr until the _esphomelib service is registered, and after a failed publish.
-  const char *network_txt_{nullptr};
-#ifdef USE_MDNS_STORE_SERVICES
-  /// The "network" record in services_, kept in step with network_txt_.
-  MDNSTXTRecord *network_record_{nullptr};
-#endif
-#endif
-
 #ifdef USE_MDNS_DYNAMIC_TXT
  /// Storage for runtime-generated TXT values from user lambdas
  /// Pre-sized at compile time via MDNS_DYNAMIC_TXT_COUNT to avoid heap allocations.
@@ -89,24 +89,7 @@ bool MDNSComponent::set_service_enabled(const char *service_type, const char *pr
 }
 #endif  // USE_MDNS_SUPPORTS_ENABLE_DISABLE && !USE_OPENTHREAD

-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-bool MDNSComponent::publish_network_txt_(const char *network) {
-  // ESP-IDF copies the value and announces the changed record
-  esp_err_t err = mdns_service_txt_item_set("_esphomelib", "_tcp", "network", network);
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Failed to update network TXT: %s", esp_err_to_name(err));
-    return false;
-  }
-  return true;
-}
-#endif
-
-void MDNSComponent::setup() {
-  this->setup_buffers_and_register_(register_esp32);
-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-  this->set_interval(NETWORK_TXT_CHECK_INTERVAL_MS, [this]() { this->update_network_txt_(); });
-#endif
-}
+void MDNSComponent::setup() { this->setup_buffers_and_register_(register_esp32); }

 void MDNSComponent::on_shutdown() {
 #ifndef USE_OPENTHREAD
@@ -46,26 +46,7 @@ void MDNSComponent::start_polling_window_() {
 }
 #endif

-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-ESPHOME_LOG_TAG(TAG, "mdns");
-
-bool MDNSComponent::publish_network_txt_(const char *network) {
-  // LEAmDNS replaces the value of an existing key; announce() sends the change
-  if (!MDNS.addServiceTxt("esphomelib", "tcp", "network", network)) {
-    ESP_LOGW(TAG, "Failed to update network TXT");
-    return false;
-  }
-  MDNS.announce();
-  this->start_polling_window_();
-  return true;
-}
-#endif
-
 void MDNSComponent::setup() {
-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-  // No-op until the first IP-up event registers the services
-  this->set_interval(NETWORK_TXT_CHECK_INTERVAL_MS, [this]() { this->update_network_txt_(); });
-#endif
  // arduino-pico stubs out LwipIntf::stateUpCB (the netif status callback LEAmDNS uses
  // on ESP8266 for auto-restart), so we must drive begin()/notifyAPChange() from our
  // own IP state listener. Both WiFi and Ethernet have the same listener signature —
@@ -9,10 +9,6 @@ class RgbDriverChip(DriverChip):
    def transforms(self) -> set[str]:
        """
        Return the set of transformations supported by this driver chip.
-        RGB displays do not support axis swapping, so this method removes CONF_SWAP_XY.
-        A model with an empty init sequence has no command interface at all, so it
-        cannot apply any transform in hardware.
+        RGB displays do not support axis swapping, so this method removes CONF_SWAP_XY
        """
-        if self.initsequence is not None and len(self.initsequence) == 0:
-            return set()
        return super().transforms - {CONF_SWAP_XY}
@@ -16,7 +16,6 @@
 #include "lwip/dns.h"
 #include "lwip/err.h"
 #include "mqtt_component.h"
-#include "mqtt_topic_match.h"

 #ifdef USE_API
 #include "esphome/components/api/api_server.h"
@@ -582,6 +581,63 @@ void MQTTClientComponent::disable() {
  this->on_shutdown();
 }

+/** Check if the message topic matches the given subscription topic
+ *
+ * INFO: MQTT spec mandates that topics must not be empty and must be valid NULL-terminated UTF-8 strings.
+ *
+ * @param message The message topic that was received from the MQTT server. Note: this must not contain
+ *                wildcard characters as mandated by the MQTT spec.
+ * @param subscription The subscription topic we are matching against.
+ * @param is_normal Is this a "normal" topic - Does the message topic not begin with a "$".
+ * @param past_separator Are we past the first '/' topic separator.
+ * @return true if the subscription topic matches the message topic, false otherwise.
+ */
+static bool topic_match(const char *message, const char *subscription, bool is_normal, bool past_separator) {
+  // Reached end of both strings at the same time, this means we have a successful match
+  if (*message == '\0' && *subscription == '\0')
+    return true;
+
+  // Either the message or the subscribe are at the end. This means they don't match.
+  if (*message == '\0' || *subscription == '\0')
+    return false;
+
+  bool do_wildcards = is_normal || past_separator;
+
+  if (*subscription == '+' && do_wildcards) {
+    // single level wildcard
+    // consume + from subscription
+    subscription++;
+    // consume everything from message until '/' found or end of string
+    while (*message != '\0' && *message != '/') {
+      message++;
+    }
+    // after this, both pointers will point to a '/' or to the end of the string
+
+    return topic_match(message, subscription, is_normal, true);
+  }
+
+  if (*subscription == '#' && do_wildcards) {
+    // multilevel wildcard - MQTT mandates that this must be at end of subscribe topic
+    return true;
+  }
+
+  // this handles '/' and normal characters at the same time.
+  if (*message != *subscription)
+    return false;
+
+  past_separator = past_separator || *subscription == '/';
+
+  // consume characters
+  subscription++;
+  message++;
+
+  return topic_match(message, subscription, is_normal, past_separator);
+}
+
+static bool topic_match(const char *message, const char *subscription) {
+  return topic_match(message, subscription, *message != '\0' && *message != '$', false);
+}
+
 void MQTTClientComponent::on_message(const std::string &topic, const std::string &payload) {
 #ifdef USE_ESP8266
  // IMPORTANT: This defer is REQUIRED to prevent stack overflow crashes on ESP8266.
@@ -273,8 +273,6 @@ class MQTTComponent : public Component {
  void subscribe_json(const std::string &topic, const mqtt_json_callback_t &callback, uint8_t qos = 0);

 protected:
-  static constexpr uint32_t SEND_DEFER_ID = 0;
-
  /// Helper method to get the discovery topic for this component into a buffer.
  StringRef get_discovery_topic_to_(std::span<char, MQTT_DISCOVERY_TOPIC_MAX_LEN> buf,
                                    const MQTTDiscoveryInfo &discovery_info) const;
@@ -121,7 +121,7 @@ void MQTTFanComponent::setup() {
                    });
  }

-  this->state_->add_on_state_callback([this]() { this->defer(SEND_DEFER_ID, [this]() { this->publish_state(); }); });
+  this->state_->add_on_state_callback([this]() { this->defer("send", [this]() { this->publish_state(); }); });
 }

 void MQTTFanComponent::dump_config() {
@@ -28,7 +28,7 @@ void MQTTJSONLightComponent::setup() {
 }

 void MQTTJSONLightComponent::on_light_remote_values_update() {
-  this->defer(SEND_DEFER_ID, [this]() { this->publish_state_(); });
+  this->defer("send", [this]() { this->publish_state_(); });
 }

 MQTTJSONLightComponent::MQTTJSONLightComponent(LightState *state) : state_(state) {}
@@ -29,7 +29,7 @@ void MQTTLockComponent::setup() {
    }
  });
  this->lock_->add_on_state_callback(
-      [this](LockState /*state*/) { this->defer(SEND_DEFER_ID, [this]() { this->publish_state(); }); });
+      [this](LockState /*state*/) { this->defer("send", [this]() { this->publish_state(); }); });
 }
 void MQTTLockComponent::dump_config() {
  ESP_LOGCONFIG(TAG, "MQTT Lock '%s': ", this->lock_->get_name().c_str());
@@ -34,7 +34,7 @@ void MQTTSwitchComponent::setup() {
    }
  });
  this->switch_->add_on_state_callback(
-      [this](bool enabled) { this->defer(SEND_DEFER_ID, [this, enabled]() { this->publish_state(enabled); }); });
+      [this](bool enabled) { this->defer("send", [this, enabled]() { this->publish_state(enabled); }); });
 }
 void MQTTSwitchComponent::dump_config() {
  ESP_LOGCONFIG(TAG, "MQTT Switch '%s': ", this->switch_->get_name().c_str());
@@ -1,28 +0,0 @@
-#pragma once
-
-namespace esphome::mqtt {
-
-/// True if the message topic matches the subscription, with + and # wildcards.
-/// A loop on purpose: recursing per character overflowed the ESP32 loop task's stack on long topics.
-inline bool topic_match(const char *message, const char *subscription) {
-  // First-level wildcards do not match topics that begin with '$'
-  bool wildcards = *message != '$';
-  while (*message != '\0' && *subscription != '\0') {
-    if (wildcards && *subscription == '#')
-      return true;
-    if (wildcards && *subscription == '+') {
-      subscription++;
-      while (*message != '\0' && *message != '/')
-        message++;
-      continue;
-    }
-    if (*message != *subscription)
-      return false;
-    wildcards |= *subscription == '/';
-    message++;
-    subscription++;
-  }
-  return *message == *subscription;  // a match only if both ended
-}
-
-}  // namespace esphome::mqtt
@@ -24,7 +24,7 @@ void MQTTUpdateComponent::setup() {
    }
  });

-  this->update_->add_on_state_callback([this]() { this->defer(SEND_DEFER_ID, [this]() { this->publish_state(); }); });
+  this->update_->add_on_state_callback([this]() { this->defer("send", [this]() { this->publish_state(); }); });
 }

 bool MQTTUpdateComponent::publish_state() {
@@ -13,8 +13,8 @@ CODEOWNERS = ["@esphome/core"]

 # Keep in sync with platformio.ini and esphome/idf_component.yml.
 # LIBSODIUM_VERSION must match the version noise-c pins in its manifests.
-NOISE_C_VERSION = "0.1.31"
-LIBSODIUM_VERSION = "1.10021.12"
+NOISE_C_VERSION = "0.1.30"
+LIBSODIUM_VERSION = "1.10021.11"

 noise_ns = cg.esphome_ns.namespace("noise")

@@ -37,7 +37,6 @@ int NoiseResponderHandshake::init(const NoiseContext &ctx, const uint8_t *prolog
      .cipher_id = NOISE_CIPHER_CHACHAPOLY,
      .hash_id = NOISE_HASH_SHA256,
      .hybrid_id = NOISE_DH_NONE,
-      .reserved = {},
  };

  int err = noise_handshakestate_new_by_id(&this->handshake_, &nid, NOISE_ROLE_RESPONDER);
@@ -12,7 +12,6 @@ from esphome.build_helpers import pch
 from esphome.build_helpers.ccache import resolve_ccache_path
 import esphome.codegen as cg
 from esphome.components.zephyr import (
-    Section,
    add_extra_script,
    copy_files as zephyr_copy_files,
    zephyr_add_overlay,
@@ -126,37 +125,11 @@ def set_core_data(config: ConfigType) -> ConfigType:
    CORE.data[KEY_CORE][KEY_TARGET_FRAMEWORK] = KEY_ZEPHYR

    if config[KEY_BOOTLOADER] in BOOTLOADER_CONFIG:
-        sections = BOOTLOADER_CONFIG[config[KEY_BOOTLOADER]]
-        if CORE.testing_mode:
-            sections = _testing_mode_sections(sections)
-        zephyr_add_pm_static(sections)
+        zephyr_add_pm_static(BOOTLOADER_CONFIG[config[KEY_BOOTLOADER]])

    return config


-# In testing mode, fake a larger flash to allow linking grouped component
-# tests. The nRF52840 has 1 MB and a mcumgr OTA config halves the app slot,
-# which an openthread config alone fills; CI images are never flashed.
-NRF52840_FLASH_SIZE = 0x100000
-TESTING_FLASH_SIZE = 0x400000
-
-
-def _testing_mode_sections(sections: list[Section]) -> list[Section]:
-    """Move a bootloader pinned to the end of the real flash to the end of the
-    faked one, so the partition manager still sees a single gap for the app."""
-    return [
-        Section(
-            section.name,
-            section.address + TESTING_FLASH_SIZE - NRF52840_FLASH_SIZE,
-            section.size,
-            section.region,
-        )
-        if section.end_address == NRF52840_FLASH_SIZE
-        else section
-        for section in sections
-    ]
-
-
 _TOOLCHAINS = (Toolchain.PLATFORMIO, Toolchain.SDK_NRF)
 _resolve_toolchain = cv.resolve_toolchain("nRF52", _TOOLCHAINS, Toolchain.SDK_NRF)

@@ -407,15 +380,6 @@ async def to_code(config: ConfigType) -> None:
    zephyr_setup_preferences()
    zephyr_to_code(config)

-    if CORE.testing_mode:
-        zephyr_add_overlay(
-            f"""
-                &flash0 {{
-                    reg = <0x0 {TESTING_FLASH_SIZE:#x}>;
-                }};
-            """
-        )
-
    if dfu_config := config.get(CONF_DFU):
        CORE.add_job(_dfu_to_code, dfu_config)
    framework_ver: cv.Version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
@@ -731,13 +695,13 @@ def upload_program(config: ConfigType, args, host: str) -> bool:
        return True  # Handled: PYOCD upload

    # Deferred imports: bleak/smpclient are heavy, only load for BLE/mcumgr paths
-    from .ble_logger import is_ble_address
+    from .ble_logger import is_mac_address
    from .ota import smpmgr_scan, smpmgr_upload

    if host == "BLE":
        mcumgr_device = asyncio.run(smpmgr_scan(CORE.name))

-    if is_ble_address(host):
+    if is_mac_address(host):
        mcumgr_device = host

    if mcumgr_device:
@@ -752,7 +716,7 @@ def upload_program(config: ConfigType, args, host: str) -> bool:

 def show_logs(config: ConfigType, args, devices: list[str]) -> bool:
    address = devices[0]
-    from .ble_logger import is_ble_address, logger_connect, logger_scan
+    from .ble_logger import is_mac_address, logger_connect, logger_scan

    if devices[0] == "BLE":
        ble_device = asyncio.run(logger_scan(CORE.name))
@@ -761,7 +725,7 @@ def show_logs(config: ConfigType, args, devices: list[str]) -> bool:
        else:
            return True

-    if is_ble_address(address):
+    if is_mac_address(address):
        asyncio.run(logger_connect(address))
        return True
    return False
@@ -834,7 +798,7 @@ _PCH_CMAKE_LINES = [
    "set(esphome_kept_options)",
    "set(esphome_pch_headers)",
    "foreach(option IN LISTS esphome_options)",
-    '  if(option MATCHES "imacros> ([^>]+)")',
+    '  if(option MATCHES "imacros> (.+)$")',
    '    list(APPEND esphome_pch_headers "${CMAKE_MATCH_1}")',
    "    list(APPEND esphome_kept_options",
    '        "$<$<NOT:$<AND:$<COMPILE_LANGUAGE:CXX>,$<STREQUAL:$<TARGET_PROPERTY:NAME>,app>>>:${option}>")',
@@ -1039,13 +1003,11 @@ def run_compile(args, config: ConfigType) -> bool:
    framework_ver = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
    bootloader = zephyr_data()[KEY_BOOTLOADER]

-    # (dev_type, sd_req) per bootloader — values from Nordic SoftDevice release notes.
-    # The bootloader resets on a package whose sd_req does not list its SoftDevice,
-    # so v7 accepts S140 7.0.1, 7.2.0 and 7.3.0 (e.g. Seeed XIAO nRF52840).
+    # (dev_type, sd_req) per bootloader — values from Nordic SoftDevice release notes
    _GENPKG_PARAMS = {
        BOOTLOADER_ADAFRUIT_NRF52_SD132: ("0x0051", "0x009D"),
        BOOTLOADER_ADAFRUIT_NRF52_SD140_V6: ("0x0052", "0x00B6"),
-        BOOTLOADER_ADAFRUIT_NRF52_SD140_V7: ("0x0052", "0x00CA,0x0100,0x0123"),
+        BOOTLOADER_ADAFRUIT_NRF52_SD140_V7: ("0x0052", "0x00CA"),
    }
    # UF2 family IDs — nRF52832 vs nRF52840 per SoftDevice variant
    _UF2_FAMILY_IDS = {
@@ -4,7 +4,6 @@ import re
 from typing import Final

 from bleak import BleakClient, BleakScanner, BLEDevice
-from bleak.backends.scanner import AdvertisementData
 from bleak.exc import (
    BleakCharacteristicNotFoundError,
    BleakDBusError,
@@ -20,31 +19,15 @@ NUS_TX_CHAR_UUID = "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
 MAC_ADDRESS_PATTERN: Final = re.compile(
    r"([0-9A-F]{2}[:]){5}[0-9A-F]{2}$", flags=re.IGNORECASE
 )
-# macOS identifies BLE peripherals by a CoreBluetooth UUID instead of a MAC address
-UUID_PATTERN: Final = re.compile(
-    r"[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$",
-    flags=re.IGNORECASE,
-)


-def is_ble_address(value: str) -> bool:
-    return bool(MAC_ADDRESS_PATTERN.match(value) or UUID_PATTERN.match(value))
-
-
-def _name_matches(device: BLEDevice, adv: AdvertisementData, name: str) -> bool:
-    # device.name can be a stale cached name on macOS; adv.local_name is what is on the air now
-    return name in (device.name, adv.local_name)
-
-
-async def find_device_by_name(name: str, timeout: float = 10.0) -> BLEDevice | None:
-    return await BleakScanner.find_device_by_filter(
-        lambda device, adv: _name_matches(device, adv, name), timeout=timeout
-    )
+def is_mac_address(value: str) -> bool:
+    return MAC_ADDRESS_PATTERN.match(value)


 async def logger_scan(name: str) -> BLEDevice | None:
    _LOGGER.info("Scanning bluetooth for %s...", name)
-    device = await find_device_by_name(name)
+    device = await BleakScanner.find_device_by_name(name)
    if not device:
        _LOGGER.error("%s Bluetooth LE device was not found!", name)
    return device
@@ -4,6 +4,7 @@ import json
 import logging
 from pathlib import Path

+from bleak import BleakScanner
 from bleak.exc import BleakDBusError, BleakDeviceNotFoundError
 from smp.exceptions import SMPBadStartDelimiter
 from smpclient import SMPClient
@@ -22,8 +23,9 @@ from smpclient.transport.serial import SMPSerialTransport
 from esphome.core import EsphomeError
 from esphome.espota2 import ProgressBar

-from .ble_logger import find_device_by_name, is_ble_address
+from .ble_logger import is_mac_address

+SMP_SERVICE_UUID = "8D53DC1D-1DB7-4CD3-868B-8A527460AA84"
 BLE_SCAN_TIMEOUT = 10.0  # seconds
 RESET_DELAY = 2.0  # seconds to wait before reset, allows on_end action to execute

@@ -43,12 +45,12 @@ def _json_state(o: object) -> object:

 async def smpmgr_scan(name: str) -> str:
    _LOGGER.info("Scanning bluetooth for %s...", name)
-    # No service filter: the SMP UUID only fits in the scan response, which macOS does not filter on.
-    # The SMP service is checked on connect.
-    device = await find_device_by_name(name, timeout=BLE_SCAN_TIMEOUT)
-    if device is None:
-        raise EsphomeError(f"BLE device {name} not found")
-    return device.address
+    for device in await BleakScanner.discover(
+        timeout=BLE_SCAN_TIMEOUT, service_uuids=[SMP_SERVICE_UUID]
+    ):
+        if device.name == name:
+            return device.address
+    raise EsphomeError(f"BLE device {name} with OTA service not found")


 async def smpmgr_upload(device: str, firmware: Path) -> None:
@@ -86,7 +88,7 @@ def _get_image_tlv_sha256(file: Path) -> bytes:
 async def _smpmgr_upload(device: str, firmware: Path) -> None:
    image_tlv_sha256 = _get_image_tlv_sha256(firmware)

-    if is_ble_address(device):
+    if is_mac_address(device):
        smp_client = SMPClient(SMPBLETransport(), device)
    else:
        smp_client = SMPClient(SMPSerialTransport(), device)
@@ -103,8 +105,7 @@ async def _smpmgr_upload(device: str, firmware: Path) -> None:
            ) from exc
        raise EsphomeError(f"BLE error connecting to {device}: {exc}") from exc
    except SMPBLETransportException as exc:
-        # Reached when a device with the right name has no SMP service, among other causes
-        raise EsphomeError(f"Connection error with {device}: {exc}") from exc
+        raise EsphomeError(f"Connection error with {device}") from exc

    _LOGGER.info("Connected %s...", device)
    try:
@@ -98,9 +98,8 @@ enum OTAType : uint8_t {
 // The OTA backend method surface. Exactly one backend exists per build,
 // selected in ota_backend_factory.h where this concept is asserted on
 // make_ota_backend()'s return type. Semantics beyond the signatures:
-// - begin: prepare for an image of the given size; 0 means the size is unknown
-//   (web_server upload) and the backend allows the largest image it can take.
-//   ota_type defaults to an app update, so both call forms must be accepted.
+// - begin: prepare for an image of the given size; ota_type defaults to an
+//   app update, so both call forms must be accepted.
 // - set_update_md5: expected digest of the incoming image, hex string.
 // - write: consume the next chunk; end: finalize and mark bootable.
 // - abort: safe to call in any state, including after end().
@@ -9,12 +9,6 @@

 #include <Updater.h>

-// LittleFS region bounds, provided by the arduino-pico linker script.
-// NOLINTNEXTLINE(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp)
-extern "C" uint8_t _FS_start;
-// NOLINTNEXTLINE(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp)
-extern "C" uint8_t _FS_end;
-
 namespace esphome::ota {

 static const char *const TAG = "ota";
@@ -25,11 +19,8 @@ OTAResponseTypes ArduinoRP2OTABackend::begin(size_t image_size, OTAType ota_type
  if (ota_type != OTA_TYPE_UPDATE_APP) {
    return OTA_RESPONSE_ERROR_UNSUPPORTED_OTA_TYPE;
  }
-  // 0 means the size is unknown (web_server upload). The updater only checks the size
-  // against the LittleFS region it stages the image in, so ask for all of it.
-  if (image_size == 0) {
-    image_size = reinterpret_cast<uintptr_t>(&_FS_end) - reinterpret_cast<uintptr_t>(&_FS_start);
-  }
+  // OTA size of 0 is not currently handled, but
+  // web_server is not supported for RP2040, so this is not an issue.
  bool ret = Update.begin(image_size, U_FLASH);
  if (ret) {
    rp2::preferences_prevent_write(true);
@@ -43,7 +34,7 @@ OTAResponseTypes ArduinoRP2OTABackend::begin(size_t image_size, OTAType ota_type
    return OTA_RESPONSE_ERROR_WRONG_NEW_FLASH_CONFIG;
  if (error == UPDATE_ERROR_FLASH_CONFIG)
    return OTA_RESPONSE_ERROR_WRONG_CURRENT_FLASH_CONFIG;
-  if (error == UPDATE_ERROR_SPACE || error == UPDATE_ERROR_SIZE)
+  if (error == UPDATE_ERROR_SPACE)
    return OTA_RESPONSE_ERROR_RP2040_NOT_ENOUGH_SPACE;

  ESP_LOGE(TAG, "Begin error: %d", error);
@@ -194,8 +194,6 @@ def _parse_platform_version(value: Any) -> str:
 #  * The new version needs to be thoroughly validated before changing the
 #    recommended version as otherwise a bunch of devices could be bricked
 #  * For all constants below, update platformio.ini (in this repo)
-#  * rp2_pio pins its own pioasm build (PIOASM_REPO_VERSION in rp2_pio/__init__.py); check
-#    https://github.com/earlephilhower/pico-quick-toolchain/releases for a matching release

 # The default/recommended arduino framework version
 #  - https://github.com/earlephilhower/arduino-pico/releases
@@ -7,9 +7,9 @@ from esphome.types import ConfigType
 DEPENDENCIES = ["rp2"]


-PIOASM_REPO_VERSION = "4.1.0"
+PIOASM_REPO_VERSION = "1.5.0-b"
 PIOASM_REPO_BASE = f"https://github.com/earlephilhower/pico-quick-toolchain/releases/download/{PIOASM_REPO_VERSION}"
-PIOASM_VERSION = "pioasm-9fdfe11.250530"
+PIOASM_VERSION = "pioasm-2e6142b.230216"
 PIOASM_DOWNLOADS = {
    "linux": {
        "aarch64": f"aarch64-linux-gnu.{PIOASM_VERSION}.tar.gz",
@@ -20,8 +20,8 @@ PIOASM_DOWNLOADS = {
        "amd64": f"x86_64-w64-mingw32.{PIOASM_VERSION}.zip",
    },
    "darwin": {
-        "x86_64": f"x86_64-apple-darwin20.4.{PIOASM_VERSION}.tar.gz",
-        "arm64": f"aarch64-apple-darwin20.4.{PIOASM_VERSION}.tar.gz",
+        "x86_64": f"x86_64-apple-darwin14.{PIOASM_VERSION}.tar.gz",
+        "arm64": f"x86_64-apple-darwin14.{PIOASM_VERSION}.tar.gz",
    },
 }

@@ -295,11 +295,8 @@ template<class C, typename... Ts> class ScriptWaitAction final : public Action<T
  }

  void loop() override {
-    if (this->num_running_ == 0) {
-      // Nothing left to wait for, e.g. once the last queued item has run
-      this->disable_loop();
+    if (this->num_running_ == 0)
      return;
-    }

    if (this->script_->is_running())
      return;
@@ -308,10 +305,9 @@ template<class C, typename... Ts> class ScriptWaitAction final : public Action<T
    // Processing all items in a while loop causes infinite loops because
    // play_next_() can trigger more items to be queued
    if (!this->param_queue_.empty()) {
-      // Take the item out first: the chain may call stop(), which clears the queue
-      auto params = std::move(this->param_queue_.front());
+      auto &params = this->param_queue_.front();
+      this->play_next_tuple_(params, std::make_index_sequence<sizeof...(Ts)>{});
      this->param_queue_.pop_front();
-      std::apply([this](auto &...args) { this->play_next_(args...); }, params);
    } else {
      // Queue is now empty - disable loop until next play_complex
      this->disable_loop();
@@ -327,8 +323,12 @@ template<class C, typename... Ts> class ScriptWaitAction final : public Action<T
  }

 protected:
+  template<size_t... S> void play_next_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
+    this->play_next_(std::get<S>(tuple)...);
+  }
+
  C *script_;
-  std::list<std::tuple<stored_trigger_arg_t<Ts>...>> param_queue_;
+  std::list<std::tuple<Ts...>> param_queue_;
 };

 }  // namespace esphome::script
@@ -9,8 +9,6 @@ namespace esphome::seeed_mr24hpc1 {

 static const char *const TAG = "seeed_mr24hpc1";

-static constexpr uint32_t STARTUP_DELAY_MS = 1000;
-
 // Prints the component's configuration data. dump_config() prints all of the component's configuration
 // items in an easy-to-read format, including the configuration key-value pairs.
 void MR24HPC1Component::dump_config() {
@@ -78,7 +76,8 @@ void MR24HPC1Component::setup() {
    this->custom_mode_end_text_sensor_->publish_state("Not in custom mode");
  }
 #endif
-  this->poll_time_base_func_check_ = false;
+  this->set_custom_end_mode();
+  this->poll_time_base_func_check_ = true;
  this->check_dev_inf_sign_ = true;
  this->sg_start_query_data_ = STANDARD_FUNCTION_QUERY_PRODUCT_MODE;
  this->sg_data_len_ = 0;
@@ -93,13 +92,7 @@ void MR24HPC1Component::setup() {
  memset(this->sg_frame_prase_buf_, 0, FRAME_BUF_MAX_SIZE);
  memset(this->sg_frame_buf_, 0, FRAME_BUF_MAX_SIZE);

-  // The module locks up when queried during its own boot, so hold all TX for a second
-  this->set_timeout(STARTUP_DELAY_MS, [this]() {
-    this->module_ready_ = true;
-    this->set_custom_end_mode();
-    this->poll_time_base_func_check_ = true;
-    this->set_interval(8000, [this]() { this->update_(); });
-  });
+  this->set_interval(8000, [this]() { this->update_(); });
 }

 // Timed polling of radar data
@@ -693,8 +686,6 @@ void MR24HPC1Component::r24_frame_parse_human_information_(uint8_t *data) {

 // Sending data frames
 void MR24HPC1Component::send_query_(const uint8_t *query, size_t string_length) {
-  if (!this->module_ready_)
-    return;
  this->write_array(query, string_length);
 }

@@ -153,7 +153,6 @@ class MR24HPC1Component final : public Component,
  int sg_start_query_data_;
  bool check_dev_inf_sign_;
  bool poll_time_base_func_check_;
-  bool module_ready_{false};

  void update_();
  void r24_split_data_frame_(uint8_t value);
@@ -1,11 +1,9 @@
 from dataclasses import dataclass, field
-import logging
-from typing import Any

 from esphome import automation
 import esphome.codegen as cg
 from esphome.components import esp32, mdns, network, psram, socket, wifi
-from esphome.components.const import CONF_ENABLED, CONF_MANUFACTURER
+from esphome.components.const import CONF_MANUFACTURER
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_BUFFER_SIZE,
@@ -27,8 +25,6 @@ from esphome.core import CORE
 from esphome.cpp_generator import MockObj
 from esphome.types import ConfigType

-_LOGGER = logging.getLogger(__name__)
-
 # mdns for autodiscovery
 AUTO_LOAD = ["mdns"]
 CODEOWNERS = ["@kahrendt"]
@@ -50,33 +46,6 @@ CONF_FIXED_DELAY = "fixed_delay"
 CONF_DECODE_MEMORY = "decode_memory"
 CONF_CODECS = "codecs"

-CONF_STATIC_PAIRING_CODE = "static_pairing_code"
-CONF_UNPAIRED_ACCESS = "unpaired_access"
-CONF_ON_OPEN_PAIRING_WINDOW = "on_open_pairing_window"
-CONF_ON_CLOSE_PAIRING_WINDOW = "on_close_pairing_window"
-CONF_ON_DISPLAY_PAIRING_CODE = "on_display_pairing_code"
-CONF_ON_CLEAR_PAIRING_CODE = "on_clear_pairing_code"
-CONF_ON_PAIRING_SUCCEEDED = "on_pairing_succeeded"
-CONF_ON_PAIRING_FAILED = "on_pairing_failed"
-
-# A static pairing code is exactly 8 decimal digits.
-STATIC_PAIRING_CODE_DIGITS = 8
-
-
-def _validate_static_pairing_code(value: Any) -> str:
-    # string_strict so leading zeros survive and `!secret` works.
-    value = cv.string_strict(value)
-    if len(value) != STATIC_PAIRING_CODE_DIGITS or not (
-        value.isascii() and value.isdigit()
-    ):
-        raise cv.Invalid(
-            f"{CONF_STATIC_PAIRING_CODE} must be exactly "
-            f"{STATIC_PAIRING_CODE_DIGITS} decimal digits "
-            '(quote the value so leading zeros are preserved, e.g. "01234567")'
-        )
-    return value
-
-
 # Matches ARTWORK_MAX_SLOTS in sendspin-cpp.
 MAX_ARTWORK_SLOTS = 4

@@ -107,6 +76,7 @@ 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")
+IMAGE_FORMAT_BMP = SendspinImageFormat.enum("BMP")

 SendspinImageSource = sendspin_library_ns.enum("SendspinImageSource", is_class=True)
 IMAGE_SOURCE_ALBUM = SendspinImageSource.enum("ALBUM")
@@ -139,34 +109,6 @@ SendspinHub = sendspin_ns.class_(
 )


-_CALLBACK_AUTOMATIONS = (
-    automation.CallbackAutomation(
-        CONF_ON_OPEN_PAIRING_WINDOW, "add_on_open_pairing_window_callback"
-    ),
-    automation.CallbackAutomation(
-        CONF_ON_CLOSE_PAIRING_WINDOW, "add_on_close_pairing_window_callback"
-    ),
-    automation.CallbackAutomation(
-        CONF_ON_DISPLAY_PAIRING_CODE,
-        "add_on_display_pairing_code_callback",
-        [(cg.std_string, "code")],
-    ),
-    automation.CallbackAutomation(
-        CONF_ON_CLEAR_PAIRING_CODE, "add_on_clear_pairing_code_callback"
-    ),
-    automation.CallbackAutomation(
-        CONF_ON_PAIRING_SUCCEEDED,
-        "add_on_pairing_succeeded_callback",
-        [(cg.std_string, "server_id")],
-    ),
-    automation.CallbackAutomation(
-        CONF_ON_PAIRING_FAILED,
-        "add_on_pairing_failed_callback",
-        [(cg.std_string, "server_id"), (cg.StringRef, "reason")],
-    ),
-)
-
-
@dataclass
 class SendspinConfiguration:
    artwork_support: bool = False
@@ -174,8 +116,6 @@ class SendspinConfiguration:
    metadata_support: bool = False
    player_support: bool = False
    visualizer_support: bool = False
-    pairing_code_display_support: bool = False
-    switch_types: set[str] = field(default_factory=set)

    artwork_preferences: list[ConfigType] = field(default_factory=list)
    player_config: ConfigType | None = None
@@ -212,16 +152,6 @@ def request_visualizer_support() -> None:
    _get_data().visualizer_support = True


-def request_pairing_code_display_support() -> None:
-    """Mark that the device can emit a dynamic pairing code (e.g. a pairing_code text sensor)."""
-    _get_data().pairing_code_display_support = True
-
-
-def request_switch(switch_type: str) -> None:
-    """Mark that a sendspin switch of this type drives the matching hub setting."""
-    _get_data().switch_types.add(switch_type)
-
-
 def register_artwork_preference(config: ConfigType) -> int:
    """Register an artwork slot preference and return the slot it was given.

@@ -278,85 +208,28 @@ CONFIG_SCHEMA = cv.All(
            cv.Optional(CONF_MANUFACTURER): DEVICE_INFO_STRING,
            cv.Optional(CONF_MODEL): DEVICE_INFO_STRING,
            cv.Optional(CONF_FIRMWARE_VERSION): DEVICE_INFO_STRING,
-            cv.Optional(CONF_STATIC_PAIRING_CODE): cv.sensitive(
-                _validate_static_pairing_code
-            ),
-            # No default: the unpaired access switch rejects this key when it is set.
-            cv.Optional(CONF_UNPAIRED_ACCESS): cv.boolean,
-            cv.Optional(CONF_ON_OPEN_PAIRING_WINDOW): automation.validate_automation(
-                {}
-            ),
-            cv.Optional(CONF_ON_CLOSE_PAIRING_WINDOW): automation.validate_automation(
-                {}
-            ),
-            cv.Optional(CONF_ON_DISPLAY_PAIRING_CODE): automation.validate_automation(
-                {}
-            ),
-            cv.Optional(CONF_ON_CLEAR_PAIRING_CODE): automation.validate_automation({}),
-            cv.Optional(CONF_ON_PAIRING_SUCCEEDED): automation.validate_automation({}),
-            cv.Optional(CONF_ON_PAIRING_FAILED): automation.validate_automation({}),
        }
    ),
    cv.only_on_esp32,
-    # sendspin-cpp needs noise-c as an ESP-IDF component, which Arduino below IDF 6.0 cannot use.
-    cv.only_with_framework("esp-idf"),
    _request_high_performance_networking,
 )


-def _offers_dynamic_pairing_code(config: ConfigType) -> bool:
-    """Whether the device can show a dynamic pairing code, so dynamic_pairing_code is advertised."""
-    return bool(
-        config.get(CONF_ON_DISPLAY_PAIRING_CODE)
-        or _get_data().pairing_code_display_support
-    )
-
-
-def _has_pairing_method(config: ConfigType) -> bool:
-    """Whether the config gives a server any way to pair with the device."""
-    return CONF_STATIC_PAIRING_CODE in config or _offers_dynamic_pairing_code(config)
-
-
-def _final_validate(config: ConfigType) -> ConfigType:
-    dynamic_code = _offers_dynamic_pairing_code(config)
-    # The protocol allows only one pairing code method.
-    if dynamic_code and CONF_STATIC_PAIRING_CODE in config:
-        raise cv.Invalid(
-            f"'{CONF_STATIC_PAIRING_CODE}' cannot be used with a dynamic pairing code "
-            f"({CONF_ON_DISPLAY_PAIRING_CODE} or a pairing_code text sensor), since only "
-            "one pairing code method can be offered",
-            path=[CONF_STATIC_PAIRING_CODE],
-        )
-    if not config.get(CONF_UNPAIRED_ACCESS, True) and not _has_pairing_method(config):
-        _LOGGER.warning(
-            "'%s' is off but there is no pairing method (%s or a dynamic pairing code), so no "
-            "new server can pair with this device",
-            CONF_UNPAIRED_ACCESS,
-            CONF_STATIC_PAIRING_CODE,
-        )
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
 def _request_controller_role(config: ConfigType) -> ConfigType:
    """Request the controller role for the sendspin.switch action."""
    request_controller_support()
    return config


-# Selects the hub. sendspin.switch adds the controller role it needs; the pairing window actions need no role.
-SENDSPIN_HUB_ACTION_SCHEMA = automation.maybe_simple_id(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.use_id(SendspinHub),
-        }
-    )
-)
-
 SENDSPIN_SIMPLE_ACTION_SCHEMA = cv.All(
-    SENDSPIN_HUB_ACTION_SCHEMA, _request_controller_role
+    automation.maybe_simple_id(
+        cv.Schema(
+            {
+                cv.GenerateID(): cv.use_id(SendspinHub),
+            }
+        )
+    ),
+    _request_controller_role,
 )


@@ -367,19 +240,6 @@ automation.register_apply_action(
 )


-automation.register_apply_action(
-    "sendspin.confirm_pairing_window",
-    SENDSPIN_HUB_ACTION_SCHEMA,
-    automation.ApplyCall("confirm_pairing_window()"),
-)
-
-automation.register_apply_action(
-    "sendspin.cancel_pairing_window",
-    SENDSPIN_HUB_ACTION_SCHEMA,
-    automation.ApplyCall("cancel_pairing_window()"),
-)
-
-
 async def to_code(config: ConfigType) -> None:
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
@@ -404,27 +264,10 @@ async def to_code(config: ConfigType) -> None:
        if value:
            cg.add(setter(value))

-    if (code := config.get(CONF_STATIC_PAIRING_CODE)) is not None:
-        cg.add(var.set_static_pairing_code(code))
-
-    # The client starts once both are set: here, or by the switch that drives the setting.
-    switch_types = _get_data().switch_types
-    if CONF_ENABLED not in switch_types:
-        cg.add(var.set_enabled(True))
-    if CONF_UNPAIRED_ACCESS not in switch_types:
-        cg.add(var.set_unpaired_access_enabled(config.get(CONF_UNPAIRED_ACCESS, True)))
-
-    if _offers_dynamic_pairing_code(config):
-        cg.add(var.set_pairing_code_display_supported(True))
-
-    await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
-
    # sendspin-cpp library
-    esp32.add_idf_component(name="sendspin/sendspin-cpp", ref="0.9.3")
-    # esp_websocket_client links esp_tls even for ws:// connections.
-    esp32.request_tls()
+    esp32.add_idf_component(name="sendspin/sendspin-cpp", ref="0.8.0")

-    cg.add_define("USE_SENDSPIN", True)  # for MDNS and the native API
+    cg.add_define("USE_SENDSPIN", True)  # for MDNS

    # Service starts disabled and the hub enables it; always advertised where unsupported
    if mdns.request_service_enable_disable():
@@ -433,9 +276,8 @@ async def to_code(config: ConfigType) -> None:

    data = _get_data()

-    # The color and source roles are not yet wired up in ESPHome; disable them in the library for now.
+    # The color role is not yet wired up in ESPHome; disable it in the library for now.
    esp32.add_idf_sdkconfig_option("CONFIG_SENDSPIN_ENABLE_COLOR", False)
-    esp32.add_idf_sdkconfig_option("CONFIG_SENDSPIN_ENABLE_SOURCE", False)

    # Configure Sendspin roles based on requested features (ESPHome internally via USE_SENDSPIN_*)
    # and disable building unused code paths in the sendspin-cpp library (IDF SDKConfig via CONFIG_SENDSPIN_ENABLE_*).
@@ -509,8 +351,7 @@ async def to_code(config: ConfigType) -> None:
            ("audio_formats", audio_format_structs),
            ("audio_buffer_capacity", player_cfg[CONF_BUFFER_SIZE]),
            ("fixed_delay_us", player_cfg[CONF_FIXED_DELAY]),
-            # The released YAML key name is kept for compatibility.
-            ("initial_output_delay_ms", player_cfg[CONF_INITIAL_STATIC_DELAY]),
+            ("initial_static_delay_ms", player_cfg[CONF_INITIAL_STATIC_DELAY]),
            ("psram_stack", psram_stack),
        ]
        if (decode_memory := player_cfg.get(CONF_DECODE_MEMORY)) is not None:
@@ -525,9 +366,6 @@ async def to_code(config: ConfigType) -> None:
    else:
        esp32.add_idf_sdkconfig_option("CONFIG_SENDSPIN_ENABLE_PLAYER", False)

-    if not data.player_support or CODEC_OPUS not in data.player_config[CONF_CODECS]:
-        esp32.add_idf_sdkconfig_option("CONFIG_SENDSPIN_ENABLE_OPUS", False)
-
    if data.visualizer_support:
        cg.add_define("USE_SENDSPIN_VISUALIZER", True)
    else:
@@ -1,7 +1,5 @@
 """Sendspin image platform."""

-from typing import Any
-
 from esphome import automation
 import esphome.codegen as cg
 from esphome.components import runtime_image
@@ -23,6 +21,7 @@ from esphome.types import ConfigType
 from .. import (
    CONF_DISPLAY_OFFSET,
    CONF_SENDSPIN_ID,
+    IMAGE_FORMAT_BMP,
    IMAGE_FORMAT_JPEG,
    IMAGE_FORMAT_PNG,
    IMAGE_SOURCE_ALBUM,
@@ -58,16 +57,9 @@ _FORMAT_TO_SENDSPIN_ENUM = {
    "JPEG": IMAGE_FORMAT_JPEG,
    "JPG": IMAGE_FORMAT_JPEG,
    "PNG": IMAGE_FORMAT_PNG,
+    "BMP": IMAGE_FORMAT_BMP,
 }

-
-# Remove before 2027.4.0
-def _reject_bmp(value: Any) -> Any:
-    if isinstance(value, str) and value.upper() == "BMP":
-        raise cv.Invalid("BMP artwork is no longer supported, use JPEG or PNG instead.")
-    return value
-
-
 # The library's SendspinImageSource::NONE is its internal "unset" sentinel; a slot advertising it
 # would never receive artwork while still paying for two frame buffers, so it is not offered here.
 IMAGE_SOURCES = {
@@ -129,9 +121,7 @@ CONFIG_SCHEMA = cv.All(
            cv.GenerateID(CONF_SENDSPIN_ID): cv.use_id(SendspinHub),
            # Narrow runtime_image's format list to what the library can request, so the
            # accepted set and the enum map below cannot drift apart.
-            cv.Required(CONF_FORMAT): cv.All(
-                _reject_bmp, cv.one_of(*_FORMAT_TO_SENDSPIN_ENUM, upper=True)
-            ),
+            cv.Required(CONF_FORMAT): cv.one_of(*_FORMAT_TO_SENDSPIN_ENUM, upper=True),
            cv.Required(CONF_RESIZE): cv.dimensions,
            cv.Required(CONF_CURRENT_IMAGE): _IMAGE_SCHEMA,
            cv.Optional(CONF_TRANSITION_IMAGE): _IMAGE_SCHEMA,
@@ -1,6 +1,6 @@
 #include "sendspin_image.h"

-#if defined(USE_ESP_IDF) && defined(USE_SENDSPIN_ARTWORK)
+#if defined(USE_ESP32) && defined(USE_SENDSPIN_ARTWORK)

 #include "esphome/core/log.h"

@@ -125,7 +125,7 @@ bool SendspinImageSlot::decode_frame_(const uint8_t *data, size_t length, const
  }

  // A decode that asked for other dimensions had the buffer taken away from it, so it painted
-  // nothing (or stopped partway). JPEG reports that as an error above; PNG carries on
+  // nothing (or stopped partway). JPEG and BMP report that as an error above; PNG carries on
  // regardless, so the frame is dropped here.
  return this->decode_sink_.decoded_into(target);
 }
@@ -2,7 +2,7 @@

 #include "esphome/core/defines.h"

-#if defined(USE_ESP_IDF) && defined(USE_SENDSPIN_ARTWORK)
+#if defined(USE_ESP32) && defined(USE_SENDSPIN_ARTWORK)

 #include "esphome/components/image/image.h"
 #include "esphome/components/runtime_image/runtime_image.h"
@@ -29,7 +29,7 @@ class ArtworkDecodeSink : public runtime_image::RuntimeImage {
  /// @brief True when the decode ended with the given buffer still in place.
  ///
  /// An external buffer is dropped rather than resized, so a decode that wanted other dimensions
-  /// leaves the sink holding nothing. The JPEG decoder reports that as a decode error, but
+  /// leaves the sink holding nothing. The JPEG and BMP decoders report that as a decode error, but
  /// the PNG decoder ignores it and reports success, so the outcome is checked here as well.
  bool decoded_into(const uint8_t *buffer) const { return this->buffer_ == buffer; }
 };
@@ -1,6 +1,6 @@
 #include "sendspin_media_player.h"

-#if defined(USE_ESP_IDF) && defined(USE_MEDIA_PLAYER) && defined(USE_SENDSPIN_CONTROLLER)
+#if defined(USE_ESP32) && defined(USE_MEDIA_PLAYER) && defined(USE_SENDSPIN_CONTROLLER)

 #include "esphome/core/application.h"
 #include "esphome/core/log.h"
@@ -2,7 +2,7 @@

 #include "esphome/core/defines.h"

-#if defined(USE_ESP_IDF) && defined(USE_MEDIA_PLAYER) && defined(USE_SENDSPIN_CONTROLLER)
+#if defined(USE_ESP32) && defined(USE_MEDIA_PLAYER) && defined(USE_SENDSPIN_CONTROLLER)

 #include "esphome/components/media_player/media_player.h"
 #include "esphome/components/sendspin/sendspin_hub.h"
@@ -11,9 +11,7 @@ from esphome.const import (
 from esphome.types import ConfigType

 from .. import (
-    CODEC_FLAC,
    CODEC_OPUS,
-    CODEC_PCM,
    CODECS,
    CONF_CODECS,
    CONF_DECODE_MEMORY,
@@ -60,11 +58,6 @@ def _resolve_codecs(config: ConfigType) -> ConfigType:
            f"Codec '{CODEC_OPUS}' requires a {CONF_SAMPLE_RATE} of {OPUS_SAMPLE_RATE}",
            path=[CONF_CODECS],
        )
-    if CODEC_FLAC not in codecs and CODEC_PCM not in codecs:
-        raise cv.Invalid(
-            f"Codecs must include '{CODEC_FLAC}' or '{CODEC_PCM}'",
-            path=[CONF_CODECS],
-        )
    return config


@@ -1,6 +1,6 @@
 #include "sendspin_media_source.h"

-#if defined(USE_ESP_IDF) && defined(USE_SENDSPIN_CONTROLLER) && defined(USE_SENDSPIN_PLAYER)
+#if defined(USE_ESP32) && defined(USE_SENDSPIN_CONTROLLER) && defined(USE_SENDSPIN_PLAYER)

 #include "esphome/components/audio/audio.h"
 #include "esphome/core/log.h"
@@ -24,7 +24,7 @@ void SendspinMediaSource::setup() {
  // Push cached states to player role. They may have been set before setup() ran.
  this->player_role_->update_volume(std::roundf(this->cached_volume_ * 100.0f));
  this->player_role_->update_muted(this->cached_muted_);
-  this->player_role_->set_output_delay_adjustable(this->static_delay_adjustable_);
+  this->player_role_->set_static_delay_adjustable(this->static_delay_adjustable_);
 }

 void SendspinMediaSource::dump_config() {
@@ -35,7 +35,7 @@ void SendspinMediaSource::dump_config() {
 void SendspinMediaSource::set_static_delay_adjustable(bool adjustable) {
  this->static_delay_adjustable_ = adjustable;
  if (this->player_role_) {
-    this->player_role_->set_output_delay_adjustable(adjustable);
+    this->player_role_->set_static_delay_adjustable(adjustable);
  }
 }

@@ -102,8 +102,8 @@ void SendspinMediaSource::handle_command(media_source::MediaSourceCommand comman
      if (!this->pending_start_) {
        // Ignore stop commands if we have a pending start, since the orchestrator may send a stop command before
        // play_uri
-        ESP_LOGD(TAG, "Received STOP command, leaving the Sendspin group");
-        this->parent_->leave_group();
+        ESP_LOGD(TAG, "Received STOP command, updating Sendspin state to EXTERNAL_SOURCE");
+        this->parent_->update_state(sendspin::SendspinClientState::EXTERNAL_SOURCE);
      }
      break;
    }
@@ -185,6 +185,8 @@ size_t SendspinMediaSource::on_audio_write(uint8_t *data, size_t length, uint32_

 // THREAD CONTEXT: Main loop (PlayerRoleListener lifecycle callback)
 void SendspinMediaSource::on_stream_start() {
+  this->parent_->update_state(sendspin::SendspinClientState::SYNCHRONIZED);
+
  if (!this->pending_start_) {
    // Dedup rapid on_stream_start() calls
    this->pending_start_ = true;
@@ -209,4 +211,4 @@ void SendspinMediaSource::on_mute_changed(bool muted) { this->request_mute_(mute

 }  // namespace esphome::sendspin_

-#endif  // USE_ESP_IDF && USE_SENDSPIN_PLAYER && USE_SENDSPIN_CONTROLLER
+#endif  // USE_ESP32 && USE_SENDSPIN_PLAYER && USE_SENDSPIN_CONTROLLER
@@ -2,7 +2,7 @@

 #include "esphome/core/defines.h"

-#if defined(USE_ESP_IDF) && defined(USE_SENDSPIN_CONTROLLER) && defined(USE_SENDSPIN_PLAYER)
+#if defined(USE_ESP32) && defined(USE_SENDSPIN_CONTROLLER) && defined(USE_SENDSPIN_PLAYER)

 #include "esphome/components/sendspin/sendspin_hub.h"

@@ -1,6 +1,6 @@
 #include "sendspin_hub.h"

-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32

 #include "esphome/components/network/util.h"
 #ifdef USE_ETHERNET
@@ -17,122 +17,26 @@

 #include <esp_log.h>

-#include <cstring>
-#include <memory>
-
 namespace esphome::sendspin_ {

 static const char *const TAG = "sendspin.hub";

-namespace {
-
-// The reason passed to on_pairing_failed automations, in the protocol's own spelling.
-StringRef pair_abort_reason_to_string(sendspin::SendspinPairAbortReason reason) {
-  using sendspin::SendspinPairAbortReason;
-  switch (reason) {
-    case SendspinPairAbortReason::ATTEMPT_TIMEOUT:
-      return StringRef::from_lit("attempt_timeout");
-    case SendspinPairAbortReason::CONCURRENT_ATTEMPT:
-      return StringRef::from_lit("concurrent_attempt");
-    case SendspinPairAbortReason::METHOD_NOT_SUPPORTED:
-      return StringRef::from_lit("method_not_supported");
-    case SendspinPairAbortReason::PAIRING_CODE_MISMATCH:
-      return StringRef::from_lit("pairing_code_mismatch");
-    case SendspinPairAbortReason::USER_CANCELLED:
-      return StringRef::from_lit("user_cancelled");
-    case SendspinPairAbortReason::UNKNOWN:
-      break;
-  }
-  return StringRef::from_lit("unknown");
-}
-
-// Zeroes through a volatile pointer so dead-store elimination cannot drop it.
-void secure_wipe(void *data, size_t len) {
-  volatile auto *p = static_cast<volatile uint8_t *>(data);
-  for (size_t i = 0; i < len; ++i) {
-    p[i] = 0;
-  }
-}
-
-// Call once per key, from setup().
-ESPPreferenceObject make_blob_pref(const std::string &name, size_t size) {
-  return global_preferences->make_preference(size, fnv1a_hash("sendspin_" + name));
-}
-
-// Loads straight into the returned buffer, which the library wipes after use. A failed load can
-// leave part of a stored private key or PSK behind, so that path wipes it here. This only covers
-// this buffer: the preference backend keeps its own copy of a pending write until it syncs.
-std::optional<std::vector<uint8_t>> read_blob(ESPPreferenceObject &pref, size_t size) {
-  std::vector<uint8_t> out(size);
-  if (!pref.load(out.data(), out.size())) {
-    secure_wipe(out.data(), out.size());
-    return std::nullopt;
-  }
-  return out;
-}
-
-// The library always writes a key's fixed size; any other length is misuse and is not stored.
-bool write_blob(ESPPreferenceObject &pref, const char *key, size_t size, const uint8_t *data, size_t len) {
-  if (len != size) {
-    ESP_LOGW(TAG, "\"%s\" blob of %zu bytes does not match its size of %zu; rejecting write", key, len, size);
-    return false;
-  }
-  if (!pref.save(data, len)) {
-    ESP_LOGW(TAG, "Failed to persist \"%s\" blob (%zu bytes)", key, len);
-    return false;
-  }
-  return true;
-}
-
-// "rec_<n>" to n; nullopt for any other key or a slot with no storage here.
-std::optional<size_t> parse_record_slot(const std::string &key) {
-  const char *const prefix = sendspin::persistence_keys::RECORD_SLOT_PREFIX;
-  const size_t prefix_len = std::strlen(prefix);
-  if (key.size() <= prefix_len || key.compare(0, prefix_len, prefix) != 0) {
-    return std::nullopt;
-  }
-  size_t slot = 0;
-  for (size_t i = prefix_len; i < key.size(); i++) {
-    const char c = key[i];
-    if (c < '0' || c > '9') {
-      return std::nullopt;
-    }
-    slot = slot * 10 + static_cast<size_t>(c - '0');
-    if (slot >= SENDSPIN_RECORD_SLOTS) {
-      return std::nullopt;
-    }
-  }
-  return slot;
-}
-
-}  // namespace
-
 #ifdef USE_SENDSPIN_ARTWORK
 // Indexed by the library enums, which start at zero and are contiguous.
 static const char *const IMAGE_SOURCE_NAMES[] = {"ALBUM", "ARTIST", "NONE"};
-static const char *const IMAGE_FORMAT_NAMES[] = {"JPEG", "PNG"};
+static const char *const IMAGE_FORMAT_NAMES[] = {"JPEG", "PNG", "BMP"};
 #endif

-SendspinHub *global_sendspin_hub = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
-SendspinHub::SendspinHub() { global_sendspin_hub = this; }
-
 void SendspinHub::setup() {
  auto config = this->build_client_config_();
  this->client_ = std::make_unique<sendspin::SendspinClient>(std::move(config));

-  // Set up persistence (preferences must be initialized before providers are added to the client). These key names
-  // are frozen; see PREFERENCE KEYS in sendspin_hub.h.
-  namespace keys = sendspin::persistence_keys;
-  this->keypair_pref_ = make_blob_pref("keypair", keys::KEYPAIR_SIZE);
-  this->pairing_psk_pref_ = make_blob_pref("pair_psk", keys::PAIRING_PSK_SIZE);
-  this->last_played_pref_ = make_blob_pref("last_played", keys::LAST_PLAYED_SIZE);
-  // Released firmware's name, so a calibrated delay survives.
-  this->output_delay_pref_ = make_blob_pref("static_delay", keys::OUTPUT_DELAY_SIZE);
-  for (size_t slot = 0; slot < SENDSPIN_RECORD_SLOTS; slot++) {
-    this->record_slot_prefs_[slot] = make_blob_pref(keys::record_slot_key(slot), keys::RECORD_SLOT_SIZE);
-  }
-  this->record_order_pref_ = make_blob_pref(keys::RECORD_ORDER, SENDSPIN_RECORD_SLOTS);
+  // Set up persistence (preferences must be initialized before providers are added to the client)
+  this->last_played_server_pref_ =
+      global_preferences->make_preference<LastPlayedServerPref>(fnv1a_hash("sendspin_last_played"));
+#ifdef USE_SENDSPIN_PLAYER
+  this->static_delay_pref_ = global_preferences->make_preference<StaticDelayPref>(fnv1a_hash("sendspin_static_delay"));
+#endif

  // Wire providers and client listener
  this->client_->set_listener(this);
@@ -158,15 +62,14 @@ void SendspinHub::setup() {
  this->client_->add_player(this->player_config_).set_listener(this->player_listener_);
 #endif

-  // Set before setup() by codegen; an unpaired access switch sets it later, from its own setup().
-  if (this->unpaired_access_.has_value()) {
-    this->client_->set_unpaired_access_enabled(*this->unpaired_access_);
-  }
+#ifndef USE_SENDSPIN_SWITCH
+  this->enabled_ = true;
+#endif
 }

 void SendspinHub::loop() {
-  if (this->enabled_.has_value() && this->unpaired_access_.has_value() &&
-      this->enabled_.value() != this->client_->is_started() && !this->status_has_error()) {
+  if (this->enabled_.has_value() && this->enabled_.value() != this->client_->is_started() &&
+      !this->status_has_error()) {
    if (!this->enabled_.value()) {
      this->client_->stop();
    } else if (!this->client_->start()) {
@@ -180,37 +83,17 @@ void SendspinHub::loop() {
 #endif
 }

-// Sends each server a goodbye and writes what the client still owed its provider. Wi-Fi sets up
-// before this hub, so it shuts down after it and the goodbyes can still go out.
-void SendspinHub::on_shutdown() {
-  // Keeps loop() from starting the client again.
-  this->enabled_ = false;
-  if (this->is_client_running()) {
-    this->client_->stop();
-  }
-}
-
 void SendspinHub::dump_config() {
-  // client_id exists only once start() has run.
-  const char *client_id = "(unavailable)";
-  if (this->client_ != nullptr && !this->client_->client_id().empty()) {
-    client_id = this->client_->client_id().c_str();
-  }
  char mac_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
  ESP_LOGCONFIG(TAG,
                "Sendspin Hub:\n"
                "  Client ID: %s\n"
-                "  MAC address: %s\n"
                "  Manufacturer: %s\n"
                "  Model: %s\n"
                "  Firmware version: %s\n"
-                "  Task stack in PSRAM: %s\n"
-                "  Unpaired access: %s\n"
-                "  Pairing code method: %s",
-                client_id, get_mac_address_into_buffer(mac_buf), this->manufacturer_, this->get_product_name_(),
-                this->firmware_version_, YESNO(this->task_stack_in_psram_),
-                YESNO(this->client_ != nullptr && this->client_->is_unpaired_access_enabled()),
-                this->pairing_code_method_());
+                "  Task stack in PSRAM: %s",
+                get_client_id_into_buffer(mac_buf), this->manufacturer_, this->get_product_name_(),
+                this->firmware_version_, YESNO(this->task_stack_in_psram_));

 #ifdef USE_SENDSPIN_ARTWORK
  // Slot indices come from the order the image platform entries were declared, so the log is the
@@ -225,7 +108,7 @@ void SendspinHub::dump_config() {
 #endif
 }

-// THREAD CONTEXT: Main loop (invoked from codegen before setup(), or from Sendspin components)
+// THREAD CONTEXT: Main loop (invoked from Sendspin components)
 void SendspinHub::set_enabled(bool enabled) {
  if (this->status_has_error()) {
    ESP_LOGE(TAG, "Cannot %s: Sendspin failed to start, reboot to retry",
@@ -235,31 +118,6 @@ void SendspinHub::set_enabled(bool enabled) {
  this->enabled_ = enabled;
 }

-// THREAD CONTEXT: Main loop
-std::optional<std::string> SendspinHub::get_pairing_token() const {
-  if (this->client_ == nullptr) {
-    return std::nullopt;
-  }
-  return this->client_->pairing_token();
-}
-
-// THREAD CONTEXT: Main loop
-StringRef SendspinHub::get_client_id() const {
-  if (this->client_ == nullptr) {
-    return StringRef();
-  }
-  return StringRef(this->client_->client_id());
-}
-
-// THREAD CONTEXT: Main loop (invoked from codegen before setup(), or from Sendspin components)
-void SendspinHub::set_unpaired_access_enabled(bool enabled) {
-  this->unpaired_access_ = enabled;
-  // Before setup() there is no client yet; setup() applies the stored value.
-  if (this->client_ != nullptr) {
-    this->client_->set_unpaired_access_enabled(enabled);
-  }
-}
-
 #ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
 // THREAD CONTEXT: Main loop
 void SendspinHub::update_mdns_service_() {
@@ -296,58 +154,22 @@ void SendspinHub::disconnect_from_server(sendspin::SendspinGoodbyeReason reason)
 }

 // THREAD CONTEXT: Main loop (invoked from Sendspin components)
-void SendspinHub::leave_group() {
-  if (this->is_client_running() &&
-      this->client_->get_group_state().playback_state == sendspin::SendspinPlaybackState::PLAYING) {
-    this->client_->leave();
-  }
-}
-
-// THREAD CONTEXT: Main loop (invoked from the sendspin.confirm_pairing_window action)
-void SendspinHub::confirm_pairing_window() {
+void SendspinHub::update_state(sendspin::SendspinClientState state) {
  if (this->is_client_running()) {
-    this->client_->confirm_pairing_window();
+    this->client_->update_state(state);
  }
 }

-// THREAD CONTEXT: Main loop (invoked from the sendspin.cancel_pairing_window action)
-void SendspinHub::cancel_pairing_window() {
-  if (this->is_client_running()) {
-    this->client_->cancel_pairing_window();
-  }
-}
-
-const char *SendspinHub::get_mac_address_into_buffer(std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf) {
-  // The server matches this MAC against the L2 source MAC of the device's multicast traffic.
+const char *SendspinHub::get_client_id_into_buffer(std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf) {
+  // The server matches client_id against the L2 source MAC of the device's multicast traffic.
  // ESP-IDF derives the ethernet MAC as base+3 by default on ESP32-S3, so we cannot use the
  // eFuse base MAC when ethernet is the active interface.
 #ifdef USE_ETHERNET
  if (ethernet::global_eth_component != nullptr) {
-    ethernet::global_eth_component->get_eth_mac_address_pretty_into_buffer(buf);
-  } else {
-    get_mac_address_pretty_into_buffer(buf);
+    return ethernet::global_eth_component->get_eth_mac_address_pretty_into_buffer(buf);
  }
-#else
-  get_mac_address_pretty_into_buffer(buf);
 #endif
-  // The pretty format is uppercase, but SendspinClientConfig::mac_address must be lowercase.
-  for (char &c : buf) {
-    if (c >= 'A' && c <= 'F') {
-      c += 'a' - 'A';
-    }
-  }
-  return buf.data();
-}
-
-// Validation rejects a static code together with the dynamic code, so at most one is set.
-const char *SendspinHub::pairing_code_method_() const {
-  if (this->pairing_code_display_supported_) {
-    return LOG_STR_LITERAL("dynamic");
-  }
-  if (this->static_pairing_code_ != nullptr) {
-    return LOG_STR_LITERAL("static");
-  }
-  return LOG_STR_LITERAL("none");
+  return get_mac_address_pretty_into_buffer(buf);
 }

 const char *SendspinHub::get_product_name_() const {
@@ -358,26 +180,12 @@ sendspin::SendspinClientConfig SendspinHub::build_client_config_() {
  sendspin::SendspinClientConfig config;

  char mac_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-  config.mac_address = SendspinHub::get_mac_address_into_buffer(mac_buf);
+  config.client_id = SendspinHub::get_client_id_into_buffer(mac_buf);
  config.name = App.get_friendly_name();
  config.product_name = this->get_product_name_();
  config.manufacturer = this->manufacturer_;
  config.software_version = this->firmware_version_;
  config.httpd_psram_stack = this->task_stack_in_psram_;
-  config.protocol_task_psram_stack = this->task_stack_in_psram_;
-  config.max_pairing_records = SENDSPIN_RECORD_SLOTS;
-
-  // The dynamic code needs a channel and a format. Only digits, since automations get the bare string and could not
-  // tell a QR code token apart.
-  if (this->pairing_code_display_supported_) {
-    config.pairing_code_out_channels = {sendspin::SendspinPairingCodeChannel::DISPLAY};
-    config.pairing_code_formats = {sendspin::SendspinPairingCodeFormat::DIGITS};
-  }
-
-  if (this->static_pairing_code_ != nullptr) {
-    config.static_pairing_code_locations = {"operator"};
-    config.static_pairing_code = this->static_pairing_code_;
-  }

  return config;
 }
@@ -407,77 +215,35 @@ void SendspinHub::on_release_high_performance() {
 #endif
 }

-void SendspinHub::on_open_pairing_window() { this->open_pairing_window_callbacks_.call(); }
-
-void SendspinHub::on_close_pairing_window() { this->close_pairing_window_callbacks_.call(); }
-
-// Only digits are offered, and the library refuses an activation in any other format.
-void SendspinHub::on_display_pairing_code(const std::string &code, sendspin::SendspinPairingCodeFormat /*format*/) {
-  this->display_pairing_code_callbacks_.call(code);
-}
-
-void SendspinHub::on_clear_pairing_code() { this->clear_pairing_code_callbacks_.call(); }
-
-void SendspinHub::on_pairing_succeeded(const std::string &server_id) {
-  this->pairing_succeeded_callbacks_.call(server_id);
-}
-
-void SendspinHub::on_pairing_failed(const std::string &server_id, sendspin::SendspinPairAbortReason reason) {
-  this->pairing_failed_callbacks_.call(server_id, pair_abort_reason_to_string(reason));
-}
-
 // --- SendspinNetworkProvider override ---

-// THREAD CONTEXT: Main loop (polled by start() and client_->loop())
+// THREAD CONTEXT: Main loop (polled by client_->loop())
 bool SendspinHub::is_network_ready() { return network::is_connected(); }

 // --- SendspinPersistenceProvider overrides ---
-// THREAD CONTEXT: Main loop (the library makes every provider call there, including from start() and stop())

-std::pair<ESPPreferenceObject *, size_t> SendspinHub::pref_for_key_(const std::string &key) {
-  namespace keys = sendspin::persistence_keys;
-  if (auto slot = parse_record_slot(key); slot.has_value()) {
-    return {&this->record_slot_prefs_[*slot], keys::RECORD_SLOT_SIZE};
+// THREAD CONTEXT: Main loop (invoked by client_->loop() during lifecycle events)
+bool SendspinHub::save_last_server_hash(uint32_t hash) {
+  LastPlayedServerPref pref{.server_id_hash = hash};
+  bool ok = this->last_played_server_pref_.save(&pref);
+  if (ok) {
+    ESP_LOGD(TAG, "Persisted last played server hash: 0x%08" PRIX32, hash);
+  } else {
+    ESP_LOGW(TAG, "Failed to persist last played server hash");
  }
-  if (key == keys::RECORD_ORDER) {
-    return {&this->record_order_pref_, SENDSPIN_RECORD_SLOTS};
-  }
-  if (key == keys::KEYPAIR) {
-    return {&this->keypair_pref_, keys::KEYPAIR_SIZE};
-  }
-  if (key == keys::PAIRING_PSK) {
-    return {&this->pairing_psk_pref_, keys::PAIRING_PSK_SIZE};
-  }
-  if (key == keys::LAST_PLAYED) {
-    return {&this->last_played_pref_, keys::LAST_PLAYED_SIZE};
-  }
-  if (key == keys::OUTPUT_DELAY) {
-    return {&this->output_delay_pref_, keys::OUTPUT_DELAY_SIZE};
-  }
-  return {nullptr, 0};
+  return ok;
 }

-std::optional<std::vector<uint8_t>> SendspinHub::load_blob(const std::string &key) {
-  auto [pref, size] = this->pref_for_key_(key);
-  if (pref == nullptr) {
-    ESP_LOGW(TAG, "load_blob: unknown key \"%s\"", key.c_str());
-    return std::nullopt;
+// THREAD CONTEXT: Main loop (invoked by client_->loop() during lifecycle events)
+std::optional<uint32_t> SendspinHub::load_last_server_hash() {
+  LastPlayedServerPref pref{};
+  if (this->last_played_server_pref_.load(&pref)) {
+    ESP_LOGI(TAG, "Loaded last played server hash: 0x%08" PRIX32, pref.server_id_hash);
+    return pref.server_id_hash;
  }
-  return read_blob(*pref, size);
+  return std::nullopt;
 }

-bool SendspinHub::save_blob(const std::string &key, const uint8_t *data, size_t len) {
-  auto [pref, size] = this->pref_for_key_(key);
-  if (pref == nullptr) {
-    ESP_LOGW(TAG, "save_blob: unknown key \"%s\"", key.c_str());
-    return false;
-  }
-  return write_blob(*pref, key.c_str(), size, data, len);
-}
-
-// Writes every component's queued preferences, so a failure may belong to another component.
-bool SendspinHub::commit() { return global_preferences->sync(); }
-
 // --- Sendspin role specific methods/overrides ---

 #ifdef USE_SENDSPIN_ARTWORK
@@ -519,7 +285,11 @@ void SendspinHub::send_client_command(sendspin::SendspinControllerCommand comman
 }

 // THREAD CONTEXT: Main loop (invoked from the sendspin.switch action)
-void SendspinHub::switch_client() { this->send_client_command(sendspin::SendspinControllerCommand::SWITCH); }
+void SendspinHub::switch_client() {
+  // Clear any EXTERNAL_SOURCE state so the switch command is followed
+  this->update_state(sendspin::SendspinClientState::SYNCHRONIZED);
+  this->send_client_command(sendspin::SendspinControllerCommand::SWITCH);
+}

 // THREAD CONTEXT: Main loop (ControllerRoleListener override, fired from client_->loop())
 void SendspinHub::on_controller_state(const sendspin::ServerStateControllerObject &state) {
@@ -562,8 +332,31 @@ sendspin::PlayerRole *SendspinHub::get_player_role() {
  }
  return nullptr;
 }
+
+// THREAD CONTEXT: Main loop (SendspinPersistenceProvider override)
+bool SendspinHub::save_static_delay(uint16_t delay_ms) {
+  StaticDelayPref pref{.delay_ms = delay_ms};
+  bool ok = this->static_delay_pref_.save(&pref);
+  if (ok) {
+    ESP_LOGD(TAG, "Persisted static delay: %u ms", delay_ms);
+  } else {
+    ESP_LOGW(TAG, "Failed to persist static delay");
+  }
+  return ok;
+}
+
+// THREAD CONTEXT: Main loop (SendspinPersistenceProvider override)
+std::optional<uint16_t> SendspinHub::load_static_delay() {
+  StaticDelayPref pref{};
+  if (this->static_delay_pref_.load(&pref)) {
+    ESP_LOGI(TAG, "Loaded static delay: %u ms", pref.delay_ms);
+    return pref.delay_ms;
+  }
+  return std::nullopt;
+}
+
 #endif

 }  // namespace esphome::sendspin_

-#endif  // USE_ESP_IDF
+#endif  // USE_ESP32
@@ -2,13 +2,12 @@

 #include "esphome/core/defines.h"

-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32

 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
-#include "esphome/core/string_ref.h"
 #include "esphome/core/version.h"

 #ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
@@ -32,15 +31,9 @@
 #include <sendspin/player_role.h>
 #endif

-#include <array>
-#include <cstddef>
-#include <cstdint>
 #include <functional>
 #include <memory>
 #include <optional>
-#include <string>
-#include <utility>
-#include <vector>

 namespace esphome::sendspin_ {

@@ -51,22 +44,23 @@ namespace esphome::sendspin_ {
 /// one step later than hub so they can assume hub's setup() has already completed.
 namespace sendspin_priority {
 // AFTER_WIFI so the hub runs after the wifi/ethernet drivers are up and we can read the active
-// interface's MAC address for the device info.
+// interface's MAC for client_id.
 inline constexpr float HUB = esphome::setup_priority::AFTER_WIFI;
 inline constexpr float CHILD = HUB - 1.0f;
 }  // namespace sendspin_priority

-// PREFERENCE KEYS: each library persistence key has its own preference, hashed from "sendspin_" + name. Renaming
-// one erases it.
-
-/// Pairing-record slots, handed to the client as max_pairing_records.
-inline constexpr size_t SENDSPIN_RECORD_SLOTS = sendspin::SendspinClientConfig::DEFAULT_MAX_PAIRING_RECORDS;
-
-/// Feature flags reported to API clients in DeviceCapabilitiesResponse.
-enum SendspinFeature : uint32_t {
-  SENDSPIN_FEATURE_PAIRING_TOKEN = 1 << 0,
+/// @brief Persistent storage structure for last played server hash.
+struct LastPlayedServerPref {
+  uint32_t server_id_hash;
 };

+#ifdef USE_SENDSPIN_PLAYER
+/// @brief Persistent storage structure for player static delay.
+struct StaticDelayPref {
+  uint16_t delay_ms;
+};
+#endif
+
 /// @brief Thin adapter over sendspin::SendspinClient.
 ///
 /// The hub owns a SendspinClient instance and bridges its listener/provider interfaces to ESPHome's CallbackManager for
@@ -96,12 +90,9 @@ class SendspinHub final : public Component,
                          public sendspin::SendspinNetworkProvider,
                          public sendspin::SendspinPersistenceProvider {
 public:
-  SendspinHub();
-
  float get_setup_priority() const override { return sendspin_priority::HUB; }
  void setup() override;
  void loop() override;
-  void on_shutdown() override;
  void dump_config() override;

  /// @brief Connects the underlying client to the given Sendspin server.
@@ -122,22 +113,14 @@ class SendspinHub final : public Component,
  ///   - `USER_REQUEST`: user explicitly requested disconnect.
  void disconnect_from_server(sendspin::SendspinGoodbyeReason reason);

-  /// @brief Leaves the current group so another source can use the speaker.
-  ///
-  /// Sends `client/leave` while the group is playing. A stopped group is left alone, so the device stays grouped.
-  /// No-op if the hub's client is not running. Must be called from the main loop thread.
-  void leave_group();
-
-  /// @brief Confirms a pairing attempt on the device. With no attempt waiting, it opens the pairing window for the
-  /// next one.
+  /// @brief Updates the client's reported playback state on the server.
  ///
  /// No-op if the hub's client is not running. Must be called from the main loop thread.
-  void confirm_pairing_window();
-
-  /// @brief Closes an open pairing window, so a waiting pairing attempt is not confirmed.
-  ///
-  /// No-op if the hub's client is not running. Must be called from the main loop thread.
-  void cancel_pairing_window();
+  /// @param state New client state:
+  ///   - `SYNCHRONIZED`: client is synchronized and playing from the server.
+  ///   - `ERROR`: client encountered a playback error.
+  ///   - `EXTERNAL_SOURCE`: client is playing from a non-Sendspin source.
+  void update_state(sendspin::SendspinClientState state);

  // --- Configuration setters (called from codegen) ---

@@ -145,65 +128,19 @@ class SendspinHub final : public Component,
    this->group_update_callbacks_.add(std::forward<F>(callback));
  }

-  template<typename F> void add_on_open_pairing_window_callback(F &&callback) {
-    this->open_pairing_window_callbacks_.add(std::forward<F>(callback));
-  }
-
-  template<typename F> void add_on_close_pairing_window_callback(F &&callback) {
-    this->close_pairing_window_callbacks_.add(std::forward<F>(callback));
-  }
-
-  template<typename F> void add_on_display_pairing_code_callback(F &&callback) {
-    this->display_pairing_code_callbacks_.add(std::forward<F>(callback));
-  }
-
-  template<typename F> void add_on_clear_pairing_code_callback(F &&callback) {
-    this->clear_pairing_code_callbacks_.add(std::forward<F>(callback));
-  }
-
-  template<typename F> void add_on_pairing_succeeded_callback(F &&callback) {
-    this->pairing_succeeded_callbacks_.add(std::forward<F>(callback));
-  }
-
-  template<typename F> void add_on_pairing_failed_callback(F &&callback) {
-    this->pairing_failed_callbacks_.add(std::forward<F>(callback));
-  }
-
  void set_task_stack_in_psram(bool task_stack_in_psram) { this->task_stack_in_psram_ = task_stack_in_psram; }

  /// @brief Requests the Sendspin client, including the server, the roles and the mDNS advertisement, to start or
  /// stop.
  ///
  /// Applied from the hub's loop(). Stopping blocks until the client is fully stopped; the roles' clear callbacks
-  /// fire from inside that call. The client stays stopped until this has been called once, by codegen or by the
-  /// enabled switch. Must be called from the main loop thread.
+  /// fire from inside that call. With a sendspin switch configured the client stays stopped until the switch has
+  /// called this once. Must be called from the main loop thread.
  void set_enabled(bool enabled);

-  /// Turns unpaired (Sentinel) access on or off. The client waits for this call, by codegen or by the unpaired
-  /// access switch, before its first start. May be called before setup(). Main loop only.
-  void set_unpaired_access_enabled(bool enabled);
-
  /// @brief Returns whether the Sendspin client is running.
  bool is_client_running() const { return this->client_ != nullptr && this->client_->is_started(); }

-  /// @brief Returns whether the client has been turned off with set_enabled().
-  bool is_disabled() const { return this->enabled_.has_value() && !this->enabled_.value(); }
-
-  /// @brief Returns the SendspinFeature flags reported to API clients.
-  uint32_t get_feature_flags() const { return SENDSPIN_FEATURE_PAIRING_TOKEN; }
-
-  /// @brief Returns the pairing token a Sendspin server uses to pair with this device.
-  ///
-  /// The token is a long-lived secret, so this component never logs it. Returns std::nullopt until the client has
-  /// started once; it stays available after the client stops. Main loop only.
-  std::optional<std::string> get_pairing_token() const;
-
-  /// @brief Returns the Sendspin client_id: base64url of the client's static public key.
-  ///
-  /// Empty until the client has started once; it stays set after the client stops. The returned StringRef points into
-  /// the client's string, which start() may rewrite, so do not keep it past the current call. Main loop only.
-  StringRef get_client_id() const;
-
  /// @brief Sets the device information reported to the server in the `client/hello` message.
  ///
  /// Each takes a pointer to a string literal emitted by codegen, so it must stay valid for the
@@ -217,13 +154,6 @@ class SendspinHub final : public Component,
  void set_mdns(mdns::MDNSComponent *mdns) { this->mdns_ = mdns; }
 #endif

-  /// The static pairing code, used on every boot.
-  void set_static_pairing_code(const char *code) { this->static_pairing_code_ = code; }
-
-  /// Set when on_display_pairing_code or a pairing_code text sensor is configured, so the device offers the dynamic
-  /// pairing code.
-  void set_pairing_code_display_supported(bool supported) { this->pairing_code_display_supported_ = supported; }
-
  // --- Sendspin role specific methods ---

 #ifdef USE_SENDSPIN_ARTWORK
@@ -289,18 +219,12 @@ class SendspinHub final : public Component,
  /// @brief Builds the SendspinClientConfig from ESPHome configuration and platform info.
  sendspin::SendspinClientConfig build_client_config_();

-  /// The preference a library key is stored in and its blob size, or {nullptr, 0} for a key with
-  /// no storage here.
-  std::pair<ESPPreferenceObject *, size_t> pref_for_key_(const std::string &key);
-
  /// @brief Returns the product name reported to the server: the configured model, or the device name.
  const char *get_product_name_() const;

-  const char *pairing_code_method_() const;
-
-  /// @brief Writes the active network interface's MAC, in lowercase, into @p buf and returns its data pointer.
+  /// @brief Writes the active network interface's MAC into @p buf and returns its data pointer.
  /// Uses the ethernet MAC if ethernet is configured, otherwise the base MAC (used by wifi).
-  static const char *get_mac_address_into_buffer(std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf);
+  static const char *get_client_id_into_buffer(std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf);

 #ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
  /// @brief Keeps the `_sendspin` mDNS service advertised while the client is running.
@@ -314,26 +238,12 @@ class SendspinHub final : public Component,

  void on_release_high_performance() override;

-  void on_open_pairing_window() override;
-
-  void on_close_pairing_window() override;
-
-  void on_display_pairing_code(const std::string &code, sendspin::SendspinPairingCodeFormat format) override;
-
-  void on_clear_pairing_code() override;
-
-  void on_pairing_succeeded(const std::string &server_id) override;
-
-  void on_pairing_failed(const std::string &server_id, sendspin::SendspinPairAbortReason reason) override;
-
  // --- SendspinNetworkProvider override ---
  bool is_network_ready() override;

  // --- SendspinPersistenceProvider overrides ---
-  // The library calls commit() after writing pairing secrets, so they reach flash right away.
-  std::optional<std::vector<uint8_t>> load_blob(const std::string &key) override;
-  bool save_blob(const std::string &key, const uint8_t *data, size_t len) override;
-  bool commit() override;
+  bool save_last_server_hash(uint32_t hash) override;
+  std::optional<uint32_t> load_last_server_hash() override;

  // --- Sendspin role specific methods/overrides/member variables ---

@@ -381,41 +291,29 @@ class SendspinHub final : public Component,
 #ifdef USE_SENDSPIN_PLAYER
  sendspin::PlayerRoleListener *player_listener_{nullptr};
  sendspin::PlayerRoleConfig player_config_{};
+
+  // Part of SendspinPersistenceProvider overrides
+  ESPPreferenceObject static_delay_pref_;
+  std::optional<uint16_t> load_static_delay() override;
+  bool save_static_delay(uint16_t delay_ms) override;
 #endif

  // --- Core member variables ---

-  // Built once in setup(): make_preference() allocates a backend that is never freed.
-  ESPPreferenceObject keypair_pref_;
-  ESPPreferenceObject pairing_psk_pref_;
-  ESPPreferenceObject last_played_pref_;
-  ESPPreferenceObject output_delay_pref_;
-  std::array<ESPPreferenceObject, SENDSPIN_RECORD_SLOTS> record_slot_prefs_;
-  ESPPreferenceObject record_order_pref_;
+  ESPPreferenceObject last_played_server_pref_;

  std::unique_ptr<sendspin::SendspinClient> client_;

  // Callback fan-out to child components
  CallbackManager<void(const sendspin::GroupUpdateObject &)> group_update_callbacks_{};

-  // Lazy: each pairing callback is fed by an optional YAML surface.
-  LazyCallbackManager<void()> open_pairing_window_callbacks_{};
-  LazyCallbackManager<void()> close_pairing_window_callbacks_{};
-  LazyCallbackManager<void(const std::string &)> display_pairing_code_callbacks_{};
-  LazyCallbackManager<void()> clear_pairing_code_callbacks_{};
-  LazyCallbackManager<void(const std::string &)> pairing_succeeded_callbacks_{};
-  LazyCallbackManager<void(const std::string &, StringRef)> pairing_failed_callbacks_{};
-
-  const char *static_pairing_code_{nullptr};  // Codegen string literal, or nullptr when not configured
-  bool pairing_code_display_supported_{false};
  bool task_stack_in_psram_{false};
 #ifdef USE_MDNS_SUPPORTS_ENABLE_DISABLE
  bool mdns_advertised_{false};  // Last state requested from mdns
 #endif

-  // Requested client state, applied from loop(). The client does not start until both are set.
+  // Requested client state, applied from loop(). Empty until the switch restores its state.
  std::optional<bool> enabled_;
-  std::optional<bool> unpaired_access_;

  // Device information sent in the `client/hello` message. Defaults apply when neither the
  // sendspin configuration nor the project information supplies a value.
@@ -449,8 +347,6 @@ class SendspinPollingChild : public PollingComponent, public Parented<SendspinHu
  float get_setup_priority() const override { return sendspin_priority::CHILD; }
 };

-extern SendspinHub *global_sendspin_hub;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
 }  // namespace esphome::sendspin_

-#endif  // USE_ESP_IDF
+#endif  // USE_ESP32
@@ -1,6 +1,6 @@
 #include "sendspin_sensor.h"

-#if defined(USE_ESP_IDF) && defined(USE_SENDSPIN_METADATA) && defined(USE_SENSOR)
+#if defined(USE_ESP32) && defined(USE_SENDSPIN_METADATA) && defined(USE_SENSOR)

 #include <sendspin/metadata_role.h>

@@ -2,7 +2,7 @@

 #include "esphome/core/defines.h"

-#if defined(USE_ESP_IDF) && defined(USE_SENDSPIN_METADATA) && defined(USE_SENSOR)
+#if defined(USE_ESP32) && defined(USE_SENDSPIN_METADATA) && defined(USE_SENSOR)

 #include "esphome/components/sendspin/sendspin_hub.h"
 #include "esphome/components/sensor/sensor.h"
@@ -1,101 +1,35 @@
-import logging
-
 import esphome.codegen as cg
 from esphome.components import switch
 from esphome.components.const import CONF_ENABLED
 import esphome.config_validation as cv
-from esphome.const import CONF_PLATFORM, CONF_SWITCH, CONF_TYPE, ENTITY_CATEGORY_CONFIG
-import esphome.final_validate as fv
+from esphome.const import CONF_TYPE, ENTITY_CATEGORY_CONFIG
 from esphome.types import ConfigType

-from .. import (
-    CONF_SENDSPIN_ID,
-    CONF_STATIC_PAIRING_CODE,
-    CONF_UNPAIRED_ACCESS,
-    DOMAIN,
-    SendspinHub,
-    _has_pairing_method,
-    request_switch,
-    sendspin_ns,
-)
-
-_LOGGER = logging.getLogger(__name__)
+from .. import CONF_SENDSPIN_ID, SendspinHub, sendspin_ns

 CODEOWNERS = ["@kahrendt"]
 DEPENDENCIES = ["sendspin"]

-SendspinEnabledSwitch = sendspin_ns.class_(
-    "SendspinEnabledSwitch", switch.Switch, cg.Component
-)
-SendspinUnpairedAccessSwitch = sendspin_ns.class_(
-    "SendspinUnpairedAccessSwitch", switch.Switch, cg.Component
-)
-
-
-def _switch_schema(class_: cg.MockObjClass) -> cv.Schema:
-    return (
-        switch.switch_schema(
-            class_,
-            block_inverted=True,
-            default_restore_mode="RESTORE_DEFAULT_ON",
-            entity_category=ENTITY_CATEGORY_CONFIG,
-        )
-        .extend({cv.GenerateID(CONF_SENDSPIN_ID): cv.use_id(SendspinHub)})
-        .extend(cv.COMPONENT_SCHEMA)
-    )
-
-
-def _request_switch(config: ConfigType) -> ConfigType:
-    """Tell the hub to wait for this switch before the client's first start."""
-    request_switch(config[CONF_TYPE])
-    return config
-
+SendspinSwitch = sendspin_ns.class_("SendspinSwitch", switch.Switch, cg.Component)

 CONFIG_SCHEMA = cv.All(
    cv.typed_schema(
        {
-            CONF_ENABLED: _switch_schema(SendspinEnabledSwitch),
-            CONF_UNPAIRED_ACCESS: _switch_schema(SendspinUnpairedAccessSwitch),
+            CONF_ENABLED: switch.switch_schema(
+                SendspinSwitch,
+                block_inverted=True,
+                default_restore_mode="RESTORE_DEFAULT_ON",
+                entity_category=ENTITY_CATEGORY_CONFIG,
+            )
+            .extend({cv.GenerateID(CONF_SENDSPIN_ID): cv.use_id(SendspinHub)})
+            .extend(cv.COMPONENT_SCHEMA),
        },
        key=CONF_TYPE,
    ),
    cv.only_on_esp32,
-    _request_switch,
 )


-def _final_validate(config: ConfigType) -> ConfigType:
-    full_config = fv.full_config.get()
-    switch_type = config[CONF_TYPE]
-    same_type = [
-        conf
-        for conf in full_config.get(CONF_SWITCH, [])
-        if conf.get(CONF_PLATFORM) == DOMAIN and conf.get(CONF_TYPE) == switch_type
-    ]
-    # Two switches of one type would each drive the same hub setting.
-    if len(same_type) > 1:
-        raise cv.Invalid(f"Only one sendspin '{switch_type}' switch is allowed")
-    if switch_type != CONF_UNPAIRED_ACCESS:
-        return config
-    hub_config = full_config.get(DOMAIN, {})
-    if CONF_UNPAIRED_ACCESS in hub_config:
-        raise cv.Invalid(
-            f"'{DOMAIN}: {CONF_UNPAIRED_ACCESS}' cannot be set together with an "
-            f"{CONF_UNPAIRED_ACCESS} switch; set the switch's restore_mode instead"
-        )
-    if not _has_pairing_method(hub_config):
-        _LOGGER.warning(
-            "The %s switch has no pairing method (%s or a dynamic pairing code), so "
-            "while it is off no new server can pair with this device",
-            CONF_UNPAIRED_ACCESS,
-            CONF_STATIC_PAIRING_CODE,
-        )
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
 async def to_code(config: ConfigType) -> None:
    var = await switch.new_switch(config)
    await cg.register_component(var, config)
@@ -1,49 +1,26 @@
 #include "sendspin_switch.h"

-#if defined(USE_ESP_IDF) && defined(USE_SENDSPIN_SWITCH)
+#ifdef USE_ESP32

 #include "esphome/core/log.h"
-#include "esphome/core/preferences.h"

 namespace esphome::sendspin_ {

 static const char *const TAG = "sendspin.switch";

-// --- SendspinEnabledSwitch ---
-
-void SendspinEnabledSwitch::setup() {
+void SendspinSwitch::setup() {
  // The hub waits for this request, so a restore mode without a state still has to answer.
  this->control(this->get_initial_state_with_restore_mode().value_or(true));
 }

-void SendspinEnabledSwitch::dump_config() { LOG_SWITCH("", "Sendspin Enabled Switch", this); }
+void SendspinSwitch::dump_config() { LOG_SWITCH("", "Sendspin Switch", this); }

 // THREAD CONTEXT: Main loop
-void SendspinEnabledSwitch::write_state(bool state) {
+void SendspinSwitch::write_state(bool state) {
  this->parent_->set_enabled(state);
  this->publish_state(state);
 }

-// --- SendspinUnpairedAccessSwitch ---
-
-void SendspinUnpairedAccessSwitch::setup() {
-  // The hub holds the client's first start for this, so a restore mode without a state still has to answer.
-  this->control(this->get_initial_state_with_restore_mode().value_or(true));
-}
-
-void SendspinUnpairedAccessSwitch::dump_config() { LOG_SWITCH("", "Sendspin Unpaired Access Switch", this); }
-
-// THREAD CONTEXT: Main loop
-void SendspinUnpairedAccessSwitch::write_state(bool state) {
-  const bool turning_off = !state && this->has_state() && this->state;
-  this->parent_->set_unpaired_access_enabled(state);
-  this->publish_state(state);
-  // Write the change to flash now: losing it in a power cut would reopen unpaired access.
-  if (turning_off) {
-    global_preferences->sync();
-  }
-}
-
 }  // namespace esphome::sendspin_

-#endif
+#endif  // USE_ESP32
@@ -2,7 +2,7 @@

 #include "esphome/core/defines.h"

-#if defined(USE_ESP_IDF) && defined(USE_SENDSPIN_SWITCH)
+#ifdef USE_ESP32

 #include "esphome/components/sendspin/sendspin_hub.h"
 #include "esphome/components/switch/switch.h"
@@ -10,19 +10,7 @@
 namespace esphome::sendspin_ {

 /// @brief Switch that starts and stops the Sendspin client through the hub (see SendspinHub::set_enabled()).
-class SendspinEnabledSwitch final : public switch_::Switch, public SendspinChild {
- public:
-  void setup() override;
-  void dump_config() override;
-
- protected:
-  void write_state(bool state) override;
-};
-
-/// @brief Switch that turns unpaired (Sentinel) access on and off through the hub (see
-/// SendspinHub::set_unpaired_access_enabled()). The library does not persist the setting, so the switch's restore
-/// mode does.
-class SendspinUnpairedAccessSwitch final : public switch_::Switch, public SendspinChild {
+class SendspinSwitch final : public switch_::Switch, public SendspinChild {
 public:
  void setup() override;
  void dump_config() override;
@@ -33,4 +21,4 @@ class SendspinUnpairedAccessSwitch final : public switch_::Switch, public Sendsp

 }  // namespace esphome::sendspin_

-#endif
+#endif  // USE_ESP32
@@ -4,29 +4,16 @@ import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_TYPE
 from esphome.types import ConfigType

-from .. import (
-    CONF_SENDSPIN_ID,
-    SendspinHub,
-    request_metadata_support,
-    request_pairing_code_display_support,
-    sendspin_ns,
-)
+from .. import CONF_SENDSPIN_ID, SendspinHub, request_metadata_support, sendspin_ns

 CODEOWNERS = ["@kahrendt"]
 DEPENDENCIES = ["sendspin"]

-CONF_PAIRING_CODE = "pairing_code"
-
 SendspinTextSensor = sendspin_ns.class_(
    "SendspinTextSensor",
    text_sensor.TextSensor,
    cg.Component,
 )
-SendspinPairingCodeTextSensor = sendspin_ns.class_(
-    "SendspinPairingCodeTextSensor",
-    text_sensor.TextSensor,
-    cg.Component,
-)

 SendspinTextMetadataTypes = sendspin_ns.enum("SendspinTextMetadataTypes", is_class=True)
 SENDSPIN_TEXT_METADATA_TYPES = {
@@ -39,29 +26,18 @@ SENDSPIN_TEXT_METADATA_TYPES = {

 def _request_roles(config: ConfigType) -> ConfigType:
    """Request the necessary Sendspin roles for the text sensor."""
-    if config[CONF_TYPE] == CONF_PAIRING_CODE:
-        # A display surface for the dynamic code, so advertise dynamic_pairing_code.
-        request_pairing_code_display_support()
-    else:
-        request_metadata_support()
+    request_metadata_support()

    return config


-_HUB_ID_SCHEMA = cv.Schema({cv.GenerateID(CONF_SENDSPIN_ID): cv.use_id(SendspinHub)})
-_METADATA_SCHEMA = text_sensor.text_sensor_schema(SendspinTextSensor).extend(
-    _HUB_ID_SCHEMA
-)
-
 CONFIG_SCHEMA = cv.All(
-    cv.typed_schema(
+    text_sensor.text_sensor_schema().extend(
        {
-            **dict.fromkeys(SENDSPIN_TEXT_METADATA_TYPES, _METADATA_SCHEMA),
-            CONF_PAIRING_CODE: text_sensor.text_sensor_schema(
-                SendspinPairingCodeTextSensor
-            ).extend(_HUB_ID_SCHEMA),
-        },
-        key=CONF_TYPE,
+            cv.GenerateID(): cv.declare_id(SendspinTextSensor),
+            cv.GenerateID(CONF_SENDSPIN_ID): cv.use_id(SendspinHub),
+            cv.Required(CONF_TYPE): cv.enum(SENDSPIN_TEXT_METADATA_TYPES),
+        }
    ),
    cv.only_on_esp32,
    _request_roles,
@@ -74,7 +50,4 @@ async def to_code(config: ConfigType) -> None:
    await cg.register_parented(var, config[CONF_SENDSPIN_ID])
    await text_sensor.register_text_sensor(var, config)

-    if (
-        metadata_type := SENDSPIN_TEXT_METADATA_TYPES.get(config[CONF_TYPE])
-    ) is not None:
-        cg.add(var.set_metadata_type(metadata_type))
+    cg.add(var.set_metadata_type(config[CONF_TYPE]))
@@ -1,10 +1,8 @@
 #include "sendspin_text_sensor.h"

-#if defined(USE_ESP_IDF) && defined(USE_TEXT_SENSOR)
+#if defined(USE_ESP32) && defined(USE_SENDSPIN_METADATA) && defined(USE_TEXT_SENSOR)

-#ifdef USE_SENDSPIN_METADATA
 #include <sendspin/metadata_role.h>
-#endif

 #include <string>

@@ -12,7 +10,6 @@ namespace esphome::sendspin_ {

 static const char *const TAG = "sendspin.text_sensor";

-#ifdef USE_SENDSPIN_METADATA
 void SendspinTextSensor::dump_config() { LOG_TEXT_SENSOR("", "Sendspin", this); }

 // A field is nullopt when the server has not provided it or has explicitly cleared it. Both mean there is nothing to
@@ -53,16 +50,6 @@ void SendspinTextSensor::publish_if_changed_(const char *value) {
    this->publish_state(value);
  }
 }
-#endif  // USE_SENDSPIN_METADATA
-
-void SendspinPairingCodeTextSensor::dump_config() { LOG_TEXT_SENSOR("", "Pairing Code", this); }
-
-// THREAD CONTEXT: Main loop. The registered callbacks also fire on the main loop (SendspinHub dispatches them from
-// its loop()).
-void SendspinPairingCodeTextSensor::setup() {
-  this->parent_->add_on_display_pairing_code_callback([this](const std::string &code) { this->publish_state(code); });
-  this->parent_->add_on_clear_pairing_code_callback([this]() { this->publish_state(""); });
-}

 }  // namespace esphome::sendspin_

@@ -2,19 +2,15 @@

 #include "esphome/core/defines.h"

-#if defined(USE_ESP_IDF) && defined(USE_TEXT_SENSOR)
+#if defined(USE_ESP32) && defined(USE_SENDSPIN_METADATA) && defined(USE_TEXT_SENSOR)

 #include "esphome/components/sendspin/sendspin_hub.h"
 #include "esphome/components/text_sensor/text_sensor.h"

-#ifdef USE_SENDSPIN_METADATA
 #include <sendspin/metadata_role.h>
-#endif

 namespace esphome::sendspin_ {

-#ifdef USE_SENDSPIN_METADATA
-
 enum class SendspinTextMetadataTypes {
  TITLE,
  ARTIST,
@@ -35,13 +31,6 @@ class SendspinTextSensor final : public SendspinChild, public text_sensor::TextS

  SendspinTextMetadataTypes metadata_type_;
 };
-#endif  // USE_SENDSPIN_METADATA
-
-class SendspinPairingCodeTextSensor final : public SendspinChild, public text_sensor::TextSensor {
- public:
-  void dump_config() override;
-  void setup() override;
-};

 }  // namespace esphome::sendspin_
 #endif
@@ -412,8 +412,6 @@ void SerialProxy::fill_identity_([[maybe_unused]] IdentityScratch &scratch, api:
    msg.usb.product_id = scratch.product_id;
    msg.usb.bcd_device = scratch.bcd_device;
    msg.usb.interface_number = this->usb_channel_->get_interface_number();
-    msg.usb.interface_class = this->usb_channel_->get_interface_class();
-    msg.usb.port_number = this->usb_channel_->get_port_number();
    msg.manufacturer = StringRef(scratch.manufacturer);
    msg.product = StringRef(scratch.product);
    msg.serial_number = StringRef(scratch.serial_number);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
CodSpeed Bot	0523725530	[core] Optimize base64 decoding fast path	2026-10-08 00:20:39 +00:00
mrtoy-me	883af036a9	[tas58xx] Improve TAS5805M audio performance and use GPIO1 for TAS5825M faults (#20319 )	2026-10-07 13:57:46 -10:00
esphome[bot]	8f003dfa3b	Bump aioesphomeapi from 46.6.0 to 46.7.0 (#20317 )	2026-10-07 13:31:24 -10:00
Jesse Hills	6d3792e5c5	[ci] Only run sync dependency versions workflow on PRs targeting dev (#20316 )	2026-10-08 12:22:07 +13:00
Jesse Hills	c73ec262e9	Merge branch 'beta' into dev	2026-10-08 12:15:20 +13:00
Jesse Hills	7a1bfed81f	Bump version to 2026.11.0-dev	2026-10-08 12:01:52 +13:00
J. Nick Koston	12c03d539a	[cc1101] Keep constant send_packet payloads in shared flash tables (#20264 )	2026-10-07 10:54:56 -10:00
J. Nick Koston	24fc86c2c4	[core] Deprecate TemplatableValue::is_static_string and get_static_string (#20280 )	2026-10-07 20:48:46 +00:00