Merge remote-tracking branch 'origin/dev' into uart-idf-write-before-setup-guard

# Conflicts:
#	esphome/components/uart/uart_component_esp_idf.h

.agents/skills/code-review/SKILL.md

@@ -1,116 +0,0 @@
----
-name: code-review
-description: Review guidance for ESPHome pull requests. Use this when reviewing a pull request that changes ESPHome Python, C++, or component code, to check it against the project's coding conventions, embedded-systems memory rules, testing requirements, and breaking-change policy.
----
-
-# Reviewing ESPHome pull requests
-
-ESPHome parses YAML into C++ firmware for memory-constrained microcontrollers
-(ESP32, ESP8266, RP2040, LibreTiny). Review changes with that in mind: RAM and
-flash are scarce, and code runs unattended for months.
-
-`AGENTS.md` in the repository root is the full contributor guide and the
-authority when it disagrees with this summary. The developer documentation at
-https://developers.esphome.io explains the component lifecycle and the reasoning
-behind these rules. This skill lists the concrete things worth flagging in a
-review; read `AGENTS.md` for the detail behind any item.
-
-Only raise findings that the diff actually introduces or changes. Do not ask for
-drive-by cleanup of pre-existing code the PR did not touch.
-
-## Memory and embedded constraints (highest value)
-
-Heap allocation after `setup()` is treated as a reliability bug, not a
-performance nit, because it fragments a small shared heap. Flag:
-
-- New heap allocation on a hot path or after setup that could be avoided.
-- `std::vector` where the size is known at compile time (use `std::array`, or
-  `StaticVector<T, N>` when a `push_back` API is needed) or fixed at runtime
-  init (use `FixedVector<T>`).
-- Listener / child-entity registration lists stored as `std::vector`; these have
-  a compile-time-known count and should use `cg.slot_counter()` plus
-  `StaticVector`.
-- `std::vector<uint8_t>` for a byte buffer that never grows: prefer
-  `std::unique_ptr<uint8_t[]>` or `std::array`.
-- `std::map` / `std::set` / `std::unordered_map` for small datasets (1-16
-  elements): a `std::vector` of a small struct with linear search is lighter.
-- `std::deque` anywhere: it allocates 512-byte blocks and should be avoided.
-- `std::string` storing a value set once from config: prefer `StringRef` (the
-  literal already lives in flash).
-- `std::string` / `std::to_string` / string-returning helpers on hot paths where
-  a buffer or view API exists.
-
-## C++ conventions
-
-- Include what you use: a file referencing a symbol must include the header that
-  declares it, even if it currently arrives transitively. New or changed uses of
-  a symbol need the matching include.
-- Prefix all member access with `this->`.
-- Naming: `lower_snake_case` for functions/methods/variables, `UpperCamelCase`
-  for classes/structs/enums, `UPPER_SNAKE_CASE` for namespace-scope constants,
-  trailing underscore on protected/private fields.
-- `enum class` values must be prefixed with the enum name in `UPPER_SNAKE_CASE`
-  (e.g. `UARTFlushResult::UART_FLUSH_RESULT_SUCCESS`). Bare names like `SUCCESS`,
-  `FAIL`, or `OK` collide with SDK macros on some platforms and break the build.
-- Prefer `const`/`enum` over `#define`; `#define` is only for conditional
-  compilation and code-generation sizes.
-- Never call `millis()` in a `loop()` body; use
-  `App.get_loop_component_start_time()`. A rate-limit gate below ~16 ms (the loop
-  period) does nothing.
-- Pick the timing primitive by cadence: gated `loop()` under 250 ms,
-  `set_interval` at 500 ms and above.
-- Do not override a base method to return the value it already returns (e.g.
-  `get_setup_priority()` returning `setup_priority::DATA`).
-- Wrap string literals passed as printf `%s` args in `LOG_STR_LITERAL()`.
-- Required, invariant dependencies should be constructor parameters, not setters.
-- Callback registration methods must be templated (`template<typename F>`), not
-  typed as `std::function`, so lightweight forwarders avoid a heap allocation.
-- Two-space indent, `using` over `typedef`, wrap at 120 columns.
-
-## Python conventions
-
-- Type-annotate every new function signature (params and return), new dataclass
-  fields, and new module-level variables. Import `ConfigType` from
-  `esphome.types`.
-- Use the walrus operator to avoid a double lookup, e.g.
-  `if (blah := config.get(CONF_BLAH)) is not None:`.
-- Reuse existing validators from `config_validation.py` (`cv.rename_key`,
-  `cv.has_exactly_one_key`, etc.) via `cv.All(...)` instead of hand-rolling.
-- `esphome/const.py` is frozen: no new `CONF_` constants there. Define them in
-  the component's own `.py`, or in `esphome/components/const/__init__.py` when
-  shared. The same constant defined in three or more component files fails CI.
-- State that must persist during code generation goes in `CORE.data` namespaced
-  under the component `DOMAIN` (a `@dataclass`), not module-level mutable globals.
-- Prefer callback-based triggers via `build_callback_automation()`; only use a
-  `Trigger<Ts...>` subclass when the forwarder needs mutable state.
-
-## Testing and coverage
-
-- New and changed lines and branches need test coverage, including defensive
-  early-returns, error paths, and no-op guards. A mocked-out function is not
-  covered; exercise the real call path too.
-- Component YAML tests live in `tests/components/<component>/`. Never define
-  buses (uart, i2c, spi, modbus) directly in a test file: pull them from
-  `tests/test_build_components/common/` through dict-style `packages:` so CI can
-  group builds. List-style packages or top-level merge keys block grouping.
-- Config-only checks use the `validate.*.yaml` prefix; compiled checks use
-  `test.*.yaml`.
-
-## Breaking changes and public API
-
-- Base classes under `esphome/core/` and documented config options are public
-  API. Undocumented `public` members of a component are internal.
-- A breaking change needs justification, a migration path in the PR description,
-  and a deprecation window where feasible (`ESPDEPRECATED` in C++,
-  `cv.rename_key(..., removed_in=...)` in Python). Changing a codegen-injected
-  lambda signature is not a breaking change.
-
-## Process and PR hygiene
-
-- PR titles start with a `[tag]` prefix: the component name (e.g. `[uart] ...`)
-  or `[core]` for shared code.
-- Prose in docs, comments, and commit messages should be plain English. Keep
-  inline comments short and only where the code is not self-explanatory; do not
-  restate what the code says.
-- Verify the PR fills out `.github/PULL_REQUEST_TEMPLATE.md` and adds
-  `CODEOWNERS` entries for a new component.

.claude/skills

@@ -1 +0,0 @@
-../.agents/skills

.github/actions/build-image/action.yaml

@@ -42,7 +42,7 @@ runs:
 
     - name: Build and push to ghcr by digest
       id: build-ghcr
-      uses: docker/build-push-action@c3c9e263c25d99ce0380d002d59b67737d91b0dc # v7.4.0
+      uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7.3.0
       env:
         DOCKER_BUILD_SUMMARY: false
         DOCKER_BUILD_RECORD_UPLOAD: false
@@ -67,7 +67,7 @@ runs:
 
     - name: Build and push to dockerhub by digest
       id: build-dockerhub
-      uses: docker/build-push-action@c3c9e263c25d99ce0380d002d59b67737d91b0dc # v7.4.0
+      uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7.3.0
       env:
         DOCKER_BUILD_SUMMARY: false
         DOCKER_BUILD_RECORD_UPLOAD: false

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

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

.github/skills

@@ -1 +0,0 @@
-../.agents/skills

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

@@ -29,7 +29,7 @@ jobs:
       - name: Set up uv
         # ``--system`` (below) installs into the setup-python interpreter;
         # no venv is created or restored by this workflow.
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
         with:
           enable-cache: true
           # Pull-request-only workflow: a save could never be shared and

.github/workflows/ci-docker.yml

@@ -67,7 +67,7 @@ jobs:
         with:
           python-version: "3.12"
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
+        uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e # v4.3.0
 
       - name: Determine tag and whether to push
         id: tag
@@ -159,7 +159,7 @@ jobs:
         with:
           python-version: "3.12"
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
+        uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e # v4.3.0
 
       - name: Log in to the GitHub container registry
         uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0

.github/workflows/ci.yml

@@ -49,7 +49,7 @@ jobs:
         # detects the activated venv via ``VIRTUAL_ENV`` so downstream jobs
         # that ``. venv/bin/activate`` see an identical layout.
         if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
         with:
           enable-cache: true
           # Pull request saves land in per-PR scopes nothing else can
@@ -321,7 +321,7 @@ jobs:
           . venv/bin/activate
           pytest -vv --cov-report=xml --tb=native --durations=30 -n auto tests --ignore=tests/integration/
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@303a32d7a59b442fa8d48b6a1cc6825c09c847a5 # v7.1.1
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
       - name: Save Python virtual environment cache
         if: github.ref == 'refs/heads/dev'
         uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
@@ -350,7 +350,7 @@ jobs:
       - name: Check out code from GitHub
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
       - name: Report empty upload to Codecov
-        uses: codecov/codecov-action@303a32d7a59b442fa8d48b6a1cc6825c09c847a5 # v7.1.1
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
         with:
           run_command: empty-upload
           force: true
@@ -413,7 +413,7 @@ jobs:
       - name: Set up uv
         # Only needed on cache miss to populate the venv.
         if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
         with:
           enable-cache: true
           # Pull request saves land in per-PR scopes nothing else can
@@ -1274,7 +1274,7 @@ jobs:
         # install step (order-of-magnitude faster on cold boots,
         # with its own wheel cache). actions/setup-python still
         # provides the interpreter.
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
         with:
           enable-cache: true
           # Pull request saves land in per-PR scopes nothing else can

.github/workflows/codeql.yml

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

.github/workflows/lock.yml

@@ -14,4 +14,4 @@ jobs:
     permissions:
       issues: write         # issues.lock on closed issues
       pull-requests: write  # issues.lock on closed pull requests
-    uses: esphome/workflows/.github/workflows/lock.yml@cc3e76de337dc59bc1cba8da58d963cd23b873f1  # 2026.9.0
+    uses: esphome/workflows/.github/workflows/lock.yml@0fdd5e311b7e744069166696072a1a9cbc5fbeb6  # 2026.8.1

.github/workflows/release.yml

@@ -123,7 +123,7 @@ jobs:
           python-version: "3.12"
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
+        uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e # v4.3.0
 
       - name: Log in to docker hub
         uses: docker/login-action@dbcb813823bdd20940b903addbd779551569679f # v4.6.0
@@ -202,7 +202,7 @@ jobs:
           merge-multiple: true
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@594f3bf4285d9ea8dc53c9a0c9c4092420091003 # v4.4.0
+        uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e # v4.3.0
 
       - name: Log in to docker hub
         if: matrix.registry == 'dockerhub'

.github/workflows/stale.yml

@@ -16,7 +16,7 @@ jobs:
     # No GITHUB_TOKEN permissions: the reusable workflow mints an ESPHome
     # GitHub App token so the labels, comments and closures come from
     # esphome[bot] instead of github-actions[bot].
-    uses: esphome/workflows/.github/workflows/stale.yml@cc3e76de337dc59bc1cba8da58d963cd23b873f1  # main
+    uses: esphome/workflows/.github/workflows/stale.yml@a1c1485ab46ef41a84a6a9d8abd7fa4b7628fd70  # main
     secrets:
       ESPHOME_GITHUB_APP_PRIVATE_KEY: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
     with:

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

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

.pre-commit-config.yaml

@@ -10,7 +10,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.16.8
+    rev: v0.16.6
     hooks:
       # Run the linter.
       - id: ruff

AGENTS.md

@@ -431,17 +431,7 @@ file does, and it is the authority when they disagree. The most useful starting
           MyComponent *parent_;
         };
         ```
-        Register it without writing a builder:
-        ```python
-        automation.register_simple_action(
-            "my_component.do_something", MyAction, schema, synchronous=True
-        )
-        ```
-        The constructor receives the object named by `config[CONF_ID]`. Use `register_bare_action` for a
-        no-argument constructor, `register_parented_action` for a class deriving from `Parented<T>`, and
-        the `@automation.register_action(...)` decorator only when the builder must also set fields.
-
-        Use `synchronous=True` for actions that run to completion inside `play()` without deferring. Use `synchronous=False` if the action may suspend/defer execution (e.g. `delay`, `wait_until`, `script.wait`) or store trigger arguments for later use.
+        Register with `@automation.register_action("my_component.do_something", MyAction, schema, synchronous=True)`. Use `synchronous=True` for actions that run to completion inside `play()` without deferring. Use `synchronous=False` if the action may suspend/defer execution (e.g. `delay`, `wait_until`, `script.wait`) or store trigger arguments for later use.
 
     *   **Conditions:**
         ```cpp
@@ -453,8 +443,7 @@ file does, and it is the authority when they disagree. The most useful starting
           MyComponent *parent_;
         };
         ```
-        Register with `automation.register_simple_condition("my_component.is_active", MyCondition, schema)`;
-        `register_bare_condition`, `register_parented_condition` and the decorator follow the action rules.
+        Register with `@automation.register_condition("my_component.is_active", MyCondition, schema)`.
 
 *   **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`.
 

CODEOWNERS

