Make the 4-byte alignment of the directly read flash tables explicit

Co-authored-by: Cursor <cursoragent@cursor.com>

.github/actions/restore-python/action.yml

@@ -32,7 +32,7 @@ runs:
       # detects the activated venv via ``VIRTUAL_ENV`` so the venv layout
       # downstream jobs rely on is preserved.
       if: steps.cache-venv.outputs.cache-hit != 'true'
-      uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+      uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
       with:
         enable-cache: true
         # Pull request saves land in per-PR scopes nothing else can

.github/workflows/ci-api-proto.yml

@@ -29,7 +29,7 @@ jobs:
       - name: Set up uv
         # ``--system`` (below) installs into the setup-python interpreter;
         # no venv is created or restored by this workflow.
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
         with:
           enable-cache: true
           # Pull-request-only workflow: a save could never be shared and
@@ -97,7 +97,7 @@ jobs:
         run: git diff
       - if: failure()
         name: Archive artifacts
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
           name: generated-proto-files
           path: |

.github/workflows/ci-docker.yml

@@ -128,7 +128,7 @@ jobs:
 
       - name: Upload compile-test image artifact
         if: matrix.os == 'ubuntu-24.04' && matrix.build_type == 'docker'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
           # The tar is already compressed, so upload it as-is. archive: false
           # skips the redundant zip and makes the file name the artifact name
@@ -210,7 +210,7 @@ jobs:
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
       - name: Download image artifact
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
         with:
           name: compile-test-image.tar.zst
       - name: Load image

.github/workflows/ci.yml

@@ -49,7 +49,7 @@ jobs:
         # detects the activated venv via ``VIRTUAL_ENV`` so downstream jobs
         # that ``. venv/bin/activate`` see an identical layout.
         if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
         with:
           enable-cache: true
           # Pull request saves land in per-PR scopes nothing else can
@@ -438,7 +438,7 @@ jobs:
       - name: Set up uv
         # Only needed on cache miss to populate the venv.
         if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
         with:
           enable-cache: true
           # Pull request saves land in per-PR scopes nothing else can
@@ -477,7 +477,7 @@ jobs:
         # Tests that compare rendered output write the image they actually got here, so a
         # failure can be looked at without reproducing the whole build locally.
         if: failure()
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
           name: integration-test-artifacts-${{ matrix.bucket.name }}
           path: test_artifacts/
@@ -488,7 +488,7 @@ jobs:
         # script/update_integration_test_durations.py; only full matrix dev
         # runs produce usable data.
         if: github.ref == 'refs/heads/dev' && needs.determine-jobs.outputs.integration-run-all == 'true'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
           name: junit-integration-${{ strategy.job-index }}
           path: junit-integration.xml
@@ -528,7 +528,7 @@ jobs:
           script/check_import_time.py --check --har importtime.har
       - name: Upload waterfall HAR
         if: always()
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
           name: import-time-waterfall
           path: importtime.har
@@ -626,7 +626,7 @@ jobs:
             apt-get install -y libc6-dbg
 
       - name: Run CodSpeed benchmarks
-        uses: CodSpeedHQ/action@c4fd08a3a159bd0cc208da1e0edf32b8c47d75e5 # v5.4.0
+        uses: CodSpeedHQ/action@f842b9a3ffe213dbb81768fd7f7eeb4dfcf1c369 # v5.4.2
         with:
           run: |
             . venv/bin/activate
@@ -1448,7 +1448,7 @@ jobs:
         # install step (order-of-magnitude faster on cold boots,
         # with its own wheel cache). actions/setup-python still
         # provides the interpreter.
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
         with:
           enable-cache: true
           # Pull request saves land in per-PR scopes nothing else can
@@ -1647,7 +1647,7 @@ jobs:
           fi
 
       - name: Upload memory analysis JSON
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
           name: memory-analysis-target
           path: memory-analysis-target.json
@@ -1710,7 +1710,7 @@ jobs:
             --platform "$platform"
 
       - name: Upload memory analysis JSON
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
           name: memory-analysis-pr
           path: memory-analysis-pr.json
@@ -1740,13 +1740,13 @@ jobs:
           python-version: ${{ env.DEFAULT_PYTHON }}
           cache-key: ${{ needs.common.outputs.cache-key }}
       - name: Download target analysis JSON
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
         with:
           name: memory-analysis-target
           path: ./memory-analysis
         continue-on-error: true
       - name: Download PR analysis JSON
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
         with:
           name: memory-analysis-pr
           path: ./memory-analysis

.github/workflows/codeql.yml

@@ -56,7 +56,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
+        uses: github/codeql-action/init@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -84,6 +84,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
+        uses: github/codeql-action/analyze@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
         with:
           category: "/language:${{matrix.language}}"

.github/workflows/release.yml

@@ -162,7 +162,7 @@ jobs:
       #     version: ${{ needs.init.outputs.tag }}
 
       - name: Upload digests
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
           name: digests-${{ matrix.platform.arch }}
           path: /tmp/digests
@@ -195,7 +195,7 @@ jobs:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Download digests
-        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
         with:
           pattern: digests-*
           path: /tmp/digests

.github/workflows/sync-device-classes.yml

@@ -47,7 +47,7 @@ jobs:
         # setup-python interpreter so subsequent ``prek`` /
         # ``script/run-in-env.py`` steps find the deps without a
         # ``uv run`` prefix.
-        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
         with:
           enable-cache: true
           # Pin uv version so the action does not have to fetch the

.pre-commit-config.yaml

@@ -10,7 +10,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.16.10
+    rev: v0.17.0
     hooks:
       # Run the linter.
       - id: ruff
@@ -36,7 +36,7 @@ repos:
       - id: end-of-file-fixer
       - id: trailing-whitespace
   - repo: https://github.com/asottile/pyupgrade
-    rev: v3.21.2
+    rev: v3.22.0
     hooks:
       - id: pyupgrade
         args: [--py312-plus]

esphome/components/ble_client/__init__.py

@@ -1,23 +1,8 @@
-from collections.abc import Callable
-import functools
-from typing import Any
-
 from esphome import automation
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
-from esphome.components import ble_device_base, bluetooth_connection
-from esphome.components.ble_device_base import (
-    BT_UUID16_FORMAT as bt_uuid16_format,
-    BT_UUID32_FORMAT as bt_uuid32_format,
-    BT_UUID128_FORMAT as bt_uuid128_format,
-    as_hex,
-    as_reversed_hex_array,
-    bt_uuid,
-)
-from esphome.config_helpers import (
-    filter_source_files_from_platform,
-    frameworks_for_platforms,
-)
+from esphome.components import esp32_ble, esp32_ble_client, esp32_ble_tracker
+from esphome.components.esp32_ble import BTLoggers
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CHARACTERISTIC_UUID,
@@ -30,55 +15,15 @@ from esphome.const import (
     CONF_SERVICE_UUID,
     CONF_TRIGGER_ID,
     CONF_VALUE,
-    PLATFORM_ESP32,
-    PlatformFramework,
 )
-from esphome.core import CORE, ID
-from esphome.enum import StrEnum
-from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
+from esphome.core import ID
 from esphome.types import ConfigType
 
-# The esp32 BLE stack (esp32_ble, esp32_ble_tracker) is imported lazily inside
-# the esp32 schema/codegen arms: importing those modules registers esp32-only
-# automations as a side effect, which must not leak into the neutral
-# platforms' registries (the bluetooth_proxy pattern).
-
-
-def _legacy_engine() -> bool:
-    """True when the build uses the legacy raw-gattc engine - one line to
-    flip when esp32 moves to the neutral engine (with
-    USE_BLE_CLIENT_LEGACY_ENGINE in _to_code_esp32)."""
-    return CORE.is_esp32
-
-
-def AUTO_LOAD() -> list[str]:
-    """The engine's closure per platform: the legacy esp32 engine builds on
-    esp32_ble_client plus bluetooth_connection (the shared service-table
-    materializer; its sources compile empty in builds without a neutral
-    node), the neutral engine on the bluetooth_connection backend. The
-    platform-less arm is the union for manifest-resolving tooling."""
-    if _legacy_engine() or CORE.target_platform is None:
-        return ["bluetooth_connection", "esp32_ble_client"]
-    return ["bluetooth_connection"]
-
-
+AUTO_LOAD = ["esp32_ble_client"]
 CODEOWNERS = ["@buxtronix", "@clydebarrow"]
+DEPENDENCIES = ["esp32_ble_tracker"]
 DOMAIN = "ble_client"
 
-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "ble_client.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP32_IDF,
-        },
-        # Every framework of every non-esp32 registry platform: a platform
-        # that validates the neutral arm must also compile the neutral engine.
-        "ble_client_gatt.cpp": frameworks_for_platforms(
-            set(bluetooth_connection.GATT_CLIENT_PLATFORMS) - {PLATFORM_ESP32}
-        ),
-    }
-)
-
 CONF_DESCRIPTOR_UUID = "descriptor_uuid"
 CONF_ON_NOTIFY = "on_notify"
 
@@ -114,9 +59,7 @@ def notify_from_on_notify(config: ConfigType) -> ConfigType:
 
 
 ble_client_ns = cg.esphome_ns.namespace("ble_client")
-# One codegen class for both engines: the exclusively-gated headers resolve
-# the name to exactly one C++ definition per build.
-BLEClient = ble_client_ns.class_("BLEClient", cg.Component)
+BLEClient = ble_client_ns.class_("BLEClient", esp32_ble_client.BLEClientBase)
 BLEClientNode = ble_client_ns.class_("BLEClientNode")
 BLEClientNodeConstRef = BLEClientNode.operator("ref").operator("const")
 # Triggers
@@ -163,179 +106,62 @@ CONF_AUTO_CONNECT = "auto_connect"
 
 MULTI_CONF = True
 
-# Keys shared by both engines' schemas.
-_COMMON_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.declare_id(BLEClient),
-        cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
-        cv.Optional(CONF_AUTO_CONNECT, default=True): cv.boolean,
-        cv.Optional(CONF_ON_CONNECT): automation.validate_automation(
-            {
-                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(BLEClientConnectTrigger),
-            }
-        ),
-        cv.Optional(CONF_ON_DISCONNECT): automation.validate_automation(
-            {
-                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                    BLEClientDisconnectTrigger
-                ),
-            }
-        ),
-    }
-).extend(cv.COMPONENT_SCHEMA)
-
-
-@functools.cache
-def _esp32_config_schema() -> cv.All:
-    """The legacy engine's schema, byte-compatible with what esp32 always had
-    (including the Bluedroid security triggers)."""
-    from esphome.components import esp32_ble_tracker
-
-    return cv.All(
-        _COMMON_SCHEMA.extend(
-            {
-                # Accepted-but-unused legacy key; not propagated to the
-                # neutral schema.
-                cv.Optional(CONF_NAME): cv.string,
-                cv.Optional(CONF_ON_PASSKEY_REQUEST): automation.validate_automation(
-                    {
-                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                            BLEClientPasskeyRequestTrigger
-                        ),
-                    }
-                ),
-                cv.Optional(
-                    CONF_ON_PASSKEY_NOTIFICATION
-                ): automation.validate_automation(
-                    {
-                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                            BLEClientPasskeyNotificationTrigger
-                        ),
-                    }
-                ),
-                cv.Optional(
-                    CONF_ON_NUMERIC_COMPARISON_REQUEST
-                ): automation.validate_automation(
-                    {
-                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                            BLEClientNumericComparisonRequestTrigger
-                        ),
-                    }
-                ),
-            }
-        ).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA),
-        bluetooth_connection.consume_gatt_slot("ble_client"),
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(BLEClient),
+            cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
+            cv.Optional(CONF_NAME): cv.string,
+            cv.Optional(CONF_AUTO_CONNECT, default=True): cv.boolean,
+            cv.Optional(CONF_ON_CONNECT): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        BLEClientConnectTrigger
+                    ),
+                }
+            ),
+            cv.Optional(CONF_ON_DISCONNECT): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        BLEClientDisconnectTrigger
+                    ),
+                }
+            ),
+            cv.Optional(CONF_ON_PASSKEY_REQUEST): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        BLEClientPasskeyRequestTrigger
+                    ),
+                }
+            ),
+            cv.Optional(CONF_ON_PASSKEY_NOTIFICATION): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        BLEClientPasskeyNotificationTrigger
+                    ),
+                }
+            ),
+            cv.Optional(
+                CONF_ON_NUMERIC_COMPARISON_REQUEST
+            ): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        BLEClientNumericComparisonRequestTrigger
+                    ),
+                }
+            ),
+        }
     )
-
-
-@functools.cache
-def _gatt_config_schema(platform: str) -> cv.All:
-    """The neutral engine's schema: the shared keys plus the hub reference
-    (parsed-advertisement sightings) and the GATT backend declaration.
-    Keyed by platform - the backend fragment differs per platform."""
-    return cv.All(
-        _COMMON_SCHEMA.extend(ble_device_base.BLE_DEVICE_SCHEMA).extend(
-            bluetooth_connection.gatt_client_schema(platform)
-        ),
-        bluetooth_connection.consume_gatt_slot("ble_client"),
-    )
-
-
-@schema_extractor("schema")
-def _validate_platform(config: ConfigType) -> ConfigType:
-    if config is SCHEMA_EXTRACT:
-        # Deliberate gap (the bluetooth_proxy pattern): the dumper gets only
-        # this shape, so the neutral arm's ble_hub_id is absent from editor
-        # schemas and the esp32-only keys are advertised on every platform.
-        # The language-schema dumper runs without a platform; expose the
-        # esp32 (legacy-engine) shape.
-        return _esp32_config_schema()
-    if _legacy_engine():
-        return _esp32_config_schema()(config)
-    if CORE.target_platform in bluetooth_connection.GATT_CLIENT_PLATFORMS:
-        return _gatt_config_schema(CORE.target_platform)(config)
-    raise cv.Invalid(f"ble_client is not supported on {CORE.target_platform}")
-
-
-CONFIG_SCHEMA = _validate_platform
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA),
+    esp32_ble.consume_connection_slots(1, "ble_client"),
+)
 
 CONF_BLE_CLIENT_ID = "ble_client_id"
 
-
-class BLEClientFeatures(StrEnum):
-    """Per-platform engine capabilities consumers declare against."""
-
-    # The platform-neutral node interface (on_connected/table + completion
-    # callbacks) - every platform with a ble_client engine.
-    GATT_NODE = "gatt_node"
-    # The raw esp32 GATT client event stream (gattc/gap handlers,
-    # node_state) - the legacy engine only.
-    RAW_GATTC = "raw_gattc"
-    # Pairing dialog replies and bond management (Bluedroid GAP/SMP).
-    SECURITY = "security"
-
-
-def _engine_features() -> set[BLEClientFeatures]:
-    """Features the validated platform's engine provides."""
-    if _legacy_engine():
-        return {
-            BLEClientFeatures.GATT_NODE,
-            BLEClientFeatures.RAW_GATTC,
-            BLEClientFeatures.SECURITY,
-        }
-    if CORE.target_platform in bluetooth_connection.GATT_CLIENT_PLATFORMS:
-        return {BLEClientFeatures.GATT_NODE}
-    return set()
-
-
-def requires_feature(
-    feature: BLEClientFeatures, description: str
-) -> Callable[[Any], Any]:
-    """Validator gating a consumer to platforms whose engine provides
-    `feature`, naming the missing capability in the error."""
-
-    def validator(value: Any) -> Any:
-        features = _engine_features()
-        if feature not in features:
-            available = (
-                f"; this platform's engine provides: {', '.join(sorted(features))}"
-                if features
-                else ""
-            )
-            raise cv.Invalid(
-                f"{description} requires the ble_client '{feature}' feature, "
-                f"which {CORE.target_platform} does not provide{available}"
-            )
-        return value
-
-    return validator
-
-
-# The one choke point for every node component still on the raw esp32 event
-# stream; migrating to the neutral interface (NODE_BLE_CLIENT_SCHEMA +
-# register_gatt_node) lifts it.
-_legacy_engine_only = requires_feature(
-    BLEClientFeatures.RAW_GATTC,
-    "This component drives the raw ESP32 GATT client events and has not "
-    "been migrated to the platform-neutral node interface yet; it",
-)
-
 BLE_CLIENT_SCHEMA = cv.Schema(
     {
-        cv.GenerateID(CONF_BLE_CLIENT_ID): cv.All(
-            cv.use_id(BLEClient), _legacy_engine_only
-        ),
-    }
-)
-
-# For node components on the neutral interface: valid wherever ble_client
-# itself is.
-NODE_BLE_CLIENT_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_BLE_CLIENT_ID): cv.All(
-            cv.use_id(BLEClient),
-            requires_feature(BLEClientFeatures.GATT_NODE, "This component"),
-        ),
+        cv.GenerateID(CONF_BLE_CLIENT_ID): cv.use_id(BLEClient),
     }
 )
 
@@ -345,31 +171,11 @@ async def register_ble_node(var, config):
     cg.add(parent.register_ble_node(var))
 
 
-def _request_gatt_node_build() -> None:
-    """Node storage and the one define meaning "the neutral node surface is
-    compiled in", plus the esp32 bridge/materializer defines."""
-    _request_node_slot()
-    cg.add_define("USE_BLE_CLIENT_GATT_NODES")
-    if _legacy_engine():
-        # Deliberately not ble_device_base.request_gatt_client(): that would
-        # claim a phantom backend slot on combined proxy builds.
-        cg.add_define("USE_BLE_GATT_CLIENT")
-        cg.add_define("USE_BLE_GATT_BACKEND_BLUEDROID")
-        cg.add_define("USE_BLUEDROID_GATT_SERVICE_TABLE")
-
-
-async def register_gatt_node(var, config):
-    """Register a node on the platform-neutral interface (both engines)."""
-    parent = await cg.get_variable(config[CONF_BLE_CLIENT_ID])
-    _request_gatt_node_build()
-    cg.add(parent.register_gatt_node(var))
-
-
 BLE_WRITE_ACTION_SCHEMA = cv.Schema(
     {
         cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-        cv.Required(CONF_SERVICE_UUID): bt_uuid,
-        cv.Required(CONF_CHARACTERISTIC_UUID): bt_uuid,
+        cv.Required(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
+        cv.Required(CONF_CHARACTERISTIC_UUID): esp32_ble_tracker.bt_uuid,
         cv.Required(CONF_VALUE): cv.templatable(cv.ensure_list(cv.hex_uint8_t)),
     }
 )
@@ -380,34 +186,25 @@ BLE_CONNECT_ACTION_SCHEMA = maybe_simple_id(
     }
 )
 
-BLE_NUMERIC_COMPARISON_REPLY_ACTION_SCHEMA = cv.All(
-    requires_feature(BLEClientFeatures.SECURITY, "This action"),
-    cv.Schema(
-        {
-            cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-            cv.Required(CONF_ACCEPT): cv.templatable(cv.boolean),
-        }
-    ),
+BLE_NUMERIC_COMPARISON_REPLY_ACTION_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
+        cv.Required(CONF_ACCEPT): cv.templatable(cv.boolean),
+    }
 )
 
-BLE_PASSKEY_REPLY_ACTION_SCHEMA = cv.All(
-    requires_feature(BLEClientFeatures.SECURITY, "This action"),
-    cv.Schema(
-        {
-            cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-            cv.Required(CONF_PASSKEY): cv.templatable(cv.int_range(min=0, max=999999)),
-        }
-    ),
+BLE_PASSKEY_REPLY_ACTION_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
+        cv.Required(CONF_PASSKEY): cv.templatable(cv.int_range(min=0, max=999999)),
+    }
 )
 
 
-BLE_REMOVE_BOND_ACTION_SCHEMA = cv.All(
-    requires_feature(BLEClientFeatures.SECURITY, "This action"),
-    cv.Schema(
-        {
-            cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-        }
-    ),
+BLE_REMOVE_BOND_ACTION_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
+    }
 )
 
 
@@ -435,8 +232,6 @@ automation.register_simple_action(
 )
 async def ble_write_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
-    # The action registers itself as a neutral node in its constructor.
-    _request_gatt_node_build()
     var = cg.new_Pvariable(action_id, template_arg, parent)
 
     value = config[CONF_VALUE]
@@ -451,20 +246,38 @@ async def ble_write_to_code(config, action_id, template_arg, args):
         arr = cg.static_const_array(arr_id, cg.ArrayInitializer(*value))
         cg.add(var.set_value_simple(arr, len(value)))
 
-    if len(config[CONF_SERVICE_UUID]) == len(bt_uuid16_format):
-        cg.add(var.set_service_uuid16(as_hex(config[CONF_SERVICE_UUID])))
-    elif len(config[CONF_SERVICE_UUID]) == len(bt_uuid32_format):
-        cg.add(var.set_service_uuid32(as_hex(config[CONF_SERVICE_UUID])))
-    elif len(config[CONF_SERVICE_UUID]) == len(bt_uuid128_format):
-        uuid128 = as_reversed_hex_array(config[CONF_SERVICE_UUID])
+    if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
+        cg.add(
+            var.set_service_uuid16(esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID]))
+        )
+    elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid32_format):
+        cg.add(
+            var.set_service_uuid32(esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID]))
+        )
+    elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid128_format):
+        uuid128 = esp32_ble_tracker.as_reversed_hex_array(config[CONF_SERVICE_UUID])
         cg.add(var.set_service_uuid128(uuid128))
 
