Merge branch 'dev' into socket-lwip-raw-udp

2026-07-10 17:05:36 +00:00 · 2026-04-21 15:08:29 +02:00
parent e7c126d3dc 14defb69b6
commit e191f5fb4b
269 changed files with 7300 additions and 2813 deletions
@@ -1 +1 @@
-f31f13994768b5b07e29624406c9b053bf4bb26e1623ac2bc1e9d4a9477502d6
+c65f1a0804a7765462d570c50891ac719260592df2c9cdfe88233fc346ac59e9
@@ -12,7 +12,7 @@
    "--privileged",
    "-e",
    "GIT_EDITOR=code --wait"
-    // uncomment and edit the path in order to pass though local USB serial to the conatiner
+    // uncomment and edit the path in order to pass through local USB serial to the container
    // , "--device=/dev/ttyACM0"
  ],
  "appPort": 6052,
@@ -22,7 +22,7 @@ runs:
        python-version: ${{ inputs.python-version }}
    - name: Restore Python virtual environment
      id: cache-venv
-      uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+      uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
      with:
        path: venv
        # yamllint disable-line rule:line-length
@@ -20,14 +20,14 @@ env:
 jobs:
  label:
    runs-on: ubuntu-latest
-    if: github.event.action != 'labeled' || github.event.sender.type != 'Bot'
+    if: github.event.pull_request.state == 'open' && (github.event.action != 'labeled' || github.event.sender.type != 'Bot')
    steps:
      - name: Checkout
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2

      - name: Generate a token
        id: generate-token
-        uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859 # v2
+        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v2
        with:
          app-id: ${{ secrets.ESPHOME_GITHUB_APP_ID }}
          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
@@ -47,7 +47,7 @@ jobs:
          python-version: ${{ env.DEFAULT_PYTHON }}
      - name: Restore Python virtual environment
        id: cache-venv
-        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: venv
          # yamllint disable-line rule:line-length
@@ -159,7 +159,7 @@ jobs:
          token: ${{ secrets.CODECOV_TOKEN }}
      - name: Save Python virtual environment cache
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: venv
          key: ${{ runner.os }}-${{ steps.restore-python.outputs.python-version }}-venv-${{ needs.common.outputs.cache-key }}
@@ -198,7 +198,7 @@ jobs:
          python-version: ${{ env.DEFAULT_PYTHON }}
          cache-key: ${{ needs.common.outputs.cache-key }}
      - name: Restore components graph cache
-        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: .temp/components_graph.json
          key: components-graph-${{ hashFiles('esphome/components/**/*.py') }}
@@ -231,7 +231,7 @@ jobs:
          echo "benchmarks=$(echo "$output" | jq -r '.benchmarks')" >> $GITHUB_OUTPUT
      - name: Save components graph cache
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: .temp/components_graph.json
          key: components-graph-${{ hashFiles('esphome/components/**/*.py') }}
@@ -253,7 +253,7 @@ jobs:
          python-version: "3.13"
      - name: Restore Python virtual environment
        id: cache-venv
-        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: venv
          key: ${{ runner.os }}-${{ steps.python.outputs.python-version }}-venv-${{ needs.common.outputs.cache-key }}
@@ -339,7 +339,7 @@ jobs:
          echo "binary=$BINARY" >> $GITHUB_OUTPUT

      - name: Run CodSpeed benchmarks
-        uses: CodSpeedHQ/action@db35df748deb45fdef0960669f57d627c1956c30 # v4
+        uses: CodSpeedHQ/action@658a901452bb54c799643e060733b7afe9121b8d # v4.14.0
        with:
          run: ${{ steps.build.outputs.binary }}
          mode: simulation
@@ -387,14 +387,14 @@ jobs:

      - name: Cache platformio
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: ~/.platformio
          key: platformio-${{ matrix.pio_cache_key }}-${{ hashFiles('platformio.ini') }}

      - name: Cache platformio
        if: github.ref != 'refs/heads/dev'
-        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: ~/.platformio
          key: platformio-${{ matrix.pio_cache_key }}-${{ hashFiles('platformio.ini') }}
@@ -466,14 +466,14 @@ jobs:

      - name: Cache platformio
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: ~/.platformio
          key: platformio-tidyesp32-${{ hashFiles('platformio.ini') }}

      - name: Cache platformio
        if: github.ref != 'refs/heads/dev'
-        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: ~/.platformio
          key: platformio-tidyesp32-${{ hashFiles('platformio.ini') }}
@@ -555,14 +555,14 @@ jobs:

      - name: Cache platformio
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: ~/.platformio
          key: platformio-tidyesp32-${{ hashFiles('platformio.ini') }}

      - name: Cache platformio
        if: github.ref != 'refs/heads/dev'
-        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: ~/.platformio
          key: platformio-tidyesp32-${{ hashFiles('platformio.ini') }}
@@ -817,7 +817,7 @@ jobs:
      - name: Restore cached memory analysis
        id: cache-memory-analysis
        if: steps.check-script.outputs.skip != 'true' && steps.check-tests.outputs.skip != 'true'
-        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: memory-analysis-target.json
          key: ${{ steps.cache-key.outputs.cache-key }}
@@ -841,7 +841,7 @@ jobs:

      - name: Cache platformio
        if: steps.check-script.outputs.skip != 'true' && steps.check-tests.outputs.skip != 'true' && steps.cache-memory-analysis.outputs.cache-hit != 'true'
-        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: ~/.platformio
          key: platformio-memory-${{ fromJSON(needs.determine-jobs.outputs.memory_impact).platform }}-${{ hashFiles('platformio.ini') }}
@@ -883,7 +883,7 @@ jobs:

      - name: Save memory analysis to cache
        if: steps.check-script.outputs.skip != 'true' && steps.check-tests.outputs.skip != 'true' && steps.cache-memory-analysis.outputs.cache-hit != 'true' && steps.build.outcome == 'success'
-        uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: memory-analysis-target.json
          key: ${{ steps.cache-key.outputs.cache-key }}
@@ -930,7 +930,7 @@ jobs:
          python-version: ${{ env.DEFAULT_PYTHON }}
          cache-key: ${{ needs.common.outputs.cache-key }}
      - name: Cache platformio
-        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
        with:
          path: ~/.platformio
          key: platformio-memory-${{ fromJSON(needs.determine-jobs.outputs.memory_impact).platform }}-${{ hashFiles('platformio.ini') }}
@@ -58,7 +58,7 @@ jobs:

      # Initializes the CodeQL tools for scanning.
      - name: Initialize CodeQL
-        uses: github/codeql-action/init@c10b8064de6f491fea524254123dbe5e09572f13 # v4.35.1
+        uses: github/codeql-action/init@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # v4.35.2
        with:
          languages: ${{ matrix.language }}
          build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
          exit 1

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@c10b8064de6f491fea524254123dbe5e09572f13 # v4.35.1
+        uses: github/codeql-action/analyze@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # v4.35.2
        with:
          category: "/language:${{matrix.language}}"
@@ -8,4 +8,4 @@ on:

 jobs:
  lock:
-    uses: esphome/workflows/.github/workflows/lock.yml@main
+    uses: esphome/workflows/.github/workflows/lock.yml@3c4e8446aa1029f1c346a482034b3ee1489077ca  # 2026.4.0
@@ -221,7 +221,7 @@ jobs:
    steps:
      - name: Generate a token
        id: generate-token
-        uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859 # v3.0.0
+        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1
        with:
          app-id: ${{ secrets.ESPHOME_GITHUB_APP_ID }}
          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
@@ -256,7 +256,7 @@ jobs:
    steps:
      - name: Generate a token
        id: generate-token
-        uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859 # v3.0.0
+        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1
        with:
          app-id: ${{ secrets.ESPHOME_GITHUB_APP_ID }}
          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
@@ -287,7 +287,7 @@ jobs:
    steps:
      - name: Generate a token
        id: generate-token
-        uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859 # v3.0.0
+        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1
        with:
          app-id: ${{ secrets.ESPHOME_GITHUB_APP_ID }}
          private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
@@ -11,7 +11,7 @@ ci:
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    # Ruff version.
-    rev: v0.15.10
+    rev: v0.15.11
    hooks:
      # Run the linter.
      - id: ruff
@@ -58,6 +58,7 @@ repos:
        entry: python3 script/run-in-env.py pylint
        language: system
        types: [python]
+        files: ^esphome/.+\.py$
      - id: clang-tidy-hash
        name: Update clang-tidy hash
        entry: python script/clang_tidy_hash.py --update-if-changed
@@ -750,8 +750,15 @@ def upload_using_esptool(
            platformio_api.FlashImage(
                path=idedata.firmware_bin_path, offset=firmware_offset
            ),
-            *idedata.extra_flash_images,
        ]
+        for image in idedata.extra_flash_images:
+            if not image.path.is_file():
+                _LOGGER.warning(
+                    "Skipping missing flash image declared by platform: %s",
+                    image.path,
+                )
+                continue
+            flash_images.append(image)

    mcu = "esp8266"
    if CORE.is_esp32:
@@ -199,11 +199,10 @@ def validate_automation(extra_schema=None, extra_validators=None, single=False):
                    return cv.Schema([schema])(value)
                except cv.Invalid as err2:
                    if "extra keys not allowed" in str(err2) and len(err2.path) == 2:
-                        # pylint: disable=raise-missing-from
-                        raise err
+                        raise err from None
                    if "Unable to find action" in str(err):
-                        raise err2
-                    raise cv.MultipleInvalid([err, err2])
+                        raise err2 from None
+                    raise cv.MultipleInvalid([err, err2]) from None
        elif isinstance(value, dict):
            if CONF_THEN in value:
                return [schema(value)]
@@ -151,8 +151,8 @@ class ConfigBundleCreator:

    def __init__(self, config: dict[str, Any]) -> None:
        self._config = config
-        self._config_dir = CORE.config_dir
-        self._config_path = CORE.config_path
+        self._config_dir = Path(CORE.config_dir).resolve()
+        self._config_path = Path(CORE.config_path).resolve()
        self._files: list[BundleFile] = []
        self._seen_paths: set[Path] = set()
        self._secrets_paths: set[Path] = set()
@@ -258,21 +258,36 @@ class ConfigBundleCreator:
    def _discover_yaml_includes(self) -> None:
        """Discover YAML files loaded during config parsing.

-        We track files by wrapping _load_yaml_internal. The config has already
-        been loaded at this point (bundle is a POST_CONFIG_ACTION), so we
-        re-load just to discover the file list.
+        Deliberately uses a fresh re-parse and force-loads every deferred
+        ``IncludeFile`` to include *all* potentially-reachable includes,
+        even branches not selected by the local substitutions. Bundles are
+        meant to be compiled on another system where command-line
+        substitution overrides may choose a different branch — e.g.
+        ``!include network/${eth_model}/config.yaml`` must ship every
+        candidate so the remote build can pick any one.
+
+        Entries with unresolved substitution variables in the filename
+        path are skipped with a warning (they cannot be resolved without
+        the substitution pass).

        Secrets files are tracked separately so we can filter them to
        only include the keys this config actually references.
        """
+        # Must be a fresh parse: IncludeFile.load() caches its result in
+        # _content, and we discover files by listening for loader calls. On
+        # an already-parsed tree the cache is populated, .load() returns
+        # without calling the loader, the listener never fires, and the
+        # referenced files would be silently dropped from the bundle.
        with yaml_util.track_yaml_loads() as loaded_files:
            try:
-                yaml_util.load_yaml(self._config_path)
+                data = yaml_util.load_yaml(self._config_path)
            except EsphomeError:
                _LOGGER.debug(
                    "Bundle: re-loading YAML for include discovery failed, "
                    "proceeding with partial file list"
                )
+            else:
+                _force_load_include_files(data)

        for fpath in loaded_files:
            if fpath == self._config_path.resolve():
@@ -608,6 +623,57 @@ def _add_bytes_to_tar(tar: tarfile.TarFile, name: str, data: bytes) -> None:
    tar.addfile(info, io.BytesIO(data))


+def _force_load_include_files(obj: Any, _seen: set[int] | None = None) -> None:
+    """Recursively resolve any ``IncludeFile`` instances in a YAML tree.
+
+    Nested ``!include`` returns a deferred ``IncludeFile`` that is only
+    resolved during the substitution pass. During bundle discovery we need
+    the referenced files to actually load so the ``track_yaml_loads``
+    listener fires for them.
+
+    ``IncludeFile`` instances with unresolved substitution variables in the
+    filename cannot be loaded — we skip and warn about those.
+    """
+    if _seen is None:
+        _seen = set()
+
+    if isinstance(obj, yaml_util.IncludeFile):
+        if id(obj) in _seen:
+            return
+        _seen.add(id(obj))
+        if obj.has_unresolved_expressions():
+            _LOGGER.warning(
+                "Bundle: cannot resolve !include %s (referenced from %s) "
+                "with substitutions in path",
+                obj.file,
+                obj.parent_file,
+            )
+            return
+        try:
+            loaded = obj.load()
+        except EsphomeError as err:
+            _LOGGER.warning(
+                "Bundle: failed to load !include %s (referenced from %s): %s",
+                obj.file,
+                obj.parent_file,
+                err,
+            )
+            return
+        _force_load_include_files(loaded, _seen)
+    elif isinstance(obj, dict):
+        if id(obj) in _seen:
+            return
+        _seen.add(id(obj))
+        for value in obj.values():
+            _force_load_include_files(value, _seen)
+    elif isinstance(obj, (list, tuple)):
+        if id(obj) in _seen:
+            return
+        _seen.add(id(obj))
+        for item in obj:
+            _force_load_include_files(item, _seen)
+
+
 def _resolve_include_path(include_path: Any) -> Path | None:
    """Resolve an include path to absolute, skipping system includes."""
    if isinstance(include_path, str) and include_path.startswith("<"):
@@ -2,7 +2,11 @@ import logging

 import esphome.codegen as cg
 from esphome.components import sensor, voltage_sampler
