Always use IDF SPI on ESP32

.ai/instructions.md

@@ -186,11 +186,6 @@ This document provides essential context for AI models interacting with this pro
         └── components/[component]/ # Component-specific tests
         ```
         Run them using `script/test_build_components`. Use `-c <component>` to test specific components and `-t <target>` for specific platforms.
-    *   **Testing All Components Together:** To verify that all components can be tested together without ID conflicts or configuration issues, use:
-        ```bash
-        ./script/test_component_grouping.py -e config --all
-        ```
-        This tests all components in a single build to catch conflicts that might not appear when testing components individually. Use `-e config` for fast configuration validation, or `-e compile` for full compilation testing.
 *   **Debugging and Troubleshooting:**
     *   **Debug Tools:**
         - `esphome config <file>.yaml` to validate configuration.

.clang-tidy.hash

@@ -1 +1 @@
-049d60eed541730efaa4c0dc5d337b4287bf29b6daa350b5dfc1f23915f1c52f
+499db61c1aa55b98b6629df603a56a1ba7aff5a9a7c781a5c1552a9dcd186c08

.github/workflows/ci-clang-tidy-hash.yml

@@ -6,7 +6,6 @@ on:
       - ".clang-tidy"
       - "platformio.ini"
       - "requirements_dev.txt"
-      - "sdkconfig.defaults"
       - ".clang-tidy.hash"
       - "script/clang_tidy_hash.py"
       - ".github/workflows/ci-clang-tidy-hash.yml"

.github/workflows/ci.yml

@@ -177,7 +177,6 @@ jobs:
       clang-tidy: ${{ steps.determine.outputs.clang-tidy }}
       python-linters: ${{ steps.determine.outputs.python-linters }}
       changed-components: ${{ steps.determine.outputs.changed-components }}
-      changed-components-with-tests: ${{ steps.determine.outputs.changed-components-with-tests }}
       component-test-count: ${{ steps.determine.outputs.component-test-count }}
     steps:
       - name: Check out code from GitHub
@@ -205,7 +204,6 @@ jobs:
           echo "clang-tidy=$(echo "$output" | jq -r '.clang_tidy')" >> $GITHUB_OUTPUT
           echo "python-linters=$(echo "$output" | jq -r '.python_linters')" >> $GITHUB_OUTPUT
           echo "changed-components=$(echo "$output" | jq -c '.changed_components')" >> $GITHUB_OUTPUT
-          echo "changed-components-with-tests=$(echo "$output" | jq -c '.changed_components_with_tests')" >> $GITHUB_OUTPUT
           echo "component-test-count=$(echo "$output" | jq -r '.component_test_count')" >> $GITHUB_OUTPUT
 
   integration-tests:
@@ -369,13 +367,12 @@ jobs:
       fail-fast: false
       max-parallel: 2
       matrix:
-        file: ${{ fromJson(needs.determine-jobs.outputs.changed-components-with-tests) }}
+        file: ${{ fromJson(needs.determine-jobs.outputs.changed-components) }}
     steps:
-      - name: Cache apt packages
-        uses: awalsh128/cache-apt-pkgs-action@acb598e5ddbc6f68a970c5da0688d2f3a9f04d05 # v1.5.3
-        with:
-          packages: libsdl2-dev
-          version: 1.0
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install libsdl2-dev
 
       - name: Check out code from GitHub
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
@@ -384,17 +381,17 @@ jobs:
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
           cache-key: ${{ needs.common.outputs.cache-key }}
-      - name: Validate config for ${{ matrix.file }}
+      - name: test_build_components -e config -c ${{ matrix.file }}
         run: |
           . venv/bin/activate
-          python3 script/test_build_components.py -e config -c ${{ matrix.file }}
-      - name: Compile config for ${{ matrix.file }}
+          ./script/test_build_components -e config -c ${{ matrix.file }}
+      - name: test_build_components -e compile -c ${{ matrix.file }}
         run: |
           . venv/bin/activate
-          python3 script/test_build_components.py -e compile -c ${{ matrix.file }}
+          ./script/test_build_components -e compile -c ${{ matrix.file }}
 
   test-build-components-splitter:
-    name: Split components for intelligent grouping (40 weighted per batch)
+    name: Split components for testing into 20 groups maximum
     runs-on: ubuntu-24.04
     needs:
       - common
@@ -405,26 +402,14 @@ jobs:
     steps:
       - name: Check out code from GitHub
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-      - name: Restore Python
-        uses: ./.github/actions/restore-python
-        with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          cache-key: ${{ needs.common.outputs.cache-key }}
-      - name: Split components intelligently based on bus configurations
+      - name: Split components into 20 groups
         id: split
         run: |
-          . venv/bin/activate
-
-          # Use intelligent splitter that groups components with same bus configs
-          components='${{ needs.determine-jobs.outputs.changed-components-with-tests }}'
-
-          echo "Splitting components intelligently..."
-          output=$(python3 script/split_components_for_ci.py --components "$components" --batch-size 40 --output github)
-
-          echo "$output" >> $GITHUB_OUTPUT
+          components=$(echo '${{ needs.determine-jobs.outputs.changed-components }}' | jq -c '.[]' | shuf | jq -s -c '[_nwise(20) | join(" ")]')
+          echo "components=$components" >> $GITHUB_OUTPUT
 
   test-build-components-split:
-    name: Test components batch (${{ matrix.components }})
+    name: Test split components
     runs-on: ubuntu-24.04
     needs:
       - common
@@ -433,23 +418,17 @@ jobs:
     if: github.event_name == 'pull_request' && fromJSON(needs.determine-jobs.outputs.component-test-count) >= 100
     strategy:
       fail-fast: false
-      max-parallel: ${{ (github.base_ref == 'beta' || github.base_ref == 'release') && 8 || 4 }}
+      max-parallel: 4
       matrix:
         components: ${{ fromJson(needs.test-build-components-splitter.outputs.matrix) }}
     steps:
-      - name: Show disk space
-        run: |
-          echo "Available disk space:"
-          df -h
-
       - name: List components
         run: echo ${{ matrix.components }}
 
-      - name: Cache apt packages
-        uses: awalsh128/cache-apt-pkgs-action@acb598e5ddbc6f68a970c5da0688d2f3a9f04d05 # v1.5.3
-        with:
-          packages: libsdl2-dev
-          version: 1.0
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install libsdl2-dev
 
       - name: Check out code from GitHub
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
@@ -458,37 +437,20 @@ jobs:
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
           cache-key: ${{ needs.common.outputs.cache-key }}
-      - name: Validate and compile components with intelligent grouping
+      - name: Validate config
         run: |
           . venv/bin/activate
-          # Use /mnt for build files (70GB available vs ~29GB on /)
-          # Bind mount PlatformIO directory to /mnt (tools, packages, build cache all go there)
-          sudo mkdir -p /mnt/platformio
-          sudo chown $USER:$USER /mnt/platformio
-          mkdir -p ~/.platformio
-          sudo mount --bind /mnt/platformio ~/.platformio
-
-          # Bind mount test build directory to /mnt
-          sudo mkdir -p /mnt/test_build_components_build
-          sudo chown $USER:$USER /mnt/test_build_components_build
-          mkdir -p tests/test_build_components/build
-          sudo mount --bind /mnt/test_build_components_build tests/test_build_components/build
-
-          # Convert space-separated components to comma-separated for Python script
-          components_csv=$(echo "${{ matrix.components }}" | tr ' ' ',')
-
-          echo "Testing components: $components_csv"
-          echo ""
-
-          # Run config validation with grouping
-          python3 script/test_build_components.py -e config -c "$components_csv" -f
-
-          echo ""
-          echo "Config validation passed! Starting compilation..."
-          echo ""
-
-          # Run compilation with grouping
-          python3 script/test_build_components.py -e compile -c "$components_csv" -f
+          for component in ${{ matrix.components }}; do
+            ./script/test_build_components -e config -c $component
+          done
+      - name: Compile config
+        run: |
+          . venv/bin/activate
+          mkdir build_cache
+          export PLATFORMIO_BUILD_CACHE_DIR=$PWD/build_cache
+          for component in ${{ matrix.components }}; do
+            ./script/test_build_components -e compile -c $component
+          done
 
   pre-commit-ci-lite:
     name: pre-commit.ci lite

.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@f443b600d91635bebf5b0d9ebc620189c0d6fba5 # v4.30.8
+        uses: github/codeql-action/init@64d10c13136e1c5bce3e5fbde8d4906eeaafc885 # v3.30.6
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@f443b600d91635bebf5b0d9ebc620189c0d6fba5 # v4.30.8
+        uses: github/codeql-action/analyze@64d10c13136e1c5bce3e5fbde8d4906eeaafc885 # v3.30.6
         with:
           category: "/language:${{matrix.language}}"

.github/workflows/stale.yml

@@ -23,7 +23,7 @@ jobs:
         with:
           debug-only: ${{ github.ref != 'refs/heads/dev' }} # Dry-run when not run on dev branch
           remove-stale-when-updated: true
-          operations-per-run: 400
+          operations-per-run: 150
 
           # The 90 day stale policy for PRs
           # - PRs

.pre-commit-config.yaml

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

CODEOWNERS

@@ -139,7 +139,6 @@ esphome/components/ens160_base/* @latonita @vincentscode
 esphome/components/ens160_i2c/* @latonita
 esphome/components/ens160_spi/* @latonita
 esphome/components/ens210/* @itn3rd77
-esphome/components/epaper_spi/* @esphome/core
 esphome/components/es7210/* @kahrendt
 esphome/components/es7243e/* @kbx81
 esphome/components/es8156/* @kbx81
@@ -257,7 +256,6 @@ esphome/components/libretiny_pwm/* @kuba2k2
 esphome/components/light/* @esphome/core
 esphome/components/lightwaverf/* @max246
 esphome/components/lilygo_t5_47/touchscreen/* @jesserockz
-esphome/components/lm75b/* @beormund
 esphome/components/ln882x/* @lamauny
 esphome/components/lock/* @esphome/core
 esphome/components/logger/* @esphome/core
@@ -430,7 +428,6 @@ esphome/components/speaker/media_player/* @kahrendt @synesthesiam
 esphome/components/spi/* @clydebarrow @esphome/core
 esphome/components/spi_device/* @clydebarrow
 esphome/components/spi_led_strip/* @clydebarrow
-esphome/components/split_buffer/* @jesserockz
 esphome/components/sprinkler/* @kbx81
 esphome/components/sps30/* @martgras
 esphome/components/ssd1322_base/* @kbx81

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2025.11.0-dev
+PROJECT_NUMBER         = 2025.10.0-dev
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

esphome/__main__.py

@@ -268,10 +268,8 @@ def has_ip_address() -> bool:
 
 
 def has_resolvable_address() -> bool:
-    """Check if CORE.address is resolvable (via mDNS, DNS, or is an IP address)."""
-    # Any address (IP, mDNS hostname, or regular DNS hostname) is resolvable
-    # The resolve_ip_address() function in helpers.py handles all types via AsyncResolver
-    return CORE.address is not None
+    """Check if CORE.address is resolvable (via mDNS or is an IP address)."""
+    return has_mdns() or has_ip_address()
 
 
 def mqtt_get_ip(config: ConfigType, username: str, password: str, client_id: str):
@@ -580,12 +578,11 @@ def show_logs(config: ConfigType, args: ArgsProtocol, devices: list[str]) -> int
     if has_api():
         addresses_to_use: list[str] | None = None
 
-        if port_type == "NETWORK":
-            # Network addresses (IPs, mDNS names, or regular DNS hostnames) can be used
-            # The resolve_ip_address() function in helpers.py handles all types
+        if port_type == "NETWORK" and (has_mdns() or is_ip_address(port)):
             addresses_to_use = devices
-        elif port_type in ("MQTT", "MQTTIP") and has_mqtt_ip_lookup():
-            # Use MQTT IP lookup for MQTT/MQTTIP types
+        elif port_type in ("NETWORK", "MQTT", "MQTTIP") and has_mqtt_ip_lookup():
+            # Only use MQTT IP lookup if the first condition didn't match
+            # (for MQTT/MQTTIP types, or for NETWORK when mdns/ip check fails)
             addresses_to_use = mqtt_get_ip(
                 config, args.username, args.password, args.client_id
             )
@@ -1005,12 +1002,6 @@ def parse_args(argv):
         action="append",
         default=[],
     )
-    options_parser.add_argument(
-        "--testing-mode",
-        help="Enable testing mode (disables validation checks for grouped component testing)",
-        action="store_true",
-        default=False,
-    )
 
     parser = argparse.ArgumentParser(
         description=f"ESPHome {const.__version__}", parents=[options_parser]
@@ -1269,7 +1260,6 @@ def run_esphome(argv):
 
     args = parse_args(argv)
     CORE.dashboard = args.dashboard
-    CORE.testing_mode = args.testing_mode
 
     # Create address cache from command-line arguments
     CORE.address_cache = AddressCache.from_cli_args(

esphome/components/animation/animation.cpp

@@ -26,12 +26,12 @@ uint32_t Animation::get_animation_frame_count() const { return this->animation_f
 int Animation::get_current_frame() const { return this->current_frame_; }
 void Animation::next_frame() {
   this->current_frame_++;
-  if (loop_count_ && static_cast<uint32_t>(this->current_frame_) == loop_end_frame_ &&
+  if (loop_count_ && this->current_frame_ == loop_end_frame_ &&
       (this->loop_current_iteration_ < loop_count_ || loop_count_ < 0)) {
     this->current_frame_ = loop_start_frame_;
     this->loop_current_iteration_++;
   }
-  if (static_cast<uint32_t>(this->current_frame_) >= animation_frame_count_) {
+  if (this->current_frame_ >= animation_frame_count_) {
     this->loop_current_iteration_ = 1;
     this->current_frame_ = 0;
   }

esphome/components/api/__init__.py

@@ -9,7 +9,6 @@ import esphome.config_validation as cv
 from esphome.const import (
     CONF_ACTION,
     CONF_ACTIONS,
-    CONF_CAPTURE_RESPONSE,
     CONF_DATA,
     CONF_DATA_TEMPLATE,
     CONF_EVENT,
@@ -18,50 +17,30 @@ from esphome.const import (
     CONF_MAX_CONNECTIONS,
     CONF_ON_CLIENT_CONNECTED,
     CONF_ON_CLIENT_DISCONNECTED,
-    CONF_ON_ERROR,
-    CONF_ON_SUCCESS,
     CONF_PASSWORD,
     CONF_PORT,
     CONF_REBOOT_TIMEOUT,
-    CONF_RESPONSE_TEMPLATE,
     CONF_SERVICE,
     CONF_SERVICES,
     CONF_TAG,
     CONF_TRIGGER_ID,
     CONF_VARIABLES,
 )
-from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
-from esphome.cpp_generator import TemplateArgsType
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.types import ConfigType
 
 _LOGGER = logging.getLogger(__name__)
 
 DOMAIN = "api"
 DEPENDENCIES = ["network"]
+AUTO_LOAD = ["socket"]
 CODEOWNERS = ["@esphome/core"]
 
-
-def AUTO_LOAD(config: ConfigType) -> list[str]:
-    """Conditionally auto-load json only when capture_response is used."""
-    base = ["socket"]
-
-    # Check if any homeassistant.action/homeassistant.service has capture_response: true
-    # This flag is set during config validation in _validate_response_config
-    if not config or CORE.data.get(DOMAIN, {}).get(CONF_CAPTURE_RESPONSE, False):
-        return base + ["json"]
-
-    return base
-
-
 api_ns = cg.esphome_ns.namespace("api")
 APIServer = api_ns.class_("APIServer", cg.Component, cg.Controller)
 HomeAssistantServiceCallAction = api_ns.class_(
     "HomeAssistantServiceCallAction", automation.Action
 )
-ActionResponse = api_ns.class_("ActionResponse")
-HomeAssistantActionResponseTrigger = api_ns.class_(
-    "HomeAssistantActionResponseTrigger", automation.Trigger
-)
 APIConnectedCondition = api_ns.class_("APIConnectedCondition", Condition)
 
 UserServiceTrigger = api_ns.class_("UserServiceTrigger", automation.Trigger)
@@ -309,29 +288,6 @@ async def to_code(config):
 KEY_VALUE_SCHEMA = cv.Schema({cv.string: cv.templatable(cv.string_strict)})
 
 
-def _validate_response_config(config: ConfigType) -> ConfigType:
-    # Validate dependencies:
-    # - response_template requires capture_response: true
-    # - capture_response: true requires on_success
-    if CONF_RESPONSE_TEMPLATE in config and not config[CONF_CAPTURE_RESPONSE]:
-        raise cv.Invalid(
-            f"`{CONF_RESPONSE_TEMPLATE}` requires `{CONF_CAPTURE_RESPONSE}: true` to be set.",
-            path=[CONF_RESPONSE_TEMPLATE],
-        )
-
-    if config[CONF_CAPTURE_RESPONSE] and CONF_ON_SUCCESS not in config:
-        raise cv.Invalid(
-            f"`{CONF_CAPTURE_RESPONSE}: true` requires `{CONF_ON_SUCCESS}` to be set.",
-            path=[CONF_CAPTURE_RESPONSE],
-        )
-
-    # Track if any action uses capture_response for AUTO_LOAD
-    if config[CONF_CAPTURE_RESPONSE]:
-        CORE.data.setdefault(DOMAIN, {})[CONF_CAPTURE_RESPONSE] = True
-
-    return config
-
-
 HOMEASSISTANT_ACTION_ACTION_SCHEMA = cv.All(
     cv.Schema(
         {
@@ -347,15 +303,10 @@ HOMEASSISTANT_ACTION_ACTION_SCHEMA = cv.All(
             cv.Optional(CONF_VARIABLES, default={}): cv.Schema(
                 {cv.string: cv.returning_lambda}
             ),
-            cv.Optional(CONF_RESPONSE_TEMPLATE): cv.templatable(cv.string),
-            cv.Optional(CONF_CAPTURE_RESPONSE, default=False): cv.boolean,
-            cv.Optional(CONF_ON_SUCCESS): automation.validate_automation(single=True),
-            cv.Optional(CONF_ON_ERROR): automation.validate_automation(single=True),
         }
     ),
     cv.has_exactly_one_key(CONF_SERVICE, CONF_ACTION),
     cv.rename_key(CONF_SERVICE, CONF_ACTION),
-    _validate_response_config,
 )
 
 
@@ -369,12 +320,7 @@ HOMEASSISTANT_ACTION_ACTION_SCHEMA = cv.All(
     HomeAssistantServiceCallAction,
     HOMEASSISTANT_ACTION_ACTION_SCHEMA,
 )
-async def homeassistant_service_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-):
+async def homeassistant_service_to_code(config, action_id, template_arg, args):
     cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
     serv = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, serv, False)
@@ -389,40 +335,6 @@ async def homeassistant_service_to_code(
     for key, value in config[CONF_VARIABLES].items():
         templ = await cg.templatable(value, args, None)
         cg.add(var.add_variable(key, templ))
-
-    if on_error := config.get(CONF_ON_ERROR):
-        cg.add_define("USE_API_HOMEASSISTANT_ACTION_RESPONSES")
-        cg.add_define("USE_API_HOMEASSISTANT_ACTION_RESPONSES_ERRORS")
-        cg.add(var.set_wants_status())
-        await automation.build_automation(
-            var.get_error_trigger(),
-            [(cg.std_string, "error"), *args],
-            on_error,
-        )
-
-    if on_success := config.get(CONF_ON_SUCCESS):
-        cg.add_define("USE_API_HOMEASSISTANT_ACTION_RESPONSES")
-        cg.add(var.set_wants_status())
-        if config[CONF_CAPTURE_RESPONSE]:
-            cg.add(var.set_wants_response())
-            cg.add_define("USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON")
-            await automation.build_automation(
-                var.get_success_trigger_with_response(),
-                [(cg.JsonObjectConst, "response"), *args],
-                on_success,
-            )
-
-            if response_template := config.get(CONF_RESPONSE_TEMPLATE):
-                templ = await cg.templatable(response_template, args, cg.std_string)
-                cg.add(var.set_response_template(templ))
-
-        else:
-            await automation.build_automation(
-                var.get_success_trigger(),
-                args,
-                on_success,
-            )
-
     return var
 
 

esphome/components/api/api.proto

@@ -780,22 +780,6 @@ message HomeassistantActionRequest {
   repeated HomeassistantServiceMap data_template = 3;
   repeated HomeassistantServiceMap variables = 4;
   bool is_event = 5;
-  uint32 call_id = 6 [(field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES"];
-  bool wants_response = 7 [(field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
-  string response_template = 8 [(no_zero_copy) = true, (field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
-}
-
-// Message sent by Home Assistant to ESPHome with service call response data
-message HomeassistantActionResponse {
-  option (id) = 130;
-  option (source) = SOURCE_CLIENT;
-  option (no_delay) = true;
-  option (ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES";
-
-  uint32 call_id = 1; // Matches the call_id from HomeassistantActionRequest
-  bool success = 2; // Whether the service call succeeded
-  string error_message = 3; // Error message if success = false
-  bytes response_data = 4 [(pointer_to_buffer) = true, (field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
 }
 
 // ==================== IMPORT HOME ASSISTANT STATES ====================

esphome/components/api/api_connection.cpp

@@ -8,9 +8,9 @@
 #endif
 #include <cerrno>
 #include <cinttypes>
+#include <utility>
 #include <functional>
 #include <limits>
-#include <utility>
 #include "esphome/components/network/util.h"
 #include "esphome/core/application.h"
 #include "esphome/core/entity_base.h"
@@ -1549,20 +1549,6 @@ void APIConnection::execute_service(const ExecuteServiceRequest &msg) {
   }
 }
 #endif
-
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-void APIConnection::on_homeassistant_action_response(const HomeassistantActionResponse &msg) {
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  if (msg.response_data_len > 0) {
-    this->parent_->handle_action_response(msg.call_id, msg.success, msg.error_message, msg.response_data,
-                                          msg.response_data_len);
-  } else
-#endif
-  {
-    this->parent_->handle_action_response(msg.call_id, msg.success, msg.error_message);
-  }
-};
-#endif
 #ifdef USE_API_NOISE
 bool APIConnection::send_noise_encryption_set_key_response(const NoiseEncryptionSetKeyRequest &msg) {
   NoiseEncryptionSetKeyResponse resp;

esphome/components/api/api_connection.h

@@ -129,10 +129,7 @@ class APIConnection final : public APIServerConnection {
       return;
     this->send_message(call, HomeassistantActionRequest::MESSAGE_TYPE);
   }
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  void on_homeassistant_action_response(const HomeassistantActionResponse &msg) override;
-#endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
-#endif  // USE_API_HOMEASSISTANT_SERVICES
+#endif
 #ifdef USE_BLUETOOTH_PROXY
   void subscribe_bluetooth_le_advertisements(const SubscribeBluetoothLEAdvertisementsRequest &msg) override;
   void unsubscribe_bluetooth_le_advertisements(const UnsubscribeBluetoothLEAdvertisementsRequest &msg) override;

esphome/components/api/api_frame_helper.h

@@ -18,17 +18,6 @@ namespace esphome::api {
 // uncomment to log raw packets
 //#define HELPER_LOG_PACKETS
 
-// Maximum message size limits to prevent OOM on constrained devices
-// Handshake messages are limited to a small size for security
-static constexpr uint16_t MAX_HANDSHAKE_SIZE = 128;
-
-// Data message limits vary by platform based on available memory
-#ifdef USE_ESP8266
-static constexpr uint16_t MAX_MESSAGE_SIZE = 8192;  // 8 KiB for ESP8266
-#else
-static constexpr uint16_t MAX_MESSAGE_SIZE = 32768;  // 32 KiB for ESP32 and other platforms
-#endif
-
 // Forward declaration
 struct ClientInfo;
 

esphome/components/api/api_frame_helper_noise.cpp

@@ -132,16 +132,26 @@ APIError APINoiseFrameHelper::loop() {
   return APIFrameHelper::loop();
 }
 
-/** Read a packet into the rx_buf_.
+/** Read a packet into the rx_buf_. If successful, stores frame data in the frame parameter
  *
- * @return APIError::OK if a full packet is in rx_buf_
+ * @param frame: The struct to hold the frame information in.
+ *   msg_start: points to the start of the payload - this pointer is only valid until the next
+ *     try_receive_raw_ call
+ *
+ * @return 0 if a full packet is in rx_buf_
+ * @return -1 if error, check errno.
  *
  * errno EWOULDBLOCK: Packet could not be read without blocking. Try again later.
  * errno ENOMEM: Not enough memory for reading packet.
  * errno API_ERROR_BAD_INDICATOR: Bad indicator byte at start of frame.
  * errno API_ERROR_HANDSHAKE_PACKET_LEN: Packet too big for this phase.
  */
-APIError APINoiseFrameHelper::try_read_frame_() {
+APIError APINoiseFrameHelper::try_read_frame_(std::vector<uint8_t> *frame) {
+  if (frame == nullptr) {
+    HELPER_LOG("Bad argument for try_read_frame_");
+    return APIError::BAD_ARG;
+  }
+
   // read header
   if (rx_header_buf_len_ < 3) {
     // no header information yet
@@ -168,17 +178,16 @@ APIError APINoiseFrameHelper::try_read_frame_() {
   // read body
   uint16_t msg_size = (((uint16_t) rx_header_buf_[1]) << 8) | rx_header_buf_[2];
 
-  // Check against size limits to prevent OOM: MAX_HANDSHAKE_SIZE for handshake, MAX_MESSAGE_SIZE for data
-  uint16_t limit = (state_ == State::DATA) ? MAX_MESSAGE_SIZE : MAX_HANDSHAKE_SIZE;
-  if (msg_size > limit) {
+  if (state_ != State::DATA && msg_size > 128) {
+    // for handshake message only permit up to 128 bytes
     state_ = State::FAILED;
-    HELPER_LOG("Bad packet: message size %u exceeds maximum %u", msg_size, limit);
-    return (state_ == State::DATA) ? APIError::BAD_DATA_PACKET : APIError::BAD_HANDSHAKE_PACKET_LEN;
+    HELPER_LOG("Bad packet len for handshake: %d", msg_size);
+    return APIError::BAD_HANDSHAKE_PACKET_LEN;
   }
 
-  // Reserve space for body
-  if (this->rx_buf_.size() != msg_size) {
-    this->rx_buf_.resize(msg_size);
+  // reserve space for body
+  if (rx_buf_.size() != msg_size) {
+    rx_buf_.resize(msg_size);
   }
 
   if (rx_buf_len_ < msg_size) {
@@ -196,12 +205,12 @@ APIError APINoiseFrameHelper::try_read_frame_() {
     }
   }
 
-  LOG_PACKET_RECEIVED(this->rx_buf_);
-
-  // Clear state for next frame (rx_buf_ still contains data for caller)
-  this->rx_buf_len_ = 0;
-  this->rx_header_buf_len_ = 0;
-
+  LOG_PACKET_RECEIVED(rx_buf_);
+  *frame = std::move(rx_buf_);
+  // consume msg
+  rx_buf_ = {};
+  rx_buf_len_ = 0;
+  rx_header_buf_len_ = 0;
   return APIError::OK;
 }
 
@@ -223,17 +232,18 @@ APIError APINoiseFrameHelper::state_action_() {
   }
   if (state_ == State::CLIENT_HELLO) {
     // waiting for client hello
-    aerr = this->try_read_frame_();
+    std::vector<uint8_t> frame;
+    aerr = try_read_frame_(&frame);
     if (aerr != APIError::OK) {
       return handle_handshake_frame_error_(aerr);
     }
     // ignore contents, may be used in future for flags
     // Resize for: existing prologue + 2 size bytes + frame data
-    size_t old_size = this->prologue_.size();
-    this->prologue_.resize(old_size + 2 + this->rx_buf_.size());
-    this->prologue_[old_size] = (uint8_t) (this->rx_buf_.size() >> 8);
-    this->prologue_[old_size + 1] = (uint8_t) this->rx_buf_.size();
-    std::memcpy(this->prologue_.data() + old_size + 2, this->rx_buf_.data(), this->rx_buf_.size());
+    size_t old_size = prologue_.size();
+    prologue_.resize(old_size + 2 + frame.size());
+    prologue_[old_size] = (uint8_t) (frame.size() >> 8);
+    prologue_[old_size + 1] = (uint8_t) frame.size();
+    std::memcpy(prologue_.data() + old_size + 2, frame.data(), frame.size());
 
     state_ = State::SERVER_HELLO;
   }
@@ -275,23 +285,24 @@ APIError APINoiseFrameHelper::state_action_() {
     int action = noise_handshakestate_get_action(handshake_);
     if (action == NOISE_ACTION_READ_MESSAGE) {
       // waiting for handshake msg
-      aerr = this->try_read_frame_();
+      std::vector<uint8_t> frame;
+      aerr = try_read_frame_(&frame);
       if (aerr != APIError::OK) {
         return handle_handshake_frame_error_(aerr);
       }
 
-      if (this->rx_buf_.empty()) {
+      if (frame.empty()) {
         send_explicit_handshake_reject_(LOG_STR("Empty handshake message"));
         return APIError::BAD_HANDSHAKE_ERROR_BYTE;
-      } else if (this->rx_buf_[0] != 0x00) {
-        HELPER_LOG("Bad handshake error byte: %u", this->rx_buf_[0]);
+      } else if (frame[0] != 0x00) {
+        HELPER_LOG("Bad handshake error byte: %u", frame[0]);
         send_explicit_handshake_reject_(LOG_STR("Bad handshake error byte"));
         return APIError::BAD_HANDSHAKE_ERROR_BYTE;
       }
 
       NoiseBuffer mbuf;
       noise_buffer_init(mbuf);
-      noise_buffer_set_input(mbuf, this->rx_buf_.data() + 1, this->rx_buf_.size() - 1);
+      noise_buffer_set_input(mbuf, frame.data() + 1, frame.size() - 1);
       err = noise_handshakestate_read_message(handshake_, &mbuf, nullptr);
       if (err != 0) {
         // Special handling for MAC failure
@@ -368,33 +379,35 @@ void APINoiseFrameHelper::send_explicit_handshake_reject_(const LogString *reaso
   state_ = orig_state;
 }
 APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {
-  APIError aerr = this->state_action_();
+  int err;
+  APIError aerr;
+  aerr = state_action_();
   if (aerr != APIError::OK) {
     return aerr;
   }
 
-  if (this->state_ != State::DATA) {
+  if (state_ != State::DATA) {
     return APIError::WOULD_BLOCK;
   }
 
-  aerr = this->try_read_frame_();
+  std::vector<uint8_t> frame;
+  aerr = try_read_frame_(&frame);
   if (aerr != APIError::OK)
     return aerr;
 
   NoiseBuffer mbuf;
   noise_buffer_init(mbuf);
-  noise_buffer_set_inout(mbuf, this->rx_buf_.data(), this->rx_buf_.size(), this->rx_buf_.size());
-  int err = noise_cipherstate_decrypt(this->recv_cipher_, &mbuf);
+  noise_buffer_set_inout(mbuf, frame.data(), frame.size(), frame.size());
+  err = noise_cipherstate_decrypt(recv_cipher_, &mbuf);
   APIError decrypt_err =
       handle_noise_error_(err, LOG_STR("noise_cipherstate_decrypt"), APIError::CIPHERSTATE_DECRYPT_FAILED);
-  if (decrypt_err != APIError::OK) {
+  if (decrypt_err != APIError::OK)
     return decrypt_err;
-  }
 
   uint16_t msg_size = mbuf.size;
-  uint8_t *msg_data = this->rx_buf_.data();
+  uint8_t *msg_data = frame.data();
   if (msg_size < 4) {
-    this->state_ = State::FAILED;
+    state_ = State::FAILED;
     HELPER_LOG("Bad data packet: size %d too short", msg_size);
     return APIError::BAD_DATA_PACKET;
   }
@@ -402,12 +415,12 @@ APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {
   uint16_t type = (((uint16_t) msg_data[0]) << 8) | msg_data[1];
   uint16_t data_len = (((uint16_t) msg_data[2]) << 8) | msg_data[3];
   if (data_len > msg_size - 4) {
-    this->state_ = State::FAILED;
+    state_ = State::FAILED;
     HELPER_LOG("Bad data packet: data_len %u greater than msg_size %u", data_len, msg_size);
     return APIError::BAD_DATA_PACKET;
   }
 
-  buffer->container = std::move(this->rx_buf_);
+  buffer->container = std::move(frame);
   buffer->data_offset = 4;
   buffer->data_len = data_len;
   buffer->type = type;

esphome/components/api/api_frame_helper_noise.h

@@ -28,7 +28,7 @@ class APINoiseFrameHelper final : public APIFrameHelper {
 
  protected:
   APIError state_action_();
-  APIError try_read_frame_();
+  APIError try_read_frame_(std::vector<uint8_t> *frame);
   APIError write_frame_(const uint8_t *data, uint16_t len);
   APIError init_handshake_();
   APIError check_handshake_finished_();

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -47,13 +47,21 @@ APIError APIPlaintextFrameHelper::loop() {
   return APIFrameHelper::loop();
 }
 
-/** Read a packet into the rx_buf_.
+/** Read a packet into the rx_buf_. If successful, stores frame data in the frame parameter
+ *
+ * @param frame: The struct to hold the frame information in.
+ *   msg: store the parsed frame in that struct
  *
  * @return See APIError
  *
  * error API_ERROR_BAD_INDICATOR: Bad indicator byte at start of frame.
  */
-APIError APIPlaintextFrameHelper::try_read_frame_() {
+APIError APIPlaintextFrameHelper::try_read_frame_(std::vector<uint8_t> *frame) {
+  if (frame == nullptr) {
+    HELPER_LOG("Bad argument for try_read_frame_");
+    return APIError::BAD_ARG;
+  }
+
   // read header
   while (!rx_header_parsed_) {
     // Now that we know when the socket is ready, we can read up to 3 bytes
@@ -115,10 +123,10 @@ APIError APIPlaintextFrameHelper::try_read_frame_() {
       continue;
     }
 
-    if (msg_size_varint->as_uint32() > MAX_MESSAGE_SIZE) {
+    if (msg_size_varint->as_uint32() > std::numeric_limits<uint16_t>::max()) {
       state_ = State::FAILED;
       HELPER_LOG("Bad packet: message size %" PRIu32 " exceeds maximum %u", msg_size_varint->as_uint32(),
-                 MAX_MESSAGE_SIZE);
+                 std::numeric_limits<uint16_t>::max());
       return APIError::BAD_DATA_PACKET;
     }
     rx_header_parsed_len_ = msg_size_varint->as_uint16();
@@ -142,9 +150,9 @@ APIError APIPlaintextFrameHelper::try_read_frame_() {
   }
   // header reading done
 
-  // Reserve space for body
-  if (this->rx_buf_.size() != this->rx_header_parsed_len_) {
-    this->rx_buf_.resize(this->rx_header_parsed_len_);
+  // reserve space for body
+  if (rx_buf_.size() != rx_header_parsed_len_) {
+    rx_buf_.resize(rx_header_parsed_len_);
   }
 
   if (rx_buf_len_ < rx_header_parsed_len_) {
@@ -162,22 +170,24 @@ APIError APIPlaintextFrameHelper::try_read_frame_() {
     }
   }
 
-  LOG_PACKET_RECEIVED(this->rx_buf_);
-
-  // Clear state for next frame (rx_buf_ still contains data for caller)
-  this->rx_buf_len_ = 0;
-  this->rx_header_buf_pos_ = 0;
-  this->rx_header_parsed_ = false;
-
+  LOG_PACKET_RECEIVED(rx_buf_);
+  *frame = std::move(rx_buf_);
+  // consume msg
+  rx_buf_ = {};
+  rx_buf_len_ = 0;
+  rx_header_buf_pos_ = 0;
+  rx_header_parsed_ = false;
   return APIError::OK;
 }
-
 APIError APIPlaintextFrameHelper::read_packet(ReadPacketBuffer *buffer) {
-  if (this->state_ != State::DATA) {
+  APIError aerr;
+
+  if (state_ != State::DATA) {
     return APIError::WOULD_BLOCK;
   }
 
-  APIError aerr = this->try_read_frame_();
+  std::vector<uint8_t> frame;
+  aerr = try_read_frame_(&frame);
   if (aerr != APIError::OK) {
     if (aerr == APIError::BAD_INDICATOR) {
       // Make sure to tell the remote that we don't
@@ -210,10 +220,10 @@ APIError APIPlaintextFrameHelper::read_packet(ReadPacketBuffer *buffer) {
     return aerr;
   }
 
-  buffer->container = std::move(this->rx_buf_);
+  buffer->container = std::move(frame);
   buffer->data_offset = 0;
-  buffer->data_len = this->rx_header_parsed_len_;
-  buffer->type = this->rx_header_parsed_type_;
+  buffer->data_len = rx_header_parsed_len_;
+  buffer->type = rx_header_parsed_type_;
   return APIError::OK;
 }
 APIError APIPlaintextFrameHelper::write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) {

esphome/components/api/api_frame_helper_plaintext.h

@@ -24,7 +24,7 @@ class APIPlaintextFrameHelper final : public APIFrameHelper {
   APIError write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) override;
 
  protected:
-  APIError try_read_frame_();
+  APIError try_read_frame_(std::vector<uint8_t> *frame);
 
   // Group 2-byte aligned types
   uint16_t rx_header_parsed_type_ = 0;

esphome/components/api/api_pb2.cpp

@@ -884,15 +884,6 @@ void HomeassistantActionRequest::encode(ProtoWriteBuffer buffer) const {
     buffer.encode_message(4, it, true);
   }
   buffer.encode_bool(5, this->is_event);
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  buffer.encode_uint32(6, this->call_id);
-#endif
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  buffer.encode_bool(7, this->wants_response);
-#endif
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  buffer.encode_string(8, this->response_template);
-#endif
 }
 void HomeassistantActionRequest::calculate_size(ProtoSize &size) const {
   size.add_length(1, this->service_ref_.size());
@@ -900,48 +891,6 @@ void HomeassistantActionRequest::calculate_size(ProtoSize &size) const {
   size.add_repeated_message(1, this->data_template);
   size.add_repeated_message(1, this->variables);
   size.add_bool(1, this->is_event);
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  size.add_uint32(1, this->call_id);
-#endif
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  size.add_bool(1, this->wants_response);
-#endif
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  size.add_length(1, this->response_template.size());
-#endif
-}
-#endif
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-bool HomeassistantActionResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
-  switch (field_id) {
-    case 1:
-      this->call_id = value.as_uint32();
-      break;
-    case 2:
-      this->success = value.as_bool();
-      break;
-    default:
-      return false;
-  }
-  return true;
-}
-bool HomeassistantActionResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
-  switch (field_id) {
-    case 3:
-      this->error_message = value.as_string();
-      break;
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-    case 4: {
-      // Use raw data directly to avoid allocation
-      this->response_data = value.data();
-      this->response_data_len = value.size();
-      break;
-    }
-#endif
-    default:
-      return false;
-  }
-  return true;
 }
 #endif
 #ifdef USE_API_HOMEASSISTANT_STATES

esphome/components/api/api_pb2.h

@@ -1104,7 +1104,7 @@ class HomeassistantServiceMap final : public ProtoMessage {
 class HomeassistantActionRequest final : public ProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 35;
-  static constexpr uint8_t ESTIMATED_SIZE = 128;
+  static constexpr uint8_t ESTIMATED_SIZE = 113;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "homeassistant_action_request"; }
 #endif
@@ -1114,15 +1114,6 @@ class HomeassistantActionRequest final : public ProtoMessage {
   std::vector<HomeassistantServiceMap> data_template{};
   std::vector<HomeassistantServiceMap> variables{};
   bool is_event{false};
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  uint32_t call_id{0};
-#endif
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  bool wants_response{false};
-#endif
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  std::string response_template{};
-#endif
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1132,30 +1123,6 @@ class HomeassistantActionRequest final : public ProtoMessage {
  protected:
 };
 #endif
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-class HomeassistantActionResponse final : public ProtoDecodableMessage {
- public:
-  static constexpr uint8_t MESSAGE_TYPE = 130;
-  static constexpr uint8_t ESTIMATED_SIZE = 34;
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  const char *message_name() const override { return "homeassistant_action_response"; }
-#endif
-  uint32_t call_id{0};
-  bool success{false};
-  std::string error_message{};
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  const uint8_t *response_data{nullptr};
-  uint16_t response_data_len{0};
-#endif
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  void dump_to(std::string &out) const override;
-#endif
-
- protected:
-  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
-  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
-};
-#endif
 #ifdef USE_API_HOMEASSISTANT_STATES
 class SubscribeHomeAssistantStatesRequest final : public ProtoMessage {
  public:

esphome/components/api/api_pb2_dump.cpp

@@ -1122,28 +1122,6 @@ void HomeassistantActionRequest::dump_to(std::string &out) const {
     out.append("\n");
   }
   dump_field(out, "is_event", this->is_event);
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  dump_field(out, "call_id", this->call_id);
-#endif
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  dump_field(out, "wants_response", this->wants_response);
-#endif
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  dump_field(out, "response_template", this->response_template);
-#endif
-}
-#endif
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-void HomeassistantActionResponse::dump_to(std::string &out) const {
-  MessageDumpHelper helper(out, "HomeassistantActionResponse");
-  dump_field(out, "call_id", this->call_id);
-  dump_field(out, "success", this->success);
-  dump_field(out, "error_message", this->error_message);
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  out.append("  response_data: ");
-  out.append(format_hex_pretty(this->response_data, this->response_data_len));
-  out.append("\n");
-#endif
 }
 #endif
 #ifdef USE_API_HOMEASSISTANT_STATES

esphome/components/api/api_pb2_service.cpp

@@ -610,17 +610,6 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       this->on_z_wave_proxy_request(msg);
       break;
     }
-#endif
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-    case HomeassistantActionResponse::MESSAGE_TYPE: {
-      HomeassistantActionResponse msg;
-      msg.decode(msg_data, msg_size);
-#ifdef HAS_PROTO_MESSAGE_DUMP
-      ESP_LOGVV(TAG, "on_homeassistant_action_response: %s", msg.dump().c_str());
-#endif
-      this->on_homeassistant_action_response(msg);
-      break;
-    }
 #endif
     default:
       break;

esphome/components/api/api_pb2_service.h

@@ -66,9 +66,6 @@ class APIServerConnectionBase : public ProtoService {
   virtual void on_subscribe_homeassistant_services_request(const SubscribeHomeassistantServicesRequest &value){};
 #endif
 
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  virtual void on_homeassistant_action_response(const HomeassistantActionResponse &value){};
-#endif
 #ifdef USE_API_HOMEASSISTANT_STATES
   virtual void on_subscribe_home_assistant_states_request(const SubscribeHomeAssistantStatesRequest &value){};
 #endif

esphome/components/api/api_server.cpp

@@ -9,16 +9,12 @@
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
 #include "esphome/core/version.h"
-#ifdef USE_API_HOMEASSISTANT_SERVICES
-#include "homeassistant_service.h"
-#endif
 
 #ifdef USE_LOGGER
 #include "esphome/components/logger/logger.h"
 #endif
 
 #include <algorithm>
-#include <utility>
 
 namespace esphome::api {
 
@@ -404,38 +400,7 @@ void APIServer::send_homeassistant_action(const HomeassistantActionRequest &call
     client->send_homeassistant_action(call);
   }
 }
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-void APIServer::register_action_response_callback(uint32_t call_id, ActionResponseCallback callback) {
-  this->action_response_callbacks_.push_back({call_id, std::move(callback)});
-}
-
-void APIServer::handle_action_response(uint32_t call_id, bool success, const std::string &error_message) {
-  for (auto it = this->action_response_callbacks_.begin(); it != this->action_response_callbacks_.end(); ++it) {
-    if (it->call_id == call_id) {
-      auto callback = std::move(it->callback);
-      this->action_response_callbacks_.erase(it);
-      ActionResponse response(success, error_message);
-      callback(response);
-      return;
-    }
-  }
-}
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-void APIServer::handle_action_response(uint32_t call_id, bool success, const std::string &error_message,
-                                       const uint8_t *response_data, size_t response_data_len) {
-  for (auto it = this->action_response_callbacks_.begin(); it != this->action_response_callbacks_.end(); ++it) {
-    if (it->call_id == call_id) {
-      auto callback = std::move(it->callback);
-      this->action_response_callbacks_.erase(it);
-      ActionResponse response(success, error_message, response_data, response_data_len);
-      callback(response);
-      return;
-    }
-  }
-}
-#endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-#endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
-#endif  // USE_API_HOMEASSISTANT_SERVICES
+#endif
 
 #ifdef USE_API_HOMEASSISTANT_STATES
 void APIServer::subscribe_home_assistant_state(std::string entity_id, optional<std::string> attribute,

esphome/components/api/api_server.h

@@ -16,7 +16,6 @@
 #include "user_services.h"
 #endif
 
-#include <map>
 #include <vector>
 
 namespace esphome::api {
@@ -112,17 +111,7 @@ class APIServer : public Component, public Controller {
 #ifdef USE_API_HOMEASSISTANT_SERVICES
   void send_homeassistant_action(const HomeassistantActionRequest &call);
 
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  // Action response handling
-  using ActionResponseCallback = std::function<void(const class ActionResponse &)>;
-  void register_action_response_callback(uint32_t call_id, ActionResponseCallback callback);
-  void handle_action_response(uint32_t call_id, bool success, const std::string &error_message);
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  void handle_action_response(uint32_t call_id, bool success, const std::string &error_message,
-                              const uint8_t *response_data, size_t response_data_len);
-#endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-#endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
-#endif  // USE_API_HOMEASSISTANT_SERVICES
+#endif
 #ifdef USE_API_SERVICES
   void register_user_service(UserServiceDescriptor *descriptor) { this->user_services_.push_back(descriptor); }
 #endif
@@ -198,13 +187,6 @@ class APIServer : public Component, public Controller {
 #ifdef USE_API_SERVICES
   std::vector<UserServiceDescriptor *> user_services_;
 #endif
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  struct PendingActionResponse {
-    uint32_t call_id;
-    ActionResponseCallback callback;
-  };
-  std::vector<PendingActionResponse> action_response_callbacks_;
-#endif
 
   // Group smaller types together
   uint16_t port_{6053};

esphome/components/api/homeassistant_service.h

@@ -3,13 +3,8 @@
 #include "api_server.h"
 #ifdef USE_API
 #ifdef USE_API_HOMEASSISTANT_SERVICES
-#include <functional>
-#include <utility>
 #include <vector>
 #include "api_pb2.h"
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-#include "esphome/components/json/json_util.h"
-#endif
 #include "esphome/core/automation.h"
 #include "esphome/core/helpers.h"
 
@@ -49,47 +44,9 @@ template<typename... Ts> class TemplatableKeyValuePair {
   TemplatableStringValue<Ts...> value;
 };
 
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-// Represents the response data from a Home Assistant action
-class ActionResponse {
- public:
-  ActionResponse(bool success, std::string error_message = "")
-      : success_(success), error_message_(std::move(error_message)) {}
-
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  ActionResponse(bool success, std::string error_message, const uint8_t *data, size_t data_len)
-      : success_(success), error_message_(std::move(error_message)) {
-    if (data == nullptr || data_len == 0)
-      return;
-    this->json_document_ = json::parse_json(data, data_len);
-  }
-#endif
-
-  bool is_success() const { return this->success_; }
-  const std::string &get_error_message() const { return this->error_message_; }
-
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  // Get data as parsed JSON object (const version returns read-only view)
-  JsonObjectConst get_json() const { return this->json_document_.as<JsonObjectConst>(); }
-#endif
-
- protected:
-  bool success_;
-  std::string error_message_;
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  JsonDocument json_document_;
-#endif
-};
-
-// Callback type for action responses
-template<typename... Ts> using ActionResponseCallback = std::function<void(const ActionResponse &, Ts...)>;
-#endif
-
 template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts...> {
  public:
-  explicit HomeAssistantServiceCallAction(APIServer *parent, bool is_event) : parent_(parent) {
-    this->flags_.is_event = is_event;
-  }
+  explicit HomeAssistantServiceCallAction(APIServer *parent, bool is_event) : parent_(parent), is_event_(is_event) {}
 
   template<typename T> void set_service(T service) { this->service_ = service; }
 
@@ -104,29 +61,11 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
     this->variables_.emplace_back(std::move(key), value);
   }
 
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  template<typename T> void set_response_template(T response_template) {
-    this->response_template_ = response_template;
-    this->flags_.has_response_template = true;
-  }
-
-  void set_wants_status() { this->flags_.wants_status = true; }
-  void set_wants_response() { this->flags_.wants_response = true; }
-
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  Trigger<JsonObjectConst, Ts...> *get_success_trigger_with_response() const {
-    return this->success_trigger_with_response_;
-  }
-#endif
-  Trigger<Ts...> *get_success_trigger() const { return this->success_trigger_; }
-  Trigger<std::string, Ts...> *get_error_trigger() const { return this->error_trigger_; }
-#endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
-
   void play(Ts... x) override {
     HomeassistantActionRequest resp;
     std::string service_value = this->service_.value(x...);
     resp.set_service(StringRef(service_value));
-    resp.is_event = this->flags_.is_event;
+    resp.is_event = this->is_event_;
     for (auto &it : this->data_) {
       resp.data.emplace_back();
       auto &kv = resp.data.back();
@@ -145,74 +84,18 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
       kv.set_key(StringRef(it.key));
       kv.value = it.value.value(x...);
     }
-
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-    if (this->flags_.wants_status) {
-      // Generate a unique call ID for this service call
-      static uint32_t call_id_counter = 1;
-      uint32_t call_id = call_id_counter++;
-      resp.call_id = call_id;
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-      if (this->flags_.wants_response) {
-        resp.wants_response = true;
-        // Set response template if provided
-        if (this->flags_.has_response_template) {
-          std::string response_template_value = this->response_template_.value(x...);
-          resp.response_template = response_template_value;
-        }
-      }
-#endif
-
-      auto captured_args = std::make_tuple(x...);
-      this->parent_->register_action_response_callback(call_id, [this, captured_args](const ActionResponse &response) {
-        std::apply(
-            [this, &response](auto &&...args) {
-              if (response.is_success()) {
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-                if (this->flags_.wants_response) {
-                  this->success_trigger_with_response_->trigger(response.get_json(), args...);
-                } else
-#endif
-                {
-                  this->success_trigger_->trigger(args...);
-                }
-              } else {
-                this->error_trigger_->trigger(response.get_error_message(), args...);
-              }
-            },
-            captured_args);
-      });
-    }
-#endif
-
     this->parent_->send_homeassistant_action(resp);
   }
 
  protected:
   APIServer *parent_;
+  bool is_event_;
   TemplatableStringValue<Ts...> service_{};
   std::vector<TemplatableKeyValuePair<Ts...>> data_;
   std::vector<TemplatableKeyValuePair<Ts...>> data_template_;
   std::vector<TemplatableKeyValuePair<Ts...>> variables_;
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  TemplatableStringValue<Ts...> response_template_{""};
-  Trigger<JsonObjectConst, Ts...> *success_trigger_with_response_ = new Trigger<JsonObjectConst, Ts...>();
-#endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  Trigger<Ts...> *success_trigger_ = new Trigger<Ts...>();
-  Trigger<std::string, Ts...> *error_trigger_ = new Trigger<std::string, Ts...>();
-#endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
-
-  struct Flags {
-    uint8_t is_event : 1;
-    uint8_t wants_status : 1;
-    uint8_t wants_response : 1;
-    uint8_t has_response_template : 1;
-    uint8_t reserved : 5;
-  } flags_{0};
 };
 
 }  // namespace esphome::api
-
 #endif
 #endif

esphome/components/api/user_services.h

@@ -35,7 +35,7 @@ template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
     msg.set_name(StringRef(this->name_));
     msg.key = this->key_;
     std::array<enums::ServiceArgType, sizeof...(Ts)> arg_types = {to_service_arg_type<Ts>()...};
-    for (size_t i = 0; i < sizeof...(Ts); i++) {
+    for (int i = 0; i < sizeof...(Ts); i++) {
       msg.args.emplace_back();
       auto &arg = msg.args.back();
       arg.type = arg_types[i];

esphome/components/audio/__init__.py

@@ -165,4 +165,4 @@ def final_validate_audio_schema(
 
 
 async def to_code(config):
-    cg.add_library("esphome/esp-audio-libs", "2.0.1")
+    cg.add_library("esphome/esp-audio-libs", "1.1.4")

esphome/components/audio/audio.cpp

@@ -57,7 +57,7 @@ const char *audio_file_type_to_string(AudioFileType file_type) {
 void scale_audio_samples(const int16_t *audio_samples, int16_t *output_buffer, int16_t scale_factor,
                          size_t samples_to_scale) {
   // Note the assembly dsps_mulc function has audio glitches if the input and output buffers are the same.
-  for (size_t i = 0; i < samples_to_scale; i++) {
+  for (int i = 0; i < samples_to_scale; i++) {
     int32_t acc = (int32_t) audio_samples[i] * (int32_t) scale_factor;
     output_buffer[i] = (int16_t) (acc >> 15);
   }

esphome/components/audio/audio_decoder.cpp

@@ -229,18 +229,18 @@ FileDecoderState AudioDecoder::decode_flac_() {
     auto result = this->flac_decoder_->read_header(this->input_transfer_buffer_->get_buffer_start(),
                                                    this->input_transfer_buffer_->available());
 
-    if (result > esp_audio_libs::flac::FLAC_DECODER_HEADER_OUT_OF_DATA) {
-      // Serrious error reading FLAC header, there is no recovery
+    if (result == esp_audio_libs::flac::FLAC_DECODER_HEADER_OUT_OF_DATA) {
+      return FileDecoderState::POTENTIALLY_FAILED;
+    }
+
+    if (result != esp_audio_libs::flac::FLAC_DECODER_SUCCESS) {
+      // Couldn't read FLAC header
       return FileDecoderState::FAILED;
     }
 
     size_t bytes_consumed = this->flac_decoder_->get_bytes_index();
     this->input_transfer_buffer_->decrease_buffer_length(bytes_consumed);
 
-    if (result == esp_audio_libs::flac::FLAC_DECODER_HEADER_OUT_OF_DATA) {
-      return FileDecoderState::MORE_TO_PROCESS;
-    }
-
     // Reallocate the output transfer buffer to the smallest necessary size
     this->free_buffer_required_ = flac_decoder_->get_output_buffer_size_bytes();
     if (!this->output_transfer_buffer_->reallocate(this->free_buffer_required_)) {
@@ -256,9 +256,9 @@ FileDecoderState AudioDecoder::decode_flac_() {
   }
 
   uint32_t output_samples = 0;
-  auto result = this->flac_decoder_->decode_frame(this->input_transfer_buffer_->get_buffer_start(),
-                                                  this->input_transfer_buffer_->available(),
-                                                  this->output_transfer_buffer_->get_buffer_end(), &output_samples);
+  auto result = this->flac_decoder_->decode_frame(
+      this->input_transfer_buffer_->get_buffer_start(), this->input_transfer_buffer_->available(),
+      reinterpret_cast<int16_t *>(this->output_transfer_buffer_->get_buffer_end()), &output_samples);
 
   if (result == esp_audio_libs::flac::FLAC_DECODER_ERROR_OUT_OF_DATA) {
     // Not an issue, just needs more data that we'll get next time.

esphome/components/bl0906/bl0906.cpp

@@ -97,10 +97,10 @@ void BL0906::handle_actions_() {
     return;
   }
   ActionCallbackFuncPtr ptr_func = nullptr;
-  for (size_t i = 0; i < this->action_queue_.size(); i++) {
+  for (int i = 0; i < this->action_queue_.size(); i++) {
     ptr_func = this->action_queue_[i];
     if (ptr_func) {
-      ESP_LOGI(TAG, "HandleActionCallback[%zu]", i);
+      ESP_LOGI(TAG, "HandleActionCallback[%d]", i);
       (this->*ptr_func)();
     }
   }

esphome/components/bl0942/bl0942.cpp

@@ -51,7 +51,7 @@ void BL0942::loop() {
   if (!avail) {
     return;
   }
-  if (static_cast<size_t>(avail) < sizeof(buffer)) {
+  if (avail < sizeof(buffer)) {
     if (!this->rx_start_) {
       this->rx_start_ = millis();
     } else if (millis() > this->rx_start_ + PKT_TIMEOUT_MS) {
@@ -148,7 +148,7 @@ void BL0942::setup() {
 
   this->write_reg_(BL0942_REG_USR_WRPROT, 0);
 
-  if (static_cast<uint32_t>(this->read_reg_(BL0942_REG_MODE)) != mode)
+  if (this->read_reg_(BL0942_REG_MODE) != mode)
     this->status_set_warning(LOG_STR("BL0942 setup failed!"));
 
   this->flush();

esphome/components/canbus/canbus.h

@@ -105,9 +105,9 @@ class Canbus : public Component {
   CallbackManager<void(uint32_t can_id, bool extended_id, bool rtr, const std::vector<uint8_t> &data)>
       callback_manager_{};
 
-  virtual bool setup_internal() = 0;
-  virtual Error send_message(struct CanFrame *frame) = 0;
-  virtual Error read_message(struct CanFrame *frame) = 0;
+  virtual bool setup_internal();
+  virtual Error send_message(struct CanFrame *frame);
+  virtual Error read_message(struct CanFrame *frame);
 };
 
 template<typename... Ts> class CanbusSendAction : public Action<Ts...>, public Parented<Canbus> {

esphome/components/cm1106/cm1106.cpp

@@ -13,7 +13,7 @@ static const uint8_t C_M1106_CMD_SET_CO2_CALIB_RESPONSE[4] = {0x16, 0x01, 0x03,
 
 uint8_t cm1106_checksum(const uint8_t *response, size_t len) {
   uint8_t crc = 0;
-  for (size_t i = 0; i < len - 1; i++) {
+  for (int i = 0; i < len - 1; i++) {
     crc -= response[i];
   }
   return crc;

esphome/components/daikin_arc/daikin_arc.cpp

@@ -26,7 +26,7 @@ void DaikinArcClimate::transmit_query_() {
   uint8_t remote_header[8] = {0x11, 0xDA, 0x27, 0x00, 0x84, 0x87, 0x20, 0x00};
 
   // Calculate checksum
-  for (size_t i = 0; i < sizeof(remote_header) - 1; i++) {
+  for (int i = 0; i < sizeof(remote_header) - 1; i++) {
     remote_header[sizeof(remote_header) - 1] += remote_header[i];
   }
 
@@ -102,7 +102,7 @@ void DaikinArcClimate::transmit_state() {
   remote_state[9] = fan_speed & 0xff;
 
   // Calculate checksum
-  for (size_t i = 0; i < sizeof(remote_header) - 1; i++) {
+  for (int i = 0; i < sizeof(remote_header) - 1; i++) {
     remote_header[sizeof(remote_header) - 1] += remote_header[i];
   }
 
@@ -350,7 +350,7 @@ bool DaikinArcClimate::on_receive(remote_base::RemoteReceiveData data) {
   bool valid_daikin_frame = false;
   if (data.expect_item(DAIKIN_HEADER_MARK, DAIKIN_HEADER_SPACE)) {
     valid_daikin_frame = true;
-    size_t bytes_count = data.size() / 2 / 8;
+    int bytes_count = data.size() / 2 / 8;
     std::unique_ptr<char[]> buf(new char[bytes_count * 3 + 1]);
     buf[0] = '\0';
     for (size_t i = 0; i < bytes_count; i++) {
@@ -370,7 +370,7 @@ bool DaikinArcClimate::on_receive(remote_base::RemoteReceiveData data) {
   if (!valid_daikin_frame) {
     char sbuf[16 * 10 + 1];
     sbuf[0] = '\0';
-    for (size_t j = 0; j < static_cast<size_t>(data.size()); j++) {
+    for (size_t j = 0; j < data.size(); j++) {
       if ((j - 2) % 16 == 0) {
         if (j > 0) {
           ESP_LOGD(TAG, "DATA %04x: %s", (j - 16 > 0xffff ? 0 : j - 16), sbuf);
@@ -380,26 +380,19 @@ bool DaikinArcClimate::on_receive(remote_base::RemoteReceiveData data) {
       char type_ch = ' ';
       // debug_tolerance = 25%
 
-      if (static_cast<int32_t>(DAIKIN_DBG_LOWER(DAIKIN_ARC_PRE_MARK)) <= data[j] &&
-          data[j] <= static_cast<int32_t>(DAIKIN_DBG_UPPER(DAIKIN_ARC_PRE_MARK)))
+      if (DAIKIN_DBG_LOWER(DAIKIN_ARC_PRE_MARK) <= data[j] && data[j] <= DAIKIN_DBG_UPPER(DAIKIN_ARC_PRE_MARK))
         type_ch = 'P';
-      if (static_cast<int32_t>(DAIKIN_DBG_LOWER(DAIKIN_ARC_PRE_SPACE)) <= -data[j] &&
-          -data[j] <= static_cast<int32_t>(DAIKIN_DBG_UPPER(DAIKIN_ARC_PRE_SPACE)))
+      if (DAIKIN_DBG_LOWER(DAIKIN_ARC_PRE_SPACE) <= -data[j] && -data[j] <= DAIKIN_DBG_UPPER(DAIKIN_ARC_PRE_SPACE))
         type_ch = 'a';
-      if (static_cast<int32_t>(DAIKIN_DBG_LOWER(DAIKIN_HEADER_MARK)) <= data[j] &&
-          data[j] <= static_cast<int32_t>(DAIKIN_DBG_UPPER(DAIKIN_HEADER_MARK)))
+      if (DAIKIN_DBG_LOWER(DAIKIN_HEADER_MARK) <= data[j] && data[j] <= DAIKIN_DBG_UPPER(DAIKIN_HEADER_MARK))
         type_ch = 'H';
-      if (static_cast<int32_t>(DAIKIN_DBG_LOWER(DAIKIN_HEADER_SPACE)) <= -data[j] &&
-          -data[j] <= static_cast<int32_t>(DAIKIN_DBG_UPPER(DAIKIN_HEADER_SPACE)))
+      if (DAIKIN_DBG_LOWER(DAIKIN_HEADER_SPACE) <= -data[j] && -data[j] <= DAIKIN_DBG_UPPER(DAIKIN_HEADER_SPACE))
         type_ch = 'h';
-      if (static_cast<int32_t>(DAIKIN_DBG_LOWER(DAIKIN_BIT_MARK)) <= data[j] &&
-          data[j] <= static_cast<int32_t>(DAIKIN_DBG_UPPER(DAIKIN_BIT_MARK)))
+      if (DAIKIN_DBG_LOWER(DAIKIN_BIT_MARK) <= data[j] && data[j] <= DAIKIN_DBG_UPPER(DAIKIN_BIT_MARK))
         type_ch = 'B';
-      if (static_cast<int32_t>(DAIKIN_DBG_LOWER(DAIKIN_ONE_SPACE)) <= -data[j] &&
-          -data[j] <= static_cast<int32_t>(DAIKIN_DBG_UPPER(DAIKIN_ONE_SPACE)))
+      if (DAIKIN_DBG_LOWER(DAIKIN_ONE_SPACE) <= -data[j] && -data[j] <= DAIKIN_DBG_UPPER(DAIKIN_ONE_SPACE))
         type_ch = '1';
-      if (static_cast<int32_t>(DAIKIN_DBG_LOWER(DAIKIN_ZERO_SPACE)) <= -data[j] &&
-          -data[j] <= static_cast<int32_t>(DAIKIN_DBG_UPPER(DAIKIN_ZERO_SPACE)))
+      if (DAIKIN_DBG_LOWER(DAIKIN_ZERO_SPACE) <= -data[j] && -data[j] <= DAIKIN_DBG_UPPER(DAIKIN_ZERO_SPACE))
         type_ch = '0';
 
       if (abs(data[j]) > 100000) {
@@ -407,7 +400,7 @@ bool DaikinArcClimate::on_receive(remote_base::RemoteReceiveData data) {
       } else {
         sprintf(sbuf, "%s%-5d[%c] ", sbuf, (int) (round(data[j] / 10.) * 10), type_ch);
       }
-      if (j + 1 == static_cast<size_t>(data.size())) {
+      if (j == data.size() - 1) {
         ESP_LOGD(TAG, "DATA %04x: %s", (j - 8 > 0xffff ? 0 : j - 8), sbuf);
       }
     }

esphome/components/dashboard_import/dashboard_import.cpp

@@ -5,7 +5,7 @@ namespace dashboard_import {
 
 static std::string g_package_import_url;  // NOLINT
 
-const std::string &get_package_import_url() { return g_package_import_url; }
+std::string get_package_import_url() { return g_package_import_url; }
 void set_package_import_url(std::string url) { g_package_import_url = std::move(url); }
 
 }  // namespace dashboard_import

esphome/components/dashboard_import/dashboard_import.h

@@ -5,7 +5,7 @@
 namespace esphome {
 namespace dashboard_import {
 
-const std::string &get_package_import_url();
+std::string get_package_import_url();
 void set_package_import_url(std::string url);
 
 }  // namespace dashboard_import

esphome/components/epaper_spi/__init__.py

@@ -1 +0,0 @@
-CODEOWNERS = ["@esphome/core"]

esphome/components/epaper_spi/display.py

@@ -1,80 +0,0 @@
-from esphome import core, pins
-import esphome.codegen as cg
-from esphome.components import display, spi
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_BUSY_PIN,
-    CONF_DC_PIN,
-    CONF_ID,
-    CONF_LAMBDA,
-    CONF_MODEL,
-    CONF_PAGES,
-    CONF_RESET_DURATION,
-    CONF_RESET_PIN,
-)
-
-AUTO_LOAD = ["split_buffer"]
-DEPENDENCIES = ["spi"]
-
-epaper_spi_ns = cg.esphome_ns.namespace("epaper_spi")
-EPaperBase = epaper_spi_ns.class_(
-    "EPaperBase", cg.PollingComponent, spi.SPIDevice, display.DisplayBuffer
-)
-
-EPaperSpectraE6 = epaper_spi_ns.class_("EPaperSpectraE6", EPaperBase)
-EPaper7p3InSpectraE6 = epaper_spi_ns.class_("EPaper7p3InSpectraE6", EPaperSpectraE6)
-
-MODELS = {
-    "7.3in-spectra-e6": EPaper7p3InSpectraE6,
-}
-
-
-CONFIG_SCHEMA = cv.All(
-    display.FULL_DISPLAY_SCHEMA.extend(
-        {
-            cv.GenerateID(): cv.declare_id(EPaperBase),
-            cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
-            cv.Required(CONF_MODEL): cv.one_of(*MODELS, lower=True, space="-"),
-            cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
-            cv.Optional(CONF_BUSY_PIN): pins.gpio_input_pin_schema,
-            cv.Optional(CONF_RESET_DURATION): cv.All(
-                cv.positive_time_period_milliseconds,
-                cv.Range(max=core.TimePeriod(milliseconds=500)),
-            ),
-        }
-    )
-    .extend(cv.polling_component_schema("60s"))
-    .extend(spi.spi_device_schema()),
-    cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
-)
-
-FINAL_VALIDATE_SCHEMA = spi.final_validate_device_schema(
-    "epaper_spi", require_miso=False, require_mosi=True
-)
-
-
-async def to_code(config):
-    model = MODELS[config[CONF_MODEL]]
-
-    rhs = model.new()
-    var = cg.Pvariable(config[CONF_ID], rhs, model)
-
-    await display.register_display(var, config)
-    await spi.register_spi_device(var, config)
-
-    dc = await cg.gpio_pin_expression(config[CONF_DC_PIN])
-    cg.add(var.set_dc_pin(dc))
-
-    if CONF_LAMBDA in config:
-        lambda_ = await cg.process_lambda(
-            config[CONF_LAMBDA], [(display.DisplayRef, "it")], return_type=cg.void
-        )
-        cg.add(var.set_writer(lambda_))
-    if CONF_RESET_PIN in config:
-        reset = await cg.gpio_pin_expression(config[CONF_RESET_PIN])
-        cg.add(var.set_reset_pin(reset))
-    if CONF_BUSY_PIN in config:
-        busy = await cg.gpio_pin_expression(config[CONF_BUSY_PIN])
-        cg.add(var.set_busy_pin(busy))
-    if CONF_RESET_DURATION in config:
-        cg.add(var.set_reset_duration(config[CONF_RESET_DURATION]))

esphome/components/epaper_spi/epaper_spi.cpp

@@ -1,227 +0,0 @@
-#include "epaper_spi.h"
-#include <cinttypes>
-#include "esphome/core/application.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome::epaper_spi {
-
-static const char *const TAG = "epaper_spi";
-
-static const LogString *epaper_state_to_string(EPaperState state) {
-  switch (state) {
-    case EPaperState::IDLE:
-      return LOG_STR("IDLE");
-    case EPaperState::UPDATE:
-      return LOG_STR("UPDATE");
-    case EPaperState::RESET:
-      return LOG_STR("RESET");
-    case EPaperState::INITIALISE:
-      return LOG_STR("INITIALISE");
-    case EPaperState::TRANSFER_DATA:
-      return LOG_STR("TRANSFER_DATA");
-    case EPaperState::POWER_ON:
-      return LOG_STR("POWER_ON");
-    case EPaperState::REFRESH_SCREEN:
-      return LOG_STR("REFRESH_SCREEN");
-    case EPaperState::POWER_OFF:
-      return LOG_STR("POWER_OFF");
-    case EPaperState::DEEP_SLEEP:
-      return LOG_STR("DEEP_SLEEP");
-    default:
-      return LOG_STR("UNKNOWN");
-  }
-}
-
-void EPaperBase::setup() {
-  if (!this->init_buffer_(this->get_buffer_length())) {
-    this->mark_failed("Failed to initialise buffer");
-    return;
-  }
-  this->setup_pins_();
-  this->spi_setup();
-}
-
-bool EPaperBase::init_buffer_(size_t buffer_length) {
-  if (!this->buffer_.init(buffer_length)) {
-    return false;
-  }
-  this->clear();
-  return true;
-}
-
-void EPaperBase::setup_pins_() {
-  this->dc_pin_->setup();  // OUTPUT
-  this->dc_pin_->digital_write(false);
-
-  if (this->reset_pin_ != nullptr) {
-    this->reset_pin_->setup();  // OUTPUT
-    this->reset_pin_->digital_write(true);
-  }
-
-  if (this->busy_pin_ != nullptr) {
-    this->busy_pin_->setup();  // INPUT
-  }
-}
-
-float EPaperBase::get_setup_priority() const { return setup_priority::PROCESSOR; }
-
-void EPaperBase::command(uint8_t value) {
-  this->start_command_();
-  this->write_byte(value);
-  this->end_command_();
-}
-
-void EPaperBase::data(uint8_t value) {
-  this->start_data_();
-  this->write_byte(value);
-  this->end_data_();
-}
-
-// write a command followed by zero or more bytes of data.
-// The command is the first byte, length is the length of data only in the second byte, followed by the data.
-// [COMMAND, LENGTH, DATA...]
-void EPaperBase::cmd_data(const uint8_t *data) {
-  const uint8_t command = data[0];
-  const uint8_t length = data[1];
-  const uint8_t *ptr = data + 2;
-
-  ESP_LOGVV(TAG, "Command: 0x%02X, Length: %d, Data: %s", command, length,
-            format_hex_pretty(ptr, length, '.', false).c_str());
-
-  this->dc_pin_->digital_write(false);
-  this->enable();
-  this->write_byte(command);
-  if (length > 0) {
-    this->dc_pin_->digital_write(true);
-    this->write_array(ptr, length);
-  }
-  this->disable();
-}
-
-bool EPaperBase::is_idle_() {
-  if (this->busy_pin_ == nullptr) {
-    return true;
-  }
-  return !this->busy_pin_->digital_read();
-}
-
-void EPaperBase::reset() {
-  if (this->reset_pin_ != nullptr) {
-    this->reset_pin_->digital_write(false);
-    this->disable_loop();
-    this->set_timeout(this->reset_duration_, [this] {
-      this->reset_pin_->digital_write(true);
-      this->set_timeout(20, [this] { this->enable_loop(); });
-    });
-  }
-}
-
-void EPaperBase::update() {
-  if (!this->state_queue_.empty()) {
-    ESP_LOGE(TAG, "Display update already in progress - %s",
-             LOG_STR_ARG(epaper_state_to_string(this->state_queue_.front())));
-    return;
-  }
-
-  this->state_queue_.push(EPaperState::UPDATE);
-  this->state_queue_.push(EPaperState::RESET);
-  this->state_queue_.push(EPaperState::INITIALISE);
-  this->state_queue_.push(EPaperState::TRANSFER_DATA);
-  this->state_queue_.push(EPaperState::POWER_ON);
-  this->state_queue_.push(EPaperState::REFRESH_SCREEN);
-  this->state_queue_.push(EPaperState::POWER_OFF);
-  this->state_queue_.push(EPaperState::DEEP_SLEEP);
-  this->state_queue_.push(EPaperState::IDLE);
-
-  this->enable_loop();
-}
-
-void EPaperBase::loop() {
-  if (this->waiting_for_idle_) {
-    if (this->is_idle_()) {
-      this->waiting_for_idle_ = false;
-    } else {
-      if (App.get_loop_component_start_time() - this->waiting_for_idle_last_print_ >= 1000) {
-        ESP_LOGV(TAG, "Waiting for idle");
-        this->waiting_for_idle_last_print_ = App.get_loop_component_start_time();
-      }
-      return;
-    }
-  }
-
-  auto state = this->state_queue_.front();
-
-  switch (state) {
-    case EPaperState::IDLE:
-      this->disable_loop();
-      break;
-    case EPaperState::UPDATE:
-      this->do_update_();  // Calls ESPHome (current page) lambda
-      break;
-    case EPaperState::RESET:
-      this->reset();
-      break;
-    case EPaperState::INITIALISE:
-      this->initialise_();
-      break;
-    case EPaperState::TRANSFER_DATA:
-      if (!this->transfer_data()) {
-        return;  // Not done yet, come back next loop
-      }
-      break;
-    case EPaperState::POWER_ON:
-      this->power_on();
-      break;
-    case EPaperState::REFRESH_SCREEN:
-      this->refresh_screen();
-      break;
-    case EPaperState::POWER_OFF:
-      this->power_off();
-      break;
-    case EPaperState::DEEP_SLEEP:
-      this->deep_sleep();
-      break;
-  }
-  this->state_queue_.pop();
-}
-
-void EPaperBase::start_command_() {
-  this->dc_pin_->digital_write(false);
-  this->enable();
-}
-
-void EPaperBase::end_command_() { this->disable(); }
-
-void EPaperBase::start_data_() {
-  this->dc_pin_->digital_write(true);
-  this->enable();
-}
-void EPaperBase::end_data_() { this->disable(); }
-
-void EPaperBase::on_safe_shutdown() { this->deep_sleep(); }
-
-void EPaperBase::initialise_() {
-  size_t index = 0;
-  const auto &sequence = this->init_sequence_;
-  const size_t sequence_size = this->init_sequence_length_;
-  while (index != sequence_size) {
-    if (sequence_size - index < 2) {
-      this->mark_failed("Malformed init sequence");
-      return;
-    }
-    const auto *ptr = sequence + index;
-    const uint8_t length = ptr[1];
-    if (sequence_size - index < length + 2) {
-      this->mark_failed("Malformed init sequence");
-      return;
-    }
-
-    this->cmd_data(ptr);
-    index += length + 2;
-  }
-
-  this->power_on();
-}
-
-}  // namespace esphome::epaper_spi

esphome/components/epaper_spi/epaper_spi.h

@@ -1,93 +0,0 @@
-#pragma once
-
-#include "esphome/components/display/display_buffer.h"
-#include "esphome/components/spi/spi.h"
-#include "esphome/components/split_buffer/split_buffer.h"
-#include "esphome/core/component.h"
-
-#include <queue>
-
-namespace esphome::epaper_spi {
-
-enum class EPaperState : uint8_t {
-  IDLE,
-  UPDATE,
-  RESET,
-  INITIALISE,
-  TRANSFER_DATA,
-  POWER_ON,
-  REFRESH_SCREEN,
-  POWER_OFF,
-  DEEP_SLEEP,
-};
-
-static const uint8_t MAX_TRANSFER_TIME = 10;  // Transfer in 10ms blocks to allow the loop to run
-
-class EPaperBase : public display::DisplayBuffer,
-                   public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,
-                                         spi::DATA_RATE_2MHZ> {
- public:
-  EPaperBase(const uint8_t *init_sequence, const size_t init_sequence_length)
-      : init_sequence_length_(init_sequence_length), init_sequence_(init_sequence) {}
-  void set_dc_pin(GPIOPin *dc_pin) { dc_pin_ = dc_pin; }
-  float get_setup_priority() const override;
-  void set_reset_pin(GPIOPin *reset) { this->reset_pin_ = reset; }
-  void set_busy_pin(GPIOPin *busy) { this->busy_pin_ = busy; }
-  void set_reset_duration(uint32_t reset_duration) { this->reset_duration_ = reset_duration; }
-
-  void command(uint8_t value);
-  void data(uint8_t value);
-  void cmd_data(const uint8_t *data);
-
-  void update() override;
-  void loop() override;
-
-  void setup() override;
-
-  void on_safe_shutdown() override;
-
- protected:
-  bool is_idle_();
-  void setup_pins_();
-  virtual void reset();
-  void initialise_();
-  bool init_buffer_(size_t buffer_length);
-
-  virtual int get_width_controller() { return this->get_width_internal(); };
-  virtual void deep_sleep() = 0;
-  /**
-   * Send data to the device via SPI
-   * @return true if done, false if should be called next loop
-   */
-  virtual bool transfer_data() = 0;
-  virtual void refresh_screen() = 0;
-
-  virtual void power_on() = 0;
-  virtual void power_off() = 0;
-  virtual uint32_t get_buffer_length() = 0;
-
-  void start_command_();
-  void end_command_();
-  void start_data_();
-  void end_data_();
-
-  const size_t init_sequence_length_{0};
-
-  size_t current_data_index_{0};
-  uint32_t reset_duration_{200};
-  uint32_t waiting_for_idle_last_print_{0};
-
-  GPIOPin *dc_pin_;
-  GPIOPin *busy_pin_{nullptr};
-  GPIOPin *reset_pin_{nullptr};
-
-  const uint8_t *init_sequence_{nullptr};
-
-  bool waiting_for_idle_{false};
-
-  split_buffer::SplitBuffer buffer_;
-
-  std::queue<EPaperState> state_queue_{{EPaperState::IDLE}};
-};
-
-}  // namespace esphome::epaper_spi

esphome/components/epaper_spi/epaper_spi_model_7p3in_spectra_e6.cpp

@@ -1,42 +0,0 @@
-#include "epaper_spi_model_7p3in_spectra_e6.h"
-
-namespace esphome::epaper_spi {
-
-static constexpr const char *const TAG = "epaper_spi.7.3in-spectra-e6";
-
-void EPaper7p3InSpectraE6::power_on() {
-  ESP_LOGI(TAG, "Power on");
-  this->command(0x04);
-  this->waiting_for_idle_ = true;
-}
-
-void EPaper7p3InSpectraE6::power_off() {
-  ESP_LOGI(TAG, "Power off");
-  this->command(0x02);
-  this->data(0x00);
-  this->waiting_for_idle_ = true;
-}
-
-void EPaper7p3InSpectraE6::refresh_screen() {
-  ESP_LOGI(TAG, "Refresh");
-  this->command(0x12);
-  this->data(0x00);
-  this->waiting_for_idle_ = true;
-}
-
-void EPaper7p3InSpectraE6::deep_sleep() {
-  ESP_LOGI(TAG, "Deep sleep");
-  this->command(0x07);
-  this->data(0xA5);
-}
-
-void EPaper7p3InSpectraE6::dump_config() {
-  LOG_DISPLAY("", "E-Paper SPI", this);
-  ESP_LOGCONFIG(TAG, "  Model: 7.3in Spectra E6");
-  LOG_PIN("  Reset Pin: ", this->reset_pin_);
-  LOG_PIN("  DC Pin: ", this->dc_pin_);
-  LOG_PIN("  Busy Pin: ", this->busy_pin_);
-  LOG_UPDATE_INTERVAL(this);
-}
-
-}  // namespace esphome::epaper_spi

esphome/components/epaper_spi/epaper_spi_model_7p3in_spectra_e6.h

@@ -1,45 +0,0 @@
-#pragma once
-
-#include "epaper_spi_spectra_e6.h"
-
-namespace esphome::epaper_spi {
-
-class EPaper7p3InSpectraE6 : public EPaperSpectraE6 {
-  static constexpr const uint16_t WIDTH = 800;
-  static constexpr const uint16_t HEIGHT = 480;
-  // clang-format off
-
-  // Command, data length, data
-  static constexpr uint8_t INIT_SEQUENCE[] = {
-    0xAA, 6, 0x49, 0x55, 0x20, 0x08, 0x09, 0x18,
-    0x01, 1, 0x3F,
-    0x00, 2, 0x5F, 0x69,
-    0x03, 4, 0x00, 0x54, 0x00, 0x44,
-    0x05, 4, 0x40, 0x1F, 0x1F, 0x2C,
-    0x06, 4, 0x6F, 0x1F, 0x17, 0x49,
-    0x08, 4, 0x6F, 0x1F, 0x1F, 0x22,
-    0x30, 1, 0x03,
-    0x50, 1, 0x3F,
-    0x60, 2, 0x02, 0x00,
-    0x61, 4, WIDTH / 256, WIDTH % 256, HEIGHT / 256, HEIGHT % 256,
-    0x84, 1, 0x01,
-    0xE3, 1, 0x2F,
-  };
-  // clang-format on
-
- public:
-  EPaper7p3InSpectraE6() : EPaperSpectraE6(INIT_SEQUENCE, sizeof(INIT_SEQUENCE)) {}
-
-  void dump_config() override;
-
- protected:
-  int get_width_internal() override { return WIDTH; };
-  int get_height_internal() override { return HEIGHT; };
-
-  void refresh_screen() override;
-  void power_on() override;
-  void power_off() override;
-  void deep_sleep() override;
-};
-
-}  // namespace esphome::epaper_spi

esphome/components/epaper_spi/epaper_spi_spectra_e6.cpp

@@ -1,135 +0,0 @@
-#include "epaper_spi_spectra_e6.h"
-
-#include "esphome/core/log.h"
-
-namespace esphome::epaper_spi {
-
-static constexpr const char *const TAG = "epaper_spi.6c";
-
-static inline uint8_t color_to_hex(Color color) {
-  if (color.red > 127) {
-    if (color.green > 170) {
-      if (color.blue > 127) {
-        return 0x1;  // White
-      } else {
-        return 0x2;  // Yellow
-      }
-    } else {
-      return 0x3;  // Red (or Magenta)
-    }
-  } else {
-    if (color.green > 127) {
-      if (color.blue > 127) {
-        return 0x5;  // Cyan -> Blue
-      } else {
-        return 0x6;  // Green
-      }
-    } else {
-      if (color.blue > 127) {
-        return 0x5;  // Blue
-      } else {
-        return 0x0;  // Black
-      }
-    }
-  }
-}
-
-void EPaperSpectraE6::fill(Color color) {
-  uint8_t pixel_color;
-  if (color.is_on()) {
-    pixel_color = color_to_hex(color);
-  } else {
-    pixel_color = 0x1;
-  }
-
-  // We store 8 bitset<3> in 3 bytes
-  // | byte 1 | byte 2 | byte 3 |
-  // |aaabbbaa|abbbaaab|bbaaabbb|
-  uint8_t byte_1 = pixel_color << 5 | pixel_color << 2 | pixel_color >> 1;
-  uint8_t byte_2 = pixel_color << 7 | pixel_color << 4 | pixel_color << 1 | pixel_color >> 2;
-  uint8_t byte_3 = pixel_color << 6 | pixel_color << 3 | pixel_color << 0;
-
-  const size_t buffer_length = this->get_buffer_length();
-  for (size_t i = 0; i < buffer_length; i += 3) {
-    this->buffer_[i + 0] = byte_1;
-    this->buffer_[i + 1] = byte_2;
-    this->buffer_[i + 2] = byte_3;
-  }
-}
-
-uint32_t EPaperSpectraE6::get_buffer_length() {
-  // 6 colors buffer, 1 pixel = 3 bits, we will store 8 pixels in 24 bits = 3 bytes
-  return this->get_width_controller() * this->get_height_internal() / 8u * 3u;
-}
-
-void HOT EPaperSpectraE6::draw_absolute_pixel_internal(int x, int y, Color color) {
-  if (x >= this->get_width_internal() || y >= this->get_height_internal() || x < 0 || y < 0)
-    return;
-
-  uint8_t pixel_bits = color_to_hex(color);
-  uint32_t pixel_position = x + y * this->get_width_controller();
-  uint32_t first_bit_position = pixel_position * 3;
-  uint32_t byte_position = first_bit_position / 8u;
-  uint32_t byte_subposition = first_bit_position % 8u;
-
-  if (byte_subposition <= 5) {
-    this->buffer_[byte_position] = (this->buffer_[byte_position] & (0xFF ^ (0b111 << (5 - byte_subposition)))) |
-                                   (pixel_bits << (5 - byte_subposition));
-  } else {
-    this->buffer_[byte_position] = (this->buffer_[byte_position] & (0xFF ^ (0b111 >> (byte_subposition - 5)))) |
-                                   (pixel_bits >> (byte_subposition - 5));
-
-    this->buffer_[byte_position + 1] =
-        (this->buffer_[byte_position + 1] & (0xFF ^ (0xFF & (0b111 << (13 - byte_subposition))))) |
-        (pixel_bits << (13 - byte_subposition));
-  }
-}
-
-bool HOT EPaperSpectraE6::transfer_data() {
-  const uint32_t start_time = App.get_loop_component_start_time();
-  if (this->current_data_index_ == 0) {
-    ESP_LOGV(TAG, "Sending data");
-    this->command(0x10);
-  }
-
-  uint8_t bytes_to_send[4]{0};
-  const size_t buffer_length = this->get_buffer_length();
-  for (size_t i = this->current_data_index_; i < buffer_length; i += 3) {
-    const uint32_t triplet = encode_uint24(this->buffer_[i + 0], this->buffer_[i + 1], this->buffer_[i + 2]);
-    // 8 pixels are stored in 3 bytes
-    // |aaabbbaa|abbbaaab|bbaaabbb|
-    // | byte 1 | byte 2 | byte 3 |
-    bytes_to_send[0] = ((triplet >> 17) & 0b01110000) | ((triplet >> 18) & 0b00000111);
-    bytes_to_send[1] = ((triplet >> 11) & 0b01110000) | ((triplet >> 12) & 0b00000111);
-    bytes_to_send[2] = ((triplet >> 5) & 0b01110000) | ((triplet >> 6) & 0b00000111);
-    bytes_to_send[3] = ((triplet << 1) & 0b01110000) | ((triplet << 0) & 0b00000111);
-
-    this->start_data_();
-    this->write_array(bytes_to_send, sizeof(bytes_to_send));
-    this->end_data_();
-
-    if (millis() - start_time > MAX_TRANSFER_TIME) {
-      // Let the main loop run and come back next loop
-      this->current_data_index_ = i + 3;
-      return false;
-    }
-  }
-  // Finished the entire dataset
-  this->current_data_index_ = 0;
-  return true;
-}
-
-void EPaperSpectraE6::reset() {
-  if (this->reset_pin_ != nullptr) {
-    this->disable_loop();
-    this->reset_pin_->digital_write(true);
-    this->set_timeout(20, [this] {
-      this->reset_pin_->digital_write(false);
-      delay(2);
-      this->reset_pin_->digital_write(true);
-      this->set_timeout(20, [this] { this->enable_loop(); });
-    });
-  }
-}
-
-}  // namespace esphome::epaper_spi

esphome/components/epaper_spi/epaper_spi_spectra_e6.h

@@ -1,23 +0,0 @@
-#pragma once
-
-#include "epaper_spi.h"
-
-namespace esphome::epaper_spi {
-
-class EPaperSpectraE6 : public EPaperBase {
- public:
-  EPaperSpectraE6(const uint8_t *init_sequence, const size_t init_sequence_length)
-      : EPaperBase(init_sequence, init_sequence_length) {}
-
-  display::DisplayType get_display_type() override { return display::DisplayType::DISPLAY_TYPE_COLOR; }
-  void fill(Color color) override;
-
- protected:
-  void draw_absolute_pixel_internal(int x, int y, Color color) override;
-  uint32_t get_buffer_length() override;
-
-  bool transfer_data() override;
-  void reset() override;
-};
-
-}  // namespace esphome::epaper_spi

esphome/components/es7210/es7210.cpp

@@ -97,12 +97,12 @@ bool ES7210::set_mic_gain(float mic_gain) {
 }
 
 bool ES7210::configure_sample_rate_() {
-  uint32_t mclk_fre = this->sample_rate_ * MCLK_DIV_FRE;
+  int mclk_fre = this->sample_rate_ * MCLK_DIV_FRE;
   int coeff = -1;
 
-  for (size_t i = 0; i < (sizeof(ES7210_COEFFICIENTS) / sizeof(ES7210_COEFFICIENTS[0])); ++i) {
+  for (int i = 0; i < (sizeof(ES7210_COEFFICIENTS) / sizeof(ES7210_COEFFICIENTS[0])); ++i) {
     if (ES7210_COEFFICIENTS[i].lrclk == this->sample_rate_ && ES7210_COEFFICIENTS[i].mclk == mclk_fre)
-      coeff = static_cast<int>(i);
+      coeff = i;
   }
 
   if (coeff >= 0) {

esphome/components/esp32/__init__.py

@@ -304,17 +304,6 @@ def _format_framework_espidf_version(ver: cv.Version, release: str) -> str:
     return f"pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v{str(ver)}/esp-idf-v{str(ver)}.zip"
 
 
-def _is_framework_url(source: str) -> str:
-    # platformio accepts many URL schemes for framework repositories and archives including http, https, git, file, and symlink
-    import urllib.parse
-
-    try:
-        parsed = urllib.parse.urlparse(source)
-    except ValueError:
-        return False
-    return bool(parsed.scheme)
-
-
 # NOTE: Keep this in mind when updating the recommended version:
 #  * New framework historically have had some regressions, especially for WiFi.
 #    The new version needs to be thoroughly validated before changing the
@@ -325,12 +314,11 @@ def _is_framework_url(source: str) -> str:
 #  - https://github.com/espressif/arduino-esp32/releases
 ARDUINO_FRAMEWORK_VERSION_LOOKUP = {
     "recommended": cv.Version(3, 2, 1),
-    "latest": cv.Version(3, 3, 2),
-    "dev": cv.Version(3, 3, 2),
+    "latest": cv.Version(3, 3, 1),
+    "dev": cv.Version(3, 3, 1),
 }
 ARDUINO_PLATFORM_VERSION_LOOKUP = {
-    cv.Version(3, 3, 2): cv.Version(55, 3, 31, "1"),
-    cv.Version(3, 3, 1): cv.Version(55, 3, 31, "1"),
+    cv.Version(3, 3, 1): cv.Version(55, 3, 31),
     cv.Version(3, 3, 0): cv.Version(55, 3, 30, "2"),
     cv.Version(3, 2, 1): cv.Version(54, 3, 21, "2"),
     cv.Version(3, 2, 0): cv.Version(54, 3, 20),
@@ -348,8 +336,8 @@ ESP_IDF_FRAMEWORK_VERSION_LOOKUP = {
     "dev": cv.Version(5, 5, 1),
 }
 ESP_IDF_PLATFORM_VERSION_LOOKUP = {
-    cv.Version(5, 5, 1): cv.Version(55, 3, 31, "1"),
-    cv.Version(5, 5, 0): cv.Version(55, 3, 31, "1"),
+    cv.Version(5, 5, 1): cv.Version(55, 3, 31),
+    cv.Version(5, 5, 0): cv.Version(55, 3, 31),
     cv.Version(5, 4, 2): cv.Version(54, 3, 21, "2"),
     cv.Version(5, 4, 1): cv.Version(54, 3, 21, "2"),
     cv.Version(5, 4, 0): cv.Version(54, 3, 21, "2"),
@@ -364,8 +352,8 @@ ESP_IDF_PLATFORM_VERSION_LOOKUP = {
 #  - https://github.com/pioarduino/platform-espressif32/releases
 PLATFORM_VERSION_LOOKUP = {
     "recommended": cv.Version(54, 3, 21, "2"),
-    "latest": cv.Version(55, 3, 31, "1"),
-    "dev": cv.Version(55, 3, 31, "1"),
+    "latest": cv.Version(55, 3, 31),
+    "dev": "https://github.com/pioarduino/platform-espressif32.git#develop",
 }
 
 
@@ -398,10 +386,6 @@ def _check_versions(value):
         value[CONF_SOURCE] = value.get(
             CONF_SOURCE, _format_framework_arduino_version(version)
         )
-        if _is_framework_url(value[CONF_SOURCE]):
-            value[CONF_SOURCE] = (
-                f"pioarduino/framework-arduinoespressif32@{value[CONF_SOURCE]}"
-            )
     else:
         if version < cv.Version(5, 0, 0):
             raise cv.Invalid("Only ESP-IDF 5.0+ is supported.")
@@ -411,8 +395,6 @@ def _check_versions(value):
             CONF_SOURCE,
             _format_framework_espidf_version(version, value.get(CONF_RELEASE, None)),
         )
-        if _is_framework_url(value[CONF_SOURCE]):
-            value[CONF_SOURCE] = f"pioarduino/framework-espidf@{value[CONF_SOURCE]}"
 
     if CONF_PLATFORM_VERSION not in value:
         if platform_lookup is None:
@@ -657,7 +639,6 @@ def _show_framework_migration_message(name: str, variant: str) -> None:
         + "Why change? ESP-IDF offers:\n"
         + color(AnsiFore.GREEN, "  ✨ Up to 40% smaller binaries\n")
         + color(AnsiFore.GREEN, "  🚀 Better performance and optimization\n")
-        + color(AnsiFore.GREEN, "  ⚡ 2-3x faster compile times\n")
         + color(AnsiFore.GREEN, "  📦 Custom-built firmware for your exact needs\n")
         + color(
             AnsiFore.GREEN,
@@ -665,6 +646,7 @@ def _show_framework_migration_message(name: str, variant: str) -> None:
         )
         + "\n"
         + "Trade-offs:\n"
+        + color(AnsiFore.YELLOW, "  ⏱️  Compile times are ~25% longer\n")
         + color(AnsiFore.YELLOW, "  🔄 Some components need migration\n")
         + "\n"
         + "What should I do?\n"

esphome/components/esp32_ble/__init__.py

@@ -285,10 +285,6 @@ def consume_connection_slots(
 
 def validate_connection_slots(max_connections: int) -> None:
     """Validate that BLE connection slots don't exceed the configured maximum."""
-    # Skip validation in testing mode to allow component grouping
-    if CORE.testing_mode:
-        return
-
     ble_data = CORE.data.get(KEY_ESP32_BLE, {})
     used_slots = ble_data.get(KEY_USED_CONNECTION_SLOTS, [])
     num_used = len(used_slots)
@@ -336,16 +332,12 @@ def final_validation(config):
 
     # Check if BLE Server is needed
     has_ble_server = "esp32_ble_server" in full_config
+    add_idf_sdkconfig_option("CONFIG_BT_GATTS_ENABLE", has_ble_server)
 
     # Check if BLE Client is needed (via esp32_ble_tracker or esp32_ble_client)
     has_ble_client = (
         "esp32_ble_tracker" in full_config or "esp32_ble_client" in full_config
     )
-
-    # ESP-IDF BLE stack requires GATT Server to be enabled when GATT Client is enabled
-    # This is an internal dependency in the Bluedroid stack (tested ESP-IDF 5.4.2-5.5.1)
-    # See: https://github.com/espressif/esp-idf/issues/17724
-    add_idf_sdkconfig_option("CONFIG_BT_GATTS_ENABLE", has_ble_server or has_ble_client)
     add_idf_sdkconfig_option("CONFIG_BT_GATTC_ENABLE", has_ble_client)
 
     # Handle max_connections: check for deprecated location in esp32_ble_tracker

esphome/components/esp32_ble/ble.cpp

@@ -213,11 +213,8 @@ bool ESP32BLE::ble_setup_() {
   if (this->name_.has_value()) {
     name = this->name_.value();
     if (App.is_name_add_mac_suffix_enabled()) {
-      // MAC address suffix length (last 6 characters of 12-char MAC address string)
-      constexpr size_t mac_address_suffix_len = 6;
-      const std::string mac_addr = get_mac_address();
-      const char *mac_suffix_ptr = mac_addr.c_str() + mac_address_suffix_len;
-      name = make_name_with_suffix(name, '-', mac_suffix_ptr, mac_address_suffix_len);
+      name += "-";
+      name += get_mac_address().substr(6);
     }
   } else {
     name = App.get_name();

esphome/components/esp32_ble/ble_advertising.cpp

@@ -152,7 +152,7 @@ void BLEAdvertising::loop() {
   if (now - this->last_advertisement_time_ > this->advertising_cycle_time_) {
     this->stop();
     this->current_adv_index_ += 1;
-    if (static_cast<size_t>(this->current_adv_index_) >= this->raw_advertisements_callbacks_.size()) {
+    if (this->current_adv_index_ >= this->raw_advertisements_callbacks_.size()) {
       this->current_adv_index_ = -1;
     }
     this->start();

esphome/components/esp32_ble/ble_uuid.cpp

@@ -42,18 +42,32 @@ ESPBTUUID ESPBTUUID::from_raw_reversed(const uint8_t *data) {
 ESPBTUUID ESPBTUUID::from_raw(const std::string &data) {
   ESPBTUUID ret;
   if (data.length() == 4) {
-    // 16-bit UUID as 4-character hex string
-    auto parsed = parse_hex<uint16_t>(data);
-    if (parsed.has_value()) {
-      ret.uuid_.len = ESP_UUID_LEN_16;
-      ret.uuid_.uuid.uuid16 = parsed.value();
+    ret.uuid_.len = ESP_UUID_LEN_16;
+    ret.uuid_.uuid.uuid16 = 0;
+    for (uint i = 0; i < data.length(); i += 2) {
+      uint8_t msb = data.c_str()[i];
+      uint8_t lsb = data.c_str()[i + 1];
+      uint8_t lsb_shift = i <= 2 ? (2 - i) * 4 : 0;
+
+      if (msb > '9')
+        msb -= 7;
+      if (lsb > '9')
+        lsb -= 7;
+      ret.uuid_.uuid.uuid16 += (((msb & 0x0F) << 4) | (lsb & 0x0F)) << lsb_shift;
     }
   } else if (data.length() == 8) {
-    // 32-bit UUID as 8-character hex string
-    auto parsed = parse_hex<uint32_t>(data);
-    if (parsed.has_value()) {
-      ret.uuid_.len = ESP_UUID_LEN_32;
-      ret.uuid_.uuid.uuid32 = parsed.value();
+    ret.uuid_.len = ESP_UUID_LEN_32;
+    ret.uuid_.uuid.uuid32 = 0;
+    for (uint i = 0; i < data.length(); i += 2) {
+      uint8_t msb = data.c_str()[i];
+      uint8_t lsb = data.c_str()[i + 1];
+      uint8_t lsb_shift = i <= 6 ? (6 - i) * 4 : 0;
+
+      if (msb > '9')
+        msb -= 7;
+      if (lsb > '9')
+        lsb -= 7;
+      ret.uuid_.uuid.uuid32 += (((msb & 0x0F) << 4) | (lsb & 0x0F)) << lsb_shift;
     }
   } else if (data.length() == 16) {  // how we can have 16 byte length string reprezenting 128 bit uuid??? needs to be
                                      // investigated (lack of time)
@@ -131,16 +145,28 @@ bool ESPBTUUID::operator==(const ESPBTUUID &uuid) const {
   if (this->uuid_.len == uuid.uuid_.len) {
     switch (this->uuid_.len) {
       case ESP_UUID_LEN_16:
-        return this->uuid_.uuid.uuid16 == uuid.uuid_.uuid.uuid16;
+        if (uuid.uuid_.uuid.uuid16 == this->uuid_.uuid.uuid16) {
+          return true;
+        }
+        break;
       case ESP_UUID_LEN_32:
-        return this->uuid_.uuid.uuid32 == uuid.uuid_.uuid.uuid32;
+        if (uuid.uuid_.uuid.uuid32 == this->uuid_.uuid.uuid32) {
+          return true;
+        }
+        break;
       case ESP_UUID_LEN_128:
-        return memcmp(this->uuid_.uuid.uuid128, uuid.uuid_.uuid.uuid128, ESP_UUID_LEN_128) == 0;
-      default:
-        return false;
+        for (uint8_t i = 0; i < ESP_UUID_LEN_128; i++) {
+          if (uuid.uuid_.uuid.uuid128[i] != this->uuid_.uuid.uuid128[i]) {
+            return false;
+          }
+        }
+        return true;
+        break;
     }
+  } else {
+    return this->as_128bit() == uuid.as_128bit();
   }
-  return this->as_128bit() == uuid.as_128bit();
+  return false;
 }
 esp_bt_uuid_t ESPBTUUID::get_uuid() const { return this->uuid_; }
 std::string ESPBTUUID::to_string() const {

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

@@ -14,6 +14,10 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 
+#ifdef USE_ARDUINO
+#include <esp32-hal-bt.h>
+#endif
+
 namespace esphome {
 namespace esp32_ble_beacon {
 

esphome/components/esp32_ble_server/ble_characteristic.cpp

@@ -125,49 +125,69 @@ bool BLECharacteristic::is_created() {
   if (this->state_ != CREATING_DEPENDENTS)
     return false;
 
+  bool created = true;
   for (auto *descriptor : this->descriptors_) {
-    if (!descriptor->is_created())
-      return false;
+    created &= descriptor->is_created();
   }
-  // All descriptors are created if we reach here
-  this->state_ = CREATED;
-  return true;
+  if (created)
+    this->state_ = CREATED;
+  return this->state_ == CREATED;
 }
 
 bool BLECharacteristic::is_failed() {
   if (this->state_ == FAILED)
     return true;
 
+  bool failed = false;
   for (auto *descriptor : this->descriptors_) {
-    if (descriptor->is_failed()) {
-      this->state_ = FAILED;
-      return true;
-    }
-  }
-  return false;
-}
-
-void BLECharacteristic::set_property_bit_(esp_gatt_char_prop_t bit, bool value) {
-  if (value) {
-    this->properties_ = (esp_gatt_char_prop_t) (this->properties_ | bit);
-  } else {
-    this->properties_ = (esp_gatt_char_prop_t) (this->properties_ & ~bit);
+    failed |= descriptor->is_failed();
   }
+  if (failed)
+    this->state_ = FAILED;
+  return this->state_ == FAILED;
 }
 
 void BLECharacteristic::set_broadcast_property(bool value) {
-  this->set_property_bit_(ESP_GATT_CHAR_PROP_BIT_BROADCAST, value);
+  if (value) {
+    this->properties_ = (esp_gatt_char_prop_t) (this->properties_ | ESP_GATT_CHAR_PROP_BIT_BROADCAST);
+  } else {
+    this->properties_ = (esp_gatt_char_prop_t) (this->properties_ & ~ESP_GATT_CHAR_PROP_BIT_BROADCAST);
+  }
 }
 void BLECharacteristic::set_indicate_property(bool value) {
-  this->set_property_bit_(ESP_GATT_CHAR_PROP_BIT_INDICATE, value);
+  if (value) {
+    this->properties_ = (esp_gatt_char_prop_t) (this->properties_ | ESP_GATT_CHAR_PROP_BIT_INDICATE);
+  } else {
+    this->properties_ = (esp_gatt_char_prop_t) (this->properties_ & ~ESP_GATT_CHAR_PROP_BIT_INDICATE);
+  }
 }
 void BLECharacteristic::set_notify_property(bool value) {
-  this->set_property_bit_(ESP_GATT_CHAR_PROP_BIT_NOTIFY, value);
+  if (value) {
+    this->properties_ = (esp_gatt_char_prop_t) (this->properties_ | ESP_GATT_CHAR_PROP_BIT_NOTIFY);
+  } else {
+    this->properties_ = (esp_gatt_char_prop_t) (this->properties_ & ~ESP_GATT_CHAR_PROP_BIT_NOTIFY);
+  }
+}
+void BLECharacteristic::set_read_property(bool value) {
+  if (value) {
+    this->properties_ = (esp_gatt_char_prop_t) (this->properties_ | ESP_GATT_CHAR_PROP_BIT_READ);
+  } else {
+    this->properties_ = (esp_gatt_char_prop_t) (this->properties_ & ~ESP_GATT_CHAR_PROP_BIT_READ);
+  }
+}
+void BLECharacteristic::set_write_property(bool value) {
+  if (value) {
+    this->properties_ = (esp_gatt_char_prop_t) (this->properties_ | ESP_GATT_CHAR_PROP_BIT_WRITE);
+  } else {
+    this->properties_ = (esp_gatt_char_prop_t) (this->properties_ & ~ESP_GATT_CHAR_PROP_BIT_WRITE);
+  }
 }
-void BLECharacteristic::set_read_property(bool value) { this->set_property_bit_(ESP_GATT_CHAR_PROP_BIT_READ, value); }
-void BLECharacteristic::set_write_property(bool value) { this->set_property_bit_(ESP_GATT_CHAR_PROP_BIT_WRITE, value); }
 void BLECharacteristic::set_write_no_response_property(bool value) {
-  this->set_property_bit_(ESP_GATT_CHAR_PROP_BIT_WRITE_NR, value);
+  if (value) {
+    this->properties_ = (esp_gatt_char_prop_t) (this->properties_ | ESP_GATT_CHAR_PROP_BIT_WRITE_NR);
+  } else {
+    this->properties_ = (esp_gatt_char_prop_t) (this->properties_ & ~ESP_GATT_CHAR_PROP_BIT_WRITE_NR);
+  }
 }
 
 void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,

esphome/components/esp32_ble_server/ble_characteristic.h

@@ -97,8 +97,6 @@ class BLECharacteristic {
   void remove_client_from_notify_list_(uint16_t conn_id);
   ClientNotificationEntry *find_client_in_notify_list_(uint16_t conn_id);
 
-  void set_property_bit_(esp_gatt_char_prop_t bit, bool value);
-
   std::unique_ptr<std::function<void(std::span<const uint8_t>, uint16_t)>> on_write_callback_;
   std::unique_ptr<std::function<void(uint16_t)>> on_read_callback_;
 

esphome/components/esp32_ble_tracker/__init__.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
 import logging
 
 from esphome import automation
@@ -53,19 +52,9 @@ class BLEFeatures(StrEnum):
     ESP_BT_DEVICE = "ESP_BT_DEVICE"
 
 
-# Dataclass for registration counts
-@dataclass
-class RegistrationCounts:
-    listeners: int = 0
-    clients: int = 0
-
-
 # Set to track which features are needed by components
 _required_features: set[BLEFeatures] = set()
 
-# Track registration counts for StaticVector sizing
-_registration_counts = RegistrationCounts()
-
 
 def register_ble_features(features: set[BLEFeatures]) -> None:
     """Register BLE features that a component needs.
@@ -268,14 +257,12 @@ async def to_code(config):
         register_ble_features({BLEFeatures.ESP_BT_DEVICE})
 
     for conf in config.get(CONF_ON_BLE_ADVERTISE, []):
-        _registration_counts.listeners += 1
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         if CONF_MAC_ADDRESS in conf:
             addr_list = [it.as_hex for it in conf[CONF_MAC_ADDRESS]]
             cg.add(trigger.set_addresses(addr_list))
         await automation.build_automation(trigger, [(ESPBTDeviceConstRef, "x")], conf)
     for conf in config.get(CONF_ON_BLE_SERVICE_DATA_ADVERTISE, []):
-        _registration_counts.listeners += 1
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         if len(conf[CONF_SERVICE_UUID]) == len(bt_uuid16_format):
             cg.add(trigger.set_service_uuid16(as_hex(conf[CONF_SERVICE_UUID])))
@@ -288,7 +275,6 @@ async def to_code(config):
             cg.add(trigger.set_address(conf[CONF_MAC_ADDRESS].as_hex))
         await automation.build_automation(trigger, [(adv_data_t_const_ref, "x")], conf)
     for conf in config.get(CONF_ON_BLE_MANUFACTURER_DATA_ADVERTISE, []):
-        _registration_counts.listeners += 1
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         if len(conf[CONF_MANUFACTURER_ID]) == len(bt_uuid16_format):
             cg.add(trigger.set_manufacturer_uuid16(as_hex(conf[CONF_MANUFACTURER_ID])))
@@ -301,7 +287,6 @@ async def to_code(config):
             cg.add(trigger.set_address(conf[CONF_MAC_ADDRESS].as_hex))
         await automation.build_automation(trigger, [(adv_data_t_const_ref, "x")], conf)
     for conf in config.get(CONF_ON_SCAN_END, []):
-        _registration_counts.listeners += 1
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [], conf)
 
@@ -335,17 +320,6 @@ async def _add_ble_features():
         cg.add_define("USE_ESP32_BLE_DEVICE")
         cg.add_define("USE_ESP32_BLE_UUID")
 
-    # Add defines for StaticVector sizing based on registration counts
-    # Only define if count > 0 to avoid allocating unnecessary memory
-    if _registration_counts.listeners > 0:
-        cg.add_define(
-            "ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT", _registration_counts.listeners
-        )
-    if _registration_counts.clients > 0:
-        cg.add_define(
-            "ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT", _registration_counts.clients
-        )
-
 
 ESP32_BLE_START_SCAN_ACTION_SCHEMA = cv.Schema(
     {
@@ -395,7 +369,6 @@ async def register_ble_device(
     var: cg.SafeExpType, config: ConfigType
 ) -> cg.SafeExpType:
     register_ble_features({BLEFeatures.ESP_BT_DEVICE})
-    _registration_counts.listeners += 1
     paren = await cg.get_variable(config[CONF_ESP32_BLE_ID])
     cg.add(paren.register_listener(var))
     return var
@@ -403,7 +376,6 @@ async def register_ble_device(
 
 async def register_client(var: cg.SafeExpType, config: ConfigType) -> cg.SafeExpType:
     register_ble_features({BLEFeatures.ESP_BT_DEVICE})
-    _registration_counts.clients += 1
     paren = await cg.get_variable(config[CONF_ESP32_BLE_ID])
     cg.add(paren.register_client(var))
     return var
@@ -417,7 +389,6 @@ async def register_raw_ble_device(
     This does NOT register the ESP_BT_DEVICE feature, meaning ESPBTDevice
     will not be compiled in if this is the only registration method used.
     """
-    _registration_counts.listeners += 1
     paren = await cg.get_variable(config[CONF_ESP32_BLE_ID])
     cg.add(paren.register_listener(var))
     return var
@@ -431,7 +402,6 @@ async def register_raw_client(
     This does NOT register the ESP_BT_DEVICE feature, meaning ESPBTDevice
     will not be compiled in if this is the only registration method used.
     """
-    _registration_counts.clients += 1
     paren = await cg.get_variable(config[CONF_ESP32_BLE_ID])
     cg.add(paren.register_client(var))
     return var

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -25,6 +25,10 @@
 #include <esp_coexist.h>
 #endif
 
+#ifdef USE_ARDUINO
+#include <esp32-hal-bt.h>
+#endif
+
 #define MBEDTLS_AES_ALT
 #include <aes_alt.h>
 
@@ -74,11 +78,9 @@ void ESP32BLETracker::setup() {
       [this](ota::OTAState state, float progress, uint8_t error, ota::OTAComponent *comp) {
         if (state == ota::OTA_STARTED) {
           this->stop_scan();
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
           for (auto *client : this->clients_) {
             client->disconnect();
           }
-#endif
         }
       });
 #endif
@@ -208,10 +210,8 @@ void ESP32BLETracker::start_scan_(bool first) {
   this->set_scanner_state_(ScannerState::STARTING);
   ESP_LOGD(TAG, "Starting scan, set scanner state to STARTING.");
   if (!first) {
-#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
     for (auto *listener : this->listeners_)
       listener->on_scan_end();
-#endif
   }
 #ifdef USE_ESP32_BLE_DEVICE
   this->already_discovered_.clear();
@@ -240,25 +240,20 @@ void ESP32BLETracker::start_scan_(bool first) {
 }
 
 void ESP32BLETracker::register_client(ESPBTClient *client) {
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
   client->app_id = ++this->app_id_;
   this->clients_.push_back(client);
   this->recalculate_advertisement_parser_types();
-#endif
 }
 
 void ESP32BLETracker::register_listener(ESPBTDeviceListener *listener) {
-#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
   listener->set_parent(this);
   this->listeners_.push_back(listener);
   this->recalculate_advertisement_parser_types();
-#endif
 }
 
 void ESP32BLETracker::recalculate_advertisement_parser_types() {
   this->raw_advertisements_ = false;
   this->parse_advertisements_ = false;
-#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
   for (auto *listener : this->listeners_) {
     if (listener->get_advertisement_parser_type() == AdvertisementParserType::PARSED_ADVERTISEMENTS) {
       this->parse_advertisements_ = true;
@@ -266,8 +261,6 @@ void ESP32BLETracker::recalculate_advertisement_parser_types() {
       this->raw_advertisements_ = true;
     }
   }
-#endif
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
   for (auto *client : this->clients_) {
     if (client->get_advertisement_parser_type() == AdvertisementParserType::PARSED_ADVERTISEMENTS) {
       this->parse_advertisements_ = true;
@@ -275,7 +268,6 @@ void ESP32BLETracker::recalculate_advertisement_parser_types() {
       this->raw_advertisements_ = true;
     }
   }
-#endif
 }
 
 void ESP32BLETracker::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
@@ -294,12 +286,10 @@ void ESP32BLETracker::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_ga
     default:
       break;
   }
-    // Forward all events to clients (scan results are handled separately via gap_scan_event_handler)
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
+  // Forward all events to clients (scan results are handled separately via gap_scan_event_handler)
   for (auto *client : this->clients_) {
     client->gap_event_handler(event, param);
   }
-#endif
 }
 
 void ESP32BLETracker::gap_scan_event_handler(const BLEScanResult &scan_result) {
@@ -362,11 +352,9 @@ void ESP32BLETracker::gap_scan_stop_complete_(const esp_ble_gap_cb_param_t::ble_
 
 void ESP32BLETracker::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                                           esp_ble_gattc_cb_param_t *param) {
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
   for (auto *client : this->clients_) {
     client->gattc_event_handler(event, gattc_if, param);
   }
-#endif
 }
 
 void ESP32BLETracker::set_scanner_state_(ScannerState state) {
@@ -720,16 +708,12 @@ bool ESPBTDevice::resolve_irk(const uint8_t *irk) const {
 void ESP32BLETracker::process_scan_result_(const BLEScanResult &scan_result) {
   // Process raw advertisements
   if (this->raw_advertisements_) {
-#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
     for (auto *listener : this->listeners_) {
       listener->parse_devices(&scan_result, 1);
     }
-#endif
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
     for (auto *client : this->clients_) {
       client->parse_devices(&scan_result, 1);
     }
-#endif
   }
 
   // Process parsed advertisements
@@ -739,20 +723,16 @@ void ESP32BLETracker::process_scan_result_(const BLEScanResult &scan_result) {
     device.parse_scan_rst(scan_result);
 
     bool found = false;
-#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
     for (auto *listener : this->listeners_) {
       if (listener->parse_device(device))
         found = true;
     }
-#endif
 
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
     for (auto *client : this->clients_) {
       if (client->parse_device(device)) {
         found = true;
       }
     }
-#endif
 
     if (!found && !this->scan_continuous_) {
       this->print_bt_device_info(device);
@@ -769,10 +749,8 @@ void ESP32BLETracker::cleanup_scan_state_(bool is_stop_complete) {
   // Reset timeout state machine instead of cancelling scheduler timeout
   this->scan_timeout_state_ = ScanTimeoutState::INACTIVE;
 
-#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
   for (auto *listener : this->listeners_)
     listener->on_scan_end();
-#endif
 
   this->set_scanner_state_(ScannerState::IDLE);
 }
@@ -796,7 +774,6 @@ void ESP32BLETracker::handle_scanner_failure_() {
 
 void ESP32BLETracker::try_promote_discovered_clients_() {
   // Only promote the first discovered client to avoid multiple simultaneous connections
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
   for (auto *client : this->clients_) {
     if (client->state() != ClientState::DISCOVERED) {
       continue;
@@ -818,7 +795,6 @@ void ESP32BLETracker::try_promote_discovered_clients_() {
     client->connect();
     break;
   }
-#endif
 }
 
 const char *ESP32BLETracker::scanner_state_to_string_(ScannerState state) const {

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -302,7 +302,6 @@ class ESP32BLETracker : public Component,
   /// Count clients in each state
   ClientStateCounts count_client_states_() const {
     ClientStateCounts counts;
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
     for (auto *client : this->clients_) {
       switch (client->state()) {
         case ClientState::DISCONNECTING:
@@ -318,17 +317,12 @@ class ESP32BLETracker : public Component,
           break;
       }
     }
-#endif
     return counts;
   }
 
   // Group 1: Large objects (12+ bytes) - vectors and callback manager
-#ifdef ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT
-  StaticVector<ESPBTDeviceListener *, ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT> listeners_;
-#endif
-#ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
-  StaticVector<ESPBTClient *, ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT> clients_;
-#endif
+  std::vector<ESPBTDeviceListener *> listeners_;
+  std::vector<ESPBTClient *> clients_;
   CallbackManager<void(ScannerState)> scanner_state_callbacks_;
 #ifdef USE_ESP32_BLE_DEVICE
   /// Vector of addresses that have already been printed in print_bt_device_info

esphome/components/esp32_can/esp32_can.cpp

@@ -68,7 +68,7 @@ static bool get_bitrate(canbus::CanSpeed bitrate, twai_timing_config_t *t_config
 
 bool ESP32Can::setup_internal() {
   static int next_twai_ctrl_num = 0;
-  if (static_cast<unsigned>(next_twai_ctrl_num) >= SOC_TWAI_CONTROLLER_NUM) {
+  if (next_twai_ctrl_num >= SOC_TWAI_CONTROLLER_NUM) {
     ESP_LOGW(TAG, "Maximum number of esp32_can components created already");
     this->mark_failed();
     return false;

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -143,7 +143,6 @@ void ESP32ImprovComponent::loop() {
 #else
       this->set_state_(improv::STATE_AUTHORIZED);
 #endif
-      this->check_wifi_connection_();
       break;
     }
     case improv::STATE_AUTHORIZED: {
@@ -157,12 +156,31 @@ void ESP32ImprovComponent::loop() {
       if (!this->check_identify_()) {
         this->set_status_indicator_state_((now % 1000) < 500);
       }
-      this->check_wifi_connection_();
       break;
     }
     case improv::STATE_PROVISIONING: {
       this->set_status_indicator_state_((now % 200) < 100);
-      this->check_wifi_connection_();
+      if (wifi::global_wifi_component->is_connected()) {
+        wifi::global_wifi_component->save_wifi_sta(this->connecting_sta_.get_ssid(),
+                                                   this->connecting_sta_.get_password());
+        this->connecting_sta_ = {};
+        this->cancel_timeout("wifi-connect-timeout");
+        this->set_state_(improv::STATE_PROVISIONED);
+
+        std::vector<std::string> urls = {ESPHOME_MY_LINK};
+#ifdef USE_WEBSERVER
+        for (auto &ip : wifi::global_wifi_component->wifi_sta_ip_addresses()) {
+          if (ip.is_ip4()) {
+            std::string webserver_url = "http://" + ip.str() + ":" + to_string(USE_WEBSERVER_PORT);
+            urls.push_back(webserver_url);
+            break;
+          }
+        }
+#endif
+        std::vector<uint8_t> data = improv::build_rpc_response(improv::WIFI_SETTINGS, urls);
+        this->send_response_(data);
+        this->stop();
+      }
       break;
     }
     case improv::STATE_PROVISIONED: {
@@ -374,36 +392,6 @@ void ESP32ImprovComponent::on_wifi_connect_timeout_() {
   wifi::global_wifi_component->clear_sta();
 }
 
-void ESP32ImprovComponent::check_wifi_connection_() {
-  if (!wifi::global_wifi_component->is_connected()) {
-    return;
-  }
-
-  if (this->state_ == improv::STATE_PROVISIONING) {
-    wifi::global_wifi_component->save_wifi_sta(this->connecting_sta_.get_ssid(), this->connecting_sta_.get_password());
-    this->connecting_sta_ = {};
-    this->cancel_timeout("wifi-connect-timeout");
-
-    std::vector<std::string> urls = {ESPHOME_MY_LINK};
-#ifdef USE_WEBSERVER
-    for (auto &ip : wifi::global_wifi_component->wifi_sta_ip_addresses()) {
-      if (ip.is_ip4()) {
-        std::string webserver_url = "http://" + ip.str() + ":" + to_string(USE_WEBSERVER_PORT);
-        urls.push_back(webserver_url);
-        break;
-      }
-    }
-#endif
-    std::vector<uint8_t> data = improv::build_rpc_response(improv::WIFI_SETTINGS, urls);
-    this->send_response_(data);
-  } else if (this->is_active() && this->state_ != improv::STATE_PROVISIONED) {
-    ESP_LOGD(TAG, "WiFi provisioned externally");
-  }
-
-  this->set_state_(improv::STATE_PROVISIONED);
-  this->stop();
-}
-
 void ESP32ImprovComponent::advertise_service_data_() {
   uint8_t service_data[IMPROV_SERVICE_DATA_SIZE] = {};
   service_data[0] = IMPROV_PROTOCOL_ID_1;  // PR

esphome/components/esp32_improv/esp32_improv_component.h

@@ -111,7 +111,6 @@ class ESP32ImprovComponent : public Component {
   void send_response_(std::vector<uint8_t> &response);
   void process_incoming_data_();
   void on_wifi_connect_timeout_();
-  void check_wifi_connection_();
   bool check_identify_();
   void advertise_service_data_();
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG

esphome/components/esphome/ota/ota_esphome.cpp

@@ -29,7 +29,7 @@ namespace esphome {
 static const char *const TAG = "esphome.ota";
 static constexpr uint16_t OTA_BLOCK_SIZE = 8192;
 static constexpr size_t OTA_BUFFER_SIZE = 1024;                  // buffer size for OTA data transfer
-static constexpr uint32_t OTA_SOCKET_TIMEOUT_HANDSHAKE = 20000;  // milliseconds for initial handshake
+static constexpr uint32_t OTA_SOCKET_TIMEOUT_HANDSHAKE = 10000;  // milliseconds for initial handshake
 static constexpr uint32_t OTA_SOCKET_TIMEOUT_DATA = 90000;       // milliseconds for data transfer
 
 #ifdef USE_OTA_PASSWORD

esphome/components/ethernet/ethernet_component.cpp

@@ -691,9 +691,7 @@ void EthernetComponent::set_manual_ip(const ManualIP &manual_ip) { this->manual_
 
 std::string EthernetComponent::get_use_address() const {
   if (this->use_address_.empty()) {
-    // ".local" suffix length for mDNS hostnames
-    constexpr size_t mdns_local_suffix_len = 5;
-    return make_name_with_suffix(App.get_name(), '.', "local", mdns_local_suffix_len);
+    return App.get_name() + ".local";
   }
   return this->use_address_;
 }

esphome/components/fingerprint_grow/fingerprint_grow.cpp

@@ -80,7 +80,7 @@ void FingerprintGrowComponent::setup() {
   delay(20);  // This delay guarantees the sensor will in fact be powered power.
 
   if (this->check_password_()) {
-    if (this->new_password_ != std::numeric_limits<uint32_t>::max()) {
+    if (this->new_password_ != -1) {
       if (this->set_password_())
         return;
     } else {

esphome/components/fingerprint_grow/fingerprint_grow.h

@@ -6,7 +6,6 @@
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #include "esphome/components/uart/uart.h"
 
-#include <limits>
 #include <vector>
 
 namespace esphome {
@@ -178,7 +177,7 @@ class FingerprintGrowComponent : public PollingComponent, public uart::UARTDevic
   uint8_t address_[4] = {0xFF, 0xFF, 0xFF, 0xFF};
   uint16_t capacity_ = 64;
   uint32_t password_ = 0x0;
-  uint32_t new_password_ = std::numeric_limits<uint32_t>::max();
+  uint32_t new_password_ = -1;
   GPIOPin *sensing_pin_{nullptr};
   GPIOPin *sensor_power_pin_{nullptr};
   uint8_t enrollment_image_ = 0;

esphome/components/graph/graph.cpp

@@ -179,7 +179,7 @@ void Graph::draw(Display *buff, uint16_t x_offset, uint16_t y_offset, Color colo
         if (b) {
           int16_t y = (int16_t) roundf((this->height_ - 1) * (1.0 - v)) - thick / 2 + y_offset;
           auto draw_pixel_at = [&buff, c, y_offset, this](int16_t x, int16_t y) {
-            if (y >= y_offset && static_cast<uint32_t>(y) < y_offset + this->height_)
+            if (y >= y_offset && y < y_offset + this->height_)
               buff->draw_pixel_at(x, y, c);
           };
           if (!continuous || !has_prev || !prev_b || (abs(y - prev_y) <= thick)) {

esphome/components/graphical_display_menu/graphical_display_menu.cpp

@@ -116,7 +116,7 @@ void GraphicalDisplayMenu::draw_menu_internal_(display::Display *display, const
   int number_items_fit_to_screen = 0;
   const int max_item_index = this->displayed_item_->items_size() - 1;
 
-  for (size_t i = 0; max_item_index >= 0 && i <= static_cast<size_t>(max_item_index); i++) {
+  for (size_t i = 0; i <= max_item_index; i++) {
     const auto *item = this->displayed_item_->get_item(i);
     const bool selected = i == this->cursor_index_;
     const display::Rect item_dimensions = this->measure_item(display, item, bounds, selected);
@@ -174,8 +174,7 @@ void GraphicalDisplayMenu::draw_menu_internal_(display::Display *display, const
 
   display->filled_rectangle(bounds->x, bounds->y, max_width, total_height, this->background_color_);
   auto y_offset = bounds->y;
-  for (size_t i = static_cast<size_t>(first_item_index);
-       last_item_index >= 0 && i <= static_cast<size_t>(last_item_index); i++) {
+  for (size_t i = first_item_index; i <= last_item_index; i++) {
     const auto *item = this->displayed_item_->get_item(i);
     const bool selected = i == this->cursor_index_;
     display::Rect dimensions = menu_dimensions[i];

esphome/components/haier/hon_climate.cpp

@@ -213,7 +213,7 @@ haier_protocol::HandlerError HonClimate::status_handler_(haier_protocol::FrameTy
                this->real_control_packet_size_);
         this->status_message_callback_.call((const char *) data, data_size);
       } else {
-        ESP_LOGW(TAG, "Status packet too small: %zu (should be >= %zu)", data_size, this->real_control_packet_size_);
+        ESP_LOGW(TAG, "Status packet too small: %d (should be >= %d)", data_size, this->real_control_packet_size_);
       }
       switch (this->protocol_phase_) {
         case ProtocolPhases::SENDING_FIRST_STATUS_REQUEST:
@@ -827,7 +827,7 @@ haier_protocol::HandlerError HonClimate::process_status_message_(const uint8_t *
   size_t expected_size =
       2 + this->status_message_header_size_ + this->real_control_packet_size_ + this->real_sensors_packet_size_;
   if (size < expected_size) {
-    ESP_LOGW(TAG, "Unexpected message size %u (expexted >= %zu)", size, expected_size);
+    ESP_LOGW(TAG, "Unexpected message size %d (expexted >= %d)", size, expected_size);
     return haier_protocol::HandlerError::WRONG_MESSAGE_STRUCTURE;
   }
   uint16_t subtype = (((uint16_t) packet_buffer[0]) << 8) + packet_buffer[1];

esphome/components/haier/hon_climate.h

@@ -178,7 +178,7 @@ class HonClimate : public HaierClimateBase {
   int extra_control_packet_bytes_{0};
   int extra_sensors_packet_bytes_{4};
   int status_message_header_size_{0};
-  size_t real_control_packet_size_{sizeof(hon_protocol::HaierPacketControl)};
+  int real_control_packet_size_{sizeof(hon_protocol::HaierPacketControl)};
   int real_sensors_packet_size_{sizeof(hon_protocol::HaierPacketSensors) + 4};
   HonControlMethod control_method_;
   std::queue<haier_protocol::HaierMessage> control_messages_queue_;

esphome/components/http_request/__init__.py

@@ -5,7 +5,6 @@ from esphome.components.const import CONF_REQUEST_HEADERS
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_CAPTURE_RESPONSE,
     CONF_ESP8266_DISABLE_SSL_SUPPORT,
     CONF_ID,
     CONF_METHOD,
@@ -58,6 +57,7 @@ CONF_HEADERS = "headers"
 CONF_COLLECT_HEADERS = "collect_headers"
 CONF_BODY = "body"
 CONF_JSON = "json"
+CONF_CAPTURE_RESPONSE = "capture_response"
 
 
 def validate_url(value):

esphome/components/http_request/http_request.h

@@ -167,8 +167,8 @@ class HttpRequestComponent : public Component {
   }
 
  protected:
-  virtual std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method,
-                                                 const std::string &body, const std::list<Header> &request_headers,
+  virtual std::shared_ptr<HttpContainer> perform(std::string url, std::string method, std::string body,
+                                                 std::list<Header> request_headers,
                                                  std::set<std::string> collect_headers) = 0;
   const char *useragent_{nullptr};
   bool follow_redirects_{};

esphome/components/http_request/http_request_arduino.cpp

@@ -14,9 +14,8 @@ namespace http_request {
 
 static const char *const TAG = "http_request.arduino";
 
-std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const std::string &url, const std::string &method,
-                                                           const std::string &body,
-                                                           const std::list<Header> &request_headers,
+std::shared_ptr<HttpContainer> HttpRequestArduino::perform(std::string url, std::string method, std::string body,
+                                                           std::list<Header> request_headers,
                                                            std::set<std::string> collect_headers) {
   if (!network::is_connected()) {
     this->status_momentary_error("failed", 1000);

esphome/components/http_request/http_request_arduino.h

@@ -31,8 +31,8 @@ class HttpContainerArduino : public HttpContainer {
 
 class HttpRequestArduino : public HttpRequestComponent {
  protected:
-  std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method, const std::string &body,
-                                         const std::list<Header> &request_headers,
+  std::shared_ptr<HttpContainer> perform(std::string url, std::string method, std::string body,
+                                         std::list<Header> request_headers,
                                          std::set<std::string> collect_headers) override;
 };
 

esphome/components/http_request/http_request_host.cpp

@@ -17,9 +17,8 @@ namespace http_request {
 
 static const char *const TAG = "http_request.host";
 
-std::shared_ptr<HttpContainer> HttpRequestHost::perform(const std::string &url, const std::string &method,
-                                                        const std::string &body,
-                                                        const std::list<Header> &request_headers,
+std::shared_ptr<HttpContainer> HttpRequestHost::perform(std::string url, std::string method, std::string body,
+                                                        std::list<Header> request_headers,
                                                         std::set<std::string> response_headers) {
   if (!network::is_connected()) {
     this->status_momentary_error("failed", 1000);

esphome/components/http_request/http_request_host.h

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

esphome/components/http_request/http_request_idf.cpp

@@ -52,9 +52,8 @@ esp_err_t HttpRequestIDF::http_event_handler(esp_http_client_event_t *evt) {
   return ESP_OK;
 }
 
-std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, const std::string &method,
-                                                       const std::string &body,
-                                                       const std::list<Header> &request_headers,
+std::shared_ptr<HttpContainer> HttpRequestIDF::perform(std::string url, std::string method, std::string body,
+                                                       std::list<Header> request_headers,
                                                        std::set<std::string> collect_headers) {
   if (!network::is_connected()) {
     this->status_momentary_error("failed", 1000);

esphome/components/http_request/http_request_idf.h

@@ -37,8 +37,8 @@ class HttpRequestIDF : public HttpRequestComponent {
   void set_buffer_size_tx(uint16_t buffer_size_tx) { this->buffer_size_tx_ = buffer_size_tx; }
 
  protected:
-  std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method, const std::string &body,
-                                         const std::list<Header> &request_headers,
+  std::shared_ptr<HttpContainer> perform(std::string url, std::string method, std::string body,
+                                         std::list<Header> request_headers,
                                          std::set<std::string> collect_headers) override;
   // if zero ESP-IDF will use DEFAULT_HTTP_BUF_SIZE
   uint16_t buffer_size_rx_{};

esphome/components/i2s_audio/__init__.py

@@ -143,18 +143,7 @@ def validate_mclk_divisible_by_3(config):
     return config
 
 
-# Key for storing legacy driver setting in CORE.data
-I2S_USE_LEGACY_DRIVER_KEY = "i2s_use_legacy_driver"
-
-
-def _get_use_legacy_driver():
-    """Get the legacy driver setting from CORE.data."""
-    return CORE.data.get(I2S_USE_LEGACY_DRIVER_KEY)
-
-
-def _set_use_legacy_driver(value: bool) -> None:
-    """Set the legacy driver setting in CORE.data."""
-    CORE.data[I2S_USE_LEGACY_DRIVER_KEY] = value
+_use_legacy_driver = None
 
 
 def i2s_audio_component_schema(
@@ -220,15 +209,17 @@ async def register_i2s_audio_component(var, config):
 
 
 def validate_use_legacy(value):
+    global _use_legacy_driver  # noqa: PLW0603
     if CONF_USE_LEGACY in value:
-        existing_value = _get_use_legacy_driver()
-        if (existing_value is not None) and (existing_value != value[CONF_USE_LEGACY]):
+        if (_use_legacy_driver is not None) and (
+            _use_legacy_driver != value[CONF_USE_LEGACY]
+        ):
             raise cv.Invalid(
                 f"All i2s_audio components must set {CONF_USE_LEGACY} to the same value."
             )
         if (not value[CONF_USE_LEGACY]) and (CORE.using_arduino):
             raise cv.Invalid("Arduino supports only the legacy i2s driver")
-        _set_use_legacy_driver(value[CONF_USE_LEGACY])
+        _use_legacy_driver = value[CONF_USE_LEGACY]
     return value
 
 
@@ -258,8 +249,7 @@ def _final_validate(_):
 
 
 def use_legacy():
-    legacy_driver = _get_use_legacy_driver()
-    return not (CORE.using_esp_idf and not legacy_driver)
+    return not (CORE.using_esp_idf and not _use_legacy_driver)
 
 
 FINAL_VALIDATE_SCHEMA = _final_validate

esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp

@@ -377,7 +377,7 @@ void I2SAudioSpeaker::speaker_task(void *params) {
             this_speaker->current_stream_info_.get_bits_per_sample() <= 16) {
           size_t len = bytes_read / sizeof(int16_t);
           int16_t *tmp_buf = (int16_t *) new_data;
-          for (size_t i = 0; i < len; i += 2) {
+          for (int i = 0; i < len; i += 2) {
             int16_t tmp = tmp_buf[i];
             tmp_buf[i] = tmp_buf[i + 1];
             tmp_buf[i + 1] = tmp;

esphome/components/ili9xxx/ili9xxx_display.cpp

@@ -325,7 +325,7 @@ void ILI9XXXDisplay::draw_pixels_at(int x_start, int y_start, int w, int h, cons
       // we could deal here with a non-zero y_offset, but if x_offset is zero, y_offset probably will be so don't bother
       this->write_array(ptr, w * h * 2);
     } else {
-      for (size_t y = 0; y != static_cast<size_t>(h); y++) {
+      for (size_t y = 0; y != h; y++) {
         this->write_array(ptr + (y + y_offset) * stride + x_offset, w * 2);
       }
     }
@@ -349,7 +349,7 @@ void ILI9XXXDisplay::draw_pixels_at(int x_start, int y_start, int w, int h, cons
         App.feed_wdt();
       }
       // end of line? Skip to the next.
-      if (++pixel == static_cast<size_t>(w)) {
+      if (++pixel == w) {
         pixel = 0;
         ptr += (x_pad + x_offset) * 2;
       }

esphome/components/json/json_util.cpp

@@ -8,13 +8,6 @@ namespace json {
 
 static const char *const TAG = "json";
 
-#ifdef USE_PSRAM
-// Global allocator that outlives all JsonDocuments returned by parse_json()
-// This prevents dangling pointer issues when JsonDocuments are returned from functions
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) - Must be mutable for ArduinoJson::Allocator
-static SpiRamAllocator global_json_allocator;
-#endif
-
 std::string build_json(const json_build_t &f) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   JsonBuilder builder;
@@ -26,21 +19,18 @@ std::string build_json(const json_build_t &f) {
 
 bool parse_json(const std::string &data, const json_parse_t &f) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-  JsonDocument doc = parse_json(reinterpret_cast<const uint8_t *>(data.c_str()), data.size());
+  JsonDocument doc = parse_json(data);
   if (doc.overflowed() || doc.isNull())
     return false;
   return f(doc.as<JsonObject>());
   // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 }
 
-JsonDocument parse_json(const uint8_t *data, size_t len) {
+JsonDocument parse_json(const std::string &data) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-  if (data == nullptr || len == 0) {
-    ESP_LOGE(TAG, "No data to parse");
-    return JsonObject();  // return unbound object
-  }
 #ifdef USE_PSRAM
-  JsonDocument json_document(&global_json_allocator);
+  auto doc_allocator = SpiRamAllocator();
+  JsonDocument json_document(&doc_allocator);
 #else
   JsonDocument json_document;
 #endif
@@ -48,7 +38,7 @@ JsonDocument parse_json(const uint8_t *data, size_t len) {
     ESP_LOGE(TAG, "Could not allocate memory for JSON document!");
     return JsonObject();  // return unbound object
   }
-  DeserializationError err = deserializeJson(json_document, data, len);
+  DeserializationError err = deserializeJson(json_document, data);
 
   if (err == DeserializationError::Ok) {
     return json_document;

esphome/components/json/json_util.h

@@ -50,13 +50,8 @@ std::string build_json(const json_build_t &f);
 
 /// Parse a JSON string and run the provided json parse function if it's valid.
 bool parse_json(const std::string &data, const json_parse_t &f);
-
 /// Parse a JSON string and return the root JsonDocument (or an unbound object on error)
-JsonDocument parse_json(const uint8_t *data, size_t len);
-/// Parse a JSON string and return the root JsonDocument (or an unbound object on error)
-inline JsonDocument parse_json(const std::string &data) {
-  return parse_json(reinterpret_cast<const uint8_t *>(data.c_str()), data.size());
-}
+JsonDocument parse_json(const std::string &data);
 
 /// Builder class for creating JSON documents without lambdas
 class JsonBuilder {

esphome/components/kamstrup_kmp/kamstrup_kmp.cpp

@@ -22,7 +22,7 @@ void KamstrupKMPComponent::dump_config() {
   LOG_SENSOR("  ", "Flow", this->flow_sensor_);
   LOG_SENSOR("  ", "Volume", this->volume_sensor_);
 
-  for (size_t i = 0; i < this->custom_sensors_.size(); i++) {
+  for (int i = 0; i < this->custom_sensors_.size(); i++) {
     LOG_SENSOR("  ", "Custom Sensor", this->custom_sensors_[i]);
     ESP_LOGCONFIG(TAG, "    Command: 0x%04X", this->custom_commands_[i]);
   }
@@ -268,7 +268,7 @@ void KamstrupKMPComponent::set_sensor_value_(uint16_t command, float value, uint
   }
 
   // Custom sensors
-  for (size_t i = 0; i < this->custom_commands_.size(); i++) {
+  for (int i = 0; i < this->custom_commands_.size(); i++) {
     if (command == this->custom_commands_[i]) {
       this->custom_sensors_[i]->publish_state(value);
     }

esphome/components/key_collector/key_collector.h

@@ -13,8 +13,8 @@ class KeyCollector : public Component {
   void loop() override;
   void dump_config() override;
   void set_provider(key_provider::KeyProvider *provider);
-  void set_min_length(uint32_t min_length) { this->min_length_ = min_length; };
-  void set_max_length(uint32_t max_length) { this->max_length_ = max_length; };
+  void set_min_length(int min_length) { this->min_length_ = min_length; };
+  void set_max_length(int max_length) { this->max_length_ = max_length; };
   void set_start_keys(std::string start_keys) { this->start_keys_ = std::move(start_keys); };
   void set_end_keys(std::string end_keys) { this->end_keys_ = std::move(end_keys); };
   void set_end_key_required(bool end_key_required) { this->end_key_required_ = end_key_required; };
@@ -33,8 +33,8 @@ class KeyCollector : public Component {
  protected:
   void key_pressed_(uint8_t key);
 
-  uint32_t min_length_{0};
-  uint32_t max_length_{0};
+  int min_length_{0};
+  int max_length_{0};
   std::string start_keys_;
   std::string end_keys_;
   bool end_key_required_{false};

esphome/components/light/light_call.cpp

@@ -10,15 +10,11 @@ namespace light {
 static const char *const TAG = "light";
 
 // Helper functions to reduce code size for logging
-static void clamp_and_log_if_invalid(const char *name, float &value, const LogString *param_name, float min = 0.0f,
-                                     float max = 1.0f) {
-  if (value < min || value > max) {
-    ESP_LOGW(TAG, "'%s': %s value %.2f is out of range [%.1f - %.1f]", name, LOG_STR_ARG(param_name), value, min, max);
-    value = clamp(value, min, max);
-  }
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_WARN
+static void log_validation_warning(const char *name, const LogString *param_name, float val, float min, float max) {
+  ESP_LOGW(TAG, "'%s': %s value %.2f is out of range [%.1f - %.1f]", name, LOG_STR_ARG(param_name), val, min, max);
 }
 
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_WARN
 static void log_feature_not_supported(const char *name, const LogString *feature) {
   ESP_LOGW(TAG, "'%s': %s not supported", name, LOG_STR_ARG(feature));
 }
@@ -31,6 +27,7 @@ static void log_invalid_parameter(const char *name, const LogString *message) {
   ESP_LOGW(TAG, "'%s': %s", name, LOG_STR_ARG(message));
 }
 #else
+#define log_validation_warning(name, param_name, val, min, max)
 #define log_feature_not_supported(name, feature)
 #define log_color_mode_not_supported(name, feature)
 #define log_invalid_parameter(name, message)
@@ -47,7 +44,7 @@ static void log_invalid_parameter(const char *name, const LogString *message) {
   } \
   LightCall &LightCall::set_##name(type name) { \
     this->name##_ = name; \
-    this->set_flag_(flag); \
+    this->set_flag_(flag, true); \
     return *this; \
   }
 
@@ -184,16 +181,6 @@ void LightCall::perform() {
   }
 }
 
-void LightCall::log_and_clear_unsupported_(FieldFlags flag, const LogString *feature, bool use_color_mode_log) {
-  auto *name = this->parent_->get_name().c_str();
-  if (use_color_mode_log) {
-    log_color_mode_not_supported(name, feature);
-  } else {
-    log_feature_not_supported(name, feature);
-  }
-  this->clear_flag_(flag);
-}
-
 LightColorValues LightCall::validate_() {
   auto *name = this->parent_->get_name().c_str();
   auto traits = this->parent_->get_traits();
@@ -201,108 +188,141 @@ LightColorValues LightCall::validate_() {
   // Color mode check
   if (this->has_color_mode() && !traits.supports_color_mode(this->color_mode_)) {
     ESP_LOGW(TAG, "'%s' does not support color mode %s", name, LOG_STR_ARG(color_mode_to_human(this->color_mode_)));
-    this->clear_flag_(FLAG_HAS_COLOR_MODE);
+    this->set_flag_(FLAG_HAS_COLOR_MODE, false);
   }
 
   // Ensure there is always a color mode set
   if (!this->has_color_mode()) {
     this->color_mode_ = this->compute_color_mode_();
-    this->set_flag_(FLAG_HAS_COLOR_MODE);
+    this->set_flag_(FLAG_HAS_COLOR_MODE, true);
   }
   auto color_mode = this->color_mode_;
 
   // Transform calls that use non-native parameters for the current mode.
   this->transform_parameters_();
 
-  // Business logic adjustments before validation
+  // Brightness exists check
+  if (this->has_brightness() && this->brightness_ > 0.0f && !(color_mode & ColorCapability::BRIGHTNESS)) {
+    log_feature_not_supported(name, LOG_STR("brightness"));
+    this->set_flag_(FLAG_HAS_BRIGHTNESS, false);
+  }
+
+  // Transition length possible check
+  if (this->has_transition_() && this->transition_length_ != 0 && !(color_mode & ColorCapability::BRIGHTNESS)) {
+    log_feature_not_supported(name, LOG_STR("transitions"));
+    this->set_flag_(FLAG_HAS_TRANSITION, false);
+  }
+
+  // Color brightness exists check
+  if (this->has_color_brightness() && this->color_brightness_ > 0.0f && !(color_mode & ColorCapability::RGB)) {
+    log_color_mode_not_supported(name, LOG_STR("RGB brightness"));
+    this->set_flag_(FLAG_HAS_COLOR_BRIGHTNESS, false);
+  }
+
+  // RGB exists check
+  if ((this->has_red() && this->red_ > 0.0f) || (this->has_green() && this->green_ > 0.0f) ||
+      (this->has_blue() && this->blue_ > 0.0f)) {
+    if (!(color_mode & ColorCapability::RGB)) {
+      log_color_mode_not_supported(name, LOG_STR("RGB color"));
+      this->set_flag_(FLAG_HAS_RED, false);
+      this->set_flag_(FLAG_HAS_GREEN, false);
+      this->set_flag_(FLAG_HAS_BLUE, false);
+    }
+  }
+
+  // White value exists check
+  if (this->has_white() && this->white_ > 0.0f &&
+      !(color_mode & ColorCapability::WHITE || color_mode & ColorCapability::COLD_WARM_WHITE)) {
+    log_color_mode_not_supported(name, LOG_STR("white value"));
+    this->set_flag_(FLAG_HAS_WHITE, false);
+  }
+
+  // Color temperature exists check
+  if (this->has_color_temperature() &&
+      !(color_mode & ColorCapability::COLOR_TEMPERATURE || color_mode & ColorCapability::COLD_WARM_WHITE)) {
+    log_color_mode_not_supported(name, LOG_STR("color temperature"));
+    this->set_flag_(FLAG_HAS_COLOR_TEMPERATURE, false);
+  }
+
+  // Cold/warm white value exists check
+  if ((this->has_cold_white() && this->cold_white_ > 0.0f) || (this->has_warm_white() && this->warm_white_ > 0.0f)) {
+    if (!(color_mode & ColorCapability::COLD_WARM_WHITE)) {
+      log_color_mode_not_supported(name, LOG_STR("cold/warm white value"));
+      this->set_flag_(FLAG_HAS_COLD_WHITE, false);
+      this->set_flag_(FLAG_HAS_WARM_WHITE, false);
+    }
+  }
+
+#define VALIDATE_RANGE_(name_, upper_name, min, max) \
+  if (this->has_##name_()) { \
+    auto val = this->name_##_; \
+    if (val < (min) || val > (max)) { \
+      log_validation_warning(name, LOG_STR(upper_name), val, (min), (max)); \
+      this->name_##_ = clamp(val, (min), (max)); \
+    } \
+  }
+#define VALIDATE_RANGE(name, upper_name) VALIDATE_RANGE_(name, upper_name, 0.0f, 1.0f)
+
+  // Range checks
+  VALIDATE_RANGE(brightness, "Brightness")
+  VALIDATE_RANGE(color_brightness, "Color brightness")
+  VALIDATE_RANGE(red, "Red")
+  VALIDATE_RANGE(green, "Green")
+  VALIDATE_RANGE(blue, "Blue")
+  VALIDATE_RANGE(white, "White")
+  VALIDATE_RANGE(cold_white, "Cold white")
+  VALIDATE_RANGE(warm_white, "Warm white")
+  VALIDATE_RANGE_(color_temperature, "Color temperature", traits.get_min_mireds(), traits.get_max_mireds())
+
   // Flag whether an explicit turn off was requested, in which case we'll also stop the effect.
   bool explicit_turn_off_request = this->has_state() && !this->state_;
 
   // Turn off when brightness is set to zero, and reset brightness (so that it has nonzero brightness when turned on).
   if (this->has_brightness() && this->brightness_ == 0.0f) {
     this->state_ = false;
-    this->set_flag_(FLAG_HAS_STATE);
+    this->set_flag_(FLAG_HAS_STATE, true);
     this->brightness_ = 1.0f;
   }
 
   // Set color brightness to 100% if currently zero and a color is set.
-  if ((this->has_red() || this->has_green() || this->has_blue()) && !this->has_color_brightness() &&
-      this->parent_->remote_values.get_color_brightness() == 0.0f) {
-    this->color_brightness_ = 1.0f;
-    this->set_flag_(FLAG_HAS_COLOR_BRIGHTNESS);
+  if (this->has_red() || this->has_green() || this->has_blue()) {
+    if (!this->has_color_brightness() && this->parent_->remote_values.get_color_brightness() == 0.0f) {
+      this->color_brightness_ = 1.0f;
+      this->set_flag_(FLAG_HAS_COLOR_BRIGHTNESS, true);
+    }
   }
 
-  // Capability validation
-  if (this->has_brightness() && this->brightness_ > 0.0f && !(color_mode & ColorCapability::BRIGHTNESS))
-    this->log_and_clear_unsupported_(FLAG_HAS_BRIGHTNESS, LOG_STR("brightness"), false);
-
-  // Transition length possible check
-  if (this->has_transition_() && this->transition_length_ != 0 && !(color_mode & ColorCapability::BRIGHTNESS))
-    this->log_and_clear_unsupported_(FLAG_HAS_TRANSITION, LOG_STR("transitions"), false);
-
-  if (this->has_color_brightness() && this->color_brightness_ > 0.0f && !(color_mode & ColorCapability::RGB))
-    this->log_and_clear_unsupported_(FLAG_HAS_COLOR_BRIGHTNESS, LOG_STR("RGB brightness"), true);
-
-  // RGB exists check
-  if (((this->has_red() && this->red_ > 0.0f) || (this->has_green() && this->green_ > 0.0f) ||
-       (this->has_blue() && this->blue_ > 0.0f)) &&
-      !(color_mode & ColorCapability::RGB)) {
-    log_color_mode_not_supported(name, LOG_STR("RGB color"));
-    this->clear_flag_(FLAG_HAS_RED);
-    this->clear_flag_(FLAG_HAS_GREEN);
-    this->clear_flag_(FLAG_HAS_BLUE);
-  }
-
-  // White value exists check
-  if (this->has_white() && this->white_ > 0.0f &&
-      !(color_mode & ColorCapability::WHITE || color_mode & ColorCapability::COLD_WARM_WHITE))
-    this->log_and_clear_unsupported_(FLAG_HAS_WHITE, LOG_STR("white value"), true);
-
-  // Color temperature exists check
-  if (this->has_color_temperature() &&
-      !(color_mode & ColorCapability::COLOR_TEMPERATURE || color_mode & ColorCapability::COLD_WARM_WHITE))
-    this->log_and_clear_unsupported_(FLAG_HAS_COLOR_TEMPERATURE, LOG_STR("color temperature"), true);
-
-  // Cold/warm white value exists check
-  if (((this->has_cold_white() && this->cold_white_ > 0.0f) || (this->has_warm_white() && this->warm_white_ > 0.0f)) &&
-      !(color_mode & ColorCapability::COLD_WARM_WHITE)) {
-    log_color_mode_not_supported(name, LOG_STR("cold/warm white value"));
-    this->clear_flag_(FLAG_HAS_COLD_WHITE);
-    this->clear_flag_(FLAG_HAS_WARM_WHITE);
-  }
-
-  // Create color values and validate+apply ranges in one step to eliminate duplicate checks
+  // Create color values for the light with this call applied.
   auto v = this->parent_->remote_values;
   if (this->has_color_mode())
     v.set_color_mode(this->color_mode_);
   if (this->has_state())
     v.set_state(this->state_);
-
-#define VALIDATE_AND_APPLY(field, setter, name_str, ...) \
-  if (this->has_##field()) { \
-    clamp_and_log_if_invalid(name, this->field##_, LOG_STR(name_str), ##__VA_ARGS__); \
-    v.setter(this->field##_); \
-  }
-
-  VALIDATE_AND_APPLY(brightness, set_brightness, "Brightness")
-  VALIDATE_AND_APPLY(color_brightness, set_color_brightness, "Color brightness")
-  VALIDATE_AND_APPLY(red, set_red, "Red")
-  VALIDATE_AND_APPLY(green, set_green, "Green")
-  VALIDATE_AND_APPLY(blue, set_blue, "Blue")
-  VALIDATE_AND_APPLY(white, set_white, "White")
-  VALIDATE_AND_APPLY(cold_white, set_cold_white, "Cold white")
-  VALIDATE_AND_APPLY(warm_white, set_warm_white, "Warm white")
-  VALIDATE_AND_APPLY(color_temperature, set_color_temperature, "Color temperature", traits.get_min_mireds(),
-                     traits.get_max_mireds())
-
-#undef VALIDATE_AND_APPLY
+  if (this->has_brightness())
+    v.set_brightness(this->brightness_);
+  if (this->has_color_brightness())
+    v.set_color_brightness(this->color_brightness_);
+  if (this->has_red())
+    v.set_red(this->red_);
+  if (this->has_green())
+    v.set_green(this->green_);
+  if (this->has_blue())
+    v.set_blue(this->blue_);
+  if (this->has_white())
+    v.set_white(this->white_);
+  if (this->has_color_temperature())
+    v.set_color_temperature(this->color_temperature_);
+  if (this->has_cold_white())
+    v.set_cold_white(this->cold_white_);
+  if (this->has_warm_white())
+    v.set_warm_white(this->warm_white_);
 
   v.normalize_color();
 
   // Flash length check
   if (this->has_flash_() && this->flash_length_ == 0) {
-    log_invalid_parameter(name, LOG_STR("flash length must be >0"));
-    this->clear_flag_(FLAG_HAS_FLASH);
+    log_invalid_parameter(name, LOG_STR("flash length must be greater than zero"));
+    this->set_flag_(FLAG_HAS_FLASH, false);
   }
 
   // validate transition length/flash length/effect not used at the same time
@@ -310,40 +330,42 @@ LightColorValues LightCall::validate_() {
 
   // If effect is already active, remove effect start
   if (this->has_effect_() && this->effect_ == this->parent_->active_effect_index_) {
-    this->clear_flag_(FLAG_HAS_EFFECT);
+    this->set_flag_(FLAG_HAS_EFFECT, false);
   }
 
   // validate effect index
   if (this->has_effect_() && this->effect_ > this->parent_->effects_.size()) {
     ESP_LOGW(TAG, "'%s': invalid effect index %" PRIu32, name, this->effect_);
-    this->clear_flag_(FLAG_HAS_EFFECT);
+    this->set_flag_(FLAG_HAS_EFFECT, false);
   }
 
   if (this->has_effect_() && (this->has_transition_() || this->has_flash_())) {
     log_invalid_parameter(name, LOG_STR("effect cannot be used with transition/flash"));
-    this->clear_flag_(FLAG_HAS_TRANSITION);
-    this->clear_flag_(FLAG_HAS_FLASH);
+    this->set_flag_(FLAG_HAS_TRANSITION, false);
+    this->set_flag_(FLAG_HAS_FLASH, false);
   }
 
   if (this->has_flash_() && this->has_transition_()) {
     log_invalid_parameter(name, LOG_STR("flash cannot be used with transition"));
-    this->clear_flag_(FLAG_HAS_TRANSITION);
+    this->set_flag_(FLAG_HAS_TRANSITION, false);
   }
 
   if (!this->has_transition_() && !this->has_flash_() && (!this->has_effect_() || this->effect_ == 0) &&
       supports_transition) {
     // nothing specified and light supports transitions, set default transition length
     this->transition_length_ = this->parent_->default_transition_length_;
-    this->set_flag_(FLAG_HAS_TRANSITION);
+    this->set_flag_(FLAG_HAS_TRANSITION, true);
   }
 
   if (this->has_transition_() && this->transition_length_ == 0) {
     // 0 transition is interpreted as no transition (instant change)
-    this->clear_flag_(FLAG_HAS_TRANSITION);
+    this->set_flag_(FLAG_HAS_TRANSITION, false);
   }
 
-  if (this->has_transition_() && !supports_transition)
-    this->log_and_clear_unsupported_(FLAG_HAS_TRANSITION, LOG_STR("transitions"), false);
+  if (this->has_transition_() && !supports_transition) {
+    log_feature_not_supported(name, LOG_STR("transitions"));
+    this->set_flag_(FLAG_HAS_TRANSITION, false);
+  }
 
   // If not a flash and turning the light off, then disable the light
   // Do not use light color values directly, so that effects can set 0% brightness
@@ -352,17 +374,17 @@ LightColorValues LightCall::validate_() {
   if (!this->has_flash_() && !target_state) {
     if (this->has_effect_()) {
       log_invalid_parameter(name, LOG_STR("cannot start effect when turning off"));
-      this->clear_flag_(FLAG_HAS_EFFECT);
+      this->set_flag_(FLAG_HAS_EFFECT, false);
     } else if (this->parent_->active_effect_index_ != 0 && explicit_turn_off_request) {
       // Auto turn off effect
       this->effect_ = 0;
-      this->set_flag_(FLAG_HAS_EFFECT);
+      this->set_flag_(FLAG_HAS_EFFECT, true);
     }
   }
 
   // Disable saving for flashes
   if (this->has_flash_())
-    this->clear_flag_(FLAG_SAVE);
+    this->set_flag_(FLAG_SAVE, false);
 
   return v;
 }
@@ -396,12 +418,12 @@ void LightCall::transform_parameters_() {
       const float gamma = this->parent_->get_gamma_correct();
       this->cold_white_ = gamma_uncorrect(cw_fraction / max_cw_ww, gamma);
       this->warm_white_ = gamma_uncorrect(ww_fraction / max_cw_ww, gamma);
-      this->set_flag_(FLAG_HAS_COLD_WHITE);
-      this->set_flag_(FLAG_HAS_WARM_WHITE);
+      this->set_flag_(FLAG_HAS_COLD_WHITE, true);
+      this->set_flag_(FLAG_HAS_WARM_WHITE, true);
     }
     if (this->has_white()) {
       this->brightness_ = this->white_;
-      this->set_flag_(FLAG_HAS_BRIGHTNESS);
+      this->set_flag_(FLAG_HAS_BRIGHTNESS, true);
     }
   }
 }
@@ -608,7 +630,7 @@ LightCall &LightCall::set_effect(optional<std::string> effect) {
 }
 LightCall &LightCall::set_effect(uint32_t effect_number) {
   this->effect_ = effect_number;
-  this->set_flag_(FLAG_HAS_EFFECT);
+  this->set_flag_(FLAG_HAS_EFFECT, true);
   return *this;
 }
 LightCall &LightCall::set_effect(optional<uint32_t> effect_number) {

esphome/components/light/light_call.h

@@ -4,10 +4,6 @@
 #include <set>
 
 namespace esphome {
-
-// Forward declaration
-struct LogString;
-
 namespace light {
 
 class LightState;
@@ -211,14 +207,14 @@ class LightCall {
     FLAG_SAVE = 1 << 15,
   };
 
-  inline bool has_transition_() { return (this->flags_ & FLAG_HAS_TRANSITION) != 0; }
-  inline bool has_flash_() { return (this->flags_ & FLAG_HAS_FLASH) != 0; }
-  inline bool has_effect_() { return (this->flags_ & FLAG_HAS_EFFECT) != 0; }
-  inline bool get_publish_() { return (this->flags_ & FLAG_PUBLISH) != 0; }
-  inline bool get_save_() { return (this->flags_ & FLAG_SAVE) != 0; }
+  bool has_transition_() { return (this->flags_ & FLAG_HAS_TRANSITION) != 0; }
+  bool has_flash_() { return (this->flags_ & FLAG_HAS_FLASH) != 0; }
+  bool has_effect_() { return (this->flags_ & FLAG_HAS_EFFECT) != 0; }
+  bool get_publish_() { return (this->flags_ & FLAG_PUBLISH) != 0; }
+  bool get_save_() { return (this->flags_ & FLAG_SAVE) != 0; }
 
-  // Helper to set flag - defaults to true for common case
-  void set_flag_(FieldFlags flag, bool value = true) {
+  // Helper to set flag
+  void set_flag_(FieldFlags flag, bool value) {
     if (value) {
       this->flags_ |= flag;
     } else {
@@ -226,12 +222,6 @@ class LightCall {
     }
   }
 
-  // Helper to clear flag - reduces code size for common case
-  void clear_flag_(FieldFlags flag) { this->flags_ &= ~flag; }
-
-  // Helper to log unsupported feature and clear flag - reduces code duplication
-  void log_and_clear_unsupported_(FieldFlags flag, const LogString *feature, bool use_color_mode_log);
-
   LightState *parent_;
 
   // Light state values - use flags_ to check if a value has been set.

esphome/components/lm75b/lm75b.cpp

@@ -1,39 +0,0 @@
-#include "lm75b.h"
-#include "esphome/core/log.h"
-#include "esphome/core/hal.h"
-
-namespace esphome {
-namespace lm75b {
-
-static const char *const TAG = "lm75b";
-
-void LM75BComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "LM75B:");
-  LOG_I2C_DEVICE(this);
-  if (this->is_failed()) {
-    ESP_LOGE(TAG, "Setting up LM75B failed!");
-  }
-  LOG_UPDATE_INTERVAL(this);
-  LOG_SENSOR("  ", "Temperature", this);
-}
-
-void LM75BComponent::update() {
-  // Create a temporary buffer
-  uint8_t buff[2];
-  if (this->read_register(LM75B_REG_TEMPERATURE, buff, 2) != i2c::ERROR_OK) {
-    this->status_set_warning();
-    return;
-  }
-  // Obtain combined 16-bit value
-  int16_t raw_temperature = (buff[0] << 8) | buff[1];
-  // Read the 11-bit raw temperature value
-  raw_temperature >>= 5;
-  // Publish the temperature in °C
-  this->publish_state(raw_temperature * 0.125);
-  if (this->status_has_warning()) {
-    this->status_clear_warning();
-  }
-}
-
-}  // namespace lm75b
-}  // namespace esphome

esphome/components/lm75b/lm75b.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/components/sensor/sensor.h"
-#include "esphome/components/i2c/i2c.h"
-
-namespace esphome {
-namespace lm75b {
-
-static const uint8_t LM75B_REG_TEMPERATURE = 0x00;
-
-class LM75BComponent : public PollingComponent, public i2c::I2CDevice, public sensor::Sensor {
- public:
-  void dump_config() override;
-  void update() override;
-};
-
-}  // namespace lm75b
-}  // namespace esphome

esphome/components/lm75b/sensor.py

@@ -1,34 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import i2c, sensor
-import esphome.config_validation as cv
-from esphome.const import (
-    DEVICE_CLASS_TEMPERATURE,
-    STATE_CLASS_MEASUREMENT,
-    UNIT_CELSIUS,
-)
-
-CODEOWNERS = ["@beormund"]
-DEPENDENCIES = ["i2c"]
-
-lm75b_ns = cg.esphome_ns.namespace("lm75b")
-LM75BComponent = lm75b_ns.class_(
-    "LM75BComponent", cg.PollingComponent, i2c.I2CDevice, sensor.Sensor
-)
-
-CONFIG_SCHEMA = (
-    sensor.sensor_schema(
-        LM75BComponent,
-        unit_of_measurement=UNIT_CELSIUS,
-        accuracy_decimals=3,
-        device_class=DEVICE_CLASS_TEMPERATURE,
-        state_class=STATE_CLASS_MEASUREMENT,
-    )
-    .extend(cv.polling_component_schema("60s"))
-    .extend(i2c.i2c_device_schema(0x48))
-)
-
-
-async def to_code(config):
-    var = await sensor.new_sensor(config)
-    await cg.register_component(var, config)
-    await i2c.register_i2c_device(var, config)

esphome/components/ltr501/ltr501.cpp

@@ -2,7 +2,6 @@
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include <limits>
 
 using esphome::i2c::ErrorCode;
 
@@ -29,30 +28,30 @@ bool operator!=(const GainTimePair &lhs, const GainTimePair &rhs) {
 
 template<typename T, size_t size> T get_next(const T (&array)[size], const T val) {
   size_t i = 0;
-  size_t idx = std::numeric_limits<size_t>::max();
-  while (idx == std::numeric_limits<size_t>::max() && i < size) {
+  size_t idx = -1;
+  while (idx == -1 && i < size) {
     if (array[i] == val) {
       idx = i;
       break;
     }
     i++;
   }
-  if (idx == std::numeric_limits<size_t>::max() || i + 1 >= size)
+  if (idx == -1 || i + 1 >= size)
     return val;
   return array[i + 1];
 }
 
 template<typename T, size_t size> T get_prev(const T (&array)[size], const T val) {
   size_t i = size - 1;
-  size_t idx = std::numeric_limits<size_t>::max();
-  while (idx == std::numeric_limits<size_t>::max() && i > 0) {
+  size_t idx = -1;
+  while (idx == -1 && i > 0) {
     if (array[i] == val) {
       idx = i;
       break;
     }
     i--;
   }
-  if (idx == std::numeric_limits<size_t>::max() || i == 0)
+  if (idx == -1 || i == 0)
     return val;
   return array[i - 1];
 }

esphome/components/ltr_als_ps/ltr_als_ps.cpp

@@ -2,7 +2,6 @@
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include <limits>
 
 using esphome::i2c::ErrorCode;
 
@@ -15,30 +14,30 @@ static const uint8_t MAX_TRIES = 5;
 
 template<typename T, size_t size> T get_next(const T (&array)[size], const T val) {
   size_t i = 0;
-  size_t idx = std::numeric_limits<size_t>::max();
-  while (idx == std::numeric_limits<size_t>::max() && i < size) {
+  size_t idx = -1;
+  while (idx == -1 && i < size) {
     if (array[i] == val) {
       idx = i;
       break;
     }
     i++;
   }
-  if (idx == std::numeric_limits<size_t>::max() || i + 1 >= size)
+  if (idx == -1 || i + 1 >= size)
     return val;
   return array[i + 1];
 }
 
 template<typename T, size_t size> T get_prev(const T (&array)[size], const T val) {
   size_t i = size - 1;
-  size_t idx = std::numeric_limits<size_t>::max();
-  while (idx == std::numeric_limits<size_t>::max() && i > 0) {
+  size_t idx = -1;
+  while (idx == -1 && i > 0) {
     if (array[i] == val) {
       idx = i;
       break;
     }
     i--;
   }
-  if (idx == std::numeric_limits<size_t>::max() || i == 0)
+  if (idx == -1 || i == 0)
     return val;
   return array[i - 1];
 }

esphome/components/matrix_keypad/matrix_keypad.h

@@ -29,9 +29,9 @@ class MatrixKeypad : public key_provider::KeyProvider, public Component {
   void set_columns(std::vector<GPIOPin *> pins) { columns_ = std::move(pins); };
   void set_rows(std::vector<GPIOPin *> pins) { rows_ = std::move(pins); };
   void set_keys(std::string keys) { keys_ = std::move(keys); };
-  void set_debounce_time(uint32_t debounce_time) { debounce_time_ = debounce_time; };
-  void set_has_diodes(bool has_diodes) { has_diodes_ = has_diodes; };
-  void set_has_pulldowns(bool has_pulldowns) { has_pulldowns_ = has_pulldowns; };
+  void set_debounce_time(int debounce_time) { debounce_time_ = debounce_time; };
+  void set_has_diodes(int has_diodes) { has_diodes_ = has_diodes; };
+  void set_has_pulldowns(int has_pulldowns) { has_pulldowns_ = has_pulldowns; };
 
   void register_listener(MatrixKeypadListener *listener);
   void register_key_trigger(MatrixKeyTrigger *trig);
@@ -40,7 +40,7 @@ class MatrixKeypad : public key_provider::KeyProvider, public Component {
   std::vector<GPIOPin *> rows_;
   std::vector<GPIOPin *> columns_;
   std::string keys_;
-  uint32_t debounce_time_ = 0;
+  int debounce_time_ = 0;
   bool has_diodes_{false};
   bool has_pulldowns_{false};
   int pressed_key_ = -1;

esphome/components/max7219digit/max7219digit.cpp

@@ -90,7 +90,7 @@ void MAX7219Component::loop() {
   }
 
   if (this->scroll_mode_ == ScrollMode::STOP) {
-    if (static_cast<size_t>(this->stepsleft_ + get_width_internal()) == first_line_size + 1) {
+    if (this->stepsleft_ + get_width_internal() == first_line_size + 1) {
       if (millis_since_last_scroll < this->scroll_dwell_) {
         ESP_LOGVV(TAG, "Dwell time at end of string in case of stop at end. Step %d, since last scroll %d, dwell %d.",
                   this->stepsleft_, millis_since_last_scroll, this->scroll_dwell_);

esphome/components/mcp23xxx_base/mcp23xxx_base.h

@@ -21,11 +21,11 @@ template<uint8_t N> class MCP23XXXBase : public Component, public gpio_expander:
 
  protected:
   // read a given register
-  virtual bool read_reg(uint8_t reg, uint8_t *value) = 0;
+  virtual bool read_reg(uint8_t reg, uint8_t *value);
   // write a value to a given register
-  virtual bool write_reg(uint8_t reg, uint8_t value) = 0;
+  virtual bool write_reg(uint8_t reg, uint8_t value);
   // update registers with given pin value.
-  virtual void update_reg(uint8_t pin, bool pin_value, uint8_t reg_a) = 0;
+  virtual void update_reg(uint8_t pin, bool pin_value, uint8_t reg_a);
 
   bool open_drain_ints_;
 };

esphome/components/mcp2515/mcp2515.cpp

@@ -20,23 +20,6 @@ bool MCP2515::setup_internal() {
     return false;
   if (this->set_bitrate_(this->bit_rate_, this->mcp_clock_) != canbus::ERROR_OK)
     return false;
-
-  // setup hardware filter RXF0 accepting all standard CAN IDs
-  if (this->set_filter_(RXF::RXF0, false, 0) != canbus::ERROR_OK) {
-    return false;
-  }
-  if (this->set_filter_mask_(MASK::MASK0, false, 0) != canbus::ERROR_OK) {
-    return false;
-  }
-
-  // setup hardware filter RXF1 accepting all extended CAN IDs
-  if (this->set_filter_(RXF::RXF1, true, 0) != canbus::ERROR_OK) {
-    return false;
-  }
-  if (this->set_filter_mask_(MASK::MASK1, true, 0) != canbus::ERROR_OK) {
-    return false;
-  }
-
   if (this->set_mode_(this->mcp_mode_) != canbus::ERROR_OK)
     return false;
   uint8_t err_flags = this->get_error_flags_();

esphome/components/mdns/__init__.py

@@ -1,6 +1,6 @@
 import esphome.codegen as cg
 from esphome.components.esp32 import add_idf_component
-from esphome.config_helpers import filter_source_files_from_platform, get_logger_level
+from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_DISABLED,
@@ -11,7 +11,7 @@ from esphome.const import (
     CONF_SERVICES,
     PlatformFramework,
 )
-from esphome.core import CORE, Lambda, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
 
 CODEOWNERS = ["@esphome/core"]
@@ -58,84 +58,26 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-def mdns_txt_record(key: str, value: str) -> cg.RawExpression:
-    """Create a mDNS TXT record.
-
-    Public API for external components. Do not remove.
-
-    Args:
-        key: The TXT record key
-        value: The TXT record value (static string only)
-
-    Returns:
-        A RawExpression representing a MDNSTXTRecord struct
-    """
-    return cg.RawExpression(
-        f"{{MDNS_STR({cg.safe_exp(key)}), MDNS_STR({cg.safe_exp(value)})}}"
+def mdns_txt_record(key: str, value: str):
+    return cg.StructInitializer(
+        MDNSTXTRecord,
+        ("key", key),
+        ("value", value),
     )
 
 
-async def _mdns_txt_record_templated(
-    mdns_comp: cg.Pvariable, key: str, value: Lambda | str
-) -> cg.RawExpression:
-    """Create a mDNS TXT record with support for templated values.
-
-    Internal helper function.
-
-    Args:
-        mdns_comp: The MDNSComponent instance (from cg.get_variable())
-        key: The TXT record key
-        value: The TXT record value (can be a static string or a lambda template)
-
-    Returns:
-        A RawExpression representing a MDNSTXTRecord struct
-    """
-    if not cg.is_template(value):
-        # It's a static string - use directly in flash, no need to store in vector
-        return mdns_txt_record(key, value)
-    # It's a lambda - evaluate and store using helper
-    templated_value = await cg.templatable(value, [], cg.std_string)
-    safe_key = cg.safe_exp(key)
-    dynamic_call = f"{mdns_comp}->add_dynamic_txt_value(({templated_value})())"
-    return cg.RawExpression(f"{{MDNS_STR({safe_key}), MDNS_STR({dynamic_call})}}")
-
-
 def mdns_service(
-    service: str, proto: str, port: int, txt_records: list[cg.RawExpression]
-) -> cg.StructInitializer:
-    """Create a mDNS service.
-
-    Public API for external components. Do not remove.
-
-    Args:
-        service: Service name (e.g., "_http")
-        proto: Protocol (e.g., "_tcp" or "_udp")
-        port: Port number
-        txt_records: List of MDNSTXTRecord expressions
-
-    Returns:
-        A StructInitializer representing a MDNSService struct
-    """
+    service: str, proto: str, port: int, txt_records: list[dict[str, str]]
+):
     return cg.StructInitializer(
         MDNSService,
-        ("service_type", cg.RawExpression(f"MDNS_STR({cg.safe_exp(service)})")),
-        ("proto", cg.RawExpression(f"MDNS_STR({cg.safe_exp(proto)})")),
+        ("service_type", service),
+        ("proto", proto),
         ("port", port),
         ("txt_records", txt_records),
     )
 
 
-def enable_mdns_storage():
-    """Enable persistent storage of mDNS services in the MDNSComponent.
-
-    Called by external components (like OpenThread) that need access to
-    services after setup() completes via get_services().
-
-    Public API for external components. Do not remove.
-    """
-    cg.add_define("USE_MDNS_STORE_SERVICES")
-
-
 @coroutine_with_priority(CoroPriority.NETWORK_SERVICES)
 async def to_code(config):
     if config[CONF_DISABLED] is True:
@@ -161,47 +103,27 @@ async def to_code(config):
 
     if config[CONF_SERVICES]:
         cg.add_define("USE_MDNS_EXTRA_SERVICES")
-        # Extra services need to be stored persistently
-        enable_mdns_storage()
 
     # Ensure at least 1 service (fallback service)
     cg.add_define("MDNS_SERVICE_COUNT", max(1, service_count))
 
-    # Calculate compile-time dynamic TXT value count
-    # Dynamic values are those that cannot be stored in flash at compile time
-    dynamic_txt_count = 0
-    if "api" in CORE.config:
-        # Always: get_mac_address()
-        dynamic_txt_count += 1
-    # User-provided templatable TXT values (only lambdas, not static strings)
-    dynamic_txt_count += sum(
-        1
-        for service in config[CONF_SERVICES]
-        for txt_value in service[CONF_TXT].values()
-        if cg.is_template(txt_value)
-    )
-
-    # Ensure at least 1 to avoid zero-size array
-    cg.add_define("MDNS_DYNAMIC_TXT_COUNT", max(1, dynamic_txt_count))
-
-    # Enable storage if verbose logging is enabled (for dump_config)
-    if get_logger_level() in ("VERBOSE", "VERY_VERBOSE"):
-        enable_mdns_storage()
-
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
     for service in config[CONF_SERVICES]:
-        txt_records = [
-            await _mdns_txt_record_templated(var, txt_key, txt_value)
+        txt = [
+            cg.StructInitializer(
+                MDNSTXTRecord,
+                ("key", txt_key),
+                ("value", await cg.templatable(txt_value, [], cg.std_string)),
+            )
             for txt_key, txt_value in service[CONF_TXT].items()
         ]
-
         exp = mdns_service(
             service[CONF_SERVICE],
             service[CONF_PROTOCOL],
             await cg.templatable(service[CONF_PORT], [], cg.uint16),
-            txt_records,
+            txt,
         )
 
         cg.add(var.add_extra_service(exp))

esphome/components/mdns/mdns_component.cpp

@@ -9,9 +9,24 @@
 #include <pgmspace.h>
 // Macro to define strings in PROGMEM on ESP8266, regular memory on other platforms
 #define MDNS_STATIC_CONST_CHAR(name, value) static const char name[] PROGMEM = value
+// Helper to get string from PROGMEM - returns a temporary std::string
+// Only define this function if we have services that will use it
+#if defined(USE_API) || defined(USE_PROMETHEUS) || defined(USE_WEBSERVER) || defined(USE_MDNS_EXTRA_SERVICES)
+static std::string mdns_string_p(const char *src) {
+  char buf[64];
+  strncpy_P(buf, src, sizeof(buf) - 1);
+  buf[sizeof(buf) - 1] = '\0';
+  return std::string(buf);
+}
+#define MDNS_STR(name) mdns_string_p(name)
+#else
+// If no services are configured, we still need the fallback service but it uses string literals
+#define MDNS_STR(name) std::string(name)
+#endif
 #else
 // On non-ESP8266 platforms, use regular const char*
-#define MDNS_STATIC_CONST_CHAR(name, value) static constexpr const char name[] = value
+#define MDNS_STATIC_CONST_CHAR(name, value) static constexpr const char *name = value
+#define MDNS_STR(name) name
 #endif
 
 #ifdef USE_API
@@ -31,29 +46,40 @@ static const char *const TAG = "mdns";
 #endif
 
 // Define all constant strings using the macro
+MDNS_STATIC_CONST_CHAR(SERVICE_ESPHOMELIB, "_esphomelib");
 MDNS_STATIC_CONST_CHAR(SERVICE_TCP, "_tcp");
+MDNS_STATIC_CONST_CHAR(SERVICE_PROMETHEUS, "_prometheus-http");
+MDNS_STATIC_CONST_CHAR(SERVICE_HTTP, "_http");
 
-// Wrap build-time defines into flash storage
-MDNS_STATIC_CONST_CHAR(VALUE_VERSION, ESPHOME_VERSION);
+MDNS_STATIC_CONST_CHAR(TXT_FRIENDLY_NAME, "friendly_name");
+MDNS_STATIC_CONST_CHAR(TXT_VERSION, "version");
+MDNS_STATIC_CONST_CHAR(TXT_MAC, "mac");
+MDNS_STATIC_CONST_CHAR(TXT_PLATFORM, "platform");
+MDNS_STATIC_CONST_CHAR(TXT_BOARD, "board");
+MDNS_STATIC_CONST_CHAR(TXT_NETWORK, "network");
+MDNS_STATIC_CONST_CHAR(TXT_API_ENCRYPTION, "api_encryption");
+MDNS_STATIC_CONST_CHAR(TXT_API_ENCRYPTION_SUPPORTED, "api_encryption_supported");
+MDNS_STATIC_CONST_CHAR(TXT_PROJECT_NAME, "project_name");
+MDNS_STATIC_CONST_CHAR(TXT_PROJECT_VERSION, "project_version");
+MDNS_STATIC_CONST_CHAR(TXT_PACKAGE_IMPORT_URL, "package_import_url");
 
-void MDNSComponent::compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUNT> &services) {
+MDNS_STATIC_CONST_CHAR(PLATFORM_ESP8266, "ESP8266");
+MDNS_STATIC_CONST_CHAR(PLATFORM_ESP32, "ESP32");
+MDNS_STATIC_CONST_CHAR(PLATFORM_RP2040, "RP2040");
+
+MDNS_STATIC_CONST_CHAR(NETWORK_WIFI, "wifi");
+MDNS_STATIC_CONST_CHAR(NETWORK_ETHERNET, "ethernet");
+MDNS_STATIC_CONST_CHAR(NETWORK_THREAD, "thread");
+
+void MDNSComponent::compile_records_() {
   this->hostname_ = App.get_name();
 
   // IMPORTANT: The #ifdef blocks below must match COMPONENTS_WITH_MDNS_SERVICES
   // in mdns/__init__.py. If you add a new service here, update both locations.
 
 #ifdef USE_API
-  MDNS_STATIC_CONST_CHAR(SERVICE_ESPHOMELIB, "_esphomelib");
-  MDNS_STATIC_CONST_CHAR(TXT_FRIENDLY_NAME, "friendly_name");
-  MDNS_STATIC_CONST_CHAR(TXT_VERSION, "version");
-  MDNS_STATIC_CONST_CHAR(TXT_MAC, "mac");
-  MDNS_STATIC_CONST_CHAR(TXT_PLATFORM, "platform");
-  MDNS_STATIC_CONST_CHAR(TXT_BOARD, "board");
-  MDNS_STATIC_CONST_CHAR(TXT_NETWORK, "network");
-  MDNS_STATIC_CONST_CHAR(VALUE_BOARD, ESPHOME_BOARD);
-
   if (api::global_api_server != nullptr) {
-    auto &service = services.emplace_next();
+    auto &service = this->services_.emplace_next();
     service.service_type = MDNS_STR(SERVICE_ESPHOMELIB);
     service.proto = MDNS_STR(SERVICE_TCP);
     service.port = api::global_api_server->get_port();
@@ -86,97 +112,73 @@ void MDNSComponent::compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUN
     txt_records.reserve(txt_count);
 
     if (!friendly_name_empty) {
-      txt_records.push_back({MDNS_STR(TXT_FRIENDLY_NAME), MDNS_STR(friendly_name.c_str())});
+      txt_records.push_back({MDNS_STR(TXT_FRIENDLY_NAME), friendly_name});
     }
-    txt_records.push_back({MDNS_STR(TXT_VERSION), MDNS_STR(VALUE_VERSION)});
-    txt_records.push_back({MDNS_STR(TXT_MAC), MDNS_STR(this->add_dynamic_txt_value(get_mac_address()))});
+    txt_records.push_back({MDNS_STR(TXT_VERSION), ESPHOME_VERSION});
+    txt_records.push_back({MDNS_STR(TXT_MAC), get_mac_address()});
 
 #ifdef USE_ESP8266
-    MDNS_STATIC_CONST_CHAR(PLATFORM_ESP8266, "ESP8266");
     txt_records.push_back({MDNS_STR(TXT_PLATFORM), MDNS_STR(PLATFORM_ESP8266)});
 #elif defined(USE_ESP32)
-    MDNS_STATIC_CONST_CHAR(PLATFORM_ESP32, "ESP32");
     txt_records.push_back({MDNS_STR(TXT_PLATFORM), MDNS_STR(PLATFORM_ESP32)});
 #elif defined(USE_RP2040)
-    MDNS_STATIC_CONST_CHAR(PLATFORM_RP2040, "RP2040");
     txt_records.push_back({MDNS_STR(TXT_PLATFORM), MDNS_STR(PLATFORM_RP2040)});
 #elif defined(USE_LIBRETINY)
-    txt_records.push_back({MDNS_STR(TXT_PLATFORM), MDNS_STR(lt_cpu_get_model_name())});
+    txt_records.emplace_back(MDNSTXTRecord{"platform", lt_cpu_get_model_name()});
 #endif
 
-    txt_records.push_back({MDNS_STR(TXT_BOARD), MDNS_STR(VALUE_BOARD)});
+    txt_records.push_back({MDNS_STR(TXT_BOARD), ESPHOME_BOARD});
 
 #if defined(USE_WIFI)
-    MDNS_STATIC_CONST_CHAR(NETWORK_WIFI, "wifi");
     txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(NETWORK_WIFI)});
 #elif defined(USE_ETHERNET)
-    MDNS_STATIC_CONST_CHAR(NETWORK_ETHERNET, "ethernet");
     txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(NETWORK_ETHERNET)});
 #elif defined(USE_OPENTHREAD)
-    MDNS_STATIC_CONST_CHAR(NETWORK_THREAD, "thread");
     txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(NETWORK_THREAD)});
 #endif
 
 #ifdef USE_API_NOISE
-    MDNS_STATIC_CONST_CHAR(TXT_API_ENCRYPTION, "api_encryption");
-    MDNS_STATIC_CONST_CHAR(TXT_API_ENCRYPTION_SUPPORTED, "api_encryption_supported");
     MDNS_STATIC_CONST_CHAR(NOISE_ENCRYPTION, "Noise_NNpsk0_25519_ChaChaPoly_SHA256");
-    bool has_psk = api::global_api_server->get_noise_ctx()->has_psk();
-    const char *encryption_key = has_psk ? TXT_API_ENCRYPTION : TXT_API_ENCRYPTION_SUPPORTED;
-    txt_records.push_back({MDNS_STR(encryption_key), MDNS_STR(NOISE_ENCRYPTION)});
+    if (api::global_api_server->get_noise_ctx()->has_psk()) {
+      txt_records.push_back({MDNS_STR(TXT_API_ENCRYPTION), MDNS_STR(NOISE_ENCRYPTION)});
+    } else {
+      txt_records.push_back({MDNS_STR(TXT_API_ENCRYPTION_SUPPORTED), MDNS_STR(NOISE_ENCRYPTION)});
+    }
 #endif
 
 #ifdef ESPHOME_PROJECT_NAME
-    MDNS_STATIC_CONST_CHAR(TXT_PROJECT_NAME, "project_name");
-    MDNS_STATIC_CONST_CHAR(TXT_PROJECT_VERSION, "project_version");
-    MDNS_STATIC_CONST_CHAR(VALUE_PROJECT_NAME, ESPHOME_PROJECT_NAME);
-    MDNS_STATIC_CONST_CHAR(VALUE_PROJECT_VERSION, ESPHOME_PROJECT_VERSION);
-    txt_records.push_back({MDNS_STR(TXT_PROJECT_NAME), MDNS_STR(VALUE_PROJECT_NAME)});
-    txt_records.push_back({MDNS_STR(TXT_PROJECT_VERSION), MDNS_STR(VALUE_PROJECT_VERSION)});
+    txt_records.push_back({MDNS_STR(TXT_PROJECT_NAME), ESPHOME_PROJECT_NAME});
+    txt_records.push_back({MDNS_STR(TXT_PROJECT_VERSION), ESPHOME_PROJECT_VERSION});
 #endif  // ESPHOME_PROJECT_NAME
 
 #ifdef USE_DASHBOARD_IMPORT
-    MDNS_STATIC_CONST_CHAR(TXT_PACKAGE_IMPORT_URL, "package_import_url");
-    txt_records.push_back(
-        {MDNS_STR(TXT_PACKAGE_IMPORT_URL), MDNS_STR(dashboard_import::get_package_import_url().c_str())});
+    txt_records.push_back({MDNS_STR(TXT_PACKAGE_IMPORT_URL), dashboard_import::get_package_import_url()});
 #endif
   }
 #endif  // USE_API
 
 #ifdef USE_PROMETHEUS
-  MDNS_STATIC_CONST_CHAR(SERVICE_PROMETHEUS, "_prometheus-http");
-
-  auto &prom_service = services.emplace_next();
+  auto &prom_service = this->services_.emplace_next();
   prom_service.service_type = MDNS_STR(SERVICE_PROMETHEUS);
   prom_service.proto = MDNS_STR(SERVICE_TCP);
   prom_service.port = USE_WEBSERVER_PORT;
 #endif
 
 #ifdef USE_WEBSERVER
-  MDNS_STATIC_CONST_CHAR(SERVICE_HTTP, "_http");
-
-  auto &web_service = services.emplace_next();
+  auto &web_service = this->services_.emplace_next();
   web_service.service_type = MDNS_STR(SERVICE_HTTP);
   web_service.proto = MDNS_STR(SERVICE_TCP);
   web_service.port = USE_WEBSERVER_PORT;
 #endif
 
 #if !defined(USE_API) && !defined(USE_PROMETHEUS) && !defined(USE_WEBSERVER) && !defined(USE_MDNS_EXTRA_SERVICES)
-  MDNS_STATIC_CONST_CHAR(SERVICE_HTTP, "_http");
-  MDNS_STATIC_CONST_CHAR(TXT_VERSION, "version");
-
   // Publish "http" service if not using native API or any other services
   // This is just to have *some* mDNS service so that .local resolution works
-  auto &fallback_service = services.emplace_next();
-  fallback_service.service_type = MDNS_STR(SERVICE_HTTP);
-  fallback_service.proto = MDNS_STR(SERVICE_TCP);
+  auto &fallback_service = this->services_.emplace_next();
+  fallback_service.service_type = "_http";
+  fallback_service.proto = "_tcp";
   fallback_service.port = USE_WEBSERVER_PORT;
-  fallback_service.txt_records.push_back({MDNS_STR(TXT_VERSION), MDNS_STR(VALUE_VERSION)});
-#endif
-
-#ifdef USE_MDNS_STORE_SERVICES
-  // Copy to member variable if storage is enabled (verbose logging, OpenThread, or extra services)
-  this->services_ = services;
+  fallback_service.txt_records.emplace_back(MDNSTXTRecord{"version", ESPHOME_VERSION});
 #endif
 }
 
@@ -185,13 +187,14 @@ void MDNSComponent::dump_config() {
                 "mDNS:\n"
                 "  Hostname: %s",
                 this->hostname_.c_str());
-#ifdef USE_MDNS_STORE_SERVICES
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
   ESP_LOGV(TAG, "  Services:");
   for (const auto &service : this->services_) {
-    ESP_LOGV(TAG, "  - %s, %s, %d", MDNS_STR_ARG(service.service_type), MDNS_STR_ARG(service.proto),
+    ESP_LOGV(TAG, "  - %s, %s, %d", service.service_type.c_str(), service.proto.c_str(),
              const_cast<TemplatableValue<uint16_t> &>(service.port).value());
     for (const auto &record : service.txt_records) {
-      ESP_LOGV(TAG, "    TXT: %s = %s", MDNS_STR_ARG(record.key), MDNS_STR_ARG(record.value));
+      ESP_LOGV(TAG, "    TXT: %s = %s", record.key.c_str(),
+               const_cast<TemplatableValue<std::string> &>(record.value).value().c_str());
     }
   }
 #endif

esphome/components/mdns/mdns_component.h

@@ -9,34 +9,21 @@
 namespace esphome {
 namespace mdns {
 
-// Helper struct that identifies strings that may be stored in flash storage (similar to LogString)
-struct MDNSString;
-
-// Macro to cast string literals to MDNSString* (works on all platforms)
-#define MDNS_STR(name) (reinterpret_cast<const esphome::mdns::MDNSString *>(name))
-
-#ifdef USE_ESP8266
-#include <pgmspace.h>
-#define MDNS_STR_ARG(s) ((PGM_P) (s))
-#else
-#define MDNS_STR_ARG(s) (reinterpret_cast<const char *>(s))
-#endif
-
 // Service count is calculated at compile time by Python codegen
 // MDNS_SERVICE_COUNT will always be defined
 
 struct MDNSTXTRecord {
-  const MDNSString *key;
-  const MDNSString *value;
+  std::string key;
+  TemplatableValue<std::string> value;
 };
 
 struct MDNSService {
   // service name _including_ underscore character prefix
   // as defined in RFC6763 Section 7
-  const MDNSString *service_type;
+  std::string service_type;
   // second label indicating protocol _including_ underscore character prefix
   // as defined in RFC6763 Section 7, like "_tcp" or "_udp"
-  const MDNSString *proto;
+  std::string proto;
   TemplatableValue<uint16_t> port;
   std::vector<MDNSTXTRecord> txt_records;
 };
@@ -55,29 +42,14 @@ class MDNSComponent : public Component {
   void add_extra_service(MDNSService service) { this->services_.emplace_next() = std::move(service); }
 #endif
 
-#ifdef USE_MDNS_STORE_SERVICES
   const StaticVector<MDNSService, MDNS_SERVICE_COUNT> &get_services() const { return this->services_; }
-#endif
 
   void on_shutdown() override;
 
-  /// Add a dynamic TXT value and return pointer to it for use in MDNSTXTRecord
-  const char *add_dynamic_txt_value(const std::string &value) {
-    this->dynamic_txt_values_.push_back(value);
-    return this->dynamic_txt_values_[this->dynamic_txt_values_.size() - 1].c_str();
-  }
-
-  /// Storage for runtime-generated TXT values (MAC address, user lambdas)
-  /// Pre-sized at compile time via MDNS_DYNAMIC_TXT_COUNT to avoid heap allocations.
-  /// Static/compile-time values (version, board, etc.) are stored directly in flash and don't use this.
-  StaticVector<std::string, MDNS_DYNAMIC_TXT_COUNT> dynamic_txt_values_;
-
  protected:
-#ifdef USE_MDNS_STORE_SERVICES
   StaticVector<MDNSService, MDNS_SERVICE_COUNT> services_{};
-#endif
   std::string hostname_;
-  void compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUNT> &services);
+  void compile_records_();
 };
 
 }  // namespace mdns