Set ble tx power

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

@@ -17,7 +17,7 @@ runs:
   steps:
     - name: Set up Python ${{ inputs.python-version }}
       id: python
-      uses: actions/setup-python@v6.0.0
+      uses: actions/setup-python@v5.6.0
       with:
         python-version: ${{ inputs.python-version }}
     - name: Restore Python virtual environment

.github/workflows/auto-label-pr.yml

@@ -32,7 +32,7 @@ jobs:
           private-key: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
 
       - name: Auto Label PR
-        uses: actions/github-script@v8.0.0
+        uses: actions/github-script@v7.0.1
         with:
           github-token: ${{ steps.generate-token.outputs.token }}
           script: |

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

@@ -23,7 +23,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v5.0.0
       - name: Set up Python
-        uses: actions/setup-python@v6.0.0
+        uses: actions/setup-python@v5.6.0
         with:
           python-version: "3.11"
 
@@ -47,7 +47,7 @@ jobs:
           fi
       - if: failure()
         name: Review PR
-        uses: actions/github-script@v8.0.0
+        uses: actions/github-script@v7.0.1
         with:
           script: |
             await github.rest.pulls.createReview({
@@ -70,7 +70,7 @@ jobs:
             esphome/components/api/api_pb2_service.*
       - if: success()
         name: Dismiss review
-        uses: actions/github-script@v8.0.0
+        uses: actions/github-script@v7.0.1
         with:
           script: |
             let reviews = await github.rest.pulls.listReviews({

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

@@ -23,7 +23,7 @@ jobs:
         uses: actions/checkout@v5.0.0
 
       - name: Set up Python
-        uses: actions/setup-python@v6.0.0
+        uses: actions/setup-python@v5.6.0
         with:
           python-version: "3.11"
 
@@ -41,7 +41,7 @@ jobs:
 
       - if: failure()
         name: Request changes
-        uses: actions/github-script@v8.0.0
+        uses: actions/github-script@v7.0.1
         with:
           script: |
             await github.rest.pulls.createReview({
@@ -54,7 +54,7 @@ jobs:
 
       - if: success()
         name: Dismiss review
-        uses: actions/github-script@v8.0.0
+        uses: actions/github-script@v7.0.1
         with:
           script: |
             let reviews = await github.rest.pulls.listReviews({

.github/workflows/ci-docker.yml

@@ -45,7 +45,7 @@ jobs:
     steps:
       - uses: actions/checkout@v5.0.0
       - name: Set up Python
-        uses: actions/setup-python@v6.0.0
+        uses: actions/setup-python@v5.6.0
         with:
           python-version: "3.11"
       - name: Set up Docker Buildx

.github/workflows/ci.yml

@@ -42,7 +42,7 @@ jobs:
         run: echo key="${{ hashFiles('requirements.txt', 'requirements_test.txt', '.pre-commit-config.yaml') }}" >> $GITHUB_OUTPUT
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         id: python
-        uses: actions/setup-python@v6.0.0
+        uses: actions/setup-python@v5.6.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
       - name: Restore Python virtual environment
@@ -156,7 +156,7 @@ jobs:
           . venv/bin/activate
           pytest -vv --cov-report=xml --tb=native -n auto tests --ignore=tests/integration/
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v5.5.1
+        uses: codecov/codecov-action@v5.5.0
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
       - name: Save Python virtual environment cache
@@ -217,7 +217,7 @@ jobs:
         uses: actions/checkout@v5.0.0
       - name: Set up Python 3.13
         id: python
-        uses: actions/setup-python@v6.0.0
+        uses: actions/setup-python@v5.6.0
         with:
           python-version: "3.13"
       - name: Restore Python virtual environment

.github/workflows/codeowner-review-request.yml

@@ -25,7 +25,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Request reviews from component codeowners
-        uses: actions/github-script@v8.0.0
+        uses: actions/github-script@v7.0.1
         with:
           script: |
             const owner = context.repo.owner;

.github/workflows/external-component-bot.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Add external component comment
-        uses: actions/github-script@v8.0.0
+        uses: actions/github-script@v7.0.1
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |

.github/workflows/issue-codeowner-notify.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Notify codeowners for component issues
-        uses: actions/github-script@v8.0.0
+        uses: actions/github-script@v7.0.1
         with:
           script: |
             const owner = context.repo.owner;

.github/workflows/release.yml

@@ -62,7 +62,7 @@ jobs:
     steps:
       - uses: actions/checkout@v5.0.0
       - name: Set up Python
-        uses: actions/setup-python@v6.0.0
+        uses: actions/setup-python@v5.6.0
         with:
           python-version: "3.x"
       - name: Build
@@ -70,7 +70,7 @@ jobs:
           pip3 install build
           python3 -m build
       - name: Publish
-        uses: pypa/gh-action-pypi-publish@v1.13.0
+        uses: pypa/gh-action-pypi-publish@v1.12.4
         with:
           skip-existing: true
 
@@ -94,7 +94,7 @@ jobs:
     steps:
       - uses: actions/checkout@v5.0.0
       - name: Set up Python
-        uses: actions/setup-python@v6.0.0
+        uses: actions/setup-python@v5.6.0
         with:
           python-version: "3.11"
 
@@ -220,7 +220,7 @@ jobs:
       - deploy-manifest
     steps:
       - name: Trigger Workflow
-        uses: actions/github-script@v8.0.0
+        uses: actions/github-script@v7.0.1
         with:
           github-token: ${{ secrets.DEPLOY_HA_ADDON_REPO_TOKEN }}
           script: |
@@ -246,7 +246,7 @@ jobs:
     environment: ${{ needs.init.outputs.deploy_env }}
     steps:
       - name: Trigger Workflow
-        uses: actions/github-script@v8.0.0
+        uses: actions/github-script@v7.0.1
         with:
           github-token: ${{ secrets.DEPLOY_ESPHOME_SCHEMA_REPO_TOKEN }}
           script: |

.github/workflows/stale.yml

@@ -17,7 +17,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v10.0.0
+      - uses: actions/stale@v9.1.0
         with:
           days-before-pr-stale: 90
           days-before-pr-close: 7
@@ -37,7 +37,7 @@ jobs:
   close-issues:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v10.0.0
+      - uses: actions/stale@v9.1.0
         with:
           days-before-pr-stale: -1
           days-before-pr-close: -1

.github/workflows/status-check-labels.yml

@@ -16,7 +16,7 @@ jobs:
           - merge-after-release
     steps:
       - name: Check for ${{ matrix.label }} label
-        uses: actions/github-script@v8.0.0
+        uses: actions/github-script@v7.0.1
         with:
           script: |
             const { data: labels } = await github.rest.issues.listLabelsOnIssue({

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

@@ -22,7 +22,7 @@ jobs:
           path: lib/home-assistant
 
       - name: Setup Python
-        uses: actions/setup-python@v6.0.0
+        uses: actions/setup-python@v5.6.0
         with:
           python-version: 3.13
 

.pre-commit-config.yaml

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

CODEOWNERS

@@ -89,7 +89,6 @@ esphome/components/bp5758d/* @Cossid
 esphome/components/button/* @esphome/core
 esphome/components/bytebuffer/* @clydebarrow
 esphome/components/camera/* @DT-art1 @bdraco
-esphome/components/camera_encoder/* @DT-art1
 esphome/components/canbus/* @danielschramm @mvturnho
 esphome/components/cap1188/* @mreditor97
 esphome/components/captive_portal/* @esphome/core

esphome/components/absolute_humidity/absolute_humidity.cpp

@@ -61,10 +61,11 @@ void AbsoluteHumidityComponent::loop() {
       ESP_LOGW(TAG, "No valid state from temperature sensor!");
     }
     if (no_humidity) {
-      ESP_LOGW(TAG, "No valid state from humidity sensor!");
+      ESP_LOGW(TAG, "No valid state from temperature sensor!");
     }
+    ESP_LOGW(TAG, "Unable to calculate absolute humidity.");
     this->publish_state(NAN);
-    this->status_set_warning(LOG_STR("Unable to calculate absolute humidity."));
+    this->status_set_warning();
     return;
   }
 
@@ -86,8 +87,9 @@ void AbsoluteHumidityComponent::loop() {
       es = es_wobus(temperature_c);
       break;
     default:
+      ESP_LOGE(TAG, "Invalid saturation vapor pressure equation selection!");
       this->publish_state(NAN);
-      this->status_set_error("Invalid saturation vapor pressure equation selection!");
+      this->status_set_error();
       return;
   }
   ESP_LOGD(TAG, "Saturation vapor pressure %f kPa", es);

esphome/components/aht10/aht10.cpp

@@ -96,7 +96,7 @@ void AHT10Component::read_data_() {
     ESP_LOGD(TAG, "Read attempt %d at %ums", this->read_count_, (unsigned) (millis() - this->start_time_));
   }
   if (this->read(data, 6) != i2c::ERROR_OK) {
-    this->status_set_warning(LOG_STR("Read failed, will retry"));
+    this->status_set_warning("Read failed, will retry");
     this->restart_read_();
     return;
   }
@@ -113,7 +113,7 @@ void AHT10Component::read_data_() {
     } else {
       ESP_LOGD(TAG, "Invalid humidity, retrying");
       if (this->write(AHT10_MEASURE_CMD, sizeof(AHT10_MEASURE_CMD)) != i2c::ERROR_OK) {
-        this->status_set_warning(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
+        this->status_set_warning(ESP_LOG_MSG_COMM_FAIL);
       }
       this->restart_read_();
       return;
@@ -144,7 +144,7 @@ void AHT10Component::update() {
     return;
   this->start_time_ = millis();
   if (this->write(AHT10_MEASURE_CMD, sizeof(AHT10_MEASURE_CMD)) != i2c::ERROR_OK) {
-    this->status_set_warning(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
+    this->status_set_warning(ESP_LOG_MSG_COMM_FAIL);
     return;
   }
   this->restart_read_();

esphome/components/alarm_control_panel/__init__.py

@@ -13,7 +13,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_WEB_SERVER,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
@@ -345,6 +345,6 @@ async def alarm_control_panel_is_armed_to_code(
     return cg.new_Pvariable(condition_id, template_arg, paren)
 
 
-@coroutine_with_priority(CoroPriority.CORE)
+@coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(alarm_control_panel_ns.using)

esphome/components/api/__init__.py

@@ -24,7 +24,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_VARIABLES,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 
 DOMAIN = "api"
 DEPENDENCIES = ["network"]
@@ -134,7 +134,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(CoroPriority.WEB)
+@coroutine_with_priority(40.0)
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/api/api.proto

@@ -1712,7 +1712,6 @@ message BluetoothScannerStateResponse {
 
   BluetoothScannerState state = 1;
   BluetoothScannerMode mode = 2;
-  BluetoothScannerMode configured_mode = 3;
 }
 
 message BluetoothScannerSetModeRequest {

esphome/components/api/api_connection.cpp

@@ -112,7 +112,7 @@ void APIConnection::start() {
   APIError err = this->helper_->init();
   if (err != APIError::OK) {
     on_fatal_error();
-    this->log_warning_(LOG_STR("Helper init failed"), err);
+    this->log_warning_("Helper init failed", err);
     return;
   }
   this->client_info_.peername = helper_->getpeername();
@@ -159,7 +159,7 @@ void APIConnection::loop() {
         break;
       } else if (err != APIError::OK) {
         on_fatal_error();
-        this->log_warning_(LOG_STR("Reading failed"), err);
+        this->log_warning_("Reading failed", err);
         return;
       } else {
         this->last_traffic_ = now;
@@ -1565,7 +1565,7 @@ bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) {
     return false;
   if (err != APIError::OK) {
     on_fatal_error();
-    this->log_warning_(LOG_STR("Packet write failed"), err);
+    this->log_warning_("Packet write failed", err);
     return false;
   }
   // Do not set last_traffic_ on send
@@ -1752,7 +1752,7 @@ void APIConnection::process_batch_() {
                                                        std::span<const PacketInfo>(packet_info, packet_count));
   if (err != APIError::OK && err != APIError::WOULD_BLOCK) {
     on_fatal_error();
-    this->log_warning_(LOG_STR("Batch write failed"), err);
+    this->log_warning_("Batch write failed", err);
   }
 
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1830,14 +1830,11 @@ void APIConnection::process_state_subscriptions_() {
 }
 #endif  // USE_API_HOMEASSISTANT_STATES
 
-void APIConnection::log_warning_(const LogString *message, APIError err) {
-  ESP_LOGW(TAG, "%s: %s %s errno=%d", this->get_client_combined_info().c_str(), LOG_STR_ARG(message),
-           LOG_STR_ARG(api_error_to_logstr(err)), errno);
+void APIConnection::log_warning_(const char *message, APIError err) {
+  ESP_LOGW(TAG, "%s: %s %s errno=%d", this->get_client_combined_info().c_str(), message, api_error_to_str(err), errno);
 }
 
-void APIConnection::log_socket_operation_failed_(APIError err) {
-  this->log_warning_(LOG_STR("Socket operation failed"), err);
-}
+void APIConnection::log_socket_operation_failed_(APIError err) { this->log_warning_("Socket operation failed", err); }
 
 }  // namespace esphome::api
 #endif

esphome/components/api/api_connection.h

@@ -732,7 +732,7 @@ class APIConnection final : public APIServerConnection {
   }
 
   // Helper function to log API errors with errno
-  void log_warning_(const LogString *message, APIError err);
+  void log_warning_(const char *message, APIError err);
   // Specific helper for duplicated error message
   void log_socket_operation_failed_(APIError err);
 };

esphome/components/api/api_frame_helper.cpp

@@ -23,59 +23,59 @@ static const char *const TAG = "api.frame_helper";
 #define LOG_PACKET_SENDING(data, len) ((void) 0)
 #endif
 
-const LogString *api_error_to_logstr(APIError err) {
+const char *api_error_to_str(APIError err) {
   // not using switch to ensure compiler doesn't try to build a big table out of it
   if (err == APIError::OK) {
-    return LOG_STR("OK");
+    return "OK";
   } else if (err == APIError::WOULD_BLOCK) {
-    return LOG_STR("WOULD_BLOCK");
+    return "WOULD_BLOCK";
   } else if (err == APIError::BAD_INDICATOR) {
-    return LOG_STR("BAD_INDICATOR");
+    return "BAD_INDICATOR";
   } else if (err == APIError::BAD_DATA_PACKET) {
-    return LOG_STR("BAD_DATA_PACKET");
+    return "BAD_DATA_PACKET";
   } else if (err == APIError::TCP_NODELAY_FAILED) {
-    return LOG_STR("TCP_NODELAY_FAILED");
+    return "TCP_NODELAY_FAILED";
   } else if (err == APIError::TCP_NONBLOCKING_FAILED) {
-    return LOG_STR("TCP_NONBLOCKING_FAILED");
+    return "TCP_NONBLOCKING_FAILED";
   } else if (err == APIError::CLOSE_FAILED) {
-    return LOG_STR("CLOSE_FAILED");
+    return "CLOSE_FAILED";
   } else if (err == APIError::SHUTDOWN_FAILED) {
-    return LOG_STR("SHUTDOWN_FAILED");
+    return "SHUTDOWN_FAILED";
   } else if (err == APIError::BAD_STATE) {
-    return LOG_STR("BAD_STATE");
+    return "BAD_STATE";
   } else if (err == APIError::BAD_ARG) {
-    return LOG_STR("BAD_ARG");
+    return "BAD_ARG";
   } else if (err == APIError::SOCKET_READ_FAILED) {
-    return LOG_STR("SOCKET_READ_FAILED");
+    return "SOCKET_READ_FAILED";
   } else if (err == APIError::SOCKET_WRITE_FAILED) {
-    return LOG_STR("SOCKET_WRITE_FAILED");
+    return "SOCKET_WRITE_FAILED";
   } else if (err == APIError::OUT_OF_MEMORY) {
-    return LOG_STR("OUT_OF_MEMORY");
+    return "OUT_OF_MEMORY";
   } else if (err == APIError::CONNECTION_CLOSED) {
-    return LOG_STR("CONNECTION_CLOSED");
+    return "CONNECTION_CLOSED";
   }
 #ifdef USE_API_NOISE
   else if (err == APIError::BAD_HANDSHAKE_PACKET_LEN) {
-    return LOG_STR("BAD_HANDSHAKE_PACKET_LEN");
+    return "BAD_HANDSHAKE_PACKET_LEN";
   } else if (err == APIError::HANDSHAKESTATE_READ_FAILED) {
-    return LOG_STR("HANDSHAKESTATE_READ_FAILED");
+    return "HANDSHAKESTATE_READ_FAILED";
   } else if (err == APIError::HANDSHAKESTATE_WRITE_FAILED) {
-    return LOG_STR("HANDSHAKESTATE_WRITE_FAILED");
+    return "HANDSHAKESTATE_WRITE_FAILED";
   } else if (err == APIError::HANDSHAKESTATE_BAD_STATE) {
-    return LOG_STR("HANDSHAKESTATE_BAD_STATE");
+    return "HANDSHAKESTATE_BAD_STATE";
   } else if (err == APIError::CIPHERSTATE_DECRYPT_FAILED) {
-    return LOG_STR("CIPHERSTATE_DECRYPT_FAILED");
+    return "CIPHERSTATE_DECRYPT_FAILED";
   } else if (err == APIError::CIPHERSTATE_ENCRYPT_FAILED) {
-    return LOG_STR("CIPHERSTATE_ENCRYPT_FAILED");
+    return "CIPHERSTATE_ENCRYPT_FAILED";
   } else if (err == APIError::HANDSHAKESTATE_SETUP_FAILED) {
-    return LOG_STR("HANDSHAKESTATE_SETUP_FAILED");
+    return "HANDSHAKESTATE_SETUP_FAILED";
   } else if (err == APIError::HANDSHAKESTATE_SPLIT_FAILED) {
-    return LOG_STR("HANDSHAKESTATE_SPLIT_FAILED");
+    return "HANDSHAKESTATE_SPLIT_FAILED";
   } else if (err == APIError::BAD_HANDSHAKE_ERROR_BYTE) {
-    return LOG_STR("BAD_HANDSHAKE_ERROR_BYTE");
+    return "BAD_HANDSHAKE_ERROR_BYTE";
   }
 #endif
-  return LOG_STR("UNKNOWN");
+  return "UNKNOWN";
 }
 
 // Default implementation for loop - handles sending buffered data

esphome/components/api/api_frame_helper.h

@@ -66,7 +66,7 @@ enum class APIError : uint16_t {
 #endif
 };
 
-const LogString *api_error_to_logstr(APIError err);
+const char *api_error_to_str(APIError err);
 
 class APIFrameHelper {
  public:

esphome/components/api/api_frame_helper_noise.cpp

@@ -10,18 +10,10 @@
 #include <cstring>
 #include <cinttypes>
 
-#ifdef USE_ESP8266
-#include <pgmspace.h>
-#endif
-
 namespace esphome::api {
 
 static const char *const TAG = "api.noise";
-#ifdef USE_ESP8266
-static const char PROLOGUE_INIT[] PROGMEM = "NoiseAPIInit";
-#else
 static const char *const PROLOGUE_INIT = "NoiseAPIInit";
-#endif
 static constexpr size_t PROLOGUE_INIT_LEN = 12;  // strlen("NoiseAPIInit")
 
 #define HELPER_LOG(msg, ...) ESP_LOGVV(TAG, "%s: " msg, this->client_info_->get_combined_info().c_str(), ##__VA_ARGS__)
@@ -35,42 +27,42 @@ static constexpr size_t PROLOGUE_INIT_LEN = 12;  // strlen("NoiseAPIInit")
 #endif
 
 /// Convert a noise error code to a readable error
-const LogString *noise_err_to_logstr(int err) {
+std::string noise_err_to_str(int err) {
   if (err == NOISE_ERROR_NO_MEMORY)
-    return LOG_STR("NO_MEMORY");
+    return "NO_MEMORY";
   if (err == NOISE_ERROR_UNKNOWN_ID)
-    return LOG_STR("UNKNOWN_ID");
+    return "UNKNOWN_ID";
   if (err == NOISE_ERROR_UNKNOWN_NAME)
-    return LOG_STR("UNKNOWN_NAME");
+    return "UNKNOWN_NAME";
   if (err == NOISE_ERROR_MAC_FAILURE)
-    return LOG_STR("MAC_FAILURE");
+    return "MAC_FAILURE";
   if (err == NOISE_ERROR_NOT_APPLICABLE)
-    return LOG_STR("NOT_APPLICABLE");
+    return "NOT_APPLICABLE";
   if (err == NOISE_ERROR_SYSTEM)
-    return LOG_STR("SYSTEM");
+    return "SYSTEM";
   if (err == NOISE_ERROR_REMOTE_KEY_REQUIRED)
-    return LOG_STR("REMOTE_KEY_REQUIRED");
+    return "REMOTE_KEY_REQUIRED";
   if (err == NOISE_ERROR_LOCAL_KEY_REQUIRED)
-    return LOG_STR("LOCAL_KEY_REQUIRED");
+    return "LOCAL_KEY_REQUIRED";
   if (err == NOISE_ERROR_PSK_REQUIRED)
-    return LOG_STR("PSK_REQUIRED");
+    return "PSK_REQUIRED";
   if (err == NOISE_ERROR_INVALID_LENGTH)
-    return LOG_STR("INVALID_LENGTH");
+    return "INVALID_LENGTH";
   if (err == NOISE_ERROR_INVALID_PARAM)
-    return LOG_STR("INVALID_PARAM");
+    return "INVALID_PARAM";
   if (err == NOISE_ERROR_INVALID_STATE)
-    return LOG_STR("INVALID_STATE");
+    return "INVALID_STATE";
   if (err == NOISE_ERROR_INVALID_NONCE)
-    return LOG_STR("INVALID_NONCE");
+    return "INVALID_NONCE";
   if (err == NOISE_ERROR_INVALID_PRIVATE_KEY)
-    return LOG_STR("INVALID_PRIVATE_KEY");
+    return "INVALID_PRIVATE_KEY";
   if (err == NOISE_ERROR_INVALID_PUBLIC_KEY)
-    return LOG_STR("INVALID_PUBLIC_KEY");
+    return "INVALID_PUBLIC_KEY";
   if (err == NOISE_ERROR_INVALID_FORMAT)
-    return LOG_STR("INVALID_FORMAT");
+    return "INVALID_FORMAT";
   if (err == NOISE_ERROR_INVALID_SIGNATURE)
-    return LOG_STR("INVALID_SIGNATURE");
-  return LOG_STR("UNKNOWN");
+    return "INVALID_SIGNATURE";
+  return to_string(err);
 }
 
 /// Initialize the frame helper, returns OK if successful.
@@ -83,11 +75,7 @@ APIError APINoiseFrameHelper::init() {
   // init prologue
   size_t old_size = prologue_.size();
   prologue_.resize(old_size + PROLOGUE_INIT_LEN);
-#ifdef USE_ESP8266
-  memcpy_P(prologue_.data() + old_size, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
-#else
   std::memcpy(prologue_.data() + old_size, PROLOGUE_INIT, PROLOGUE_INIT_LEN);
-#endif
 
   state_ = State::CLIENT_HELLO;
   return APIError::OK;
@@ -95,18 +83,18 @@ APIError APINoiseFrameHelper::init() {
 // Helper for handling handshake frame errors
 APIError APINoiseFrameHelper::handle_handshake_frame_error_(APIError aerr) {
   if (aerr == APIError::BAD_INDICATOR) {
-    send_explicit_handshake_reject_(LOG_STR("Bad indicator byte"));
+    send_explicit_handshake_reject_("Bad indicator byte");
   } else if (aerr == APIError::BAD_HANDSHAKE_PACKET_LEN) {
-    send_explicit_handshake_reject_(LOG_STR("Bad handshake packet len"));
+    send_explicit_handshake_reject_("Bad handshake packet len");
   }
   return aerr;
 }
 
 // Helper for handling noise library errors
-APIError APINoiseFrameHelper::handle_noise_error_(int err, const LogString *func_name, APIError api_err) {
+APIError APINoiseFrameHelper::handle_noise_error_(int err, const char *func_name, APIError api_err) {
   if (err != 0) {
     state_ = State::FAILED;
-    HELPER_LOG("%s failed: %s", LOG_STR_ARG(func_name), LOG_STR_ARG(noise_err_to_logstr(err)));
+    HELPER_LOG("%s failed: %s", func_name, noise_err_to_str(err).c_str());
     return api_err;
   }
   return APIError::OK;
@@ -291,11 +279,11 @@ APIError APINoiseFrameHelper::state_action_() {
       }
 
       if (frame.empty()) {
-        send_explicit_handshake_reject_(LOG_STR("Empty handshake message"));
+        send_explicit_handshake_reject_("Empty handshake message");
         return APIError::BAD_HANDSHAKE_ERROR_BYTE;
       } else if (frame[0] != 0x00) {
         HELPER_LOG("Bad handshake error byte: %u", frame[0]);
-        send_explicit_handshake_reject_(LOG_STR("Bad handshake error byte"));
+        send_explicit_handshake_reject_("Bad handshake error byte");
         return APIError::BAD_HANDSHAKE_ERROR_BYTE;
       }
 
@@ -305,10 +293,8 @@ APIError APINoiseFrameHelper::state_action_() {
       err = noise_handshakestate_read_message(handshake_, &mbuf, nullptr);
       if (err != 0) {
         // Special handling for MAC failure
-        send_explicit_handshake_reject_(err == NOISE_ERROR_MAC_FAILURE ? LOG_STR("Handshake MAC failure")
-                                                                       : LOG_STR("Handshake error"));
-        return handle_noise_error_(err, LOG_STR("noise_handshakestate_read_message"),
-                                   APIError::HANDSHAKESTATE_READ_FAILED);
+        send_explicit_handshake_reject_(err == NOISE_ERROR_MAC_FAILURE ? "Handshake MAC failure" : "Handshake error");
+        return handle_noise_error_(err, "noise_handshakestate_read_message", APIError::HANDSHAKESTATE_READ_FAILED);
       }
 
       aerr = check_handshake_finished_();
@@ -321,8 +307,8 @@ APIError APINoiseFrameHelper::state_action_() {
       noise_buffer_set_output(mbuf, buffer + 1, sizeof(buffer) - 1);
 
       err = noise_handshakestate_write_message(handshake_, &mbuf, nullptr);
-      APIError aerr_write = handle_noise_error_(err, LOG_STR("noise_handshakestate_write_message"),
-                                                APIError::HANDSHAKESTATE_WRITE_FAILED);
+      APIError aerr_write =
+          handle_noise_error_(err, "noise_handshakestate_write_message", APIError::HANDSHAKESTATE_WRITE_FAILED);
       if (aerr_write != APIError::OK)
         return aerr_write;
       buffer[0] = 0x00;  // success
@@ -345,31 +331,15 @@ APIError APINoiseFrameHelper::state_action_() {
   }
   return APIError::OK;
 }
-void APINoiseFrameHelper::send_explicit_handshake_reject_(const LogString *reason) {
-#ifdef USE_STORE_LOG_STR_IN_FLASH
-  // On ESP8266 with flash strings, we need to use PROGMEM-aware functions
-  size_t reason_len = strlen_P(reinterpret_cast<PGM_P>(reason));
+void APINoiseFrameHelper::send_explicit_handshake_reject_(const std::string &reason) {
   std::vector<uint8_t> data;
-  data.resize(reason_len + 1);
-  data[0] = 0x01;  // failure
-
-  // Copy error message from PROGMEM
-  if (reason_len > 0) {
-    memcpy_P(data.data() + 1, reinterpret_cast<PGM_P>(reason), reason_len);
-  }
-#else
-  // Normal memory access
-  const char *reason_str = LOG_STR_ARG(reason);
-  size_t reason_len = strlen(reason_str);
-  std::vector<uint8_t> data;
-  data.resize(reason_len + 1);
+  data.resize(reason.length() + 1);
   data[0] = 0x01;  // failure
 
   // Copy error message in bulk
-  if (reason_len > 0) {
-    std::memcpy(data.data() + 1, reason_str, reason_len);
+  if (!reason.empty()) {
+    std::memcpy(data.data() + 1, reason.c_str(), reason.length());
   }
-#endif
 
   // temporarily remove failed state
   auto orig_state = state_;
@@ -398,8 +368,7 @@ APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {
   noise_buffer_init(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);
+  APIError decrypt_err = handle_noise_error_(err, "noise_cipherstate_decrypt", APIError::CIPHERSTATE_DECRYPT_FAILED);
   if (decrypt_err != APIError::OK)
     return decrypt_err;
 
@@ -481,8 +450,7 @@ APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, st
                            4 + packet.payload_size + frame_footer_size_);
 
     int err = noise_cipherstate_encrypt(send_cipher_, &mbuf);
-    APIError aerr =
-        handle_noise_error_(err, LOG_STR("noise_cipherstate_encrypt"), APIError::CIPHERSTATE_ENCRYPT_FAILED);
+    APIError aerr = handle_noise_error_(err, "noise_cipherstate_encrypt", APIError::CIPHERSTATE_ENCRYPT_FAILED);
     if (aerr != APIError::OK)
       return aerr;
 
@@ -536,27 +504,25 @@ APIError APINoiseFrameHelper::init_handshake_() {
   nid_.modifier_ids[0] = NOISE_MODIFIER_PSK0;
 
   err = noise_handshakestate_new_by_id(&handshake_, &nid_, NOISE_ROLE_RESPONDER);
-  APIError aerr =
-      handle_noise_error_(err, LOG_STR("noise_handshakestate_new_by_id"), APIError::HANDSHAKESTATE_SETUP_FAILED);
+  APIError aerr = handle_noise_error_(err, "noise_handshakestate_new_by_id", APIError::HANDSHAKESTATE_SETUP_FAILED);
   if (aerr != APIError::OK)
     return aerr;
 
   const auto &psk = ctx_->get_psk();
   err = noise_handshakestate_set_pre_shared_key(handshake_, psk.data(), psk.size());
-  aerr = handle_noise_error_(err, LOG_STR("noise_handshakestate_set_pre_shared_key"),
-                             APIError::HANDSHAKESTATE_SETUP_FAILED);
+  aerr = handle_noise_error_(err, "noise_handshakestate_set_pre_shared_key", APIError::HANDSHAKESTATE_SETUP_FAILED);
   if (aerr != APIError::OK)
     return aerr;
 
   err = noise_handshakestate_set_prologue(handshake_, prologue_.data(), prologue_.size());
-  aerr = handle_noise_error_(err, LOG_STR("noise_handshakestate_set_prologue"), APIError::HANDSHAKESTATE_SETUP_FAILED);
+  aerr = handle_noise_error_(err, "noise_handshakestate_set_prologue", APIError::HANDSHAKESTATE_SETUP_FAILED);
   if (aerr != APIError::OK)
     return aerr;
   // set_prologue copies it into handshakestate, so we can get rid of it now
   prologue_ = {};
 
   err = noise_handshakestate_start(handshake_);
-  aerr = handle_noise_error_(err, LOG_STR("noise_handshakestate_start"), APIError::HANDSHAKESTATE_SETUP_FAILED);
+  aerr = handle_noise_error_(err, "noise_handshakestate_start", APIError::HANDSHAKESTATE_SETUP_FAILED);
   if (aerr != APIError::OK)
     return aerr;
   return APIError::OK;
@@ -574,8 +540,7 @@ APIError APINoiseFrameHelper::check_handshake_finished_() {
     return APIError::HANDSHAKESTATE_BAD_STATE;
   }
   int err = noise_handshakestate_split(handshake_, &send_cipher_, &recv_cipher_);
-  APIError aerr =
-      handle_noise_error_(err, LOG_STR("noise_handshakestate_split"), APIError::HANDSHAKESTATE_SPLIT_FAILED);
+  APIError aerr = handle_noise_error_(err, "noise_handshakestate_split", APIError::HANDSHAKESTATE_SPLIT_FAILED);
   if (aerr != APIError::OK)
     return aerr;
 

esphome/components/api/api_frame_helper_noise.h

@@ -32,9 +32,9 @@ class APINoiseFrameHelper final : public APIFrameHelper {
   APIError write_frame_(const uint8_t *data, uint16_t len);
   APIError init_handshake_();
   APIError check_handshake_finished_();
-  void send_explicit_handshake_reject_(const LogString *reason);
+  void send_explicit_handshake_reject_(const std::string &reason);
   APIError handle_handshake_frame_error_(APIError aerr);
-  APIError handle_noise_error_(int err, const LogString *func_name, APIError api_err);
+  APIError handle_noise_error_(int err, const char *func_name, APIError api_err);
 
   // Pointers first (4 bytes each)
   NoiseHandshakeState *handshake_{nullptr};

esphome/components/api/api_pb2.cpp

@@ -2153,12 +2153,10 @@ void BluetoothDeviceClearCacheResponse::calculate_size(ProtoSize &size) const {
 void BluetoothScannerStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(1, static_cast<uint32_t>(this->state));
   buffer.encode_uint32(2, static_cast<uint32_t>(this->mode));
-  buffer.encode_uint32(3, static_cast<uint32_t>(this->configured_mode));
 }
 void BluetoothScannerStateResponse::calculate_size(ProtoSize &size) const {
   size.add_uint32(1, static_cast<uint32_t>(this->state));
   size.add_uint32(1, static_cast<uint32_t>(this->mode));
-  size.add_uint32(1, static_cast<uint32_t>(this->configured_mode));
 }
 bool BluetoothScannerSetModeRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {

esphome/components/api/api_pb2.h

@@ -2214,13 +2214,12 @@ class BluetoothDeviceClearCacheResponse final : public ProtoMessage {
 class BluetoothScannerStateResponse final : public ProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 126;
-  static constexpr uint8_t ESTIMATED_SIZE = 6;
+  static constexpr uint8_t ESTIMATED_SIZE = 4;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "bluetooth_scanner_state_response"; }
 #endif
   enums::BluetoothScannerState state{};
   enums::BluetoothScannerMode mode{};
-  enums::BluetoothScannerMode configured_mode{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP

esphome/components/api/api_pb2_dump.cpp

@@ -1135,7 +1135,7 @@ void ExecuteServiceArgument::dump_to(std::string &out) const {
   dump_field(out, "string_", this->string_);
   dump_field(out, "int_", this->int_);
   for (const auto it : this->bool_array) {
-    dump_field(out, "bool_array", static_cast<bool>(it), 4);
+    dump_field(out, "bool_array", it, 4);
   }
   for (const auto &it : this->int_array) {
     dump_field(out, "int_array", it, 4);
@@ -1704,7 +1704,6 @@ void BluetoothScannerStateResponse::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "BluetoothScannerStateResponse");
   dump_field(out, "state", static_cast<enums::BluetoothScannerState>(this->state));
   dump_field(out, "mode", static_cast<enums::BluetoothScannerMode>(this->mode));
-  dump_field(out, "configured_mode", static_cast<enums::BluetoothScannerMode>(this->configured_mode));
 }
 void BluetoothScannerSetModeRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "BluetoothScannerSetModeRequest");

esphome/components/async_tcp/__init__.py

@@ -8,7 +8,7 @@ from esphome.const import (
     PLATFORM_LN882X,
     PLATFORM_RTL87XX,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 
 CODEOWNERS = ["@esphome/core"]
 
@@ -27,7 +27,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(CoroPriority.NETWORK_TRANSPORT)
+@coroutine_with_priority(200.0)
 async def to_code(config):
     if CORE.is_esp32 or CORE.is_libretiny:
         # https://github.com/ESP32Async/AsyncTCP

esphome/components/audio_adc/__init__.py

@@ -2,7 +2,7 @@ from esphome import automation
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_MIC_GAIN
-from esphome.core import CoroPriority, coroutine_with_priority
+from esphome.core import coroutine_with_priority
 
 CODEOWNERS = ["@kbx81"]
 IS_PLATFORM_COMPONENT = True
@@ -35,7 +35,7 @@ async def audio_adc_set_mic_gain_to_code(config, action_id, template_arg, args):
     return var
 
 
-@coroutine_with_priority(CoroPriority.CORE)
+@coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_define("USE_AUDIO_ADC")
     cg.add_global(audio_adc_ns.using)

esphome/components/audio_dac/__init__.py

@@ -3,7 +3,7 @@ from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_VOLUME
-from esphome.core import CoroPriority, coroutine_with_priority
+from esphome.core import coroutine_with_priority
 
 CODEOWNERS = ["@kbx81"]
 IS_PLATFORM_COMPONENT = True
@@ -51,7 +51,7 @@ async def audio_dac_set_volume_to_code(config, action_id, template_arg, args):
     return var
 
 
-@coroutine_with_priority(CoroPriority.CORE)
+@coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_define("USE_AUDIO_DAC")
     cg.add_global(audio_dac_ns.using)

esphome/components/axs15231/touchscreen/axs15231_touchscreen.cpp

@@ -12,7 +12,7 @@ constexpr static const uint8_t AXS_READ_TOUCHPAD[11] = {0xb5, 0xab, 0xa5, 0x5a,
 
 #define ERROR_CHECK(err) \
   if ((err) != i2c::ERROR_OK) { \
-    this->status_set_warning(LOG_STR("Failed to communicate")); \
+    this->status_set_warning("Failed to communicate"); \
     return; \
   }
 

esphome/components/binary_sensor/__init__.py

@@ -59,7 +59,7 @@ from esphome.const import (
     DEVICE_CLASS_VIBRATION,
     DEVICE_CLASS_WINDOW,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 from esphome.util import Registry
@@ -652,7 +652,7 @@ async def binary_sensor_is_off_to_code(config, condition_id, template_arg, args)
     return cg.new_Pvariable(condition_id, template_arg, paren, False)
 
 
-@coroutine_with_priority(CoroPriority.CORE)
+@coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(binary_sensor_ns.using)
 

esphome/components/binary_sensor/binary_sensor.cpp

@@ -15,8 +15,8 @@ void log_binary_sensor(const char *tag, const char *prefix, const char *type, Bi
 
   ESP_LOGCONFIG(tag, "%s%s '%s'", prefix, type, obj->get_name().c_str());
 
-  if (!obj->get_device_class_ref().empty()) {
-    ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->get_device_class_ref().c_str());
+  if (!obj->get_device_class().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Device Class: '%s'", prefix, obj->get_device_class().c_str());
   }
 }
 

esphome/components/bl0942/bl0942.cpp

@@ -149,7 +149,7 @@ void BL0942::setup() {
   this->write_reg_(BL0942_REG_USR_WRPROT, 0);
 
   if (this->read_reg_(BL0942_REG_MODE) != mode)
-    this->status_set_warning(LOG_STR("BL0942 setup failed!"));
+    this->status_set_warning("BL0942 setup failed!");
 
   this->flush();
 }

esphome/components/bluetooth_proxy/__init__.py

@@ -80,7 +80,7 @@ CONFIG_SCHEMA = cv.All(
         cv.Schema(
             {
                 cv.GenerateID(): cv.declare_id(BluetoothProxy),
-                cv.Optional(CONF_ACTIVE, default=True): cv.boolean,
+                cv.Optional(CONF_ACTIVE, default=False): cv.boolean,
                 cv.SplitDefault(CONF_CACHE_SERVICES, esp32_idf=True): cv.All(
                     cv.only_with_esp_idf, cv.boolean
                 ),

esphome/components/bluetooth_proxy/bluetooth_proxy.cpp

@@ -24,9 +24,6 @@ void BluetoothProxy::setup() {
   this->connections_free_response_.limit = BLUETOOTH_PROXY_MAX_CONNECTIONS;
   this->connections_free_response_.free = BLUETOOTH_PROXY_MAX_CONNECTIONS;
 
-  // Capture the configured scan mode from YAML before any API changes
-  this->configured_scan_active_ = this->parent_->get_scan_active();
-
   this->parent_->add_scanner_state_callback([this](esp32_ble_tracker::ScannerState state) {
     if (this->api_connection_ != nullptr) {
       this->send_bluetooth_scanner_state_(state);
@@ -39,9 +36,6 @@ void BluetoothProxy::send_bluetooth_scanner_state_(esp32_ble_tracker::ScannerSta
   resp.state = static_cast<api::enums::BluetoothScannerState>(state);
   resp.mode = this->parent_->get_scan_active() ? api::enums::BluetoothScannerMode::BLUETOOTH_SCANNER_MODE_ACTIVE
                                                : api::enums::BluetoothScannerMode::BLUETOOTH_SCANNER_MODE_PASSIVE;
-  resp.configured_mode = this->configured_scan_active_
-                             ? api::enums::BluetoothScannerMode::BLUETOOTH_SCANNER_MODE_ACTIVE
-                             : api::enums::BluetoothScannerMode::BLUETOOTH_SCANNER_MODE_PASSIVE;
   this->api_connection_->send_message(resp, api::BluetoothScannerStateResponse::MESSAGE_TYPE);
 }
 
@@ -189,12 +183,6 @@ void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest
         this->send_device_connection(msg.address, false);
         return;
       }
-      if (!msg.has_address_type) {
-        ESP_LOGE(TAG, "[%d] [%s] Missing address type in connect request", connection->get_connection_index(),
-                 connection->address_str().c_str());
-        this->send_device_connection(msg.address, false);
-        return;
-      }
       if (connection->state() == espbt::ClientState::CONNECTED ||
           connection->state() == espbt::ClientState::ESTABLISHED) {
         this->log_connection_request_ignored_(connection, connection->state());
@@ -221,9 +209,13 @@ void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest
         connection->set_connection_type(espbt::ConnectionType::V3_WITHOUT_CACHE);
         this->log_connection_info_(connection, "v3 without cache");
       }
-      uint64_to_bd_addr(msg.address, connection->remote_bda_);
-      connection->set_remote_addr_type(static_cast<esp_ble_addr_type_t>(msg.address_type));
-      connection->set_state(espbt::ClientState::DISCOVERED);
+      if (msg.has_address_type) {
+        uint64_to_bd_addr(msg.address, connection->remote_bda_);
+        connection->set_remote_addr_type(static_cast<esp_ble_addr_type_t>(msg.address_type));
+        connection->set_state(espbt::ClientState::DISCOVERED);
+      } else {
+        connection->set_state(espbt::ClientState::SEARCHING);
+      }
       this->send_connections_free();
       break;
     }

esphome/components/bluetooth_proxy/bluetooth_proxy.h

@@ -161,8 +161,7 @@ class BluetoothProxy final : public esp32_ble_tracker::ESPBTDeviceListener, publ
   // Group 4: 1-byte types grouped together
   bool active_;
   uint8_t connection_count_{0};
-  bool configured_scan_active_{false};  // Configured scan mode from YAML
-  // 3 bytes used, 1 byte padding
+  // 2 bytes used, 2 bytes padding
 };
 
 extern BluetoothProxy *global_bluetooth_proxy;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

esphome/components/button/__init__.py

@@ -17,7 +17,7 @@ from esphome.const import (
     DEVICE_CLASS_RESTART,
     DEVICE_CLASS_UPDATE,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
@@ -134,6 +134,6 @@ async def button_press_to_code(config, action_id, template_arg, args):
     return cg.new_Pvariable(action_id, template_arg, paren)
 
 
-@coroutine_with_priority(CoroPriority.CORE)
+@coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(button_ns.using)

esphome/components/button/button.cpp

@@ -14,8 +14,8 @@ void log_button(const char *tag, const char *prefix, const char *type, Button *o
 
   ESP_LOGCONFIG(tag, "%s%s '%s'", prefix, type, obj->get_name().c_str());
 
-  if (!obj->get_icon_ref().empty()) {
-    ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon_ref().c_str());
+  if (!obj->get_icon().empty()) {
+    ESP_LOGCONFIG(tag, "%s  Icon: '%s'", prefix, obj->get_icon().c_str());
   }
 }
 

esphome/components/camera/buffer.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include <cinttypes>
-#include <cstddef>
-
-namespace esphome::camera {
-
-/// Interface for a generic buffer that stores image data.
-class Buffer {
- public:
-  /// Returns a pointer to the buffer's data.
-  virtual uint8_t *get_data_buffer() = 0;
-  /// Returns the length of the buffer in bytes.
-  virtual size_t get_data_length() = 0;
-  virtual ~Buffer() = default;
-};
-
-}  // namespace esphome::camera

esphome/components/camera/buffer_impl.cpp

@@ -1,20 +0,0 @@
-#include "buffer_impl.h"
-
-namespace esphome::camera {
-
-BufferImpl::BufferImpl(size_t size) {
-  this->data_ = this->allocator_.allocate(size);
-  this->size_ = size;
-}
-
-BufferImpl::BufferImpl(CameraImageSpec *spec) {
-  this->data_ = this->allocator_.allocate(spec->bytes_per_image());
-  this->size_ = spec->bytes_per_image();
-}
-
-BufferImpl::~BufferImpl() {
-  if (this->data_ != nullptr)
-    this->allocator_.deallocate(this->data_, this->size_);
-}
-
-}  // namespace esphome::camera

esphome/components/camera/buffer_impl.h

@@ -1,26 +0,0 @@
-#pragma once
-
-#include "buffer.h"
-#include "camera.h"
-
-namespace esphome::camera {
-
-/// Default implementation of Buffer Interface.
-/// Uses a RAMAllocator for memory reservation.
-class BufferImpl : public Buffer {
- public:
-  explicit BufferImpl(size_t size);
-  explicit BufferImpl(CameraImageSpec *spec);
-  // -------- Buffer --------
-  uint8_t *get_data_buffer() override { return data_; }
-  size_t get_data_length() override { return size_; }
-  // ------------------------
-  ~BufferImpl() override;
-
- protected:
-  RAMAllocator<uint8_t> allocator_;
-  size_t size_{};
-  uint8_t *data_{};
-};
-
-}  // namespace esphome::camera

esphome/components/camera/camera.h

@@ -15,26 +15,6 @@ namespace camera {
  */
 enum CameraRequester : uint8_t { IDLE, API_REQUESTER, WEB_REQUESTER };
 
-/// Enumeration of different pixel formats.
-enum PixelFormat : uint8_t {
-  PIXEL_FORMAT_GRAYSCALE = 0,  ///< 8-bit grayscale.
-  PIXEL_FORMAT_RGB565,         ///< 16-bit RGB (5-6-5).
-  PIXEL_FORMAT_BGR888,         ///< RGB pixel data in 8-bit format, stored as B, G, R (1 byte each).
-};
-
-/// Returns string name for a given PixelFormat.
-inline const char *to_string(PixelFormat format) {
-  switch (format) {
-    case PIXEL_FORMAT_GRAYSCALE:
-      return "PIXEL_FORMAT_GRAYSCALE";
-    case PIXEL_FORMAT_RGB565:
-      return "PIXEL_FORMAT_RGB565";
-    case PIXEL_FORMAT_BGR888:
-      return "PIXEL_FORMAT_BGR888";
-  }
-  return "PIXEL_FORMAT_UNKNOWN";
-}
-
 /** Abstract camera image base class.
  *  Encapsulates the JPEG encoded data and it is shared among
  *  all connected clients.
@@ -63,29 +43,6 @@ class CameraImageReader {
   virtual ~CameraImageReader() {}
 };
 
-/// Specification of a caputured camera image.
-/// This struct defines the format and size details for images captured
-/// or processed by a camera component.
-struct CameraImageSpec {
-  uint16_t width;
-  uint16_t height;
-  PixelFormat format;
-  size_t bytes_per_pixel() {
-    switch (format) {
-      case PIXEL_FORMAT_GRAYSCALE:
-        return 1;
-      case PIXEL_FORMAT_RGB565:
-        return 2;
-      case PIXEL_FORMAT_BGR888:
-        return 3;
-    }
-
-    return 1;
-  }
-  size_t bytes_per_row() { return bytes_per_pixel() * width; }
-  size_t bytes_per_image() { return bytes_per_pixel() * width * height; }
-};
-
 /** Abstract camera base class. Collaborates with API.
  *  1) API server starts and installs callback (add_image_callback)
  *     which is called by the camera when a new image is available.

esphome/components/camera/encoder.h

@@ -1,69 +0,0 @@
-#pragma once
-
-#include "buffer.h"
-#include "camera.h"
-
-namespace esphome::camera {
-
-/// Result codes from the encoder used to control camera pipeline flow.
-enum EncoderError : uint8_t {
-  ENCODER_ERROR_SUCCESS = 0,   ///< Encoding succeeded, continue pipeline normally.
-  ENCODER_ERROR_SKIP_FRAME,    ///< Skip current frame, try again on next frame.
-  ENCODER_ERROR_RETRY_FRAME,   ///< Retry current frame, after buffer growth or for incremental encoding.
-  ENCODER_ERROR_CONFIGURATION  ///< Fatal config error, shut down pipeline.
-};
-
-/// Converts EncoderError to string.
-inline const char *to_string(EncoderError error) {
-  switch (error) {
-    case ENCODER_ERROR_SUCCESS:
-      return "ENCODER_ERROR_SUCCESS";
-    case ENCODER_ERROR_SKIP_FRAME:
-      return "ENCODER_ERROR_SKIP_FRAME";
-    case ENCODER_ERROR_RETRY_FRAME:
-      return "ENCODER_ERROR_RETRY_FRAME";
-    case ENCODER_ERROR_CONFIGURATION:
-      return "ENCODER_ERROR_CONFIGURATION";
-  }
-  return "ENCODER_ERROR_INVALID";
-}
-
-/// Interface for an encoder buffer supporting resizing and variable-length data.
-class EncoderBuffer {
- public:
-  ///  Sets logical buffer size, reallocates if needed.
-  ///  @param size Required size in bytes.
-  ///  @return true on success, false on allocation failure.
-  virtual bool set_buffer_size(size_t size) = 0;
-
-  /// Returns a pointer to the buffer data.
-  virtual uint8_t *get_data() const = 0;
-
-  /// Returns number of bytes currently used.
-  virtual size_t get_size() const = 0;
-
-  ///  Returns total allocated buffer size.
-  virtual size_t get_max_size() const = 0;
-
-  virtual ~EncoderBuffer() = default;
-};
-
-/// Interface for image encoders used in a camera pipeline.
-class Encoder {
- public:
-  /// Encodes pixel data from a previous camera pipeline stage.
-  /// @param spec Specification of the input pixel data.
-  /// @param pixels Image pixels in RGB or grayscale format, as specified in @p spec.
-  /// @return EncoderError Indicating the result of the encoding operation.
-  virtual EncoderError encode_pixels(CameraImageSpec *spec, Buffer *pixels) = 0;
-
-  /// Returns the encoder's output buffer.
-  /// @return Pointer to an EncoderBuffer containing encoded data.
-  virtual EncoderBuffer *get_output_buffer() = 0;
-
-  ///  Prints the encoder's configuration to the log.
-  virtual void dump_config() = 0;
-  virtual ~Encoder() = default;
-};
-
-}  // namespace esphome::camera

esphome/components/camera_encoder/__init__.py

@@ -1,62 +0,0 @@
-import esphome.codegen as cg
-from esphome.components.esp32 import add_idf_component
-import esphome.config_validation as cv
-from esphome.const import CONF_BUFFER_SIZE, CONF_ID, CONF_TYPE
-from esphome.core import CORE
-from esphome.types import ConfigType
-
-CODEOWNERS = ["@DT-art1"]
-
-AUTO_LOAD = ["camera"]
-
-CONF_BUFFER_EXPAND_SIZE = "buffer_expand_size"
-CONF_ENCODER_BUFFER_ID = "encoder_buffer_id"
-CONF_QUALITY = "quality"
-
-ESP32_CAMERA_ENCODER = "esp32_camera"
-
-camera_ns = cg.esphome_ns.namespace("camera")
-camera_encoder_ns = cg.esphome_ns.namespace("camera_encoder")
-
-Encoder = camera_ns.class_("Encoder")
-EncoderBufferImpl = camera_encoder_ns.class_("EncoderBufferImpl")
-
-ESP32CameraJPEGEncoder = camera_encoder_ns.class_("ESP32CameraJPEGEncoder", Encoder)
-
-MAX_JPEG_BUFFER_SIZE_2MB = 2 * 1024 * 1024
-
-ESP32_CAMERA_ENCODER_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.declare_id(ESP32CameraJPEGEncoder),
-        cv.Optional(CONF_QUALITY, default=80): cv.int_range(1, 100),
-        cv.Optional(CONF_BUFFER_SIZE, default=4096): cv.int_range(
-            1024, MAX_JPEG_BUFFER_SIZE_2MB
-        ),
-        cv.Optional(CONF_BUFFER_EXPAND_SIZE, default=1024): cv.int_range(
-            0, MAX_JPEG_BUFFER_SIZE_2MB
-        ),
-        cv.GenerateID(CONF_ENCODER_BUFFER_ID): cv.declare_id(EncoderBufferImpl),
-    }
-)
-
-CONFIG_SCHEMA = cv.typed_schema(
-    {
-        ESP32_CAMERA_ENCODER: ESP32_CAMERA_ENCODER_SCHEMA,
-    },
-    default_type=ESP32_CAMERA_ENCODER,
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    buffer = cg.new_Pvariable(config[CONF_ENCODER_BUFFER_ID])
-    cg.add(buffer.set_buffer_size(config[CONF_BUFFER_SIZE]))
-    if config[CONF_TYPE] == ESP32_CAMERA_ENCODER:
-        if CORE.using_esp_idf:
-            add_idf_component(name="espressif/esp32-camera", ref="2.1.0")
-        cg.add_build_flag("-DUSE_ESP32_CAMERA_JPEG_ENCODER")
-        var = cg.new_Pvariable(
-            config[CONF_ID],
-            config[CONF_QUALITY],
-            buffer,
-        )
-        cg.add(var.set_buffer_expand_size(config[CONF_BUFFER_EXPAND_SIZE]))

esphome/components/camera_encoder/encoder_buffer_impl.cpp

@@ -1,23 +0,0 @@
-#include "encoder_buffer_impl.h"
-
-namespace esphome::camera_encoder {
-
-bool EncoderBufferImpl::set_buffer_size(size_t size) {
-  if (size > this->capacity_) {
-    uint8_t *p = this->allocator_.reallocate(this->data_, size);
-    if (p == nullptr)
-      return false;
-
-    this->data_ = p;
-    this->capacity_ = size;
-  }
-  this->size_ = size;
-  return true;
-}
-
-EncoderBufferImpl::~EncoderBufferImpl() {
-  if (this->data_ != nullptr)
-    this->allocator_.deallocate(this->data_, this->capacity_);
-}
-
-}  // namespace esphome::camera_encoder

esphome/components/camera_encoder/encoder_buffer_impl.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#include "esphome/components/camera/encoder.h"
-#include "esphome/core/helpers.h"
-
-namespace esphome::camera_encoder {
-
-class EncoderBufferImpl : public camera::EncoderBuffer {
- public:
-  // --- EncoderBuffer  ---
-  bool set_buffer_size(size_t size) override;
-  uint8_t *get_data() const override { return this->data_; }
-  size_t get_size() const override { return this->size_; }
-  size_t get_max_size() const override { return this->capacity_; }
-  // ----------------------
-  ~EncoderBufferImpl() override;
-
- protected:
-  RAMAllocator<uint8_t> allocator_;
-  size_t capacity_{};
-  size_t size_{};
-  uint8_t *data_{};
-};
-
-}  // namespace esphome::camera_encoder

esphome/components/camera_encoder/esp32_camera_jpeg_encoder.cpp

@@ -1,82 +0,0 @@
-#ifdef USE_ESP32_CAMERA_JPEG_ENCODER
-
-#include "esp32_camera_jpeg_encoder.h"
-
-namespace esphome::camera_encoder {
-
-static const char *const TAG = "camera_encoder";
-
-ESP32CameraJPEGEncoder::ESP32CameraJPEGEncoder(uint8_t quality, camera::EncoderBuffer *output) {
-  this->quality_ = quality;
-  this->output_ = output;
-}
-
-camera::EncoderError ESP32CameraJPEGEncoder::encode_pixels(camera::CameraImageSpec *spec, camera::Buffer *pixels) {
-  this->bytes_written_ = 0;
-  this->out_of_output_memory_ = false;
-  bool success = fmt2jpg_cb(pixels->get_data_buffer(), pixels->get_data_length(), spec->width, spec->height,
-                            to_internal_(spec->format), this->quality_, callback_, this);
-
-  if (!success)
-    return camera::ENCODER_ERROR_CONFIGURATION;
-
-  if (this->out_of_output_memory_) {
-    if (this->buffer_expand_size_ <= 0)
-      return camera::ENCODER_ERROR_SKIP_FRAME;
-
-    size_t current_size = this->output_->get_max_size();
-    size_t new_size = this->output_->get_max_size() + this->buffer_expand_size_;
-    if (!this->output_->set_buffer_size(new_size)) {
-      ESP_LOGE(TAG, "Failed to expand output buffer.");
-      this->buffer_expand_size_ = 0;
-      return camera::ENCODER_ERROR_SKIP_FRAME;
-    }
-
-    ESP_LOGD(TAG, "Output buffer expanded (%u -> %u).", current_size, this->output_->get_max_size());
-    return camera::ENCODER_ERROR_RETRY_FRAME;
-  }
-
-  this->output_->set_buffer_size(this->bytes_written_);
-  return camera::ENCODER_ERROR_SUCCESS;
-}
-
-void ESP32CameraJPEGEncoder::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "ESP32 Camera JPEG Encoder:\n"
-                "  Size: %zu\n"
-                "  Quality: %d\n"
-                "  Expand: %d\n",
-                this->output_->get_max_size(), this->quality_, this->buffer_expand_size_);
-}
-
-size_t ESP32CameraJPEGEncoder::callback_(void *arg, size_t index, const void *data, size_t len) {
-  ESP32CameraJPEGEncoder *that = reinterpret_cast<ESP32CameraJPEGEncoder *>(arg);
-  uint8_t *buffer = that->output_->get_data();
-  size_t buffer_length = that->output_->get_max_size();
-  if (index + len > buffer_length) {
-    that->out_of_output_memory_ = true;
-    return 0;
-  }
-
-  std::memcpy(&buffer[index], data, len);
-  that->bytes_written_ += len;
-  return len;
-}
-
-pixformat_t ESP32CameraJPEGEncoder::to_internal_(camera::PixelFormat format) {
-  switch (format) {
-    case camera::PIXEL_FORMAT_GRAYSCALE:
-      return PIXFORMAT_GRAYSCALE;
-    case camera::PIXEL_FORMAT_RGB565:
-      return PIXFORMAT_RGB565;
-    // Internal representation for RGB is in byte order: B, G, R
-    case camera::PIXEL_FORMAT_BGR888:
-      return PIXFORMAT_RGB888;
-  }
-
-  return PIXFORMAT_GRAYSCALE;
-}
-
-}  // namespace esphome::camera_encoder
-
-#endif

esphome/components/camera_encoder/esp32_camera_jpeg_encoder.h

@@ -1,39 +0,0 @@
-#pragma once
-
-#ifdef USE_ESP32_CAMERA_JPEG_ENCODER
-
-#include <esp_camera.h>
-
-#include "esphome/components/camera/encoder.h"
-
-namespace esphome::camera_encoder {
-
-/// Encoder that uses the software-based JPEG implementation from Espressif's esp32-camera component.
-class ESP32CameraJPEGEncoder : public camera::Encoder {
- public:
-  /// Constructs a ESP32CameraJPEGEncoder instance.
-  /// @param quality Sets the quality of the encoded image (1-100).
-  /// @param output Pointer to preallocated output buffer.
-  ESP32CameraJPEGEncoder(uint8_t quality, camera::EncoderBuffer *output);
-  /// Sets the number of bytes to expand the output buffer on underflow during encoding.
-  /// @param buffer_expand_size Number of bytes to expand the buffer.
-  void set_buffer_expand_size(size_t buffer_expand_size) { this->buffer_expand_size_ = buffer_expand_size; }
-  // -------- Encoder --------
-  camera::EncoderError encode_pixels(camera::CameraImageSpec *spec, camera::Buffer *pixels) override;
-  camera::EncoderBuffer *get_output_buffer() override { return output_; }
-  void dump_config() override;
-  // -------------------------
- protected:
-  static size_t callback_(void *arg, size_t index, const void *data, size_t len);
-  pixformat_t to_internal_(camera::PixelFormat format);
-
-  camera::EncoderBuffer *output_{};
-  size_t buffer_expand_size_{};
-  size_t bytes_written_{};
-  uint8_t quality_{};
-  bool out_of_output_memory_{};
-};
-
-}  // namespace esphome::camera_encoder
-
-#endif

esphome/components/captive_portal/__init__.py

@@ -10,7 +10,7 @@ from esphome.const import (
     PLATFORM_LN882X,
     PLATFORM_RTL87XX,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 
 AUTO_LOAD = ["web_server_base", "ota.web_server"]
 DEPENDENCIES = ["wifi"]
@@ -40,7 +40,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(CoroPriority.COMMUNICATION)
+@coroutine_with_priority(64.0)
 async def to_code(config):
     paren = await cg.get_variable(config[CONF_WEB_SERVER_BASE_ID])
 

esphome/components/captive_portal/captive_portal.cpp

@@ -11,35 +11,17 @@ namespace captive_portal {
 static const char *const TAG = "captive_portal";
 
 void CaptivePortal::handle_config(AsyncWebServerRequest *request) {
-  AsyncResponseStream *stream = request->beginResponseStream(F("application/json"));
-  stream->addHeader(F("cache-control"), F("public, max-age=0, must-revalidate"));
-#ifdef USE_ESP8266
-  stream->print(F("{\"mac\":\""));
-  stream->print(get_mac_address_pretty().c_str());
-  stream->print(F("\",\"name\":\""));
-  stream->print(App.get_name().c_str());
-  stream->print(F("\",\"aps\":[{}"));
-#else
+  AsyncResponseStream *stream = request->beginResponseStream("application/json");
+  stream->addHeader("cache-control", "public, max-age=0, must-revalidate");
   stream->printf(R"({"mac":"%s","name":"%s","aps":[{})", get_mac_address_pretty().c_str(), App.get_name().c_str());
-#endif
 
   for (auto &scan : wifi::global_wifi_component->get_scan_result()) {
     if (scan.get_is_hidden())
       continue;
 
-      // Assumes no " in ssid, possible unicode isses?
-#ifdef USE_ESP8266
-    stream->print(F(",{\"ssid\":\""));
-    stream->print(scan.get_ssid().c_str());
-    stream->print(F("\",\"rssi\":"));
-    stream->print(scan.get_rssi());
-    stream->print(F(",\"lock\":"));
-    stream->print(scan.get_with_auth());
-    stream->print(F("}"));
-#else
+    // Assumes no " in ssid, possible unicode isses?
     stream->printf(R"(,{"ssid":"%s","rssi":%d,"lock":%d})", scan.get_ssid().c_str(), scan.get_rssi(),
                    scan.get_with_auth());
-#endif
   }
   stream->print(F("]}"));
   request->send(stream);
@@ -52,7 +34,7 @@ void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
   ESP_LOGI(TAG, "  Password=" LOG_SECRET("'%s'"), psk.c_str());
   wifi::global_wifi_component->save_wifi_sta(ssid, psk);
   wifi::global_wifi_component->start_scanning();
-  request->redirect(F("/?save"));
+  request->redirect("/?save");
 }
 
 void CaptivePortal::setup() {
@@ -71,23 +53,18 @@ void CaptivePortal::start() {
   this->dns_server_ = make_unique<DNSServer>();
   this->dns_server_->setErrorReplyCode(DNSReplyCode::NoError);
   network::IPAddress ip = wifi::global_wifi_component->wifi_soft_ap_ip();
-  this->dns_server_->start(53, F("*"), ip);
+  this->dns_server_->start(53, "*", ip);
   // Re-enable loop() when DNS server is started
   this->enable_loop();
 #endif
 
   this->base_->get_server()->onNotFound([this](AsyncWebServerRequest *req) {
     if (!this->active_ || req->host().c_str() == wifi::global_wifi_component->wifi_soft_ap_ip().str()) {
-      req->send(404, F("text/html"), F("File not found"));
+      req->send(404, "text/html", "File not found");
       return;
     }
 
-#ifdef USE_ESP8266
-    String url = F("http://");
-    url += wifi::global_wifi_component->wifi_soft_ap_ip().str().c_str();
-#else
     auto url = "http://" + wifi::global_wifi_component->wifi_soft_ap_ip().str();
-#endif
     req->redirect(url.c_str());
   });
 
@@ -96,19 +73,19 @@ void CaptivePortal::start() {
 }
 
 void CaptivePortal::handleRequest(AsyncWebServerRequest *req) {
-  if (req->url() == F("/")) {
+  if (req->url() == "/") {
 #ifndef USE_ESP8266
-    auto *response = req->beginResponse(200, F("text/html"), INDEX_GZ, sizeof(INDEX_GZ));
+    auto *response = req->beginResponse(200, "text/html", INDEX_GZ, sizeof(INDEX_GZ));
 #else
-    auto *response = req->beginResponse_P(200, F("text/html"), INDEX_GZ, sizeof(INDEX_GZ));
+    auto *response = req->beginResponse_P(200, "text/html", INDEX_GZ, sizeof(INDEX_GZ));
 #endif
-    response->addHeader(F("Content-Encoding"), F("gzip"));
+    response->addHeader("Content-Encoding", "gzip");
     req->send(response);
     return;
-  } else if (req->url() == F("/config.json")) {
+  } else if (req->url() == "/config.json") {
     this->handle_config(req);
     return;
-  } else if (req->url() == F("/wifisave")) {
+  } else if (req->url() == "/wifisave") {
     this->handle_wifisave(req);
     return;
   }

esphome/components/captive_portal/captive_portal.h

@@ -45,11 +45,11 @@ class CaptivePortal : public AsyncWebHandler, public Component {
       return false;
 
     if (request->method() == HTTP_GET) {
-      if (request->url() == F("/"))
+      if (request->url() == "/")
         return true;
-      if (request->url() == F("/config.json"))
+      if (request->url() == "/config.json")
         return true;
-      if (request->url() == F("/wifisave"))
+      if (request->url() == "/wifisave")
         return true;
     }
 

esphome/components/climate/__init__.py

@@ -47,7 +47,7 @@ from esphome.const import (
     CONF_VISUAL,
     CONF_WEB_SERVER,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
@@ -517,6 +517,6 @@ async def climate_control_to_code(config, action_id, template_arg, args):
     return var
 
 
-@coroutine_with_priority(CoroPriority.CORE)
+@coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(climate_ns.using)

esphome/components/cover/__init__.py

@@ -32,7 +32,7 @@ from esphome.const import (
     DEVICE_CLASS_SHUTTER,
     DEVICE_CLASS_WINDOW,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
@@ -263,6 +263,6 @@ async def cover_control_to_code(config, action_id, template_arg, args):
     return var
 
 
-@coroutine_with_priority(CoroPriority.CORE)
+@coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(cover_ns.using)

esphome/components/cover/cover.h

@@ -19,8 +19,8 @@ const extern float COVER_CLOSED;
     if (traits_.get_is_assumed_state()) { \
       ESP_LOGCONFIG(TAG, "%s  Assumed State: YES", prefix); \
     } \
-    if (!(obj)->get_device_class_ref().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class_ref().c_str()); \
+    if (!(obj)->get_device_class().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class().c_str()); \
     } \
   }
 

esphome/components/dallas_temp/dallas_temp.cpp

@@ -64,7 +64,7 @@ bool DallasTemperatureSensor::read_scratch_pad_() {
     }
   } else {
     ESP_LOGW(TAG, "'%s' - reading scratch pad failed bus reset", this->get_name().c_str());
-    this->status_set_warning(LOG_STR("bus reset failed"));
+    this->status_set_warning("bus reset failed");
   }
   return success;
 }
@@ -124,7 +124,7 @@ bool DallasTemperatureSensor::check_scratch_pad_() {
             crc8(this->scratch_pad_, 8));
 #endif
   if (!chksum_validity) {
-    this->status_set_warning(LOG_STR("scratch pad checksum invalid"));
+    this->status_set_warning("scratch pad checksum invalid");
     ESP_LOGD(TAG, "Scratch pad: %02X.%02X.%02X.%02X.%02X.%02X.%02X.%02X.%02X (%02X)", this->scratch_pad_[0],
              this->scratch_pad_[1], this->scratch_pad_[2], this->scratch_pad_[3], this->scratch_pad_[4],
              this->scratch_pad_[5], this->scratch_pad_[6], this->scratch_pad_[7], this->scratch_pad_[8],

esphome/components/datetime/__init__.py

@@ -21,7 +21,7 @@ from esphome.const import (
     CONF_WEB_SERVER,
     CONF_YEAR,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
@@ -172,7 +172,7 @@ async def new_datetime(config, *args):
     return var
 
 
-@coroutine_with_priority(CoroPriority.CORE)
+@coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(datetime_ns.using)
 

esphome/components/datetime/date_entity.h

@@ -16,8 +16,8 @@ namespace datetime {
 #define LOG_DATETIME_DATE(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon_ref().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
+    if (!(obj)->get_icon().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
     } \
   }
 

esphome/components/datetime/datetime_entity.h

@@ -16,8 +16,8 @@ namespace datetime {
 #define LOG_DATETIME_DATETIME(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon_ref().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
+    if (!(obj)->get_icon().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
     } \
   }
 

esphome/components/datetime/time_entity.h

@@ -16,8 +16,8 @@ namespace datetime {
 #define LOG_DATETIME_TIME(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon_ref().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
+    if (!(obj)->get_icon().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
     } \
   }
 

esphome/components/display/__init__.py

@@ -15,7 +15,7 @@ from esphome.const import (
     CONF_UPDATE_INTERVAL,
     SCHEDULER_DONT_RUN,
 )
-from esphome.core import CoroPriority, coroutine_with_priority
+from esphome.core import coroutine_with_priority
 
 IS_PLATFORM_COMPONENT = True
 
@@ -176,7 +176,7 @@ async def display_page_show_to_code(config, action_id, template_arg, args):
     DisplayPageShowNextAction,
     maybe_simple_id(
         {
-            cv.GenerateID(CONF_ID): cv.templatable(cv.use_id(Display)),
+            cv.Required(CONF_ID): cv.templatable(cv.use_id(Display)),
         }
     ),
 )
@@ -190,7 +190,7 @@ async def display_page_show_next_to_code(config, action_id, template_arg, args):
     DisplayPageShowPrevAction,
     maybe_simple_id(
         {
-            cv.GenerateID(CONF_ID): cv.templatable(cv.use_id(Display)),
+            cv.Required(CONF_ID): cv.templatable(cv.use_id(Display)),
         }
     ),
 )
@@ -218,7 +218,7 @@ async def display_is_displaying_page_to_code(config, condition_id, template_arg,
     return var
 
 
-@coroutine_with_priority(CoroPriority.CORE)
+@coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(display_ns.using)
     cg.add_define("USE_DISPLAY")

esphome/components/esp32/__init__.py

@@ -40,7 +40,6 @@ from esphome.cpp_generator import RawExpression
 import esphome.final_validate as fv
 from esphome.helpers import copy_file_if_changed, mkdir_p, write_file_if_changed
 from esphome.types import ConfigType
-from esphome.writer import clean_cmake_cache
 
 from .boards import BOARDS, STANDARD_BOARDS
 from .const import (  # noqa
@@ -841,9 +840,6 @@ async def to_code(config):
     if conf[CONF_ADVANCED][CONF_IGNORE_EFUSE_CUSTOM_MAC]:
         cg.add_define("USE_ESP32_IGNORE_EFUSE_CUSTOM_MAC")
 
-    for clean_var in ("IDF_PATH", "IDF_TOOLS_PATH"):
-        os.environ.pop(clean_var, None)
-
     add_extra_script(
         "post",
         "post_build.py",
@@ -859,6 +855,11 @@ async def to_code(config):
 
         cg.add_platformio_option("platform_packages", [conf[CONF_SOURCE]])
 
+        # platformio/toolchain-esp32ulp does not support linux_aarch64 yet and has not been updated for over 2 years
+        # This is espressif's own published version which is more up to date.
+        cg.add_platformio_option(
+            "platform_packages", ["espressif/toolchain-esp32ulp@2.35.0-20220830"]
+        )
         add_idf_sdkconfig_option(f"CONFIG_IDF_TARGET_{variant}", True)
         add_idf_sdkconfig_option(
             f"CONFIG_ESPTOOLPY_FLASHSIZE_{config[CONF_FLASH_SIZE]}", True
@@ -1078,11 +1079,7 @@ def _write_idf_component_yml():
         contents = yaml_util.dump({"dependencies": dependencies})
     else:
         contents = ""
-    if write_file_if_changed(yml_path, contents):
-        dependencies_lock = CORE.relative_build_path("dependencies.lock")
-        if os.path.isfile(dependencies_lock):
-            os.remove(dependencies_lock)
-        clean_cmake_cache()
+    write_file_if_changed(yml_path, contents)
 
 
 # Called by writer.py

esphome/components/esp32_ble/__init__.py

@@ -3,7 +3,17 @@ import re
 
 from esphome import automation
 import esphome.codegen as cg
-from esphome.components.esp32 import add_idf_sdkconfig_option, const, get_esp32_variant
+from esphome.components.esp32 import (
+    VARIANT_ESP32C2,
+    VARIANT_ESP32C3,
+    VARIANT_ESP32C5,
+    VARIANT_ESP32C6,
+    VARIANT_ESP32H2,
+    VARIANT_ESP32S3,
+    add_idf_sdkconfig_option,
+    const,
+    get_esp32_variant,
+)
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ENABLE_ON_BOOT,
@@ -11,8 +21,10 @@ from esphome.const import (
     CONF_ID,
     CONF_NAME,
     CONF_NAME_ADD_MAC_SUFFIX,
+    CONF_TX_POWER,
 )
 from esphome.core import CORE, TimePeriod
+from esphome.cpp_types import MockObj
 import esphome.final_validate as fv
 
 DEPENDENCIES = ["esp32"]
@@ -151,7 +163,8 @@ IO_CAPABILITY = {
 
 esp_power_level_t = cg.global_ns.enum("esp_power_level_t")
 
-TX_POWER_LEVELS = {
+# Power level mappings for code generation - ESP32 classic
+TX_POWER_LEVELS_ESP32 = {
     -12: esp_power_level_t.ESP_PWR_LVL_N12,
     -9: esp_power_level_t.ESP_PWR_LVL_N9,
     -6: esp_power_level_t.ESP_PWR_LVL_N6,
@@ -162,6 +175,53 @@ TX_POWER_LEVELS = {
     9: esp_power_level_t.ESP_PWR_LVL_P9,
 }
 
+# Power level mappings for code generation - Extended variants
+TX_POWER_LEVELS_EXT = {
+    -24: esp_power_level_t.ESP_PWR_LVL_N24,
+    -21: esp_power_level_t.ESP_PWR_LVL_N21,
+    -18: esp_power_level_t.ESP_PWR_LVL_N18,
+    -15: esp_power_level_t.ESP_PWR_LVL_N15,
+    -12: esp_power_level_t.ESP_PWR_LVL_N12,
+    -9: esp_power_level_t.ESP_PWR_LVL_N9,
+    -6: esp_power_level_t.ESP_PWR_LVL_N6,
+    -3: esp_power_level_t.ESP_PWR_LVL_N3,
+    0: esp_power_level_t.ESP_PWR_LVL_N0,
+    3: esp_power_level_t.ESP_PWR_LVL_P3,
+    6: esp_power_level_t.ESP_PWR_LVL_P6,
+    9: esp_power_level_t.ESP_PWR_LVL_P9,
+    12: esp_power_level_t.ESP_PWR_LVL_P12,
+    15: esp_power_level_t.ESP_PWR_LVL_P15,
+    18: esp_power_level_t.ESP_PWR_LVL_P18,
+    20: esp_power_level_t.ESP_PWR_LVL_P20,
+}
+
+
+def _get_tx_power_levels() -> dict[str, MockObj]:
+    variant = get_esp32_variant()
+    if variant in [
+        VARIANT_ESP32C2,
+        VARIANT_ESP32C3,
+        VARIANT_ESP32C5,
+        VARIANT_ESP32C6,
+        VARIANT_ESP32H2,
+        VARIANT_ESP32S3,
+    ]:
+        return TX_POWER_LEVELS_EXT
+    return TX_POWER_LEVELS_ESP32
+
+
+def validate_tx_power(value: int) -> int:
+    value = cv.decibel(value)
+    power_levels = _get_tx_power_levels()
+    if value not in power_levels:
+        raise cv.Invalid(
+            f"TX power {value}dBm is not valid. "
+            f"Valid values are: {', '.join(str(v) + 'dBm' for v in sorted(power_levels.keys()))}"
+        )
+    # Return just the dBm value, we'll map it to enum in to_code
+    return value
+
+
 CONFIG_SCHEMA = cv.Schema(
     {
         cv.GenerateID(): cv.declare_id(ESP32BLE),
@@ -169,6 +229,7 @@ CONFIG_SCHEMA = cv.Schema(
         cv.Optional(CONF_IO_CAPABILITY, default="none"): cv.enum(
             IO_CAPABILITY, lower=True
         ),
+        cv.Optional(CONF_TX_POWER): validate_tx_power,
         cv.Optional(CONF_ENABLE_ON_BOOT, default=True): cv.boolean,
         cv.Optional(CONF_ADVERTISING, default=False): cv.boolean,
         cv.Optional(
@@ -259,6 +320,9 @@ async def to_code(config):
     cg.add(var.set_advertising_cycle_time(config[CONF_ADVERTISING_CYCLE_TIME]))
     if (name := config.get(CONF_NAME)) is not None:
         cg.add(var.set_name(name))
+    if (tx_power := config.get(CONF_TX_POWER)) is not None:
+        # The validation already returned the enum value
+        cg.add(var.set_tx_power(_get_tx_power_levels()[tx_power]))
     await cg.register_component(var, config)
 
     if CORE.using_esp_idf:

esphome/components/esp32_ble/ble.cpp

@@ -212,6 +212,15 @@ bool ESP32BLE::ble_setup_() {
     return false;
   }
 
+  // Set TX power for all BLE operations (advertising, scanning, connections)
+  err = esp_ble_tx_power_set(ESP_BLE_PWR_TYPE_DEFAULT, this->tx_power_);
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "esp_ble_tx_power_set failed: %s", esp_err_to_name(err));
+    // Continue anyway as this is not critical
+  } else {
+    ESP_LOGD(TAG, "BLE TX power set to level %d", this->tx_power_);
+  }
+
   // BLE takes some time to be fully set up, 200ms should be more than enough
   delay(200);  // NOLINT
 
@@ -520,11 +529,106 @@ void ESP32BLE::dump_config() {
         io_capability_s = "invalid";
         break;
     }
+    // Convert TX power level to dBm for display
+    int tx_power_dbm = 0;
+#if defined(CONFIG_IDF_TARGET_ESP32)
+    // ESP32 classic power levels (0-7)
+    switch (this->tx_power_) {
+      case 0:
+        tx_power_dbm = -12;
+        break;  // ESP_PWR_LVL_N12
+      case 1:
+        tx_power_dbm = -9;
+        break;  // ESP_PWR_LVL_N9
+      case 2:
+        tx_power_dbm = -6;
+        break;  // ESP_PWR_LVL_N6
+      case 3:
+        tx_power_dbm = -3;
+        break;  // ESP_PWR_LVL_N3
+      case 4:
+        tx_power_dbm = 0;
+        break;  // ESP_PWR_LVL_N0
+      case 5:
+        tx_power_dbm = 3;
+        break;  // ESP_PWR_LVL_P3
+      case 6:
+        tx_power_dbm = 6;
+        break;  // ESP_PWR_LVL_P6
+      case 7:
+        tx_power_dbm = 9;
+        break;  // ESP_PWR_LVL_P9
+      default:
+        tx_power_dbm = 0;
+        break;
+    }
+#elif defined(CONFIG_IDF_TARGET_ESP32C2) || defined(CONFIG_IDF_TARGET_ESP32C3) || \
+    defined(CONFIG_IDF_TARGET_ESP32C5) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32H2) || \
+    defined(CONFIG_IDF_TARGET_ESP32S3)
+    // Extended power levels for C2/C3/C5/C6/H2/S3 (0-15)
+    switch (this->tx_power_) {
+      case 0:
+        tx_power_dbm = -24;
+        break;  // ESP_PWR_LVL_N24
+      case 1:
+        tx_power_dbm = -21;
+        break;  // ESP_PWR_LVL_N21
+      case 2:
+        tx_power_dbm = -18;
+        break;  // ESP_PWR_LVL_N18
+      case 3:
+        tx_power_dbm = -15;
+        break;  // ESP_PWR_LVL_N15
+      case 4:
+        tx_power_dbm = -12;
+        break;  // ESP_PWR_LVL_N12
+      case 5:
+        tx_power_dbm = -9;
+        break;  // ESP_PWR_LVL_N9
+      case 6:
+        tx_power_dbm = -6;
+        break;  // ESP_PWR_LVL_N6
+      case 7:
+        tx_power_dbm = -3;
+        break;  // ESP_PWR_LVL_N3
+      case 8:
+        tx_power_dbm = 0;
+        break;  // ESP_PWR_LVL_N0
+      case 9:
+        tx_power_dbm = 3;
+        break;  // ESP_PWR_LVL_P3
+      case 10:
+        tx_power_dbm = 6;
+        break;  // ESP_PWR_LVL_P6
+      case 11:
+        tx_power_dbm = 9;
+        break;  // ESP_PWR_LVL_P9
+      case 12:
+        tx_power_dbm = 12;
+        break;  // ESP_PWR_LVL_P12
+      case 13:
+        tx_power_dbm = 15;
+        break;  // ESP_PWR_LVL_P15
+      case 14:
+        tx_power_dbm = 18;
+        break;  // ESP_PWR_LVL_P18
+      case 15:
+        tx_power_dbm = 20;
+        break;  // ESP_PWR_LVL_P20
+      default:
+        tx_power_dbm = 0;
+        break;
+    }
+#else
+    // Unknown variant
+    tx_power_dbm = 0;
+#endif
     ESP_LOGCONFIG(TAG,
                   "BLE:\n"
                   "  MAC address: %s\n"
-                  "  IO Capability: %s",
-                  format_mac_address_pretty(mac_address).c_str(), io_capability_s);
+                  "  IO Capability: %s\n"
+                  "  TX Power: %d dBm",
+                  format_mac_address_pretty(mac_address).c_str(), io_capability_s, tx_power_dbm);
   } else {
     ESP_LOGCONFIG(TAG, "Bluetooth stack is not enabled");
   }

esphome/components/esp32_ble/ble.h

@@ -20,6 +20,7 @@
 
 #ifdef USE_ESP32
 
+#include <esp_bt.h>
 #include <esp_gap_ble_api.h>
 #include <esp_gattc_api.h>
 #include <esp_gatts_api.h>
@@ -94,6 +95,7 @@ class BLEStatusEventHandler {
 class ESP32BLE : public Component {
  public:
   void set_io_capability(IoCapability io_capability) { this->io_cap_ = (esp_ble_io_cap_t) io_capability; }
+  void set_tx_power(esp_power_level_t tx_power) { this->tx_power_ = tx_power; }
 
   void set_advertising_cycle_time(uint32_t advertising_cycle_time) {
     this->advertising_cycle_time_ = advertising_cycle_time;
@@ -172,6 +174,7 @@ class ESP32BLE : public Component {
   // 1-byte aligned members (grouped together to minimize padding)
   BLEComponentState state_{BLE_COMPONENT_STATE_OFF};  // 1 byte (uint8_t enum)
   bool enable_on_boot_{};                             // 1 byte
+  esp_power_level_t tx_power_{ESP_PWR_LVL_P9};        // 1 byte (default: +9 dBm)
 };
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)

esphome/components/esp32_ble_client/ble_client_base.cpp

@@ -93,7 +93,7 @@ bool BLEClientBase::parse_device(const espbt::ESPBTDevice &device) {
     return false;
   if (this->address_ == 0 || device.address_uint64() != this->address_)
     return false;
-  if (this->state_ != espbt::ClientState::IDLE)
+  if (this->state_ != espbt::ClientState::IDLE && this->state_ != espbt::ClientState::SEARCHING)
     return false;
 
   this->log_event_("Found device");
@@ -168,7 +168,8 @@ void BLEClientBase::unconditional_disconnect() {
     this->log_gattc_warning_("esp_ble_gattc_close", err);
   }
 
-  if (this->state_ == espbt::ClientState::READY_TO_CONNECT || this->state_ == espbt::ClientState::DISCOVERED) {
+  if (this->state_ == espbt::ClientState::SEARCHING || this->state_ == espbt::ClientState::READY_TO_CONNECT ||
+      this->state_ == espbt::ClientState::DISCOVERED) {
     this->set_address(0);
     this->set_state(espbt::ClientState::IDLE);
   } else {

esphome/components/esp32_ble_tracker/__init__.py

@@ -30,7 +30,7 @@ from esphome.const import (
     CONF_SERVICE_UUID,
     CONF_TRIGGER_ID,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 from esphome.enum import StrEnum
 from esphome.types import ConfigType
 
@@ -368,7 +368,7 @@ async def to_code(config):
 # This needs to be run as a job with very low priority so that all components have
 # chance to call register_ble_tracker and register_client before the list is checked
 # and added to the global defines list.
-@coroutine_with_priority(CoroPriority.FINAL)
+@coroutine_with_priority(-1000)
 async def _add_ble_features():
     # Add feature-specific defines based on what's needed
     if BLEFeatures.ESP_BT_DEVICE in _required_features:

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -49,6 +49,8 @@ const char *client_state_to_string(ClientState state) {
       return "DISCONNECTING";
     case ClientState::IDLE:
       return "IDLE";
+    case ClientState::SEARCHING:
+      return "SEARCHING";
     case ClientState::DISCOVERED:
       return "DISCOVERED";
     case ClientState::READY_TO_CONNECT:
@@ -134,8 +136,9 @@ void ESP32BLETracker::loop() {
   ClientStateCounts counts = this->count_client_states_();
   if (counts != this->client_state_counts_) {
     this->client_state_counts_ = counts;
-    ESP_LOGD(TAG, "connecting: %d, discovered: %d, disconnecting: %d", this->client_state_counts_.connecting,
-             this->client_state_counts_.discovered, this->client_state_counts_.disconnecting);
+    ESP_LOGD(TAG, "connecting: %d, discovered: %d, searching: %d, disconnecting: %d",
+             this->client_state_counts_.connecting, this->client_state_counts_.discovered,
+             this->client_state_counts_.searching, this->client_state_counts_.disconnecting);
   }
 
   if (this->scanner_state_ == ScannerState::FAILED ||
@@ -155,8 +158,10 @@ void ESP32BLETracker::loop() {
     https://github.com/espressif/esp-idf/issues/6688
 
   */
+  bool promote_to_connecting = counts.discovered && !counts.searching && !counts.connecting;
 
-  if (this->scanner_state_ == ScannerState::IDLE && !counts.connecting && !counts.disconnecting && !counts.discovered) {
+  if (this->scanner_state_ == ScannerState::IDLE && !counts.connecting && !counts.disconnecting &&
+      !promote_to_connecting) {
 #ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
     this->update_coex_preference_(false);
 #endif
@@ -165,11 +170,12 @@ void ESP32BLETracker::loop() {
     }
   }
   // If there is a discovered client and no connecting
-  // clients, then promote the discovered client to ready to connect.
+  // clients and no clients using the scanner to search for
+  // devices, then promote the discovered client to ready to connect.
   // We check both RUNNING and IDLE states because:
   // - RUNNING: gap_scan_event_handler initiates stop_scan_() but promotion can happen immediately
   // - IDLE: Scanner has already stopped (naturally or by gap_scan_event_handler)
-  if (counts.discovered && !counts.connecting &&
+  if (promote_to_connecting &&
       (this->scanner_state_ == ScannerState::RUNNING || this->scanner_state_ == ScannerState::IDLE)) {
     this->try_promote_discovered_clients_();
   }
@@ -301,7 +307,14 @@ void ESP32BLETracker::gap_scan_event_handler(const BLEScanResult &scan_result) {
 
   if (scan_result.search_evt == ESP_GAP_SEARCH_INQ_RES_EVT) {
     // Process the scan result immediately
-    this->process_scan_result_(scan_result);
+    bool found_discovered_client = this->process_scan_result_(scan_result);
+
+    // If we found a discovered client that needs promotion, stop scanning
+    // This replaces the promote_to_connecting logic from loop()
+    if (found_discovered_client && this->scanner_state_ == ScannerState::RUNNING) {
+      ESP_LOGD(TAG, "Found discovered client, stopping scan for connection");
+      this->stop_scan_();
+    }
   } else if (scan_result.search_evt == ESP_GAP_SEARCH_INQ_CMPL_EVT) {
     // Scan finished on its own
     if (this->scanner_state_ != ScannerState::RUNNING) {
@@ -627,8 +640,9 @@ void ESP32BLETracker::dump_config() {
                 this->scan_duration_, this->scan_interval_ * 0.625f, this->scan_window_ * 0.625f,
                 this->scan_active_ ? "ACTIVE" : "PASSIVE", YESNO(this->scan_continuous_));
   ESP_LOGCONFIG(TAG, "  Scanner State: %s", this->scanner_state_to_string_(this->scanner_state_));
-  ESP_LOGCONFIG(TAG, "  Connecting: %d, discovered: %d, disconnecting: %d", this->client_state_counts_.connecting,
-                this->client_state_counts_.discovered, this->client_state_counts_.disconnecting);
+  ESP_LOGCONFIG(TAG, "  Connecting: %d, discovered: %d, searching: %d, disconnecting: %d",
+                this->client_state_counts_.connecting, this->client_state_counts_.discovered,
+                this->client_state_counts_.searching, this->client_state_counts_.disconnecting);
   if (this->scan_start_fail_count_) {
     ESP_LOGCONFIG(TAG, "  Scan Start Fail Count: %d", this->scan_start_fail_count_);
   }
@@ -706,9 +720,20 @@ bool ESPBTDevice::resolve_irk(const uint8_t *irk) const {
          ecb_ciphertext[13] == ((addr64 >> 16) & 0xff);
 }
 
+bool ESP32BLETracker::has_connecting_clients_() const {
+  for (auto *client : this->clients_) {
+    auto state = client->state();
+    if (state == ClientState::CONNECTING || state == ClientState::READY_TO_CONNECT) {
+      return true;
+    }
+  }
+  return false;
+}
 #endif  // USE_ESP32_BLE_DEVICE
 
-void ESP32BLETracker::process_scan_result_(const BLEScanResult &scan_result) {
+bool ESP32BLETracker::process_scan_result_(const BLEScanResult &scan_result) {
+  bool found_discovered_client = false;
+
   // Process raw advertisements
   if (this->raw_advertisements_) {
     for (auto *listener : this->listeners_) {
@@ -734,6 +759,14 @@ void ESP32BLETracker::process_scan_result_(const BLEScanResult &scan_result) {
     for (auto *client : this->clients_) {
       if (client->parse_device(device)) {
         found = true;
+        // Check if this client is discovered and needs promotion
+        if (client->state() == ClientState::DISCOVERED) {
+          // Only check for connecting clients if we found a discovered client
+          // This matches the original logic: !connecting && client->state() == DISCOVERED
+          if (!this->has_connecting_clients_()) {
+            found_discovered_client = true;
+          }
+        }
       }
     }
 
@@ -742,6 +775,8 @@ void ESP32BLETracker::process_scan_result_(const BLEScanResult &scan_result) {
     }
 #endif  // USE_ESP32_BLE_DEVICE
   }
+
+  return found_discovered_client;
 }
 
 void ESP32BLETracker::cleanup_scan_state_(bool is_stop_complete) {

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -141,10 +141,12 @@ class ESPBTDeviceListener {
 struct ClientStateCounts {
   uint8_t connecting = 0;
   uint8_t discovered = 0;
+  uint8_t searching = 0;
   uint8_t disconnecting = 0;
 
   bool operator==(const ClientStateCounts &other) const {
-    return connecting == other.connecting && discovered == other.discovered && disconnecting == other.disconnecting;
+    return connecting == other.connecting && discovered == other.discovered && searching == other.searching &&
+           disconnecting == other.disconnecting;
   }
 
   bool operator!=(const ClientStateCounts &other) const { return !(*this == other); }
@@ -157,6 +159,8 @@ enum class ClientState : uint8_t {
   DISCONNECTING,
   // Connection is idle, no device detected.
   IDLE,
+  // Searching for device.
+  SEARCHING,
   // Device advertisement found.
   DISCOVERED,
   // Device is discovered and the scanner is stopped
@@ -288,7 +292,12 @@ class ESP32BLETracker : public Component,
   /// Common cleanup logic when transitioning scanner to IDLE state
   void cleanup_scan_state_(bool is_stop_complete);
   /// Process a single scan result immediately
-  void process_scan_result_(const BLEScanResult &scan_result);
+  /// Returns true if a discovered client needs promotion to READY_TO_CONNECT
+  bool process_scan_result_(const BLEScanResult &scan_result);
+#ifdef USE_ESP32_BLE_DEVICE
+  /// Check if any clients are in connecting or ready to connect state
+  bool has_connecting_clients_() const;
+#endif
   /// Handle scanner failure states
   void handle_scanner_failure_();
   /// Try to promote discovered clients to ready to connect
@@ -312,6 +321,9 @@ class ESP32BLETracker : public Component,
         case ClientState::DISCOVERED:
           counts.discovered++;
           break;
+        case ClientState::SEARCHING:
+          counts.searching++;
+          break;
         case ClientState::CONNECTING:
         case ClientState::READY_TO_CONNECT:
           counts.connecting++;

esphome/components/esp8266/__init__.py

@@ -17,7 +17,7 @@ from esphome.const import (
     PLATFORM_ESP8266,
     ThreadModel,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 from esphome.helpers import copy_file_if_changed
 
 from .boards import BOARDS, ESP8266_LD_SCRIPTS
@@ -176,7 +176,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(CoroPriority.PLATFORM)
+@coroutine_with_priority(1000)
 async def to_code(config):
     cg.add(esp8266_ns.setup_preferences())
 

esphome/components/esp8266/core.cpp

@@ -58,8 +58,8 @@ extern "C" void resetPins() {  // NOLINT
 
 #ifdef USE_ESP8266_EARLY_PIN_INIT
   for (int i = 0; i < 16; i++) {
-    uint8_t mode = progmem_read_byte(&ESPHOME_ESP8266_GPIO_INITIAL_MODE[i]);
-    uint8_t level = progmem_read_byte(&ESPHOME_ESP8266_GPIO_INITIAL_LEVEL[i]);
+    uint8_t mode = ESPHOME_ESP8266_GPIO_INITIAL_MODE[i];
+    uint8_t level = ESPHOME_ESP8266_GPIO_INITIAL_LEVEL[i];
     if (mode != 255)
       pinMode(i, mode);  // NOLINT
     if (level != 255)

esphome/components/esp8266/gpio.py

@@ -17,7 +17,7 @@ from esphome.const import (
     CONF_PULLUP,
     PLATFORM_ESP8266,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 
 from . import boards
 from .const import KEY_BOARD, KEY_ESP8266, KEY_PIN_INITIAL_STATES, esp8266_ns
@@ -188,7 +188,7 @@ async def esp8266_pin_to_code(config):
     return var
 
 
-@coroutine_with_priority(CoroPriority.WORKAROUNDS)
+@coroutine_with_priority(-999.0)
 async def add_pin_initial_states_array():
     # Add includes at the very end, so that they override everything
     initial_states: list[PinInitialState] = CORE.data[KEY_ESP8266][
@@ -199,11 +199,11 @@ async def add_pin_initial_states_array():
 
     cg.add_global(
         cg.RawExpression(
-            f"const uint8_t ESPHOME_ESP8266_GPIO_INITIAL_MODE[16] PROGMEM = {{{initial_modes_s}}}"
+            f"const uint8_t ESPHOME_ESP8266_GPIO_INITIAL_MODE[16] = {{{initial_modes_s}}}"
         )
     )
     cg.add_global(
         cg.RawExpression(
-            f"const uint8_t ESPHOME_ESP8266_GPIO_INITIAL_LEVEL[16] PROGMEM = {{{initial_levels_s}}}"
+            f"const uint8_t ESPHOME_ESP8266_GPIO_INITIAL_LEVEL[16] = {{{initial_levels_s}}}"
         )
     )

esphome/components/esp8266/preferences.cpp

@@ -1,7 +1,6 @@
 #ifdef USE_ESP8266
 
 #include <c_types.h>
-#include <cinttypes>
 extern "C" {
 #include "spi_flash.h"
 }
@@ -120,16 +119,16 @@ static bool load_from_rtc(size_t offset, uint32_t *data, size_t len) {
 
 class ESP8266PreferenceBackend : public ESPPreferenceBackend {
  public:
+  size_t offset = 0;
   uint32_t type = 0;
-  uint16_t offset = 0;
-  uint8_t length_words = 0;  // Max 255 words (1020 bytes of data)
   bool in_flash = false;
+  size_t length_words = 0;
 
   bool save(const uint8_t *data, size_t len) override {
     if (bytes_to_words(len) != length_words) {
       return false;
     }
-    size_t buffer_size = static_cast<size_t>(length_words) + 1;
+    size_t buffer_size = length_words + 1;
     std::unique_ptr<uint32_t[]> buffer(new uint32_t[buffer_size]());  // Note the () for zero-initialization
     memcpy(buffer.get(), data, len);
     buffer[length_words] = calculate_crc(buffer.get(), buffer.get() + length_words, type);
@@ -143,7 +142,7 @@ class ESP8266PreferenceBackend : public ESPPreferenceBackend {
     if (bytes_to_words(len) != length_words) {
       return false;
     }
-    size_t buffer_size = static_cast<size_t>(length_words) + 1;
+    size_t buffer_size = length_words + 1;
     std::unique_ptr<uint32_t[]> buffer(new uint32_t[buffer_size]());
     bool ret = in_flash ? load_from_flash(offset, buffer.get(), buffer_size)
                         : load_from_rtc(offset, buffer.get(), buffer_size);
@@ -177,19 +176,15 @@ class ESP8266Preferences : public ESPPreferences {
 
   ESPPreferenceObject make_preference(size_t length, uint32_t type, bool in_flash) override {
     uint32_t length_words = bytes_to_words(length);
-    if (length_words > 255) {
-      ESP_LOGE(TAG, "Preference too large: %" PRIu32 " words > 255", length_words);
-      return {};
-    }
     if (in_flash) {
       uint32_t start = current_flash_offset;
       uint32_t end = start + length_words + 1;
       if (end > ESP8266_FLASH_STORAGE_SIZE)
         return {};
       auto *pref = new ESP8266PreferenceBackend();  // NOLINT(cppcoreguidelines-owning-memory)
-      pref->offset = static_cast<uint16_t>(start);
+      pref->offset = start;
       pref->type = type;
-      pref->length_words = static_cast<uint8_t>(length_words);
+      pref->length_words = length_words;
       pref->in_flash = true;
       current_flash_offset = end;
       return {pref};
@@ -215,9 +210,9 @@ class ESP8266Preferences : public ESPPreferences {
     uint32_t rtc_offset = in_normal ? start + 32 : start - 96;
 
     auto *pref = new ESP8266PreferenceBackend();  // NOLINT(cppcoreguidelines-owning-memory)
-    pref->offset = static_cast<uint16_t>(rtc_offset);
+    pref->offset = rtc_offset;
     pref->type = type;
-    pref->length_words = static_cast<uint8_t>(length_words);
+    pref->length_words = length_words;
     pref->in_flash = false;
     current_offset += length_words + 1;
     return pref;

esphome/components/esphome/ota/__init__.py

@@ -16,7 +16,7 @@ from esphome.const import (
     CONF_SAFE_MODE,
     CONF_VERSION,
 )
-from esphome.core import CoroPriority, coroutine_with_priority
+from esphome.core import coroutine_with_priority
 import esphome.final_validate as fv
 
 _LOGGER = logging.getLogger(__name__)
@@ -121,7 +121,7 @@ CONFIG_SCHEMA = (
 FINAL_VALIDATE_SCHEMA = ota_esphome_final_validate
 
 
-@coroutine_with_priority(CoroPriority.COMMUNICATION)
+@coroutine_with_priority(52.0)
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     cg.add(var.set_port(config[CONF_PORT]))

esphome/components/esphome/ota/ota_esphome.cpp

@@ -30,19 +30,19 @@ void ESPHomeOTAComponent::setup() {
 
   this->server_ = socket::socket_ip_loop_monitored(SOCK_STREAM, 0);  // monitored for incoming connections
   if (this->server_ == nullptr) {
-    this->log_socket_error_(LOG_STR("creation"));
+    this->log_socket_error_("creation");
     this->mark_failed();
     return;
   }
   int enable = 1;
   int err = this->server_->setsockopt(SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int));
   if (err != 0) {
-    this->log_socket_error_(LOG_STR("reuseaddr"));
+    this->log_socket_error_("reuseaddr");
     // we can still continue
   }
   err = this->server_->setblocking(false);
   if (err != 0) {
-    this->log_socket_error_(LOG_STR("non-blocking"));
+    this->log_socket_error_("non-blocking");
     this->mark_failed();
     return;
   }
@@ -51,21 +51,21 @@ void ESPHomeOTAComponent::setup() {
 
   socklen_t sl = socket::set_sockaddr_any((struct sockaddr *) &server, sizeof(server), this->port_);
   if (sl == 0) {
-    this->log_socket_error_(LOG_STR("set sockaddr"));
+    this->log_socket_error_("set sockaddr");
     this->mark_failed();
     return;
   }
 
   err = this->server_->bind((struct sockaddr *) &server, sizeof(server));
   if (err != 0) {
-    this->log_socket_error_(LOG_STR("bind"));
+    this->log_socket_error_("bind");
     this->mark_failed();
     return;
   }
 
   err = this->server_->listen(4);
   if (err != 0) {
-    this->log_socket_error_(LOG_STR("listen"));
+    this->log_socket_error_("listen");
     this->mark_failed();
     return;
   }
@@ -100,8 +100,8 @@ void ESPHomeOTAComponent::handle_handshake_() {
   /// Handle the initial OTA handshake.
   ///
   /// This method is non-blocking and will return immediately if no data is available.
-  /// It reads all 5 magic bytes (0x6C, 0x26, 0xF7, 0x5C, 0x45) non-blocking
-  /// before proceeding to handle_data_(). A 10-second timeout is enforced from initial connection.
+  /// It waits for the first magic byte (0x6C) before proceeding to handle_data_().
+  /// A 10-second timeout is enforced from initial connection.
 
   if (this->client_ == nullptr) {
     // We already checked server_->ready() in loop(), so we can accept directly
@@ -114,19 +114,18 @@ void ESPHomeOTAComponent::handle_handshake_() {
       return;
     int err = this->client_->setsockopt(IPPROTO_TCP, TCP_NODELAY, &enable, sizeof(int));
     if (err != 0) {
-      this->log_socket_error_(LOG_STR("nodelay"));
+      this->log_socket_error_("nodelay");
       this->cleanup_connection_();
       return;
     }
     err = this->client_->setblocking(false);
     if (err != 0) {
-      this->log_socket_error_(LOG_STR("non-blocking"));
+      this->log_socket_error_("non-blocking");
       this->cleanup_connection_();
       return;
     }
-    this->log_start_(LOG_STR("handshake"));
+    this->log_start_("handshake");
     this->client_connect_time_ = App.get_loop_component_start_time();
-    this->magic_buf_pos_ = 0;  // Reset magic buffer position
   }
 
   // Check for handshake timeout
@@ -137,47 +136,34 @@ void ESPHomeOTAComponent::handle_handshake_() {
     return;
   }
 
-  // Try to read remaining magic bytes
-  if (this->magic_buf_pos_ < 5) {
-    // Read as many bytes as available
-    uint8_t bytes_to_read = 5 - this->magic_buf_pos_;
-    ssize_t read = this->client_->read(this->magic_buf_ + this->magic_buf_pos_, bytes_to_read);
+  // Try to read first byte of magic bytes
+  uint8_t first_byte;
+  ssize_t read = this->client_->read(&first_byte, 1);
 
-    if (read == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
-      return;  // No data yet, try again next loop
-    }
-
-    if (read <= 0) {
-      // Error or connection closed
-      if (read == -1) {
-        this->log_socket_error_(LOG_STR("reading magic bytes"));
-      } else {
-        ESP_LOGW(TAG, "Remote closed during handshake");
-      }
-      this->cleanup_connection_();
-      return;
-    }
-
-    this->magic_buf_pos_ += read;
+  if (read == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
+    return;  // No data yet, try again next loop
   }
 
-  // Check if we have all 5 magic bytes
-  if (this->magic_buf_pos_ == 5) {
-    // Validate magic bytes
-    static const uint8_t MAGIC_BYTES[5] = {0x6C, 0x26, 0xF7, 0x5C, 0x45};
-    if (memcmp(this->magic_buf_, MAGIC_BYTES, 5) != 0) {
-      ESP_LOGW(TAG, "Magic bytes mismatch! 0x%02X-0x%02X-0x%02X-0x%02X-0x%02X", this->magic_buf_[0],
-               this->magic_buf_[1], this->magic_buf_[2], this->magic_buf_[3], this->magic_buf_[4]);
-      // Send error response (non-blocking, best effort)
-      uint8_t error = static_cast<uint8_t>(ota::OTA_RESPONSE_ERROR_MAGIC);
-      this->client_->write(&error, 1);
-      this->cleanup_connection_();
-      return;
+  if (read <= 0) {
+    // Error or connection closed
+    if (read == -1) {
+      this->log_socket_error_("reading first byte");
+    } else {
+      ESP_LOGW(TAG, "Remote closed during handshake");
     }
-
-    // All 5 magic bytes are valid, continue with data handling
-    this->handle_data_();
+    this->cleanup_connection_();
+    return;
   }
+
+  // Got first byte, check if it's the magic byte
+  if (first_byte != 0x6C) {
+    ESP_LOGW(TAG, "Invalid initial byte: 0x%02X", first_byte);
+    this->cleanup_connection_();
+    return;
+  }
+
+  // First byte is valid, continue with data handling
+  this->handle_data_();
 }
 
 void ESPHomeOTAComponent::handle_data_() {
@@ -200,6 +186,18 @@ void ESPHomeOTAComponent::handle_data_() {
   size_t size_acknowledged = 0;
 #endif
 
+  // Read remaining 4 bytes of magic (we already read the first byte 0x6C in handle_handshake_)
+  if (!this->readall_(buf, 4)) {
+    this->log_read_error_("magic bytes");
+    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
+  }
+  // Check remaining magic bytes: 0x26, 0xF7, 0x5C, 0x45
+  if (buf[0] != 0x26 || buf[1] != 0xF7 || buf[2] != 0x5C || buf[3] != 0x45) {
+    ESP_LOGW(TAG, "Magic bytes mismatch! 0x6C-0x%02X-0x%02X-0x%02X-0x%02X", buf[0], buf[1], buf[2], buf[3]);
+    error_code = ota::OTA_RESPONSE_ERROR_MAGIC;
+    goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
+  }
+
   // Send OK and version - 2 bytes
   buf[0] = ota::OTA_RESPONSE_OK;
   buf[1] = USE_OTA_VERSION;
@@ -209,7 +207,7 @@ void ESPHomeOTAComponent::handle_data_() {
 
   // Read features - 1 byte
   if (!this->readall_(buf, 1)) {
-    this->log_read_error_(LOG_STR("features"));
+    this->log_read_error_("features");
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
   ota_features = buf[0];  // NOLINT
@@ -288,7 +286,7 @@ void ESPHomeOTAComponent::handle_data_() {
 
   // Read size, 4 bytes MSB first
   if (!this->readall_(buf, 4)) {
-    this->log_read_error_(LOG_STR("size"));
+    this->log_read_error_("size");
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
   ota_size = 0;
@@ -302,7 +300,7 @@ void ESPHomeOTAComponent::handle_data_() {
   // starting the update, set the warning status and notify
   // listeners. This ensures that port scanners do not
   // accidentally trigger the update process.
-  this->log_start_(LOG_STR("update"));
+  this->log_start_("update");
   this->status_set_warning();
 #ifdef USE_OTA_STATE_CALLBACK
   this->state_callback_.call(ota::OTA_STARTED, 0.0f, 0);
@@ -320,7 +318,7 @@ void ESPHomeOTAComponent::handle_data_() {
 
   // Read binary MD5, 32 bytes
   if (!this->readall_(buf, 32)) {
-    this->log_read_error_(LOG_STR("MD5 checksum"));
+    this->log_read_error_("MD5 checksum");
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
   sbuf[32] = '\0';
@@ -393,7 +391,7 @@ void ESPHomeOTAComponent::handle_data_() {
 
   // Read ACK
   if (!this->readall_(buf, 1) || buf[0] != ota::OTA_RESPONSE_OK) {
-    this->log_read_error_(LOG_STR("ack"));
+    this->log_read_error_("ack");
     // do not go to error, this is not fatal
   }
 
@@ -477,21 +475,18 @@ float ESPHomeOTAComponent::get_setup_priority() const { return setup_priority::A
 uint16_t ESPHomeOTAComponent::get_port() const { return this->port_; }
 void ESPHomeOTAComponent::set_port(uint16_t port) { this->port_ = port; }
 
-void ESPHomeOTAComponent::log_socket_error_(const LogString *msg) {
-  ESP_LOGW(TAG, "Socket %s: errno %d", LOG_STR_ARG(msg), errno);
-}
+void ESPHomeOTAComponent::log_socket_error_(const char *msg) { ESP_LOGW(TAG, "Socket %s: errno %d", msg, errno); }
 
-void ESPHomeOTAComponent::log_read_error_(const LogString *what) { ESP_LOGW(TAG, "Read %s failed", LOG_STR_ARG(what)); }
+void ESPHomeOTAComponent::log_read_error_(const char *what) { ESP_LOGW(TAG, "Read %s failed", what); }
 
-void ESPHomeOTAComponent::log_start_(const LogString *phase) {
-  ESP_LOGD(TAG, "Starting %s from %s", LOG_STR_ARG(phase), this->client_->getpeername().c_str());
+void ESPHomeOTAComponent::log_start_(const char *phase) {
+  ESP_LOGD(TAG, "Starting %s from %s", phase, this->client_->getpeername().c_str());
 }
 
 void ESPHomeOTAComponent::cleanup_connection_() {
   this->client_->close();
   this->client_ = nullptr;
   this->client_connect_time_ = 0;
-  this->magic_buf_pos_ = 0;
 }
 
 void ESPHomeOTAComponent::yield_and_feed_watchdog_() {

esphome/components/esphome/ota/ota_esphome.h

@@ -3,7 +3,6 @@
 #include "esphome/core/defines.h"
 #ifdef USE_OTA
 #include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
 #include "esphome/core/preferences.h"
 #include "esphome/components/ota/ota_backend.h"
 #include "esphome/components/socket/socket.h"
@@ -32,9 +31,9 @@ class ESPHomeOTAComponent : public ota::OTAComponent {
   void handle_data_();
   bool readall_(uint8_t *buf, size_t len);
   bool writeall_(const uint8_t *buf, size_t len);
-  void log_socket_error_(const LogString *msg);
-  void log_read_error_(const LogString *what);
-  void log_start_(const LogString *phase);
+  void log_socket_error_(const char *msg);
+  void log_read_error_(const char *what);
+  void log_start_(const char *phase);
   void cleanup_connection_();
   void yield_and_feed_watchdog_();
 
@@ -42,13 +41,11 @@ class ESPHomeOTAComponent : public ota::OTAComponent {
   std::string password_;
 #endif  // USE_OTA_PASSWORD
 
+  uint16_t port_;
+  uint32_t client_connect_time_{0};
+
   std::unique_ptr<socket::Socket> server_;
   std::unique_ptr<socket::Socket> client_;
-
-  uint32_t client_connect_time_{0};
-  uint16_t port_;
-  uint8_t magic_buf_[5];
-  uint8_t magic_buf_pos_{0};
 };
 
 }  // namespace esphome

esphome/components/ethernet/__init__.py

@@ -38,12 +38,7 @@ from esphome.const import (
     KEY_CORE,
     KEY_FRAMEWORK_VERSION,
 )
-from esphome.core import (
-    CORE,
-    CoroPriority,
-    TimePeriodMilliseconds,
-    coroutine_with_priority,
-)
+from esphome.core import CORE, TimePeriodMilliseconds, coroutine_with_priority
 import esphome.final_validate as fv
 
 CONFLICTS_WITH = ["wifi"]
@@ -294,7 +289,7 @@ def phy_register(address: int, value: int, page: int):
     )
 
 
-@coroutine_with_priority(CoroPriority.COMMUNICATION)
+@coroutine_with_priority(60.0)
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/ethernet/ethernet_component.cpp

@@ -492,7 +492,7 @@ void EthernetComponent::start_connect_() {
   global_eth_component->ipv6_count_ = 0;
 #endif /* USE_NETWORK_IPV6 */
   this->connect_begin_ = millis();
-  this->status_set_warning(LOG_STR("waiting for IP configuration"));
+  this->status_set_warning("waiting for IP configuration");
 
   esp_err_t err;
   err = esp_netif_set_hostname(this->eth_netif_, App.get_name().c_str());

esphome/components/event/__init__.py

@@ -17,7 +17,7 @@ from esphome.const import (
     DEVICE_CLASS_EMPTY,
     DEVICE_CLASS_MOTION,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
@@ -143,6 +143,6 @@ async def event_fire_to_code(config, action_id, template_arg, args):
     return var
 
 
-@coroutine_with_priority(CoroPriority.CORE)
+@coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(event_ns.using)

esphome/components/event/event.h

@@ -13,11 +13,11 @@ namespace event {
 #define LOG_EVENT(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon_ref().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
+    if (!(obj)->get_icon().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
     } \
-    if (!(obj)->get_device_class_ref().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class_ref().c_str()); \
+    if (!(obj)->get_device_class().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class().c_str()); \
     } \
   }
 

esphome/components/fan/__init__.py

@@ -31,7 +31,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_WEB_SERVER,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 
 IS_PLATFORM_COMPONENT = True
@@ -398,6 +398,6 @@ async def fan_is_on_off_to_code(config, condition_id, template_arg, args):
     return cg.new_Pvariable(condition_id, template_arg, paren)
 
 
-@coroutine_with_priority(CoroPriority.CORE)
+@coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(fan_ns.using)

esphome/components/gdk101/gdk101.cpp

@@ -11,22 +11,22 @@ static const uint8_t NUMBER_OF_READ_RETRIES = 5;
 void GDK101Component::update() {
   uint8_t data[2];
   if (!this->read_dose_1m_(data)) {
-    this->status_set_warning(LOG_STR("Failed to read dose 1m"));
+    this->status_set_warning("Failed to read dose 1m");
     return;
   }
 
   if (!this->read_dose_10m_(data)) {
-    this->status_set_warning(LOG_STR("Failed to read dose 10m"));
+    this->status_set_warning("Failed to read dose 10m");
     return;
   }
 
   if (!this->read_status_(data)) {
-    this->status_set_warning(LOG_STR("Failed to read status"));
+    this->status_set_warning("Failed to read status");
     return;
   }
 
   if (!this->read_measurement_duration_(data)) {
-    this->status_set_warning(LOG_STR("Failed to read measurement duration"));
+    this->status_set_warning("Failed to read measurement duration");
     return;
   }
   this->status_clear_warning();

esphome/components/globals/__init__.py

@@ -8,7 +8,7 @@ from esphome.const import (
     CONF_TYPE,
     CONF_VALUE,
 )
-from esphome.core import CoroPriority, coroutine_with_priority
+from esphome.core import coroutine_with_priority
 
 CODEOWNERS = ["@esphome/core"]
 globals_ns = cg.esphome_ns.namespace("globals")
@@ -35,7 +35,7 @@ CONFIG_SCHEMA = cv.Schema(
 
 
 # Run with low priority so that namespaces are registered first
-@coroutine_with_priority(CoroPriority.LATE)
+@coroutine_with_priority(-100.0)
 async def to_code(config):
     type_ = cg.RawExpression(config[CONF_TYPE])
     restore = config[CONF_RESTORE_VALUE]

esphome/components/gpio/binary_sensor/gpio_binary_sensor.cpp

@@ -6,23 +6,6 @@ namespace gpio {
 
 static const char *const TAG = "gpio.binary_sensor";
 
-static const LogString *interrupt_type_to_string(gpio::InterruptType type) {
-  switch (type) {
-    case gpio::INTERRUPT_RISING_EDGE:
-      return LOG_STR("RISING_EDGE");
-    case gpio::INTERRUPT_FALLING_EDGE:
-      return LOG_STR("FALLING_EDGE");
-    case gpio::INTERRUPT_ANY_EDGE:
-      return LOG_STR("ANY_EDGE");
-    default:
-      return LOG_STR("UNKNOWN");
-  }
-}
-
-static const LogString *gpio_mode_to_string(bool use_interrupt) {
-  return use_interrupt ? LOG_STR("interrupt") : LOG_STR("polling");
-}
-
 void IRAM_ATTR GPIOBinarySensorStore::gpio_intr(GPIOBinarySensorStore *arg) {
   bool new_state = arg->isr_pin_.digital_read();
   if (new_state != arg->last_state_) {
@@ -68,9 +51,25 @@ void GPIOBinarySensor::setup() {
 void GPIOBinarySensor::dump_config() {
   LOG_BINARY_SENSOR("", "GPIO Binary Sensor", this);
   LOG_PIN("  Pin: ", this->pin_);
-  ESP_LOGCONFIG(TAG, "  Mode: %s", LOG_STR_ARG(gpio_mode_to_string(this->use_interrupt_)));
+  const char *mode = this->use_interrupt_ ? "interrupt" : "polling";
+  ESP_LOGCONFIG(TAG, "  Mode: %s", mode);
   if (this->use_interrupt_) {
-    ESP_LOGCONFIG(TAG, "  Interrupt Type: %s", LOG_STR_ARG(interrupt_type_to_string(this->interrupt_type_)));
+    const char *interrupt_type;
+    switch (this->interrupt_type_) {
+      case gpio::INTERRUPT_RISING_EDGE:
+        interrupt_type = "RISING_EDGE";
+        break;
+      case gpio::INTERRUPT_FALLING_EDGE:
+        interrupt_type = "FALLING_EDGE";
+        break;
+      case gpio::INTERRUPT_ANY_EDGE:
+        interrupt_type = "ANY_EDGE";
+        break;
+      default:
+        interrupt_type = "UNKNOWN";
+        break;
+    }
+    ESP_LOGCONFIG(TAG, "  Interrupt Type: %s", interrupt_type);
   }
 }
 

esphome/components/gt911/touchscreen/gt911_touchscreen.cpp

@@ -20,7 +20,7 @@ static const size_t MAX_BUTTONS = 4;  // max number of buttons scanned
 
 #define ERROR_CHECK(err) \
   if ((err) != i2c::ERROR_OK) { \
-    this->status_set_warning(LOG_STR(ESP_LOG_MSG_COMM_FAIL)); \
+    this->status_set_warning(ESP_LOG_MSG_COMM_FAIL); \
     return; \
   }
 

esphome/components/honeywellabp2_i2c/honeywellabp2.cpp

@@ -15,7 +15,7 @@ static const char *const TAG = "honeywellabp2";
 void HONEYWELLABP2Sensor::read_sensor_data() {
   if (this->read(raw_data_, 7) != i2c::ERROR_OK) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
-    this->status_set_warning(LOG_STR("couldn't read sensor data"));
+    this->status_set_warning("couldn't read sensor data");
     return;
   }
   float press_counts = encode_uint24(raw_data_[1], raw_data_[2], raw_data_[3]);  // calculate digital pressure counts
@@ -31,7 +31,7 @@ void HONEYWELLABP2Sensor::read_sensor_data() {
 void HONEYWELLABP2Sensor::start_measurement() {
   if (this->write(i2c_cmd_, 3) != i2c::ERROR_OK) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
-    this->status_set_warning(LOG_STR("couldn't start measurement"));
+    this->status_set_warning("couldn't start measurement");
     return;
   }
   this->measurement_running_ = true;
@@ -40,7 +40,7 @@ void HONEYWELLABP2Sensor::start_measurement() {
 bool HONEYWELLABP2Sensor::is_measurement_ready() {
   if (this->read(raw_data_, 1) != i2c::ERROR_OK) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
-    this->status_set_warning(LOG_STR("couldn't check measurement"));
+    this->status_set_warning("couldn't check measurement");
     return false;
   }
   if ((raw_data_[0] & (0x1 << STATUS_BIT_BUSY)) > 0) {
@@ -53,7 +53,7 @@ bool HONEYWELLABP2Sensor::is_measurement_ready() {
 void HONEYWELLABP2Sensor::measurement_timeout() {
   ESP_LOGE(TAG, "Timeout!");
   this->measurement_running_ = false;
-  this->status_set_warning(LOG_STR("measurement timed out"));
+  this->status_set_warning("measurement timed out");
 }
 
 float HONEYWELLABP2Sensor::get_pressure() { return this->last_pressure_; }

esphome/components/host/preferences.h

@@ -42,10 +42,9 @@ class HostPreferences : public ESPPreferences {
     if (len > 255)
       return false;
     this->setup_();
-    auto it = this->data.find(key);
-    if (it == this->data.end())
+    if (this->data.count(key) == 0)
       return false;
-    const auto &vec = it->second;
+    auto vec = this->data[key];
     if (vec.size() != len)
       return false;
     memcpy(data, vec.data(), len);

esphome/components/http_request/ota/__init__.py

@@ -3,7 +3,7 @@ import esphome.codegen as cg
 from esphome.components.ota import BASE_OTA_SCHEMA, OTAComponent, ota_to_code
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_PASSWORD, CONF_URL, CONF_USERNAME
-from esphome.core import CoroPriority, coroutine_with_priority
+from esphome.core import coroutine_with_priority
 
 from .. import CONF_HTTP_REQUEST_ID, HttpRequestComponent, http_request_ns
 
@@ -40,7 +40,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(CoroPriority.COMMUNICATION)
+@coroutine_with_priority(52.0)
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await ota_to_code(var, config)

esphome/components/i2c/__init__.py

@@ -18,7 +18,7 @@ from esphome.const import (
     PLATFORM_RP2040,
     PlatformFramework,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 import esphome.final_validate as fv
 
 LOGGER = logging.getLogger(__name__)
@@ -74,7 +74,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(CoroPriority.BUS)
+@coroutine_with_priority(1.0)
 async def to_code(config):
     cg.add_global(i2c_ns.using)
     cg.add_define("USE_I2C")

esphome/components/i2c/i2c.cpp

@@ -39,22 +39,18 @@ ErrorCode I2CDevice::read_register16(uint16_t a_register, uint8_t *data, size_t
 }
 
 ErrorCode I2CDevice::write_register(uint8_t a_register, const uint8_t *data, size_t len) const {
-  SmallBufferWithHeapFallback<17> buffer_alloc;  // Most I2C writes are <= 16 bytes
-  uint8_t *buffer = buffer_alloc.get(len + 1);
-
-  buffer[0] = a_register;
-  std::copy(data, data + len, buffer + 1);
-  return this->bus_->write_readv(this->address_, buffer, len + 1, nullptr, 0);
+  std::vector<uint8_t> v{};
+  v.push_back(a_register);
+  v.insert(v.end(), data, data + len);
+  return bus_->write_readv(this->address_, v.data(), v.size(), nullptr, 0);
 }
 
 ErrorCode I2CDevice::write_register16(uint16_t a_register, const uint8_t *data, size_t len) const {
-  SmallBufferWithHeapFallback<18> buffer_alloc;  // Most I2C writes are <= 16 bytes + 2 for register
-  uint8_t *buffer = buffer_alloc.get(len + 2);
-
-  buffer[0] = a_register >> 8;
-  buffer[1] = a_register;
-  std::copy(data, data + len, buffer + 2);
-  return this->bus_->write_readv(this->address_, buffer, len + 2, nullptr, 0);
+  std::vector<uint8_t> v(len + 2);
+  v.push_back(a_register >> 8);
+  v.push_back(a_register);
+  v.insert(v.end(), data, data + len);
+  return bus_->write_readv(this->address_, v.data(), v.size(), nullptr, 0);
 }
 
 bool I2CDevice::read_bytes_16(uint8_t a_register, uint16_t *data, uint8_t len) {

esphome/components/i2c/i2c_bus.h

@@ -2,7 +2,6 @@
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
-#include <memory>
 #include <utility>
 #include <vector>
 
@@ -11,22 +10,6 @@
 namespace esphome {
 namespace i2c {
 
-/// @brief Helper class for efficient buffer allocation - uses stack for small sizes, heap for large
-template<size_t STACK_SIZE> class SmallBufferWithHeapFallback {
- public:
-  uint8_t *get(size_t size) {
-    if (size <= STACK_SIZE) {
-      return this->stack_buffer_;
-    }
-    this->heap_buffer_ = std::unique_ptr<uint8_t[]>(new uint8_t[size]);
-    return this->heap_buffer_.get();
-  }
-
- private:
-  uint8_t stack_buffer_[STACK_SIZE];
-  std::unique_ptr<uint8_t[]> heap_buffer_;
-};
-
 /// @brief Error codes returned by I2CBus and I2CDevice methods
 enum ErrorCode {
   NO_ERROR = 0,                ///< No error found during execution of method
@@ -91,17 +74,14 @@ class I2CBus {
     for (size_t i = 0; i != count; i++) {
       total_len += read_buffers[i].len;
     }
-
-    SmallBufferWithHeapFallback<128> buffer_alloc;  // Most I2C reads are small
-    uint8_t *buffer = buffer_alloc.get(total_len);
-
-    auto err = this->write_readv(address, nullptr, 0, buffer, total_len);
+    std::vector<uint8_t> buffer(total_len);
+    auto err = this->write_readv(address, nullptr, 0, buffer.data(), total_len);
     if (err != ERROR_OK)
       return err;
     size_t pos = 0;
     for (size_t i = 0; i != count; i++) {
       if (read_buffers[i].len != 0) {
-        std::memcpy(read_buffers[i].data, buffer + pos, read_buffers[i].len);
+        std::memcpy(read_buffers[i].data, buffer.data() + pos, read_buffers[i].len);
         pos += read_buffers[i].len;
       }
     }
@@ -111,21 +91,11 @@ class I2CBus {
   ESPDEPRECATED("This method is deprecated and will be removed in ESPHome 2026.3.0. Use write_readv() instead.",
                 "2025.9.0")
   ErrorCode writev(uint8_t address, const WriteBuffer *write_buffers, size_t count, bool stop = true) {
-    size_t total_len = 0;
+    std::vector<uint8_t> buffer{};
     for (size_t i = 0; i != count; i++) {
-      total_len += write_buffers[i].len;
+      buffer.insert(buffer.end(), write_buffers[i].data, write_buffers[i].data + write_buffers[i].len);
     }
-
-    SmallBufferWithHeapFallback<128> buffer_alloc;  // Most I2C writes are small
-    uint8_t *buffer = buffer_alloc.get(total_len);
-
-    size_t pos = 0;
-    for (size_t i = 0; i != count; i++) {
-      std::memcpy(buffer + pos, write_buffers[i].data, write_buffers[i].len);
-      pos += write_buffers[i].len;
-    }
-
-    return this->write_readv(address, buffer, total_len, nullptr, 0);
+    return this->write_readv(address, buffer.data(), buffer.size(), nullptr, 0);
   }
 
  protected:

esphome/components/json/__init__.py

@@ -1,6 +1,6 @@
 import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome.core import CoroPriority, coroutine_with_priority
+from esphome.core import coroutine_with_priority
 
 CODEOWNERS = ["@esphome/core"]
 json_ns = cg.esphome_ns.namespace("json")
@@ -10,7 +10,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(CoroPriority.BUS)
+@coroutine_with_priority(1.0)
 async def to_code(config):
     cg.add_library("bblanchon/ArduinoJson", "7.4.2")
     cg.add_define("USE_JSON")

esphome/components/kmeteriso/kmeteriso.cpp

@@ -33,7 +33,7 @@ void KMeterISOComponent::setup() {
   }
 
   uint8_t read_buf[4] = {1};
-  if (!this->read_bytes(KMETER_ERROR_STATUS_REG, read_buf, 1)) {
+  if (!this->read_register(KMETER_ERROR_STATUS_REG, read_buf, 1)) {
     ESP_LOGCONFIG(TAG, "Could not read from the device.");
     this->error_code_ = COMMUNICATION_FAILED;
     this->mark_failed();

esphome/components/light/__init__.py

@@ -37,7 +37,7 @@ from esphome.const import (
     CONF_WEB_SERVER,
     CONF_WHITE,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
@@ -283,6 +283,6 @@ async def new_light(config, *args):
     return output_var
 
 
-@coroutine_with_priority(CoroPriority.CORE)
+@coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(light_ns.using)

esphome/components/light/light_call.cpp

@@ -11,21 +11,19 @@ static const char *const TAG = "light";
 
 // Helper functions to reduce code size for logging
 #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);
+static void log_validation_warning(const char *name, const char *param_name, float val, float min, float max) {
+  ESP_LOGW(TAG, "'%s': %s value %.2f is out of range [%.1f - %.1f]", name, param_name, val, min, max);
 }
 
-static void log_feature_not_supported(const char *name, const LogString *feature) {
-  ESP_LOGW(TAG, "'%s': %s not supported", name, LOG_STR_ARG(feature));
+static void log_feature_not_supported(const char *name, const char *feature) {
+  ESP_LOGW(TAG, "'%s': %s not supported", name, feature);
 }
 
-static void log_color_mode_not_supported(const char *name, const LogString *feature) {
-  ESP_LOGW(TAG, "'%s': color mode does not support setting %s", name, LOG_STR_ARG(feature));
+static void log_color_mode_not_supported(const char *name, const char *feature) {
+  ESP_LOGW(TAG, "'%s': color mode does not support setting %s", name, feature);
 }
 
-static void log_invalid_parameter(const char *name, const LogString *message) {
-  ESP_LOGW(TAG, "'%s': %s", name, LOG_STR_ARG(message));
-}
+static void log_invalid_parameter(const char *name, const char *message) { ESP_LOGW(TAG, "'%s': %s", name, message); }
 #else
 #define log_validation_warning(name, param_name, val, min, max)
 #define log_feature_not_supported(name, feature)
@@ -203,19 +201,19 @@ LightColorValues LightCall::validate_() {
 
   // Brightness exists check
   if (this->has_brightness() && this->brightness_ > 0.0f && !(color_mode & ColorCapability::BRIGHTNESS)) {
-    log_feature_not_supported(name, LOG_STR("brightness"));
+    log_feature_not_supported(name, "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"));
+    log_feature_not_supported(name, "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"));
+    log_color_mode_not_supported(name, "RGB brightness");
     this->set_flag_(FLAG_HAS_COLOR_BRIGHTNESS, false);
   }
 
@@ -223,7 +221,7 @@ LightColorValues LightCall::validate_() {
   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"));
+      log_color_mode_not_supported(name, "RGB color");
       this->set_flag_(FLAG_HAS_RED, false);
       this->set_flag_(FLAG_HAS_GREEN, false);
       this->set_flag_(FLAG_HAS_BLUE, false);
@@ -233,21 +231,21 @@ LightColorValues LightCall::validate_() {
   // 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"));
+    log_color_mode_not_supported(name, "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"));
+    log_color_mode_not_supported(name, "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"));
+      log_color_mode_not_supported(name, "cold/warm white value");
       this->set_flag_(FLAG_HAS_COLD_WHITE, false);
       this->set_flag_(FLAG_HAS_WARM_WHITE, false);
     }
@@ -257,7 +255,7 @@ LightColorValues LightCall::validate_() {
   if (this->has_##name_()) { \
     auto val = this->name_##_; \
     if (val < (min) || val > (max)) { \
-      log_validation_warning(name, LOG_STR(upper_name), val, (min), (max)); \
+      log_validation_warning(name, LOG_STR_LITERAL(upper_name), val, (min), (max)); \
       this->name_##_ = clamp(val, (min), (max)); \
     } \
   }
@@ -321,7 +319,7 @@ LightColorValues LightCall::validate_() {
 
   // Flash length check
   if (this->has_flash_() && this->flash_length_ == 0) {
-    log_invalid_parameter(name, LOG_STR("flash length must be greater than zero"));
+    log_invalid_parameter(name, "flash length must be greater than zero");
     this->set_flag_(FLAG_HAS_FLASH, false);
   }
 
@@ -340,13 +338,13 @@ LightColorValues LightCall::validate_() {
   }
 
   if (this->has_effect_() && (this->has_transition_() || this->has_flash_())) {
-    log_invalid_parameter(name, LOG_STR("effect cannot be used with transition/flash"));
+    log_invalid_parameter(name, "effect cannot be used with transition/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"));
+    log_invalid_parameter(name, "flash cannot be used with transition");
     this->set_flag_(FLAG_HAS_TRANSITION, false);
   }
 
@@ -363,7 +361,7 @@ LightColorValues LightCall::validate_() {
   }
 
   if (this->has_transition_() && !supports_transition) {
-    log_feature_not_supported(name, LOG_STR("transitions"));
+    log_feature_not_supported(name, "transitions");
     this->set_flag_(FLAG_HAS_TRANSITION, false);
   }
 
@@ -373,7 +371,7 @@ LightColorValues LightCall::validate_() {
   bool target_state = this->has_state() ? this->state_ : v.is_on();
   if (!this->has_flash_() && !target_state) {
     if (this->has_effect_()) {
-      log_invalid_parameter(name, LOG_STR("cannot start effect when turning off"));
+      log_invalid_parameter(name, "cannot start effect when turning off");
       this->set_flag_(FLAG_HAS_EFFECT, false);
     } else if (this->parent_->active_effect_index_ != 0 && explicit_turn_off_request) {
       // Auto turn off effect

esphome/components/lock/__init__.py

@@ -13,7 +13,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_WEB_SERVER,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
 from esphome.cpp_generator import MockObjClass
 
@@ -155,6 +155,6 @@ async def lock_is_off_to_code(config, condition_id, template_arg, args):
     return cg.new_Pvariable(condition_id, template_arg, paren, False)
 
 
-@coroutine_with_priority(CoroPriority.CORE)
+@coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(lock_ns.using)

esphome/components/lock/lock.h

@@ -15,8 +15,8 @@ class Lock;
 #define LOG_LOCK(prefix, type, obj) \
   if ((obj) != nullptr) { \
     ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
-    if (!(obj)->get_icon_ref().empty()) { \
-      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon_ref().c_str()); \
+    if (!(obj)->get_icon().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
     } \
     if ((obj)->traits.get_assumed_state()) { \
       ESP_LOGCONFIG(TAG, "%s  Assumed State: YES", prefix); \

esphome/components/logger/__init__.py

@@ -51,7 +51,7 @@ from esphome.const import (
     PLATFORM_RTL87XX,
     PlatformFramework,
 )
-from esphome.core import CORE, CoroPriority, Lambda, coroutine_with_priority
+from esphome.core import CORE, Lambda, coroutine_with_priority
 
 CODEOWNERS = ["@esphome/core"]
 logger_ns = cg.esphome_ns.namespace("logger")
@@ -275,7 +275,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(CoroPriority.DIAGNOSTICS)
+@coroutine_with_priority(90.0)
 async def to_code(config):
     baud_rate = config[CONF_BAUD_RATE]
     level = config[CONF_LEVEL]