[ld2420] Extract command frame builders from the blocking senders

Behavior free refactor: split the frame serialization out of send_cmd_from_array, split the frame construction out of the blocking command functions into build helpers, name the ack timeout and retry constants, remove the unused CmdFrameT length field and the unused get_reg_value_ method. No functional change.
[ld2420] Drop the setup priority override so setup runs after the UART bus
2026-08-23 14:46:20 +00:00 · 2026-08-16 21:12:28 -05:00 · 2026-08-16 21:00:05 -05:00
187 changed files with 1173 additions and 3109 deletions
@@ -32,7 +32,7 @@ runs:
      # detects the activated venv via ``VIRTUAL_ENV`` so the venv layout
      # downstream jobs rely on is preserved.
      if: steps.cache-venv.outputs.cache-hit != 'true'
-      uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+      uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
      with:
        enable-cache: true
        # Pull request saves land in per-PR scopes nothing else can
@@ -49,7 +49,7 @@ runs:
        python -m venv venv
        source venv/bin/activate
        python --version
-        uv pip install -r requirements.txt -r requirements_dev.txt -r requirements_test.txt
+        uv pip install -r requirements.txt -r requirements_test.txt
        uv pip install -e .
    - name: Create Python virtual environment
      if: steps.cache-venv.outputs.cache-hit != 'true' && runner.os == 'Windows'
@@ -58,5 +58,5 @@ runs:
        python -m venv venv
        source ./venv/Scripts/activate
        python --version
-        uv pip install -r requirements.txt -r requirements_dev.txt -r requirements_test.txt
+        uv pip install -r requirements.txt -r requirements_test.txt
        uv pip install -e .
@@ -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@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
        with:
          enable-cache: true
          # Pull-request-only workflow: a save could never be shared and
@@ -41,32 +41,10 @@ jobs:
          version: "0.11.15"

      - name: Install apt dependencies
-        # PR-only workflow, so nothing on dev could seed a shared apt cache
-        # entry; the cached apt action would save one copy per PR. Plain apt
-        # with every call bounded: the apt.conf.d timeouts make a dead
-        # mirror fail over in seconds, and timeout runs under sudo so it can
-        # kill apt-get itself. Install without update first: image lists are
-        # fresh, and the index refresh is what a congested mirror makes slow.
-        timeout-minutes: 15
        run: |
-          sudo tee /etc/apt/apt.conf.d/99ci-acquire-timeouts >/dev/null <<'EOF'
-          Acquire::Retries "1";
-          Acquire::http::Timeout "15";
-          Acquire::https::Timeout "15";
-          EOF
-          # Common path: the image's package lists are fresh enough.
-          if sudo DEBIAN_FRONTEND=noninteractive timeout -k 15 90 \
-              apt-get install -y protobuf-compiler; then
-            protoc --version
-            exit 0
-          fi
-          # Rescue path: refresh the lists once with a generous bound; the
-          # apt config already fails a stalled mirror over quickly.
-          sudo DEBIAN_FRONTEND=noninteractive timeout -k 10 30 \
-            dpkg --configure -a || true
-          sudo timeout -k 15 300 apt-get update
-          sudo DEBIAN_FRONTEND=noninteractive timeout -k 15 300 \
-            apt-get install -y protobuf-compiler
+          sudo apt update
+          sudo apt-cache show protobuf-compiler
+          sudo apt install -y protobuf-compiler
          protoc --version
      - name: Install python dependencies
        run: uv pip install --system aioesphomeapi -c requirements.txt -r requirements_dev.txt
@@ -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@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -68,22 +68,6 @@ jobs:
          uv pip install -r requirements.txt -r requirements_dev.txt -r requirements_test.txt
          uv pip install -e .

-  seed-apt-cache:
-    name: Seed apt package cache
-    runs-on: ubuntu-24.04
-    # PR-branch cache saves are invisible to other PRs, so dev/beta/release
-    # pushes seed the one shared entry PR jobs restore. The key is derived
-    # only from the package list and version; keep both identical in every
-    # step that restores it. In ci-status needs so a broken seed fails dev.
-    if: github.event_name == 'push'
-    timeout-minutes: 10
-    steps:
-      - name: Install apt packages (cached)
-        uses: awalsh128/cache-apt-pkgs-action@553a35bb8ebd9fcabcb1c9451aa4c98e1b4ca8a9 # v1.6.3
-        with:
-          packages: libsdl2-dev ccache
-          version: 1.1
-
  determine-jobs:
    name: Determine which jobs to run
    runs-on: ubuntu-24.04
@@ -339,8 +323,7 @@ jobs:

  integration-tests:
    name: Run integration tests (${{ matrix.bucket.name }})
-    # Must match seed-apt-cache's image: the apt cache key has no OS in it.
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-latest
    needs:
      - common
      - determine-jobs
@@ -352,16 +335,24 @@ jobs:
    steps:
      - name: Check out code from GitHub
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-      - name: Install apt packages (cached)
-        # ccache speeds up the host compiles. A cache hit never touches apt
-        # (mirror outages cannot hang the job); the timeout bounds the cold
-        # path. Packages and version must match seed-apt-cache exactly;
-        # libsdl2-dev is unused here and carried only for cache-key parity.
-        timeout-minutes: 10
-        uses: awalsh128/cache-apt-pkgs-action@553a35bb8ebd9fcabcb1c9451aa4c98e1b4ca8a9 # v1.6.3
+      - name: Install ccache
+        # Speeds up the host compiles: tests in a bucket compile overlapping
+        # component sets, so later tests reuse earlier tests' objects.
+        run: |
+          sudo apt-get update -qq
+          sudo apt-get install -y --no-install-recommends ccache
+      - name: Restore ccache (restore-only)
+        # esphome stores the PlatformIO ccache under the machine-global cache
+        # dir (see _ccache_env() in esphome/platformio/toolchain.py). The
+        # bucket-name prefix prefers a same-bucket seed; the bare prefix falls
+        # back to any seed when the bucket layout differs from dev.
+        uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
        with:
-          packages: libsdl2-dev ccache
-          version: 1.1
+          path: ~/.cache/esphome/platformio-ccache
+          key: integration-ccache-${{ matrix.bucket.name }}-${{ github.sha }}
+          restore-keys: |
+            integration-ccache-${{ matrix.bucket.name }}-
+            integration-ccache-
      - name: Set up Python 3.13
        id: python
        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
@@ -376,7 +367,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@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -410,6 +401,14 @@ jobs:
        # esphome stores the PlatformIO ccache under the machine-global cache
        # dir (see _ccache_env() in esphome/platformio/toolchain.py).
        run: CCACHE_DIR="$HOME/.cache/esphome/platformio-ccache" ccache -s
+      - name: Save ccache
+        # Pull request saves land in per-PR scopes nothing else can reuse;
+        # dev pushes seed the shared copy instead.
+        if: github.event_name != 'pull_request'
+        uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: ~/.cache/esphome/platformio-ccache
+          key: integration-ccache-${{ matrix.bucket.name }}-${{ github.sha }}

  import-time:
    name: Check import esphome.__main__ time
@@ -442,7 +441,6 @@ jobs:
  benchmarks:
    name: Run CodSpeed benchmarks
    runs-on: ubuntu-24.04
-    timeout-minutes: 30
    needs:
      - common
      - determine-jobs
@@ -466,58 +464,12 @@ jobs:
      - name: Build benchmarks
        id: build
        run: |
-          # pipefail: without it a failed build is masked by the grep/cut
-          # pipeline below, leaving BINARY empty and silently dropping every
-          # C++ benchmark from the run while the job still reports success.
-          set -o pipefail
          . venv/bin/activate
-          BENCHMARK_LIB_CONFIG=$(python script/setup_codspeed_lib.py)
-          export BENCHMARK_LIB_CONFIG
-          # --build-only prints BUILD_BINARY=<path> to stdout; the grep is
-          # non-fatal so a missing marker reaches the check below instead of
-          # tripping errexit at this assignment
-          BINARY=$(script/cpp_benchmark.py --all --build-only | { grep '^BUILD_BINARY=' || true; } | tail -1 | cut -d= -f2-)
-          if [ -z "$BINARY" ]; then
-            echo "::error::Benchmark build did not report a binary path"
-            exit 1
-          fi
+          export BENCHMARK_LIB_CONFIG=$(python script/setup_codspeed_lib.py)
+          # --build-only prints BUILD_BINARY=<path> to stdout
+          BINARY=$(script/cpp_benchmark.py --all --build-only | grep '^BUILD_BINARY=' | tail -1 | cut -d= -f2-)
          echo "binary=$BINARY" >> $GITHUB_OUTPUT

-      - name: Bound apt fetches and pre-install libc6-dbg
-        # The CodSpeed runner installs valgrind + libc6-dbg via its own
-        # unbounded apt-get update; per-invocation apt options cannot reach
-        # it. The apt.conf.d timeouts below bound every later apt call in
-        # this job, the runner's included. Pre-installing libc6-dbg lets the
-        # runner skip apt once its valgrind cache is restored (it checks
-        # ``dpkg -s libc6-dbg``, so the cache action's unregistered restores
-        # would not count). Install without update first: image lists are
-        # fresh, and the index refresh is what a congested mirror makes
-        # slow. Best effort; the job timeout is the last backstop.
-        timeout-minutes: 15
-        continue-on-error: true
-        run: |
-          sudo tee /etc/apt/apt.conf.d/99ci-acquire-timeouts >/dev/null <<'EOF'
-          Acquire::Retries "1";
-          Acquire::http::Timeout "15";
-          Acquire::https::Timeout "15";
-          EOF
-          if dpkg -s libc6-dbg >/dev/null 2>&1; then
-            echo "libc6-dbg already installed"
-            exit 0
-          fi
-          # Common path: the image's package lists are fresh enough.
-          if sudo DEBIAN_FRONTEND=noninteractive timeout -k 15 90 \
-              apt-get install -y libc6-dbg; then
-            exit 0
-          fi
-          # Rescue path: refresh the lists once with a generous bound; the
-          # apt config already fails a stalled mirror over quickly.
-          sudo DEBIAN_FRONTEND=noninteractive timeout -k 10 30 \
-            dpkg --configure -a || true
-          sudo timeout -k 15 300 apt-get update
-          sudo DEBIAN_FRONTEND=noninteractive timeout -k 15 300 \
-            apt-get install -y libc6-dbg
-
      - name: Run CodSpeed benchmarks
        uses: CodSpeedHQ/action@4296e51e7041e24dadb86d1d6e8b9320d223dbe8 # v5.0.3
        with:
@@ -602,29 +554,24 @@ jobs:
          fetch-depth: 2

      - name: Restore Python
-        id: restore-python
        uses: ./.github/actions/restore-python
        with:
          python-version: ${{ env.DEFAULT_PYTHON }}
          cache-key: ${{ needs.common.outputs.cache-key }}

-      # Key on the exact Python version as well: LibreTiny creates a venv under
-      # ~/.platformio/penv whose interpreter is a symlink into the runner's
-      # hosted toolcache, so a cache saved on an older runner image breaks once
-      # a new image ships a newer patch release and drops the old interpreter.
      - name: Cache platformio
        if: github.ref == 'refs/heads/dev' && matrix.pio_cache_key
        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
        with:
          path: ~/.platformio
-          key: platformio-${{ matrix.pio_cache_key }}-${{ steps.restore-python.outputs.python-version }}-${{ hashFiles('platformio.ini') }}
+          key: platformio-${{ matrix.pio_cache_key }}-${{ hashFiles('platformio.ini') }}

      - name: Cache platformio
        if: github.ref != 'refs/heads/dev' && matrix.pio_cache_key
        uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
        with:
          path: ~/.platformio
-          key: platformio-${{ matrix.pio_cache_key }}-${{ steps.restore-python.outputs.python-version }}-${{ hashFiles('platformio.ini') }}
+          key: platformio-${{ matrix.pio_cache_key }}-${{ hashFiles('platformio.ini') }}

      - name: Cache ESP-IDF install
        if: matrix.cache_idf
@@ -941,17 +888,12 @@ jobs:
      - name: List components
        run: echo ${{ matrix.batch.components }}