@@ -182,6 +182,7 @@ esphome/components/esp32_camera_web_server/* @ayufan
 esphome/components/esp32_can/* @Sympatron
 esphome/components/esp32_hosted/* @swoboda1337
 esphome/components/esp32_hosted/update/* @swoboda1337
+esphome/components/esp32_improv/* @jesserockz
 esphome/components/esp32_rmt/* @jesserockz
 esphome/components/esp32_rmt_led_strip/* @jesserockz
 esphome/components/esp8266/* @esphome/core
@@ -265,10 +266,8 @@ esphome/components/i2s_audio/* @jesserockz
 esphome/components/i2s_audio/microphone/* @jesserockz
 esphome/components/i2s_audio/speaker/* @jesserockz @kahrendt
 esphome/components/iaqcore/* @yozik04
-esphome/components/icnt86/* @danepowell
 esphome/components/ili9xxx/* @clydebarrow @nielsnl68
 esphome/components/improv_base/* @esphome/core
-esphome/components/improv_ble/* @jesserockz
 esphome/components/improv_serial/* @esphome/core
 esphome/components/ina226/* @latonita @Sergio303
 esphome/components/ina260/* @mreditor97
@@ -478,7 +477,6 @@ esphome/components/sendspin/image/* @kahrendt
 esphome/components/sendspin/media_player/* @kahrendt
 esphome/components/sendspin/media_source/* @kahrendt
 esphome/components/sendspin/sensor/* @kahrendt
-esphome/components/sendspin/switch/* @kahrendt
 esphome/components/sendspin/text_sensor/* @kahrendt
 esphome/components/sensirion_common/* @martgras
 esphome/components/sensor/* @esphome/core
@@ -591,7 +589,6 @@ esphome/components/uart/* @esphome/core
 esphome/components/uart/button/* @ssieb
 esphome/components/uart/event/* @eoasmxd
 esphome/components/uart/packet_transport/* @clydebarrow
-esphome/components/uart_mux/* @kbx81
 esphome/components/udp/* @clydebarrow
 esphome/components/ufire_ec/* @pvizeli
 esphome/components/ufire_ise/* @pvizeli

esphome/automation.py

@@ -102,101 +102,6 @@ def register_condition(name: str, condition_type: MockObjClass, schema: cv.Schem
     return CONDITION_REGISTRY.register(name, condition_type, schema)
 
 
-async def _build_with_parent(
-    config: ConfigType,
-    automation_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    parent = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(automation_id, template_arg, parent)
-
-
-async def _build_without_parent(
-    config: ConfigType,
-    automation_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    return cg.new_Pvariable(automation_id, template_arg)
-
-
-async def _build_parented(
-    config: ConfigType,
-    automation_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(automation_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    return var
-
-
-def register_simple_action(
-    name: str,
-    action_type: MockObjClass,
-    schema: cv.Schema,
-    *,
-    synchronous: bool,
-) -> None:
-    """Register an action whose constructor takes the object named by ``config[CONF_ID]``.
-
-    Use the ``register_action`` decorator instead when the builder must also set fields.
-    """
-    register_action(name, action_type, schema, synchronous=synchronous)(
-        _build_with_parent
-    )
-
-
-def register_simple_condition(
-    name: str, condition_type: MockObjClass, schema: cv.Schema
-) -> None:
-    """Condition counterpart of ``register_simple_action``."""
-    register_condition(name, condition_type, schema)(_build_with_parent)
-
-
-def register_bare_action(
-    name: str,
-    action_type: MockObjClass,
-    schema: cv.Schema,
-    *,
-    synchronous: bool,
-) -> None:
-    """Register an action whose constructor takes no arguments."""
-    register_action(name, action_type, schema, synchronous=synchronous)(
-        _build_without_parent
-    )
-
-
-def register_bare_condition(
-    name: str, condition_type: MockObjClass, schema: cv.Schema
-) -> None:
-    """Condition counterpart of ``register_bare_action``."""
-    register_condition(name, condition_type, schema)(_build_without_parent)
-
-
-def register_parented_action(
-    name: str,
-    action_type: MockObjClass,
-    schema: cv.Schema,
-    *,
-    synchronous: bool,
-) -> None:
-    """Register an action deriving from ``Parented<T>``.
-
-    The object is constructed without arguments and ``set_parent()`` receives the object
-    named by ``config[CONF_ID]``.
-    """
-    register_action(name, action_type, schema, synchronous=synchronous)(_build_parented)
-
-
-def register_parented_condition(
-    name: str, condition_type: MockObjClass, schema: cv.Schema
-) -> None:
-    """Condition counterpart of ``register_parented_action``."""
-    register_condition(name, condition_type, schema)(_build_parented)
-
-
 Action = cg.esphome_ns.class_("Action")
 Trigger = cg.esphome_ns.class_("Trigger")
 ACTION_REGISTRY = Registry()
@@ -629,20 +534,44 @@ async def lambda_action_to_code(
     return new_lambda_pvariable(action_id, lambda_, StatelessLambdaAction, template_arg)
 
 
-register_simple_action(
+@register_action(
     "component.update",
     UpdateComponentAction,
-    maybe_simple_id({cv.Required(CONF_ID): cv.use_id(cg.PollingComponent)}),
+    maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(cg.PollingComponent),
+        }
+    ),
     synchronous=True,
 )
+async def component_update_action_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    comp = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, comp)
 
 
-register_simple_action(
+@register_action(
     "component.suspend",
     SuspendComponentAction,
-    maybe_simple_id({cv.Required(CONF_ID): cv.use_id(cg.PollingComponent)}),
+    maybe_simple_id(
+        {
+            cv.Required(CONF_ID): cv.use_id(cg.PollingComponent),
+        }
+    ),
     synchronous=True,
 )
+async def component_suspend_action_to_code(
+    config: ConfigType,
+    action_id: ID,
+    template_arg: cg.TemplateArguments,
+    args: TemplateArgsType,
+) -> MockObj:
+    comp = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, comp)
 
 
 @register_action(

esphome/build_gen/espidf.py

@@ -90,10 +90,9 @@ def get_project_cmakelists(
     """
     idf_target = variant_to_idf_target(get_esp32_variant())
 
-    # esp_idf_size 2.x (IDF >=6.0) made NG the default and removed --ng;
-    # 1.x (IDF 5.5) needs --ng for --format=json2. 1.x json2 also lacks
-    # total_size, hence the ELF fallback in espidf/size_summary.py; both
-    # go away together when 1.x support is dropped.
+    # esp_idf_size 2.x (bundled with IDF >=6.0) made NG the default and
+    # removed the --ng flag; on 1.x (IDF 5.5) --ng is required to get
+    # --format=raw because the legacy mode doesn't support it.
     size_ng_flag = "--ng" if idf_version() < cv.Version(6, 0, 0) else ""
 
     # Project-wide compile options: -D defines and -W warning flags (skip
@@ -212,12 +211,10 @@ include($ENV{{IDF_PATH}}/tools/cmake/project.cmake)
 
 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.
+# Emit raw JSON size data for ESPHome to read post-build.
 add_custom_command(
     TARGET ${{CMAKE_PROJECT_NAME}}.elf POST_BUILD
-    COMMAND ${{PYTHON}} -m esp_idf_size {size_ng_flag} --format=json2
+    COMMAND ${{PYTHON}} -m esp_idf_size {size_ng_flag} --format=raw
             -o ${{CMAKE_BINARY_DIR}}/esp_idf_size.json
             ${{CMAKE_PROJECT_NAME}}.map
     WORKING_DIRECTORY ${{CMAKE_BINARY_DIR}}

esphome/component_aliases.py

@@ -6,6 +6,5 @@ See the component-alias section of esphome/loader.py.
 
 # alias -> (canonical component, removal version or None)
 COMPONENT_ALIASES: dict[str, tuple[str, str | None]] = {
-    "esp32_improv": ("improv_ble", "2027.4.0"),
     "rp2040": ("rp2", "2027.7.0"),
 }

esphome/components/adc/adc_sensor.h

@@ -94,7 +94,7 @@ class ADCSensor final : public sensor::Sensor, public PollingComponent, public v
   ///   - SamplingMode::MIN: Use the lowest sample value
   ///   - SamplingMode::MAX: Use the highest sample value
   /// @param sampling_mode The desired sampling mode to use for aggregating ADC samples.
-  void set_sampling_mode(SamplingMode sampling_mode) { this->sampling_mode_ = sampling_mode; }
+  void set_sampling_mode(SamplingMode sampling_mode);
 
   /// Perform a single ADC sampling operation and return the measured value.
   /// This function handles raw readings, calibration, and averaging as needed.

esphome/components/adc/adc_sensor_common.cpp

@@ -76,4 +76,6 @@ void ADCSensor::set_sample_count(uint8_t sample_count) {
   }
 }
 
+void ADCSensor::set_sampling_mode(SamplingMode sampling_mode) { this->sampling_mode_ = sampling_mode; }
+
 }  // namespace esphome::adc

esphome/components/alarm_control_panel/alarm_control_panel.h

@@ -138,11 +138,11 @@ class AlarmControlPanel : public EntityBase {
   // in order to store last panel state in flash
   ESPPreferenceObject pref_;
   // current state
-  AlarmControlPanelState current_state_{ACP_STATE_DISARMED};
+  AlarmControlPanelState current_state_;
   // the desired (or previous) state
-  AlarmControlPanelState desired_state_{ACP_STATE_DISARMED};
+  AlarmControlPanelState desired_state_;
   // last time the state was updated
-  uint32_t last_update_{0};
+  uint32_t last_update_;
   // the call control function
   virtual void control(const AlarmControlPanelCall &call) = 0;
   // state callback - passes the new state to listeners

esphome/components/api/__init__.py

@@ -136,12 +136,6 @@ CONF_LISTEN_BACKLOG = "listen_backlog"
 CONF_MAX_SEND_QUEUE = "max_send_queue"
 CONF_STATE_SUBSCRIPTION_ONLY = "state_subscription_only"
 
-# Schema defaults that also match the C++ initializers in api_server.h; codegen
-# skips the setter when the config equals them.
-DEFAULT_PORT = 6053
-DEFAULT_REBOOT_TIMEOUT = "15min"
-DEFAULT_BATCH_DELAY = "100ms"
-
 
 def _register_provisioning_source(config: ConfigType) -> ConfigType:
     """Register the API as a provisioning source when encryption is enabled.
@@ -298,7 +292,7 @@ CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(APIServer),
-            cv.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+            cv.Optional(CONF_PORT, default=6053): cv.port,
             # Removed in 2026.1.0 - kept to provide helpful error message
             cv.Optional(CONF_PASSWORD): cv.invalid(
                 "The 'password' option has been removed in ESPHome 2026.1.0.\n"
@@ -311,14 +305,14 @@ CONFIG_SCHEMA = cv.All(
                 "Or visit https://esphome.io/components/api/#configuration-variables"
             ),
             cv.Optional(
-                CONF_REBOOT_TIMEOUT, default=DEFAULT_REBOOT_TIMEOUT
+                CONF_REBOOT_TIMEOUT, default="15min"
             ): cv.positive_time_period_milliseconds,
             cv.Exclusive(
                 CONF_SERVICES, group_of_exclusion=CONF_ACTIONS
             ): ACTIONS_SCHEMA,
             cv.Exclusive(CONF_ACTIONS, group_of_exclusion=CONF_ACTIONS): ACTIONS_SCHEMA,
             cv.Optional(CONF_ENCRYPTION): encryption_schema,
-            cv.Optional(CONF_BATCH_DELAY, default=DEFAULT_BATCH_DELAY): cv.All(
+            cv.Optional(CONF_BATCH_DELAY, default="100ms"): cv.All(
                 cv.positive_time_period_milliseconds,
                 cv.Range(max=cv.TimePeriod(milliseconds=65535)),
             ),
@@ -468,15 +462,9 @@ async def to_code(config: ConfigType) -> None:
     # Request a log listener slot for API log streaming
     request_log_listener()
 
-    # Skip the setters when the config matches the C++ initializers (DEFAULT_*).
-    if (port := config[CONF_PORT]) != DEFAULT_PORT:
-        cg.add(var.set_port(port))
-    if (reboot_timeout := config[CONF_REBOOT_TIMEOUT]) != cv.time_period(
-        DEFAULT_REBOOT_TIMEOUT
-    ):
-        cg.add(var.set_reboot_timeout(reboot_timeout))
-    if (batch_delay := config[CONF_BATCH_DELAY]) != cv.time_period(DEFAULT_BATCH_DELAY):
-        cg.add(var.set_batch_delay(batch_delay))
+    cg.add(var.set_port(config[CONF_PORT]))
+    cg.add(var.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
+    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]))
     cg.add_define("MAX_API_CONNECTIONS", config[CONF_MAX_CONNECTIONS])

esphome/components/api/api_connection.cpp

@@ -720,7 +720,12 @@ uint16_t APIConnection::try_send_switch_info(EntityBase *entity, APIConnection *
 }
 void APIConnection::on_switch_command_request(const SwitchCommandRequest &msg) {
   ENTITY_COMMAND_GET(switch_::Switch, a_switch, switch)
-  a_switch->control(msg.state);
+
+  if (msg.state) {
+    a_switch->turn_on();
+  } else {
+    a_switch->turn_off();
+  }
 }
 #endif
 

esphome/components/api/api_server.cpp

@@ -29,29 +29,6 @@ static const char *const TAG = "api";
 // APIServer
 APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-#ifdef USE_API_NOISE
-static constexpr uint32_t NOISE_PSK_PREF_HASH = 88491486UL;
-#endif
-
-#if defined(USE_API_NOISE) && defined(USE_OTA_ENCRYPTION_PROVISIONED)
-bool load_saved_noise_psk(noise::psk_t &out) {
-  SavedNoisePsk saved;
-#ifdef USE_PREFERENCE_KEY_LOOKUP
-  const bool loaded =
-      global_preferences->load_from_key(NOISE_PSK_PREF_HASH, reinterpret_cast<uint8_t *>(&saved), sizeof(saved));
-#else
-  // Slot backends need the reservation walk; it only lands on the record when the reservations before
-  // it match a normal boot, otherwise the type checked checksum fails the load
-  const bool loaded = global_preferences->make_preference<SavedNoisePsk>(NOISE_PSK_PREF_HASH, true).load(&saved);
-#endif
-  // The all-zeros record means no key
-  if (!loaded || noise::NoiseContext::is_all_zeros(saved.psk))
-    return false;
-  out = saved.psk;
-  return true;
-}
-#endif
-
 APIServer::APIServer() { global_api_server = this; }
 
 void APIServer::socket_failed_(const LogString *msg) {
@@ -66,7 +43,8 @@ void APIServer::setup() {
 #ifdef USE_API_NOISE
   // Always reserve the slot: flash preferences are positional on esp8266, so
   // a yaml key build must keep the layout of a runtime key build
-  this->noise_pref_ = global_preferences->make_preference<SavedNoisePsk>(NOISE_PSK_PREF_HASH, true);
+  uint32_t hash = 88491486UL;
+  this->noise_pref_ = global_preferences->make_preference<SavedNoisePsk>(hash, true);
 #ifndef USE_API_NOISE_PSK_FROM_YAML
   // A cleared record loads fine but holds no key
   if (this->load_and_apply_noise_psk_() && this->noise_ctx_.has_psk()) {

esphome/components/api/api_server.h

@@ -43,11 +43,6 @@ struct SavedNoisePsk {
   noise::psk_t psk;
 } PACKED;  // NOLINT
 #endif
-#if defined(USE_API_NOISE) && defined(USE_OTA_ENCRYPTION_PROVISIONED)
-/// One-shot read of the provisioned key for a boot without an api server (safe mode); false when
-/// there is no key
-bool load_saved_noise_psk(noise::psk_t &out);
-#endif
 
 class APIServer final : public Component,
                         public Controller
@@ -319,7 +314,7 @@ class APIServer final : public Component,
 #endif
 
   // 4-byte aligned types
-  uint32_t reboot_timeout_{900000};  // Keep in sync with DEFAULT_REBOOT_TIMEOUT in __init__.py
+  uint32_t reboot_timeout_{300000};
   uint32_t last_connected_{0};
 
   // Slots [0, api_connection_count_) are populated; trailing slots are always nullptr.
@@ -356,8 +351,8 @@ class APIServer final : public Component,
 #endif
 
   // Group smaller types together
-  uint16_t port_{6053};        // Keep in sync with DEFAULT_PORT in __init__.py
-  uint16_t batch_delay_{100};  // Keep in sync with DEFAULT_BATCH_DELAY in __init__.py
+  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.
   uint8_t listen_backlog_{4};

esphome/components/at581x/__init__.py

@@ -181,11 +181,11 @@ async def at581x_settings_to_code(
     await cg.register_parented(var, config[CONF_ID])
 
     # Radar configuration
-    if (frontend_reset := config.get(CONF_HW_FRONTEND_RESET)) is not None:
+    if frontend_reset := config.get(CONF_HW_FRONTEND_RESET):
         template_ = await cg.templatable(frontend_reset, args, cg.int8)
         cg.add(var.set_hw_frontend_reset(template_))
 
-    if (freq := config.get(CONF_FREQUENCY)) is not None:
+    if freq := config.get(CONF_FREQUENCY):
         if not cg.is_template(freq):
             freq = int(freq / 1000000)
         template_ = await cg.templatable(freq, args, cg.int_)
@@ -195,19 +195,19 @@ async def at581x_settings_to_code(
         template_ = await cg.templatable(sens_dist, args, cg.int_)
         cg.add(var.set_sensing_distance(template_))
 
-    if (selfcheck := config.get(CONF_POWERON_SELFCHECK_TIME)) is not None:
+    if selfcheck := config.get(CONF_POWERON_SELFCHECK_TIME):
         template_ = await cg.templatable(selfcheck, args, cg.int_)
         cg.add(var.set_poweron_selfcheck_time(template_))
 
-    if (protect := config.get(CONF_PROTECT_TIME)) is not None:
+    if protect := config.get(CONF_PROTECT_TIME):
         template_ = await cg.templatable(protect, args, cg.int_)
         cg.add(var.set_protect_time(template_))
 
-    if (trig_base := config.get(CONF_TRIGGER_BASE)) is not None:
+    if trig_base := config.get(CONF_TRIGGER_BASE):
         template_ = await cg.templatable(trig_base, args, cg.int_)
         cg.add(var.set_trigger_base(template_))
 
-    if (trig_keep := config.get(CONF_TRIGGER_KEEP)) is not None:
+    if trig_keep := config.get(CONF_TRIGGER_KEEP):
         template_ = await cg.templatable(trig_keep, args, cg.int_)
         cg.add(var.set_trigger_keep(template_))
 
@@ -215,7 +215,7 @@ async def at581x_settings_to_code(
         template_ = await cg.templatable(stage_gain, args, cg.int_)
         cg.add(var.set_stage_gain(template_))
 
-    if (power := config.get(CONF_POWER_CONSUMPTION)) is not None:
+    if power := config.get(CONF_POWER_CONSUMPTION):
         if not cg.is_template(power):
             power = int(power * 1000000)
         template_ = await cg.templatable(power, args, cg.int_)

esphome/components/audio/__init__.py

@@ -339,7 +339,7 @@ async def to_code(config: ConfigType) -> None:
     # HTTPS streams verify the server against the root certificate bundle
     require_certificate_bundle()
 
-    add_idf_component(name="esphome/esp-audio-libs", ref="4.0.1")
+    add_idf_component(name="esphome/esp-audio-libs", ref="4.0.0")
 
     data = _get_data()
 

esphome/components/bang_bang/bang_bang_climate.cpp

@@ -203,10 +203,16 @@ void BangBangClimate::set_away_config(const BangBangClimateTargetTempConfig &awa
   this->away_config_ = away_config;
 }
 
+void BangBangClimate::set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
+void BangBangClimate::set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
+
 Trigger<> *BangBangClimate::get_idle_trigger() { return &this->idle_trigger_; }
 Trigger<> *BangBangClimate::get_cool_trigger() { return &this->cool_trigger_; }
 Trigger<> *BangBangClimate::get_heat_trigger() { return &this->heat_trigger_; }
 
+void BangBangClimate::set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }
+void BangBangClimate::set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }
+
 void BangBangClimate::dump_config() {
   LOG_CLIMATE("", "Bang Bang Climate", this);
   ESP_LOGCONFIG(TAG,

esphome/components/bang_bang/bang_bang_climate.h

@@ -22,10 +22,10 @@ class BangBangClimate final : public climate::Climate, public Component {
   void setup() override;
   void dump_config() override;
 
-  void set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
-  void set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
-  void set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }
-  void set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }
+  void set_sensor(sensor::Sensor *sensor);
+  void set_humidity_sensor(sensor::Sensor *humidity_sensor);
+  void set_supports_cool(bool supports_cool);
+  void set_supports_heat(bool supports_heat);
   void set_normal_config(const BangBangClimateTargetTempConfig &normal_config);
   void set_away_config(const BangBangClimateTargetTempConfig &away_config);
 

esphome/components/binary/light/binary_light_output.h

@@ -17,7 +17,11 @@ class BinaryLightOutput final : public light::LightOutput {
   void write_state(light::LightState *state) override {
     bool binary;
     state->current_values_as_binary(&binary);
-    this->output_->set_state(binary);
+    if (binary) {
+      this->output_->turn_on();
+    } else {
+      this->output_->turn_off();
+    }
   }
 
  protected:

esphome/components/binary_sensor/__init__.py

@@ -39,7 +39,6 @@ from esphome.const import (
     DEVICE_CLASS_EMPTY,
     DEVICE_CLASS_GARAGE_DOOR,
     DEVICE_CLASS_GAS,
-    DEVICE_CLASS_GLASS_BREAK,
     DEVICE_CLASS_HEAT,
     DEVICE_CLASS_LIGHT,
     DEVICE_CLASS_LOCK,
@@ -82,7 +81,6 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_EMPTY,
     DEVICE_CLASS_GARAGE_DOOR,
     DEVICE_CLASS_GAS,
-    DEVICE_CLASS_GLASS_BREAK,
     DEVICE_CLASS_HEAT,
     DEVICE_CLASS_LIGHT,
     DEVICE_CLASS_LOCK,

esphome/components/binary_sensor/binary_sensor.h

@@ -32,8 +32,7 @@ void log_binary_sensor(const char *tag, const char *prefix, const char *type, Bi
  */
 class BinarySensor : public StatefulEntityBase<bool> {
  public:
-  // User provided, not "= default": `new(p) BinarySensor()` would zero-fill .bss that is already zero.
-  explicit BinarySensor() {}
+  explicit BinarySensor() = default;
 
   const bool &get_state() const override { return this->state; }
   void set_trigger_on_initial_state(bool value) { this->trigger_on_initial_state_ = value; }

esphome/components/binary_sensor/filter.h

@@ -53,9 +53,6 @@ class DelayedOnOffFilter final : public Filter {
 
 class DelayedOnFilter : public Filter {
  public:
-  // User provided, not "= default": `new(p) DelayedOnFilter()` would zero-fill .bss that is already zero.
-  DelayedOnFilter() {}
-
   optional<bool> new_value(bool value) override;
 
   template<typename T> void set_delay(T delay) { this->delay_ = delay; }
@@ -66,9 +63,6 @@ class DelayedOnFilter : public Filter {
 
 class DelayedOffFilter : public Filter {
  public:
-  // User provided, not "= default": `new(p) DelayedOffFilter()` would zero-fill .bss that is already zero.
-  DelayedOffFilter() {}
-
   optional<bool> new_value(bool value) override;
 
   template<typename T> void set_delay(T delay) { this->delay_ = delay; }
@@ -149,8 +143,6 @@ class StatelessLambdaFilter : public Filter {
 
 class SettleFilter : public Filter {
  public:
-  // User provided, not "= default": `new(p) SettleFilter()` would zero-fill .bss that is already zero.
-  SettleFilter() {}
   optional<bool> new_value(bool value) override;
 
   template<typename T> void set_delay(T delay) { this->delay_ = delay; }

esphome/components/bk72xx_ble/__init__.py

@@ -23,7 +23,7 @@ public ble_api.h.
 import logging
 
 import esphome.codegen as cg
-from esphome.components import libretiny, wifi
+from esphome.components import libretiny
 from esphome.components.libretiny.const import (
     FAMILY_BK7231N,
     FAMILY_BK7231Q,
@@ -84,15 +84,6 @@ def _final_validate(config: ConfigType) -> None:
     # which run on a BLE 4.2 board. The hard error is raised at codegen.
     if msg := _unsupported_family_message(libretiny.get_libretiny_family()):
         _LOGGER.warning("%s (this configuration cannot compile)", msg)
-    # Any wifi power_save_mode other than NONE also arms the Beken SDK's MCU
-    # sleep. With the BLE controller running, that sleep never wakes up once the
-    # station is stopped (adapter restart after failed roams, wifi.disable): the
-    # device is dead until a power cycle (esphome#18592). Keep power save off
-    # until LibreTiny ships the SDK-side fix (libretiny-eu/libretiny#414).
-    wifi.force_power_save_off(
-        "with BLE running, the Beken SDK's MCU sleep halts the device once the "
-        "station is stopped (https://github.com/esphome/esphome/issues/18592)"
-    )
 
 
 FINAL_VALIDATE_SCHEMA = _final_validate

esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.h

@@ -31,9 +31,6 @@ class BluetoothConnection;
 // void disconnect() cannot overload with an int-returning twin.
 class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public Component {
  public:
-  // User provided, not "= default": `new(p) BluedroidGattClient()` would zero-fill .bss that is already zero.
-  BluedroidGattClient() {}
-
   static constexpr uint16_t UNSET_CONN_ID = 0xFFFF;
 
   // Lifecycle of one connection attempt's service search.

esphome/components/bluetooth_connection/bluetooth_connection_hub.h

@@ -37,9 +37,6 @@ enum class PendingAck : uint8_t {
 
 class BluetoothConnection final : public ble_device_base::GattClientListener {
  public:
-  // User provided, not "= default": `new(p) BluetoothConnection()` would zero-fill .bss that is already zero.
-  BluetoothConnection() {}
-
   /// Wire the platform backend. Called from codegen before setup.
   void set_backend(ble_device_base::BLEGattConnection *backend) {
     this->backend_ = backend;

esphome/components/bluetooth_connection/bluetooth_connection_rp2.cpp

@@ -626,7 +626,7 @@ void RP2GattClient::handle_connected_(uint8_t status, uint16_t con_handle) {
   // explicit kick the MTU would only be exchanged on the first GATT query,
   // which never happens on a V3_WITH_CACHE connection.
   // Both registration calls above return void (BTstack 075a078, arduino-pico
-  // 6.1.0); failures surface as a missing GATT_EVENT_MTU and are reclaimed by
+  // 6.0.0); failures surface as a missing GATT_EVENT_MTU and are reclaimed by
   // the connect timeout in loop().
   gatt_client_send_mtu_negotiation(&RP2GattClient::gatt_packet_handler, this->con_handle_);
 }

esphome/components/bme280_base/bme280_base.cpp

@@ -341,6 +341,7 @@ void BME280Component::set_pressure_oversampling(BME280Oversampling pressure_over
 void BME280Component::set_humidity_oversampling(BME280Oversampling humidity_over_sampling) {
   this->humidity_oversampling_ = humidity_over_sampling;
 }
+void BME280Component::set_iir_filter(BME280IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
 uint8_t BME280Component::read_u8_(uint8_t a_register) {
   uint8_t data = 0;
   this->read_byte(a_register, &data);

esphome/components/bme280_base/bme280_base.h

@@ -69,7 +69,7 @@ class BME280Component : public PollingComponent {
   /// Set the oversampling value for the humidity sensor. Default is 16x.
   void set_humidity_oversampling(BME280Oversampling humidity_over_sampling);
   /// Set the IIR Filter used to increase accuracy, defaults to no IIR Filter.
-  void set_iir_filter(BME280IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
+  void set_iir_filter(BME280IIRFilter iir_filter);
 
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)

esphome/components/bme680/bme680.cpp

@@ -503,6 +503,7 @@ void BME680Component::set_pressure_oversampling(BME680Oversampling pressure_over
 void BME680Component::set_humidity_oversampling(BME680Oversampling humidity_oversampling) {
   this->humidity_oversampling_ = humidity_oversampling;
 }
+void BME680Component::set_iir_filter(BME680IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
 void BME680Component::set_heater(uint16_t heater_temperature, uint16_t heater_duration) {
   this->heater_temperature_ = heater_temperature;
   this->heater_duration_ = heater_duration;

esphome/components/bme680/bme680.h

@@ -74,7 +74,7 @@ class BME680Component final : public PollingComponent, public i2c::I2CDevice {
   /// Set the humidity oversampling value. Defaults to 16X.
   void set_humidity_oversampling(BME680Oversampling humidity_oversampling);
   /// Set the IIR Filter value. Defaults to no IIR Filter.
-  void set_iir_filter(BME680IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
+  void set_iir_filter(BME680IIRFilter iir_filter);
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
   void set_pressure_sensor(sensor::Sensor *pressure_sensor) { pressure_sensor_ = pressure_sensor; }

esphome/components/bmp280_base/bmp280_base.cpp

@@ -254,6 +254,7 @@ void BMP280Component::set_temperature_oversampling(BMP280Oversampling temperatur
 void BMP280Component::set_pressure_oversampling(BMP280Oversampling pressure_over_sampling) {
   this->pressure_oversampling_ = pressure_over_sampling;
 }
+void BMP280Component::set_iir_filter(BMP280IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
 uint8_t BMP280Component::read_u8_(uint8_t a_register) {
   uint8_t data = 0;
   this->bmp_read_byte(a_register, &data);

esphome/components/bmp280_base/bmp280_base.h

@@ -59,7 +59,7 @@ class BMP280Component : public PollingComponent {
   /// Set the oversampling value for the pressure sensor. Default is 16x.
   void set_pressure_oversampling(BMP280Oversampling pressure_over_sampling);
   /// Set the IIR Filter used to increase accuracy, defaults to no IIR Filter.
-  void set_iir_filter(BMP280IIRFilter iir_filter) { this->iir_filter_ = iir_filter; }
+  void set_iir_filter(BMP280IIRFilter iir_filter);
 
   void setup() override;
   void dump_config() override;

esphome/components/cdc_acm_uart/bridge/cdc_acm_uart_bridge.h

@@ -30,7 +30,6 @@ class CDCACMUARTBridge final : public Component {
 
   void set_line_coding();
   void set_line_state(bool dtr, bool rts);
-  uart::IDFUARTComponent *get_uart_parent() const { return this->uart_parent_; }
 
   /**
    * Stop forwarding in both directions and hand the UART back to its configured

esphome/components/copy/switch/copy_switch.cpp

@@ -13,6 +13,12 @@ void CopySwitch::setup() {
 
 void CopySwitch::dump_config() { LOG_SWITCH("", "Copy Switch", this); }
 
-void CopySwitch::write_state(bool state) { this->source_->control(state); }
+void CopySwitch::write_state(bool state) {
+  if (state) {
+    source_->turn_on();
+  } else {
+    source_->turn_off();
+  }
+}
 
 }  // namespace esphome::copy

esphome/components/display/display.cpp

@@ -3,7 +3,6 @@
 #include <utility>
 #include <numbers>
 #include "display_color_utils.h"
-#include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 
@@ -771,12 +770,10 @@ Rect Display::get_clipping() const {
 
 void Display::clear_clipping_() { this->clipping_rectangle_.clear(); }
 
-void Display::feed_wdt_pixel_slow_() { App.feed_wdt(); }
-
 bool Display::clip(int x, int y) {
   if (x < 0 || x >= this->get_width() || y < 0 || y >= this->get_height())
     return false;
-  if (this->is_point_clipped(x, y))
+  if (!this->get_clipping().inside(x, y))
     return false;
   return true;
 }

esphome/components/display/display.h

@@ -758,13 +758,6 @@ class Display : public PollingComponent {
 
   bool is_clipping() const { return !this->clipping_rectangle_.empty(); }
 
-  /// Whether (x, y) falls outside the active clipping rectangle. Tests the
-  /// stack top in place: get_clipping() is out of line and returns the Rect
-  /// by value, which per pixel drawing cannot afford.
-  bool ESPHOME_ALWAYS_INLINE is_point_clipped(int x, int y) const {
-    return this->is_clipping() && !this->clipping_rectangle_.back().inside(x, y);
-  }
-
   /** Check if pixel is within region of display.
    */
   bool clip(int x, int y);
@@ -781,17 +774,6 @@ class Display : public PollingComponent {
   void do_update_();
   void clear_clipping_();
 
-  /// Watchdog feed for per pixel loops. App.feed_wdt() is already rate
-  /// limited, but every call reads the clock; only every 256th pixel makes
-  /// that call, so the real feeds are unchanged and a pixel costs a counter.
-  /// At 20 us per pixel on the slowest e-paper path that is about 5 ms
-  /// between clock reads.
-  void ESPHOME_ALWAYS_INLINE feed_wdt_per_pixel_() {
-    if (++this->wdt_pixel_counter_ == 0)
-      this->feed_wdt_pixel_slow_();
-  }
-  void feed_wdt_pixel_slow_();
-
   virtual int get_height_internal() = 0;
   virtual int get_width_internal() = 0;
 
@@ -811,7 +793,6 @@ class Display : public PollingComponent {
   std::vector<DisplayOnPageChangeTrigger *> on_page_change_triggers_;
   bool auto_clear_enabled_{true};
   std::vector<Rect> clipping_rectangle_;
-  uint8_t wdt_pixel_counter_{0};
   bool show_test_card_{false};
 };
 

esphome/components/display/display_buffer.cpp

@@ -2,6 +2,7 @@
 
 #include <utility>
 
+#include "esphome/core/application.h"
 #include "esphome/core/log.h"
 
 namespace esphome::display {
@@ -43,7 +44,7 @@ int DisplayBuffer::get_height() {
 }
 
 void HOT DisplayBuffer::draw_pixel_at(int x, int y, Color color) {
-  if (this->is_point_clipped(x, y))
+  if (!this->get_clipping().inside(x, y))
     return;  // NOLINT
 
   switch (this->rotation_) {
@@ -63,7 +64,7 @@ void HOT DisplayBuffer::draw_pixel_at(int x, int y, Color color) {
       break;
   }
   this->draw_absolute_pixel_internal(x, y, color);
-  this->feed_wdt_per_pixel_();
+  App.feed_wdt();
 }
 
 }  // namespace esphome::display

esphome/components/display/rect.cpp

@@ -63,6 +63,16 @@ bool Rect::equal(Rect rect) const {
   return (rect.x == this->x) && (rect.w == this->w) && (rect.y == this->y) && (rect.h == this->h);
 }
 
+bool Rect::inside(int16_t test_x, int16_t test_y, bool absolute) const {  // NOLINT
+  if (!this->is_set()) {
+    return true;
+  }
+  if (absolute) {
+    return test_x >= this->x && test_x < this->x2() && test_y >= this->y && test_y < this->y2();
+  }
+  return test_x >= 0 && test_x < this->w && test_y >= 0 && test_y < this->h;
+}
+
 bool Rect::inside(Rect rect) const {
   if (!this->is_set() || !rect.is_set()) {
     return true;

esphome/components/display/rect.h

@@ -26,15 +26,7 @@ class Rect {
   void shrink(Rect rect);
 
   bool inside(Rect rect) const;
-  bool ESPHOME_ALWAYS_INLINE inside(int16_t test_x, int16_t test_y, bool absolute = true) const {
-    if (!this->is_set()) {
-      return true;
-    }
-    if (absolute) {
-      return test_x >= this->x && test_x < this->x2() && test_y >= this->y && test_y < this->y2();
-    }
-    return test_x >= 0 && test_x < this->w && test_y >= 0 && test_y < this->h;
-  }
+  bool inside(int16_t test_x, int16_t test_y, bool absolute = true) const;
   bool equal(Rect rect) const;
   void info(const std::string &prefix = "rect info:");
 };

esphome/components/epaper_spi/epaper_spi.cpp

@@ -299,7 +299,7 @@ bool EPaperBase::initialise(bool partial) {
  * @return false if the coordinates are out of bounds
  */
 bool EPaperBase::rotate_coordinates_(int &x, int &y) {
-  if (this->is_point_clipped(x, y))
+  if (!this->get_clipping().inside(x, y))
     return false;
   if (this->effective_transform_ & SWAP_XY)
     std::swap(x, y);

esphome/components/esp32/__init__.py

@@ -111,7 +111,6 @@ CONF_ENGINEERING_SAMPLE = "engineering_sample"
 CONF_INCLUDE_BUILTIN_IDF_COMPONENTS = "include_builtin_idf_components"
 CONF_ENABLE_LWIP_ASSERT = "enable_lwip_assert"
 CONF_EXECUTE_FROM_PSRAM = "execute_from_psram"
-CONF_FLASH_CHIP = "flash_chip"
 CONF_KEY_ID = "key_id"
 CONF_MINIMUM_CHIP_REVISION = "minimum_chip_revision"
 CONF_NVS_ENCRYPTION = "nvs_encryption"
@@ -262,7 +261,7 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = (
     "esp_lcd",  # LCD controller drivers - only needed by display component
     "esp_local_ctrl",  # Local control over HTTPS/BLE - ESPHome has native API
     "esp_phy",  # RF PHY - re-included by internal_temperature on the original ESP32; esp_wifi/bt/ieee802154 pull it back
-    "esp_wifi",  # WiFi stack - re-included by request_wifi(), espnow, esp32_hosted; bt pulls it back for BLE builds
+    "esp_wifi",  # WiFi stack - re-included by request_wifi(), espnow; bt pulls it back for BLE builds
     "espcoredump",  # Core dump support - ESPHome has its own debug component
     "fatfs",  # FAT filesystem - ESPHome doesn't use filesystem storage
     "ieee802154",  # 802.15.4 radio - IDF openthread and the Zigbee libs pull it back
@@ -465,20 +464,6 @@ ESP32_CHIP_REVISIONS = {
     "3.1": "CONFIG_ESP32_REV_MIN_3_1",
 }
 
-# Flash vendor drivers ESP-IDF can link; each costs IRAM plus a 124 B table in DRAM
-# and only the one matching the flash ID is ever used
-ESP32_FLASH_CHIPS = {
-    "gd": "CONFIG_SPI_FLASH_SUPPORT_GD_CHIP",
-    "issi": "CONFIG_SPI_FLASH_SUPPORT_ISSI_CHIP",
-    "mxic": "CONFIG_SPI_FLASH_SUPPORT_MXIC_CHIP",
-    "winbond": "CONFIG_SPI_FLASH_SUPPORT_WINBOND_CHIP",
-    "boya": "CONFIG_SPI_FLASH_SUPPORT_BOYA_CHIP",
-    "th": "CONFIG_SPI_FLASH_SUPPORT_TH_CHIP",
-    "mxic_opi": "CONFIG_SPI_FLASH_SUPPORT_MXIC_OPI_CHIP",
-}
-FLASH_CHIP_GENERIC = "generic"
-FLASH_CHIP_OPI = "mxic_opi"  # the octal driver, ESP32-S3 only
-
 # Socket limit configuration for ESP-IDF
 # ESP-IDF CONFIG_LWIP_MAX_SOCKETS has range 1-253, default 10
 DEFAULT_MAX_SOCKETS = 10  # ESP-IDF default
@@ -1534,13 +1519,6 @@ def final_validate(config) -> None:
                 path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_MINIMUM_CHIP_REVISION],
             )
         )
-    if config[CONF_VARIANT] != VARIANT_ESP32S3 and config.get(CONF_FLASH_MODE) == "opi":
-        errs.append(
-            cv.Invalid(
-                f"'{CONF_FLASH_MODE}: opi' is only supported on {VARIANT_ESP32S3}",
-                path=[CONF_FLASH_MODE],
-            )
-        )
     if config[CONF_VARIANT] != VARIANT_ESP32 and advanced[CONF_SRAM1_AS_IRAM]:
         errs.append(
             cv.Invalid(
@@ -1548,25 +1526,6 @@ def final_validate(config) -> None:
                 path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_SRAM1_AS_IRAM],
             )
         )
-    if (flash_chip := advanced.get(CONF_FLASH_CHIP)) is not None:
-        opi = flash_chip == FLASH_CHIP_OPI
-        if opi and config[CONF_VARIANT] != VARIANT_ESP32S3:
-            errs.append(
-                cv.Invalid(
-                    f"'{CONF_FLASH_CHIP}: {flash_chip}' is only supported on {VARIANT_ESP32S3}",
-                    path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_FLASH_CHIP],
-                )
-            )
-        elif opi != (config.get(CONF_FLASH_MODE) == "opi"):
-            errs.append(
-                cv.Invalid(
-                    f"'{CONF_FLASH_CHIP}: {flash_chip}' requires '{CONF_FLASH_MODE}: opi'"
-                    if opi
-                    else f"'{CONF_FLASH_CHIP}: {flash_chip}' does not match "
-                    f"'{CONF_FLASH_MODE}: opi'; octal flash uses {FLASH_CHIP_OPI}",
-                    path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_FLASH_CHIP],
-                )
-            )
     if (
         config[CONF_VARIANT] != VARIANT_ESP32P4
         and config.get(CONF_ENGINEERING_SAMPLE) is not None
@@ -2005,9 +1964,6 @@ FRAMEWORK_SCHEMA = cv.Schema(
                     *ESP32_CHIP_REVISIONS, string=True
                 ),
                 cv.Optional(CONF_SRAM1_AS_IRAM, default=False): cv.boolean,
-                cv.Optional(CONF_FLASH_CHIP): cv.one_of(
-                    FLASH_CHIP_GENERIC, *ESP32_FLASH_CHIPS, lower=True
-                ),
                 # DHCP server is needed for WiFi AP mode. When WiFi component is used,
                 # it will handle disabling DHCP server when AP is not configured.
                 # Default to false (disabled) when WiFi is not used.
@@ -2653,13 +2609,6 @@ async def to_code(config):
     # NVS finds stored preferences by key, so preference key migration is possible
     cg.add_define("USE_PREFERENCE_KEY_LOOKUP")
     cg.add_build_flag("-Wl,-z,noexecstack")
-    # assert(), HAL_ASSERT and ESP_ERROR_CHECK bake __FILE__ into rodata, and
-    # IDF's noflash placement puts the flash driver's copies in DRAM. The
-    # basename keeps the panic output useful at a fraction of the size.
-    # __FILE_NAME__ is a GCC 12 builtin; IDF 5.0 still ships GCC 11.2.
-    if idf_version() >= cv.Version(5, 1, 0):
-        cg.add_build_flag("-D__FILE__=__FILE_NAME__")
-        cg.add_build_flag("-Wno-builtin-macro-redefined")
     # Deferred so KEY_COMPONENTS is fully populated -- see the coroutine.
     CORE.add_job(_finalize_arduino_aware_flags)
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
@@ -2776,8 +2725,6 @@ async def to_code(config):
         add_idf_sdkconfig_option(
             f"CONFIG_ESPTOOLPY_FLASHMODE_{flash_mode.upper()}", True
         )
-        # the opi mode choice only exists once octal flash is enabled
-        add_idf_sdkconfig_option("CONFIG_ESPTOOLPY_OCT_FLASH", flash_mode == "opi")
     if flash_frequency := config.get(CONF_FLASH_FREQUENCY):
         add_idf_sdkconfig_option(
             f"CONFIG_ESPTOOLPY_FLASHFREQ_{flash_frequency[:-3]}M", True
@@ -2792,11 +2739,6 @@ async def to_code(config):
             config.get(CONF_ENGINEERING_SAMPLE, False),
         )
 
-    # ESP32-C2 defaults to the ROM's newlib "nano" printf, which does not
-    # understand %zu or %lld and crashes on any %s that follows one.
-    if variant == VARIANT_ESP32C2:
-        add_idf_sdkconfig_option("CONFIG_LIBC_NEWLIB_NANO_FORMAT", False)
-
     # Set minimum chip revision for ESP32 variant
     # Setting this to 3.0 or higher reduces flash size by excluding workaround code,
     # and for PSRAM users saves significant IRAM by keeping C library functions in ROM.
@@ -2807,11 +2749,6 @@ async def to_code(config):
                 add_idf_sdkconfig_option(flag, rev == min_rev)
             cg.add_define("USE_ESP32_MIN_CHIP_REVISION_SET")
 
-    # Keep only the flash vendor driver the board needs; the boot log names it
-    if (flash_chip := conf[CONF_ADVANCED].get(CONF_FLASH_CHIP)) is not None:
-        for chip, flag in ESP32_FLASH_CHIPS.items():
-            add_idf_sdkconfig_option(flag, chip == flash_chip)
-
     # Use SRAM1 region as IRAM on ESP32 (original) variant
     # This provides an additional 40KB of IRAM by using SRAM1 memory that was previously
     # reserved for bootloader DRAM. Requires a bootloader from ESP-IDF v5.1 or later.

esphome/components/esp32/crash_handler.cpp

@@ -173,10 +173,7 @@ static const char *const TAG = "esp32.crash";
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static uint32_t s_current_build_time = static_cast<uint32_t>(ESPHOME_BUILD_TIME);
 
-// Validate the NOINIT record. Runs on every has_data() call; re-running is
-// harmless and the magic is left alone so the record survives an OTA
-// rollback reboot, crash_handler_clear() drops it once an API client has it.
-static void read_crash_data() {
+void crash_handler_read_and_clear() {
   if (s_raw_crash_data.magic == CRASH_MAGIC && s_raw_crash_data.version == CRASH_DATA_VERSION) {
     s_crash_data_valid = true;
     // Clamp counts to prevent out-of-bounds reads from corrupt .noinit data
@@ -197,12 +194,11 @@ static void read_crash_data() {
       s_raw_crash_data.other_reg_frame_count = s_raw_crash_data.other_backtrace_count;
 #endif
   }
+  // Don't clear magic here — crash data must survive OTA rollback reboots.
+  // Magic is cleared by crash_handler_clear() after an API client receives the data.
 }
 
-bool crash_handler_has_data() {
-  read_crash_data();
-  return s_crash_data_valid;
-}
+bool crash_handler_has_data() { return s_crash_data_valid; }
 
 void crash_handler_clear() {
   // Only clear the magic so data doesn't survive the next reboot.
@@ -430,7 +426,7 @@ static void log_foreign_addresses() {
 // crashes again during boot, and allowing the CLI's process_stacktrace to match
 // and decode each address individually.
 void crash_handler_log() {
-  if (!crash_handler_has_data())
+  if (!s_crash_data_valid)
     return;
 
   ESP_LOGE(TAG, "*** CRASH DETECTED ON PREVIOUS BOOT ***");

esphome/components/esp32/crash_handler.h

@@ -4,6 +4,11 @@
 
 namespace esphome::esp32 {
 
+/// Read and validate crash data from NOINIT memory.
+/// Does not clear the magic marker — call crash_handler_clear() after
+/// the data has been delivered to an API client so it survives OTA rollback reboots.
+void crash_handler_read_and_clear();
+
 /// Log crash data if a crash was detected on previous boot.
 void crash_handler_log();
 
@@ -11,7 +16,7 @@ void crash_handler_log();
 /// Call after the data has been delivered to an API client.
 void crash_handler_clear();
 
-/// Returns true if crash data was found this boot, reading it first if needed.
+/// Returns true if crash data was found this boot.
 bool crash_handler_has_data();
 
 }  // namespace esphome::esp32

esphome/components/esp32/hal.cpp

@@ -1,6 +1,9 @@
 #ifdef USE_ESP32
 
+// defines.h must come before crash_handler.h so USE_ESP32_CRASH_HANDLER is set
+// before crash_handler.h's #ifdef-guarded namespace block is parsed.
 #include "esphome/core/defines.h"
+#include "crash_handler.h"
 #include "esphome/core/hal.h"
 
 #include <esp_clk_tree.h>
@@ -42,6 +45,11 @@ void arch_restart() {
 }
 
 void arch_init() {
+#ifdef USE_ESP32_CRASH_HANDLER
+  // Read crash data from previous boot before anything else
+  esp32::crash_handler_read_and_clear();
+#endif
+
   // Enable the task watchdog only on the loop task (from which we're currently running)
   esp_task_wdt_add(nullptr);
 

esphome/components/esp32_ble_server/__init__.py

@@ -597,7 +597,7 @@ async def to_code(config):
     cg.add(parent.advertising_set_appearance(config[CONF_APPEARANCE]))
     cg.add(var.set_max_clients(config[CONF_MAX_CLIENTS]))
     # Only advertise for the server itself when the configuration gives clients something to
-    # find. A server that is auto-loaded purely to host a runtime service (improv_ble) stays
+    # find. A server that is auto-loaded purely to host a runtime service (esp32_improv) stays
     # silent until that service asks for advertising.
     cg.add(
         var.set_advertising_required(

esphome/components/esp32_ble_server/ble_server.h

@@ -40,7 +40,7 @@ class BLEServer final : public Component, public Parented<ESP32BLE> {
 
   /** Whether this server needs the device to advertise so clients can find and connect to it.
    *
-   * False for a server that only hosts services created at runtime (e.g. improv_ble), which
+   * False for a server that only hosts services created at runtime (e.g. esp32_improv), which
    * request advertising themselves for as long as they need it.
    */
   void set_advertising_required(bool required) { this->advertising_required_ = required; }

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -135,7 +135,7 @@ class ESPBTClient : public ESPBTDeviceListener {
   void set_tracker_state_version(uint8_t *version) { this->tracker_state_version_ = version; }
 
   // Memory optimized layout
-  uint8_t app_id{0};  // App IDs are small integers assigned sequentially
+  uint8_t app_id;  // App IDs are small integers assigned sequentially
 
  protected:
   /// Set state without IDLE handling - use for direct state transitions.

esphome/components/esp32_camera/esp32_camera.cpp

@@ -433,10 +433,25 @@ void ESP32Camera::set_pixel_format(ESP32CameraPixelFormat format) {
   }
 }
 void ESP32Camera::set_jpeg_quality(uint8_t quality) { this->config_.jpeg_quality = quality; }
+void ESP32Camera::set_vertical_flip(bool vertical_flip) { this->vertical_flip_ = vertical_flip; }
+void ESP32Camera::set_horizontal_mirror(bool horizontal_mirror) { this->horizontal_mirror_ = horizontal_mirror; }
+void ESP32Camera::set_contrast(int contrast) { this->contrast_ = contrast; }
+void ESP32Camera::set_brightness(int brightness) { this->brightness_ = brightness; }
+void ESP32Camera::set_saturation(int saturation) { this->saturation_ = saturation; }
+void ESP32Camera::set_special_effect(ESP32SpecialEffect effect) { this->special_effect_ = effect; }
 /* set exposure parameters */
+void ESP32Camera::set_aec_mode(ESP32GainControlMode mode) { this->aec_mode_ = mode; }
+void ESP32Camera::set_aec2(bool aec2) { this->aec2_ = aec2; }
+void ESP32Camera::set_ae_level(int ae_level) { this->ae_level_ = ae_level; }
+void ESP32Camera::set_aec_value(uint32_t aec_value) { this->aec_value_ = aec_value; }
 /* set gains parameters */
+void ESP32Camera::set_agc_mode(ESP32GainControlMode mode) { this->agc_mode_ = mode; }
+void ESP32Camera::set_agc_value(uint8_t agc_value) { this->agc_value_ = agc_value; }
+void ESP32Camera::set_agc_gain_ceiling(ESP32AgcGainCeiling gain_ceiling) { this->agc_gain_ceiling_ = gain_ceiling; }
 /* set white balance */
+void ESP32Camera::set_wb_mode(ESP32WhiteBalanceMode mode) { this->wb_mode_ = mode; }
 /* set test mode */
+void ESP32Camera::set_test_pattern(bool test_pattern) { this->test_pattern_ = test_pattern; }
 /* set fps */
 void ESP32Camera::set_max_update_interval(uint32_t max_update_interval) {
   this->max_update_interval_ = max_update_interval;

esphome/components/esp32_camera/esp32_camera.h

@@ -140,25 +140,25 @@ class ESP32Camera final : public camera::Camera {
   void set_pixel_format(ESP32CameraPixelFormat format);
   void set_frame_size(ESP32CameraFrameSize size);
   void set_jpeg_quality(uint8_t quality);
-  void set_vertical_flip(bool vertical_flip) { this->vertical_flip_ = vertical_flip; }
-  void set_horizontal_mirror(bool horizontal_mirror) { this->horizontal_mirror_ = horizontal_mirror; }
-  void set_contrast(int contrast) { this->contrast_ = contrast; }
-  void set_brightness(int brightness) { this->brightness_ = brightness; }
-  void set_saturation(int saturation) { this->saturation_ = saturation; }
-  void set_special_effect(ESP32SpecialEffect effect) { this->special_effect_ = effect; }
+  void set_vertical_flip(bool vertical_flip);
+  void set_horizontal_mirror(bool horizontal_mirror);
+  void set_contrast(int contrast);
+  void set_brightness(int brightness);
+  void set_saturation(int saturation);
+  void set_special_effect(ESP32SpecialEffect effect);
   /* -- exposure */
-  void set_aec_mode(ESP32GainControlMode mode) { this->aec_mode_ = mode; }
-  void set_aec2(bool aec2) { this->aec2_ = aec2; }
-  void set_ae_level(int ae_level) { this->ae_level_ = ae_level; }
-  void set_aec_value(uint32_t aec_value) { this->aec_value_ = aec_value; }
+  void set_aec_mode(ESP32GainControlMode mode);
+  void set_aec2(bool aec2);
+  void set_ae_level(int ae_level);
+  void set_aec_value(uint32_t aec_value);
   /* -- gains */
-  void set_agc_mode(ESP32GainControlMode mode) { this->agc_mode_ = mode; }
-  void set_agc_value(uint8_t agc_value) { this->agc_value_ = agc_value; }
-  void set_agc_gain_ceiling(ESP32AgcGainCeiling gain_ceiling) { this->agc_gain_ceiling_ = gain_ceiling; }
+  void set_agc_mode(ESP32GainControlMode mode);
+  void set_agc_value(uint8_t agc_value);
+  void set_agc_gain_ceiling(ESP32AgcGainCeiling gain_ceiling);
   /* -- white balance */
-  void set_wb_mode(ESP32WhiteBalanceMode mode) { this->wb_mode_ = mode; }
+  void set_wb_mode(ESP32WhiteBalanceMode mode);
   /* -- test */
-  void set_test_pattern(bool test_pattern) { this->test_pattern_ = test_pattern; }
+  void set_test_pattern(bool test_pattern);
   /* -- framerates */
   void set_max_update_interval(uint32_t max_update_interval);
   void set_idle_update_interval(uint32_t idle_update_interval);

esphome/components/esp32_hosted/__init__.py

@@ -290,8 +290,6 @@ async def to_code(config: ConfigType) -> None:
     # symbols are simply unused and never register a callback at runtime.
     if esp32.get_esp32_variant() == esp32.VARIANT_ESP32P4:
         add_define("USE_ESP_NOW_HOSTED")
-        # esp_now_hosted.cpp includes esp_now.h, which esp_wifi provides
-        esp32.include_builtin_idf_component("esp_wifi")
         # esp-hosted's CustomRpc ("peer data transfer") path — off by default.
         esp32.add_idf_sdkconfig_option(
             "CONFIG_ESP_HOSTED_ENABLE_PEER_DATA_TRANSFER", True

esphome/components/esp32_hosted/update/esp32_hosted_update.cpp

@@ -169,7 +169,7 @@ void Esp32HostedUpdate::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "  Mode: HTTP\n"
                 "  Source URL: %s",
-                this->source_url_);
+                this->source_url_.c_str());
 #else
   ESP_LOGCONFIG(TAG,
                 "  Mode: Embedded\n"
@@ -215,7 +215,7 @@ bool Esp32HostedUpdate::fetch_manifest_() {
 
   auto container = this->http_request_parent_->get(this->source_url_);
   if (container == nullptr || container->status_code != 200) {
-    ESP_LOGE(TAG, "Failed to fetch manifest from %s", this->source_url_);
+    ESP_LOGE(TAG, "Failed to fetch manifest from %s", this->source_url_.c_str());
     this->status_set_error(LOG_STR("Failed to fetch manifest"));
     return false;
   }

esphome/components/esp32_hosted/update/esp32_hosted_update.h

@@ -25,7 +25,7 @@ class Esp32HostedUpdate final : public update::UpdateEntity, public PollingCompo
 
 #ifdef USE_ESP32_HOSTED_HTTP_UPDATE
   // HTTP mode setters
-  void set_source_url(const char *url) { this->source_url_ = url; }
+  void set_source_url(const std::string &url) { this->source_url_ = url; }
   void set_http_request_parent(http_request::HttpRequestComponent *parent) { this->http_request_parent_ = parent; }
 #else
   // Embedded mode setters
@@ -38,7 +38,7 @@ class Esp32HostedUpdate final : public update::UpdateEntity, public PollingCompo
 #ifdef USE_ESP32_HOSTED_HTTP_UPDATE
   // HTTP mode members
   http_request::HttpRequestComponent *http_request_parent_{nullptr};
-  const char *source_url_{nullptr};  // literal from codegen
+  std::string source_url_;
   std::string firmware_url_;
 
   // HTTP mode helpers

esphome/components/esp32_improv/__init__.py

@@ -1,41 +1,14 @@
 from esphome import automation
 import esphome.codegen as cg
-from esphome.components import binary_sensor, improv_base, output
+from esphome.components import binary_sensor, esp32_ble, improv_base, output
+from esphome.components.esp32_ble import BTLoggers
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ID,
-    CONF_ON_START,
-    CONF_ON_STATE,
-    CONF_TRIGGER_ID,
-    PLATFORM_ESP32,
-)
-from esphome.core import CORE
+from esphome.const import CONF_ID, CONF_ON_START, CONF_ON_STATE, CONF_TRIGGER_ID
 from esphome.types import ConfigType
 
-# The BLE GATT server component that hosts the Improv service, per target
-# platform. improv_ble itself is platform neutral; supporting another chip
-# means adding its BLE server component here and the matching backend in
-# improv_ble_component.cpp. Doubles as the platform gate below, so an
-# unsupported chip is rejected in validation rather than at link time.
-BLE_SERVER_BACKENDS: dict[str, str] = {
-    PLATFORM_ESP32: "esp32_ble_server",
-}
-
-
-def AUTO_LOAD() -> list[str]:
-    auto_load = ["improv_base"]
-    if backend := BLE_SERVER_BACKENDS.get(CORE.target_platform):
-        auto_load.append(backend)
-    return auto_load
-
-
+AUTO_LOAD = ["esp32_ble_server", "improv_base"]
 CODEOWNERS = ["@jesserockz"]
-DEPENDENCIES = ["wifi"]
-
-# Legacy top-level YAML key that routes here; esphome/loader.py and
-# esphome/config.py handle the warning and the key rename.
-ALIASES = ["esp32_improv"]
-ALIAS_REMOVAL_VERSION = "2027.4.0"
+DEPENDENCIES = ["wifi", "esp32"]
 
 CONF_AUTHORIZED_DURATION = "authorized_duration"
 CONF_AUTHORIZER = "authorizer"
@@ -56,29 +29,29 @@ improv_ns = cg.esphome_ns.namespace("improv")
 Error = improv_ns.enum("Error")
 State = improv_ns.enum("State")
 
-improv_ble_ns = cg.esphome_ns.namespace("improv_ble")
-ImprovBLEComponent = improv_ble_ns.class_("ImprovBLEComponent", cg.Component)
-ImprovBLEProvisionedTrigger = improv_ble_ns.class_(
-    "ImprovBLEProvisionedTrigger", automation.Trigger.template()
+esp32_improv_ns = cg.esphome_ns.namespace("esp32_improv")
+ESP32ImprovComponent = esp32_improv_ns.class_("ESP32ImprovComponent", cg.Component)
+ESP32ImprovProvisionedTrigger = esp32_improv_ns.class_(
+    "ESP32ImprovProvisionedTrigger", automation.Trigger.template()
 )
-ImprovBLEProvisioningTrigger = improv_ble_ns.class_(
-    "ImprovBLEProvisioningTrigger", automation.Trigger.template()
+ESP32ImprovProvisioningTrigger = esp32_improv_ns.class_(
+    "ESP32ImprovProvisioningTrigger", automation.Trigger.template()
 )
-ImprovBLEStartTrigger = improv_ble_ns.class_(
-    "ImprovBLEStartTrigger", automation.Trigger.template()
+ESP32ImprovStartTrigger = esp32_improv_ns.class_(
+    "ESP32ImprovStartTrigger", automation.Trigger.template()
 )
-ImprovBLEStateTrigger = improv_ble_ns.class_(
-    "ImprovBLEStateTrigger", automation.Trigger.template()
+ESP32ImprovStateTrigger = esp32_improv_ns.class_(
+    "ESP32ImprovStateTrigger", automation.Trigger.template()
 )
-ImprovBLEStoppedTrigger = improv_ble_ns.class_(
-    "ImprovBLEStoppedTrigger", automation.Trigger.template()
+ESP32ImprovStoppedTrigger = esp32_improv_ns.class_(
+    "ESP32ImprovStoppedTrigger", automation.Trigger.template()
 )
 
 
-CONFIG_SCHEMA = cv.All(
+CONFIG_SCHEMA = (
     cv.Schema(
         {
-            cv.GenerateID(): cv.declare_id(ImprovBLEComponent),
+            cv.GenerateID(): cv.declare_id(ESP32ImprovComponent),
             cv.Required(CONF_AUTHORIZER): cv.Any(
                 cv.none, cv.use_id(binary_sensor.BinarySensor)
             ),
@@ -95,60 +68,55 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_ON_PROVISIONED): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        ImprovBLEProvisionedTrigger
+                        ESP32ImprovProvisionedTrigger
                     ),
                 }
             ),
             cv.Optional(CONF_ON_PROVISIONING): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        ImprovBLEProvisioningTrigger
+                        ESP32ImprovProvisioningTrigger
                     ),
                 }
             ),
             cv.Optional(CONF_ON_START): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        ImprovBLEStartTrigger
+                        ESP32ImprovStartTrigger
                     ),
                 }
             ),
             cv.Optional(CONF_ON_STATE): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        ImprovBLEStateTrigger
+                        ESP32ImprovStateTrigger
                     ),
                 }
             ),
             cv.Optional(CONF_ON_STOP): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        ImprovBLEStoppedTrigger
+                        ESP32ImprovStoppedTrigger
                     ),
                 }
             ),
         }
     )
     .extend(improv_base.IMPROV_SCHEMA)
-    .extend(cv.COMPONENT_SCHEMA),
-    cv.only_on(list(BLE_SERVER_BACKENDS)),
+    .extend(cv.COMPONENT_SCHEMA)
 )
 
 
 async def to_code(config: ConfigType) -> None:
-    # ESP32 backend setup: the platform gate above means this is the only backend
-    # that can reach to_code. Make it conditional when a second one is added.
-    from esphome.components import esp32_ble
-
     # Register the loggers this component needs
-    esp32_ble.register_bt_logger(esp32_ble.BTLoggers.GATT, esp32_ble.BTLoggers.SMP)
+    esp32_ble.register_bt_logger(BTLoggers.GATT, BTLoggers.SMP)
 
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
-    cg.add_define("USE_IMPROV_BLE")
+    cg.add_define("USE_IMPROV")
 
-    await improv_base.setup_improv_core(var, config)
+    await improv_base.setup_improv_core(var, config, "esp32_improv")
 
     cg.add(var.set_identify_duration(config[CONF_IDENTIFY_DURATION]))
     cg.add(var.set_authorized_duration(config[CONF_AUTHORIZED_DURATION]))
@@ -187,4 +155,4 @@ async def to_code(config: ConfigType) -> None:
         await automation.build_automation(trigger, [], conf)
         use_state_callback = True
     if use_state_callback:
-        cg.add_define("USE_IMPROV_BLE_STATE_CALLBACK")
+        cg.add_define("USE_ESP32_IMPROV_STATE_CALLBACK")

esphome/components/esp32_improv/automation.h

@@ -1,17 +1,17 @@
 #pragma once
 #ifdef USE_ESP32
-#ifdef USE_IMPROV_BLE_STATE_CALLBACK
-#include "improv_ble_component.h"
+#ifdef USE_ESP32_IMPROV_STATE_CALLBACK
+#include "esp32_improv_component.h"
 
 #include "esphome/core/automation.h"
 
 #include <improv.h>
 
-namespace esphome::improv_ble {
+namespace esphome::esp32_improv {
 
-class ImprovBLEProvisionedTrigger final : public Trigger<> {
+class ESP32ImprovProvisionedTrigger final : public Trigger<> {
  public:
-  explicit ImprovBLEProvisionedTrigger(ImprovBLEComponent *parent) : parent_(parent) {
+  explicit ESP32ImprovProvisionedTrigger(ESP32ImprovComponent *parent) : parent_(parent) {
     parent->add_on_state_callback([this](improv::State state, improv::Error error) {
       if (state == improv::STATE_PROVISIONED && !this->parent_->is_failed()) {
         this->trigger();
@@ -20,12 +20,12 @@ class ImprovBLEProvisionedTrigger final : public Trigger<> {
   }
 
  protected:
-  ImprovBLEComponent *parent_;
+  ESP32ImprovComponent *parent_;
 };
 
-class ImprovBLEProvisioningTrigger final : public Trigger<> {
+class ESP32ImprovProvisioningTrigger final : public Trigger<> {
  public:
-  explicit ImprovBLEProvisioningTrigger(ImprovBLEComponent *parent) : parent_(parent) {
+  explicit ESP32ImprovProvisioningTrigger(ESP32ImprovComponent *parent) : parent_(parent) {
     parent->add_on_state_callback([this](improv::State state, improv::Error error) {
       if (state == improv::STATE_PROVISIONING && !this->parent_->is_failed()) {
         this->trigger();
@@ -34,12 +34,12 @@ class ImprovBLEProvisioningTrigger final : public Trigger<> {
   }
 
  protected:
-  ImprovBLEComponent *parent_;
+  ESP32ImprovComponent *parent_;
 };
 
-class ImprovBLEStartTrigger final : public Trigger<> {
+class ESP32ImprovStartTrigger final : public Trigger<> {
  public:
-  explicit ImprovBLEStartTrigger(ImprovBLEComponent *parent) : parent_(parent) {
+  explicit ESP32ImprovStartTrigger(ESP32ImprovComponent *parent) : parent_(parent) {
     parent->add_on_state_callback([this](improv::State state, improv::Error error) {
       if ((state == improv::STATE_AUTHORIZED || state == improv::STATE_AWAITING_AUTHORIZATION) &&
           !this->parent_->is_failed()) {
@@ -49,12 +49,12 @@ class ImprovBLEStartTrigger final : public Trigger<> {
   }
 
  protected:
-  ImprovBLEComponent *parent_;
+  ESP32ImprovComponent *parent_;
 };
 
-class ImprovBLEStateTrigger final : public Trigger<improv::State, improv::Error> {
+class ESP32ImprovStateTrigger final : public Trigger<improv::State, improv::Error> {
  public:
-  explicit ImprovBLEStateTrigger(ImprovBLEComponent *parent) : parent_(parent) {
+  explicit ESP32ImprovStateTrigger(ESP32ImprovComponent *parent) : parent_(parent) {
     parent->add_on_state_callback([this](improv::State state, improv::Error error) {
       if (!this->parent_->is_failed()) {
         this->trigger(state, error);
@@ -63,12 +63,12 @@ class ImprovBLEStateTrigger final : public Trigger<improv::State, improv::Error>
   }
 
  protected:
-  ImprovBLEComponent *parent_;
+  ESP32ImprovComponent *parent_;
 };
 
-class ImprovBLEStoppedTrigger final : public Trigger<> {
+class ESP32ImprovStoppedTrigger final : public Trigger<> {
  public:
-  explicit ImprovBLEStoppedTrigger(ImprovBLEComponent *parent) : parent_(parent) {
+  explicit ESP32ImprovStoppedTrigger(ESP32ImprovComponent *parent) : parent_(parent) {
     parent->add_on_state_callback([this](improv::State state, improv::Error error) {
       if (state == improv::STATE_STOPPED && !this->parent_->is_failed()) {
         this->trigger();
@@ -77,10 +77,10 @@ class ImprovBLEStoppedTrigger final : public Trigger<> {
   }
 
  protected:
-  ImprovBLEComponent *parent_;
+  ESP32ImprovComponent *parent_;
 };
 
-}  // namespace esphome::improv_ble
+}  // namespace esphome::esp32_improv
 
 #endif
 #endif

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -1,7 +1,10 @@
-#include "improv_ble_component.h"
+#include "esp32_improv_component.h"
 
 #include <array>
 
+#include "esphome/components/bytebuffer/bytebuffer.h"
+#include "esphome/components/esp32_ble/ble.h"
+#include "esphome/components/esp32_ble_server/ble_2902.h"
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
@@ -12,15 +15,11 @@
 
 #ifdef USE_ESP32
 
-#include "esphome/components/bytebuffer/bytebuffer.h"
-#include "esphome/components/esp32_ble/ble.h"
-#include "esphome/components/esp32_ble_server/ble_2902.h"
-
-namespace esphome::improv_ble {
+namespace esphome::esp32_improv {
 
 using namespace bytebuffer;
 
-static const char *const TAG = "improv_ble.component";
+static const char *const TAG = "esp32_improv.component";
 static constexpr size_t IMPROV_MAX_LOG_BYTES = 128;
 static constexpr char ESPHOME_MY_LINK[] = "https://my.home-assistant.io/redirect/config_flow_start?domain=esphome";
 // command + data length + trailing byte
@@ -39,9 +38,9 @@ static constexpr uint8_t IMPROV_SERVICE_DATA_SIZE = 8;
 static constexpr uint8_t IMPROV_PROTOCOL_ID_1 = 0x77;  // 'P' << 1 | 'R' >> 7
 static constexpr uint8_t IMPROV_PROTOCOL_ID_2 = 0x46;  // 'I' << 1 | 'M' >> 7
 
-ImprovBLEComponent::ImprovBLEComponent() { global_improv_component = this; }
+ESP32ImprovComponent::ESP32ImprovComponent() { global_improv_component = this; }
 
-void ImprovBLEComponent::setup() {
+void ESP32ImprovComponent::setup() {
 #ifdef USE_BINARY_SENSOR
   if (this->authorizer_ != nullptr) {
     this->authorizer_->add_on_state_callback([this](bool state) {
@@ -67,7 +66,7 @@ void ImprovBLEComponent::setup() {
   this->disable_loop();
 }
 
-void ImprovBLEComponent::setup_characteristics() {
+void ESP32ImprovComponent::setup_characteristics() {
   this->status_ = this->service_->create_characteristic(
       improv::STATUS_UUID, BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
   BLEDescriptor *status_descriptor = new BLE2902();
@@ -105,11 +104,11 @@ void ImprovBLEComponent::setup_characteristics() {
   this->setup_complete_ = true;
 }
 
-void ImprovBLEComponent::loop() {
+void ESP32ImprovComponent::loop() {
   if (!global_ble_server->is_running()) {
     if (this->state_ != improv::STATE_STOPPED) {
       this->state_ = improv::STATE_STOPPED;
-#ifdef USE_IMPROV_BLE_STATE_CALLBACK
+#ifdef USE_ESP32_IMPROV_STATE_CALLBACK
       this->state_callback_.call(this->state_, this->error_state_);
 #endif
     }
@@ -201,19 +200,23 @@ void ImprovBLEComponent::loop() {
   }
 }
 
-void ImprovBLEComponent::set_status_indicator_state_(bool state) {
+void ESP32ImprovComponent::set_status_indicator_state_(bool state) {
 #ifdef USE_OUTPUT
   if (this->status_indicator_ == nullptr)
     return;
   if (this->status_indicator_state_ == state)
     return;
   this->status_indicator_state_ = state;
-  this->status_indicator_->set_state(state);
+  if (state) {
+    this->status_indicator_->turn_on();
+  } else {
+    this->status_indicator_->turn_off();
+  }
 #endif
 }
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG
-const char *ImprovBLEComponent::state_to_string_(improv::State state) {
+const char *ESP32ImprovComponent::state_to_string_(improv::State state) {
   switch (state) {
     case improv::STATE_STOPPED:
       return "STOPPED";
@@ -231,7 +234,7 @@ const char *ImprovBLEComponent::state_to_string_(improv::State state) {
 }
 #endif
 
-bool ImprovBLEComponent::check_identify_() {
+bool ESP32ImprovComponent::check_identify_() {
   uint32_t now = millis();
 
   bool identify = this->identify_start_ != 0 && now - this->identify_start_ <= this->identify_duration_;
@@ -243,7 +246,7 @@ bool ImprovBLEComponent::check_identify_() {
   return identify;
 }
 
-void ImprovBLEComponent::set_state_(improv::State state, bool update_advertising) {
+void ESP32ImprovComponent::set_state_(improv::State state, bool update_advertising) {
   // Skip if state hasn't changed
   if (this->state_ == state) {
     return;
@@ -271,12 +274,12 @@ void ImprovBLEComponent::set_state_(improv::State state, bool update_advertising
     // Advertise the new state via service data
     this->advertise_service_data_();
   }
-#ifdef USE_IMPROV_BLE_STATE_CALLBACK
+#ifdef USE_ESP32_IMPROV_STATE_CALLBACK
   this->state_callback_.call(this->state_, this->error_state_);
 #endif
 }
 
-void ImprovBLEComponent::set_error_(improv::Error error) {
+void ESP32ImprovComponent::set_error_(improv::Error error) {
   if (error != improv::ERROR_NONE) {
     ESP_LOGE(TAG, "Error: %d", error);
   }
@@ -292,14 +295,14 @@ void ImprovBLEComponent::set_error_(improv::Error error) {
   }
 }
 
-void ImprovBLEComponent::send_response_(std::span<const uint8_t> response) {
+void ESP32ImprovComponent::send_response_(std::span<const uint8_t> response) {
   // The BLE characteristic owns its value, so one exact-size copy is required here
   this->rpc_response_->set_value(std::vector<uint8_t>(response.begin(), response.end()));
   if (this->state_ != improv::STATE_STOPPED)
     this->rpc_response_->notify();
 }
 
-void ImprovBLEComponent::start() {
+void ESP32ImprovComponent::start() {
   if (this->should_start_ || this->state_ != improv::STATE_STOPPED)
     return;
 
@@ -317,7 +320,7 @@ void ImprovBLEComponent::start() {
   this->enable_loop();
 }
 
-void ImprovBLEComponent::stop() {
+void ESP32ImprovComponent::stop() {
   this->should_start_ = false;
   // Wait before stopping the service to ensure all BLE clients see the state change.
   // This prevents clients from repeatedly reconnecting and wasting resources by allowing
@@ -332,10 +335,10 @@ void ImprovBLEComponent::stop() {
   });
 }
 
-float ImprovBLEComponent::get_setup_priority() const { return setup_priority::AFTER_BLUETOOTH; }
+float ESP32ImprovComponent::get_setup_priority() const { return setup_priority::AFTER_BLUETOOTH; }
 
-void ImprovBLEComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "Improv BLE:");
+void ESP32ImprovComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "ESP32 Improv:");
 #ifdef USE_BINARY_SENSOR
   LOG_BINARY_SENSOR("  ", "Authorizer", this->authorizer_);
 #endif
@@ -344,7 +347,7 @@ void ImprovBLEComponent::dump_config() {
 #endif
 }
 
-void ImprovBLEComponent::process_incoming_data_() {
+void ESP32ImprovComponent::process_incoming_data_() {
   if (this->incoming_data_.size() < 3)
     return;
   uint8_t length = this->incoming_data_[1];
@@ -419,7 +422,7 @@ void ImprovBLEComponent::process_incoming_data_() {
   }
 }
 
-void ImprovBLEComponent::on_wifi_connect_timeout_() {
+void ESP32ImprovComponent::on_wifi_connect_timeout_() {
   this->set_error_(improv::ERROR_UNABLE_TO_CONNECT);
   this->set_state_(improv::STATE_AUTHORIZED);
 #ifdef USE_BINARY_SENSOR
@@ -430,7 +433,7 @@ void ImprovBLEComponent::on_wifi_connect_timeout_() {
   wifi::global_wifi_component->clear_sta();
 }
 
-void ImprovBLEComponent::check_wifi_connection_() {
+void ESP32ImprovComponent::check_wifi_connection_() {
   if (!wifi::global_wifi_component->is_connected()) {
     return;
   }
@@ -444,7 +447,7 @@ void ImprovBLEComponent::check_wifi_connection_() {
     std::array<uint8_t, improv::RPC_RESPONSE_MAX_SIZE> buf;
     improv::RpcResponseBuilder builder(buf, improv::WIFI_SETTINGS);
 
-#ifdef USE_IMPROV_NEXT_URL
+#ifdef USE_ESP32_IMPROV_NEXT_URL
     // Add next_url if configured (should be first per Improv BLE spec)
     this->add_next_url_(builder, MAX_NEXT_URL_LEN);
 #endif
@@ -477,7 +480,7 @@ void ImprovBLEComponent::check_wifi_connection_() {
   this->stop();
 }
 
-void ImprovBLEComponent::advertise_service_data_() {
+void ESP32ImprovComponent::advertise_service_data_() {
   uint8_t service_data[IMPROV_SERVICE_DATA_SIZE] = {};
   service_data[0] = IMPROV_PROTOCOL_ID_1;  // PR
   service_data[1] = IMPROV_PROTOCOL_ID_2;  // IM
@@ -496,7 +499,7 @@ void ImprovBLEComponent::advertise_service_data_() {
   esp32_ble::global_ble->advertising_set_service_data_and_name(std::span<const uint8_t>(service_data), false);
 }
 
-void ImprovBLEComponent::update_advertising_type_() {
+void ESP32ImprovComponent::update_advertising_type_() {
   uint32_t now = App.get_loop_component_start_time();
 
   // If we're advertising the device name and it's been more than NAME_ADVERTISING_DURATION, switch back to service data
@@ -521,21 +524,21 @@ void ImprovBLEComponent::update_advertising_type_() {
   }
 }
 
-void ImprovBLEComponent::request_advertising_() {
+void ESP32ImprovComponent::request_advertising_() {
   if (this->advertising_requested_)
     return;
   this->advertising_requested_ = true;
   esp32_ble::global_ble->advertising_start();
 }
 
-void ImprovBLEComponent::release_advertising_() {
+void ESP32ImprovComponent::release_advertising_() {
   if (!this->advertising_requested_)
     return;
   this->advertising_requested_ = false;
   esp32_ble::global_ble->advertising_stop();
 }
 
-improv::State ImprovBLEComponent::get_initial_state_() const {
+improv::State ESP32ImprovComponent::get_initial_state_() const {
 #ifdef USE_BINARY_SENSOR
   // If we have an authorizer, start in awaiting authorization state
   return this->authorizer_ == nullptr ? improv::STATE_AUTHORIZED : improv::STATE_AWAITING_AUTHORIZATION;
@@ -545,8 +548,8 @@ improv::State ImprovBLEComponent::get_initial_state_() const {
 #endif
 }
 
-ImprovBLEComponent *global_improv_component = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+ESP32ImprovComponent *global_improv_component = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
-}  // namespace esphome::improv_ble
+}  // namespace esphome::esp32_improv
 
 #endif

esphome/components/esp32_improv/esp32_improv_component.h

@@ -5,10 +5,12 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
 
+#include "esphome/components/esp32_ble_server/ble_characteristic.h"
+#include "esphome/components/esp32_ble_server/ble_server.h"
 #include "esphome/components/improv_base/improv_base.h"
 #include "esphome/components/wifi/wifi_component.h"
 
-#ifdef USE_IMPROV_BLE_STATE_CALLBACK
+#ifdef USE_ESP32_IMPROV_STATE_CALLBACK
 #include "esphome/core/automation.h"
 #endif
 
@@ -23,23 +25,17 @@
 #include <span>
 #include <vector>
 
-// ESP-IDF is currently the only target platform with a BLE GATT server, so it is
-// the only backend this component has. The Python side keeps the platform table
-// (BLE_SERVER_BACKENDS in __init__.py); a second backend adds another arm here.
 #ifdef USE_ESP32
 
-#include "esphome/components/esp32_ble_server/ble_characteristic.h"
-#include "esphome/components/esp32_ble_server/ble_server.h"
-
 #include <improv.h>
 
-namespace esphome::improv_ble {
+namespace esphome::esp32_improv {
 
 using namespace esp32_ble_server;
 
-class ImprovBLEComponent final : public Component, public improv_base::ImprovBase {
+class ESP32ImprovComponent final : public Component, public improv_base::ImprovBase {
  public:
-  ImprovBLEComponent();
+  ESP32ImprovComponent();
   void dump_config() override;
   void loop() override;
   void setup() override;
@@ -51,7 +47,7 @@ class ImprovBLEComponent final : public Component, public improv_base::ImprovBas
   bool is_active() const { return this->state_ != improv::STATE_STOPPED; }
   bool should_start() const { return this->should_start_; }
 
-#ifdef USE_IMPROV_BLE_STATE_CALLBACK
+#ifdef USE_ESP32_IMPROV_STATE_CALLBACK
   template<typename F> void add_on_state_callback(F &&callback) {
     this->state_callback_.add(std::forward<F>(callback));
   }
@@ -101,7 +97,7 @@ class ImprovBLEComponent final : public Component, public improv_base::ImprovBas
 
   improv::State state_{improv::STATE_STOPPED};
   improv::Error error_state_{improv::ERROR_NONE};
-#ifdef USE_IMPROV_BLE_STATE_CALLBACK
+#ifdef USE_ESP32_IMPROV_STATE_CALLBACK
   CallbackManager<void(improv::State, improv::Error)> state_callback_{};
 #endif
 
@@ -129,8 +125,8 @@ class ImprovBLEComponent final : public Component, public improv_base::ImprovBas
 };
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-extern ImprovBLEComponent *global_improv_component;
+extern ESP32ImprovComponent *global_improv_component;
 
-}  // namespace esphome::improv_ble
+}  // namespace esphome::esp32_improv
 
 #endif

esphome/components/esp8266/__init__.py

@@ -363,6 +363,14 @@ async def to_code(config: ConfigType) -> None:
     if config.get(CONF_ENABLE_SERIAL1):
         enable_serial1()
 
+    # Arduino 2 has a non-standards conformant new that returns a nullptr instead of failing when
+    # out of memory and exceptions are disabled. Since Arduino 2.6.0, this flag can be used to make
+    # new abort instead. Use it so that OOM fails early (on allocation) instead of on dereference of
+    # a NULL pointer (so the stacktrace makes more sense), and for consistency with Arduino 3,
+    # which always aborts if exceptions are disabled.
+    # For cases where nullptrs can be handled, use nothrow: `new (std::nothrow) T;`
+    cg.add_build_flag("-DNEW_OOM_ABORT")
+
     # Force-include inline std::__throw_* overrides so GCC dead-strips the unused
     # libstdc++ error message strings (e.g. "basic_string::_M_create") from DRAM.
     # See throw_stubs.h for details. Must be prepended before <string>, so this

esphome/components/esp8266_pwm/esp8266_pwm.h

@@ -11,9 +11,6 @@ namespace esphome::esp8266_pwm {
 
 class ESP8266PWM final : public output::FloatOutput, public Component {
  public:
-  // User provided, not "= default": `new(p) ESP8266PWM()` would zero-fill .bss that is already zero.
-  ESP8266PWM() {}
-
   void set_pin(InternalGPIOPin *pin) { pin_ = pin; }
   void set_frequency(float frequency) { this->frequency_ = frequency; }
   /// Dynamically update frequency
@@ -31,7 +28,7 @@ class ESP8266PWM final : public output::FloatOutput, public Component {
  protected:
   void write_state(float state) override;
 
-  InternalGPIOPin *pin_{nullptr};
+  InternalGPIOPin *pin_;
   float frequency_{1000.0};  // Keep in sync with DEFAULT_FREQUENCY in output.py
   /// Cache last output level for dynamic frequency updating
   float last_output_{0.0};

esphome/components/esphome/ota/__init__.py

@@ -166,17 +166,9 @@ def ota_esphome_final_validate(config: ConfigType) -> None:
                 CONF_PASSWORD,
             )
     # web_server and prometheus keep the shared listener up; the captive
-    # portal's copy only exists on the fallback AP and is the recovery path.
-    # web_server `ota: false` gates /update behind the captive portal on
-    # every listener
-    web_server_conf = full_conf.get(CONF_WEB_SERVER)
-    plaintext_update_reachable = (
-        web_server_conf.get(CONF_OTA) is not False
-        if web_server_conf is not None
-        else "prometheus" in full_conf
-    )
+    # portal's copy only exists on the fallback AP and is the recovery path
     if (
-        plaintext_update_reachable
+        (CONF_WEB_SERVER in full_conf or "prometheus" in full_conf)
         and any(conf.get(CONF_PLATFORM) == CONF_WEB_SERVER for conf in full_ota_conf)
         and any(
             CONF_ENCRYPTION in conf
@@ -316,16 +308,20 @@ async def to_code(config: ConfigType) -> None:
     # One key per device: an api encryption block supplies it (static or
     # runtime) and offers; the ota block only adds the requirement
     api_conf = CORE.config.get(CONF_API) or {}
-    if key := static_encryption_key(config) or static_encryption_key(api_conf):
-        # Build time key: the ota keeps its own pointer so safe mode, which
-        # has no api server, still has it
+    encryption_conf = config.get(CONF_ENCRYPTION)
+    own_key = None
+    if encryption_conf is not None and static_encryption_key(api_conf) is None:
+        own_key = encryption_conf[CONF_KEY]
+    if own_key is not None:
         cg.add_define("USE_OTA_ENCRYPTION")
-        cg.add(var.set_noise_psk(new_psk_progmem(config[CONF_ID], key)))
+        cg.add(var.set_noise_psk(new_psk_progmem(config[CONF_ID], own_key)))
     elif CONF_ENCRYPTION in api_conf:
-        # Runtime key: found in the api server, or in preferences in safe mode
         cg.add_define("USE_OTA_ENCRYPTION")
-        cg.add_define("USE_OTA_ENCRYPTION_PROVISIONED")
-    if CONF_ENCRYPTION in config:
+        cg.add_define("USE_OTA_ENCRYPTION_FROM_API")
+        if static_encryption_key(api_conf) is None:
+            # The key arrives at runtime, so the offer has to look for it
+            cg.add_define("USE_OTA_ENCRYPTION_PROVISIONED")
+    if encryption_conf is not None:
         cg.add_define("USE_OTA_ENCRYPTION_REQUIRED")
 
     # Build flag so lwip_fast_select.c (a .c file that can't include defines.h) sees it.

esphome/components/esphome/ota/ota_esphome.cpp

@@ -1,5 +1,5 @@
 #include "ota_esphome.h"
-#ifdef USE_OTA_ENCRYPTION_PROVISIONED
+#ifdef USE_OTA_ENCRYPTION_FROM_API
 #include "esphome/components/api/api_server.h"
 #endif
 #ifdef USE_OTA
@@ -32,13 +32,11 @@ static const char *const TAG = "esphome.ota";
 
 #ifdef USE_OTA_ENCRYPTION
 const noise::NoiseContext &ESPHomeOTAComponent::noise_context_() const {
-#ifdef USE_OTA_ENCRYPTION_PROVISIONED
-  // The api server holds the live key; safe mode never constructs it, and then
-  // noise_ctx_ holds the saved key setup() found, if any
-  if (api::global_api_server != nullptr)
-    return api::global_api_server->get_noise_ctx();
-#endif
+#ifdef USE_OTA_ENCRYPTION_FROM_API
+  return api::global_api_server->get_noise_ctx();
+#else
   return this->noise_ctx_;
+#endif
 }
 #endif
 static constexpr uint16_t OTA_BLOCK_SIZE = 8192;
@@ -60,16 +58,6 @@ extern "C" void esphome_wake_ota_component_any_context() {
 }
 
 void ESPHomeOTAComponent::setup() {
-#ifdef USE_OTA_ENCRYPTION_PROVISIONED
-  // Safe mode never constructs the api server, so read the key it saved
-  noise::psk_t psk;
-  if (api::global_api_server == nullptr && api::load_saved_noise_psk(psk)) {
-    this->saved_psk_ = RAMAllocator<noise::psk_t>().make_unique(psk);
-    if (this->saved_psk_ != nullptr) {
-      this->noise_ctx_.set_psk(this->saved_psk_->data());
-    }
-  }
-#endif
   this->server_ = socket::socket_ip_loop_monitored(SOCK_STREAM, 0).release();  // monitored for incoming connections
   if (this->server_ == nullptr) {
     this->server_failed_(LOG_STR("creation"));

esphome/components/esphome/ota/ota_esphome.h

@@ -44,7 +44,7 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
   }
 #endif  // USE_OTA_PASSWORD
 
-#ifdef USE_OTA_ENCRYPTION
+#if defined(USE_OTA_ENCRYPTION) && !defined(USE_OTA_ENCRYPTION_FROM_API)
   /// psk points at 32 bytes that live in flash for the life of the program
   void set_noise_psk(const uint8_t *psk) { this->noise_ctx_.set_psk(psk); }
 #endif
@@ -86,8 +86,7 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
     bool writing{false};    // a produced handshake frame is still being flushed
     uint8_t frame_buf[noise::FRAME_HEADER_SIZE + 1 + noise::MAX_HANDSHAKE_SIZE];
   };
-  // The api server's live context when it exists, otherwise our own (a build
-  // time key, or the saved key loaded in safe mode)
+  // The api server's live context when the api has encryption, else our own
   const noise::NoiseContext &noise_context_() const;
   bool noise_start_session_(uint8_t server_feature_flags);
   bool handle_noise_handshake_();
@@ -149,10 +148,8 @@ class ESPHomeOTAComponent final : public ota::OTAComponent {
   RAMUniquePtr<uint8_t[]> auth_buf_;
 #endif  // USE_OTA_PASSWORD
 #ifdef USE_OTA_ENCRYPTION
+#ifndef USE_OTA_ENCRYPTION_FROM_API
   noise::NoiseContext noise_ctx_;
-#ifdef USE_OTA_ENCRYPTION_PROVISIONED
-  // Backs noise_ctx_ in safe mode, where no api server holds the saved key
-  RAMUniquePtr<noise::psk_t> saved_psk_;
 #endif
   RAMUniquePtr<NoiseSession> noise_;
 #endif  // USE_OTA_ENCRYPTION

esphome/components/ethernet_info/ethernet_info_text_sensor.h

@@ -13,9 +13,6 @@ class IPAddressEthernetInfo final : public Component,
                                     public text_sensor::TextSensor,
                                     public ethernet::EthernetIPStateListener {
  public:
-  // User provided, not "= default": `new(p) IPAddressEthernetInfo()` would zero-fill .bss that is already zero.
-  IPAddressEthernetInfo() {}
-
   void setup() override;
   void dump_config() override;
   void add_ip_sensors(uint8_t index, text_sensor::TextSensor *s) { this->ip_sensors_[index] = s; }

esphome/components/fan/fan.h

@@ -183,7 +183,7 @@ class Fan : public EntityBase {
 
   LazyCallbackManager<void()> state_callback_{};
   ESPPreferenceObject rtc_;
-  FanRestoreMode restore_mode_{FanRestoreMode::NO_RESTORE};
+  FanRestoreMode restore_mode_;
 
  private:
   /// Lazy-allocate preset modes vector (never freed — entity lives forever).

esphome/components/file/image.py

@@ -42,7 +42,7 @@ from esphome.const import (
     CONF_TYPE,
     CONF_URL,
 )
-from esphome.core import HexInt
+from esphome.core import CORE, HexInt
 from esphome.cpp_generator import MockObj, MockObjClass
 from esphome.external_files import RemoteFile
 from esphome.types import ConfigType
@@ -76,18 +76,16 @@ def compute_local_image_path(value: str | ConfigType) -> Path:
     return external_files.compute_local_file_path(DOMAIN, url)
 
 
-def local_path(value: Path | ConfigType) -> Path:
-    # cv.file_ has already resolved the path against the config dir.
-    return value[CONF_PATH] if isinstance(value, dict) else value
+def local_path(value: str | ConfigType) -> str:
+    value = value[CONF_PATH] if isinstance(value, dict) else value
+    return str(CORE.relative_config_path(value))
 
 
-def download_file(url: str, path: Path) -> Path:
+def download_file(url: str, path: Path) -> str:
     # The shared NETWORK_TIMEOUT applies; a per-caller timeout would be
     # silently ignored on a per-run memo hit anyway (memos key by path).
     external_files.download_content(url, path)
-    # Keep the Path: config-hash normalizes Path values under the data dir,
-    # which a str would dump verbatim and break the CLI/add-on comparison.
-    return path
+    return str(path)
 
 
 def _gh_svg_url_path(mdi_id: str, source: str) -> tuple[str, Path]:
@@ -95,13 +93,13 @@ def _gh_svg_url_path(mdi_id: str, source: str) -> tuple[str, Path]:
     return MDI_SOURCES[source] + mdi_id + ".svg", base_dir / f"{mdi_id}.svg"
 
 
-def download_gh_svg(value: str | ConfigType, source: str) -> Path:
+def download_gh_svg(value: str | ConfigType, source: str) -> str:
     mdi_id = value[CONF_ICON] if isinstance(value, dict) else value
     url, path = _gh_svg_url_path(mdi_id, source)
     return download_file(url, path)
 
 
-def download_image(value: str | ConfigType) -> Path:
+def download_image(value: str | ConfigType) -> str:
     value = value[CONF_URL] if isinstance(value, dict) else value
     return download_file(value, compute_local_image_path(value))
 
@@ -149,7 +147,7 @@ def _extract_entry_ref(entry: ConfigType) -> RemoteFile | None:
 PREFETCH_FILES = external_files.single_stage_prefetch(_extract_entry_ref)
 
 
-def validate_file_shorthand(value: Any) -> Path:
+def validate_file_shorthand(value: Any) -> str:
     value = cv.string_strict(value)
     if (remote := _parse_remote_shorthand(value)) is not None:
         return download_file(remote.url, remote.path)
@@ -167,7 +165,7 @@ LOCAL_SCHEMA = cv.All(
 
 
 def mdi_schema(source: str) -> cv.All:
-    def validate_mdi(value: ConfigType) -> Path:
+    def validate_mdi(value: ConfigType) -> str:
         return download_gh_svg(value, source)
 
     return cv.All(

esphome/components/gpio/binary_sensor/gpio_binary_sensor.h

@@ -47,9 +47,6 @@ class GPIOBinarySensorStore {
 
 class GPIOBinarySensor final : public binary_sensor::BinarySensor, public Component {
  public:
-  // User provided, not "= default": `new(p) GPIOBinarySensor()` would zero-fill .bss that is already zero.
-  GPIOBinarySensor() {}
-
   // No destructor needed: ESPHome components are created at boot and live forever.
   // Interrupts are only detached on reboot when memory is cleared anyway.
 
@@ -73,7 +70,7 @@ class GPIOBinarySensor final : public binary_sensor::BinarySensor, public Compon
   void loop() override;
 
  protected:
-  GPIOPin *pin_{nullptr};
+  GPIOPin *pin_;
   GPIOBinarySensorStore store_;
 };
 

esphome/components/gpio/switch/gpio_switch.cpp

@@ -13,10 +13,18 @@ void GPIOSwitch::setup() {
   bool initial_state = this->get_initial_state_with_restore_mode().value_or(false);
 
   // write state before setup
-  this->control(initial_state);
+  if (initial_state) {
+    this->turn_on();
+  } else {
+    this->turn_off();
+  }
   this->pin_->setup();
   // write after setup again for other IOs
-  this->control(initial_state);
+  if (initial_state) {
+    this->turn_on();
+  } else {
+    this->turn_off();
+  }
 }
 void GPIOSwitch::dump_config() {
   LOG_SWITCH("", "GPIO Switch", this);

esphome/components/gpio/switch/gpio_switch.h

@@ -9,9 +9,6 @@ namespace esphome::gpio {
 
 class GPIOSwitch final : public switch_::Switch, public Component {
  public:
-  // User provided, not "= default": `new(p) GPIOSwitch()` would zero-fill .bss that is already zero.
-  GPIOSwitch() {}
-
   void set_pin(GPIOPin *pin) { pin_ = pin; }
 
   // ========== INTERNAL METHODS ==========
@@ -28,7 +25,7 @@ class GPIOSwitch final : public switch_::Switch, public Component {
  protected:
   void write_state(bool state) override;
 
-  GPIOPin *pin_{nullptr};
+  GPIOPin *pin_;
 #ifdef USE_GPIO_SWITCH_INTERLOCK
   FixedVector<Switch *> interlock_;
   uint32_t interlock_wait_time_{0};

esphome/components/graphical_display_menu/graphical_display_menu.cpp

@@ -57,6 +57,10 @@ void GraphicalDisplayMenu::dump_config() {
   }
 }
 
+void GraphicalDisplayMenu::set_display(display::Display *display) { this->display_ = display; }
+
+void GraphicalDisplayMenu::set_font(display::BaseFont *font) { this->font_ = font; }
+
 void GraphicalDisplayMenu::set_foreground_color(Color foreground_color) { this->foreground_color_ = foreground_color; }
 void GraphicalDisplayMenu::set_background_color(Color background_color) { this->background_color_ = background_color; }
 

esphome/components/graphical_display_menu/graphical_display_menu.h

@@ -38,8 +38,8 @@ class GraphicalDisplayMenu final : public display_menu_base::DisplayMenuComponen
   void setup() override;
   void dump_config() override;
 
-  void set_display(display::Display *display) { this->display_ = display; }
-  void set_font(display::BaseFont *font) { this->font_ = font; }
+  void set_display(display::Display *display);
+  void set_font(display::BaseFont *font);
   template<typename V> void set_menu_item_value(V menu_item_value) { this->menu_item_value_ = menu_item_value; }
   void set_foreground_color(Color foreground_color);
   void set_background_color(Color background_color);

esphome/components/haier/haier_base.cpp

@@ -190,6 +190,8 @@ void HaierClimateBase::set_supported_presets(climate::ClimatePresetMask presets)
     this->traits_.add_supported_preset(climate::CLIMATE_PRESET_NONE);
 }
 
+void HaierClimateBase::set_send_wifi(bool send_wifi) { this->send_wifi_signal_ = send_wifi; }
+
 void HaierClimateBase::send_custom_command(const haier_protocol::HaierMessage &message) {
   this->action_request_ = PendingAction({ActionRequest::SEND_CUSTOM_COMMAND, message});
 }

esphome/components/haier/haier_base.h

@@ -71,7 +71,7 @@ class HaierClimateBase : public esphome::Component,
   };
   bool can_send_message() const { return haier_protocol_.get_outgoing_queue_size() == 0; };
   void set_answer_timeout(uint32_t timeout);
-  void set_send_wifi(bool send_wifi) { this->send_wifi_signal_ = send_wifi; }
+  void set_send_wifi(bool send_wifi);
   void send_custom_command(const haier_protocol::HaierMessage &message);
   template<typename F> void add_status_message_callback(F &&callback) {
     this->status_message_callback_.add(std::forward<F>(callback));

esphome/components/http_request/http_request.h

@@ -331,46 +331,27 @@ class HttpRequestComponent : public Component {
   void set_follow_redirects(bool follow_redirects) { this->follow_redirects_ = follow_redirects; }
   void set_redirect_limit(uint16_t limit) { this->redirect_limit_ = limit; }
 
-  std::shared_ptr<HttpContainer> get(const char *url) { return this->start(url, "GET", "", std::vector<Header>{}); }
-  std::shared_ptr<HttpContainer> get(const char *url, const std::vector<Header> &request_headers) {
-    return this->start(url, "GET", "", request_headers);
+  std::shared_ptr<HttpContainer> get(const std::string &url) {
+    return this->start(url, "GET", "", std::vector<Header>{});
   }
-  std::shared_ptr<HttpContainer> get(const char *url, const std::vector<Header> &request_headers,
-                                     const std::vector<std::string> &lower_case_collect_headers) {
-    return this->start(url, "GET", "", request_headers, lower_case_collect_headers);
-  }
-  std::shared_ptr<HttpContainer> post(const char *url, const std::string &body) {
-    return this->start(url, "POST", body, std::vector<Header>{});
-  }
-  std::shared_ptr<HttpContainer> post(const char *url, const std::string &body,
-                                      const std::vector<Header> &request_headers) {
-    return this->start(url, "POST", body, request_headers);
-  }
-  std::shared_ptr<HttpContainer> post(const char *url, const std::string &body,
-                                      const std::vector<Header> &request_headers,
-                                      const std::vector<std::string> &lower_case_collect_headers) {
-    return this->start(url, "POST", body, request_headers, lower_case_collect_headers);
-  }
-
-  std::shared_ptr<HttpContainer> get(const std::string &url) { return this->get(url.c_str()); }
   std::shared_ptr<HttpContainer> get(const std::string &url, const std::vector<Header> &request_headers) {
-    return this->get(url.c_str(), request_headers);
+    return this->start(url, "GET", "", request_headers);
   }
   std::shared_ptr<HttpContainer> get(const std::string &url, const std::vector<Header> &request_headers,
                                      const std::vector<std::string> &lower_case_collect_headers) {
-    return this->get(url.c_str(), request_headers, lower_case_collect_headers);
+    return this->start(url, "GET", "", request_headers, lower_case_collect_headers);
   }
   std::shared_ptr<HttpContainer> post(const std::string &url, const std::string &body) {
-    return this->post(url.c_str(), body);
+    return this->start(url, "POST", body, std::vector<Header>{});
   }
   std::shared_ptr<HttpContainer> post(const std::string &url, const std::string &body,
                                       const std::vector<Header> &request_headers) {
-    return this->post(url.c_str(), body, request_headers);
+    return this->start(url, "POST", body, request_headers);
   }
   std::shared_ptr<HttpContainer> post(const std::string &url, const std::string &body,
                                       const std::vector<Header> &request_headers,
                                       const std::vector<std::string> &lower_case_collect_headers) {
-    return this->post(url.c_str(), body, request_headers, lower_case_collect_headers);
+    return this->start(url, "POST", body, request_headers, lower_case_collect_headers);
   }
 
   // Remove before 2027.1.0
@@ -398,15 +379,11 @@ class HttpRequestComponent : public Component {
     return this->post(url, body, std::vector<Header>(request_headers.begin(), request_headers.end()), collect_headers);
   }
 
-  std::shared_ptr<HttpContainer> start(const char *url, const char *method, const std::string &body,
+  std::shared_ptr<HttpContainer> start(const std::string &url, const std::string &method, const std::string &body,
                                        const std::vector<Header> &request_headers) {
     // Call perform() directly to avoid ambiguity with the deprecated overloads
     return this->perform(url, method, body, request_headers, {});
   }
-  std::shared_ptr<HttpContainer> start(const std::string &url, const std::string &method, const std::string &body,
-                                       const std::vector<Header> &request_headers) {
-    return this->start(url.c_str(), method.c_str(), body, request_headers);
-  }
 
   // Remove before 2027.1.0
   ESPDEPRECATED("Pass request_headers as std::vector<Header> instead of std::list. Removed in 2027.1.0.", "2026.7.0")
@@ -426,7 +403,7 @@ class HttpRequestComponent : public Component {
     for (const auto &h : collect_headers) {
       lower.push_back(str_lower_case(h));  // NOLINT
     }
-    return this->perform(url.c_str(), method.c_str(), body, request_headers, lower);
+    return this->perform(url, method, body, request_headers, lower);
   }
 
   // Remove before 2027.1.0
@@ -441,8 +418,7 @@ class HttpRequestComponent : public Component {
     for (const auto &h : collect_headers) {
       lower.push_back(str_lower_case(h));  // NOLINT
     }
-    return this->perform(url.c_str(), method.c_str(), body,
-                         std::vector<Header>(request_headers.begin(), request_headers.end()), lower);
+    return this->perform(url, method, body, std::vector<Header>(request_headers.begin(), request_headers.end()), lower);
   }
 
   // Remove before 2027.1.0
@@ -450,25 +426,19 @@ class HttpRequestComponent : public Component {
   std::shared_ptr<HttpContainer> start(const std::string &url, const std::string &method, const std::string &body,
                                        const std::list<Header> &request_headers,
                                        const std::vector<std::string> &lower_case_collect_headers) {
-    return this->perform(url.c_str(), method.c_str(), body,
-                         std::vector<Header>(request_headers.begin(), request_headers.end()),
+    return this->perform(url, method, body, std::vector<Header>(request_headers.begin(), request_headers.end()),
                          lower_case_collect_headers);
   }
 
-  std::shared_ptr<HttpContainer> start(const char *url, const char *method, const std::string &body,
+  std::shared_ptr<HttpContainer> start(const std::string &url, const std::string &method, const std::string &body,
                                        const std::vector<Header> &request_headers,
                                        const std::vector<std::string> &lower_case_collect_headers) {
     return this->perform(url, method, body, request_headers, lower_case_collect_headers);
   }
-  std::shared_ptr<HttpContainer> start(const std::string &url, const std::string &method, const std::string &body,
-                                       const std::vector<Header> &request_headers,
-                                       const std::vector<std::string> &lower_case_collect_headers) {
-    return this->start(url.c_str(), method.c_str(), body, request_headers, lower_case_collect_headers);
-  }
 
  protected:
-  virtual std::shared_ptr<HttpContainer> perform(const char *url, const char *method, const std::string &body,
-                                                 const std::vector<Header> &request_headers,
+  virtual std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method,
+                                                 const std::string &body, const std::vector<Header> &request_headers,
                                                  const std::vector<std::string> &lower_case_collect_headers) = 0;
   const char *useragent_{nullptr};
   bool follow_redirects_{};
@@ -529,8 +499,8 @@ template<typename... Ts> class HttpRequestSendAction final : public Action<Ts...
       request_headers.push_back({key, val.value(x...)});
     }
 
-    auto container = this->parent_->start(this->url_.value(x...).c_str(), this->method_.value(x...), body,
-                                          request_headers, this->lower_case_collect_headers_);
+    auto container = this->parent_->start(this->url_.value(x...), this->method_.value(x...), body, request_headers,
+                                          this->lower_case_collect_headers_);
 
     auto captured_args = std::make_tuple(x...);
 

esphome/components/http_request/http_request_arduino.cpp

@@ -2,8 +2,6 @@
 
 #if defined(USE_ARDUINO) && !defined(USE_ESP32) && !defined(USE_LIBRETINY)
 
-#include <cstring>
-
 #include "esphome/components/network/util.h"
 #include "esphome/components/watchdog/watchdog.h"
 
@@ -24,7 +22,8 @@ static const char *const TAG = "http_request";
 static constexpr int ESP8266_SSL_ERR_OOM = -1000;
 #endif
 
-std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const char *url, const char *method, const std::string &body,
+std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const std::string &url, const std::string &method,
+                                                           const std::string &body,
                                                            const std::vector<Header> &request_headers,
                                                            const std::vector<std::string> &lower_case_collect_headers) {
   if (!network::is_connected()) {
@@ -38,7 +37,7 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const char *url, cons
 
   const uint32_t start = millis();
 
-  bool secure = strstr(url, "https:") != nullptr;
+  bool secure = url.find("https:") != std::string::npos;
   container->set_secure(secure);
 
   watchdog::WatchdogManager wdm(this->get_watchdog_timeout());
@@ -71,19 +70,19 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const char *url, cons
   stream_ptr = std::make_unique<WiFiClient>();
 #endif  // USE_HTTP_REQUEST_ESP8266_HTTPS
 
-  bool status = container->client_.begin(*stream_ptr, url);
+  bool status = container->client_.begin(*stream_ptr, url.c_str());
 
 #elif defined(USE_RP2)
   if (secure) {
     container->client_.setInsecure();
   }
-  bool status = container->client_.begin(url);
+  bool status = container->client_.begin(url.c_str());
 #endif
 
   App.feed_wdt();
 
   if (!status) {
-    ESP_LOGW(TAG, "HTTP Request failed; URL: %s", url);
+    ESP_LOGW(TAG, "HTTP Request failed; URL: %s", url.c_str());
     container->end();
     this->status_momentary_error("failed", 1000);
     return nullptr;
@@ -108,7 +107,7 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const char *url, cons
   container->client_.collectHeaders(header_keys, index);
 
   App.feed_wdt();
-  container->status_code = container->client_.sendRequest(method, body.c_str());
+  container->status_code = container->client_.sendRequest(method.c_str(), body.c_str());
   App.feed_wdt();
   if (container->status_code < 0) {
 #if defined(USE_ESP8266) && defined(USE_HTTP_REQUEST_ESP8266_HTTPS)
@@ -140,7 +139,7 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const char *url, cons
     }
 #endif
 
-    ESP_LOGW(TAG, "HTTP Request failed; URL: %s; Error: %s", url,
+    ESP_LOGW(TAG, "HTTP Request failed; URL: %s; Error: %s", url.c_str(),
              HTTPClient::errorToString(container->status_code).c_str());
 
     this->status_momentary_error("failed", 1000);
@@ -148,7 +147,7 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const char *url, cons
     return nullptr;
   }
   if (!is_success(container->status_code)) {
-    ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url, container->status_code);
+    ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url.c_str(), container->status_code);
     this->status_momentary_error("failed", 1000);
     // Still return the container, so it can be used to get the status code and error message
   }

esphome/components/http_request/http_request_arduino.h

@@ -54,7 +54,7 @@ class HttpRequestArduino final : public HttpRequestComponent {
 #endif
 
  protected:
-  std::shared_ptr<HttpContainer> perform(const char *url, const char *method, const std::string &body,
+  std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method, const std::string &body,
                                          const std::vector<Header> &request_headers,
                                          const std::vector<std::string> &lower_case_collect_headers) override;
 #ifdef USE_ESP8266

esphome/components/http_request/http_request_host.cpp

@@ -5,8 +5,6 @@
 #include "httplib.h"
 #include "http_request_host.h"
 
-#include <cstring>
-
 #include <regex>
 #include "esphome/components/network/util.h"
 #include "esphome/components/watchdog/watchdog.h"
@@ -18,7 +16,8 @@ namespace esphome::http_request {
 
 static const char *const TAG = "http_request";
 
-std::shared_ptr<HttpContainer> HttpRequestHost::perform(const char *url, const char *method, const std::string &body,
+std::shared_ptr<HttpContainer> HttpRequestHost::perform(const std::string &url, const std::string &method,
+                                                        const std::string &body,
                                                         const std::vector<Header> &request_headers,
                                                         const std::vector<std::string> &lower_case_collect_headers) {
   if (!network::is_connected()) {
@@ -28,10 +27,10 @@ std::shared_ptr<HttpContainer> HttpRequestHost::perform(const char *url, const c
   }
 
   std::regex url_regex(R"(^(([^:\/?#]+):)?(//([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?)", std::regex::extended);
-  std::cmatch url_match_result;
+  std::smatch url_match_result;
 
   if (!std::regex_match(url, url_match_result, url_regex) || url_match_result.length() < 7) {
-    ESP_LOGE(TAG, "HTTP Request failed; Malformed URL: %s", url);
+    ESP_LOGE(TAG, "HTTP Request failed; Malformed URL: %s", url.c_str());
     return nullptr;
   }
   auto host = url_match_result[4].str();
@@ -55,7 +54,7 @@ std::shared_ptr<HttpContainer> HttpRequestHost::perform(const char *url, const c
   }
   httplib::Client client(scheme_host.c_str());
   if (!client.is_valid()) {
-    ESP_LOGE(TAG, "HTTP Request failed; Invalid URL: %s", url);
+    ESP_LOGE(TAG, "HTTP Request failed; Invalid URL: %s", url.c_str());
     return nullptr;
   }
   client.set_follow_location(this->follow_redirects_);
@@ -65,41 +64,41 @@ std::shared_ptr<HttpContainer> HttpRequestHost::perform(const char *url, const c
 #endif
 
   httplib::Result result;
-  if (strcmp(method, "GET") == 0) {
+  if (method == "GET") {
     result = client.Get(path, h_headers, [&](const char *data, size_t data_length) {
       ESP_LOGV(TAG, "Got data length: %zu", data_length);
       container->response_body_.insert(container->response_body_.end(), (const uint8_t *) data,
                                        (const uint8_t *) data + data_length);
       return true;
     });
-  } else if (strcmp(method, "HEAD") == 0) {
+  } else if (method == "HEAD") {
     result = client.Head(path, h_headers);
-  } else if (strcmp(method, "PUT") == 0) {
+  } else if (method == "PUT") {
     result = client.Put(path, h_headers, body, "");
     if (result) {
       auto data = std::vector<uint8_t>(result->body.begin(), result->body.end());
       container->response_body_.insert(container->response_body_.end(), data.begin(), data.end());
     }
-  } else if (strcmp(method, "PATCH") == 0) {
+  } else if (method == "PATCH") {
     result = client.Patch(path, h_headers, body, "");
     if (result) {
       auto data = std::vector<uint8_t>(result->body.begin(), result->body.end());
       container->response_body_.insert(container->response_body_.end(), data.begin(), data.end());
     }
-  } else if (strcmp(method, "POST") == 0) {
+  } else if (method == "POST") {
     result = client.Post(path, h_headers, body, "");
     if (result) {
       auto data = std::vector<uint8_t>(result->body.begin(), result->body.end());
       container->response_body_.insert(container->response_body_.end(), data.begin(), data.end());
     }
   } else {
-    ESP_LOGW(TAG, "HTTP Request failed - unsupported method %s; URL: %s", method, url);
+    ESP_LOGW(TAG, "HTTP Request failed - unsupported method %s; URL: %s", method.c_str(), url.c_str());
     container->end();
     return nullptr;
   }
   App.feed_wdt();
   if (!result) {
-    ESP_LOGW(TAG, "HTTP Request failed; URL: %s, error code: %u", url, (unsigned) result.error());
+    ESP_LOGW(TAG, "HTTP Request failed; URL: %s, error code: %u", url.c_str(), (unsigned) result.error());
     container->end();
     this->status_momentary_error("failed", 1000);
     return nullptr;
@@ -108,7 +107,7 @@ std::shared_ptr<HttpContainer> HttpRequestHost::perform(const char *url, const c
   auto response = *result;
   container->status_code = response.status;
   if (!is_success(response.status)) {
-    ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url, response.status);
+    ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url.c_str(), response.status);
     this->status_momentary_error("failed", 1000);
     // Still return the container, so it can be used to get the status code and error message
   }

esphome/components/http_request/http_request_host.h

@@ -18,7 +18,7 @@ class HttpContainerHost : public HttpContainer {
 
 class HttpRequestHost final : public HttpRequestComponent {
  public:
-  std::shared_ptr<HttpContainer> perform(const char *url, const char *method, const std::string &body,
+  std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method, const std::string &body,
                                          const std::vector<Header> &request_headers,
                                          const std::vector<std::string> &lower_case_collect_headers) override;
   void set_ca_path(const char *ca_path) { this->ca_path_ = ca_path; }

esphome/components/http_request/http_request_idf.cpp

@@ -2,8 +2,6 @@
 
 #ifdef USE_ESP32
 
-#include <cstring>
-
 #include "esphome/components/network/util.h"
 #include "esphome/components/watchdog/watchdog.h"
 
@@ -50,7 +48,8 @@ esp_err_t HttpRequestIDF::http_event_handler(esp_http_client_event_t *evt) {
   return ESP_OK;
 }
 
-std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const char *url, const char *method, const std::string &body,
+std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, const std::string &method,
+                                                       const std::string &body,
                                                        const std::vector<Header> &request_headers,
                                                        const std::vector<std::string> &lower_case_collect_headers) {
   if (!network::is_connected()) {
@@ -60,15 +59,15 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const char *url, const ch
   }
 
   esp_http_client_method_t method_idf;
-  if (strcmp(method, "GET") == 0) {
+  if (method == "GET") {
     method_idf = HTTP_METHOD_GET;
-  } else if (strcmp(method, "POST") == 0) {
+  } else if (method == "POST") {
     method_idf = HTTP_METHOD_POST;
-  } else if (strcmp(method, "PUT") == 0) {
+  } else if (method == "PUT") {
     method_idf = HTTP_METHOD_PUT;
-  } else if (strcmp(method, "DELETE") == 0) {
+  } else if (method == "DELETE") {
     method_idf = HTTP_METHOD_DELETE;
-  } else if (strcmp(method, "PATCH") == 0) {
+  } else if (method == "PATCH") {
     method_idf = HTTP_METHOD_PATCH;
   } else {
     this->status_momentary_error("failed", ERROR_DURATION_MS);
@@ -76,11 +75,11 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const char *url, const ch
     return nullptr;
   }
 
-  bool secure = strstr(url, "https:") != nullptr;
+  bool secure = url.find("https:") != std::string::npos;
 
   esp_http_client_config_t config = {};
 
-  config.url = url;
+  config.url = url.c_str();
   config.method = method_idf;
   config.timeout_ms = this->timeout_;
   config.disable_auto_redirect = !this->follow_redirects_;
@@ -219,7 +218,7 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const char *url, const ch
     }
   }
 
-  ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url, container->status_code);
+  ESP_LOGE(TAG, "HTTP Request failed; URL: %s; Code: %d", url.c_str(), container->status_code);
   this->status_momentary_error("failed", ERROR_DURATION_MS);
   return container;
 }

esphome/components/http_request/http_request_idf.h

@@ -30,9 +30,6 @@ class HttpContainerIDF : public HttpContainer {
 
 class HttpRequestIDF final : public HttpRequestComponent {
  public:
-  // User provided, not "= default": `new(p) HttpRequestIDF()` would zero-fill .bss that is already zero.
-  HttpRequestIDF() {}
-
   void dump_config() override;
 
   void set_buffer_size_rx(uint16_t buffer_size_rx) { this->buffer_size_rx_ = buffer_size_rx; }
@@ -41,7 +38,7 @@ class HttpRequestIDF final : public HttpRequestComponent {
   void set_ca_certificate(const char *ca_certificate) { this->ca_certificate_ = ca_certificate; }
 
  protected:
-  std::shared_ptr<HttpContainer> perform(const char *url, const char *method, const std::string &body,
+  std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method, const std::string &body,
                                          const std::vector<Header> &request_headers,
                                          const std::vector<std::string> &lower_case_collect_headers) override;
   // if zero ESP-IDF will use DEFAULT_HTTP_BUF_SIZE

esphome/components/http_request/update/http_request_update.cpp

@@ -1,7 +1,5 @@
 #include "http_request_update.h"
 
-#include <cstring>
-
 #include "esphome/core/application.h"
 #include "esphome/core/version.h"
 
@@ -96,7 +94,7 @@ void HttpRequestUpdate::update_task(void *params) {
   auto container = this_update->request_parent_->get(this_update->source_url_);
 
   if (container == nullptr || container->status_code != HTTP_STATUS_OK) {
-    ESP_LOGE(TAG, "Failed to fetch manifest from %s", this_update->source_url_);
+    ESP_LOGE(TAG, "Failed to fetch manifest from %s", this_update->source_url_.c_str());
     if (container != nullptr)
       container->end();
     result->error_str = LOG_STR("Failed to fetch manifest");
@@ -176,26 +174,21 @@ void HttpRequestUpdate::update_task(void *params) {
     allocator.deallocate(data, content_length);
 
     if (!valid) {
-      ESP_LOGE(TAG, "Failed to parse JSON from %s", this_update->source_url_);
+      ESP_LOGE(TAG, "Failed to parse JSON from %s", this_update->source_url_.c_str());
       result->error_str = LOG_STR("Failed to parse manifest JSON");
       goto defer;  // NOLINT(cppcoreguidelines-avoid-goto)
     }
 
     // Merge source_url_ and firmware_url
     if (!info->firmware_url.empty() && info->firmware_url.find("http") == std::string::npos) {
-      const char *source = this_update->source_url_;
-      const size_t source_len = strlen(source);
-      size_t prefix_len;
-      if (info->firmware_url[0] == '/') {
-        // scheme and host, up to the first slash after "https://"
-        const char *host_end = source_len > 8 ? strchr(source + 8, '/') : nullptr;
-        prefix_len = host_end != nullptr ? host_end - source : source_len;
+      std::string path = info->firmware_url;
+      if (path[0] == '/') {
+        std::string domain = this_update->source_url_.substr(0, this_update->source_url_.find('/', 8));
+        info->firmware_url = domain + path;
       } else {
-        // directory of the manifest, up to and including its last slash
-        const char *dir_end = strrchr(source, '/');
-        prefix_len = dir_end != nullptr ? dir_end - source + 1 : 0;
+        std::string domain = this_update->source_url_.substr(0, this_update->source_url_.rfind('/') + 1);
+        info->firmware_url = domain + path;
       }
-      info->firmware_url.insert(0, source, prefix_len);
     }
 
 #ifdef ESPHOME_PROJECT_VERSION

esphome/components/http_request/update/http_request_update.h

@@ -21,7 +21,7 @@ class HttpRequestUpdate final : public update::UpdateEntity, public PollingCompo
   void perform(bool force) override;
   void check() override { this->update(); }
 
-  void set_source_url(const char *source_url) { this->source_url_ = source_url; }
+  void set_source_url(const std::string &source_url) { this->source_url_ = source_url; }
 
   void set_request_parent(HttpRequestComponent *request_parent) { this->request_parent_ = request_parent; }
   void set_ota_parent(OtaHttpRequestComponent *ota_parent) { this->ota_parent_ = ota_parent; }
@@ -33,15 +33,13 @@ class HttpRequestUpdate final : public update::UpdateEntity, public PollingCompo
  protected:
   HttpRequestComponent *request_parent_;
   OtaHttpRequestComponent *ota_parent_;
+  std::string source_url_;
 
   static void update_task(void *params);
 #ifdef USE_ESP32
   TaskHandle_t update_task_handle_{nullptr};
 #endif
   uint8_t initial_check_remaining_{0};
-
- private:
-  const char *source_url_{nullptr};  // literal from codegen
 };
 
 }  // namespace esphome::http_request

esphome/components/hub75/hub75.cpp

@@ -1,4 +1,5 @@
 #include "hub75_component.h"
+#include "esphome/core/application.h"
 
 #include <cinttypes>
 
@@ -123,11 +124,11 @@ void HOT HUB75Display::draw_pixel_at(int x, int y, Color color) {
   if (x >= this->get_width_internal() || x < 0 || y >= this->get_height_internal() || y < 0) [[unlikely]]
     return;
 
-  if (this->is_point_clipped(x, y))
+  if (!this->get_clipping().inside(x, y))
     return;
 
   driver_->set_pixel(x, y, color.r, color.g, color.b);
-  this->feed_wdt_per_pixel_();
+  App.feed_wdt();
 }
 
 void HOT HUB75Display::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,

esphome/components/i2s_audio/speaker/i2s_audio_spdif.cpp

@@ -48,11 +48,10 @@ static esp_err_t spdif_write_cb(void *user_ctx, uint32_t *data, size_t size, Tic
   auto *speaker = static_cast<I2SAudioSpeakerSPDIF *>(user_ctx);
   size_t bytes_written = 0;
   esp_err_t err = i2s_channel_write(speaker->get_tx_handle(), data, size, &bytes_written, ticks_to_wait);
-  if (err != ESP_OK || bytes_written != size) {
+  if (err != ESP_OK) {
     ESP_LOGV(TAG, "I2S write failed: %s (wrote %zu/%zu bytes)", esp_err_to_name(err), bytes_written, size);
-    return (err != ESP_OK) ? err : ESP_FAIL;
   }
-  return ESP_OK;
+  return err;
 }
 
 void I2SAudioSpeakerSPDIF::setup() {
@@ -168,44 +167,33 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
     }
   }
 
-  // Preload DMA buffers with SPDIF-encoded silence before enabling the channel.
-  // This ensures the first data transmitted is valid SPDIF (not raw zeros from
-  // auto_clear) and prevents phantom DMA events before real audio is available.
-  // Each preloaded block pushes a 0-real-frame record so that the corresponding
-  // on_sent events drain in lockstep without crediting any audio frames. Runs with
-  // the channel disabled: at startup and after a resync.
-  auto preload_silence = [&]() -> bool {
-    bool ok = true;
-    this->spdif_encoder_->set_preload_mode(true);
-    for (size_t i = 0; i < SPDIF_DMA_BUFFERS_COUNT; i++) {
-      // i2s_channel_preload_data is non-blocking (returns immediately when the preload buffer fills), so no wait.
-      const uint32_t silence_record = 0;
-      if ((this->spdif_encoder_->flush_with_silence(0) != ESP_OK) ||
-          (xQueueSendToBack(this->write_records_queue_, &silence_record, 0) != pdTRUE)) {
-        ok = false;
-        break;
-      }
-    }
-    this->spdif_encoder_->set_preload_mode(false);
-    this->spdif_encoder_->reset();  // Clean encoder state for the main loop
-    return ok;
-  };
-
-  if (successful_setup) {
-    successful_setup = preload_silence();
-  }
-
-  if (successful_setup) {
-    // Register the callback before enabling so the first transmitted block generates a queued event.
-    xQueueReset(this->i2s_event_queue_);
-    const i2s_event_callbacks_t callbacks = {.on_sent = i2s_on_sent_cb};
-    i2s_channel_register_event_callback(this->tx_handle_, &callbacks, this);
-    successful_setup = i2s_channel_enable(this->tx_handle_) == ESP_OK;
-  }
-
   if (!successful_setup) {
     xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_ESP_NO_MEM);
   } else {
+    // Preload DMA buffers with SPDIF-encoded silence before enabling the channel.
+    // This ensures the first data transmitted is valid SPDIF (not raw zeros from
+    // auto_clear) and prevents phantom DMA events before real audio is available.
+    // Each preloaded block pushes a 0-real-frame record so that the corresponding
+    // on_sent events drain in lockstep without crediting any audio frames.
+    this->spdif_encoder_->set_preload_mode(true);
+    for (size_t i = 0; i < SPDIF_DMA_BUFFERS_COUNT; i++) {
+      // i2s_channel_preload_data is non-blocking (returns immediately when the preload buffer fills), so no wait.
+      esp_err_t preload_err = this->spdif_encoder_->flush_with_silence(0);
+      if (preload_err != ESP_OK) {
+        break;  // DMA preload buffer full or error
+      }
+      const uint32_t silence_record = 0;
+      xQueueSendToBack(this->write_records_queue_, &silence_record, 0);
+    }
+    this->spdif_encoder_->set_preload_mode(false);
+    this->spdif_encoder_->reset();  // Clean encoder state for the main loop
+
+    // Now register the callback and enable the channel
+    xQueueReset(this->i2s_event_queue_);
+    const i2s_event_callbacks_t callbacks = {.on_sent = i2s_on_sent_cb};
+    i2s_channel_register_event_callback(this->tx_handle_, &callbacks, this);
+    i2s_channel_enable(this->tx_handle_);
+
     // Always-fill model: each iteration produces exactly one SPDIF block (= one DMA buffer).
     // We drain real PCM up to one block from the ring buffer and silence-pad any remainder.
     // Blocking writes pace the loop at the DMA consumption rate. This mirrors the standard
@@ -222,20 +210,24 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
     uint32_t spdif_pending_frames = 0;
     int64_t spdif_pending_timestamp = 0;
     uint32_t spdif_dma_event_count = 0;
-    bool resync_needed = false;
-    // Real frames consumed from the ring buffer that never reached a write record
-    uint32_t unrecorded_frames = 0;
 
     xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::TASK_RUNNING);
 
     // SPDIF continuous mode: loop runs indefinitely, outputting silence when no audio data
     // to keep the receiver synced. Exits only via break (stream info change, silence timeout,
-    // or a failed lockstep resync).
+    // lockstep desync, dropped event, or partial-write failure).
     while (true) {
       uint32_t event_group_bits = xEventGroupGetBits(this->event_group_);
 
       if (event_group_bits & SpeakerEventGroupBits::COMMAND_STOP) {
         xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::COMMAND_STOP);
+        // The ISR pairs COMMAND_STOP with ERR_DROPPED_EVENT when it has to discard a completion
+        // event; that desyncs the lockstep queues permanently and the only safe recovery is a full
+        // task restart.
+        if (event_group_bits & SpeakerEventGroupBits::ERR_DROPPED_EVENT) {
+          ESP_LOGV(TAG, "Exiting: ISR dropped event, restarting to recover lockstep");
+          break;
+        }
         // User-initiated stop. In SPDIF continuous mode, transition to silence output rather
         // than tearing the task down.
         this->spdif_silence_start_ = millis();
@@ -252,30 +244,6 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
         break;
       }
 
-      if (event_group_bits & SpeakerEventGroupBits::ERR_DROPPED_EVENT) {
-        ESP_LOGE(TAG, "ISR event queue overflow, resyncing DMA lockstep");
-        resync_needed = true;
-      }
-      if (resync_needed) {
-        // Rebuild the lockstep in place. Frames held back by decimation are credited too, since their
-        // blocks are discarded with the rest of the DMA contents.
-        this->spdif_encoder_->reset();
-        const uint32_t credited_frames = unrecorded_frames + spdif_pending_frames;
-        const bool resynced = this->resync_lockstep_(credited_frames, preload_silence);
-        unrecorded_frames = 0;
-        spdif_pending_frames = 0;
-        spdif_dma_event_count = 0;
-        resync_needed = false;
-        if (credited_frames > 0) {
-          // Real audio was dropped, so the silence timer's start no longer reflects the stream
-          this->spdif_silence_start_ = 0;
-        }
-        if (!resynced) {
-          ESP_LOGE(TAG, "DMA lockstep resync failed, restarting speaker task");
-          break;
-        }
-      }
-
       // Drain ISR completion events, popping a matching record for each.
       int64_t write_timestamp;
       bool lockstep_broken = false;
@@ -285,7 +253,8 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
         // order matches DMA completion order. Empty records queue here means lockstep broke.
         uint32_t real_frames = 0;
         if (xQueueReceive(this->write_records_queue_, &real_frames, 0) != pdTRUE) {
-          ESP_LOGE(TAG, "Event without matching write record, resyncing DMA lockstep");
+          ESP_LOGV(TAG, "Event without matching write record");
+          xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_LOCKSTEP_DESYNC);
           lockstep_broken = true;
           break;
         }
@@ -321,8 +290,8 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
         }
       }
       if (lockstep_broken) {
-        resync_needed = true;
-        continue;
+        ESP_LOGV(TAG, "Exiting: lockstep desync, restarting task");
+        break;
       }
 
       // Always-fill: produce exactly one SPDIF block this iteration. The blocking encoder write
@@ -353,8 +322,9 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
                                                       &blocks_sent, &pcm_consumed);
           if (err != ESP_OK) {
             // A failed (or timed-out) send leaves an unsent block in the encoder's stitch buffer;
-            // resuming would credit the next iteration's bytes against an old block.
-            ESP_LOGE(TAG, "SPDIF block send failed, resyncing DMA lockstep");
+            // resuming would credit the next iteration's bytes against an old block. Bail and
+            // let loop() restart the task with a clean encoder.
+            xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_PARTIAL_WRITE);
             partial_write_failure = true;
             break;
           }
@@ -371,9 +341,7 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
       }
 
       if (partial_write_failure) {
-        unrecorded_frames += real_frames_in_block;
-        resync_needed = true;
-        continue;
+        break;
       }
 
       if (!block_committed) {
@@ -381,20 +349,16 @@ void I2SAudioSpeakerSPDIF::run_speaker_task() {
         // or emit a full silence block if the encoder is empty.
         esp_err_t err = this->spdif_encoder_->flush_with_silence(write_timeout_ticks);
         if (err != ESP_OK) {
-          ESP_LOGE(TAG, "SPDIF block send failed, resyncing DMA lockstep");
-          unrecorded_frames += real_frames_in_block;
-          resync_needed = true;
-          continue;
+          xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_PARTIAL_WRITE);
+          break;
         }
       }
 
       // One block committed to DMA; push exactly one record carrying its real-audio frame count.
       // Failure here means the records queue is full, which violates the lockstep invariant.
       if (xQueueSendToBack(this->write_records_queue_, &real_frames_in_block, 0) != pdTRUE) {
-        ESP_LOGE(TAG, "Write records queue full, resyncing DMA lockstep");
-        unrecorded_frames += real_frames_in_block;
-        resync_needed = true;
-        continue;
+        xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_LOCKSTEP_DESYNC);
+        break;
       }
 
       // Silence-timeout tracking and graceful-stop reset.

esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp

@@ -14,19 +14,17 @@
 
 #include "esp_timer.h"
 
-#include <cmath>
+// esp-audio-libs
+#include <gain.h>
 
 namespace esphome::i2s_audio {
 
 static const char *const TAG = "i2s_audio.speaker";
 
-// Software volume control maps the user-facing (0.0, 1.0) range linearly to a dB reduction in
-// [-49.0, 0.0] dB; 0.0 is silence.
+// Software volume control maps the user-facing [0.0, 1.0] range to a Q31 scale factor.
+// Volumes in (0.0, 1.0) map linearly to a dB reduction in [-49.0, 0.0] dB.
 static constexpr float SOFTWARE_VOLUME_MIN_DB = -49.0f;
 
-// Rate at which the software gain moves toward a new target.
-static constexpr uint32_t GAIN_RAMP_MS_PER_DB = 1;
-
 void I2SAudioSpeakerBase::setup() {
   this->event_group_ = xEventGroupCreate();
 
@@ -36,10 +34,9 @@ void I2SAudioSpeakerBase::setup() {
     return;
   }
 
-  // Initialize volume control. When audio_dac is configured, this sets the DAC volume and mute state.
+  // Initialize volume control. When audio_dac is configured, this sets the DAC volume.
   // When no audio_dac is configured, this initializes software volume control.
   this->set_volume(this->volume_);
-  this->set_mute_state(this->mute_state_);
 }
 
 void I2SAudioSpeakerBase::dump_config() {
@@ -80,6 +77,17 @@ void I2SAudioSpeakerBase::loop() {
   }
   if (event_group_bits & SpeakerEventGroupBits::TASK_STOPPING) {
     ESP_LOGV(TAG, "Stopping");
+    // Lockstep-breaking error bits are latched by the task and cleared along with all other bits
+    // when TASK_STOPPED is processed; log them here, exactly once, as the task winds down.
+    if (event_group_bits & SpeakerEventGroupBits::ERR_DROPPED_EVENT) {
+      ESP_LOGE(TAG, "ISR event queue overflow, restarting speaker task to recover timestamp sync");
+    }
+    if (event_group_bits & SpeakerEventGroupBits::ERR_PARTIAL_WRITE) {
+      ESP_LOGE(TAG, "Partial DMA write broke buffer alignment, restarting speaker task");
+    }
+    if (event_group_bits & SpeakerEventGroupBits::ERR_LOCKSTEP_DESYNC) {
+      ESP_LOGE(TAG, "Event/record queues desynced, restarting speaker task");
+    }
     xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::TASK_STOPPING);
     this->state_ = speaker::STATE_STOPPING;
   }
@@ -128,10 +136,6 @@ void I2SAudioSpeakerBase::loop() {
         break;
       }
 
-      // Seed the ramp at the live target so this run adopts it instantly rather than fading to it
-      // from wherever the previous run left off. Posted here, not in the task: the ramp's mailbox
-      // allows one writer, and that is the main loop.
-      this->post_software_gain_(0);
       xTaskCreate(I2SAudioSpeakerBase::speaker_task, "speaker_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
                   &this->speaker_task_handle_);
 
@@ -149,31 +153,50 @@ void I2SAudioSpeakerBase::loop() {
 }
 
 void I2SAudioSpeakerBase::set_volume(float volume) {
-  speaker::Speaker::set_volume(volume);
-  this->post_software_gain_(this->audio_stream_info_.ms_to_samples(GAIN_RAMP_MS_PER_DB));
+  this->volume_ = volume;
+#ifdef USE_AUDIO_DAC
+  if (this->audio_dac_ != nullptr) {
+    if (volume > 0.0f) {
+      this->audio_dac_->set_mute_off();
+    }
+    this->audio_dac_->set_volume(volume);
+  } else
+#endif  // USE_AUDIO_DAC
+  {
+    // Fallback to software volume control by using a Q31 fixed point scaling factor.
+    // At maximum volume (1.0), set to INT32_MAX to bypass volume processing entirely
+    // and avoid any floating-point precision issues that could cause slight volume reduction.
+    if (volume >= 1.0f) {
+      this->q31_volume_factor_ = INT32_MAX;
+    } else if (volume <= 0.0f) {
+      this->q31_volume_factor_ = 0;
+    } else {
+      this->q31_volume_factor_ =
+          esp_audio_libs::gain::db_to_q31(remap<float, float>(volume, 0.0f, 1.0f, SOFTWARE_VOLUME_MIN_DB, 0.0f));
+    }
+  }
 }
 
 void I2SAudioSpeakerBase::set_mute_state(bool mute_state) {
-  speaker::Speaker::set_mute_state(mute_state);
-  this->post_software_gain_(this->audio_stream_info_.ms_to_samples(GAIN_RAMP_MS_PER_DB));
-}
-
-void I2SAudioSpeakerBase::post_software_gain_(uint32_t rate_samples) {
+  this->mute_state_ = mute_state;
 #ifdef USE_AUDIO_DAC
-  if (this->audio_dac_ != nullptr) {
-    return;  // Hardware volume; the ramp stays at unity
-  }
+  if (this->audio_dac_) {
+    if (mute_state) {
+      this->audio_dac_->set_mute_on();
+    } else {
+      this->audio_dac_->set_mute_off();
+    }
+  } else
 #endif  // USE_AUDIO_DAC
-  // Software volume control. The ramp treats 0 dB as unity and skips processing there.
-  float target_db;
-  if (this->is_silent_()) {
-    target_db = -INFINITY;
-  } else if (this->volume_ >= 1.0f) {
-    target_db = 0.0f;
-  } else {
-    target_db = remap<float, float>(this->volume_, 0.0f, 1.0f, SOFTWARE_VOLUME_MIN_DB, 0.0f);
+  {
+    if (mute_state) {
+      // Fallback to software volume control and scale by 0
+      this->q31_volume_factor_ = 0;
+    } else {
+      // Revert to previous volume when unmuting
+      this->set_volume(this->volume_);
+    }
   }
-  this->gain_ramp_.set_target_db_at_rate(target_db, rate_samples);
 }
 
 size_t I2SAudioSpeakerBase::play(const uint8_t *data, size_t length, TickType_t ticks_to_wait) {
@@ -314,10 +337,16 @@ bool IRAM_ATTR I2SAudioSpeakerBase::i2s_on_sent_cb(i2s_chan_handle_t handle, i2s
   I2SAudioSpeakerBase *this_speaker = (I2SAudioSpeakerBase *) user_ctx;
 
   if (xQueueIsQueueFullFromISR(this_speaker->i2s_event_queue_)) {
-    // Queue is full, so discard the oldest event. The lockstep queues are now desynced; the task resyncs them.
+    // Queue is full, so discard the oldest event. Once we drop a completion event, ``i2s_event_queue_``
+    // and any per-buffer record queue maintained by the task are permanently desynced, so the task
+    // must restart to recover. Set both ERR_DROPPED_EVENT (so loop() can log it) and COMMAND_STOP
+    // (so the task bails immediately, closing the race where loop() could clear the error bit
+    // before the task observes it).
     int64_t dummy;
     xQueueReceiveFromISR(this_speaker->i2s_event_queue_, &dummy, &need_yield1);
-    xEventGroupSetBitsFromISR(this_speaker->event_group_, SpeakerEventGroupBits::ERR_DROPPED_EVENT, &need_yield2);
+    xEventGroupSetBitsFromISR(this_speaker->event_group_,
+                              SpeakerEventGroupBits::ERR_DROPPED_EVENT | SpeakerEventGroupBits::COMMAND_STOP,
+                              &need_yield2);
   }
 
   xQueueSendToBackFromISR(this_speaker->i2s_event_queue_, &now, &need_yield3);
@@ -325,33 +354,15 @@ bool IRAM_ATTR I2SAudioSpeakerBase::i2s_on_sent_cb(i2s_chan_handle_t handle, i2s
   return need_yield1 | need_yield2 | need_yield3;
 }
 
-void I2SAudioSpeakerBase::drain_lockstep_(uint32_t extra_frames) {
-  // Stop DMA so no more completion events arrive while the queues are rebuilt
-  i2s_channel_disable(this->tx_handle_);
-  xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::ERR_DROPPED_EVENT);
-
-  uint32_t frames = extra_frames;
-  uint32_t record_frames = 0;
-  while (xQueueReceive(this->write_records_queue_, &record_frames, 0) == pdTRUE) {
-    frames += record_frames;
-  }
-  xQueueReset(this->i2s_event_queue_);
-
-  if (frames > 0) {
-    ESP_LOGV(TAG, "Crediting %" PRIu32 " dropped frames as played", frames);
-    this->audio_output_callback_(frames, esp_timer_get_time());
-  }
-}
-
 void I2SAudioSpeakerBase::apply_software_volume_(uint8_t *data, size_t bytes_read) {
-#ifdef USE_AUDIO_DAC
-  if (this->audio_dac_ != nullptr) {
-    return;  // Hardware volume; the ramp is never targeted
+  if (this->q31_volume_factor_ == INT32_MAX) {
+    return;  // Max volume, no processing needed
   }
-#endif  // USE_AUDIO_DAC
+
   const size_t bytes_per_sample = this->current_stream_info_.samples_to_bytes(1);
-  this->gain_ramp_.process(data, static_cast<uint8_t>(bytes_per_sample),
-                           this->current_stream_info_.bytes_to_samples(bytes_read));
+  const uint32_t len = bytes_read / bytes_per_sample;
+
+  esp_audio_libs::gain::apply(data, data, this->q31_volume_factor_, len, bytes_per_sample);
 }
 
 void I2SAudioSpeakerBase::swap_esp32_mono_samples_(uint8_t *data, size_t bytes_read) {

esphome/components/i2s_audio/speaker/i2s_audio_speaker.h

@@ -16,8 +16,6 @@
 #include "esphome/core/gpio.h"
 #include "esphome/core/helpers.h"
 
-#include <gain.h>  // esp-audio-libs
-
 namespace esphome::i2s_audio {
 
 // Shared constants used by both standard and SPDIF speaker implementations
@@ -36,7 +34,9 @@ enum SpeakerEventGroupBits : uint32_t {
 
   ERR_ESP_NO_MEM = (1 << 19),
 
-  ERR_DROPPED_EVENT = (1 << 20),  // ISR overflowed the event queue, dropping a completion event
+  ERR_DROPPED_EVENT = (1 << 20),    // ISR overflowed the event queue, dropping a completion event
+  ERR_PARTIAL_WRITE = (1 << 21),    // i2s_channel_write returned fewer bytes than requested
+  ERR_LOCKSTEP_DESYNC = (1 << 22),  // i2s_event_queue_ and write_records_queue_ fell out of sync
 
   ALL_BITS = 0x00FFFFFF,  // All valid FreeRTOS event group bits
 };
@@ -77,23 +77,19 @@ class I2SAudioSpeakerBase : public I2SAudioOut, public speaker::Speaker, public
 
   bool has_buffered_data() const override;
 
-  /// @brief Sets the volume of the speaker. Uses the speaker's configured audio dac component. If unavailable, it is
-  /// implemented as a software volume control. Overrides the default setter to convert the volume to a dB target for
-  /// the gain ramp.
+  /// @brief Sets the volume of the speaker. Uses the speaker's configured audio dac component. If unavailble, it is
+  /// implemented as a software volume control. Overrides the default setter to convert the floating point volume to a
+  /// Q15 fixed-point factor.
   /// @param volume between 0.0 and 1.0
   void set_volume(float volume) override;
 
-  /// @brief Mutes or unmutes the speaker. Uses the speaker's configured audio dac component. If unavailable, it is
-  /// implemented as a software volume control. Overrides the default setter to post the mute state to the gain ramp.
+  /// @brief Mutes or unmute the speaker. Uses the speaker's configured audio dac component. If unavailble, it is
+  /// implemented as a software volume control. Overrides the default setter to convert the floating point volume to a
+  /// Q15 fixed-point factor.
   /// @param mute_state true for muting, false for unmuting
   void set_mute_state(bool mute_state) override;
 
  protected:
-  /// @brief Posts the ramp target derived from the current volume and mute state. No-op when an audio dac owns
-  /// volume. Main loop only.
-  /// @param rate_samples Samples the ramp takes per dB of change; 0 adopts the target at once
-  void post_software_gain_(uint32_t rate_samples);
-
   /// @brief FreeRTOS task entry point. Casts params to I2SAudioSpeakerBase and calls run_speaker_task_().
   /// @param params I2SAudioSpeakerBase component pointer
   static void speaker_task(void *params);
@@ -132,23 +128,7 @@ class I2SAudioSpeakerBase : public I2SAudioOut, public speaker::Speaker, public
   /// @brief Called in loop() when the task has stopped. Override for mode-specific cleanup.
   virtual void on_task_stopped() {}
 
-  /// @brief Rebuilds the lockstep queues in place: disables the channel, credits every in-flight real frame as
-  /// played now, empties both queues, preloads silence through ``preload`` and re-enables the channel. Speaker
-  /// task only.
-  /// @param extra_frames Real frames the caller consumed that never reached a write record
-  /// @param preload Callable returning true once every DMA descriptor holds silence with a matching record
-  /// @return false if the preload or the channel enable failed; the caller should restart the task
-  template<typename F> bool resync_lockstep_(uint32_t extra_frames, F &&preload) {
-    this->drain_lockstep_(extra_frames);
-    return preload() && (i2s_channel_enable(this->tx_handle_) == ESP_OK);
-  }
-
-  /// @brief Disables the channel, credits ``extra_frames`` plus every real frame still recorded as in flight,
-  /// and empties both lockstep queues.
-  void drain_lockstep_(uint32_t extra_frames);
-
-  /// @brief Apply software volume control by running the samples through the gain ramp. Called from the
-  /// speaker task only.
+  /// @brief Apply software volume control using Q15 fixed-point scaling.
   /// @param data Pointer to audio sample data (modified in place)
   /// @param bytes_read Number of bytes of audio data
   void apply_software_volume_(uint8_t *data, size_t bytes_read);
@@ -175,9 +155,7 @@ class I2SAudioSpeakerBase : public I2SAudioOut, public speaker::Speaker, public
 
   bool pause_state_{false};
 
-  // Smooths software gain changes. The main loop posts targets, the speaker task processes;
-  // GainRamp's mailbox makes that safe. The main loop is the only poster.
-  esp_audio_libs::gain::GainRamp gain_ramp_;
+  int32_t q31_volume_factor_{INT32_MAX};
 
   audio::AudioStreamInfo current_stream_info_;  // Format of the audio in the ring buffer (the I2S input)
   // Format actually clocked out of the I2S peripheral. Same channel count and sample rate as

esphome/components/i2s_audio/speaker/i2s_audio_speaker_standard.cpp

@@ -134,29 +134,27 @@ void I2SAudioSpeaker::run_speaker_task() {
     }
   }
 
-  // Preload every DMA descriptor with silence and push a matching zero-real-frames record per buffer, so every
-  // on_sent event has a write record from the start. Runs with the channel disabled: at startup and after a resync.
-  auto preload_silence = [&]() -> bool {
+  if (successful_setup) {
+    // Preload every DMA descriptor with silence and push a matching zero-real-frames record per buffer.
+    // This guarantees that every on_sent event has a corresponding write record from the start, so
+    // ``i2s_event_queue_`` and ``write_records_queue_`` stay in lockstep for the entire task lifetime.
     for (size_t i = 0; i < DMA_BUFFERS_COUNT; i++) {
       size_t bytes_loaded = 0;
       esp_err_t err = i2s_channel_preload_data(this->tx_handle_, silence_buffer, dma_buffer_bytes, &bytes_loaded);
       if (err != ESP_OK || bytes_loaded != dma_buffer_bytes) {
         ESP_LOGV(TAG, "Failed to preload silence into DMA buffer %u (err=%d, loaded=%u)", (unsigned) i, (int) err,
                  (unsigned) bytes_loaded);
-        return false;
+        successful_setup = false;
+        break;
       }
       uint32_t zero_real_frames = 0;
       if (xQueueSend(this->write_records_queue_, &zero_real_frames, 0) != pdTRUE) {
         // Should never happen: the queue was just reset and is sized for DMA_BUFFERS_COUNT * 2 entries.
         ESP_LOGV(TAG, "Failed to push preload write record");
-        return false;
+        successful_setup = false;
+        break;
       }
     }
-    return true;
-  };
-
-  if (successful_setup) {
-    successful_setup = preload_silence();
   }
 
   if (successful_setup) {
@@ -179,9 +177,6 @@ void I2SAudioSpeaker::run_speaker_task() {
     // stop to wait until every real-audio buffer has been confirmed played by an ISR event.
     uint32_t pending_real_buffers = 0;
     uint32_t last_data_received_time = millis();
-    bool resync_needed = false;
-    // Real frames consumed from the ring buffer that never reached a write record
-    uint32_t unrecorded_frames = 0;
 
     xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::TASK_RUNNING);
 
@@ -202,6 +197,8 @@ void I2SAudioSpeaker::run_speaker_task() {
       uint32_t event_group_bits = xEventGroupGetBits(this->event_group_);
 
       if (event_group_bits & SpeakerEventGroupBits::COMMAND_STOP) {
+        // COMMAND_STOP is set both by user-initiated stop() and by the ISR when it drops a completion
+        // event (paired with ERR_DROPPED_EVENT so loop() can distinguish the two cases).
         xEventGroupClearBits(this->event_group_, SpeakerEventGroupBits::COMMAND_STOP);
         ESP_LOGV(TAG, "Exiting: COMMAND_STOP received");
         break;
@@ -217,22 +214,6 @@ void I2SAudioSpeaker::run_speaker_task() {
         break;
       }
 
-      if (event_group_bits & SpeakerEventGroupBits::ERR_DROPPED_EVENT) {
-        ESP_LOGE(TAG, "ISR event queue overflow, resyncing DMA lockstep");
-        resync_needed = true;
-      }
-      if (resync_needed) {
-        // Rebuild the lockstep in place; the ring buffer keeps accepting audio throughout
-        const bool resynced = this->resync_lockstep_(unrecorded_frames, preload_silence);
-        unrecorded_frames = 0;
-        pending_real_buffers = 0;
-        resync_needed = false;
-        if (!resynced) {
-          ESP_LOGE(TAG, "DMA lockstep resync failed, restarting speaker task");
-          break;
-        }
-      }
-
       // Drain ISR-stamped completion events. Each event corresponds 1:1 with a write_records_queue_
       // entry by construction (preloaded records at startup, plus exactly one record pushed per
       // iteration alongside exactly one DMA-buffer-sized write).
@@ -242,7 +223,8 @@ void I2SAudioSpeaker::run_speaker_task() {
         uint32_t real_frames = 0;
         if (xQueueReceive(this->write_records_queue_, &real_frames, 0) != pdTRUE) {
           // Should never happen: would indicate the lockstep invariant is broken.
-          ESP_LOGE(TAG, "Event without matching write record, resyncing DMA lockstep");
+          ESP_LOGV(TAG, "Event without matching write record");
+          xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_LOCKSTEP_DESYNC);
           lockstep_broken = true;
           break;
         }
@@ -258,8 +240,7 @@ void I2SAudioSpeaker::run_speaker_task() {
         }
       }
       if (lockstep_broken) {
-        resync_needed = true;
-        continue;
+        break;
       }
 
       // Graceful stop: exit only after the source's exposed chunk is drained, the underlying ring
@@ -318,12 +299,10 @@ void I2SAudioSpeaker::run_speaker_task() {
           size_t bw = 0;
           i2s_channel_write(this->tx_handle_, chunk, output_bytes, &bw, WRITE_TIMEOUT_TICKS);
           if (bw != output_bytes) {
-            // A short write breaks DMA descriptor alignment for every subsequent event. Drop the chunk rather
-            // than retry it: it was already narrowed in place.
-            ESP_LOGE(TAG, "Partial DMA write (%u of %u bytes), resyncing DMA lockstep", (unsigned) bw,
-                     (unsigned) output_bytes);
-            audio_source->consume(input_bytes);
-            real_frames_total += frames_to_write;
+            // A short real-audio write breaks DMA descriptor alignment for every subsequent event;
+            // the only safe recovery is to restart the task.
+            ESP_LOGV(TAG, "Partial real audio write: %u of %u bytes", (unsigned) bw, (unsigned) output_bytes);
+            xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_PARTIAL_WRITE);
             partial_write_failure = true;
             break;
           }
@@ -337,9 +316,7 @@ void I2SAudioSpeaker::run_speaker_task() {
       }
 
       if (partial_write_failure) {
-        unrecorded_frames += real_frames_total;
-        resync_needed = true;
-        continue;
+        break;
       }
 
       const size_t silence_bytes = dma_buffer_bytes - bytes_written_total;
@@ -348,22 +325,19 @@ void I2SAudioSpeaker::run_speaker_task() {
         i2s_channel_write(this->tx_handle_, silence_buffer, silence_bytes, &bw, WRITE_TIMEOUT_TICKS);
         if (bw != silence_bytes) {
           // Same descriptor-alignment hazard as a partial real-audio write.
-          ESP_LOGE(TAG, "Partial DMA write (%u of %u bytes), resyncing DMA lockstep", (unsigned) bw,
-                   (unsigned) silence_bytes);
-          unrecorded_frames += real_frames_total;
-          resync_needed = true;
-          continue;
+          ESP_LOGV(TAG, "Partial silence write: %u of %u bytes", (unsigned) bw, (unsigned) silence_bytes);
+          xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_PARTIAL_WRITE);
+          break;
         }
       }
 
       // Push the matching write record. Capacity headroom in I2S_EVENT_QUEUE_COUNT guarantees this
       // succeeds even with a transient backlog of unprocessed events; if it ever fails the lockstep
-      // invariant is broken and every subsequent timestamp would be silently wrong, so rebuild it.
+      // invariant is broken and every subsequent timestamp would be silently wrong, so bail.
       if (xQueueSend(this->write_records_queue_, &real_frames_total, 0) != pdTRUE) {
-        ESP_LOGE(TAG, "Write records queue full, resyncing DMA lockstep");
-        unrecorded_frames += real_frames_total;
-        resync_needed = true;
-        continue;
+        ESP_LOGV(TAG, "Exiting: write records queue full");
+        xEventGroupSetBits(this->event_group_, SpeakerEventGroupBits::ERR_LOCKSTEP_DESYNC);
+        break;
       }
       if (real_frames_total > 0) {
         pending_real_buffers++;

esphome/components/icnt86/__init__.py

@@ -1 +0,0 @@
-CODEOWNERS = ["@danepowell"]

esphome/components/icnt86/icnt86.cpp

@@ -1,84 +0,0 @@
-#include "icnt86.h"
-#include "esphome/core/log.h"
-
-namespace esphome::icnt86 {
-
-static const char *const TAG = "icnt86";
-static constexpr uint16_t REG_TOUCH_NUM = 0x1001;
-static constexpr uint16_t REG_POINT1 = 0x1002;
-static constexpr uint8_t MAX_TOUCHES = 5;
-static constexpr uint8_t POINT_SIZE = 7;
-
-void ICNT86Touchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up icnt86 Touchscreen...");
-
-  // Register interrupt pin
-  if (this->interrupt_pin_ != nullptr) {
-    this->interrupt_pin_->setup();
-    this->attach_interrupt_(this->interrupt_pin_, gpio::INTERRUPT_FALLING_EDGE);
-  }
-
-  // Perform reset if necessary
-  if (this->reset_pin_ != nullptr) {
-    this->reset_pin_->setup();
-    this->reset_pin_->digital_write(false);
-    delay(10);
-    this->reset_pin_->digital_write(true);
-  }
-
-  if (this->x_raw_max_ == this->x_raw_min_) {
-    this->x_raw_max_ = this->display_->get_native_width();
-  }
-  if (this->y_raw_max_ == this->y_raw_min_) {
-    this->y_raw_max_ = this->display_->get_native_height();
-  }
-}
-
-void ICNT86Touchscreen::update_touches() {
-  uint8_t buf[MAX_TOUCHES * POINT_SIZE] = {0};
-  uint8_t mask[1] = {0x00};
-
-  if (this->read_register16(REG_TOUCH_NUM, buf, 1) != i2c::ERROR_OK) {
-    this->status_set_warning();
-    this->skip_update_ = true;
-    ESP_LOGW(TAG, "Failed to read touch count");
-    return;
-  }
-  uint8_t touch_count = buf[0];
-
-  if (touch_count == 0x00 || touch_count > MAX_TOUCHES) {  // No new touch
-    this->status_clear_warning();
-    return;
-  }
-  if (this->read_register16(REG_POINT1, buf, touch_count * POINT_SIZE) != i2c::ERROR_OK) {
-    this->status_set_warning();
-    this->skip_update_ = true;
-    ESP_LOGW(TAG, "Failed to read touch points");
-    return;
-  }
-  this->write_register16(REG_TOUCH_NUM, mask, 1);
-  ESP_LOGV(TAG, "Touch count: %d", touch_count);
-  this->status_clear_warning();
-
-  for (uint8_t i = 0; i < touch_count; i++) {
-    uint16_t x = ((uint16_t) buf[2 + 7 * i] << 8) + buf[1 + 7 * i];
-    uint16_t y = ((uint16_t) buf[4 + 7 * i] << 8) + buf[3 + 7 * i];
-    uint8_t pressure = buf[5 + 7 * i];
-    uint8_t touch_id = buf[6 + 7 * i];
-
-    // A zero-pressure report just means this point is no longer touched; skipping it here leaves is_touched_
-    // false (when no other point is active) so send_touches_() reports the release as normal.
-    if (pressure != 0) {
-      this->add_raw_touch_position_(touch_id, x, y, pressure);
-    }
-  }
-}
-
-void ICNT86Touchscreen::dump_config() {
-  ESP_LOGCONFIG(TAG, "icnt86 Touchscreen:");
-  LOG_I2C_DEVICE(this);
-  LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
-  LOG_PIN("  Reset Pin: ", this->reset_pin_);
-}
-
-}  // namespace esphome::icnt86