Say how a string table goes into flash

Scope the grouping note to compiled tests and describe both flash helpers
State the re-arm cost precisely
2026-10-23 06:15:58 +00:00 · 2026-10-11 08:48:27 -10:00 · 2026-10-11 08:10:46 -10:00 · 2026-10-11 08:01:32 -10:00 · 2026-10-11 07:59:16 -10:00 · 2026-10-11 07:56:49 -10:00
2278 changed files with 12955 additions and 7359 deletions
@@ -53,7 +53,7 @@ module.exports = async ({ github, context }) => {
  });
  const currentLabels = currentLabelsData.map(label => label.name);
  const managedLabels = currentLabels.filter(label =>
-    label.startsWith('component: ') || MANAGED_LABELS.includes(label)
+    label.startsWith('component: ') || label.startsWith('platform: ') || MANAGED_LABELS.includes(label)
  );

  // Check for mega-PR early - if present, skip most automatic labeling
@@ -286,7 +286,7 @@ jobs:
          fi
          echo "version=$version" >> "$GITHUB_OUTPUT"
      - name: Run prek
-        uses: j178/prek-action@4e14d07f9231acabce116ccfca13b13dd9755ece # v3.0.0
+        uses: j178/prek-action@1382ad72dea72f9d53832f2bcb65b3e87a947204 # v3.0.1
        with:
          prek-version: ${{ steps.prek.outputs.version }}
          # This job only runs on pull requests, so nothing ever populates
@@ -1335,6 +1335,91 @@ jobs:
          # config first, so a separate config pass is redundant.
          python3 script/test_build_components.py -e compile -t esp8266-ard -c "$TEST_COMPONENTS" -f --toolchain arduino --fail-on-no-tests

+  test-esp8266-native-windows:
+    name: Compile esp8266 with the native toolchain on Windows (ccache ${{ matrix.ccache }})
+    runs-on: windows-latest
+    needs:
+      - common
+      - determine-jobs
+    if: github.event_name == 'pull_request' && needs.determine-jobs.outputs.esp8266-native == 'true'
+    # A hung compiler must fail the job, not hold the runner for six hours.
+    timeout-minutes: 40
+    strategy:
+      fail-fast: false
+      matrix:
+        # Both ways the build runs on Windows: ESPHome Desktop bundles
+        # ccache and puts it on PATH, a pip install has none.
+        ccache: ["1", "0"]
+    env:
+      ESPHOME_CCACHE_ENABLE: ${{ matrix.ccache }}
+      # The test script prints characters the cp1252 console cannot encode
+      PYTHONUTF8: "1"
+      # The exact static build ESPHome Desktop ships
+      CCACHE_URL: https://github.com/ccache/ccache/releases/download/v4.14/ccache-4.14-windows-x86_64.zip
+      CCACHE_SHA256: 2568347a697e103ca1b073981c704ad76fb2507d066c38dba038dd73399d968f
+    steps:
+      - name: Check out code from GitHub
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Restore Python
+        uses: ./.github/actions/restore-python
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON }}
+          cache-key: ${{ needs.common.outputs.cache-key }}
+
+      - name: Install ccache
+        if: matrix.ccache == '1'
+        shell: pwsh
+        run: |
+          $dir = Join-Path $env:RUNNER_TEMP "ccache"
+          New-Item -ItemType Directory -Force $dir | Out-Null
+          $zip = Join-Path $dir "ccache.zip"
+          Invoke-WebRequest -Uri $env:CCACHE_URL -OutFile $zip
+          $hash = (Get-FileHash $zip -Algorithm SHA256).Hash.ToLower()
+          if ($hash -ne $env:CCACHE_SHA256) {
+            Write-Host "::error::ccache archive sha256 $hash does not match $env:CCACHE_SHA256"
+            exit 1
+          }
+          Expand-Archive -Path $zip -DestinationPath $dir
+          $bin = Get-ChildItem -Path $dir -Recurse -Filter ccache.exe | Select-Object -First 1
+          Add-Content -Path $env:GITHUB_PATH -Value $bin.DirectoryName
+          & $bin.FullName --version
+
+      - name: Compile
+        shell: pwsh
+        # One component test: web_server brings wifi, api and the async web
+        # server libraries, the shape of a typical ESP8266 device
+        run: |
+          . .\venv\Scripts\Activate.ps1
+          $arguments = "script/test_build_components.py", "-e", "compile", "-t", "esp8266-ard", "-c", "web_server", "--base-only", "--toolchain", "arduino", "--fail-on-no-tests"
+          $p = Start-Process -FilePath python -ArgumentList $arguments -NoNewWindow -PassThru
+          # Reading the handle keeps ExitCode available after the process exits
+          $null = $p.Handle
+          if (-not $p.WaitForExit(25 * 60 * 1000)) {
+            Write-Host "::error::The compile did not finish in 25 minutes; processes still running:"
+            Get-CimInstance Win32_Process |
+              Where-Object { $_.CommandLine -match 'xtensa|ccache|ninja|esphome' } |
+              Select-Object ProcessId, ParentProcessId, CreationDate, CommandLine |
+              Format-List | Out-String -Width 4096 | Write-Host
+            Get-Process |
+              Where-Object { $_.Name -match 'cc1|ccache|ninja|xtensa|python' } |
+              Select-Object Id, Name, CPU, WorkingSet64 |
+              Format-Table | Out-String | Write-Host
+            taskkill /PID $p.Id /T /F
+            exit 1
+          }
+          exit $p.ExitCode
+
+      - name: Show ccache statistics
+        # Also after a failed or killed compile: the counters say whether
+        # ccache was ever reached
+        if: always() && matrix.ccache == '1'
+        shell: pwsh
+        # The build keeps its store under the esphome tools cache
+        run: |
+          $env:CCACHE_DIR = Join-Path $env:LOCALAPPDATA "esphome\Cache\arduino8266\ccache"
+          ccache -s
+
  device-builder:
    name: Test downstream esphome/device-builder
    runs-on: ubuntu-24.04
@@ -1422,31 +1507,27 @@ jobs:
            echo "::warning::ci_memory_impact_extract.py not found on target branch, skipping memory impact analysis"
          fi

-      # Check if test files exist on the target branch for the requested
-      # components and platform. When a PR adds new test files for a platform,
-      # the target branch won't have them yet, so skip instead of failing.
-      # This check must be done here (not in determine-jobs.py) because
-      # determine-jobs runs on the PR branch and cannot see what the target
-      # branch has.
+      # The build below uses --base-only, so skip unless the target branch has
+      # test.<platform>.yaml for every requested component (test-*.yaml
+      # variants alone compile nothing, and a partial set would compare a
+      # smaller target build against the PR build). Checked here, not in
+      # determine-jobs.py, because determine-jobs runs on the PR branch and
+      # cannot see the target branch.
      - name: Check for test files on target branch
        id: check-tests
        if: steps.check-script.outputs.skip != 'true'
        run: |
          components='${{ toJSON(fromJSON(needs.determine-jobs.outputs.memory_impact).components) }}'
          platform="${{ fromJSON(needs.determine-jobs.outputs.memory_impact).platform }}"
-          found=false
+          missing=""
          for component in $(echo "$components" | jq -r '.[]'); do
-            # Check for test files matching the platform (test.platform.yaml or test-*.platform.yaml)
-            for f in tests/components/${component}/test*.${platform}.yaml; do
-              if [ -f "$f" ]; then
-                found=true
-                break 2
-              fi
-            done
+            if [ ! -f "tests/components/${component}/test.${platform}.yaml" ]; then
+              missing="${missing} ${component}"
+            fi
          done
-          if [ "$found" = false ]; then
+          if [ -n "$missing" ]; then
            echo "skip=true" >> $GITHUB_OUTPUT
-            echo "::warning::No test files found on target branch for platform ${platform}, skipping memory impact analysis"
+            echo "::warning::No test.${platform}.yaml on target branch for${missing}, skipping memory impact analysis"
          else
            echo "skip=false" >> $GITHUB_OUTPUT
          fi
@@ -1709,6 +1790,7 @@ jobs:
      - test-build-components-split
      - test-esp32-platformio
      - test-esp8266-native
+      - test-esp8266-native-windows
      - device-builder
      - memory-impact-target-branch
      - memory-impact-pr-branch
@@ -16,16 +16,18 @@ jobs:
    # No GITHUB_TOKEN permissions: the reusable workflow mints an ESPHome
    # GitHub App token so the labels, comments and closures come from
    # esphome[bot] instead of github-actions[bot].
-    uses: esphome/workflows/.github/workflows/stale.yml@cc3e76de337dc59bc1cba8da58d963cd23b873f1  # main
+    uses: esphome/workflows/.github/workflows/stale.yml@4fbce13026c393d6eb6b247e394dcd9ef1af76c2  # main
    secrets:
      ESPHOME_GITHUB_APP_PRIVATE_KEY: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
    with:
      # Live only on dev: a workflow_dispatch from any other branch is a dry run
      dry-run: ${{ github.ref != 'refs/heads/dev' }}
      days-before-stale: 90
+      days-before-stale-conflicting: 30
      days-before-close: 7
      stale-label: stale
      exempt-label: not-stale
+      conflict-label: needs-rebase
      ignored-users: esphbot,codecov-commenter
      stale-pr-message: >
        There hasn't been any activity on this pull request recently. This
@@ -36,6 +38,18 @@ jobs:
        to keep it open. Also, please merge the latest dev branch into your
        branch to ensure that it's up to date with the latest changes.

+        Thank you for your contribution!
+      conflict-pr-message: >
+        This pull request has merge conflicts. Please merge the latest dev
+        branch into your branch to resolve them.
+      stale-conflicting-pr-message: >
+        The merge conflicts on this pull request have not been resolved for
+        30 days, so it has been marked as stale and will be closed if they
+        are not resolved within 7 days.
+
+        Please merge the latest dev branch into your branch. Once the pull
+        request is mergeable again the stale label is removed.
+
        Thank you for your contribution!
      stale-issue-message: >
        There hasn't been any activity on this issue recently. Due to the
@@ -15,6 +15,8 @@ on:
  # base branch checkout, so fork code never runs with the token.
  pull_request_target:
    types: [opened, synchronize, reopened]
+    branches:
+      - dev
    paths:
      - requirements_dev.txt
      - requirements_test.txt
@@ -67,6 +67,7 @@ file does, and it is the authority when they disagree. The most useful starting
        - Function-local constants: `lower_snake_case`
        - Protected/private fields: `lower_snake_case_with_trailing_underscore_`
        - Favor descriptive names over abbreviations
+        - Device components are named brand plus model (`siemens_ira211`), without a protocol-family prefix
        - Enumerator names: prefix every value of an `enum class` with the enum name converted to
          `UPPER_SNAKE_CASE` (e.g. `UARTFlushResult::UART_FLUSH_RESULT_SUCCESS`). Never use bare
          names like `SUCCESS`, `FAILURE`, `OK`, or `FAIL`: platform SDK headers define macros with
@@ -177,6 +178,15 @@ file does, and it is the authority when they disagree. The most useful starting
        Pick the primitive by cadence: under 250 ms use a gated `loop()`; 500 ms and above use
        `set_interval`. Full reasoning, including why `set_interval` costs more below 500 ms:
        https://developers.esphome.io/architecture/components/advanced/#quick-rule-of-thumb
+    *   **Repeating work:** use `set_interval`, never a `set_timeout` that re-arms itself; every re-arm
+        rebuilds the callback and re-queues a scheduler item, and the period drifts.
+    *   **Scheduler ids:** name a timer only when it must be cancelled or replaced, and use a
+        `static constexpr uint32_t` id, never a string. Ids are per component instance and cannot clash with other
+        components, so number them from 0 and keep all of a component's ids together in one place.
+        ```cpp
+        static constexpr uint32_t READ_TIMEOUT_ID = 0;
+        this->set_timeout(READ_TIMEOUT_ID, 50, [this]() { this->read_(); });
+        ```
    *   **Don't override a default with the same value:** if a base class method already returns what you
        want, do not override it. `Component::get_setup_priority()` returns `setup_priority::DATA`, so a
        component that wants `DATA` should simply leave it alone.
@@ -184,6 +194,20 @@ file does, and it is the authority when they disagree. The most useful starting
        // Bad - this is exactly what the base class already does
        float get_setup_priority() const override { return setup_priority::DATA; }
        ```
+    *   **Constant data lives in RAM on ESP8266** unless marked `PROGMEM`: `const` tables, class-scope
+        constant arrays, and in-class `std::array` initializers (a `.rodata` template plus a copy). Mark the
+        table `PROGMEM` and read it with `progmem_memcpy()` or `progmem_read_byte()` (`esphome/core/hal.h`);
+        for a table of structs copy the whole entry out and return the copy, never a pointer into flash. A table
+        of strings is `PROGMEM` char arrays behind a `PROGMEM` pointer table read with `progmem_read_ptr()`;
+        `LOG_STR()` cannot fill a static table, since it expands to code that runs at first use.
+        On other platforms they are a plain `memcpy` and dereference, so no `#ifdef` is needed. Declare log tags with
+        `ESPHOME_LOG_TAG(TAG, "name")`, pass status text as `LOG_STR`, e.g.
+        `this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL))`, and give an action whose payload is a byte array
+        a `TEMPLATABLE_BYTES` field so a static code stays in flash.
+    *   **Failures after `setup()`:** `mark_failed()` is for `setup()` only. A runtime read or write failure
+        sets `status_set_warning()` and the next success clears it; writes skip work when `is_failed()`.
+    *   **Fixed platform facts compile to nothing:** gate on `#ifdef USE_ESP8266` and friends, not on a
+        runtime check of something the build already knows.
    *   **Logging string literals:** wrap literals passed as `%s` arguments in `LOG_STR_LITERAL()` so they
        can be stored in flash rather than RAM.
        ```cpp
@@ -230,6 +254,10 @@ file does, and it is the authority when they disagree. The most useful starting
        ```

    *   **Component Metadata:**
+        - `DOMAIN`: Required in every component's `__init__.py`, set to the component's own name as a plain
+          string (e.g. `DOMAIN = "my_component"`). Other code refers to the component through it, e.g.
+          `from esphome.components.my_component import DOMAIN`. Keep it in alphabetical order with the other
+          metadata constants. CI (`lint_component_domain`) fails without it.
        - `DEPENDENCIES`: List of required components
        - `AUTO_LOAD`: Components to automatically load
        - `CONFLICTS_WITH`: Incompatible components
@@ -243,6 +271,7 @@ file does, and it is the authority when they disagree. The most useful starting
        import esphome.config_validation as cv
        from esphome.const import CONF_KEY, CONF_ID

+        DOMAIN = "my_component"
        CONF_PARAM = "param"  # A constant that does not yet exist in esphome/const.py

        my_component_ns = cg.esphome_ns.namespace("my_component")