-    if len(config[CONF_CHARACTERISTIC_UUID]) == len(bt_uuid16_format):
-        cg.add(var.set_char_uuid16(as_hex(config[CONF_CHARACTERISTIC_UUID])))
-    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(bt_uuid32_format):
-        cg.add(var.set_char_uuid32(as_hex(config[CONF_CHARACTERISTIC_UUID])))
-    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(bt_uuid128_format):
-        uuid128 = as_reversed_hex_array(config[CONF_CHARACTERISTIC_UUID])
+    if len(config[CONF_CHARACTERISTIC_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
+        cg.add(
+            var.set_char_uuid16(
+                esp32_ble_tracker.as_hex(config[CONF_CHARACTERISTIC_UUID])
+            )
+        )
+    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(
+        esp32_ble_tracker.bt_uuid32_format
+    ):
+        cg.add(
+            var.set_char_uuid32(
+                esp32_ble_tracker.as_hex(config[CONF_CHARACTERISTIC_UUID])
+            )
+        )
+    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(
+        esp32_ble_tracker.bt_uuid128_format
+    ):
+        uuid128 = esp32_ble_tracker.as_reversed_hex_array(
+            config[CONF_CHARACTERISTIC_UUID]
+        )
         cg.add(var.set_char_uuid128(uuid128))
 
     return var
@@ -518,45 +331,14 @@ automation.register_simple_action(
 )
 
 
-async def _to_code_esp32(config: ConfigType) -> cg.MockObj:
-    from esphome.components import esp32_ble, esp32_ble_tracker
-    from esphome.components.esp32_ble import BTLoggers
-
+async def to_code(config):
     # Register the loggers this component needs
     esp32_ble.register_bt_logger(BTLoggers.GATT, BTLoggers.SMP)
     cg.add_define("USE_ESP32_BLE_UUID")
-    cg.add_define("USE_BLE_CLIENT_LEGACY_ENGINE")
 
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await esp32_ble_tracker.register_client(var, config)
-    return var
-
-
-# Sizes the neutral client's node storage; the client itself requests a
-# baseline slot so the define exists on every build that compiles the engine.
-_request_node_slot = cg.slot_counter("ESPHOME_BLE_CLIENT_MAX_NODES")
-
-
-async def _to_code_gatt(config: ConfigType) -> cg.MockObj:
-    # The engine always carries the node surface (the client itself owns the
-    # baseline slot).
-    _request_gatt_node_build()
-    backend = await bluetooth_connection.new_gatt_backend(config)
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    cg.add(var.set_backend(backend))
-    # Sighting-gated connects: the client listens for the peer's parsed
-    # advertisements through the hub.
-    await ble_device_base.register_ble_device(var, config)
-    return var
-
-
-async def to_code(config: ConfigType) -> None:
-    if _legacy_engine():
-        var = await _to_code_esp32(config)
-    else:
-        var = await _to_code_gatt(config)
     cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
     cg.add(var.set_auto_connect(config[CONF_AUTO_CONNECT]))
     for conf in config.get(CONF_ON_CONNECT, []):

esphome/components/ble_client/automation.cpp

@@ -0,0 +1,11 @@
+#ifdef USE_ESP32
+
+#include "automation.h"
+
+namespace esphome::ble_client {
+
+const char *const Automation::TAG = "ble_client.automation";  // NOLINT: ble_client never builds for ESP8266
+
+}  // namespace esphome::ble_client
+
+#endif

esphome/components/ble_client/automation.h

@@ -1,14 +1,27 @@
 #pragma once
 
-#include "esphome/core/defines.h"
+#ifdef USE_ESP32
 
-#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
+#include <utility>
+#include <vector>
 
 #include "esphome/core/automation.h"
 #include "esphome/components/ble_client/ble_client.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+// Maximum bytes to log in hex format for BLE writes (many logging buffers are 256 chars)
+static constexpr size_t BLE_WRITE_MAX_LOG_BYTES = 64;
 
 namespace esphome::ble_client {
 
+// placeholder class for static TAG .
+class Automation {
+ public:
+  // could be made inline with C++17
+  static const char *const TAG;
+};
+
 // Base for nodes that never read the parent's services.
 // The parent releases its services only once every node reports Established, so a node that never
 // reports it keeps that memory allocated for the life of the connection.
@@ -97,6 +110,144 @@ class BLEClientNumericComparisonRequestTrigger final : public Trigger<uint32_t>,
   }
 };
 
+// implement the ble_client.ble_write action.
+template<typename... Ts> class BLEClientWriteAction final : public Action<Ts...>, public BLEClientNode {
+ public:
+  BLEClientWriteAction(BLEClient *ble_client) {
+    ble_client->register_ble_node(this);
+    ble_client_ = ble_client;
+  }
+
+  void set_service_uuid16(uint16_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
+  void set_service_uuid32(uint32_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
+  void set_service_uuid128(uint8_t *uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
+
+  void set_char_uuid16(uint16_t uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
+  void set_char_uuid32(uint32_t uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
+  void set_char_uuid128(uint8_t *uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
+
+  void set_value_template(std::vector<uint8_t> (*func)(Ts...)) {
+    this->value_.func = func;
+    this->len_ = -1;  // Sentinel value indicates template mode
+  }
+
+  // Store pointer to static data in flash (no RAM copy)
+  void set_value_simple(const uint8_t *data, size_t len) {
+    this->value_.data = data;
+    this->len_ = len;  // Length >= 0 indicates static mode
+  }
+
+  void play(const Ts &...x) override {}
+
+  void play_complex(const Ts &...x) override {
+    this->num_running_++;
+    this->var_ = std::make_tuple(x...);
+
+    bool result;
+    if (this->len_ >= 0) {
+      // Static mode: write directly from flash pointer
+      result = this->write(this->value_.data, this->len_);
+    } else {
+      // Template mode: call function and write the vector
+      std::vector<uint8_t> value = this->value_.func(x...);
+      result = this->write(value);
+    }
+
+    // on write failure, continue the automation chain rather than stopping so that e.g. disconnect can work.
+    if (!result)
+      this->play_next_(x...);
+  }
+
+  /**
+   * Note about logging: the esph_log_X macros are used here because the CI checks complain about use of the ESP LOG
+   * macros in header files (Can't even write it in a comment!)
+   * Not sure why, because they seem to work just fine.
+   * The problem is that the implementation of a templated class can't be placed in a .cpp file when using C++ less than
+   * 17, so the methods have to be here.  The esph_log_X macros are equivalent in function, but don't trigger the CI
+   * errors.
+   */
+  // initiate the write. Return true if all went well, will be followed by a WRITE_CHAR event.
+  bool write(const uint8_t *data, size_t len) {
+    if (this->node_state != espbt::ClientState::ESTABLISHED) {
+      esph_log_w(Automation::TAG, "Cannot write to BLE characteristic - not connected");
+      return false;
+    }
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
+    char hex_buf[format_hex_pretty_size(BLE_WRITE_MAX_LOG_BYTES)];
+    esph_log_vv(Automation::TAG, "Will write %d bytes: %s", len, format_hex_pretty_to(hex_buf, data, len));
+#endif
+    esp_err_t err =
+        esp_ble_gattc_write_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->char_handle_, len,
+                                 const_cast<uint8_t *>(data), this->write_type_, ESP_GATT_AUTH_REQ_NONE);
+    if (err != ESP_OK) {
+      esph_log_e(Automation::TAG, "Error writing to characteristic: %s!", esp_err_to_name(err));
+      return false;
+    }
+    return true;
+  }
+
+  bool write(const std::vector<uint8_t> &value) { return this->write(value.data(), value.size()); }
+
+  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                           esp_ble_gattc_cb_param_t *param) override {
+    switch (event) {
+      case ESP_GATTC_WRITE_CHAR_EVT:
+        // upstream code checked the MAC address, verify the characteristic.
+        if (param->write.handle == this->char_handle_)
+          this->parent()->run_later([this]() { this->play_next_tuple_(this->var_); });
+        break;
+      case ESP_GATTC_DISCONNECT_EVT:
+        if (this->num_running_ != 0)
+          this->stop_complex();
+        break;
+      case ESP_GATTC_SEARCH_CMPL_EVT: {
+        auto *chr = this->parent()->get_characteristic(this->service_uuid_, this->char_uuid_);
+        if (chr == nullptr) {
+          char char_buf[esp32_ble::UUID_STR_LEN];
+          char service_buf[esp32_ble::UUID_STR_LEN];
+          esph_log_w("ble_write_action", "Characteristic %s was not found in service %s",
+                     this->char_uuid_.to_str(char_buf), this->service_uuid_.to_str(service_buf));
+          break;
+        }
+        this->char_handle_ = chr->handle;
+        this->char_props_ = chr->properties;
+        if (this->char_props_ & ESP_GATT_CHAR_PROP_BIT_WRITE) {
+          this->write_type_ = ESP_GATT_WRITE_TYPE_RSP;
+          esph_log_d(Automation::TAG, "Write type: ESP_GATT_WRITE_TYPE_RSP");
+        } else if (this->char_props_ & ESP_GATT_CHAR_PROP_BIT_WRITE_NR) {
+          this->write_type_ = ESP_GATT_WRITE_TYPE_NO_RSP;
+          esph_log_d(Automation::TAG, "Write type: ESP_GATT_WRITE_TYPE_NO_RSP");
+        } else {
+          char char_buf[esp32_ble::UUID_STR_LEN];
+          esph_log_e(Automation::TAG, "Characteristic %s does not allow writing", this->char_uuid_.to_str(char_buf));
+          break;
+        }
+        this->node_state = espbt::ClientState::ESTABLISHED;
+        char char_buf[esp32_ble::UUID_STR_LEN];
+        esph_log_d(Automation::TAG, "Found characteristic %s on device %s", this->char_uuid_.to_str(char_buf),
+                   ble_client_->address_str());
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+ private:
+  BLEClient *ble_client_;
+  ssize_t len_{-1};  // -1 = template mode, >=0 = static mode with length
+  union Value {
+    std::vector<uint8_t> (*func)(Ts...);  // Function pointer (stateless lambdas)
+    const uint8_t *data;                  // Pointer to static data in flash
+  } value_;
+  espbt::ESPBTUUID service_uuid_;
+  espbt::ESPBTUUID char_uuid_;
+  std::tuple<Ts...> var_{};
+  uint16_t char_handle_{};
+  esp_gatt_char_prop_t char_props_{};
+  esp_gatt_write_type_t write_type_{};
+};
+
 template<typename... Ts> class BLEClientPasskeyReplyAction final : public Action<Ts...> {
  public:
   BLEClientPasskeyReplyAction(BLEClient *ble_client) { parent_ = ble_client; }

esphome/components/ble_client/automation_gatt.h

@@ -1,118 +0,0 @@
-// Neutral twins of the shared ble_client automations. Class names, namespace,
-// and codegen-visible signatures are IDENTICAL to automation.h so generated
-// main.cpp compiles against whichever engine the build gates in; only the
-// internals differ (client callbacks and the neutral node interface instead
-// of raw gattc events). The Bluedroid-security automations (passkey, numeric
-// comparison, remove bond) have no neutral equivalent and stay esp32-only.
-
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#if defined(USE_BLE_GATT_CLIENT) && !defined(USE_BLE_CLIENT_LEGACY_ENGINE)
-
-#include <tuple>
-
-#include "ble_client_gatt.h"
-#include "esphome/core/automation.h"
-
-namespace esphome::ble_client {
-
-class BLEClientConnectTrigger final : public Trigger<> {
- public:
-  explicit BLEClientConnectTrigger(BLEClient *parent) {
-    parent->add_on_connect_callback([this]() { this->trigger(); });
-  }
-};
-
-class BLEClientDisconnectTrigger final : public Trigger<> {
- public:
-  explicit BLEClientDisconnectTrigger(BLEClient *parent) {
-    // Fires only after a completed connection (never for failed attempts),
-    // matching the legacy CLOSE_EVT semantics.
-    parent->add_on_disconnect_callback([this]() { this->trigger(); });
-  }
-};
-
-template<typename... Ts> class BLEClientConnectAction final : public Action<Ts...> {
- public:
-  BLEClientConnectAction(BLEClient *ble_client) {
-    ble_client_ = ble_client;
-    ble_client->add_on_connect_callback([this]() {
-      if (this->num_running_ != 0)
-        this->play_next_tuple_(this->var_);
-    });
-    // A connect attempt that dies (or a later disconnect) terminates the
-    // chain, mirroring the legacy DISCONNECT_EVT handling.
-    ble_client->add_on_connect_failed_callback([this]() {
-      if (this->num_running_ != 0)
-        this->stop_complex();
-    });
-    ble_client->add_on_disconnect_callback([this]() {
-      if (this->num_running_ != 0)
-        this->stop_complex();
-    });
-  }
-
-  // not used since we override play_complex_
-  void play(const Ts &...x) override {}
-
-  void play_complex(const Ts &...x) override {
-    // it makes no sense to have multiple instances of this running at the
-    // same time; cancel a re-trigger while still running.
-    if (this->num_running_ != 0) {
-      this->stop_complex();
-      return;
-    }
-    this->num_running_++;
-    if (this->ble_client_->connected()) {
-      this->play_next_(x...);
-    } else {
-      this->var_ = std::make_tuple(x...);
-      // No-op while already connecting; the callback resolves the wait.
-      this->ble_client_->connect();
-    }
-  }
-
- private:
-  BLEClient *ble_client_;
-  std::tuple<Ts...> var_{};
-};
-
-template<typename... Ts> class BLEClientDisconnectAction final : public Action<Ts...> {
- public:
-  BLEClientDisconnectAction(BLEClient *ble_client) {
-    ble_client_ = ble_client;
-    // Both terminal outcomes resolve the wait: a completed teardown and a
-    // connect attempt that died on the way down.
-    ble_client->add_on_disconnect_callback([this]() {
-      if (this->num_running_ != 0)
-        this->play_next_tuple_(this->var_);
-    });
-    ble_client->add_on_connect_failed_callback([this]() {
-      if (this->num_running_ != 0)
-        this->play_next_tuple_(this->var_);
-    });
-  }
-
-  // not used since we override play_complex_
-  void play(const Ts &...x) override {}
-
-  void play_complex(const Ts &...x) override {
-    this->num_running_++;
-    if (this->ble_client_->idle()) {
-      this->play_next_(x...);
-    } else {
-      this->var_ = std::make_tuple(x...);
-      this->ble_client_->disconnect();
-    }
-  }
-
- private:
-  BLEClient *ble_client_;
-  std::tuple<Ts...> var_{};
-};
-
-}  // namespace esphome::ble_client
-
-#endif  // USE_BLE_GATT_CLIENT && !USE_BLE_CLIENT_LEGACY_ENGINE

esphome/components/ble_client/ble_client.cpp

@@ -2,16 +2,10 @@
 #include "esphome/components/esp32_ble_client/ble_client_base.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/application.h"
-#include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
-
-#ifdef USE_BLE_CLIENT_GATT_NODES
-#include "esphome/components/bluetooth_connection/bluetooth_connection.h"
-#include "esphome/components/bluetooth_connection/gatt_service_table_bluedroid.h"
-#endif
+#ifdef USE_ESP32
 
 namespace esphome::ble_client {
 
@@ -36,10 +30,6 @@ void BLEClient::dump_config() {
 bool BLEClient::parse_device(const espbt::ESPBTDevice &device) {
   if (!this->enabled)
     return false;
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  if (device.address_uint64() == this->address_ && this->gatt_backoff_.holding_off())
-    return false;
-#endif
   return BLEClientBase::parse_device(device);
 }
 
@@ -50,60 +40,24 @@ void BLEClient::set_enabled(bool enabled) {
   if (!enabled) {
     ESP_LOGI(TAG, "[%s] Disabling BLE client.", this->address_str());
     this->disconnect();
-    return;
   }
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  // A re-enable clears the backoff (neutral-engine parity).
-  this->gatt_backoff_.reset();
-#endif
 }
 
 bool BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t esp_gattc_if,
                                     esp_ble_gattc_cb_param_t *param) {
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  // Bridge-initiated registrations bypass the base's REG_FOR_NOTIFY handling:
-  // its automatic CCCD write would double the node's own.
-  // Handle-keyed: mixed legacy/neutral subscriptions to one characteristic
-  // are unsupported during the migration window.
-  if (event == ESP_GATTC_REG_FOR_NOTIFY_EVT && esp_gattc_if == this->gattc_if_ &&
-      this->take_pending_gatt_reg_(param->reg_for_notify.handle)) {
-    if (this->pending_notify_regs_ > 0)
-      this->pending_notify_regs_--;
-    int err = param->reg_for_notify.status == ESP_GATT_OK ? 0 : param->reg_for_notify.status;
-    this->notify_state_to_gatt_nodes_(param->reg_for_notify.handle, true, err);
-    // A retiring last registration must still release the cache.
-    this->maybe_release_services_();
-    return true;
-  }
-#endif
   if (!BLEClientBase::gattc_event_handler(event, esp_gattc_if, param))
     return false;
 
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  // Before the legacy fan-out so gatt nodes resolve before any trigger fires.
-  if (!this->gatt_nodes_.empty()) {
-    if (event == ESP_GATTC_SEARCH_CMPL_EVT) {
-      // A failed discovery tears the link down; the on_connect trigger must
-      // not fire into the teardown.
-      if (!this->handle_gatt_search_cmpl_(param->search_cmpl.status))
-        return true;
-    } else {
-      this->dispatch_gatt_event_(event, param);
-    }
-  }
-#endif
   for (auto *node : this->nodes_)
     node->gattc_event_handler(event, esp_gattc_if, param);
-  this->maybe_release_services_();
-  return true;
-}
 
-void BLEClient::maybe_release_services_() {
   // The release frees the GATT cache that BLEClientBase's CCCD lookup still needs.
+  // The last REG_FOR_NOTIFY event clears the counter before node dispatch, so the release still runs here.
   if (!this->services_.empty() && !this->notify_registration_pending() && this->all_nodes_established_()) {
     this->release_services();
     ESP_LOGD(TAG, "All clients established, services released");
   }
+  return true;
 }
 
 void BLEClient::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
@@ -111,19 +65,10 @@ void BLEClient::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_p
 
   for (auto *node : this->nodes_)
     node->gap_event_handler(event, param);
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  if (event == ESP_GAP_BLE_AUTH_CMPL_EVT && this->check_addr(param->ble_security.auth_cmpl.bd_addr)) {
-    int status = param->ble_security.auth_cmpl.success ? 0 : param->ble_security.auth_cmpl.fail_reason;
-    for (auto *node : this->gatt_nodes_)
-      node->on_pairing_result(status);
-  }
-#endif
 }
 
 void BLEClient::set_state(espbt::ClientState state) {
   BLEClientBase::set_state(state);
-  // ESTABLISHED never flows through here; gatt nodes are promoted after the
-  // on_connected fan-out.
   for (auto &node : nodes_)
     node->node_state = state;
 }
@@ -138,221 +83,6 @@ bool BLEClient::all_nodes_established_() {
   return true;
 }
 
-#ifdef USE_BLE_CLIENT_GATT_NODES
-
-void BLEClient::register_gatt_node(BLEClientNode *node) {
-  // Parent before the capacity check so a dropped node still has a usable
-  // parent() (neutral-engine parity).
-  node->set_ble_client_parent(this);
-  if (this->gatt_nodes_.size() == ESPHOME_BLE_CLIENT_MAX_NODES) {
-    // push_back past capacity is a silent no-op; an undersized slot count
-    // must be loud at boot, not an unresolvable node at runtime.
-    ESP_LOGE(TAG, "[%s] Node capacity exceeded; node dropped", this->address_str());
-    this->status_set_error(LOG_STR("node capacity exceeded"));
-    return;
-  }
-  this->gatt_nodes_.push_back(node);
-  // nodes_ covers the shared state bookkeeping; gatt_nodes_ is the neutral
-  // fan-out subset.
-  this->register_ble_node(node);
-}
-
-int BLEClient::find_pending_gatt_reg_(uint16_t handle) const {
-  for (uint8_t i = 0; i < this->pending_gatt_reg_count_; i++) {
-    if (this->pending_gatt_regs_[i] == handle)
-      return i;
-  }
-  return -1;
-}
-
-bool BLEClient::take_pending_gatt_reg_(uint16_t handle) {
-  int i = this->find_pending_gatt_reg_(handle);
-  if (i < 0)
-    return false;
-  // No duplicates (notify_characteristic refuses a re-push); swap-with-last.
-  this->pending_gatt_regs_[i] = this->pending_gatt_regs_[--this->pending_gatt_reg_count_];
-  return true;
-}
-
-void BLEClient::notify_state_to_gatt_nodes_(uint16_t handle, bool enabled, int error) {
-  if (error != 0) {
-    ESP_LOGW(TAG, "[%s] Notify %s on handle 0x%04x failed, status=%d", this->address_str(),
-             enabled ? "enable" : "disable", handle, error);
-  }
-  for (auto *node : this->gatt_nodes_)
-    node->on_notify_state(handle, enabled, error);
-}
-
-void BLEClient::dispatch_gatt_event_(esp_gattc_cb_event_t event, esp_ble_gattc_cb_param_t *param) {
-  switch (event) {
-    case ESP_GATTC_READ_CHAR_EVT:
-    case ESP_GATTC_READ_DESCR_EVT: {
-      bool ok = param->read.status == ESP_GATT_OK;
-      if (!ok) {
-        // Breadcrumb even when no node claims the handle.
-        ESP_LOGD(TAG, "[%s] Read on handle 0x%04x completed with status %d", this->address_str(), param->read.handle,
-                 param->read.status);
-      }
-      for (auto *node : this->gatt_nodes_) {
-        node->on_read_result(param->read.handle, ok ? param->read.value : nullptr, ok ? param->read.value_len : 0,
-                             ok ? 0 : param->read.status);
-      }
-      break;
-    }
-    case ESP_GATTC_WRITE_CHAR_EVT:
-    case ESP_GATTC_WRITE_DESCR_EVT:
-      if (param->write.status != ESP_GATT_OK) {
-        // Breadcrumb even when no node claims the handle.
-        ESP_LOGD(TAG, "[%s] Write on handle 0x%04x completed with status %d", this->address_str(), param->write.handle,
-                 param->write.status);
-      }
-      for (auto *node : this->gatt_nodes_) {
-        node->on_write_result(param->write.handle, param->write.status == ESP_GATT_OK ? 0 : param->write.status);
-      }
-      break;
-    case ESP_GATTC_NOTIFY_EVT:
-      for (auto *node : this->gatt_nodes_) {
-        node->on_notify(param->notify.handle, param->notify.value, param->notify.value_len);
-      }
-      break;
-    case ESP_GATTC_UNREG_FOR_NOTIFY_EVT:
-      // The base does no CCCD work for unregister; no interception needed.
-      this->notify_state_to_gatt_nodes_(
-          param->unreg_for_notify.handle, false,
-          param->unreg_for_notify.status == ESP_GATT_OK ? 0 : param->unreg_for_notify.status);
-      break;
-    default:
-      break;
-  }
-}
-
-bool BLEClient::handle_gatt_search_cmpl_(esp_gatt_status_t status) {
-  // The base ignores the search status; the neutral contract must not.
-  uint16_t service_total = 0;
-  bool counted = status == ESP_GATT_OK && bluetooth_connection::BluedroidServiceTable::count_services(
-                                              this->gattc_if_, this->conn_id_, &service_total);
-  if (!counted || service_total == 0) {
-    // A failed search poisons the whole discovery, legacy nodes included.
-    ESP_LOGW(TAG, "[%s] Discovery failed (status=%d, services=%u)", this->address_str(), status, service_total);
-    this->gatt_backoff_.register_failure(this->address_str());
-    this->disconnect();
-    return false;
-  }
-  // Stack-owned; nodes copy their handles during on_connected().
-  bluetooth_connection::BluedroidServiceTable table;
-  if (!table.build(this->gattc_if_, this->conn_id_, service_total, this->connection_index_)) {
-    if (!this->has_legacy_nodes_()) {
-      ESP_LOGW(TAG, "[%s] Service table build failed; treating as failed discovery", this->address_str());
-      this->gatt_backoff_.register_failure(this->address_str());
-      this->disconnect();
-      return false;
-    }
-    // Only the table build failed; legacy nodes read the base's services_
-    // and keep the link. Gatt nodes catch the next connection.
-    ESP_LOGW(TAG, "[%s] Service table build failed; gatt nodes skip this connection", this->address_str());
-    this->status_set_warning(LOG_STR("gatt nodes inactive: service table build failed"));
-    // A peer whose database never walks must not retry the build at
-    // advertisement cadence once the legacy nodes drop the link.
-    this->gatt_backoff_.register_failure(this->address_str());
-  } else {
-    this->gatt_connected_ = true;
-    auto view = table.view();
-    for (auto *node : this->gatt_nodes_) {
-      node->on_connected(view);
-      if (this->state() != espbt::ClientState::ESTABLISHED) {
-        // The node tore the link down; remaining nodes get on_disconnected
-        // with no preceding on_connected, so leave a trace of why.
-        ESP_LOGW(TAG, "[%s] A node aborted the connection during setup", this->address_str());
-        return false;
-      }
-    }
-    this->gatt_backoff_.reset();
-    this->status_clear_warning();
-  }
-  // Promote so the legacy release condition can fire.
-  for (auto *node : this->gatt_nodes_)
-    node->node_state = espbt::ClientState::ESTABLISHED;
-  return true;
-}
-
-void BLEClient::on_disconnect_complete(esp_err_t reason) {
-  this->pending_gatt_reg_count_ = 0;
-  if (!this->gatt_connected_)
-    return;  // Never-established links report nothing (neutral parity).
-  this->gatt_connected_ = false;
-  for (auto *node : this->gatt_nodes_)
-    node->on_disconnected();
-}
-
-int BLEClient::check_and_log_error_(const char *operation, esp_err_t err) {
-  if (err != ESP_OK)
-    this->log_gattc_warning_(operation, err);
-  return err;
-}
-
-int BLEClient::write_characteristic(uint16_t handle, const uint8_t *data, uint16_t len, bool response) {
-  if (this->conn_id_ == UNSET_CONN_ID)
-    return ble_device_base::GATT_ERR_NOT_CONNECTED;
-  return this->check_and_log_error_(
-      "esp_ble_gattc_write_char",
-      esp_ble_gattc_write_char(this->gattc_if_, this->conn_id_, handle, len, const_cast<uint8_t *>(data),
-                               response ? ESP_GATT_WRITE_TYPE_RSP : ESP_GATT_WRITE_TYPE_NO_RSP,
-                               ESP_GATT_AUTH_REQ_NONE));
-}
-
-int BLEClient::read_characteristic(uint16_t handle) {
-  if (this->conn_id_ == UNSET_CONN_ID)
-    return ble_device_base::GATT_ERR_NOT_CONNECTED;
-  return this->check_and_log_error_("esp_ble_gattc_read_char", esp_ble_gattc_read_char(this->gattc_if_, this->conn_id_,
-                                                                                       handle, ESP_GATT_AUTH_REQ_NONE));
-}
-
-int BLEClient::read_descriptor(uint16_t handle) {
-  if (this->conn_id_ == UNSET_CONN_ID)
-    return ble_device_base::GATT_ERR_NOT_CONNECTED;
-  return this->check_and_log_error_(
-      "esp_ble_gattc_read_char_descr",
-      esp_ble_gattc_read_char_descr(this->gattc_if_, this->conn_id_, handle, ESP_GATT_AUTH_REQ_NONE));
-}
-
-int BLEClient::write_descriptor(uint16_t handle, const uint8_t *data, uint16_t len) {
-  if (this->conn_id_ == UNSET_CONN_ID)
-    return ble_device_base::GATT_ERR_NOT_CONNECTED;
-  return this->check_and_log_error_(
-      "esp_ble_gattc_write_char_descr",
-      esp_ble_gattc_write_char_descr(this->gattc_if_, this->conn_id_, handle, len, const_cast<uint8_t *>(data),
-                                     ESP_GATT_WRITE_TYPE_RSP, ESP_GATT_AUTH_REQ_NONE));
-}
-
-int BLEClient::notify_characteristic(uint16_t handle, bool enable) {
-  if (this->conn_id_ == UNSET_CONN_ID)
-    return ble_device_base::GATT_ERR_NOT_CONNECTED;
-  if (enable) {
-    if (this->find_pending_gatt_reg_(handle) >= 0) {
-      // ESP_OK: the in-flight registration's completion fans out to all nodes.
-      ESP_LOGW(TAG, "[%s] Notify registration already pending for handle 0x%04x", this->address_str(), handle);
-      return ESP_OK;
-    }
-    if (this->pending_gatt_reg_count_ == MAX_PENDING_NOTIFY_REGS) {
-      // An untracked registration would let the base's auto-CCCD through.
-      ESP_LOGE(TAG, "[%s] Too many pending notify registrations", this->address_str());
-      return ble_device_base::GATT_ERR_NO_MEMORY;
-    }
-    // The base helper's pending count holds the service-release until the
-    // (intercepted) completion.
-    esp_err_t err = this->register_for_notify(handle);
-    if (err == ESP_OK)
-      this->pending_gatt_regs_[this->pending_gatt_reg_count_++] = handle;
-    return this->check_and_log_error_("esp_ble_gattc_register_for_notify", err);
-  }
-  return this->check_and_log_error_("esp_ble_gattc_unregister_for_notify",
-                                    esp_ble_gattc_unregister_for_notify(this->gattc_if_, this->remote_bda_, handle));
-}
-
-int BLEClient::unpair() { return bluetooth_connection::unpair_device(this->get_address()); }
-
-#endif  // USE_BLE_CLIENT_GATT_NODES
-
 }  // namespace esphome::ble_client
 
 #endif

esphome/components/ble_client/ble_client.h

@@ -1,20 +1,18 @@
 #pragma once
 
-#include "esphome/core/defines.h"
-
-#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
-
-#include "ble_client_node.h"
-#include "connect_backoff.h"
 #include "esphome/components/esp32_ble_client/ble_client_base.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 
+#ifdef USE_ESP32
+
 #include <esp_bt_defs.h>
 #include <esp_gap_ble_api.h>
 #include <esp_gatt_common_api.h>
 #include <esp_gattc_api.h>
+#include <array>
+#include <string>
 #include <vector>
 
 namespace esphome::ble_client {
@@ -23,6 +21,34 @@ namespace espbt = esphome::esp32_ble_tracker;
 
 using namespace esp32_ble_client;
 
+class BLEClient;
+
+class BLEClientNode {
+ public:
+  virtual void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                                   esp_ble_gattc_cb_param_t *param){};
+  virtual void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {}
+  virtual void loop() {}
+  void set_address(uint64_t address) { address_ = address; }
+  espbt::ESPBTClient *client;
+  // This should be transitioned to Established once the node no longer needs
+  // the services/descriptors/characteristics of the parent client. This will
+  // allow some memory to be freed.
+  // The parent frees the peer's GATT cache once every node reports Established.
+  // Never report Established while an operation that reads that cache is outstanding.
+  // - esp_ble_gattc_register_for_notify() completes asynchronously.
+  // - Register from ESP_GATTC_SEARCH_CMPL_EVT, then set this from ESP_GATTC_REG_FOR_NOTIFY_EVT.
+  // - BLEClientBase::register_for_notify() holds the release until the registration completes.
+  espbt::ClientState node_state;
+
+  BLEClient *parent() { return this->parent_; }
+  void set_ble_client_parent(BLEClient *parent) { this->parent_ = parent; }
+
+ protected:
+  BLEClient *parent_;
+  uint64_t address_;
+};
+
 class BLEClient final : public BLEClientBase {
  public:
   void setup() override;
@@ -38,6 +64,7 @@ class BLEClient final : public BLEClientBase {
   void set_enabled(bool enabled);
 
   void register_ble_node(BLEClientNode *node) {
+    node->client = this;
     node->set_ble_client_parent(this);
     this->nodes_.push_back(node);
   }
@@ -46,57 +73,10 @@ class BLEClient final : public BLEClientBase {
 
   void set_state(espbt::ClientState state) override;
 
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  // ---- the neutral node surface (signatures shared with the non-esp32
-  // engine, so nodes on the neutral interface compile against either) ----
-  void register_gatt_node(BLEClientNode *node);
-
-  bool idle() const { return this->state() == espbt::ClientState::IDLE; }
-
-  int write_characteristic(uint16_t handle, const uint8_t *data, uint16_t len, bool response);
-  int read_characteristic(uint16_t handle);
-  int read_descriptor(uint16_t handle);
-  int write_descriptor(uint16_t handle, const uint8_t *data, uint16_t len);
-  /// Local registration only; per the neutral contract the CCCD write is the
-  /// node's job (the legacy auto-CCCD is suppressed for these handles).
-  int notify_characteristic(uint16_t handle, bool enable);
-  // pair() comes from BLEClientBase, matching the neutral engine's.
-  int unpair();
-#endif
-
  protected:
   bool all_nodes_established_();
-  void maybe_release_services_();
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  int check_and_log_error_(const char *operation, esp_err_t err);
-  int find_pending_gatt_reg_(uint16_t handle) const;
-  void notify_state_to_gatt_nodes_(uint16_t handle, bool enabled, int error);
-  void dispatch_gatt_event_(esp_gattc_cb_event_t event, esp_ble_gattc_cb_param_t *param);
-  // False = failed discovery: the link comes down and the caller suppresses
-  // the legacy fan-out.
-  bool handle_gatt_search_cmpl_(esp_gatt_status_t status);
-  bool take_pending_gatt_reg_(uint16_t handle);
-  void on_disconnect_complete(esp_err_t reason) override;
-#endif
 
   std::vector<BLEClientNode *> nodes_;
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  // Raise if a migrated node needs more concurrent registrations.
-  static constexpr uint8_t MAX_PENDING_NOTIFY_REGS = 4;
-
-  // Nodes on the neutral surface; fed the translated callbacks and
-  // auto-established after the on_connected fan-out. Every gatt node is
-  // also in nodes_ (registration pushes into both).
-  StaticVector<BLEClientNode *, ESPHOME_BLE_CLIENT_MAX_NODES> gatt_nodes_;
-  bool has_legacy_nodes_() const { return this->nodes_.size() > this->gatt_nodes_.size(); }
-  // Reconnect backoff after materializer failures.
-  ConnectBackoff gatt_backoff_;
-  // Bridge-initiated notify registrations awaiting REG_FOR_NOTIFY_EVT.
-  uint16_t pending_gatt_regs_[MAX_PENDING_NOTIFY_REGS];
-  uint8_t pending_gatt_reg_count_{0};
-  // on_connected fan-out started; on_disconnected is owed at teardown.
-  bool gatt_connected_{false};
-#endif
 };
 
 }  // namespace esphome::ble_client

esphome/components/ble_client/ble_client_gatt.cpp

@@ -1,255 +0,0 @@
-#include "ble_client_gatt.h"
-
-#if defined(USE_BLE_GATT_CLIENT) && !defined(USE_BLE_CLIENT_LEGACY_ENGINE)
-
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-
-namespace esphome::ble_client {
-
-ESPHOME_LOG_TAG(TAG, "ble_client");
-
-void BLEClient::register_ble_node(BLEClientNode *node) {
-  node->set_ble_client_parent(this);
-  if (this->nodes_.size() == ESPHOME_BLE_CLIENT_MAX_NODES) {
-    // push_back past capacity is a silent no-op; an undersized slot count
-    // must be loud at boot, not an unresolvable node at runtime.
-    ESP_LOGE(TAG, "[%s] Node capacity exceeded; node dropped", this->address_str_);
-    this->status_set_error(LOG_STR("node capacity exceeded"));
-    return;
-  }
-  this->nodes_.push_back(node);
-}
-
-void BLEClient::set_address(uint64_t address) {
-  this->address_ = address;
-  uint8_t mac[6];
-  ble_device_base::uint64_to_mac_msb_first(address, mac);
-  format_mac_addr_upper(mac, this->address_str_);
-}
-
-void BLEClient::set_enabled(bool enabled) {
-  if (enabled == this->enabled)
-    return;
-  ESP_LOGI(TAG, "[%s] %s", this->address_str_, enabled ? "Enabled" : "Disabled");
-  this->enabled = enabled;
-  if (!enabled) {
-    this->disconnect();
-    return;
-  }
-  // A re-enable clears the backoff; the next sighting connects (legacy
-  // parity: enabling does not itself connect).
-  this->backoff_.reset();
-}
-
-bool BLEClient::parse_device(const ble_device_base::ESPBTDevice &device) {
-  if (device.address_uint64() != this->address_)
-    return false;
-  // The sighting is the source of truth for the address type.
-  this->address_type_ = device.get_address_type();
-  this->address_type_known_ = true;
-  if (!this->enabled || !this->auto_connect_ || this->state_ != State::IDLE)
-    return true;
-  if (this->backoff_.holding_off())
-    return true;
-  this->attempt_connect_();
-  return true;
-}
-
-void BLEClient::connect() {
-  if (this->state_ != State::IDLE) {
-    ESP_LOGD(TAG, "[%s] Connect requested while busy, ignoring", this->address_str_);
-    return;
-  }
-  // An absent peer can inhibit scanning for the backend's full connect
-  // timeout, so this is worth a breadcrumb - but it is a supported action.
-  ESP_LOGI(TAG, "[%s] Connecting on request", this->address_str_);
-  if (!this->address_type_known_) {
-    // Legacy parity: without a sighting the address type defaults to
-    // public, which never matches a random-static peer.
-    ESP_LOGW(TAG, "[%s] No sighting yet; assuming a public address type", this->address_str_);
-  }
-  this->attempt_connect_();
-}
-
-void BLEClient::attempt_connect_() {
-  int err = this->backend_->connect(this->address_, this->address_type_);
-  if (err != 0) {
-    // A refused connect never produces a callback: stay idle, charge the
-    // backoff, and resolve any waiting connect action through the failure
-    // path so its chain terminates.
-    ESP_LOGW(TAG, "[%s] Connect refused, err=%d", this->address_str_, err);
-    this->backoff_.register_failure(this->address_str_);
-    this->defer([this]() { this->connect_failed_callbacks_.call(); });
-    return;
-  }
-  ESP_LOGD(TAG, "[%s] Connecting", this->address_str_);
-  this->state_ = State::CONNECTING;
-}
-
-void BLEClient::disconnect() {
-  if (this->state_ == State::IDLE) {
-    ESP_LOGD(TAG, "[%s] Disconnect requested while idle, ignoring", this->address_str_);
-    return;
-  }
-  // A deliberate teardown's failure report must not feed the backoff.
-  this->cancel_requested_ = true;
-  int err = this->backend_->gatt_disconnect();
-  if (err != 0) {
-    // Refused synchronously: backend and client disagree about the link
-    // state. Warn, then settle through the deliberate-cancel path.
-    ESP_LOGW(TAG, "[%s] Disconnect refused, err=%d; settling locally", this->address_str_, err);
-    this->on_connection_state(false, 0, err);
-  }
-}
-
-void BLEClient::on_connection_state(bool connected, uint16_t mtu, int error) {
-  if (connected) {
-    this->state_ = State::DISCOVERING;
-    int discover_err = this->backend_->discover_services();
-    if (discover_err != 0) {
-      // Synchronous refusal: no discovery completion will follow.
-      ESP_LOGW(TAG, "[%s] Service discovery refused, err=%d", this->address_str_, discover_err);
-      this->backoff_.register_failure(this->address_str_);
-      // Deliberate teardown: its report must not charge the backoff again.
-      this->disconnect();
-    }
-    return;
-  }
-  bool was_connected = this->state_ == State::CONNECTED;
-  bool cancelled = this->cancel_requested_;
-  this->cancel_requested_ = false;
-  this->state_ = State::IDLE;
-  if (was_connected) {
-    ESP_LOGI(TAG, "[%s] Disconnected, status=%d", this->address_str_, error);
-    for (auto *node : this->nodes_) {
-      node->on_disconnected();
-    }
-    // Continuations leave the backend's event-drain stack first.
-    this->defer([this]() { this->disconnect_callbacks_.call(); });
-  } else {
-    if (cancelled) {
-      // status carries the refusal code when the teardown settled
-      // synchronously; 0 on a backend-completed cancel.
-      ESP_LOGD(TAG, "[%s] Connect attempt cancelled, status=%d", this->address_str_, error);
-    } else {
-      ESP_LOGW(TAG, "[%s] Connect failed, status=%d", this->address_str_, error);
-      this->backoff_.register_failure(this->address_str_);
-    }
-    this->defer([this]() { this->connect_failed_callbacks_.call(); });
-  }
-}
-
-void BLEClient::on_service_discovery_done(int error) {
-  if (this->state_ != State::DISCOVERING || this->cancel_requested_) {
-    // Raced a teardown; the terminal report settles the link.
-    ESP_LOGD(TAG, "[%s] Discovery completed during teardown, ignoring", this->address_str_);
-    this->backend_->release_services();
-    return;
-  }
-  if (error != 0) {
-    ESP_LOGW(TAG, "[%s] Service discovery failed, status=%d", this->address_str_, error);
-    this->backoff_.register_failure(this->address_str_);
-    // The teardown is deliberate: do not charge the backoff again for its
-    // connection report.
-    this->disconnect();
-    return;
-  }
-  ble_device_base::GattServiceTable table{};
-  if (!this->nodes_.empty()) {
-    // Materialize only when a node will read it: a client with no nodes
-    // would pay the build/free cycle on every (re)connect for nothing.
-    table = this->backend_->get_service_table();
-    if (table.service_count == 0) {
-      // A failed materialization is indistinguishable from a service-less
-      // peer, and a real GATT peer always exposes at least GAP/GATT: fail
-      // the discovery before CONNECTED so the teardown resolves through
-      // connect_failed, never a spurious on_disconnect.
-      ESP_LOGW(TAG, "[%s] Service table is empty; treating as failed discovery", this->address_str_);
-      this->backend_->release_services();
-      this->backoff_.register_failure(this->address_str_);
-      this->disconnect();
-      return;
-    }
-  }
-  // CONNECTED before the fan-out so nodes may consult connected() from
-  // their own on_connected().
-  this->state_ = State::CONNECTED;
-  for (auto *node : this->nodes_) {
-    node->on_connected(table);
-    if (this->state_ != State::CONNECTED || this->cancel_requested_) {
-      // A node tore the link down mid-fan-out: on_disconnect fires with no
-      // preceding on_connect, so leave a trace of why.
-      ESP_LOGW(TAG, "[%s] A node aborted the connection during setup", this->address_str_);
-      this->backend_->release_services();
-      return;
-    }
-  }
-  this->backend_->release_services();
-  this->backoff_.reset();
-  ESP_LOGI(TAG, "[%s] Connected", this->address_str_);
-  this->defer([this]() { this->connect_callbacks_.call(); });
-}
-
-void BLEClient::on_write_result(uint16_t handle, int error) {
-  if (error != 0) {
-    // Breadcrumb even when no node claims the handle.
-    ESP_LOGD(TAG, "[%s] Write on handle 0x%04x completed with status %d", this->address_str_, handle, error);
-  }
-  for (auto *node : this->nodes_) {
-    node->on_write_result(handle, error);
-  }
-}
-
-void BLEClient::on_read_result(uint16_t handle, const uint8_t *data, uint16_t len, int error) {
-  if (error != 0) {
-    // Breadcrumb even when no node claims the handle.
-    ESP_LOGD(TAG, "[%s] Read on handle 0x%04x completed with status %d", this->address_str_, handle, error);
-  }
-  for (auto *node : this->nodes_) {
-    node->on_read_result(handle, data, len, error);
-  }
-}
-
-void BLEClient::on_notify_data(uint16_t handle, const uint8_t *data, uint16_t len) {
-  // Every node sees every notification and filters by handle (legacy parity).
-  for (auto *node : this->nodes_) {
-    node->on_notify(handle, data, len);
-  }
-}
-
-void BLEClient::on_notify_state(uint16_t handle, bool enabled, int error) {
-  if (error != 0) {
-    ESP_LOGW(TAG, "[%s] Notify %s on handle 0x%04x failed, status=%d", this->address_str_,
-             enabled ? "enable" : "disable", handle, error);
-  }
-  for (auto *node : this->nodes_) {
-    node->on_notify_state(handle, enabled, error);
-  }
-}
-
-void BLEClient::on_pairing_result(int status) {
-  if (status != 0) {
-    ESP_LOGW(TAG, "[%s] Pairing failed, status=%d", this->address_str_, status);
-  } else {
-    ESP_LOGI(TAG, "[%s] Paired", this->address_str_);
-  }
-  for (auto *node : this->nodes_) {
-    node->on_pairing_result(status);
-  }
-}
-
-void BLEClient::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "BLE Client:\n"
-                "  Address: %s\n"
-                "  Auto connect: %s",
-                this->address_str_, YESNO(this->auto_connect_));
-  if (this->enabled && this->state_ == State::IDLE) {
-    ESP_LOGCONFIG(TAG, "  Waiting for an advertisement from the device");
-  }
-}
-
-}  // namespace esphome::ble_client
-
-#endif  // USE_BLE_GATT_CLIENT && !USE_BLE_CLIENT_LEGACY_ENGINE

esphome/components/ble_client/ble_client_gatt.h

@@ -1,149 +0,0 @@
-// Platform-neutral ble_client engine on the ble_device_base GATT contract.
-//
-// Compiled on every platform with a GATT backend except esp32, which keeps
-// the legacy BLEClientBase engine (ble_client.h) until its raw-gattc node
-// family migrates - the exclusive gates make the same class names resolve to
-// exactly one definition per build, so codegen is shared.
-//
-// Connects are sighting-gated like the legacy engine: the client is a parsed
-// advertisement listener, captures the peer's address type from the sighting,
-// and asks the backend to connect only when enabled and idle.
-
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#if defined(USE_BLE_GATT_CLIENT) && !defined(USE_BLE_CLIENT_LEGACY_ENGINE)
-
-#include "ble_client_node.h"
-#include "connect_backoff.h"
-#include "esphome/components/ble_device_base/ble_device.h"
-#include "esphome/components/ble_device_base/ble_gatt_client.h"
-#include "esphome/components/bluetooth_connection/bluetooth_connection.h"
-#include "esphome/components/bluetooth_connection/bluetooth_connection_gatt_backend.h"
-#include "esphome/core/component.h"
-#include "esphome/core/helpers.h"
-
-#include <cstdint>
-#include <functional>
-
-namespace esphome::ble_client {
-
-class BLEClient : public Component,
-                  public ble_device_base::ESPBTDeviceListener,
-                  public ble_device_base::GattClientListener {
- public:
-  void dump_config() override;
-
-  // Public field for legacy parity (the switch platform republishes it).
-  bool enabled{true};
-
-  void set_backend(ble_device_base::BLEGattConnection *backend) {
-    this->backend_ = backend;
-    backend->set_listener(this);
-  }
-  void set_address(uint64_t address);
-  void set_auto_connect(bool auto_connect) { this->auto_connect_ = auto_connect; }
-  void set_enabled(bool enabled);
-  const char *address_str() const { return this->address_str_; }
-
-  void register_ble_node(BLEClientNode *node);
-  // One registration spelling shared with the esp32 engine's bridge.
-  void register_gatt_node(BLEClientNode *node) { this->register_ble_node(node); }
-
-  bool connected() const { return this->state_ == State::CONNECTED; }
-  bool idle() const { return this->state_ == State::IDLE; }
-
-  /// Action-initiated connect (no sighting needed; uses the last captured
-  /// address type, public until a sighting arrives). No-op unless idle.
-  void connect();
-  void disconnect();
-
-  /// Legacy-named deferral used by the automation twins: neutral listener
-  /// callbacks run inside the backend's event drain, so automation chain
-  /// continuations must leave that stack first.
-  void run_later(std::function<void()> &&f) { this->defer(std::move(f)); }  // NOLINT
-
-  // Backend ops for nodes and actions - the frozen node-facing surface.
-  // Only write_characteristic has an in-tree caller; subscribing means
-  // notify_characteristic plus a CCCD write_descriptor (the caller's job
-  // per the contract).
-  int write_characteristic(uint16_t handle, const uint8_t *data, uint16_t len, bool response) {
-    return this->backend_->write_characteristic(handle, data, len, response);
-  }
-  int read_characteristic(uint16_t handle) { return this->backend_->read_characteristic(handle); }
-  int read_descriptor(uint16_t handle) { return this->backend_->read_descriptor(handle); }
-  int write_descriptor(uint16_t handle, const uint8_t *data, uint16_t len) {
-    return this->backend_->write_descriptor(handle, data, len);
-  }
-  int notify_characteristic(uint16_t handle, bool enable) {
-    return this->backend_->notify_characteristic(handle, enable);
-  }
-  int pair() { return this->backend_->pair(); }
-  int unpair() { return bluetooth_connection::unpair_device(this->address_); }
-
-  // Automation callback registration.
-  template<typename F> void add_on_connect_callback(F &&callback) {
-    this->connect_callbacks_.add(std::forward<F>(callback));
-  }
-  template<typename F> void add_on_disconnect_callback(F &&callback) {
-    this->disconnect_callbacks_.add(std::forward<F>(callback));
-  }
-  // Fired when a connect attempt dies before being established; the user
-  // on_disconnect trigger deliberately does NOT fire here (legacy parity).
-  template<typename F> void add_on_connect_failed_callback(F &&callback) {
-    this->connect_failed_callbacks_.add(std::forward<F>(callback));
-  }
-
-  // ---- ble_device_base::ESPBTDeviceListener ----
-  bool parse_device(const ble_device_base::ESPBTDevice &device) override;
-
-  // ---- ble_device_base::GattClientListener ----
-  void on_connection_state(bool connected, uint16_t mtu, int error) override;
-  void on_service_discovery_done(int error) override;
-  void on_read_result(uint16_t handle, const uint8_t *data, uint16_t len, int error) override;
-  void on_write_result(uint16_t handle, int error) override;
-  void on_notify_data(uint16_t handle, const uint8_t *data, uint16_t len) override;
-  void on_notify_state(uint16_t handle, bool enabled, int error) override;
-  void on_pairing_result(int status) override;
-
- protected:
-  enum class State : uint8_t { IDLE, CONNECTING, DISCOVERING, CONNECTED };
-
-  void attempt_connect_();
-
-  // Group 1: pointers / containers
-  ble_device_base::BLEGattConnection *backend_{nullptr};
-  // Codegen-sized (ESPHOME_BLE_CLIENT_MAX_NODES); filled during setup.
-  StaticVector<BLEClientNode *, ESPHOME_BLE_CLIENT_MAX_NODES> nodes_;
-
-  // Group 2: 8-byte types
-  uint64_t address_{0};
-
-  // Group 3: callback managers (pointer-sized when empty)
-  LazyCallbackManager<void()> connect_callbacks_;
-  LazyCallbackManager<void()> disconnect_callbacks_;
-  LazyCallbackManager<void()> connect_failed_callbacks_;
-
-  // Group 4: 4-byte types
-  // Backoff so an undiscoverable database or a dead peer cannot produce a
-  // battery-draining connect loop.
-  ConnectBackoff backoff_;
-
-  // Group 5: arrays
-  char address_str_[MAC_ADDRESS_PRETTY_BUFFER_SIZE]{};
-
-  // Group 6: 1-byte types
-  State state_{State::IDLE};
-  uint8_t address_type_{0};  // BLE_ADDR_TYPE_*, captured from the sighting
-  // Distinguishes a captured public type from the never-sighted default.
-  bool address_type_known_{false};
-  bool auto_connect_{true};
-  // A user-initiated teardown in flight; its failure report is not a
-  // connect failure and must not feed the backoff.
-  bool cancel_requested_{false};
-};
-
-}  // namespace esphome::ble_client
-
-#endif  // USE_BLE_GATT_CLIENT && !USE_BLE_CLIENT_LEGACY_ENGINE

esphome/components/ble_client/ble_client_node.h

@@ -1,68 +0,0 @@
-// The single BLEClientNode both ble_client engines share. The neutral
-// callback surface is the one interface node components build on; the raw
-// esp32 surface below it remains for components that have not migrated yet.
-
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#ifdef USE_BLE_GATT_CLIENT
-#include "esphome/components/ble_device_base/ble_gatt_client.h"
-#endif
-#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
-#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
-
-#include <esp_gap_ble_api.h>
-#include <esp_gattc_api.h>
-#endif
-
-#include <cstdint>
-
-namespace esphome::ble_client {
-
-class BLEClient;
-
-class BLEClientNode {
- public:
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  // Neutral surface, delivered by both engines. The table is borrowed: copy
-  // handles during on_connected(). All nodes see all completions; filter by
-  // handle.
-  // A node that disconnects from inside on_connected() aborts the fan-out;
-  // the user's on_disconnect may then fire without a preceding on_connect.
-  virtual void on_connected(const ble_device_base::GattServiceTable &table) {}
-  virtual void on_disconnected() {}
-  virtual void on_notify(uint16_t handle, const uint8_t *data, uint16_t len) {}
-  // One in-flight registration per handle; its completion fans out to every
-  // node, so a refused duplicate request still sees on_notify_state.
-  virtual void on_notify_state(uint16_t handle, bool enabled, int error) {}
-  virtual void on_read_result(uint16_t handle, const uint8_t *data, uint16_t len, int error) {}
-  virtual void on_write_result(uint16_t handle, int error) {}
-  virtual void on_pairing_result(int status) {}
-#endif
-#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
-  // Legacy raw surface; components overriding these need the legacy engine
-  // until migrated to the neutral surface above.
-  virtual void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
-                                   esp_ble_gattc_cb_param_t *param) {}
-  virtual void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {}
-  virtual void loop() {}
-  // This should be transitioned to Established once the node no longer needs
-  // the services/descriptors/characteristics of the parent client. This will
-  // allow some memory to be freed.
-  // The parent frees the peer's GATT cache once every node reports Established.
-  // Never report Established while an operation that reads that cache is outstanding.
-  // - esp_ble_gattc_register_for_notify() completes asynchronously.
-  // - Register from ESP_GATTC_SEARCH_CMPL_EVT, then set this from ESP_GATTC_REG_FOR_NOTIFY_EVT.
-  // - BLEClientBase::register_for_notify() holds the release until the registration completes.
-  esp32_ble_tracker::ClientState node_state;
-#endif
-
-  BLEClient *parent() const { return this->parent_; }
-  void set_ble_client_parent(BLEClient *parent) { this->parent_ = parent; }
-
- protected:
-  BLEClient *parent_{nullptr};
-};
-
-}  // namespace esphome::ble_client

esphome/components/ble_client/ble_write_action.h

@@ -1,172 +0,0 @@
-// The ble_client.ble_write action: a node on the platform-neutral interface,
-// so one implementation serves both engines (the esp32 bridge and the
-// neutral engine).
-
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#ifdef USE_BLE_CLIENT_GATT_NODES
-
-#include <tuple>
-#include <vector>
-
-// One of the two engine headers resolves per build.
-#include "ble_client.h"
-#include "ble_client_gatt.h"
-#include "ble_client_node.h"
-#include "esphome/core/automation.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome::ble_client {
-
-static const char *const BLE_WRITE_TAG = "ble_client.automation";
-
-// Maximum bytes to log in hex format for BLE writes (many logging buffers are 256 chars)
-static constexpr size_t BLE_WRITE_MAX_LOG_BYTES = 64;
-
-template<typename... Ts> class BLEClientWriteAction final : public Action<Ts...>, public BLEClientNode {
- public:
-  BLEClientWriteAction(BLEClient *ble_client) {
-    ble_client->register_gatt_node(this);
-    ble_client_ = ble_client;
-  }
-
-  void set_service_uuid16(uint16_t uuid) { this->service_uuid_ = ble_device_base::ESPBTUUID::from_uint16(uuid); }
-  void set_service_uuid32(uint32_t uuid) { this->service_uuid_ = ble_device_base::ESPBTUUID::from_uint32(uuid); }
-  void set_service_uuid128(uint8_t *uuid) { this->service_uuid_ = ble_device_base::ESPBTUUID::from_raw(uuid); }
-
-  void set_char_uuid16(uint16_t uuid) { this->char_uuid_ = ble_device_base::ESPBTUUID::from_uint16(uuid); }
-  void set_char_uuid32(uint32_t uuid) { this->char_uuid_ = ble_device_base::ESPBTUUID::from_uint32(uuid); }
-  void set_char_uuid128(uint8_t *uuid) { this->char_uuid_ = ble_device_base::ESPBTUUID::from_raw(uuid); }
-
-  void set_value_template(std::vector<uint8_t> (*func)(Ts...)) {
-    this->value_.func = func;
-    this->len_ = -1;  // Sentinel value indicates template mode
-  }
-
-  // Store pointer to static data in flash (no RAM copy)
-  void set_value_simple(const uint8_t *data, size_t len) {
-    this->value_.data = data;
-    this->len_ = len;  // Length >= 0 indicates static mode
-  }
-
-  void play(const Ts &...x) override {}
-
-  void play_complex(const Ts &...x) override {
-    this->num_running_++;
-    this->var_ = std::make_tuple(x...);
-
-    bool result;
-    if (this->len_ >= 0) {
-      result = this->write(this->value_.data, this->len_);
-    } else {
-      std::vector<uint8_t> value = this->value_.func(x...);
-      result = this->write(value.data(), value.size());
-    }
-
-    // on write failure, continue the automation chain rather than stopping so
-    // that e.g. disconnect can work.
-    if (!result)
-      this->play_next_(x...);
-  }
-
-  // Initiate the write; the completion arrives in on_write_result. The
-  // response-less path can complete synchronously inside the call, so the
-  // handle is armed before the backend is touched.
-  bool write(const uint8_t *data, size_t len) {
-    if (!this->ble_client_->connected()) {
-      esph_log_w(BLE_WRITE_TAG, "Cannot write to BLE characteristic - not connected");
-      return false;
-    }
-    if (!this->resolved_) {
-      esph_log_w(BLE_WRITE_TAG, "Cannot write to BLE characteristic - characteristic was not resolved");
-      return false;
-    }
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
-    char hex_buf[format_hex_pretty_size(BLE_WRITE_MAX_LOG_BYTES)];
-    esph_log_vv(BLE_WRITE_TAG, "Will write %d bytes: %s", len, format_hex_pretty_to(hex_buf, data, len));
-#endif
-    int err = this->ble_client_->write_characteristic(this->char_handle_, data, len, this->write_response_);
-    if (err != 0) {
-      esph_log_e(BLE_WRITE_TAG, "Error writing to characteristic: %d!", err);
-      return false;
-    }
-    return true;
-  }
-
-  void on_connected(const ble_device_base::GattServiceTable &table) override {
-    // Resolution comes from this table only; a re-discovery must not keep a
-    // stale handle.
-    this->resolved_ = false;
-    this->char_handle_ = 0;
-    const auto *service = ble_device_base::find_service(table, this->service_uuid_);
-    const auto *chr =
-        service == nullptr ? nullptr : ble_device_base::find_characteristic(table, *service, this->char_uuid_);
-    if (chr == nullptr) {
-      char char_buf[ble_device_base::UUID_STR_LEN];
-      char service_buf[ble_device_base::UUID_STR_LEN];
-      esph_log_w(BLE_WRITE_TAG, "Characteristic %s was not found in service %s", this->char_uuid_.to_str(char_buf),
-                 this->service_uuid_.to_str(service_buf));
-      return;
-    }
-    if (chr->properties & ble_device_base::GATT_CHAR_PROP_WRITE) {
-      this->write_response_ = true;
-    } else if (chr->properties & ble_device_base::GATT_CHAR_PROP_WRITE_NO_RSP) {
-      this->write_response_ = false;
-    } else {
-      char char_buf[ble_device_base::UUID_STR_LEN];
-      esph_log_e(BLE_WRITE_TAG, "Characteristic %s does not allow writing", this->char_uuid_.to_str(char_buf));
-      return;
-    }
-    this->char_handle_ = chr->value_handle;
-    this->resolved_ = true;
-    char char_buf[ble_device_base::UUID_STR_LEN];
-    esph_log_d(BLE_WRITE_TAG, "Found characteristic %s on device %s", this->char_uuid_.to_str(char_buf),
-               this->ble_client_->address_str());
-  }
-
-  void on_disconnected() override {
-    this->resolved_ = false;
-    this->char_handle_ = 0;
-    if (this->num_running_ != 0)
-      this->stop_complex();
-  }
-
-  void on_write_result(uint16_t handle, int error) override {
-    if (this->num_running_ == 0) {
-      return;
-    }
-    if (!this->resolved_ || handle != this->char_handle_) {
-      // A parked chain waiting on a completion that never matches would
-      // otherwise stall silently until disconnect.
-      esph_log_d(BLE_WRITE_TAG, "Write result for handle 0x%04x ignored, waiting on 0x%04x", handle,
-                 this->char_handle_);
-      return;
-    }
-    if (error != 0) {
-      // Continue the chain (legacy parity) but leave a breadcrumb.
-      esph_log_w(BLE_WRITE_TAG, "Write completed with status %d", error);
-    }
-    this->ble_client_->run_later([this]() { this->play_next_tuple_(this->var_); });
-  }
-
- private:
-  BLEClient *ble_client_;
-  ssize_t len_{-1};  // -1 = template mode, >=0 = static mode with length
-  union Value {
-    std::vector<uint8_t> (*func)(Ts...);  // Function pointer (stateless lambdas)
-    const uint8_t *data;                  // Pointer to static data in flash
-  } value_;
-  ble_device_base::ESPBTUUID service_uuid_;
-  ble_device_base::ESPBTUUID char_uuid_;
-  std::tuple<Ts...> var_{};
-  uint16_t char_handle_{};
-  bool write_response_{false};
-  bool resolved_{false};
-};
-
-}  // namespace esphome::ble_client
-
-#endif  // USE_BLE_CLIENT_GATT_NODES

esphome/components/ble_client/connect_backoff.h

@@ -1,43 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#ifdef USE_BLE_GATT_CLIENT
-
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-
-#include <cstdint>
-
-namespace esphome::ble_client {
-
-/// Reconnect backoff after repeated connect/discovery failures, shared by
-/// both engines. 256 ms ticks in a uint16_t keep it 4 bytes; the ~4.7 h tick
-/// wrap can at worst reinstate one stale hold-off of a minute.
-class ConnectBackoff {
- public:
-  bool holding_off() const {
-    return this->failures_ != 0 && static_cast<uint16_t>(now() - this->start_) < this->failures_ * STEP_TICKS;
-  }
-  void register_failure(const char *address_str) {
-    if (this->failures_ < MAX_STEPS)
-      this->failures_++;
-    this->start_ = now();
-    esph_log_w("ble_client", "[%s] Holding off reconnect for %u s", address_str, this->failures_ * 10u);
-  }
-  void reset() { this->failures_ = 0; }
-
- private:
-  // ~10 s per consecutive failure, capped so a flapping peer retries within
-  // a minute at worst.
-  static constexpr uint16_t STEP_TICKS = 40;  // x 256 ms
-  static constexpr uint8_t MAX_STEPS = 6;
-  static uint16_t now() { return static_cast<uint16_t>(millis() >> 8); }
-
-  uint16_t start_{0};
-  uint8_t failures_{0};
-};
-
-}  // namespace esphome::ble_client
-
-#endif  // USE_BLE_GATT_CLIENT

esphome/components/ble_device_base/ble_gatt_client.cpp

@@ -1,48 +0,0 @@
-#include "ble_gatt_client.h"
-
-#ifdef USE_BLE_GATT_CLIENT
-
-#include "esphome/core/log.h"
-
-namespace esphome::ble_device_base {
-
-ESPHOME_LOG_TAG(TAG, "ble_device_base");
-
-const GattCharacteristic *find_characteristic(const GattServiceTable &table, const GattService &service,
-                                              const ESPBTUUID &uuid) {
-  // 32-bit range math: a corrupt first/count pair cannot wrap past the check.
-  uint32_t end = uint32_t(service.first_characteristic) + service.characteristic_count;
-  if (end > table.characteristic_count) {
-    ESP_LOGW(TAG, "characteristic range out of bounds");
-    return nullptr;
-  }
-  for (uint32_t i = service.first_characteristic; i < end; i++) {
-    if (table.characteristics[i].uuid == uuid)
-      return &table.characteristics[i];
-  }
-  return nullptr;
-}
-
-const GattDescriptor *find_descriptor(const GattServiceTable &table, const GattCharacteristic &characteristic,
-                                      const ESPBTUUID &uuid) {
-  uint32_t end = uint32_t(characteristic.first_descriptor) + characteristic.descriptor_count;
-  if (end > table.descriptor_count) {
-    // Corrupt range, not a missing descriptor.
-    ESP_LOGW(TAG, "descriptor range out of bounds");
-    return nullptr;
-  }
-  for (uint32_t i = characteristic.first_descriptor; i < end; i++) {
-    if (table.descriptors[i].uuid == uuid)
-      return &table.descriptors[i];
-  }
-  return nullptr;
-}
-
-uint16_t find_cccd(const GattServiceTable &table, const GattCharacteristic &characteristic) {
-  const GattDescriptor *desc = find_descriptor(table, characteristic, ESPBTUUID::from_uint16(CCCD_UUID));
-  return desc != nullptr ? desc->handle : 0;
-}
-
-}  // namespace esphome::ble_device_base
-
-#endif  // USE_BLE_GATT_CLIENT

esphome/components/ble_device_base/ble_gatt_client.h

@@ -11,16 +11,13 @@
 // interface. All listener calls are delivered on the ESPHome main loop;
 // borrowed data pointers are valid only for the duration of the call.
 //
-// Error domain (plain int, forwarded to the API without translation, so the
-// values are wire-frozen - API clients interpret them):
+// Error domain (plain int, forwarded to the API without translation):
 //   0            success
-//   1..0x11      ATT error codes (Bluetooth spec) - reserved; a backend whose
-//                native error codes land in this window must remap them out
+//   1..0x11      ATT error codes (Bluetooth spec; BTstack and Bluedroid agree)
 //   GATT_ERR_NOT_CONNECTED (-1)  no connection to the peer (on esp32 a raw
 //                ESP_FAIL from the stack shares this value; both read as a
 //                failed, unusable connection on the client side)
 //   GATT_ERR_NO_MEMORY (-2)      backend storage exhausted
-//   -1..-15      reserved for future contract sentinels
 //   anything else: platform stack error/status code, surfaced opaquely.
 // Connection events carry HCI status/disconnect reason codes (same code
 // space on every controller).
@@ -102,18 +99,9 @@ class GattClientListener {
 // The BLEGattConnection op surface, asserted where the alias binds
 // (bluetooth_connection_gatt_backend.h). Operations return 0 when accepted (completion arrives
 // through the listener) or a synchronous error (busy, not connected, stack
-// rejection); one operation may be outstanding at a time. An accepted
-// operation's completion is delivered from the event loop, NEVER
-// synchronously from inside the op call - a synchronous terminal
-// on_connection_state from within gatt_disconnect() would re-enter the
-// consumer mid-teardown. Semantics beyond the signatures:
+// rejection); one operation may be outstanding at a time. Semantics beyond
+// the signatures:
 // - connect: addr_type is a BLE_ADDR_TYPE_* constant (ble_device.h).
-//   Returning 0 means the request is accepted, not that the radio acted: the
-//   backend owns integration with its platform's scan/connect arbitration
-//   (Bluedroid parks the request for the tracker's promote loop, which owns
-//   scan-stop/coex/one-connect-at-a-time; the rp2 backend opens immediately
-//   and relies on sighting-gated consumers). Consumers must not assume
-//   connect timing.
 // - gatt_disconnect: also cancels a connect in progress (named to coexist
 //   with a platform stack's own void disconnect() on one backend class).
 //   Nonzero means nothing to tear down and no completion will follow; an
@@ -155,41 +143,6 @@ concept BLEGattConnectionContract = requires(T conn, GattClientListener *listene
   { conn.set_connection_type(ConnectionType{}) } -> std::same_as<void>;
 };
 
-// ---- service table lookup helpers ----
-//
-// Neutral, bounds-checked walks over a materialized GattServiceTable for
-// direct consumers that resolve a known device's handles by UUID (streaming
-// consumers forward the raw database and never need these). Linear search:
-// the table exists only between discovery and release_services(), for one
-// small known device.
-
-/// Client Characteristic Configuration descriptor UUID (Bluetooth spec).
-static constexpr uint16_t CCCD_UUID = 0x2902;
-
-// Characteristic property bits (the Bluetooth-spec declaration byte carried
-// in GattCharacteristic::properties; the ESP-IDF macros for these do not
-// exist on the other platforms).
-static constexpr uint8_t GATT_CHAR_PROP_WRITE_NO_RSP = 0x04;
-static constexpr uint8_t GATT_CHAR_PROP_WRITE = 0x08;
-
-inline const GattService *find_service(const GattServiceTable &table, const ESPBTUUID &uuid) {
-  for (uint16_t i = 0; i < table.service_count; i++) {
-    if (table.services[i].uuid == uuid)
-      return &table.services[i];
-  }
-  return nullptr;
-}
-
-const GattCharacteristic *find_characteristic(const GattServiceTable &table, const GattService &service,
-                                              const ESPBTUUID &uuid);
-
-const GattDescriptor *find_descriptor(const GattServiceTable &table, const GattCharacteristic &characteristic,
-                                      const ESPBTUUID &uuid);
-
-/// Handle of the characteristic's Client Characteristic Configuration
-/// descriptor (0x2902), or 0 when it has none.
-uint16_t find_cccd(const GattServiceTable &table, const GattCharacteristic &characteristic);
-
 }  // namespace esphome::ble_device_base
 
 #endif  // USE_BLE_GATT_CLIENT

esphome/components/bluetooth_connection/__init__.py

@@ -1,14 +1,12 @@
 """Per-platform GATT connection backends and the helpers to embed one.
 
-Backends: esp32 Bluedroid, rp2 BTstack. No user-facing configuration; a
-consumer's codegen declares and registers the backend instances — the
-Bluetooth proxy through its per-slot connection wrappers (a streaming
-consumer), and the neutral ble_client through gatt_client_schema() +
-new_gatt_backend().
+Backends: esp32 Bluedroid, rp2 BTstack. No user-facing configuration; the
+Bluetooth proxy's codegen declares and registers the backend instances
+through gatt_client_schema()/hub_connection_schema() + new_gatt_backend().
 """
 
 from collections.abc import Awaitable, Callable
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 
 import esphome.codegen as cg
 from esphome.components import rp2040_ble
@@ -25,8 +23,7 @@ from esphome.types import ConfigType
 def AUTO_LOAD() -> list[str]:
     """ble_device_base plus the platform BLE stack the build's backend
     registers with (the Bluedroid header includes the tracker's), so
-    consumers stay platform-blind. The platform-less arm serves tooling that
-    resolves the manifest without a target."""
+    consumers need not know. The platform-less arm serves manifest tooling."""
     if CORE.is_esp32:
         return ["ble_device_base", "esp32_ble_tracker"]
     if CORE.is_rp2:
@@ -66,8 +63,6 @@ DOMAIN = "bluetooth_connection"
 @dataclass
 class _ConnectionData:
     rp2_backend_count: int = 0
-    # GATT connection slots claimed this run, for the platform cap check.
-    slot_consumers: list[str] = field(default_factory=list)
 
 
 def _get_data() -> _ConnectionData:
@@ -124,10 +119,6 @@ class _PlatformBackend:
     backend_class: cg.MockObjClass
     schema_fragment: Callable[[], cv.Schema]
     register: Callable[[cg.MockObj, ConfigType], Awaitable[None]]
-    # Selects the backend's alias-ladder arm (order-independent arms).
-    define: str
-    # The backend's on-demand materializer gate, when it has one.
-    materializer_define: str | None = None
 
 
 # The single registry of platforms with a GATT client backend; a platform
@@ -135,20 +126,11 @@ class _PlatformBackend:
 # platform's arm.
 _PLATFORM_BACKENDS: dict[str, _PlatformBackend] = {
     PLATFORM_ESP32: _PlatformBackend(
-        BluedroidGattClient,
-        _esp32_schema_fragment,
-        _esp32_register,
-        "USE_BLE_GATT_BACKEND_BLUEDROID",
-        materializer_define="USE_BLUEDROID_GATT_SERVICE_TABLE",
-    ),
-    PLATFORM_RP2: _PlatformBackend(
-        RP2GattClient, _rp2_schema_fragment, _rp2_register, "USE_BLE_GATT_BACKEND_RP2"
+        BluedroidGattClient, _esp32_schema_fragment, _esp32_register
     ),
+    PLATFORM_RP2: _PlatformBackend(RP2GattClient, _rp2_schema_fragment, _rp2_register),
 }
 
-# Gates dedicated-backend consumers (cv.only_on).
-GATT_CLIENT_PLATFORMS = list(_PLATFORM_BACKENDS)
-
 
 def _backend_entry(platform: str | None = None) -> _PlatformBackend:
     key = platform if platform is not None else CORE.target_platform
@@ -183,97 +165,21 @@ def hub_connection_schema(platform: str | None = None) -> cv.Schema:
     )
 
 
-def _charge_esp32_budget(count: int, consumer: str, config: ConfigType) -> None:
-    from esphome.components import esp32_ble
-
-    esp32_ble.consume_connection_slots(count, consumer)(config)
-
-
-def _charge_rp2_budget(count: int, consumer: str, config: ConfigType) -> None:
-    rp2040_ble.consume_connection_slots(count, consumer)(config)
-
-
-# Platforms whose BLE stack owns its own connection budget: the claim is
-# charged there and that stack's final validation is the one place an
-# overcommit is reported (never two messages for one misconfiguration). One
-# mapping drives both, so a platform can never be skipped without a charge.
-_STACK_BUDGETS: dict[str, Callable[[int, str, ConfigType], None]] = {
-    PLATFORM_ESP32: _charge_esp32_budget,
-    PLATFORM_RP2: _charge_rp2_budget,
-}
-
-
-def consume_gatt_slot(
-    consumer: str, count: int = 1
-) -> Callable[[ConfigType], ConfigType]:
-    """Validator claiming GATT connection slots - the one spelling for every
-    claimant. The neutral ledger covers backend platforms without a stack
-    budget (the cap check in FINAL_VALIDATE_SCHEMA)."""
-
-    def validator(config: ConfigType) -> ConfigType:
-        _get_data().slot_consumers.extend([consumer] * count)
-        if (charge := _STACK_BUDGETS.get(CORE.target_platform)) is not None:
-            charge(count, consumer, config)
-        return config
-
-    return validator
-
-
-def _validate_slot_totals(config: ConfigType) -> ConfigType:
-    # Skipped in testing mode so grouped component builds can co-exist
-    # (mirrors esp32_ble.validate_connection_slots).
-    if CORE.testing_mode:
-        return config
-    if CORE.target_platform in _STACK_BUDGETS:
-        return config
-    if (cap := HUB_MAX_CONNECTIONS.get(CORE.target_platform)) is None:
-        # Any backend platform without a stack budget must carry a cap here
-        # or fail loudly, never fail open.
-        if CORE.target_platform in _PLATFORM_BACKENDS:
-            raise cv.Invalid(
-                f"{CORE.target_platform} has a GATT backend but no slot cap "
-                "in HUB_MAX_CONNECTIONS"
-            )
-        return config
-    claimed = _get_data().slot_consumers
-    if len(claimed) > cap:
-        raise cv.Invalid(
-            f"{CORE.target_platform} supports at most {cap} GATT client "
-            f"connection(s); {len(claimed)} requested by: {', '.join(claimed)}"
-        )
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _validate_slot_totals
-
-
-async def new_gatt_backend(
-    config: ConfigType, *, service_table: bool = True
-) -> cg.MockObj:
+async def new_gatt_backend(config: ConfigType) -> cg.MockObj:
     """Instantiate the backend declared by gatt_client_schema() and register
     it with its platform stack. The connection slot is claimed at validation
-    (the consume_gatt_slot validators), not here.
-
-    service_table is honored by the Bluedroid backend only: forward
-    scaffolding for the first esp32 direct consumer, load-bearing on no
-    current build (rp2 ignores the define and always materializes - its
-    proxy hub streams through get_service_table(), so it must keep the
-    materializer regardless of the flag).
+    (the proxy's slot validators), not here.
     """
     from esphome.components import ble_device_base
 
-    entry = _backend_entry()
     ble_device_base.request_gatt_client()
-    cg.add_define(entry.define)
-    if service_table and entry.materializer_define is not None:
-        cg.add_define(entry.materializer_define)
     backend = cg.new_Pvariable(config[CONF_BACKEND_ID])
     # The backend is the slot's real Component: component keys from the
     # connection entry (setup_priority, ...) apply to it. Consumers whose own
     # schema carries keys that register_component would misapply to the
     # backend (e.g. a polling interval) must not put them in this config.
     await cg.register_component(backend, config)
-    await entry.register(backend, config)
+    await _backend_entry().register(backend, config)
     return backend
 
 
@@ -281,7 +187,6 @@ async def new_gatt_backend(
 # list (this module cannot import bluetooth_proxy to derive it).
 SOURCE_FILE_FRAMEWORKS: dict[str, set[PlatformFramework]] = {
     "bluetooth_connection_bluedroid.cpp": frameworks_for_platforms([PLATFORM_ESP32]),
-    "gatt_service_table_bluedroid.cpp": frameworks_for_platforms([PLATFORM_ESP32]),
     # Every hub platform the proxy admits (the file compiles empty where
     # USE_BLE_GATT_CLIENT is not defined), so a platform gaining a backend
     # cannot hit a missing-symbol trap here.

esphome/components/bluetooth_connection/bluetooth_connection.cpp

@@ -46,7 +46,7 @@ BatchClose close_service_batch(api::BluetoothGATTGetServicesResponse &resp, size
 
 #endif  // USE_BLUETOOTH_PROXY_CONNECTIONS
 
-#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)
+#if defined(USE_ESP32) && defined(USE_BLE_GATT_CLIENT)
 namespace esphome::bluetooth_connection {
 
 // Address-scoped Bluedroid maintenance. Gated with the connection surface:
@@ -65,4 +65,4 @@ conn_err_t clear_gatt_cache(uint64_t address) {
 }
 
 }  // namespace esphome::bluetooth_connection
-#endif  // USE_ESP32_BLE && USE_BLE_GATT_CLIENT
+#endif  // USE_ESP32 && USE_BLE_GATT_CLIENT

esphome/components/bluetooth_connection/bluetooth_connection.h

@@ -48,16 +48,15 @@ static constexpr conn_err_t CONN_OK = 0;
 // GATT contract so backend and wrapper cannot drift.
 static constexpr conn_err_t GATT_NOT_CONNECTED = ble_device_base::GATT_ERR_NOT_CONNECTED;
 
-// What the build's connection backend supports beyond GATT operations; the
-// proxy derives its feature flags and legacy version from these. Keyed on
-// the backend define, never the platform, so a second backend on one
-// platform carries its own facts.
-#if defined(USE_BLE_GATT_BACKEND_BLUEDROID)
+// What the platform's connection backend supports beyond GATT operations;
+// the proxy derives its feature flags and legacy version from these.
+#if defined(USE_ESP32)
 static constexpr bool SUPPORTS_PAIRING = true;
 static constexpr bool SUPPORTS_CACHE_CLEARING = true;
-#elif defined(USE_BLE_GATT_BACKEND_RP2)
+#elif defined(USE_RP2040_BLE) && defined(USE_BLE_GATT_CLIENT)
 // The rp2 BTstack backend pairs (just works + bonding); it has no service
-// cache to clear.
+// cache to clear. Keyed on the backend, not the generic client define, so a
+// future backend without pairing keeps the stub arm below.
 static constexpr bool SUPPORTS_PAIRING = true;
 static constexpr bool SUPPORTS_CACHE_CLEARING = false;
 #else
@@ -65,14 +64,13 @@ static constexpr bool SUPPORTS_PAIRING = false;
 static constexpr bool SUPPORTS_CACHE_CLEARING = false;
 #endif
 
-// Address-scoped (not connection-scoped) maintenance requests; keyed on the
-// stack (the calls need no backend instance).
-#if (defined(USE_ESP32_BLE) || defined(USE_RP2040_BLE)) && defined(USE_BLE_GATT_CLIENT)
+// Address-scoped (not connection-scoped) maintenance requests.
+#if (defined(USE_ESP32) || defined(USE_RP2040_BLE)) && defined(USE_BLE_GATT_CLIENT)
 conn_err_t unpair_device(uint64_t address);
 #else
 inline conn_err_t unpair_device(uint64_t) { return GATT_NOT_CONNECTED; }
 #endif
-#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)
+#if defined(USE_ESP32) && defined(USE_BLE_GATT_CLIENT)
 conn_err_t clear_gatt_cache(uint64_t address);
 #else
 inline conn_err_t clear_gatt_cache(uint64_t) { return GATT_NOT_CONNECTED; }

esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.cpp

@@ -2,11 +2,10 @@
 
 #if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)
 
-#include "bluetooth_connection.h"
-
 // The in-place streamer serves the proxy's service-discovery API; backend-only
 // builds compile without the proxy headers or the streamer.
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
+#include "bluetooth_connection.h"
 #include "bluetooth_connection_hub.h"
 
 #include "esphome/components/bluetooth_proxy/bluetooth_proxy.h"
@@ -349,9 +348,6 @@ int BluedroidGattClient::update_connection_params(uint16_t min_interval, uint16_
 
 void BluedroidGattClient::release_services() {
   this->service_total_ = 0;
-#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
-  this->table_.free();
-#endif
   // Always set: terminates any in-flight stream on every cache config.
   this->services_released_ = true;
 #ifndef CONFIG_BT_GATTC_CACHE_NVS_FLASH
@@ -364,24 +360,6 @@ void BluedroidGattClient::release_services() {
 #endif
 }
 
-#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
-ble_device_base::GattServiceTable BluedroidGattClient::get_service_table() {
-  // Lifetime: every teardown path (CLOSE_EVT, the safety timeout, stack-down,
-  // passive DISCONNECT) routes through release_services(), so a materialized
-  // table cannot outlive its link.
-  if (this->table_.empty() &&
-      (this->services_released_ || this->service_total_ == 0 ||
-       !this->table_.build(this->gattc_if_, this->conn_id_, this->service_total_, this->connection_index_))) {
-    // Released / no services / failed build all collapse to empty; the
-    // build failures warned above, log the quiet two.
-    ESP_LOGD(TAG, "[%d] No service table (released=%d, services=%u)", this->connection_index_, this->services_released_,
-             this->service_total_);
-    return {};
-  }
-  return this->table_.view();
-}
-#endif  // USE_BLUEDROID_GATT_SERVICE_TABLE
-
 // ---- internals ----
 
 bool BluedroidGattClient::check_addr_(const esp_bd_addr_t &addr) const {
@@ -428,11 +406,6 @@ void BluedroidGattClient::log_gattc_warning_(const char *operation, int code) {
 // ---- service streaming ----
 
 int BluedroidGattClient::handle_search_cmpl_(esp_gatt_status_t status) {
-#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
-  // Re-discovery moves the counts the table view derives offsets from; free
-  // the stale table.
-  this->table_.free();
-#endif
   // Step down from the fast discovery params.
   this->update_conn_params_(MEDIUM_MIN_CONN_INTERVAL, MEDIUM_MAX_CONN_INTERVAL, 0, MEDIUM_CONN_TIMEOUT, "medium");
   if (status != ESP_GATT_OK) {

esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.h

@@ -11,9 +11,6 @@
 
 #if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)
 
-#include "bluetooth_connection.h"
-#include "gatt_service_table_bluedroid.h"
-
 #include "esphome/components/ble_device_base/ble_gatt_client.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/component.h"
@@ -79,16 +76,11 @@ class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public
   int notify_characteristic(uint16_t handle, bool enable);
   int pair();
   int update_connection_params(uint16_t min_interval, uint16_t max_interval, uint16_t latency, uint16_t timeout);
-  // On-demand table for direct consumers; the proxy streams instead, so the
-  // materializer compiles only under USE_BLUEDROID_GATT_SERVICE_TABLE (emitted by
-  // direct-consumer codegen, never by the proxy).
-#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
-  ble_device_base::GattServiceTable get_service_table();
-#else
-  // A direct consumer reaching this stub misconfigured its codegen
-  // (service_table=False): the empty table reads as a service-less peer.
+  // Contract stub: the proxy streams in place; the on-demand materializer
+  // for direct consumers lands with #18205. NOTE: a direct consumer reaching
+  // this stub gets an empty table indistinguishable from a service-less
+  // peer - do not ship one against this backend before the materializer.
   ble_device_base::GattServiceTable get_service_table() { return {}; }
-#endif
   void release_services();
 
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
@@ -118,9 +110,6 @@ class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public
 
   // Group 1: pointers / composed objects
   ble_device_base::GattClientListener *listener_{nullptr};
-#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
-  BluedroidServiceTable table_;
-#endif
   // Group 2: 4-byte types
   uint32_t disconnecting_started_{0};
 

esphome/components/bluetooth_connection/bluetooth_connection_gatt_backend.h

@@ -12,12 +12,10 @@
 
 #include "esphome/components/ble_device_base/ble_gatt_client.h"
 
-// Arms are keyed on codegen-emitted per-backend defines (_PLATFORM_BACKENDS
-// in __init__.py), so they are order-independent.
-#if defined(USE_BLE_GATT_BACKEND_RP2)
+#if defined(USE_RP2040_BLE)
 #include "bluetooth_connection_rp2.h"
 #define ESPHOME_BLE_GATT_CONNECTION_TYPE bluetooth_connection::RP2GattClient
-#elif defined(USE_BLE_GATT_BACKEND_BLUEDROID)
+#elif defined(USE_ESP32_BLE)
 #include "bluetooth_connection_bluedroid.h"
 #define ESPHOME_BLE_GATT_CONNECTION_TYPE bluetooth_connection::BluedroidGattClient
 #elif defined(USE_BLE_GATT_CLIENT_STUB_BACKEND)

esphome/components/bluetooth_connection/gatt_service_table_bluedroid.cpp

@@ -1,198 +0,0 @@
-#include "gatt_service_table_bluedroid.h"
-
-#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT) && defined(USE_BLUEDROID_GATT_SERVICE_TABLE)
-
-#include "esphome/core/log.h"
-
-namespace esphome::bluetooth_connection {
-
-ESPHOME_LOG_TAG(TAG, "bluetooth_connection");
-
-// A stack that never reports end-of-range would otherwise walk forever.
-static constexpr uint16_t MAX_DESCRIPTORS_PER_CHARACTERISTIC = 64;
-
-// Shared enumeration for both build passes: an identical walk order is what
-// lets the counting pass size the block the filling pass fills.
-// INVALID_OFFSET/NOT_FOUND mean end-of-range; anything else is a failure.
-template<typename ServiceFn, typename CharFn, typename DescFn>
-bool BluedroidServiceTable::walk_(ServiceFn &&on_service, CharFn &&on_char, DescFn &&on_desc) {
-  for (uint16_t s = 0; s < this->service_total_; s++) {
-    esp_gattc_service_elem_t svc;
-    uint16_t svc_count = 1;
-    auto svc_status = esp_ble_gattc_get_service(this->gattc_if_, this->conn_id_, nullptr, &svc, &svc_count, s);
-    if (svc_status != ESP_GATT_OK || svc_count == 0) {
-      this->log_walk_warning_("esp_ble_gattc_get_service", svc_status);
-      return false;
-    }
-    if (!on_service(s, svc)) {
-      return false;
-    }
-    uint16_t svc_chars = 0;
-    auto count_status = esp_ble_gattc_get_attr_count(this->gattc_if_, this->conn_id_, ESP_GATT_DB_CHARACTERISTIC,
-                                                     svc.start_handle, svc.end_handle, 0, &svc_chars);
-    if (count_status != ESP_GATT_OK) {
-      this->log_walk_warning_("esp_ble_gattc_get_attr_count", count_status);
-      return false;
-    }
-    for (uint16_t c = 0; c < svc_chars; c++) {
-      esp_gattc_char_elem_t chr;
-      uint16_t char_count = 1;
-      auto status = esp_ble_gattc_get_all_char(this->gattc_if_, this->conn_id_, svc.start_handle, svc.end_handle, &chr,
-                                               &char_count, c);
-      if (status != ESP_GATT_OK || char_count == 0) {
-        // An early terminator contradicts svc_chars from the same cache;
-        // never build a silently truncated table.
-        this->log_walk_warning_("esp_ble_gattc_get_all_char", status);
-        return false;
-      }
-      if (!on_char(svc, chr)) {
-        return false;
-      }
-      for (uint16_t d = 0;; d++) {
-        if (d == MAX_DESCRIPTORS_PER_CHARACTERISTIC) {
-          // A stack that never reports end-of-range; fail like every other
-          // inconsistency instead of truncating the table silently.
-          ESP_LOGW(TAG, "[%d] Descriptor walk exceeded %u entries", this->log_index_,
-                   MAX_DESCRIPTORS_PER_CHARACTERISTIC);
-          return false;
-        }
-        esp_gattc_descr_elem_t desc;
-        uint16_t desc_count = 1;
-        auto desc_status =
-            esp_ble_gattc_get_all_descr(this->gattc_if_, this->conn_id_, chr.char_handle, &desc, &desc_count, d);
-        if (desc_status == ESP_GATT_INVALID_OFFSET || desc_status == ESP_GATT_NOT_FOUND) {
-          break;
-        }
-        if (desc_status != ESP_GATT_OK || desc_count == 0) {
-          this->log_walk_warning_("esp_ble_gattc_get_all_descr", desc_status);
-          return false;
-        }
-        if (!on_desc(chr, desc)) {
-          return false;
-        }
-      }
-    }
-  }
-  return true;
-}
-
-bool BluedroidServiceTable::count_services(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t *total) {
-  uint16_t primary = 0;
-  uint16_t secondary = 0;
-  if (esp_ble_gattc_get_attr_count(gattc_if, conn_id, ESP_GATT_DB_PRIMARY_SERVICE, 0x0001, 0xFFFF, 0, &primary) !=
-          ESP_GATT_OK ||
-      esp_ble_gattc_get_attr_count(gattc_if, conn_id, ESP_GATT_DB_SECONDARY_SERVICE, 0x0001, 0xFFFF, 0, &secondary) !=
-          ESP_GATT_OK) {
-    // A failed count must not read as an authoritative empty database.
-    return false;
-  }
-  *total = primary + secondary;
-  return true;
-}
-
-bool BluedroidServiceTable::build(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t service_total, uint8_t log_index) {
-  this->free();
-  this->gattc_if_ = gattc_if;
-  this->conn_id_ = conn_id;
-  this->service_total_ = service_total;
-  this->log_index_ = log_index;
-
-  // Pass 1: count, so one exact-size block holds the whole table.
-  uint16_t char_total = 0;
-  uint16_t desc_total = 0;
-  bool counted = this->walk_([](uint16_t, const esp_gattc_service_elem_t &) { return true; },
-                             [&](const esp_gattc_service_elem_t &, const esp_gattc_char_elem_t &) {
-                               char_total++;
-                               return true;
-                             },
-                             [&](const esp_gattc_char_elem_t &, const esp_gattc_descr_elem_t &) {
-                               desc_total++;
-                               return true;
-                             });
-  if (!counted) {
-    ESP_LOGW(TAG, "[%d] Service table walk failed during count", this->log_index_);
-    this->free();
-    return false;
-  }
-
-  // The arrays share one block; carving stays aligned because each struct's
-  // strictest member is the UUID and array sizes are multiples of it.
-  static_assert(alignof(ble_device_base::GattService) >= alignof(ble_device_base::GattCharacteristic) &&
-                alignof(ble_device_base::GattCharacteristic) >= alignof(ble_device_base::GattDescriptor));
-  size_t svc_bytes = this->service_total_ * sizeof(ble_device_base::GattService);
-  size_t char_bytes = char_total * sizeof(ble_device_base::GattCharacteristic);
-  size_t total_bytes = svc_bytes + char_bytes + desc_total * sizeof(ble_device_base::GattDescriptor);
-  RAMAllocator<uint8_t> allocator(RAMAllocator<uint8_t>::ALLOC_INTERNAL);
-  this->storage_ = allocator.allocate(total_bytes);
-  if (this->storage_ == nullptr) {
-    ESP_LOGW(TAG, "[%d] Service table allocation failed (%u bytes)", this->log_index_,
-             static_cast<unsigned>(total_bytes));
-    this->free();
-    return false;
-  }
-  auto *services = reinterpret_cast<ble_device_base::GattService *>(this->storage_);
-  auto *characteristics = reinterpret_cast<ble_device_base::GattCharacteristic *>(this->storage_ + svc_bytes);
-  auto *descriptors = reinterpret_cast<ble_device_base::GattDescriptor *>(this->storage_ + svc_bytes + char_bytes);
-
-  // Pass 2: fill, bounded by the pass-1 totals. A bound trip or a shortfall
-  // means the cached database changed between the passes; fail the build
-  // rather than serve an inconsistent table (the consumer retries).
-  uint16_t char_index = 0;
-  uint16_t desc_index = 0;
-  ble_device_base::GattService *cur_service = nullptr;
-  ble_device_base::GattCharacteristic *cur_char = nullptr;
-  bool filled = this->walk_(
-      [&](uint16_t s, const esp_gattc_service_elem_t &svc) {
-        cur_service = &services[s];
-        cur_service->uuid = ble_device_base::ESPBTUUID::from_uuid(svc.uuid);
-        cur_service->start_handle = svc.start_handle;
-        cur_service->end_handle = svc.end_handle;
-        cur_service->first_characteristic = char_index;
-        cur_service->characteristic_count = 0;
-        return true;
-      },
-      [&](const esp_gattc_service_elem_t &svc, const esp_gattc_char_elem_t &chr) {
-        if (char_index >= char_total) {
-          return false;
-        }
-        cur_char = &characteristics[char_index++];
-        cur_char->uuid = ble_device_base::ESPBTUUID::from_uuid(chr.uuid);
-        cur_char->value_handle = chr.char_handle;
-        // Bluedroid addresses descriptors by characteristic handle, so the
-        // table's end_handle only needs the service-bounded upper bound.
-        cur_char->end_handle = svc.end_handle;
-        cur_char->properties = chr.properties;
-        cur_char->first_descriptor = desc_index;
-        cur_char->descriptor_count = 0;
-        cur_service->characteristic_count++;
-        return true;
-      },
-      [&](const esp_gattc_char_elem_t &, const esp_gattc_descr_elem_t &desc) {
-        if (desc_index >= desc_total) {
-          return false;
-        }
-        descriptors[desc_index].uuid = ble_device_base::ESPBTUUID::from_uuid(desc.uuid);
-        descriptors[desc_index].handle = desc.handle;
-        desc_index++;
-        cur_char->descriptor_count++;
-        return true;
-      });
-  if (!filled || char_index != char_total || desc_index != desc_total) {
-    // Walk error or the database changed between passes; better an empty
-    // table than a corrupt one.
-    ESP_LOGW(TAG, "[%d] Service table walk mismatch, discarding", this->log_index_);
-    this->free();
-    return false;
-  }
-  this->char_total_ = char_total;
-  this->desc_total_ = desc_total;
-  return true;
-}
-
-void BluedroidServiceTable::log_walk_warning_(const char *operation, int code) {
-  ESP_LOGW(TAG, "[%d] %s failed, status=%d", this->log_index_, operation, code);
-}
-
-}  // namespace esphome::bluetooth_connection
-
-#endif  // USE_ESP32_BLE && USE_BLE_GATT_CLIENT && USE_BLUEDROID_GATT_SERVICE_TABLE

esphome/components/bluetooth_connection/gatt_service_table_bluedroid.h

@@ -1,82 +0,0 @@
-// Owning two-pass materializer of one Bluedroid GATT database snapshot into
-// the neutral GattServiceTable layout, shared by the BluedroidGattClient
-// backend and ble_client's esp32 engine.
-
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT) && defined(USE_BLUEDROID_GATT_SERVICE_TABLE)
-
-#include "esphome/components/ble_device_base/ble_gatt_client.h"
-#include "esphome/core/helpers.h"
-
-#include <esp_gattc_api.h>
-
-namespace esphome::bluetooth_connection {
-
-class BluedroidServiceTable {
- public:
-  ~BluedroidServiceTable() { this->free(); }
-  // Owns storage_; a copy would double-free. The default constructor is user
-  // provided, not "= default", so value-initializing the enclosing backend
-  // cannot zero-fill .bss that is already zero.
-  BluedroidServiceTable() {}
-  BluedroidServiceTable(const BluedroidServiceTable &) = delete;
-  BluedroidServiceTable &operator=(const BluedroidServiceTable &) = delete;
-
-  /// The service count build() requires: the stack's PRIMARY+SECONDARY
-  /// attribute totals, never the SEARCH_RES event count.
-  static bool count_services(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t *total);
-
-  /// Two-pass build from the stack's cached database (service_total from
-  /// count_services()). log_index labels warnings. Frees any previous table
-  /// first; on failure the table is left empty.
-  bool build(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t service_total, uint8_t log_index);
-
-  // The view is carved from the storage block and the counts on each call
-  // (a cold path) rather than cached, saving a per-instance table member.
-  ble_device_base::GattServiceTable view() const {
-    size_t svc_bytes = this->service_total_ * sizeof(ble_device_base::GattService);
-    size_t char_bytes = this->char_total_ * sizeof(ble_device_base::GattCharacteristic);
-    return {reinterpret_cast<const ble_device_base::GattService *>(this->storage_),
-            reinterpret_cast<const ble_device_base::GattCharacteristic *>(this->storage_ + svc_bytes),
-            reinterpret_cast<const ble_device_base::GattDescriptor *>(this->storage_ + svc_bytes + char_bytes),
-            this->service_total_,
-            this->char_total_,
-            this->desc_total_};
-  }
-
-  // Always resets the counts: a failed build must never leave a non-zero
-  // service_total_ behind a null table.
-  void free() {
-    if (this->storage_ != nullptr) {
-      RAMAllocator<uint8_t> allocator(RAMAllocator<uint8_t>::ALLOC_INTERNAL);
-      allocator.deallocate(this->storage_, 0);
-      this->storage_ = nullptr;
-    }
-    this->service_total_ = 0;
-    this->char_total_ = 0;
-    this->desc_total_ = 0;
-  }
-
-  bool empty() const { return this->storage_ == nullptr; }
-
- private:
-  template<typename ServiceFn, typename CharFn, typename DescFn>
-  bool walk_(ServiceFn &&on_service, CharFn &&on_char, DescFn &&on_desc);
-  void log_walk_warning_(const char *operation, int code);
-
-  uint8_t *storage_{nullptr};
-  uint16_t service_total_{0};
-  uint16_t char_total_{0};
-  uint16_t desc_total_{0};
-  // Walk context, set by build().
-  uint16_t conn_id_{0};
-  esp_gatt_if_t gattc_if_{};  // uint8_t width
-  uint8_t log_index_{0};
-};
-
-}  // namespace esphome::bluetooth_connection
-
-#endif  // USE_ESP32_BLE && USE_BLE_GATT_CLIENT && USE_BLUEDROID_GATT_SERVICE_TABLE

esphome/components/bluetooth_proxy/__init__.py

@@ -99,15 +99,9 @@ def _esp32_config_schema() -> cv.All:
                 raise cv.Invalid(
                     "Connections can only be used if the proxy is set to active"
                 )
-            # Explicit entries claim slots like the generated ones; dev
-            # historically skipped this, letting an explicit-connections
-            # config evade the controller budget.
-            bluetooth_connection.consume_gatt_slot(
-                "bluetooth_proxy", len(config[CONF_CONNECTIONS])
-            )(config)
         elif config[CONF_ACTIVE]:
             connection_slots: int = config[CONF_CONNECTION_SLOTS]
-            bluetooth_connection.consume_gatt_slot("bluetooth_proxy", connection_slots)(
+            esp32_ble.consume_connection_slots(connection_slots, "bluetooth_proxy")(
                 config
             )
 
@@ -164,14 +158,14 @@ def _rp2_config_schema() -> cv.All:
     connection_schema = bluetooth_connection.hub_connection_schema(PLATFORM_RP2)
 
     def populate_connections(config: ConfigType) -> ConfigType:
+        from esphome.components import rp2040_ble
+
         # One wrapper + backend pair per slot, declared during validation so
         # their ids exist for codegen (the esp32 arm's `connections` pattern).
         if not config[CONF_ACTIVE]:
             return config
         connection_slots: int = config[CONF_CONNECTION_SLOTS]
-        bluetooth_connection.consume_gatt_slot("bluetooth_proxy", connection_slots)(
-            config
-        )
+        rp2040_ble.consume_connection_slots(connection_slots, "bluetooth_proxy")(config)
         return {
             **config,
             CONF_CONNECTIONS: [connection_schema({}) for _ in range(connection_slots)],
@@ -221,9 +215,7 @@ async def _connections_to_code(var: cg.MockObj, config: ConfigType) -> None:
         # sends those requests and their handlers and encoders are dead.
         cg.add_define("USE_BLUETOOTH_PROXY_CONNECTIONS")
     for connection_conf in connections:
-        backend = await bluetooth_connection.new_gatt_backend(
-            connection_conf, service_table=False
-        )
+        backend = await bluetooth_connection.new_gatt_backend(connection_conf)
         connection = cg.new_Pvariable(connection_conf[CONF_ID])
         cg.add(connection.set_backend(backend))
         cg.add(var.register_connection(connection))

esphome/components/display/display.cpp

@@ -5,6 +5,7 @@
 #include "display_color_utils.h"
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome::display {
@@ -52,40 +53,65 @@ void Display::line_at_angle(int x, int y, int angle, int start_radius, int stop_
   this->line(x1, y1, x2, y2, color);
 }
 
-void Display::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
-                             ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
-  size_t line_stride = x_offset + w + x_pad;  // length of each source line in pixels
-  uint32_t color_value;
+// flatten keeps to_color() inlined in the pixel loop; in PSRAM builds GCC at
+// -Os stops inlining it once there are two call sites, which costs a call and
+// spills per pixel. Without PSRAM there is one call site and it changes
+// nothing, and draw_pixel_at() stays a virtual call either way.
+template<ColorBitness BITNESS>
+static void __attribute__((flatten))
+draw_packed_pixels(Display *display, int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
+                   bool big_endian, int x_offset, int y_offset, int x_pad) {
+  const size_t line_stride = x_offset + w + x_pad;  // length of each source line in pixels
+  // BITNESS is a constant here, so to_color()'s three per pixel divisions
+  // become a multiply and shift and its bitness switch folds.
+  const auto draw_source_pixel = [&](int x, int y, size_t source_idx) ESPHOME_ALWAYS_INLINE {
+    display->draw_pixel_at(
+        x + x_start, y + y_start,
+        ColorUtil::to_color(ColorUtil::read_packed<BITNESS>(ptr, source_idx, big_endian), order, BITNESS));
+  };
+  // The source and frame buffers are row-major, so walking rows keeps the read
+  // and the write sequential. When the display swaps the axes before writing,
+  // walking columns keeps the write sequential instead; with the frame buffer
+  // in PSRAM a strided write costs more than a strided read.
+#ifdef USE_PSRAM
+  if (display->pixel_axes_swapped()) {
+    size_t column_idx = y_offset * line_stride + x_offset;
+    for (int x = 0; x != w; x++, column_idx++) {
+      size_t source_idx = column_idx;
+      for (int y = 0; y != h; y++, source_idx += line_stride) {
+        draw_source_pixel(x, y, source_idx);
+      }
+    }
+    return;
+  }
+#endif
+  // Row walk: builds without PSRAM, and PSRAM builds whose axes are not swapped.
   for (int y = 0; y != h; y++) {
     size_t source_idx = (y_offset + y) * line_stride + x_offset;
-    size_t source_idx_mod;
     for (int x = 0; x != w; x++, source_idx++) {
-      switch (bitness) {
-        default:
-          color_value = ptr[source_idx];
-          break;
-        case COLOR_BITNESS_565:
-          source_idx_mod = source_idx * 2;
-          if (big_endian) {
-            color_value = (ptr[source_idx_mod] << 8) + ptr[source_idx_mod + 1];
-          } else {
-            color_value = ptr[source_idx_mod] + (ptr[source_idx_mod + 1] << 8);
-          }
-          break;
-        case COLOR_BITNESS_888:
-          source_idx_mod = source_idx * 3;
-          if (big_endian) {
-            color_value = (ptr[source_idx_mod + 0] << 16) + (ptr[source_idx_mod + 1] << 8) + ptr[source_idx_mod + 2];
-          } else {
-            color_value = ptr[source_idx_mod + 0] + (ptr[source_idx_mod + 1] << 8) + (ptr[source_idx_mod + 2] << 16);
-          }
-          break;
-      }
-      this->draw_pixel_at(x + x_start, y + y_start, ColorUtil::to_color(color_value, order, bitness));
+      draw_source_pixel(x, y, source_idx);
     }
   }
 }
 
+void Display::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
+                             ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
+  switch (bitness) {
+    case COLOR_BITNESS_565:
+      draw_packed_pixels<COLOR_BITNESS_565>(this, x_start, y_start, w, h, ptr, order, big_endian, x_offset, y_offset,
+                                            x_pad);
+      break;
+    case COLOR_BITNESS_888:
+      draw_packed_pixels<COLOR_BITNESS_888>(this, x_start, y_start, w, h, ptr, order, big_endian, x_offset, y_offset,
+                                            x_pad);
+      break;
+    default:
+      draw_packed_pixels<COLOR_BITNESS_332>(this, x_start, y_start, w, h, ptr, order, big_endian, x_offset, y_offset,
+                                            x_pad);
+      break;
+  }
+}
+
 void HOT Display::horizontal_line(int x, int y, int width, Color color) {
   // Future: Could be made more efficient by manipulating buffer directly in certain rotations.
   for (int i = x; i < x + width; i++)

esphome/components/display/display.h

@@ -139,6 +139,11 @@ enum DisplayRotation {
   DISPLAY_ROTATION_270_DEGREES = 270,
 };
 
+/// Whether a rotation swaps the x and y axes.
+constexpr bool rotation_swaps_axes(DisplayRotation rotation) {
+  return rotation == DISPLAY_ROTATION_90_DEGREES || rotation == DISPLAY_ROTATION_270_DEGREES;
+}
+
 const int EDGES_TRIGON = 3;
 const int EDGES_TRIANGLE = 3;
 const int EDGES_TETRAGON = 4;
@@ -717,6 +722,12 @@ class Display : public PollingComponent {
 
   virtual DisplayRotation get_rotation() const { return this->rotation_; }
 
+  /// True when draw_pixel_at() swaps x and y before writing, so pixels that are
+  /// neighbours along x land a row apart in the frame buffer. Not the same as
+  /// get_width()/get_height() swapping: a display that rotates in hardware
+  /// reports swapped dimensions but writes unswapped pixels.
+  virtual bool pixel_axes_swapped() const { return rotation_swaps_axes(this->rotation_); }
+
   /** Get the type of display that the buffer corresponds to. In case of dynamically configurable displays,
    * returns the type the display is currently configured to.
    */

esphome/components/display/display_color_utils.h

@@ -2,6 +2,7 @@
 #include <array>
 #include <cstdint>
 #include "esphome/core/color.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome::display {
 enum ColorOrder : uint8_t { COLOR_ORDER_RGB = 0, COLOR_ORDER_BGR = 1, COLOR_ORDER_GRB = 2 };
@@ -10,6 +11,27 @@ inline static uint8_t esp_scale(uint8_t i, uint8_t scale, uint8_t max_value = 25
 
 class ColorUtil {
  public:
+  /// Reads one packed pixel of the given bitness from a source buffer into the
+  /// value to_color() takes. BITNESS is a template argument so the byte layout
+  /// folds; pass it on to to_color() as a constant too, and its channel scaling
+  /// divides by a constant, which the compiler turns into a multiply and shift.
+  template<ColorBitness BITNESS>
+  static ESPHOME_ALWAYS_INLINE uint32_t read_packed(const uint8_t *ptr, size_t index, bool big_endian) {
+    if constexpr (BITNESS == COLOR_BITNESS_565) {
+      const size_t idx = index * 2;
+      if (big_endian)
+        return (ptr[idx] << 8) + ptr[idx + 1];
+      return ptr[idx] + (ptr[idx + 1] << 8);
+    } else if constexpr (BITNESS == COLOR_BITNESS_888) {
+      const size_t idx = index * 3;
+      if (big_endian)
+        return (ptr[idx + 0] << 16) + (ptr[idx + 1] << 8) + ptr[idx + 2];
+      return ptr[idx + 0] + (ptr[idx + 1] << 8) + (ptr[idx + 2] << 16);
+    } else {
+      return ptr[index];
+    }
+  }
+
   static Color to_color(uint32_t colorcode, ColorOrder color_order,
                         ColorBitness color_bitness = ColorBitness::COLOR_BITNESS_888, bool right_bit_aligned = true) {
     uint8_t first_color, second_color, third_color;

esphome/components/epaper_spi/epaper_spi.h

@@ -106,6 +106,7 @@ class EPaperBase : public Display,
 
   int get_width() override { return this->effective_transform_ & SWAP_XY ? this->height_ : this->width_; }
   int get_height() override { return this->effective_transform_ & SWAP_XY ? this->width_ : this->height_; }
+  bool pixel_axes_swapped() const override { return this->effective_transform_ & SWAP_XY; }
   void draw_pixel_at(int x, int y, Color color) override;
   void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
                       ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;

esphome/components/epaper_spi/models/jd79660.py

@@ -87,6 +87,38 @@ jd79660.extend(
     ),
 )
 
+# Waveshare 2.13-G (V2 hardware/init revision, PCB marked "rev 2.1" or later)
+#
+# Vendor init derived from vendor sample code
+# <https://github.com/waveshareteam/e-Paper/blob/master/E-paper_Separate_Program/2in13_e-Paper_G/ESP32/EPD_2in13g_V2.cpp>
+# Compatible MIT license, see esphome/LICENSE file.
+#
+# Note: busy pin uses LOW=busy, HIGH=idle. Configure with inverted: true in YAML.
+# Note: panel is 122px wide, but vendor code declares the TRES register as a fixed
+# 124 on this revision. width=124 is declared here (rather than 122) purely so the
+# transferred bytes-per-row matches what the vendor init tells the IC to expect; the
+# extra 2 columns fall outside the visible glass. The model width must equal the
+# TRES value in initsequence, so overriding dimensions: in YAML brings the shear back.
+#
+# fmt: off
+jd79660.extend(
+    "Waveshare-2.13in-G",
+    width=124,
+    height=250,
+
+    initsequence=(
+        (0x61, 0x00, 0x7C, 0x00, 0xFA,),  # TRES: 124x250 fixed (124 = TRES stride value)
+        (0xE9, 0x01,),
+        # Power On (0x04): Must be early part of init seq = Disabled later!
+        (0x04,),
+    ),
+    fast_update=(
+        (0xE0, 0x02,),
+        (0xE6, 0x5A,),
+        (0xA5,),
+    ),
+)
+
 # Waveshare 7.5-H
 #
 # Vendor init derived from vendor sample code
@@ -130,7 +162,7 @@ jd79660.extend(
 # Note: busy pin uses LOW=busy, HIGH=idle.
 #
 # fmt: off
-jd79660.extend(
+gdey0213f51 = jd79660.extend(
     "goodisplay-gdey0213f51-2.13",
     width=128,
     height=250,
@@ -154,3 +186,13 @@ jd79660.extend(
         (0x04,),
     ),
 )
+
+# Waveshare 2.13-G (V1 hardware/init revision, older stock): the same panel and init as the Good
+# Display entry above, byte for byte, so it only adds the name. Vendor sample:
+# <https://github.com/waveshareteam/e-Paper/blob/master/E-paper_Separate_Program/2in13_e-Paper_G/ESP32/EPD_2in13g.cpp>
+# Compatible MIT license, see esphome/LICENSE file.
+#
+# Note: busy pin uses LOW=busy, HIGH=idle. Configure with inverted: true in YAML.
+# Note: width=128 is the TRES value the init sequence programs, not the 122 visible columns; overriding
+# dimensions: in YAML shears the image. Not tested on V1 hardware.
+gdey0213f51.extend("Waveshare-2.13in-G-V1")

esphome/components/epaper_spi/models/waveshare_b.py

@@ -24,3 +24,11 @@ WaveshareB(
     data_rate="10MHz",
     minimum_update_interval="1s",
 )
+
+WaveshareB(
+    "waveshare-2.66in-b",
+    width=152,
+    height=296,
+    data_rate="10MHz",
+    minimum_update_interval="15s",
+)

esphome/components/esp32_can/canbus.py

@@ -6,6 +6,8 @@ import esphome.codegen as cg
 from esphome.components import canbus
 from esphome.components.canbus import CONF_BIT_RATE, CanbusComponent, CanSpeed
 from esphome.components.esp32 import (
+    CONF_MINIMUM_CHIP_REVISION,
+    KEY_ESP32,
     VARIANT_ESP32,
     VARIANT_ESP32C3,
     VARIANT_ESP32C5,
@@ -20,6 +22,8 @@ from esphome.components.esp32 import (
 )
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_ADVANCED,
+    CONF_FRAMEWORK,
     CONF_ID,
     CONF_MODE,
     CONF_RX_PIN,
@@ -27,6 +31,7 @@ from esphome.const import (
     CONF_TX_PIN,
     CONF_TX_QUEUE_LEN,
 )
+import esphome.final_validate as fv
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@Sympatron"]
@@ -42,6 +47,7 @@ CanMode = esp32_can_ns.enum("CanMode")
 CAN_MODES = {
     "NORMAL": CanMode.CAN_MODE_NORMAL,
     "LISTENONLY": CanMode.CAN_MODE_LISTEN_ONLY,
+    "NO_ACK": CanMode.CAN_MODE_NO_ACK,
 }
 
 # Currently the driver only supports a subset of the bit rates defined in canbus
@@ -49,6 +55,7 @@ CAN_MODES = {
 # See ESP-IDF Programming Guide --> API Reference --> Two-Wire Automotive Interface (TWAI)
 
 CAN_SPEEDS_ESP32 = {
+    "20KBPS": CanSpeed.CAN_20KBPS,
     "25KBPS": CanSpeed.CAN_25KBPS,
     "50KBPS": CanSpeed.CAN_50KBPS,
     "100KBPS": CanSpeed.CAN_100KBPS,
@@ -114,6 +121,22 @@ CONFIG_SCHEMA = canbus.CANBUS_SCHEMA.extend(
 )
 
 
+def _final_validate(config: ConfigType) -> None:
+    if get_esp32_variant() == VARIANT_ESP32 and config[CONF_BIT_RATE] == "20KBPS":
+        esp32_config = fv.full_config.get()[KEY_ESP32]
+        min_revision = esp32_config[CONF_FRAMEWORK][CONF_ADVANCED].get(
+            CONF_MINIMUM_CHIP_REVISION
+        )
+        if min_revision is None or min_revision < "2.0":
+            raise cv.Invalid(
+                "20KBPS on ESP32 requires esp32.framework.advanced.minimum_chip_revision: '2.0' or higher",
+                path=[CONF_BIT_RATE],
+            )
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
 def get_default_tx_enqueue_timeout(bit_rate: str) -> int:
     bit_rate_numeric = canbus.get_rate(bit_rate)
     bits_per_packet = 140  # ~max CAN message length

esphome/components/esp32_can/esp32_can.cpp

@@ -33,6 +33,10 @@ static bool get_bitrate(canbus::CanSpeed bitrate, twai_timing_config_t *t_config
     case canbus::CAN_16KBPS:
       *t_config = (twai_timing_config_t) TWAI_TIMING_CONFIG_16KBITS();
       return true;
+#endif
+#if defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32C61) || \
+    defined(USE_ESP32_VARIANT_ESP32H2) || defined(USE_ESP32_VARIANT_ESP32P4) || defined(USE_ESP32_VARIANT_ESP32S2) || \
+    defined(USE_ESP32_VARIANT_ESP32S3) || (defined(USE_ESP32_VARIANT_ESP32) && CONFIG_ESP32_REV_MIN_FULL >= 200)
     case canbus::CAN_20KBPS:
       *t_config = (twai_timing_config_t) TWAI_TIMING_CONFIG_20KBITS();
       return true;
@@ -75,10 +79,13 @@ bool ESP32Can::setup_internal() {
   }
 
   // Select TWAI mode based on configuration
-  twai_mode_t twai_mode = (this->mode_ == CAN_MODE_LISTEN_ONLY) ? TWAI_MODE_LISTEN_ONLY : TWAI_MODE_NORMAL;
-
+  twai_mode_t twai_mode = TWAI_MODE_NORMAL;
   if (this->mode_ == CAN_MODE_LISTEN_ONLY) {
+    twai_mode = TWAI_MODE_LISTEN_ONLY;
     ESP_LOGI(TAG, "CAN bus configured in LISTEN_ONLY mode (passive, no ACKs)");
+  } else if (this->mode_ == CAN_MODE_NO_ACK) {
+    twai_mode = TWAI_MODE_NO_ACK;
+    ESP_LOGI(TAG, "CAN bus configured in NO_ACK mode (transmit without requiring ACK)");
   }
 
   twai_general_config_t g_config =

esphome/components/esp32_can/esp32_can.h

@@ -12,6 +12,7 @@ namespace esphome::esp32_can {
 enum CanMode : uint8_t {
   CAN_MODE_NORMAL = 0,
   CAN_MODE_LISTEN_ONLY = 1,
+  CAN_MODE_NO_ACK = 2,
 };
 
 class ESP32Can final : public canbus::Canbus {

esphome/components/haier/hon_climate.cpp

@@ -3,6 +3,7 @@
 #include "esphome/components/climate/climate.h"
 #include "esphome/components/uart/uart.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/progmem.h"
 #include "hon_climate.h"
 #include "hon_packet.h"
 
@@ -20,6 +21,27 @@ constexpr size_t ALARM_STATUS_REQUEST_INTERVAL_MS = 600000;
 const uint8_t ONE_BUF[] = {0x00, 0x01};
 const uint8_t ZERO_BUF[] = {0x00, 0x00};
 
+// Alarm texts indexed by alarm code; the last entry is the fallback for unknown codes
+PROGMEM_STRING_TABLE(
+    HonAlarmMessages, "Outdoor module failure", "Outdoor defrost sensor failure",
+    "Outdoor compressor exhaust sensor failure", "Outdoor EEPROM abnormality", "Indoor coil sensor failure",
+    "Indoor-outdoor communication failure", "Power supply overvoltage protection",
+    "Communication failure between panel and indoor unit", "Outdoor compressor overheat protection",
+    "Outdoor environmental sensor abnormality", "Full water protection", "Indoor EEPROM failure",
+    "Outdoor out air sensor failure", "CBD and module communication failure", "Indoor DC fan failure",
+    "Outdoor DC fan failure", "Door switch failure", "Dust filter needs cleaning reminder", "Water shortage protection",
+    "Humidity sensor failure", "Indoor temperature sensor failure", "Manipulator limit failure",
+    "Indoor PM2.5 sensor failure", "Outdoor PM2.5 sensor failure", "Indoor heating overload/high load alarm",
+    "Outdoor AC current protection", "Outdoor compressor operation abnormality", "Outdoor DC current protection",
+    "Outdoor no-load failure", "CT current abnormality", "Indoor cooling freeze protection",
+    "High and low pressure protection", "Compressor out air temperature is too high",
+    "Outdoor evaporator sensor failure", "Outdoor cooling overload", "Water pump drainage failure",
+    "Three-phase power supply failure", "Four-way valve failure", "External alarm/scraper flow switch failure",
+    "Temperature cutoff protection alarm", "Different mode operation failure", "Electronic expansion valve failure",
+    "Dual heat source sensor Tw failure", "Communication failure with the wired controller",
+    "Indoor unit address duplication failure", "50Hz zero crossing failure", "Outdoor unit failure",
+    "Formaldehyde sensor failure", "VOC sensor failure", "CO2 sensor failure", "Firewall failure", "Unknown");
+
 HonClimate::HonClimate()
     : cleaning_status_(CleaningState::NO_CLEANING), got_valid_outdoor_temp_(false), active_alarms_{0x00, 0x00, 0x00,
                                                                                                    0x00, 0x00, 0x00,
@@ -687,9 +709,17 @@ void HonClimate::process_alarm_message_(const uint8_t *packet, uint8_t size, boo
             if ((packet[2 + i] & alarm_bit) != (this->active_alarms_[i] & alarm_bit)) {
               bool alarm_status = (packet[2 + i] & alarm_bit) != 0;
               int log_level = alarm_status ? ESPHOME_LOG_LEVEL_WARN : ESPHOME_LOG_LEVEL_INFO;
-              const char *alarm_message = alarm_code < esphome::haier::hon_protocol::HON_ALARM_COUNT
-                                              ? esphome::haier::hon_protocol::HON_ALARM_MESSAGES[alarm_code].c_str()
-                                              : "Unknown";
+#ifdef USE_ESP8266
+              // Static so a delayed on_alarm automation can still read it, but only until the next
+              // alarm change, including a later one in this packet; `code` stays correct
+              static char alarm_message[HonAlarmMessages::MAX_LENGTH + 1];
+              ESPHOME_strncpy_P(alarm_message,
+                                reinterpret_cast<const char *>(
+                                    HonAlarmMessages::get_progmem_str(alarm_code, HonAlarmMessages::LAST_INDEX)),
+                                sizeof(alarm_message));
+#else
+              const char *alarm_message = HonAlarmMessages::get_progmem_str(alarm_code, HonAlarmMessages::LAST_INDEX);
+#endif
               esp_log_printf_(log_level, TAG, __LINE__, "Alarm %s (%d): %s", alarm_status ? "activated" : "deactivated",
                               alarm_code, alarm_message);
               if (alarm_status) {

esphome/components/haier/hon_packet.h

@@ -197,60 +197,4 @@ enum class SubcommandsControl : uint16_t {
                                   // content: all values like in status packet)
 };
 
-const std::string HON_ALARM_MESSAGES[] = {
-    "Outdoor module failure",
-    "Outdoor defrost sensor failure",
-    "Outdoor compressor exhaust sensor failure",
-    "Outdoor EEPROM abnormality",
-    "Indoor coil sensor failure",
-    "Indoor-outdoor communication failure",
-    "Power supply overvoltage protection",
-    "Communication failure between panel and indoor unit",
-    "Outdoor compressor overheat protection",
-    "Outdoor environmental sensor abnormality",
-    "Full water protection",
-    "Indoor EEPROM failure",
-    "Outdoor out air sensor failure",
-    "CBD and module communication failure",
-    "Indoor DC fan failure",
-    "Outdoor DC fan failure",
-    "Door switch failure",
-    "Dust filter needs cleaning reminder",
-    "Water shortage protection",
-    "Humidity sensor failure",
-    "Indoor temperature sensor failure",
-    "Manipulator limit failure",
-    "Indoor PM2.5 sensor failure",
-    "Outdoor PM2.5 sensor failure",
-    "Indoor heating overload/high load alarm",
-    "Outdoor AC current protection",
-    "Outdoor compressor operation abnormality",
-    "Outdoor DC current protection",
-    "Outdoor no-load failure",
-    "CT current abnormality",
-    "Indoor cooling freeze protection",
-    "High and low pressure protection",
-    "Compressor out air temperature is too high",
-    "Outdoor evaporator sensor failure",
-    "Outdoor cooling overload",
-    "Water pump drainage failure",
-    "Three-phase power supply failure",
-    "Four-way valve failure",
-    "External alarm/scraper flow switch failure",
-    "Temperature cutoff protection alarm",
-    "Different mode operation failure",
-    "Electronic expansion valve failure",
-    "Dual heat source sensor Tw failure",
-    "Communication failure with the wired controller",
-    "Indoor unit address duplication failure",
-    "50Hz zero crossing failure",
-    "Outdoor unit failure",
-    "Formaldehyde sensor failure",
-    "VOC sensor failure",
-    "CO2 sensor failure",
-    "Firewall failure",
-};
-
-constexpr size_t HON_ALARM_COUNT = sizeof(HON_ALARM_MESSAGES) / sizeof(HON_ALARM_MESSAGES[0]);
-
 }  // namespace esphome::haier::hon_protocol

esphome/components/ili9xxx/__init__.py

@@ -3,4 +3,5 @@ DOMAIN = "ili9xxx"
 DEPRECATED_COMPONENT = """
 The 'ili9xxx' component is deprecated and no new models will be added to it.
 New model PRs should target the newer and more performant 'mipi_spi' component.
+It will be removed in ESPHome 2027.5.0.
 """

esphome/components/ili9xxx/display.py

@@ -220,8 +220,10 @@ FINAL_VALIDATE_SCHEMA = final_validate
 
 
 async def to_code(config: ConfigType) -> None:
+    # Remove before 2027.5.0
     LOGGER.warning(
-        "The 'ili9xxx' component is deprecated, it is recommended to use 'mipi_spi' instead."
+        "The 'ili9xxx' component is deprecated and will be removed in ESPHome 2027.5.0, "
+        "migrate to 'mipi_spi' instead."
     )
     rhs = MODELS[config[CONF_MODEL]].new()
     var = cg.Pvariable(config[CONF_ID], rhs)

esphome/components/it8951/it8951.h

@@ -204,6 +204,7 @@ class IT8951Display : public Display,
                       ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
   int get_width() override { return (this->effective_transform_ & TRANSFORM_SWAP_XY) ? this->height_ : this->width_; }
   int get_height() override { return (this->effective_transform_ & TRANSFORM_SWAP_XY) ? this->width_ : this->height_; }
+  bool pixel_axes_swapped() const override { return this->effective_transform_ & TRANSFORM_SWAP_XY; }
 
  protected:
   int get_height_internal() override { return this->height_; }

esphome/components/mdns/__init__.py

@@ -3,7 +3,9 @@ from esphome.components.esp32 import add_idf_component, add_idf_sdkconfig_option
 from esphome.config_helpers import filter_source_files_from_platform, get_logger_level
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_API,
     CONF_DISABLED,
+    CONF_ETHERNET,
     CONF_ID,
     CONF_OPENTHREAD,
     CONF_PORT,
@@ -285,6 +287,23 @@ async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
+    # 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 (
+        CONF_API in CORE.config
+        and CONF_WIFI in CORE.config
+        and CONF_ETHERNET in CORE.config
+        and CONF_OPENTHREAD not in CORE.config
+    ):
+        from esphome.components import network
+
+        cg.add_define("USE_MDNS_DYNAMIC_NETWORK_TXT")
+        # Where the network component tracks the default route (ESP32), follow
+        # it; otherwise mdns checks the connected interface every second.
+        if await network.register_active_interface_listener(var):
+            cg.add_define("USE_MDNS_ACTIVE_INTERFACE_LISTENER")
+
     for service in config[CONF_SERVICES]:
         txt_records = [
             await _mdns_txt_record_templated(var, txt_key, txt_value)

esphome/components/mdns/mdns_component.cpp

@@ -62,12 +62,9 @@ const char *MDNSComponent::connected_network_() const {
   return nullptr;
 }
 
-void MDNSComponent::update_network_txt_() {
-  if (this->network_txt_ == nullptr)
-    return;
+void MDNSComponent::update_network_txt_(const char *network) {
   // 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_)
+  if (this->network_txt_ == nullptr || network == nullptr || network == this->network_txt_)
     return;
   if (!this->publish_network_txt_(network)) {
     // The _esphomelib service is missing, so a retry would fail too
@@ -80,6 +77,21 @@ void MDNSComponent::update_network_txt_() {
   this->network_record_->value = MDNS_STR(network);
 #endif
 }
+
+#ifdef USE_MDNS_ACTIVE_INTERFACE_LISTENER
+void MDNSComponent::on_active_interface(network::NetworkInterface interface) {
+  switch (interface) {
+    case network::NetworkInterface::NETWORK_INTERFACE_ETHERNET:
+      this->update_network_txt_(NETWORK_ETHERNET);
+      break;
+    case network::NetworkInterface::NETWORK_INTERFACE_WIFI:
+      this->update_network_txt_(NETWORK_WIFI);
+      break;
+    default:
+      break;
+  }
+}
+#endif
 #endif
 
 void MDNSComponent::setup_buffers_and_register_(PlatformRegisterFn platform_register) {

esphome/components/mdns/mdns_component.h

@@ -32,10 +32,11 @@
 #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
+// USE_MDNS_DYNAMIC_NETWORK_TXT (wifi + ethernet + api): the _esphomelib "network" TXT value follows the
+// connected interface. With USE_MDNS_ACTIVE_INTERFACE_LISTENER (ESP32) the network component reports
+// default route changes; otherwise the value is checked every NETWORK_TXT_CHECK_INTERVAL_MS.
+#ifdef USE_MDNS_ACTIVE_INTERFACE_LISTENER
+#include "esphome/components/network/network_component.h"
 #endif
 
 namespace esphome::mdns {
@@ -79,6 +80,10 @@ class MDNSComponent final : public Component
     ,
                             public ethernet::EthernetIPStateListener
 #endif
+#ifdef USE_MDNS_ACTIVE_INTERFACE_LISTENER
+    ,
+                            public network::ActiveInterfaceListener
+#endif
 {
  public:
   void setup() override;
@@ -140,6 +145,10 @@ class MDNSComponent final : public Component
   }
 #endif
 
+#ifdef USE_MDNS_ACTIVE_INTERFACE_LISTENER
+  void on_active_interface(network::NetworkInterface interface) override;
+#endif
+
 #ifdef USE_MDNS_EVENT_DRIVEN_POLLING
   void on_ip_state(const network::IPAddresses &ips, const network::IPAddress &dns1,
                    const network::IPAddress &dns2) override;
@@ -160,8 +169,8 @@ class MDNSComponent final : public Component
   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_();
+  /// Publish network as the "network" TXT value if it changed; nullptr keeps the current value.
+  void update_network_txt_(const char *network);
   /// 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.

esphome/components/mdns/mdns_esp32.cpp

@@ -103,8 +103,9 @@ bool MDNSComponent::publish_network_txt_(const char *network) {
 
 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_(); });
+#if defined(USE_MDNS_DYNAMIC_NETWORK_TXT) && !defined(USE_MDNS_ACTIVE_INTERFACE_LISTENER)
+  this->set_interval(NETWORK_TXT_CHECK_INTERVAL_MS,
+                     [this]() { this->update_network_txt_(this->connected_network_()); });
 #endif
 }
 

esphome/components/mdns/mdns_rp2.cpp

@@ -64,7 +64,8 @@ bool MDNSComponent::publish_network_txt_(const char *network) {
 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_(); });
+  this->set_interval(NETWORK_TXT_CHECK_INTERVAL_MS,
+                     [this]() { this->update_network_txt_(this->connected_network_()); });
 #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

esphome/components/midea/air_conditioner.cpp

@@ -127,6 +127,19 @@ ClimateTraits AirConditioner::traits() {
   return traits;
 }
 
+#ifdef USE_REMOTE_TRANSMITTER
+static const LogString *display_control_str(DisplayControl control) {
+  switch (control) {
+    case DisplayControl::DISPLAY_CONTROL_UART:
+      return LOG_STR("UART");
+    case DisplayControl::DISPLAY_CONTROL_IR:
+      return LOG_STR("IR");
+    default:
+      return LOG_STR("AUTO");
+  }
+}
+#endif
+
 void AirConditioner::dump_config() {
   ESP_LOGCONFIG(Constants::TAG,
                 "MideaDongle:\n"
@@ -135,7 +148,10 @@ void AirConditioner::dump_config() {
                 "  [x] Request attempts: %d",
                 this->base_.getPeriod(), this->base_.getTimeout(), this->base_.getNumAttempts());
 #ifdef USE_REMOTE_TRANSMITTER
-  ESP_LOGCONFIG(Constants::TAG, "  [x] Using RemoteTransmitter");
+  ESP_LOGCONFIG(Constants::TAG,
+                "  [x] Using RemoteTransmitter\n"
+                "  [x] Display control: %s",
+                LOG_STR_ARG(display_control_str(this->display_control_)));
 #endif
   if (this->base_.getAutoconfStatus() == dudanov::midea::AUTOCONF_OK) {
     this->base_.getCapabilities().dump();
@@ -183,16 +199,20 @@ void AirConditioner::do_swing_step() {
 }
 
 void AirConditioner::do_display_toggle() {
-  if (this->base_.getCapabilities().supportLightControl()) {
-    this->base_.displayToggle();
-  } else {
 #ifdef USE_REMOTE_TRANSMITTER
+  // AUTO uses IR unless the appliance reports light control over UART. Without a transmitter
+  // built in, every setting sends the UART request: Mundoclima, Rotenso and others accept it
+  // without advertising it in the 0xB5 capabilities report.
+  const bool use_ir = this->display_control_ == DisplayControl::DISPLAY_CONTROL_IR ||
+                      (this->display_control_ == DisplayControl::DISPLAY_CONTROL_AUTO &&
+                       !this->base_.getCapabilities().supportLightControl());
+  if (use_ir) {
     IrSpecialData data(0x08);
     this->transmitter_.transmit(data);
-#else
-    ESP_LOGW(Constants::TAG, "Action needs remote_transmitter component");
-#endif
+    return;
   }
+#endif
+  this->base_.displayToggle();
 }
 
 }  // namespace esphome::midea::ac

esphome/components/midea/air_conditioner.h

@@ -21,12 +21,20 @@ using climate::ClimateModeMask;
 using climate::ClimateSwingModeMask;
 using climate::ClimatePresetMask;
 
+// How the display toggle reaches the appliance; the AUTO rules are in do_display_toggle()
+enum class DisplayControl : uint8_t {
+  DISPLAY_CONTROL_UART,  // always the UART request
+  DISPLAY_CONTROL_AUTO,  // UART when the appliance reports it or no transmitter is built in, else IR
+  DISPLAY_CONTROL_IR,    // always the IR remote, needs a transmitter
+};
+
 class AirConditioner final : public ApplianceBase<dudanov::midea::ac::AirConditioner>, public climate::Climate {
  public:
   void dump_config() override;
   void set_outdoor_temperature_sensor(Sensor *sensor) { this->outdoor_sensor_ = sensor; }
   void set_humidity_setpoint_sensor(Sensor *sensor) { this->humidity_sensor_ = sensor; }
   void set_power_sensor(Sensor *sensor) { this->power_sensor_ = sensor; }
+  void set_display_control(DisplayControl control) { this->display_control_ = control; }
   void on_status_change() override;
 
   /* ############### */
@@ -54,6 +62,7 @@ class AirConditioner final : public ApplianceBase<dudanov::midea::ac::AirConditi
   ClimateSwingModeMask supported_swing_modes_{};
   ClimatePresetMask supported_presets_{};
   bool frost_protection_set_{false};
+  DisplayControl display_control_{DisplayControl::DISPLAY_CONTROL_AUTO};
   Sensor *outdoor_sensor_{nullptr};
   Sensor *humidity_sensor_{nullptr};
   Sensor *power_sensor_{nullptr};

esphome/components/midea/climate.py

@@ -33,15 +33,18 @@ from esphome.const import (
     UNIT_WATT,
 )
 from esphome.core import CORE
+from esphome.types import ConfigType
 
 CODEOWNERS = ["@dudanov"]
 DEPENDENCIES = ["climate", "uart"]
 AUTO_LOAD = ["sensor"]
 CONF_POWER_USAGE = "power_usage"
 CONF_HUMIDITY_SETPOINT = "humidity_setpoint"
+CONF_DISPLAY_CONTROL = "display_control"
 midea_ac_ns = cg.esphome_ns.namespace("midea").namespace("ac")
 AirConditioner = midea_ac_ns.class_("AirConditioner", climate.Climate, cg.Component)
 Capabilities = midea_ac_ns.namespace("Constants")
+DisplayControl = midea_ac_ns.enum("DisplayControl", is_class=True)
 
 
 def templatize(value):
@@ -82,11 +85,29 @@ CUSTOM_PRESETS = {
     "FREEZE_PROTECTION": Capabilities.FREEZE_PROTECTION,
 }
 
+# How midea_ac.display_toggle reaches the appliance; see do_display_toggle() for the AUTO rules
+DISPLAY_CONTROLS = {
+    "UART": DisplayControl.DISPLAY_CONTROL_UART,
+    "AUTO": DisplayControl.DISPLAY_CONTROL_AUTO,
+    "IR": DisplayControl.DISPLAY_CONTROL_IR,
+}
+
 validate_modes = cv.enum(ALLOWED_CLIMATE_MODES, upper=True)
 validate_presets = cv.enum(ALLOWED_CLIMATE_PRESETS, upper=True)
 validate_swing_modes = cv.enum(ALLOWED_CLIMATE_SWING_MODES, upper=True)
 validate_custom_fan_modes = cv.enum(CUSTOM_FAN_MODES, upper=True)
 validate_custom_presets = cv.enum(CUSTOM_PRESETS, upper=True)
+validate_display_control = cv.enum(DISPLAY_CONTROLS, upper=True)
+
+
+def validate_display_control_with_transmitter(config: ConfigType) -> ConfigType:
+    """`display_control: IR` needs a `remote_transmitter` to send through; UART and AUTO do not."""
+    if config.get(CONF_DISPLAY_CONTROL) == "IR" and CONF_TRANSMITTER_ID not in config:
+        raise cv.Invalid(
+            f"'{CONF_DISPLAY_CONTROL}: IR' requires '{CONF_TRANSMITTER_ID}' to be set"
+        )
+    return config
+
 
 CONFIG_SCHEMA = cv.All(
     climate.climate_schema(AirConditioner)
@@ -100,6 +121,7 @@ CONFIG_SCHEMA = cv.All(
             ),
             cv.Optional(CONF_BEEPER, default=False): cv.boolean,
             cv.Optional(CONF_AUTOCONF, default=True): cv.boolean,
+            cv.Optional(CONF_DISPLAY_CONTROL, default="AUTO"): validate_display_control,
             cv.Optional(CONF_SUPPORTED_MODES): cv.ensure_list(validate_modes),
             cv.Optional(CONF_SUPPORTED_SWING_MODES): cv.ensure_list(
                 validate_swing_modes
@@ -134,6 +156,7 @@ CONFIG_SCHEMA = cv.All(
     )
     .extend(uart.UART_DEVICE_SCHEMA)
     .extend(cv.COMPONENT_SCHEMA),
+    validate_display_control_with_transmitter,
     cv.only_on(
         [
             PLATFORM_ESP32,
@@ -204,6 +227,7 @@ async def to_code(config):
         cg.add(var.set_transmitter(transmitter_))
     cg.add(var.set_beeper_feedback(config[CONF_BEEPER]))
     cg.add(var.set_autoconf(config[CONF_AUTOCONF]))
+    cg.add(var.set_display_control(config[CONF_DISPLAY_CONTROL]))
     if CONF_SUPPORTED_MODES in config:
         cg.add(var.set_supported_modes(config[CONF_SUPPORTED_MODES]))
     if CONF_SUPPORTED_SWING_MODES in config:

esphome/components/mipi_spi/mipi_spi.h

@@ -130,19 +130,8 @@ class MipiSpi : public display::Display,
   }
   display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
 
-  int get_width() override {
-    if (this->rotation_ == display::DISPLAY_ROTATION_90_DEGREES ||
-        this->rotation_ == display::DISPLAY_ROTATION_270_DEGREES)
-      return HEIGHT;
-    return WIDTH;
-  }
-
-  int get_height() override {
-    if (this->rotation_ == display::DISPLAY_ROTATION_90_DEGREES ||
-        this->rotation_ == display::DISPLAY_ROTATION_270_DEGREES)
-      return WIDTH;
-    return HEIGHT;
-  }
+  int get_width() override { return display::rotation_swaps_axes(this->rotation_) ? HEIGHT : WIDTH; }
+  int get_height() override { return display::rotation_swaps_axes(this->rotation_) ? WIDTH : HEIGHT; }
 
   void set_init_sequence(const uint8_t *sequence, size_t len) {
     this->init_sequence_ = sequence;
@@ -621,6 +610,9 @@ class MipiSpiBuffer
 #endif
   }
 
+  // With hardware rotation the buffer is written in drawn coordinates.
+  bool pixel_axes_swapped() const override { return !HAS_HARDWARE_ROTATION && display::Display::pixel_axes_swapped(); }
+
   // Draw a pixel at the given coordinates.
   void draw_pixel_at(int x, int y, Color color) override {
     if (this->is_point_clipped(x, y))

esphome/components/network/__init__.py

@@ -100,6 +100,37 @@ if (
 
 network_ns = cg.esphome_ns.namespace("network")
 NetworkComponent = network_ns.class_("NetworkComponent", cg.Component)
+
+_request_active_interface_listener_slot = cg.slot_counter(
+    "NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT"
+)
+
+
+def has_active_interface() -> bool:
+    """Return True when NetworkComponent tracks the interface holding the default route.
+
+    That is ESP32 with more than one interface in 'network: priority:', the same
+    condition that emits USE_NETWORK_DEFAULT_ROUTE.
+    """
+    return CORE.is_esp32 and len(CORE.config.get(DOMAIN, {}).get(CONF_PRIORITY, [])) > 1
+
+
+async def register_active_interface_listener(listener: cg.MockObj) -> bool:
+    """Register an ActiveInterfaceListener with the NetworkComponent.
+
+    The listener is notified from the main loop when the interface holding the
+    default route changes. Returns False, and registers nothing, when
+    has_active_interface() is False; the caller then needs another way to
+    follow interface changes.
+    """
+    if not has_active_interface():
+        return False
+    _request_active_interface_listener_slot()
+    network = await cg.get_variable(CORE.config[DOMAIN][CONF_ID])
+    cg.add(network.add_active_interface_listener(listener))
+    return True
+
+
 IPAddress = network_ns.class_("IPAddress")
 
 
@@ -402,7 +433,7 @@ async def to_code(config: ConfigType) -> None:
         # frameworks build from source.
         # The ethernet/wifi-only assumption behind the arbitration is enforced in
         # _final_validate() so a future unsupported type fails as a config error.
-        if len(priority_list) > 1 and CORE.is_esp32:
+        if has_active_interface():
             cg.add_define("USE_NETWORK_DEFAULT_ROUTE")
             # Have lwIP switch to the DNS servers of the netif that owns the
             # default route whenever the arbitration changes it.

esphome/components/network/network_component.cpp

@@ -78,16 +78,24 @@ void NetworkComponent::loop() {
   // USE_NETWORK_PRIMARY_INTERFACE_WIFI is emitted for a wifi-first priority list;
   // it selects the reported address in util.cpp and doubles as the route-order
   // pivot here — the two uses must stay in sync.
-  esp_netif_t *best;
+  esp_netif_t *wifi = connected_wifi_netif();
+  esp_netif_t *ethernet = connected_ethernet_netif();
 #ifdef USE_NETWORK_PRIMARY_INTERFACE_WIFI
-  best = connected_wifi_netif();
-  if (best == nullptr)
-    best = connected_ethernet_netif();
+  esp_netif_t *best = wifi != nullptr ? wifi : ethernet;
 #else
-  best = connected_ethernet_netif();
-  if (best == nullptr)
-    best = connected_wifi_netif();
+  esp_netif_t *best = ethernet != nullptr ? ethernet : wifi;
 #endif
+  NetworkInterface active = NetworkInterface::NETWORK_INTERFACE_NONE;
+  if (best != nullptr) {
+    active = best == ethernet ? NetworkInterface::NETWORK_INTERFACE_ETHERNET : NetworkInterface::NETWORK_INTERFACE_WIFI;
+  }
+  if (active != this->active_interface_) {
+    this->active_interface_ = active;
+#ifdef NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT
+    for (auto *listener : this->active_interface_listeners_)
+      listener->on_active_interface(active);
+#endif
+  }
   if (best == nullptr) {
     // Forget the last winner: stopping its netif cleared lwIP's default route and
     // IDF's manual override suppresses re-election, so reconnect must re-assert it.

esphome/components/network/network_component.h

@@ -4,12 +4,32 @@
 #include "esphome/core/component.h"
 
 #ifdef USE_NETWORK_DEFAULT_ROUTE
+#include "esphome/core/helpers.h"
 // Forward declaration matching esp_netif's own typedef; avoids pulling esp_netif.h
 // into this header.
 using esp_netif_t = struct esp_netif_obj;
 #endif
 
 namespace esphome::network {
+
+#ifdef USE_NETWORK_DEFAULT_ROUTE
+/// The interface holding the default route. Lists only the interfaces loop() arbitrates
+/// (ARBITRATED_NETWORK_TYPES in __init__.py); extend both together.
+enum class NetworkInterface : uint8_t {
+  NETWORK_INTERFACE_NONE,
+  NETWORK_INTERFACE_ETHERNET,
+  NETWORK_INTERFACE_WIFI,
+};
+
+#ifdef NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT
+/// Notified from the main loop when the interface holding the default route changes.
+class ActiveInterfaceListener {
+ public:
+  virtual void on_active_interface(NetworkInterface interface) = 0;
+};
+#endif
+#endif
+
 class NetworkComponent final : public Component {
  public:
   void setup() override;
@@ -20,6 +40,14 @@ class NetworkComponent final : public Component {
 #ifdef USE_NETWORK_DEFAULT_ROUTE
   void loop() override;
 
+  /// The first connected interface in network: priority order; NONE while none is connected.
+  NetworkInterface get_active_interface() const { return this->active_interface_; }
+#ifdef NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT
+  void add_active_interface_listener(ActiveInterfaceListener *listener) {
+    this->active_interface_listeners_.push_back(listener);
+  }
+#endif
+
  protected:
   // Verify-lwIP-route interval for the settled state; keeps the global lwIP core
   // mutex off the hot loop path.
@@ -27,6 +55,10 @@ class NetworkComponent final : public Component {
   // Last netif this component made the default; avoids redundant esp_netif calls.
   esp_netif_t *default_netif_{nullptr};
   uint32_t last_route_check_{0};
+#ifdef NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT
+  StaticVector<ActiveInterfaceListener *, NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT> active_interface_listeners_;
+#endif
+  NetworkInterface active_interface_{NetworkInterface::NETWORK_INTERFACE_NONE};
 #endif
 };
 }  // namespace esphome::network

esphome/components/qspi_dbi/__init__.py

@@ -6,4 +6,5 @@ CONF_DRAW_FROM_ORIGIN = "draw_from_origin"
 DEPRECATED_COMPONENT = """
 The 'qspi_dbi' component is deprecated and no new models will be added to it.
 New model PRs should target the newer and more performant 'mipi_spi' component.
+It will be removed in ESPHome 2027.5.0.
 """

esphome/components/qspi_dbi/display.py

@@ -165,8 +165,10 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config: ConfigType) -> None:
+    # Remove before 2027.5.0
     LOGGER.warning(
-        "The 'qspi_dbi' component is deprecated, it is recommended to use 'mipi_spi' instead."
+        "The 'qspi_dbi' component is deprecated and will be removed in ESPHome 2027.5.0, "
+        "migrate to 'mipi_spi' instead."
     )
     var = cg.new_Pvariable(config[CONF_ID])
     await display.register_display(var, config)

esphome/components/radon_eye_rd200/radon_eye_rd200.cpp

@@ -1,150 +1,123 @@
 #include "radon_eye_rd200.h"
-
-#ifdef USE_BLE_CLIENT_GATT_NODES
-
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
+#include "esphome/components/esp32_ble/ble_uuid.h"
 
 #include <cstring>
 
+#ifdef USE_ESP32
+
 namespace esphome::radon_eye_rd200 {
 
 ESPHOME_LOG_TAG(TAG, "radon_eye_rd200");
 
-using ble_device_base::ESPBTUUID;
-
-// V1 (RD200 firmware < 2.0) exposes a vendor service; V2 (>= 2.0) moved to
-// Bluetooth-base (16-bit) UUIDs with a different command byte and payload
-// layout.
-static const char *const SERVICE_UUID_V1 = "00001523-1212-efde-1523-785feabcd123";
-static const char *const WRITE_CHARACTERISTIC_UUID_V1 = "00001524-1212-efde-1523-785feabcd123";
-static const char *const READ_CHARACTERISTIC_UUID_V1 = "00001525-1212-efde-1523-785feabcd123";
+static const esp32_ble_tracker::ESPBTUUID SERVICE_UUID_V1 =
+    esp32_ble_tracker::ESPBTUUID::from_raw("00001523-1212-efde-1523-785feabcd123");
+static const esp32_ble_tracker::ESPBTUUID WRITE_CHARACTERISTIC_UUID_V1 =
+    esp32_ble_tracker::ESPBTUUID::from_raw("00001524-1212-efde-1523-785feabcd123");
+static const esp32_ble_tracker::ESPBTUUID READ_CHARACTERISTIC_UUID_V1 =
+    esp32_ble_tracker::ESPBTUUID::from_raw("00001525-1212-efde-1523-785feabcd123");
 static const uint8_t WRITE_COMMAND_V1 = 0x50;
 
-static const uint16_t SERVICE_UUID_V2 = 0x1523;
-static const uint16_t WRITE_CHARACTERISTIC_UUID_V2 = 0x1524;
-static const uint16_t READ_CHARACTERISTIC_UUID_V2 = 0x1525;
+static const esp32_ble_tracker::ESPBTUUID SERVICE_UUID_V2 =
+    esp32_ble_tracker::ESPBTUUID::from_raw("00001523-0000-1000-8000-00805f9b34fb");
+static const esp32_ble_tracker::ESPBTUUID WRITE_CHARACTERISTIC_UUID_V2 =
+    esp32_ble_tracker::ESPBTUUID::from_raw("00001524-0000-1000-8000-00805f9b34fb");
+static const esp32_ble_tracker::ESPBTUUID READ_CHARACTERISTIC_UUID_V2 =
+    esp32_ble_tracker::ESPBTUUID::from_raw("00001525-0000-1000-8000-00805f9b34fb");
 static const uint8_t WRITE_COMMAND_V2 = 0x40;
 
-// Minimum notification payload carrying all three measurements.
-static const uint16_t MESSAGE_MIN_LEN_V1 = 20;
-static const uint16_t MESSAGE_MIN_LEN_V2 = 68;
-
-RadonEyeRD200::RadonEyeRD200() : PollingComponent(10000) {}
-
-void RadonEyeRD200::update() {
-  if (this->parent()->connected())
-    return;
-  if (!this->parent()->enabled) {
-    ESP_LOGW(TAG, "Reconnecting to device");
-    this->parent()->set_enabled(true);
-  } else {
-    ESP_LOGW(TAG, "Connection in progress");
-  }
-}
-
-void RadonEyeRD200::on_connected(const ble_device_base::GattServiceTable &table) {
-  if (!this->resolve_handles_(table)) {
-    // Retried on the next poll (update() re-enables the client).
-    this->parent()->set_enabled(false);
-    return;
-  }
-  // Local notification registration; the CCCD write follows in
-  // on_notify_state (the contract leaves the CCCD to the node).
-  if (this->parent()->notify_characteristic(this->read_handle_, true) != 0) {
-    this->parent()->set_enabled(false);
-  }
-}
-
-bool RadonEyeRD200::resolve_handles_(const ble_device_base::GattServiceTable &table) {
-  struct Variant {
-    ESPBTUUID service;
-    ESPBTUUID write_chr;
-    ESPBTUUID read_chr;
-    uint8_t command;
-  };
-  // Built on the stack per (cold) discovery so the UUID objects stay out of
-  // static RAM; the V1 strings live in flash.
-  const Variant variants[] = {
-      {ESPBTUUID::from_raw(SERVICE_UUID_V1), ESPBTUUID::from_raw(WRITE_CHARACTERISTIC_UUID_V1),
-       ESPBTUUID::from_raw(READ_CHARACTERISTIC_UUID_V1), WRITE_COMMAND_V1},
-      {ESPBTUUID::from_uint16(SERVICE_UUID_V2), ESPBTUUID::from_uint16(WRITE_CHARACTERISTIC_UUID_V2),
-       ESPBTUUID::from_uint16(READ_CHARACTERISTIC_UUID_V2), WRITE_COMMAND_V2},
-  };
-  for (const auto &variant : variants) {
-    const auto *service = ble_device_base::find_service(table, variant.service);
-    if (service == nullptr) {
-      continue;
+void RadonEyeRD200::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                                        esp_ble_gattc_cb_param_t *param) {
+  switch (event) {
+    case ESP_GATTC_OPEN_EVT: {
+      if (param->open.status == ESP_GATT_OK) {
+        ESP_LOGI(TAG, "Connected successfully!");
+      }
+      break;
     }
-    const auto *read_chr = ble_device_base::find_characteristic(table, *service, variant.read_chr);
-    const auto *write_chr = ble_device_base::find_characteristic(table, *service, variant.write_chr);
-    if (read_chr == nullptr || write_chr == nullptr) {
-      ESP_LOGW(TAG, "Service found but a sensor characteristic is missing");
-      return false;
+
+    case ESP_GATTC_DISCONNECT_EVT: {
+      ESP_LOGW(TAG, "Disconnected!");
+      break;
     }
-    this->cccd_handle_ = ble_device_base::find_cccd(table, *read_chr);
-    if (this->cccd_handle_ == 0) {
-      ESP_LOGW(TAG, "Sensor read characteristic has no CCCD");
-      return false;
+
+    case ESP_GATTC_SEARCH_CMPL_EVT: {
+      if (this->parent()->get_service(SERVICE_UUID_V1) != nullptr) {
+        service_uuid_ = SERVICE_UUID_V1;
+        sensors_write_characteristic_uuid_ = WRITE_CHARACTERISTIC_UUID_V1;
+        sensors_read_characteristic_uuid_ = READ_CHARACTERISTIC_UUID_V1;
+        write_command_ = WRITE_COMMAND_V1;
+      } else if (this->parent()->get_service(SERVICE_UUID_V2) != nullptr) {
+        service_uuid_ = SERVICE_UUID_V2;
+        sensors_write_characteristic_uuid_ = WRITE_CHARACTERISTIC_UUID_V2;
+        sensors_read_characteristic_uuid_ = READ_CHARACTERISTIC_UUID_V2;
+        write_command_ = WRITE_COMMAND_V2;
+      } else {
+        ESP_LOGW(TAG, "No supported device has been found, disconnecting");
+        parent()->set_enabled(false);
+        break;
+      }
+
+      this->read_handle_ = 0;
+      auto *chr = this->parent()->get_characteristic(service_uuid_, sensors_read_characteristic_uuid_);
+      if (chr == nullptr) {
+        char service_buf[esp32_ble::UUID_STR_LEN];
+        char char_buf[esp32_ble::UUID_STR_LEN];
+        ESP_LOGW(TAG, "No sensor read characteristic found at service %s char %s", service_uuid_.to_str(service_buf),
+                 sensors_read_characteristic_uuid_.to_str(char_buf));
+        break;
+      }
+      this->read_handle_ = chr->handle;
+
+      auto *write_chr = this->parent()->get_characteristic(service_uuid_, sensors_write_characteristic_uuid_);
+      if (write_chr == nullptr) {
+        char service_buf[esp32_ble::UUID_STR_LEN];
+        char char_buf[esp32_ble::UUID_STR_LEN];
+        ESP_LOGW(TAG, "No sensor write characteristic found at service %s char %s", service_uuid_.to_str(service_buf),
+                 sensors_write_characteristic_uuid_.to_str(char_buf));
+        break;
+      }
+      this->write_handle_ = write_chr->handle;
+
+      esp_err_t status =
+          esp_ble_gattc_register_for_notify(gattc_if, this->parent()->get_remote_bda(), this->read_handle_);
+      if (status) {
+        ESP_LOGW(TAG, "Error registering for sensor notify, status=%d", status);
+      }
+      break;
     }
-    this->read_handle_ = read_chr->value_handle;
-    this->write_handle_ = write_chr->value_handle;
-    this->write_command_ = variant.command;
-    return true;
-  }
-  ESP_LOGW(TAG, "No supported device has been found, disconnecting");
-  return false;
-}
 
-void RadonEyeRD200::on_notify_state(uint16_t handle, bool enabled, int error) {
-  if (handle != this->read_handle_) {
-    return;
-  }
-  if (error != 0) {
-    ESP_LOGW(TAG, "Error registering for sensor notify, status=%d", error);
-    this->parent()->set_enabled(false);
-    return;
-  }
-  if (!enabled) {
-    return;
-  }
-  static const uint8_t ENABLE_NOTIFY[2] = {0x01, 0x00};
-  if (this->parent()->write_descriptor(this->cccd_handle_, ENABLE_NOTIFY, sizeof(ENABLE_NOTIFY)) != 0) {
-    this->parent()->set_enabled(false);
+    case ESP_GATTC_WRITE_DESCR_EVT: {
+      if (param->write.status != ESP_GATT_OK) {
+        ESP_LOGE(TAG, "write descr failed, error status = %x", param->write.status);
+        break;
+      }
+      ESP_LOGV(TAG, "Write descr success, writing 0x%02X at write_handle=%d", this->write_command_,
+               this->write_handle_);
+      esp_err_t status =
+          esp_ble_gattc_write_char(gattc_if, this->parent()->get_conn_id(), this->write_handle_, sizeof(write_command_),
+                                   (uint8_t *) &write_command_, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
+      if (status) {
+        ESP_LOGW(TAG, "Error writing 0x%02x command, status=%d", write_command_, status);
+      }
+      break;
+    }
+
+    case ESP_GATTC_NOTIFY_EVT: {
+      if (param->notify.is_notify) {
+        ESP_LOGV(TAG, "ESP_GATTC_NOTIFY_EVT, receive notify value, %d bytes", param->notify.value_len);
+      } else {
+        ESP_LOGV(TAG, "ESP_GATTC_NOTIFY_EVT, receive indicate value, %d bytes", param->notify.value_len);
+      }
+      read_sensors_(param->notify.value, param->notify.value_len);
+      break;
+    }
+
+    default:
+      break;
   }
 }
 
-void RadonEyeRD200::on_write_result(uint16_t handle, int error) {
-  // The command write (no response) also lands here; only the CCCD
-  // completion advances the sequence.
-  if (handle != this->cccd_handle_) {
-    return;
-  }
-  if (error != 0) {
-    ESP_LOGE(TAG, "CCCD write on handle 0x%04x failed, status=%d", handle, error);
-    this->parent()->set_enabled(false);
-    return;
-  }
-  ESP_LOGV(TAG, "Write descr success, writing 0x%02X at write_handle=%d", this->write_command_, this->write_handle_);
-  if (this->parent()->write_characteristic(this->write_handle_, &this->write_command_, sizeof(this->write_command_),
-                                           false) != 0) {
-    ESP_LOGW(TAG, "Error writing 0x%02x command", this->write_command_);
-    this->parent()->set_enabled(false);
-  }
-}
-
-void RadonEyeRD200::on_notify(uint16_t handle, const uint8_t *data, uint16_t len) {
-  if (handle != this->read_handle_) {
-    return;
-  }
-  ESP_LOGV(TAG, "Received notify value, %d bytes", len);
-  this->read_sensors_(data, len);
-  // This instance must not stay connected so other clients can connect to it
-  // (e.g. the mobile app).
-  this->parent()->set_enabled(false);
-}
-
-void RadonEyeRD200::read_sensors_(const uint8_t *value, uint16_t value_len) {
+void RadonEyeRD200::read_sensors_(uint8_t *value, uint16_t value_len) {
   if (value_len < 1) {
     ESP_LOGW(TAG, "Unexpected empty message");
     return;
@@ -152,8 +125,7 @@ void RadonEyeRD200::read_sensors_(const uint8_t *value, uint16_t value_len) {
 
   uint8_t command = value[0];
 
-  if ((command == WRITE_COMMAND_V1 && value_len < MESSAGE_MIN_LEN_V1) ||
-      (command == WRITE_COMMAND_V2 && value_len < MESSAGE_MIN_LEN_V2)) {
+  if ((command == WRITE_COMMAND_V1 && value_len < 20) || (command == WRITE_COMMAND_V2 && value_len < 68)) {
     ESP_LOGW(TAG, "Unexpected command 0x%02X message length %d", command, value_len);
     return;
   }
@@ -162,11 +134,8 @@ void RadonEyeRD200::read_sensors_(const uint8_t *value, uint16_t value_len) {
   // 501085EBB9400000000000000000220025000000
   // Example data V2:
   // 4042323230313033525532303338330652443230304e56322e302e3200014a00060a00080000000300010079300000e01108001c00020000003822005c8f423fa4709d3f
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-  // Sized for the V2 minimum payload; format_hex_to truncates longer messages.
-  char hex_buf[format_hex_size(MESSAGE_MIN_LEN_V2)];
-  ESP_LOGV(TAG, "radon sensors raw bytes: %s", format_hex_to(hex_buf, value, value_len));
-#endif
+  ESP_LOGV(TAG, "radon sensors raw bytes");
+  ESP_LOG_BUFFER_HEX_LEVEL(TAG, value, value_len, ESP_LOG_VERBOSE);
 
   // Convert from pCi/L to Bq/m³
   constexpr float convert_to_bwpm3 = 37.0;
@@ -216,6 +185,22 @@ void RadonEyeRD200::read_sensors_(const uint8_t *value, uint16_t value_len) {
            "  Measurements (pCi/L) now: %0.03f, day: %0.03f, month: %0.03f",
            radon_now, radon_day, radon_month, radon_now / convert_to_bwpm3, radon_day / convert_to_bwpm3,
            radon_month / convert_to_bwpm3);
+
+  // This instance must not stay connected
+  // so other clients can connect to it (e.g. the
+  // mobile app).
+  parent()->set_enabled(false);
+}
+
+void RadonEyeRD200::update() {
+  if (this->node_state != esp32_ble_tracker::ClientState::ESTABLISHED) {
+    if (!parent()->enabled) {
+      ESP_LOGW(TAG, "Reconnecting to device");
+      parent()->set_enabled(true);
+    } else {
+      ESP_LOGW(TAG, "Connection in progress");
+    }
+  }
 }
 
 void RadonEyeRD200::dump_config() {
@@ -223,6 +208,8 @@ void RadonEyeRD200::dump_config() {
   LOG_SENSOR("  ", "Radon Long Term", this->radon_long_term_sensor_);
 }
 
+RadonEyeRD200::RadonEyeRD200() : PollingComponent(10000) {}
+
 }  // namespace esphome::radon_eye_rd200
 
-#endif  // USE_BLE_CLIENT_GATT_NODES
+#endif  // USE_ESP32

esphome/components/radon_eye_rd200/radon_eye_rd200.h

@@ -1,29 +1,15 @@
-// RD200 radon sensor on the platform-neutral ble_client node interface -
-// one implementation for every platform with a GATT client engine (esp32
-// and rp2 / Pico W today).
-//
-// Poll cycle: enable the client (it connects on the peer's next sighting) →
-// resolve the V1/V2 variant and handles from the service table during
-// on_connected() → local notify registration → explicit CCCD write (the
-// contract makes the CCCD the node's job) → write the read command → parse
-// the notification → disable. The link is dropped after every reading so the
-// vendor mobile app can connect between polls.
-
 #pragma once
 
-#include "esphome/core/defines.h"
+#ifdef USE_ESP32
 
-#ifdef USE_BLE_CLIENT_GATT_NODES
-
-#include "esphome/components/ble_client/ble_client_node.h"
+#include <esp_gattc_api.h>
+#include <algorithm>
+#include <iterator>
+#include "esphome/components/ble_client/ble_client.h"
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/core/component.h"
-
-#ifdef USE_ESP32
-#include "esphome/components/ble_client/ble_client.h"
-#else
-#include "esphome/components/ble_client/ble_client_gatt.h"
-#endif
+#include "esphome/core/log.h"
 
 namespace esphome::radon_eye_rd200 {
 
@@ -34,28 +20,26 @@ class RadonEyeRD200 final : public PollingComponent, public ble_client::BLEClien
   void dump_config() override;
   void update() override;
 
-  void set_radon(sensor::Sensor *radon) { this->radon_sensor_ = radon; }
-  void set_radon_long_term(sensor::Sensor *radon_long_term) { this->radon_long_term_sensor_ = radon_long_term; }
+  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                           esp_ble_gattc_cb_param_t *param) override;
 
-  // ---- ble_client::BLEClientNode (unused events keep the no-op defaults) ----
-  void on_connected(const ble_device_base::GattServiceTable &table) override;
-  void on_notify(uint16_t handle, const uint8_t *data, uint16_t len) override;
-  void on_notify_state(uint16_t handle, bool enabled, int error) override;
-  void on_write_result(uint16_t handle, int error) override;
+  void set_radon(sensor::Sensor *radon) { radon_sensor_ = radon; }
+  void set_radon_long_term(sensor::Sensor *radon_long_term) { radon_long_term_sensor_ = radon_long_term; }
 
  protected:
-  bool resolve_handles_(const ble_device_base::GattServiceTable &table);
-  void read_sensors_(const uint8_t *value, uint16_t value_len);
+  void read_sensors_(uint8_t *value, uint16_t value_len);
 
   sensor::Sensor *radon_sensor_{nullptr};
   sensor::Sensor *radon_long_term_sensor_{nullptr};
 
-  uint16_t read_handle_{0};
-  uint16_t write_handle_{0};
-  uint16_t cccd_handle_{0};
-  uint8_t write_command_{0};
+  uint8_t write_command_;
+  uint16_t read_handle_;
+  uint16_t write_handle_;
+  esp32_ble_tracker::ESPBTUUID service_uuid_;
+  esp32_ble_tracker::ESPBTUUID sensors_write_characteristic_uuid_;
+  esp32_ble_tracker::ESPBTUUID sensors_read_characteristic_uuid_;
 };
 
 }  // namespace esphome::radon_eye_rd200
 
-#endif  // USE_BLE_CLIENT_GATT_NODES
+#endif  // USE_ESP32

esphome/components/radon_eye_rd200/sensor.py

@@ -37,7 +37,7 @@ CONFIG_SCHEMA = cv.All(
         }
     )
     .extend(cv.polling_component_schema("5min"))
-    .extend(ble_client.NODE_BLE_CLIENT_SCHEMA),
+    .extend(ble_client.BLE_CLIENT_SCHEMA),
 )
 
 
@@ -45,7 +45,7 @@ async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
-    await ble_client.register_gatt_node(var, config)
+    await ble_client.register_ble_node(var, config)
 
     sensors = sensor.sub_sensors(config)
     await sensors(CONF_RADON, var.set_radon)

esphome/components/rpi_dpi_rgb/__init__.py

@@ -4,4 +4,5 @@ DOMAIN = "rpi_dpi_rgb"
 DEPRECATED_COMPONENT = """
 The 'rpi_dpi_rgb' component is deprecated and no new models will be added to it.
 New model PRs should target the newer and more performant 'mipi_rgb' component.
+It will be removed in ESPHome 2027.5.0.
 """

esphome/components/rpi_dpi_rgb/display.py

@@ -132,8 +132,10 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config: ConfigType) -> None:
+    # Remove before 2027.5.0
     LOGGER.warning(
-        "The 'rpi_dpi_rgb' component is deprecated, it is recommended to use 'mipi_rgb' instead."
+        "The 'rpi_dpi_rgb' component is deprecated and will be removed in ESPHome 2027.5.0, "
+        "migrate to 'mipi_rgb' instead."
     )
     var = cg.new_Pvariable(config[CONF_ID])
     await display.register_display(var, config)

esphome/components/seeed_mr60fda2/seeed_mr60fda2.cpp

@@ -1,4 +1,5 @@
 #include "seeed_mr60fda2.h"
+#include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
@@ -109,23 +110,10 @@ static uint8_t find_nearest_index(float value, const float *arr, int size) {
   return nearest_index;
 }
 
-/**
- * @brief Convert a float value to a byte array.
- *
- * This function converts a float value to a byte array.
- *
- * @param value The float value to convert.
- * @param bytes The byte array to store the converted value.
- */
-static void float_to_bytes(float value, unsigned char *bytes) {
-  union {
-    float float_value;
-    unsigned char byte_array[4];
-  } u;
-
-  u.float_value = value;
-  memcpy(bytes, u.byte_array, 4);
-}
+// Read with 32-bit loads or progmem_memcpy only; the radar takes the floats little-endian
+alignas(4) static const float INSTALL_HEIGHT[7] PROGMEM = {2.4f, 2.5f, 2.6f, 2.7f, 2.8f, 2.9f, 3.0f};
+alignas(4) static const float HEIGHT_THRESHOLD[7] PROGMEM = {0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f};
+alignas(4) static const float SENSITIVITY[3] PROGMEM = {3, 15, 30};
 
 /**
  * @brief Convert a 32-bit unsigned integer to a byte array.
@@ -334,7 +322,7 @@ void MR60FDA2Component::set_install_height(uint8_t index) {
   if (index >= std::size(INSTALL_HEIGHT))
     return;
   uint8_t send_data[13] = {0x01, 0x00, 0x00, 0x00, 0x04, 0x0E, 0x04, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00};
-  float_to_bytes(INSTALL_HEIGHT[index], &send_data[8]);
+  progmem_memcpy(&send_data[8], &INSTALL_HEIGHT[index], 4);
   send_data[12] = calculate_checksum(send_data + 8, 4);
   this->write_array(send_data, 13);
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
@@ -347,7 +335,7 @@ void MR60FDA2Component::set_height_threshold(uint8_t index) {
   if (index >= std::size(HEIGHT_THRESHOLD))
     return;
   uint8_t send_data[13] = {0x01, 0x00, 0x00, 0x00, 0x04, 0x0E, 0x08, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00};
-  float_to_bytes(HEIGHT_THRESHOLD[index], &send_data[8]);
+  progmem_memcpy(&send_data[8], &HEIGHT_THRESHOLD[index], 4);
   send_data[12] = calculate_checksum(send_data + 8, 4);
   this->write_array(send_data, 13);
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE

esphome/components/seeed_mr60fda2/seeed_mr60fda2.h

@@ -48,14 +48,6 @@ enum FrameLocation {
   LOCATE_PROCESS_FRAME,
 };
 
-static const float INSTALL_HEIGHT[7] = {2.4f, 2.5f, 2.6f, 2.7f, 2.8f, 2.9f, 3.0f};
-static const float HEIGHT_THRESHOLD[7] = {0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f};
-static const float SENSITIVITY[3] = {3, 15, 30};
-
-static const char *const INSTALL_HEIGHT_STR[7] = {"2.4m", "2.5m", "2.6", "2.7m", "2.8", "2.9m", "3.0m"};
-static const char *const HEIGHT_THRESHOLD_STR[7] = {"0.0m", "0.1m", "0.2m", "0.3m", "0.4m", "0.5m", "0.6m"};
-static const char *const SENSITIVITY_STR[3] = {"1", "2", "3"};
-
 class MR60FDA2Component final : public Component,
                                 public uart::UARTDevice {  // The class name must be the name defined by text_sensor.py
 #ifdef USE_BINARY_SENSOR

esphome/components/sen6x/sen6x.cpp

@@ -14,6 +14,15 @@ static constexpr uint32_t POLL_INTERVAL = 50;   // 50 ms between poll attempts
 // Numeric timeout IDs. Each chain is sequential, so only one timeout per ID is active at a time.
 static constexpr uint32_t TIMEOUT_POLL = 1;
 static constexpr uint32_t TIMEOUT_SETUP_STEP = 2;
+static constexpr uint32_t TIMEOUT_STARTUP = 3;
+// Post-command wait times from the datasheet: start execution (4.8.1), stop execution (4.8.2),
+// fan cleaning (4.8.22), SHT heater (4.8.23), CO2 conditioning after start on SEN63C/SEN69C (4.8.1)
+static constexpr uint32_t START_MEASUREMENT_DELAY = 50;
+static constexpr uint32_t STOP_MEASUREMENT_DELAY = 1400;
+static constexpr uint32_t FAN_CLEANING_DELAY = 10000;
+static constexpr uint32_t SHT_HEATER_DELAY = 20000;
+static constexpr uint32_t CO2_CONDITIONING_DELAY = 24000;
+static constexpr uint32_t STARTUP_DELAY = 60000;  // ms before published values are considered valid
 static constexpr uint16_t SEN6X_CMD_GET_DATA_READY_STATUS = 0x0202;
 static constexpr uint16_t SEN6X_CMD_GET_FIRMWARE_VERSION = 0xD100;
 static constexpr uint16_t SEN6X_CMD_GET_PRODUCT_NAME = 0xD014;
@@ -27,6 +36,9 @@ static constexpr uint16_t SEN6X_CMD_READ_MEASUREMENT_SEN68 = 0x0467;
 static constexpr uint16_t SEN6X_CMD_READ_MEASUREMENT_SEN69C = 0x04B5;
 
 static constexpr uint16_t SEN6X_CMD_START_MEASUREMENTS = 0x0021;
+static constexpr uint16_t SEN6X_CMD_STOP_MEASUREMENTS = 0x0104;
+static constexpr uint16_t SEN6X_CMD_START_FAN_CLEANING = 0x5607;
+static constexpr uint16_t SEN6X_CMD_ACTIVATE_SHT_HEATER = 0x6765;
 static constexpr uint16_t SEN6X_CMD_RESET = 0xD304;
 static constexpr uint16_t SEN6X_CMD_VOC_ALGORITHM_TUNING = 0x60D0;
 static constexpr uint16_t SEN6X_CMD_NOX_ALGORITHM_TUNING = 0x60E1;
@@ -191,7 +203,7 @@ void SEN6XComponent::finish_setup_() {
     return;
   }
 
-  this->set_timeout(60000, [this]() { this->startup_complete_ = true; });
+  this->on_measurement_started_();
   this->initialized_ = true;
   ESP_LOGD(TAG, "Initialized");
 }
@@ -240,7 +252,7 @@ void SEN6XComponent::dump_config() {
 }
 
 void SEN6XComponent::update() {
-  if (!this->initialized_) {
+  if (!this->initialized_ || !this->measuring_) {
     return;
   }
 
@@ -442,6 +454,101 @@ void SEN6XComponent::parse_and_publish_measurements_() {
   this->status_clear_warning();
 }
 
+// True while the previous command's execution or settling time has not elapsed
+bool SEN6XComponent::command_blocked_() const { return millis() - this->command_started_at_ < this->command_wait_; }
+
+void SEN6XComponent::set_command_wait_(uint32_t wait_ms) {
+  this->command_started_at_ = millis();
+  this->command_wait_ = wait_ms;
+}
+
+void SEN6XComponent::on_measurement_started_() {
+  this->measuring_ = true;
+  this->set_command_wait_(START_MEASUREMENT_DELAY);
+  // SEN63C/SEN69C condition the CO2 sensor for 24 s after a start; block restarts until then
+  if (this->sen6x_type_ == SEN63C || this->sen6x_type_ == SEN69C) {
+    this->co2_started_at_ = millis();
+    this->co2_wait_ = CO2_CONDITIONING_DELAY;
+  }
+  // Values need the warm-up period again after every start
+  this->startup_complete_ = false;
+  this->set_timeout(TIMEOUT_STARTUP, STARTUP_DELAY, [this]() { this->startup_complete_ = true; });
+}
+
+void SEN6XComponent::start_measurement() {
+  if (!this->initialized_ || this->measuring_)
+    return;
+  // The CO2 conditioning window only blocks restarting, not other commands
+  if (this->command_blocked_() || millis() - this->co2_started_at_ < this->co2_wait_) {
+    ESP_LOGW(TAG, "Device busy");
+    return;
+  }
+  if (!this->write_command(SEN6X_CMD_START_MEASUREMENTS)) {
+    this->status_set_warning();
+    ESP_LOGW(TAG, "Start measurement failed (%d)", this->last_error_);
+    return;
+  }
+  this->on_measurement_started_();
+}
+
+void SEN6XComponent::stop_measurement() {
+  if (!this->initialized_ || !this->measuring_)
+    return;
+  if (this->command_blocked_()) {
+    ESP_LOGW(TAG, "Device busy");
+    return;
+  }
+  // Stop any in-flight polling before the device goes idle
+  this->cancel_timeout(TIMEOUT_POLL);
+  if (!this->write_command(SEN6X_CMD_STOP_MEASUREMENTS)) {
+    this->status_set_warning();
+    ESP_LOGW(TAG, "Stop measurement failed (%d)", this->last_error_);
+    return;
+  }
+  this->measuring_ = false;
+  this->set_command_wait_(STOP_MEASUREMENT_DELAY);
+}
+
+void SEN6XComponent::start_fan_cleaning() {
+  if (!this->initialized_)
+    return;
+  // The device only accepts this command in idle mode (datasheet section 4.8.22)
+  if (this->measuring_) {
+    ESP_LOGW(TAG, "Fan cleaning requires idle mode; stop the measurement first");
+    return;
+  }
+  if (this->command_blocked_()) {
+    ESP_LOGW(TAG, "Device busy");
+    return;
+  }
+  if (!this->write_command(SEN6X_CMD_START_FAN_CLEANING)) {
+    this->status_set_warning();
+    ESP_LOGW(TAG, "Fan cleaning failed (%d)", this->last_error_);
+    return;
+  }
+  this->set_command_wait_(FAN_CLEANING_DELAY);
+}
+
+void SEN6XComponent::activate_sht_heater() {
+  if (!this->initialized_)
+    return;
+  // The device only accepts this command in idle mode (datasheet section 4.8.23)
+  if (this->measuring_) {
+    ESP_LOGW(TAG, "SHT heater requires idle mode; stop the measurement first");
+    return;
+  }
+  if (this->command_blocked_()) {
+    ESP_LOGW(TAG, "Device busy");
+    return;
+  }
+  if (!this->write_command(SEN6X_CMD_ACTIVATE_SHT_HEATER)) {
+    this->status_set_warning();
+    ESP_LOGW(TAG, "SHT heater failed (%d)", this->last_error_);
+    return;
+  }
+  this->set_command_wait_(SHT_HEATER_DELAY);
+}
+
 SEN6XComponent::Sen6xType SEN6XComponent::infer_type_from_product_name_(const std::string &product_name) {
   if (product_name == "SEN62")
     return SEN62;

esphome/components/sen6x/sen6x.h

@@ -58,6 +58,10 @@ class SEN6XComponent final : public PollingComponent, public sensirion_common::S
                                          NOX_STD_INITIAL,
                                          gain_factor};
   }
+  void start_measurement();
+  void stop_measurement();
+  void start_fan_cleaning();
+  void activate_sht_heater();
 
  protected:
   Sen6xType infer_type_from_product_name_(const std::string &product_name);
@@ -65,6 +69,9 @@ class SEN6XComponent final : public PollingComponent, public sensirion_common::S
   void finish_setup_();
   bool write_config_words_(uint16_t i2c_command, const uint16_t *data, uint8_t len);
   bool write_tuning_parameters_(uint16_t i2c_command, const GasTuning &tuning);
+  bool command_blocked_() const;
+  void set_command_wait_(uint32_t wait_ms);
+  void on_measurement_started_();
   void poll_data_ready_();
   void read_measurements_();
   void parse_and_publish_measurements_();
@@ -74,6 +81,11 @@ class SEN6XComponent final : public PollingComponent, public sensirion_common::S
   optional<GasTuning> voc_tuning_params_;
   optional<GasTuning> nox_tuning_params_;
   Sen6xType sen6x_type_{UNKNOWN};
+  // Post-command wait windows, stored as start time plus duration so elapsed-time checks survive millis() wrap
+  uint32_t command_started_at_{0};
+  uint32_t command_wait_{0};
+  uint32_t co2_started_at_{0};
+  uint32_t co2_wait_{0};
   uint16_t read_cmd_{0};
   uint8_t setup_step_index_{0};
   uint8_t firmware_version_major_{0};
@@ -81,6 +93,7 @@ class SEN6XComponent final : public PollingComponent, public sensirion_common::S
   uint8_t poll_retries_remaining_{0};
   uint8_t read_words_{0};
   bool initialized_{false};
+  bool measuring_{false};
   bool startup_complete_{false};
 };
 

esphome/components/sen6x/sensor.py

@@ -1,3 +1,5 @@
+from esphome import automation
+from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
 from esphome.components import i2c, sensirion_common, sensor
 from esphome.components.const import CONF_NOX_INDEX, CONF_VOC_INDEX
@@ -209,3 +211,21 @@ async def to_code(config: ConfigType) -> None:
                 args.append(std_initial)
             args.append(tuning[CONF_GAIN_FACTOR])
             cg.add(getattr(var, setter)(*args))
+
+
+SEN6X_ACTION_SCHEMA = maybe_simple_id(
+    {
+        cv.Required(CONF_ID): cv.use_id(SEN6XComponent),
+    }
+)
+
+
+for _name, _call in (
+    ("sen6x.start_measurement", "start_measurement()"),
+    ("sen6x.stop_measurement", "stop_measurement()"),
+    ("sen6x.start_fan_cleaning", "start_fan_cleaning()"),
+    ("sen6x.activate_sht_heater", "activate_sht_heater()"),
+):
+    automation.register_apply_action(
+        _name, SEN6X_ACTION_SCHEMA, automation.ApplyCall(_call)
+    )

esphome/components/st7735/__init__.py

@@ -7,4 +7,5 @@ st7735_ns = cg.esphome_ns.namespace("st7735")
 DEPRECATED_COMPONENT = """
 The 'st7735' component is deprecated and no new models will be added to it.
 New model PRs should target the newer and more performant 'mipi_spi' component.
+It will be removed in ESPHome 2027.5.0.
 """

esphome/components/st7735/display.py

@@ -92,8 +92,10 @@ async def setup_st7735(var: MockObj, config: ConfigType) -> None:
 
 
 async def to_code(config: ConfigType) -> None:
+    # Remove before 2027.5.0
     LOGGER.warning(
-        "The 'st7735' component is deprecated, it is recommended to use 'mipi_spi' instead."
+        "The 'st7735' component is deprecated and will be removed in ESPHome 2027.5.0, "
+        "migrate to 'mipi_spi' instead."
     )
     var = cg.new_Pvariable(
         config[CONF_ID],

esphome/components/st7789v/__init__.py

@@ -7,4 +7,5 @@ st7789v_ns = cg.esphome_ns.namespace("st7789v")
 DEPRECATED_COMPONENT = """
 The 'st7789v' component is deprecated and no new functionality will be added to it.
 PRs should target the newer and more performant 'mipi_spi' component.
+It will be removed in ESPHome 2027.5.0.
 """

esphome/components/st7789v/display.py

@@ -183,8 +183,10 @@ FINAL_VALIDATE_SCHEMA = spi.final_validate_device_schema(
 
 
 async def to_code(config: ConfigType) -> None:
+    # Remove before 2027.5.0
     LOGGER.warning(
-        "The 'st7789v' component is deprecated, it is recommended to use 'mipi_spi' instead."
+        "The 'st7789v' component is deprecated and will be removed in ESPHome 2027.5.0, "
+        "migrate to 'mipi_spi' instead."
     )
     var = cg.new_Pvariable(config[CONF_ID])
     await display.register_display(var, config)

esphome/components/sy6970/__init__.py

@@ -17,12 +17,22 @@ CONF_CHARGE_CURRENT = "charge_current"
 CONF_PRECHARGE_CURRENT = "precharge_current"
 CONF_CHARGE_ENABLED = "charge_enabled"
 CONF_ENABLE_ADC = "enable_adc"
+CONF_I2C_WATCHDOG_TIMEOUT = "i2c_watchdog_timeout"
 
 sy6970_ns = cg.esphome_ns.namespace("sy6970")
 SY6970Component = sy6970_ns.class_(
     "SY6970Component", cg.PollingComponent, i2c.I2CDevice
 )
 SY6970Listener = sy6970_ns.class_("SY6970Listener")
+I2CWatchdogTimeout = sy6970_ns.enum("I2CWatchdogTimeout")
+
+# REG07[5:4]; the component kicks the watchdog itself, so the chip's 40S default can stay on
+I2C_WATCHDOG_TIMEOUTS = {
+    "DISABLED": I2CWatchdogTimeout.I2C_WATCHDOG_DISABLED,
+    "40S": I2CWatchdogTimeout.I2C_WATCHDOG_40S,
+    "80S": I2CWatchdogTimeout.I2C_WATCHDOG_80S,
+    "160S": I2CWatchdogTimeout.I2C_WATCHDOG_160S,
+}
 
 CONFIG_SCHEMA = (
     cv.Schema(
@@ -43,6 +53,9 @@ CONFIG_SCHEMA = (
             ),
             cv.Optional(CONF_CHARGE_ENABLED, default=True): cv.boolean,
             cv.Optional(CONF_ENABLE_ADC, default=True): cv.boolean,
+            cv.Optional(CONF_I2C_WATCHDOG_TIMEOUT, default="40S"): cv.enum(
+                I2C_WATCHDOG_TIMEOUTS, upper=True
+            ),
         }
     )
     .extend(cv.polling_component_schema("5s"))
@@ -60,6 +73,7 @@ async def to_code(config: ConfigType) -> None:
         config[CONF_PRECHARGE_CURRENT],
         config[CONF_CHARGE_ENABLED],
         config[CONF_ENABLE_ADC],
+        config[CONF_I2C_WATCHDOG_TIMEOUT],
     )
     await cg.register_component(var, config)
     await i2c.register_i2c_device(var, config)

esphome/components/sy6970/sy6970.cpp

@@ -6,6 +6,25 @@ namespace esphome::sy6970 {
 
 ESPHOME_LOG_TAG(TAG, "sy6970");
 
+static const LogString *i2c_watchdog_timeout_to_string(I2CWatchdogTimeout timeout) {
+  switch (timeout) {
+    case I2C_WATCHDOG_DISABLED:
+      return LOG_STR("Disabled");
+    case I2C_WATCHDOG_40S:
+      return LOG_STR("40s");
+    case I2C_WATCHDOG_80S:
+      return LOG_STR("80s");
+    case I2C_WATCHDOG_160S:
+      return LOG_STR("160s");
+    default:
+      return LOG_STR("Unknown");
+  }
+}
+
+static constexpr uint32_t I2C_WATCHDOG_KICK_INTERVAL_ID = 0;
+// Well under the 40 s default, so a failed kick or a timeout the chip did not accept still leaves margin
+static constexpr uint32_t I2C_WATCHDOG_KICK_INTERVAL_MS = 10000;
+
 bool SY6970Component::read_all_registers_() {
   // Read all registers from 0x00 to 0x14 in one transaction (21 bytes)
   // This includes unused registers 0x0F, 0x10 for performance
@@ -51,6 +70,11 @@ void SY6970Component::setup() {
     ESP_LOGW(TAG, "Unexpected chip ID: 0x%02X (expected 0x00)", chip_id);
   }
 
+  // Service the watchdog first, so the settings below are not reverted while they are written
+  ESP_LOGV(TAG, "Setting I2C watchdog timeout to %s",
+           LOG_STR_ARG(i2c_watchdog_timeout_to_string(this->i2c_watchdog_timeout_)));
+  this->set_i2c_watchdog_timeout(this->i2c_watchdog_timeout_);
+
   // Apply configuration options (all have defaults now)
   ESP_LOGV(TAG, "Setting LED enabled to %s", ONOFF(this->led_enabled_));
   this->set_led_enabled(this->led_enabled_);
@@ -85,9 +109,11 @@ void SY6970Component::dump_config() {
                 "  Charge Current: %u mA\n"
                 "  Precharge Current: %u mA\n"
                 "  Charge Enabled: %s\n"
-                "  ADC Enabled: %s",
+                "  ADC Enabled: %s\n"
+                "  I2C Watchdog Timeout: %s",
                 ONOFF(this->led_enabled_), this->input_current_limit_, this->charge_voltage_, this->charge_current_,
-                this->precharge_current_, ONOFF(this->charge_enabled_), ONOFF(this->enable_adc_));
+                this->precharge_current_, ONOFF(this->charge_enabled_), ONOFF(this->enable_adc_),
+                LOG_STR_ARG(i2c_watchdog_timeout_to_string(this->i2c_watchdog_timeout_)));
   LOG_I2C_DEVICE(this);
   LOG_UPDATE_INTERVAL(this);
   if (this->is_failed()) {
@@ -198,4 +224,44 @@ void SY6970Component::set_enable_adc_measure(bool enabled) {
   this->update_register_(SY6970_REG_ADC_CONTROL, 0xC0, enabled ? 0xC0 : 0x00);
 }
 
+void SY6970Component::set_i2c_watchdog_timeout(I2CWatchdogTimeout timeout) {
+  if (this->is_failed())
+    return;
+
+  if (timeout != I2C_WATCHDOG_DISABLED) {
+    // Changing the timeout does not restart the chip's timer, which may be close to expiring
+    this->reset_i2c_watchdog();
+  }
+
+  // REG07 bits 5:4 (WATCHDOG[1:0])
+  bool written = this->update_register_(SY6970_REG_TIMER_CONTROL, 0x30, static_cast<uint8_t>(timeout) << 4);
+  if (!written) {
+    ESP_LOGW(TAG, "Failed to set I2C watchdog timeout to %s", LOG_STR_ARG(i2c_watchdog_timeout_to_string(timeout)));
+  }
+
+  if (timeout == I2C_WATCHDOG_DISABLED && written) {
+    this->i2c_watchdog_timeout_ = timeout;
+    this->cancel_interval(I2C_WATCHDOG_KICK_INTERVAL_ID);
+    return;
+  }
+  if (timeout != I2C_WATCHDOG_DISABLED) {
+    this->i2c_watchdog_timeout_ = timeout;
+  }
+  // Keeps kicking after a failed write too: the chip may still be on its 40 s default
+  this->set_interval(I2C_WATCHDOG_KICK_INTERVAL_ID, I2C_WATCHDOG_KICK_INTERVAL_MS,
+                     [this]() { this->reset_i2c_watchdog(); });
+}
+
+bool SY6970Component::reset_i2c_watchdog() {
+  if (this->is_failed())
+    return false;
+
+  // WD_RST, self-clearing
+  if (!this->update_register_(SY6970_REG_SYS_CONTROL, 0x40, 0x40)) {
+    ESP_LOGW(TAG, "I2C watchdog reset failed, settings may revert");
+    return false;
+  }
+  return true;
+}
+
 }  // namespace esphome::sy6970

esphome/components/sy6970/sy6970.h

@@ -62,6 +62,15 @@ enum ChargeStatus {
   CHARGE_STATUS_CHARGE_DONE = 3,
 };
 
+// REG07[5:4]. When the watchdog elapses the chip reverts CHG_CONFIG and STAT_DIS to their defaults,
+// so an enabled watchdog is kicked on its own interval.
+enum I2CWatchdogTimeout {
+  I2C_WATCHDOG_DISABLED = 0,
+  I2C_WATCHDOG_40S = 1,
+  I2C_WATCHDOG_80S = 2,
+  I2C_WATCHDOG_160S = 3,
+};
+
 // Structure to hold all register data read in one transaction
 struct SY6970Data {
   uint8_t registers[21];  // Registers 0x00-0x14 (includes unused 0x0F, 0x10)
@@ -76,14 +85,16 @@ class SY6970Listener {
 class SY6970Component final : public PollingComponent, public i2c::I2CDevice {
  public:
   SY6970Component(bool led_enabled, uint16_t input_current_limit, uint16_t charge_voltage, uint16_t charge_current,
-                  uint16_t precharge_current, bool charge_enabled, bool enable_adc)
+                  uint16_t precharge_current, bool charge_enabled, bool enable_adc,
+                  I2CWatchdogTimeout i2c_watchdog_timeout)
       : led_enabled_(led_enabled),
         input_current_limit_(input_current_limit),
         charge_voltage_(charge_voltage),
         charge_current_(charge_current),
         precharge_current_(precharge_current),
         charge_enabled_(charge_enabled),
-        enable_adc_(enable_adc) {}
+        enable_adc_(enable_adc),
+        i2c_watchdog_timeout_(i2c_watchdog_timeout) {}
   void setup() override;
   void dump_config() override;
   void update() override;
@@ -99,6 +110,10 @@ class SY6970Component final : public PollingComponent, public i2c::I2CDevice {
   void set_charge_enabled(bool enabled);
   void set_led_enabled(bool enabled);
   void set_enable_adc_measure(bool enabled = true);
+  void set_i2c_watchdog_timeout(I2CWatchdogTimeout timeout);
+
+  /// Kick the I2C watchdog (REG03 bit 6); runs on its own interval while enabled. Returns false when not written.
+  bool reset_i2c_watchdog();
 
  protected:
   bool read_all_registers_();
@@ -116,6 +131,7 @@ class SY6970Component final : public PollingComponent, public i2c::I2CDevice {
   uint16_t precharge_current_;
   bool charge_enabled_;
   bool enable_adc_;
+  I2CWatchdogTimeout i2c_watchdog_timeout_;
 };
 
 }  // namespace esphome::sy6970

esphome/components/tmp102/text_sensor.py

@@ -0,0 +1,31 @@
+"""TMP102 threshold status entity."""
+
+import esphome.codegen as cg
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import ENTITY_CATEGORY_DIAGNOSTIC
+from esphome.types import ConfigType
+
+from . import CONF_TMP102_ID, TMP102Component, validate_unique_child
+
+CONFIG_SCHEMA = text_sensor.text_sensor_schema(
+    entity_category=ENTITY_CATEGORY_DIAGNOSTIC
+).extend(
+    {
+        cv.GenerateID(CONF_TMP102_ID): cv.use_id(TMP102Component),
+    }
+)
+
+
+def _final_validate(config: ConfigType) -> ConfigType:
+    return validate_unique_child(config, "text_sensor")
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
+async def to_code(config: ConfigType) -> None:
+    cg.add_define("USE_TMP102_TEXT_SENSOR")
+    parent = await cg.get_variable(config[CONF_TMP102_ID])
+    var = await text_sensor.new_text_sensor(config)
+    cg.add(parent.set_threshold_status_text_sensor(var))

esphome/components/tmp102/tmp102.cpp

@@ -1,8 +1,14 @@
 #include "tmp102.h"
 #include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#ifdef USE_TMP102_TEXT_SENSOR
+#include "esphome/core/progmem.h"
+#endif
 
 #include <cmath>
+#ifdef USE_TMP102_TEXT_SENSOR
+#include <cstdio>
+#endif
 
 namespace esphome::tmp102 {
 
@@ -12,6 +18,30 @@ static constexpr uint32_t READ_TEMP_TIMEOUT_ID = 0;
 
 static constexpr uint8_t TMP102_REGISTER_TEMPERATURE = 0x00;
 static constexpr float TMP102_CONVERSION_FACTOR = 0.0625f;
+
+enum TMP102ThresholdStatus : uint8_t {
+  TMP102_THRESHOLD_STATUS_NOT_CONFIGURED,
+  TMP102_THRESHOLD_STATUS_SETUP_FAILED,
+  TMP102_THRESHOLD_STATUS_OK,
+  TMP102_THRESHOLD_STATUS_RESTORE_RESET,
+  TMP102_THRESHOLD_STATUS_RESTORE_RESET_SAVE_FAILED,
+  TMP102_THRESHOLD_STATUS_PREFERENCE_SAVE_FAILED,
+  TMP102_THRESHOLD_STATUS_RECOVERY_FAILED,
+  TMP102_THRESHOLD_STATUS_RECOVERED,
+  TMP102_THRESHOLD_STATUS_WRITE_HIGH_FAILED,
+  TMP102_THRESHOLD_STATUS_WRITE_LOW_FAILED,
+  TMP102_THRESHOLD_STATUS_SENSOR_SETUP_FAILED,
+  TMP102_THRESHOLD_STATUS_COUNT,
+};
+
+#ifdef USE_TMP102_TEXT_SENSOR
+PROGMEM_STRING_TABLE(ThresholdStatusStrings, "Not configured", "Setup failed", "OK", "Restored thresholds reset",
+                     "Restore reset; save failed", "Preference save failed", "Configuration recovery failed",
+                     "Configuration restored", "Write failed: high threshold", "Write failed: low threshold",
+                     "Rejected: sensor setup failed");
+static_assert(ThresholdStatusStrings::COUNT == TMP102_THRESHOLD_STATUS_COUNT);
+#endif
+
 #if defined(USE_TMP102_CONFIGURE) || defined(USE_TMP102_BINARY_SENSOR)
 static constexpr uint8_t TMP102_REGISTER_CONFIGURATION = 0x01;
 static constexpr uint16_t TMP102_ALERT_BIT = 0x0020;
@@ -42,15 +72,30 @@ static uint16_t encode_temperature(float temperature, bool extended) {
   return static_cast<uint16_t>(static_cast<uint32_t>(static_cast<uint16_t>(steps)) << (extended ? 3 : 4));
 }
 #endif
+#endif
 
+#if defined(USE_TMP102_CONFIGURE) || defined(USE_TMP102_TEXT_SENSOR)
 void TMP102Component::setup() {
-  if (!this->configure_)
+#ifdef USE_TMP102_CONFIGURE
+  if (this->configure_) {
+    this->setup_configured_();
     return;
+  }
+#endif
+  this->publish_threshold_status_(TMP102_THRESHOLD_STATUS_NOT_CONFIGURED);
+}
+#endif
+
+#ifdef USE_TMP102_CONFIGURE
+void TMP102Component::setup_configured_() {
+  bool corrected = false;
 #ifdef USE_TMP102_NUMBER
   float restored[2]{};
-  this->prepare_number_limits_(restored);
+  bool restore_corrected[2]{};
+  corrected = this->prepare_number_limits_(restored, restore_corrected);
 #endif
   if (!this->write_configuration_()) {
+    this->publish_threshold_status_(TMP102_THRESHOLD_STATUS_SETUP_FAILED);
     this->mark_failed();
     return;
   }
@@ -61,14 +106,17 @@ void TMP102Component::setup() {
     if (control == nullptr)
       continue;
     const float value = this->get_limit_temperature_(static_cast<TMP102LimitType>(limit));
-    if (value != restored[limit])
+    if (restore_corrected[limit] || value != restored[limit])
       saved &= control->save_value_(value);
     control->publish_state(value);
   }
   if (!saved) {
     ESP_LOGW(TAG, "Failed to save threshold preferences");
+    this->publish_threshold_status_(TMP102_THRESHOLD_STATUS_RESTORE_RESET_SAVE_FAILED);
+    return;
   }
 #endif
+  this->publish_threshold_status_(corrected ? TMP102_THRESHOLD_STATUS_RESTORE_RESET : TMP102_THRESHOLD_STATUS_OK);
 }
 #endif
 
@@ -83,6 +131,9 @@ void TMP102Component::dump_config() {
 #ifdef USE_TMP102_BINARY_SENSOR
   LOG_BINARY_SENSOR("  ", "Alert", this->alert_binary_sensor_);
 #endif
+#ifdef USE_TMP102_TEXT_SENSOR
+  LOG_TEXT_SENSOR("  ", "Threshold Status", this->threshold_status_text_sensor_);
+#endif
 #ifdef USE_TMP102_CONFIGURE
   if (!this->configure_)
     return;
@@ -203,6 +254,9 @@ bool TMP102Component::check_configuration_() {
   this->set_warning_and_invalidate_alert_();
   if (!this->write_configuration_()) {
     ESP_LOGW(TAG, "Failed to restore configuration and thresholds");
+    this->publish_threshold_status_(TMP102_THRESHOLD_STATUS_RECOVERY_FAILED);
+  } else {
+    this->publish_threshold_status_(TMP102_THRESHOLD_STATUS_RECOVERED);
   }
   return false;
 }
@@ -228,22 +282,25 @@ void TMP102Component::set_limit_control(TMP102LimitNumber *number) {
   this->limit_controls_[number->limit_type_] = number;
 }
 
-void TMP102Component::prepare_number_limits_(float *restored) {
+bool TMP102Component::prepare_number_limits_(float *restored, bool *restore_corrected) {
   const bool extended = this->config_ & TMP102_EXTENDED_MODE_BIT;
   uint16_t raw[2] = {this->low_limit_, this->high_limit_};
+  bool corrected = false;
   for (uint8_t limit = 0; limit < 2; ++limit) {
     TMP102LimitNumber *control = this->limit_controls_[limit];
     if (control == nullptr)
       continue;
-    restored[limit] = control->load_value_(decode_temperature(raw[limit], extended));
+    restored[limit] = control->load_value_(decode_temperature(raw[limit], extended), restore_corrected[limit]);
+    corrected |= restore_corrected[limit];
     raw[limit] = encode_temperature(restored[limit], extended);
   }
   if (static_cast<int16_t>(raw[TMP102_LIMIT_LOW]) > static_cast<int16_t>(raw[TMP102_LIMIT_HIGH])) {
     ESP_LOGW(TAG, "Restored thresholds are inverted; using configured values");
-    return;
+    return true;
   }
   this->low_limit_ = raw[TMP102_LIMIT_LOW];
   this->high_limit_ = raw[TMP102_LIMIT_HIGH];
+  return corrected;
 }
 
 float TMP102Component::get_limit_temperature_(TMP102LimitType limit) const {
@@ -261,10 +318,13 @@ bool TMP102Component::set_limit_temperature_(TMP102LimitType limit, float temper
     ESP_LOGW(TAG, "Rejected %s threshold %.4f°C: crosses %s threshold %.4f°C",
              high ? LOG_STR_LITERAL("high") : LOG_STR_LITERAL("low"), decode_temperature(raw, extended),
              high ? LOG_STR_LITERAL("low") : LOG_STR_LITERAL("high"), decode_temperature(other, extended));
+    this->publish_threshold_rejection_(high, decode_temperature(raw, extended), decode_temperature(other, extended));
     return false;
   }
   if (!this->write_register_(static_cast<uint8_t>(TMP102_REGISTER_LOW_LIMIT + limit), raw)) {
     this->status_set_warning();
+    this->publish_threshold_status_(high ? TMP102_THRESHOLD_STATUS_WRITE_HIGH_FAILED
+                                         : TMP102_THRESHOLD_STATUS_WRITE_LOW_FAILED);
     return false;
   }
   (high ? this->high_limit_ : this->low_limit_) = raw;
@@ -273,6 +333,32 @@ bool TMP102Component::set_limit_temperature_(TMP102LimitType limit, float temper
 #endif
 #endif
 
+#ifdef USE_TMP102_TEXT_SENSOR
+void TMP102Component::publish_threshold_status_(uint8_t status) {
+  if (this->threshold_status_text_sensor_ == nullptr)
+    return;
+  char text[40];
+  ESPHOME_strncpy_P(
+      text,
+      reinterpret_cast<ESPHOME_PGM_P>(ThresholdStatusStrings::get_progmem_str(status, TMP102_THRESHOLD_STATUS_OK)),
+      sizeof(text));
+  text[sizeof(text) - 1] = '\0';
+  this->threshold_status_text_sensor_->publish_state(text);
+}
+
+void TMP102Component::publish_threshold_rejection_(bool high, float value, float other) {
+  if (this->threshold_status_text_sensor_ == nullptr)
+    return;
+  char text[96];
+  if (high) {
+    ESPHOME_snprintf_P(text, sizeof(text), ESPHOME_PSTR("Rejected: high %.4f°C crosses low %.4f°C"), value, other);
+  } else {
+    ESPHOME_snprintf_P(text, sizeof(text), ESPHOME_PSTR("Rejected: low %.4f°C crosses high %.4f°C"), value, other);
+  }
+  this->threshold_status_text_sensor_->publish_state(text);
+}
+#endif
+
 #ifdef USE_TMP102_BINARY_SENSOR
 void TMP102Component::invalidate_alert_() {
   if (this->alert_binary_sensor_ != nullptr)
@@ -294,7 +380,7 @@ bool TMP102Component::read_alert_state_() {
 #endif
 
 #ifdef USE_TMP102_NUMBER
-float TMP102LimitNumber::load_value_(float fallback) {
+float TMP102LimitNumber::load_value_(float fallback, bool &corrected) {
   float value = fallback;
   if (this->restore_value_) {
     this->pref_ = this->make_entity_preference<float>();
@@ -303,6 +389,7 @@ float TMP102LimitNumber::load_value_(float fallback) {
   if (!std::isfinite(value) || value < this->traits.get_min_value() || value > this->traits.get_max_value()) {
     ESP_LOGW(TAG, "Invalid restored threshold; using configured value");
     value = fallback;
+    corrected = true;
   }
   return value;
 }
@@ -313,6 +400,7 @@ void TMP102LimitNumber::control(float value) {
   // A chip that failed setup holds nothing the entity could show
   if (this->parent_->is_failed()) {
     ESP_LOGW(TAG, "Rejected threshold change: sensor setup failed");
+    this->parent_->publish_threshold_status_(TMP102_THRESHOLD_STATUS_SENSOR_SETUP_FAILED);
     return;
   }
   const bool accepted = this->parent_->set_limit_temperature_(this->limit_type_, value);
@@ -320,6 +408,9 @@ void TMP102LimitNumber::control(float value) {
   this->publish_state(value);
   if (accepted && !this->save_value_(value)) {
     ESP_LOGW(TAG, "Failed to save threshold preference");
+    this->parent_->publish_threshold_status_(TMP102_THRESHOLD_STATUS_PREFERENCE_SAVE_FAILED);
+  } else if (accepted) {
+    this->parent_->publish_threshold_status_(TMP102_THRESHOLD_STATUS_OK);
   }
 }
 #endif

esphome/components/tmp102/tmp102.h

@@ -12,11 +12,20 @@
 #include "esphome/core/preferences.h"
 #endif
 #include "esphome/components/sensor/sensor.h"
+#ifdef USE_TMP102_TEXT_SENSOR
+#include "esphome/components/text_sensor/text_sensor.h"
+#endif
 
 #include <cstdint>
 
 namespace esphome::tmp102 {
 
+#ifdef USE_HOST
+namespace testing {
+class TMP102Test;
+}
+#endif
+
 #ifdef USE_TMP102_NUMBER
 enum TMP102LimitType : uint8_t {
   TMP102_LIMIT_LOW = 0,
@@ -31,8 +40,13 @@ class TMP102Component final : public PollingComponent, public i2c::I2CDevice, pu
 #ifdef USE_TMP102_BINARY_SENSOR
   SUB_BINARY_SENSOR(alert)
 #endif
-#ifdef USE_TMP102_CONFIGURE
+#ifdef USE_TMP102_TEXT_SENSOR
+  SUB_TEXT_SENSOR(threshold_status)
+#endif
+#if defined(USE_TMP102_CONFIGURE) || defined(USE_TMP102_TEXT_SENSOR)
   void setup() override;
+#endif
+#ifdef USE_TMP102_CONFIGURE
   void set_configuration(uint16_t config, uint16_t high_limit, uint16_t low_limit) {
     this->config_ = config;
     this->high_limit_ = high_limit;
@@ -47,6 +61,13 @@ class TMP102Component final : public PollingComponent, public i2c::I2CDevice, pu
   void update() override;
 
  protected:
+#ifdef USE_TMP102_TEXT_SENSOR
+  void publish_threshold_status_(uint8_t status);
+  void publish_threshold_rejection_(bool high, float value, float other);
+#else
+  void publish_threshold_status_(uint8_t) {}
+  void publish_threshold_rejection_(bool, float, float) {}
+#endif
   void set_warning_and_invalidate_alert_() {
     this->status_set_warning();
 #ifdef USE_TMP102_BINARY_SENSOR
@@ -58,6 +79,7 @@ class TMP102Component final : public PollingComponent, public i2c::I2CDevice, pu
   void invalidate_alert_();
 #endif
 #ifdef USE_TMP102_CONFIGURE
+  void setup_configured_();
   bool write_register_(uint8_t reg, uint16_t value);
   bool write_configuration_();
   bool check_configuration_();
@@ -67,11 +89,10 @@ class TMP102Component final : public PollingComponent, public i2c::I2CDevice, pu
   friend class TMP102LimitNumber;
   bool set_limit_temperature_(TMP102LimitType limit, float temperature);
   float get_limit_temperature_(TMP102LimitType limit) const;
-  void prepare_number_limits_(float *restored);
+  bool prepare_number_limits_(float *restored, bool *restore_corrected);
 
   TMP102LimitNumber *limit_controls_[2]{};
 #endif
-
   uint16_t config_{0};
   uint16_t high_limit_{0};
   uint16_t low_limit_{0};
@@ -87,7 +108,10 @@ class TMP102LimitNumber final : public number::Number, public Parented<TMP102Com
 
  protected:
   friend class TMP102Component;
-  float load_value_(float fallback);
+#ifdef USE_HOST
+  friend class testing::TMP102Test;
+#endif
+  float load_value_(float fallback, bool &corrected);
   bool save_value_(float value);
   void control(float value) override;
 

esphome/components/zigbee/zigbee_zephyr.py

@@ -1,4 +1,4 @@
-import datetime
+import datetime as dt
 import random
 
 import esphome.codegen as cg
@@ -176,7 +176,7 @@ async def _attr_to_code(config: ConfigType) -> None:
             basic_attrs.date_code,
             # Local build time, matching the esp32 implementation
             # (App.get_build_time() in C++).
-            datetime.datetime.now().astimezone().strftime("%Y%m%d %H%M%S"),
+            dt.datetime.now().astimezone().strftime("%Y%m%d %H%M%S"),
         ),
         zigbee_assign(
             basic_attrs.power_source,

esphome/core/defines.h

@@ -217,6 +217,7 @@
 #define TCA8418_LISTENER_COUNT 1
 #define USE_MEDIA_PLAYER
 #define USE_MEDIA_SOURCE
+#define NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT 1
 #define USE_NETWORK
 #define USE_NETWORK_DEFAULT_ROUTE
 #define USE_NETWORK_PRIMARY_INTERFACE_WIFI
@@ -271,6 +272,7 @@
 #define USE_TMP102_BINARY_SENSOR
 #define USE_TMP102_CONFIGURE
 #define USE_TMP102_NUMBER
+#define USE_TMP102_TEXT_SENSOR
 #define USE_TOUCHSCREEN
 #define USE_UART_DEBUGGER
 #define USE_UART_WAKE_LOOP_ON_RX
@@ -437,11 +439,6 @@
 #define USE_ESP32_BLE_TRACKER
 #define USE_ESP32_BLE_TRACKER_DIRECT_CONN_GUARD
 #define USE_BLE_GATT_CLIENT
-#define USE_BLE_GATT_BACKEND_BLUEDROID
-#define USE_BLUEDROID_GATT_SERVICE_TABLE
-#define USE_BLE_CLIENT_GATT_NODES
-#define USE_BLE_CLIENT_LEGACY_ENGINE
-#define ESPHOME_BLE_CLIENT_MAX_NODES 1
 #define ESPHOME_BLE_GATT_CLIENT_COUNT 1
 #define ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT 1
 #define ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT 1
@@ -572,6 +569,10 @@
 #endif
 #ifndef USE_OPENTHREAD
 #define USE_MDNS_SUPPORTS_ENABLE_DISABLE
+#ifdef USE_ETHERNET
+#define USE_MDNS_ACTIVE_INTERFACE_LISTENER
+#define USE_MDNS_DYNAMIC_NETWORK_TXT
+#endif
 #endif
 #endif
 
@@ -642,10 +643,7 @@
 #define ESPHOME_BLE_DEVICE_BASE_LISTENER_COUNT 1
 #define USE_BLE_SCAN_RESPONSE_MERGER
 #define USE_BLE_GATT_CLIENT
-#define USE_BLE_GATT_BACKEND_RP2
-#define USE_BLE_CLIENT_GATT_NODES
 #define ESPHOME_BLE_GATT_CLIENT_COUNT 3
-#define ESPHOME_BLE_CLIENT_MAX_NODES 1
 #define USE_RP2040_VARIANT_RP2040
 #define USE_SPI
 #ifndef USE_ETHERNET
@@ -655,6 +653,7 @@
 #define USE_ETHERNET_SPI
 #endif
 #define USE_ETHERNET_W5500
+#define USE_MDNS_DYNAMIC_NETWORK_TXT
 #define USE_WIFI_IP_STATE_LISTENERS
 #define ESPHOME_WIFI_IP_STATE_LISTENERS 2
 #define USE_ETHERNET_IP_STATE_LISTENERS

esphome/core/progmem.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <algorithm>
 #include <array>
 #include <cstddef>
 #include <cstdint>
@@ -68,6 +69,7 @@ template<size_t N> struct FixedString {
 };
 
 /// Compile-time string table that packs strings into a single blob with offset lookup.
+/// Blobs over 255 bytes have no offsets and are scanned, so keep those for rarely read strings.
 /// Use PROGMEM_STRING_TABLE macro to instantiate with proper flash placement on ESP8266.
 ///
 /// Example:
@@ -78,6 +80,11 @@ template<size_t N> struct FixedString {
 template<FixedString... Strs> struct ProgmemStringTable {
   static constexpr size_t COUNT = sizeof...(Strs);
   static constexpr size_t BLOB_SIZE = (0 + ... + (Strs.size() + 1));
+  /// Length of the longest string, for sizing a RAM copy on ESP8266
+  static constexpr size_t MAX_LENGTH = std::max({Strs.size()...});
+  /// One-byte offsets address up to 255 bytes; a larger blob has no offset table and is scanned instead,
+  /// which costs less flash than wider offsets for the rarely read tables that get this big.
+  static constexpr bool INDEXED = BLOB_SIZE <= UINT8_MAX;
 
   /// Generate packed string blob at compile time
   static constexpr auto make_blob() {
@@ -91,18 +98,28 @@ template<FixedString... Strs> struct ProgmemStringTable {
     return result;
   }
 
-  /// Generate offset table at compile time (uint8_t limits blob to 255 bytes)
+  /// Generate offset table at compile time
   static constexpr auto make_offsets() {
     static_assert(COUNT > 0, "PROGMEM_STRING_TABLE must contain at least one string");
     static_assert(COUNT <= 255, "PROGMEM_STRING_TABLE supports at most 255 strings with uint8_t indices");
-    static_assert(BLOB_SIZE <= 255, "PROGMEM_STRING_TABLE blob exceeds 255 bytes; use fewer/shorter strings");
-    std::array<uint8_t, COUNT> result{};
-    size_t pos = 0, idx = 0;
-    ((result[idx++] = static_cast<uint8_t>(pos), pos += Strs.size() + 1), ...);
-    return result;
+    if constexpr (INDEXED) {
+      std::array<uint8_t, COUNT> result{};
+      size_t pos = 0, idx = 0;
+      ((result[idx++] = static_cast<uint8_t>(pos), pos += Strs.size() + 1), ...);
+      return result;
+    } else {
+      return std::array<uint8_t, 0>{};
+    }
   }
 };
 
+/// Skip idx strings in a packed NUL-separated blob that may live in flash.
+inline const char *progmem_skip_strings(const char *blob, uint8_t idx) {
+  while (idx-- > 0)
+    blob += ESPHOME_strlen_P(blob) + 1;
+  return blob;
+}
+
 // Forward declaration for LogString (defined in log.h)
 struct LogString;
 
@@ -115,6 +132,7 @@ struct LogString;
     static constexpr size_t COUNT = Table::COUNT; \
     static constexpr uint8_t LAST_INDEX = COUNT - 1; \
     static constexpr size_t BLOB_SIZE = Table::BLOB_SIZE; \
+    static constexpr size_t MAX_LENGTH = Table::MAX_LENGTH; \
     static constexpr auto BLOB ESPHOME_PROGMEM_STRING_TABLE_STORAGE = Table::make_blob(); \
     static constexpr auto OFFSETS ESPHOME_PROGMEM_STRING_TABLE_STORAGE = Table::make_offsets(); \
     static const char *get_(uint8_t idx, uint8_t fallback) { \
@@ -122,7 +140,10 @@ struct LogString;
         idx = fallback; \
       /* std::launder is used here to prevent the inter-procedural analysis that */ \
       /* causes the false positive that the string is not null terminated */ \
-      return std::launder(&BLOB[::esphome::progmem_read_byte(&OFFSETS[idx])]); \
+      if constexpr (Table::INDEXED) \
+        return std::launder(&BLOB[::esphome::progmem_read_byte(&OFFSETS[idx])]); \
+      else \
+        return std::launder(::esphome::progmem_skip_strings(BLOB.data(), idx)); \
     } \
     static ::ProgmemStr get_progmem_str(uint8_t idx, uint8_t fallback) { \
       return reinterpret_cast<::ProgmemStr>(get_(idx, fallback)); \

requirements.txt

@@ -10,7 +10,7 @@ tzlocal==5.4.4    # from time
 tzdata>=2026.5  # from time
 pyserial==3.5
 platformio==6.2.0
-esptool==5.4.0
+esptool==5.5.0
 click==8.5.0
 aioesphomeapi==46.10.0
 aiohappyeyeballs==2.7.1  # Happy Eyeballs for requests downloads; already pulled in by aioesphomeapi
@@ -19,7 +19,7 @@ puremagic==2.2.0
 ruamel.yaml==0.19.1 # dashboard_import
 ruamel.yaml.clib==0.2.15 # dashboard_import
 esphome-glyphsets==0.2.0
-backports.zstd==1.7.0; python_version < "3.14"  # esphome.helpers.zstd_module; compression.zstd is in the standard library from 3.14
+backports.zstd==1.8.0; python_version < "3.14"  # esphome.helpers.zstd_module; compression.zstd is in the standard library from 3.14
 pillow==12.3.0
 resvg-py==0.5.0
 freetype-py==2.5.1
@@ -31,9 +31,9 @@ smp==4.2.0; platform_system != "Darwin" or platform_machine != "x86_64"
 smp==4.1.0; platform_system == "Darwin" and platform_machine == "x86_64"
 requests==2.34.2
 py7zr==1.1.3
-platformdirs==4.12.3  # native esp-idf toolchain global cache dir
+platformdirs==4.12.4  # native esp-idf toolchain global cache dir
 ninja==1.13.2  # native host and esp8266 arduino toolchain build driver
-filelock==4.0.12  # inter-process locks (PlatformIO cache heal, git clone cache); >=3.32 for FileLock(fallback_to_soft=...), older versions silently drop the kwarg
+filelock==4.1.0  # inter-process locks (PlatformIO cache heal, git clone cache); >=3.32 for FileLock(fallback_to_soft=...), older versions silently drop the kwarg
 
 # esp-idf >= 5.0 requires this
 pyparsing >= 3.3.3

requirements_test.txt

@@ -1,7 +1,7 @@
 pylint==4.1.2
 flake8==7.4.1  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
-ruff==0.16.10  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
-pyupgrade==3.21.2  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
+ruff==0.17.0  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
+pyupgrade==3.22.0  # .pre-commit-config.yaml rev synced by script/sync_dependency_versions.py
 prek==0.5.5  # .github/workflows/ci.yml reads this pin
 yamlrocks==0.6.1  # used by script/sync_dependency_versions.py
 

tests/benchmarks/components/display/__init__.py

@@ -0,0 +1,7 @@
+from tests.testing_helpers import ComponentManifestOverride, add_defines_to_code
+
+
+def override_manifest(manifest: ComponentManifestOverride) -> None:
+    # Loops that only exist on boards with PSRAM are gated on this define;
+    # set it so the host benchmark measures the same code those boards run.
+    add_defines_to_code(manifest, "USE_PSRAM")

tests/benchmarks/components/display/bench_draw_pixels_at.cpp

@@ -0,0 +1,82 @@
+#include <benchmark/benchmark.h>
+
+#include <cstdint>
+#include <memory>
+
+#include "esphome/components/display/display_buffer.h"
+
+namespace esphome::display::benchmarks {
+
+static constexpr int kWidth = 128;
+static constexpr int kHeight = 96;
+// Square frame so a rotated block stays inside it.
+static constexpr int kStride = kWidth > kHeight ? kWidth : kHeight;
+
+// A buffered display without its own draw_pixels_at(), so every block goes
+// through the base class fallback and the DisplayBuffer pixel path.
+class BenchDisplay : public DisplayBuffer {
+ public:
+  BenchDisplay() : frame_(std::make_unique<uint8_t[]>(kStride * kStride)) {}
+  void update() override {}
+  DisplayType get_display_type() override { return DisplayType::DISPLAY_TYPE_COLOR; }
+  int get_width_internal() override { return kStride; }
+  int get_height_internal() override { return kStride; }
+
+ protected:
+  void draw_absolute_pixel_internal(int x, int y, Color color) override { this->frame_[y * kStride + x] = color.r; }
+
+  std::unique_ptr<uint8_t[]> frame_;
+};
+
+// Deterministic pseudo random pixel bytes, sized for the widest format.
+static std::unique_ptr<uint8_t[]> make_pixels() {
+  constexpr size_t bytes = kWidth * kHeight * 3;
+  auto data = std::make_unique<uint8_t[]>(bytes);
+  uint32_t seed = 11897;
+  for (size_t i = 0; i < bytes; i++) {
+    seed = seed * 1103515245u + 12345u;
+    data[i] = static_cast<uint8_t>(seed >> 16);
+  }
+  return data;
+}
+
+// One full block the way LVGL hands a display its rendering.
+static void draw_block(benchmark::State &state, ColorBitness bitness, bool big_endian,
+                       DisplayRotation rotation = DISPLAY_ROTATION_0_DEGREES) {
+  auto data = make_pixels();
+  BenchDisplay display;
+  display.set_rotation(rotation);
+  for (auto _ : state) {
+    display.draw_pixels_at(0, 0, kWidth, kHeight, data.get(), COLOR_ORDER_RGB, bitness, big_endian, 0, 0, 0);
+  }
+  state.SetItemsProcessed(state.iterations() * kWidth * kHeight);
+}
+
+static void DrawPixelsAt_RGB565_BigEndian(benchmark::State &state) { draw_block(state, COLOR_BITNESS_565, true); }
+BENCHMARK(DrawPixelsAt_RGB565_BigEndian);
+
+static void DrawPixelsAt_RGB565_LittleEndian(benchmark::State &state) { draw_block(state, COLOR_BITNESS_565, false); }
+BENCHMARK(DrawPixelsAt_RGB565_LittleEndian);
+
+static void DrawPixelsAt_RGB888(benchmark::State &state) { draw_block(state, COLOR_BITNESS_888, true); }
+BENCHMARK(DrawPixelsAt_RGB888);
+
+static void DrawPixelsAt_RGB332(benchmark::State &state) { draw_block(state, COLOR_BITNESS_332, true); }
+BENCHMARK(DrawPixelsAt_RGB332);
+
+static void DrawPixelsAt_RGB565_Rotated(benchmark::State &state) {
+  draw_block(state, COLOR_BITNESS_565, true, DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(DrawPixelsAt_RGB565_Rotated);
+
+static void DrawPixelsAt_RGB888_Rotated(benchmark::State &state) {
+  draw_block(state, COLOR_BITNESS_888, true, DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(DrawPixelsAt_RGB888_Rotated);
+
+static void DrawPixelsAt_RGB332_Rotated(benchmark::State &state) {
+  draw_block(state, COLOR_BITNESS_332, true, DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(DrawPixelsAt_RGB332_Rotated);
+
+}  // namespace esphome::display::benchmarks

tests/benchmarks/components/image/__init__.py

@@ -0,0 +1,7 @@
+from tests.testing_helpers import ComponentManifestOverride, add_defines_to_code
+
+
+def override_manifest(manifest: ComponentManifestOverride) -> None:
+    # Loops that only exist on boards with PSRAM are gated on this define;
+    # set it so the host benchmark measures the same code those boards run.
+    add_defines_to_code(manifest, "USE_PSRAM")

tests/benchmarks/components/image/bench_image_draw.cpp

@@ -0,0 +1,245 @@
+#include <benchmark/benchmark.h>
+
+#include <cstdint>
+#include <cstring>
+#include <memory>
+
+#include "esphome/components/display/display_buffer.h"
+#include "esphome/components/image/image.h"
+
+namespace esphome::image::benchmarks {
+
+static constexpr int kWidth = 128;
+static constexpr int kHeight = 96;
+// Square frame so a rotated draw of the image stays inside it.
+static constexpr int kStride = kWidth > kHeight ? kWidth : kHeight;
+
+// One byte per pixel frame buffer with no hardware behind it, so the
+// measurement is Image::draw() plus the DisplayBuffer pixel path every
+// buffered display shares. Everything fits the host cache, so this counts
+// the per pixel work, not what a frame buffer in PSRAM costs.
+class BenchDisplay : public display::DisplayBuffer {
+ public:
+  BenchDisplay() : frame_(std::make_unique<uint8_t[]>(kStride * kStride)) {}
+  void update() override {}
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
+  int get_width_internal() override { return kStride; }
+  int get_height_internal() override { return kStride; }
+
+ protected:
+  void draw_absolute_pixel_internal(int x, int y, Color color) override { this->frame_[y * kStride + x] = color.r; }
+
+  std::unique_ptr<uint8_t[]> frame_;
+
+ public:
+  uint8_t pixel(int x, int y) const { return this->frame_[y * kStride + x]; }
+};
+
+// Models a driver with a bulk path: rows of little endian RGB565 are copied
+// straight into a 16 bit frame, as the TFT drivers do for their own format.
+// Image::draw() only reaches it once it hands opaque images to
+// draw_pixels_at(); until then this case matches ImageDraw_RGB565.
+class BulkBenchDisplay : public BenchDisplay {
+ public:
+  BulkBenchDisplay() : frame565_(std::make_unique<uint16_t[]>(kStride * kStride)) {}
+  void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
+                      display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override {
+    if (bitness != display::COLOR_BITNESS_565 || big_endian) {
+      BenchDisplay::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
+      return;
+    }
+    const size_t stride = x_offset + w + x_pad;
+    for (int y = 0; y < h; y++) {
+      memcpy(this->frame565_.get() + (y_start + y) * kStride + x_start, ptr + ((y_offset + y) * stride + x_offset) * 2,
+             w * 2);
+    }
+  }
+
+ protected:
+  std::unique_ptr<uint16_t[]> frame565_;
+};
+
+// Draws the image at rotation 0 and 90 and checks the second frame is the
+// transpose of the first, which is what a wrong traversal order would break.
+static bool frames_match(Image &image) {
+  BenchDisplay plain;
+  BenchDisplay rotated;
+  rotated.set_rotation(display::DISPLAY_ROTATION_90_DEGREES);
+  image.draw(0, 0, &plain, display::COLOR_ON, display::COLOR_OFF);
+  image.draw(0, 0, &rotated, display::COLOR_ON, display::COLOR_OFF);
+  for (int y = 0; y < kHeight; y++) {
+    for (int x = 0; x < kWidth; x++) {
+      // DisplayBuffer maps (x, y) to (width - y - 1, x) at 90 degrees
+      if (plain.pixel(x, y) != rotated.pixel(kStride - y - 1, x))
+        return false;
+    }
+  }
+  return true;
+}
+
+// Deterministic pseudo random pixel bytes so the alpha branch sees a mix of
+// pixels. Sized for the widest format, the image reads only what it needs.
+static std::unique_ptr<uint8_t[]> make_pixels() {
+  constexpr size_t bytes = kWidth * kHeight * 4;
+  auto data = std::make_unique<uint8_t[]>(bytes);
+  uint32_t seed = 11897;
+  for (size_t i = 0; i < bytes; i++) {
+    seed = seed * 1103515245u + 12345u;
+    data[i] = static_cast<uint8_t>(seed >> 16);
+  }
+  return data;
+}
+
+static void draw_image(benchmark::State &state, ImageType type, Transparency transparency,
+                       display::DisplayRotation rotation = display::DISPLAY_ROTATION_0_DEGREES) {
+  auto data = make_pixels();
+  Image image(data.get(), kWidth, kHeight, type, transparency);
+  BenchDisplay display;
+  display.set_rotation(rotation);
+  if (!frames_match(image)) {
+    state.SkipWithError("rotated draw is not the transpose of the plain draw");
+    return;
+  }
+
+  for (auto _ : state) {
+    image.draw(0, 0, &display, display::COLOR_ON, display::COLOR_OFF);
+  }
+  state.SetItemsProcessed(state.iterations() * kWidth * kHeight);
+}
+
+static void ImageDraw_Binary(benchmark::State &state) { draw_image(state, IMAGE_TYPE_BINARY, TRANSPARENCY_OPAQUE); }
+BENCHMARK(ImageDraw_Binary);
+
+static void ImageDraw_Grayscale(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_GRAYSCALE, TRANSPARENCY_OPAQUE);
+}
+BENCHMARK(ImageDraw_Grayscale);
+
+static void ImageDraw_RGB565(benchmark::State &state) { draw_image(state, IMAGE_TYPE_RGB565, TRANSPARENCY_OPAQUE); }
+BENCHMARK(ImageDraw_RGB565);
+
+static void ImageDraw_RGB(benchmark::State &state) { draw_image(state, IMAGE_TYPE_RGB, TRANSPARENCY_OPAQUE); }
+BENCHMARK(ImageDraw_RGB);
+
+// The same opaque RGB565 image on a display with a bulk path.
+static void ImageDraw_RGB565_Bulk(benchmark::State &state) {
+  auto data = make_pixels();
+  Image image(data.get(), kWidth, kHeight, IMAGE_TYPE_RGB565, TRANSPARENCY_OPAQUE);
+  BulkBenchDisplay display;
+  for (auto _ : state) {
+    image.draw(0, 0, &display, display::COLOR_ON, display::COLOR_OFF);
+  }
+  state.SetItemsProcessed(state.iterations() * kWidth * kHeight);
+}
+BENCHMARK(ImageDraw_RGB565_Bulk);
+
+static void ImageDraw_RGB_Rotated(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_RGB, TRANSPARENCY_OPAQUE, display::DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(ImageDraw_RGB_Rotated);
+
+static void ImageDraw_Binary_Transparent(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_BINARY, TRANSPARENCY_CHROMA_KEY);
+}
+BENCHMARK(ImageDraw_Binary_Transparent);
+
+static void ImageDraw_Grayscale_ChromaKey(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_GRAYSCALE, TRANSPARENCY_CHROMA_KEY);
+}
+BENCHMARK(ImageDraw_Grayscale_ChromaKey);
+
+static void ImageDraw_Grayscale_Alpha(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_GRAYSCALE, TRANSPARENCY_ALPHA_CHANNEL);
+}
+BENCHMARK(ImageDraw_Grayscale_Alpha);
+
+static void ImageDraw_RGB_Alpha(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_RGB, TRANSPARENCY_ALPHA_CHANNEL);
+}
+BENCHMARK(ImageDraw_RGB_Alpha);
+
+static void ImageDraw_RGB_ChromaKey(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_RGB, TRANSPARENCY_CHROMA_KEY);
+}
+BENCHMARK(ImageDraw_RGB_ChromaKey);
+
+static void ImageDraw_RGB565_ChromaKey(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_RGB565, TRANSPARENCY_CHROMA_KEY);
+}
+BENCHMARK(ImageDraw_RGB565_ChromaKey);
+
+static void ImageDraw_RGB565_Alpha(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_RGB565, TRANSPARENCY_ALPHA_CHANNEL);
+}
+BENCHMARK(ImageDraw_RGB565_Alpha);
+
+static void ImageDraw_RGB111(benchmark::State &state) { draw_image(state, IMAGE_TYPE_RGB111, TRANSPARENCY_OPAQUE); }
+BENCHMARK(ImageDraw_RGB111);
+
+static void ImageDraw_RGB111_Alpha(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_RGB111, TRANSPARENCY_ALPHA_CHANNEL);
+}
+BENCHMARK(ImageDraw_RGB111_Alpha);
+
+// The same cases with the display rotated 90 degrees, which walks the other loop order.
+static void ImageDraw_Binary_Rotated(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_BINARY, TRANSPARENCY_OPAQUE, display::DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(ImageDraw_Binary_Rotated);
+
+static void ImageDraw_Grayscale_Rotated(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_GRAYSCALE, TRANSPARENCY_OPAQUE, display::DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(ImageDraw_Grayscale_Rotated);
+
+static void ImageDraw_RGB565_Rotated(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_RGB565, TRANSPARENCY_OPAQUE, display::DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(ImageDraw_RGB565_Rotated);
+
+static void ImageDraw_Binary_Transparent_Rotated(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_BINARY, TRANSPARENCY_CHROMA_KEY, display::DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(ImageDraw_Binary_Transparent_Rotated);
+
+static void ImageDraw_Grayscale_ChromaKey_Rotated(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_GRAYSCALE, TRANSPARENCY_CHROMA_KEY, display::DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(ImageDraw_Grayscale_ChromaKey_Rotated);
+
+static void ImageDraw_Grayscale_Alpha_Rotated(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_GRAYSCALE, TRANSPARENCY_ALPHA_CHANNEL, display::DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(ImageDraw_Grayscale_Alpha_Rotated);
+
+static void ImageDraw_RGB_Alpha_Rotated(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_RGB, TRANSPARENCY_ALPHA_CHANNEL, display::DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(ImageDraw_RGB_Alpha_Rotated);
+
+static void ImageDraw_RGB_ChromaKey_Rotated(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_RGB, TRANSPARENCY_CHROMA_KEY, display::DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(ImageDraw_RGB_ChromaKey_Rotated);
+
+static void ImageDraw_RGB565_ChromaKey_Rotated(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_RGB565, TRANSPARENCY_CHROMA_KEY, display::DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(ImageDraw_RGB565_ChromaKey_Rotated);
+
+static void ImageDraw_RGB565_Alpha_Rotated(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_RGB565, TRANSPARENCY_ALPHA_CHANNEL, display::DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(ImageDraw_RGB565_Alpha_Rotated);
+
+static void ImageDraw_RGB111_Rotated(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_RGB111, TRANSPARENCY_OPAQUE, display::DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(ImageDraw_RGB111_Rotated);
+
+static void ImageDraw_RGB111_Alpha_Rotated(benchmark::State &state) {
+  draw_image(state, IMAGE_TYPE_RGB111, TRANSPARENCY_ALPHA_CHANNEL, display::DISPLAY_ROTATION_90_DEGREES);
+}
+BENCHMARK(ImageDraw_RGB111_Alpha_Rotated);
+
+}  // namespace esphome::image::benchmarks

tests/benchmarks/components/runtime_image/bench_runtime_image_draw.cpp

@@ -0,0 +1,125 @@
+#include <benchmark/benchmark.h>
+
+#include <cstdint>
+#include <memory>
+
+#include "esphome/components/display/display_buffer.h"
+#include "esphome/components/runtime_image/runtime_image.h"
+
+namespace esphome::runtime_image::benchmarks {
+
+static constexpr int kWidth = 128;
+static constexpr int kHeight = 96;
+
+// One byte per pixel frame buffer with no hardware behind it, so the
+// measurement is the image draw plus the DisplayBuffer pixel path every
+// buffered display shares.
+class BenchDisplay : public display::DisplayBuffer {
+ public:
+  BenchDisplay() : frame_(std::make_unique<uint8_t[]>(kWidth * kHeight)) {}
+  void update() override {}
+  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
+  int get_width_internal() override { return kWidth; }
+  int get_height_internal() override { return kHeight; }
+
+ protected:
+  void draw_absolute_pixel_internal(int x, int y, Color color) override { this->frame_[y * kWidth + x] = color.r; }
+
+  std::unique_ptr<uint8_t[]> frame_;
+};
+
+// A runtime image filled the way a decoder fills it, one draw_pixel() per
+// pixel, then published as decoded so draw() uses the buffer.
+class BenchImage : public RuntimeImage {
+ public:
+  BenchImage(image::ImageType type, image::Transparency transparency, bool big_endian)
+      : RuntimeImage(JPEG, type, transparency, nullptr, big_endian, kWidth, kHeight) {}
+
+  bool fill() {
+    if (this->resize(kWidth, kHeight) == 0)
+      return false;
+    uint32_t seed = 11897;
+    for (int y = 0; y < kHeight; y++) {
+      for (int x = 0; x < kWidth; x++) {
+        seed = seed * 1103515245u + 12345u;
+        // Every fourth pixel is transparent so the chroma key cases hit both branches
+        const uint8_t alpha = (x & 3) == 0 ? 0x00 : 0xFF;
+        this->draw_pixel(x, y, Color(seed >> 24, seed >> 16, seed >> 8, alpha));
+      }
+    }
+    this->width_ = this->buffer_width_;
+    this->height_ = this->buffer_height_;
+    this->data_start_ = this->buffer_;
+    return true;
+  }
+};
+
+// The decoder side: writing every pixel of the image into its buffer.
+static void fill_image(benchmark::State &state, image::ImageType type, image::Transparency transparency) {
+  BenchImage image(type, transparency, false);
+  for (auto _ : state) {
+    if (!image.fill()) {
+      state.SkipWithError("buffer allocation failed");
+      return;
+    }
+    benchmark::DoNotOptimize(image.get_data_start());
+  }
+  state.SetItemsProcessed(state.iterations() * kWidth * kHeight);
+}
+
+// The display side: drawing the decoded image onto a buffered display.
+static void draw_image(benchmark::State &state, image::ImageType type, image::Transparency transparency,
+                       bool big_endian = false) {
+  BenchImage image(type, transparency, big_endian);
+  if (!image.fill()) {
+    state.SkipWithError("buffer allocation failed");
+    return;
+  }
+  BenchDisplay display;
+  for (auto _ : state) {
+    image.draw(0, 0, &display, display::COLOR_ON, display::COLOR_OFF);
+  }
+  state.SetItemsProcessed(state.iterations() * kWidth * kHeight);
+}
+
+static void RuntimeImageFill_RGB565(benchmark::State &state) {
+  fill_image(state, image::IMAGE_TYPE_RGB565, image::TRANSPARENCY_OPAQUE);
+}
+BENCHMARK(RuntimeImageFill_RGB565);
+
+static void RuntimeImageFill_RGB565_ChromaKey(benchmark::State &state) {
+  fill_image(state, image::IMAGE_TYPE_RGB565, image::TRANSPARENCY_CHROMA_KEY);
+}
+BENCHMARK(RuntimeImageFill_RGB565_ChromaKey);
+
+static void RuntimeImageFill_RGB(benchmark::State &state) {
+  fill_image(state, image::IMAGE_TYPE_RGB, image::TRANSPARENCY_OPAQUE);
+}
+BENCHMARK(RuntimeImageFill_RGB);
+
+static void RuntimeImageDraw_RGB565(benchmark::State &state) {
+  draw_image(state, image::IMAGE_TYPE_RGB565, image::TRANSPARENCY_OPAQUE);
+}
+BENCHMARK(RuntimeImageDraw_RGB565);
+
+static void RuntimeImageDraw_RGB565_BigEndian(benchmark::State &state) {
+  draw_image(state, image::IMAGE_TYPE_RGB565, image::TRANSPARENCY_OPAQUE, true);
+}
+BENCHMARK(RuntimeImageDraw_RGB565_BigEndian);
+
+static void RuntimeImageDraw_RGB565_ChromaKey(benchmark::State &state) {
+  draw_image(state, image::IMAGE_TYPE_RGB565, image::TRANSPARENCY_CHROMA_KEY);
+}
+BENCHMARK(RuntimeImageDraw_RGB565_ChromaKey);
+
+static void RuntimeImageDraw_RGB(benchmark::State &state) {
+  draw_image(state, image::IMAGE_TYPE_RGB, image::TRANSPARENCY_OPAQUE);
+}
+BENCHMARK(RuntimeImageDraw_RGB);
+
+static void RuntimeImageDraw_Grayscale(benchmark::State &state) {
+  draw_image(state, image::IMAGE_TYPE_GRAYSCALE, image::TRANSPARENCY_OPAQUE);
+}
+BENCHMARK(RuntimeImageDraw_Grayscale);
+
+}  // namespace esphome::runtime_image::benchmarks

tests/component_tests/ble_client/test_validation.py

@@ -19,21 +19,9 @@ from esphome.const import (
     CONF_NOTIFY,
     CONF_SERVICE_UUID,
     CONF_TYPE,
-    PlatformFramework,
 )
-from esphome.core import CORE
 from esphome.types import ConfigType
 
-from ..types import SetCoreConfigCallable
-
-
-@pytest.fixture(autouse=True)
-def esp32_platform(set_core_config: SetCoreConfigCallable) -> None:
-    # The raw-gattc node family gates through BLE_CLIENT_SCHEMA's
-    # _legacy_engine_only choke point; these schema tests exercise the esp32 arm.
-    set_core_config(PlatformFramework.ESP32_IDF)
-
-
 DESCRIPTOR_CONFIG: ConfigType = {
     CONF_NAME: "test",
     CONF_SERVICE_UUID: "6E400001-B5A3-F393-E0A9-E50E24DCCA9E",
@@ -96,72 +84,3 @@ def test_on_notify_implies_notify() -> None:
 def test_notify_unchanged_without_on_notify() -> None:
     config: ConfigType = {CONF_NOTIFY: False}
     assert notify_from_on_notify(config)[CONF_NOTIFY] is False
-
-
-def test_legacy_node_choke_point_rejects_other_platforms(
-    set_core_config: SetCoreConfigCallable,
-) -> None:
-    from esphome.components import ble_client
-    from esphome.core import ID
-
-    set_core_config(PlatformFramework.RP2_ARDUINO)
-    with pytest.raises(cv.Invalid, match="not been migrated"):
-        ble_client._legacy_engine_only(ID("x"))
-    # Through the public schema too, so removing the cv.All wiring fails here.
-    with pytest.raises(cv.Invalid, match="not been migrated"):
-        ble_client.BLE_CLIENT_SCHEMA({})
-
-
-def test_neutral_arm_rejects_esp32_only_keys(
-    set_core_config: SetCoreConfigCallable,
-) -> None:
-    # Pins the schema split's rejection side: the legacy-only keys must not
-    # leak into the neutral arm. The hub is registered so the extra key is
-    # the only error - without it the missing-tracker error would satisfy
-    # the raises vacuously.
-    from esphome.components import ble_client, ble_device_base
-
-    set_core_config(PlatformFramework.RP2_ARDUINO)
-    ble_device_base.register_hub_provider("rp2_ble_tracker")
-    CORE.loaded_integrations.add("rp2_ble_tracker")
-    for key in ("name", "on_passkey_request", "on_passkey_notification"):
-        with pytest.raises(cv.Invalid, match="extra keys not allowed"):
-            ble_client.CONFIG_SCHEMA({"mac_address": "AA:BB:CC:DD:EE:FF", key: "x"})
-
-
-def test_security_actions_reject_platforms_without_the_feature(
-    set_core_config: SetCoreConfigCallable,
-) -> None:
-    from esphome.components import ble_client
-
-    set_core_config(PlatformFramework.RP2_ARDUINO)
-    for schema in (
-        ble_client.BLE_PASSKEY_REPLY_ACTION_SCHEMA,
-        ble_client.BLE_NUMERIC_COMPARISON_REPLY_ACTION_SCHEMA,
-        ble_client.BLE_REMOVE_BOND_ACTION_SCHEMA,
-    ):
-        with pytest.raises(cv.Invalid, match="'security' feature, which rp2"):
-            schema({})
-
-
-def test_node_schema_passes_on_every_gatt_platform(
-    set_core_config: SetCoreConfigCallable,
-) -> None:
-    # The neutral node schema carries no engine gate: raw_gattc components
-    # stay choked, gatt_node components validate wherever ble_client does.
-    from esphome.components import ble_client
-
-    for pf in (PlatformFramework.ESP32_IDF, PlatformFramework.RP2_ARDUINO):
-        set_core_config(pf)
-        assert ble_client.NODE_BLE_CLIENT_SCHEMA({})
-
-
-def test_feature_error_names_the_available_features(
-    set_core_config: SetCoreConfigCallable,
-) -> None:
-    from esphome.components import ble_client
-    from esphome.core import ID
-
-    set_core_config(PlatformFramework.RP2_ARDUINO)
-    with pytest.raises(cv.Invalid, match="provides: gatt_node"):
-        ble_client._legacy_engine_only(ID("x"))

tests/component_tests/bluetooth_connection/test_slot_ledger.py

@@ -1,79 +0,0 @@
-"""Tests for the cross-component GATT slot ledger."""
-
-import pytest
-
-from esphome import config_validation as cv
-from esphome.components import (
-    ble_client,
-    ble_device_base,
-    bluetooth_connection,
-    bluetooth_proxy,
-    rp2040_ble,
-)
-from esphome.const import CONF_MAC_ADDRESS, PlatformFramework
-from esphome.core import CORE
-
-from ..types import SetCoreConfigCallable
-
-
-def test_gatt_slot_ledger_rejects_overcommit_on_rp2(
-    set_core_config: SetCoreConfigCallable,
-) -> None:
-    # rp2 owns its budget: the stack's validation reports the overcommit and
-    # the neutral cap check stays silent (one message per misconfiguration).
-    set_core_config(PlatformFramework.RP2_ARDUINO)
-    bluetooth_connection.consume_gatt_slot("bluetooth_proxy", 3)({})
-    bluetooth_connection.consume_gatt_slot("ble_client")({})
-    bluetooth_connection.FINAL_VALIDATE_SCHEMA({})
-    with pytest.raises(cv.Invalid, match="rp2 maximum is 3"):
-        rp2040_ble.validate_connection_slots()
-
-
-def test_gatt_slot_ledger_skipped_in_testing_mode(
-    set_core_config: SetCoreConfigCallable,
-) -> None:
-    # Grouped component builds merge fixtures past the cap; the check defers
-    # to testing mode like esp32_ble.validate_connection_slots.
-    set_core_config(PlatformFramework.RP2_ARDUINO)
-    bluetooth_connection.consume_gatt_slot("bluetooth_proxy", 3)({})
-    bluetooth_connection.consume_gatt_slot("ble_client")({})
-    CORE.testing_mode = True
-    try:
-        bluetooth_connection.FINAL_VALIDATE_SCHEMA({})
-        rp2040_ble.validate_connection_slots()
-    finally:
-        CORE.testing_mode = False
-
-
-def test_real_validators_charge_the_ledger_on_rp2(
-    set_core_config: SetCoreConfigCallable,
-) -> None:
-    # End to end through the component CONFIG_SCHEMAs (no hand charges):
-    # removing either consumer's consume_gatt_slot call fails this test.
-    set_core_config(PlatformFramework.RP2_ARDUINO)
-    ble_device_base.register_hub_provider("rp2_ble_tracker")
-    CORE.loaded_integrations.add("rp2_ble_tracker")
-    bluetooth_proxy.CONFIG_SCHEMA({})
-    ble_client.CONFIG_SCHEMA({CONF_MAC_ADDRESS: "AA:BB:CC:DD:EE:FF"})
-    # The proxy defaults to 3 slots on rp2; ble_client's claim overcommits
-    # and rp2's own budget names every claimant.
-    with pytest.raises(
-        cv.Invalid,
-        match="Components: bluetooth_proxy, bluetooth_proxy, bluetooth_proxy, "
-        "ble_client",
-    ):
-        rp2040_ble.validate_connection_slots()
-
-
-def test_neutral_cap_check_guards_future_hub_platforms(
-    set_core_config: SetCoreConfigCallable, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    # Both current platforms defer to their stack budgets; pin the message
-    # and boundary of the branch a future budget-less hub platform takes.
-    set_core_config(PlatformFramework.RP2_ARDUINO)
-    monkeypatch.setattr(bluetooth_connection, "_STACK_BUDGETS", {})
-    bluetooth_connection.consume_gatt_slot("bluetooth_proxy", 3)({})
-    bluetooth_connection.FINAL_VALIDATE_SCHEMA({})
-    bluetooth_connection.consume_gatt_slot("ble_client")({})
-    with pytest.raises(cv.Invalid, match="supports at most 3 GATT client connection"):
-        bluetooth_connection.FINAL_VALIDATE_SCHEMA({})

tests/component_tests/bluetooth_proxy/test_platform_gates.py

@@ -186,18 +186,6 @@ def test_rp2_rejects_esp32_only_keys_by_name(
         bluetooth_proxy.CONFIG_SCHEMA({"connections": [{}]})
 
 
-def test_esp32_explicit_connections_claim_gatt_slots(
-    set_core_config: SetCoreConfigCallable,
-) -> None:
-    # Explicit `connections:` entries must charge the slot ledger like the
-    # generated ones; dev historically let them evade the budget.
-    set_core_config(PlatformFramework.ESP32_IDF)
-    bluetooth_proxy.CONFIG_SCHEMA({"active": True, "connections": [{}, {}]})
-    # Exact match (one entry per slot): catches a missed charge and a
-    # double charge alike.
-    assert bluetooth_connection._get_data().slot_consumers == ["bluetooth_proxy"] * 2
-
-
 def test_hub_source_filter_covers_every_hub_platform() -> None:
     # bluetooth_connection cannot import this module to derive the hub.cpp
     # framework set, so pin it here: a platform admitted to the proxy but
@@ -241,12 +229,6 @@ def test_every_registered_hub_platform_has_a_schema_arm() -> None:
     # Hub platforms must also be in the backend registry the shared codegen
     # helpers dispatch on.
     assert registered <= set(bluetooth_connection._PLATFORM_BACKENDS)
-    # Every non-esp32 backend platform must carry a slot cap: without one the
-    # ledger's FINAL_VALIDATE accepts unlimited claims silently (esp32's cap
-    # is the controller budget in esp32_ble).
-    assert set(bluetooth_connection._PLATFORM_BACKENDS) - {"esp32"} <= set(
-        bluetooth_connection.HUB_MAX_CONNECTIONS
-    )
     # The outer walkable schema's bound must stay the loosest platform cap.
     assert (
         max(bluetooth_connection.HUB_MAX_CONNECTIONS.values())

tests/component_tests/network/config/priority_ethernet_first_api.yaml

@@ -0,0 +1,28 @@
+esphome:
+  name: test
+
+esp32:
+  board: esp32dev
+  framework:
+    type: esp-idf
+
+wifi:
+  ssid: "test_ssid"
+  password: "test_password"
+
+ethernet:
+  type: W5500
+  clk_pin: 19
+  mosi_pin: 21
+  miso_pin: 23
+  cs_pin: 18
+  interrupt_pin: 36
+  reset_pin: 22
+  clock_speed: 10Mhz
+
+network:
+  priority:
+    - ethernet
+    - wifi
+
+api:

tests/component_tests/network/config/priority_rp2040_api.yaml

@@ -0,0 +1,26 @@
+esphome:
+  name: test
+
+rp2:
+  board: rpipicow
+
+wifi:
+  ssid: "test_ssid"
+  password: "test_password"
+
+ethernet:
+  type: W5500
+  clk_pin: 18
+  mosi_pin: 19
+  miso_pin: 16
+  cs_pin: 17
+  interrupt_pin: 21
+  reset_pin: 20
+  mac_address: "02:AA:BB:CC:DD:01"
+
+network:
+  priority:
+    - ethernet
+    - wifi
+
+api:

tests/component_tests/network/test_active_interface.py

@@ -0,0 +1,52 @@
+"""mDNS follows the interface holding the default route through an
+ActiveInterfaceListener, only where NetworkComponent tracks that interface
+(ESP32 with more than one interface) and the network TXT record exists."""
+
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+
+from esphome.core import CORE
+
+DYNAMIC_TXT_DEFINE = "USE_MDNS_DYNAMIC_NETWORK_TXT"
+LISTENER_DEFINES = {
+    "USE_MDNS_ACTIVE_INTERFACE_LISTENER",
+    "NETWORK_ACTIVE_INTERFACE_LISTENER_COUNT",
+}
+
+
+def _defines() -> set[str]:
+    return {define.name for define in CORE.defines}
+
+
+def test_mdns_registers_on_esp32_with_wifi_ethernet_and_api(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+) -> None:
+    main_cpp = generate_main(component_config_path("priority_ethernet_first_api.yaml"))
+
+    assert "add_active_interface_listener(" in main_cpp
+    assert _defines() >= LISTENER_DEFINES | {DYNAMIC_TXT_DEFINE}
+
+
+@pytest.mark.parametrize(
+    ("fixture", "dynamic_txt"),
+    [
+        # No api means no _esphomelib service, so no network TXT record
+        pytest.param("priority_ethernet_first.yaml", False, id="esp32_without_api"),
+        # No route arbitration on RP2; mDNS keeps its periodic check there
+        pytest.param("priority_rp2040_api.yaml", True, id="rp2040"),
+    ],
+)
+def test_mdns_does_not_register(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+    fixture: str,
+    dynamic_txt: bool,
+) -> None:
+    main_cpp = generate_main(component_config_path(fixture))
+
+    assert "add_active_interface_listener(" not in main_cpp
+    assert not LISTENER_DEFINES & _defines()
+    assert (DYNAMIC_TXT_DEFINE in _defines()) is dynamic_txt

tests/component_tests/tmp102/config/duplicate_status.yaml

@@ -0,0 +1,23 @@
+---
+esphome:
+  name: tmp102-test
+
+esp32:
+  board: esp32dev
+
+i2c:
+  sda: GPIO21
+  scl: GPIO22
+
+sensor:
+  - platform: tmp102
+    id: parent_sensor
+    name: Temperature
+
+text_sensor:
+  - platform: tmp102
+    tmp102_id: parent_sensor
+    name: First Status
+  - platform: tmp102
+    tmp102_id: parent_sensor
+    name: Second Status

tests/component_tests/tmp102/config/status.yaml

@@ -0,0 +1,20 @@
+---
+esphome:
+  name: tmp102-test
+
+esp32:
+  board: esp32dev
+
+i2c:
+  sda: GPIO21
+  scl: GPIO22
+
+sensor:
+  - platform: tmp102
+    id: parent_sensor
+    name: Temperature
+
+text_sensor:
+  - platform: tmp102
+    tmp102_id: parent_sensor
+    name: Threshold Status

tests/component_tests/tmp102/test_config.py

@@ -58,6 +58,30 @@ def test_duplicate_alert_entities_are_rejected(
     )
 
 
+def test_status_entity_is_read_only(
+    generate_main: Callable[[Path], str],
+    component_config_path: Callable[[str], Path],
+) -> None:
+    source = generate_main(component_config_path("status.yaml"))
+    assert "set_threshold_status_text_sensor" in source
+    assert "set_configuration" not in source
+    defines = " ".join(define.name for define in CORE.defines)
+    assert "USE_TMP102_TEXT_SENSOR" in defines
+    assert "USE_TMP102_CONFIGURE" not in defines
+
+
+def test_duplicate_status_entities_are_rejected(
+    component_config_path: Callable[[str], Path],
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    CORE.config_path = component_config_path("duplicate_status.yaml")
+    assert read_config({}) is None
+    assert (
+        "Only one TMP102 text_sensor may reference each temperature sensor"
+        in capsys.readouterr().out
+    )
+
+
 def test_threshold_numbers_enable_configuration_once(
     generate_main: Callable[[Path], str],
     component_config_path: Callable[[str], Path],

tests/components/ble_client/common-gatt.yaml

@@ -1,24 +0,0 @@
-ble_client:
-  - mac_address: 01:02:03:04:05:06
-    id: test_blec
-    on_connect:
-      then:
-        - ble_client.ble_write:
-            id: test_blec
-            service_uuid: '1802'
-            characteristic_uuid: '2a06'
-            value: [0x04, 0x05, 0x06]
-    on_disconnect:
-      then:
-        - ble_client.disconnect: test_blec
-
-button:
-  - platform: template
-    name: Connect button
-    on_press:
-      - ble_client.connect: test_blec
-      - ble_client.ble_write:
-          id: test_blec
-          service_uuid: '1802'
-          characteristic_uuid: '2a06'
-          value: !lambda return {0x01, 0x02};

tests/components/ble_client/test.rp2040-ard.yaml

@@ -1,6 +0,0 @@
-# The neutral engine: the BTstack backend and rp2040_ble come in through
-# bluetooth_connection's auto-load; the tracker hub supplies the sightings.
-packages:
-  common: !include common-gatt.yaml
-
-rp2_ble_tracker: