[api] Use MAX_STATE_LEN constant for Home Assistant state buffer

2026-01-18 07:54:50 -07:00 · 2026-01-16 09:37:48 -10:00
39 changed files with 383 additions and 1113 deletions
--- a/.claude/skills/pr-workflow/SKILL.md
+++ b/.claude/skills/pr-workflow/SKILL.md
@@ -1,96 +0,0 @@
---
-name: pr-workflow
-description: Create pull requests for esphome. Use when creating PRs, submitting changes, or preparing contributions.
-allowed-tools: Read, Bash, Glob, Grep
---
-
-# ESPHome PR Workflow
-
-When creating a pull request for esphome, follow these steps:
-
-## 1. Create Branch from Upstream
-
-Always base your branch on **upstream** (not origin/fork) to ensure you have the latest code:
-
-```bash
-git fetch upstream
-git checkout -b <branch-name> upstream/dev
-```
-
-## 2. Read the PR Template
-
-Before creating a PR, read `.github/PULL_REQUEST_TEMPLATE.md` to understand required fields.
-
-## 3. Create the PR
-
-Use `gh pr create` with the **full template** filled in. Never skip or abbreviate sections.
-
-Required fields:
- **What does this implement/fix?**: Brief description of changes
- **Types of changes**: Check ONE appropriate box (Bugfix, New feature, Breaking change, etc.)
- **Related issue**: Use `fixes <link>` syntax if applicable
- **Pull request in esphome-docs**: Link if docs are needed
- **Test Environment**: Check platforms you tested on
- **Example config.yaml**: Include working example YAML
- **Checklist**: Verify code is tested and tests added
-
-## 4. Example PR Body
-
-```markdown
-# What does this implement/fix?
-
-<describe your changes here>
-
-## Types of changes
-
- [ ] Bugfix (non-breaking change which fixes an issue)
- [x] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
- [ ] Developer breaking change (an API change that could break external components)
- [ ] Code quality improvements to existing code or addition of tests
- [ ] Other
-
-**Related issue or feature (if applicable):**
-
- fixes https://github.com/esphome/esphome/issues/XXX
-
-**Pull request in [esphome-docs](https://github.com/esphome/esphome-docs) with documentation (if applicable):**
-
- esphome/esphome-docs#XXX
-
-## Test Environment
-
- [x] ESP32
- [x] ESP32 IDF
- [ ] ESP8266
- [ ] RP2040
- [ ] BK72xx
- [ ] RTL87xx
- [ ] LN882x
- [ ] nRF52840
-
-## Example entry for `config.yaml`:
-
-```yaml
-# Example config.yaml
-component_name:
-  id: my_component
-  option: value
-```
-
-## Checklist:
-  - [x] The code change is tested and works locally.
-  - [x] Tests have been added to verify that the new code works (under `tests/` folder).
-
-If user exposed functionality or configuration variables are added/changed:
-  - [ ] Documentation added/updated in [esphome-docs](https://github.com/esphome/esphome-docs).
-```
-
-## 5. Push and Create PR
-
-```bash
-git push -u origin <branch-name>
-gh pr create --repo esphome/esphome --base dev --title "[component] Brief description"
-```
-
-Title should be prefixed with the component name in brackets, e.g. `[safe_mode] Add feature`.
--- a/.github/actions/restore-python/action.yml
+++ b/.github/actions/restore-python/action.yml
@@ -22,7 +22,7 @@ runs:
        python-version: ${{ inputs.python-version }}
    - name: Restore Python virtual environment
      id: cache-venv
-      uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+      uses: actions/cache/restore@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
      with:
        path: venv
        # yamllint disable-line rule:line-length
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -47,7 +47,7 @@ jobs:
          python-version: ${{ env.DEFAULT_PYTHON }}
      - name: Restore Python virtual environment
        id: cache-venv
-        uses: actions/cache@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: venv
          # yamllint disable-line rule:line-length
@@ -157,7 +157,7 @@ jobs:
          token: ${{ secrets.CODECOV_TOKEN }}
      - name: Save Python virtual environment cache
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache/save@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache/save@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: venv
          key: ${{ runner.os }}-${{ steps.restore-python.outputs.python-version }}-venv-${{ needs.common.outputs.cache-key }}
@@ -193,7 +193,7 @@ jobs:
          python-version: ${{ env.DEFAULT_PYTHON }}
          cache-key: ${{ needs.common.outputs.cache-key }}
      - name: Restore components graph cache
-        uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache/restore@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: .temp/components_graph.json
          key: components-graph-${{ hashFiles('esphome/components/**/*.py') }}
@@ -223,7 +223,7 @@ jobs:
          echo "component-test-batches=$(echo "$output" | jq -c '.component_test_batches')" >> $GITHUB_OUTPUT
      - name: Save components graph cache
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache/save@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache/save@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: .temp/components_graph.json
          key: components-graph-${{ hashFiles('esphome/components/**/*.py') }}
@@ -245,7 +245,7 @@ jobs:
          python-version: "3.13"
      - name: Restore Python virtual environment
        id: cache-venv
-        uses: actions/cache@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: venv
          key: ${{ runner.os }}-${{ steps.python.outputs.python-version }}-venv-${{ needs.common.outputs.cache-key }}
@@ -334,14 +334,14 @@ jobs:

      - name: Cache platformio
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: ~/.platformio
          key: platformio-${{ matrix.pio_cache_key }}-${{ hashFiles('platformio.ini') }}

      - name: Cache platformio
        if: github.ref != 'refs/heads/dev'
-        uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache/restore@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: ~/.platformio
          key: platformio-${{ matrix.pio_cache_key }}-${{ hashFiles('platformio.ini') }}
@@ -413,14 +413,14 @@ jobs:

      - name: Cache platformio
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: ~/.platformio
          key: platformio-tidyesp32-${{ hashFiles('platformio.ini') }}

      - name: Cache platformio
        if: github.ref != 'refs/heads/dev'
-        uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache/restore@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: ~/.platformio
          key: platformio-tidyesp32-${{ hashFiles('platformio.ini') }}
@@ -502,14 +502,14 @@ jobs:

      - name: Cache platformio
        if: github.ref == 'refs/heads/dev'
-        uses: actions/cache@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: ~/.platformio
          key: platformio-tidyesp32-${{ hashFiles('platformio.ini') }}

      - name: Cache platformio
        if: github.ref != 'refs/heads/dev'
-        uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache/restore@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: ~/.platformio
          key: platformio-tidyesp32-${{ hashFiles('platformio.ini') }}
@@ -735,7 +735,7 @@ jobs:
      - name: Restore cached memory analysis
        id: cache-memory-analysis
        if: steps.check-script.outputs.skip != 'true'
-        uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache/restore@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: memory-analysis-target.json
          key: ${{ steps.cache-key.outputs.cache-key }}
@@ -759,7 +759,7 @@ jobs:

      - name: Cache platformio
        if: steps.check-script.outputs.skip != 'true' && steps.cache-memory-analysis.outputs.cache-hit != 'true'
-        uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache/restore@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: ~/.platformio
          key: platformio-memory-${{ fromJSON(needs.determine-jobs.outputs.memory_impact).platform }}-${{ hashFiles('platformio.ini') }}
@@ -800,7 +800,7 @@ jobs:

      - name: Save memory analysis to cache
        if: steps.check-script.outputs.skip != 'true' && steps.cache-memory-analysis.outputs.cache-hit != 'true' && steps.build.outcome == 'success'
-        uses: actions/cache/save@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache/save@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: memory-analysis-target.json
          key: ${{ steps.cache-key.outputs.cache-key }}
@@ -847,7 +847,7 @@ jobs:
          python-version: ${{ env.DEFAULT_PYTHON }}
          cache-key: ${{ needs.common.outputs.cache-key }}
      - name: Cache platformio
-        uses: actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: actions/cache/restore@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
        with:
          path: ~/.platformio
          key: platformio-memory-${{ fromJSON(needs.determine-jobs.outputs.memory_impact).platform }}-${{ hashFiles('platformio.ini') }}
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -11,7 +11,7 @@ ci:
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    # Ruff version.
-    rev: v0.14.13
+    rev: v0.14.11
    hooks:
      # Run the linter.
      - id: ruff
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -1712,8 +1712,8 @@ void APIConnection::on_home_assistant_state_response(const HomeAssistantStateRes
    }

    // Create null-terminated state for callback (parse_number needs null-termination)
-    // HA state max length is 255, so 256 byte buffer covers all cases
-    char state_buf[256];
+    // HA state max length is MAX_STATE_LEN, so buffer needs +1 for null terminator
+    char state_buf[MAX_STATE_LEN + 1];
    size_t copy_len = msg.state.size();
    if (copy_len >= sizeof(state_buf)) {
      copy_len = sizeof(state_buf) - 1;  // Truncate to leave space for null terminator
--- a/esphome/components/api/proto.cpp
+++ b/esphome/components/api/proto.cpp
@@ -48,14 +48,14 @@ uint32_t ProtoDecodableMessage::count_repeated_field(const uint8_t *buffer, size
        }
        uint32_t field_length = res->as_uint32();
        ptr += consumed;
-        if (field_length > static_cast<size_t>(end - ptr)) {
+        if (ptr + field_length > end) {
          return count;  // Out of bounds
        }
        ptr += field_length;
        break;
      }
      case WIRE_TYPE_FIXED32: {  // 32-bit - skip 4 bytes
-        if (end - ptr < 4) {
+        if (ptr + 4 > end) {
          return count;
        }
        ptr += 4;
@@ -110,7 +110,7 @@ void ProtoDecodableMessage::decode(const uint8_t *buffer, size_t length) {
        }
        uint32_t field_length = res->as_uint32();
        ptr += consumed;
-        if (field_length > static_cast<size_t>(end - ptr)) {
+        if (ptr + field_length > end) {
          ESP_LOGV(TAG, "Out-of-bounds Length Delimited at offset %ld", (long) (ptr - buffer));
          return;
        }
@@ -121,7 +121,7 @@ void ProtoDecodableMessage::decode(const uint8_t *buffer, size_t length) {
        break;
      }
      case WIRE_TYPE_FIXED32: {  // 32-bit
-        if (end - ptr < 4) {
+        if (ptr + 4 > end) {
          ESP_LOGV(TAG, "Out-of-bounds Fixed32-bit at offset %ld", (long) (ptr - buffer));
          return;
        }
--- a/esphome/components/bluetooth_proxy/bluetooth_connection.cpp
+++ b/esphome/components/bluetooth_proxy/bluetooth_connection.cpp
@@ -135,8 +135,8 @@ void BluetoothConnection::loop() {
  // - For V3_WITH_CACHE: Services are never sent, disable after INIT state
  // - For V3_WITHOUT_CACHE: Disable only after service discovery is complete
  //   (send_service_ == DONE_SENDING_SERVICES, which is only set after services are sent)
-  if (this->state() != espbt::ClientState::INIT && (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE ||
-                                                    this->send_service_ == DONE_SENDING_SERVICES)) {
+  if (this->state_ != espbt::ClientState::INIT && (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE ||
+                                                   this->send_service_ == DONE_SENDING_SERVICES)) {
    this->disable_loop();
  }
 }
--- a/esphome/components/esp32_ble_client/ble_client_base.cpp
+++ b/esphome/components/esp32_ble_client/ble_client_base.cpp
@@ -50,7 +50,7 @@ void BLEClientBase::loop() {
    this->set_state(espbt::ClientState::INIT);
    return;
  }
-  if (this->state() == espbt::ClientState::INIT) {
+  if (this->state_ == espbt::ClientState::INIT) {
    auto ret = esp_ble_gattc_app_register(this->app_id);
    if (ret) {
      ESP_LOGE(TAG, "gattc app register failed. app_id=%d code=%d", this->app_id, ret);
@@ -60,7 +60,7 @@ void BLEClientBase::loop() {
  }
  // If idle, we can disable the loop as connect()
  // will enable it again when a connection is needed.
-  else if (this->state() == espbt::ClientState::IDLE) {
+  else if (this->state_ == espbt::ClientState::IDLE) {
    this->disable_loop();
  }
 }
@@ -86,7 +86,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)
    return false;

  this->log_event_("Found device");
@@ -102,10 +102,10 @@ bool BLEClientBase::parse_device(const espbt::ESPBTDevice &device) {

 void BLEClientBase::connect() {
  // Prevent duplicate connection attempts
-  if (this->state() == espbt::ClientState::CONNECTING || this->state() == espbt::ClientState::CONNECTED ||
-      this->state() == espbt::ClientState::ESTABLISHED) {
+  if (this->state_ == espbt::ClientState::CONNECTING || this->state_ == espbt::ClientState::CONNECTED ||
+      this->state_ == espbt::ClientState::ESTABLISHED) {
    ESP_LOGW(TAG, "[%d] [%s] Connection already in progress, state=%s", this->connection_index_, this->address_str_,
-             espbt::client_state_to_string(this->state()));
+             espbt::client_state_to_string(this->state_));
    return;
  }
  ESP_LOGI(TAG, "[%d] [%s] 0x%02x Connecting", this->connection_index_, this->address_str_, this->remote_addr_type_);
@@ -133,12 +133,12 @@ void BLEClientBase::connect() {
 esp_err_t BLEClientBase::pair() { return esp_ble_set_encryption(this->remote_bda_, ESP_BLE_SEC_ENCRYPT); }

 void BLEClientBase::disconnect() {
-  if (this->state() == espbt::ClientState::IDLE || this->state() == espbt::ClientState::DISCONNECTING) {
+  if (this->state_ == espbt::ClientState::IDLE || this->state_ == espbt::ClientState::DISCONNECTING) {
    ESP_LOGI(TAG, "[%d] [%s] Disconnect requested, but already %s", this->connection_index_, this->address_str_,
-             espbt::client_state_to_string(this->state()));
+             espbt::client_state_to_string(this->state_));
    return;
  }
-  if (this->state() == espbt::ClientState::CONNECTING || this->conn_id_ == UNSET_CONN_ID) {
+  if (this->state_ == espbt::ClientState::CONNECTING || this->conn_id_ == UNSET_CONN_ID) {
    ESP_LOGD(TAG, "[%d] [%s] Disconnect before connected, disconnect scheduled", this->connection_index_,
             this->address_str_);
    this->want_disconnect_ = true;
@@ -150,7 +150,7 @@ void BLEClientBase::disconnect() {
 void BLEClientBase::unconditional_disconnect() {
  // Disconnect without checking the state.
  ESP_LOGI(TAG, "[%d] [%s] Disconnecting (conn_id: %d).", this->connection_index_, this->address_str_, this->conn_id_);
-  if (this->state() == espbt::ClientState::DISCONNECTING) {
+  if (this->state_ == espbt::ClientState::DISCONNECTING) {
    this->log_error_("Already disconnecting");
    return;
  }
@@ -170,7 +170,7 @@ void BLEClientBase::unconditional_disconnect() {
    this->log_gattc_warning_("esp_ble_gattc_close", err);
  }

-  if (this->state() == espbt::ClientState::DISCOVERED) {
+  if (this->state_ == espbt::ClientState::DISCOVERED) {
    this->set_address(0);
    this->set_state(espbt::ClientState::IDLE);
  } else {
@@ -295,18 +295,18 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
      // ESP-IDF's BLE stack may send ESP_GATTC_OPEN_EVT after esp_ble_gattc_open() returns an
      // error, if the error occurred at the BTA/GATT layer. This can result in the event
      // arriving after we've already transitioned to IDLE state.
-      if (this->state() == espbt::ClientState::IDLE) {
+      if (this->state_ == espbt::ClientState::IDLE) {
        ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_OPEN_EVT in IDLE state (status=%d), ignoring", this->connection_index_,
                 this->address_str_, param->open.status);
        break;
      }

-      if (this->state() != espbt::ClientState::CONNECTING) {
+      if (this->state_ != espbt::ClientState::CONNECTING) {
        // This should not happen but lets log it in case it does
        // because it means we have a bad assumption about how the
        // ESP BT stack works.
        ESP_LOGE(TAG, "[%d] [%s] ESP_GATTC_OPEN_EVT in %s state (status=%d)", this->connection_index_,
-                 this->address_str_, espbt::client_state_to_string(this->state()), param->open.status);
+                 this->address_str_, espbt::client_state_to_string(this->state_), param->open.status);
      }
      if (param->open.status != ESP_GATT_OK && param->open.status != ESP_GATT_ALREADY_OPEN) {
        this->log_gattc_warning_("Connection open", param->open.status);
@@ -327,7 +327,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
      if (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE) {
        // Cached connections already connected with medium parameters, no update needed
        // only set our state, subclients might have more stuff to do yet.
-        this->set_state_internal_(espbt::ClientState::ESTABLISHED);
+        this->state_ = espbt::ClientState::ESTABLISHED;
        break;
      }
      // For V3_WITHOUT_CACHE, we already set fast params before connecting
@@ -356,7 +356,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
        return false;
      // Check if we were disconnected while waiting for service discovery
      if (param->disconnect.reason == ESP_GATT_CONN_TERMINATE_PEER_USER &&
-          this->state() == espbt::ClientState::CONNECTED) {
+          this->state_ == espbt::ClientState::CONNECTED) {
        this->log_warning_("Remote closed during discovery");
      } else {
        ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_DISCONNECT_EVT, reason 0x%02x", this->connection_index_, this->address_str_,
@@ -433,7 +433,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
 #endif
      }
      ESP_LOGI(TAG, "[%d] [%s] Service discovery complete", this->connection_index_, this->address_str_);
-      this->set_state_internal_(espbt::ClientState::ESTABLISHED);
+      this->state_ = espbt::ClientState::ESTABLISHED;
      break;
    }
    case ESP_GATTC_READ_DESCR_EVT: {
--- a/esphome/components/esp32_ble_client/ble_client_base.h
+++ b/esphome/components/esp32_ble_client/ble_client_base.h
@@ -44,7 +44,7 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
  void unconditional_disconnect();
  void release_services();

-  bool connected() { return this->state() == espbt::ClientState::ESTABLISHED; }
+  bool connected() { return this->state_ == espbt::ClientState::ESTABLISHED; }

  void set_auto_connect(bool auto_connect) { this->auto_connect_ = auto_connect; }

--- a/esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp
+++ b/esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp
@@ -105,13 +105,15 @@ void ESP32BLETracker::loop() {
  }

  // Check for scan timeout - moved here from scheduler to avoid false reboots
-  // when the loop is blocked. This must run every iteration for safety.
+  // when the loop is blocked
  if (this->scanner_state_ == ScannerState::RUNNING) {
    switch (this->scan_timeout_state_) {
      case ScanTimeoutState::MONITORING: {
+        uint32_t now = App.get_loop_component_start_time();
+        uint32_t timeout_ms = this->scan_duration_ * 2000;
        // Robust time comparison that handles rollover correctly
        // This works because unsigned arithmetic wraps around predictably
-        if ((App.get_loop_component_start_time() - this->scan_start_time_) > this->scan_timeout_ms_) {
+        if ((now - this->scan_start_time_) > timeout_ms) {
          // First time we've seen the timeout exceeded - wait one more loop iteration
          // This ensures all components have had a chance to process pending events
          // This is because esp32_ble may not have run yet and called
@@ -126,31 +128,13 @@ void ESP32BLETracker::loop() {
        ESP_LOGE(TAG, "Scan never terminated, rebooting");
        App.reboot();
        break;
+
      case ScanTimeoutState::INACTIVE:
+        // This case should be unreachable - scanner and timeout states are always synchronized
        break;
    }
  }

-  // Fast path: skip expensive client state counting and processing
-  // if no state has changed since last loop iteration.
-  //
-  // How state changes ensure we reach the code below:
-  // - handle_scanner_failure_(): scanner_state_ becomes FAILED via set_scanner_state_(), or
-  //   scan_set_param_failed_ requires scanner_state_==RUNNING which can only be reached via
-  //   set_scanner_state_(RUNNING) in gap_scan_start_complete_() (scan params are set during
-  //   STARTING, not RUNNING, so version is always incremented before this condition is true)
-  // - start_scan_(): scanner_state_ becomes IDLE via set_scanner_state_() in cleanup_scan_state_()
-  // - try_promote_discovered_clients_(): client enters DISCOVERED via set_state(), or
-  //   connecting client finishes (state change), or scanner reaches RUNNING/IDLE
-  //
-  // All conditions that affect the logic below are tied to state changes that increment
-  // state_version_, so the fast path is safe.
-  if (this->state_version_ == this->last_processed_version_) {
-    return;
-  }
-  this->last_processed_version_ = this->state_version_;
-
-  // State changed - do full processing
  ClientStateCounts counts = this->count_client_states_();
  if (counts != this->client_state_counts_) {
    this->client_state_counts_ = counts;
@@ -158,7 +142,6 @@ void ESP32BLETracker::loop() {
             this->client_state_counts_.discovered, this->client_state_counts_.disconnecting);
  }

-  // Scanner failure: reached when set_scanner_state_(FAILED) or scan_set_param_failed_ set
  if (this->scanner_state_ == ScannerState::FAILED ||
      (this->scan_set_param_failed_ && this->scanner_state_ == ScannerState::RUNNING)) {
    this->handle_scanner_failure_();
@@ -177,8 +160,6 @@ void ESP32BLETracker::loop() {

  */

-  // Start scan: reached when scanner_state_ becomes IDLE (via set_scanner_state_()) and
-  // all clients are idle (their state changes increment version when they finish)
  if (this->scanner_state_ == ScannerState::IDLE && !counts.connecting && !counts.disconnecting && !counts.discovered) {
 #ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
    this->update_coex_preference_(false);
@@ -187,9 +168,8 @@ void ESP32BLETracker::loop() {
      this->start_scan_(false);  // first = false
    }
  }
-  // Promote discovered clients: reached when a client's state becomes DISCOVERED (via set_state()),
-  // or when a blocking condition clears (connecting client finishes, scanner reaches RUNNING/IDLE).
-  // All these trigger state_version_ increment, so we'll process and check promotion eligibility.
+  // If there is a discovered client and no connecting
+  // clients, 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)
@@ -256,7 +236,6 @@ void ESP32BLETracker::start_scan_(bool first) {
  // Start timeout monitoring in loop() instead of using scheduler
  // This prevents false reboots when the loop is blocked
  this->scan_start_time_ = App.get_loop_component_start_time();
-  this->scan_timeout_ms_ = this->scan_duration_ * 2000;
  this->scan_timeout_state_ = ScanTimeoutState::MONITORING;

  esp_err_t err = esp_ble_gap_set_scan_params(&this->scan_params_);
@@ -274,10 +253,6 @@ void ESP32BLETracker::start_scan_(bool first) {
 void ESP32BLETracker::register_client(ESPBTClient *client) {
 #ifdef ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT
  client->app_id = ++this->app_id_;
-  // Give client a pointer to our state_version_ so it can notify us of state changes.
-  // This enables loop() fast-path optimization - we skip expensive work when no state changed.
-  // Safe because ESP32BLETracker (singleton) outlives all registered clients.
-  client->set_tracker_state_version(&this->state_version_);
  this->clients_.push_back(client);
  this->recalculate_advertisement_parser_types();
 #endif
@@ -407,7 +382,6 @@ void ESP32BLETracker::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_i

 void ESP32BLETracker::set_scanner_state_(ScannerState state) {
  this->scanner_state_ = state;
-  this->state_version_++;
  for (auto *listener : this->scanner_state_listeners_) {
    listener->on_scanner_state(state);
  }
--- a/esphome/components/esp32_ble_tracker/esp32_ble_tracker.h
+++ b/esphome/components/esp32_ble_tracker/esp32_ble_tracker.h
@@ -216,19 +216,6 @@ enum class ConnectionType : uint8_t {
  V3_WITHOUT_CACHE
 };

-/// Base class for BLE GATT clients that connect to remote devices.
-///
-/// State Change Tracking Design:
-/// -----------------------------
-/// ESP32BLETracker::loop() needs to know when client states change to avoid
-/// expensive polling. Rather than checking all clients every iteration (~7000/min),
-/// we use a version counter owned by ESP32BLETracker that clients increment on
-/// state changes. The tracker compares versions to skip work when nothing changed.
-///
-/// Ownership: ESP32BLETracker owns state_version_. Clients hold a non-owning
-/// pointer (tracker_state_version_) set during register_client(). Clients
-/// increment the counter through this pointer when their state changes.
-/// The pointer may be null if the client is not registered with a tracker.
 class ESPBTClient : public ESPBTDeviceListener {
 public:
  virtual bool gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
@@ -238,49 +225,26 @@ class ESPBTClient : public ESPBTDeviceListener {
  virtual void disconnect() = 0;
  bool disconnect_pending() const { return this->want_disconnect_; }
  void cancel_pending_disconnect() { this->want_disconnect_ = false; }
-
-  /// Set the client state with IDLE handling (clears want_disconnect_).
-  /// Notifies the tracker of state change for loop optimization.
  virtual void set_state(ClientState st) {
-    this->set_state_internal_(st);
+    this->state_ = st;
    if (st == ClientState::IDLE) {
      this->want_disconnect_ = false;
    }
  }
-  ClientState state() const { return this->state_; }
-
-  /// Called by ESP32BLETracker::register_client() to enable state change notifications.
-  /// The pointer must remain valid for the lifetime of the client (guaranteed since
-  /// ESP32BLETracker is a singleton that outlives all clients).
-  void set_tracker_state_version(uint8_t *version) { this->tracker_state_version_ = version; }
+  ClientState state() const { return state_; }

  // Memory optimized layout
  uint8_t app_id;  // App IDs are small integers assigned sequentially

 protected:
-  /// Set state without IDLE handling - use for direct state transitions.
-  /// Increments the tracker's state version counter to signal that loop()
-  /// should do full processing on the next iteration.
-  void set_state_internal_(ClientState st) {
-    this->state_ = st;
-    // Notify tracker that state changed (tracker_state_version_ is owned by ESP32BLETracker)
-    if (this->tracker_state_version_ != nullptr) {
-      (*this->tracker_state_version_)++;
-    }
-  }
-
+  // Group 1: 1-byte types
+  ClientState state_{ClientState::INIT};
  // want_disconnect_ is set to true when a disconnect is requested
  // while the client is connecting. This is used to disconnect the
  // client as soon as we get the connection id (conn_id_) from the
  // ESP_GATTC_OPEN_EVT event.
  bool want_disconnect_{false};
-
- private:
-  ClientState state_{ClientState::INIT};
-  /// Non-owning pointer to ESP32BLETracker::state_version_. When this client's
-  /// state changes, we increment the tracker's counter to signal that loop()
-  /// should perform full processing. Null if client not registered with tracker.
-  uint8_t *tracker_state_version_{nullptr};
+  // 2 bytes used, 2 bytes padding
 };

 class ESP32BLETracker : public Component,
@@ -416,16 +380,6 @@ class ESP32BLETracker : public Component,
  // Group 4: 1-byte types (enums, uint8_t, bool)
  uint8_t app_id_{0};
  uint8_t scan_start_fail_count_{0};
-  /// Version counter for loop() fast-path optimization. Incremented when:
-  /// - Scanner state changes (via set_scanner_state_())
-  /// - Any registered client's state changes (clients hold pointer to this counter)
-  /// Owned by this class; clients receive non-owning pointer via register_client().
-  /// When loop() sees state_version_ == last_processed_version_, it skips expensive
-  /// client state counting and takes the fast path (just timeout check + return).
-  uint8_t state_version_{0};
-  /// Last state_version_ value when loop() did full processing. Compared against
-  /// state_version_ to detect if any state changed since last iteration.
-  uint8_t last_processed_version_{0};
  ScannerState scanner_state_{ScannerState::IDLE};
  bool scan_continuous_;
  bool scan_active_;
@@ -442,8 +396,6 @@ class ESP32BLETracker : public Component,
    EXCEEDED_WAIT,  // Timeout exceeded, waiting one loop before reboot
  };
  uint32_t scan_start_time_{0};
-  /// Precomputed timeout value: scan_duration_ * 2000
-  uint32_t scan_timeout_ms_{0};
  ScanTimeoutState scan_timeout_state_{ScanTimeoutState::INACTIVE};
 };

--- a/esphome/components/hmac_sha256/hmac_sha256.cpp
+++ b/esphome/components/hmac_sha256/hmac_sha256.cpp
@@ -1,3 +1,4 @@
+#include <cstdio>
 #include <cstring>
 #include "hmac_sha256.h"
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY) || defined(USE_HOST)
@@ -25,7 +26,9 @@ void HmacSHA256::calculate() { mbedtls_md_hmac_finish(&this->ctx_, this->digest_
 void HmacSHA256::get_bytes(uint8_t *output) { memcpy(output, this->digest_, SHA256_DIGEST_SIZE); }

 void HmacSHA256::get_hex(char *output) {
-  format_hex_to(output, SHA256_DIGEST_SIZE * 2 + 1, this->digest_, SHA256_DIGEST_SIZE);
+  for (size_t i = 0; i < SHA256_DIGEST_SIZE; i++) {
+    sprintf(output + (i * 2), "%02x", this->digest_[i]);
+  }
 }

 bool HmacSHA256::equals_bytes(const uint8_t *expected) {
--- a/esphome/components/http_request/http_request.h
+++ b/esphome/components/http_request/http_request.h
@@ -242,7 +242,9 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
      return;
    }

-    size_t max_length = this->max_response_buffer_size_;
+    size_t content_length = container->content_length;
+    size_t max_length = std::min(content_length, this->max_response_buffer_size_);
+
 #ifdef USE_HTTP_REQUEST_RESPONSE
    if (this->capture_response_.value(x...)) {
      std::string response_body;
--- a/esphome/components/http_request/http_request_idf.cpp
+++ b/esphome/components/http_request/http_request_idf.cpp
@@ -213,12 +213,18 @@ int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {
  const uint32_t start = millis();
  watchdog::WatchdogManager wdm(this->parent_->get_watchdog_timeout());

-  this->feed_wdt();
-  int read_len = esp_http_client_read(this->client_, (char *) buf, max_len);
-  this->feed_wdt();
-  if (read_len > 0) {
-    this->bytes_read_ += read_len;
+  int bufsize = std::min(max_len, this->content_length - this->bytes_read_);
+
+  if (bufsize == 0) {
+    this->duration_ms += (millis() - start);
+    return 0;
  }
+
+  this->feed_wdt();
+  int read_len = esp_http_client_read(this->client_, (char *) buf, bufsize);
+  this->feed_wdt();
+  this->bytes_read_ += read_len;
+
  this->duration_ms += (millis() - start);

  return read_len;
--- a/esphome/components/hub75/display.py
+++ b/esphome/components/hub75/display.py
@@ -1,4 +1,3 @@
-import logging
 from typing import Any

 from esphome import automation, pins
@@ -19,16 +18,13 @@ from esphome.const import (
    CONF_ROTATION,
    CONF_UPDATE_INTERVAL,
 )
-from esphome.core import ID, EnumValue
+from esphome.core import ID
 from esphome.cpp_generator import MockObj, TemplateArgsType
 import esphome.final_validate as fv
-from esphome.helpers import add_class_to_obj
 from esphome.types import ConfigType

 from . import boards, hub75_ns

-_LOGGER = logging.getLogger(__name__)
-
 DEPENDENCIES = ["esp32"]
 CODEOWNERS = ["@stuartparmenter"]

@@ -124,51 +120,13 @@ PANEL_LAYOUTS = {
 }

 Hub75ScanWiring = cg.global_ns.enum("Hub75ScanWiring", is_class=True)
-SCAN_WIRINGS = {
+SCAN_PATTERNS = {
    "STANDARD_TWO_SCAN": Hub75ScanWiring.STANDARD_TWO_SCAN,
-    "SCAN_1_4_16PX_HIGH": Hub75ScanWiring.SCAN_1_4_16PX_HIGH,
-    "SCAN_1_8_32PX_HIGH": Hub75ScanWiring.SCAN_1_8_32PX_HIGH,
-    "SCAN_1_8_40PX_HIGH": Hub75ScanWiring.SCAN_1_8_40PX_HIGH,
-    "SCAN_1_8_64PX_HIGH": Hub75ScanWiring.SCAN_1_8_64PX_HIGH,
+    "FOUR_SCAN_16PX_HIGH": Hub75ScanWiring.FOUR_SCAN_16PX_HIGH,
+    "FOUR_SCAN_32PX_HIGH": Hub75ScanWiring.FOUR_SCAN_32PX_HIGH,
+    "FOUR_SCAN_64PX_HIGH": Hub75ScanWiring.FOUR_SCAN_64PX_HIGH,
 }

-# Deprecated scan wiring names - mapped to new names
-DEPRECATED_SCAN_WIRINGS = {
-    "FOUR_SCAN_16PX_HIGH": "SCAN_1_4_16PX_HIGH",
-    "FOUR_SCAN_32PX_HIGH": "SCAN_1_8_32PX_HIGH",
-    "FOUR_SCAN_64PX_HIGH": "SCAN_1_8_64PX_HIGH",
-}
-
-
-def _validate_scan_wiring(value):
-    """Validate scan_wiring with deprecation warnings for old names."""
-    value = cv.string(value).upper().replace(" ", "_")
-
-    # Check if using deprecated name
-    # Remove deprecated names in 2026.7.0
-    if value in DEPRECATED_SCAN_WIRINGS:
-        new_name = DEPRECATED_SCAN_WIRINGS[value]
-        _LOGGER.warning(
-            "Scan wiring '%s' is deprecated and will be removed in ESPHome 2026.7.0. "
-            "Please use '%s' instead.",
-            value,
-            new_name,
-        )
-        value = new_name
-
-    # Validate against allowed values
-    if value not in SCAN_WIRINGS:
-        raise cv.Invalid(
-            f"Unknown scan wiring '{value}'. "
-            f"Valid options are: {', '.join(sorted(SCAN_WIRINGS.keys()))}"
-        )
-
-    # Return as EnumValue like cv.enum does
-    result = add_class_to_obj(value, EnumValue)
-    result.enum_value = SCAN_WIRINGS[value]
-    return result
-
-
 Hub75ClockSpeed = cg.global_ns.enum("Hub75ClockSpeed", is_class=True)
 CLOCK_SPEEDS = {
    "8MHZ": Hub75ClockSpeed.HZ_8M,
@@ -424,7 +382,9 @@ CONFIG_SCHEMA = cv.All(
            cv.Optional(CONF_LAYOUT_COLS): cv.positive_int,
            cv.Optional(CONF_LAYOUT): cv.enum(PANEL_LAYOUTS, upper=True, space="_"),
            # Panel hardware configuration
-            cv.Optional(CONF_SCAN_WIRING): _validate_scan_wiring,
+            cv.Optional(CONF_SCAN_WIRING): cv.enum(
+                SCAN_PATTERNS, upper=True, space="_"
+            ),
            cv.Optional(CONF_SHIFT_DRIVER): cv.enum(SHIFT_DRIVERS, upper=True),
            # Display configuration
            cv.Optional(CONF_DOUBLE_BUFFER): cv.boolean,
@@ -587,7 +547,7 @@ def _build_config_struct(
 async def to_code(config: ConfigType) -> None:
    add_idf_component(
        name="esphome/esp-hub75",
-        ref="0.3.0",
+        ref="0.2.2",
    )

    # Set compile-time configuration via build flags (so external library sees them)
--- a/esphome/components/infrared/infrared.cpp
+++ b/esphome/components/infrared/infrared.cpp
@@ -19,12 +19,12 @@ InfraredCall &InfraredCall::set_carrier_frequency(uint32_t frequency) {
 InfraredCall &InfraredCall::set_raw_timings(const std::vector<int32_t> &timings) {
  this->raw_timings_ = &timings;
  this->packed_data_ = nullptr;
-  this->base64url_ptr_ = nullptr;
+  this->base85_ptr_ = nullptr;
  return *this;
 }

-InfraredCall &InfraredCall::set_raw_timings_base64url(const std::string &base64url) {
-  this->base64url_ptr_ = &base64url;
+InfraredCall &InfraredCall::set_raw_timings_base85(const std::string &base85) {
+  this->base85_ptr_ = &base85;
  this->raw_timings_ = nullptr;
  this->packed_data_ = nullptr;
  return *this;
@@ -35,7 +35,7 @@ InfraredCall &InfraredCall::set_raw_timings_packed(const uint8_t *data, uint16_t
  this->packed_length_ = length;
  this->packed_count_ = count;
  this->raw_timings_ = nullptr;
-  this->base64url_ptr_ = nullptr;
+  this->base85_ptr_ = nullptr;
  return *this;
 }

@@ -101,22 +101,13 @@ void Infrared::control(const InfraredCall &call) {
                                               call.get_packed_count());
    ESP_LOGD(TAG, "Transmitting packed raw timings: count=%u, repeat=%u", call.get_packed_count(),
             call.get_repeat_count());
-  } else if (call.is_base64url()) {
-    // Decode base64url (URL-safe) into transmit buffer
-    if (!transmit_data->set_data_from_base64url(call.get_base64url_data())) {
-      ESP_LOGE(TAG, "Invalid base64url data");
+  } else if (call.is_base85()) {
+    // Decode base85 directly into transmit buffer (zero heap allocations)
+    if (!transmit_data->set_data_from_base85(call.get_base85_data())) {
+      ESP_LOGE(TAG, "Invalid base85 data");
      return;
    }
-    // Sanity check: validate timing values are within reasonable bounds
-    constexpr int32_t max_timing_us = 500000;  // 500ms absolute max
-    for (int32_t timing : transmit_data->get_data()) {
-      int32_t abs_timing = timing < 0 ? -timing : timing;
-      if (abs_timing > max_timing_us) {
-        ESP_LOGE(TAG, "Invalid timing value: %d µs (max %d)", timing, max_timing_us);
-        return;
-      }
-    }
-    ESP_LOGD(TAG, "Transmitting base64url raw timings: count=%zu, repeat=%u", transmit_data->get_data().size(),
+    ESP_LOGD(TAG, "Transmitting base85 raw timings: count=%zu, repeat=%u", transmit_data->get_data().size(),
             call.get_repeat_count());
  } else {
    // From vector (lambdas/automations)
--- a/esphome/components/infrared/infrared.h
+++ b/esphome/components/infrared/infrared.h
@@ -40,11 +40,11 @@ class InfraredCall {
  /// @note Usage: Primarily for lambdas/automations where the vector is in scope.
  InfraredCall &set_raw_timings(const std::vector<int32_t> &timings);

-  /// Set the raw timings from base64url-encoded little-endian int32 data
+  /// Set the raw timings from base85-encoded int32 data
  /// @note Lifetime: Stores a pointer to the string. The string must outlive perform().
-  /// @note Usage: For web_server - base64url is fully URL-safe (uses '-' and '_').
+  /// @note Usage: For web_server where the encoded string is on the stack.
  /// @note Decoding happens at perform() time, directly into the transmit buffer.
-  InfraredCall &set_raw_timings_base64url(const std::string &base64url);
+  InfraredCall &set_raw_timings_base85(const std::string &base85);

  /// Set the raw timings from packed protobuf sint32 data (zigzag + varint encoded)
  /// @note Lifetime: Stores a pointer to the buffer. The buffer must outlive perform().
@@ -59,18 +59,18 @@ class InfraredCall {

  /// Get the carrier frequency
  const optional<uint32_t> &get_carrier_frequency() const { return this->carrier_frequency_; }
-  /// Get the raw timings (only valid if set via set_raw_timings)
+  /// Get the raw timings (only valid if set via set_raw_timings, not packed or base85)
  const std::vector<int32_t> &get_raw_timings() const { return *this->raw_timings_; }
-  /// Check if raw timings have been set (any format)
+  /// Check if raw timings have been set (vector, packed, or base85)
  bool has_raw_timings() const {
-    return this->raw_timings_ != nullptr || this->packed_data_ != nullptr || this->base64url_ptr_ != nullptr;
+    return this->raw_timings_ != nullptr || this->packed_data_ != nullptr || this->base85_ptr_ != nullptr;
  }
  /// Check if using packed data format
  bool is_packed() const { return this->packed_data_ != nullptr; }
-  /// Check if using base64url data format
-  bool is_base64url() const { return this->base64url_ptr_ != nullptr; }
-  /// Get the base64url data string
-  const std::string &get_base64url_data() const { return *this->base64url_ptr_; }
+  /// Check if using base85 data format
+  bool is_base85() const { return this->base85_ptr_ != nullptr; }
+  /// Get the base85 data string
+  const std::string &get_base85_data() const { return *this->base85_ptr_; }
  /// Get packed data (only valid if set via set_raw_timings_packed)
  const uint8_t *get_packed_data() const { return this->packed_data_; }
  uint16_t get_packed_length() const { return this->packed_length_; }
@@ -84,8 +84,8 @@ class InfraredCall {
  optional<uint32_t> carrier_frequency_;
  // Pointer to vector-based timings (caller-owned, must outlive perform())
  const std::vector<int32_t> *raw_timings_{nullptr};
-  // Pointer to base64url-encoded string (caller-owned, must outlive perform())
-  const std::string *base64url_ptr_{nullptr};
+  // Pointer to base85-encoded string (caller-owned, must outlive perform())
+  const std::string *base85_ptr_{nullptr};
  // Pointer to packed protobuf buffer (caller-owned, must outlive perform())
  const uint8_t *packed_data_{nullptr};
  uint16_t packed_length_{0};
--- a/esphome/components/light/light_json_schema.cpp
+++ b/esphome/components/light/light_json_schema.cpp
@@ -1,5 +1,4 @@
 #include "light_json_schema.h"
-#include "color_mode.h"
 #include "light_output.h"
 #include "esphome/core/progmem.h"

@@ -9,32 +8,29 @@ namespace esphome::light {

 // See https://www.home-assistant.io/integrations/light.mqtt/#json-schema for documentation on the schema

-// Get JSON string for color mode.
-// ColorMode enum values are sparse bitmasks (0, 1, 3, 7, 11, 19, 35, 39, 47, 51) which would
-// generate a large jump table. Converting to bit index (0-9) allows a compact switch.
-static ProgmemStr get_color_mode_json_str(ColorMode mode) {
-  switch (ColorModeBitPolicy::to_bit(mode)) {
-    case 1:
-      return ESPHOME_F("onoff");
-    case 2:
-      return ESPHOME_F("brightness");
-    case 3:
-      return ESPHOME_F("white");
-    case 4:
-      return ESPHOME_F("color_temp");
-    case 5:
-      return ESPHOME_F("cwww");
-    case 6:
-      return ESPHOME_F("rgb");
-    case 7:
-      return ESPHOME_F("rgbw");
-    case 8:
-      return ESPHOME_F("rgbct");
-    case 9:
-      return ESPHOME_F("rgbww");
-    default:
-      return nullptr;
+// Get JSON string for color mode using linear search (avoids large switch jump table)
+static const char *get_color_mode_json_str(ColorMode mode) {
+  // Parallel arrays: mode values and their corresponding strings
+  // Uses less RAM than a switch jump table on sparse enum values
+  static constexpr ColorMode MODES[] = {
+      ColorMode::ON_OFF,
+      ColorMode::BRIGHTNESS,
+      ColorMode::WHITE,
+      ColorMode::COLOR_TEMPERATURE,
+      ColorMode::COLD_WARM_WHITE,
+      ColorMode::RGB,
+      ColorMode::RGB_WHITE,
+      ColorMode::RGB_COLOR_TEMPERATURE,
+      ColorMode::RGB_COLD_WARM_WHITE,
+  };
+  static constexpr const char *STRINGS[] = {
+      "onoff", "brightness", "white", "color_temp", "cwww", "rgb", "rgbw", "rgbct", "rgbww",
+  };
+  for (size_t i = 0; i < sizeof(MODES) / sizeof(MODES[0]); i++) {
+    if (MODES[i] == mode)
+      return STRINGS[i];
  }
+  return nullptr;
 }

 void LightJSONSchema::dump_json(LightState &state, JsonObject root) {
@@ -48,7 +44,7 @@ void LightJSONSchema::dump_json(LightState &state, JsonObject root) {
  auto values = state.remote_values;

  const auto color_mode = values.get_color_mode();
-  const auto *mode_str = get_color_mode_json_str(color_mode);
+  const char *mode_str = get_color_mode_json_str(color_mode);
  if (mode_str != nullptr) {
    root[ESPHOME_F("color_mode")] = mode_str;
  }
--- a/esphome/components/mipi_dsi/models/guition.py
+++ b/esphome/components/mipi_dsi/models/guition.py
@@ -101,225 +101,4 @@ DriverChip(
        (0xFF, 0x77, 0x01, 0x00, 0x00, 0x00),
    ]
 )
-
-# jc8012P4A1 Driver Configuration (jd9365)
-# Using parameters from esp_lcd_jd9365.h and the working full init sequence
-# ----------------------------------------------------------------------------------------------------------------------
-# * Resolution: 800x1280
-# * PCLK Frequency: 60 MHz
-# * DSI Lane Bit Rate: 1 Gbps (using 2-Lane DSI configuration)
-# * Horizontal Timing (hsync_pulse_width=20, hsync_back_porch=20, hsync_front_porch=40)
-# * Vertical Timing (vsync_pulse_width=4, vsync_back_porch=8, vsync_front_porch=20)
-# ----------------------------------------------------------------------------------------------------------------------
-DriverChip(
-    "JC8012P4A1",
-    width=800,
-    height=1280,
-    hsync_back_porch=20,
-    hsync_pulse_width=20,
-    hsync_front_porch=40,
-    vsync_back_porch=8,
-    vsync_pulse_width=4,
-    vsync_front_porch=20,
-    pclk_frequency="60MHz",
-    lane_bit_rate="1Gbps",
-    swap_xy=cv.UNDEFINED,
-    color_order="RGB",
-    reset_pin=27,
-    initsequence=[
-        (0xE0, 0x00),
-        (0xE1, 0x93),
-        (0xE2, 0x65),
-        (0xE3, 0xF8),
-        (0x80, 0x01),
-        (0xE0, 0x01),
-        (0x00, 0x00),
-        (0x01, 0x39),
-        (0x03, 0x10),
-        (0x04, 0x41),
-        (0x0C, 0x74),
-        (0x17, 0x00),
-        (0x18, 0xD7),
-        (0x19, 0x00),
-        (0x1A, 0x00),
-        (0x1B, 0xD7),
-        (0x1C, 0x00),
-        (0x24, 0xFE),
-        (0x35, 0x26),
-        (0x37, 0x69),
-        (0x38, 0x05),
-        (0x39, 0x06),
-        (0x3A, 0x08),
-        (0x3C, 0x78),
-        (0x3D, 0xFF),
-        (0x3E, 0xFF),
-        (0x3F, 0xFF),
-        (0x40, 0x06),
-        (0x41, 0xA0),
-        (0x43, 0x14),
-        (0x44, 0x0B),
-        (0x45, 0x30),
-        (0x4B, 0x04),
-        (0x55, 0x02),
-        (0x57, 0x89),
-        (0x59, 0x0A),
-        (0x5A, 0x28),
-        (0x5B, 0x15),
-        (0x5D, 0x50),
-        (0x5E, 0x37),
-        (0x5F, 0x29),
-        (0x60, 0x1E),
-        (0x61, 0x1D),
-        (0x62, 0x12),
-        (0x63, 0x1A),
-        (0x64, 0x08),
-        (0x65, 0x25),
-        (0x66, 0x26),
-        (0x67, 0x28),
-        (0x68, 0x49),
-        (0x69, 0x3A),
-        (0x6A, 0x43),
-        (0x6B, 0x3A),
-        (0x6C, 0x3B),
-        (0x6D, 0x32),
-        (0x6E, 0x1F),
-        (0x6F, 0x0E),
-        (0x70, 0x50),
-        (0x71, 0x37),
-        (0x72, 0x29),
-        (0x73, 0x1E),
-        (0x74, 0x1D),
-        (0x75, 0x12),
-        (0x76, 0x1A),
-        (0x77, 0x08),
-        (0x78, 0x25),
-        (0x79, 0x26),
-        (0x7A, 0x28),
-        (0x7B, 0x49),
-        (0x7C, 0x3A),
-        (0x7D, 0x43),
-        (0x7E, 0x3A),
-        (0x7F, 0x3B),
-        (0x80, 0x32),
-        (0x81, 0x1F),
-        (0x82, 0x0E),
-        (0xE0, 0x02),
-        (0x00, 0x1F),
-        (0x01, 0x1F),
-        (0x02, 0x52),
-        (0x03, 0x51),
-        (0x04, 0x50),
-        (0x05, 0x4B),
-        (0x06, 0x4A),
-        (0x07, 0x49),
-        (0x08, 0x48),
-        (0x09, 0x47),
-        (0x0A, 0x46),
-        (0x0B, 0x45),
-        (0x0C, 0x44),
-        (0x0D, 0x40),
-        (0x0E, 0x41),
-        (0x0F, 0x1F),
-        (0x10, 0x1F),
-        (0x11, 0x1F),
-        (0x12, 0x1F),
-        (0x13, 0x1F),
-        (0x14, 0x1F),
-        (0x15, 0x1F),
-        (0x16, 0x1F),
-        (0x17, 0x1F),
-        (0x18, 0x52),
-        (0x19, 0x51),
-        (0x1A, 0x50),
-        (0x1B, 0x4B),
-        (0x1C, 0x4A),
-        (0x1D, 0x49),
-        (0x1E, 0x48),
-        (0x1F, 0x47),
-        (0x20, 0x46),
-        (0x21, 0x45),
-        (0x22, 0x44),
-        (0x23, 0x40),
-        (0x24, 0x41),
-        (0x25, 0x1F),
-        (0x26, 0x1F),
-        (0x27, 0x1F),
-        (0x28, 0x1F),
-        (0x29, 0x1F),
-        (0x2A, 0x1F),
-        (0x2B, 0x1F),
-        (0x2C, 0x1F),
-        (0x2D, 0x1F),
-        (0x2E, 0x52),
-        (0x2F, 0x40),
-        (0x30, 0x41),
-        (0x31, 0x48),
-        (0x32, 0x49),
-        (0x33, 0x4A),
-        (0x34, 0x4B),
-        (0x35, 0x44),
-        (0x36, 0x45),
-        (0x37, 0x46),
-        (0x38, 0x47),
-        (0x39, 0x51),
-        (0x3A, 0x50),
-        (0x3B, 0x1F),
-        (0x3C, 0x1F),
-        (0x3D, 0x1F),
-        (0x3E, 0x1F),
-        (0x3F, 0x1F),
-        (0x40, 0x1F),
-        (0x41, 0x1F),
-        (0x42, 0x1F),
-        (0x43, 0x1F),
-        (0x44, 0x52),
-        (0x45, 0x40),
-        (0x46, 0x41),
-        (0x47, 0x48),
-        (0x48, 0x49),
-        (0x49, 0x4A),
-        (0x4A, 0x4B),
-        (0x4B, 0x44),
-        (0x4C, 0x45),
-        (0x4D, 0x46),
-        (0x4E, 0x47),
-        (0x4F, 0x51),
-        (0x50, 0x50),
-        (0x51, 0x1F),
-        (0x52, 0x1F),
-        (0x53, 0x1F),
-        (0x54, 0x1F),
-        (0x55, 0x1F),
-        (0x56, 0x1F),
-        (0x57, 0x1F),
-        (0x58, 0x40),
-        (0x59, 0x00),
-        (0x5A, 0x00),
-        (0x5B, 0x10),
-        (0x5C, 0x05),
-        (0x5D, 0x50),
-        (0x5E, 0x01),
-        (0x5F, 0x02),
-        (0x60, 0x50),
-        (0x61, 0x06),
-        (0x62, 0x04),
-        (0x63, 0x03),
-        (0x64, 0x64),
-        (0x65, 0x65),
-        (0x66, 0x0B),
-        (0x67, 0x73),
-        (0x68, 0x07),
-        (0x69, 0x06),
-        (0x6A, 0x64),
-        (0x6B, 0x08),
-        (0x6C, 0x00),
-        (0x6D, 0x32),
-        (0x6E, 0x08),
-        (0xE0, 0x04),
-        (0x2C, 0x6B),
-        (0x35, 0x08),
-        (0x37, 0x00),
-        (0xE0, 0x00),
-    ]
-)
 # fmt: on
--- a/esphome/components/mqtt/mqtt_component.cpp
+++ b/esphome/components/mqtt/mqtt_component.cpp
@@ -189,7 +189,8 @@ bool MQTTComponent::send_discovery_() {
        StringRef object_id = this->get_default_object_id_to_(object_id_buf);
        if (discovery_info.unique_id_generator == MQTT_MAC_ADDRESS_UNIQUE_ID_GENERATOR) {
          char friendly_name_hash[9];
-          snprintf(friendly_name_hash, sizeof(friendly_name_hash), "%08" PRIx32, fnv1_hash(this->friendly_name_()));
+          sprintf(friendly_name_hash, "%08" PRIx32, fnv1_hash(this->friendly_name_()));
+          friendly_name_hash[8] = 0;  // ensure the hash-string ends with null
          // Format: mac-component_type-hash (e.g. "aabbccddeeff-sensor-12345678")
          // MAC (12) + "-" (1) + domain (max 20) + "-" (1) + hash (8) + null (1) = 43
          char unique_id[MAC_ADDRESS_BUFFER_SIZE + ESPHOME_DOMAIN_MAX_LEN + 11];
--- a/esphome/components/ntc/ntc.cpp
+++ b/esphome/components/ntc/ntc.cpp
@@ -23,7 +23,7 @@ void NTC::process_(float value) {
  double v = this->a_ + this->b_ * lr + this->c_ * lr * lr * lr;
  auto temp = float(1.0 / v - 273.15);

-  ESP_LOGV(TAG, "'%s' - Temperature: %.1f°C", this->name_.c_str(), temp);
+  ESP_LOGD(TAG, "'%s' - Temperature: %.1f°C", this->name_.c_str(), temp);
  this->publish_state(temp);
 }

--- a/esphome/components/opentherm/opentherm.cpp
+++ b/esphome/components/opentherm/opentherm.cpp
@@ -561,9 +561,8 @@ const char *OpenTherm::message_id_to_str(MessageId id) {
 }

 void OpenTherm::debug_data(OpenthermData &data) {
-  char type_buf[9], id_buf[9], hb_buf[9], lb_buf[9];
-  ESP_LOGD(TAG, "%s %s %s %s", format_bin_to(type_buf, data.type), format_bin_to(id_buf, data.id),
-           format_bin_to(hb_buf, data.valueHB), format_bin_to(lb_buf, data.valueLB));
+  ESP_LOGD(TAG, "%s %s %s %s", format_bin(data.type).c_str(), format_bin(data.id).c_str(),
+           format_bin(data.valueHB).c_str(), format_bin(data.valueLB).c_str());
  ESP_LOGD(TAG, "type: %s; id: %u; HB: %u; LB: %u; uint_16: %u; float: %f",
           this->message_type_to_str((MessageType) data.type), data.id, data.valueHB, data.valueLB, data.u16(),
           data.f88());
--- a/esphome/components/remote_base/aeha_protocol.cpp
+++ b/esphome/components/remote_base/aeha_protocol.cpp
@@ -85,8 +85,8 @@ optional<AEHAData> AEHAProtocol::decode(RemoteReceiveData src) {
 std::string AEHAProtocol::format_data_(const std::vector<uint8_t> &data) {
  std::string out;
  for (uint8_t byte : data) {
-    char buf[8];  // "0x%02X," = 5 chars + null + margin
-    snprintf(buf, sizeof(buf), "0x%02X,", byte);
+    char buf[6];
+    sprintf(buf, "0x%02X,", byte);
    out += buf;
  }
  out.pop_back();
--- a/esphome/components/remote_base/raw_protocol.cpp
+++ b/esphome/components/remote_base/raw_protocol.cpp
@@ -1,5 +1,4 @@
 #include "raw_protocol.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"

 namespace esphome {
@@ -9,30 +8,36 @@ static const char *const TAG = "remote.raw";

 bool RawDumper::dump(RemoteReceiveData src) {
  char buffer[256];
-  size_t pos = buf_append_printf(buffer, sizeof(buffer), 0, "Received Raw: ");
+  uint32_t buffer_offset = 0;
+  buffer_offset += sprintf(buffer, "Received Raw: ");

  for (int32_t i = 0; i < src.size() - 1; i++) {
    const int32_t value = src[i];
-    size_t prev_pos = pos;
+    const uint32_t remaining_length = sizeof(buffer) - buffer_offset;
+    int written;

    if (i + 1 < src.size() - 1) {
-      pos = buf_append_printf(buffer, sizeof(buffer), pos, "%" PRId32 ", ", value);
+      written = snprintf(buffer + buffer_offset, remaining_length, "%" PRId32 ", ", value);
    } else {
-      pos = buf_append_printf(buffer, sizeof(buffer), pos, "%" PRId32, value);
+      written = snprintf(buffer + buffer_offset, remaining_length, "%" PRId32, value);
    }

-    if (pos >= sizeof(buffer) - 1) {
-      // buffer full, flush and continue
-      buffer[prev_pos] = '\0';
+    if (written < 0 || written >= int(remaining_length)) {
+      // write failed, flush...
+      buffer[buffer_offset] = '\0';
      ESP_LOGI(TAG, "%s", buffer);
+      buffer_offset = 0;
+      written = sprintf(buffer, "  ");
      if (i + 1 < src.size() - 1) {
-        pos = buf_append_printf(buffer, sizeof(buffer), 0, "  %" PRId32 ", ", value);
+        written += sprintf(buffer + written, "%" PRId32 ", ", value);
      } else {
-        pos = buf_append_printf(buffer, sizeof(buffer), 0, "  %" PRId32, value);
+        written += sprintf(buffer + written, "%" PRId32, value);
      }
    }
+
+    buffer_offset += written;
  }
-  if (pos != 0) {
+  if (buffer_offset != 0) {
    ESP_LOGI(TAG, "%s", buffer);
  }
  return true;
--- a/esphome/components/remote_base/remote_base.cpp
+++ b/esphome/components/remote_base/remote_base.cpp
@@ -1,7 +1,8 @@
 #include "remote_base.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"

+#include <cinttypes>
+
 namespace esphome {
 namespace remote_base {

@@ -158,8 +159,8 @@ void RemoteTransmitData::set_data_from_packed_sint32(const uint8_t *data, size_t
  }
 }

-bool RemoteTransmitData::set_data_from_base64url(const std::string &base64url) {
-  return base64_decode_int32_vector(base64url, this->data_);
+bool RemoteTransmitData::set_data_from_base85(const std::string &base85) {
+  return base85_decode_int32_vector(base85, this->data_);
 }

 /* RemoteTransmitterBase */
@@ -168,31 +169,36 @@ void RemoteTransmitterBase::send_(uint32_t send_times, uint32_t send_wait) {
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
  const auto &vec = this->temp_.get_data();
  char buffer[256];
-  size_t pos = buf_append_printf(buffer, sizeof(buffer), 0,
-                                 "Sending times=%" PRIu32 " wait=%" PRIu32 "ms: ", send_times, send_wait);
+  uint32_t buffer_offset = 0;
+  buffer_offset += sprintf(buffer, "Sending times=%" PRIu32 " wait=%" PRIu32 "ms: ", send_times, send_wait);

  for (size_t i = 0; i < vec.size(); i++) {
    const int32_t value = vec[i];
-    size_t prev_pos = pos;
+    const uint32_t remaining_length = sizeof(buffer) - buffer_offset;
+    int written;

    if (i + 1 < vec.size()) {
-      pos = buf_append_printf(buffer, sizeof(buffer), pos, "%" PRId32 ", ", value);
+      written = snprintf(buffer + buffer_offset, remaining_length, "%" PRId32 ", ", value);
    } else {
-      pos = buf_append_printf(buffer, sizeof(buffer), pos, "%" PRId32, value);
+      written = snprintf(buffer + buffer_offset, remaining_length, "%" PRId32, value);
    }

-    if (pos >= sizeof(buffer) - 1) {
-      // buffer full, flush and continue
-      buffer[prev_pos] = '\0';
+    if (written < 0 || written >= int(remaining_length)) {
+      // write failed, flush...
+      buffer[buffer_offset] = '\0';
      ESP_LOGVV(TAG, "%s", buffer);
+      buffer_offset = 0;
+      written = sprintf(buffer, "  ");
      if (i + 1 < vec.size()) {
-        pos = buf_append_printf(buffer, sizeof(buffer), 0, "  %" PRId32 ", ", value);
+        written += sprintf(buffer + written, "%" PRId32 ", ", value);
      } else {
-        pos = buf_append_printf(buffer, sizeof(buffer), 0, "  %" PRId32, value);
+        written += sprintf(buffer + written, "%" PRId32, value);
      }
    }
+
+    buffer_offset += written;
  }
-  if (pos != 0) {
+  if (buffer_offset != 0) {
    ESP_LOGVV(TAG, "%s", buffer);
  }
 #endif
--- a/esphome/components/remote_base/remote_base.h
+++ b/esphome/components/remote_base/remote_base.h
@@ -36,11 +36,11 @@ class RemoteTransmitData {
  /// @param len Length of the buffer in bytes
  /// @param count Number of values (for reserve optimization)
  void set_data_from_packed_sint32(const uint8_t *data, size_t len, size_t count);
-  /// Set data from base64url-encoded little-endian int32 values
-  /// Base64url is URL-safe: uses '-' instead of '+', '_' instead of '/'
-  /// @param base64url Base64url-encoded string of little-endian int32 values
+  /// Set data from base85-encoded int32 values
+  /// Decodes directly into internal buffer (zero heap allocations)
+  /// @param base85 Base85-encoded string (5 chars per int32 value)
  /// @return true if successful, false if decode failed or invalid size
-  bool set_data_from_base64url(const std::string &base64url);
+  bool set_data_from_base85(const std::string &base85);
  void reset() {
    this->data_.clear();
    this->carrier_frequency_ = 0;
--- a/esphome/components/resistance/resistance_sensor.cpp
+++ b/esphome/components/resistance/resistance_sensor.cpp
@@ -39,7 +39,7 @@ void ResistanceSensor::process_(float value) {
  }

  res *= this->resistor_;
-  ESP_LOGV(TAG, "'%s' - Resistance %.1fΩ", this->name_.c_str(), res);
+  ESP_LOGD(TAG, "'%s' - Resistance %.1fΩ", this->name_.c_str(), res);
  this->publish_state(res);
 }

--- a/esphome/components/select/init.py
+++ b/esphome/components/select/init.py
@@ -8,20 +8,17 @@ from esphome.const import (
    CONF_ICON,
    CONF_ID,
    CONF_INDEX,
-    CONF_LAMBDA,
    CONF_MODE,
    CONF_MQTT_ID,
    CONF_ON_VALUE,
    CONF_OPERATION,
    CONF_OPTION,
-    CONF_OPTIONS,
    CONF_TRIGGER_ID,
    CONF_WEB_SERVER,
 )
-from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
-from esphome.cpp_generator import MockObjClass, TemplateArguments
-from esphome.cpp_types import global_ns
+from esphome.cpp_generator import MockObjClass

 CODEOWNERS = ["@esphome/core"]
 IS_PLATFORM_COMPONENT = True
@@ -41,9 +38,6 @@ SelectSetAction = select_ns.class_("SelectSetAction", automation.Action)
 SelectSetIndexAction = select_ns.class_("SelectSetIndexAction", automation.Action)
 SelectOperationAction = select_ns.class_("SelectOperationAction", automation.Action)

-# Conditions
-SelectIsCondition = select_ns.class_("SelectIsCondition", automation.Condition)
-
 # Enums
 SelectOperation = select_ns.enum("SelectOperation")
 SELECT_OPERATION_OPTIONS = {
@@ -171,41 +165,6 @@ async def select_set_index_to_code(config, action_id, template_arg, args):
    return var


-@automation.register_condition(
-    "select.is",
-    SelectIsCondition,
-    OPERATION_BASE_SCHEMA.extend(
-        {
-            cv.Optional(CONF_OPTIONS): cv.All(
-                cv.ensure_list(cv.string_strict), cv.Length(min=1)
-            ),
-            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
-        }
-    ).add_extra(cv.has_exactly_one_key(CONF_OPTIONS, CONF_LAMBDA)),
-)
-async def select_is_to_code(config, condition_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    if options := config.get(CONF_OPTIONS):
-        # List of constant options
-        # Create a constexpr and pass that with a template length
-        arr_id = ID(
-            f"{condition_id}_data",
-            is_declaration=True,
-            type=global_ns.namespace("constexpr char * const"),
-        )
-        arg = cg.static_const_array(arr_id, cg.ArrayInitializer(*options))
-        template_arg = TemplateArguments(len(options), *template_arg)
-    else:
-        # Lambda
-        arg = await cg.process_lambda(
-            config[CONF_LAMBDA],
-            [(global_ns.namespace("StringRef &").operator("const"), "current")] + args,
-            return_type=cg.bool_,
-        )
-        template_arg = TemplateArguments(0, *template_arg)
-    return cg.new_Pvariable(condition_id, template_arg, paren, arg)
-
-
@automation.register_action(
    "select.operation",
    SelectOperationAction,
--- a/esphome/components/select/automation.h
+++ b/esphome/components/select/automation.h
@@ -66,34 +66,4 @@ template<typename... Ts> class SelectOperationAction : public Action<Ts...> {
  Select *select_;
 };

-template<size_t N, typename... Ts> class SelectIsCondition : public Condition<Ts...> {
- public:
-  SelectIsCondition(Select *parent, const char *const *option_list) : parent_(parent), option_list_(option_list) {}
-
-  bool check(const Ts &...x) override {
-    auto current = this->parent_->current_option();
-    for (size_t i = 0; i != N; i++) {
-      if (current == this->option_list_[i]) {
-        return true;
-      }
-    }
-    return false;
-  }
-
- protected:
-  Select *parent_;
-  const char *const *option_list_;
-};
-
-template<typename... Ts> class SelectIsCondition<0, Ts...> : public Condition<Ts...> {
- public:
-  SelectIsCondition(Select *parent, std::function<bool(const StringRef &, const Ts &...)> &&f)
-      : parent_(parent), f_(f) {}
-
-  bool check(const Ts &...x) override { return this->f_(this->parent_->current_option(), x...); }
-
- protected:
-  Select *parent_;
-  std::function<bool(const StringRef &, const Ts &...)> f_;
-};
 }  // namespace esphome::select
--- a/esphome/components/web_server/list_entities.cpp
+++ b/esphome/components/web_server/list_entities.cpp
@@ -143,7 +143,7 @@ bool ListEntitiesIterator::on_water_heater(water_heater::WaterHeater *obj) {

 #ifdef USE_INFRARED
 bool ListEntitiesIterator::on_infrared(infrared::Infrared *obj) {
-  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::infrared_all_json_generator);
+  // Infrared web_server support not yet implemented - this stub acknowledges the entity
  return true;
 }
 #endif
--- a/esphome/components/web_server/web_server.cpp
+++ b/esphome/components/web_server/web_server.cpp
@@ -33,10 +33,6 @@
 #include "esphome/components/water_heater/water_heater.h"
 #endif

-#ifdef USE_INFRARED
-#include "esphome/components/infrared/infrared.h"
-#endif
-
 #ifdef USE_WEBSERVER_LOCAL
 #if USE_WEBSERVER_VERSION == 2
 #include "server_index_v2.h"
@@ -662,24 +658,6 @@ std::string WebServer::text_sensor_json_(text_sensor::TextSensor *obj, const std
 #endif

 #ifdef USE_SWITCH
-enum SwitchAction : uint8_t { SWITCH_ACTION_NONE, SWITCH_ACTION_TOGGLE, SWITCH_ACTION_TURN_ON, SWITCH_ACTION_TURN_OFF };
-
-static void execute_switch_action(switch_::Switch *obj, SwitchAction action) {
-  switch (action) {
-    case SWITCH_ACTION_TOGGLE:
-      obj->toggle();
-      break;
-    case SWITCH_ACTION_TURN_ON:
-      obj->turn_on();
-      break;
-    case SWITCH_ACTION_TURN_OFF:
-      obj->turn_off();
-      break;
-    default:
-      break;
-  }
-}
-
 void WebServer::on_switch_update(switch_::Switch *obj) {
  if (!this->include_internal_ && obj->is_internal())
    return;
@@ -698,22 +676,34 @@ void WebServer::handle_switch_request(AsyncWebServerRequest *request, const UrlM
      return;
    }

-    SwitchAction action = SWITCH_ACTION_NONE;
+    // Handle action methods with single defer and response
+    enum SwitchAction { NONE, TOGGLE, TURN_ON, TURN_OFF };
+    SwitchAction action = NONE;

    if (match.method_equals(ESPHOME_F("toggle"))) {
-      action = SWITCH_ACTION_TOGGLE;
+      action = TOGGLE;
    } else if (match.method_equals(ESPHOME_F("turn_on"))) {
-      action = SWITCH_ACTION_TURN_ON;
+      action = TURN_ON;
    } else if (match.method_equals(ESPHOME_F("turn_off"))) {
-      action = SWITCH_ACTION_TURN_OFF;
+      action = TURN_OFF;
    }

-    if (action != SWITCH_ACTION_NONE) {
-#ifdef USE_ESP8266
-      execute_switch_action(obj, action);
-#else
-      this->defer([obj, action]() { execute_switch_action(obj, action); });
-#endif
+    if (action != NONE) {
+      this->defer([obj, action]() {
+        switch (action) {
+          case TOGGLE:
+            obj->toggle();
+            break;
+          case TURN_ON:
+            obj->turn_on();
+            break;
+          case TURN_OFF:
+            obj->turn_off();
+            break;
+          default:
+            break;
+        }
+      });
      request->send(200);
    } else {
      request->send(404);
@@ -753,7 +743,7 @@ void WebServer::handle_button_request(AsyncWebServerRequest *request, const UrlM
      std::string data = this->button_json_(obj, detail);
      request->send(200, "application/json", data.c_str());
    } else if (match.method_equals(ESPHOME_F("press"))) {
-      DEFER_ACTION(obj, obj->press());
+      this->defer([obj]() { obj->press(); });
      request->send(200);
      return;
    } else {
@@ -838,7 +828,7 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
      std::string data = this->fan_json_(obj, detail);
      request->send(200, "application/json", data.c_str());
    } else if (match.method_equals(ESPHOME_F("toggle"))) {
-      DEFER_ACTION(obj, obj->toggle().perform());
+      this->defer([obj]() { obj->toggle().perform(); });
      request->send(200);
    } else {
      bool is_on = match.method_equals(ESPHOME_F("turn_on"));
@@ -869,7 +859,7 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
            return;
        }
      }
-      DEFER_ACTION(call, call.perform());
+      this->defer([call]() mutable { call.perform(); });
      request->send(200);
    }
    return;
@@ -919,7 +909,7 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
      std::string data = this->light_json_(obj, detail);
      request->send(200, "application/json", data.c_str());
    } else if (match.method_equals(ESPHOME_F("toggle"))) {
-      DEFER_ACTION(obj, obj->toggle().perform());
+      this->defer([obj]() { obj->toggle().perform(); });
      request->send(200);
    } else {
      bool is_on = match.method_equals(ESPHOME_F("turn_on"));
@@ -948,7 +938,7 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
        parse_string_param_(request, ESPHOME_F("effect"), call, &decltype(call)::set_effect);
      }

-      DEFER_ACTION(call, call.perform());
+      this->defer([call]() mutable { call.perform(); });
      request->send(200);
    }
    return;
@@ -1037,7 +1027,7 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
    parse_float_param_(request, ESPHOME_F("position"), call, &decltype(call)::set_position);
    parse_float_param_(request, ESPHOME_F("tilt"), call, &decltype(call)::set_tilt);

-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
    request->send(200);
    return;
  }
@@ -1096,7 +1086,7 @@ void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlM
    auto call = obj->make_call();
    parse_float_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_value);

-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
    request->send(200);
    return;
  }
@@ -1169,7 +1159,7 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat

    parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_date);

-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
    request->send(200);
    return;
  }
@@ -1233,7 +1223,7 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat

    parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_time);

-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
    request->send(200);
    return;
  }
@@ -1296,7 +1286,7 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur

    parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_datetime);

-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
    request->send(200);
    return;
  }
@@ -1356,7 +1346,7 @@ void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMat
    auto call = obj->make_call();
    parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_value);

-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
    request->send(200);
    return;
  }
@@ -1414,7 +1404,7 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM
    auto call = obj->make_call();
    parse_string_param_(request, ESPHOME_F("option"), call, &decltype(call)::set_option);

-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
    request->send(200);
    return;
  }
@@ -1483,7 +1473,7 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
    parse_float_param_(request, ESPHOME_F("target_temperature_low"), call, &decltype(call)::set_target_temperature_low);
    parse_float_param_(request, ESPHOME_F("target_temperature"), call, &decltype(call)::set_target_temperature);

-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
    request->send(200);
    return;
  }
@@ -1599,24 +1589,6 @@ std::string WebServer::climate_json_(climate::Climate *obj, JsonDetail start_con
 #endif

 #ifdef USE_LOCK
-enum LockAction : uint8_t { LOCK_ACTION_NONE, LOCK_ACTION_LOCK, LOCK_ACTION_UNLOCK, LOCK_ACTION_OPEN };
-
-static void execute_lock_action(lock::Lock *obj, LockAction action) {
-  switch (action) {
-    case LOCK_ACTION_LOCK:
-      obj->lock();
-      break;
-    case LOCK_ACTION_UNLOCK:
-      obj->unlock();
-      break;
-    case LOCK_ACTION_OPEN:
-      obj->open();
-      break;
-    default:
-      break;
-  }
-}
-
 void WebServer::on_lock_update(lock::Lock *obj) {
  if (!this->include_internal_ && obj->is_internal())
    return;
@@ -1635,22 +1607,34 @@ void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMat
      return;
    }

-    LockAction action = LOCK_ACTION_NONE;
+    // Handle action methods with single defer and response
+    enum LockAction { NONE, LOCK, UNLOCK, OPEN };
+    LockAction action = NONE;

    if (match.method_equals(ESPHOME_F("lock"))) {
-      action = LOCK_ACTION_LOCK;
+      action = LOCK;
    } else if (match.method_equals(ESPHOME_F("unlock"))) {
-      action = LOCK_ACTION_UNLOCK;
+      action = UNLOCK;
    } else if (match.method_equals(ESPHOME_F("open"))) {
-      action = LOCK_ACTION_OPEN;
+      action = OPEN;
    }

-    if (action != LOCK_ACTION_NONE) {
-#ifdef USE_ESP8266
-      execute_lock_action(obj, action);
-#else
-      this->defer([obj, action]() { execute_lock_action(obj, action); });
-#endif
+    if (action != NONE) {
+      this->defer([obj, action]() {
+        switch (action) {
+          case LOCK:
+            obj->lock();
+            break;
+          case UNLOCK:
+            obj->unlock();
+            break;
+          case OPEN:
+            obj->open();
+            break;
+          default:
+            break;
+        }
+      });
      request->send(200);
    } else {
      request->send(404);
@@ -1733,7 +1717,7 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa

    parse_float_param_(request, ESPHOME_F("position"), call, &decltype(call)::set_position);

-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
    request->send(200);
    return;
  }
@@ -1812,7 +1796,7 @@ void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *reques
      return;
    }

-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
    request->send(200);
    return;
  }
@@ -1888,7 +1872,7 @@ void WebServer::handle_water_heater_request(AsyncWebServerRequest *request, cons
    // Parse on/off parameter
    parse_bool_param_(request, ESPHOME_F("is_on"), base_call, &water_heater::WaterHeaterCall::set_on);

-    DEFER_ACTION(call, call.perform());
+    this->defer([call]() mutable { call.perform(); });
    request->send(200);
    return;
  }
@@ -1956,110 +1940,6 @@ std::string WebServer::water_heater_json_(water_heater::WaterHeater *obj, JsonDe
 }
 #endif

-#ifdef USE_INFRARED
-void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const UrlMatch &match) {
-  for (infrared::Infrared *obj : App.get_infrareds()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
-      continue;
-
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
-      auto detail = get_request_detail(request);
-      std::string data = this->infrared_json_(obj, detail);
-      request->send(200, ESPHOME_F("application/json"), data.c_str());
-      return;
-    }
-    if (!match.method_equals(ESPHOME_F("transmit"))) {
-      request->send(404);
-      return;
-    }
-
-    // Only allow transmit if the device supports it
-    if (!obj->has_transmitter()) {
-      request->send(400, ESPHOME_F("text/plain"), "Device does not support transmission");
-      return;
-    }
-
-    // Parse parameters
-    auto call = obj->make_call();
-
-    // Parse carrier frequency (optional)
-    if (request->hasParam(ESPHOME_F("carrier_frequency"))) {
-      auto value = parse_number<uint32_t>(request->getParam(ESPHOME_F("carrier_frequency"))->value().c_str());
-      if (value.has_value()) {
-        call.set_carrier_frequency(*value);
-      }
-    }
-
-    // Parse repeat count (optional, defaults to 1)
-    if (request->hasParam(ESPHOME_F("repeat_count"))) {
-      auto value = parse_number<uint32_t>(request->getParam(ESPHOME_F("repeat_count"))->value().c_str());
-      if (value.has_value()) {
-        call.set_repeat_count(*value);
-      }
-    }
-
-    // Parse base64url-encoded raw timings (required)
-    // Base64url is URL-safe: uses A-Za-z0-9-_ (no special characters needing escaping)
-    if (!request->hasParam(ESPHOME_F("data"))) {
-      request->send(400, ESPHOME_F("text/plain"), "Missing 'data' parameter");
-      return;
-    }
-
-    // .c_str() is required for Arduino framework where value() returns Arduino String instead of std::string
-    std::string encoded =
-        request->getParam(ESPHOME_F("data"))->value().c_str();  // NOLINT(readability-redundant-string-cstr)
-
-    // Validate base64url is not empty
-    if (encoded.empty()) {
-      request->send(400, ESPHOME_F("text/plain"), "Empty 'data' parameter");
-      return;
-    }
-
-#ifdef USE_ESP8266
-    // ESP8266 is single-threaded, call directly
-    call.set_raw_timings_base64url(encoded);
-    call.perform();
-#else
-    // Defer to main loop for thread safety. Move encoded string into lambda to ensure
-    // it outlives the call - set_raw_timings_base64url stores a pointer, so the string
-    // must remain valid until perform() completes.
-    this->defer([call, encoded = std::move(encoded)]() mutable {
-      call.set_raw_timings_base64url(encoded);
-      call.perform();
-    });
-#endif
-
-    request->send(200);
-    return;
-  }
-  request->send(404);
-}
-
-std::string WebServer::infrared_all_json_generator(WebServer *web_server, void *source) {
-  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-  return web_server->infrared_json_(static_cast<infrared::Infrared *>(source), DETAIL_ALL);
-}
-
-std::string WebServer::infrared_json_(infrared::Infrared *obj, JsonDetail start_config) {
-  json::JsonBuilder builder;
-  JsonObject root = builder.root();
-
-  set_json_icon_state_value(root, obj, "infrared", "", 0, start_config);
-
-  auto traits = obj->get_traits();
-
-  root[ESPHOME_F("supports_transmitter")] = traits.get_supports_transmitter();
-  root[ESPHOME_F("supports_receiver")] = traits.get_supports_receiver();
-
-  if (start_config == DETAIL_ALL) {
-    this->add_sorting_info_(root, obj);
-  }
-
-  return builder.serialize();
-}
-#endif
-
 #ifdef USE_EVENT
 void WebServer::on_event(event::Event *obj) {
  if (!this->include_internal_ && obj->is_internal())
@@ -2152,7 +2032,7 @@ void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlM
      return;
    }

-    DEFER_ACTION(obj, obj->perform());
+    this->defer([obj]() mutable { obj->perform(); });
    request->send(200);
    return;
  }
@@ -2191,21 +2071,24 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) const {
  const auto &url = request->url();
  const auto method = request->method();

-  // Static URL checks - use ESPHOME_F to keep strings in flash on ESP8266
-  if (url == ESPHOME_F("/"))
-    return true;
+  // Static URL checks
+  static const char *const STATIC_URLS[] = {
+    "/",
 #if !defined(USE_ESP32) && defined(USE_ARDUINO)
-  if (url == ESPHOME_F("/events"))
-    return true;
+    "/events",
 #endif
 #ifdef USE_WEBSERVER_CSS_INCLUDE
-  if (url == ESPHOME_F("/0.css"))
-    return true;
+    "/0.css",
 #endif
 #ifdef USE_WEBSERVER_JS_INCLUDE
-  if (url == ESPHOME_F("/0.js"))
-    return true;
+    "/0.js",
 #endif
+  };
+
+  for (const auto &static_url : STATIC_URLS) {
+    if (url == static_url)
+      return true;
+  }

 #ifdef USE_WEBSERVER_PRIVATE_NETWORK_ACCESS
  if (method == HTTP_OPTIONS && request->hasHeader(ESPHOME_F("Access-Control-Request-Private-Network")))
@@ -2225,100 +2108,90 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) const {
  if (!is_get_or_post)
    return false;

-  // Check GET-only domains - use ESPHOME_F to keep strings in flash on ESP8266
-  if (is_get) {
+  // Use lookup tables for domain checks
+  static const char *const GET_ONLY_DOMAINS[] = {
 #ifdef USE_SENSOR
-    if (match.domain_equals(ESPHOME_F("sensor")))
-      return true;
+      "sensor",
 #endif
 #ifdef USE_BINARY_SENSOR
-    if (match.domain_equals(ESPHOME_F("binary_sensor")))
-      return true;
+      "binary_sensor",
 #endif
 #ifdef USE_TEXT_SENSOR
-    if (match.domain_equals(ESPHOME_F("text_sensor")))
-      return true;
+      "text_sensor",
 #endif
 #ifdef USE_EVENT
-    if (match.domain_equals(ESPHOME_F("event")))
-      return true;
+      "event",
 #endif
+  };
+
+  static const char *const GET_POST_DOMAINS[] = {
+#ifdef USE_SWITCH
+      "switch",
+#endif
+#ifdef USE_BUTTON
+      "button",
+#endif
+#ifdef USE_FAN
+      "fan",
+#endif
+#ifdef USE_LIGHT
+      "light",
+#endif
+#ifdef USE_COVER
+      "cover",
+#endif
+#ifdef USE_NUMBER
+      "number",
+#endif
+#ifdef USE_DATETIME_DATE
+      "date",
+#endif
+#ifdef USE_DATETIME_TIME
+      "time",
+#endif
+#ifdef USE_DATETIME_DATETIME
+      "datetime",
+#endif
+#ifdef USE_TEXT
+      "text",
+#endif
+#ifdef USE_SELECT
+      "select",
+#endif
+#ifdef USE_CLIMATE
+      "climate",
+#endif
+#ifdef USE_LOCK
+      "lock",
+#endif
+#ifdef USE_VALVE
+      "valve",
+#endif
+#ifdef USE_ALARM_CONTROL_PANEL
+      "alarm_control_panel",
+#endif
+#ifdef USE_UPDATE
+      "update",
+#endif
+#ifdef USE_WATER_HEATER
+      "water_heater",
+#endif
+  };
+
+  // Check GET-only domains
+  if (is_get) {
+    for (const auto &domain : GET_ONLY_DOMAINS) {
+      if (match.domain_equals(domain))
+        return true;
+    }
  }

  // Check GET+POST domains
  if (is_get_or_post) {
-#ifdef USE_SWITCH
-    if (match.domain_equals(ESPHOME_F("switch")))
-      return true;
-#endif
-#ifdef USE_BUTTON
-    if (match.domain_equals(ESPHOME_F("button")))
-      return true;
-#endif
-#ifdef USE_FAN
-    if (match.domain_equals(ESPHOME_F("fan")))
-      return true;
-#endif
-#ifdef USE_LIGHT
-    if (match.domain_equals(ESPHOME_F("light")))
-      return true;
-#endif
-#ifdef USE_COVER
-    if (match.domain_equals(ESPHOME_F("cover")))
-      return true;
-#endif
-#ifdef USE_NUMBER
-    if (match.domain_equals(ESPHOME_F("number")))
-      return true;
-#endif
-#ifdef USE_DATETIME_DATE
-    if (match.domain_equals(ESPHOME_F("date")))
-      return true;
-#endif
-#ifdef USE_DATETIME_TIME
-    if (match.domain_equals(ESPHOME_F("time")))
-      return true;
-#endif
-#ifdef USE_DATETIME_DATETIME
-    if (match.domain_equals(ESPHOME_F("datetime")))
-      return true;
-#endif
-#ifdef USE_TEXT
-    if (match.domain_equals(ESPHOME_F("text")))
-      return true;
-#endif
-#ifdef USE_SELECT
-    if (match.domain_equals(ESPHOME_F("select")))
-      return true;
-#endif
-#ifdef USE_CLIMATE
-    if (match.domain_equals(ESPHOME_F("climate")))
-      return true;
-#endif
-#ifdef USE_LOCK
-    if (match.domain_equals(ESPHOME_F("lock")))
-      return true;
-#endif
-#ifdef USE_VALVE
-    if (match.domain_equals(ESPHOME_F("valve")))
-      return true;
-#endif
-#ifdef USE_ALARM_CONTROL_PANEL
-    if (match.domain_equals(ESPHOME_F("alarm_control_panel")))
-      return true;
-#endif
-#ifdef USE_UPDATE
-    if (match.domain_equals(ESPHOME_F("update")))
-      return true;
-#endif
-#ifdef USE_WATER_HEATER
-    if (match.domain_equals(ESPHOME_F("water_heater")))
-      return true;
-#endif
-#ifdef USE_INFRARED
-    if (match.domain_equals(ESPHOME_F("infrared")))
-      return true;
-#endif
+    for (const auto &domain : GET_POST_DOMAINS) {
+      if (match.domain_equals(domain))
+        return true;
+    }
  }

  return false;
@@ -2467,11 +2340,6 @@ void WebServer::handleRequest(AsyncWebServerRequest *request) {
  else if (match.domain_equals(ESPHOME_F("water_heater"))) {
    this->handle_water_heater_request(request, match);
  }
-#endif
-#ifdef USE_INFRARED
-  else if (match.domain_equals(ESPHOME_F("infrared"))) {
-    this->handle_infrared_request(request, match);
-  }
 #endif
  else {
    // No matching handler found - send 404
--- a/esphome/components/web_server/web_server.h
+++ b/esphome/components/web_server/web_server.h
@@ -42,14 +42,6 @@ using ParamNameType = const __FlashStringHelper *;
 using ParamNameType = const char *;
 #endif

-// ESP8266 is single-threaded, so actions can execute directly in request context.
-// Multi-core platforms need to defer to main loop thread for thread safety.
-#ifdef USE_ESP8266
-#define DEFER_ACTION(capture, action) action
-#else
-#define DEFER_ACTION(capture, action) this->defer([capture]() mutable { action; })
-#endif
-
 /// Result of matching a URL against an entity
 struct EntityMatchResult {
  bool matched;          ///< True if entity matched the URL
@@ -460,13 +452,6 @@ class WebServer : public Controller,
  static std::string water_heater_all_json_generator(WebServer *web_server, void *source);
 #endif

-#ifdef USE_INFRARED
-  /// Handle an infrared request under '/infrared/<id>/transmit'.
-  void handle_infrared_request(AsyncWebServerRequest *request, const UrlMatch &match);
-
-  static std::string infrared_all_json_generator(WebServer *web_server, void *source);
-#endif
-
 #ifdef USE_EVENT
  void on_event(event::Event *obj) override;

@@ -669,9 +654,6 @@ class WebServer : public Controller,
 #ifdef USE_WATER_HEATER
  std::string water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config);
 #endif
-#ifdef USE_INFRARED
-  std::string infrared_json_(infrared::Infrared *obj, JsonDetail start_config);
-#endif
 #ifdef USE_UPDATE
  std::string update_json_(update::UpdateEntity *obj, JsonDetail start_config);
 #endif
--- a/esphome/core/helpers.cpp
+++ b/esphome/core/helpers.cpp
@@ -404,31 +404,15 @@ std::string format_hex_pretty(const std::string &data, char separator, bool show
  return format_hex_pretty_uint8(reinterpret_cast<const uint8_t *>(data.data()), data.length(), separator, show_length);
 }

-char *format_bin_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length) {
-  if (buffer_size == 0) {
-    return buffer;
-  }
-  // Calculate max bytes we can format: each byte needs 8 chars
-  size_t max_bytes = (buffer_size - 1) / 8;
-  if (max_bytes == 0 || length == 0) {
-    buffer[0] = '\0';
-    return buffer;
-  }
-  size_t bytes_to_format = std::min(length, max_bytes);
-
-  for (size_t byte_idx = 0; byte_idx < bytes_to_format; byte_idx++) {
-    for (size_t bit_idx = 0; bit_idx < 8; bit_idx++) {
-      buffer[byte_idx * 8 + bit_idx] = ((data[byte_idx] >> (7 - bit_idx)) & 1) + '0';
-    }
-  }
-  buffer[bytes_to_format * 8] = '\0';
-  return buffer;
-}
-
 std::string format_bin(const uint8_t *data, size_t length) {
  std::string result;
  result.resize(length * 8);
-  format_bin_to(&result[0], length * 8 + 1, data, length);
+  for (size_t byte_idx = 0; byte_idx < length; byte_idx++) {
+    for (size_t bit_idx = 0; bit_idx < 8; bit_idx++) {
+      result[byte_idx * 8 + bit_idx] = ((data[byte_idx] >> (7 - bit_idx)) & 1) + '0';
+    }
+  }
+
  return result;
 }

@@ -503,26 +487,19 @@ static constexpr const char *BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                            "abcdefghijklmnopqrstuvwxyz"
                                            "0123456789+/";

-// Helper function to find the index of a base64/base64url character in the lookup table.
+// Helper function to find the index of a base64 character in the lookup table.
 // Returns the character's position (0-63) if found, or 0 if not found.
-// Supports both standard base64 (+/) and base64url (-_) alphabets.
 // NOTE: This returns 0 for both 'A' (valid base64 char at index 0) and invalid characters.
 // This is safe because is_base64() is ALWAYS checked before calling this function,
 // preventing invalid characters from ever reaching here. The base64_decode function
 // stops processing at the first invalid character due to the is_base64() check in its
 // while loop condition, making this edge case harmless in practice.
 static inline uint8_t base64_find_char(char c) {
-  // Handle base64url variants: '-' maps to '+' (index 62), '_' maps to '/' (index 63)
-  if (c == '-')
-    return 62;
-  if (c == '_')
-    return 63;
  const char *pos = strchr(BASE64_CHARS, c);
  return pos ? (pos - BASE64_CHARS) : 0;
 }

-// Check if character is valid base64 or base64url
-static inline bool is_base64(char c) { return (isalnum(c) || (c == '+') || (c == '/') || (c == '-') || (c == '_')); }
+static inline bool is_base64(char c) { return (isalnum(c) || (c == '+') || (c == '/')); }

 std::string base64_encode(const std::vector<uint8_t> &buf) { return base64_encode(buf.data(), buf.size()); }

@@ -640,44 +617,53 @@ std::vector<uint8_t> base64_decode(const std::string &encoded_string) {
  return ret;
 }

-/// Decode base64/base64url string directly into vector of little-endian int32 values
-/// @param base64 Base64 or base64url encoded string (both +/ and -_ accepted)
-/// @param out Output vector (cleared and filled with decoded int32 values)
-/// @return true if successful, false if decode failed or invalid size
-bool base64_decode_int32_vector(const std::string &base64, std::vector<int32_t> &out) {
-  // Decode in chunks to minimize stack usage
-  constexpr size_t chunk_bytes = 48;  // 12 int32 values
-  constexpr size_t chunk_chars = 64;  // 48 * 4/3 = 64 chars
-  uint8_t chunk[chunk_bytes];
+/// Encode int32 to 5 base85 characters + null terminator
+/// Standard ASCII85 alphabet: '!' (33) = 0 through 'u' (117) = 84
+inline void base85_encode_int32(int32_t value, std::span<char, BASE85_INT32_ENCODED_SIZE> output) {
+  uint32_t v = static_cast<uint32_t>(value);
+  // Encode least significant digit first, then reverse
+  for (int i = 4; i >= 0; i--) {
+    output[i] = static_cast<char>('!' + (v % 85));
+    v /= 85;
+  }
+  output[5] = '\0';
+}
+
+/// Decode 5 base85 characters to int32
+inline bool base85_decode_int32(const char *input, int32_t &out) {
+  uint8_t c0 = static_cast<uint8_t>(input[0] - '!');
+  uint8_t c1 = static_cast<uint8_t>(input[1] - '!');
+  uint8_t c2 = static_cast<uint8_t>(input[2] - '!');
+  uint8_t c3 = static_cast<uint8_t>(input[3] - '!');
+  uint8_t c4 = static_cast<uint8_t>(input[4] - '!');
+
+  // Each digit must be 0-84. Since uint8_t wraps, chars below '!' become > 84
+  if (c0 > 84 || c1 > 84 || c2 > 84 || c3 > 84 || c4 > 84)
+    return false;
+
+  // 85^4 = 52200625, 85^3 = 614125, 85^2 = 7225, 85^1 = 85
+  out = static_cast<int32_t>(c0 * 52200625u + c1 * 614125u + c2 * 7225u + c3 * 85u + c4);
+  return true;
+}
+
+/// Decode base85 string directly into vector (no intermediate buffer)
+bool base85_decode_int32_vector(const std::string &base85, std::vector<int32_t> &out) {
+  size_t len = base85.size();
+  if (len % 5 != 0)
+    return false;

  out.clear();
+  const char *ptr = base85.data();
+  const char *end = ptr + len;

-  const uint8_t *input = reinterpret_cast<const uint8_t *>(base64.data());
-  size_t remaining = base64.size();
-  size_t pos = 0;
-
-  while (remaining > 0) {
-    size_t chars_to_decode = std::min(remaining, chunk_chars);
-    size_t decoded_len = base64_decode(input + pos, chars_to_decode, chunk, chunk_bytes);
-
-    if (decoded_len == 0)
+  while (ptr < end) {
+    int32_t value;
+    if (!base85_decode_int32(ptr, value))
      return false;
-
-    // Parse little-endian int32 values
-    for (size_t i = 0; i + 3 < decoded_len; i += 4) {
-      int32_t timing = static_cast<int32_t>(encode_uint32(chunk[i + 3], chunk[i + 2], chunk[i + 1], chunk[i]));
-      out.push_back(timing);
-    }
-
-    // Check for incomplete int32 in last chunk
-    if (remaining <= chunk_chars && (decoded_len % 4) != 0)
-      return false;
-
-    pos += chars_to_decode;
-    remaining -= chars_to_decode;
+    out.push_back(value);
+    ptr += 5;
  }
-
-  return !out.empty();
+  return true;
 }

 // Colors
--- a/esphome/core/helpers.h
+++ b/esphome/core/helpers.h
@@ -1096,66 +1096,9 @@ std::string format_hex_pretty(T val, char separator = '.', bool show_length = tr
  return format_hex_pretty(reinterpret_cast<uint8_t *>(&val), sizeof(T), separator, show_length);
 }

-/// Calculate buffer size needed for format_bin_to: "01234567...\0" = bytes * 8 + 1
-constexpr size_t format_bin_size(size_t byte_count) { return byte_count * 8 + 1; }
-
-/** Format byte array as binary string to buffer.
- *
- * Each byte is formatted as 8 binary digits (MSB first).
- * Truncates output if data exceeds buffer capacity.
- *
- * @param buffer Output buffer to write to.
- * @param buffer_size Size of the output buffer.
- * @param data Pointer to the byte array to format.
- * @param length Number of bytes in the array.
- * @return Pointer to buffer.
- *
- * Buffer size needed: length * 8 + 1 (use format_bin_size()).
- *
- * Example:
- * @code
- * char buf[9];  // format_bin_size(1)
- * format_bin_to(buf, sizeof(buf), data, 1);  // "10101011"
- * @endcode
- */
-char *format_bin_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length);
-
-/// Format byte array as binary to buffer. Automatically deduces buffer size.
-template<size_t N> inline char *format_bin_to(char (&buffer)[N], const uint8_t *data, size_t length) {
-  static_assert(N >= 9, "Buffer must hold at least one binary byte (9 chars)");
-  return format_bin_to(buffer, N, data, length);
-}
-
-/** Format an unsigned integer in binary to buffer, MSB first.
- *
- * @tparam N Buffer size (must be >= sizeof(T) * 8 + 1).
- * @tparam T Unsigned integer type.
- * @param buffer Output buffer to write to.
- * @param val The unsigned integer value to format.
- * @return Pointer to buffer.
- *
- * Example:
- * @code
- * char buf[9];  // format_bin_size(sizeof(uint8_t))
- * format_bin_to(buf, uint8_t{0xAA});  // "10101010"
- * char buf16[17];  // format_bin_size(sizeof(uint16_t))
- * format_bin_to(buf16, uint16_t{0x1234});  // "0001001000110100"
- * @endcode
- */
-template<size_t N, typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
-inline char *format_bin_to(char (&buffer)[N], T val) {
-  static_assert(N >= sizeof(T) * 8 + 1, "Buffer too small for type");
-  val = convert_big_endian(val);
-  return format_bin_to(buffer, reinterpret_cast<const uint8_t *>(&val), sizeof(T));
-}
-
 /// Format the byte array \p data of length \p len in binary.
-/// @warning Allocates heap memory. Use format_bin_to() with a stack buffer instead.
-/// Causes heap fragmentation on long-running devices.
 std::string format_bin(const uint8_t *data, size_t length);
 /// Format an unsigned integer in binary, starting with the most significant byte.
-/// @warning Allocates heap memory. Use format_bin_to() with a stack buffer instead.
-/// Causes heap fragmentation on long-running devices.
 template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> std::string format_bin(T val) {
  val = convert_big_endian(val);
  return format_bin(reinterpret_cast<uint8_t *>(&val), sizeof(T));
@@ -1194,11 +1137,13 @@ std::vector<uint8_t> base64_decode(const std::string &encoded_string);
 size_t base64_decode(std::string const &encoded_string, uint8_t *buf, size_t buf_len);
 size_t base64_decode(const uint8_t *encoded_data, size_t encoded_len, uint8_t *buf, size_t buf_len);

-/// Decode base64/base64url string directly into vector of little-endian int32 values
-/// @param base64 Base64 or base64url encoded string (both +/ and -_ accepted)
-/// @param out Output vector (cleared and filled with decoded int32 values)
-/// @return true if successful, false if decode failed or invalid size
-bool base64_decode_int32_vector(const std::string &base64, std::vector<int32_t> &out);
+/// Size of buffer needed for base85 encoded int32 (5 chars + null terminator)
+static constexpr size_t BASE85_INT32_ENCODED_SIZE = 6;
+
+void base85_encode_int32(int32_t value, std::span<char, BASE85_INT32_ENCODED_SIZE> output);
+
+bool base85_decode_int32(const char *input, int32_t &out);
+bool base85_decode_int32_vector(const std::string &base85, std::vector<int32_t> &out);

 ///@}

--- a/esphome/core/progmem.h
+++ b/esphome/core/progmem.h
@@ -12,8 +12,6 @@
 #define ESPHOME_strncpy_P strncpy_P
 #define ESPHOME_strncat_P strncat_P
 #define ESPHOME_snprintf_P snprintf_P
-// Type for pointers to PROGMEM strings (for use with ESPHOME_F return values)
-using ProgmemStr = const __FlashStringHelper *;
 #else
 #define ESPHOME_F(string_literal) (string_literal)
 #define ESPHOME_PGM_P const char *
@@ -21,6 +19,4 @@ using ProgmemStr = const __FlashStringHelper *;
 #define ESPHOME_strncpy_P strncpy
 #define ESPHOME_strncat_P strncat
 #define ESPHOME_snprintf_P snprintf
-// Type for pointers to strings (no PROGMEM on non-ESP8266 platforms)
-using ProgmemStr = const char *;
 #endif
--- a/esphome/idf_component.yml
+++ b/esphome/idf_component.yml
@@ -28,8 +28,8 @@ dependencies:
    rules:
      - if: "target in [esp32s2, esp32s3, esp32p4]"
  esphome/esp-hub75:
-    version: 0.3.0
+    version: 0.2.2
    rules:
-      - if: "target in [esp32, esp32s2, esp32s3, esp32c6, esp32p4]"
+      - if: "target in [esp32, esp32s2, esp32s3, esp32p4]"
  esp32async/asynctcp:
    version: 3.4.91
--- a/requirements_test.txt
+++ b/requirements_test.txt
@@ -1,6 +1,6 @@
 pylint==4.0.4
 flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
-ruff==0.14.13  # also change in .pre-commit-config.yaml when updating
+ruff==0.14.12  # also change in .pre-commit-config.yaml when updating
 pyupgrade==3.21.2  # also change in .pre-commit-config.yaml when updating
 pre-commit

--- a/script/ci-custom.py
+++ b/script/ci-custom.py
@@ -682,7 +682,6 @@ def lint_trailing_whitespace(fname, match):
 # Heap-allocating helpers that cause fragmentation on long-running embedded devices.
 # These return std::string and should be replaced with stack-based alternatives.
 HEAP_ALLOCATING_HELPERS = {
-    "format_bin": "format_bin_to() with a stack buffer",
    "format_hex": "format_hex_to() with a stack buffer",
    "format_hex_pretty": "format_hex_pretty_to() with a stack buffer",
    "format_mac_address_pretty": "format_mac_addr_upper() with a stack buffer",
@@ -700,7 +699,6 @@ HEAP_ALLOCATING_HELPERS = {
    # get_mac_address(?!_) ensures we don't match get_mac_address_into_buffer, etc.
    # CPP_RE_EOL captures rest of line so NOLINT comments are detected
    r"[^\w]("
-    r"format_bin(?!_)|"
    r"format_hex(?!_)|"
    r"format_hex_pretty(?!_)|"
    r"format_mac_address_pretty|"
--- a/tests/components/template/common-base.yaml
+++ b/tests/components/template/common-base.yaml
@@ -53,17 +53,6 @@ binary_sensor:
        // Garage Door is closed.
        return false;
      }
-  - platform: template
-    id: select_binary_sensor
-    name: Select is one or two
-    condition:
-      any:
-        - select.is:
-            id: template_select
-            options: [one, two]
-        - select.is:
-            id: template_select
-            lambda: return current == id(template_text).state;
  - platform: template
    id: other_binary_sensor
    name: "Garage Door Closed"
@@ -331,7 +320,6 @@ valve:

 text:
  - platform: template
-    id: template_text
    name: "Template text"
    optimistic: true
    min_length: 0