@@ -384,6 +413,25 @@ file does, and it is the authority when they disagree. The most useful starting
                )
        ```

+        When the callback's parameters differ from the automation's arguments, or the trigger should only
+        fire for some values, pass `params`, `forward` and `when`; the helper then generates a capture-less
+        lambda (stored inline, nothing allocated). Name the parent with `automation.parent_ref(var)` and build
+        `forward` from `MockObj` calls, not f-strings of C++:
+        ```python
+        parent = automation.parent_ref(var)
+        index = cg.RawExpression("index")
+        await automation.build_callback_automation(
+            var,
+            "add_on_state_callback",
+            [(cg.StringRef, "x"), (cg.size_t, "i")],
+            conf,
+            params=[(cg.size_t, "index")],
+            forward=[cg.StringRef(parent.option_at(index)), index],
+        )
+        ```
+        `build_parent_callback_automation`, `build_trigger_callback`, `build_callback_automations` and
+        `build_trigger_automations` cover the other shapes; see their docstrings in `esphome/automation.py`.
+
        **C++ -- no trigger class needed.** The callback registration method must be templatized to accept both `std::function` and lightweight forwarder structs (which avoid heap allocation):
        ```cpp
        class MyComponent : public Component {
@@ -503,6 +551,7 @@ file does, and it is the authority when they disagree. The most useful starting
        `cover.is_open`, `rtttl.is_playing` and `component.is_idle` are in-tree examples.

 *   **Type Hints:** Type-hint all function signatures, including test functions and config validators (e.g. `def validate_x(config: ConfigType) -> ConfigType:`, `def test_x() -> None:`). Import `ConfigType` from `esphome.types`.
+    An intentionally empty body (an unused `register_dumper` builder, for example) gets a one-line docstring, not `pass`.

 *   **Configuration Validation:**
    *   **Reuse existing validators:** Before writing a custom validator, check for an existing one in `config_validation.py` and compose it in `cv.All(...)` rather than duplicating logic across components. For example, rename a config key with `cv.rename_key(CONF_OLD, CONF_NEW, removed_in="2026.6.0")`, and reject mutually-exclusive keys with `cv.has_at_most_one_key(...)` / `cv.has_exactly_one_key(...)`. See how `api` composes `cv.has_exactly_one_key` + `cv.rename_key`.
@@ -538,6 +587,13 @@ file does, and it is the authority when they disagree. The most useful starting
 *   **Testing:**
    *   **Python:** Run unit tests with `pytest`.
    *   **C++:** Use `clang-tidy` for static analysis.
+    *   **C++ unit tests:** gtests in `tests/components/<component>/*.cpp`, run with
+        `script/cpp_unit_test.py <component>`; see `tests/components/README.md`. Set the loop clock in a test
+        with `LoopBlockingGuard{nullptr, nullptr, now_ms}`; the runner resets it before every test.
+    *   **Integration tests:** `tests/integration/` runs real firmware on the host. Serial components prove
+        timeouts and recovery with the `uart_mock` fixture (`tests/integration/test_uart_mock_*.py`).
+    *   **Keep build-test variants few:** one `test.<platform>.yaml` per platform the code actually differs
+        on. A variant per board for platform-identical code only adds CI time.
    *   **Component Tests:** YAML-based compilation tests are located in `tests/`. The structure is as follows:
        ```
        tests/
@@ -584,6 +640,7 @@ file does, and it is the authority when they disagree. The most useful starting
            name: My Sensor
        ```
        Components that define buses directly are flagged as "NEEDS MIGRATION" and cannot be grouped, increasing CI build time.
+        `!extend` and `!remove` in a `test.*.yaml` also make the component ungroupable; add a standalone entity with its own id instead.

    *   **Testing All Components Together:** To verify that all components can be tested together without ID conflicts or configuration issues, use:
        ```bash
@@ -188,6 +188,7 @@ esphome/components/esp32_rmt_led_strip/* @jesserockz
 esphome/components/esp8266/* @esphome/core
 esphome/components/esp_ldo/* @clydebarrow
 esphome/components/espectre/* @francescopace
+esphome/components/esphome/ota/* @esphome/core
 esphome/components/espnow/* @jesserockz
 esphome/components/espnow/packet_transport/* @EasilyBoredEngineer
 esphome/components/ethernet_info/* @gtjadsonsantos
@@ -518,6 +519,7 @@ esphome/components/sound_level/* @kahrendt
 esphome/components/spa06_base/* @danielkent-net
 esphome/components/spa06_i2c/* @danielkent-net
 esphome/components/spa06_spi/* @danielkent-net
+esphome/components/spd2010/* @grischard
 esphome/components/speaker/* @jesserockz @kahrendt
 esphome/components/speaker/media_player/* @kahrendt @synesthesiam
 esphome/components/speaker_source/* @kahrendt
@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.

-PROJECT_NUMBER         = 2026.10.0
+PROJECT_NUMBER         = 2026.11.0-dev

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

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

 RUN \
    platformio settings set enable_telemetry No \
@@ -51,6 +51,7 @@ from esphome.const import (
    KEY_ESP32,
    KEY_VARIANT,
    SECRETS_FILES,
+    ErrorFormat,
    Toolchain,
 )
 from esphome.core import CORE, EsphomeError, coroutine
@@ -2205,6 +2206,16 @@ def _add_states_args(parser: argparse.ArgumentParser) -> None:
    )


+def _error_format(value: str) -> ErrorFormat:
+    try:
+        return ErrorFormat(value.lower())
+    except ValueError:
+        choices = ", ".join(ErrorFormat)
+        raise argparse.ArgumentTypeError(
+            f"invalid choice: '{value}' (choose from {choices})"
+        ) from None
+
+
 def parse_args(argv):
    options_parser = argparse.ArgumentParser(add_help=False)
    options_parser.add_argument(
@@ -2267,6 +2278,17 @@ def parse_args(argv):
        ),
    )

+    options_parser.add_argument(
+        "--error-format",
+        type=_error_format,
+        metavar="{" + ",".join(f.value for f in ErrorFormat) + "}",
+        help=(
+            "How configuration errors are shown. 'yaml' shows them inside the "
+            "failing YAML; 'line' prints one 'file:line:column: error: message' "
+            "line per error. Default: $ESPHOME_ERROR_FORMAT, else 'yaml'."
+        ),
+    )
+
    parser = argparse.ArgumentParser(
        description=f"ESPHome {const.__version__}", parents=[options_parser]
    )
@@ -2570,9 +2592,18 @@ def parse_args(argv):
        args, unknown_args = parser.parse_known_args(arguments)
        if unknown_args:
            _LOGGER.warning("Ignored unrecognized arguments: %s", unknown_args)
-        return args
+    else:
+        args = parser.parse_args(arguments)

-    return parser.parse_args(arguments)
+    # Read here rather than as the option default, so a bad value is reported
+    # against the environment variable instead of --error-format
+    if args.error_format is None:
+        env_value = os.getenv("ESPHOME_ERROR_FORMAT", ErrorFormat.YAML.value)
+        try:
+            args.error_format = _error_format(env_value)
+        except argparse.ArgumentTypeError as err:
+            parser.error(f"ESPHOME_ERROR_FORMAT: {err}")
+    return args


 def _warn_if_source_tree_mismatch() -> None:
@@ -2645,6 +2676,7 @@ def run_esphome(argv):
    args = parse_args(argv)
    CORE.dashboard = args.dashboard
    CORE.testing_mode = args.testing_mode
+    CORE.error_format = args.error_format

    # Create address cache from command-line arguments
    CORE.address_cache = AddressCache.from_cli_args(
@@ -58,31 +58,31 @@ FRAMEWORK_RELEASES: dict[Version, FrameworkRelease] = {
 TOOLCHAIN_PACKAGE = "toolchain-xtensa-lx106-elf"
 # gcc 10.3, the toolchain Arduino core 3.x builds with; the build
 # generator's compile flags are tuned to it.
-TOOLCHAIN_VERSION = "10.3.0-esphome.2"
+TOOLCHAIN_VERSION = "10.3.0-esphome.3"
 _TOOLCHAIN_RELEASES = (
    "https://github.com/esphome-libs/xtensa-lx106-elf-toolchain/releases/"
 )
 # Registry system tag -> (sha256, size) of that host's archive
 TOOLCHAIN_BUILDS: dict[str, tuple[str, int]] = {
    "darwin_arm64": (
-        "849cede44d4d5c6ea0f14099783239f559f46327bea314281814f2652b486201",
-        60830321,
+        "ad0ea929238d9b527c43e0d20257acc2a5680bdb0d2b1cf8f2c99169786217e9",
+        60747260,
    ),
    "darwin_x86_64": (
-        "ca69904daabf0c5983b372423e5e62f49182a793e992c052e94666852470c897",
-        64149487,
+        "997090cac80c8eb59604ec52b73fb3568e5f2d9b2971f83c3f2a5c545c9c949c",
+        64065752,
    ),
    "linux_aarch64": (
-        "60a49a4f082bf246544bd409a9517dbbcab19bb30ac9decbee544b896aaccbd6",
-        67573397,
+        "403f14d0d5755682fcd6eaea1e4c457a1d8cad30690e52fb0c804d8db266b908",
+        67487067,
    ),
    "linux_x86_64": (
-        "1fba33ca1494ec79f2776e0e37eca93282d30f8bb9992f5f4f9a655d6fff1db4",
-        68431336,
+        "64f21fa3ba736b363dc8c234dbbb39e005e574e33de08a78e9a00c55a64ae706",
+        68343668,
    ),
    "windows_amd64": (
-        "af9066b0e5bf036f04f2bd9d08b89b81a7f183c57dac0abcaff71dd861cf5f3b",
-        67664137,
+        "1e62abf8df041ce5158f5770dffef955f2f981ce7f7adee88fcd5a8197705aa6",
+        67536405,
    ),
 }

@@ -1,4 +1,4 @@
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
 import logging
 import string
@@ -23,7 +23,7 @@ from esphome.const import (
 )
 from esphome.core import CORE, ID, EsphomeError, HexInt, Lambda
 from esphome.cpp_generator import (
-    FlashStringLiteral,
+    Expression,
    LambdaExpression,
    MockObj,
    MockObjClass,
@@ -245,9 +245,7 @@ ApplyCondition = cg.esphome_ns.class_("ApplyCondition", Condition)

 def flash_string(config: ConfigType, value: str) -> str:
    """Default renderer for ``std::string`` constants; copies the literal out of flash on ESP8266."""
-    if CORE.is_esp8266:
-        return f"progmem_string({FlashStringLiteral(value)})"
-    return str(cg.safe_exp(value))
+    return str(cg.progmem_string(value))


 def literal_with_length(config: ConfigType, value: str) -> str:
@@ -259,13 +257,24 @@ def literal_with_length(config: ConfigType, value: str) -> str:
    return f"{cg.safe_exp(value)}, {len(value.encode('utf-8'))}"


+def string_ref_literal(config: ConfigType, value: str) -> str:
+    """Renderer for a ``StringRef`` comparison: a flash literal on ESP8266, else ``StringRef(literal, length)``."""
+    if CORE.is_esp8266:
+        return str(cg.FlashStringLiteral(value))
+    return f"StringRef({literal_with_length(config, value)})"
+
+
+def _names_parent(text: str) -> bool:
+    return any(f == "parent" for _, f, _, _ in string.Formatter().parse(text))
+
+
@dataclass(frozen=True)
 class ApplyCall:
    """One statement from config keys, e.g. ``"set_range({}, {})"`` with ``((CONF_LOW, cg.float_), ...)``.

    Each arg is ``(conf_key, type_)`` or ``(conf_key, type_, const_fn)``. A ``conf_key`` may be a
-    path into nested sections. A plain ``str`` ``type_`` is raw C++ type text and may use
-    ``{parent}``. ``const_fn(config, value)`` renders a constant's argument text; a lambda or an
+    path into nested sections. ``target`` and a plain ``str`` ``type_`` (raw C++ type text) may
+    name the parent object as ``{parent}``. ``const_fn(config, value)`` renders a constant's argument text; a lambda or an
    id bypasses it. The statement is skipped when none of its keys is set, always emitted when it
    has no keys, and a partial set is a config error.
    """
@@ -277,13 +286,13 @@ class ApplyCall:
        fields = [
            f for _, f, _, _ in string.Formatter().parse(self.target) if f is not None
        ]
-        if any(fields):
+        if any(f not in ("", "parent") for f in fields):
            raise ValueError(
-                f"apply target {self.target!r}: only bare {{}} placeholders"
+                f"apply target {self.target!r}: only {{}} and {{parent}} placeholders"
            )
-        if len(fields) != len(self.args):
+        if (count := fields.count("")) != len(self.args):
            raise ValueError(
-                f"apply target {self.target!r} has {len(fields)} "
+                f"apply target {self.target!r} has {count} "
                f"placeholder(s) for {len(self.args)} config key(s)"
            )
        if any(len(arg) not in (2, 3) for arg in self.args):
@@ -291,6 +300,12 @@ class ApplyCall:
                f"apply target {self.target!r}: each arg is (conf_key, type_[, const_fn])"
            )

+    @property
+    def names_parent(self) -> bool:
+        return _names_parent(self.target) or any(
+            isinstance(arg[1], str) and _names_parent(arg[1]) for arg in self.args
+        )
+
    @property
    def members(self) -> list[tuple[Any, Any, Any]]:
        """Each arg as ``(conf_key, type_, const_fn or None)``."""
@@ -365,9 +380,16 @@ def _check_key_in_schema(
        schema = schema.schema[markers[part]]


+def parent_ref(var: MockObj) -> MockObj:
+    """``var`` named from global scope, so a trigger argument cannot shadow it.
+
+    Also how a generated callback names its Automation.
+    """
+    return MockObj(f"::{var}", "->")
+
+
 async def _apply_parent(config: ConfigType, id_key: str = CONF_ID) -> str:
-    # Global-scope qualified so a trigger arg named like the id cannot shadow it.
-    return f"::{await cg.get_variable(config[id_key])}"
+    return str(parent_ref(await cg.get_variable(config[id_key])))


 def _apply_lambda_args(args: TemplateArgsType) -> TemplateArgsType:
@@ -399,7 +421,7 @@ async def _render_values(
    members: list[tuple[Any, Any, Any]],
    values: list[Any],
    config: ConfigType,
-    parent: str,
+    parent: str | None,
    lambda_args: TemplateArgsType,
    compare: bool = False,
 ) -> list[str]:
@@ -477,12 +499,12 @@ def register_apply_action(
        statements: list[str] = []
        for target, members in statements_spec:
            values = _apply_values(config, members)
-            if members and all(value is None for value in values):
+            if not _apply_call_active(members, values):
                continue
            exprs = await _render_values(
                name, target, members, values, config, parent, lambda_args
            )
-            statements.append(f"{receiver}{target.format(*exprs)};")
+            statements.append(f"{receiver}{target.format(*exprs, parent=parent)};")
        if call:
            statements = [
                f"auto apply_call = {parent}->{call}();",
@@ -496,6 +518,27 @@ def register_apply_action(
    register_action(name, ApplyAction, schema, synchronous=True)(builder)


+def _apply_call_active(members: list[tuple[Any, Any, Any]], values: list[Any]) -> bool:
+    """An ``ApplyCall`` is emitted unless it has keys and none of them is set."""
+    return not members or any(value is not None for value in values)
+
+
+async def _render_check(
+    name: str,
+    target: str,
+    members: list[tuple[Any, Any, Any]],
+    values: list[Any],
+    config: ConfigType,
+    parent: str | None,
+    lambda_args: TemplateArgsType,
+) -> str:
+    """Render a boolean check with ``values`` compared against config."""
+    exprs = await _render_values(
+        name, target, members, values, config, parent, lambda_args, compare=True
+    )
+    return target.format(*exprs, parent=parent)
+
+
 def register_apply_condition(
    name: str, schema: cv.Schema, check: str | ApplyCall, id_key: str = CONF_ID
 ) -> None:
@@ -521,22 +564,16 @@ def register_apply_condition(
    ) -> MockObj:
        parent = await _apply_parent(config, id_key)
        lambda_args = _apply_lambda_args(args)
-        exprs = await _render_values(
-            name,
-            call.target,
-            members,
-            _apply_values(config, members),
-            config,
-            parent,
-            lambda_args,
-            compare=True,
+        values = _apply_values(config, members)
+        check = await _render_check(
+            name, call.target, members, values, config, parent, lambda_args
        )
        return _apply_function(
            condition_id,
            cg.bool_,
            template_arg,
            lambda_args,
-            [f"return {parent}->{call.target.format(*exprs)};"],
+            [f"return {parent}->{check};"],
        )

    register_condition(name, ApplyCondition, schema)(builder)
@@ -1011,23 +1048,78 @@ def has_non_synchronous_actions(actions: ConfigType) -> bool:
    return False


-async def build_automation(
-    trigger: MockObj, args: TemplateArgsType, config: ConfigType
+async def _new_automation(
+    args: TemplateArgsType, config: ConfigType, *ctor_args: MockObj
 ) -> MockObj:
-    arg_types = [arg[0] for arg in args]
-    templ = cg.TemplateArguments(*arg_types)
-    obj = cg.new_Pvariable(config[CONF_AUTOMATION_ID], templ, trigger)
+    """Create the Automation for ``config`` with its actions."""
+    templ = cg.TemplateArguments(*(arg[0] for arg in args))
+    obj = cg.new_Pvariable(config[CONF_AUTOMATION_ID], templ, *ctor_args)
    actions = await build_action_list(config[CONF_THEN], templ, args)
    cg.add(obj.add_actions(actions))
    return obj


+async def build_automation(
+    trigger: MockObj, args: TemplateArgsType, config: ConfigType
+) -> MockObj:
+    return await _new_automation(args, config, trigger)
+
+
+async def build_trigger_callback(
+    args: TemplateArgsType,
+    config: ConfigType,
+    params: TemplateArgsType,
+    forward: Sequence[str | Expression] | None = None,
+    when: str | ApplyCall | None = None,
+    parent: MockObj | None = None,
+) -> LambdaExpression:
+    """Build the Automation for ``config`` and return a stateless callback that triggers it.
+
+    ``params`` are the parent callback's parameters, ``forward`` the expressions passed to
+    ``trigger()`` (default: the parameter names; write the parent as ``parent_ref(var)``),
+    ``when`` a filter the callback returns early on, skipped like any ``ApplyCall`` when none
+    of its keys is set. ``when`` may name ``parent`` as ``{parent}``, e.g.
+    ``"{parent}->is_fully_open()"``.
+    """
+    members: list[tuple[Any, Any, Any]] = []
+    if when is not None:
+        call = when if isinstance(when, ApplyCall) else ApplyCall(when)
+        members = call.members
+        if parent is None and call.names_parent:
+            raise ValueError(f"trigger filter {call.target!r} names {{parent}}")
+    obj = await _new_automation(args, config)
+    lambda_args = _apply_lambda_args(params)
+    statements: list[str] = []
+    if when is not None:
+        values = _apply_values(config, members)
+        if _apply_call_active(members, values):
+            check = await _render_check(
+                "trigger filter",
+                call.target,
+                members,
+                values,
+                config,
+                None if parent is None else str(parent_ref(parent)),
+                lambda_args,
+            )
+            statements.append(f"if (!({check}))\n  return;")
+    if forward is None:
+        forward = [name for _, name in params]
+    statements.append(f"{parent_ref(obj)}->trigger({', '.join(map(str, forward))});")
+    return LambdaExpression(
+        ["\n".join(statements)], lambda_args, capture="", return_type=cg.void
+    )
+
+
 async def build_callback_automation(
    parent: MockObj,
    callback_method: str,
    args: TemplateArgsType,
    config: ConfigType,
    forwarder: MockObj | MockObjClass | None = None,
+    params: TemplateArgsType | None = None,
+    forward: Sequence[str | Expression] | None = None,
+    when: str | ApplyCall | None = None,
 ) -> None:
    """Build an Automation and register it as a callback on the parent.

@@ -1039,6 +1131,9 @@ async def build_callback_automation(
    pointer-sized (single Automation* field) to fit inline in Callback::ctx_
    and avoid heap allocation.

+    With ``params``, ``forward`` or ``when`` the callback is instead the stateless
+    lambda of ``build_trigger_callback``; ``forwarder`` cannot be combined with them.
+
    :param parent: The component object (e.g., button, sensor).
    :param callback_method: Name of the callback method (e.g., "add_on_press_callback").
    :param args: Automation template args as list of (type, name) tuples.
@@ -1047,22 +1142,56 @@ async def build_callback_automation(
        TriggerForwarder<Ts...>. Pass any struct type whose aggregate init takes
        a single Automation pointer (e.g., TriggerOnTrueForwarder).
    """
-    arg_types = [arg[0] for arg in args]
-    templ = cg.TemplateArguments(*arg_types)
-    obj = cg.new_Pvariable(config[CONF_AUTOMATION_ID], templ)
-    actions = await build_action_list(config[CONF_THEN], templ, args)
-    cg.add(obj.add_actions(actions))
+    if params is not None or forward is not None or when is not None:
+        if forwarder is not None:
+            raise ValueError(
+                "forwarder cannot be combined with params, forward or when"
+            )
+        callback = await build_trigger_callback(
+            args, config, args if params is None else params, forward, when, parent
+        )
+        cg.add(getattr(parent, callback_method)(callback))
+        return
+    obj = await _new_automation(args, config)
    # Use template forwarder structs for deduplication. The compiler generates
    # one operator() per forwarder type; different automation pointers are just
    # data in the struct.
    if forwarder is None:
-        forwarder = TriggerForwarder.template(templ)
+        forwarder = TriggerForwarder.template(*(arg[0] for arg in args))
    # RawExpression for aggregate init — both forwarder and obj are codegen
    # MockObjs (not user input), and there's no Expression type for positional
    # aggregate initialization (StructInitializer uses named fields).
    cg.add(getattr(parent, callback_method)(cg.RawExpression(f"{forwarder}{{{obj}}}")))


+async def build_parent_callback_automation(
+    parent: MockObj, callback_method: str, arg: tuple[Any, str], config: ConfigType
+) -> None:
+    """Register an Automation that receives ``parent`` from a callback that carries nothing.
+
+    ``arg`` is the automation's ``(type, name)``, e.g. ``(Fan.operator("ptr"), "x")``.
+    """
+    await build_callback_automation(
+        parent, callback_method, [arg], config, params=[], forward=[parent_ref(parent)]
+    )
+
+
+async def build_trigger_automations(
+    parent: MockObj | None,
+    config: ConfigType,
+    entries: tuple[tuple[str, TemplateArgsType], ...],
+) -> None:
+    """Instantiate each entry's Trigger class, with ``parent`` when given, and build its automations.
+
+    ``entries`` are ``(conf_key, args)`` pairs; the class comes from the entry's ``CONF_TRIGGER_ID``.
+    """
+    ctor_args = () if parent is None else (parent,)
+    for conf_key, args in entries:
+        for conf in config.get(conf_key, []):
+            trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], *ctor_args)
+            await build_automation(trigger, args, conf)
+
+
@dataclass(frozen=True, slots=True)
 class CallbackAutomation:
    """A single callback automation entry for build_callback_automations."""
@@ -1071,6 +1200,9 @@ class CallbackAutomation:
    callback_method: str
    args: TemplateArgsType = field(default_factory=list)
    forwarder: MockObj | MockObjClass | None = None
+    params: TemplateArgsType | None = None
+    forward: Sequence[str | Expression] | None = None
+    when: str | ApplyCall | None = None


 async def build_callback_automations(
@@ -1092,4 +1224,7 @@ async def build_callback_automations(
                entry.args,
                conf,
                forwarder=entry.forwarder,
+                params=entry.params,
+                forward=entry.forward,
+                when=entry.when,
            )
@@ -237,6 +237,35 @@ def idf_macro_matches(idf_path: Path) -> bool:
    return live == _EXPECTED_MACRO


+def _cmake_args_for_write(minimal: bool) -> dict[str, str]:
+    """The cg.add_cmake_arg() values for one project write.
+
+    The discovery (minimal) write lets every built-in component register so
+    the list it finds, cached per target, serves any exclusion set; the full
+    write drops the excluded names from that list and passes all of them to
+    IDF. Names outside the framework's components directory (managed
+    components) stay excluded on the discovery write too, since the list
+    only holds built-in ones. A checkout supplied through IDF_PATH caches
+    nothing, so its discovery keeps every exclusion.
+    """
+    from esphome.espidf.toolchain import _esphome_manages_idf, _get_idf_path
+
+    args = dict(CORE.cmake_args)
+    if (
+        not minimal
+        or not _esphome_manages_idf()
+        or not (excluded := args.get("EXCLUDE_COMPONENTS"))
+    ):
+        return args
+    root = _get_idf_path() / "components"
+    outside = [name for name in excluded.split(";") if not (root / name).is_dir()]
+    if outside:
+        args["EXCLUDE_COMPONENTS"] = ";".join(outside)
+    else:
+        del args["EXCLUDE_COMPONENTS"]
+    return args
+
+
 def get_project_cmakelists(
    minimal: bool = False, builtin_components: list[str] | None = None
 ) -> str:
@@ -300,11 +329,10 @@ def get_project_cmakelists(

    # CMake variables registered via cg.add_cmake_arg(). Emitted before
    # include(project.cmake) so values like EXCLUDE_COMPONENTS are already
-    # set when project.cmake seeds the component list, and on minimal
-    # (discovery) writes too so excluded components never register.
+    # set when project.cmake seeds the component list.
    cmake_args = "\n".join(
        f"set({name} {_cmake_quote(value)})"
-        for name, value in sorted(CORE.cmake_args.items())
+        for name, value in sorted(_cmake_args_for_write(minimal).items())
    )

    # Per-project list exposed as a CMake variable so converted PIO libs
@@ -327,10 +355,10 @@ def get_project_cmakelists(
    # component's REQUIRES including real IDF components). Referenced by
    # src/CMakeLists and by each converted PIO lib's CMakeLists. Skipped
    # on minimal writes because project_description.json may be stale.
-    # Excluded components are dropped here as well: a stale
-    # project_description.json from a build without exclusions may still
-    # list them, and requiring an excluded component pulls it back into
-    # the build (IDF requirement expansion overrides EXCLUDE_COMPONENTS).
+    # Excluded components are dropped here as well: the discovery list
+    # (cached per target) still holds them, and requiring an excluded
+    # component pulls it back into the build (IDF requirement expansion
+    # overrides EXCLUDE_COMPONENTS).
    # Derived from the EXCLUDE_COMPONENTS cmake arg emitted above so the
    # two can never disagree within one generated file.
    builtin_components_property = (
@@ -397,15 +425,24 @@ project({CORE.name})
 # Emit per-memory-type JSON size data for ESPHome to read post-build.
 # json2 stays small; raw dumps every symbol (~2s on a large map) and
 # this command runs inside the link edge, blocking everything downstream.
-# The map is a BYPRODUCT so ninja knows the link writes it; IDF's size
-# target depends on the map and can then be built in the same run as all.
-# IDF's cmakev2 declares the map itself, so drop this line on that switch.
+# IDF's size target depends on the map, so ninja has to know the link
+# writes it for size to build in the same run as all. IDF declares the
+# map itself since espressif/esp-idf#19201 (and in cmakev2), and ninja
+# rejects two rules for one output, so declare it here only when IDF has
+# not. add_custom_command(OUTPUT) marks its outputs GENERATED.
+get_source_file_property(esphome_map_declared
+    ${{CMAKE_BINARY_DIR}}/${{CMAKE_PROJECT_NAME}}.map GENERATED)
+if(esphome_map_declared)
+    set(esphome_map_byproducts)
+else()
+    set(esphome_map_byproducts BYPRODUCTS ${{CMAKE_BINARY_DIR}}/${{CMAKE_PROJECT_NAME}}.map)
+endif()
 add_custom_command(
    TARGET ${{CMAKE_PROJECT_NAME}}.elf POST_BUILD
    COMMAND ${{PYTHON}} -m esp_idf_size {size_ng_flag} --format=json2
            -o ${{CMAKE_BINARY_DIR}}/esp_idf_size.json
            ${{CMAKE_PROJECT_NAME}}.map
-    BYPRODUCTS ${{CMAKE_BINARY_DIR}}/${{CMAKE_PROJECT_NAME}}.map
+    ${{esphome_map_byproducts}}
    WORKING_DIRECTORY ${{CMAKE_BINARY_DIR}}
    VERBATIM
 )
@@ -554,10 +591,9 @@ def write_project(
    )

    # Snapshot the exclusion set so has_outdated_files() can trigger a
-    # discovery reconfigure when it changes. Excluded components never
-    # register in project_description.json, so re-including one (e.g. a
-    # config gains mqtt) requires a fresh discovery pass before the
-    # ESPHOME_PROJECT_BUILTIN_COMPONENTS property can list it.
+    # reconfigure when it changes. The ESPHOME_PROJECT_BUILTIN_COMPONENTS
+    # property drops excluded names, so re-including one (e.g. a config
+    # gains mqtt) needs a reconfigure to rebuild it from the discovery list.
    write_file_if_changed(
        CORE.relative_build_path("exclude_components.esphomeinternal"),
        ";".join(get_excluded_builtin_components()),
@@ -34,11 +34,13 @@ from esphome.cpp_generator import (  # noqa: F401
    extern_progmem_array,
    get_variable,
    get_variable_with_full_id,
+    is_static_pointer,
    is_template,
    new_Pvariable,
    new_variable,
    process_lambda,
    progmem_array,
+    progmem_string,
    safe_exp,
    set_cpp_standard,
    shared_progmem_array,
@@ -1 +1,2 @@
 CODEOWNERS = ["@MrSuicideParrot"]
+DOMAIN = "a01nyub"
@@ -6,7 +6,7 @@

 namespace esphome::a01nyub {

-static const char *const TAG = "a01nyub.sensor";
+ESPHOME_LOG_TAG(TAG, "a01nyub.sensor");

 void A01nyubComponent::loop() {
  uint8_t data;
@@ -1 +1,2 @@
 CODEOWNERS = ["@TH-Braemer"]
+DOMAIN = "a02yyuw"
@@ -6,7 +6,7 @@

 namespace esphome::a02yyuw {

-static const char *const TAG = "a02yyuw.sensor";
+ESPHOME_LOG_TAG(TAG, "a02yyuw.sensor");

 void A02yyuwComponent::loop() {
  uint8_t data;
@@ -0,0 +1 @@
+DOMAIN = "a4988"
@@ -3,7 +3,7 @@

 namespace esphome::a4988 {

-static const char *const TAG = "a4988.stepper";
+ESPHOME_LOG_TAG(TAG, "a4988.stepper");

 void A4988::setup() {
  if (this->sleep_pin_ != nullptr) {
@@ -1 +1,2 @@
 CODEOWNERS = ["@DAVe3283"]
+DOMAIN = "absolute_humidity"
@@ -3,7 +3,7 @@

 namespace esphome::absolute_humidity {

-static const char *const TAG{"absolute_humidity.sensor"};
+ESPHOME_LOG_TAG(TAG, "absolute_humidity.sensor");

 void AbsoluteHumidityComponent::setup() {
  this->temperature_sensor_->add_on_state_callback([this](float state) {
@@ -0,0 +1 @@
+DOMAIN = "ac_dimmer"
@@ -14,7 +14,7 @@

 namespace esphome::ac_dimmer {

-static const char *const TAG = "ac_dimmer";
+ESPHOME_LOG_TAG(TAG, "ac_dimmer");

 // Global array to store dimmer objects
 static AcDimmerDataStore *all_dimmers[32];  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -9,7 +9,7 @@
 #include "esp_clk_tree.h"
 #include "soc/clk_tree_defs.h"

-static const char *const TAG = "hw_timer_esp_idf";
+ESPHOME_LOG_TAG(TAG, "hw_timer_esp_idf");

 namespace esphome::ac_dimmer {

@@ -9,6 +9,7 @@ from esphome.cpp_generator import MockObj
 from esphome.types import ConfigType

 DEPENDENCIES = ["uart"]
+DOMAIN = "adalight"

 adalight_ns = cg.esphome_ns.namespace("adalight")
 AdalightLightEffect = adalight_ns.class_(
@@ -3,7 +3,7 @@

 namespace esphome::adalight {

-static const char *const TAG = "adalight_light_effect";
+ESPHOME_LOG_TAG(TAG, "adalight_light_effect");

 static const uint32_t ADALIGHT_ACK_INTERVAL = 1000;
 static const uint32_t ADALIGHT_RECEIVE_TIMEOUT = 1000;
@@ -22,6 +22,7 @@ from esphome.core import CORE
 from esphome.types import ConfigType

 CODEOWNERS = ["@esphome/core"]
+DOMAIN = "adc"

 adc_ns = cg.esphome_ns.namespace("adc")

@@ -3,7 +3,7 @@

 namespace esphome::adc {

-static const char *const TAG = "adc";
+ESPHOME_LOG_TAG(TAG, "adc");

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

 namespace esphome::adc {

-static const char *const TAG = "adc";
+ESPHOME_LOG_TAG(TAG, "adc");

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

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

 namespace esphome::adc {

-static const char *const TAG = "adc";
+ESPHOME_LOG_TAG(TAG, "adc");

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

 namespace esphome::adc {

-static const char *const TAG = "adc";
+ESPHOME_LOG_TAG(TAG, "adc");

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

 namespace esphome::adc {

-static const char *const TAG = "adc";
+ESPHOME_LOG_TAG(TAG, "adc");

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

 namespace esphome::adc {

-static const char *const TAG = "adc";
+ESPHOME_LOG_TAG(TAG, "adc");

 void ADCSensor::setup() {
  if (!adc_is_ready_dt(this->channel_)) {
@@ -5,6 +5,7 @@ from esphome.const import CONF_ID
 from esphome.types import ConfigType

 DEPENDENCIES = ["spi"]
+DOMAIN = "adc128s102"
 MULTI_CONF = True
 CODEOWNERS = ["@DeerMaximum"]

@@ -3,7 +3,7 @@

 namespace esphome::adc128s102 {

-static const char *const TAG = "adc128s102";
+ESPHOME_LOG_TAG(TAG, "adc128s102");

 float ADC128S102::get_setup_priority() const { return setup_priority::HARDWARE; }

@@ -4,7 +4,7 @@

 namespace esphome::adc128s102 {

-static const char *const TAG = "adc128s102.sensor";
+ESPHOME_LOG_TAG(TAG, "adc128s102.sensor");

 ADC128S102Sensor::ADC128S102Sensor(uint8_t channel) : channel_(channel) {}

@@ -0,0 +1 @@
+DOMAIN = "addressable_light"
@@ -3,7 +3,7 @@

 namespace esphome::addressable_light {

-static const char *const TAG = "addressable_light.display";
+ESPHOME_LOG_TAG(TAG, "addressable_light.display");

 int AddressableLightDisplay::get_width_internal() { return this->width_; }
 int AddressableLightDisplay::get_height_internal() { return this->height_; }
@@ -0,0 +1 @@
+DOMAIN = "ade7880"
@@ -15,7 +15,7 @@

 namespace esphome::ade7880 {

-static const char *const TAG = "ade7880";
+ESPHOME_LOG_TAG(TAG, "ade7880");

 void IRAM_ATTR ADE7880Store::gpio_intr(ADE7880Store *arg) { arg->reset_done = true; }

@@ -1 +1,2 @@
 CODEOWNERS = ["@angelnu"]
+DOMAIN = "ade7953"
@@ -27,6 +27,7 @@ from esphome.cpp_generator import MockObj
 from esphome.types import ConfigType

 CODEOWNERS = ["@angelnu"]
+DOMAIN = "ade7953_base"

 CONF_CURRENT_A = "current_a"
 CONF_CURRENT_B = "current_b"
@@ -5,7 +5,7 @@

 namespace esphome::ade7953_base {

-static const char *const TAG = "ade7953";
+ESPHOME_LOG_TAG(TAG, "ade7953");

 constexpr uint16_t CONFIG_DEFAULT = 0x8004u;
 constexpr uint16_t CONFIG_LOCK_BIT = 0x8000u;
@@ -1 +1,2 @@
 CODEOWNERS = ["@angelnu"]
+DOMAIN = "ade7953_i2c"
@@ -4,7 +4,7 @@

 namespace esphome::ade7953_i2c {

-static const char *const TAG = "ade7953";
+ESPHOME_LOG_TAG(TAG, "ade7953");

 void AdE7953I2c::dump_config() {
  ESP_LOGCONFIG(TAG, "ADE7953_i2c:");
@@ -1 +1,2 @@
 CODEOWNERS = ["@angelnu"]
+DOMAIN = "ade7953_spi"
@@ -4,7 +4,7 @@

 namespace esphome::ade7953_spi {

-static const char *const TAG = "ade7953";
+ESPHOME_LOG_TAG(TAG, "ade7953");

 // Datasheet requires at least 1.2µs after clearing CONFIG LOCK_BIT before raising CS
 constexpr uint8_t CONFIG_LOCK_SETTLE_US = 2;
@@ -5,6 +5,7 @@ from esphome.const import CONF_ID
 from esphome.types import ConfigType

 DEPENDENCIES = ["i2c"]
+DOMAIN = "ads1115"
 MULTI_CONF = True

 ads1115_ns = cg.esphome_ns.namespace("ads1115")
@@ -4,7 +4,7 @@

 namespace esphome::ads1115 {

-static const char *const TAG = "ads1115";
+ESPHOME_LOG_TAG(TAG, "ads1115");
 static const uint8_t ADS1115_REGISTER_CONVERSION = 0x00;
 static const uint8_t ADS1115_REGISTER_CONFIG = 0x01;

@@ -4,7 +4,7 @@

 namespace esphome::ads1115 {

-static const char *const TAG = "ads1115.sensor";
+ESPHOME_LOG_TAG(TAG, "ads1115.sensor");

 float ADS1115Sensor::sample() {
  return this->parent_->request_measurement(this->multiplexer_, this->gain_, this->resolution_, this->samplerate_);
@@ -6,6 +6,7 @@ from esphome.types import ConfigType

 CODEOWNERS = ["@solomondg1"]
 DEPENDENCIES = ["spi"]
+DOMAIN = "ads1118"
 MULTI_CONF = True

 CONF_ADS1118_ID = "ads1118_id"
@@ -4,7 +4,7 @@

 namespace esphome::ads1118 {

-static const char *const TAG = "ads1118";
+ESPHOME_LOG_TAG(TAG, "ads1118");
 static const uint8_t ADS1118_DATA_RATE_860_SPS = 0b111;

 void ADS1118::setup() {
@@ -4,7 +4,7 @@

 namespace esphome::ads1118 {

-static const char *const TAG = "ads1118.sensor";
+ESPHOME_LOG_TAG(TAG, "ads1118.sensor");

 void ADS1118Sensor::dump_config() {
  LOG_SENSOR("  ", "ADS1118 Sensor", this);
@@ -1 +1,2 @@
 CODEOWNERS = ["@mak-42"]
+DOMAIN = "ags10"
@@ -4,7 +4,7 @@
 #include <cinttypes>

 namespace esphome::ags10 {
-static const char *const TAG = "ags10";
+ESPHOME_LOG_TAG(TAG, "ags10");

 // Data acquisition.
 static const uint8_t REG_TVOC = 0x00;
@@ -0,0 +1 @@
+DOMAIN = "aht10"
@@ -19,7 +19,7 @@

 namespace esphome::aht10 {

-static const char *const TAG = "aht10";
+ESPHOME_LOG_TAG(TAG, "aht10");
 static const uint8_t AHT10_INITIALIZE_CMD[] = {0xE1, 0x08, 0x00};
 static const uint8_t AHT20_INITIALIZE_CMD[] = {0xBE, 0x08, 0x00};
 static const uint8_t AHT10_MEASURE_CMD[] = {0xAC, 0x33, 0x00};
@@ -0,0 +1 @@
+DOMAIN = "aic3204"
@@ -6,7 +6,7 @@

 namespace esphome::aic3204 {

-static const char *const TAG = "aic3204";
+ESPHOME_LOG_TAG(TAG, "aic3204");

 #define ERROR_CHECK(err, msg) \
  if (!(err)) { \
@@ -6,6 +6,7 @@ from esphome.types import ConfigType

 AUTO_LOAD = ["ble_device_base"]
 CODEOWNERS = ["@jeromelaban"]
+DOMAIN = "airthings_ble"

 airthings_ble_ns = cg.esphome_ns.namespace("airthings_ble")
 AirthingsListener = airthings_ble_ns.class_(
@@ -4,7 +4,7 @@

 namespace esphome::airthings_ble {

-static const char *const TAG = "airthings_ble";
+ESPHOME_LOG_TAG(TAG, "airthings_ble");

 bool AirthingsListener::parse_device(const ble_device_base::ESPBTDevice &device) {
  for (auto &it : device.get_manufacturer_datas()) {
@@ -24,6 +24,7 @@ from esphome.cpp_generator import MockObj
 from esphome.types import ConfigType

 CODEOWNERS = ["@ncareau", "@jeromelaban"]
+DOMAIN = "airthings_wave_base"

 DEPENDENCIES = ["ble_client"]

@@ -8,7 +8,10 @@

 namespace esphome::airthings_wave_base {

-static const char *const TAG = "airthings_wave_base";
+ESPHOME_LOG_TAG(TAG, "airthings_wave_base");
+
+static constexpr uint32_t BATTERY_READ_TIMEOUT_ID = 0;
+static constexpr uint32_t RESPONSE_TIMEOUT_ID = 1;

 void AirthingsWaveBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                                            esp_ble_gattc_cb_param_t *param) {
@@ -181,7 +184,7 @@ void AirthingsWaveBase::read_battery_(uint8_t *raw_value, uint16_t value_len) {
    // read the battery again at the configured update interval
    if (this->battery_update_interval_ != this->update_interval_) {
      this->read_battery_next_update_ = false;
-      this->set_timeout("battery", this->battery_update_interval_,
+      this->set_timeout(BATTERY_READ_TIMEOUT_ID, this->battery_update_interval_,
                        [this]() { this->read_battery_next_update_ = true; });
    }
  }
@@ -204,7 +207,7 @@ void AirthingsWaveBase::response_received_() {
 }

 void AirthingsWaveBase::set_response_timeout_() {
-  this->set_timeout("response_timeout", 30 * 1000, [this]() {
+  this->set_timeout(RESPONSE_TIMEOUT_ID, 30 * 1000, [this]() {
    this->responses_pending_ = 1;
    this->response_received_();
  });
@@ -1 +1,2 @@
 CODEOWNERS = ["@ncareau"]
+DOMAIN = "airthings_wave_mini"
@@ -4,7 +4,7 @@

 namespace esphome::airthings_wave_mini {

-static const char *const TAG = "airthings_wave_mini";
+ESPHOME_LOG_TAG(TAG, "airthings_wave_mini");

 void AirthingsWaveMini::read_sensors(uint8_t *raw_value, uint16_t value_len) {
  auto *value = (WaveMiniReadings *) raw_value;
@@ -1 +1,2 @@
 CODEOWNERS = ["@jeromelaban", "@precurse"]
+DOMAIN = "airthings_wave_plus"
@@ -4,7 +4,7 @@

 namespace esphome::airthings_wave_plus {

-static const char *const TAG = "airthings_wave_plus";
+ESPHOME_LOG_TAG(TAG, "airthings_wave_plus");

 void AirthingsWavePlus::read_sensors(uint8_t *raw_value, uint16_t value_len) {
  auto *value = (WavePlusReadings *) raw_value;
@@ -21,6 +21,7 @@ from esphome.core.entity_helpers import (
 from esphome.cpp_generator import MockObjClass

 CODEOWNERS = ["@grahambrown11", "@hwstar"]
+DOMAIN = "alarm_control_panel"
 IS_PLATFORM_COMPONENT = True

 CONF_ON_TRIGGERED = "on_triggered"
@@ -10,7 +10,7 @@

 namespace esphome::alarm_control_panel {

-static const char *const TAG = "alarm_control_panel";
+ESPHOME_LOG_TAG(TAG, "alarm_control_panel");

 AlarmControlPanelCall AlarmControlPanel::make_call() { return AlarmControlPanelCall(this); }

@@ -6,7 +6,7 @@

 namespace esphome::alarm_control_panel {

-static const char *const TAG = "alarm_control_panel";
+ESPHOME_LOG_TAG(TAG, "alarm_control_panel");

 AlarmControlPanelCall::AlarmControlPanelCall(AlarmControlPanel *parent) : parent_(parent) {}

@@ -1 +1,2 @@
 CODEOWNERS = ["@jan-hofmeier"]
+DOMAIN = "alpha3"
@@ -7,7 +7,7 @@

 namespace esphome::alpha3 {

-static const char *const TAG = "alpha3";
+ESPHOME_LOG_TAG(TAG, "alpha3");

 void Alpha3::dump_config() {
  ESP_LOGCONFIG(TAG, "ALPHA3");
@@ -1 +1,2 @@
 CODEOWNERS = ["@swoboda1337"]
+DOMAIN = "am2315c"
@@ -26,7 +26,7 @@

 namespace esphome::am2315c {

-static const char *const TAG = "am2315c";
+ESPHOME_LOG_TAG(TAG, "am2315c");

 bool AM2315C::reset_register_(uint8_t reg) {
  //  code based on demo code sent by www.aosong.com
@@ -0,0 +1 @@
+DOMAIN = "am2320"
@@ -10,7 +10,7 @@

 namespace esphome::am2320 {

-static const char *const TAG = "am2320";
+ESPHOME_LOG_TAG(TAG, "am2320");

 void AM2320Component::update() {
  uint8_t data[8];
@@ -1 +1,2 @@
 CODEOWNERS = ["@buxtronix"]
+DOMAIN = "am43"
@@ -5,7 +5,7 @@

 namespace esphome::am43 {

-static const char *const TAG = "am43_cover";
+ESPHOME_LOG_TAG(TAG, "am43_cover");

 using namespace esphome::cover;

@@ -6,7 +6,7 @@

 namespace esphome::am43 {

-static const char *const TAG = "am43";
+ESPHOME_LOG_TAG(TAG, "am43");

 void Am43::dump_config() {
  ESP_LOGCONFIG(TAG, "AM43");
@@ -1 +1,2 @@
 CODEOWNERS = ["@ianchi"]
+DOMAIN = "analog_threshold"
@@ -3,7 +3,7 @@

 namespace esphome::analog_threshold {

-static const char *const TAG = "analog_threshold.binary_sensor";
+ESPHOME_LOG_TAG(TAG, "analog_threshold.binary_sensor");

 void AnalogThresholdBinarySensor::setup() {
  float sensor_value = this->sensor_->get_state();
@@ -0,0 +1 @@
+DOMAIN = "anova"
@@ -5,7 +5,7 @@

 namespace esphome::anova {

-static const char *const TAG = "anova";
+ESPHOME_LOG_TAG(TAG, "anova");

 using namespace esphome::climate;

@@ -2,3 +2,4 @@
 # https://www.mouser.ca/datasheet/2/678/AVGO_S_A0002854364_1-2574547.pdf

 CODEOWNERS = ["@aodrenah"]
+DOMAIN = "apds9306"
@@ -7,7 +7,7 @@

 namespace esphome::apds9306 {

-static const char *const TAG = "apds9306";
+ESPHOME_LOG_TAG(TAG, "apds9306");

 enum {  // APDS9306 registers
  APDS9306_MAIN_CTRL = 0x00,
@@ -5,6 +5,7 @@ from esphome.const import CONF_ID
 from esphome.types import ConfigType

 DEPENDENCIES = ["i2c"]
+DOMAIN = "apds9960"
 MULTI_CONF = True

 CONF_APDS9960_ID = "apds9960_id"
@@ -4,7 +4,7 @@

 namespace esphome::apds9960 {

-static const char *const TAG = "apds9960";
+ESPHOME_LOG_TAG(TAG, "apds9960");

 #define APDS9960_ERROR_CHECK(func) \
  if (!(func)) { \
@@ -8,6 +8,7 @@ from esphome.automation import Condition
 import esphome.codegen as cg
 from esphome.components.const import CONF_DESCRIPTION, CONF_HOST
 from esphome.components.logger import request_log_listener
+from esphome.components.network import DOMAIN as NETWORK_DOMAIN

 # ENCRYPTION_SCHEMA and validate_encryption_key are re-exported for external
 # components and downstream consumers that import them from api
@@ -514,7 +515,7 @@ def _validate_outgoing_host_ipv6(config: ConfigType) -> ConfigType:
        or host.version != 6
    ):
        return config
-    network_conf = fv.full_config.get().get("network") or {}
+    network_conf = fv.full_config.get().get(NETWORK_DOMAIN) or {}
    if not network_conf.get(CONF_ENABLE_IPV6):
        raise cv.Invalid(
            "outgoing_connection host is an IPv6 address but IPv6 is not "
@@ -403,9 +403,6 @@ message WizardCapabilities {
 message SendspinCapabilities {
  // Bitmask of the Sendspin features this device supports
  uint32 feature_flags = 1;
-  // The Sendspin client_id: base64url of the client's static public key, 43 characters.
-  // Empty until the Sendspin client has started once since boot.
-  string client_id = 2 [(max_data_length) = 43];
 }

 message DeviceCapabilitiesResponse {
@@ -447,7 +444,7 @@ message DeviceWizardRequest {
 //   {"version": 1,
 //    "pages": [{"title": "...", "description": "...",
 //      "entities": [{"key": 123, "device_id": 456, "description": "..."}],
-//      "inputs": [{"key": 789, "description": "...", "multiple": true, "max_length": 1023,
+//      "inputs": [{"key": 789, "description": "...",
 //        "entity_filters": [{"integration": "...", "domain": ["..."],
 //                            "device_class": ["..."], "supported_features": ["..."]}]}]}]}
 //
@@ -471,14 +468,6 @@ message DeviceWizardRequest {
 // an entity matches a filter when it satisfies every field that is set, and an entity
 // that matches any one of the filters is accepted.
 //
-// An input with "multiple": true lets the user pick several entities. The client sends
-// them in one WizardInputSetRequest as a comma separated list with no spaces
-// ("calendar.a,calendar.b"); the device also accepts spaces around each id and stores the
-// list without them. "max_length" (only on a multiple input, 255 when left out) is the
-// longest list in bytes the device accepts. The version stays 1: a client that does not
-// know "multiple" ignores it, shows a single picker and sends one entity id, which a
-// multiple input accepts.
-//
 // The device keeps the entity id of an input in RAM only and does not store it across
 // restarts. The client therefore stores the choice itself and, after every connection
 // and before it sends SubscribeHomeAssistantStatesRequest, sends a WizardInputSetRequest
@@ -494,13 +483,8 @@ message DeviceWizardResponse {

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

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

 message ListEntitiesRequest {
@@ -776,7 +760,7 @@ message ListEntitiesLightResponse {
  bool legacy_supports_color_temperature = 8 [deprecated=true];
  float min_mireds = 9;
  float max_mireds = 10;
-  repeated string effects = 11 [(container_pointer_no_template) = "FixedVector<const char *>"];
+  repeated string effects = 11 [(container_pointer_no_template) = "light::LightEffectNames"];
  bool disabled_by_default = 13;
  string icon = 14 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
  EntityCategory entity_category = 15;
@@ -3046,15 +3030,12 @@ enum SerialProxyIdentityFlag {
                                             // IDs below are empty
 }

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

 // The identity of the device behind a port. Identifies one physical device among others of
@@ -91,7 +91,7 @@ static_assert(sizeof(ESPHOME_VERSION) - 1 <= 32, "Update max_data_length for esp
 static_assert(ESPHOME_DEVICE_NAME_MAX_LEN <= 31, "Update max_data_length for name in api.proto");
 static_assert(ESPHOME_FRIENDLY_NAME_MAX_LEN <= 120, "Update max_data_length for friendly_name in api.proto");

-static const char *const TAG = "api.connection";
+ESPHOME_LOG_TAG(TAG, "api.connection");

 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_WARN
 void log_dropped_message(const char *tag, int line, const LogString *what) {
@@ -644,16 +644,7 @@ uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *c
    msg.min_mireds = traits.get_min_mireds();
    msg.max_mireds = traits.get_max_mireds();
  }
-  FixedVector<const char *> effects_list;
-  if (light->supports_effects()) {
-    auto &light_effects = light->get_effects();
-    effects_list.init(light_effects.size() + 1);
-    effects_list.push_back("None");
-    for (auto *effect : light_effects) {
-      // c_str() is safe as effect names are null-terminated strings from codegen
-      effects_list.push_back(effect->get_name().c_str());
-    }
-  }
+  light::LightEffectNames effects_list(light->get_effects());
  msg.effects = &effects_list;
  return fill_and_encode_entity_info(light, msg, conn, remaining_size);
 }
@@ -2128,7 +2119,6 @@ bool APIConnection::send_device_capabilities_response_() {
 #endif
 #if defined(USE_SENDSPIN) && defined(USE_ESP_IDF)
  resp.sendspin.feature_flags = sendspin_::global_sendspin_hub->get_feature_flags();
-  resp.sendspin.client_id = sendspin_::global_sendspin_hub->get_client_id();
 #endif
  return this->send_message(resp);
 }
@@ -10,7 +10,7 @@

 namespace esphome::api {

-static const char *const TAG = "api.frame_helper";
+ESPHOME_LOG_TAG(TAG, "api.frame_helper");

 // Maximum bytes to log in hex format (168 * 3 = 504, under TX buffer size of 512)
 static constexpr size_t API_MAX_LOG_BYTES = 168;
@@ -22,7 +22,7 @@ using noise::noise_err_to_logstr;
 static_assert(MAX_HANDSHAKE_SIZE == noise::MAX_HANDSHAKE_SIZE,
              "api and noise component handshake size limits must match");

-static const char *const TAG = "api.noise";
+ESPHOME_LOG_TAG(TAG, "api.noise");
 static constexpr char PROLOGUE_INIT[] PROGMEM = "NoiseAPIInit";
 static constexpr size_t PROLOGUE_INIT_LEN = 12;  // strlen("NoiseAPIInit")

@@ -16,7 +16,7 @@

 namespace esphome::api {

-static const char *const TAG = "api.plaintext";
+ESPHOME_LOG_TAG(TAG, "api.plaintext");

 // Maximum bytes to log in hex format (168 * 3 = 504, under TX buffer size of 512)
 static constexpr size_t API_MAX_LOG_BYTES = 168;
@@ -15,7 +15,7 @@

 namespace esphome::api {

-static const char *const TAG = "api.outgoing";
+ESPHOME_LOG_TAG(TAG, "api.outgoing");

 #ifndef API_OUTGOING_CONNECTION_HOST
 static constexpr uint32_t OUTGOING_TARGET_PREF_HASH = 629847102UL;
@@ -152,7 +152,10 @@ void OutgoingConnectionManager::loop(APIServer *server) {

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

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

  // Byte-aligned types last
 #ifndef API_OUTGOING_CONNECTION_HOST
@@ -310,14 +310,12 @@ uint32_t WizardCapabilities::calc_size_msg(const void *self) {
 uint8_t *SendspinCapabilities::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
  const auto &msg = *static_cast<const SendspinCapabilities *>(self);
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.feature_flags);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.client_id);
  return pos;
 }
 uint32_t SendspinCapabilities::calc_size_msg(const void *self) {
  const auto &msg = *static_cast<const SendspinCapabilities *>(self);
  uint32_t size = 0;
  size += ProtoSize::calc_uint32(1, msg.feature_flags);
-  size += !msg.client_id.empty() ? 2 + msg.client_id.size() : 0;
  return size;
 }
 #endif
@@ -690,8 +688,8 @@ uint8_t *ListEntitiesLightResponse::encode_msg(const void *self, uint8_t *__rest
  if (uint32_t raw = float_to_raw(msg.max_mireds); raw != 0) [[likely]] {
    pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 85, raw);
  }
-  for (const char *it : *msg.effects) {
-    pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 11, it, strlen(it));
+  for (const auto &it : *msg.effects) {
+    pos = ProtoEncode::encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, 11, it);
  }
  pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.disabled_by_default);
 #ifdef USE_ENTITY_ICON
@@ -715,8 +713,8 @@ uint32_t ListEntitiesLightResponse::calc_size_msg(const void *self) {
  size += ProtoSize::calc_float(1, msg.min_mireds);
  size += ProtoSize::calc_float(1, msg.max_mireds);
  if (!msg.effects->empty()) {
-    for (const char *it : *msg.effects) {
-      size += ProtoSize::calc_length_force(1, strlen(it));
+    for (const auto &it : *msg.effects) {
+      size += ProtoSize::calc_length_force(1, it.size());
    }
  }
  size += ProtoSize::calc_bool(1, msg.disabled_by_default);
@@ -4177,8 +4175,6 @@ uint8_t *UsbDeviceDescriptor::encode_msg(const void *self, uint8_t *__restrict__
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.product_id);
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.bcd_device);
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.interface_number);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.interface_class);
-  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.port_number);
  return pos;
 }
 uint32_t UsbDeviceDescriptor::calc_size_msg(const void *self) {
@@ -4188,8 +4184,6 @@ uint32_t UsbDeviceDescriptor::calc_size_msg(const void *self) {
  size += ProtoSize::calc_uint32(1, msg.product_id);
  size += ProtoSize::calc_uint32(1, msg.bcd_device);
  size += ProtoSize::calc_uint32(1, msg.interface_number);
-  size += ProtoSize::calc_uint32(1, msg.interface_class);
-  size += ProtoSize::calc_uint32(1, msg.port_number);
  return size;
 }
 uint8_t *SerialProxyIdentity::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
@@ -750,7 +750,6 @@ class WizardCapabilities final : public ProtoMessage {
 class SendspinCapabilities final : public ProtoMessage {
 public:
  uint32_t feature_flags{0};
-  StringRef client_id{nullptr, 0};  // null until set, encode only
  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
    return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -1060,7 +1059,7 @@ class ListEntitiesLightResponse final : public InfoResponseProtoMessage {
  const light::ColorModeMask *supported_color_modes{};
  float min_mireds{0.0f};
  float max_mireds{0.0f};
-  const FixedVector<const char *> *effects{};
+  const light::LightEffectNames *effects{};
  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
    return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -4084,8 +4083,6 @@ class UsbDeviceDescriptor final : public ProtoMessage {
  uint32_t product_id{0};
  uint32_t bcd_device{0};
  uint32_t interface_number{0};
-  uint32_t interface_class{0};
-  uint32_t port_number{0};
  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
    return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -1119,7 +1119,6 @@ const char *WizardCapabilities::dump_to(DumpBuffer &out) const {
 const char *SendspinCapabilities::dump_to(DumpBuffer &out) const {
  MessageDumpHelper helper(out, ESPHOME_PSTR("SendspinCapabilities"));
  dump_field(out, ESPHOME_PSTR("feature_flags"), this->feature_flags);
-  dump_field(out, ESPHOME_PSTR("client_id"), this->client_id);
  return out.c_str();
 }
 #endif
@@ -2943,8 +2942,6 @@ const char *UsbDeviceDescriptor::dump_to(DumpBuffer &out) const {
  dump_field(out, ESPHOME_PSTR("product_id"), this->product_id);
  dump_field(out, ESPHOME_PSTR("bcd_device"), this->bcd_device);
  dump_field(out, ESPHOME_PSTR("interface_number"), this->interface_number);
-  dump_field(out, ESPHOME_PSTR("interface_class"), this->interface_class);
-  dump_field(out, ESPHOME_PSTR("port_number"), this->port_number);
  return out.c_str();
 }
 const char *SerialProxyIdentity::dump_to(DumpBuffer &out) const {
@@ -15,6 +15,7 @@
 #endif

 #ifdef USE_LIGHT
+#include "esphome/components/light/light_effect_names.h"
 #include "esphome/components/light/light_traits.h"
 #endif

@@ -6,7 +6,7 @@

 namespace esphome::api {

-static const char *const TAG = "api.service";
+ESPHOME_LOG_TAG(TAG, "api.service");

 #ifdef HAS_PROTO_MESSAGE_DUMP
 void APIServerConnectionBase::log_send_message_(const LogString *name, const char *dump) {