-from esphome.components.esp32 import get_esp32_variant, include_builtin_idf_component
+from esphome.components.esp32 import (
+    get_esp32_variant,
+    include_builtin_idf_component,
+    require_adc_oneshot_iram,
+)
 from esphome.components.nrf52.const import AIN_TO_GPIO, EXTRA_ADC
 from esphome.components.zephyr import (
    zephyr_add_overlay,
@@ -24,6 +28,7 @@ from esphome.const import (
    PlatformFramework,
 )
 from esphome.core import CORE
+from esphome.types import ConfigType

 from . import (
    ATTENUATION_MODES,
@@ -65,6 +70,13 @@ def validate_config(config):
    return config


+def _require_adc_iram(config: ConfigType) -> ConfigType:
+    """Register ADC oneshot IRAM requirement during config validation."""
+    if CORE.is_esp32:
+        require_adc_oneshot_iram()
+    return config
+
+
 ADCSensor = adc_ns.class_(
    "ADCSensor", sensor.Sensor, cg.PollingComponent, voltage_sampler.VoltageSampler
 )
@@ -95,6 +107,7 @@ CONFIG_SCHEMA = cv.All(
    )
    .extend(cv.polling_component_schema("60s")),
    validate_config,
+    _require_adc_iram,
 )

 CONF_ADC_CHANNEL_ID = "adc_channel_id"
@@ -2,6 +2,8 @@
 #include <cstdio>
 #include <cstring>

+#include "esphome/core/alloc_helpers.h"
+
 namespace esphome {
 namespace anova {

@@ -105,14 +107,14 @@ void AnovaCodec::decode(const uint8_t *data, uint16_t length) {
    }
    case READ_TARGET_TEMPERATURE:
    case SET_TARGET_TEMPERATURE: {
-      this->target_temp_ = parse_number<float>(str_until(buf, '\r')).value_or(0.0f);
+      this->target_temp_ = parse_number<float>(str_until(buf, '\r')).value_or(0.0f);  // NOLINT
      if (this->fahrenheit_)
        this->target_temp_ = ftoc(this->target_temp_);
      this->has_target_temp_ = true;
      break;
    }
    case READ_CURRENT_TEMPERATURE: {
-      this->current_temp_ = parse_number<float>(str_until(buf, '\r')).value_or(0.0f);
+      this->current_temp_ = parse_number<float>(str_until(buf, '\r')).value_or(0.0f);  // NOLINT
      if (this->fahrenheit_)
        this->current_temp_ = ftoc(this->current_temp_);
      this->has_current_temp_ = true;
@@ -291,12 +291,12 @@ CONFIG_SCHEMA = cv.All(
            cv.SplitDefault(
                CONF_MAX_CONNECTIONS,
                esp8266=4,  # ~40KB free RAM, each connection uses ~500-1000 bytes
-                esp32=8,  # 520KB RAM available
+                esp32=5,  # 520KB RAM available
                rp2040=4,  # 264KB RAM but LWIP constraints
-                bk72xx=8,  # Moderate RAM
-                rtl87xx=8,  # Moderate RAM
+                bk72xx=5,  # Moderate RAM
+                rtl87xx=5,  # Moderate RAM
                host=8,  # Abundant resources
-                ln882x=8,  # Moderate RAM
+                ln882x=5,  # Moderate RAM
            ): cv.int_range(min=1, max=20),
            # Maximum queued send buffers per connection before dropping connection
            # Each buffer uses ~8-12 bytes overhead plus actual message size
@@ -336,8 +336,7 @@ async def to_code(config: ConfigType) -> None:
    cg.add(var.set_batch_delay(config[CONF_BATCH_DELAY]))
    if CONF_LISTEN_BACKLOG in config:
        cg.add(var.set_listen_backlog(config[CONF_LISTEN_BACKLOG]))
-    if CONF_MAX_CONNECTIONS in config:
-        cg.add(var.set_max_connections(config[CONF_MAX_CONNECTIONS]))
+    cg.add_define("MAX_API_CONNECTIONS", config[CONF_MAX_CONNECTIONS])
    cg.add_define("API_MAX_SEND_QUEUE", config[CONF_MAX_SEND_QUEUE])

    # Set USE_API_USER_DEFINED_ACTIONS if any services are enabled
@@ -671,6 +671,7 @@ message SensorStateResponse {
  option (source) = SOURCE_SERVER;
  option (ifdef) = "USE_SENSOR";
  option (no_delay) = true;
+  option (speed_optimized) = true;

  fixed32 key = 1 [(force) = true];
  float state = 2;
@@ -777,9 +778,10 @@ message SubscribeLogsResponse {
  option (source) = SOURCE_SERVER;
  option (log) = false;
  option (no_delay) = false;
+  option (speed_optimized) = true;

-  LogLevel level = 1;
-  bytes message = 3;
+  LogLevel level = 1 [(force) = true];
+  bytes message = 3 [(force) = true];
 }

 // ==================== NOISE ENCRYPTION ====================
@@ -1638,6 +1640,7 @@ message BluetoothLERawAdvertisementsResponse {
  option (source) = SOURCE_SERVER;
  option (ifdef) = "USE_BLUETOOTH_PROXY";
  option (no_delay) = true;
+  option (speed_optimized) = true;

  repeated BluetoothLERawAdvertisement advertisements = 1 [(fixed_array_with_length_define) = "BLUETOOTH_PROXY_ADVERTISEMENT_BATCH_SIZE"];
 }
@@ -23,6 +23,7 @@ extend google.protobuf.MessageOptions {
    optional bool no_delay = 1040 [default=false];
    optional string base_class = 1041;
    optional bool inline_encode = 1042 [default=false];
+    optional bool speed_optimized = 1043 [default=false];
 }

 extend google.protobuf.FieldOptions {
@@ -745,7 +745,9 @@ uint32_t ListEntitiesSensorResponse::calculate_size() const {
 #endif
  return size;
 }
-uint8_t *SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
+uint8_t *
+SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
  uint8_t *__restrict__ pos = buffer.get_pos();
  ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, this->key);
  ProtoEncode::encode_float(pos PROTO_ENCODE_DEBUG_ARG, 2, this->state);
@@ -755,7 +757,9 @@ uint8_t *SensorStateResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG
 #endif
  return pos;
 }
-uint32_t SensorStateResponse::calculate_size() const {
+__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
+uint32_t
+SensorStateResponse::calculate_size() const {
  uint32_t size = 0;
  size += 5;
  size += ProtoSize::calc_float(1, this->state);
@@ -912,16 +916,22 @@ bool SubscribeLogsRequest::decode_varint(uint32_t field_id, proto_varint_value_t
  }
  return true;
 }
-uint8_t *SubscribeLogsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
+uint8_t *
+SubscribeLogsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
  uint8_t *__restrict__ pos = buffer.get_pos();
-  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(this->level));
-  ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 3, this->message_ptr_, this->message_len_);
+  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(this->level), true);
+  ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 26);
+  ProtoEncode::encode_varint_raw(pos PROTO_ENCODE_DEBUG_ARG, this->message_len_);
+  ProtoEncode::encode_raw(pos PROTO_ENCODE_DEBUG_ARG, this->message_ptr_, this->message_len_);
  return pos;
 }
-uint32_t SubscribeLogsResponse::calculate_size() const {
+__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
+uint32_t
+SubscribeLogsResponse::calculate_size() const {
  uint32_t size = 0;
-  size += this->level ? 2 : 0;
-  size += ProtoSize::calc_length(1, this->message_len_);
+  size += 2;
+  size += ProtoSize::calc_length_force(1, this->message_len_);
  return size;
 }
 #ifdef USE_API_NOISE
@@ -2328,7 +2338,9 @@ bool SubscribeBluetoothLEAdvertisementsRequest::decode_varint(uint32_t field_id,
  }
  return true;
 }
-uint8_t *BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
+uint8_t *
+BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
  uint8_t *__restrict__ pos = buffer.get_pos();
  for (uint16_t i = 0; i < this->advertisements_len; i++) {
    auto &sub_msg = this->advertisements[i];
@@ -2350,7 +2362,9 @@ uint8_t *BluetoothLERawAdvertisementsResponse::encode(ProtoWriteBuffer &buffer P
  }
  return pos;
 }
-uint32_t BluetoothLERawAdvertisementsResponse::calculate_size() const {
+__attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
+uint32_t
+BluetoothLERawAdvertisementsResponse::calculate_size() const {
  uint32_t size = 0;
  for (uint16_t i = 0; i < this->advertisements_len; i++) {
    auto &sub_msg = this->advertisements[i];
@@ -118,7 +118,7 @@ void APIServer::loop() {
    this->accept_new_connections_();
  }

-  if (this->clients_.empty()) {
+  if (this->api_connection_count_ == 0) {
    // Check reboot timeout - done in loop to avoid scheduler heap churn
    // (cancelled scheduler items sit in heap memory until their scheduled time)
    if (this->reboot_timeout_ != 0) {
@@ -135,15 +135,15 @@ void APIServer::loop() {
  // Check network connectivity once for all clients
  if (!network::is_connected()) {
    // Network is down - disconnect all clients
-    for (auto &client : this->clients_) {
+    for (auto &client : this->active_clients()) {
      client->on_fatal_error();
      client->log_client_(ESPHOME_LOG_LEVEL_WARN, LOG_STR("Network down; disconnect"));
    }
    // Continue to process and clean up the clients below
  }

-  size_t client_index = 0;
-  while (client_index < this->clients_.size()) {
+  uint8_t client_index = 0;
+  while (client_index < this->api_connection_count_) {
    auto &client = this->clients_[client_index];

    // Common case: process active client
@@ -161,7 +161,7 @@ void APIServer::loop() {
  }
 }

-void APIServer::remove_client_(size_t client_index) {
+void APIServer::remove_client_(uint8_t client_index) {
  auto &client = this->clients_[client_index];

 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
@@ -179,14 +179,17 @@ void APIServer::remove_client_(size_t client_index) {
  // Close socket now (was deferred from on_fatal_error to allow getpeername)
  client->helper_->close();

-  // Swap with the last element and pop (avoids expensive vector shifts)
-  if (client_index < this->clients_.size() - 1) {
-    std::swap(this->clients_[client_index], this->clients_.back());
+  // Swap-and-reset: move the removed client to the trailing slot and null it out so slots
+  // [api_connection_count_, N) remain nullptr.
+  const uint8_t last_index = this->api_connection_count_ - 1;
+  if (client_index < last_index) {
+    std::swap(this->clients_[client_index], this->clients_[last_index]);
  }
-  this->clients_.pop_back();
+  this->clients_[last_index].reset();
+  this->api_connection_count_--;

  // Last client disconnected - set warning and start tracking for reboot timeout
-  if (this->clients_.empty() && this->reboot_timeout_ != 0) {
+  if (this->api_connection_count_ == 0 && this->reboot_timeout_ != 0) {
    this->status_set_warning(LOG_STR("waiting for client connection"));
    this->last_connected_ = App.get_loop_component_start_time();
  }
@@ -210,8 +213,8 @@ void __attribute__((flatten)) APIServer::accept_new_connections_() {
    sock->getpeername_to(peername);

    // Check if we're at the connection limit
-    if (this->clients_.size() >= this->max_connections_) {
-      ESP_LOGW(TAG, "Max connections (%d), rejecting %s", this->max_connections_, peername);
+    if (this->api_connection_count_ >= MAX_API_CONNECTIONS) {
+      ESP_LOGW(TAG, "Max connections (%d), rejecting %s", MAX_API_CONNECTIONS, peername);
      // Immediately close - socket destructor will handle cleanup
      sock.reset();
      continue;
@@ -220,11 +223,11 @@ void __attribute__((flatten)) APIServer::accept_new_connections_() {
    ESP_LOGD(TAG, "Accept %s", peername);

    auto *conn = new APIConnection(std::move(sock), this);
-    this->clients_.emplace_back(conn);
+    this->clients_[this->api_connection_count_++].reset(conn);
    conn->start();

    // First client connected - clear warning and update timestamp
-    if (this->clients_.size() == 1 && this->reboot_timeout_ != 0) {
+    if (this->api_connection_count_ == 1 && this->reboot_timeout_ != 0) {
      this->status_clear_warning();
      this->last_connected_ = App.get_loop_component_start_time();
    }
@@ -237,7 +240,7 @@ void APIServer::dump_config() {
                "  Address: %s:%u\n"
                "  Listen backlog: %u\n"
                "  Max connections: %u",
-                network::get_use_address(), this->port_, this->listen_backlog_, this->max_connections_);
+                network::get_use_address(), this->port_, this->listen_backlog_, MAX_API_CONNECTIONS);
 #ifdef USE_API_NOISE
  ESP_LOGCONFIG(TAG, "  Noise encryption: %s", YESNO(this->noise_ctx_.has_psk()));
  if (!this->noise_ctx_.has_psk()) {
@@ -255,7 +258,7 @@ void APIServer::handle_disconnect(APIConnection *conn) {}
  void APIServer::on_##entity_name##_update(entity_type *obj) { /* NOLINT(bugprone-macro-parentheses) */ \
    if (obj->is_internal()) \
      return; \
-    for (auto &c : this->clients_) { \
+    for (auto &c : this->active_clients()) { \
      if (c->flags_.state_subscription) \
        c->send_##entity_name##_state(obj); \
    } \
@@ -337,7 +340,7 @@ API_DISPATCH_UPDATE(water_heater::WaterHeater, water_heater)
 void APIServer::on_event(event::Event *obj) {
  if (obj->is_internal())
    return;
-  for (auto &c : this->clients_) {
+  for (auto &c : this->active_clients()) {
    if (c->flags_.state_subscription)
      c->send_event(obj);
  }
@@ -349,7 +352,7 @@ void APIServer::on_event(event::Event *obj) {
 void APIServer::on_update(update::UpdateEntity *obj) {
  if (obj->is_internal())
    return;
-  for (auto &c : this->clients_) {
+  for (auto &c : this->active_clients()) {
    if (c->flags_.state_subscription)
      c->send_update_state(obj);
  }
@@ -360,7 +363,7 @@ void APIServer::on_update(update::UpdateEntity *obj) {
 void APIServer::on_zwave_proxy_request(const ZWaveProxyRequest &msg) {
  // We could add code to manage a second subscription type, but, since this message type is
  //  very infrequent and small, we simply send it to all clients
-  for (auto &c : this->clients_)
+  for (auto &c : this->active_clients())
    c->send_message(msg);
 }
 #endif
@@ -375,7 +378,7 @@ void APIServer::send_infrared_rf_receive_event([[maybe_unused]] uint32_t device_
  resp.key = key;
  resp.timings = timings;

-  for (auto &c : this->clients_)
+  for (auto &c : this->active_clients())
    c->send_infrared_rf_receive_event(resp);
 }
 #endif
@@ -392,7 +395,7 @@ void APIServer::set_batch_delay(uint16_t batch_delay) { this->batch_delay_ = bat

 #ifdef USE_API_HOMEASSISTANT_SERVICES
 void APIServer::send_homeassistant_action(const HomeassistantActionRequest &call) {
-  for (auto &client : this->clients_) {
+  for (auto &client : this->active_clients()) {
    client->send_homeassistant_action(call);
  }
 }
@@ -532,7 +535,7 @@ bool APIServer::update_noise_psk_(const SavedNoisePsk &new_psk, const LogString
        return;
      }
      ESP_LOGW(TAG, "Disconnecting all clients to reset PSK");
-      for (auto &c : this->clients_) {
+      for (auto &c : this->active_clients()) {
        DisconnectRequest req;
        c->send_message(req);
      }
@@ -583,7 +586,7 @@ bool APIServer::clear_noise_psk(bool make_active) {

 #ifdef USE_HOMEASSISTANT_TIME
 void APIServer::request_time() {
-  for (auto &client : this->clients_) {
+  for (auto &client : this->active_clients()) {
    if (!client->flags_.remove && client->is_authenticated()) {
      client->send_time_request();
      return;  // Only request from one client to avoid clock conflicts
@@ -593,8 +596,8 @@ void APIServer::request_time() {
 #endif

 bool APIServer::is_connected_with_state_subscription() const {
-  for (const auto &client : this->clients_) {
-    if (client->flags_.state_subscription) {
+  for (uint8_t i = 0; i < this->api_connection_count_; i++) {
+    if (this->clients_[i]->flags_.state_subscription) {
      return true;
    }
  }
@@ -609,7 +612,7 @@ void APIServer::on_log(uint8_t level, const char *tag, const char *message, size
    // we would be filling a buffer we are trying to clear
    return;
  }
-  for (auto &c : this->clients_) {
+  for (auto &c : this->active_clients()) {
    if (!c->flags_.remove && c->get_log_subscription_level() >= level)
      c->try_send_log_message(level, tag, message, message_len);
  }
@@ -618,7 +621,7 @@ void APIServer::on_log(uint8_t level, const char *tag, const char *message, size

 #ifdef USE_CAMERA
 void APIServer::on_camera_image(const std::shared_ptr<camera::CameraImage> &image) {
-  for (auto &c : this->clients_) {
+  for (auto &c : this->active_clients()) {
    if (!c->flags_.remove)
      c->set_camera_state(image);
  }
@@ -635,7 +638,7 @@ void APIServer::on_shutdown() {
  this->batch_delay_ = 5;

  // Send disconnect requests to all connected clients
-  for (auto &c : this->clients_) {
+  for (auto &c : this->active_clients()) {
    DisconnectRequest req;
    if (!c->send_message(req)) {
      // If we can't send the disconnect request directly (tx_buffer full),
@@ -653,7 +656,7 @@ bool APIServer::teardown() {
  this->loop();

  // Return true only when all clients have been torn down
-  return this->clients_.empty();
+  return this->api_connection_count_ == 0;
 }

 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
@@ -21,6 +21,8 @@
 #include "esphome/components/camera/camera.h"
 #endif

+#include <array>
+#include <memory>
 #include <vector>

 namespace esphome::api {
@@ -63,7 +65,6 @@ class APIServer final : public Component,
  void set_batch_delay(uint16_t batch_delay);
  uint16_t get_batch_delay() const { return batch_delay_; }
  void set_listen_backlog(uint8_t listen_backlog) { this->listen_backlog_ = listen_backlog; }
-  void set_max_connections(uint8_t max_connections) { this->max_connections_ = max_connections; }

  // Get reference to shared buffer for API connections
  APIBuffer &get_shared_buffer_ref() { return shared_write_buffer_; }
@@ -186,9 +187,26 @@ class APIServer final : public Component,
  void send_infrared_rf_receive_event(uint32_t device_id, uint32_t key, const std::vector<int32_t> *timings);
 #endif

-  bool is_connected() const { return !this->clients_.empty(); }
+  bool is_connected() const { return this->api_connection_count_ != 0; }
  bool is_connected_with_state_subscription() const;

+  // Range-for view over the populated slice [0, api_connection_count_). Read-only with respect
+  // to ownership — callers get `const unique_ptr&` so they can invoke non-const methods on the
+  // APIConnection but cannot reset/move the slot and break the count invariant.
+  using APIConnectionPtr = std::unique_ptr<APIConnection>;
+  class ActiveClientsView {
+    const APIConnectionPtr *begin_;
+    const APIConnectionPtr *end_;
+
+   public:
+    ActiveClientsView(const APIConnectionPtr *b, const APIConnectionPtr *e) : begin_(b), end_(e) {}
+    const APIConnectionPtr *begin() const { return this->begin_; }
+    const APIConnectionPtr *end() const { return this->end_; }
+  };
+  ActiveClientsView active_clients() const {
+    return {this->clients_.data(), this->clients_.data() + this->api_connection_count_};
+  }
+
 #ifdef USE_API_HOMEASSISTANT_STATES
  struct HomeAssistantStateSubscription {
    const char *entity_id;  // Pointer to flash (internal) or heap (external)
@@ -234,8 +252,8 @@ class APIServer final : public Component,
 protected:
  // Accept incoming socket connections. Only called when socket has pending connections.
  void __attribute__((noinline)) accept_new_connections_();
-  // Remove a disconnected client by index. Swaps with last element and pops.
-  void __attribute__((noinline)) remove_client_(size_t client_index);
+  // Remove a disconnected client by index. Swaps with the last populated slot and resets it.
+  void __attribute__((noinline)) remove_client_(uint8_t client_index);

 #ifdef USE_API_NOISE
  bool update_noise_psk_(const SavedNoisePsk &new_psk, const LogString *save_log_msg, const LogString *fail_log_msg,
@@ -273,8 +291,9 @@ class APIServer final : public Component,
  uint32_t reboot_timeout_{300000};
  uint32_t last_connected_{0};

+  // Slots [0, api_connection_count_) are populated; trailing slots are always nullptr.
+  std::array<std::unique_ptr<APIConnection>, MAX_API_CONNECTIONS> clients_{};
  // Vectors and strings (12 bytes each on 32-bit)
-  std::vector<std::unique_ptr<APIConnection>> clients_;
  // Shared proto write buffer for all connections.
  // Not pre-allocated: all send paths call prepare_first_message_buffer() which
  // reserves the exact needed size. Pre-allocating here would cause heap fragmentation
@@ -309,10 +328,10 @@ class APIServer final : public Component,
  uint16_t port_{6053};
  uint16_t batch_delay_{100};
  // Connection limits - these defaults will be overridden by config values
-  // from cv.SplitDefault in __init__.py which sets platform-specific defaults
+  // from cv.SplitDefault in __init__.py which sets platform-specific defaults.
  uint8_t listen_backlog_{4};
-  uint8_t max_connections_{8};
  bool shutting_down_ = false;
+  uint8_t api_connection_count_{0};
  // 7 bytes used, 1 byte padding

 #ifdef USE_API_NOISE
@@ -83,7 +83,7 @@ def angle_to_position(value, min=-360, max=360):
        value = angle(min=min, max=max)(value)
        return (RESOLUTION + round(value * ANGLE_TO_POSITION)) % RESOLUTION
    except cv.Invalid as e:
-        raise cv.Invalid(f"When using angle, {e.error_message}")
+        raise cv.Invalid(f"When using angle, {e.error_message}") from e


 def percent_to_position(value):
@@ -164,7 +164,7 @@ def has_valid_range_config():
        except cv.Invalid as e:
            raise cv.Invalid(
                f"The range between start and end position is invalid. It was was {range} but {e.error_message}"
-            )
+            ) from e

    return validator

@@ -111,14 +111,14 @@ class ATM90E32Component : public PollingComponent,
 #endif
  float get_reference_voltage(uint8_t phase) {
 #ifdef USE_NUMBER
-    return (phase >= 0 && phase < 3 && ref_voltages_[phase]) ? ref_voltages_[phase]->state : 120.0;  // Default voltage
+    return (phase < 3 && ref_voltages_[phase]) ? ref_voltages_[phase]->state : 120.0;  // Default voltage
 #else
    return 120.0;  // Default voltage
 #endif
  }
  float get_reference_current(uint8_t phase) {
 #ifdef USE_NUMBER
-    return (phase >= 0 && phase < 3 && ref_currents_[phase]) ? ref_currents_[phase]->state : 5.0f;  // Default current
+    return (phase < 3 && ref_currents_[phase]) ? ref_currents_[phase]->state : 5.0f;  // Default current
 #else
    return 5.0f;   // Default current
 #endif
@@ -1,7 +1,11 @@
 from dataclasses import dataclass

 import esphome.codegen as cg
-from esphome.components.esp32 import add_idf_component, include_builtin_idf_component
+from esphome.components.esp32 import (
+    add_idf_component,
+    add_idf_sdkconfig_option,
+    include_builtin_idf_component,
+)
 import esphome.config_validation as cv
 from esphome.const import CONF_BITS_PER_SAMPLE, CONF_NUM_CHANNELS, CONF_SAMPLE_RATE
 from esphome.core import CORE
@@ -27,6 +31,7 @@ class AudioData:
    flac_support: bool = False
    mp3_support: bool = False
    opus_support: bool = False
+    micro_decoder_support: bool = False


 def _get_data() -> AudioData:
@@ -50,6 +55,11 @@ def request_opus_support() -> None:
    _get_data().opus_support = True


+def request_micro_decoder_support() -> None:
+    """Request micro-decoder library support for audio decoding."""
+    _get_data().micro_decoder_support = True
+
+
 CONF_MIN_BITS_PER_SAMPLE = "min_bits_per_sample"
 CONF_MAX_BITS_PER_SAMPLE = "max_bits_per_sample"
 CONF_MIN_CHANNELS = "min_channels"
@@ -208,6 +218,19 @@ async def to_code(config):
    )

    data = _get_data()
+
+    if data.micro_decoder_support:
+        add_idf_component(name="esphome/micro-decoder", ref="0.1.1")
+
+        # All codecs are enabled by default in micro-decoder, so disable the ones that aren't requested to save flash
+        if not data.flac_support:
+            add_idf_sdkconfig_option("CONFIG_MICRO_DECODER_CODEC_FLAC", False)
+        if not data.mp3_support:
+            add_idf_sdkconfig_option("CONFIG_MICRO_DECODER_CODEC_MP3", False)
+        if not data.opus_support:
+            add_idf_sdkconfig_option("CONFIG_MICRO_DECODER_CODEC_OPUS", False)
+
+    # Legacy audio_decoder.cpp support defines and components
    if data.flac_support:
        cg.add_define("USE_AUDIO_FLAC_SUPPORT")
        add_idf_component(name="esphome/micro-flac", ref="0.1.1")
@@ -116,7 +116,7 @@ def read_audio_file_and_type(file_config: ConfigType) -> tuple[bytes, MockObj]:
        raise cv.Invalid(
            f"Unable to determine audio file type of '{path}'. "
            f"Try re-encoding the file into a supported format. Details: {e}"
-        )
+        ) from e

    media_file_type = audio.AUDIO_FILE_TYPE_ENUM["NONE"]
    if file_type == "wav":
@@ -332,8 +332,9 @@ def parse_multi_click_timing_str(value):
    try:
        state = cv.boolean(parts[0])
    except cv.Invalid:
-        # pylint: disable=raise-missing-from
-        raise cv.Invalid(f"First word must either be ON or OFF, not {parts[0]}")
+        raise cv.Invalid(
+            f"First word must either be ON or OFF, not {parts[0]}"
+        ) from None

    if parts[1] != "for":
        raise cv.Invalid(f"Second word must be 'for', got {parts[1]}")
@@ -350,7 +351,9 @@ def parse_multi_click_timing_str(value):
        try:
            length = cv.positive_time_period_milliseconds(parts[4])
        except cv.Invalid as err:
-            raise cv.Invalid(f"Multi Click Grammar Parsing length failed: {err}")
+            raise cv.Invalid(
+                f"Multi Click Grammar Parsing length failed: {err}"
+            ) from err
        return {CONF_STATE: state, key: str(length)}

    if parts[3] != "to":
@@ -359,12 +362,16 @@ def parse_multi_click_timing_str(value):
    try:
        min_length = cv.positive_time_period_milliseconds(parts[2])
    except cv.Invalid as err:
-        raise cv.Invalid(f"Multi Click Grammar Parsing minimum length failed: {err}")
+        raise cv.Invalid(
+            f"Multi Click Grammar Parsing minimum length failed: {err}"
+        ) from err

    try:
        max_length = cv.positive_time_period_milliseconds(parts[4])
    except cv.Invalid as err:
-        raise cv.Invalid(f"Multi Click Grammar Parsing minimum length failed: {err}")
+        raise cv.Invalid(
+            f"Multi Click Grammar Parsing maximum length failed: {err}"
+        ) from err

    return {
        CONF_STATE: state,
@@ -65,3 +65,8 @@ async def to_code(config):
@pins.PIN_SCHEMA_REGISTRY.register("bk72xx", PIN_SCHEMA)
 async def pin_to_code(config):
    return await libretiny.gpio.component_pin_to_code(config)
+
+
+# Called by writer.py; delegates to the shared libretiny implementation.
+def copy_files() -> None:
+    libretiny.copy_files()
@@ -63,7 +63,7 @@ void BM8563::read_time() {
           rtc_time.day_of_week, rtc_time.hour, rtc_time.minute, rtc_time.second);

  rtc_time.recalc_timestamp_utc(false);
-  if (!rtc_time.is_valid()) {
+  if (!rtc_time.is_valid(/*check_day_of_week=*/true, /*check_day_of_year=*/false)) {
    ESP_LOGE(TAG, "Invalid RTC time, not syncing to system clock.");
    return;
  }
@@ -6,6 +6,7 @@ from esphome.const import CONF_ID, CONF_SAMPLE_RATE, CONF_TEMPERATURE_OFFSET, Fr
 CODEOWNERS = ["@trvrnrth"]
 DEPENDENCIES = ["i2c"]
 AUTO_LOAD = ["sensor", "text_sensor"]
+CONFLICTS_WITH = ["bme68x_bsec2"]
 MULTI_CONF = True

 CONF_BME680_BSEC_ID = "bme680_bsec_id"
@@ -13,10 +13,12 @@ from esphome.const import (
 )

 CODEOWNERS = ["@neffs", "@kbx81"]
+CONFLICTS_WITH = ["bme680_bsec"]

 DOMAIN = "bme68x_bsec2"

 BSEC2_LIBRARY_VERSION = "1.10.2610"
+BME68x_LIBRARY_VERSION = "v1.3.40408"

 CONF_ALGORITHM_OUTPUT = "algorithm_output"
 CONF_BME68X_BSEC2_ID = "bme68x_bsec2_id"
@@ -170,7 +172,9 @@ async def to_code_base(config):
        with open(path, encoding="utf-8") as f:
            bsec2_iaq_config = f.read()
    except Exception as e:
-        raise core.EsphomeError(f"Could not open binary configuration file {path}: {e}")
+        raise core.EsphomeError(
+            f"Could not open binary configuration file {path}: {e}"
+        ) from e

    # Convert retrieved BSEC2 config to an array of ints
    rhs = [int(x) for x in bsec2_iaq_config.split(",")]
@@ -184,16 +188,31 @@ async def to_code_base(config):
    if core.CORE.using_arduino:
        cg.add_library("Wire", None)
        cg.add_library("SPI", None)
-    cg.add_library(
-        "BME68x Sensor library",
-        None,
-        "https://github.com/boschsensortec/Bosch-BME68x-Library#v1.3.40408",
-    )
-    cg.add_library(
-        "BSEC2 Software Library",
-        None,
-        f"https://github.com/boschsensortec/Bosch-BSEC2-Library.git#{BSEC2_LIBRARY_VERSION}",
-    )
+
+    if core.CORE.is_esp32:
+        from esphome.components.esp32 import add_idf_component
+
+        add_idf_component(
+            name="boschsensortec/Bosch-BME68x-Library",
+            repo="https://github.com/esphome-libs/Bosch-BME68x-Library",
+            ref=BME68x_LIBRARY_VERSION,
+        )
+        add_idf_component(
+            name="boschsensortec/Bosch-BSEC2-Library",
+            repo="https://github.com/esphome-libs/Bosch-BSEC2-Library",
+            ref=BSEC2_LIBRARY_VERSION,
+        )
+    else:
+        cg.add_library(
+            "BME68x Sensor library",
+            None,
+            f"https://github.com/boschsensortec/Bosch-BME68x-Library#{BME68x_LIBRARY_VERSION}",
+        )
+        cg.add_library(
+            "BSEC2 Software Library",
+            None,
+            f"https://github.com/boschsensortec/Bosch-BSEC2-Library.git#{BSEC2_LIBRARY_VERSION}",
+        )

    cg.add_define("USE_BSEC2")

@@ -162,7 +162,6 @@ async def canbus_action_to_code(config, action_id, template_arg, args):
    await cg.register_parented(var, config[CONF_CANBUS_ID])

    if (can_id := config.get(CONF_CAN_ID)) is not None:
-        can_id = await cg.templatable(can_id, args, cg.uint32)
        cg.add(var.set_can_id(can_id))
        cg.add(var.set_use_extended_id(config[CONF_USE_EXTENDED_ID]))

@@ -106,6 +106,30 @@ void IRAM_ATTR CC1101Component::gpio_intr(CC1101Component *arg) { arg->enable_lo

 void CC1101Component::setup() {
  this->spi_setup();
+
+  if (this->gdo0_pin_ != nullptr) {
+    this->gdo0_pin_->setup();
+  }
+
+  this->configure();
+  if (this->is_failed()) {
+    return;
+  }
+
+  // Defer pin mode setup until after all components have completed setup()
+  // This handles the case where remote_transmitter runs after CC1101 and changes pin mode
+  if (this->gdo0_pin_ != nullptr) {
+    this->defer([this]() {
+      this->gdo0_pin_->pin_mode(gpio::FLAG_INPUT);
+      if (this->state_.PKT_FORMAT == static_cast<uint8_t>(PacketFormat::PACKET_FORMAT_FIFO)) {
+        this->gdo0_pin_->attach_interrupt(&CC1101Component::gpio_intr, this, gpio::INTERRUPT_RISING_EDGE);
+      }
+    });
+  }
+}
+
+void CC1101Component::configure() {
+  // Manual reset sequence per CC1101 datasheet section 19.1.2
  this->cs_->digital_write(true);
  delayMicroseconds(1);
  this->cs_->digital_write(false);
@@ -128,11 +152,6 @@ void CC1101Component::setup() {
    return;
  }

-  // Setup GDO0 pin if configured
-  if (this->gdo0_pin_ != nullptr) {
-    this->gdo0_pin_->setup();
-  }
-
  this->initialized_ = true;

  for (uint8_t i = 0; i <= static_cast<uint8_t>(Register::TEST0); i++) {
@@ -142,21 +161,11 @@ void CC1101Component::setup() {
    this->write_(static_cast<Register>(i));
  }
  this->set_output_power(this->output_power_requested_);
+
  if (!this->enter_rx_()) {
    this->mark_failed();
    return;
  }
-
-  // Defer pin mode setup until after all components have completed setup()
-  // This handles the case where remote_transmitter runs after CC1101 and changes pin mode
-  if (this->gdo0_pin_ != nullptr) {
-    this->defer([this]() {
-      this->gdo0_pin_->pin_mode(gpio::FLAG_INPUT);
-      if (this->state_.PKT_FORMAT == static_cast<uint8_t>(PacketFormat::PACKET_FORMAT_FIFO)) {
-        this->gdo0_pin_->attach_interrupt(&CC1101Component::gpio_intr, this, gpio::INTERRUPT_RISING_EDGE);
-      }
-    });
-  }
 }

 void CC1101Component::call_listeners_(const std::vector<uint8_t> &packet, float freq_offset, float rssi, uint8_t lqi) {
@@ -273,7 +282,7 @@ void CC1101Component::begin_rx() {

 void CC1101Component::reset() {
  this->strobe_(Command::RES);
-  this->setup();
+  this->configure();
 }

 void CC1101Component::set_idle() {
@@ -25,6 +25,7 @@ class CC1101Component : public Component,
  void setup() override;
  void loop() override;
  void dump_config() override;
+  void configure();

  // Actions
  void begin_tx();
@@ -30,7 +30,7 @@ void DebugComponent::dump_config() {

  char device_info_buffer[DEVICE_INFO_BUFFER_SIZE];
  ESP_LOGD(TAG, "ESPHome version %s", ESPHOME_VERSION);
-  size_t pos = buf_append_printf(device_info_buffer, DEVICE_INFO_BUFFER_SIZE, 0, "%s", ESPHOME_VERSION);
+  size_t pos = buf_append_str(device_info_buffer, DEVICE_INFO_BUFFER_SIZE, 0, ESPHOME_VERSION);

  this->free_heap_ = get_free_heap_();
  ESP_LOGD(TAG, "Free Heap Size: %" PRIu32 " bytes", this->free_heap_);
@@ -224,17 +224,21 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
  const char *model = ESPHOME_VARIANT;

  // Build features string
-  pos = buf_append_printf(buf, size, pos, "|Chip: %s Features:", model);
+  pos = buf_append_str(buf, size, pos, "|Chip: ");
+  pos = buf_append_str(buf, size, pos, model);
+  pos = buf_append_str(buf, size, pos, " Features:");
  bool first_feature = true;
  for (const auto &feature : CHIP_FEATURES) {
    if (info.features & feature.bit) {
-      pos = buf_append_printf(buf, size, pos, "%s%s", first_feature ? "" : ", ", feature.name);
+      pos = buf_append_str(buf, size, pos, first_feature ? "" : ", ");
+      pos = buf_append_str(buf, size, pos, feature.name);
      first_feature = false;
      info.features &= ~feature.bit;
    }
  }
  if (info.features != 0) {
-    pos = buf_append_printf(buf, size, pos, "%sOther:0x%" PRIx32, first_feature ? "" : ", ", info.features);
+    pos = buf_append_str(buf, size, pos, first_feature ? "" : ", ");
+    pos = buf_append_printf(buf, size, pos, "Other:0x%" PRIx32, info.features);
  }
  pos = buf_append_printf(buf, size, pos, " Cores:%u Revision:%u", info.cores, info.revision);

@@ -267,17 +271,20 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
  // Framework detection
 #ifdef USE_ARDUINO
  ESP_LOGD(TAG, "  Framework: Arduino");
-  pos = buf_append_printf(buf, size, pos, "|Framework: Arduino");
+  pos = buf_append_str(buf, size, pos, "|Framework: Arduino");
 #else
  ESP_LOGD(TAG, "  Framework: ESP-IDF");
-  pos = buf_append_printf(buf, size, pos, "|Framework: ESP-IDF");
+  pos = buf_append_str(buf, size, pos, "|Framework: ESP-IDF");
 #endif

-  pos = buf_append_printf(buf, size, pos, "|ESP-IDF: %s", esp_get_idf_version());
+  pos = buf_append_str(buf, size, pos, "|ESP-IDF: ");
+  pos = buf_append_str(buf, size, pos, esp_get_idf_version());
  pos = buf_append_printf(buf, size, pos, "|EFuse MAC: %02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3],
                          mac[4], mac[5]);
-  pos = buf_append_printf(buf, size, pos, "|Reset: %s", reset_reason);
-  pos = buf_append_printf(buf, size, pos, "|Wakeup: %s", wakeup_cause);
+  pos = buf_append_str(buf, size, pos, "|Reset: ");
+  pos = buf_append_str(buf, size, pos, reset_reason);
+  pos = buf_append_str(buf, size, pos, "|Wakeup: ");
+  pos = buf_append_str(buf, size, pos, wakeup_cause);

  return pos;
 }
@@ -38,9 +38,12 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
           lt_get_version(), lt_cpu_get_model_name(), lt_cpu_get_model(), lt_cpu_get_freq_mhz(), mac_id,
           lt_get_board_code(), flash_kib, ram_kib, reset_reason);

-  pos = buf_append_printf(buf, size, pos, "|Version: %s", LT_BANNER_STR + 10);
-  pos = buf_append_printf(buf, size, pos, "|Reset Reason: %s", reset_reason);
-  pos = buf_append_printf(buf, size, pos, "|Chip Name: %s", lt_cpu_get_model_name());
+  pos = buf_append_str(buf, size, pos, "|Version: ");
+  pos = buf_append_str(buf, size, pos, LT_BANNER_STR + 10);
+  pos = buf_append_str(buf, size, pos, "|Reset Reason: ");
+  pos = buf_append_str(buf, size, pos, reset_reason);
+  pos = buf_append_str(buf, size, pos, "|Chip Name: ");
+  pos = buf_append_str(buf, size, pos, lt_cpu_get_model_name());
  pos = buf_append_printf(buf, size, pos, "|Chip ID: 0x%06" PRIX32, mac_id);
  pos = buf_append_printf(buf, size, pos, "|Flash: %" PRIu32 " KiB", flash_kib);
  pos = buf_append_printf(buf, size, pos, "|RAM: %" PRIu32 " KiB", ram_kib);
@@ -162,14 +162,18 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
  const char *supply_status =
      (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_NORMAL) ? "Normal voltage." : "High voltage.";
  ESP_LOGD(TAG, "Main supply status: %s", supply_status);
-  pos = buf_append_printf(buf, size, pos, "|Main supply status: %s", supply_status);
+  pos = buf_append_str(buf, size, pos, "|Main supply status: ");
+  pos = buf_append_str(buf, size, pos, supply_status);

  // Regulator stage 0
  if (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_HIGH) {
    const char *reg0_type = nrf_power_dcdcen_vddh_get(NRF_POWER) ? "DC/DC" : "LDO";
    const char *reg0_voltage = regout0_to_str((NRF_UICR->REGOUT0 & UICR_REGOUT0_VOUT_Msk) >> UICR_REGOUT0_VOUT_Pos);
    ESP_LOGD(TAG, "Regulator stage 0: %s, %s", reg0_type, reg0_voltage);
-    pos = buf_append_printf(buf, size, pos, "|Regulator stage 0: %s, %s", reg0_type, reg0_voltage);
+    pos = buf_append_str(buf, size, pos, "|Regulator stage 0: ");
+    pos = buf_append_str(buf, size, pos, reg0_type);
+    pos = buf_append_str(buf, size, pos, ", ");
+    pos = buf_append_str(buf, size, pos, reg0_voltage);
 #ifdef USE_NRF52_REG0_VOUT
    if ((NRF_UICR->REGOUT0 & UICR_REGOUT0_VOUT_Msk) >> UICR_REGOUT0_VOUT_Pos != USE_NRF52_REG0_VOUT) {
      ESP_LOGE(TAG, "Regulator stage 0: expected %s", regout0_to_str(USE_NRF52_REG0_VOUT));
@@ -177,13 +181,14 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
 #endif
  } else {
    ESP_LOGD(TAG, "Regulator stage 0: disabled");
-    pos = buf_append_printf(buf, size, pos, "|Regulator stage 0: disabled");
+    pos = buf_append_str(buf, size, pos, "|Regulator stage 0: disabled");
  }

  // Regulator stage 1
  const char *reg1_type = nrf_power_dcdcen_get(NRF_POWER) ? "DC/DC" : "LDO";
  ESP_LOGD(TAG, "Regulator stage 1: %s", reg1_type);
-  pos = buf_append_printf(buf, size, pos, "|Regulator stage 1: %s", reg1_type);
+  pos = buf_append_str(buf, size, pos, "|Regulator stage 1: ");
+  pos = buf_append_str(buf, size, pos, reg1_type);

  // USB power state
  const char *usb_state;
@@ -197,7 +202,8 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
    usb_state = "disconnected";
  }
  ESP_LOGD(TAG, "USB power state: %s", usb_state);
-  pos = buf_append_printf(buf, size, pos, "|USB power state: %s", usb_state);
+  pos = buf_append_str(buf, size, pos, "|USB power state: ");
+  pos = buf_append_str(buf, size, pos, usb_state);

  // Power-fail comparator
  bool enabled;
@@ -302,14 +308,18 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
          break;
      }
      ESP_LOGD(TAG, "Power-fail comparator: %s, VDDH: %s", pof_voltage, vddh_voltage);
-      pos = buf_append_printf(buf, size, pos, "|Power-fail comparator: %s, VDDH: %s", pof_voltage, vddh_voltage);
+      pos = buf_append_str(buf, size, pos, "|Power-fail comparator: ");
+      pos = buf_append_str(buf, size, pos, pof_voltage);
+      pos = buf_append_str(buf, size, pos, ", VDDH: ");
+      pos = buf_append_str(buf, size, pos, vddh_voltage);
    } else {
      ESP_LOGD(TAG, "Power-fail comparator: %s", pof_voltage);
-      pos = buf_append_printf(buf, size, pos, "|Power-fail comparator: %s", pof_voltage);
+      pos = buf_append_str(buf, size, pos, "|Power-fail comparator: ");
+      pos = buf_append_str(buf, size, pos, pof_voltage);
    }
  } else {
    ESP_LOGD(TAG, "Power-fail comparator: disabled");
-    pos = buf_append_printf(buf, size, pos, "|Power-fail comparator: disabled");
+    pos = buf_append_str(buf, size, pos, "|Power-fail comparator: disabled");
  }

  auto package = [](uint32_t value) {
@@ -44,7 +44,7 @@ void DS1307Component::read_time() {
      .year = uint16_t(ds1307_.reg.year + 10u * ds1307_.reg.year_10 + 2000),
  };
  rtc_time.recalc_timestamp_utc(false);
-  if (!rtc_time.is_valid()) {
+  if (!rtc_time.is_valid(/*check_day_of_week=*/true, /*check_day_of_year=*/false)) {
    ESP_LOGE(TAG, "Invalid RTC time, not syncing to system clock.");
    return;
  }
@@ -0,0 +1,97 @@
+#include "epaper_spi_ssd1683.h"
+
+#include <algorithm>
+
+#include "esphome/core/log.h"
+
+namespace esphome::epaper_spi {
+static constexpr const char *const TAG = "epaper_spi.mono";
+
+void EPaperSSD1683::refresh_screen(bool partial) {
+  ESP_LOGV(TAG, "Refresh screen");
+  this->cmd_data(0x3C, {partial ? (uint8_t) 0x80 : (uint8_t) 0x01});
+  // On partial update, set red RAM to inverse to remove BW ghosting
+  this->cmd_data(0x21, {partial ? (uint8_t) 0x80 : (uint8_t) 0x40, (uint8_t) 0x00});
+  // Set full update to 0xD7 for fast update, 0xF7 for normal
+  // Fast update flashes less and draws sooner but is in busy state for the same amount of time
+  // Manufacturer recommends not using fast update all the time, TODO expose this to the user
+  this->cmd_data(0x22, {partial ? (uint8_t) 0xFC : (uint8_t) 0xF7});
+  this->command(0x20);
+}
+
+// Puts the display into deep sleep mode 1, only way to get out is to reset the display
+// Mode 1 retains RAM while sleeping, necessary for future partial and window updates
+void EPaperSSD1683::deep_sleep() {
+  if (this->is_using_partial_update_()) {
+    ESP_LOGV(TAG, "Deep sleep mode 1");
+    this->cmd_data(0x10, {0x01});  // deep sleep, retain RAM
+  } else {
+    ESP_LOGV(TAG, "Deep sleep mode 2");
+    this->cmd_data(0x10, {0x03});  // deep sleep, lose RAM
+  }
+}
+
+void EPaperSSD1683::set_window() {
+  // if not using partial update, the display will go into deep sleep mode 2, so must rewrite entire
+  // buffer since the display RAM will not retain contents
+  if (!this->is_using_partial_update_()) {
+    this->x_low_ = 0;
+    this->x_high_ = this->width_;
+    this->y_low_ = 0;
+    this->y_high_ = this->height_;
+  }
+
+  // round x-coordinates to byte boundaries
+  this->x_low_ /= 8;
+  this->x_high_ += 7;
+  this->x_high_ /= 8;
+
+  this->cmd_data(0x44, {(uint8_t) this->x_low_, (uint8_t) (this->x_high_ - 1)});
+  this->cmd_data(0x45, {(uint8_t) this->y_low_, (uint8_t) (this->y_low_ / 256), (uint8_t) (this->y_high_ - 1),
+                        (uint8_t) ((this->y_high_ - 1) / 256)});
+  this->cmd_data(0x4E, {(uint8_t) this->x_low_});
+  this->cmd_data(0x4F, {(uint8_t) this->y_low_, (uint8_t) (this->y_low_ / 256)});
+}
+
+bool HOT EPaperSSD1683::transfer_data() {
+  auto start_time = millis();
+  if (this->current_data_index_ == 0) {
+    if (this->send_red_) {
+      // round to byte boundaries
+      this->set_window();
+    }
+    // for monochrome, we need to send red on every refresh to prevent dirty pixels
+    // when doing a partial refresh
+    this->command(this->send_red_ ? 0x26 : 0x24);
+    this->current_data_index_ = this->y_low_;  // actually current line
+  }
+  size_t row_length = this->x_high_ - this->x_low_;
+  FixedVector<uint8_t> bytes_to_send{};
+  bytes_to_send.init(row_length);
+  ESP_LOGV(TAG, "Writing %u bytes at line %zu at %ums", row_length, this->current_data_index_, (unsigned) millis());
+  this->start_data_();
+  while (this->current_data_index_ != this->y_high_) {
+    size_t data_idx = this->current_data_index_ * this->row_width_ + this->x_low_;
+    for (size_t i = 0; i != row_length; i++) {
+      bytes_to_send[i] = this->buffer_[data_idx++];
+    }
+    ++this->current_data_index_;
+    this->write_array(&bytes_to_send.front(), row_length);  // NOLINT
+    if (millis() - start_time > MAX_TRANSFER_TIME) {
+      // Let the main loop run and come back next loop
+      this->disable();
+      return false;
+    }
+  }
+
+  this->disable();
+  this->current_data_index_ = 0;
+  if (this->send_red_) {
+    this->send_red_ = false;
+    return false;
+  }
+  this->send_red_ = true;
+  return true;
+}
+
+}  // namespace esphome::epaper_spi
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "epaper_spi_mono.h"
+
+namespace esphome::epaper_spi {
+/**
+ * A class for Solomon SSD1683 epaper displays.
+ */
+class EPaperSSD1683 : public EPaperMono {
+ public:
+  EPaperSSD1683(const char *name, uint16_t width, uint16_t height, const uint8_t *init_sequence,
+                size_t init_sequence_length)
+      : EPaperMono(name, width, height, init_sequence, init_sequence_length) {}
+
+ protected:
+  void refresh_screen(bool partial) override;
+  void deep_sleep() override;
+  void set_window() override;
+  bool transfer_data() override;
+};
+
+}  // namespace esphome::epaper_spi
@@ -43,3 +43,11 @@ wave_4_26.extend(
        },
    },
 )
+
+
+ssd1677.extend(
+    "waveshare-3.97in",
+    width=800,
+    height=480,
+    mirror_x=True,
+)
@@ -0,0 +1,27 @@
+from esphome.const import CONF_DATA_RATE
+
+from . import EpaperModel
+
+
+class SSD1683(EpaperModel):
+    def __init__(self, name, class_name="EPaperSSD1683", data_rate="20MHz", **defaults):
+        defaults[CONF_DATA_RATE] = data_rate
+        super().__init__(name, class_name, **defaults)
+
+    # fmt: off
+    def get_init_sequence(self, config: dict):
+        _width, height = self.get_dimensions(config)
+        return (
+            (0x01, (height - 1) % 256, (height - 1) // 256, 0x00),    # Set column gate limit
+            (0x18, 0x80),    # Select internal Temp sensor
+            (0x11, 0x03),      # Set transform
+        )
+
+
+ssd1683 = SSD1683("ssd1683")
+
+goodisplay_gdey042t81 = ssd1683.extend(
+    "goodisplay-gdey042t81-4.2",
+    width=400,
+    height=300,
+)
@@ -671,11 +671,12 @@ def _is_framework_url(source: str) -> bool:
 # The default/recommended arduino framework version
 #  - https://github.com/espressif/arduino-esp32/releases
 ARDUINO_FRAMEWORK_VERSION_LOOKUP = {
-    "recommended": cv.Version(3, 3, 7),
-    "latest": cv.Version(3, 3, 7),
-    "dev": cv.Version(3, 3, 7),
+    "recommended": cv.Version(3, 3, 8),
+    "latest": cv.Version(3, 3, 8),
+    "dev": cv.Version(3, 3, 8),
 }
 ARDUINO_PLATFORM_VERSION_LOOKUP = {
+    cv.Version(3, 3, 8): cv.Version(55, 3, 38, "1"),
    cv.Version(3, 3, 7): cv.Version(55, 3, 37),
    cv.Version(3, 3, 6): cv.Version(55, 3, 36),
    cv.Version(3, 3, 5): cv.Version(55, 3, 35),
@@ -695,6 +696,7 @@ ARDUINO_PLATFORM_VERSION_LOOKUP = {
 # These versions correspond to pioarduino/esp-idf releases
 # See: https://github.com/pioarduino/esp-idf/releases
 ARDUINO_IDF_VERSION_LOOKUP = {
+    cv.Version(3, 3, 8): cv.Version(5, 5, 4),
    cv.Version(3, 3, 7): cv.Version(5, 5, 3, "1"),
    cv.Version(3, 3, 6): cv.Version(5, 5, 2),
    cv.Version(3, 3, 5): cv.Version(5, 5, 2),
@@ -714,17 +716,15 @@ ARDUINO_IDF_VERSION_LOOKUP = {
 # The default/recommended esp-idf framework version
 #  - https://github.com/espressif/esp-idf/releases
 ESP_IDF_FRAMEWORK_VERSION_LOOKUP = {
-    "recommended": cv.Version(5, 5, 3, "1"),
-    "latest": cv.Version(5, 5, 3, "1"),
+    "recommended": cv.Version(5, 5, 4),
+    "latest": cv.Version(5, 5, 4),
    "dev": cv.Version(5, 5, 4),
 }
 ESP_IDF_PLATFORM_VERSION_LOOKUP = {
    cv.Version(
        6, 0, 0
    ): "https://github.com/pioarduino/platform-espressif32.git#prep_IDF6",
-    cv.Version(
-        5, 5, 4
-    ): "https://github.com/pioarduino/platform-espressif32.git#develop",
+    cv.Version(5, 5, 4): cv.Version(55, 3, 38, "1"),
    cv.Version(5, 5, 3, "1"): cv.Version(55, 3, 37),
    cv.Version(5, 5, 3): cv.Version(55, 3, 37),
    cv.Version(5, 5, 2): cv.Version(55, 3, 37),
@@ -744,8 +744,8 @@ ESP_IDF_PLATFORM_VERSION_LOOKUP = {
 # The platform-espressif32 version
 #  - https://github.com/pioarduino/platform-espressif32/releases
 PLATFORM_VERSION_LOOKUP = {
-    "recommended": cv.Version(55, 3, 37),
-    "latest": cv.Version(55, 3, 37),
+    "recommended": cv.Version(55, 3, 38, "1"),
+    "latest": cv.Version(55, 3, 38, "1"),
    "dev": "https://github.com/pioarduino/platform-espressif32.git#develop",
 }

@@ -1058,6 +1058,7 @@ CONF_DISABLE_MBEDTLS_PEER_CERT = "disable_mbedtls_peer_cert"
 CONF_DISABLE_MBEDTLS_PKCS7 = "disable_mbedtls_pkcs7"
 CONF_DISABLE_REGI2C_IN_IRAM = "disable_regi2c_in_iram"
 CONF_DISABLE_FATFS = "disable_fatfs"
+CONF_ADC_ONESHOT_IN_IRAM = "adc_oneshot_in_iram"

 # VFS requirement tracking
 # Components that need VFS features can call require_vfs_*() functions
@@ -1071,6 +1072,7 @@ KEY_MBEDTLS_PEER_CERT_REQUIRED = "mbedtls_peer_cert_required"
 KEY_MBEDTLS_PKCS7_REQUIRED = "mbedtls_pkcs7_required"
 KEY_FATFS_REQUIRED = "fatfs_required"
 KEY_MBEDTLS_SHA512_REQUIRED = "mbedtls_sha512_required"
+KEY_ADC_ONESHOT_IRAM_REQUIRED = "adc_oneshot_iram_required"


 def require_vfs_select() -> None:
@@ -1168,6 +1170,17 @@ def require_fatfs() -> None:
    CORE.data[KEY_ESP32][KEY_FATFS_REQUIRED] = True


+def require_adc_oneshot_iram() -> None:
+    """Mark that ADC oneshot IRAM safety is required by a component.
+
+    Call this from components that use the ADC oneshot driver. When flash cache is
+    disabled (e.g., during NVS writes by WiFi, BLE, Zigbee, or power management),
+    the ADC oneshot read function must be in IRAM to avoid crashes.
+    This sets CONFIG_ADC_ONESHOT_CTRL_FUNC_IN_IRAM.
+    """
+    CORE.data[KEY_ESP32][KEY_ADC_ONESHOT_IRAM_REQUIRED] = True
+
+
 def _parse_idf_component(value: str) -> ConfigType:
    """Parse IDF component shorthand syntax like 'owner/component^version'"""
    # Match operator followed by version-like string (digit or *)
@@ -1209,7 +1222,7 @@ FRAMEWORK_SCHEMA = cv.Schema(
                cv.Optional(CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False): cv.boolean,
                cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC, default=False): cv.boolean,
                cv.Optional(CONF_MINIMUM_CHIP_REVISION): cv.one_of(
-                    *ESP32_CHIP_REVISIONS
+                    *ESP32_CHIP_REVISIONS, string=True
                ),
                cv.Optional(CONF_SRAM1_AS_IRAM, default=False): cv.boolean,
                # DHCP server is needed for WiFi AP mode. When WiFi component is used,
@@ -1268,6 +1281,7 @@ FRAMEWORK_SCHEMA = cv.Schema(
                cv.Optional(CONF_DISABLE_MBEDTLS_PEER_CERT, default=True): cv.boolean,
                cv.Optional(CONF_DISABLE_MBEDTLS_PKCS7, default=True): cv.boolean,
                cv.Optional(CONF_DISABLE_REGI2C_IN_IRAM, default=True): cv.boolean,
+                cv.Optional(CONF_ADC_ONESHOT_IN_IRAM, default=False): cv.boolean,
                cv.Optional(CONF_DISABLE_FATFS, default=True): cv.boolean,
            }
        ),
@@ -2068,6 +2082,16 @@ async def to_code(config):
    if advanced[CONF_DISABLE_REGI2C_IN_IRAM]:
        add_idf_sdkconfig_option("CONFIG_ESP_REGI2C_CTRL_FUNC_IN_IRAM", False)

+    # Place ADC oneshot control functions in IRAM for cache safety
+    # When flash cache is disabled (during NVS writes by WiFi, BLE, Zigbee, Thread,
+    # power management, etc.), ADC reads will crash if these functions are in flash.
+    # Components using ADC call require_adc_oneshot_iram() to force this.
+    if (
+        CORE.data[KEY_ESP32].get(KEY_ADC_ONESHOT_IRAM_REQUIRED, False)
+        or advanced[CONF_ADC_ONESHOT_IN_IRAM]
+    ):
+        add_idf_sdkconfig_option("CONFIG_ADC_ONESHOT_CTRL_FUNC_IN_IRAM", True)
+
    # Disable FATFS support
    # Components that need FATFS (SD card, etc.) can call require_fatfs()
    if CORE.data[KEY_ESP32].get(KEY_FATFS_REQUIRED, False):
@@ -1960,6 +1960,10 @@ BOARDS = {
        "name": "Hornbill ESP32 Minima",
        "variant": VARIANT_ESP32,
    },
+    "huidu_hd_wf1": {
+        "name": "Huidu HD-WF1",
+        "variant": VARIANT_ESP32S2,
+    },
    "huidu_hd_wf2": {
        "name": "Huidu HD-WF2",
        "variant": VARIANT_ESP32S3,
@@ -2028,6 +2032,10 @@ BOARDS = {
        "name": "LilyGo T-Display-S3",
        "variant": VARIANT_ESP32S3,
    },
+    "lilygo-t-energy-s3": {
+        "name": "LilyGo T-Energy-S3",
+        "variant": VARIANT_ESP32S3,
+    },
    "lilygo-t3-s3": {
        "name": "LilyGo T3-S3",
        "variant": VARIANT_ESP32S3,
@@ -2289,10 +2297,18 @@ BOARDS = {
        "name": "S.ODI Ultra v1",
        "variant": VARIANT_ESP32,
    },
+    "seeed_xiao_esp32_s3_plus": {
+        "name": "Seeed Studio XIAO ESP32S3 Plus",
+        "variant": VARIANT_ESP32S3,
+    },
    "seeed_xiao_esp32c3": {
        "name": "Seeed Studio XIAO ESP32C3",
        "variant": VARIANT_ESP32C3,
    },
+    "seeed_xiao_esp32c5": {
+        "name": "Seeed Studio XIAO ESP32C5",
+        "variant": VARIANT_ESP32C5,
+    },
    "seeed_xiao_esp32c6": {
        "name": "Seeed Studio XIAO ESP32C6",
        "variant": VARIANT_ESP32C6,
@@ -61,6 +61,9 @@ uint32_t arch_get_cpu_freq_hz() {
 }

 TaskHandle_t loop_task_handle = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+static StaticTask_t loop_task_tcb;        // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+static StackType_t
+    loop_task_stack[ESPHOME_LOOP_TASK_STACK_SIZE];  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

 void loop_task(void *pv_params) {
  setup();
@@ -73,9 +76,11 @@ extern "C" void app_main() {
  initArduino();
  esp32::setup_preferences();
 #if CONFIG_FREERTOS_UNICORE
-  xTaskCreate(loop_task, "loopTask", ESPHOME_LOOP_TASK_STACK_SIZE, nullptr, 1, &loop_task_handle);
+  loop_task_handle = xTaskCreateStatic(loop_task, "loopTask", ESPHOME_LOOP_TASK_STACK_SIZE, nullptr, 1, loop_task_stack,
+                                       &loop_task_tcb);
 #else
-  xTaskCreatePinnedToCore(loop_task, "loopTask", ESPHOME_LOOP_TASK_STACK_SIZE, nullptr, 1, &loop_task_handle, 1);
+  loop_task_handle = xTaskCreateStaticPinnedToCore(loop_task, "loopTask", ESPHOME_LOOP_TASK_STACK_SIZE, nullptr, 1,
+                                                   loop_task_stack, &loop_task_tcb, 1);
 #endif
 }

@@ -172,10 +172,16 @@ def validate_gpio_pin(pin):
            exc,
        )
    else:
-        # Throw an exception if used for a pin that would not have resulted
-        # in a validation error anyway!
+        # `ignore_pin_validation_error` only suppresses an error raised by the
+        # variant's pin_validation above (e.g. SPI flash/PSRAM pins, invalid pin
+        # numbers). If that didn't raise, the option is a no-op -- warn so the
+        # user can clean it up, but don't block the build.
        if ignore_pin_validation_warning:
-            raise cv.Invalid(f"GPIO{pin[CONF_NUMBER]} is not a reserved pin")
+            _LOGGER.warning(
+                "GPIO%d has no validation errors to ignore; "
+                "remove `ignore_pin_validation_error: true` from this pin.",
+                pin[CONF_NUMBER],
+            )

    return pin

@@ -4,7 +4,6 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include <nvs_flash.h>
-#include <cinttypes>
 #include <cstring>
 #include <vector>

@@ -12,9 +11,6 @@ namespace esphome::esp32 {

 static const char *const TAG = "preferences";

-// Buffer size for converting uint32_t to string: max "4294967295" (10 chars) + null terminator + 1 padding
-static constexpr size_t KEY_BUFFER_SIZE = 12;
-
 struct NVSData {
  uint32_t key;
  SmallInlineBuffer<8> data;  // Most prefs fit in 8 bytes (covers fan, cover, select, etc.)
@@ -51,8 +47,8 @@ bool ESP32PreferenceBackend::load(uint8_t *data, size_t len) {
    }
  }

-  char key_str[KEY_BUFFER_SIZE];
-  snprintf(key_str, sizeof(key_str), "%" PRIu32, this->key);
+  char key_str[UINT32_MAX_STR_SIZE];
+  uint32_to_str(key_str, this->key);
  size_t actual_len;
  esp_err_t err = nvs_get_blob(this->nvs_handle, key_str, nullptr, &actual_len);
  if (err != 0) {
@@ -108,8 +104,8 @@ bool ESP32Preferences::sync() {
  uint32_t last_key = 0;

  for (const auto &save : s_pending_save) {
-    char key_str[KEY_BUFFER_SIZE];
-    snprintf(key_str, sizeof(key_str), "%" PRIu32, save.key);
+    char key_str[UINT32_MAX_STR_SIZE];
+    uint32_to_str(key_str, save.key);
    ESP_LOGVV(TAG, "Checking if NVS data %s has changed", key_str);
    if (this->is_changed_(this->nvs_handle, save, key_str)) {
      esp_err_t err = nvs_set_blob(this->nvs_handle, key_str, save.data.data(), save.data.size());
@@ -78,6 +78,14 @@ def ota_esphome_final_validate(config):
        else:
            new_ota_conf.append(ota_conf)

+    if len(merged_ota_esphome_configs_by_port) > 1:
+        raise cv.Invalid(
+            f"Only a single port is supported for '{CONF_OTA}' "
+            f"'{CONF_PLATFORM}: {CONF_ESPHOME}'. Got ports "
+            f"{sorted(merged_ota_esphome_configs_by_port.keys())}. Consolidate "
+            f"onto a single port; configs sharing a port are merged automatically."
+        )
+
    new_ota_conf.extend(merged_ota_esphome_configs_by_port.values())

    full_conf[CONF_OTA] = new_ota_conf
@@ -147,6 +155,8 @@ async def to_code(config: ConfigType) -> None:
        cg.add(var.set_auth_password(config[CONF_PASSWORD]))
        cg.add_define("USE_OTA_PASSWORD")
    cg.add_define("USE_OTA_VERSION", config[CONF_VERSION])
+    # Build flag so lwip_fast_select.c (a .c file that can't include defines.h) sees it.
+    cg.add_build_flag("-DUSE_OTA_PLATFORM_ESPHOME")

    await cg.register_component(var, config)
    await ota_to_code(var, config)
@@ -15,6 +15,9 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
+#ifdef USE_LWIP_FAST_SELECT
+#include "esphome/core/lwip_fast_select.h"
+#endif

 #include <cerrno>
 #include <cstdio>
@@ -28,6 +31,17 @@ static constexpr size_t OTA_BUFFER_SIZE = 1024;                  // buffer size
 static constexpr uint32_t OTA_SOCKET_TIMEOUT_HANDSHAKE = 20000;  // milliseconds for initial handshake
 static constexpr uint32_t OTA_SOCKET_TIMEOUT_DATA = 90000;       // milliseconds for data transfer

+// Single-instance pointer — multi-port configs are rejected in final_validate.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+static ESPHomeOTAComponent *global_esphome_ota_component = nullptr;
+
+// Called from any context (LwIP TCP/IP task, RP2040 user-IRQ).
+extern "C" void esphome_wake_ota_component_any_context() {
+  if (global_esphome_ota_component != nullptr) {
+    global_esphome_ota_component->enable_loop_soon_any_context();
+  }
+}
+
 void ESPHomeOTAComponent::setup() {
  this->server_ = socket::socket_ip_loop_monitored(SOCK_STREAM, 0).release();  // monitored for incoming connections
  if (this->server_ == nullptr) {
@@ -65,6 +79,14 @@ void ESPHomeOTAComponent::setup() {
    this->server_failed_(LOG_STR("listen"));
    return;
  }
+
+  // loop() self-disables on its first idle tick; no explicit disable_loop() needed here.
+  global_esphome_ota_component = this;
+#ifdef USE_LWIP_FAST_SELECT
+  // Filter fast-select wakes to this listener only. If the sock lookup returns nullptr,
+  // no wakes fire and loop() falls back to the self-disable safety net.
+  esphome_fast_select_set_ota_listener_sock(esphome_lwip_get_sock(this->server_->get_fd()));
+#endif
 }

 void ESPHomeOTAComponent::dump_config() {
@@ -81,13 +103,15 @@ void ESPHomeOTAComponent::dump_config() {
 }

 void ESPHomeOTAComponent::loop() {
-  // Skip handle_handshake_() call if no client connected and no incoming connections
-  // This optimization reduces idle loop overhead when OTA is not active
-  // Note: No need to check server_ for null as the component is marked failed in setup()
-  // if server_ creation fails
-  if (this->client_ != nullptr || this->server_->ready()) {
-    this->handle_handshake_();
+  // Self-disabling idle loop. Runs when a wake path marks us pending-enable (fast-select
+  // listener filter, raw-TCP accept_fn_, or host select), finds no work, and goes back
+  // to sleep. cleanup_connection_() deliberately leaves the loop enabled for one more
+  // iteration so a connection queued mid-session is still caught here.
+  if (this->client_ == nullptr && !this->server_->ready()) {
+    this->disable_loop();
+    return;
  }
+  this->handle_handshake_();
 }

 static const uint8_t FEATURE_SUPPORTS_COMPRESSION = 0x01;
@@ -566,6 +590,9 @@ void ESPHomeOTAComponent::cleanup_connection_() {
 #ifdef USE_OTA_PASSWORD
  this->cleanup_auth_();
 #endif
+  // Intentionally no disable_loop() — letting loop() run one more iteration catches
+  // any connection that queued on the listener mid-session (otherwise the wake flag,
+  // set while we were in LOOP state, would be lost to enable_pending_loops_()).
 }

 void ESPHomeOTAComponent::yield_and_feed_watchdog_() {
@@ -221,7 +221,7 @@ class EthernetComponent final : public Component {
  int reset_pin_{-1};
  int phy_addr_spi_{-1};
  int clock_speed_;
-  spi_host_device_t interface_{SPI3_HOST};
+  spi_host_device_t interface_{SPI2_HOST};
 #ifdef USE_ETHERNET_SPI_POLLING_SUPPORT
  uint32_t polling_interval_{0};
 #endif
@@ -325,7 +325,7 @@ def download_gfont(value):
            raise cv.Invalid(
                f"Could not download font at {url}, please check the fonts exists "
                f"at google fonts ({e})"
-            )
+            ) from e
        match = re.search(r"src:\s+url\((.+)\)\s+format\('truetype'\);", req.text)
        if match is None:
            raise cv.Invalid(
@@ -108,8 +108,13 @@ async def globals_set_to_code(config, action_id, template_arg, args):
    full_id, paren = await cg.get_variable_with_full_id(config[CONF_ID])
    template_arg = cg.TemplateArguments(full_id.type, *template_arg)
    var = cg.new_Pvariable(action_id, template_arg, paren)
+    # Use the global's value_type alias as the lambda return type so
+    # TemplatableFn stores a direct function pointer instead of going through
+    # the deprecated converting trampoline when the value expression deduces
+    # to a different type (e.g. int literal assigned to a float global).
+    value_type = cg.RawExpression(f"{full_id.type}::value_type")
    templ = await cg.templatable(
-        config[CONF_VALUE], args, None, to_exp=cg.RawExpression, wrap_constant=True
+        config[CONF_VALUE], args, value_type, to_exp=cg.RawExpression
    )
    cg.add(var.set_value(templ))
    return var
@@ -60,20 +60,35 @@ CONFIG_SCHEMA = (
 )


-async def to_code(config):
-    var = await binary_sensor.new_binary_sensor(config)
-    await cg.register_component(var, config)
+def _pin_shared_only_with_deep_sleep(pin_num: int) -> bool:
+    """Check if pin is shared exclusively with deep_sleep (wakeup pin)."""
+    pin_key = (CORE.target_platform, CORE.target_platform, pin_num)
+    pin_users = pins.PIN_SCHEMA_REGISTRY.pins_used.get(pin_key, [])
+    if len(pin_users) != 2:
+        return False
+    return any(path and path[0] == "deep_sleep" for path, _, _ in pin_users)

-    pin = await cg.gpio_pin_expression(config[CONF_PIN])
-    cg.add(var.set_pin(pin))

-    # Check for ESP8266 GPIO16 interrupt limitation
-    # GPIO16 on ESP8266 is a special pin that doesn't support interrupts through
-    # the Arduino attachInterrupt() function. This is the only known GPIO pin
-    # across all supported platforms that has this limitation, so we handle it
-    # here instead of in the platform-specific code.
+def _final_validate(config):
    use_interrupt = config[CONF_USE_INTERRUPT]
-    if use_interrupt and CORE.is_esp8266 and config[CONF_PIN][CONF_NUMBER] == 16:
+    if not use_interrupt:
+        return config
+
+    pin_num = config[CONF_PIN][CONF_NUMBER]
+
+    # Expander pins (e.g. PCF8574, MCP23017) don't support direct interrupt
+    # attachment — only internal/native GPIO pins do.
+    if pins.PIN_SCHEMA_REGISTRY.get_key(config[CONF_PIN]) != CORE.target_platform:
+        _LOGGER.info(
+            "GPIO binary_sensor '%s': Pin is not an internal GPIO, "
+            "falling back to polling mode.",
+            config.get(CONF_NAME, config[CONF_ID]),
+        )
+        config[CONF_USE_INTERRUPT] = False
+        return config
+
+    # GPIO16 on ESP8266 doesn't support interrupts through attachInterrupt().
+    if CORE.is_esp8266 and pin_num == 16:
        _LOGGER.warning(
            "GPIO binary_sensor '%s': GPIO16 on ESP8266 doesn't support interrupts. "
            "Falling back to polling mode (same as in ESPHome <2025.7). "
@@ -81,22 +96,45 @@ async def to_code(config):
            "performance with interrupts.",
            config.get(CONF_NAME, config[CONF_ID]),
        )
-        use_interrupt = False
+        config[CONF_USE_INTERRUPT] = False
+        return config

-    # Check if pin is shared with other components (allow_other_uses)
    # 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
-    if use_interrupt and config[CONF_PIN].get(CONF_ALLOW_OTHER_USES, False):
-        _LOGGER.info(
-            "GPIO binary_sensor '%s': Disabling interrupts because pin %s is shared with other components. "
-            "The sensor will use polling mode for compatibility with other pin uses.",
-            config.get(CONF_NAME, config[CONF_ID]),
-            config[CONF_PIN][CONF_NUMBER],
-        )
-        use_interrupt = False
+    # (e.g., duty_cycle sensor) that need to monitor the pin's state changes.
+    # Exception: deep_sleep wakeup pins are compatible with interrupts when
+    # the pin is only shared between this sensor and deep_sleep (count == 2).
+    if config[CONF_PIN].get(CONF_ALLOW_OTHER_USES, False):
+        if not _pin_shared_only_with_deep_sleep(pin_num):
+            _LOGGER.info(
+                "GPIO binary_sensor '%s': Disabling interrupts because pin %s is shared "
+                "with other components. The sensor will use polling mode for "
+                "compatibility with other pin uses.",
+                config.get(CONF_NAME, config[CONF_ID]),
+                pin_num,
+            )
+            config[CONF_USE_INTERRUPT] = False
+        else:
+            _LOGGER.debug(
+                "GPIO binary_sensor '%s': Pin %s is shared with deep_sleep, "
+                "keeping interrupts enabled.",
+                config.get(CONF_NAME, config[CONF_ID]),
+                pin_num,
+            )

-    if use_interrupt:
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
+async def to_code(config):
+    var = await binary_sensor.new_binary_sensor(config)
+    await cg.register_component(var, config)
+
+    pin = await cg.gpio_pin_expression(config[CONF_PIN])
+    cg.add(var.set_pin(pin))
+
+    if config[CONF_USE_INTERRUPT]:
        cg.add(var.set_interrupt_type(config[CONF_INTERRUPT_TYPE]))
    else:
-        # Only generate call when disabling interrupts (default is true)
-        cg.add(var.set_use_interrupt(use_interrupt))
+        cg.add(var.set_use_interrupt(False))
@@ -46,11 +46,6 @@ void GPIOBinarySensorStore::setup(InternalGPIOPin *pin, Component *component) {
 }

 void GPIOBinarySensor::setup() {
-  if (this->store_.use_interrupt_ && !this->pin_->is_internal()) {
-    ESP_LOGD(TAG, "GPIO is not internal, falling back to polling mode");
-    this->store_.use_interrupt_ = false;
-  }
-
  if (this->store_.use_interrupt_) {
    auto *internal_pin = static_cast<InternalGPIOPin *>(this->pin_);
    this->store_.setup(internal_pin, this);
@@ -127,6 +127,6 @@ async def to_code(config):
    cg.add(var.set_min_temperature(config[CONF_MIN_TEMPERATURE]))
    cg.add_build_flag("-Wno-error=overloaded-virtual")

-    cg.add_library("tonia/HeatpumpIR", "1.0.40")
+    cg.add_library("tonia/HeatpumpIR", "1.0.41")
    if CORE.is_libretiny or CORE.is_esp32:
        CORE.add_platformio_option("lib_ignore", ["IRremoteESP8266"])
@@ -22,7 +22,7 @@ void HttpRequestComponent::dump_config() {
 }

 std::string HttpContainer::get_response_header(const std::string &header_name) {
-  auto lower = str_lower_case(header_name);
+  auto lower = str_lower_case(header_name);  // NOLINT
  for (const auto &entry : this->response_headers_) {
    if (entry.name == lower) {
      ESP_LOGD(TAG, "Header with name %s found with value %s", lower.c_str(), entry.value.c_str());
@@ -11,6 +11,7 @@
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
+#include "esphome/core/alloc_helpers.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"

@@ -400,7 +401,7 @@ class HttpRequestComponent : public Component {
    std::vector<std::string> lower;
    lower.reserve(collect_headers.size());
    for (const auto &h : collect_headers) {
-      lower.push_back(str_lower_case(h));
+      lower.push_back(str_lower_case(h));  // NOLINT
    }
    return this->perform(url, method, body, request_headers, lower);
  }
@@ -415,7 +416,7 @@ class HttpRequestComponent : public Component {
    std::vector<std::string> lower;
    lower.reserve(collect_headers.size());
    for (const auto &h : collect_headers) {
-      lower.push_back(str_lower_case(h));
+      lower.push_back(str_lower_case(h));  // NOLINT
    }
    return this->perform(url, method, body, std::vector<Header>(request_headers.begin(), request_headers.end()), lower);
  }
@@ -161,7 +161,7 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const std::string &ur
  container->response_headers_.clear();
  auto header_count = container->client_.headers();
  for (int i = 0; i < header_count; i++) {
-    const std::string header_name = str_lower_case(container->client_.headerName(i).c_str());
+    const std::string header_name = str_lower_case(container->client_.headerName(i).c_str());  // NOLINT
    if (should_collect_header(lower_case_collect_headers, header_name)) {
      std::string header_value = container->client_.header(i).c_str();
      ESP_LOGD(TAG, "Received response header, name: %s, value: %s", header_name.c_str(), header_value.c_str());
@@ -115,7 +115,7 @@ std::shared_ptr<HttpContainer> HttpRequestHost::perform(const std::string &url,
  container->content_length = container->response_body_.size();
  for (auto header : response.headers) {
    ESP_LOGD(TAG, "Header: %s: %s", header.first.c_str(), header.second.c_str());
-    auto lower_name = str_lower_case(header.first);
+    auto lower_name = str_lower_case(header.first);  // NOLINT
    if (should_collect_header(lower_case_collect_headers, lower_name)) {
      container->response_headers_.push_back({lower_name, header.second});
    }
@@ -38,7 +38,7 @@ esp_err_t HttpRequestIDF::http_event_handler(esp_http_client_event_t *evt) {

  switch (evt->event_id) {
    case HTTP_EVENT_ON_HEADER: {
-      const std::string header_name = str_lower_case(evt->header_key);
+      const std::string header_name = str_lower_case(evt->header_key);  // NOLINT
      if (should_collect_header(user_data->lower_case_collect_headers, header_name)) {
        const std::string header_value = evt->header_value;
        ESP_LOGD(TAG, "Received response header, name: %s, value: %s", header_name.c_str(), header_value.c_str());
@@ -36,7 +36,7 @@ I2SAudioMicrophone = i2s_audio_ns.class_(
 )

 INTERNAL_ADC_VARIANTS = [esp32.VARIANT_ESP32]
-PDM_VARIANTS = [esp32.VARIANT_ESP32, esp32.VARIANT_ESP32S3]
+PDM_VARIANTS = [esp32.VARIANT_ESP32, esp32.VARIANT_ESP32S3, esp32.VARIANT_ESP32P4]


 def _validate_esp32_variant(config):
@@ -283,7 +283,7 @@ async def to_code(config):
            try:
                return Image.open(path)
            except Exception as e:
-                raise core.EsphomeError(f"Could not load image file {path}: {e}")
+                raise core.EsphomeError(f"Could not load image file {path}: {e}") from e

        # make a wide horizontal combined image.
        images = [load_image(x) for x in config[CONF_COLOR_PALETTE_IMAGES]]
@@ -1,5 +1,7 @@
 #pragma once

+#include <cstdint>
+
 namespace esphome {
 namespace ili9xxx {

@@ -229,6 +229,10 @@ void ILI9XXXDisplay::update() {
 }

 void ILI9XXXDisplay::display_() {
+  // buffer may be null if allocation failed
+  if (this->buffer_ == nullptr) {
+    return;
+  }
  // check if something was displayed
  if ((this->x_high_ < this->x_low_) || (this->y_high_ < this->y_low_)) {
    return;
@@ -28,7 +28,6 @@ from esphome.const import (
    CONF_URL,
 )
 from esphome.core import CORE, HexInt
-from esphome.final_validate import full_config

 _LOGGER = logging.getLogger(__name__)

@@ -676,12 +675,16 @@ def _final_validate(config):
    :param config:
    :return:
    """
-    fv = full_config.get()
-    if "lvgl" in fv and not all(CONF_BYTE_ORDER in x for x in config):
-        config = config.copy()
-        for c in config:
-            if not c.get(CONF_BYTE_ORDER):
-                c[CONF_BYTE_ORDER] = "LITTLE_ENDIAN"
+    config = config.copy()
+    for c in config:
+        if byte_order := c.get(CONF_BYTE_ORDER):
+            if byte_order == "BIG_ENDIAN":
+                _LOGGER.warning(
+                    "The image '%s' is configured with big-endian byte order, little-endian is expected",
+                    c.get(CONF_FILE),
+                )
+        else:
+            c[CONF_BYTE_ORDER] = "LITTLE_ENDIAN"
    return config


@@ -753,7 +756,7 @@ async def write_image(config, all_frames=False):
            for col in range(width):
                encoder.encode(pixels[row * width + col])
            encoder.end_row()
-        encoder.end_image()
+    encoder.end_image()

    rhs = [HexInt(x) for x in encoder.data]
    prog_arr = cg.progmem_array(config[CONF_RAW_DATA_ID], rhs)
@@ -189,7 +189,7 @@ Color Image::get_rgb_pixel_(int x, int y) const {
 }
 Color Image::get_rgb565_pixel_(int x, int y) const {
  const uint8_t *pos = this->data_start_ + (x + y * this->width_) * this->bpp_ / 8;
-  uint16_t rgb565 = encode_uint16(progmem_read_byte(pos), progmem_read_byte(pos + 1));
+  uint16_t rgb565 = encode_uint16(progmem_read_byte(pos + 1), progmem_read_byte(pos));
  auto r = (rgb565 & 0xF800) >> 11;
  auto g = (rgb565 & 0x07E0) >> 5;
  auto b = rgb565 & 0x001F;
@@ -360,8 +360,8 @@ void LD2410Component::handle_periodic_data_() {
  */
 #ifdef USE_SENSOR
  SAFE_PUBLISH_SENSOR(this->moving_target_distance_sensor_,
-                      encode_uint16(this->buffer_data_[MOVING_TARGET_HIGH], this->buffer_data_[MOVING_TARGET_LOW]))
-  SAFE_PUBLISH_SENSOR(this->moving_target_energy_sensor_, this->buffer_data_[MOVING_ENERGY])
+                      encode_uint16(this->buffer_data_[MOVING_TARGET_HIGH], this->buffer_data_[MOVING_TARGET_LOW]));
+  SAFE_PUBLISH_SENSOR(this->moving_target_energy_sensor_, this->buffer_data_[MOVING_ENERGY]);
  SAFE_PUBLISH_SENSOR(this->still_target_distance_sensor_,
                      encode_uint16(this->buffer_data_[STILL_TARGET_HIGH], this->buffer_data_[STILL_TARGET_LOW]));
  SAFE_PUBLISH_SENSOR(this->still_target_energy_sensor_, this->buffer_data_[STILL_ENERGY]);
@@ -375,26 +375,26 @@ void LD2410Component::handle_periodic_data_() {
      Moving energy: 20~28th bytes
    */
    for (uint8_t i = 0; i < TOTAL_GATES; i++) {
-      SAFE_PUBLISH_SENSOR(this->gate_move_sensors_[i], this->buffer_data_[MOVING_SENSOR_START + i])
+      SAFE_PUBLISH_SENSOR(this->gate_move_sensors_[i], this->buffer_data_[MOVING_SENSOR_START + i]);
    }
    /*
      Still energy: 29~37th bytes
    */
    for (uint8_t i = 0; i < TOTAL_GATES; i++) {
-      SAFE_PUBLISH_SENSOR(this->gate_still_sensors_[i], this->buffer_data_[STILL_SENSOR_START + i])
+      SAFE_PUBLISH_SENSOR(this->gate_still_sensors_[i], this->buffer_data_[STILL_SENSOR_START + i]);
    }
    /*
      Light sensor: 38th bytes
    */
-    SAFE_PUBLISH_SENSOR(this->light_sensor_, this->buffer_data_[LIGHT_SENSOR])
+    SAFE_PUBLISH_SENSOR(this->light_sensor_, this->buffer_data_[LIGHT_SENSOR]);
  } else {
    for (auto &gate_move_sensor : this->gate_move_sensors_) {
-      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_move_sensor)
+      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_move_sensor);
    }
    for (auto &gate_still_sensor : this->gate_still_sensors_) {
-      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_still_sensor)
+      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_still_sensor);
    }
-    SAFE_PUBLISH_SENSOR_UNKNOWN(this->light_sensor_)
+    SAFE_PUBLISH_SENSOR_UNKNOWN(this->light_sensor_);
  }
 #endif
 #ifdef USE_BINARY_SENSOR
@@ -786,13 +786,12 @@ void LD2410Component::set_light_out_control() {
 }

 #ifdef USE_SENSOR
-// These could leak memory, but they are only set once prior to 'setup()' and should never be used again.
 void LD2410Component::set_gate_move_sensor(uint8_t gate, sensor::Sensor *s) {
-  this->gate_move_sensors_[gate] = new SensorWithDedup<uint8_t>(s);
+  this->gate_move_sensors_[gate].set_sensor(s);
 }

 void LD2410Component::set_gate_still_sensor(uint8_t gate, sensor::Sensor *s) {
-  this->gate_still_sensors_[gate] = new SensorWithDedup<uint8_t>(s);
+  this->gate_still_sensors_[gate].set_sensor(s);
 }
 #endif

@@ -129,8 +129,8 @@ class LD2410Component : public Component, public uart::UARTDevice {
  std::array<number::Number *, TOTAL_GATES> gate_still_threshold_numbers_{};
 #endif
 #ifdef USE_SENSOR
-  std::array<SensorWithDedup<uint8_t> *, TOTAL_GATES> gate_move_sensors_{};
-  std::array<SensorWithDedup<uint8_t> *, TOTAL_GATES> gate_still_sensors_{};
+  std::array<SensorWithDedup<uint8_t>, TOTAL_GATES> gate_move_sensors_{};
+  std::array<SensorWithDedup<uint8_t>, TOTAL_GATES> gate_still_sensors_{};
 #endif
 };

@@ -397,12 +397,12 @@ void LD2412Component::handle_periodic_data_() {
  */
 #ifdef USE_SENSOR
  SAFE_PUBLISH_SENSOR(this->moving_target_distance_sensor_,
-                      encode_uint16(this->buffer_data_[MOVING_TARGET_HIGH], this->buffer_data_[MOVING_TARGET_LOW]))
-  SAFE_PUBLISH_SENSOR(this->moving_target_energy_sensor_, this->buffer_data_[MOVING_ENERGY])
+                      encode_uint16(this->buffer_data_[MOVING_TARGET_HIGH], this->buffer_data_[MOVING_TARGET_LOW]));
+  SAFE_PUBLISH_SENSOR(this->moving_target_energy_sensor_, this->buffer_data_[MOVING_ENERGY]);
  SAFE_PUBLISH_SENSOR(this->still_target_distance_sensor_,
-                      encode_uint16(this->buffer_data_[STILL_TARGET_HIGH], this->buffer_data_[STILL_TARGET_LOW]))
-  SAFE_PUBLISH_SENSOR(this->still_target_energy_sensor_, this->buffer_data_[STILL_ENERGY])
-  if (this->detection_distance_sensor_ != nullptr) {
+                      encode_uint16(this->buffer_data_[STILL_TARGET_HIGH], this->buffer_data_[STILL_TARGET_LOW]));
+  SAFE_PUBLISH_SENSOR(this->still_target_energy_sensor_, this->buffer_data_[STILL_ENERGY]);
+  if (this->detection_distance_sensor_.has_sensor()) {
    int new_detect_distance = 0;
    if (target_state != 0x00 && (target_state & MOVE_BITMASK)) {
      new_detect_distance =
@@ -410,7 +410,7 @@ void LD2412Component::handle_periodic_data_() {
    } else if (target_state != 0x00) {
      new_detect_distance = encode_uint16(this->buffer_data_[STILL_TARGET_HIGH], this->buffer_data_[STILL_TARGET_LOW]);
    }
-    this->detection_distance_sensor_->publish_state_if_not_dup(new_detect_distance);
+    this->detection_distance_sensor_.publish_state_if_not_dup(new_detect_distance);
  }
  if (engineering_mode) {
    // Engineering mode needs at least LIGHT_SENSOR + 1 bytes
@@ -423,27 +423,27 @@ void LD2412Component::handle_periodic_data_() {
        Moving energy: 20~28th bytes
      */
      for (uint8_t i = 0; i < TOTAL_GATES; i++) {
-        SAFE_PUBLISH_SENSOR(this->gate_move_sensors_[i], this->buffer_data_[MOVING_SENSOR_START + i])
+        SAFE_PUBLISH_SENSOR(this->gate_move_sensors_[i], this->buffer_data_[MOVING_SENSOR_START + i]);
      }
      /*
        Still energy: 29~37th bytes
      */
      for (uint8_t i = 0; i < TOTAL_GATES; i++) {
-        SAFE_PUBLISH_SENSOR(this->gate_still_sensors_[i], this->buffer_data_[STILL_SENSOR_START + i])
+        SAFE_PUBLISH_SENSOR(this->gate_still_sensors_[i], this->buffer_data_[STILL_SENSOR_START + i]);
      }
      /*
        Light sensor value
      */
-      SAFE_PUBLISH_SENSOR(this->light_sensor_, this->buffer_data_[LIGHT_SENSOR])
+      SAFE_PUBLISH_SENSOR(this->light_sensor_, this->buffer_data_[LIGHT_SENSOR]);
    }
  } else {
    for (auto &gate_move_sensor : this->gate_move_sensors_) {
-      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_move_sensor)
+      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_move_sensor);
    }
    for (auto &gate_still_sensor : this->gate_still_sensors_) {
-      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_still_sensor)
+      SAFE_PUBLISH_SENSOR_UNKNOWN(gate_still_sensor);
    }
-    SAFE_PUBLISH_SENSOR_UNKNOWN(this->light_sensor_)
+    SAFE_PUBLISH_SENSOR_UNKNOWN(this->light_sensor_);
  }
 #endif
  // the radar module won't tell us when it's done, so we just have to keep polling...
@@ -766,32 +766,38 @@ void LD2412Component::get_distance_resolution_() { this->send_command_(CMD_QUERY
 void LD2412Component::query_light_control_() { this->send_command_(CMD_QUERY_LIGHT_CONTROL, nullptr, 0); }

 void LD2412Component::set_basic_config() {
+  uint8_t min_gate = 1;
+  uint8_t max_gate = TOTAL_GATES;
+  uint16_t timeout = DEFAULT_PRESENCE_TIMEOUT;
+  uint8_t out_pin_level = 0x01;
+
 #ifdef USE_NUMBER
-  if (!this->min_distance_gate_number_->has_state() || !this->max_distance_gate_number_->has_state() ||
-      !this->timeout_number_->has_state()) {
-    return;
+  if (this->min_distance_gate_number_ != nullptr) {
+    if (!this->min_distance_gate_number_->has_state())
+      return;
+    min_gate = static_cast<int>(this->min_distance_gate_number_->state);
+  }
+  if (this->max_distance_gate_number_ != nullptr) {
+    if (!this->max_distance_gate_number_->has_state())
+      return;
+    max_gate = static_cast<int>(this->max_distance_gate_number_->state) + 1;
+  }
+  if (this->timeout_number_ != nullptr) {
+    if (!this->timeout_number_->has_state())
+      return;
+    timeout = static_cast<int>(this->timeout_number_->state);
  }
 #endif
 #ifdef USE_SELECT
-  if (!this->out_pin_level_select_->has_state()) {
-    return;
+  if (this->out_pin_level_select_ != nullptr) {
+    if (!this->out_pin_level_select_->has_state())
+      return;
+    out_pin_level = find_uint8(OUT_PIN_LEVELS_BY_STR, this->out_pin_level_select_->current_option().c_str());
  }
 #endif

  uint8_t value[5] = {
-#ifdef USE_NUMBER
-      lowbyte(static_cast<int>(this->min_distance_gate_number_->state)),
-      lowbyte(static_cast<int>(this->max_distance_gate_number_->state) + 1),
-      lowbyte(static_cast<int>(this->timeout_number_->state)),
-      highbyte(static_cast<int>(this->timeout_number_->state)),
-#else
-      1,    TOTAL_GATES, DEFAULT_PRESENCE_TIMEOUT, 0,
-#endif
-#ifdef USE_SELECT
-      find_uint8(OUT_PIN_LEVELS_BY_STR, this->out_pin_level_select_->current_option().c_str()),
-#else
-      0x01,  // Default value if not using select
-#endif
+      lowbyte(min_gate), lowbyte(max_gate), lowbyte(timeout), highbyte(timeout), out_pin_level,
  };
  this->set_config_mode_(true);
  this->send_command_(CMD_BASIC_CONF, value, sizeof(value));
@@ -846,12 +852,11 @@ void LD2412Component::set_light_out_control() {
 }

 #ifdef USE_SENSOR
-// These could leak memory, but they are only set once prior to 'setup()' and should never be used again.
 void LD2412Component::set_gate_move_sensor(uint8_t gate, sensor::Sensor *s) {
-  this->gate_move_sensors_[gate] = new SensorWithDedup<uint8_t>(s);
+  this->gate_move_sensors_[gate].set_sensor(s);
 }
 void LD2412Component::set_gate_still_sensor(uint8_t gate, sensor::Sensor *s) {
-  this->gate_still_sensors_[gate] = new SensorWithDedup<uint8_t>(s);
+  this->gate_still_sensors_[gate].set_sensor(s);
 }
 #endif

@@ -133,8 +133,8 @@ class LD2412Component : public Component, public uart::UARTDevice {
  std::array<number::Number *, TOTAL_GATES> gate_still_threshold_numbers_{};
 #endif
 #ifdef USE_SENSOR
-  std::array<SensorWithDedup<uint8_t> *, TOTAL_GATES> gate_move_sensors_{};
-  std::array<SensorWithDedup<uint8_t> *, TOTAL_GATES> gate_still_sensors_{};
+  std::array<SensorWithDedup<uint8_t>, TOTAL_GATES> gate_move_sensors_{};
+  std::array<SensorWithDedup<uint8_t>, TOTAL_GATES> gate_still_sensors_{};
 #endif
 };

@@ -565,6 +565,7 @@ void LD2450Component::handle_periodic_data_() {
  SAFE_PUBLISH_SENSOR(this->still_target_count_sensor_, still_target_count);
  // Moving Target Count
  SAFE_PUBLISH_SENSOR(this->moving_target_count_sensor_, moving_target_count);
+
 #endif

 #ifdef USE_BINARY_SENSOR
@@ -872,33 +873,32 @@ void LD2450Component::query_target_tracking_mode_() { this->send_command_(CMD_QU
 void LD2450Component::query_zone_() { this->send_command_(CMD_QUERY_ZONE, nullptr, 0); }

 #ifdef USE_SENSOR
-// These could leak memory, but they are only set once prior to 'setup()' and should never be used again.
 void LD2450Component::set_move_x_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_x_sensors_[target] = new SensorWithDedup<int16_t>(s);
+  this->move_x_sensors_[target].set_sensor(s);
 }
 void LD2450Component::set_move_y_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_y_sensors_[target] = new SensorWithDedup<int16_t>(s);
+  this->move_y_sensors_[target].set_sensor(s);
 }
 void LD2450Component::set_move_speed_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_speed_sensors_[target] = new SensorWithDedup<int16_t>(s);
+  this->move_speed_sensors_[target].set_sensor(s);
 }
 void LD2450Component::set_move_angle_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_angle_sensors_[target] = new SensorWithDedup<float>(s);
+  this->move_angle_sensors_[target].set_sensor(s);
 }
 void LD2450Component::set_move_distance_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_distance_sensors_[target] = new SensorWithDedup<uint16_t>(s);
+  this->move_distance_sensors_[target].set_sensor(s);
 }
 void LD2450Component::set_move_resolution_sensor(uint8_t target, sensor::Sensor *s) {
-  this->move_resolution_sensors_[target] = new SensorWithDedup<uint16_t>(s);
+  this->move_resolution_sensors_[target].set_sensor(s);
 }
 void LD2450Component::set_zone_target_count_sensor(uint8_t zone, sensor::Sensor *s) {
-  this->zone_target_count_sensors_[zone] = new SensorWithDedup<uint8_t>(s);
+  this->zone_target_count_sensors_[zone].set_sensor(s);
 }
 void LD2450Component::set_zone_still_target_count_sensor(uint8_t zone, sensor::Sensor *s) {
-  this->zone_still_target_count_sensors_[zone] = new SensorWithDedup<uint8_t>(s);
+  this->zone_still_target_count_sensors_[zone].set_sensor(s);
 }
 void LD2450Component::set_zone_moving_target_count_sensor(uint8_t zone, sensor::Sensor *s) {
-  this->zone_moving_target_count_sensors_[zone] = new SensorWithDedup<uint8_t>(s);
+  this->zone_moving_target_count_sensors_[zone].set_sensor(s);
 }
 #endif
 #ifdef USE_TEXT_SENSOR
@@ -182,15 +182,15 @@ class LD2450Component : public Component, public uart::UARTDevice {
  ZoneOfNumbers zone_numbers_[MAX_ZONES];
 #endif
 #ifdef USE_SENSOR
-  std::array<SensorWithDedup<int16_t> *, MAX_TARGETS> move_x_sensors_{};
-  std::array<SensorWithDedup<int16_t> *, MAX_TARGETS> move_y_sensors_{};
-  std::array<SensorWithDedup<int16_t> *, MAX_TARGETS> move_speed_sensors_{};
-  std::array<SensorWithDedup<float> *, MAX_TARGETS> move_angle_sensors_{};
-  std::array<SensorWithDedup<uint16_t> *, MAX_TARGETS> move_distance_sensors_{};
-  std::array<SensorWithDedup<uint16_t> *, MAX_TARGETS> move_resolution_sensors_{};
-  std::array<SensorWithDedup<uint8_t> *, MAX_ZONES> zone_target_count_sensors_{};
-  std::array<SensorWithDedup<uint8_t> *, MAX_ZONES> zone_still_target_count_sensors_{};
-  std::array<SensorWithDedup<uint8_t> *, MAX_ZONES> zone_moving_target_count_sensors_{};
+  std::array<SensorWithDedup<int16_t>, MAX_TARGETS> move_x_sensors_{};
+  std::array<SensorWithDedup<int16_t>, MAX_TARGETS> move_y_sensors_{};
+  std::array<SensorWithDedup<int16_t>, MAX_TARGETS> move_speed_sensors_{};
+  std::array<SensorWithDedup<float>, MAX_TARGETS> move_angle_sensors_{};
+  std::array<SensorWithDedup<uint16_t>, MAX_TARGETS> move_distance_sensors_{};
+  std::array<SensorWithDedup<uint16_t>, MAX_TARGETS> move_resolution_sensors_{};
+  std::array<SensorWithDedup<uint8_t>, MAX_ZONES> zone_target_count_sensors_{};
+  std::array<SensorWithDedup<uint8_t>, MAX_ZONES> zone_still_target_count_sensors_{};
+  std::array<SensorWithDedup<uint8_t>, MAX_ZONES> zone_moving_target_count_sensors_{};
 #endif
 #ifdef USE_TEXT_SENSOR
  std::array<text_sensor::TextSensor *, MAX_TARGETS> direction_text_sensors_{};
@@ -11,28 +11,20 @@

 #define SUB_SENSOR_WITH_DEDUP(name, dedup_type) \
 protected: \
-  ld24xx::SensorWithDedup<dedup_type> *name##_sensor_{nullptr}; \
+  ld24xx::SensorWithDedup<dedup_type> name##_sensor_{}; \
 \
 public: \
-  void set_##name##_sensor(sensor::Sensor *sensor) { \
-    this->name##_sensor_ = new ld24xx::SensorWithDedup<dedup_type>(sensor); \
-  }
+  void set_##name##_sensor(sensor::Sensor *sensor) { this->name##_sensor_.set_sensor(sensor); }
 #endif

 #define LOG_SENSOR_WITH_DEDUP_SAFE(tag, name, sensor) \
-  if ((sensor) != nullptr) { \
-    LOG_SENSOR(tag, name, (sensor)->sens); \
+  if ((sensor).has_sensor()) { \
+    LOG_SENSOR(tag, name, (sensor).get_sensor()); \
  }

-#define SAFE_PUBLISH_SENSOR(sensor, value) \
-  if ((sensor) != nullptr) { \
-    (sensor)->publish_state_if_not_dup(value); \
-  }
+#define SAFE_PUBLISH_SENSOR(sensor, value) (sensor).publish_state_if_not_dup(value)

-#define SAFE_PUBLISH_SENSOR_UNKNOWN(sensor) \
-  if ((sensor) != nullptr) { \
-    (sensor)->publish_state_unknown(); \
-  }
+#define SAFE_PUBLISH_SENSOR_UNKNOWN(sensor) (sensor).publish_state_unknown()

 #define highbyte(val) (uint8_t)((val) >> 8)
 #define lowbyte(val) (uint8_t)((val) &0xff)
@@ -70,25 +62,33 @@ inline void format_version_str(const uint8_t *version, std::span<char, 20> buffe
 }

 #ifdef USE_SENSOR
-// Helper class to store a sensor with a deduplicator & publish state only when the value changes
+/// Sensor with deduplication — sensor may be null, null check is internal.
+/// Stored inline, no heap allocation. Does nothing when no sensor is set.
 template<typename T> class SensorWithDedup {
 public:
-  SensorWithDedup(sensor::Sensor *sens) : sens(sens) {}
+  void set_sensor(sensor::Sensor *sens) {
+    this->sens_ = sens;
+    this->dedup_ = {};
+  }

  void publish_state_if_not_dup(T state) {
-    if (this->publish_dedup.next(state)) {
-      this->sens->publish_state(static_cast<float>(state));
+    if (this->sens_ != nullptr && this->dedup_.next(state)) {
+      this->sens_->publish_state(static_cast<float>(state));
    }
  }

  void publish_state_unknown() {
-    if (this->publish_dedup.next_unknown()) {
-      this->sens->publish_state(NAN);
+    if (this->sens_ != nullptr && this->dedup_.next_unknown()) {
+      this->sens_->publish_state(NAN);
    }
  }

-  sensor::Sensor *sens;
-  Deduplicator<T> publish_dedup;
+  bool has_sensor() const { return this->sens_ != nullptr; }
+  sensor::Sensor *get_sensor() const { return this->sens_; }
+
+ protected:
+  sensor::Sensor *sens_{nullptr};
+  Deduplicator<T> dedup_;
 };
 #endif
 }  // namespace esphome::ld24xx
@@ -1,5 +1,6 @@
 import json
 import logging
+from pathlib import Path

 import esphome.codegen as cg
 import esphome.config_validation as cv
@@ -24,6 +25,7 @@ from esphome.const import (
 )
 from esphome.core import CORE
 from esphome.core.config import BOARD_MAX_LENGTH
+from esphome.helpers import copy_file_if_changed
 from esphome.storage_json import StorageJSON

 from . import gpio  # noqa
@@ -465,6 +467,11 @@ async def component_to_code(config):
        # it for project source files only. GCC uses the last -O flag.
        build_src_flags += " -Os"
    cg.add_platformio_option("build_src_flags", build_src_flags)
+    # IRAM_ATTR is a no-op on BK72xx (SDK masks FIQ+IRQ around flash ops).
+    # On other families, patch_linker.py routes .sram.text into the right
+    # RAM-executable output section and prints a post-link placement summary.
+    if FAMILY_COMPONENT[config[CONF_FAMILY]] != COMPONENT_BK72XX:
+        cg.add_platformio_option("extra_scripts", ["pre:patch_linker.py"])
    # dummy version code
    cg.add_define("USE_ARDUINO_VERSION_CODE", cg.RawExpression("VERSION_CODE(0, 0, 0)"))
    # decrease web server stack size (16k words -> 4k words)
@@ -549,3 +556,13 @@ async def component_to_code(config):
    _configure_lwip(config)

    await cg.register_component(var, config)
+
+
+# Called by writer.py
+def copy_files() -> None:
+    script_dir = Path(__file__).parent
+    patch_linker_file = script_dir / "patch_linker.py.script"
+    copy_file_if_changed(
+        patch_linker_file,
+        CORE.relative_build_path("patch_linker.py"),
+    )
@@ -79,6 +79,11 @@ async def to_code(config):
@pins.PIN_SCHEMA_REGISTRY.register("{COMPONENT_LOWER}", PIN_SCHEMA)
 async def pin_to_code(config):
    return await libretiny.gpio.component_pin_to_code(config)
+
+
+# Called by writer.py; delegates to the shared libretiny implementation.
+def copy_files() -> None:
+    libretiny.copy_files()
 '''

 BASE_CODE_BOARDS = '''
@@ -0,0 +1,171 @@
+# pylint: disable=E0602
+Import("env")  # noqa
+
+import os
+import re
+import subprocess
+
+# ESPHome marks ISR code IRAM_ATTR, which on LibreTiny maps to a per-family
+# section routed into RAM-executable memory (see esphome/core/hal.h).
+#
+# This script is NOT loaded on BK72xx (IRAM_ATTR is a no-op there; the SDK
+# masks FIQ+IRQ around flash writes). On the remaining families:
+# - RTL8710B: hal.h uses section(".image2.ram.text"); stock linker consumes it.
+# - RTL8720C: hal.h uses section(".sram.text"); stock linker consumes it.
+# - LN882H: stock linker has no glob for ".sram.text", so we inject
+#   KEEP(*(.sram.text*)) into ".flash_copysection" (> RAM0 AT> FLASH).
+#
+# All families also get a post-link summary showing where IRAM_ATTR landed.
+
+
+_MARKER = "/* esphome .sram.text */"
+# Strong assignments (not PROVIDE) so the symbols are always emitted in the
+# ELF; PROVIDE symbols with no references can be garbage-collected.
+_KEEP_LINE = (
+    "    __esphome_sram_text_start = .; "
+    "KEEP(*(.sram.text*)) "
+    "__esphome_sram_text_end = .; "
+    + _MARKER + "\n"
+)
+_LN_COPY = re.compile(r"(\.flash_copysection\s*:\s*\{\s*\n)")
+
+
+def _detect(env):
+    prefix = "USE_LIBRETINY_VARIANT_"
+    # CPPDEFINES may hold strings or (name, value) tuples; BUILD_FLAGS holds
+    # the raw "-DNAME" strings. PlatformIO populates both, but the exact order
+    # vs. extra_scripts varies, so check both to be robust.
+    for token in env.get("CPPDEFINES", []):
+        if isinstance(token, (list, tuple)):
+            token = token[0]
+        if isinstance(token, str) and token.startswith(prefix):
+            return token[len(prefix):]
+    for flag in env.get("BUILD_FLAGS", []):
+        if isinstance(flag, str) and "-D" + prefix in flag:
+            name = flag.split("-D", 1)[1].split("=", 1)[0].strip()
+            if name.startswith(prefix):
+                return name[len(prefix):]
+    return None
+
+
+KNOWN_VARIANTS = frozenset({
+    "LN882H",
+    "RTL8710B",
+    "RTL8720C",
+})
+
+
+def _inject_keep(host_section):
+    """Return a patcher that injects _KEEP_LINE at the top of `host_section`."""
+    def patch(content):
+        if _MARKER in content:
+            return content
+        return host_section.sub(r"\1" + _KEEP_LINE, content, count=1)
+    return patch
+
+
+# Variants not listed here intentionally have no .ld patcher:
+# - RTL8710B: hal.h uses section(".image2.ram.text") which the stock linker
+#   already routes into .ram_image2.text (> BD_RAM).
+# - RTL8720C: stock linker already consumes *(.sram.text*).
+# - BK72xx (all): SDK masks FIQ+IRQ around flash writes, IRAM_ATTR is no-op.
+_PATCHERS_BY_VARIANT = {
+    "LN882H": (_inject_keep(_LN_COPY),),
+}
+
+
+def _patchers_for(variant):
+    return _PATCHERS_BY_VARIANT.get(variant, ())
+
+
+def _pre_link(target, source, env):
+    build_dir = env.subst("$BUILD_DIR")
+    ld_files = [f for f in os.listdir(build_dir) if f.endswith(".ld")]
+    patched = 0
+    for name in ld_files:
+        path = os.path.join(build_dir, name)
+        with open(path, "r", encoding="utf-8") as fh:
+            original = fh.read()
+        if _MARKER in original:
+            patched += 1
+            continue
+        content = original
+        for fn in _patchers:
+            content = fn(content)
+        if content != original:
+            with open(path, "w", encoding="utf-8") as fh:
+                fh.write(content)
+            print("ESPHome: patched {} for IRAM_ATTR placement".format(name))
+            patched += 1
+    if not patched:
+        raise RuntimeError(
+            "ESPHome: no .ld in {} was patched for IRAM_ATTR. Update the "
+            "regex in patch_linker.py.script (_PATCHERS_BY_VARIANT).".format(
+                build_dir
+            )
+        )
+
+
+# Substrings matched against demangled names as a fallback on RTL8720C,
+# where we cannot inject __esphome_sram_text_start/end markers.
+_FALLBACK_SUBSTRINGS = ("wake_loop_any_context", "wake_loop_isrsafe",
+                        "enable_loop_soon_any_context")
+
+
+def _post_link(target, source, env):
+    """Print where IRAM_ATTR ended up so users can confirm at a glance."""
+    elf = env.subst("$BUILD_DIR/${PROGNAME}.elf")
+    if not os.path.isfile(elf):
+        return
+    nm = env.subst("$NM")
+    try:
+        out = subprocess.check_output(
+            [nm, "--defined-only", "--demangle", elf], text=True
+        )
+    except (OSError, subprocess.CalledProcessError) as exc:
+        print("ESPHome: IRAM_ATTR summary unavailable (nm failed: {})".format(exc))
+        return
+    start = end = None
+    fallback = []
+    for line in out.splitlines():
+        parts = line.split(maxsplit=2)
+        if len(parts) != 3:
+            continue
+        addr_str, _kind, name = parts
+        if name == "__esphome_sram_text_start":
+            start = int(addr_str, 16)
+        elif name == "__esphome_sram_text_end":
+            end = int(addr_str, 16)
+        elif "veneer" not in name and any(s in name for s in _FALLBACK_SUBSTRINGS):
+            fallback.append(int(addr_str, 16))
+    print("ESPHome: IRAM_ATTR placement summary ({}):".format(_variant))
+    if start is not None and end is not None:
+        print("  .sram.text:  {} bytes at 0x{:08x} - 0x{:08x}".format(end - start, start, end))
+    elif fallback:
+        lo, hi = min(fallback), max(fallback)
+        print("  IRAM symbols at 0x{:08x} - 0x{:08x} (approx {} bytes)".format(lo, hi, hi - lo))
+    else:
+        print("  no IRAM_ATTR symbols found")
+
+
+if (_variant := _detect(env)) is None:
+    raise RuntimeError(
+        "ESPHome: could not determine LibreTiny variant from build flags. "
+        "patch_linker.py needs USE_LIBRETINY_VARIANT_* to route IRAM_ATTR "
+        "into SRAM; without it, ISR handlers would silently end up in flash."
+    )
+if _variant not in KNOWN_VARIANTS:
+    raise RuntimeError(
+        "ESPHome: unknown LibreTiny variant {!r}; patch_linker.py does not "
+        "know how to route IRAM_ATTR into SRAM for this family. Update "
+        "patch_linker.py.script before shipping firmware.".format(_variant)
+    )
+
+if _patchers := _patchers_for(_variant):
+    # LibreTiny writes the processed .ld templates into $BUILD_DIR during its
+    # own builder setup, which may run after this script. Register the patch
+    # as a pre-link action so it executes once the linker scripts exist.
+    env.AddPreAction("$BUILD_DIR/${PROGNAME}.elf", _pre_link)
+
+# Post-link summary for every family that reaches this script.
+env.AddPostAction("$BUILD_DIR/${PROGNAME}.elf", _post_link)
@@ -3,7 +3,6 @@
 #include "preferences.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include <cinttypes>
 #include <cstring>
 #include <vector>

@@ -11,9 +10,6 @@ namespace esphome::libretiny {

 static const char *const TAG = "preferences";

-// Buffer size for converting uint32_t to string: max "4294967295" (10 chars) + null terminator + 1 padding
-static constexpr size_t KEY_BUFFER_SIZE = 12;
-
 struct NVSData {
  uint32_t key;
  SmallInlineBuffer<8> data;  // Most prefs fit in 8 bytes (covers fan, cover, select, etc.)
@@ -50,8 +46,8 @@ bool LibreTinyPreferenceBackend::load(uint8_t *data, size_t len) {
    }
  }

-  char key_str[KEY_BUFFER_SIZE];
-  snprintf(key_str, sizeof(key_str), "%" PRIu32, this->key);
+  char key_str[UINT32_MAX_STR_SIZE];
+  uint32_to_str(key_str, this->key);
  fdb_blob_make(this->blob, data, len);
  size_t actual_len = fdb_kv_get_blob(this->db, key_str, this->blob);
  if (actual_len != len) {
@@ -92,8 +88,8 @@ bool LibreTinyPreferences::sync() {
  uint32_t last_key = 0;

  for (const auto &save : s_pending_save) {
-    char key_str[KEY_BUFFER_SIZE];
-    snprintf(key_str, sizeof(key_str), "%" PRIu32, save.key);
+    char key_str[UINT32_MAX_STR_SIZE];
+    uint32_to_str(key_str, save.key);
    ESP_LOGVV(TAG, "Checking if FDB data %s has changed", key_str);
    if (this->is_changed_(&this->db, save, key_str)) {
      ESP_LOGV(TAG, "sync: key: %s, len: %zu", key_str, save.data.size());
@@ -58,6 +58,12 @@ void AddressableLightTransformer::start() {
  // our transition will handle brightness, disable brightness in correction.
  this->light_.correction_.set_local_brightness(255);
  this->target_color_ *= to_uint8_scale(end_values.get_brightness() * end_values.get_state());
+
+  // Uniformity scan is deferred to the first apply() call. start() can run before the underlying
+  // LED output's setup() has allocated its frame buffer (e.g. on_boot at priority > HARDWARE
+  // triggering a transition), and reading through ESPColorView would deref a null buffer.
+  this->uniform_start_scanned_ = false;
+  this->uniform_start_is_uniform_ = false;
 }

 inline constexpr uint8_t subtract_scaled_difference(uint8_t a, uint8_t b, int32_t scale) {
@@ -97,12 +103,57 @@ optional<LightColorValues> AddressableLightTransformer::apply() {
  // non-linear when applying small deltas.

  if (smoothed_progress > this->last_transition_progress_ && this->last_transition_progress_ < 1.f) {
-    int32_t scale = int32_t(256.f * std::max((1.f - smoothed_progress) / (1.f - this->last_transition_progress_), 0.f));
-    for (auto led : this->light_) {
-      led.set_rgbw(subtract_scaled_difference(this->target_color_.red, led.get_red(), scale),
-                   subtract_scaled_difference(this->target_color_.green, led.get_green(), scale),
-                   subtract_scaled_difference(this->target_color_.blue, led.get_blue(), scale),
-                   subtract_scaled_difference(this->target_color_.white, led.get_white(), scale));
+    // Lazy uniformity scan: deferred from start() so the LED output's setup() has run and the
+    // frame buffer is valid. When every LED already has the same color (the common case: plain
+    // turn_on/turn_off on a uniform strip), interpolate math-only against a single start color.
+    // Avoiding the per-step read-back through the 8-bit stored byte prevents gamma round-trip
+    // quantization from stalling the fade at low values (e.g. gamma 2.8 pre-gamma values <27
+    // round to stored 0, freezing progress).
+    if (!this->uniform_start_scanned_) {
+      this->uniform_start_scanned_ = true;
+      if (this->light_.size() > 0) {
+        Color first = this->light_[0].get();
+        bool uniform = true;
+        for (int32_t i = 1; i < this->light_.size(); i++) {
+          if (this->light_[i].get() != first) {
+            uniform = false;
+            break;
+          }
+        }
+        if (uniform) {
+          this->uniform_start_color_ = first;
+          this->uniform_start_is_uniform_ = true;
+        }
+      }
+    }
+    if (this->uniform_start_is_uniform_) {
+      // All LEDs started at the same color: compute the interpolated value once and write it to
+      // every LED. No read-back, so each LED's stored byte advances through every gamma threshold
+      // as smoothed_progress crosses it, instead of stalling at 0 for low pre-gamma values.
+      //
+      // Trade-off: any mid-transition writes to individual LEDs (e.g. from a user lambda) will be
+      // overwritten on the next apply() here. The fallback path below would have respected them
+      // via its read-back. Concurrent per-LED mutation during a transition isn't a pattern we
+      // support, so this is acceptable.
+      // lerp(start, target, progress) via existing helper: target - (target-start)*(1-progress).
+      const Color &start = this->uniform_start_color_;
+      int32_t remaining = int32_t(256.f * (1.f - smoothed_progress));
+      uint8_t r = subtract_scaled_difference(this->target_color_.red, start.red, remaining);
+      uint8_t g = subtract_scaled_difference(this->target_color_.green, start.green, remaining);
+      uint8_t b = subtract_scaled_difference(this->target_color_.blue, start.blue, remaining);
+      uint8_t w = subtract_scaled_difference(this->target_color_.white, start.white, remaining);
+      for (auto led : this->light_) {
+        led.set_rgbw(r, g, b, w);
+      }
+    } else {
+      int32_t scale =
+          int32_t(256.f * std::max((1.f - smoothed_progress) / (1.f - this->last_transition_progress_), 0.f));
+      for (auto led : this->light_) {
+        led.set_rgbw(subtract_scaled_difference(this->target_color_.red, led.get_red(), scale),
+                     subtract_scaled_difference(this->target_color_.green, led.get_green(), scale),
+                     subtract_scaled_difference(this->target_color_.blue, led.get_blue(), scale),
+                     subtract_scaled_difference(this->target_color_.white, led.get_white(), scale));
+      }
    }
    this->last_transition_progress_ = smoothed_progress;
    this->light_.schedule_show();
@@ -115,6 +115,9 @@ class AddressableLightTransformer : public LightTransformer {
  AddressableLight &light_;
  float last_transition_progress_{0.0f};
  Color target_color_{};
+  Color uniform_start_color_{};
+  bool uniform_start_scanned_{false};
+  bool uniform_start_is_uniform_{false};
 };

 }  // namespace esphome::light
@@ -22,4 +22,20 @@ uint8_t ESPColorCorrection::gamma_uncorrect_(uint8_t value) const {
  return (target - a <= b - target) ? lo : lo + 1;
 }

+Color ESPColorCorrection::color_uncorrect(Color color) const {
+  // uncorrected = corrected^(1/gamma) / (max_brightness * local_brightness)
+  return Color(this->color_uncorrect_red(color.red), this->color_uncorrect_green(color.green),
+               this->color_uncorrect_blue(color.blue), this->color_uncorrect_white(color.white));
+}
+
+uint8_t ESPColorCorrection::color_uncorrect_channel_(uint8_t value, uint8_t max_brightness) const {
+  if (max_brightness == 0 || this->local_brightness_ == 0)
+    return 0;
+  // Use 32-bit intermediates: when max_brightness and local_brightness_ are small but non-zero,
+  // (uncorrected / max_brightness) * 255 can exceed 65535 before the std::min(255) clamp runs.
+  uint32_t uncorrected = this->gamma_uncorrect_(value) * 255UL;
+  uint32_t res = ((uncorrected / max_brightness) * 255UL) / this->local_brightness_;
+  return static_cast<uint8_t>(std::min(res, uint32_t(255)));
+}
+
 }  // namespace esphome::light
@@ -46,38 +46,18 @@ class ESPColorCorrection {
    uint8_t res = esp_scale8_twice(white, this->max_brightness_.white, this->local_brightness_);
    return this->gamma_correct_(res);
  }
-  inline Color color_uncorrect(Color color) const ESPHOME_ALWAYS_INLINE {
-    // uncorrected = corrected^(1/gamma) / (max_brightness * local_brightness)
-    return Color(this->color_uncorrect_red(color.red), this->color_uncorrect_green(color.green),
-                 this->color_uncorrect_blue(color.blue), this->color_uncorrect_white(color.white));
-  }
+  Color color_uncorrect(Color color) const;
  inline uint8_t color_uncorrect_red(uint8_t red) const ESPHOME_ALWAYS_INLINE {
-    if (this->max_brightness_.red == 0 || this->local_brightness_ == 0)
-      return 0;
-    uint16_t uncorrected = this->gamma_uncorrect_(red) * 255UL;
-    uint16_t res = ((uncorrected / this->max_brightness_.red) * 255UL) / this->local_brightness_;
-    return (uint8_t) std::min(res, uint16_t(255));
+    return this->color_uncorrect_channel_(red, this->max_brightness_.red);
  }
  inline uint8_t color_uncorrect_green(uint8_t green) const ESPHOME_ALWAYS_INLINE {
-    if (this->max_brightness_.green == 0 || this->local_brightness_ == 0)
-      return 0;
-    uint16_t uncorrected = this->gamma_uncorrect_(green) * 255UL;
-    uint16_t res = ((uncorrected / this->max_brightness_.green) * 255UL) / this->local_brightness_;
-    return (uint8_t) std::min(res, uint16_t(255));
+    return this->color_uncorrect_channel_(green, this->max_brightness_.green);
  }
  inline uint8_t color_uncorrect_blue(uint8_t blue) const ESPHOME_ALWAYS_INLINE {
-    if (this->max_brightness_.blue == 0 || this->local_brightness_ == 0)
-      return 0;
-    uint16_t uncorrected = this->gamma_uncorrect_(blue) * 255UL;
-    uint16_t res = ((uncorrected / this->max_brightness_.blue) * 255UL) / this->local_brightness_;
-    return (uint8_t) std::min(res, uint16_t(255));
+    return this->color_uncorrect_channel_(blue, this->max_brightness_.blue);
  }
  inline uint8_t color_uncorrect_white(uint8_t white) const ESPHOME_ALWAYS_INLINE {
-    if (this->max_brightness_.white == 0 || this->local_brightness_ == 0)
-      return 0;
-    uint16_t uncorrected = this->gamma_uncorrect_(white) * 255UL;
-    uint16_t res = ((uncorrected / this->max_brightness_.white) * 255UL) / this->local_brightness_;
-    return (uint8_t) std::min(res, uint16_t(255));
+    return this->color_uncorrect_channel_(white, this->max_brightness_.white);
  }

 protected:
@@ -85,6 +65,9 @@ class ESPColorCorrection {
  uint8_t gamma_correct_(uint8_t value) const;
  /// Reverse gamma: binary search the forward PROGMEM table
  uint8_t gamma_uncorrect_(uint8_t value) const;
+  /// Shared body of color_uncorrect_{red,green,blue,white}. Kept out-of-line
+  /// to avoid duplicating two 16-bit divides at every call site.
+  uint8_t color_uncorrect_channel_(uint8_t value, uint8_t max_brightness) const;

  const uint16_t *gamma_table_{nullptr};
  Color max_brightness_{255, 255, 255, 255};
@@ -222,7 +222,7 @@ class LightCall {
  inline bool get_save_() { return (this->flags_ & FLAG_SAVE) != 0; }

  // Helper to set flag - defaults to true for common case
-  void set_flag_(FieldFlags flag, bool value = true) {
+  void set_flag_(FieldFlags flag, bool value = true) ESPHOME_ALWAYS_INLINE {
    if (value) {
      this->flags_ |= flag;
    } else {
@@ -231,7 +231,7 @@ class LightCall {
  }

  // Helper to clear flag - reduces code size for common case
-  void clear_flag_(FieldFlags flag) { this->flags_ &= ~flag; }
+  void clear_flag_(FieldFlags flag) ESPHOME_ALWAYS_INLINE { this->flags_ &= ~flag; }

  // Helper to log unsupported feature and clear flag - reduces code duplication
  void log_and_clear_unsupported_(FieldFlags flag, const LogString *feature, bool use_color_mode_log);
@@ -65,3 +65,8 @@ async def to_code(config):
@pins.PIN_SCHEMA_REGISTRY.register("ln882x", PIN_SCHEMA)
 async def pin_to_code(config):
    return await libretiny.gpio.component_pin_to_code(config)
+
+
+# Called by writer.py; delegates to the shared libretiny implementation.
+def copy_files() -> None:
+    libretiny.copy_files()
@@ -35,9 +35,11 @@ LockStateForwarder = lock_ns.class_("LockStateForwarder")
 LockState = lock_ns.enum("LockState")

 LOCK_STATES = {
+    "OPEN": LockState.LOCK_STATE_OPEN,
    "LOCKED": LockState.LOCK_STATE_LOCKED,
    "UNLOCKED": LockState.LOCK_STATE_UNLOCKED,
    "JAMMED": LockState.LOCK_STATE_JAMMED,
+    "OPENING": LockState.LOCK_STATE_OPENING,
    "LOCKING": LockState.LOCK_STATE_LOCKING,
    "UNLOCKING": LockState.LOCK_STATE_UNLOCKING,
 }
@@ -8,9 +8,10 @@ namespace esphome::lock {

 static const char *const TAG = "lock";

-// Lock state strings indexed by LockState enum (0-5): NONE(UNKNOWN), LOCKED, UNLOCKED, JAMMED, LOCKING, UNLOCKING
+// Lock state strings indexed by LockState enum.
 // Index 0 is UNKNOWN (for LOCK_STATE_NONE), also used as fallback for out-of-range
-PROGMEM_STRING_TABLE(LockStateStrings, "UNKNOWN", "LOCKED", "UNLOCKED", "JAMMED", "LOCKING", "UNLOCKING");
+PROGMEM_STRING_TABLE(LockStateStrings, "UNKNOWN", "LOCKED", "UNLOCKED", "JAMMED", "LOCKING", "UNLOCKING", "OPENING",
+                     "OPEN");

 const LogString *lock_state_to_string(LockState state) {
  return LockStateStrings::get_log_str(static_cast<uint8_t>(state), 0);
@@ -74,12 +75,16 @@ LockCall &LockCall::set_state(optional<LockState> state) {
  return *this;
 }
 LockCall &LockCall::set_state(const char *state) {
-  if (ESPHOME_strcasecmp_P(state, ESPHOME_PSTR("LOCKED")) == 0) {
+  if (ESPHOME_strcasecmp_P(state, ESPHOME_PSTR("OPEN")) == 0) {
+    this->set_state(LOCK_STATE_OPEN);
+  } else if (ESPHOME_strcasecmp_P(state, ESPHOME_PSTR("LOCKED")) == 0) {
    this->set_state(LOCK_STATE_LOCKED);
  } else if (ESPHOME_strcasecmp_P(state, ESPHOME_PSTR("UNLOCKED")) == 0) {
    this->set_state(LOCK_STATE_UNLOCKED);
  } else if (ESPHOME_strcasecmp_P(state, ESPHOME_PSTR("JAMMED")) == 0) {
    this->set_state(LOCK_STATE_JAMMED);
+  } else if (ESPHOME_strcasecmp_P(state, ESPHOME_PSTR("OPENING")) == 0) {
+    this->set_state(LOCK_STATE_OPENING);
  } else if (ESPHOME_strcasecmp_P(state, ESPHOME_PSTR("LOCKING")) == 0) {
    this->set_state(LOCK_STATE_LOCKING);
  } else if (ESPHOME_strcasecmp_P(state, ESPHOME_PSTR("UNLOCKING")) == 0) {
@@ -26,7 +26,9 @@ enum LockState : uint8_t {
  LOCK_STATE_UNLOCKED = 2,
  LOCK_STATE_JAMMED = 3,
  LOCK_STATE_LOCKING = 4,
-  LOCK_STATE_UNLOCKING = 5
+  LOCK_STATE_UNLOCKING = 5,
+  LOCK_STATE_OPENING = 6,
+  LOCK_STATE_OPEN = 7,
 };
 const LogString *lock_state_to_string(LockState state);

@@ -45,6 +45,7 @@ optional<uint32_t> LTR390Component::read_sensor_data_(LTR390MODE mode) {
  uint8_t buffer[num_bytes];

  // Wait until data available
+  constexpr uint32_t max_wait_ms = 25;
  const uint32_t now = millis();
  while (true) {
    std::bitset<8> status = this->reg(LTR390_MAIN_STATUS).get();
@@ -52,12 +53,12 @@ optional<uint32_t> LTR390Component::read_sensor_data_(LTR390MODE mode) {
    if (available)
      break;

-    if (millis() - now > 100) {
+    if (millis() - now > max_wait_ms) {
      ESP_LOGW(TAG, "Sensor didn't return any data, aborting");
      return {};
    }
-    ESP_LOGD(TAG, "Waiting for data");
-    delay(2);
+    ESP_LOGV(TAG, "Waiting for data");
+    delay(1);
  }

  if (!this->read_bytes(MODEADDRESSES[mode], buffer, num_bytes)) {
@@ -44,6 +44,7 @@ from esphome.core import CORE, ID, Lambda
 from esphome.cpp_generator import MockObj
 from esphome.final_validate import full_config
 from esphome.helpers import write_file_if_changed
+from esphome.writer import clean_build
 from esphome.yaml_util import load_yaml

 from . import defines as df, helpers, lv_validation as lvalid, widgets
@@ -341,7 +342,7 @@ async def to_code(configs):
                df.LOGGER.info("LVGL will use hardware rotation via display driver")
            else:
                rotation_type = RotationType.ROTATION_SOFTWARE
-                if get_esp32_variant() == VARIANT_ESP32P4:
+                if CORE.is_esp32 and get_esp32_variant() == VARIANT_ESP32P4:
                    df.LOGGER.info("LVGL will use software rotation (PPA accelerated)")
                else:
                    df.LOGGER.info("LVGL will use software rotation")
@@ -451,7 +452,8 @@ async def to_code(configs):
        df.add_define(f"LV_DRAW_SW_SUPPORT_{fmt}", "1")

    lv_conf_h_file = CORE.relative_src_path(LV_CONF_FILENAME)
-    write_file_if_changed(lv_conf_h_file, generate_lv_conf_h())
+    if write_file_if_changed(lv_conf_h_file, generate_lv_conf_h()):
+        clean_build(clear_pio_cache=False)
    cg.add_build_flag("-DLV_CONF_H=1")
    # handle windows paths in a way that doesn't break the generated C++
    lv_conf_h_path = Path(lv_conf_h_file).as_posix()
@@ -89,10 +89,12 @@
                      id: hello_world_label_
                      text: "Hello World!"
                      align: center
-            - obj:
+            - container:
                id: hello_world_qrcode_
                outline_width: 0
                border_width: 0
+                height: 100
+                width: 100
                hidden: !lambda |-
                    return lv_obj_get_width(lv_screen_active()) < 300 && lv_obj_get_height(lv_screen_active()) < 400;
                widgets:
@@ -642,26 +642,28 @@ void LvglComponent::write_random_() {
  int iterations = 6 - lv_display_get_inactive_time(this->disp_) / 60000;
  if (iterations <= 0)
    iterations = 1;
+  int16_t width = lv_display_get_horizontal_resolution(this->disp_);
+  int16_t height = lv_display_get_vertical_resolution(this->disp_);
  while (iterations-- != 0) {
-    int32_t col = random_uint32() % this->width_;
+    int32_t col = random_uint32() % width;
    col = col / this->draw_rounding * this->draw_rounding;
-    int32_t row = random_uint32() % this->height_;
+    int32_t row = random_uint32() % height;
    row = row / this->draw_rounding * this->draw_rounding;
    // size will be between 8 and 32, and a multiple of draw_rounding
    int32_t size = (random_uint32() % 25 + 8) / this->draw_rounding * this->draw_rounding;
-    lv_area_t area{col, row, col + size - 1, row + size - 1};
+    lv_area_t area{.x1 = col, .y1 = row, .x2 = col + size - 1, .y2 = row + size - 1};
    // clip to display bounds just in case
-    if (area.x2 >= this->width_)
-      area.x2 = this->width_ - 1;
-    if (area.y2 >= this->height_)
-      area.y2 = this->height_ - 1;
+    if (area.x2 >= width)
+      area.x2 = width - 1;
+    if (area.y2 >= height)
+      area.y2 = height - 1;

    // line_len can't exceed 1024, and minimum buffer size is 2048, so this won't overflow the buffer
    size_t line_len = lv_area_get_width(&area) * lv_area_get_height(&area) / 2;
    for (size_t i = 0; i != line_len; i++) {
-      ((uint32_t *) (this->draw_buf_))[i] = random_uint32();
+      reinterpret_cast<uint32_t *>(this->draw_buf_)[i] = random_uint32();
    }
-    this->draw_buffer_(&area, (lv_color_data *) this->draw_buf_);
+    this->draw_buffer_(&area, reinterpret_cast<lv_color_data *>(this->draw_buf_));
  }
 }

@@ -76,16 +76,23 @@ inline void lv_style_set_text_font(lv_style_t *style, const font::Font *font) {
 }
 #endif
 #if defined(USE_LVGL_IMAGE) && defined(USE_IMAGE)
-// Shortcut / overload, so that the source of an image can easily be updated
-// from within a lambda.
-inline void lv_image_set_src(lv_obj_t *obj, image::Image *image) { lv_image_set_src(obj, image->get_lv_image_dsc()); }
+#if LV_USE_IMAGE
+// Shortcut / overload, so that the source of an image widget can easily be updated from within a lambda.
+inline void lv_image_set_src(lv_obj_t *obj, image::Image *image) { ::lv_image_set_src(obj, image->get_lv_image_dsc()); }
+#endif  // LV_USE_IMAGE

 inline void lv_obj_set_style_bitmap_mask_src(lv_obj_t *obj, image::Image *image, lv_style_selector_t selector) {
-  lv_obj_set_style_bitmap_mask_src(obj, image->get_lv_image_dsc(), selector);
+  ::lv_obj_set_style_bitmap_mask_src(obj, image->get_lv_image_dsc(), selector);
 }

 inline void lv_obj_set_style_bg_image_src(lv_obj_t *obj, image::Image *image, lv_style_selector_t selector) {
-  lv_obj_set_style_bg_image_src(obj, image->get_lv_image_dsc(), selector);
+  ::lv_obj_set_style_bg_image_src(obj, image->get_lv_image_dsc(), selector);
+}
+inline void lv_style_set_bg_image_src(lv_style_t *style, image::Image *image) {
+  ::lv_style_set_bg_image_src(style, image->get_lv_image_dsc());
+}
+inline void lv_style_set_bitmap_mask_src(lv_style_t *style, image::Image *image) {
+  ::lv_style_set_bitmap_mask_src(style, image->get_lv_image_dsc());
 }
 #endif  // USE_LVGL_IMAGE
 #ifdef USE_LVGL_ANIMIMG
@@ -77,8 +77,11 @@ class ArcType(NumberType):
                # start_angle and end_angle are mapped to bg_start_angle and bg_end_angle
                prop = str(prop)
                if prop.endswith("_angle"):
-                    prop = "bg_" + prop
-                await w.set_property(prop, config, processor=validator)
+                    await w.set_property(
+                        "bg_" + prop, await validator.process(config.get(prop))
+                    )
+                else:
+                    await w.set_property(prop, config, processor=validator)
        if CONF_ADJUSTABLE in config:
            if not config[CONF_ADJUSTABLE]:
                lv_obj.remove_style(w.obj, nullptr, LV_PART.KNOB)
@@ -52,19 +52,23 @@ class KeyboardType(WidgetType):
        if mode := config.get(CONF_MODE):
            await w.set_property(CONF_MODE, await KEYBOARD_MODES.process(mode))
        if textarea := config.get(CONF_TEXTAREA):
-            # If a textarea is configured, it must be generated before the keyboard can attach it.
-            # If not yet configured, defer the attachment code.
+            if not is_widget_completed(textarea):
+                # Can only happen for an initial config, where the keyboard is configured before the
+                # textarea, so it's ok to always emit into the global context
+                async def add_textarea():
+                    async with LvContext():
+                        await w.set_property(
+                            CONF_TEXTAREA,
+                            (await get_widgets(config, CONF_TEXTAREA))[0].obj,
+                        )

-            async def add_textarea():
-                async with LvContext():
-                    await w.set_property(
-                        CONF_TEXTAREA, (await get_widgets(config, CONF_TEXTAREA))[0].obj
-                    )
-
-            if is_widget_completed(textarea):
-                await add_textarea()
-            else:
                CORE.add_job(add_textarea)
+            else:
+                # Handles updates in automations, and properly ordered initial config. Code is generated
+                # into the enclosing context (main or lambda)
+                await w.set_property(
+                    CONF_TEXTAREA, (await get_widgets(config, CONF_TEXTAREA))[0].obj
+                )


 keyboard_spec = KeyboardType()
@@ -170,7 +170,7 @@ async def to_code(config):
            cg.add_library("LEAmDNS", None)

    if CORE.is_esp32:
-        add_idf_component(name="espressif/mdns", ref="1.10.0")
+        add_idf_component(name="espressif/mdns", ref="1.11.0")

    cg.add_define("USE_MDNS")

@@ -452,14 +452,14 @@ async def to_code(config):

    esp32.add_idf_component(name="espressif/esp-tflite-micro", ref="1.3.3~1")
    # Pin esp-nn for stable future builds (esp-tflite-micro depends on esp-nn)
-    esp32.add_idf_component(name="espressif/esp-nn", ref="1.2.1")
+    esp32.add_idf_component(name="espressif/esp-nn", ref="1.1.2")
+
+    esp32.add_idf_component(name="esphome/esp-micro-speech-features", ref="1.2.3")

    cg.add_build_flag("-DTF_LITE_STATIC_MEMORY")
    cg.add_build_flag("-DTF_LITE_DISABLE_X86_NEON")
    cg.add_build_flag("-DESP_NN")

-    cg.add_library("kahrendt/ESPMicroSpeechFeatures", "1.1.0")
-
    if vad_model := config.get(CONF_VAD):
        cg.add_define("USE_MICRO_WAKE_WORD_VAD")

@@ -28,7 +28,8 @@ void AirConditioner::on_status_change() {
  if (this->base_.getAutoconfStatus() == dudanov::midea::AUTOCONF_OK &&
      this->base_.getCapabilities().supportFrostProtectionPreset() && !this->frost_protection_set_) {
    // Read existing presets (set by codegen), append frost protection, write back
-    const auto &existing = this->get_traits().get_supported_custom_presets();
+    auto traits = this->get_traits();
+    const auto &existing = traits.get_supported_custom_presets();
    bool found = false;
    for (const char *p : existing) {
      if (strcmp(p, Constants::FREEZE_PROTECTION) == 0) {
@@ -0,0 +1,29 @@
+from esphome.components.mipi import DriverChip
+import esphome.config_validation as cv
+
+# Standalone display
+# Product page: https://www.seeedstudio.com/reTerminal-D1001-p-6729.html
+DriverChip(
+    "SEEED-RETERMINAL-D1001",
+    height=1280,
+    width=800,
+    hsync_back_porch=20,
+    hsync_pulse_width=20,
+    hsync_front_porch=40,
+    vsync_back_porch=12,
+    vsync_pulse_width=4,
+    vsync_front_porch=30,
+    pclk_frequency="80MHz",
+    lane_bit_rate="1.5Gbps",
+    swap_xy=cv.UNDEFINED,
+    color_order="RGB",
+    enable_pin=[{"xl9535": None, "number": 0}, {"xl9535": None, "number": 7}],
+    reset_pin={"xl9535": None, "number": 2},
+    initsequence=(
+        (0xE0, 0x00),
+        (0xE1, 0x93),
+        (0xE2, 0x65),
+        (0xE3, 0xF8),
+        (0x80, 0x01),
+    ),
+)
@@ -0,0 +1,51 @@
+from esphome.components.mipi import DriverChip
+from esphome.config_validation import UNDEFINED
+
+# fmt: off
+sunton = DriverChip(
+    "ESP32-8048S070",
+    swap_xy=UNDEFINED,
+    initsequence=(),
+    width=800,
+    height=480,
+    pclk_frequency="12.5MHz",
+    de_pin=41,
+    hsync_pin=39,
+    vsync_pin=40,
+    pclk_pin=42,
+    hsync_pulse_width=30,
+    hsync_back_porch=16,
+    hsync_front_porch=210,
+    vsync_pulse_width=13,
+    vsync_back_porch=10,
+    vsync_front_porch=22,
+    data_pins={
+        "red": [14, 21, 47, 48, 45],
+        "green": [9, 46, 3, 8, 16, 1],
+        "blue": [15, 7, 6, 5, 4],
+    },
+)
+
+sunton.extend(
+    "ESP32-8048S050",
+    swap_xy=UNDEFINED,
+    initsequence=(),
+    width=800,
+    height=480,
+    pclk_frequency="16MHz",
+    de_pin=40,
+    hsync_pin=39,
+    vsync_pin=41,
+    pclk_pin=42,
+    hsync_back_porch=8,
+    hsync_front_porch=8,
+    hsync_pulse_width=4,
+    vsync_back_porch=8,
+    vsync_front_porch=8,
+    vsync_pulse_width=4,
+    data_pins={
+        "red": [45, 48, 47, 21, 14],
+        "green": [5, 6, 7, 15, 16, 4],
+        "blue": [8, 3, 46, 9, 1],
+    },
+)
@@ -195,7 +195,7 @@ def model_schema(config):
                    "big_endian", "little_endian", lower=True
                ),
                model.option(CONF_COLOR_DEPTH, 16): cv.one_of(*color_depth, lower=True),
-                model.option(CONF_DRAW_ROUNDING, 2): power_of_two,
+                model.option(CONF_DRAW_ROUNDING, 1): power_of_two,
                model.option(CONF_PIXEL_MODE, DISPLAY_16BIT): cv.one_of(
                    *pixel_modes, lower=True
                ),
@@ -297,9 +297,9 @@ def _final_validate(config):

        buffer_size = color_depth // 8 * width * height // frac
        # Target a buffer size of 20kB, except for large displays, which shouldn't end up here
-        fraction = min(20000.0, buffer_size // 16) / buffer_size
+        fraction = min(20000.0, buffer_size // 4) / buffer_size
        config[CONF_BUFFER_SIZE] = 1.0 / next(
-            x for x in range(2, 17) if fraction >= 1 / x
+            (x for x in range(2, 8) if fraction >= 1 / x), 8
        )


@@ -234,9 +234,9 @@ class MipiSpi : public display::Display,
  }

  void dump_config() override {
-    internal_dump_config(this->model_, this->get_width(), this->get_height(), OFFSET_WIDTH, OFFSET_HEIGHT, MADCTL,
-                         this->invert_colors_, DISPLAYPIXEL * 8, IS_BIG_ENDIAN, this->brightness_, this->cs_,
-                         this->reset_pin_, this->dc_pin_, this->mode_, this->data_rate_, BUS_TYPE,
+    internal_dump_config(this->model_, this->get_width(), this->get_height(), OFFSET_WIDTH, OFFSET_HEIGHT,
+                         (uint8_t) MADCTL, this->invert_colors_, DISPLAYPIXEL * 8, IS_BIG_ENDIAN, this->brightness_,
+                         this->cs_, this->reset_pin_, this->dc_pin_, this->mode_, this->data_rate_, BUS_TYPE,
                         HAS_HARDWARE_ROTATION);
  }

@@ -305,7 +305,7 @@ class MipiSpi : public display::Display,
      this->write_command_(BRIGHTNESS, this->brightness_.value());

    // calculate new madctl value from base value adjusted for rotation
-    uint8_t madctl = MADCTL;  // lower 8 bits only
+    uint8_t madctl = (uint8_t) MADCTL;  // lower 8 bits only
    constexpr bool use_flips = (MADCTL & MADCTL_FLIP_FLAG) != 0;
    constexpr uint8_t x_mask = use_flips ? MADCTL_XFLIP : MADCTL_MX;
    constexpr uint8_t y_mask = use_flips ? MADCTL_YFLIP : MADCTL_MY;
@@ -546,13 +546,12 @@ class MipiSpiBuffer : public MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DIS
    }
    // for updates with a small buffer, we repeatedly call the writer_ function, clipping the height to a fraction of
    // the display height,
-    for (this->start_line_ = 0; this->start_line_ < this->get_height_internal();
-         this->start_line_ += this->get_height_internal() / FRACTION) {
+    auto increment = (this->get_height_internal() / FRACTION / ROUNDING) * ROUNDING;
+    for (this->start_line_ = 0; this->start_line_ < this->get_height_internal(); this->start_line_ = this->end_line_) {
 #if ESPHOME_LOG_LEVEL == ESPHOME_LOG_LEVEL_VERBOSE
      auto lap = millis();
 #endif
-      this->end_line_ =
-          clamp_at_most(this->start_line_ + this->get_height_internal() / FRACTION, this->get_height_internal());
+      this->end_line_ = clamp_at_most(this->start_line_ + increment, this->get_height_internal());
      if (this->auto_clear_enabled_) {
        this->clear();
      }
@@ -574,12 +573,13 @@ class MipiSpiBuffer : public MipiSpi<BUFFERTYPE, BUFFERPIXEL, IS_BIG_ENDIAN, DIS
      // Some chips require that the drawing window be aligned on certain boundaries
      this->x_low_ = this->x_low_ / ROUNDING * ROUNDING;
      this->y_low_ = this->y_low_ / ROUNDING * ROUNDING;
-      this->x_high_ = (this->x_high_ + ROUNDING) / ROUNDING * ROUNDING - 1;
-      this->y_high_ = (this->y_high_ + ROUNDING) / ROUNDING * ROUNDING - 1;
+      this->x_high_ = round_buffer(this->x_high_ + 1) - 1;
+      this->y_high_ = clamp_at_most(round_buffer(this->y_high_ + 1) - 1, this->end_line_ - 1);
      int w = this->x_high_ - this->x_low_ + 1;
      int h = this->y_high_ - this->y_low_ + 1;
      this->write_to_display_(this->x_low_, this->y_low_, w, h, this->buffer_, this->x_low_,
-                              this->y_low_ - this->start_line_, round_buffer(this->get_width_internal()) - w);
+                              this->y_low_ - this->start_line_,
+                              round_buffer(this->get_width_internal()) - w - this->x_low_);
      // invalidate watermarks
      this->x_low_ = this->get_width_internal();
      this->y_low_ = this->get_height_internal();
@@ -1,4 +1,6 @@
-from .ili import ILI9341, ILI9342, ST7789V
+from esphome.const import CONF_IGNORE_STRAPPING_WARNING, CONF_NUMBER
+
+from .ili import GC9A01A, ILI9341, ILI9342, ST7789V

 ILI9341.extend(
    # ESP32-2432S028 CYD board with Micro USB, has ILI9341 controller
@@ -43,3 +45,10 @@ ILI9342.extend(
        (0xE1, 0x00, 0x0B, 0x11, 0x05, 0x13, 0x09, 0x33, 0x67, 0x48, 0x07, 0x0E, 0x0B, 0x23, 0x33, 0x0F),  # Negative Gamma Correction
    )
 )
+
+GC9A01A.extend(
+    "ESP32-2424S012",
+    invert_colors=True,
+    cs_pin=10,
+    dc_pin={CONF_NUMBER: 2, CONF_IGNORE_STRAPPING_WARNING: True},
+)
--- a/Show More
+++ b/Show More