-      - name: Install apt packages (cached)
-        # A cache hit (seeded on dev by seed-apt-cache) never touches apt,
-        # so mirror outages cannot hang this PR-only job; the timeout bounds
-        # the cold path. Packages and version must match seed-apt-cache
-        # exactly. The action has no --no-install-recommends; same package
-        # set this job used before #17463.
-        timeout-minutes: 10
-        uses: awalsh128/cache-apt-pkgs-action@553a35bb8ebd9fcabcb1c9451aa4c98e1b4ca8a9 # v1.6.3
-        with:
-          packages: libsdl2-dev ccache
-          version: 1.1
+      - name: Install apt packages
+        # Not cached: this job is pull-request-only, so a cache save could
+        # never be shared and would only consume quota.
+        run: |
+          sudo apt-get update -qq
+          sudo apt-get install -y --no-install-recommends libsdl2-dev ccache

      - name: Check out code from GitHub
        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -1153,7 +1095,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@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -1486,7 +1428,6 @@ jobs:
    # this check.
    needs:
      - common
-      - seed-apt-cache
      - determine-jobs
      - ci-custom
      - pylint
@@ -56,7 +56,7 @@ jobs:

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

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

 RUN \
    platformio settings set enable_telemetry No \
@@ -3,7 +3,7 @@

 namespace esphome::adc {

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

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

 namespace esphome::adc {

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

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

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

 namespace esphome::adc {

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

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

 namespace esphome::adc {

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

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

 namespace esphome::adc {

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

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

 namespace esphome::adc {

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

 void ADCSensor::setup() {
  if (!adc_is_ready_dt(this->channel_)) {
@@ -497,7 +497,7 @@ async def to_code(config: ConfigType) -> None:
            # and plaintext disabled. Only a factory reset can remove it.
            cg.add_define("USE_API_PLAINTEXT")
        cg.add_define("USE_API_NOISE")
-        cg.add_library("esphome/noise-c", "0.1.21")
+        cg.add_library("esphome/noise-c", "0.1.11")
        # Enable optimized memzero/memcmp in libsodium instead of volatile byte loops
        cg.add_build_flag("-DHAVE_WEAK_SYMBOLS=1")
        cg.add_build_flag("-DHAVE_INLINE_ASM=1")
@@ -160,6 +160,11 @@ APIConnection::APIConnection(std::unique_ptr<socket::Socket> sock, APIServer *pa
 #else
 #error "No frame helper defined"
 #endif
+#ifdef USE_CAMERA
+  if (camera::Camera::instance() != nullptr) {
+    this->image_reader_ = std::unique_ptr<camera::CameraImageReader>{camera::Camera::instance()->create_image_reader()};
+  }
+#endif
 }

 void APIConnection::start() {
@@ -1135,7 +1140,6 @@ void APIConnection::try_send_camera_image_() {
  if (!this->image_reader_)
    return;

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

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

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

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

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

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

-bool APIConnection::send_message_smart_(EntityBase *entity, uint16_t message_type, uint8_t estimated_size,
+bool APIConnection::send_message_smart_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
                                        uint8_t aux_data_index) {
  if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
    auto &shared_buf = this->parent_->get_shared_buffer_ref();
@@ -326,10 +326,8 @@ class APIConnection final : public APIServerConnectionBase {
  bool is_marked_for_removal() const { return this->flags_.remove; }
  uint8_t get_log_subscription_level() const { return this->flags_.log_subscription; }

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

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

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

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

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

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

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

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

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

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

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

  // Helper function to log client messages with name and peername
  void log_client_(int level, const LogString *message);
@@ -49,16 +49,16 @@ struct ReadPacketBuffer {
 };

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

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

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

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

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

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

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

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

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

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

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

  return total_header_len;
 }

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

@@ -22,7 +21,7 @@ class APIPlaintextFrameHelper final : public APIFrameHelper {
  APIError init() override;
  APIError loop() override;
  APIError read_packet(ReadPacketBuffer *buffer) override;
-  APIError write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) override;
+  APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) override;
  APIError write_protobuf_messages(ProtoWriteBuffer buffer, std::span<const MessageInfo> messages) override;
 #ifdef USE_API_NOISE
  // After try_read_frame_ returned PROTOCOL_SWITCH_TO_NOISE: copy out the
@@ -684,6 +684,11 @@ class ProtoSize {
    return value < VARINT_THRESHOLD_1_BYTE ? 1 : (value < VARINT_THRESHOLD_2_BYTE ? 2 : 3);
  }

+  // Varint encoded length for an 8-bit value (1 or 2 bytes).
+  static constexpr inline uint8_t ESPHOME_ALWAYS_INLINE varint8(uint8_t value) {
+    return value < VARINT_THRESHOLD_1_BYTE ? 1 : 2;
+  }
+
  /**
   * @brief Calculates the size in bytes needed to encode a uint32_t value as a varint
   *
@@ -300,12 +300,46 @@ void BekenSPILEDStripLightOutput::write_state(light::LightState *state) {
 }

 light::ESPColorView BekenSPILEDStripLightOutput::get_view_internal(int32_t index) const {
-  const light::ChannelColors &colors = this->channel_colors_;
-  uint8_t *led = this->buf_ + (index * colors.bytes_per_led());
-  return {led + colors.r,
-          led + colors.g,
-          led + colors.b,
-          colors.has_white() ? led + colors.w : nullptr,
+  int32_t r = 0, g = 0, b = 0;
+  switch (this->rgb_order_) {
+    case ORDER_RGB:
+      r = 0;
+      g = 1;
+      b = 2;
+      break;
+    case ORDER_RBG:
+      r = 0;
+      g = 2;
+      b = 1;
+      break;
+    case ORDER_GRB:
+      r = 1;
+      g = 0;
+      b = 2;
+      break;
+    case ORDER_GBR:
+      r = 2;
+      g = 0;
+      b = 1;
+      break;
+    case ORDER_BGR:
+      r = 2;
+      g = 1;
+      b = 0;
+      break;
+    case ORDER_BRG:
+      r = 1;
+      g = 2;
+      b = 0;
+      break;
+  }
+  uint8_t multiplier = this->is_rgbw_ || this->is_wrgb_ ? 4 : 3;
+  uint8_t white = this->is_wrgb_ ? 0 : 3;
+
+  return {this->buf_ + (index * multiplier) + r + this->is_wrgb_,
+          this->buf_ + (index * multiplier) + g + this->is_wrgb_,
+          this->buf_ + (index * multiplier) + b + this->is_wrgb_,
+          this->is_rgbw_ || this->is_wrgb_ ? this->buf_ + (index * multiplier) + white : nullptr,
          &this->effect_data_[index],
          &this->correction_};
 }
@@ -315,12 +349,35 @@ void BekenSPILEDStripLightOutput::dump_config() {
                "Beken SPI LED Strip:\n"
                "  Pin: %u",
                this->pin_);
-  char channel_colors[5];
+  const char *rgb_order;
+  switch (this->rgb_order_) {
+    case ORDER_RGB:
+      rgb_order = "RGB";
+      break;
+    case ORDER_RBG:
+      rgb_order = "RBG";
+      break;
+    case ORDER_GRB:
+      rgb_order = "GRB";
+      break;
+    case ORDER_GBR:
+      rgb_order = "GBR";
+      break;
+    case ORDER_BGR:
+      rgb_order = "BGR";
+      break;
+    case ORDER_BRG:
+      rgb_order = "BRG";
+      break;
+    default:
+      rgb_order = "UNKNOWN";
+      break;
+  }
  ESP_LOGCONFIG(TAG,
-                "  Channel colors: %s\n"
+                "  RGB Order: %s\n"
                "  Max refresh rate: %" PRIu32 "\n"
                "  Number of LEDs: %u",
-                this->channel_colors_.to_string(channel_colors), this->max_refresh_rate_.value_or(0), this->num_leds_);
+                rgb_order, this->max_refresh_rate_.value_or(0), this->num_leds_);
 }

 float BekenSPILEDStripLightOutput::get_setup_priority() const { return setup_priority::HARDWARE; }
@@ -3,7 +3,6 @@
 #ifdef USE_BK72XX

 #include "esphome/components/light/addressable_light.h"
-#include "esphome/components/light/channel_colors.h"
 #include "esphome/components/light/light_output.h"
 #include "esphome/core/color.h"
 #include "esphome/core/component.h"
@@ -11,6 +10,15 @@

 namespace esphome::beken_spi_led_strip {

+enum RGBOrder : uint8_t {
+  ORDER_RGB,
+  ORDER_RBG,
+  ORDER_GRB,
+  ORDER_GBR,
+  ORDER_BGR,
+  ORDER_BRG,
+};
+
 class BekenSPILEDStripLightOutput final : public light::AddressableLight {
 public:
  void setup() override;
@@ -20,7 +28,7 @@ class BekenSPILEDStripLightOutput final : public light::AddressableLight {
  int32_t size() const override { return this->num_leds_; }
  light::LightTraits get_traits() override {
    auto traits = light::LightTraits();
-    if (this->channel_colors_.has_white()) {
+    if (this->is_rgbw_ || this->is_wrgb_) {
      traits.set_supported_color_modes({light::ColorMode::RGB_WHITE, light::ColorMode::WHITE});
    } else {
      traits.set_supported_color_modes({light::ColorMode::RGB});
@@ -30,13 +38,16 @@ class BekenSPILEDStripLightOutput final : public light::AddressableLight {

  void set_pin(uint8_t pin) { this->pin_ = pin; }
  void set_num_leds(uint16_t num_leds) { this->num_leds_ = num_leds; }
-  void set_channel_colors(light::ChannelColors channel_colors) { this->channel_colors_ = channel_colors; }
+  void set_is_rgbw(bool is_rgbw) { this->is_rgbw_ = is_rgbw; }
+  void set_is_wrgb(bool is_wrgb) { this->is_wrgb_ = is_wrgb; }

  /// Set a maximum refresh rate in µs as some lights do not like being updated too often.
  void set_max_refresh_rate(uint32_t interval_us) { this->max_refresh_rate_ = interval_us; }

  void set_led_params(uint8_t bit0, uint8_t bit1, uint32_t spi_frequency);

+  void set_rgb_order(RGBOrder rgb_order) { this->rgb_order_ = rgb_order; }
+
  void clear_effect_data() override {
    for (int i = 0; i < this->size(); i++)
      this->effect_data_[i] = 0;
@@ -47,7 +58,7 @@ class BekenSPILEDStripLightOutput final : public light::AddressableLight {
 protected:
  light::ESPColorView get_view_internal(int32_t index) const override;

-  size_t get_buffer_size_() const { return this->num_leds_ * this->channel_colors_.bytes_per_led(); }
+  size_t get_buffer_size_() const { return this->num_leds_ * (this->is_rgbw_ || this->is_wrgb_ ? 4 : 3); }

  uint8_t *buf_{nullptr};
  uint8_t *effect_data_{nullptr};
@@ -55,11 +66,13 @@ class BekenSPILEDStripLightOutput final : public light::AddressableLight {

  uint8_t pin_;
  uint16_t num_leds_;
+  bool is_rgbw_;
+  bool is_wrgb_;

  uint32_t spi_frequency_{6666666};
  uint8_t bit0_{0xE0};
  uint8_t bit1_{0xFC};
-  light::ChannelColors channel_colors_{0, 1, 2, light::ChannelColors::NO_WHITE};
+  RGBOrder rgb_order_;

  uint32_t last_refresh_{0};
  optional<uint32_t> max_refresh_rate_{};
@@ -3,7 +3,6 @@ from dataclasses import dataclass
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import libretiny, light
-from esphome.components.const import CONF_CHANNEL_COLORS, CONF_IS_WRGB
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_CHIPSET,
@@ -14,7 +13,6 @@ from esphome.const import (
    CONF_PIN,
    CONF_RGB_ORDER,
 )
-from esphome.types import ConfigType

 CODEOWNERS = ["@Mat931"]
 DEPENDENCIES = ["libretiny"]
@@ -24,6 +22,17 @@ BekenSPILEDStripLightOutput = beken_spi_led_strip_ns.class_(
    "BekenSPILEDStripLightOutput", light.AddressableLight
 )

+RGBOrder = beken_spi_led_strip_ns.enum("RGBOrder")
+
+RGB_ORDERS = {
+    "RGB": RGBOrder.ORDER_RGB,
+    "RBG": RGBOrder.ORDER_RBG,
+    "GRB": RGBOrder.ORDER_GRB,
+    "GBR": RGBOrder.ORDER_GBR,
+    "BGR": RGBOrder.ORDER_BGR,
+    "BRG": RGBOrder.ORDER_BRG,
+}
+

@dataclass
 class LEDStripTimings:
@@ -48,6 +57,8 @@ CHIPSETS = {
 }


+CONF_IS_WRGB = "is_wrgb"
+
 SUPPORTED_PINS = {
    libretiny.const.FAMILY_BK7231N: [16],
    libretiny.const.FAMILY_BK7231T: [16],
@@ -68,9 +79,10 @@ def _validate_pin(value):
    return value


-def _validate_num_leds(value: ConfigType) -> ConfigType:
-    # A white channel makes each LED one byte wider, so fewer of them fit in the DMA buffer.
-    max_num_leds = 123 if "W" in value[CONF_CHANNEL_COLORS] else 165  # 127 / 170
+def _validate_num_leds(value):
+    max_num_leds = 165  # 170
+    if value[CONF_IS_RGBW] or value[CONF_IS_WRGB]:
+        max_num_leds = 123  # 127
    if value[CONF_NUM_LEDS] > max_num_leds:
        raise cv.Invalid(
            f"The maximum number of LEDs for this configuration is {max_num_leds}.",
@@ -87,23 +99,18 @@ CONFIG_SCHEMA = cv.All(
                pins.internal_gpio_output_pin_number, _validate_pin
            ),
            cv.Required(CONF_NUM_LEDS): cv.positive_not_null_int,
-            cv.Optional(CONF_CHANNEL_COLORS): light.validate_channel_colors,
-            # Deprecated in favour of CONF_CHANNEL_COLORS, remove in 2027.3.0
-            cv.Optional(CONF_RGB_ORDER): cv.one_of(*light.RGB_ORDERS, upper=True),
-            cv.Optional(CONF_IS_RGBW): cv.boolean,
-            cv.Optional(CONF_IS_WRGB): cv.boolean,
+            cv.Required(CONF_RGB_ORDER): cv.enum(RGB_ORDERS, upper=True),
            cv.Optional(CONF_MAX_REFRESH_RATE): cv.positive_time_period_microseconds,
            cv.Required(CONF_CHIPSET): cv.one_of(*CHIPSETS, upper=True),
+            cv.Optional(CONF_IS_RGBW, default=False): cv.boolean,
+            cv.Optional(CONF_IS_WRGB, default=False): cv.boolean,
        }
    ),
-    light.migrate_channel_colors(
-        removed_in="2027.3.0", component="beken_spi_led_strip"
-    ),
    _validate_num_leds,
 )


-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
    var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
    await light.register_light(var, config)
    await cg.register_component(var, config)
@@ -123,6 +130,6 @@ async def to_code(config: ConfigType) -> None:
        )
    )

-    cg.add(
-        var.set_channel_colors(light.channel_colors_struct(config[CONF_CHANNEL_COLORS]))
-    )
+    cg.add(var.set_rgb_order(config[CONF_RGB_ORDER]))
+    cg.add(var.set_is_rgbw(config[CONF_IS_RGBW]))
+    cg.add(var.set_is_wrgb(config[CONF_IS_WRGB]))
@@ -68,11 +68,12 @@ def _unsupported_family_message(family: str) -> str | None:
    return None


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


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

 namespace esphome::bluetooth_connection {

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

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

 namespace esphome::bluetooth_connection {

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

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


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

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

+    return config
+

 FINAL_VALIDATE_SCHEMA = _final_validate

@@ -10,7 +10,6 @@ CONF_ACCELEROMETER_RANGE = "accelerometer_range"
 CONF_B_CONSTANT = "b_constant"
 CONF_BREATH_VOC_EQUIVALENT = "breath_voc_equivalent"
 CONF_BYTE_ORDER = "byte_order"
-CONF_CHANNEL_COLORS = "channel_colors"
 CONF_CLIMATE_ID = "climate_id"
 CONF_CO2_EQUIVALENT = "co2_equivalent"
 CONF_COLOR_DEPTH = "color_depth"
@@ -23,7 +22,6 @@ CONF_GYROSCOPE_ODR = "gyroscope_odr"
 CONF_GYROSCOPE_RANGE = "gyroscope_range"
 CONF_IAQ = "iaq"
 CONF_IGNORE_NOT_FOUND = "ignore_not_found"
-CONF_IS_WRGB = "is_wrgb"
 CONF_LABEL = "label"
 CONF_LIBRETINY = "libretiny"
 CONF_LOOP = "loop"
@@ -5,7 +5,7 @@

 namespace esphome::deep_sleep {

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

 #ifdef USE_DEEP_SLEEP_ON_WAKE
 WakeupCause get_wakeup_cause() {
@@ -88,7 +88,7 @@ async def to_code(config):
    cg.add_library("esphome/dsmr_parser", "1.9.0")


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

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

+    return config
+

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


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

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


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


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


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -1073,26 +1073,6 @@ def _parse_pio_platform_version(value):
        return value


-def _normalize_p4_engineering_sample(value: ConfigType) -> bool:
-    """Fill in CONF_ENGINEERING_SAMPLE when unset, warning that production
-    silicon (rev3) is assumed. Returns the normalized flag."""
-    if (engineering_sample := value.get(CONF_ENGINEERING_SAMPLE)) is None:
-        _LOGGER.warning(
-            "Defaulting to ESP32-P4 production silicon (rev3).\n"
-            "If you have an early engineering sample (pre-rev3), add this to your config:\n"
-            "\n"
-            "  esp32:\n"
-            "    engineering_sample: true\n"
-            "\n"
-            "To check your chip revision, look for 'chip revision: vX.Y' in the boot log.\n"
-            "Engineering samples will show a revision below v3.0.\n"
-            "The 'debug:' component also reports the revision (e.g. Revision: 100 = v1.0, 300 = v3.0)."
-        )
-        engineering_sample = False
-        value[CONF_ENGINEERING_SAMPLE] = engineering_sample
-    return engineering_sample
-
-
 def _detect_variant(value):
    board = value.get(CONF_BOARD)
    variant = value.get(CONF_VARIANT)
@@ -1105,8 +1085,6 @@ def _detect_variant(value):
        # name rather than carrying a PIO board name through the IDF build.
        if CORE.using_toolchain_esp_idf:
            value = value.copy()
-            if variant == VARIANT_ESP32P4:
-                _normalize_p4_engineering_sample(value)
            value[CONF_BOARD] = VARIANT_FRIENDLY[variant].lower()
            return value
        if variant not in STANDARD_BOARDS:
@@ -1117,8 +1095,22 @@ def _detect_variant(value):
            )
        value = value.copy()
        value[CONF_BOARD] = STANDARD_BOARDS[variant]
-        if variant == VARIANT_ESP32P4 and _normalize_p4_engineering_sample(value):
-            value[CONF_BOARD] = "esp32-p4-evboard"
+        if variant == VARIANT_ESP32P4:
+            engineering_sample = value.get(CONF_ENGINEERING_SAMPLE)
+            if engineering_sample is None:
+                _LOGGER.warning(
+                    "No board specified for ESP32-P4. Defaulting to production silicon (rev3).\n"
+                    "If you have an early engineering sample (pre-rev3), add this to your config:\n"
+                    "\n"
+                    "  esp32:\n"
+                    "    engineering_sample: true\n"
+                    "\n"
+                    "To check your chip revision, look for 'chip revision: vX.Y' in the boot log.\n"
+                    "Engineering samples will show a revision below v3.0.\n"
+                    "The 'debug:' component also reports the revision (e.g. Revision: 100 = v1.0, 300 = v3.0)."
+                )
+            elif engineering_sample:
+                value[CONF_BOARD] = "esp32-p4-evboard"
    elif board in BOARDS:
        variant = variant or BOARDS[board][KEY_VARIANT]
        if variant != BOARDS[board][KEY_VARIANT]:
@@ -1128,14 +1120,6 @@ def _detect_variant(value):
            )
        value = value.copy()
        value[CONF_VARIANT] = variant
-        if variant == VARIANT_ESP32P4:
-            board_is_es = BOARDS[board].get("engineering_sample", False)
-            engineering_sample = value.setdefault(CONF_ENGINEERING_SAMPLE, board_is_es)
-            if engineering_sample != board_is_es:
-                raise cv.Invalid(
-                    f"'{CONF_ENGINEERING_SAMPLE}' does not match board '{board}'",
-                    path=[CONF_ENGINEERING_SAMPLE],
-                )
    elif not variant:
        raise cv.Invalid(
            "This board is unknown, if you are sure you want to compile with this board selection, "
@@ -1147,9 +1131,6 @@ def _detect_variant(value):
            "This board is unknown; the specified variant '%s' will be used but this may not work as expected.",
            variant,
        )
-        if variant == VARIANT_ESP32P4:
-            value = value.copy()
-            _normalize_p4_engineering_sample(value)
    return value


@@ -1387,7 +1368,7 @@ def _validate_signed_ota_keys(config: ConfigType) -> ConfigType:
    return config


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

@@ -1453,6 +1434,20 @@ def final_validate(config) -> None:
                path=[CONF_ENGINEERING_SAMPLE],
            )
        )
+    if (
+        config[CONF_VARIANT] == VARIANT_ESP32P4
+        and config.get(CONF_ENGINEERING_SAMPLE) is not None
+    ):
+        board_is_es = BOARDS.get(config[CONF_BOARD], {}).get(
+            "engineering_sample", False
+        )
+        if config[CONF_ENGINEERING_SAMPLE] != board_is_es:
+            errs.append(
+                cv.Invalid(
+                    f"'{CONF_ENGINEERING_SAMPLE}' does not match board '{config[CONF_BOARD]}'",
+                    path=[CONF_ENGINEERING_SAMPLE],
+                )
+            )
    if advanced[CONF_EXECUTE_FROM_PSRAM]:
        if config[CONF_VARIANT] not in {VARIANT_ESP32S3, VARIANT_ESP32P4}:
            errs.append(
@@ -1634,6 +1629,8 @@ def final_validate(config) -> None:
    if errs:
        raise cv.MultipleInvalid(errs)

+    return config
+

 CONF_SDKCONFIG_OPTIONS = "sdkconfig_options"
 CONF_ENABLE_LWIP_DHCP_SERVER = "enable_lwip_dhcp_server"
@@ -2523,14 +2520,15 @@ async def to_code(config):
            f"CONFIG_ESPTOOLPY_FLASHFREQ_{flash_frequency[:-3]}M", True
        )

-    # ESP32-P4: pre-v3 and rev3 (v3.0+) silicon are not binary compatible.
-    # CONFIG_ESP32P4_SELECTS_REV_LESS_V3 selects which layout ESP-IDF links;
-    # validation normalizes CONF_ENGINEERING_SAMPLE from the board when unset.
+    # ESP32-P4: ESP-IDF 5.5.3 changed the default of ESP32P4_SELECTS_REV_LESS_V3
+    # from y to n. PlatformIO uses sections.ld.in (for rev <3) or
+    # sections.rev3.ld.in (for rev >=3) based on board definition.
+    # Set the sdkconfig option to match the board's chip revision.
    if variant == VARIANT_ESP32P4:
-        add_idf_sdkconfig_option(
-            "CONFIG_ESP32P4_SELECTS_REV_LESS_V3",
-            config.get(CONF_ENGINEERING_SAMPLE, False),
+        is_eng_sample = BOARDS.get(config[CONF_BOARD], {}).get(
+            "engineering_sample", False
        )
+        add_idf_sdkconfig_option("CONFIG_ESP32P4_SELECTS_REV_LESS_V3", is_eng_sample)

    # Set minimum chip revision for ESP32 variant
    # Setting this to 3.0 or higher reduces flash size by excluding workaround code,
@@ -443,7 +443,7 @@ def validate_connection_slots(max_connections: int) -> None:
    )


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

+    return config
+

 FINAL_VALIDATE_SCHEMA = final_validation

@@ -307,7 +307,7 @@ def create_device_information_service(config):
    return config


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


 def validate_value_type(value_config):
@@ -126,7 +126,7 @@ CONFIG_SCHEMA = cv.typed_schema(
 )


-def _final_validate(config: ConfigType) -> None:
+def _final_validate(config: ConfigType) -> ConfigType:
    # The esp_hosted releases compatible with older ESP-IDF versions crash at
    # boot with a heap double free in the SDIO RX path (fixed in esp_hosted
    # 2.11.0, which requires ESP-IDF 5.3), so reject them at validation time.
@@ -136,6 +136,7 @@ def _final_validate(config: ConfigType) -> None:
            "Remove the framework version from your configuration to use the "
            "recommended version, or pin a version at or above 5.3."
        )
+    return config


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -221,12 +221,46 @@ void ESP32RMTLEDStripLightOutput::write_state(light::LightState *state) {
 }

 light::ESPColorView ESP32RMTLEDStripLightOutput::get_view_internal(int32_t index) const {
-  const light::ChannelColors &colors = this->channel_colors_;
-  uint8_t *led = this->buf_ + (index * colors.bytes_per_led());
-  return {led + colors.r,
-          led + colors.g,
-          led + colors.b,
-          colors.has_white() ? led + colors.w : nullptr,
+  int32_t r = 0, g = 0, b = 0;
+  switch (this->rgb_order_) {
+    case ORDER_RGB:
+      r = 0;
+      g = 1;
+      b = 2;
+      break;
+    case ORDER_RBG:
+      r = 0;
+      g = 2;
+      b = 1;
+      break;
+    case ORDER_GRB:
+      r = 1;
+      g = 0;
+      b = 2;
+      break;
+    case ORDER_GBR:
+      r = 2;
+      g = 0;
+      b = 1;
+      break;
+    case ORDER_BGR:
+      r = 2;
+      g = 1;
+      b = 0;
+      break;
+    case ORDER_BRG:
+      r = 1;
+      g = 2;
+      b = 0;
+      break;
+  }
+  uint8_t multiplier = this->is_rgbw_ || this->is_wrgb_ ? 4 : 3;
+  uint8_t white = this->is_wrgb_ ? 0 : this->white_index_;
+
+  return {this->buf_ + (index * multiplier) + r + (white <= r),
+          this->buf_ + (index * multiplier) + g + (white <= g),
+          this->buf_ + (index * multiplier) + b + (white <= b),
+          this->is_rgbw_ || this->is_wrgb_ ? this->buf_ + (index * multiplier) + white : nullptr,
          &this->effect_data_[index],
          &this->correction_};
 }
@@ -237,12 +271,46 @@ void ESP32RMTLEDStripLightOutput::dump_config() {
                "  Pin: %u",
                this->pin_);
  ESP_LOGCONFIG(TAG, "  RMT Symbols: %" PRIu32, this->rmt_symbols_);
-  char channel_colors[5];
+  const char *rgb_order;
+  switch (this->rgb_order_) {
+    case ORDER_RGB:
+      rgb_order = "RGB";
+      break;
+    case ORDER_RBG:
+      rgb_order = "RBG";
+      break;
+    case ORDER_GRB:
+      rgb_order = "GRB";
+      break;
+    case ORDER_GBR:
+      rgb_order = "GBR";
+      break;
+    case ORDER_BGR:
+      rgb_order = "BGR";
+      break;
+    case ORDER_BRG:
+      rgb_order = "BRG";
+      break;
+    default:
+      rgb_order = "UNKNOWN";
+      break;
+  }
+  if (this->is_rgbw_ || this->is_wrgb_) {
+    char rgbw_order[5];
+    uint8_t white = this->is_wrgb_ ? 0 : this->white_index_;
+    uint8_t rgb_index = 0;
+    for (uint8_t i = 0; i < 4; i++) {
+      rgbw_order[i] = i == white ? 'W' : rgb_order[rgb_index++];
+    }
+    rgbw_order[4] = '\0';
+    ESP_LOGCONFIG(TAG, "  RGBW Order: %s", rgbw_order);
+  } else {
+    ESP_LOGCONFIG(TAG, "  RGB Order: %s", rgb_order);
+  }
  ESP_LOGCONFIG(TAG,
-                "  Channel colors: %s\n"
                "  Max refresh rate: %" PRIu32 "\n"
                "  Number of LEDs: %u",
-                this->channel_colors_.to_string(channel_colors), this->max_refresh_rate_.value_or(0), this->num_leds_);
+                this->max_refresh_rate_.value_or(0), this->num_leds_);
 }

 float ESP32RMTLEDStripLightOutput::get_setup_priority() const { return setup_priority::HARDWARE; }
@@ -3,7 +3,6 @@
 #ifdef USE_ESP32

 #include "esphome/components/light/addressable_light.h"
-#include "esphome/components/light/channel_colors.h"
 #include "esphome/components/light/light_output.h"
 #include "esphome/core/color.h"
 #include "esphome/core/component.h"
@@ -16,6 +15,15 @@

 namespace esphome::esp32_rmt_led_strip {

+enum RGBOrder : uint8_t {
+  ORDER_RGB,
+  ORDER_RBG,
+  ORDER_GRB,
+  ORDER_GBR,
+  ORDER_BGR,
+  ORDER_BRG,
+};
+
 struct LedParams {
  rmt_symbol_word_t bit0;
  rmt_symbol_word_t bit1;
@@ -31,7 +39,7 @@ class ESP32RMTLEDStripLightOutput final : public light::AddressableLight {
  int32_t size() const override { return this->num_leds_; }
  light::LightTraits get_traits() override {
    auto traits = light::LightTraits();
-    if (this->channel_colors_.has_white()) {
+    if (this->is_rgbw_ || this->is_wrgb_) {
      traits.set_supported_color_modes({light::ColorMode::RGB_WHITE, light::ColorMode::WHITE});
    } else {
      traits.set_supported_color_modes({light::ColorMode::RGB});
@@ -42,7 +50,13 @@ class ESP32RMTLEDStripLightOutput final : public light::AddressableLight {
  void set_pin(uint8_t pin) { this->pin_ = pin; }
  void set_inverted(bool inverted) { this->invert_out_ = inverted; }
  void set_num_leds(uint16_t num_leds) { this->num_leds_ = num_leds; }
-  void set_channel_colors(light::ChannelColors channel_colors) { this->channel_colors_ = channel_colors; }
+  void set_is_rgbw(bool is_rgbw) { this->is_rgbw_ = is_rgbw; }
+  void set_is_wrgb(bool is_wrgb) { this->is_wrgb_ = is_wrgb; }
+  void set_rgbw_order(uint8_t white_index) {
+    this->is_rgbw_ = true;
+    this->is_wrgb_ = false;
+    this->white_index_ = white_index;
+  }
  void set_use_dma(bool use_dma) { this->use_dma_ = use_dma; }
  void set_use_psram(bool use_psram) { this->use_psram_ = use_psram; }

@@ -52,6 +66,7 @@ class ESP32RMTLEDStripLightOutput final : public light::AddressableLight {
  void set_led_params(uint32_t bit0_high, uint32_t bit0_low, uint32_t bit1_high, uint32_t bit1_low,
                      uint32_t reset_time_high, uint32_t reset_time_low);

+  void set_rgb_order(RGBOrder rgb_order) { this->rgb_order_ = rgb_order; }
  void set_rmt_symbols(uint32_t rmt_symbols) { this->rmt_symbols_ = rmt_symbols; }

  void clear_effect_data() override {
@@ -64,7 +79,7 @@ class ESP32RMTLEDStripLightOutput final : public light::AddressableLight {
 protected:
  light::ESPColorView get_view_internal(int32_t index) const override;

-  size_t get_buffer_size_() const { return this->num_leds_ * this->channel_colors_.bytes_per_led(); }
+  size_t get_buffer_size_() const { return this->num_leds_ * (this->is_rgbw_ || this->is_wrgb_ ? 4 : 3); }

  uint8_t *buf_{nullptr};
  uint8_t *effect_data_{nullptr};
@@ -79,11 +94,15 @@ class ESP32RMTLEDStripLightOutput final : public light::AddressableLight {
  uint32_t rmt_symbols_{48};
  uint8_t pin_;
  uint16_t num_leds_;
+  bool is_rgbw_{false};
+  bool is_wrgb_{false};
+  // An index after the RGB channels makes offset adjustment a no-op for three-channel strips.
+  uint8_t white_index_{3};
  bool use_dma_{false};
  bool use_psram_{false};
  bool invert_out_{false};

-  light::ChannelColors channel_colors_{0, 1, 2, light::ChannelColors::NO_WHITE};
+  RGBOrder rgb_order_{ORDER_RGB};

  uint32_t last_refresh_{0};
  optional<uint32_t> max_refresh_rate_{};
@@ -1,9 +1,10 @@
 from dataclasses import dataclass
+import logging

 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import esp32, esp32_rmt, light
-from esphome.components.const import CONF_CHANNEL_COLORS, CONF_IS_WRGB, CONF_USE_PSRAM
+from esphome.components.const import CONF_USE_PSRAM
 from esphome.components.esp32 import include_builtin_idf_component
 import esphome.config_validation as cv
 from esphome.const import (
@@ -21,6 +22,8 @@ from esphome.const import (
 )
 from esphome.types import ConfigType

+_LOGGER = logging.getLogger(__name__)
+
 CODEOWNERS = ["@jesserockz"]
 DEPENDENCIES = ["esp32"]

@@ -29,6 +32,17 @@ ESP32RMTLEDStripLightOutput = esp32_rmt_led_strip_ns.class_(
    "ESP32RMTLEDStripLightOutput", light.AddressableLight
 )

+RGBOrder = esp32_rmt_led_strip_ns.enum("RGBOrder")
+
+RGB_ORDERS = {
+    "RGB": RGBOrder.ORDER_RGB,
+    "RBG": RGBOrder.ORDER_RBG,
+    "GRB": RGBOrder.ORDER_GRB,
+    "GBR": RGBOrder.ORDER_GBR,
+    "BGR": RGBOrder.ORDER_BGR,
+    "BRG": RGBOrder.ORDER_BRG,
+}
+

@dataclass
 class LEDStripTimings:
@@ -48,6 +62,8 @@ CHIPSETS = {
    "SM16703": LEDStripTimings(300, 900, 900, 300, 0, 0),
 }

+CONF_IS_WRGB = "is_wrgb"
+CONF_RGBW_ORDER = "rgbw_order"
 CONF_BIT0_HIGH = "bit0_high"
 CONF_BIT0_LOW = "bit0_low"
 CONF_BIT1_HIGH = "bit1_high"
@@ -56,6 +72,26 @@ CONF_RESET_HIGH = "reset_high"
 CONF_RESET_LOW = "reset_low"


+def _validate_rgbw_order(value: str) -> str:
+    value = cv.string(value).upper()
+    if len(value) != 4 or set(value) != set("RGBW"):
+        raise cv.Invalid("RGBW order must be a permutation of RGBW")
+    return value
+
+
+def _split_rgbw_order(rgbw_order: str) -> tuple[str, int]:
+    return rgbw_order.replace("W", ""), rgbw_order.index("W")
+
+
+def _validate_rgbw_order_exclusivity(config: ConfigType) -> ConfigType:
+    if CONF_RGBW_ORDER in config and (config[CONF_IS_RGBW] or config[CONF_IS_WRGB]):
+        raise cv.Invalid(
+            f"'{CONF_RGBW_ORDER}' cannot be used with '{CONF_IS_RGBW}' or "
+            f"'{CONF_IS_WRGB}'"
+        )
+    return config
+
+
 CONFIG_SCHEMA = cv.All(
    esp32.only_on_variant(
        unsupported=list(esp32_rmt.VARIANTS_NO_RMT),
@@ -66,11 +102,8 @@ CONFIG_SCHEMA = cv.All(
            cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(ESP32RMTLEDStripLightOutput),
            cv.Required(CONF_PIN): pins.internal_gpio_output_pin_schema,
            cv.Required(CONF_NUM_LEDS): cv.positive_not_null_int,
-            cv.Optional(CONF_CHANNEL_COLORS): light.validate_channel_colors,
-            # Deprecated in favour of CONF_CHANNEL_COLORS, remove in 2027.3.0
-            cv.Optional(CONF_RGB_ORDER): cv.one_of(*light.RGB_ORDERS, upper=True),
-            cv.Optional(CONF_IS_RGBW): cv.boolean,
-            cv.Optional(CONF_IS_WRGB): cv.boolean,
+            cv.Optional(CONF_RGB_ORDER): cv.enum(RGB_ORDERS, upper=True),
+            cv.Optional(CONF_RGBW_ORDER): _validate_rgbw_order,
            cv.SplitDefault(
                CONF_RMT_SYMBOLS,
                esp32=192,
@@ -84,6 +117,8 @@ CONFIG_SCHEMA = cv.All(
            ): cv.int_range(min=2),
            cv.Optional(CONF_MAX_REFRESH_RATE): cv.positive_time_period_microseconds,
            cv.Optional(CONF_CHIPSET): cv.one_of(*CHIPSETS, upper=True),
+            cv.Optional(CONF_IS_RGBW, default=False): cv.boolean,
+            cv.Optional(CONF_IS_WRGB, default=False): cv.boolean,
            cv.Optional(CONF_USE_DMA): cv.All(
                esp32.only_on_variant(
                    supported=[esp32.VARIANT_ESP32P4, esp32.VARIANT_ESP32S3]
@@ -118,13 +153,12 @@ CONFIG_SCHEMA = cv.All(
        }
    ).extend(cv.COMPONENT_SCHEMA),
    cv.has_exactly_one_key(CONF_CHIPSET, CONF_BIT0_HIGH),
-    light.migrate_channel_colors(
-        removed_in="2027.3.0", component="esp32_rmt_led_strip"
-    ),
+    cv.has_exactly_one_key(CONF_RGB_ORDER, CONF_RGBW_ORDER),
+    _validate_rgbw_order_exclusivity,
 )


-async def to_code(config: ConfigType) -> None:
+async def to_code(config):
    # Re-enable ESP-IDF's RMT driver (excluded by default to save compile time)
    include_builtin_idf_component("esp_driver_rmt")

@@ -164,9 +198,14 @@ async def to_code(config: ConfigType) -> None:
            )
        )

-    cg.add(
-        var.set_channel_colors(light.channel_colors_struct(config[CONF_CHANNEL_COLORS]))
-    )
+    if (rgbw_order := config.get(CONF_RGBW_ORDER)) is not None:
+        rgb_order, white_index = _split_rgbw_order(rgbw_order)
+        cg.add(var.set_rgb_order(RGB_ORDERS[rgb_order]))
+        cg.add(var.set_rgbw_order(white_index))
+    else:
+        cg.add(var.set_rgb_order(config[CONF_RGB_ORDER]))
+        cg.add(var.set_is_rgbw(config[CONF_IS_RGBW]))
+        cg.add(var.set_is_wrgb(config[CONF_IS_WRGB]))
    cg.add(var.set_use_psram(config[CONF_USE_PSRAM]))
    cg.add(var.set_rmt_symbols(config[CONF_RMT_SYMBOLS]))
    if CONF_USE_DMA in config:
@@ -767,7 +767,7 @@ def _final_validate_rmii_pins(config: ConfigType) -> None:
            raise cv.Invalid(error_msg, path=pin_path)


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

    _final_validate_spi(config)
    _final_validate_rmii_pins(config)
+    return config


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


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


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -23,7 +23,6 @@ from esphome.components.image import (
    get_image_type_enum,
    get_transparency_enum,
    is_svg_file,
-    validate_byte_order,
    validate_settings,
    validate_transparency,
    validate_type,
@@ -201,7 +200,7 @@ OPTIONS_SCHEMA = {
        "NONE", "FLOYDSTEINBERG", upper=True
    ),
    cv.Optional(CONF_INVERT_ALPHA, default=False): cv.boolean,
-    cv.Optional(CONF_BYTE_ORDER): validate_byte_order,
+    cv.Optional(CONF_BYTE_ORDER): cv.one_of("BIG_ENDIAN", "LITTLE_ENDIAN", upper=True),
    cv.Optional(CONF_TRANSPARENCY, default=CONF_OPAQUE): validate_transparency(),
 }

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


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

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


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


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

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

    pin_num = config[CONF_PIN][CONF_NUMBER]

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

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

+    return config
+

 FINAL_VALIDATE_SCHEMA = _final_validate

@@ -1,22 +0,0 @@
-from esphome import pins
-import esphome.config_validation as cv
-from esphome.const import CONF_ALLOW_OTHER_USES, CONF_INTERRUPT_PIN, CONF_INVERTED
-from esphome.types import ConfigType
-
-
-def validate_interrupt_pin(value: ConfigType) -> ConfigType:
-    # The expander components own INT polarity (active-low, hardcoded falling-edge ISR)
-    # and install a single ISR per GPIO, so neither inversion nor sharing is supported.
-    value = pins.internal_gpio_input_pin_schema(value)
-    if value.get(CONF_INVERTED):
-        raise cv.Invalid(
-            f"'{CONF_INVERTED}: true' is not supported on '{CONF_INTERRUPT_PIN}'; "
-            "the expander INT line is fixed active-low"
-        )
-    if value.get(CONF_ALLOW_OTHER_USES):
-        raise cv.Invalid(
-            f"'{CONF_ALLOW_OTHER_USES}: true' is not supported on '{CONF_INTERRUPT_PIN}'; "
-            "sharing the interrupt pin between multiple components is not implemented. "
-            f"Remove the '{CONF_INTERRUPT_PIN}' to fall back to polling."
-        )
-    return value
@@ -163,8 +163,8 @@ CONFIG_SCHEMA = (
 )


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


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


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


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


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


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


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


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

 namespace esphome::http_request {

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

 namespace esphome::http_request {

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

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

 namespace esphome::http_request {

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

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


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

+    return config
+

 FINAL_VALIDATE_SCHEMA = cv.Schema(_final_validate)

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

 namespace esphome::i2c {

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

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

 namespace esphome::i2c {

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

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

 namespace esphome::i2c {

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

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

 namespace esphome::i2c {

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

 static const char *get_speed(uint32_t dev_config) {
  switch (I2C_SPEED_GET(dev_config)) {
@@ -10,14 +10,7 @@ from PIL import Image, UnidentifiedImageError
 import esphome.codegen as cg
 from esphome.components.const import CONF_BYTE_ORDER, KEY_METADATA
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_DEFAULTS,
-    CONF_FILE,
-    CONF_FILES,
-    CONF_ID,
-    CONF_PLATFORM,
-    CONF_TYPE,
-)
+from esphome.const import CONF_DEFAULTS, CONF_FILE, CONF_ID, CONF_PLATFORM, CONF_TYPE
 from esphome.core import CORE
 from esphome.types import ConfigType

@@ -55,9 +48,6 @@ TRANSPARENCY_TYPES = (
    CONF_ALPHA_CHANNEL,
 )

-# Shared validator for the image platform schemas and `_drop_incompatible_byte_order`.
-validate_byte_order = cv.one_of("BIG_ENDIAN", "LITTLE_ENDIAN", upper=True)
-

 def get_image_type_enum(type):
    return getattr(ImageType, f"IMAGE_TYPE_{type.upper()}")
@@ -414,120 +404,6 @@ def get_image_metadata(image_id: str) -> ImageMetaData | None:
    return get_all_image_metadata().get(image_id)


-# ---------------------------------------------------------------------------
-# `defaults:`/`files:` expansion: a `platform:` entry merges shared `defaults:`
-# into every `files:` entry; the platform's CONFIG_SCHEMA validates each.
-# Permanent, unlike the legacy migration below.
-# ---------------------------------------------------------------------------
-
-
-def _drop_incompatible_byte_order(
-    merged: dict, explicit: dict, *, index: int | None = None
-) -> dict:
-    """Drop `byte_order` when the resolved type doesn't support it, unless written directly on `explicit`.
-
-    With `index`, inherited values are validated before being dropped (the legacy flattener always drops).
-    """
-    if CONF_BYTE_ORDER in explicit:
-        return merged
-    type_class = IMAGE_TYPE.get(str(merged.get(CONF_TYPE, "")).upper())
-    if (
-        CONF_BYTE_ORDER in merged
-        and isinstance(type_class, type)
-        and issubclass(type_class, ImageEncoder)
-        and not type_class.is_endian()
-    ):
-        if index is not None:
-            try:
-                validate_byte_order(merged[CONF_BYTE_ORDER])
-            except cv.Invalid as exc:
-                exc.prepend([index])
-                raise
-        del merged[CONF_BYTE_ORDER]
-    return merged
-
-
-def _expand_platform_entry(index: int, entry: dict) -> list[dict]:
-    if CONF_FILES not in entry:
-        if CONF_DEFAULTS in entry:
-            raise cv.Invalid(
-                f"'{CONF_DEFAULTS}' may only be used together with '{CONF_FILES}'",
-                path=[index],
-            )
-        return [entry]
-
-    extra_keys = set(entry) - {CONF_PLATFORM, CONF_DEFAULTS, CONF_FILES}
-    if extra_keys:
-        raise cv.Invalid(
-            f"'{CONF_FILES}' cannot be combined with "
-            f"{', '.join(sorted(extra_keys))} on the same entry",
-            path=[index],
-        )
-
-    files = entry[CONF_FILES]
-    if files is None:
-        raise cv.Invalid(f"'{CONF_FILES}' must not be empty", path=[index])
-    if not isinstance(files, list):
-        raise cv.Invalid(f"'{CONF_FILES}' must be a list", path=[index])
-    if not files:
-        raise cv.Invalid(f"'{CONF_FILES}' must not be empty", path=[index])
-
-    defaults = entry.get(CONF_DEFAULTS, {})
-    if defaults is None:
-        defaults = {}
-    if not isinstance(defaults, dict):
-        raise cv.Invalid(f"'{CONF_DEFAULTS}' must be a mapping", path=[index])
-    # Neither `id:` nor `platform:` makes sense inside `defaults:`.
-    for disallowed in (CONF_ID, CONF_PLATFORM):
-        if disallowed in defaults:
-            raise cv.Invalid(
-                f"'{disallowed}' is not allowed inside '{CONF_DEFAULTS}'",
-                path=[index],
-            )
-
-    from esphome import yaml_util
-
-    platform = entry[CONF_PLATFORM]
-    result: list[dict] = []
-    for file_entry in files:
-        if not isinstance(file_entry, dict):
-            raise cv.Invalid(
-                f"each entry in '{CONF_FILES}' must be a mapping", path=[index]
-            )
-        # The platform is chosen by the entry's own `platform:` key, not per file.
-        if CONF_PLATFORM in file_entry:
-            raise cv.Invalid(
-                f"'{CONF_PLATFORM}' is not allowed inside '{CONF_FILES}'",
-                path=[index],
-            )
-        # Keep the `files:` item's source range so whole-entry errors anchor there;
-        # `make_data_base` needs a real ESPHomeDataBase, so skip it for plain dicts.
-        source = (
-            file_entry if isinstance(file_entry, yaml_util.ESPHomeDataBase) else None
-        )
-        merged = yaml_util.make_data_base(
-            {CONF_PLATFORM: platform, **defaults, **file_entry}, source
-        )
-        result.append(_drop_incompatible_byte_order(merged, file_entry, index=index))
-    return result
-
-
-def expand_platform_config(config: list) -> list:
-    """Expand `defaults:`/`files:` entries; the platform's own CONFIG_SCHEMA validates each result."""
-    result = []
-    for i, entry in enumerate(config):
-        if isinstance(entry, dict) and CONF_PLATFORM in entry:
-            result.extend(_expand_platform_entry(i, entry))
-        else:
-            result.append(entry)
-    return result
-
-
-EXPAND_PLATFORM_CONFIG = expand_platform_config
-
-# --------------------- end defaults/files expansion -------------------------
-
-
 # ---------------------------------------------------------------------------
 # Legacy top-level component -> `image:` platform deprecation helpers
 # -- REMOVE after 2027.1.0 together with the `animation:`/`online_image:` shims.
@@ -620,17 +496,11 @@ def _is_legacy_image_format(config: object) -> bool:
    proper error instead of the migration silently dropping the input.
    """
    if isinstance(config, list):
-        # Exclude `files:` entries -- the list branch would otherwise silently
-        # migrate them to `platform: file` instead of raising the missing-platform error.
+        # A bare list of (not-yet-platform-tagged) image dicts.
        return bool(config) and all(
-            isinstance(entry, dict)
-            and CONF_PLATFORM not in entry
-            and CONF_FILES not in entry
-            for entry in config
+            isinstance(entry, dict) and CONF_PLATFORM not in entry for entry in config
        )
-    if not isinstance(config, dict) or CONF_PLATFORM in config or CONF_FILES in config:
-        # `platform:`/`files:` dicts are new-format (left for list-wrapping +
-        # expansion); the legacy flattener has no `files:` branch and would drop them.
+    if not isinstance(config, dict):
        return False
    # A single image dict, or the grouped `defaults:`/`images:`/type-key form.
    return (
@@ -662,8 +532,18 @@ def _flatten_legacy_image_config(config: object) -> list[dict]:

    def _add(entry: dict, extra: dict) -> None:
        merged = {**defaults, **extra, **entry}
-        # Always drop, matching the pre-platform behavior -- see `_drop_incompatible_byte_order`.
-        result.append(_drop_incompatible_byte_order(merged, {}))
+        # The legacy `defaults:`/type-grouped forms only applied `byte_order` to
+        # types that support it. Replicate that so an endian default merged into
+        # e.g. a binary image stays valid.
+        type_class = IMAGE_TYPE.get(str(merged.get(CONF_TYPE, "")).upper())
+        if (
+            CONF_BYTE_ORDER in merged
+            and isinstance(type_class, type)
+            and issubclass(type_class, ImageEncoder)
+            and not type_class.is_endian()
+        ):
+            del merged[CONF_BYTE_ORDER]
+        result.append(merged)

    def _add_entries(entries: object, extra: dict) -> None:
        # `entries` may be a single image dict or a list of them; non-dict
@@ -22,7 +22,7 @@ CONFIG_SCHEMA = (
 )


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


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


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


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

 namespace esphome::internal_temperature {

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

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

 namespace esphome::internal_temperature {

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

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

 namespace esphome::internal_temperature {

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

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

 namespace esphome::internal_temperature {

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

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

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


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


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


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


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -64,6 +64,8 @@ static const char *const TAG = "ld2420";

 // Local const's
 static constexpr uint16_t REFRESH_RATE_MS = 1000;
+static constexpr uint32_t CMD_ACK_TIMEOUT_MS = 1000;
+static constexpr uint8_t CMD_MAX_RETRIES = 3;

 // Command sets
 static constexpr uint16_t CMD_DISABLE_CONF = 0x00FE;
@@ -631,37 +633,39 @@ void LD2420Component::handle_ack_data_(uint8_t *buffer, int len) {
  }
 }

+void LD2420Component::write_cmd_frame_(const CmdFrameT &frame) {
+  uint8_t cmd_buffer[MAX_LINE_LENGTH];
+  uint16_t length = 0;
+  const uint16_t frame_data_bytes = frame.data_length + 2;  // Always add two bytes for the cmd size
+
+  memcpy(&cmd_buffer[length], &frame.header, sizeof(frame.header));
+  length += sizeof(frame.header);
+
+  memcpy(&cmd_buffer[length], &frame_data_bytes, sizeof(frame.data_length));
+  length += sizeof(frame.data_length);
+
+  memcpy(&cmd_buffer[length], &frame.command, sizeof(frame.command));
+  length += sizeof(frame.command);
+
+  memcpy(&cmd_buffer[length], frame.data, frame.data_length);
+  length += frame.data_length;
+
+  memcpy(&cmd_buffer[length], &frame.footer, sizeof(frame.footer));
+  length += sizeof(frame.footer);
+  this->write_array(cmd_buffer, length);
+}
+
 int LD2420Component::send_cmd_from_array(CmdFrameT frame) {
  uint32_t start_millis = millis();
  uint8_t error = 0;
  uint8_t ack_buffer[MAX_LINE_LENGTH];
-  uint8_t cmd_buffer[MAX_LINE_LENGTH];
  this->cmd_reply_.ack = false;
  if (frame.command != CMD_RESTART) {
    this->cmd_active_ = true;
  }  // Restart does not reply, thus no ack state required
-  uint8_t retry = 3;
+  uint8_t retry = CMD_MAX_RETRIES;
  while (retry) {
-    frame.length = 0;
-    uint16_t frame_data_bytes = frame.data_length + 2;  // Always add two bytes for the cmd size
-
-    memcpy(&cmd_buffer[frame.length], &frame.header, sizeof(frame.header));
-    frame.length += sizeof(frame.header);
-
-    memcpy(&cmd_buffer[frame.length], &frame_data_bytes, sizeof(frame.data_length));
-    frame.length += sizeof(frame.data_length);
-
-    memcpy(&cmd_buffer[frame.length], &frame.command, sizeof(frame.command));
-    frame.length += sizeof(frame.command);
-
-    for (uint16_t index = 0; index < frame.data_length; index++) {
-      memcpy(&cmd_buffer[frame.length], &frame.data[index], sizeof(frame.data[index]));
-      frame.length += sizeof(frame.data[index]);
-    }
-
-    memcpy(cmd_buffer + frame.length, &frame.footer, sizeof(frame.footer));
-    frame.length += sizeof(frame.footer);
-    this->write_array(cmd_buffer, frame.length);
+    this->write_cmd_frame_(frame);

    error = 0;
    if (frame.command == CMD_RESTART) {
@@ -674,7 +678,7 @@ int LD2420Component::send_cmd_from_array(CmdFrameT frame) {
      }
      delay_microseconds_safe(1450);
      // Wait on an Rx from the LD2420 for up to 3 1 second loops, otherwise it could trigger a WDT.
-      if ((millis() - start_millis) > 1000) {
+      if ((millis() - start_millis) > CMD_ACK_TIMEOUT_MS) {
        start_millis = millis();
        error = LD2420_ERROR_TIMEOUT;
        retry--;
@@ -691,16 +695,20 @@ int LD2420Component::send_cmd_from_array(CmdFrameT frame) {
  return error;
 }

+void LD2420Component::build_config_mode_frame_(CmdFrameT &frame, bool enable) {
+  frame.data_length = 0;
+  frame.header = CMD_FRAME_HEADER;
+  frame.command = enable ? CMD_ENABLE_CONF : CMD_DISABLE_CONF;
+  if (enable) {
+    memcpy(&frame.data[0], &CMD_PROTOCOL_VER, sizeof(CMD_PROTOCOL_VER));
+    frame.data_length += sizeof(CMD_PROTOCOL_VER);
+  }
+  frame.footer = CMD_FRAME_FOOTER;
+}
+
 uint8_t LD2420Component::set_config_mode(bool enable) {
  CmdFrameT cmd_frame;
-  cmd_frame.data_length = 0;
-  cmd_frame.header = CMD_FRAME_HEADER;
-  cmd_frame.command = enable ? CMD_ENABLE_CONF : CMD_DISABLE_CONF;
-  if (enable) {
-    memcpy(&cmd_frame.data[0], &CMD_PROTOCOL_VER, sizeof(CMD_PROTOCOL_VER));
-    cmd_frame.data_length += sizeof(CMD_PROTOCOL_VER);
-  }
-  cmd_frame.footer = CMD_FRAME_FOOTER;
+  this->build_config_mode_frame_(cmd_frame, enable);
  ESP_LOGV(TAG, "Sending set config %s command: %2X", enable ? "enable" : "disable", cmd_frame.command);
  return this->send_cmd_from_array(cmd_frame);
 }
@@ -718,18 +726,6 @@ void LD2420Component::ld2420_restart() {
  this->send_cmd_from_array(cmd_frame);
 }

-void LD2420Component::get_reg_value_(uint16_t reg) {
-  CmdFrameT cmd_frame;
-  cmd_frame.data_length = 0;
-  cmd_frame.header = CMD_FRAME_HEADER;
-  cmd_frame.command = CMD_READ_REGISTER;
-  cmd_frame.data[1] = reg;
-  cmd_frame.data_length += 2;
-  cmd_frame.footer = CMD_FRAME_FOOTER;
-  ESP_LOGV(TAG, "Sending read register %4X command: %2X", reg, cmd_frame.command);
-  this->send_cmd_from_array(cmd_frame);
-}
-
 void LD2420Component::set_reg_value(uint16_t reg, uint16_t value) {
  CmdFrameT cmd_frame;
  cmd_frame.data_length = 0;
@@ -753,19 +749,22 @@ void LD2420Component::handle_cmd_error(uint16_t error) {
  }
 }

+void LD2420Component::build_gate_threshold_frame_(CmdFrameT &frame, uint8_t gate) {
+  frame.data_length = 0;
+  frame.header = CMD_FRAME_HEADER;
+  frame.command = CMD_READ_ABD_PARAM;
+  memcpy(&frame.data[frame.data_length], &CMD_GATE_MOVE_THRESH[gate], sizeof(CMD_GATE_MOVE_THRESH[gate]));
+  frame.data_length += 2;
+  memcpy(&frame.data[frame.data_length], &CMD_GATE_STILL_THRESH[gate], sizeof(CMD_GATE_STILL_THRESH[gate]));
+  frame.data_length += 2;
+  frame.footer = CMD_FRAME_FOOTER;
+  ESP_LOGV(TAG, "Sending read gate %d high/low threshold command: %2X", gate, frame.command);
+}
+
 int LD2420Component::get_gate_threshold_(uint8_t gate) {
-  uint8_t error;
  CmdFrameT cmd_frame;
-  cmd_frame.data_length = 0;
-  cmd_frame.header = CMD_FRAME_HEADER;
-  cmd_frame.command = CMD_READ_ABD_PARAM;
-  memcpy(&cmd_frame.data[cmd_frame.data_length], &CMD_GATE_MOVE_THRESH[gate], sizeof(CMD_GATE_MOVE_THRESH[gate]));
-  cmd_frame.data_length += 2;
-  memcpy(&cmd_frame.data[cmd_frame.data_length], &CMD_GATE_STILL_THRESH[gate], sizeof(CMD_GATE_STILL_THRESH[gate]));
-  cmd_frame.data_length += 2;
-  cmd_frame.footer = CMD_FRAME_FOOTER;
-  ESP_LOGV(TAG, "Sending read gate %d high/low threshold command: %2X", gate, cmd_frame.command);
-  error = this->send_cmd_from_array(cmd_frame);
+  this->build_gate_threshold_frame_(cmd_frame, gate);
+  uint8_t error = this->send_cmd_from_array(cmd_frame);
  if (error == 0) {
    this->current_config.move_thresh[gate] = cmd_reply_.data[0];
    this->current_config.still_thresh[gate] = cmd_reply_.data[1];
@@ -773,24 +772,27 @@ int LD2420Component::get_gate_threshold_(uint8_t gate) {
  return error;
 }

-int LD2420Component::get_min_max_distances_timeout_() {
-  uint8_t error;
-  CmdFrameT cmd_frame;
-  cmd_frame.data_length = 0;
-  cmd_frame.header = CMD_FRAME_HEADER;
-  cmd_frame.command = CMD_READ_ABD_PARAM;
-  memcpy(&cmd_frame.data[cmd_frame.data_length], &CMD_MIN_GATE_REG,
+void LD2420Component::build_min_max_timeout_frame_(CmdFrameT &frame) {
+  frame.data_length = 0;
+  frame.header = CMD_FRAME_HEADER;
+  frame.command = CMD_READ_ABD_PARAM;
+  memcpy(&frame.data[frame.data_length], &CMD_MIN_GATE_REG,
         sizeof(CMD_MIN_GATE_REG));  // Register: global min detect gate number
-  cmd_frame.data_length += sizeof(CMD_MIN_GATE_REG);
-  memcpy(&cmd_frame.data[cmd_frame.data_length], &CMD_MAX_GATE_REG,
+  frame.data_length += sizeof(CMD_MIN_GATE_REG);
+  memcpy(&frame.data[frame.data_length], &CMD_MAX_GATE_REG,
         sizeof(CMD_MAX_GATE_REG));  // Register: global max detect gate number
-  cmd_frame.data_length += sizeof(CMD_MAX_GATE_REG);
-  memcpy(&cmd_frame.data[cmd_frame.data_length], &CMD_TIMEOUT_REG,
+  frame.data_length += sizeof(CMD_MAX_GATE_REG);
+  memcpy(&frame.data[frame.data_length], &CMD_TIMEOUT_REG,
         sizeof(CMD_TIMEOUT_REG));  // Register: global delay time
-  cmd_frame.data_length += sizeof(CMD_TIMEOUT_REG);
-  cmd_frame.footer = CMD_FRAME_FOOTER;
-  ESP_LOGV(TAG, "Sending read gate min max and timeout command: %2X", cmd_frame.command);
-  error = this->send_cmd_from_array(cmd_frame);
+  frame.data_length += sizeof(CMD_TIMEOUT_REG);
+  frame.footer = CMD_FRAME_FOOTER;
+  ESP_LOGV(TAG, "Sending read gate min max and timeout command: %2X", frame.command);
+}
+
+int LD2420Component::get_min_max_distances_timeout_() {
+  CmdFrameT cmd_frame;
+  this->build_min_max_timeout_frame_(cmd_frame);
+  uint8_t error = this->send_cmd_from_array(cmd_frame);
  if (error == 0) {
    this->current_config.min_gate = (uint16_t) cmd_reply_.data[0];
    this->current_config.max_gate = (uint16_t) cmd_reply_.data[1];
@@ -799,33 +801,40 @@ int LD2420Component::get_min_max_distances_timeout_() {
  return error;
 }

+void LD2420Component::build_system_mode_frame_(CmdFrameT &frame, uint16_t mode) {
+  uint16_t unknown_parm = 0x0000;
+  frame.data_length = 0;
+  frame.header = CMD_FRAME_HEADER;
+  frame.command = CMD_WRITE_SYS_PARAM;
+  memcpy(&frame.data[frame.data_length], &CMD_SYSTEM_MODE, sizeof(CMD_SYSTEM_MODE));
+  frame.data_length += sizeof(CMD_SYSTEM_MODE);
+  memcpy(&frame.data[frame.data_length], &mode, sizeof(mode));
+  frame.data_length += sizeof(mode);
+  memcpy(&frame.data[frame.data_length], &unknown_parm, sizeof(unknown_parm));
+  frame.data_length += sizeof(unknown_parm);
+  frame.footer = CMD_FRAME_FOOTER;
+  ESP_LOGV(TAG, "Sending write system mode command: %2X", frame.command);
+}
+
 void LD2420Component::set_system_mode(uint16_t mode) {
  CmdFrameT cmd_frame;
-  uint16_t unknown_parm = 0x0000;
-  cmd_frame.data_length = 0;
-  cmd_frame.header = CMD_FRAME_HEADER;
-  cmd_frame.command = CMD_WRITE_SYS_PARAM;
-  memcpy(&cmd_frame.data[cmd_frame.data_length], &CMD_SYSTEM_MODE, sizeof(CMD_SYSTEM_MODE));
-  cmd_frame.data_length += sizeof(CMD_SYSTEM_MODE);
-  memcpy(&cmd_frame.data[cmd_frame.data_length], &mode, sizeof(mode));
-  cmd_frame.data_length += sizeof(mode);
-  memcpy(&cmd_frame.data[cmd_frame.data_length], &unknown_parm, sizeof(unknown_parm));
-  cmd_frame.data_length += sizeof(unknown_parm);
-  cmd_frame.footer = CMD_FRAME_FOOTER;
-  ESP_LOGV(TAG, "Sending write system mode command: %2X", cmd_frame.command);
+  this->build_system_mode_frame_(cmd_frame, mode);
  if (this->send_cmd_from_array(cmd_frame) == 0) {
    this->set_mode_(mode);
  }
 }

+void LD2420Component::build_version_frame_(CmdFrameT &frame) {
+  frame.data_length = 0;
+  frame.header = CMD_FRAME_HEADER;
+  frame.command = CMD_READ_VERSION;
+  frame.footer = CMD_FRAME_FOOTER;
+  ESP_LOGV(TAG, "Sending read firmware version command: %2X", frame.command);
+}
+
 void LD2420Component::get_firmware_version_() {
  CmdFrameT cmd_frame;
-  cmd_frame.data_length = 0;
-  cmd_frame.header = CMD_FRAME_HEADER;
-  cmd_frame.command = CMD_READ_VERSION;
-  cmd_frame.footer = CMD_FRAME_FOOTER;
-
-  ESP_LOGV(TAG, "Sending read firmware version command: %2X", cmd_frame.command);
+  this->build_version_frame_(cmd_frame);
  this->send_cmd_from_array(cmd_frame);
 }

@@ -45,7 +45,6 @@ class LD2420Component final : public Component, public uart::UARTDevice {
  struct CmdFrameT {
    uint32_t header{0};
    uint32_t footer{0};
-    uint16_t length{0};
    uint16_t command{0};
    uint16_t data_length{0};
    uint8_t data[18];
@@ -155,8 +154,13 @@ class LD2420Component final : public Component, public uart::UARTDevice {

  void get_firmware_version_();
  int get_gate_threshold_(uint8_t gate);
-  void get_reg_value_(uint16_t reg);
  int get_min_max_distances_timeout_();
+  void write_cmd_frame_(const CmdFrameT &frame);
+  void build_config_mode_frame_(CmdFrameT &frame, bool enable);
+  void build_min_max_timeout_frame_(CmdFrameT &frame);
+  void build_gate_threshold_frame_(CmdFrameT &frame, uint8_t gate);
+  void build_version_frame_(CmdFrameT &frame);
+  void build_system_mode_frame_(CmdFrameT &frame, uint16_t mode);
  uint16_t get_mode_() { return this->system_mode_; };
  void set_mode_(uint16_t mode) { this->system_mode_ = mode; };
  bool get_presence_() { return this->presence_; };
@@ -84,7 +84,7 @@ CONFIG_SCHEMA = cv.Schema(
 )


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

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

+    return config
+

 FINAL_VALIDATE_SCHEMA = final_validate

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


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

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

+    return config
+

 FINAL_VALIDATE_SCHEMA = final_validate

@@ -1,12 +1,9 @@
-from collections.abc import Callable
 from dataclasses import dataclass, field
 import enum
-import logging

 import esphome.automation as auto
 import esphome.codegen as cg
 from esphome.components import mqtt, power_supply, web_server
-from esphome.components.const import CONF_CHANNEL_COLORS, CONF_IS_WRGB
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_BLUE,
@@ -26,7 +23,6 @@ from esphome.const import (
    CONF_ICON,
    CONF_ID,
    CONF_INITIAL_STATE,
-    CONF_IS_RGBW,
    CONF_MQTT_ID,
    CONF_NAME,
    CONF_ON_STATE,
@@ -36,7 +32,6 @@ from esphome.const import (
    CONF_POWER_SUPPLY,
    CONF_RED,
    CONF_RESTORE_MODE,
-    CONF_RGB_ORDER,
    CONF_STATE,
    CONF_TRIGGER_ID,
    CONF_WARM_WHITE,
@@ -66,7 +61,6 @@ from .effects import (
 from .types import (  # noqa: F401
    AddressableLight,
    AddressableLightState,
-    ChannelColors,
    ColorMode,
    LightOutput,
    LightState,
@@ -77,8 +71,6 @@ from .types import (  # noqa: F401
    light_ns,
 )

-_LOGGER = logging.getLogger(__name__)
-
 CODEOWNERS = ["@esphome/core"]
 IS_PLATFORM_COMPONENT = True

@@ -173,105 +165,7 @@ def available_effects_str(effects: list) -> str:
    return ", ".join(f"'{name}'" for name in available) if available else "none"


-# Accepted values of the deprecated `rgb_order` key.
-RGB_ORDERS = ("RGB", "RBG", "GRB", "GBR", "BGR", "BRG")
-
-_RGB_CHANNELS = frozenset("RGB")
-_RGBW_CHANNELS = frozenset("RGBW")
-
-
-def validate_channel_colors(value: str) -> str:
-    """Validate the channel order of an addressable strip, e.g. "GRB" or "WRGB"."""
-    value = cv.string_strict(value).upper()
-    channels = frozenset(value)
-    if len(channels) != len(value) or channels not in (_RGB_CHANNELS, _RGBW_CHANNELS):
-        raise cv.Invalid(
-            f"'{value}' is not a valid channel order. List each of R, G and B exactly "
-            "once, optionally with a single W, in the order the strip expects them "
-            "(for example GRB, GRBW or WRGB)"
-        )
-    return value
-
-
-def channel_colors_struct(value: str) -> cg.StructInitializer:
-    """Build the C++ `light::ChannelColors` for a validated channel order string."""
-    return cg.StructInitializer(
-        ChannelColors,
-        ("r", value.index("R")),
-        ("g", value.index("G")),
-        ("b", value.index("B")),
-        (
-            "w",
-            value.index("W")
-            if "W" in value
-            else cg.RawExpression(f"{ChannelColors}::NO_WHITE"),
-        ),
-    )
-
-
-def _quote_and_join(keys: list[str]) -> str:
-    """Quote each key and join them into a readable list, e.g. "'a', 'b' and 'c'"."""
-    quoted = [f"'{key}'" for key in keys]
-    if len(quoted) == 1:
-        return quoted[0]
-    return f"{', '.join(quoted[:-1])} and {quoted[-1]}"
-
-
-def migrate_channel_colors(
-    *, removed_in: str, component: str
-) -> Callable[[ConfigType], ConfigType]:
-    """Fold the deprecated `rgb_order`, `is_rgbw` and `is_wrgb` keys into `channel_colors`.
-
-    This also enforces that `channel_colors` is set, which the schema cannot do on its
-    own while the deprecated keys are still accepted. After this runs, `to_code` only
-    ever sees `channel_colors`.
-    """
-
-    def validator(config: ConfigType) -> ConfigType:
-        config = config.copy()
-        deprecated = [
-            key for key in (CONF_RGB_ORDER, CONF_IS_RGBW, CONF_IS_WRGB) if key in config
-        ]
-        if CONF_CHANNEL_COLORS in config:
-            if deprecated:
-                raise cv.Invalid(
-                    f"'{CONF_CHANNEL_COLORS}' cannot be combined with "
-                    f"{_quote_and_join(deprecated)}"
-                )
-            return config
-        if CONF_RGB_ORDER not in config:
-            raise cv.Invalid(
-                f"'{CONF_CHANNEL_COLORS}' is required", path=[CONF_CHANNEL_COLORS]
-            )
-        rgb_order = config.pop(CONF_RGB_ORDER)
-        is_rgbw = config.pop(CONF_IS_RGBW, False)
-        is_wrgb = config.pop(CONF_IS_WRGB, False)
-        if is_rgbw and is_wrgb:
-            raise cv.Invalid(
-                f"'{CONF_IS_RGBW}' and '{CONF_IS_WRGB}' cannot both be enabled"
-            )
-        if is_wrgb:
-            channel_colors = f"W{rgb_order}"
-        elif is_rgbw:
-            channel_colors = f"{rgb_order}W"
-        else:
-            channel_colors = rgb_order
-        _LOGGER.warning(
-            "[%s] %s %s deprecated, use '%s: %s'. Will be removed in %s",
-            component,
-            _quote_and_join(deprecated),
-            "are" if len(deprecated) > 1 else "is",
-            CONF_CHANNEL_COLORS,
-            channel_colors,
-            removed_in,
-        )
-        config[CONF_CHANNEL_COLORS] = channel_colors
-        return config
-
-    return validator
-
-
-def _final_validate(config: ConfigType) -> None:
+def _final_validate(config: ConfigType) -> ConfigType:
    """Validate all recorded effect name references against their target lights.

    This runs once per light platform instance. If no light platform is configured,
@@ -279,7 +173,7 @@ def _final_validate(config: ConfigType) -> None:
    """
    data = _get_data()
    if not data.effect_refs and not data.effect_cycle_refs:
-        return
+        return config

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

+    return config
+

 FINAL_VALIDATE_SCHEMA = _final_validate

@@ -1,41 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-namespace esphome::light {
-
-/// Which byte of an addressable LED's data carries each colour.
-///
-/// Built from a configuration string such as "GRB" or "WRGB": every field holds the
-/// position that colour occupies in the bytes the strip expects. `w` is NO_WHITE when
-/// the strip has no separate white channel.
-struct ChannelColors {
-  /// Value of `w` for a strip that only has red, green and blue channels.
-  static constexpr uint8_t NO_WHITE = 0xFF;
-
-  uint8_t r;
-  uint8_t g;
-  uint8_t b;
-  uint8_t w;
-
-  bool has_white() const { return this->w != NO_WHITE; }
-
-  uint8_t bytes_per_led() const { return this->has_white() ? 4 : 3; }
-
-  /// Write the order back out as text, e.g. "GRBW".
-  ///
-  /// `buf` must have room for at least 5 characters. Returns `buf` so the result can be
-  /// passed straight to a log call.
-  const char *to_string(char *buf) const {
-    buf[this->r] = 'R';
-    buf[this->g] = 'G';
-    buf[this->b] = 'B';
-    if (this->has_white()) {
-      buf[this->w] = 'W';
-    }
-    buf[this->bytes_per_led()] = '\0';
-    return buf;
-  }
-};
-
-}  // namespace esphome::light
@@ -16,9 +16,6 @@ LightColorValues = light_ns.class_("LightColorValues")
 LightStateRTCState = light_ns.struct("LightStateRTCState")
 LightCall = light_ns.class_("LightCall")

-# Addressable strips
-ChannelColors = light_ns.struct("ChannelColors")
-
 # Color modes
 ColorMode = light_ns.enum("ColorMode", is_class=True)
 COLOR_MODES = {
@@ -1,6 +1,6 @@
 from esphome import pins
 import esphome.codegen as cg
-from esphome.components import gpio_expander, i2c
+from esphome.components import i2c
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_ID,
@@ -25,7 +25,7 @@ CONFIG_SCHEMA = (
    cv.Schema(
        {
            cv.Required(CONF_ID): cv.declare_id(MCP23016),
-            cv.Optional(CONF_INTERRUPT_PIN): gpio_expander.validate_interrupt_pin,
+            cv.Optional(CONF_INTERRUPT_PIN): pins.internal_gpio_input_pin_schema,
        }
    )
    .extend(cv.COMPONENT_SCHEMA)
@@ -1,8 +1,8 @@
 from esphome import pins
 import esphome.codegen as cg
-from esphome.components import gpio_expander
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_ALLOW_OTHER_USES,
    CONF_ID,
    CONF_INPUT,
    CONF_INTERRUPT,
@@ -32,10 +32,28 @@ MCP23XXX_INTERRUPT_MODES = {
 }


+def _validate_interrupt_pin(value):
+    # The MCP component owns INT polarity (active-low, hardcoded falling-edge ISR)
+    # and installs a single ISR per GPIO, so neither inversion nor sharing is supported.
+    value = pins.internal_gpio_input_pin_schema(value)
+    if value.get(CONF_INVERTED):
+        raise cv.Invalid(
+            f"'{CONF_INVERTED}: true' is not supported on '{CONF_INTERRUPT_PIN}'; "
+            "the MCP23xxx INT line is fixed active-low"
+        )
+    if value.get(CONF_ALLOW_OTHER_USES):
+        raise cv.Invalid(
+            f"'{CONF_ALLOW_OTHER_USES}: true' is not supported on '{CONF_INTERRUPT_PIN}'; "
+            "sharing the interrupt pin between multiple MCP23xxx (or other components) "
+            "is not implemented. Remove the interrupt_pin to fall back to polling."
+        )
+    return value
+
+
 MCP23XXX_CONFIG_SCHEMA = cv.Schema(
    {
        cv.Optional(CONF_OPEN_DRAIN_INTERRUPT, default=False): cv.boolean,
-        cv.Optional(CONF_INTERRUPT_PIN): gpio_expander.validate_interrupt_pin,
+        cv.Optional(CONF_INTERRUPT_PIN): _validate_interrupt_pin,
    }
 ).extend(cv.COMPONENT_SCHEMA)

@@ -34,7 +34,7 @@ CONF_NONVOLATILE_WRITE_DELAY = "nonvolatile_write_delay"
 VOLATILE_CHANNELS = ("A", "B", "C", "D")


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

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

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


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


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

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


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


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

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


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


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

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


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


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

-    uart.final_validate_device_schema(
+    return uart.final_validate_device_schema(
        DOMAIN,
        require_rx=True,
        require_tx=True,
@@ -219,25 +219,14 @@ void ModbusServerHub::parse_modbus_frames() {
    this->clear_rx_buffer_(LOG_STR("timeout after partial response"), true);
 }

-uint16_t Modbus::find_frame_end_by_crc_(uint16_t min_length) const {
-  // Unknown-length functions (user-defined codes, unimplemented management codes, unassigned values)
-  // could be any length - we have to rely on the CRC to determine completeness.
+uint16_t Modbus::find_custom_frame_end_(uint16_t min_length) const {
+  // Custom functions could be any length - we have to rely on the CRC to determine completeness.
  // If a CRC match is never found, the buffer will eventually overflow and be cleared.
  const uint8_t *raw = &this->rx_buffer_[0];
  const size_t size = this->rx_buffer_.size();
-  const auto max_len = static_cast<uint16_t>(std::min(size, size_t(MAX_FRAME_SIZE)));
-  if (min_length > max_len)
-    return 0;
-  // The Modbus CRC (poly 0xa001, refin/refout false) keeps its running state in the returned value,
-  // so we seed once over the first min_length bytes and extend one byte at a time instead of
-  // recomputing the whole prefix for every candidate length.
-  uint16_t crc = crc16(raw, min_length);
-  if (crc == 0)
-    return min_length;
-  for (uint16_t len = min_length; len < max_len; len++) {
-    crc = crc16(&raw[len], 1, crc);
-    if (crc == 0)
-      return len + 1;
+  for (uint16_t len = min_length; len <= std::min(size, size_t(MAX_FRAME_SIZE)); len++) {
+    if (crc16(raw, len) == 0)
+      return len;
  }
  return 0;
 }
@@ -252,11 +241,11 @@ bool Modbus::parse_modbus_server_frame_() {
  uint8_t address = this->rx_buffer_[0];
  uint8_t function_code = this->rx_buffer_[1];

-  if (helpers::is_function_code_unknown_length(function_code)) {
-    frame_length = this->find_frame_end_by_crc_(frame_length);
+  if (helpers::is_function_code_custom(function_code)) {
+    frame_length = this->find_custom_frame_end_(frame_length);
    if (frame_length == 0)
      return size < MAX_FRAME_SIZE;  // Continue to parse until we hit max size
-    ESP_LOGD(TAG, "Unknown-length function %02X found", function_code);
+    ESP_LOGD(TAG, "User-defined function %02X found", function_code);
  } else {
    if (crc16(&this->rx_buffer_[0], frame_length) != 0)
      return false;
@@ -283,11 +272,11 @@ bool ModbusServerHub::parse_modbus_client_frame_() {
  uint8_t address = this->rx_buffer_[0];
  uint8_t function_code = this->rx_buffer_[1];

-  if (helpers::is_function_code_unknown_length(function_code)) {
-    frame_length = this->find_frame_end_by_crc_(frame_length);
+  if (helpers::is_function_code_custom(function_code)) {
+    frame_length = this->find_custom_frame_end_(frame_length);
    if (frame_length == 0)
      return size < MAX_FRAME_SIZE;  // Continue to parse until we hit max size
-    ESP_LOGD(TAG, "Unknown-length function %02X found", function_code);
+    ESP_LOGD(TAG, "User-defined function %02X found", function_code);
  } else {
    if (crc16(&this->rx_buffer_[0], frame_length) != 0)
      return false;
@@ -82,7 +82,7 @@ class Modbus : public uart::UARTDevice, public Component {
  bool send_frame_(const ModbusFrame &frame);
  // Scans forward from min_length to find a frame boundary by CRC match for custom function codes.
  // Returns the matched frame length, or 0 if no valid CRC was found within MAX_FRAME_SIZE.
-  uint16_t find_frame_end_by_crc_(uint16_t min_length) const;
+  uint16_t find_custom_frame_end_(uint16_t min_length) const;

  uint32_t last_modbus_byte_{0};
  uint32_t last_receive_check_{0};
@@ -55,38 +55,6 @@ inline bool is_function_code_custom(uint8_t function_code) {
          masked_function_code <= FUNCTION_CODE_USER_DEFINED_SPACE_2_END);
 }

-/// True for any function code whose frame length the parsers cannot predict - everything the
-/// server_pdu_length()/client_pdu_length() switches fall through to `default` on (keep the case list
-/// in step with those switches). Deliberately wider than is_function_code_custom(): the user-defined
-/// ranges are unknown to the parser too, but so are the assigned-but-unimplemented codes
-/// (READ_EXCEPTION_STATUS, DIAGNOSTICS, GET_COMM_EVENT_*, REPORT_SERVER_ID) and every unassigned value.
-/// The 0x80 exception flag is masked off first, so a frame with it set classifies by its base code -
-/// even though a spec exception reply has a known 2-byte PDU. That is deliberate, matching what
-/// is_function_code_custom() has always done: some vendors use codes with the 0x80 bit set as ordinary
-/// codes with longer payloads, so the response parser CRC-scans these rather than assuming the spec
-/// length. For an intact spec exception the scan matches at its first candidate, so only a corrupt one
-/// pays (recovery by timeout instead of an immediate CRC failure).
-inline bool is_function_code_unknown_length(uint8_t function_code) {
-  switch (static_cast<FunctionCode>(function_code & FUNCTION_CODE_MASK)) {
-    case FunctionCode::READ_COILS:
-    case FunctionCode::READ_DISCRETE_INPUTS:
-    case FunctionCode::READ_HOLDING_REGISTERS:
-    case FunctionCode::READ_INPUT_REGISTERS:
-    case FunctionCode::WRITE_SINGLE_COIL:
-    case FunctionCode::WRITE_SINGLE_REGISTER:
-    case FunctionCode::WRITE_MULTIPLE_COILS:
-    case FunctionCode::WRITE_MULTIPLE_REGISTERS:
-    case FunctionCode::READ_FILE_RECORD:
-    case FunctionCode::WRITE_FILE_RECORD:
-    case FunctionCode::MASK_WRITE_REGISTER:
-    case FunctionCode::READ_WRITE_MULTIPLE_REGISTERS:
-    case FunctionCode::READ_FIFO_QUEUE:
-      return false;
-    default:
-      return true;
-  }
-}
-
 // Returns the expected length of a server response PDU based on the function code.
 // If too few bytes have arrived to determine the length, returns the minimum length. `size` is the
 // number of bytes available so far, which may exceed the eventual PDU (e.g. include the frame's CRC
@@ -135,8 +135,10 @@ def validate_modbus_register(config):
    return config


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


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


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


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

 namespace esphome::mqtt {

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

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

 namespace esphome::nextion {

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

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

 namespace esphome::nextion {

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

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

 namespace esphome::ota {

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

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

@@ -11,7 +11,7 @@

 namespace esphome::ota {

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

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

@@ -46,7 +46,7 @@ static constexpr size_t MIN_BUFFER_SIZE = 256;

 namespace esphome::ota {

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

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

@@ -15,7 +15,7 @@

 namespace esphome::ota {

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

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

@@ -27,7 +27,7 @@ namespace esphome::ota {

 namespace {

-const char *const TAG = "ota";
+const char *const TAG = "ota.host";

 constexpr size_t MAX_OTA_SIZE = 256u * 1024u * 1024u;  // 256 MiB
 constexpr size_t HEADER_PEEK_SIZE = 64;
@@ -11,7 +11,7 @@

 namespace esphome::ota {

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

 OTAResponseTypes IDFOTABackend::register_and_validate_bootloader_part_() {
  // Register the bootloader partition
--- a/Show More
+++ b/Show More